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, xflags)
1202 return (extract_delimited_string (string, sindex, starter, "(", ")", SX_COMMAND));
1204 xflags |= (no_longjmp_on_fatal_error ? SX_NOLONGJMP : 0);
1205 return (xparse_dolparen (string, string+*sindex, sindex, xflags));
1208 #endif /* PROCESS_SUBSTITUTION */
1210 #if defined (ARRAY_VARS)
1211 /* This can be fooled by unquoted right parens in the passed string. If
1212 each caller verifies that the last character in STRING is a right paren,
1213 we don't even need to call extract_delimited_string. */
1215 extract_array_assignment_list (string, sindex)
1222 slen = strlen (string); /* ( */
1223 if (string[slen - 1] == ')')
1225 ret = substring (string, *sindex, slen - 1);
1233 /* Extract and create a new string from the contents of STRING, a
1234 character string delimited with OPENER and CLOSER. SINDEX is
1235 the address of an int describing the current offset in STRING;
1236 it should point to just after the first OPENER found. On exit,
1237 SINDEX gets the position of the last character of the matching CLOSER.
1238 If OPENER is more than a single character, ALT_OPENER, if non-null,
1239 contains a character string that can also match CLOSER and thus
1240 needs to be skipped. */
1242 extract_delimited_string (string, sindex, opener, alt_opener, closer, flags)
1245 char *opener, *alt_opener, *closer;
1251 int pass_character, nesting_level, in_comment;
1252 int len_closer, len_opener, len_alt_opener;
1255 slen = strlen (string + *sindex) + *sindex;
1256 len_opener = STRLEN (opener);
1257 len_alt_opener = STRLEN (alt_opener);
1258 len_closer = STRLEN (closer);
1260 pass_character = in_comment = 0;
1265 while (nesting_level)
1276 ADVANCE_CHAR (string, slen, i);
1280 if (pass_character) /* previous char was backslash */
1283 ADVANCE_CHAR (string, slen, i);
1287 /* Not exactly right yet; should handle shell metacharacters and
1288 multibyte characters, too. See COMMENT_BEGIN define in parse.y */
1289 if ((flags & SX_COMMAND) && c == '#' && (i == 0 || string[i - 1] == '\n' || shellblank (string[i - 1])))
1292 ADVANCE_CHAR (string, slen, i);
1296 if (c == CTLESC || c == '\\')
1303 /* Process a nested command substitution, but only if we're parsing an
1304 arithmetic substitution. */
1305 if ((flags & SX_COMMAND) && string[i] == '$' && string[i+1] == LPAREN)
1308 t = extract_command_subst (string, &si, flags|SX_NOALLOC);
1313 /* Process a nested OPENER. */
1314 if (STREQN (string + i, opener, len_opener))
1316 si = i + len_opener;
1317 t = extract_delimited_string (string, &si, opener, alt_opener, closer, flags|SX_NOALLOC);
1322 /* Process a nested ALT_OPENER */
1323 if (len_alt_opener && STREQN (string + i, alt_opener, len_alt_opener))
1325 si = i + len_alt_opener;
1326 t = extract_delimited_string (string, &si, alt_opener, alt_opener, closer, flags|SX_NOALLOC);
1331 /* If the current substring terminates the delimited string, decrement
1332 the nesting level. */
1333 if (STREQN (string + i, closer, len_closer))
1335 i += len_closer - 1; /* move to last byte of the closer */
1337 if (nesting_level == 0)
1341 /* Pass old-style command substitution through verbatim. */
1345 t = string_extract (string, &si, "`", flags|SX_NOALLOC);
1350 /* Pass single-quoted and double-quoted strings through verbatim. */
1351 if (c == '\'' || c == '"')
1354 i = (c == '\'') ? skip_single_quoted (string, slen, si)
1355 : skip_double_quoted (string, slen, si);
1359 /* move past this character, which was not special. */
1360 ADVANCE_CHAR (string, slen, i);
1363 if (c == 0 && nesting_level)
1365 if (no_longjmp_on_fatal_error == 0)
1367 last_command_exit_value = EXECUTION_FAILURE;
1368 report_error (_("bad substitution: no closing `%s' in %s"), closer, string);
1369 exp_jump_to_top_level (DISCARD);
1374 return (char *)NULL;
1378 si = i - *sindex - len_closer + 1;
1379 if (flags & SX_NOALLOC)
1380 result = (char *)NULL;
1383 result = (char *)xmalloc (1 + si);
1384 strncpy (result, string + *sindex, si);
1392 /* Extract a parameter expansion expression within ${ and } from STRING.
1393 Obey the Posix.2 rules for finding the ending `}': count braces while
1394 skipping over enclosed quoted strings and command substitutions.
1395 SINDEX is the address of an int describing the current offset in STRING;
1396 it should point to just after the first `{' found. On exit, SINDEX
1397 gets the position of the matching `}'. QUOTED is non-zero if this
1398 occurs inside double quotes. */
1399 /* XXX -- this is very similar to extract_delimited_string -- XXX */
1401 extract_dollar_brace_string (string, sindex, quoted, flags)
1403 int *sindex, quoted, flags;
1407 int pass_character, nesting_level, si, dolbrace_state;
1413 slen = strlen (string + *sindex) + *sindex;
1415 /* The handling of dolbrace_state needs to agree with the code in parse.y:
1416 parse_matched_pair(). The different initial value is to handle the
1417 case where this function is called to parse the word in
1418 ${param op word} (SX_WORD). */
1419 dolbrace_state = (flags & SX_WORD) ? DOLBRACE_WORD : DOLBRACE_PARAM;
1420 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && (flags & SX_POSIXEXP))
1421 dolbrace_state = DOLBRACE_QUOTE;
1424 while (c = string[i])
1429 ADVANCE_CHAR (string, slen, i);
1433 /* CTLESCs and backslashes quote the next character. */
1434 if (c == CTLESC || c == '\\')
1441 if (string[i] == '$' && string[i+1] == LBRACE)
1451 if (nesting_level == 0)
1457 /* Pass the contents of old-style command substitutions through
1462 t = string_extract (string, &si, "`", flags|SX_NOALLOC);
1467 /* Pass the contents of new-style command substitutions and
1468 arithmetic substitutions through verbatim. */
1469 if (string[i] == '$' && string[i+1] == LPAREN)
1472 t = extract_command_subst (string, &si, flags|SX_NOALLOC);
1477 /* Pass the contents of double-quoted strings through verbatim. */
1481 i = skip_double_quoted (string, slen, si);
1482 /* skip_XXX_quoted leaves index one past close quote */
1488 /*itrace("extract_dollar_brace_string: c == single quote flags = %d quoted = %d dolbrace_state = %d", flags, quoted, dolbrace_state);*/
1489 if (posixly_correct && shell_compatibility_level > 42 && dolbrace_state != DOLBRACE_QUOTE && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
1490 ADVANCE_CHAR (string, slen, i);
1494 i = skip_single_quoted (string, slen, si);
1500 /* move past this character, which was not special. */
1501 ADVANCE_CHAR (string, slen, i);
1503 /* This logic must agree with parse.y:parse_matched_pair, since they
1504 share the same defines. */
1505 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 && c == '/' && (i - *sindex) > 1)
1510 dolbrace_state = DOLBRACE_QUOTE2; /* XXX */
1511 else if (dolbrace_state == DOLBRACE_PARAM && c == '^' && (i - *sindex) > 1)
1512 dolbrace_state = DOLBRACE_QUOTE;
1513 else if (dolbrace_state == DOLBRACE_PARAM && c == ',' && (i - *sindex) > 1)
1514 dolbrace_state = DOLBRACE_QUOTE;
1515 else if (dolbrace_state == DOLBRACE_PARAM && strchr ("#%^,~:-=?+/", c) != 0)
1516 dolbrace_state = DOLBRACE_OP;
1517 else if (dolbrace_state == DOLBRACE_OP && strchr ("#%^,~:-=?+/", c) == 0)
1518 dolbrace_state = DOLBRACE_WORD;
1521 if (c == 0 && nesting_level)
1523 if (no_longjmp_on_fatal_error == 0)
1525 last_command_exit_value = EXECUTION_FAILURE;
1526 report_error (_("bad substitution: no closing `%s' in %s"), "}", string);
1527 exp_jump_to_top_level (DISCARD);
1532 return ((char *)NULL);
1536 result = (flags & SX_NOALLOC) ? (char *)NULL : substring (string, *sindex, i);
1542 /* Remove backslashes which are quoting backquotes from STRING. Modifies
1543 STRING, and returns a pointer to it. */
1545 de_backslash (string)
1548 register size_t slen;
1549 register int i, j, prev_i;
1552 slen = strlen (string);
1555 /* Loop copying string[i] to string[j], i >= j. */
1558 if (string[i] == '\\' && (string[i + 1] == '`' || string[i + 1] == '\\' ||
1559 string[i + 1] == '$'))
1562 ADVANCE_CHAR (string, slen, i);
1564 do string[j++] = string[prev_i++]; while (prev_i < i);
1575 /* Replace instances of \! in a string with !. */
1577 unquote_bang (string)
1581 register char *temp;
1583 temp = (char *)xmalloc (1 + strlen (string));
1585 for (i = 0, j = 0; (temp[j] = string[i]); i++, j++)
1587 if (string[i] == '\\' && string[i + 1] == '!')
1593 strcpy (string, temp);
1598 #define CQ_RETURN(x) do { no_longjmp_on_fatal_error = 0; return (x); } while (0)
1600 /* This function assumes s[i] == open; returns with s[ret] == close; used to
1601 parse array subscripts. FLAGS & 1 means to not attempt to skip over
1602 matched pairs of quotes or backquotes, or skip word expansions; it is
1603 intended to be used after expansion has been performed and during final
1604 assignment parsing (see arrayfunc.c:assign_compound_array_list()). */
1606 skip_matched_pair (string, start, open, close, flags)
1608 int start, open, close, flags;
1610 int i, pass_next, backq, si, c, count;
1615 slen = strlen (string + start) + start;
1616 no_longjmp_on_fatal_error = 1;
1618 i = start + 1; /* skip over leading bracket */
1620 pass_next = backq = 0;
1621 ss = (char *)string;
1622 while (c = string[i])
1629 ADVANCE_CHAR (string, slen, i);
1642 ADVANCE_CHAR (string, slen, i);
1645 else if ((flags & 1) == 0 && c == '`')
1651 else if ((flags & 1) == 0 && c == open)
1657 else if (c == close)
1665 else if ((flags & 1) == 0 && (c == '\'' || c == '"'))
1667 i = (c == '\'') ? skip_single_quoted (ss, slen, ++i)
1668 : skip_double_quoted (ss, slen, ++i);
1669 /* no increment, the skip functions increment past the closing quote. */
1671 else if ((flags&1) == 0 && c == '$' && (string[i+1] == LPAREN || string[i+1] == LBRACE))
1674 if (string[si] == '\0')
1677 if (string[i+1] == LPAREN)
1678 temp = extract_delimited_string (ss, &si, "$(", "(", ")", SX_NOALLOC|SX_COMMAND); /* ) */
1680 temp = extract_dollar_brace_string (ss, &si, 0, SX_NOALLOC);
1682 if (string[i] == '\0') /* don't increment i past EOS in loop */
1688 ADVANCE_CHAR (string, slen, i);
1694 #if defined (ARRAY_VARS)
1696 skipsubscript (string, start, flags)
1700 return (skip_matched_pair (string, start, '[', ']', flags));
1704 /* Skip characters in STRING until we find a character in DELIMS, and return
1705 the index of that character. START is the index into string at which we
1706 begin. This is similar in spirit to strpbrk, but it returns an index into
1707 STRING and takes a starting index. This little piece of code knows quite
1708 a lot of shell syntax. It's very similar to skip_double_quoted and other
1709 functions of that ilk. */
1711 skip_to_delim (string, start, delims, flags)
1717 int i, pass_next, backq, si, c, invert, skipquote, skipcmd;
1719 char *temp, open[3];
1722 slen = strlen (string + start) + start;
1723 if (flags & SD_NOJMP)
1724 no_longjmp_on_fatal_error = 1;
1725 invert = (flags & SD_INVERT);
1726 skipcmd = (flags & SD_NOSKIPCMD) == 0;
1729 pass_next = backq = 0;
1730 while (c = string[i])
1732 /* If this is non-zero, we should not let quote characters be delimiters
1733 and the current character is a single or double quote. We should not
1734 test whether or not it's a delimiter until after we skip single- or
1735 double-quoted strings. */
1736 skipquote = ((flags & SD_NOQUOTEDELIM) && (c == '\'' || c =='"'));
1742 ADVANCE_CHAR (string, slen, i);
1755 ADVANCE_CHAR (string, slen, i);
1764 else if (skipquote == 0 && invert == 0 && member (c, delims))
1766 else if (c == '\'' || c == '"')
1768 i = (c == '\'') ? skip_single_quoted (string, slen, ++i)
1769 : skip_double_quoted (string, slen, ++i);
1770 /* no increment, the skip functions increment past the closing quote. */
1772 else if (c == '$' && ((skipcmd && string[i+1] == LPAREN) || string[i+1] == LBRACE))
1775 if (string[si] == '\0')
1778 if (string[i+1] == LPAREN)
1779 temp = extract_delimited_string (string, &si, "$(", "(", ")", SX_NOALLOC|SX_COMMAND); /* ) */
1781 temp = extract_dollar_brace_string (string, &si, 0, SX_NOALLOC);
1783 if (string[i] == '\0') /* don't increment i past EOS in loop */
1788 #if defined (PROCESS_SUBSTITUTION)
1789 else if (skipcmd && (c == '<' || c == '>') && string[i+1] == LPAREN)
1792 if (string[si] == '\0')
1794 temp = extract_process_subst (string, (c == '<') ? "<(" : ">(", &si, 0);
1795 free (temp); /* no SX_ALLOC here */
1797 if (string[i] == '\0')
1802 #endif /* PROCESS_SUBSTITUTION */
1803 #if defined (EXTENDED_GLOB)
1804 else if ((flags & SD_EXTGLOB) && extended_glob && string[i+1] == LPAREN && member (c, "?*+!@"))
1807 if (string[si] == '\0')
1813 temp = extract_delimited_string (string, &si, open, "(", ")", SX_NOALLOC); /* ) */
1816 if (string[i] == '\0') /* don't increment i past EOS in loop */
1822 else if ((flags & SD_GLOB) && c == LBRACK)
1825 if (string[si] == '\0')
1828 temp = extract_delimited_string (string, &si, "[", "[", "]", SX_NOALLOC); /* ] */
1831 if (string[i] == '\0') /* don't increment i past EOS in loop */
1836 else if ((skipquote || invert) && (member (c, delims) == 0))
1839 ADVANCE_CHAR (string, slen, i);
1845 #if defined (READLINE)
1846 /* Return 1 if the portion of STRING ending at EINDEX is quoted (there is
1847 an unclosed quoted string), or if the character at EINDEX is quoted
1848 by a backslash. NO_LONGJMP_ON_FATAL_ERROR is used to flag that the various
1849 single and double-quoted string parsing functions should not return an
1850 error if there are unclosed quotes or braces. The characters that this
1851 recognizes need to be the same as the contents of
1852 rl_completer_quote_characters. */
1855 char_is_quoted (string, eindex)
1859 int i, pass_next, c;
1863 slen = strlen (string);
1864 no_longjmp_on_fatal_error = 1;
1873 if (i >= eindex) /* XXX was if (i >= eindex - 1) */
1875 ADVANCE_CHAR (string, slen, i);
1884 else if (c == '\'' || c == '"')
1886 i = (c == '\'') ? skip_single_quoted (string, slen, ++i)
1887 : skip_double_quoted (string, slen, ++i);
1890 /* no increment, the skip_xxx functions go one past end */
1893 ADVANCE_CHAR (string, slen, i);
1900 unclosed_pair (string, eindex, openstr)
1905 int i, pass_next, openc, olen;
1909 slen = strlen (string);
1910 olen = strlen (openstr);
1911 i = pass_next = openc = 0;
1917 if (i >= eindex) /* XXX was if (i >= eindex - 1) */
1919 ADVANCE_CHAR (string, slen, i);
1922 else if (string[i] == '\\')
1928 else if (STREQN (string + i, openstr, olen))
1933 else if (string[i] == '\'' || string[i] == '"')
1935 i = (string[i] == '\'') ? skip_single_quoted (string, slen, i)
1936 : skip_double_quoted (string, slen, i);
1941 ADVANCE_CHAR (string, slen, i);
1946 /* Split STRING (length SLEN) at DELIMS, and return a WORD_LIST with the
1947 individual words. If DELIMS is NULL, the current value of $IFS is used
1948 to split the string, and the function follows the shell field splitting
1949 rules. SENTINEL is an index to look for. NWP, if non-NULL,
1950 gets the number of words in the returned list. CWP, if non-NULL, gets
1951 the index of the word containing SENTINEL. Non-whitespace chars in
1952 DELIMS delimit separate fields. */
1954 split_at_delims (string, slen, delims, sentinel, flags, nwp, cwp)
1958 int sentinel, flags;
1961 int ts, te, i, nw, cw, ifs_split, dflags;
1962 char *token, *d, *d2;
1963 WORD_LIST *ret, *tl;
1965 if (string == 0 || *string == '\0')
1971 return ((WORD_LIST *)NULL);
1974 d = (delims == 0) ? ifs_value : delims;
1975 ifs_split = delims == 0;
1977 /* Make d2 the non-whitespace characters in delims */
1982 #if defined (HANDLE_MULTIBYTE)
1983 size_t mblength = 1;
1987 slength = strlen (delims);
1988 d2 = (char *)xmalloc (slength + 1);
1992 #if defined (HANDLE_MULTIBYTE)
1993 mbstate_t state_bak;
1995 mblength = MBRLEN (delims + i, slength, &state);
1996 if (MB_INVALIDCH (mblength))
1998 else if (mblength > 1)
2000 memcpy (d2 + ts, delims + i, mblength);
2003 slength -= mblength;
2007 if (whitespace (delims[i]) == 0)
2008 d2[ts++] = delims[i];
2016 ret = (WORD_LIST *)NULL;
2018 /* Remove sequences of whitespace characters at the start of the string, as
2019 long as those characters are delimiters. */
2020 for (i = 0; member (string[i], d) && spctabnl (string[i]); i++)
2022 if (string[i] == '\0')
2028 dflags = flags|SD_NOJMP;
2031 te = skip_to_delim (string, ts, d, dflags);
2033 /* If we have a non-whitespace delimiter character, use it to make a
2034 separate field. This is just about what $IFS splitting does and
2035 is closer to the behavior of the shell parser. */
2036 if (ts == te && d2 && member (string[ts], d2))
2039 /* If we're using IFS splitting, the non-whitespace delimiter char
2040 and any additional IFS whitespace delimits a field. */
2042 while (member (string[te], d) && spctabnl (string[te]))
2045 while (member (string[te], d2))
2049 token = substring (string, ts, te);
2051 ret = add_string_to_list (token, ret);
2055 if (sentinel >= ts && sentinel <= te)
2058 /* If the cursor is at whitespace just before word start, set the
2059 sentinel word to the current word. */
2060 if (cwp && cw == -1 && sentinel == ts-1)
2063 /* If the cursor is at whitespace between two words, make a new, empty
2064 word, add it before (well, after, since the list is in reverse order)
2065 the word we just added, and set the current word to that one. */
2066 if (cwp && cw == -1 && sentinel < ts)
2068 tl = make_word_list (make_word (""), ret->next);
2074 if (string[te] == 0)
2078 while (member (string[i], d) && (ifs_split || spctabnl(string[i])))
2087 /* Special case for SENTINEL at the end of STRING. If we haven't found
2088 the word containing SENTINEL yet, and the index we're looking for is at
2089 the end of STRING (or past the end of the previously-found token,
2090 possible if the end of the line is composed solely of IFS whitespace)
2091 add an additional null argument and set the current word pointer to that. */
2092 if (cwp && cw == -1 && (sentinel >= slen || sentinel >= te))
2094 if (whitespace (string[sentinel - 1]))
2097 ret = add_string_to_list (token, ret);
2110 return (REVERSE_LIST (ret, WORD_LIST *));
2112 #endif /* READLINE */
2116 /* Extract the name of the variable to bind to from the assignment string. */
2118 assignment_name (string)
2124 offset = assignment (string, 0);
2126 return (char *)NULL;
2127 temp = substring (string, 0, offset);
2132 /* **************************************************************** */
2134 /* Functions to convert strings to WORD_LISTs and vice versa */
2136 /* **************************************************************** */
2138 /* Return a single string of all the words in LIST. SEP is the separator
2139 to put between individual elements of LIST in the output string. */
2141 string_list_internal (list, sep)
2145 register WORD_LIST *t;
2147 int word_len, sep_len, result_size;
2150 return ((char *)NULL);
2152 /* Short-circuit quickly if we don't need to separate anything. */
2153 if (list->next == 0)
2154 return (savestring (list->word->word));
2156 /* This is nearly always called with either sep[0] == 0 or sep[1] == 0. */
2157 sep_len = STRLEN (sep);
2160 for (t = list; t; t = t->next)
2163 result_size += sep_len;
2164 result_size += strlen (t->word->word);
2167 r = result = (char *)xmalloc (result_size + 1);
2169 for (t = list; t; t = t->next)
2171 if (t != list && sep_len)
2175 FASTCOPY (sep, r, sep_len);
2182 word_len = strlen (t->word->word);
2183 FASTCOPY (t->word->word, r, word_len);
2191 /* Return a single string of all the words present in LIST, separating
2192 each word with a space. */
2197 return (string_list_internal (list, " "));
2200 /* An external interface that can be used by the rest of the shell to
2201 obtain a string containing the first character in $IFS. Handles all
2202 the multibyte complications. If LENP is non-null, it is set to the
2203 length of the returned string. */
2205 ifs_firstchar (lenp)
2211 ret = xmalloc (MB_LEN_MAX + 1);
2212 #if defined (HANDLE_MULTIBYTE)
2213 if (ifs_firstc_len == 1)
2215 ret[0] = ifs_firstc[0];
2217 len = ret[0] ? 1 : 0;
2221 memcpy (ret, ifs_firstc, ifs_firstc_len);
2222 ret[len = ifs_firstc_len] = '\0';
2225 ret[0] = ifs_firstc;
2227 len = ret[0] ? 0 : 1;
2236 /* Return a single string of all the words present in LIST, obeying the
2237 quoting rules for "$*", to wit: (P1003.2, draft 11, 3.5.2) "If the
2238 expansion [of $*] appears within a double quoted string, it expands
2239 to a single field with the value of each parameter separated by the
2240 first character of the IFS variable, or by a <space> if IFS is unset." */
2242 string_list_dollar_star (list)
2246 #if defined (HANDLE_MULTIBYTE)
2247 # if defined (__GNUC__)
2248 char sep[MB_CUR_MAX + 1];
2256 #if defined (HANDLE_MULTIBYTE)
2257 # if !defined (__GNUC__)
2258 sep = (char *)xmalloc (MB_CUR_MAX + 1);
2259 # endif /* !__GNUC__ */
2260 if (ifs_firstc_len == 1)
2262 sep[0] = ifs_firstc[0];
2267 memcpy (sep, ifs_firstc, ifs_firstc_len);
2268 sep[ifs_firstc_len] = '\0';
2271 sep[0] = ifs_firstc;
2275 ret = string_list_internal (list, sep);
2276 #if defined (HANDLE_MULTIBYTE) && !defined (__GNUC__)
2282 /* Turn $@ into a string. If (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
2283 is non-zero, the $@ appears within double quotes, and we should quote
2284 the list before converting it into a string. If IFS is unset, and the
2285 word is not quoted, we just need to quote CTLESC and CTLNUL characters
2286 in the words in the list, because the default value of $IFS is
2287 <space><tab><newline>, IFS characters in the words in the list should
2288 also be split. If IFS is null, and the word is not quoted, we need
2289 to quote the words in the list to preserve the positional parameters
2292 string_list_dollar_at (list, quoted)
2297 #if defined (HANDLE_MULTIBYTE)
2298 # if defined (__GNUC__)
2299 char sep[MB_CUR_MAX + 1];
2302 # endif /* !__GNUC__ */
2308 /* XXX this could just be ifs = ifs_value; */
2309 ifs = ifs_var ? value_cell (ifs_var) : (char *)0;
2311 #if defined (HANDLE_MULTIBYTE)
2312 # if !defined (__GNUC__)
2313 sep = (char *)xmalloc (MB_CUR_MAX + 1);
2314 # endif /* !__GNUC__ */
2317 if (ifs_firstc_len == 1)
2319 sep[0] = ifs_firstc[0];
2324 memcpy (sep, ifs_firstc, ifs_firstc_len);
2325 sep[ifs_firstc_len] = '\0';
2334 sep[0] = (ifs == 0 || *ifs == 0) ? ' ' : *ifs;
2338 /* XXX -- why call quote_list if ifs == 0? we can get away without doing
2339 it now that quote_escapes quotes spaces */
2340 tlist = (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES|Q_PATQUOTE))
2342 : list_quote_escapes (list);
2344 ret = string_list_internal (tlist, sep);
2345 #if defined (HANDLE_MULTIBYTE) && !defined (__GNUC__)
2351 /* Turn the positional parameters into a string, understanding quoting and
2352 the various subtleties of using the first character of $IFS as the
2353 separator. Calls string_list_dollar_at, string_list_dollar_star, and
2354 string_list as appropriate. */
2356 string_list_pos_params (pchar, list, quoted)
2364 if (pchar == '*' && (quoted & Q_DOUBLE_QUOTES))
2366 tlist = quote_list (list);
2367 word_list_remove_quoted_nulls (tlist);
2368 ret = string_list_dollar_star (tlist);
2370 else if (pchar == '*' && (quoted & Q_HERE_DOCUMENT))
2372 tlist = quote_list (list);
2373 word_list_remove_quoted_nulls (tlist);
2374 ret = string_list (tlist);
2376 else if (pchar == '*')
2378 /* Even when unquoted, string_list_dollar_star does the right thing
2379 making sure that the first character of $IFS is used as the
2381 ret = string_list_dollar_star (list);
2383 else if (pchar == '@' && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
2384 /* We use string_list_dollar_at, but only if the string is quoted, since
2385 that quotes the escapes if it's not, which we don't want. We could
2386 use string_list (the old code did), but that doesn't do the right
2387 thing if the first character of $IFS is not a space. We use
2388 string_list_dollar_star if the string is unquoted so we make sure that
2389 the elements of $@ are separated by the first character of $IFS for
2391 ret = string_list_dollar_at (list, quoted);
2392 else if (pchar == '@')
2393 ret = string_list_dollar_star (list);
2395 ret = string_list ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) ? quote_list (list) : list);
2400 /* Return the list of words present in STRING. Separate the string into
2401 words at any of the characters found in SEPARATORS. If QUOTED is
2402 non-zero then word in the list will have its quoted flag set, otherwise
2403 the quoted flag is left as make_word () deemed fit.
2405 This obeys the P1003.2 word splitting semantics. If `separators' is
2406 exactly <space><tab><newline>, then the splitting algorithm is that of
2407 the Bourne shell, which treats any sequence of characters from `separators'
2408 as a delimiter. If IFS is unset, which results in `separators' being set
2409 to "", no splitting occurs. If separators has some other value, the
2410 following rules are applied (`IFS white space' means zero or more
2411 occurrences of <space>, <tab>, or <newline>, as long as those characters
2412 are in `separators'):
2414 1) IFS white space is ignored at the start and the end of the
2416 2) Each occurrence of a character in `separators' that is not
2417 IFS white space, along with any adjacent occurrences of
2418 IFS white space delimits a field.
2419 3) Any nonzero-length sequence of IFS white space delimits a field.
2422 /* BEWARE! list_string strips null arguments. Don't call it twice and
2423 expect to have "" preserved! */
2425 /* This performs word splitting and quoted null character removal on
2428 (((separators)[0]) ? ((separators)[1] ? isifs(c) \
2429 : (c) == (separators)[0]) \
2433 list_string (string, separators, quoted)
2434 register char *string, *separators;
2439 char *current_word, *s;
2440 int sindex, sh_style_split, whitesep, xflags;
2443 if (!string || !*string)
2444 return ((WORD_LIST *)NULL);
2446 sh_style_split = separators && separators[0] == ' ' &&
2447 separators[1] == '\t' &&
2448 separators[2] == '\n' &&
2449 separators[3] == '\0';
2450 for (xflags = 0, s = ifs_value; s && *s; s++)
2452 if (*s == CTLESC) xflags |= SX_NOCTLESC;
2453 else if (*s == CTLNUL) xflags |= SX_NOESCCTLNUL;
2457 /* Remove sequences of whitespace at the beginning of STRING, as
2458 long as those characters appear in IFS. Do not do this if
2459 STRING is quoted or if there are no separator characters. */
2460 if (!quoted || !separators || !*separators)
2462 for (s = string; *s && spctabnl (*s) && issep (*s); s++);
2465 return ((WORD_LIST *)NULL);
2470 /* OK, now STRING points to a word that does not begin with white space.
2471 The splitting algorithm is:
2472 extract a word, stopping at a separator
2473 skip sequences of spc, tab, or nl as long as they are separators
2474 This obeys the field splitting rules in Posix.2. */
2475 slen = (MB_CUR_MAX > 1) ? strlen (string) : 1;
2476 for (result = (WORD_LIST *)NULL, sindex = 0; string[sindex]; )
2478 /* Don't need string length in ADVANCE_CHAR or string_extract_verbatim
2479 unless multibyte chars are possible. */
2480 current_word = string_extract_verbatim (string, slen, &sindex, separators, xflags);
2481 if (current_word == 0)
2484 /* If we have a quoted empty string, add a quoted null argument. We
2485 want to preserve the quoted null character iff this is a quoted
2486 empty string; otherwise the quoted null characters are removed
2488 if (QUOTED_NULL (current_word))
2490 t = alloc_word_desc ();
2491 t->word = make_quoted_char ('\0');
2492 t->flags |= W_QUOTED|W_HASQUOTEDNULL;
2493 result = make_word_list (t, result);
2495 else if (current_word[0] != '\0')
2497 /* If we have something, then add it regardless. However,
2498 perform quoted null character removal on the current word. */
2499 remove_quoted_nulls (current_word);
2500 result = add_string_to_list (current_word, result);
2501 result->word->flags &= ~W_HASQUOTEDNULL; /* just to be sure */
2502 if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
2503 result->word->flags |= W_QUOTED;
2506 /* If we're not doing sequences of separators in the traditional
2507 Bourne shell style, then add a quoted null argument. */
2508 else if (!sh_style_split && !spctabnl (string[sindex]))
2510 t = alloc_word_desc ();
2511 t->word = make_quoted_char ('\0');
2512 t->flags |= W_QUOTED|W_HASQUOTEDNULL;
2513 result = make_word_list (t, result);
2516 free (current_word);
2518 /* Note whether or not the separator is IFS whitespace, used later. */
2519 whitesep = string[sindex] && spctabnl (string[sindex]);
2521 /* Move past the current separator character. */
2525 ADVANCE_CHAR (string, slen, sindex);
2528 /* Now skip sequences of space, tab, or newline characters if they are
2529 in the list of separators. */
2530 while (string[sindex] && spctabnl (string[sindex]) && issep (string[sindex]))
2533 /* If the first separator was IFS whitespace and the current character
2534 is a non-whitespace IFS character, it should be part of the current
2535 field delimiter, not a separate delimiter that would result in an
2536 empty field. Look at POSIX.2, 3.6.5, (3)(b). */
2537 if (string[sindex] && whitesep && issep (string[sindex]) && !spctabnl (string[sindex]))
2540 /* An IFS character that is not IFS white space, along with any
2541 adjacent IFS white space, shall delimit a field. (SUSv3) */
2542 while (string[sindex] && spctabnl (string[sindex]) && isifs (string[sindex]))
2546 return (REVERSE_LIST (result, WORD_LIST *));
2549 /* Parse a single word from STRING, using SEPARATORS to separate fields.
2550 ENDPTR is set to the first character after the word. This is used by
2551 the `read' builtin. This is never called with SEPARATORS != $IFS;
2552 it should be simplified.
2554 XXX - this function is very similar to list_string; they should be
2557 get_word_from_string (stringp, separators, endptr)
2558 char **stringp, *separators, **endptr;
2562 int sindex, sh_style_split, whitesep, xflags;
2565 if (!stringp || !*stringp || !**stringp)
2566 return ((char *)NULL);
2568 sh_style_split = separators && separators[0] == ' ' &&
2569 separators[1] == '\t' &&
2570 separators[2] == '\n' &&
2571 separators[3] == '\0';
2572 for (xflags = 0, s = ifs_value; s && *s; s++)
2574 if (*s == CTLESC) xflags |= SX_NOCTLESC;
2575 if (*s == CTLNUL) xflags |= SX_NOESCCTLNUL;
2581 /* Remove sequences of whitespace at the beginning of STRING, as
2582 long as those characters appear in IFS. */
2583 if (sh_style_split || !separators || !*separators)
2585 for (; *s && spctabnl (*s) && isifs (*s); s++);
2587 /* If the string is nothing but whitespace, update it and return. */
2593 return ((char *)NULL);
2597 /* OK, S points to a word that does not begin with white space.
2598 Now extract a word, stopping at a separator, save a pointer to
2599 the first character after the word, then skip sequences of spc,
2600 tab, or nl as long as they are separators.
2602 This obeys the field splitting rules in Posix.2. */
2604 /* Don't need string length in ADVANCE_CHAR or string_extract_verbatim
2605 unless multibyte chars are possible. */
2606 slen = (MB_CUR_MAX > 1) ? strlen (s) : 1;
2607 current_word = string_extract_verbatim (s, slen, &sindex, separators, xflags);
2609 /* Set ENDPTR to the first character after the end of the word. */
2611 *endptr = s + sindex;
2613 /* Note whether or not the separator is IFS whitespace, used later. */
2614 whitesep = s[sindex] && spctabnl (s[sindex]);
2616 /* Move past the current separator character. */
2620 ADVANCE_CHAR (s, slen, sindex);
2623 /* Now skip sequences of space, tab, or newline characters if they are
2624 in the list of separators. */
2625 while (s[sindex] && spctabnl (s[sindex]) && isifs (s[sindex]))
2628 /* If the first separator was IFS whitespace and the current character is
2629 a non-whitespace IFS character, it should be part of the current field
2630 delimiter, not a separate delimiter that would result in an empty field.
2631 Look at POSIX.2, 3.6.5, (3)(b). */
2632 if (s[sindex] && whitesep && isifs (s[sindex]) && !spctabnl (s[sindex]))
2635 /* An IFS character that is not IFS white space, along with any adjacent
2636 IFS white space, shall delimit a field. */
2637 while (s[sindex] && spctabnl (s[sindex]) && isifs (s[sindex]))
2641 /* Update STRING to point to the next field. */
2642 *stringp = s + sindex;
2643 return (current_word);
2646 /* Remove IFS white space at the end of STRING. Start at the end
2647 of the string and walk backwards until the beginning of the string
2648 or we find a character that's not IFS white space and not CTLESC.
2649 Only let CTLESC escape a white space character if SAW_ESCAPE is
2652 strip_trailing_ifs_whitespace (string, separators, saw_escape)
2653 char *string, *separators;
2658 s = string + STRLEN (string) - 1;
2659 while (s > string && ((spctabnl (*s) && isifs (*s)) ||
2660 (saw_escape && *s == CTLESC && spctabnl (s[1]))))
2668 /* Split STRING into words at whitespace. Obeys shell-style quoting with
2669 backslashes, single and double quotes. */
2671 list_string_with_quotes (string)
2677 int c, i, tokstart, len;
2679 for (s = string; s && *s && spctabnl (*s); s++)
2681 if (s == 0 || *s == 0)
2682 return ((WORD_LIST *)NULL);
2686 list = (WORD_LIST *)NULL;
2697 i = skip_single_quoted (s, s_len, ++i);
2699 i = skip_double_quoted (s, s_len, ++i);
2700 else if (c == 0 || spctabnl (c))
2702 /* We have found the end of a token. Make a word out of it and
2703 add it to the word list. */
2704 token = substring (s, tokstart, i);
2705 list = add_string_to_list (token, list);
2707 while (spctabnl (s[i]))
2715 i++; /* normal character */
2717 return (REVERSE_LIST (list, WORD_LIST *));
2721 /********************************************************/
2723 /* Functions to perform assignment statements */
2725 /********************************************************/
2727 #if defined (ARRAY_VARS)
2729 do_compound_assignment (name, value, flags)
2734 int mklocal, mkassoc, mkglobal;
2737 mklocal = flags & ASS_MKLOCAL;
2738 mkassoc = flags & ASS_MKASSOC;
2739 mkglobal = flags & ASS_MKGLOBAL;
2741 if (mklocal && variable_context)
2743 v = find_variable (name);
2744 list = expand_compound_array_assignment (v, value, flags);
2746 v = make_local_assoc_variable (name);
2747 else if (v == 0 || (array_p (v) == 0 && assoc_p (v) == 0) || v->context != variable_context)
2748 v = make_local_array_variable (name, 0);
2750 assign_compound_array_list (v, list, flags);
2752 /* In a function but forcing assignment in global context */
2753 else if (mkglobal && variable_context)
2755 v = find_global_variable (name);
2756 list = expand_compound_array_assignment (v, value, flags);
2757 if (v == 0 && mkassoc)
2758 v = make_new_assoc_variable (name);
2759 else if (v && mkassoc && assoc_p (v) == 0)
2760 v = convert_var_to_assoc (v);
2762 v = make_new_array_variable (name);
2763 else if (v && mkassoc == 0 && array_p (v) == 0)
2764 v = convert_var_to_array (v);
2766 assign_compound_array_list (v, list, flags);
2769 v = assign_array_from_string (name, value, flags);
2775 /* Given STRING, an assignment string, get the value of the right side
2776 of the `=', and bind it to the left side. If EXPAND is true, then
2777 perform parameter expansion, command substitution, and arithmetic
2778 expansion on the right-hand side. Perform tilde expansion in any
2779 case. Do not perform word splitting on the result of expansion. */
2781 do_assignment_internal (word, expand)
2782 const WORD_DESC *word;
2785 int offset, appendop, assign_list, aflags, retval;
2786 char *name, *value, *temp;
2788 #if defined (ARRAY_VARS)
2794 if (word == 0 || word->word == 0)
2797 appendop = assign_list = aflags = 0;
2798 string = word->word;
2799 offset = assignment (string, 0);
2800 name = savestring (string);
2801 value = (char *)NULL;
2803 if (name[offset] == '=')
2805 if (name[offset - 1] == '+')
2808 name[offset - 1] = '\0';
2811 name[offset] = 0; /* might need this set later */
2812 temp = name + offset + 1;
2814 #if defined (ARRAY_VARS)
2815 if (expand && (word->flags & W_COMPASSIGN))
2817 assign_list = ni = 1;
2818 value = extract_array_assignment_list (temp, &ni);
2822 if (expand && temp[0])
2823 value = expand_string_if_necessary (temp, 0, expand_string_assignment);
2825 value = savestring (temp);
2830 value = (char *)xmalloc (1);
2834 if (echo_command_at_execute)
2837 name[offset - 1] = '+';
2838 xtrace_print_assignment (name, value, assign_list, 1);
2840 name[offset - 1] = '\0';
2843 #define ASSIGN_RETURN(r) do { FREE (value); free (name); return (r); } while (0)
2846 aflags |= ASS_APPEND;
2848 #if defined (ARRAY_VARS)
2849 if (t = mbschr (name, '[')) /*]*/
2853 report_error (_("%s: cannot assign list to array member"), name);
2856 entry = assign_array_element (name, value, aflags);
2860 else if (assign_list)
2862 if ((word->flags & W_ASSIGNARG) && (word->flags & W_ASSNGLOBAL) == 0)
2863 aflags |= ASS_MKLOCAL;
2864 if ((word->flags & W_ASSIGNARG) && (word->flags & W_ASSNGLOBAL))
2865 aflags |= ASS_MKGLOBAL;
2866 if (word->flags & W_ASSIGNASSOC)
2867 aflags |= ASS_MKASSOC;
2868 entry = do_compound_assignment (name, value, aflags);
2871 #endif /* ARRAY_VARS */
2872 entry = bind_variable (name, value, aflags);
2874 stupidly_hack_special_variables (name);
2876 /* Return 1 if the assignment seems to have been performed correctly. */
2877 if (entry == 0 || readonly_p (entry))
2878 retval = 0; /* assignment failure */
2879 else if (noassign_p (entry))
2881 last_command_exit_value = EXECUTION_FAILURE;
2882 retval = 1; /* error status, but not assignment failure */
2887 if (entry && retval != 0 && noassign_p (entry) == 0)
2888 VUNSETATTR (entry, att_invisible);
2890 ASSIGN_RETURN (retval);
2893 /* Perform the assignment statement in STRING, and expand the
2894 right side by doing tilde, command and parameter expansion. */
2896 do_assignment (string)
2901 td.flags = W_ASSIGNMENT;
2904 return do_assignment_internal (&td, 1);
2908 do_word_assignment (word, flags)
2912 return do_assignment_internal (word, 1);
2915 /* Given STRING, an assignment string, get the value of the right side
2916 of the `=', and bind it to the left side. Do not perform any word
2917 expansions on the right hand side. */
2919 do_assignment_no_expand (string)
2924 td.flags = W_ASSIGNMENT;
2927 return (do_assignment_internal (&td, 0));
2930 /***************************************************
2932 * Functions to manage the positional parameters *
2934 ***************************************************/
2936 /* Return the word list that corresponds to `$*'. */
2938 list_rest_of_args ()
2940 register WORD_LIST *list, *args;
2943 /* Break out of the loop as soon as one of the dollar variables is null. */
2944 for (i = 1, list = (WORD_LIST *)NULL; i < 10 && dollar_vars[i]; i++)
2945 list = make_word_list (make_bare_word (dollar_vars[i]), list);
2947 for (args = rest_of_args; args; args = args->next)
2948 list = make_word_list (make_bare_word (args->word->word), list);
2950 return (REVERSE_LIST (list, WORD_LIST *));
2956 register WORD_LIST *list;
2959 for (n = 0; n < 9 && dollar_vars[n+1]; n++)
2961 for (list = rest_of_args; list; list = list->next)
2966 /* Return the value of a positional parameter. This handles values > 10. */
2968 get_dollar_var_value (ind)
2975 temp = dollar_vars[ind] ? savestring (dollar_vars[ind]) : (char *)NULL;
2976 else /* We want something like ${11} */
2979 for (p = rest_of_args; p && ind--; p = p->next)
2981 temp = p ? savestring (p->word->word) : (char *)NULL;
2986 /* Make a single large string out of the dollar digit variables,
2987 and the rest_of_args. If DOLLAR_STAR is 1, then obey the special
2988 case of "$*" with respect to IFS. */
2990 string_rest_of_args (dollar_star)
2993 register WORD_LIST *list;
2996 list = list_rest_of_args ();
2997 string = dollar_star ? string_list_dollar_star (list) : string_list (list);
2998 dispose_words (list);
3002 /* Return a string containing the positional parameters from START to
3003 END, inclusive. If STRING[0] == '*', we obey the rules for $*,
3004 which only makes a difference if QUOTED is non-zero. If QUOTED includes
3005 Q_HERE_DOCUMENT or Q_DOUBLE_QUOTES, this returns a quoted list, otherwise
3006 no quoting chars are added. */
3008 pos_params (string, start, end, quoted)
3010 int start, end, quoted;
3012 WORD_LIST *save, *params, *h, *t;
3016 /* see if we can short-circuit. if start == end, we want 0 parameters. */
3018 return ((char *)NULL);
3020 save = params = list_rest_of_args ();
3022 return ((char *)NULL);
3024 if (start == 0) /* handle ${@:0[:x]} specially */
3026 t = make_word_list (make_word (dollar_vars[0]), params);
3030 for (i = start ? 1 : 0; params && i < start; i++)
3031 params = params->next;
3033 return ((char *)NULL);
3034 for (h = t = params; params && i < end; i++)
3037 params = params->next;
3040 t->next = (WORD_LIST *)NULL;
3042 ret = string_list_pos_params (string[0], h, quoted);
3047 dispose_words (save);
3051 /******************************************************************/
3053 /* Functions to expand strings to strings or WORD_LISTs */
3055 /******************************************************************/
3057 #if defined (PROCESS_SUBSTITUTION)
3058 #define EXP_CHAR(s) (s == '$' || s == '`' || s == '<' || s == '>' || s == CTLESC || s == '~')
3060 #define EXP_CHAR(s) (s == '$' || s == '`' || s == CTLESC || s == '~')
3063 /* If there are any characters in STRING that require full expansion,
3064 then call FUNC to expand STRING; otherwise just perform quote
3065 removal if necessary. This returns a new string. */
3067 expand_string_if_necessary (string, quoted, func)
3078 /* Don't need string length for ADVANCE_CHAR unless multibyte chars possible. */
3079 slen = (MB_CUR_MAX > 1) ? strlen (string) : 0;
3083 if (EXP_CHAR (string[i]))
3085 else if (string[i] == '\'' || string[i] == '\\' || string[i] == '"')
3087 ADVANCE_CHAR (string, slen, i);
3092 list = (*func) (string, quoted);
3095 ret = string_list (list);
3096 dispose_words (list);
3101 else if (saw_quote && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
3102 ret = string_quote_removal (string, quoted);
3104 ret = savestring (string);
3109 static inline char *
3110 expand_string_to_string_internal (string, quoted, func)
3118 if (string == 0 || *string == '\0')
3119 return ((char *)NULL);
3121 list = (*func) (string, quoted);
3124 ret = string_list (list);
3125 dispose_words (list);
3134 expand_string_to_string (string, quoted)
3138 return (expand_string_to_string_internal (string, quoted, expand_string));
3142 expand_string_unsplit_to_string (string, quoted)
3146 return (expand_string_to_string_internal (string, quoted, expand_string_unsplit));
3150 expand_assignment_string_to_string (string, quoted)
3154 return (expand_string_to_string_internal (string, quoted, expand_string_assignment));
3158 expand_arith_string (string, quoted)
3163 WORD_LIST *list, *tlist;
3169 /* Don't need string length for ADVANCE_CHAR unless multibyte chars possible. */
3170 slen = (MB_CUR_MAX > 1) ? strlen (string) : 0;
3174 if (EXP_CHAR (string[i]))
3176 else if (string[i] == '\'' || string[i] == '\\' || string[i] == '"')
3178 ADVANCE_CHAR (string, slen, i);
3183 /* This is expanded version of expand_string_internal as it's called by
3184 expand_string_leave_quoted */
3185 td.flags = W_NOPROCSUB; /* don't want process substitution */
3186 td.word = savestring (string);
3187 list = call_expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
3188 /* This takes care of the calls from expand_string_leave_quoted and
3192 tlist = word_list_split (list);
3193 dispose_words (list);
3196 dequote_list (list);
3198 /* This comes from expand_string_if_necessary */
3201 ret = string_list (list);
3202 dispose_words (list);
3208 else if (saw_quote && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
3209 ret = string_quote_removal (string, quoted);
3211 ret = savestring (string);
3216 #if defined (COND_COMMAND)
3217 /* Just remove backslashes in STRING. Returns a new string. */
3219 remove_backslashes (string)
3224 r = ret = (char *)xmalloc (strlen (string) + 1);
3225 for (s = string; s && *s; )
3237 /* This needs better error handling. */
3238 /* Expand W for use as an argument to a unary or binary operator in a
3239 [[...]] expression. If SPECIAL is 1, this is the rhs argument
3240 to the != or == operator, and should be treated as a pattern. In
3241 this case, we quote the string specially for the globbing code. If
3242 SPECIAL is 2, this is an rhs argument for the =~ operator, and should
3243 be quoted appropriately for regcomp/regexec. The caller is responsible
3244 for removing the backslashes if the unquoted word is needed later. */
3246 cond_expand_word (w, special)
3254 if (w->word == 0 || w->word[0] == '\0')
3255 return ((char *)NULL);
3257 expand_no_split_dollar_star = 1;
3258 w->flags |= W_NOSPLIT2;
3259 l = call_expand_word_internal (w, 0, 0, (int *)0, (int *)0);
3260 expand_no_split_dollar_star = 0;
3263 if (special == 0) /* LHS */
3266 r = string_list (l);
3270 /* Need to figure out whether or not we should call dequote_escapes
3271 or a new dequote_ctlnul function here, and under what
3273 qflags = QGLOB_CVTNULL;
3275 qflags |= QGLOB_REGEXP;
3276 p = string_list (l);
3277 r = quote_string_for_globbing (p, qflags);
3289 /* Call expand_word_internal to expand W and handle error returns.
3290 A convenience function for functions that don't want to handle
3291 any errors or free any memory before aborting. */
3293 call_expand_word_internal (w, q, i, c, e)
3299 result = expand_word_internal (w, q, i, c, e);
3300 if (result == &expand_word_error || result == &expand_word_fatal)
3302 /* By convention, each time this error is returned, w->word has
3303 already been freed (it sometimes may not be in the fatal case,
3304 but that doesn't result in a memory leak because we're going
3305 to exit in most cases). */
3306 w->word = (char *)NULL;
3307 last_command_exit_value = EXECUTION_FAILURE;
3308 exp_jump_to_top_level ((result == &expand_word_error) ? DISCARD : FORCE_EOF);
3316 /* Perform parameter expansion, command substitution, and arithmetic
3317 expansion on STRING, as if it were a word. Leave the result quoted.
3318 Since this does not perform word splitting, it leaves quoted nulls
3321 expand_string_internal (string, quoted)
3328 if (string == 0 || *string == 0)
3329 return ((WORD_LIST *)NULL);
3332 td.word = savestring (string);
3334 tresult = call_expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
3340 /* Expand STRING by performing parameter expansion, command substitution,
3341 and arithmetic expansion. Dequote the resulting WORD_LIST before
3342 returning it, but do not perform word splitting. The call to
3343 remove_quoted_nulls () is in here because word splitting normally
3344 takes care of quote removal. */
3346 expand_string_unsplit (string, quoted)
3352 if (string == 0 || *string == '\0')
3353 return ((WORD_LIST *)NULL);
3355 expand_no_split_dollar_star = 1;
3356 value = expand_string_internal (string, quoted);
3357 expand_no_split_dollar_star = 0;
3363 remove_quoted_nulls (value->word->word);
3364 value->word->flags &= ~W_HASQUOTEDNULL;
3366 dequote_list (value);
3371 /* Expand the rhs of an assignment statement */
3373 expand_string_assignment (string, quoted)
3380 if (string == 0 || *string == '\0')
3381 return ((WORD_LIST *)NULL);
3383 expand_no_split_dollar_star = 1;
3385 td.flags = W_ASSIGNRHS;
3386 td.word = savestring (string);
3387 value = call_expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
3390 expand_no_split_dollar_star = 0;
3396 remove_quoted_nulls (value->word->word);
3397 value->word->flags &= ~W_HASQUOTEDNULL;
3399 dequote_list (value);
3405 /* Expand one of the PS? prompt strings. This is a sort of combination of
3406 expand_string_unsplit and expand_string_internal, but returns the
3407 passed string when an error occurs. Might want to trap other calls
3408 to jump_to_top_level here so we don't endlessly loop. */
3410 expand_prompt_string (string, quoted, wflags)
3418 if (string == 0 || *string == 0)
3419 return ((WORD_LIST *)NULL);
3422 td.word = savestring (string);
3424 no_longjmp_on_fatal_error = 1;
3425 value = expand_word_internal (&td, quoted, 0, (int *)NULL, (int *)NULL);
3426 no_longjmp_on_fatal_error = 0;
3428 if (value == &expand_word_error || value == &expand_word_fatal)
3430 value = make_word_list (make_bare_word (string), (WORD_LIST *)NULL);
3438 remove_quoted_nulls (value->word->word);
3439 value->word->flags &= ~W_HASQUOTEDNULL;
3441 dequote_list (value);
3446 /* Expand STRING just as if you were expanding a word, but do not dequote
3447 the resultant WORD_LIST. This is called only from within this file,
3448 and is used to correctly preserve quoted characters when expanding
3449 things like ${1+"$@"}. This does parameter expansion, command
3450 substitution, arithmetic expansion, and word splitting. */
3452 expand_string_leave_quoted (string, quoted)
3459 if (string == 0 || *string == '\0')
3460 return ((WORD_LIST *)NULL);
3462 tlist = expand_string_internal (string, quoted);
3466 tresult = word_list_split (tlist);
3467 dispose_words (tlist);
3470 return ((WORD_LIST *)NULL);
3473 /* This does not perform word splitting or dequote the WORD_LIST
3476 expand_string_for_rhs (string, quoted, dollar_at_p, has_dollar_at)
3478 int quoted, *dollar_at_p, *has_dollar_at;
3483 if (string == 0 || *string == '\0')
3484 return (WORD_LIST *)NULL;
3486 td.flags = W_NOSPLIT2; /* no splitting, remove "" and '' */
3488 tresult = call_expand_word_internal (&td, quoted, 1, dollar_at_p, has_dollar_at);
3492 /* Expand STRING just as if you were expanding a word. This also returns
3493 a list of words. Note that filename globbing is *NOT* done for word
3494 or string expansion, just when the shell is expanding a command. This
3495 does parameter expansion, command substitution, arithmetic expansion,
3496 and word splitting. Dequote the resultant WORD_LIST before returning. */
3498 expand_string (string, quoted)
3504 if (string == 0 || *string == '\0')
3505 return ((WORD_LIST *)NULL);
3507 result = expand_string_leave_quoted (string, quoted);
3508 return (result ? dequote_list (result) : result);
3511 /***************************************************
3513 * Functions to handle quoting chars *
3515 ***************************************************/
3519 A string with s[0] == CTLNUL && s[1] == 0 is a quoted null string.
3520 The parser passes CTLNUL as CTLESC CTLNUL. */
3522 /* Quote escape characters in string s, but no other characters. This is
3523 used to protect CTLESC and CTLNUL in variable values from the rest of
3524 the word expansion process after the variable is expanded (word splitting
3525 and filename generation). If IFS is null, we quote spaces as well, just
3526 in case we split on spaces later (in the case of unquoted $@, we will
3527 eventually attempt to split the entire word on spaces). Corresponding
3528 code exists in dequote_escapes. Even if we don't end up splitting on
3529 spaces, quoting spaces is not a problem. This should never be called on
3530 a string that is quoted with single or double quotes or part of a here
3531 document (effectively double-quoted). */
3533 quote_escapes (string)
3536 register char *s, *t;
3538 char *result, *send;
3539 int quote_spaces, skip_ctlesc, skip_ctlnul;
3542 slen = strlen (string);
3543 send = string + slen;
3545 quote_spaces = (ifs_value && *ifs_value == 0);
3547 for (skip_ctlesc = skip_ctlnul = 0, s = ifs_value; s && *s; s++)
3548 skip_ctlesc |= *s == CTLESC, skip_ctlnul |= *s == CTLNUL;
3550 t = result = (char *)xmalloc ((slen * 2) + 1);
3555 if ((skip_ctlesc == 0 && *s == CTLESC) || (skip_ctlnul == 0 && *s == CTLNUL) || (quote_spaces && *s == ' '))
3557 COPY_CHAR_P (t, s, send);
3565 list_quote_escapes (list)
3568 register WORD_LIST *w;
3571 for (w = list; w; w = w->next)
3574 w->word->word = quote_escapes (t);
3580 /* Inverse of quote_escapes; remove CTLESC protecting CTLESC or CTLNUL.
3582 The parser passes us CTLESC as CTLESC CTLESC and CTLNUL as CTLESC CTLNUL.
3583 This is necessary to make unquoted CTLESC and CTLNUL characters in the
3584 data stream pass through properly.
3586 We need to remove doubled CTLESC characters inside quoted strings before
3587 quoting the entire string, so we do not double the number of CTLESC
3590 Also used by parts of the pattern substitution code. */
3592 dequote_escapes (string)
3595 register char *s, *t, *s1;
3597 char *result, *send;
3604 slen = strlen (string);
3605 send = string + slen;
3607 t = result = (char *)xmalloc (slen + 1);
3609 if (strchr (string, CTLESC) == 0)
3610 return (strcpy (result, string));
3612 quote_spaces = (ifs_value && *ifs_value == 0);
3617 if (*s == CTLESC && (s[1] == CTLESC || s[1] == CTLNUL || (quote_spaces && s[1] == ' ')))
3623 COPY_CHAR_P (t, s, send);
3631 list_dequote_escapes (list)
3634 register WORD_LIST *w;
3637 for (w = list; w; w = w->next)
3640 w->word->word = dequote_escapes (t);
3646 /* Return a new string with the quoted representation of character C.
3647 This turns "" into QUOTED_NULL, so the W_HASQUOTEDNULL flag needs to be
3648 set in any resultant WORD_DESC where this value is the word. */
3650 make_quoted_char (c)
3655 temp = (char *)xmalloc (3);
3670 /* Quote STRING, returning a new string. This turns "" into QUOTED_NULL, so
3671 the W_HASQUOTEDNULL flag needs to be set in any resultant WORD_DESC where
3672 this value is the word. */
3674 quote_string (string)
3679 char *result, *send;
3683 result = (char *)xmalloc (2);
3691 slen = strlen (string);
3692 send = string + slen;
3694 result = (char *)xmalloc ((slen * 2) + 1);
3696 for (t = result; string < send; )
3699 COPY_CHAR_P (t, string, send);
3706 /* De-quote quoted characters in STRING. */
3708 dequote_string (string)
3711 register char *s, *t;
3713 char *result, *send;
3716 slen = strlen (string);
3718 t = result = (char *)xmalloc (slen + 1);
3720 if (QUOTED_NULL (string))
3726 /* If no character in the string can be quoted, don't bother examining
3727 each character. Just return a copy of the string passed to us. */
3728 if (strchr (string, CTLESC) == NULL)
3729 return (strcpy (result, string));
3731 send = string + slen;
3741 COPY_CHAR_P (t, s, send);
3748 /* Quote the entire WORD_LIST list. */
3753 register WORD_LIST *w;
3756 for (w = list; w; w = w->next)
3759 w->word->word = quote_string (t);
3761 w->word->flags |= W_HASQUOTEDNULL; /* XXX - turn on W_HASQUOTEDNULL here? */
3762 w->word->flags |= W_QUOTED;
3768 /* De-quote quoted characters in each word in LIST. */
3774 register WORD_LIST *tlist;
3776 for (tlist = list; tlist; tlist = tlist->next)
3778 s = dequote_string (tlist->word->word);
3779 if (QUOTED_NULL (tlist->word->word))
3780 tlist->word->flags &= ~W_HASQUOTEDNULL;
3781 free (tlist->word->word);
3782 tlist->word->word = s;
3787 /* Remove CTLESC protecting a CTLESC or CTLNUL in place. Return the passed
3790 remove_quoted_escapes (string)
3797 t = dequote_escapes (string);
3805 /* Perform quoted null character removal on STRING. We don't allow any
3806 quoted null characters in the middle or at the ends of strings because
3807 of how expand_word_internal works. remove_quoted_nulls () turns
3808 STRING into an empty string iff it only consists of a quoted null,
3809 and removes all unquoted CTLNUL characters. */
3811 remove_quoted_nulls (string)
3814 register size_t slen;
3815 register int i, j, prev_i;
3818 if (strchr (string, CTLNUL) == 0) /* XXX */
3819 return string; /* XXX */
3821 slen = strlen (string);
3826 if (string[i] == CTLESC)
3828 /* Old code had j++, but we cannot assume that i == j at this
3829 point -- what if a CTLNUL has already been removed from the
3830 string? We don't want to drop the CTLESC or recopy characters
3831 that we've already copied down. */
3832 i++; string[j++] = CTLESC;
3836 else if (string[i] == CTLNUL)
3843 ADVANCE_CHAR (string, slen, i);
3846 do string[j++] = string[prev_i++]; while (prev_i < i);
3856 /* Perform quoted null character removal on each element of LIST.
3857 This modifies LIST. */
3859 word_list_remove_quoted_nulls (list)
3862 register WORD_LIST *t;
3864 for (t = list; t; t = t->next)
3866 remove_quoted_nulls (t->word->word);
3867 t->word->flags &= ~W_HASQUOTEDNULL;
3871 /* **************************************************************** */
3873 /* Functions for Matching and Removing Patterns */
3875 /* **************************************************************** */
3877 #if defined (HANDLE_MULTIBYTE)
3878 #if 0 /* Currently unused */
3879 static unsigned char *
3880 mb_getcharlens (string, len)
3884 int i, offset, last;
3891 ret = (unsigned char *)xmalloc (len);
3892 memset (ret, 0, len);
3893 while (string[last])
3895 ADVANCE_CHAR (string, len, offset);
3896 ret[last] = offset - last;
3904 /* Remove the portion of PARAM matched by PATTERN according to OP, where OP
3905 can have one of 4 values:
3906 RP_LONG_LEFT remove longest matching portion at start of PARAM
3907 RP_SHORT_LEFT remove shortest matching portion at start of PARAM
3908 RP_LONG_RIGHT remove longest matching portion at end of PARAM
3909 RP_SHORT_RIGHT remove shortest matching portion at end of PARAM
3912 #define RP_LONG_LEFT 1
3913 #define RP_SHORT_LEFT 2
3914 #define RP_LONG_RIGHT 3
3915 #define RP_SHORT_RIGHT 4
3917 /* Returns its first argument if nothing matched; new memory otherwise */
3919 remove_upattern (param, pattern, op)
3920 char *param, *pattern;
3925 register char *p, *ret, c;
3927 len = STRLEN (param);
3932 case RP_LONG_LEFT: /* remove longest match at start */
3933 for (p = end; p >= param; p--)
3936 if (strmatch (pattern, param, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3939 return (savestring (p));
3946 case RP_SHORT_LEFT: /* remove shortest match at start */
3947 for (p = param; p <= end; p++)
3950 if (strmatch (pattern, param, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3953 return (savestring (p));
3959 case RP_LONG_RIGHT: /* remove longest match at end */
3960 for (p = param; p <= end; p++)
3962 if (strmatch (pattern, p, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3965 ret = savestring (param);
3972 case RP_SHORT_RIGHT: /* remove shortest match at end */
3973 for (p = end; p >= param; p--)
3975 if (strmatch (pattern, p, FNMATCH_EXTFLAG) != FNM_NOMATCH)
3978 ret = savestring (param);
3986 return (param); /* no match, return original string */
3989 #if defined (HANDLE_MULTIBYTE)
3990 /* Returns its first argument if nothing matched; new memory otherwise */
3992 remove_wpattern (wparam, wstrlen, wpattern, op)
4003 case RP_LONG_LEFT: /* remove longest match at start */
4004 for (n = wstrlen; n >= 0; n--)
4006 wc = wparam[n]; wparam[n] = L'\0';
4007 if (wcsmatch (wpattern, wparam, FNMATCH_EXTFLAG) != FNM_NOMATCH)
4010 return (wcsdup (wparam + n));
4016 case RP_SHORT_LEFT: /* remove shortest match at start */
4017 for (n = 0; n <= wstrlen; n++)
4019 wc = wparam[n]; wparam[n] = L'\0';
4020 if (wcsmatch (wpattern, wparam, FNMATCH_EXTFLAG) != FNM_NOMATCH)
4023 return (wcsdup (wparam + n));
4029 case RP_LONG_RIGHT: /* remove longest match at end */
4030 for (n = 0; n <= wstrlen; n++)
4032 if (wcsmatch (wpattern, wparam + n, FNMATCH_EXTFLAG) != FNM_NOMATCH)
4034 wc = wparam[n]; wparam[n] = L'\0';
4035 ret = wcsdup (wparam);
4042 case RP_SHORT_RIGHT: /* remove shortest match at end */
4043 for (n = wstrlen; n >= 0; n--)
4045 if (wcsmatch (wpattern, wparam + n, FNMATCH_EXTFLAG) != FNM_NOMATCH)
4047 wc = wparam[n]; wparam[n] = L'\0';
4048 ret = wcsdup (wparam);
4056 return (wparam); /* no match, return original string */
4058 #endif /* HANDLE_MULTIBYTE */
4061 remove_pattern (param, pattern, op)
4062 char *param, *pattern;
4069 if (*param == '\0' || pattern == NULL || *pattern == '\0') /* minor optimization */
4070 return (savestring (param));
4072 #if defined (HANDLE_MULTIBYTE)
4075 wchar_t *ret, *oret;
4077 wchar_t *wparam, *wpattern;
4080 n = xdupmbstowcs (&wpattern, NULL, pattern);
4081 if (n == (size_t)-1)
4083 xret = remove_upattern (param, pattern, op);
4084 return ((xret == param) ? savestring (param) : xret);
4086 n = xdupmbstowcs (&wparam, NULL, param);
4088 if (n == (size_t)-1)
4091 xret = remove_upattern (param, pattern, op);
4092 return ((xret == param) ? savestring (param) : xret);
4094 oret = ret = remove_wpattern (wparam, n, wpattern, op);
4095 /* Don't bother to convert wparam back to multibyte string if nothing
4096 matched; just return copy of original string */
4101 return (savestring (param));
4108 xret = (char *)xmalloc (n + 1);
4109 memset (&ps, '\0', sizeof (mbstate_t));
4110 n = wcsrtombs (xret, (const wchar_t **)&ret, n, &ps);
4111 xret[n] = '\0'; /* just to make sure */
4118 xret = remove_upattern (param, pattern, op);
4119 return ((xret == param) ? savestring (param) : xret);
4123 /* Match PAT anywhere in STRING and return the match boundaries.
4124 This returns 1 in case of a successful match, 0 otherwise. SP
4125 and EP are pointers into the string where the match begins and
4126 ends, respectively. MTYPE controls what kind of match is attempted.
4127 MATCH_BEG and MATCH_END anchor the match at the beginning and end
4128 of the string, respectively. The longest match is returned. */
4130 match_upattern (string, pat, mtype, sp, ep)
4136 register char *p, *p1, *npat;
4140 /* If the pattern doesn't match anywhere in the string, go ahead and
4141 short-circuit right away. A minor optimization, saves a bunch of
4142 unnecessary calls to strmatch (up to N calls for a string of N
4143 characters) if the match is unsuccessful. To preserve the semantics
4144 of the substring matches below, we make sure that the pattern has
4145 `*' as first and last character, making a new pattern if necessary. */
4146 /* XXX - check this later if I ever implement `**' with special meaning,
4147 since this will potentially result in `**' at the beginning or end */
4149 if (pat[0] != '*' || (pat[0] == '*' && pat[1] == LPAREN && extended_glob) || pat[len - 1] != '*')
4151 p = npat = (char *)xmalloc (len + 3);
4153 if (*p1 != '*' || (*p1 == '*' && p1[1] == LPAREN && extended_glob))
4157 if (p1[-1] != '*' || p[-2] == '\\')
4163 c = strmatch (npat, string, FNMATCH_EXTFLAG);
4166 if (c == FNM_NOMATCH)
4169 len = STRLEN (string);
4172 mlen = umatchlen (pat, len);
4177 for (p = string; p <= end; p++)
4179 if (match_pattern_char (pat, p))
4181 p1 = (mlen == -1) ? end : p + mlen;
4182 /* p1 - p = length of portion of string to be considered
4183 p = current position in string
4184 mlen = number of characters consumed by match (-1 for entire string)
4186 we want to break immediately if the potential match len
4187 is greater than the number of characters remaining in the
4192 for ( ; p1 >= p; p1--)
4194 c = *p1; *p1 = '\0';
4195 if (strmatch (pat, p, FNMATCH_EXTFLAG) == 0)
4204 /* If MLEN != -1, we have a fixed length pattern. */
4215 if (match_pattern_char (pat, string) == 0)
4218 for (p = (mlen == -1) ? end : string + mlen; p >= string; p--)
4221 if (strmatch (pat, string, FNMATCH_EXTFLAG) == 0)
4229 /* If MLEN != -1, we have a fixed length pattern. */
4237 for (p = end - ((mlen == -1) ? len : mlen); p <= end; p++)
4239 if (strmatch (pat, p, FNMATCH_EXTFLAG) == 0)
4245 /* If MLEN != -1, we have a fixed length pattern. */
4256 #if defined (HANDLE_MULTIBYTE)
4257 /* Match WPAT anywhere in WSTRING and return the match boundaries.
4258 This returns 1 in case of a successful match, 0 otherwise. Wide
4259 character version. */
4261 match_wpattern (wstring, indices, wstrlen, wpat, mtype, sp, ep)
4269 wchar_t wc, *wp, *nwpat, *wp1;
4272 int n, n1, n2, simple;
4274 simple = (wpat[0] != L'\\' && wpat[0] != L'*' && wpat[0] != L'?' && wpat[0] != L'[');
4275 #if defined (EXTENDED_GLOB)
4277 simple &= (wpat[1] != L'(' || (wpat[0] != L'*' && wpat[0] != L'?' && wpat[0] != L'+' && wpat[0] != L'!' && wpat[0] != L'@')); /*)*/
4280 /* If the pattern doesn't match anywhere in the string, go ahead and
4281 short-circuit right away. A minor optimization, saves a bunch of
4282 unnecessary calls to strmatch (up to N calls for a string of N
4283 characters) if the match is unsuccessful. To preserve the semantics
4284 of the substring matches below, we make sure that the pattern has
4285 `*' as first and last character, making a new pattern if necessary. */
4286 len = wcslen (wpat);
4287 if (wpat[0] != L'*' || (wpat[0] == L'*' && wpat[1] == WLPAREN && extended_glob) || wpat[len - 1] != L'*')
4289 wp = nwpat = (wchar_t *)xmalloc ((len + 3) * sizeof (wchar_t));
4291 if (*wp1 != L'*' || (*wp1 == '*' && wp1[1] == WLPAREN && extended_glob))
4293 while (*wp1 != L'\0')
4295 if (wp1[-1] != L'*' || wp1[-2] == L'\\')
4301 len = wcsmatch (nwpat, wstring, FNMATCH_EXTFLAG);
4304 if (len == FNM_NOMATCH)
4307 mlen = wmatchlen (wpat, wstrlen);
4309 /* itrace("wmatchlen (%ls) -> %d", wpat, mlen); */
4313 for (n = 0; n <= wstrlen; n++)
4315 n2 = simple ? (*wpat == wstring[n]) : match_pattern_wchar (wpat, wstring + n);
4318 n1 = (mlen == -1) ? wstrlen : n + mlen;
4322 for ( ; n1 >= n; n1--)
4324 wc = wstring[n1]; wstring[n1] = L'\0';
4325 if (wcsmatch (wpat, wstring + n, FNMATCH_EXTFLAG) == 0)
4333 /* If MLEN != -1, we have a fixed length pattern. */
4343 if (match_pattern_wchar (wpat, wstring) == 0)
4346 for (n = (mlen == -1) ? wstrlen : mlen; n >= 0; n--)
4348 wc = wstring[n]; wstring[n] = L'\0';
4349 if (wcsmatch (wpat, wstring, FNMATCH_EXTFLAG) == 0)
4357 /* If MLEN != -1, we have a fixed length pattern. */
4365 for (n = wstrlen - ((mlen == -1) ? wstrlen : mlen); n <= wstrlen; n++)
4367 if (wcsmatch (wpat, wstring + n, FNMATCH_EXTFLAG) == 0)
4370 *ep = indices[wstrlen];
4373 /* If MLEN != -1, we have a fixed length pattern. */
4383 #endif /* HANDLE_MULTIBYTE */
4386 match_pattern (string, pat, mtype, sp, ep)
4391 #if defined (HANDLE_MULTIBYTE)
4394 wchar_t *wstring, *wpat;
4396 size_t slen, plen, mslen, mplen;
4399 if (string == 0 || *string == 0 || pat == 0 || *pat == 0)
4402 #if defined (HANDLE_MULTIBYTE)
4405 if (mbsmbchar (string) == 0 && mbsmbchar (pat) == 0)
4406 return (match_upattern (string, pat, mtype, sp, ep));
4408 n = xdupmbstowcs (&wpat, NULL, pat);
4409 if (n == (size_t)-1)
4410 return (match_upattern (string, pat, mtype, sp, ep));
4411 n = xdupmbstowcs (&wstring, &indices, string);
4412 if (n == (size_t)-1)
4415 return (match_upattern (string, pat, mtype, sp, ep));
4417 ret = match_wpattern (wstring, indices, n, wpat, mtype, sp, ep);
4427 return (match_upattern (string, pat, mtype, sp, ep));
4431 getpatspec (c, value)
4436 return ((*value == '#') ? RP_LONG_LEFT : RP_SHORT_LEFT);
4438 return ((*value == '%') ? RP_LONG_RIGHT : RP_SHORT_RIGHT);
4441 /* Posix.2 says that the WORD should be run through tilde expansion,
4442 parameter expansion, command substitution and arithmetic expansion.
4443 This leaves the result quoted, so quote_string_for_globbing () has
4444 to be called to fix it up for strmatch (). If QUOTED is non-zero,
4445 it means that the entire expression was enclosed in double quotes.
4446 This means that quoting characters in the pattern do not make any
4447 special pattern characters quoted. For example, the `*' in the
4448 following retains its special meaning: "${foo#'*'}". */
4450 getpattern (value, quoted, expandpat)
4452 int quoted, expandpat;
4459 /* There is a problem here: how to handle single or double quotes in the
4460 pattern string when the whole expression is between double quotes?
4461 POSIX.2 says that enclosing double quotes do not cause the pattern to
4462 be quoted, but does that leave us a problem with @ and array[@] and their
4463 expansions inside a pattern? */
4465 if (expandpat && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && *tword)
4468 pat = string_extract_double_quoted (tword, &i, 1);
4474 /* expand_string_for_rhs () leaves WORD quoted and does not perform
4476 l = *value ? expand_string_for_rhs (value,
4477 (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) ? Q_PATQUOTE : quoted,
4478 (int *)NULL, (int *)NULL)
4480 pat = string_list (l);
4484 tword = quote_string_for_globbing (pat, QGLOB_CVTNULL);
4492 /* Handle removing a pattern from a string as a result of ${name%[%]value}
4493 or ${name#[#]value}. */
4495 variable_remove_pattern (value, pattern, patspec, quoted)
4496 char *value, *pattern;
4497 int patspec, quoted;
4501 tword = remove_pattern (value, pattern, patspec);
4508 list_remove_pattern (list, pattern, patspec, itype, quoted)
4511 int patspec, itype, quoted;
4517 for (new = (WORD_LIST *)NULL, l = list; l; l = l->next)
4519 tword = remove_pattern (l->word->word, pattern, patspec);
4520 w = alloc_word_desc ();
4521 w->word = tword ? tword : savestring ("");
4522 new = make_word_list (w, new);
4525 l = REVERSE_LIST (new, WORD_LIST *);
4526 tword = string_list_pos_params (itype, l, quoted);
4533 parameter_list_remove_pattern (itype, pattern, patspec, quoted)
4536 int patspec, quoted;
4541 list = list_rest_of_args ();
4543 return ((char *)NULL);
4544 ret = list_remove_pattern (list, pattern, patspec, itype, quoted);
4545 dispose_words (list);
4549 #if defined (ARRAY_VARS)
4551 array_remove_pattern (var, pattern, patspec, varname, quoted)
4555 char *varname; /* so we can figure out how it's indexed */
4565 /* compute itype from varname here */
4566 v = array_variable_part (varname, &ret, 0);
4569 if (v && invisible_p (var))
4570 return ((char *)NULL);
4574 a = (v && array_p (v)) ? array_cell (v) : 0;
4575 h = (v && assoc_p (v)) ? assoc_cell (v) : 0;
4577 list = a ? array_to_word_list (a) : (h ? assoc_to_word_list (h) : 0);
4579 return ((char *)NULL);
4580 ret = list_remove_pattern (list, pattern, patspec, itype, quoted);
4581 dispose_words (list);
4585 #endif /* ARRAY_VARS */
4588 parameter_brace_remove_pattern (varname, value, ind, patstr, rtype, quoted, flags)
4589 char *varname, *value;
4592 int rtype, quoted, flags;
4594 int vtype, patspec, starsub;
4595 char *temp1, *val, *pattern;
4599 return ((char *)NULL);
4601 this_command_name = varname;
4603 vtype = get_var_and_type (varname, value, ind, quoted, flags, &v, &val);
4605 return ((char *)NULL);
4607 starsub = vtype & VT_STARSUB;
4608 vtype &= ~VT_STARSUB;
4610 patspec = getpatspec (rtype, patstr);
4611 if (patspec == RP_LONG_LEFT || patspec == RP_LONG_RIGHT)
4614 /* Need to pass getpattern newly-allocated memory in case of expansion --
4615 the expansion code will free the passed string on an error. */
4616 temp1 = savestring (patstr);
4617 pattern = getpattern (temp1, quoted, 1);
4620 temp1 = (char *)NULL; /* shut up gcc */
4624 case VT_ARRAYMEMBER:
4625 temp1 = remove_pattern (val, pattern, patspec);
4626 if (vtype == VT_VARIABLE)
4630 val = (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
4631 ? quote_string (temp1)
4632 : quote_escapes (temp1);
4637 #if defined (ARRAY_VARS)
4639 temp1 = array_remove_pattern (v, pattern, patspec, varname, quoted);
4640 if (temp1 && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
4642 val = quote_escapes (temp1);
4649 temp1 = parameter_list_remove_pattern (varname[0], pattern, patspec, quoted);
4650 if (temp1 && ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) == 0))
4652 val = quote_escapes (temp1);
4663 /*******************************************
4665 * Functions to expand WORD_DESCs *
4667 *******************************************/
4669 /* Expand WORD, performing word splitting on the result. This does
4670 parameter expansion, command substitution, arithmetic expansion,
4671 word splitting, and quote removal. */
4674 expand_word (word, quoted)
4678 WORD_LIST *result, *tresult;
4680 tresult = call_expand_word_internal (word, quoted, 0, (int *)NULL, (int *)NULL);
4681 result = word_list_split (tresult);
4682 dispose_words (tresult);
4683 return (result ? dequote_list (result) : result);
4686 /* Expand WORD, but do not perform word splitting on the result. This
4687 does parameter expansion, command substitution, arithmetic expansion,
4688 and quote removal. */
4690 expand_word_unsplit (word, quoted)
4696 expand_no_split_dollar_star = 1;
4697 #if defined (HANDLE_MULTIBYTE)
4698 if (ifs_firstc[0] == 0)
4700 if (ifs_firstc == 0)
4702 word->flags |= W_NOSPLIT;
4703 word->flags |= W_NOSPLIT2;
4704 result = call_expand_word_internal (word, quoted, 0, (int *)NULL, (int *)NULL);
4705 expand_no_split_dollar_star = 0;
4707 return (result ? dequote_list (result) : result);
4710 /* Perform shell expansions on WORD, but do not perform word splitting or
4711 quote removal on the result. Virtually identical to expand_word_unsplit;
4712 could be combined if implementations don't diverge. */
4714 expand_word_leave_quoted (word, quoted)
4720 expand_no_split_dollar_star = 1;
4721 #if defined (HANDLE_MULTIBYTE)
4722 if (ifs_firstc[0] == 0)
4724 if (ifs_firstc == 0)
4726 word->flags |= W_NOSPLIT;
4727 word->flags |= W_NOSPLIT2;
4728 result = call_expand_word_internal (word, quoted, 0, (int *)NULL, (int *)NULL);
4729 expand_no_split_dollar_star = 0;
4734 #if defined (PROCESS_SUBSTITUTION)
4736 /*****************************************************************/
4738 /* Hacking Process Substitution */
4740 /*****************************************************************/
4742 #if !defined (HAVE_DEV_FD)
4743 /* Named pipes must be removed explicitly with `unlink'. This keeps a list
4744 of FIFOs the shell has open. unlink_fifo_list will walk the list and
4745 unlink all of them. add_fifo_list adds the name of an open FIFO to the
4746 list. NFIFO is a count of the number of FIFOs in the list. */
4747 #define FIFO_INCR 20
4754 static struct temp_fifo *fifo_list = (struct temp_fifo *)NULL;
4756 static int fifo_list_size;
4759 copy_fifo_list (sizep)
4764 return (char *)NULL;
4768 add_fifo_list (pathname)
4771 if (nfifo >= fifo_list_size - 1)
4773 fifo_list_size += FIFO_INCR;
4774 fifo_list = (struct temp_fifo *)xrealloc (fifo_list,
4775 fifo_list_size * sizeof (struct temp_fifo));
4778 fifo_list[nfifo].file = savestring (pathname);
4786 if ((fifo_list[i].proc == -1) || (kill(fifo_list[i].proc, 0) == -1))
4788 unlink (fifo_list[i].file);
4789 free (fifo_list[i].file);
4790 fifo_list[i].file = (char *)NULL;
4791 fifo_list[i].proc = -1;
4803 for (i = saved = 0; i < nfifo; i++)
4805 if ((fifo_list[i].proc == -1) || (kill(fifo_list[i].proc, 0) == -1))
4807 unlink (fifo_list[i].file);
4808 free (fifo_list[i].file);
4809 fifo_list[i].file = (char *)NULL;
4810 fifo_list[i].proc = -1;
4816 /* If we didn't remove some of the FIFOs, compact the list. */
4819 for (i = j = 0; i < nfifo; i++)
4820 if (fifo_list[i].file)
4822 fifo_list[j].file = fifo_list[i].file;
4823 fifo_list[j].proc = fifo_list[i].proc;
4832 /* Take LIST, which is a bitmap denoting active FIFOs in fifo_list
4833 from some point in the past, and close all open FIFOs in fifo_list
4834 that are not marked as active in LIST. If LIST is NULL, close
4835 everything in fifo_list. LSIZE is the number of elements in LIST, in
4836 case it's larger than fifo_list_size (size of fifo_list). */
4838 close_new_fifos (list, lsize)
4846 unlink_fifo_list ();
4850 for (i = 0; i < lsize; i++)
4851 if (list[i] == 0 && i < fifo_list_size && fifo_list[i].proc != -1)
4854 for (i = lsize; i < fifo_list_size; i++)
4875 tname = sh_mktmpname ("sh-np", MT_USERANDOM|MT_USETMPDIR);
4876 if (mkfifo (tname, 0600) < 0)
4879 return ((char *)NULL);
4882 add_fifo_list (tname);
4886 #else /* HAVE_DEV_FD */
4888 /* DEV_FD_LIST is a bitmap of file descriptors attached to pipes the shell
4889 has open to children. NFDS is a count of the number of bits currently
4890 set in DEV_FD_LIST. TOTFDS is a count of the highest possible number
4892 static char *dev_fd_list = (char *)NULL;
4894 static int totfds; /* The highest possible number of open files. */
4897 copy_fifo_list (sizep)
4902 if (nfds == 0 || totfds == 0)
4906 return (char *)NULL;
4911 ret = (char *)xmalloc (totfds);
4912 return (memcpy (ret, dev_fd_list, totfds));
4919 if (dev_fd_list == 0 || fd >= totfds)
4924 totfds = getdtablesize ();
4925 if (totfds < 0 || totfds > 256)
4930 dev_fd_list = (char *)xrealloc (dev_fd_list, totfds);
4931 memset (dev_fd_list + ofds, '\0', totfds - ofds);
4934 dev_fd_list[fd] = 1;
4941 return 0; /* used for cleanup; not needed with /dev/fd */
4954 if (dev_fd_list[fd])
4957 dev_fd_list[fd] = 0;
4970 for (i = 0; nfds && i < totfds; i++)
4976 /* Take LIST, which is a snapshot copy of dev_fd_list from some point in
4977 the past, and close all open fds in dev_fd_list that are not marked
4978 as open in LIST. If LIST is NULL, close everything in dev_fd_list.
4979 LSIZE is the number of elements in LIST, in case it's larger than
4980 totfds (size of dev_fd_list). */
4982 close_new_fifos (list, lsize)
4990 unlink_fifo_list ();
4994 for (i = 0; i < lsize; i++)
4995 if (list[i] == 0 && i < totfds && dev_fd_list[i])
4998 for (i = lsize; i < totfds; i++)
5002 #if defined (NOTDEF)
5003 print_dev_fd_list ()
5007 fprintf (stderr, "pid %ld: dev_fd_list:", (long)getpid ());
5010 for (i = 0; i < totfds; i++)
5013 fprintf (stderr, " %d", i);
5015 fprintf (stderr, "\n");
5020 make_dev_fd_filename (fd)
5023 char *ret, intbuf[INT_STRLEN_BOUND (int) + 1], *p;
5025 ret = (char *)xmalloc (sizeof (DEV_FD_PREFIX) + 8);
5027 strcpy (ret, DEV_FD_PREFIX);
5028 p = inttostr (fd, intbuf, sizeof (intbuf));
5029 strcpy (ret + sizeof (DEV_FD_PREFIX) - 1, p);
5035 #endif /* HAVE_DEV_FD */
5037 /* Return a filename that will open a connection to the process defined by
5038 executing STRING. HAVE_DEV_FD, if defined, means open a pipe and return
5039 a filename in /dev/fd corresponding to a descriptor that is one of the
5040 ends of the pipe. If not defined, we use named pipes on systems that have
5041 them. Systems without /dev/fd and named pipes are out of luck.
5043 OPEN_FOR_READ_IN_CHILD, if 1, means open the named pipe for reading or
5044 use the read end of the pipe and dup that file descriptor to fd 0 in
5045 the child. If OPEN_FOR_READ_IN_CHILD is 0, we open the named pipe for
5046 writing or use the write end of the pipe in the child, and dup that
5047 file descriptor to fd 1 in the child. The parent does the opposite. */
5050 process_substitute (string, open_for_read_in_child)
5052 int open_for_read_in_child;
5057 #if defined (HAVE_DEV_FD)
5058 int parent_pipe_fd, child_pipe_fd;
5060 #endif /* HAVE_DEV_FD */
5061 #if defined (JOB_CONTROL)
5062 pid_t old_pipeline_pgrp;
5065 if (!string || !*string || wordexp_only)
5066 return ((char *)NULL);
5068 #if !defined (HAVE_DEV_FD)
5069 pathname = make_named_pipe ();
5070 #else /* HAVE_DEV_FD */
5071 if (pipe (fildes) < 0)
5073 sys_error (_("cannot make pipe for process substitution"));
5074 return ((char *)NULL);
5076 /* If OPEN_FOR_READ_IN_CHILD == 1, we want to use the write end of
5077 the pipe in the parent, otherwise the read end. */
5078 parent_pipe_fd = fildes[open_for_read_in_child];
5079 child_pipe_fd = fildes[1 - open_for_read_in_child];
5080 /* Move the parent end of the pipe to some high file descriptor, to
5081 avoid clashes with FDs used by the script. */
5082 parent_pipe_fd = move_to_high_fd (parent_pipe_fd, 1, 64);
5084 pathname = make_dev_fd_filename (parent_pipe_fd);
5085 #endif /* HAVE_DEV_FD */
5089 sys_error (_("cannot make pipe for process substitution"));
5090 return ((char *)NULL);
5093 old_pid = last_made_pid;
5095 #if defined (JOB_CONTROL)
5096 old_pipeline_pgrp = pipeline_pgrp;
5097 pipeline_pgrp = shell_pgrp;
5099 #endif /* JOB_CONTROL */
5101 pid = make_child ((char *)NULL, 1);
5104 reset_terminating_signals (); /* XXX */
5105 free_pushed_string_input ();
5106 /* Cancel traps, in trap.c. */
5107 restore_original_signals (); /* XXX - what about special builtins? bash-4.2 */
5108 setup_async_signals ();
5109 subshell_environment |= SUBSHELL_COMSUB|SUBSHELL_PROCSUB;
5112 #if defined (JOB_CONTROL)
5113 set_sigchld_handler ();
5114 stop_making_children ();
5115 /* XXX - should we only do this in the parent? (as in command subst) */
5116 pipeline_pgrp = old_pipeline_pgrp;
5117 #endif /* JOB_CONTROL */
5121 sys_error (_("cannot make child for process substitution"));
5123 #if defined (HAVE_DEV_FD)
5124 close (parent_pipe_fd);
5125 close (child_pipe_fd);
5126 #endif /* HAVE_DEV_FD */
5127 return ((char *)NULL);
5132 #if defined (JOB_CONTROL)
5133 restore_pipeline (1);
5136 #if !defined (HAVE_DEV_FD)
5137 fifo_list[nfifo-1].proc = pid;
5140 last_made_pid = old_pid;
5142 #if defined (JOB_CONTROL) && defined (PGRP_PIPE)
5144 #endif /* JOB_CONTROL && PGRP_PIPE */
5146 #if defined (HAVE_DEV_FD)
5147 close (child_pipe_fd);
5148 #endif /* HAVE_DEV_FD */
5153 set_sigint_handler ();
5155 #if defined (JOB_CONTROL)
5156 set_job_control (0);
5157 #endif /* JOB_CONTROL */
5159 #if !defined (HAVE_DEV_FD)
5160 /* Open the named pipe in the child. */
5161 fd = open (pathname, open_for_read_in_child ? O_RDONLY : O_WRONLY);
5164 /* Two separate strings for ease of translation. */
5165 if (open_for_read_in_child)
5166 sys_error (_("cannot open named pipe %s for reading"), pathname);
5168 sys_error (_("cannot open named pipe %s for writing"), pathname);
5172 if (open_for_read_in_child)
5174 if (sh_unset_nodelay_mode (fd) < 0)
5176 sys_error (_("cannot reset nodelay mode for fd %d"), fd);
5180 #else /* HAVE_DEV_FD */
5182 #endif /* HAVE_DEV_FD */
5184 if (dup2 (fd, open_for_read_in_child ? 0 : 1) < 0)
5186 sys_error (_("cannot duplicate named pipe %s as fd %d"), pathname,
5187 open_for_read_in_child ? 0 : 1);
5191 if (fd != (open_for_read_in_child ? 0 : 1))
5194 /* Need to close any files that this process has open to pipes inherited
5196 if (current_fds_to_close)
5198 close_fd_bitmap (current_fds_to_close);
5199 current_fds_to_close = (struct fd_bitmap *)NULL;
5202 #if defined (HAVE_DEV_FD)
5203 /* Make sure we close the parent's end of the pipe and clear the slot
5204 in the fd list so it is not closed later, if reallocated by, for
5205 instance, pipe(2). */
5206 close (parent_pipe_fd);
5207 dev_fd_list[parent_pipe_fd] = 0;
5208 #endif /* HAVE_DEV_FD */
5210 /* subshells shouldn't have this flag, which controls using the temporary
5211 environment for variable lookups. */
5212 expanding_redir = 0;
5214 result = parse_and_execute (string, "process substitution", (SEVAL_NONINT|SEVAL_NOHIST));
5216 #if !defined (HAVE_DEV_FD)
5217 /* Make sure we close the named pipe in the child before we exit. */
5218 close (open_for_read_in_child ? 0 : 1);
5219 #endif /* !HAVE_DEV_FD */
5221 last_command_exit_value = result;
5222 result = run_exit_trap ();
5226 #endif /* PROCESS_SUBSTITUTION */
5228 /***********************************/
5230 /* Command Substitution */
5232 /***********************************/
5235 read_comsub (fd, quoted, rflag)
5239 char *istring, buf[128], *bufp, *s;
5240 int istring_index, istring_size, c, tflag, skip_ctlesc, skip_ctlnul;
5243 istring = (char *)NULL;
5244 istring_index = istring_size = bufn = tflag = 0;
5246 for (skip_ctlesc = skip_ctlnul = 0, s = ifs_value; s && *s; s++)
5247 skip_ctlesc |= *s == CTLESC, skip_ctlnul |= *s == CTLNUL;
5249 /* Read the output of the command through the pipe. This may need to be
5250 changed to understand multibyte characters in the future. */
5257 bufn = zread (fd, buf, sizeof (buf));
5267 internal_warning ("read_comsub: ignored null byte in input");
5272 /* Add the character to ISTRING, possibly after resizing it. */
5273 RESIZE_MALLOCED_BUFFER (istring, istring_index, 2, istring_size, DEFAULT_ARRAY_SIZE);
5275 /* This is essentially quote_string inline */
5276 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) /* || c == CTLESC || c == CTLNUL */)
5277 istring[istring_index++] = CTLESC;
5278 /* Escape CTLESC and CTLNUL in the output to protect those characters
5279 from the rest of the word expansions (word splitting and globbing.)
5280 This is essentially quote_escapes inline. */
5281 else if (skip_ctlesc == 0 && c == CTLESC)
5283 tflag |= W_HASCTLESC;
5284 istring[istring_index++] = CTLESC;
5286 else if ((skip_ctlnul == 0 && c == CTLNUL) || (c == ' ' && (ifs_value && *ifs_value == 0)))
5287 istring[istring_index++] = CTLESC;
5289 istring[istring_index++] = c;
5292 #if defined (__CYGWIN__)
5293 if (c == '\n' && istring_index > 1 && istring[istring_index - 2] == '\r')
5296 istring[istring_index - 1] = '\n';
5303 istring[istring_index] = '\0';
5305 /* If we read no output, just return now and save ourselves some
5307 if (istring_index == 0)
5312 return (char *)NULL;
5315 /* Strip trailing newlines from the output of the command. */
5316 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
5318 while (istring_index > 0)
5320 if (istring[istring_index - 1] == '\n')
5324 /* If the newline was quoted, remove the quoting char. */
5325 if (istring[istring_index - 1] == CTLESC)
5331 istring[istring_index] = '\0';
5334 strip_trailing (istring, istring_index - 1, 1);
5341 /* Perform command substitution on STRING. This returns a WORD_DESC * with the
5342 contained string possibly quoted. */
5344 command_substitute (string, quoted)
5348 pid_t pid, old_pid, old_pipeline_pgrp, old_async_pid;
5350 int result, fildes[2], function_value, pflags, rc, tflag;
5353 istring = (char *)NULL;
5355 /* Don't fork () if there is no need to. In the case of no command to
5356 run, just return NULL. */
5357 if (!string || !*string || (string[0] == '\n' && !string[1]))
5358 return ((WORD_DESC *)NULL);
5360 if (wordexp_only && read_but_dont_execute)
5362 last_command_exit_value = EX_WEXPCOMSUB;
5363 jump_to_top_level (EXITPROG);
5366 /* We're making the assumption here that the command substitution will
5367 eventually run a command from the file system. Since we'll run
5368 maybe_make_export_env in this subshell before executing that command,
5369 the parent shell and any other shells it starts will have to remake
5370 the environment. If we make it before we fork, other shells won't
5371 have to. Don't bother if we have any temporary variable assignments,
5372 though, because the export environment will be remade after this
5373 command completes anyway, but do it if all the words to be expanded
5374 are variable assignments. */
5375 if (subst_assign_varlist == 0 || garglist == 0)
5376 maybe_make_export_env (); /* XXX */
5378 /* Flags to pass to parse_and_execute() */
5379 pflags = (interactive && sourcelevel == 0) ? SEVAL_RESETLINE : 0;
5381 /* Pipe the output of executing STRING into the current shell. */
5382 if (pipe (fildes) < 0)
5384 sys_error (_("cannot make pipe for command substitution"));
5388 old_pid = last_made_pid;
5389 #if defined (JOB_CONTROL)
5390 old_pipeline_pgrp = pipeline_pgrp;
5391 /* Don't reset the pipeline pgrp if we're already a subshell in a pipeline. */
5392 if ((subshell_environment & SUBSHELL_PIPE) == 0)
5393 pipeline_pgrp = shell_pgrp;
5394 cleanup_the_pipeline ();
5395 #endif /* JOB_CONTROL */
5397 old_async_pid = last_asynchronous_pid;
5398 pid = make_child ((char *)NULL, subshell_environment&SUBSHELL_ASYNC);
5399 last_asynchronous_pid = old_async_pid;
5403 /* Reset the signal handlers in the child, but don't free the
5404 trap strings. Set a flag noting that we have to free the
5405 trap strings if we run trap to change a signal disposition. */
5406 reset_signal_handlers ();
5407 subshell_environment |= SUBSHELL_RESETTRAP;
5410 #if defined (JOB_CONTROL)
5411 /* XXX DO THIS ONLY IN PARENT ? XXX */
5412 set_sigchld_handler ();
5413 stop_making_children ();
5415 pipeline_pgrp = old_pipeline_pgrp;
5417 stop_making_children ();
5418 #endif /* JOB_CONTROL */
5422 sys_error (_("cannot make child for command substitution"));
5425 last_made_pid = old_pid;
5430 return ((WORD_DESC *)NULL);
5435 set_sigint_handler (); /* XXX */
5437 free_pushed_string_input ();
5439 if (dup2 (fildes[1], 1) < 0)
5441 sys_error (_("command_substitute: cannot duplicate pipe as fd 1"));
5442 exit (EXECUTION_FAILURE);
5445 /* If standard output is closed in the parent shell
5446 (such as after `exec >&-'), file descriptor 1 will be
5447 the lowest available file descriptor, and end up in
5448 fildes[0]. This can happen for stdin and stderr as well,
5449 but stdout is more important -- it will cause no output
5450 to be generated from this command. */
5451 if ((fildes[1] != fileno (stdin)) &&
5452 (fildes[1] != fileno (stdout)) &&
5453 (fildes[1] != fileno (stderr)))
5456 if ((fildes[0] != fileno (stdin)) &&
5457 (fildes[0] != fileno (stdout)) &&
5458 (fildes[0] != fileno (stderr)))
5462 /* Let stdio know the fd may have changed from text to binary mode, and
5463 make sure to preserve stdout line buffering. */
5464 freopen (NULL, "w", stdout);
5465 sh_setlinebuf (stdout);
5466 #endif /* __CYGWIN__ */
5468 /* The currently executing shell is not interactive. */
5471 /* This is a subshell environment. */
5472 subshell_environment |= SUBSHELL_COMSUB;
5474 /* When not in POSIX mode, command substitution does not inherit
5476 if (posixly_correct == 0)
5478 builtin_ignoring_errexit = 0;
5479 change_flag ('e', FLAG_OFF);
5483 remove_quoted_escapes (string);
5485 startup_state = 2; /* see if we can avoid a fork */
5486 /* Give command substitution a place to jump back to on failure,
5487 so we don't go back up to main (). */
5488 result = setjmp_nosigs (top_level);
5490 /* If we're running a command substitution inside a shell function,
5491 trap `return' so we don't return from the function in the subshell
5492 and go off to never-never land. */
5493 if (result == 0 && return_catch_flag)
5494 function_value = setjmp_nosigs (return_catch);
5498 if (result == ERREXIT)
5499 rc = last_command_exit_value;
5500 else if (result == EXITPROG)
5501 rc = last_command_exit_value;
5503 rc = EXECUTION_FAILURE;
5504 else if (function_value)
5505 rc = return_catch_value;
5509 rc = parse_and_execute (string, "command substitution", pflags|SEVAL_NOHIST);
5513 last_command_exit_value = rc;
5514 rc = run_exit_trap ();
5515 #if defined (PROCESS_SUBSTITUTION)
5516 unlink_fifo_list ();
5522 #if defined (JOB_CONTROL) && defined (PGRP_PIPE)
5524 #endif /* JOB_CONTROL && PGRP_PIPE */
5529 istring = read_comsub (fildes[0], quoted, &tflag);
5533 current_command_subst_pid = pid;
5534 last_command_exit_value = wait_for (pid);
5535 last_command_subst_pid = pid;
5536 last_made_pid = old_pid;
5538 #if defined (JOB_CONTROL)
5539 /* If last_command_exit_value > 128, then the substituted command
5540 was terminated by a signal. If that signal was SIGINT, then send
5541 SIGINT to ourselves. This will break out of loops, for instance. */
5542 if (last_command_exit_value == (128 + SIGINT) && last_command_exit_signal == SIGINT)
5543 kill (getpid (), SIGINT);
5545 /* wait_for gives the terminal back to shell_pgrp. If some other
5546 process group should have it, give it away to that group here.
5547 pipeline_pgrp is non-zero only while we are constructing a
5548 pipeline, so what we are concerned about is whether or not that
5549 pipeline was started in the background. A pipeline started in
5550 the background should never get the tty back here. */
5551 if (interactive && pipeline_pgrp != (pid_t)0 && (subshell_environment & SUBSHELL_ASYNC) == 0)
5552 give_terminal_to (pipeline_pgrp, 0);
5553 #endif /* JOB_CONTROL */
5555 ret = alloc_word_desc ();
5556 ret->word = istring;
5563 /********************************************************
5565 * Utility functions for parameter expansion *
5567 ********************************************************/
5569 #if defined (ARRAY_VARS)
5572 array_length_reference (s)
5583 var = array_variable_part (s, &t, &len);
5585 /* If unbound variables should generate an error, report one and return
5587 if ((var == 0 || invisible_p (var) || (assoc_p (var) == 0 && array_p (var) == 0)) && unbound_vars_is_error)
5591 last_command_exit_value = EXECUTION_FAILURE;
5596 else if (var == 0 || invisible_p (var))
5599 /* We support a couple of expansions for variables that are not arrays.
5600 We'll return the length of the value for v[0], and 1 for v[@] or
5601 v[*]. Return 0 for everything else. */
5603 array = array_p (var) ? array_cell (var) : (ARRAY *)NULL;
5604 h = assoc_p (var) ? assoc_cell (var) : (HASH_TABLE *)NULL;
5606 if (ALL_ELEMENT_SUB (t[0]) && t[1] == ']')
5609 return (h ? assoc_num_elements (h) : 0);
5610 else if (array_p (var))
5611 return (array ? array_num_elements (array) : 0);
5613 return (var_isset (var) ? 1 : 0);
5619 akey = expand_assignment_string_to_string (t, 0); /* [ */
5621 if (akey == 0 || *akey == 0)
5623 err_badarraysub (t);
5627 t = assoc_reference (assoc_cell (var), akey);
5632 ind = array_expand_index (var, t, len);
5633 /* negative subscripts to indexed arrays count back from end */
5634 if (var && array_p (var) && ind < 0)
5635 ind = array_max_index (array_cell (var)) + 1 + ind;
5638 err_badarraysub (t);
5642 t = array_reference (array, ind);
5644 t = (ind == 0) ? value_cell (var) : (char *)NULL;
5647 len = MB_STRLEN (t);
5650 #endif /* ARRAY_VARS */
5653 valid_brace_expansion_word (name, var_is_special)
5657 if (DIGIT (*name) && all_digits (name))
5659 else if (var_is_special)
5661 #if defined (ARRAY_VARS)
5662 else if (valid_array_reference (name))
5664 #endif /* ARRAY_VARS */
5665 else if (legal_identifier (name))
5672 chk_atstar (name, quoted, quoted_dollar_atp, contains_dollar_at)
5675 int *quoted_dollar_atp, *contains_dollar_at;
5681 if (quoted_dollar_atp)
5682 *quoted_dollar_atp = 0;
5683 if (contains_dollar_at)
5684 *contains_dollar_at = 0;
5688 /* check for $@ and $* */
5689 if (name[0] == '@' && name[1] == 0)
5691 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
5692 *quoted_dollar_atp = 1;
5693 if (contains_dollar_at)
5694 *contains_dollar_at = 1;
5697 else if (name[0] == '*' && name[1] == '\0' && quoted == 0)
5699 if (contains_dollar_at)
5700 *contains_dollar_at = 1;
5704 /* Now check for ${array[@]} and ${array[*]} */
5705 #if defined (ARRAY_VARS)
5706 else if (valid_array_reference (name))
5708 temp1 = mbschr (name, '[');
5709 if (temp1 && temp1[1] == '@' && temp1[2] == ']')
5711 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
5712 *quoted_dollar_atp = 1;
5713 if (contains_dollar_at)
5714 *contains_dollar_at = 1;
5717 /* ${array[*]}, when unquoted, should be treated like ${array[@]},
5718 which should result in separate words even when IFS is unset. */
5719 if (temp1 && temp1[1] == '*' && temp1[2] == ']' && quoted == 0)
5721 if (contains_dollar_at)
5722 *contains_dollar_at = 1;
5730 /* Parameter expand NAME, and return a new string which is the expansion,
5731 or NULL if there was no expansion.
5732 VAR_IS_SPECIAL is non-zero if NAME is one of the special variables in
5733 the shell, e.g., "@", "$", "*", etc. QUOTED, if non-zero, means that
5734 NAME was found inside of a double-quoted expression. */
5736 parameter_brace_expand_word (name, var_is_special, quoted, pflags, indp)
5738 int var_is_special, quoted, pflags;
5755 /* Handle multiple digit arguments, as in ${11}. */
5756 if (legal_number (name, &arg_index))
5758 tt = get_dollar_var_value (arg_index);
5760 temp = (*tt && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
5762 : quote_escapes (tt);
5764 temp = (char *)NULL;
5767 else if (var_is_special) /* ${@} */
5770 tt = (char *)xmalloc (2 + strlen (name));
5771 tt[sindex = 0] = '$';
5772 strcpy (tt + 1, name);
5774 ret = param_expand (tt, &sindex, quoted, (int *)NULL, (int *)NULL,
5775 (int *)NULL, (int *)NULL, pflags);
5778 #if defined (ARRAY_VARS)
5779 else if (valid_array_reference (name))
5782 /* XXX - does this leak if name[@] or name[*]? */
5783 if (pflags & PF_ASSIGNRHS)
5785 temp = array_variable_name (name, &tt, (int *)0);
5786 if (ALL_ELEMENT_SUB (tt[0]) && tt[1] == ']')
5787 temp = array_value (name, quoted|Q_DOUBLE_QUOTES, 0, &atype, &ind);
5789 temp = array_value (name, quoted, 0, &atype, &ind);
5792 temp = array_value (name, quoted, 0, &atype, &ind);
5793 if (atype == 0 && temp)
5795 temp = (*temp && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
5796 ? quote_string (temp)
5797 : quote_escapes (temp);
5798 rflags |= W_ARRAYIND;
5802 else if (atype == 1 && temp && QUOTED_NULL (temp) && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
5803 rflags |= W_HASQUOTEDNULL;
5806 else if (var = find_variable (name))
5808 if (var_isset (var) && invisible_p (var) == 0)
5810 #if defined (ARRAY_VARS)
5812 temp = assoc_reference (assoc_cell (var), "0");
5813 else if (array_p (var))
5814 temp = array_reference (array_cell (var), 0);
5816 temp = value_cell (var);
5818 temp = value_cell (var);
5822 temp = (*temp && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
5823 ? quote_string (temp)
5824 : quote_escapes (temp);
5827 temp = (char *)NULL;
5829 else if (var = find_variable_last_nameref (name))
5831 temp = nameref_cell (var);
5832 #if defined (ARRAY_VARS)
5833 /* Handle expanding nameref whose value is x[n] */
5834 if (temp && *temp && valid_array_reference (temp))
5837 goto expand_arrayref;
5841 /* y=2 ; typeset -n x=y; echo ${x} is not the same as echo ${2} in ksh */
5842 if (temp && *temp && legal_identifier (temp) == 0)
5844 last_command_exit_value = EXECUTION_FAILURE;
5845 report_error (_("%s: invalid variable name for name reference"), temp);
5846 temp = &expand_param_error;
5849 temp = (char *)NULL;
5852 temp = (char *)NULL;
5856 ret = alloc_word_desc ();
5858 ret->flags |= rflags;
5864 parameter_brace_find_indir (name, var_is_special, quoted, find_nameref)
5866 int var_is_special, quoted, find_nameref;
5872 if (find_nameref && var_is_special == 0 && (v = find_variable_last_nameref (name)) &&
5873 nameref_p (v) && (t = nameref_cell (v)) && *t)
5874 return (savestring (t));
5876 /* If var_is_special == 0, and name is not an array reference, this does
5877 more expansion than necessary. It should really look up the variable's
5878 value and not try to expand it. */
5879 w = parameter_brace_expand_word (name, var_is_special, quoted, PF_IGNUNBOUND, 0);
5881 /* Have to dequote here if necessary */
5884 temp = (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
5885 ? dequote_string (t)
5886 : dequote_escapes (t);
5890 dispose_word_desc (w);
5895 /* Expand an indirect reference to a variable: ${!NAME} expands to the
5896 value of the variable whose name is the value of NAME. */
5898 parameter_brace_expand_indir (name, var_is_special, quoted, quoted_dollar_atp, contains_dollar_at)
5900 int var_is_special, quoted;
5901 int *quoted_dollar_atp, *contains_dollar_at;
5907 /* See if it's a nameref first, behave in ksh93-compatible fashion.
5908 There is at least one incompatibility: given ${!foo[0]} where foo=bar,
5909 bash performs an indirect lookup on foo[0] and expands the result;
5910 ksh93 expands bar[0]. We could do that here -- there are enough usable
5911 primitives to do that -- but do not at this point. */
5912 if (var_is_special == 0 && (v = find_variable_last_nameref (name)))
5914 if (nameref_p (v) && (t = nameref_cell (v)) && *t)
5916 w = alloc_word_desc ();
5917 w->word = savestring (t);
5923 t = parameter_brace_find_indir (name, var_is_special, quoted, 0);
5925 chk_atstar (t, quoted, quoted_dollar_atp, contains_dollar_at);
5927 return (WORD_DESC *)NULL;
5929 w = parameter_brace_expand_word (t, SPECIAL_VAR(t, 0), quoted, 0, 0);
5935 /* Expand the right side of a parameter expansion of the form ${NAMEcVALUE},
5936 depending on the value of C, the separating character. C can be one of
5937 "-", "+", or "=". QUOTED is true if the entire brace expression occurs
5938 between double quotes. */
5940 parameter_brace_expand_rhs (name, value, c, quoted, qdollaratp, hasdollarat)
5942 int c, quoted, *qdollaratp, *hasdollarat;
5946 char *t, *t1, *temp;
5949 /* If the entire expression is between double quotes, we want to treat
5950 the value as a double-quoted string, with the exception that we strip
5951 embedded unescaped double quotes (for sh backwards compatibility). */
5952 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && *value)
5955 temp = string_extract_double_quoted (value, &hasdol, 1);
5960 w = alloc_word_desc ();
5962 /* XXX was 0 not quoted */
5963 l = *temp ? expand_string_for_rhs (temp, quoted, &hasdol, (int *)NULL)
5966 *hasdollarat = hasdol || (l && l->next);
5971 /* The expansion of TEMP returned something. We need to treat things
5972 slightly differently if HASDOL is non-zero. If we have "$@", the
5973 individual words have already been quoted. We need to turn them
5974 into a string with the words separated by the first character of
5975 $IFS without any additional quoting, so string_list_dollar_at won't
5976 do the right thing. We use string_list_dollar_star instead. */
5977 temp = (hasdol || l->next) ? string_list_dollar_star (l) : string_list (l);
5979 /* If l->next is not null, we know that TEMP contained "$@", since that
5980 is the only expansion that creates more than one word. */
5981 if (qdollaratp && ((hasdol && quoted) || l->next))
5983 /* If we have a quoted null result (QUOTED_NULL(temp)) and the word is
5984 a quoted null (l->next == 0 && QUOTED_NULL(l->word->word)), the
5985 flags indicate it (l->word->flags & W_HASQUOTEDNULL), and the
5986 expansion is quoted (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
5987 (which is more paranoia than anything else), we need to return the
5988 quoted null string and set the flags to indicate it. */
5989 if (l->next == 0 && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && QUOTED_NULL (temp) && QUOTED_NULL (l->word->word) && (l->word->flags & W_HASQUOTEDNULL))
5991 w->flags |= W_HASQUOTEDNULL;
5995 else if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && hasdol)
5997 /* The brace expansion occurred between double quotes and there was
5998 a $@ in TEMP. It does not matter if the $@ is quoted, as long as
5999 it does not expand to anything. In this case, we want to return
6000 a quoted empty string. */
6001 temp = make_quoted_char ('\0');
6002 w->flags |= W_HASQUOTEDNULL;
6005 temp = (char *)NULL;
6007 if (c == '-' || c == '+')
6014 t = temp ? savestring (temp) : savestring ("");
6015 t1 = dequote_string (t);
6017 #if defined (ARRAY_VARS)
6018 if (valid_array_reference (name))
6019 assign_array_element (name, t1, 0);
6021 #endif /* ARRAY_VARS */
6022 bind_variable (name, t1, 0);
6024 if (STREQ (name, "IFS") == 0)
6026 stupidly_hack_special_variables (name);
6028 /* From Posix group discussion Feb-March 2010. Issue 7 0000221 */
6035 /* Deal with the right hand side of a ${name:?value} expansion in the case
6036 that NAME is null or not set. If VALUE is non-null it is expanded and
6037 used as the error message to print, otherwise a standard message is
6040 parameter_brace_expand_error (name, value)
6046 last_command_exit_value = EXECUTION_FAILURE; /* ensure it's non-zero */
6047 if (value && *value)
6049 l = expand_string (value, 0);
6050 temp = string_list (l);
6051 report_error ("%s: %s", name, temp ? temp : ""); /* XXX was value not "" */
6056 report_error (_("%s: parameter null or not set"), name);
6058 /* Free the data we have allocated during this expansion, since we
6059 are about to longjmp out. */
6064 /* Return 1 if NAME is something for which parameter_brace_expand_length is
6067 valid_length_expression (name)
6070 return (name[1] == '\0' || /* ${#} */
6071 ((sh_syntaxtab[(unsigned char) name[1]] & CSPECVAR) && name[2] == '\0') || /* special param */
6072 (DIGIT (name[1]) && all_digits (name + 1)) || /* ${#11} */
6073 #if defined (ARRAY_VARS)
6074 valid_array_reference (name + 1) || /* ${#a[7]} */
6076 legal_identifier (name + 1)); /* ${#PS1} */
6079 /* Handle the parameter brace expansion that requires us to return the
6080 length of a parameter. */
6082 parameter_brace_expand_length (name)
6086 intmax_t number, arg_index;
6088 #if defined (ARRAY_VARS)
6092 if (name[1] == '\0') /* ${#} */
6093 number = number_of_args ();
6094 else if ((name[1] == '@' || name[1] == '*') && name[2] == '\0') /* ${#@}, ${#*} */
6095 number = number_of_args ();
6096 else if ((sh_syntaxtab[(unsigned char) name[1]] & CSPECVAR) && name[2] == '\0')
6098 /* Take the lengths of some of the shell's special parameters. */
6102 t = which_set_flags ();
6105 t = itos (last_command_exit_value);
6108 t = itos (dollar_dollar_pid);
6111 if (last_asynchronous_pid == NO_PID)
6112 t = (char *)NULL; /* XXX - error if set -u set? */
6114 t = itos (last_asynchronous_pid);
6117 t = itos (number_of_args ());
6120 number = STRLEN (t);
6123 #if defined (ARRAY_VARS)
6124 else if (valid_array_reference (name + 1))
6125 number = array_length_reference (name + 1);
6126 #endif /* ARRAY_VARS */
6131 if (legal_number (name + 1, &arg_index)) /* ${#1} */
6133 t = get_dollar_var_value (arg_index);
6134 if (t == 0 && unbound_vars_is_error)
6136 number = MB_STRLEN (t);
6139 #if defined (ARRAY_VARS)
6140 else if ((var = find_variable (name + 1)) && (invisible_p (var) == 0) && (array_p (var) || assoc_p (var)))
6143 t = assoc_reference (assoc_cell (var), "0");
6145 t = array_reference (array_cell (var), 0);
6146 if (t == 0 && unbound_vars_is_error)
6148 number = MB_STRLEN (t);
6153 newname = savestring (name);
6155 list = expand_string (newname, Q_DOUBLE_QUOTES);
6156 t = list ? string_list (list) : (char *)NULL;
6159 dispose_words (list);
6161 number = t ? MB_STRLEN (t) : 0;
6169 /* Skip characters in SUBSTR until DELIM. SUBSTR is an arithmetic expression,
6170 so we do some ad-hoc parsing of an arithmetic expression to find
6171 the first DELIM, instead of using strchr(3). Two rules:
6172 1. If the substring contains a `(', read until closing `)'.
6173 2. If the substring contains a `?', read past one `:' for each `?'.
6177 skiparith (substr, delim)
6182 int skipcol, pcount, i;
6185 sublen = strlen (substr);
6186 i = skipcol = pcount = 0;
6189 /* Balance parens */
6190 if (substr[i] == LPAREN)
6196 if (substr[i] == RPAREN && pcount)
6204 ADVANCE_CHAR (substr, sublen, i);
6208 /* Skip one `:' for each `?' */
6209 if (substr[i] == ':' && skipcol)
6215 if (substr[i] == delim)
6217 if (substr[i] == '?')
6223 ADVANCE_CHAR (substr, sublen, i);
6226 return (substr + i);
6229 /* Verify and limit the start and end of the desired substring. If
6230 VTYPE == 0, a regular shell variable is being used; if it is 1,
6231 then the positional parameters are being used; if it is 2, then
6232 VALUE is really a pointer to an array variable that should be used.
6233 Return value is 1 if both values were OK, 0 if there was a problem
6234 with an invalid expression, or -1 if the values were out of range. */
6236 verify_substring_values (v, value, substr, vtype, e1p, e2p)
6238 char *value, *substr;
6240 intmax_t *e1p, *e2p;
6242 char *t, *temp1, *temp2;
6245 #if defined (ARRAY_VARS)
6250 /* duplicate behavior of strchr(3) */
6251 t = skiparith (substr, ':');
6252 if (*t && *t == ':')
6257 temp1 = expand_arith_string (substr, Q_DOUBLE_QUOTES);
6258 *e1p = evalexp (temp1, &expok);
6263 len = -1; /* paranoia */
6267 case VT_ARRAYMEMBER:
6268 len = MB_STRLEN (value);
6271 len = number_of_args () + 1;
6273 len++; /* add one arg if counting from $0 */
6275 #if defined (ARRAY_VARS)
6277 /* For arrays, the first value deals with array indices. Negative
6278 offsets count from one past the array's maximum index. Associative
6279 arrays treat the number of elements as the maximum index. */
6283 len = assoc_num_elements (h) + (*e1p < 0);
6288 len = array_max_index (a) + (*e1p < 0); /* arrays index from 0 to n - 1 */
6294 if (len == -1) /* paranoia */
6297 if (*e1p < 0) /* negative offsets count from end */
6300 if (*e1p > len || *e1p < 0)
6303 #if defined (ARRAY_VARS)
6304 /* For arrays, the second offset deals with the number of elements. */
6305 if (vtype == VT_ARRAYVAR)
6306 len = assoc_p (v) ? assoc_num_elements (h) : array_num_elements (a);
6312 temp2 = savestring (t);
6313 temp1 = expand_arith_string (temp2, Q_DOUBLE_QUOTES);
6316 *e2p = evalexp (temp1, &expok);
6321 if ((vtype == VT_ARRAYVAR || vtype == VT_POSPARMS) && *e2p < 0)
6323 /* bash-4.3: allow positional parameter length < 0 to count backwards
6324 from end of positional parameters */
6325 if (vtype == VT_ARRAYVAR && *e2p < 0)
6328 internal_error (_("%s: substring expression < 0"), t);
6331 #if defined (ARRAY_VARS)
6332 /* In order to deal with sparse arrays, push the intelligence about how
6333 to deal with the number of elements desired down to the array-
6334 specific functions. */
6335 if (vtype != VT_ARRAYVAR)
6341 if (*e2p < 0 || *e2p < *e1p)
6343 internal_error (_("%s: substring expression < 0"), t);
6348 *e2p += *e1p; /* want E2 chars starting at E1 */
6359 /* Return the type of variable specified by VARNAME (simple variable,
6360 positional param, or array variable). Also return the value specified
6361 by VARNAME (value of a variable or a reference to an array element).
6362 QUOTED is the standard description of quoting state, using Q_* defines.
6363 FLAGS is currently a set of flags to pass to array_value. If IND is
6364 non-null and not INTMAX_MIN, and FLAGS includes AV_USEIND, IND is
6365 passed to array_value so the array index is not computed again.
6366 If this returns VT_VARIABLE, the caller assumes that CTLESC and CTLNUL
6367 characters in the value are quoted with CTLESC and takes appropriate
6368 steps. For convenience, *VALP is set to the dequoted VALUE. */
6370 get_var_and_type (varname, value, ind, quoted, flags, varp, valp)
6371 char *varname, *value;
6377 int vtype, want_indir;
6380 #if defined (ARRAY_VARS)
6385 want_indir = *varname == '!' &&
6386 (legal_variable_starter ((unsigned char)varname[1]) || DIGIT (varname[1])
6387 || VALID_INDIR_PARAM (varname[1]));
6389 vname = parameter_brace_find_indir (varname+1, SPECIAL_VAR (varname, 1), quoted, 1);
6393 /* This sets vtype to VT_VARIABLE or VT_POSPARMS */
6394 vtype = (vname[0] == '@' || vname[0] == '*') && vname[1] == '\0';
6395 if (vtype == VT_POSPARMS && vname[0] == '*')
6396 vtype |= VT_STARSUB;
6397 *varp = (SHELL_VAR *)NULL;
6399 #if defined (ARRAY_VARS)
6400 if (valid_array_reference (vname))
6402 v = array_variable_part (vname, &temp, (int *)0);
6403 /* If we want to signal array_value to use an already-computed index,
6404 set LIND to that index */
6405 lind = (ind != INTMAX_MIN && (flags & AV_USEIND)) ? ind : 0;
6406 if (v && invisible_p (v))
6408 vtype = VT_ARRAYMEMBER;
6409 *varp = (SHELL_VAR *)NULL;
6410 *valp = (char *)NULL;
6412 if (v && (array_p (v) || assoc_p (v)))
6414 if (ALL_ELEMENT_SUB (temp[0]) && temp[1] == ']')
6416 /* Callers have to differentiate between indexed and associative */
6417 vtype = VT_ARRAYVAR;
6419 vtype |= VT_STARSUB;
6420 *valp = array_p (v) ? (char *)array_cell (v) : (char *)assoc_cell (v);
6424 vtype = VT_ARRAYMEMBER;
6425 *valp = array_value (vname, Q_DOUBLE_QUOTES, flags, (int *)NULL, &lind);
6429 else if (v && (ALL_ELEMENT_SUB (temp[0]) && temp[1] == ']'))
6431 vtype = VT_VARIABLE;
6433 if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
6434 *valp = dequote_string (value);
6436 *valp = dequote_escapes (value);
6440 vtype = VT_ARRAYMEMBER;
6442 *valp = array_value (vname, Q_DOUBLE_QUOTES, flags, (int *)NULL, &lind);
6445 else if ((v = find_variable (vname)) && (invisible_p (v) == 0) && (assoc_p (v) || array_p (v)))
6447 vtype = VT_ARRAYMEMBER;
6449 *valp = assoc_p (v) ? assoc_reference (assoc_cell (v), "0") : array_reference (array_cell (v), 0);
6454 if (value && vtype == VT_VARIABLE)
6456 if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
6457 *valp = dequote_string (value);
6459 *valp = dequote_escapes (value);
6471 /******************************************************/
6473 /* Functions to extract substrings of variable values */
6475 /******************************************************/
6477 #if defined (HANDLE_MULTIBYTE)
6478 /* Character-oriented rather than strictly byte-oriented substrings. S and
6479 E, rather being strict indices into STRING, indicate character (possibly
6480 multibyte character) positions that require calculation.
6481 Used by the ${param:offset[:length]} expansion. */
6483 mb_substring (string, s, e)
6488 int start, stop, i, slen;
6492 /* Don't need string length in ADVANCE_CHAR unless multibyte chars possible. */
6493 slen = (MB_CUR_MAX > 1) ? STRLEN (string) : 0;
6496 while (string[start] && i--)
6497 ADVANCE_CHAR (string, slen, start);
6500 while (string[stop] && i--)
6501 ADVANCE_CHAR (string, slen, stop);
6502 tt = substring (string, start, stop);
6507 /* Process a variable substring expansion: ${name:e1[:e2]}. If VARNAME
6508 is `@', use the positional parameters; otherwise, use the value of
6509 VARNAME. If VARNAME is an array variable, use the array elements. */
6512 parameter_brace_substring (varname, value, ind, substr, quoted, flags)
6513 char *varname, *value;
6519 int vtype, r, starsub;
6520 char *temp, *val, *tt, *oname;
6524 return ((char *)NULL);
6526 oname = this_command_name;
6527 this_command_name = varname;
6529 vtype = get_var_and_type (varname, value, ind, quoted, flags, &v, &val);
6532 this_command_name = oname;
6533 return ((char *)NULL);
6536 starsub = vtype & VT_STARSUB;
6537 vtype &= ~VT_STARSUB;
6539 r = verify_substring_values (v, val, substr, vtype, &e1, &e2);
6540 this_command_name = oname;
6543 if (vtype == VT_VARIABLE)
6545 return ((r == 0) ? &expand_param_error : (char *)NULL);
6551 case VT_ARRAYMEMBER:
6552 #if defined (HANDLE_MULTIBYTE)
6554 tt = mb_substring (val, e1, e2);
6557 tt = substring (val, e1, e2);
6559 if (vtype == VT_VARIABLE)
6561 if (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT))
6562 temp = quote_string (tt);
6564 temp = tt ? quote_escapes (tt) : (char *)NULL;
6568 tt = pos_params (varname, e1, e2, quoted);
6569 if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) == 0)
6571 temp = tt ? quote_escapes (tt) : (char *)NULL;
6577 #if defined (ARRAY_VARS)
6580 /* we convert to list and take first e2 elements starting at e1th
6581 element -- officially undefined for now */
6582 temp = assoc_subrange (assoc_cell (v), e1, e2, starsub, quoted);
6584 /* We want E2 to be the number of elements desired (arrays can be sparse,
6585 so verify_substring_values just returns the numbers specified and we
6586 rely on array_subrange to understand how to deal with them). */
6587 temp = array_subrange (array_cell (v), e1, e2, starsub, quoted);
6588 /* array_subrange now calls array_quote_escapes as appropriate, so the
6589 caller no longer needs to. */
6593 temp = (char *)NULL;
6599 /****************************************************************/
6601 /* Functions to perform pattern substitution on variable values */
6603 /****************************************************************/
6606 shouldexp_replacement (s)
6611 for (p = s; p && *p; p++)
6622 pat_subst (string, pat, rep, mflags)
6623 char *string, *pat, *rep;
6626 char *ret, *s, *e, *str, *rstr, *mstr;
6627 int rsize, rptr, l, replen, mtype, rxpand, rslen, mlen;
6630 return (savestring (""));
6632 mtype = mflags & MATCH_TYPEMASK;
6634 #if 0 /* bash-4.2 ? */
6635 rxpand = (rep && *rep) ? shouldexp_replacement (rep) : 0;
6641 * 1. A null pattern with mtype == MATCH_BEG means to prefix STRING
6642 * with REP and return the result.
6643 * 2. A null pattern with mtype == MATCH_END means to append REP to
6644 * STRING and return the result.
6645 * These don't understand or process `&' in the replacement string.
6647 if ((pat == 0 || *pat == 0) && (mtype == MATCH_BEG || mtype == MATCH_END))
6649 replen = STRLEN (rep);
6650 l = STRLEN (string);
6651 ret = (char *)xmalloc (replen + l + 2);
6653 strcpy (ret, string);
6654 else if (mtype == MATCH_BEG)
6657 strcpy (ret + replen, string);
6661 strcpy (ret, string);
6662 strcpy (ret + l, rep);
6667 ret = (char *)xmalloc (rsize = 64);
6670 for (replen = STRLEN (rep), rptr = 0, str = string;;)
6672 if (match_pattern (str, pat, mtype, &s, &e) == 0)
6680 mstr = xmalloc (mlen + 1);
6681 for (x = 0; x < mlen; x++)
6684 rstr = strcreplace (rep, '&', mstr, 0);
6685 rslen = strlen (rstr);
6693 RESIZE_MALLOCED_BUFFER (ret, rptr, (l + rslen), rsize, 64);
6695 /* OK, now copy the leading unmatched portion of the string (from
6696 str to s) to ret starting at rptr (the current offset). Then copy
6697 the replacement string at ret + rptr + (s - str). Increment
6698 rptr (if necessary) and str and go on. */
6701 strncpy (ret + rptr, str, l);
6706 strncpy (ret + rptr, rstr, rslen);
6709 str = e; /* e == end of match */
6714 if (((mflags & MATCH_GLOBREP) == 0) || mtype != MATCH_ANY)
6719 /* On a zero-length match, make sure we copy one character, since
6720 we increment one character to avoid infinite recursion. */
6721 RESIZE_MALLOCED_BUFFER (ret, rptr, 1, rsize, 64);
6722 ret[rptr++] = *str++;
6723 e++; /* avoid infinite recursion on zero-length match */
6727 /* Now copy the unmatched portion of the input string */
6730 RESIZE_MALLOCED_BUFFER (ret, rptr, STRLEN(str) + 1, rsize, 64);
6731 strcpy (ret + rptr, str);
6739 /* Do pattern match and replacement on the positional parameters. */
6741 pos_params_pat_subst (string, pat, rep, mflags)
6742 char *string, *pat, *rep;
6745 WORD_LIST *save, *params;
6750 save = params = list_rest_of_args ();
6752 return ((char *)NULL);
6754 for ( ; params; params = params->next)
6756 ret = pat_subst (params->word->word, pat, rep, mflags);
6757 w = alloc_word_desc ();
6758 w->word = ret ? ret : savestring ("");
6759 dispose_word (params->word);
6763 pchar = (mflags & MATCH_STARSUB) == MATCH_STARSUB ? '*' : '@';
6764 qflags = (mflags & MATCH_QUOTED) == MATCH_QUOTED ? Q_DOUBLE_QUOTES : 0;
6766 ret = string_list_pos_params (pchar, save, qflags);
6768 dispose_words (save);
6773 /* Perform pattern substitution on VALUE, which is the expansion of
6774 VARNAME. PATSUB is an expression supplying the pattern to match
6775 and the string to substitute. QUOTED is a flags word containing
6776 the type of quoting currently in effect. */
6778 parameter_brace_patsub (varname, value, ind, patsub, quoted, flags)
6779 char *varname, *value;
6784 int vtype, mflags, starsub, delim;
6785 char *val, *temp, *pat, *rep, *p, *lpatsub, *tt;
6789 return ((char *)NULL);
6791 this_command_name = varname;
6793 vtype = get_var_and_type (varname, value, ind, quoted, flags, &v, &val);
6795 return ((char *)NULL);
6797 starsub = vtype & VT_STARSUB;
6798 vtype &= ~VT_STARSUB;
6801 /* PATSUB is never NULL when this is called. */
6804 mflags |= MATCH_GLOBREP;
6808 /* Malloc this because expand_string_if_necessary or one of the expansion
6809 functions in its call chain may free it on a substitution error. */
6810 lpatsub = savestring (patsub);
6812 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
6813 mflags |= MATCH_QUOTED;
6816 mflags |= MATCH_STARSUB;
6818 /* If the pattern starts with a `/', make sure we skip over it when looking
6819 for the replacement delimiter. */
6820 delim = skip_to_delim (lpatsub, ((*patsub == '/') ? 1 : 0), "/", 0);
6821 if (lpatsub[delim] == '/')
6824 rep = lpatsub + delim + 1;
6829 if (rep && *rep == '\0')
6832 /* Perform the same expansions on the pattern as performed by the
6833 pattern removal expansions. */
6834 pat = getpattern (lpatsub, quoted, 1);
6838 /* We want to perform quote removal on the expanded replacement even if
6839 the entire expansion is double-quoted because the parser and string
6840 extraction functions treated quotes in the replacement string as
6841 special. THIS IS NOT BACKWARDS COMPATIBLE WITH BASH-4.2. */
6842 if (shell_compatibility_level > 42)
6843 rep = expand_string_if_necessary (rep, quoted & ~(Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT), expand_string_unsplit);
6844 /* This is the bash-4.2 code. */
6845 else if ((mflags & MATCH_QUOTED) == 0)
6846 rep = expand_string_if_necessary (rep, quoted, expand_string_unsplit);
6848 rep = expand_string_to_string_internal (rep, quoted, expand_string_unsplit);
6851 /* ksh93 doesn't allow the match specifier to be a part of the expanded
6852 pattern. This is an extension. Make sure we don't anchor the pattern
6853 at the beginning or end of the string if we're doing global replacement,
6856 if (mflags & MATCH_GLOBREP)
6857 mflags |= MATCH_ANY;
6858 else if (pat && pat[0] == '#')
6860 mflags |= MATCH_BEG;
6863 else if (pat && pat[0] == '%')
6865 mflags |= MATCH_END;
6869 mflags |= MATCH_ANY;
6871 /* OK, we now want to substitute REP for PAT in VAL. If
6872 flags & MATCH_GLOBREP is non-zero, the substitution is done
6873 everywhere, otherwise only the first occurrence of PAT is
6874 replaced. The pattern matching code doesn't understand
6875 CTLESC quoting CTLESC and CTLNUL so we use the dequoted variable
6876 values passed in (VT_VARIABLE) so the pattern substitution
6877 code works right. We need to requote special chars after
6878 we're done for VT_VARIABLE and VT_ARRAYMEMBER, and for the
6879 other cases if QUOTED == 0, since the posparams and arrays
6880 indexed by * or @ do special things when QUOTED != 0. */
6885 case VT_ARRAYMEMBER:
6886 temp = pat_subst (val, p, rep, mflags);
6887 if (vtype == VT_VARIABLE)
6891 tt = (mflags & MATCH_QUOTED) ? quote_string (temp) : quote_escapes (temp);
6897 temp = pos_params_pat_subst (val, p, rep, mflags);
6898 if (temp && (mflags & MATCH_QUOTED) == 0)
6900 tt = quote_escapes (temp);
6905 #if defined (ARRAY_VARS)
6907 temp = assoc_p (v) ? assoc_patsub (assoc_cell (v), p, rep, mflags)
6908 : array_patsub (array_cell (v), p, rep, mflags);
6909 /* Don't call quote_escapes anymore; array_patsub calls
6910 array_quote_escapes as appropriate before adding the
6911 space separators; ditto for assoc_patsub. */
6923 /****************************************************************/
6925 /* Functions to perform case modification on variable values */
6927 /****************************************************************/
6929 /* Do case modification on the positional parameters. */
6932 pos_params_modcase (string, pat, modop, mflags)
6937 WORD_LIST *save, *params;
6942 save = params = list_rest_of_args ();
6944 return ((char *)NULL);
6946 for ( ; params; params = params->next)
6948 ret = sh_modcase (params->word->word, pat, modop);
6949 w = alloc_word_desc ();
6950 w->word = ret ? ret : savestring ("");
6951 dispose_word (params->word);
6955 pchar = (mflags & MATCH_STARSUB) == MATCH_STARSUB ? '*' : '@';
6956 qflags = (mflags & MATCH_QUOTED) == MATCH_QUOTED ? Q_DOUBLE_QUOTES : 0;
6958 ret = string_list_pos_params (pchar, save, qflags);
6959 dispose_words (save);
6964 /* Perform case modification on VALUE, which is the expansion of
6965 VARNAME. MODSPEC is an expression supplying the type of modification
6966 to perform. QUOTED is a flags word containing the type of quoting
6967 currently in effect. */
6969 parameter_brace_casemod (varname, value, ind, modspec, patspec, quoted, flags)
6970 char *varname, *value;
6975 int vtype, starsub, modop, mflags, x;
6976 char *val, *temp, *pat, *p, *lpat, *tt;
6980 return ((char *)NULL);
6982 this_command_name = varname;
6984 vtype = get_var_and_type (varname, value, ind, quoted, flags, &v, &val);
6986 return ((char *)NULL);
6988 starsub = vtype & VT_STARSUB;
6989 vtype &= ~VT_STARSUB;
6993 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
6994 mflags |= MATCH_QUOTED;
6996 mflags |= MATCH_STARSUB;
7001 x = p && p[0] == modspec;
7002 modop = x ? CASE_UPPER : CASE_UPFIRST;
7005 else if (modspec == ',')
7007 x = p && p[0] == modspec;
7008 modop = x ? CASE_LOWER : CASE_LOWFIRST;
7011 else if (modspec == '~')
7013 x = p && p[0] == modspec;
7014 modop = x ? CASE_TOGGLEALL : CASE_TOGGLE;
7018 lpat = p ? savestring (p) : 0;
7019 /* Perform the same expansions on the pattern as performed by the
7020 pattern removal expansions. FOR LATER */
7021 pat = lpat ? getpattern (lpat, quoted, 1) : 0;
7023 /* OK, now we do the case modification. */
7027 case VT_ARRAYMEMBER:
7028 temp = sh_modcase (val, pat, modop);
7029 if (vtype == VT_VARIABLE)
7033 tt = (mflags & MATCH_QUOTED) ? quote_string (temp) : quote_escapes (temp);
7040 temp = pos_params_modcase (val, pat, modop, mflags);
7041 if (temp && (mflags & MATCH_QUOTED) == 0)
7043 tt = quote_escapes (temp);
7049 #if defined (ARRAY_VARS)
7051 temp = assoc_p (v) ? assoc_modcase (assoc_cell (v), pat, modop, mflags)
7052 : array_modcase (array_cell (v), pat, modop, mflags);
7053 /* Don't call quote_escapes; array_modcase calls array_quote_escapes
7054 as appropriate before adding the space separators; ditto for
7066 /* Check for unbalanced parens in S, which is the contents of $(( ... )). If
7067 any occur, this must be a nested command substitution, so return 0.
7068 Otherwise, return 1. A valid arithmetic expression must always have a
7069 ( before a matching ), so any cases where there are more right parens
7070 means that this must not be an arithmetic expression, though the parser
7071 will not accept it without a balanced total number of parens. */
7073 chk_arithsub (s, len)
7085 else if (s[i] == RPAREN)
7095 ADVANCE_CHAR (s, len, i);
7101 ADVANCE_CHAR (s, len, i);
7105 i = skip_single_quoted (s, len, ++i);
7109 i = skip_double_quoted ((char *)s, len, ++i);
7114 return (count == 0);
7117 /****************************************************************/
7119 /* Functions to perform parameter expansion on a string */
7121 /****************************************************************/
7123 /* ${[#][!]name[[:][^[^]][,[,]]#[#]%[%]-=?+[word][:e1[:e2]]]} */
7125 parameter_brace_expand (string, indexp, quoted, pflags, quoted_dollar_atp, contains_dollar_at)
7127 int *indexp, quoted, *quoted_dollar_atp, *contains_dollar_at, pflags;
7129 int check_nullness, var_is_set, var_is_null, var_is_special;
7130 int want_substring, want_indir, want_patsub, want_casemod;
7131 char *name, *value, *temp, *temp1;
7132 WORD_DESC *tdesc, *ret;
7133 int t_index, sindex, c, tflag, modspec;
7137 temp = temp1 = value = (char *)NULL;
7138 var_is_set = var_is_null = var_is_special = check_nullness = 0;
7139 want_substring = want_indir = want_patsub = want_casemod = 0;
7143 /* ${#var} doesn't have any of the other parameter expansions on it. */
7144 if (string[t_index] == '#' && legal_variable_starter (string[t_index+1])) /* {{ */
7145 name = string_extract (string, &t_index, "}", SX_VARNAME);
7147 #if defined (CASEMOD_EXPANSIONS)
7148 /* To enable case-toggling expansions using the `~' operator character
7149 change the 1 to 0. */
7150 # if defined (CASEMOD_CAPCASE)
7151 name = string_extract (string, &t_index, "#%^,~:-=?+/}", SX_VARNAME);
7153 name = string_extract (string, &t_index, "#%^,:-=?+/}", SX_VARNAME);
7154 # endif /* CASEMOD_CAPCASE */
7156 name = string_extract (string, &t_index, "#%:-=?+/}", SX_VARNAME);
7157 #endif /* CASEMOD_EXPANSIONS */
7164 /* If the name really consists of a special variable, then make sure
7165 that we have the entire name. We don't allow indirect references
7166 to special variables except `#', `?', `@' and `*'. */
7167 if ((sindex == t_index && VALID_SPECIAL_LENGTH_PARAM (string[t_index])) ||
7168 (sindex == t_index - 1 && string[sindex] == '!' && VALID_INDIR_PARAM (string[t_index])))
7171 temp1 = string_extract (string, &t_index, "#%:-=?+/}", 0);
7172 name = (char *)xrealloc (name, 3 + (strlen (temp1)));
7173 *name = string[sindex];
7174 if (string[sindex] == '!')
7176 /* indirect reference of $#, $?, $@, or $* */
7177 name[1] = string[sindex + 1];
7178 strcpy (name + 2, temp1);
7181 strcpy (name + 1, temp1);
7186 /* Find out what character ended the variable name. Then
7187 do the appropriate thing. */
7188 if (c = string[sindex])
7191 /* If c is followed by one of the valid parameter expansion
7192 characters, move past it as normal. If not, assume that
7193 a substring specification is being given, and do not move
7195 if (c == ':' && VALID_PARAM_EXPAND_CHAR (string[sindex]))
7198 if (c = string[sindex])
7201 else if (c == ':' && string[sindex] != RBRACE)
7203 else if (c == '/' /* && string[sindex] != RBRACE */) /* XXX */
7205 #if defined (CASEMOD_EXPANSIONS)
7206 else if (c == '^' || c == ',' || c == '~')
7213 /* Catch the valid and invalid brace expressions that made it through the
7215 /* ${#-} is a valid expansion and means to take the length of $-.
7216 Similarly for ${#?} and ${##}... */
7217 if (name[0] == '#' && name[1] == '\0' && check_nullness == 0 &&
7218 VALID_SPECIAL_LENGTH_PARAM (c) && string[sindex] == RBRACE)
7220 name = (char *)xrealloc (name, 3);
7223 c = string[sindex++];
7226 /* ...but ${#%}, ${#:}, ${#=}, ${#+}, and ${#/} are errors. */
7227 if (name[0] == '#' && name[1] == '\0' && check_nullness == 0 &&
7228 member (c, "%:=+/") && string[sindex] == RBRACE)
7230 temp = (char *)NULL;
7231 goto bad_substitution;
7234 /* Indirect expansion begins with a `!'. A valid indirect expansion is
7235 either a variable name, one of the positional parameters or a special
7236 variable that expands to one of the positional parameters. */
7237 want_indir = *name == '!' &&
7238 (legal_variable_starter ((unsigned char)name[1]) || DIGIT (name[1])
7239 || VALID_INDIR_PARAM (name[1]));
7241 /* Determine the value of this variable. */
7243 /* Check for special variables, directly referenced. */
7244 if (SPECIAL_VAR (name, want_indir))
7247 /* Check for special expansion things, like the length of a parameter */
7248 if (*name == '#' && name[1])
7250 /* If we are not pointing at the character just after the
7251 closing brace, then we haven't gotten all of the name.
7252 Since it begins with a special character, this is a bad
7253 substitution. Also check NAME for validity before trying
7255 if (string[sindex - 1] != RBRACE || (valid_length_expression (name) == 0))
7257 temp = (char *)NULL;
7258 goto bad_substitution;
7261 number = parameter_brace_expand_length (name);
7262 if (number == INTMAX_MIN && unbound_vars_is_error)
7264 last_command_exit_value = EXECUTION_FAILURE;
7265 err_unboundvar (name+1);
7267 return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
7273 return (&expand_wdesc_error);
7276 ret = alloc_word_desc ();
7277 ret->word = itos (number);
7282 /* ${@} is identical to $@. */
7283 if (name[0] == '@' && name[1] == '\0')
7285 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
7286 *quoted_dollar_atp = 1;
7288 if (contains_dollar_at)
7289 *contains_dollar_at = 1;
7291 tflag |= W_DOLLARAT;
7294 /* Process ${!PREFIX*} expansion. */
7295 if (want_indir && string[sindex - 1] == RBRACE &&
7296 (string[sindex - 2] == '*' || string[sindex - 2] == '@') &&
7297 legal_variable_starter ((unsigned char) name[1]))
7302 temp1 = savestring (name + 1);
7303 number = strlen (temp1);
7304 temp1[number - 1] = '\0';
7305 x = all_variables_matching_prefix (temp1);
7306 xlist = strvec_to_word_list (x, 0, 0);
7307 if (string[sindex - 2] == '*')
7308 temp = string_list_dollar_star (xlist);
7311 temp = string_list_dollar_at (xlist, quoted);
7312 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
7313 *quoted_dollar_atp = 1;
7314 if (contains_dollar_at)
7315 *contains_dollar_at = 1;
7317 tflag |= W_DOLLARAT;
7320 dispose_words (xlist);
7326 ret = alloc_word_desc ();
7328 ret->flags = tflag; /* XXX */
7332 #if defined (ARRAY_VARS)
7333 /* Process ${!ARRAY[@]} and ${!ARRAY[*]} expansion. */ /* [ */
7334 if (want_indir && string[sindex - 1] == RBRACE &&
7335 string[sindex - 2] == ']' && valid_array_reference (name+1))
7339 temp1 = savestring (name + 1);
7340 x = array_variable_name (temp1, &x1, (int *)0); /* [ */
7342 if (ALL_ELEMENT_SUB (x1[0]) && x1[1] == ']')
7344 temp = array_keys (temp1, quoted); /* handles assoc vars too */
7347 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
7348 *quoted_dollar_atp = 1;
7349 if (contains_dollar_at)
7350 *contains_dollar_at = 1;
7352 tflag |= W_DOLLARAT;
7358 ret = alloc_word_desc ();
7360 ret->flags = tflag; /* XXX */
7366 #endif /* ARRAY_VARS */
7368 /* Make sure that NAME is valid before trying to go on. */
7369 if (valid_brace_expansion_word (want_indir ? name + 1 : name,
7370 var_is_special) == 0)
7372 temp = (char *)NULL;
7373 goto bad_substitution;
7378 tdesc = parameter_brace_expand_indir (name + 1, var_is_special, quoted, quoted_dollar_atp, contains_dollar_at);
7379 /* Turn off the W_ARRAYIND flag because there is no way for this function
7380 to return the index we're supposed to be using. */
7381 if (tdesc && tdesc->flags)
7382 tdesc->flags &= ~W_ARRAYIND;
7385 tdesc = parameter_brace_expand_word (name, var_is_special, quoted, PF_IGNUNBOUND|(pflags&(PF_NOSPLIT2|PF_ASSIGNRHS)), &ind);
7390 tflag = tdesc->flags;
7391 dispose_word_desc (tdesc);
7396 if (temp == &expand_param_error || temp == &expand_param_fatal)
7400 return (temp == &expand_param_error ? &expand_wdesc_error : &expand_wdesc_fatal);
7403 #if defined (ARRAY_VARS)
7404 if (valid_array_reference (name))
7405 chk_atstar (name, quoted, quoted_dollar_atp, contains_dollar_at);
7408 var_is_set = temp != (char *)0;
7409 var_is_null = check_nullness && (var_is_set == 0 || *temp == 0);
7410 /* XXX - this may not need to be restricted to special variables */
7412 var_is_null |= var_is_set && var_is_special && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && QUOTED_NULL (temp);
7414 /* Get the rest of the stuff inside the braces. */
7415 if (c && c != RBRACE)
7417 /* Extract the contents of the ${ ... } expansion
7418 according to the Posix.2 rules. */
7419 value = extract_dollar_brace_string (string, &sindex, quoted, (c == '%' || c == '#' || c =='/' || c == '^' || c == ',' || c ==':') ? SX_POSIXEXP|SX_WORD : SX_WORD);
7420 if (string[sindex] == RBRACE)
7423 goto bad_substitution;
7426 value = (char *)NULL;
7430 /* All the cases where an expansion can possibly generate an unbound
7432 if (want_substring || want_patsub || want_casemod || c == '#' || c == '%' || c == RBRACE)
7434 if (var_is_set == 0 && unbound_vars_is_error && ((name[0] != '@' && name[0] != '*') || name[1]))
7436 last_command_exit_value = EXECUTION_FAILURE;
7437 err_unboundvar (name);
7441 return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
7445 /* If this is a substring spec, process it and add the result. */
7448 temp1 = parameter_brace_substring (name, temp, ind, value, quoted, (tflag & W_ARRAYIND) ? AV_USEIND : 0);
7453 if (temp1 == &expand_param_error)
7454 return (&expand_wdesc_error);
7455 else if (temp1 == &expand_param_fatal)
7456 return (&expand_wdesc_fatal);
7458 ret = alloc_word_desc ();
7460 /* We test quoted_dollar_atp because we want variants with double-quoted
7461 "$@" to take a different code path. In fact, we make sure at the end
7462 of expand_word_internal that we're only looking at these flags if
7463 quoted_dollar_at == 0. */
7465 (quoted_dollar_atp == 0 || *quoted_dollar_atp == 0) &&
7466 QUOTED_NULL (temp1) && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
7467 ret->flags |= W_QUOTED|W_HASQUOTEDNULL;
7470 else if (want_patsub)
7472 temp1 = parameter_brace_patsub (name, temp, ind, value, quoted, (tflag & W_ARRAYIND) ? AV_USEIND : 0);
7477 if (temp1 == &expand_param_error)
7478 return (&expand_wdesc_error);
7479 else if (temp1 == &expand_param_fatal)
7480 return (&expand_wdesc_fatal);
7482 ret = alloc_word_desc ();
7485 (quoted_dollar_atp == 0 || *quoted_dollar_atp == 0) &&
7486 QUOTED_NULL (temp1) && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
7487 ret->flags |= W_QUOTED|W_HASQUOTEDNULL;
7490 #if defined (CASEMOD_EXPANSIONS)
7491 else if (want_casemod)
7493 temp1 = parameter_brace_casemod (name, temp, ind, modspec, value, quoted, (tflag & W_ARRAYIND) ? AV_USEIND : 0);
7498 if (temp1 == &expand_param_error)
7499 return (&expand_wdesc_error);
7500 else if (temp1 == &expand_param_fatal)
7501 return (&expand_wdesc_fatal);
7503 ret = alloc_word_desc ();
7506 (quoted_dollar_atp == 0 || *quoted_dollar_atp == 0) &&
7507 QUOTED_NULL (temp1) && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
7508 ret->flags |= W_QUOTED|W_HASQUOTEDNULL;
7513 /* Do the right thing based on which character ended the variable name. */
7519 last_command_exit_value = EXECUTION_FAILURE;
7520 report_error (_("%s: bad substitution"), string ? string : "??");
7524 return &expand_wdesc_error;
7529 case '#': /* ${param#[#]pattern} */
7530 case '%': /* ${param%[%]pattern} */
7531 if (value == 0 || *value == '\0' || temp == 0 || *temp == '\0')
7536 temp1 = parameter_brace_remove_pattern (name, temp, ind, value, c, quoted, (tflag & W_ARRAYIND) ? AV_USEIND : 0);
7541 ret = alloc_word_desc ();
7543 if (temp1 && QUOTED_NULL (temp1) && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
7544 ret->flags |= W_QUOTED|W_HASQUOTEDNULL;
7551 if (var_is_set && var_is_null == 0)
7553 /* If the operator is `+', we don't want the value of the named
7554 variable for anything, just the value of the right hand side. */
7557 /* XXX -- if we're double-quoted and the named variable is "$@",
7558 we want to turn off any special handling of "$@" --
7559 we're not using it, so whatever is on the rhs applies. */
7560 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
7561 *quoted_dollar_atp = 0;
7562 if (contains_dollar_at)
7563 *contains_dollar_at = 0;
7568 /* From Posix discussion on austin-group list. Issue 221
7569 requires that backslashes escaping `}' inside
7570 double-quoted ${...} be removed. */
7571 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
7572 quoted |= Q_DOLBRACE;
7573 ret = parameter_brace_expand_rhs (name, value, c,
7576 contains_dollar_at);
7577 /* XXX - fix up later, esp. noting presence of
7578 W_HASQUOTEDNULL in ret->flags */
7582 temp = (char *)NULL;
7588 /* Otherwise do nothing; just use the value in TEMP. */
7590 else /* VAR not set or VAR is NULL. */
7593 temp = (char *)NULL;
7594 if (c == '=' && var_is_special)
7596 last_command_exit_value = EXECUTION_FAILURE;
7597 report_error (_("$%s: cannot assign in this way"), name);
7600 return &expand_wdesc_error;
7604 parameter_brace_expand_error (name, value);
7605 return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
7609 /* XXX -- if we're double-quoted and the named variable is "$@",
7610 we want to turn off any special handling of "$@" --
7611 we're not using it, so whatever is on the rhs applies. */
7612 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && quoted_dollar_atp)
7613 *quoted_dollar_atp = 0;
7614 if (contains_dollar_at)
7615 *contains_dollar_at = 0;
7617 /* From Posix discussion on austin-group list. Issue 221 requires
7618 that backslashes escaping `}' inside double-quoted ${...} be
7620 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
7621 quoted |= Q_DOLBRACE;
7622 ret = parameter_brace_expand_rhs (name, value, c, quoted,
7624 contains_dollar_at);
7625 /* XXX - fix up later, esp. noting presence of
7626 W_HASQUOTEDNULL in tdesc->flags */
7637 ret = alloc_word_desc ();
7644 /* Expand a single ${xxx} expansion. The braces are optional. When
7645 the braces are used, parameter_brace_expand() does the work,
7646 possibly calling param_expand recursively. */
7648 param_expand (string, sindex, quoted, expanded_something,
7649 contains_dollar_at, quoted_dollar_at_p, had_quoted_null_p,
7652 int *sindex, quoted, *expanded_something, *contains_dollar_at;
7653 int *quoted_dollar_at_p, *had_quoted_null_p, pflags;
7655 char *temp, *temp1, uerror[3];
7656 int zindex, t_index, expok;
7661 WORD_DESC *tdesc, *ret;
7665 c = string[++zindex];
7667 temp = (char *)NULL;
7668 ret = tdesc = (WORD_DESC *)NULL;
7671 /* Do simple cases first. Switch on what follows '$'. */
7685 temp1 = dollar_vars[TODIGIT (c)];
7686 if (unbound_vars_is_error && temp1 == (char *)NULL)
7691 last_command_exit_value = EXECUTION_FAILURE;
7692 err_unboundvar (uerror);
7693 return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
7696 temp = (*temp1 && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
7697 ? quote_string (temp1)
7698 : quote_escapes (temp1);
7700 temp = (char *)NULL;
7704 /* $$ -- pid of the invoking shell. */
7706 temp = itos (dollar_dollar_pid);
7709 /* $# -- number of positional parameters. */
7711 temp = itos (number_of_args ());
7714 /* $? -- return value of the last synchronous command. */
7716 temp = itos (last_command_exit_value);
7719 /* $- -- flags supplied to the shell on invocation or by `set'. */
7721 temp = which_set_flags ();
7724 /* $! -- Pid of the last asynchronous command. */
7726 /* If no asynchronous pids have been created, expand to nothing.
7727 If `set -u' has been executed, and no async processes have
7728 been created, this is an expansion error. */
7729 if (last_asynchronous_pid == NO_PID)
7731 if (expanded_something)
7732 *expanded_something = 0;
7733 temp = (char *)NULL;
7734 if (unbound_vars_is_error)
7739 last_command_exit_value = EXECUTION_FAILURE;
7740 err_unboundvar (uerror);
7741 return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
7745 temp = itos (last_asynchronous_pid);
7748 /* The only difference between this and $@ is when the arg is quoted. */
7749 case '*': /* `$*' */
7750 list = list_rest_of_args ();
7753 /* According to austin-group posix proposal by Geoff Clare in
7754 <20090505091501.GA10097@squonk.masqnet> of 5 May 2009:
7756 "The shell shall write a message to standard error and
7757 immediately exit when it tries to expand an unset parameter
7758 other than the '@' and '*' special parameters."
7761 if (list == 0 && unbound_vars_is_error && (pflags & PF_IGNUNBOUND) == 0)
7766 last_command_exit_value = EXECUTION_FAILURE;
7767 err_unboundvar (uerror);
7768 return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
7772 /* If there are no command-line arguments, this should just
7773 disappear if there are other characters in the expansion,
7774 even if it's quoted. */
7775 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && list == 0)
7776 temp = (char *)NULL;
7777 else if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES|Q_PATQUOTE))
7779 /* If we have "$*" we want to make a string of the positional
7780 parameters, separated by the first character of $IFS, and
7781 quote the whole string, including the separators. If IFS
7782 is unset, the parameters are separated by ' '; if $IFS is
7783 null, the parameters are concatenated. */
7784 temp = (quoted & (Q_DOUBLE_QUOTES|Q_PATQUOTE)) ? string_list_dollar_star (list) : string_list (list);
7787 temp1 = quote_string (temp);
7789 tflag |= W_HASQUOTEDNULL;
7796 /* We check whether or not we're eventually going to split $* here,
7797 for example when IFS is empty and we are processing the rhs of
7798 an assignment statement. In that case, we don't separate the
7799 arguments at all. Otherwise, if the $* is not quoted it is
7801 # if defined (HANDLE_MULTIBYTE)
7802 if (expand_no_split_dollar_star && ifs_firstc[0] == 0)
7804 if (expand_no_split_dollar_star && ifs_firstc == 0)
7806 temp = string_list_dollar_star (list);
7809 temp = string_list_dollar_at (list, quoted);
7810 if (quoted == 0 && (ifs_is_set == 0 || ifs_is_null))
7811 tflag |= W_SPLITSPACE;
7814 if (expand_no_split_dollar_star == 0 && contains_dollar_at)
7815 *contains_dollar_at = 1;
7818 dispose_words (list);
7821 /* When we have "$@" what we want is "$1" "$2" "$3" ... This
7822 means that we have to turn quoting off after we split into
7823 the individually quoted arguments so that the final split
7824 on the first character of $IFS is still done. */
7825 case '@': /* `$@' */
7826 list = list_rest_of_args ();
7829 /* According to austin-group posix proposal by Geoff Clare in
7830 <20090505091501.GA10097@squonk.masqnet> of 5 May 2009:
7832 "The shell shall write a message to standard error and
7833 immediately exit when it tries to expand an unset parameter
7834 other than the '@' and '*' special parameters."
7837 if (list == 0 && unbound_vars_is_error && (pflags & PF_IGNUNBOUND) == 0)
7842 last_command_exit_value = EXECUTION_FAILURE;
7843 err_unboundvar (uerror);
7844 return (interactive_shell ? &expand_wdesc_error : &expand_wdesc_fatal);
7848 /* We want to flag the fact that we saw this. We can't turn
7849 off quoting entirely, because other characters in the
7850 string might need it (consider "\"$@\""), but we need some
7851 way to signal that the final split on the first character
7852 of $IFS should be done, even though QUOTED is 1. */
7853 /* XXX - should this test include Q_PATQUOTE? */
7854 if (quoted_dollar_at_p && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
7855 *quoted_dollar_at_p = 1;
7856 if (contains_dollar_at)
7857 *contains_dollar_at = 1;
7859 /* We want to separate the positional parameters with the first
7860 character of $IFS in case $IFS is something other than a space.
7861 We also want to make sure that splitting is done no matter what --
7862 according to POSIX.2, this expands to a list of the positional
7863 parameters no matter what IFS is set to. */
7864 /* XXX - what to do when in a context where word splitting is not
7865 performed? Even when IFS is not the default, posix seems to imply
7866 that we behave like unquoted $* ? Maybe we should use PF_NOSPLIT2
7868 temp = string_list_dollar_at (list, (pflags & PF_ASSIGNRHS) ? (quoted|Q_DOUBLE_QUOTES) : quoted);
7870 tflag |= W_DOLLARAT;
7871 dispose_words (list);
7875 tdesc = parameter_brace_expand (string, &zindex, quoted, pflags,
7877 contains_dollar_at);
7879 if (tdesc == &expand_wdesc_error || tdesc == &expand_wdesc_fatal)
7881 temp = tdesc ? tdesc->word : (char *)0;
7884 /* Quoted nulls should be removed if there is anything else
7886 /* Note that we saw the quoted null so we can add one back at
7887 the end of this function if there are no other characters
7888 in the string, discard TEMP, and go on. The exception to
7889 this is when we have "${@}" and $1 is '', since $@ needs
7890 special handling. */
7891 if (tdesc && tdesc->word && (tdesc->flags & W_HASQUOTEDNULL) && QUOTED_NULL (temp))
7893 if (had_quoted_null_p)
7894 *had_quoted_null_p = 1;
7895 if (*quoted_dollar_at_p == 0)
7898 tdesc->word = temp = (char *)NULL;
7906 /* Do command or arithmetic substitution. */
7908 /* We have to extract the contents of this paren substitution. */
7909 t_index = zindex + 1;
7910 temp = extract_command_subst (string, &t_index, 0);
7913 /* For Posix.2-style `$(( ))' arithmetic substitution,
7914 extract the expression and pass it to the evaluator. */
7915 if (temp && *temp == LPAREN)
7919 temp2 = savestring (temp1);
7920 t_index = strlen (temp2) - 1;
7922 if (temp2[t_index] != RPAREN)
7928 /* Cut off ending `)' */
7929 temp2[t_index] = '\0';
7931 if (chk_arithsub (temp2, t_index) == 0)
7935 internal_warning (_("future versions of the shell will force evaluation as an arithmetic substitution"));
7940 /* Expand variables found inside the expression. */
7941 temp1 = expand_arith_string (temp2, Q_DOUBLE_QUOTES);
7945 /* No error messages. */
7946 this_command_name = (char *)NULL;
7947 number = evalexp (temp1, &expok);
7952 if (interactive_shell == 0 && posixly_correct)
7954 last_command_exit_value = EXECUTION_FAILURE;
7955 return (&expand_wdesc_fatal);
7958 return (&expand_wdesc_error);
7960 temp = itos (number);
7965 if (pflags & PF_NOCOMSUB)
7966 /* we need zindex+1 because string[zindex] == RPAREN */
7967 temp1 = substring (string, *sindex, zindex+1);
7970 tdesc = command_substitute (temp, quoted);
7971 temp1 = tdesc ? tdesc->word : (char *)NULL;
7973 dispose_word_desc (tdesc);
7979 /* Do POSIX.2d9-style arithmetic substitution. This will probably go
7980 away in a future bash release. */
7982 /* Extract the contents of this arithmetic substitution. */
7983 t_index = zindex + 1;
7984 temp = extract_arithmetic_subst (string, &t_index);
7988 temp = savestring (string);
7989 if (expanded_something)
7990 *expanded_something = 0;
7994 /* Do initial variable expansion. */
7995 temp1 = expand_arith_string (temp, Q_DOUBLE_QUOTES);
8000 /* Find the variable in VARIABLE_LIST. */
8001 temp = (char *)NULL;
8003 for (t_index = zindex; (c = string[zindex]) && legal_variable_char (c); zindex++)
8005 temp1 = (zindex > t_index) ? substring (string, t_index, zindex) : (char *)NULL;
8007 /* If this isn't a variable name, then just output the `$'. */
8008 if (temp1 == 0 || *temp1 == '\0')
8011 temp = (char *)xmalloc (2);
8014 if (expanded_something)
8015 *expanded_something = 0;
8019 /* If the variable exists, return its value cell. */
8020 var = find_variable (temp1);
8022 if (var && invisible_p (var) == 0 && var_isset (var))
8024 #if defined (ARRAY_VARS)
8025 if (assoc_p (var) || array_p (var))
8027 temp = array_p (var) ? array_reference (array_cell (var), 0)
8028 : assoc_reference (assoc_cell (var), "0");
8030 temp = (*temp && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
8031 ? quote_string (temp)
8032 : quote_escapes (temp);
8033 else if (unbound_vars_is_error)
8034 goto unbound_variable;
8039 temp = value_cell (var);
8041 temp = (*temp && (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)))
8042 ? quote_string (temp)
8043 : quote_escapes (temp);
8050 else if (var && (invisible_p (var) || var_isset (var) == 0))
8051 temp = (char *)NULL;
8052 else if ((var = find_variable_last_nameref (temp1)) && var_isset (var) && invisible_p (var) == 0)
8054 temp = nameref_cell (var);
8055 #if defined (ARRAY_VARS)
8056 if (temp && *temp && valid_array_reference (temp))
8058 tdesc = parameter_brace_expand_word (temp, SPECIAL_VAR (temp, 0), quoted, pflags, (arrayind_t *)NULL);
8059 if (tdesc == &expand_wdesc_error || tdesc == &expand_wdesc_fatal)
8066 /* y=2 ; typeset -n x=y; echo $x is not the same as echo $2 in ksh */
8067 if (temp && *temp && legal_identifier (temp) == 0)
8069 last_command_exit_value = EXECUTION_FAILURE;
8070 report_error (_("%s: invalid variable name for name reference"), temp);
8071 return (&expand_wdesc_error); /* XXX */
8074 temp = (char *)NULL;
8077 temp = (char *)NULL;
8080 if (unbound_vars_is_error)
8082 last_command_exit_value = EXECUTION_FAILURE;
8083 err_unboundvar (temp1);
8092 last_command_exit_value = EXECUTION_FAILURE;
8093 return ((unbound_vars_is_error && interactive_shell == 0)
8094 ? &expand_wdesc_fatal
8095 : &expand_wdesc_error);
8106 ret = alloc_word_desc ();
8107 ret->flags = tflag; /* XXX */
8113 /* Make a word list which is the result of parameter and variable
8114 expansion, command substitution, arithmetic substitution, and
8115 quote removal of WORD. Return a pointer to a WORD_LIST which is
8116 the result of the expansion. If WORD contains a null word, the
8117 word list returned is also null.
8119 QUOTED contains flag values defined in shell.h.
8121 ISEXP is used to tell expand_word_internal that the word should be
8122 treated as the result of an expansion. This has implications for
8123 how IFS characters in the word are treated.
8125 CONTAINS_DOLLAR_AT and EXPANDED_SOMETHING are return values; when non-null
8126 they point to an integer value which receives information about expansion.
8127 CONTAINS_DOLLAR_AT gets non-zero if WORD contained "$@", else zero.
8128 EXPANDED_SOMETHING get non-zero if WORD contained any parameter expansions,
8131 This only does word splitting in the case of $@ expansion. In that
8132 case, we split on ' '. */
8134 /* Values for the local variable quoted_state. */
8136 #define PARTIALLY_QUOTED 1
8137 #define WHOLLY_QUOTED 2
8140 expand_word_internal (word, quoted, isexp, contains_dollar_at, expanded_something)
8143 int *contains_dollar_at;
8144 int *expanded_something;
8149 /* The intermediate string that we build while expanding. */
8152 /* The current size of the above object. */
8155 /* Index into ISTRING. */
8158 /* Temporary string storage. */
8161 /* The text of WORD. */
8162 register char *string;
8164 /* The size of STRING. */
8167 /* The index into STRING. */
8170 /* This gets 1 if we see a $@ while quoted. */
8171 int quoted_dollar_at;
8173 /* One of UNQUOTED, PARTIALLY_QUOTED, or WHOLLY_QUOTED, depending on
8174 whether WORD contains no quoting characters, a partially quoted
8175 string (e.g., "xx"ab), or is fully quoted (e.g., "xxab"). */
8179 int had_quoted_null;
8180 int has_dollar_at, temp_has_dollar_at;
8181 int split_on_spaces;
8183 int pflags; /* flags passed to param_expand */
8185 int assignoff; /* If assignment, offset of `=' */
8187 register unsigned char c; /* Current character. */
8188 int t_index; /* For calls to string_extract_xxx. */
8194 istring = (char *)xmalloc (istring_size = DEFAULT_INITIAL_ARRAY_SIZE);
8195 istring[istring_index = 0] = '\0';
8196 quoted_dollar_at = had_quoted_null = has_dollar_at = 0;
8197 split_on_spaces = 0;
8198 quoted_state = UNQUOTED;
8200 string = word->word;
8202 goto finished_with_string;
8203 /* Don't need the string length for the SADD... and COPY_ macros unless
8204 multibyte characters are possible. */
8205 string_size = (MB_CUR_MAX > 1) ? strlen (string) : 1;
8207 if (contains_dollar_at)
8208 *contains_dollar_at = 0;
8212 /* Begin the expansion. */
8218 /* Case on top-level character. */
8222 goto finished_with_string;
8226 #if HANDLE_MULTIBYTE
8227 if (MB_CUR_MAX > 1 && string[sindex])
8229 SADD_MBQCHAR_BODY(temp, string, sindex, string_size);
8234 temp = (char *)xmalloc (3);
8236 temp[1] = c = string[sindex];
8247 istring = sub_append_string (temp, istring, &istring_index, &istring_size);
8253 #if defined (PROCESS_SUBSTITUTION)
8254 /* Process substitution. */
8258 if (string[++sindex] != LPAREN || (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || (word->flags & (W_DQUOTE|W_NOPROCSUB)) || posixly_correct)
8260 sindex--; /* add_character: label increments sindex */
8264 t_index = sindex + 1; /* skip past both '<' and LPAREN */
8266 temp1 = extract_process_subst (string, (c == '<') ? "<(" : ">(", &t_index, 0); /*))*/
8269 /* If the process substitution specification is `<()', we want to
8270 open the pipe for writing in the child and produce output; if
8271 it is `>()', we want to open the pipe for reading in the child
8272 and consume input. */
8273 temp = temp1 ? process_substitute (temp1, (c == '>')) : (char *)0;
8277 goto dollar_add_string;
8279 #endif /* PROCESS_SUBSTITUTION */
8282 /* Posix.2 section 3.6.1 says that tildes following `=' in words
8283 which are not assignment statements are not expanded. If the
8284 shell isn't in posix mode, though, we perform tilde expansion
8285 on `likely candidate' unquoted assignment statements (flags
8286 include W_ASSIGNMENT but not W_QUOTED). A likely candidate
8287 contains an unquoted :~ or =~. Something to think about: we
8288 now have a flag that says to perform tilde expansion on arguments
8289 to `assignment builtins' like declare and export that look like
8290 assignment statements. We now do tilde expansion on such words
8291 even in POSIX mode. */
8292 if (word->flags & (W_ASSIGNRHS|W_NOTILDE))
8294 if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c))
8295 goto add_ifs_character;
8299 /* If we're not in posix mode or forcing assignment-statement tilde
8300 expansion, note where the `=' appears in the word and prepare to
8301 do tilde expansion following the first `='. */
8302 if ((word->flags & W_ASSIGNMENT) &&
8303 (posixly_correct == 0 || (word->flags & W_TILDEEXP)) &&
8304 assignoff == -1 && sindex > 0)
8306 if (sindex == assignoff && string[sindex+1] == '~') /* XXX */
8307 word->flags |= W_ITILDE;
8309 else if ((word->flags & W_ASSIGNMENT) &&
8310 (posixly_correct == 0 || (word->flags & W_TILDEEXP)) &&
8311 string[sindex+1] == '~')
8312 word->flags |= W_ITILDE;
8314 if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c))
8315 goto add_ifs_character;
8320 if (word->flags & W_NOTILDE)
8322 if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c))
8323 goto add_ifs_character;
8328 if ((word->flags & (W_ASSIGNMENT|W_ASSIGNRHS|W_TILDEEXP)) &&
8329 string[sindex+1] == '~')
8330 word->flags |= W_ITILDE;
8332 if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c))
8333 goto add_ifs_character;
8338 /* If the word isn't supposed to be tilde expanded, or we're not
8339 at the start of a word or after an unquoted : or = in an
8340 assignment statement, we don't do tilde expansion. */
8341 if ((word->flags & (W_NOTILDE|W_DQUOTE)) ||
8342 (sindex > 0 && ((word->flags & W_ITILDE) == 0)) ||
8343 (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
8345 word->flags &= ~W_ITILDE;
8346 if (isexp == 0 && (word->flags & (W_NOSPLIT|W_NOSPLIT2)) == 0 && isifs (c) && (quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) == 0)
8347 goto add_ifs_character;
8352 if (word->flags & W_ASSIGNRHS)
8354 else if (word->flags & (W_ASSIGNMENT|W_TILDEEXP))
8359 temp = bash_tilde_find_word (string + sindex, tflag, &t_index);
8361 word->flags &= ~W_ITILDE;
8363 if (temp && *temp && t_index > 0)
8365 temp1 = bash_tilde_expand (temp, tflag);
8366 if (temp1 && *temp1 == '~' && STREQ (temp, temp1))
8370 goto add_character; /* tilde expansion failed */
8375 goto add_quoted_string; /* XXX was add_string */
8384 if (expanded_something)
8385 *expanded_something = 1;
8387 temp_has_dollar_at = 0;
8388 pflags = (word->flags & W_NOCOMSUB) ? PF_NOCOMSUB : 0;
8389 if (word->flags & W_NOSPLIT2)
8390 pflags |= PF_NOSPLIT2;
8391 if (word->flags & W_ASSIGNRHS)
8392 pflags |= PF_ASSIGNRHS;
8393 tword = param_expand (string, &sindex, quoted, expanded_something,
8394 &temp_has_dollar_at, "ed_dollar_at,
8395 &had_quoted_null, pflags);
8396 has_dollar_at += temp_has_dollar_at;
8397 split_on_spaces += (tword->flags & W_SPLITSPACE);
8399 if (tword == &expand_wdesc_error || tword == &expand_wdesc_fatal)
8403 return ((tword == &expand_wdesc_error) ? &expand_word_error
8404 : &expand_word_fatal);
8406 if (contains_dollar_at && has_dollar_at)
8407 *contains_dollar_at = 1;
8409 if (tword && (tword->flags & W_HASQUOTEDNULL))
8410 had_quoted_null = 1;
8412 temp = tword ? tword->word : (char *)NULL;
8413 dispose_word_desc (tword);
8415 /* Kill quoted nulls; we will add them back at the end of
8416 expand_word_internal if nothing else in the string */
8417 if (had_quoted_null && temp && QUOTED_NULL (temp))
8420 temp = (char *)NULL;
8426 case '`': /* Backquoted command substitution. */
8430 temp = string_extract (string, &sindex, "`", SX_REQMATCH);
8431 /* The test of sindex against t_index is to allow bare instances of
8432 ` to pass through, for backwards compatibility. */
8433 if (temp == &extract_string_error || temp == &extract_string_fatal)
8435 if (sindex - 1 == t_index)
8440 last_command_exit_value = EXECUTION_FAILURE;
8441 report_error (_("bad substitution: no closing \"`\" in %s") , string+t_index);
8444 return ((temp == &extract_string_error) ? &expand_word_error
8445 : &expand_word_fatal);
8448 if (expanded_something)
8449 *expanded_something = 1;
8451 if (word->flags & W_NOCOMSUB)
8452 /* sindex + 1 because string[sindex] == '`' */
8453 temp1 = substring (string, t_index, sindex + 1);
8456 de_backslash (temp);
8457 tword = command_substitute (temp, quoted);
8458 temp1 = tword ? tword->word : (char *)NULL;
8460 dispose_word_desc (tword);
8464 goto dollar_add_string;
8468 if (string[sindex + 1] == '\n')
8474 c = string[++sindex];
8476 if (quoted & Q_HERE_DOCUMENT)
8478 else if (quoted & Q_DOUBLE_QUOTES)
8483 /* From Posix discussion on austin-group list: Backslash escaping
8484 a } in ${...} is removed. Issue 0000221 */
8485 if ((quoted & Q_DOLBRACE) && c == RBRACE)
8487 SCOPY_CHAR_I (twochars, CTLESC, c, string, sindex, string_size);
8489 /* This is the fix for " $@\ " */
8490 else if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && ((sh_syntaxtab[c] & tflag) == 0) && isexp == 0 && isifs (c))
8492 RESIZE_MALLOCED_BUFFER (istring, istring_index, 2, istring_size,
8493 DEFAULT_ARRAY_SIZE);
8494 istring[istring_index++] = CTLESC;
8495 istring[istring_index++] = '\\';
8496 istring[istring_index] = '\0';
8498 SCOPY_CHAR_I (twochars, CTLESC, c, string, sindex, string_size);
8500 else if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) && ((sh_syntaxtab[c] & tflag) == 0))
8502 SCOPY_CHAR_I (twochars, '\\', c, string, sindex, string_size);
8507 sindex--; /* add_character: label increments sindex */
8512 SCOPY_CHAR_I (twochars, CTLESC, c, string, sindex, string_size);
8517 /* BEFORE jumping here, we need to increment sindex if appropriate */
8518 RESIZE_MALLOCED_BUFFER (istring, istring_index, 2, istring_size,
8519 DEFAULT_ARRAY_SIZE);
8520 istring[istring_index++] = twochars[0];
8521 istring[istring_index++] = twochars[1];
8522 istring[istring_index] = '\0';
8527 if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
8531 temp = string_extract_double_quoted (string, &sindex, 0);
8533 /* If the quotes surrounded the entire string, then the
8534 whole word was quoted. */
8535 quoted_state = (t_index == 1 && string[sindex] == '\0')
8541 tword = alloc_word_desc ();
8544 temp = (char *)NULL;
8546 temp_has_dollar_at = 0; /* XXX */
8547 /* Need to get W_HASQUOTEDNULL flag through this function. */
8548 list = expand_word_internal (tword, Q_DOUBLE_QUOTES, 0, &temp_has_dollar_at, (int *)NULL);
8549 has_dollar_at += temp_has_dollar_at;
8551 if (list == &expand_word_error || list == &expand_word_fatal)
8555 /* expand_word_internal has already freed temp_word->word
8556 for us because of the way it prints error messages. */
8557 tword->word = (char *)NULL;
8558 dispose_word (tword);
8562 dispose_word (tword);
8564 /* "$@" (a double-quoted dollar-at) expands into nothing,
8565 not even a NULL word, when there are no positional
8567 if (list == 0 && has_dollar_at)
8573 /* If we get "$@", we know we have expanded something, so we
8574 need to remember it for the final split on $IFS. This is
8575 a special case; it's the only case where a quoted string
8576 can expand into more than one word. It's going to come back
8577 from the above call to expand_word_internal as a list with
8578 a single word, in which all characters are quoted and
8579 separated by blanks. What we want to do is to turn it back
8580 into a list for the next piece of code. */
8582 dequote_list (list);
8584 if (list && list->word && (list->word->flags & W_HASQUOTEDNULL))
8585 had_quoted_null = 1; /* XXX */
8590 if (contains_dollar_at)
8591 *contains_dollar_at = 1;
8592 if (expanded_something)
8593 *expanded_something = 1;
8598 /* What we have is "". This is a minor optimization. */
8600 list = (WORD_LIST *)NULL;
8603 /* The code above *might* return a list (consider the case of "$@",
8604 where it returns "$1", "$2", etc.). We can't throw away the
8605 rest of the list, and we have to make sure each word gets added
8606 as quoted. We test on tresult->next: if it is non-NULL, we
8607 quote the whole list, save it to a string with string_list, and
8608 add that string. We don't need to quote the results of this
8609 (and it would be wrong, since that would quote the separators
8610 as well), so we go directly to add_string. */
8615 /* Testing quoted_dollar_at makes sure that "$@" is
8616 split correctly when $IFS does not contain a space. */
8617 temp = quoted_dollar_at
8618 ? string_list_dollar_at (list, Q_DOUBLE_QUOTES)
8619 : string_list (quote_list (list));
8620 dispose_words (list);
8625 temp = savestring (list->word->word);
8626 tflag = list->word->flags;
8627 dispose_words (list);
8629 /* If the string is not a quoted null string, we want
8630 to remove any embedded unquoted CTLNUL characters.
8631 We do not want to turn quoted null strings back into
8632 the empty string, though. We do this because we
8633 want to remove any quoted nulls from expansions that
8634 contain other characters. For example, if we have
8635 x"$*"y or "x$*y" and there are no positional parameters,
8636 the $* should expand into nothing. */
8637 /* We use the W_HASQUOTEDNULL flag to differentiate the
8638 cases: a quoted null character as above and when
8639 CTLNUL is contained in the (non-null) expansion
8640 of some variable. We use the had_quoted_null flag to
8641 pass the value through this function to its caller. */
8642 if ((tflag & W_HASQUOTEDNULL) && QUOTED_NULL (temp) == 0)
8643 remove_quoted_nulls (temp); /* XXX */
8647 temp = (char *)NULL;
8649 /* We do not want to add quoted nulls to strings that are only
8650 partially quoted; we can throw them away. The exception to
8651 this is when we are going to be performing word splitting,
8652 since we have to preserve a null argument if the next character
8653 will cause word splitting. */
8654 if (temp == 0 && quoted_state == PARTIALLY_QUOTED && (word->flags & (W_NOSPLIT|W_NOSPLIT2)))
8662 temp = quote_string (temp);
8670 sindex--; /* add_character: label increments sindex */
8677 if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)))
8681 temp = string_extract_single_quoted (string, &sindex);
8683 /* If the entire STRING was surrounded by single quotes,
8684 then the string is wholly quoted. */
8685 quoted_state = (t_index == 1 && string[sindex] == '\0')
8689 /* If all we had was '', it is a null expansion. */
8693 temp = (char *)NULL;
8696 remove_quoted_escapes (temp); /* ??? */
8698 /* We do not want to add quoted nulls to strings that are only
8699 partially quoted; such nulls are discarded. */
8700 if (temp == 0 && (quoted_state == PARTIALLY_QUOTED))
8703 /* If we have a quoted null expansion, add a quoted NULL to istring. */
8707 sindex--; /* add_character: label increments sindex */
8711 goto add_quoted_string;
8716 /* This is the fix for " $@ " */
8718 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || (isexp == 0 && isifs (c)))
8720 if (string[sindex]) /* from old goto dollar_add_string */
8729 #if HANDLE_MULTIBYTE
8735 SADD_MBQCHAR_BODY(temp, string, sindex, string_size);
8740 twochars[0] = CTLESC;
8747 SADD_MBCHAR (temp, string, sindex, string_size);
8750 RESIZE_MALLOCED_BUFFER (istring, istring_index, 1, istring_size,
8751 DEFAULT_ARRAY_SIZE);
8752 istring[istring_index++] = c;
8753 istring[istring_index] = '\0';
8755 /* Next character. */
8760 finished_with_string:
8761 /* OK, we're ready to return. If we have a quoted string, and
8762 quoted_dollar_at is not set, we do no splitting at all; otherwise
8763 we split on ' '. The routines that call this will handle what to
8764 do if nothing has been expanded. */
8766 /* Partially and wholly quoted strings which expand to the empty
8767 string are retained as an empty arguments. Unquoted strings
8768 which expand to the empty string are discarded. The single
8769 exception is the case of expanding "$@" when there are no
8770 positional parameters. In that case, we discard the expansion. */
8772 /* Because of how the code that handles "" and '' in partially
8773 quoted strings works, we need to make ISTRING into a QUOTED_NULL
8774 if we saw quoting characters, but the expansion was empty.
8775 "" and '' are tossed away before we get to this point when
8776 processing partially quoted strings. This makes "" and $xxx""
8777 equivalent when xxx is unset. We also look to see whether we
8778 saw a quoted null from a ${} expansion and add one back if we
8781 /* If we expand to nothing and there were no single or double quotes
8782 in the word, we throw it away. Otherwise, we return a NULL word.
8783 The single exception is for $@ surrounded by double quotes when
8784 there are no positional parameters. In that case, we also throw
8787 if (*istring == '\0')
8789 if (quoted_dollar_at == 0 && (had_quoted_null || quoted_state == PARTIALLY_QUOTED))
8791 istring[0] = CTLNUL;
8793 tword = make_bare_word (istring);
8794 tword->flags |= W_HASQUOTEDNULL; /* XXX */
8795 list = make_word_list (tword, (WORD_LIST *)NULL);
8796 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
8797 tword->flags |= W_QUOTED;
8799 /* According to sh, ksh, and Posix.2, if a word expands into nothing
8800 and a double-quoted "$@" appears anywhere in it, then the entire
8802 else if (quoted_state == UNQUOTED || quoted_dollar_at)
8803 list = (WORD_LIST *)NULL;
8807 tword = make_bare_word (istring);
8808 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
8809 tword->flags |= W_QUOTED;
8810 list = make_word_list (tword, (WORD_LIST *)NULL);
8814 list = (WORD_LIST *)NULL;
8817 else if (word->flags & W_NOSPLIT)
8819 tword = make_bare_word (istring);
8820 if (word->flags & W_ASSIGNMENT)
8821 tword->flags |= W_ASSIGNMENT; /* XXX */
8822 if (word->flags & W_COMPASSIGN)
8823 tword->flags |= W_COMPASSIGN; /* XXX */
8824 if (word->flags & W_NOGLOB)
8825 tword->flags |= W_NOGLOB; /* XXX */
8826 if (word->flags & W_NOBRACE)
8827 tword->flags |= W_NOBRACE; /* XXX */
8828 if (word->flags & W_NOEXPAND)
8829 tword->flags |= W_NOEXPAND; /* XXX */
8830 if (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
8831 tword->flags |= W_QUOTED;
8832 if (had_quoted_null && QUOTED_NULL (istring))
8833 tword->flags |= W_HASQUOTEDNULL;
8834 list = make_word_list (tword, (WORD_LIST *)NULL);
8841 ifs_chars = (quoted_dollar_at || has_dollar_at) ? ifs_value : (char *)NULL;
8843 /* If we have $@, we need to split the results no matter what. If
8844 IFS is unset or NULL, string_list_dollar_at has separated the
8845 positional parameters with a space, so we split on space (we have
8846 set ifs_chars to " \t\n" above if ifs is unset). If IFS is set,
8847 string_list_dollar_at has separated the positional parameters
8848 with the first character of $IFS, so we split on $IFS. If
8849 SPLIT_ON_SPACES is set, we expanded $* (unquoted) with IFS either
8850 unset or null, and we want to make sure that we split on spaces
8851 regardless of what else has happened to IFS since the expansion. */
8852 if (split_on_spaces)
8853 list = list_string (istring, " ", 1); /* XXX quoted == 1? */
8854 /* If we have $@ (has_dollar_at != 0) and we are in a context where we
8855 don't want to split the result (W_NOSPLIT2), and we are not quoted,
8856 we have already separated the arguments with the first character of
8857 $IFS. In this case, we want to return a list with a single word
8858 with the separator possibly replaced with a space (it's what other
8860 quoted_dollar_at is internal to this function and is set if we are
8861 passed an argument that is unquoted (quoted == 0) but we encounter a
8862 double-quoted $@ while expanding it. */
8863 else if (has_dollar_at && quoted_dollar_at == 0 && ifs_chars && quoted == 0 && (word->flags & W_NOSPLIT2))
8865 /* Only split and rejoin if we have to */
8866 if (*ifs_chars && *ifs_chars != ' ')
8868 list = list_string (istring, *ifs_chars ? ifs_chars : " ", 1);
8869 tstring = string_list (list);
8873 tword = make_bare_word (tstring);
8874 if (tstring != istring)
8876 goto set_word_flags;
8878 else if (has_dollar_at && ifs_chars)
8879 list = list_string (istring, *ifs_chars ? ifs_chars : " ", 1);
8882 tword = make_bare_word (istring);
8884 if ((quoted & (Q_DOUBLE_QUOTES|Q_HERE_DOCUMENT)) || (quoted_state == WHOLLY_QUOTED))
8885 tword->flags |= W_QUOTED;
8886 if (word->flags & W_ASSIGNMENT)
8887 tword->flags |= W_ASSIGNMENT;
8888 if (word->flags & W_COMPASSIGN)
8889 tword->flags |= W_COMPASSIGN;
8890 if (word->flags & W_NOGLOB)
8891 tword->flags |= W_NOGLOB;
8892 if (word->flags & W_NOBRACE)
8893 tword->flags |= W_NOBRACE;
8894 if (word->flags & W_NOEXPAND)
8895 tword->flags |= W_NOEXPAND;
8896 if (had_quoted_null && QUOTED_NULL (istring))
8897 tword->flags |= W_HASQUOTEDNULL; /* XXX */
8898 list = make_word_list (tword, (WORD_LIST *)NULL);
8906 /* **************************************************************** */
8908 /* Functions for Quote Removal */
8910 /* **************************************************************** */
8912 /* Perform quote removal on STRING. If QUOTED > 0, assume we are obeying the
8913 backslash quoting rules for within double quotes or a here document. */
8915 string_quote_removal (string, quoted)
8920 char *r, *result_string, *temp, *send;
8921 int sindex, tindex, dquote;
8925 /* The result can be no longer than the original string. */
8926 slen = strlen (string);
8927 send = string + slen;
8929 r = result_string = (char *)xmalloc (slen + 1);
8931 for (dquote = sindex = 0; c = string[sindex];)
8936 c = string[++sindex];
8942 if (((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || dquote) && (sh_syntaxtab[c] & CBSDQUOTE) == 0)
8947 SCOPY_CHAR_M (r, string, send, sindex);
8951 if ((quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES)) || dquote)
8957 tindex = sindex + 1;
8958 temp = string_extract_single_quoted (string, &tindex);
8969 dquote = 1 - dquote;
8975 return (result_string);
8980 /* Perform quote removal on word WORD. This allocates and returns a new
8983 word_quote_removal (word, quoted)
8990 t = string_quote_removal (word->word, quoted);
8991 w = alloc_word_desc ();
8992 w->word = t ? t : savestring ("");
8996 /* Perform quote removal on all words in LIST. If QUOTED is non-zero,
8997 the members of the list are treated as if they are surrounded by
8998 double quotes. Return a new list, or NULL if LIST is NULL. */
9000 word_list_quote_removal (list, quoted)
9004 WORD_LIST *result, *t, *tresult, *e;
9006 for (t = list, result = (WORD_LIST *)NULL; t; t = t->next)
9008 tresult = make_word_list (word_quote_removal (t->word, quoted), (WORD_LIST *)NULL);
9010 result = (WORD_LIST *) list_append (result, tresult);
9013 result = e = tresult;
9026 /*******************************************
9028 * Functions to perform word splitting *
9030 *******************************************/
9040 ifs_value = (v && value_cell (v)) ? value_cell (v) : " \t\n";
9042 ifs_is_set = ifs_var != 0;
9043 ifs_is_null = ifs_is_set && (*ifs_value == 0);
9045 /* Should really merge ifs_cmap with sh_syntaxtab. XXX - doesn't yet
9046 handle multibyte chars in IFS */
9047 memset (ifs_cmap, '\0', sizeof (ifs_cmap));
9048 for (t = ifs_value ; t && *t; t++)
9054 #if defined (HANDLE_MULTIBYTE)
9057 ifs_firstc[0] = '\0';
9063 ifs_len = strnlen (ifs_value, MB_CUR_MAX);
9064 ifs_firstc_len = MBLEN (ifs_value, ifs_len);
9065 if (ifs_firstc_len == 1 || ifs_firstc_len == 0 || MB_INVALIDCH (ifs_firstc_len))
9067 ifs_firstc[0] = ifs_value[0];
9068 ifs_firstc[1] = '\0';
9072 memcpy (ifs_firstc, ifs_value, ifs_firstc_len);
9075 ifs_firstc = ifs_value ? *ifs_value : 0;
9085 /* This splits a single word into a WORD LIST on $IFS, but only if the word
9086 is not quoted. list_string () performs quote removal for us, even if we
9087 don't do any splitting. */
9089 word_split (w, ifs_chars)
9099 xifs = ((w->flags & W_QUOTED) || ifs_chars == 0) ? "" : ifs_chars;
9100 result = list_string (w->word, xifs, w->flags & W_QUOTED);
9103 result = (WORD_LIST *)NULL;
9108 /* Perform word splitting on LIST and return the RESULT. It is possible
9109 to return (WORD_LIST *)NULL. */
9111 word_list_split (list)
9114 WORD_LIST *result, *t, *tresult, *e;
9116 for (t = list, result = (WORD_LIST *)NULL; t; t = t->next)
9118 tresult = word_split (t->word, ifs_value);
9120 result = e = tresult;
9131 /**************************************************
9133 * Functions to expand an entire WORD_LIST *
9135 **************************************************/
9137 /* Do any word-expansion-specific cleanup and jump to top_level */
9139 exp_jump_to_top_level (v)
9142 set_pipestatus_from_exit (last_command_exit_value);
9144 /* Cleanup code goes here. */
9145 expand_no_split_dollar_star = 0; /* XXX */
9146 expanding_redir = 0;
9147 assigning_in_environment = 0;
9149 if (parse_and_execute_level == 0)
9150 top_level_cleanup (); /* from sig.c */
9152 jump_to_top_level (v);
9155 /* Put NLIST (which is a WORD_LIST * of only one element) at the front of
9156 ELIST, and set ELIST to the new list. */
9157 #define PREPEND_LIST(nlist, elist) \
9158 do { nlist->next = elist; elist = nlist; } while (0)
9160 /* Separate out any initial variable assignments from TLIST. If set -k has
9161 been executed, remove all assignment statements from TLIST. Initial
9162 variable assignments and other environment assignments are placed
9163 on SUBST_ASSIGN_VARLIST. */
9165 separate_out_assignments (tlist)
9168 register WORD_LIST *vp, *lp;
9171 return ((WORD_LIST *)NULL);
9173 if (subst_assign_varlist)
9174 dispose_words (subst_assign_varlist); /* Clean up after previous error */
9176 subst_assign_varlist = (WORD_LIST *)NULL;
9179 /* Separate out variable assignments at the start of the command.
9180 Loop invariant: vp->next == lp
9182 lp = list of words left after assignment statements skipped
9183 tlist = original list of words
9185 while (lp && (lp->word->flags & W_ASSIGNMENT))
9191 /* If lp != tlist, we have some initial assignment statements.
9192 We make SUBST_ASSIGN_VARLIST point to the list of assignment
9193 words and TLIST point to the remaining words. */
9196 subst_assign_varlist = tlist;
9197 /* ASSERT(vp->next == lp); */
9198 vp->next = (WORD_LIST *)NULL; /* terminate variable list */
9199 tlist = lp; /* remainder of word list */
9202 /* vp == end of variable list */
9203 /* tlist == remainder of original word list without variable assignments */
9205 /* All the words in tlist were assignment statements */
9206 return ((WORD_LIST *)NULL);
9208 /* ASSERT(tlist != NULL); */
9209 /* ASSERT((tlist->word->flags & W_ASSIGNMENT) == 0); */
9211 /* If the -k option is in effect, we need to go through the remaining
9212 words, separate out the assignment words, and place them on
9213 SUBST_ASSIGN_VARLIST. */
9214 if (place_keywords_in_env)
9216 WORD_LIST *tp; /* tp == running pointer into tlist */
9221 /* Loop Invariant: tp->next == lp */
9222 /* Loop postcondition: tlist == word list without assignment statements */
9225 if (lp->word->flags & W_ASSIGNMENT)
9227 /* Found an assignment statement, add this word to end of
9228 subst_assign_varlist (vp). */
9229 if (!subst_assign_varlist)
9230 subst_assign_varlist = vp = lp;
9237 /* Remove the word pointed to by LP from TLIST. */
9238 tp->next = lp->next;
9239 /* ASSERT(vp == lp); */
9240 lp->next = (WORD_LIST *)NULL;
9253 #define WEXP_VARASSIGN 0x001
9254 #define WEXP_BRACEEXP 0x002
9255 #define WEXP_TILDEEXP 0x004
9256 #define WEXP_PARAMEXP 0x008
9257 #define WEXP_PATHEXP 0x010
9259 /* All of the expansions, including variable assignments at the start of
9261 #define WEXP_ALL (WEXP_VARASSIGN|WEXP_BRACEEXP|WEXP_TILDEEXP|WEXP_PARAMEXP|WEXP_PATHEXP)
9263 /* All of the expansions except variable assignments at the start of
9265 #define WEXP_NOVARS (WEXP_BRACEEXP|WEXP_TILDEEXP|WEXP_PARAMEXP|WEXP_PATHEXP)
9267 /* All of the `shell expansions': brace expansion, tilde expansion, parameter
9268 expansion, command substitution, arithmetic expansion, word splitting, and
9270 #define WEXP_SHELLEXP (WEXP_BRACEEXP|WEXP_TILDEEXP|WEXP_PARAMEXP)
9272 /* Take the list of words in LIST and do the various substitutions. Return
9273 a new list of words which is the expanded list, and without things like
9274 variable assignments. */
9280 return (expand_word_list_internal (list, WEXP_ALL));
9283 /* Same as expand_words (), but doesn't hack variable or environment
9286 expand_words_no_vars (list)
9289 return (expand_word_list_internal (list, WEXP_NOVARS));
9293 expand_words_shellexp (list)
9296 return (expand_word_list_internal (list, WEXP_SHELLEXP));
9300 glob_expand_word_list (tlist, eflags)
9304 char **glob_array, *temp_string;
9305 register int glob_index;
9306 WORD_LIST *glob_list, *output_list, *disposables, *next;
9309 output_list = disposables = (WORD_LIST *)NULL;
9310 glob_array = (char **)NULL;
9313 /* For each word, either globbing is attempted or the word is
9314 added to orig_list. If globbing succeeds, the results are
9315 added to orig_list and the word (tlist) is added to the list
9316 of disposable words. If globbing fails and failed glob
9317 expansions are left unchanged (the shell default), the
9318 original word is added to orig_list. If globbing fails and
9319 failed glob expansions are removed, the original word is
9320 added to the list of disposable words. orig_list ends up
9321 in reverse order and requires a call to REVERSE_LIST to
9322 be set right. After all words are examined, the disposable
9326 /* If the word isn't an assignment and contains an unquoted
9327 pattern matching character, then glob it. */
9328 if ((tlist->word->flags & W_NOGLOB) == 0 &&
9329 unquoted_glob_pattern_p (tlist->word->word))
9331 glob_array = shell_glob_filename (tlist->word->word);
9333 /* Handle error cases.
9334 I don't think we should report errors like "No such file
9335 or directory". However, I would like to report errors
9336 like "Read failed". */
9338 if (glob_array == 0 || GLOB_FAILED (glob_array))
9340 glob_array = (char **)xmalloc (sizeof (char *));
9341 glob_array[0] = (char *)NULL;
9344 /* Dequote the current word in case we have to use it. */
9345 if (glob_array[0] == NULL)
9347 temp_string = dequote_string (tlist->word->word);
9348 free (tlist->word->word);
9349 tlist->word->word = temp_string;
9352 /* Make the array into a word list. */
9353 glob_list = (WORD_LIST *)NULL;
9354 for (glob_index = 0; glob_array[glob_index]; glob_index++)
9356 tword = make_bare_word (glob_array[glob_index]);
9357 glob_list = make_word_list (tword, glob_list);
9362 output_list = (WORD_LIST *)list_append (glob_list, output_list);
9363 PREPEND_LIST (tlist, disposables);
9365 else if (fail_glob_expansion != 0)
9367 last_command_exit_value = EXECUTION_FAILURE;
9368 report_error (_("no match: %s"), tlist->word->word);
9369 exp_jump_to_top_level (DISCARD);
9371 else if (allow_null_glob_expansion == 0)
9373 /* Failed glob expressions are left unchanged. */
9374 PREPEND_LIST (tlist, output_list);
9378 /* Failed glob expressions are removed. */
9379 PREPEND_LIST (tlist, disposables);
9384 /* Dequote the string. */
9385 temp_string = dequote_string (tlist->word->word);
9386 free (tlist->word->word);
9387 tlist->word->word = temp_string;
9388 PREPEND_LIST (tlist, output_list);
9391 strvec_dispose (glob_array);
9392 glob_array = (char **)NULL;
9398 dispose_words (disposables);
9401 output_list = REVERSE_LIST (output_list, WORD_LIST *);
9403 return (output_list);
9406 #if defined (BRACE_EXPANSION)
9408 brace_expand_word_list (tlist, eflags)
9412 register char **expansions;
9414 WORD_LIST *disposables, *output_list, *next;
9418 for (disposables = output_list = (WORD_LIST *)NULL; tlist; tlist = next)
9422 if (tlist->word->flags & W_NOBRACE)
9424 /*itrace("brace_expand_word_list: %s: W_NOBRACE", tlist->word->word);*/
9425 PREPEND_LIST (tlist, output_list);
9429 if ((tlist->word->flags & (W_COMPASSIGN|W_ASSIGNARG)) == (W_COMPASSIGN|W_ASSIGNARG))
9431 /*itrace("brace_expand_word_list: %s: W_COMPASSIGN|W_ASSIGNARG", tlist->word->word);*/
9432 PREPEND_LIST (tlist, output_list);
9436 /* Only do brace expansion if the word has a brace character. If
9437 not, just add the word list element to BRACES and continue. In
9438 the common case, at least when running shell scripts, this will
9439 degenerate to a bunch of calls to `mbschr', and then what is
9440 basically a reversal of TLIST into BRACES, which is corrected
9441 by a call to REVERSE_LIST () on BRACES when the end of TLIST
9443 if (mbschr (tlist->word->word, LBRACE))
9445 expansions = brace_expand (tlist->word->word);
9447 for (eindex = 0; temp_string = expansions[eindex]; eindex++)
9449 w = alloc_word_desc ();
9450 w->word = temp_string;
9452 /* If brace expansion didn't change the word, preserve
9453 the flags. We may want to preserve the flags
9454 unconditionally someday -- XXX */
9455 if (STREQ (temp_string, tlist->word->word))
9456 w->flags = tlist->word->flags;
9458 w = make_word_flags (w, temp_string);
9460 output_list = make_word_list (w, output_list);
9464 /* Add TLIST to the list of words to be freed after brace
9465 expansion has been performed. */
9466 PREPEND_LIST (tlist, disposables);
9469 PREPEND_LIST (tlist, output_list);
9473 dispose_words (disposables);
9476 output_list = REVERSE_LIST (output_list, WORD_LIST *);
9478 return (output_list);
9482 #if defined (ARRAY_VARS)
9483 /* Take WORD, a compound associative array assignment, and internally run
9484 'declare -A w', where W is the variable name portion of WORD. */
9486 make_internal_declare (word, option)
9494 w = make_word (word);
9496 t = assignment (w->word, 0);
9499 wl = make_word_list (w, (WORD_LIST *)NULL);
9500 wl = make_word_list (make_word (option), wl);
9502 return (declare_builtin (wl));
9507 shell_expand_word_list (tlist, eflags)
9511 WORD_LIST *expanded, *orig_list, *new_list, *next, *temp_list;
9512 int expanded_something, has_dollar_at;
9515 /* We do tilde expansion all the time. This is what 1003.2 says. */
9516 new_list = (WORD_LIST *)NULL;
9517 for (orig_list = tlist; tlist; tlist = next)
9519 temp_string = tlist->word->word;
9523 #if defined (ARRAY_VARS)
9524 /* If this is a compound array assignment to a builtin that accepts
9525 such assignments (e.g., `declare'), take the assignment and perform
9526 it separately, handling the semantics of declarations inside shell
9527 functions. This avoids the double-evaluation of such arguments,
9528 because `declare' does some evaluation of compound assignments on
9530 if ((tlist->word->flags & (W_COMPASSIGN|W_ASSIGNARG)) == (W_COMPASSIGN|W_ASSIGNARG))
9536 if (tlist->word->flags & (W_ASSIGNASSOC|W_ASSNGLOBAL|W_ASSIGNARRAY))
9539 if ((tlist->word->flags & (W_ASSIGNASSOC|W_ASSNGLOBAL)) == (W_ASSIGNASSOC|W_ASSNGLOBAL))
9544 else if (tlist->word->flags & W_ASSIGNASSOC)
9546 else if ((tlist->word->flags & (W_ASSIGNARRAY|W_ASSNGLOBAL)) == (W_ASSIGNARRAY|W_ASSNGLOBAL))
9551 else if (tlist->word->flags & W_ASSIGNARRAY)
9553 else if (tlist->word->flags & W_ASSNGLOBAL)
9557 /* If we have special handling note the integer attribute */
9558 if (opti > 0 && (tlist->word->flags & W_ASSIGNINT))
9564 make_internal_declare (tlist->word->word, opts);
9566 t = do_word_assignment (tlist->word, 0);
9569 last_command_exit_value = EXECUTION_FAILURE;
9570 exp_jump_to_top_level (DISCARD);
9573 /* Now transform the word as ksh93 appears to do and go on */
9574 t = assignment (tlist->word->word, 0);
9575 tlist->word->word[t] = '\0';
9576 tlist->word->flags &= ~(W_ASSIGNMENT|W_NOSPLIT|W_COMPASSIGN|W_ASSIGNARG|W_ASSIGNASSOC|W_ASSIGNARRAY);
9580 expanded_something = 0;
9581 expanded = expand_word_internal
9582 (tlist->word, 0, 0, &has_dollar_at, &expanded_something);
9584 if (expanded == &expand_word_error || expanded == &expand_word_fatal)
9586 /* By convention, each time this error is returned,
9587 tlist->word->word has already been freed. */
9588 tlist->word->word = (char *)NULL;
9590 /* Dispose our copy of the original list. */
9591 dispose_words (orig_list);
9592 /* Dispose the new list we're building. */
9593 dispose_words (new_list);
9595 last_command_exit_value = EXECUTION_FAILURE;
9596 if (expanded == &expand_word_error)
9597 exp_jump_to_top_level (DISCARD);
9599 exp_jump_to_top_level (FORCE_EOF);
9602 /* Don't split words marked W_NOSPLIT. */
9603 if (expanded_something && (tlist->word->flags & W_NOSPLIT) == 0)
9605 temp_list = word_list_split (expanded);
9606 dispose_words (expanded);
9610 /* If no parameter expansion, command substitution, process
9611 substitution, or arithmetic substitution took place, then
9612 do not do word splitting. We still have to remove quoted
9613 null characters from the result. */
9614 word_list_remove_quoted_nulls (expanded);
9615 temp_list = expanded;
9618 expanded = REVERSE_LIST (temp_list, WORD_LIST *);
9619 new_list = (WORD_LIST *)list_append (expanded, new_list);
9623 dispose_words (orig_list);
9626 new_list = REVERSE_LIST (new_list, WORD_LIST *);
9631 /* The workhorse for expand_words () and expand_words_no_vars ().
9632 First arg is LIST, a WORD_LIST of words.
9633 Second arg EFLAGS is a flags word controlling which expansions are
9636 This does all of the substitutions: brace expansion, tilde expansion,
9637 parameter expansion, command substitution, arithmetic expansion,
9638 process substitution, word splitting, and pathname expansion, according
9639 to the bits set in EFLAGS. Words with the W_QUOTED or W_NOSPLIT bits
9640 set, or for which no expansion is done, do not undergo word splitting.
9641 Words with the W_NOGLOB bit set do not undergo pathname expansion; words
9642 with W_NOBRACE set do not undergo brace expansion (see
9643 brace_expand_word_list above). */
9645 expand_word_list_internal (list, eflags)
9649 WORD_LIST *new_list, *temp_list;
9652 tempenv_assign_error = 0;
9654 return ((WORD_LIST *)NULL);
9656 garglist = new_list = copy_word_list (list);
9657 if (eflags & WEXP_VARASSIGN)
9659 garglist = new_list = separate_out_assignments (new_list);
9662 if (subst_assign_varlist)
9664 /* All the words were variable assignments, so they are placed
9665 into the shell's environment. */
9666 for (temp_list = subst_assign_varlist; temp_list; temp_list = temp_list->next)
9668 this_command_name = (char *)NULL; /* no arithmetic errors */
9669 tint = do_word_assignment (temp_list->word, 0);
9670 /* Variable assignment errors in non-interactive shells
9671 running in Posix.2 mode cause the shell to exit. */
9674 last_command_exit_value = EXECUTION_FAILURE;
9675 if (interactive_shell == 0 && posixly_correct)
9676 exp_jump_to_top_level (FORCE_EOF);
9678 exp_jump_to_top_level (DISCARD);
9681 dispose_words (subst_assign_varlist);
9682 subst_assign_varlist = (WORD_LIST *)NULL;
9684 return ((WORD_LIST *)NULL);
9688 /* Begin expanding the words that remain. The expansions take place on
9689 things that aren't really variable assignments. */
9691 #if defined (BRACE_EXPANSION)
9692 /* Do brace expansion on this word if there are any brace characters
9694 if ((eflags & WEXP_BRACEEXP) && brace_expansion && new_list)
9695 new_list = brace_expand_word_list (new_list, eflags);
9696 #endif /* BRACE_EXPANSION */
9698 /* Perform the `normal' shell expansions: tilde expansion, parameter and
9699 variable substitution, command substitution, arithmetic expansion,
9700 and word splitting. */
9701 new_list = shell_expand_word_list (new_list, eflags);
9703 /* Okay, we're almost done. Now let's just do some filename
9707 if ((eflags & WEXP_PATHEXP) && disallow_filename_globbing == 0)
9708 /* Glob expand the word list unless globbing has been disabled. */
9709 new_list = glob_expand_word_list (new_list, eflags);
9711 /* Dequote the words, because we're not performing globbing. */
9712 new_list = dequote_list (new_list);
9715 if ((eflags & WEXP_VARASSIGN) && subst_assign_varlist)
9717 sh_wassign_func_t *assign_func;
9718 int is_special_builtin, is_builtin_or_func;
9720 /* If the remainder of the words expand to nothing, Posix.2 requires
9721 that the variable and environment assignments affect the shell's
9723 assign_func = new_list ? assign_in_env : do_word_assignment;
9724 tempenv_assign_error = 0;
9726 is_builtin_or_func = (new_list && new_list->word && (find_shell_builtin (new_list->word->word) || find_function (new_list->word->word)));
9727 /* Posix says that special builtins exit if a variable assignment error
9728 occurs in an assignment preceding it. */
9729 is_special_builtin = (posixly_correct && new_list && new_list->word && find_special_builtin (new_list->word->word));
9731 for (temp_list = subst_assign_varlist; temp_list; temp_list = temp_list->next)
9733 this_command_name = (char *)NULL;
9734 assigning_in_environment = (assign_func == assign_in_env);
9735 tint = (*assign_func) (temp_list->word, is_builtin_or_func);
9736 assigning_in_environment = 0;
9737 /* Variable assignment errors in non-interactive shells running
9738 in Posix.2 mode cause the shell to exit. */
9741 if (assign_func == do_word_assignment)
9743 last_command_exit_value = EXECUTION_FAILURE;
9744 if (interactive_shell == 0 && posixly_correct && is_special_builtin)
9745 exp_jump_to_top_level (FORCE_EOF);
9747 exp_jump_to_top_level (DISCARD);
9750 tempenv_assign_error++;
9754 dispose_words (subst_assign_varlist);
9755 subst_assign_varlist = (WORD_LIST *)NULL;