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-2016 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)
40 #define NEED_FPURGE_DECL
43 #include "posixstat.h"
50 #include "execute_cmd.h"
54 #include "mailcheck.h"
57 #if defined (HAVE_MBSTR_H) && defined (HAVE_MBSCHR)
58 # include <mbstr.h> /* mbschr */
62 #include "builtins/getopt.h"
63 #include "builtins/common.h"
65 #include "builtins/builtext.h"
67 #include <tilde/tilde.h>
68 #include <glob/strmatch.h>
74 /* The size that strings change by. */
75 #define DEFAULT_INITIAL_ARRAY_SIZE 112
76 #define DEFAULT_ARRAY_SIZE 128
82 #define VT_ARRAYMEMBER 3
85 #define VT_STARSUB 128 /* $* or ${array[*]} -- used to split */
87 /* Flags for quoted_strchr */
88 #define ST_BACKSL 0x01
89 #define ST_CTLESC 0x02
90 #define ST_SQUOTE 0x04 /* unused yet */
91 #define ST_DQUOTE 0x08 /* unused yet */
93 /* These defs make it easier to use the editor. */
101 #if defined (HANDLE_MULTIBYTE)
106 #define DOLLAR_AT_STAR(c) ((c) == '@' || (c) == '*')
107 #define STR_DOLLAR_AT_STAR(s) (DOLLAR_AT_STAR ((s)[0]) && (s)[1] == '\0')
109 /* Evaluates to 1 if C is one of the shell's special parameters whose length
110 can be taken, but is also one of the special expansion characters. */
111 #define VALID_SPECIAL_LENGTH_PARAM(c) \
112 ((c) == '-' || (c) == '?' || (c) == '#' || (c) == '@')
114 /* Evaluates to 1 if C is one of the shell's special parameters for which an
115 indirect variable reference may be made. */
116 #define VALID_INDIR_PARAM(c) \
117 ((posixly_correct == 0 && (c) == '#') || (posixly_correct == 0 && (c) == '?') || (c) == '@' || (c) == '*')
119 /* Evaluates to 1 if C is one of the OP characters that follows the parameter
120 in ${parameter[:]OPword}. */
121 #define VALID_PARAM_EXPAND_CHAR(c) (sh_syntaxtab[(unsigned char)c] & CSUBSTOP)
123 /* Evaluates to 1 if this is one of the shell's special variables. */
124 #define SPECIAL_VAR(name, wi) \
125 (*name && ((DIGIT (*name) && all_digits (name)) || \
126 (name[1] == '\0' && (sh_syntaxtab[(unsigned char)*name] & CSPECVAR)) || \
127 (wi && name[2] == '\0' && VALID_INDIR_PARAM (name[1]))))
129 /* This can be used by all of the *_extract_* functions that have a similar
130 structure. It can't just be wrapped in a do...while(0) loop because of
131 the embedded `break'. The dangling else accommodates a trailing semicolon;
132 we could also put in a do ; while (0) */
135 #define CHECK_STRING_OVERRUN(oind, ind, len, ch) \
144 /* An expansion function that takes a string and a quoted flag and returns
145 a WORD_LIST *. Used as the type of the third argument to
146 expand_string_if_necessary(). */
147 typedef WORD_LIST
*EXPFUNC
__P((char *, int));
149 /* Process ID of the last command executed within command substitution. */
150 pid_t last_command_subst_pid
= NO_PID
;
151 pid_t current_command_subst_pid
= NO_PID
;
153 /* Variables used to keep track of the characters in IFS. */
156 unsigned char ifs_cmap
[UCHAR_MAX
+ 1];
157 int ifs_is_set
, ifs_is_null
;
159 #if defined (HANDLE_MULTIBYTE)
160 unsigned char ifs_firstc
[MB_LEN_MAX
];
161 size_t ifs_firstc_len
;
163 unsigned char ifs_firstc
;
166 /* If non-zero, command substitution inherits the value of errexit option */
167 int inherit_errexit
= 0;
169 /* Sentinel to tell when we are performing variable assignments preceding a
170 command name and putting them into the environment. Used to make sure
171 we use the temporary environment when looking up variable values. */
172 int assigning_in_environment
;
174 /* Used to hold a list of variable assignments preceding a command. Global
175 so the SIGCHLD handler in jobs.c can unwind-protect it when it runs a
176 SIGCHLD trap and so it can be saved and restored by the trap handlers. */
177 WORD_LIST
*subst_assign_varlist
= (WORD_LIST
*)NULL
;
179 /* Tell the expansion functions to not longjmp back to top_level on fatal
180 errors. Enabled when doing completion and prompt string expansion. */
181 int no_longjmp_on_fatal_error
= 0;
183 /* Extern functions and variables from different files. */
184 extern int last_command_exit_value
, last_command_exit_signal
;
185 extern int subshell_environment
, running_in_background
;
186 extern int subshell_level
, parse_and_execute_level
, sourcelevel
;
187 extern int eof_encountered
, line_number
;
188 extern int return_catch_flag
, return_catch_value
;
189 extern pid_t dollar_dollar_pid
;
190 extern int posixly_correct
;
191 extern char *this_command_name
;
192 extern struct fd_bitmap
*current_fds_to_close
;
193 extern int wordexp_only
;
194 extern int expanding_redir
;
195 extern int tempenv_assign_error
;
196 extern int builtin_ignoring_errexit
;
198 #if defined (JOB_CONTROL) && defined (PROCESS_SUBSTITUTION)
199 extern PROCESS
*last_procsub_child
;
202 #if !defined (HAVE_WCSDUP) && defined (HANDLE_MULTIBYTE)
203 extern wchar_t *wcsdup
__P((const wchar_t *));
206 /* Non-zero means to allow unmatched globbed filenames to expand to
208 int allow_null_glob_expansion
;
210 /* Non-zero means to throw an error when globbing fails to match anything. */
211 int fail_glob_expansion
;
214 /* Variables to keep track of which words in an expanded word list (the
215 output of expand_word_list_internal) are the result of globbing
216 expansions. GLOB_ARGV_FLAGS is used by execute_cmd.c.
217 (CURRENTLY UNUSED). */
218 char *glob_argv_flags
;
219 static int glob_argv_flags_size
;
222 static WORD_LIST
*cached_quoted_dollar_at
= 0;
224 static WORD_LIST expand_word_error
, expand_word_fatal
;
225 static WORD_DESC expand_wdesc_error
, expand_wdesc_fatal
;
226 static char expand_param_error
, expand_param_fatal
;
227 static char extract_string_error
, extract_string_fatal
;
229 /* Set by expand_word_unsplit; used to inhibit splitting and re-joining
230 $* on $IFS, primarily when doing assignment statements. */
231 static int expand_no_split_dollar_star
= 0;
233 /* A WORD_LIST of words to be expanded by expand_word_list_internal,
234 without any leading variable assignments. */
235 static WORD_LIST
*garglist
= (WORD_LIST
*)NULL
;
237 static char *quoted_substring
__P((char *, int, int));
238 static int quoted_strlen
__P((char *));
239 static char *quoted_strchr
__P((char *, int, int));
241 static char *expand_string_if_necessary
__P((char *, int, EXPFUNC
*));
242 static inline char *expand_string_to_string_internal
__P((char *, int, EXPFUNC
*));
243 static WORD_LIST
*call_expand_word_internal
__P((WORD_DESC
*, int, int, int *, int *));
244 static WORD_LIST
*expand_string_internal
__P((char *, int));
245 static WORD_LIST
*expand_string_leave_quoted
__P((char *, int));
246 static WORD_LIST
*expand_string_for_rhs
__P((char *, int, int *, int *));
248 static WORD_LIST
*list_quote_escapes
__P((WORD_LIST
*));
249 static WORD_LIST
*list_dequote_escapes
__P((WORD_LIST
*));
251 static char *make_quoted_char
__P((int));
252 static WORD_LIST
*quote_list
__P((WORD_LIST
*));
254 static int unquoted_substring
__P((char *, char *));
255 static int unquoted_member
__P((int, char *));
257 #if defined (ARRAY_VARS)
258 static SHELL_VAR
*do_compound_assignment
__P((char *, char *, int));
260 static int do_assignment_internal
__P((const WORD_DESC
*, int));
262 static char *string_extract_verbatim
__P((char *, size_t, int *, char *, int));
263 static char *string_extract
__P((char *, int *, char *, int));
264 static char *string_extract_double_quoted
__P((char *, int *, int));
265 static inline char *string_extract_single_quoted
__P((char *, int *));
266 static inline int skip_single_quoted
__P((const char *, size_t, int, int));
267 static int skip_double_quoted
__P((char *, size_t, int, int));
268 static char *extract_delimited_string
__P((char *, int *, char *, char *, char *, int));
269 static char *extract_dollar_brace_string
__P((char *, int *, int, int));
270 static int skip_matched_pair
__P((const char *, int, int, int, int));
272 static char *pos_params
__P((char *, int, int, int));
274 static unsigned char *mb_getcharlens
__P((char *, int));
276 static char *remove_upattern
__P((char *, char *, int));
277 #if defined (HANDLE_MULTIBYTE)
278 static wchar_t *remove_wpattern
__P((wchar_t *, size_t, wchar_t *, int));
280 static char *remove_pattern
__P((char *, char *, int));
282 static int match_upattern
__P((char *, char *, int, char **, char **));
283 #if defined (HANDLE_MULTIBYTE)
284 static int match_wpattern
__P((wchar_t *, char **, size_t, wchar_t *, int, char **, char **));
286 static int match_pattern
__P((char *, char *, int, char **, char **));
287 static int getpatspec
__P((int, char *));
288 static char *getpattern
__P((char *, int, int));
289 static char *variable_remove_pattern
__P((char *, char *, int, int));
290 static char *list_remove_pattern
__P((WORD_LIST
*, char *, int, int, int));
291 static char *parameter_list_remove_pattern
__P((int, char *, int, int));
293 static char *array_remove_pattern
__P((SHELL_VAR
*, char *, int, char *, int));
295 static char *parameter_brace_remove_pattern
__P((char *, char *, int, char *, int, int, int));
297 static char *string_var_assignment
__P((SHELL_VAR
*, char *));
298 #if defined (ARRAY_VARS)
299 static char *array_var_assignment
__P((SHELL_VAR
*, int, int));
301 static char *pos_params_assignment
__P((WORD_LIST
*, int, int));
302 static char *string_transform
__P((int, SHELL_VAR
*, char *));
303 static char *list_transform
__P((int, SHELL_VAR
*, WORD_LIST
*, int, int));
304 static char *parameter_list_transform
__P((int, int, int));
305 #if defined ARRAY_VARS
306 static char *array_transform
__P((int, SHELL_VAR
*, char *, int));
308 static char *parameter_brace_transform
__P((char *, char *, int, char *, int, int, int));
310 static char *process_substitute
__P((char *, int));
312 static char *read_comsub
__P((int, int, int *));
315 static arrayind_t array_length_reference
__P((char *));
318 static int valid_brace_expansion_word
__P((char *, int));
319 static int chk_atstar
__P((char *, int, int *, int *));
320 static int chk_arithsub
__P((const char *, int));
322 static WORD_DESC
*parameter_brace_expand_word
__P((char *, int, int, int, arrayind_t
*));
323 static char *parameter_brace_find_indir
__P((char *, int, int, int));
324 static WORD_DESC
*parameter_brace_expand_indir
__P((char *, int, int, int *, int *));
325 static WORD_DESC
*parameter_brace_expand_rhs
__P((char *, char *, int, int, int, int *, int *));
326 static void parameter_brace_expand_error
__P((char *, char *));
328 static int valid_length_expression
__P((char *));
329 static intmax_t parameter_brace_expand_length
__P((char *));
331 static char *skiparith
__P((char *, int));
332 static int verify_substring_values
__P((SHELL_VAR
*, char *, char *, int, intmax_t *, intmax_t *));
333 static int get_var_and_type
__P((char *, char *, arrayind_t
, int, int, SHELL_VAR
**, char **));
334 static char *mb_substring
__P((char *, int, int));
335 static char *parameter_brace_substring
__P((char *, char *, int, char *, int, int));
337 static int shouldexp_replacement
__P((char *));
339 static char *pos_params_pat_subst
__P((char *, char *, char *, int));
341 static char *parameter_brace_patsub
__P((char *, char *, int, char *, int, int, int));
343 static char *pos_params_casemod
__P((char *, char *, int, int));
344 static char *parameter_brace_casemod
__P((char *, char *, int, int, char *, int, int));
346 static WORD_DESC
*parameter_brace_expand
__P((char *, int *, int, int, int *, int *));
347 static WORD_DESC
*param_expand
__P((char *, int *, int, int *, int *, int *, int *, int));
349 static WORD_LIST
*expand_word_internal
__P((WORD_DESC
*, int, int, int *, int *));
351 static WORD_LIST
*word_list_split
__P((WORD_LIST
*));
353 static void exp_jump_to_top_level
__P((int));
355 static WORD_LIST
*separate_out_assignments
__P((WORD_LIST
*));
356 static WORD_LIST
*glob_expand_word_list
__P((WORD_LIST
*, int));
357 #ifdef BRACE_EXPANSION
358 static WORD_LIST
*brace_expand_word_list
__P((WORD_LIST
*, int));
360 #if defined (ARRAY_VARS)
361 static int make_internal_declare
__P((char *, char *, char *));
363 static WORD_LIST
*shell_expand_word_list
__P((WORD_LIST
*, int));
364 static WORD_LIST
*expand_word_list_internal
__P((WORD_LIST
*, int));
366 /* **************************************************************** */
368 /* Utility Functions */
370 /* **************************************************************** */
374 dump_word_flags (flags
)
380 fprintf (stderr
, "%d -> ", f
);
384 fprintf (stderr
, "W_ARRAYIND%s", f
? "|" : "");
386 if (f
& W_ASSIGNASSOC
)
389 fprintf (stderr
, "W_ASSIGNASSOC%s", f
? "|" : "");
391 if (f
& W_ASSIGNARRAY
)
394 fprintf (stderr
, "W_ASSIGNARRAY%s", f
? "|" : "");
399 fprintf (stderr
, "W_HASCTLESC%s", f
? "|" : "");
404 fprintf (stderr
, "W_NOPROCSUB%s", f
? "|" : "");
409 fprintf (stderr
, "W_DQUOTE%s", f
? "|" : "");
411 if (f
& W_HASQUOTEDNULL
)
413 f
&= ~W_HASQUOTEDNULL
;
414 fprintf (stderr
, "W_HASQUOTEDNULL%s", f
? "|" : "");
419 fprintf (stderr
, "W_ASSIGNARG%s", f
? "|" : "");
424 fprintf (stderr
, "W_ASSNBLTIN%s", f
? "|" : "");
426 if (f
& W_ASSNGLOBAL
)
429 fprintf (stderr
, "W_ASSNGLOBAL%s", f
? "|" : "");
431 if (f
& W_COMPASSIGN
)
434 fprintf (stderr
, "W_COMPASSIGN%s", f
? "|" : "");
439 fprintf (stderr
, "W_NOEXPAND%s", f
? "|" : "");
444 fprintf (stderr
, "W_ITILDE%s", f
? "|" : "");
449 fprintf (stderr
, "W_NOTILDE%s", f
? "|" : "");
454 fprintf (stderr
, "W_ASSIGNRHS%s", f
? "|" : "");
459 fprintf (stderr
, "W_NOCOMSUB%s", f
? "|" : "");
461 if (f
& W_DOLLARSTAR
)
464 fprintf (stderr
, "W_DOLLARSTAR%s", f
? "|" : "");
469 fprintf (stderr
, "W_DOLLARAT%s", f
? "|" : "");
474 fprintf (stderr
, "W_TILDEEXP%s", f
? "|" : "");
479 fprintf (stderr
, "W_NOSPLIT2%s", f
? "|" : "");
484 fprintf (stderr
, "W_NOSPLIT%s", f
? "|" : "");
489 fprintf (stderr
, "W_NOBRACE%s", f
? "|" : "");
494 fprintf (stderr
, "W_NOGLOB%s", f
? "|" : "");
496 if (f
& W_SPLITSPACE
)
499 fprintf (stderr
, "W_SPLITSPACE%s", f
? "|" : "");
501 if (f
& W_ASSIGNMENT
)
504 fprintf (stderr
, "W_ASSIGNMENT%s", f
? "|" : "");
509 fprintf (stderr
, "W_QUOTED%s", f
? "|" : "");
514 fprintf (stderr
, "W_HASDOLLAR%s", f
? "|" : "");
519 fprintf (stderr
, "W_COMPLETE%s", f
? "|" : "");
522 fprintf (stderr
, "\n");
527 #ifdef INCLUDE_UNUSED
529 quoted_substring (string
, start
, end
)
534 register char *result
, *s
, *r
;
538 /* Move to string[start], skipping quoted characters. */
539 for (s
= string
, l
= 0; *s
&& l
< start
; )
551 r
= result
= (char *)xmalloc (2*len
+ 1); /* save room for quotes */
553 /* Copy LEN characters, including quote characters. */
555 for (l
= 0; l
< len
; s
++)
569 #ifdef INCLUDE_UNUSED
570 /* Return the length of S, skipping over quoted characters */
594 /* Find the first occurrence of character C in string S, obeying shell
595 quoting rules. If (FLAGS & ST_BACKSL) is non-zero, backslash-escaped
596 characters are skipped. If (FLAGS & ST_CTLESC) is non-zero, characters
597 escaped with CTLESC are skipped. */
599 quoted_strchr (s
, c
, flags
)
607 if (((flags
& ST_BACKSL
) && *p
== '\\')
608 || ((flags
& ST_CTLESC
) && *p
== CTLESC
))
612 return ((char *)NULL
);
618 return ((char *)NULL
);
621 #if defined (INCLUDE_UNUSED)
622 /* Return 1 if CHARACTER appears in an unquoted portion of
623 STRING. Return 0 otherwise. CHARACTER must be a single-byte character. */
625 unquoted_member (character
, string
)
633 slen
= strlen (string
);
635 while (c
= string
[sindex
])
643 ADVANCE_CHAR (string
, slen
, sindex
);
649 ADVANCE_CHAR (string
, slen
, sindex
);
653 sindex
= skip_single_quoted (string
, slen
, ++sindex
, 0);
657 sindex
= skip_double_quoted (string
, slen
, ++sindex
, 0);
664 /* Return 1 if SUBSTR appears in an unquoted portion of STRING. */
666 unquoted_substring (substr
, string
)
667 char *substr
, *string
;
670 int sindex
, c
, sublen
;
673 if (substr
== 0 || *substr
== '\0')
676 slen
= strlen (string
);
677 sublen
= strlen (substr
);
678 for (sindex
= 0; c
= string
[sindex
]; )
680 if (STREQN (string
+ sindex
, substr
, sublen
))
688 ADVANCE_CHAR (string
, slen
, sindex
);
692 sindex
= skip_single_quoted (string
, slen
, ++sindex
, 0);
696 sindex
= skip_double_quoted (string
, slen
, ++sindex
, 0);
700 ADVANCE_CHAR (string
, slen
, sindex
);
708 /* Most of the substitutions must be done in parallel. In order
709 to avoid using tons of unclear goto's, I have some functions
710 for manipulating malloc'ed strings. They all take INDX, a
711 pointer to an integer which is the offset into the string
712 where manipulation is taking place. They also take SIZE, a
713 pointer to an integer which is the current length of the
714 character array for this string. */
716 /* Append SOURCE to TARGET at INDEX. SIZE is the current amount
717 of space allocated to TARGET. SOURCE can be NULL, in which
718 case nothing happens. Gets rid of SOURCE by freeing it.
719 Returns TARGET in case the location has changed. */
721 sub_append_string (source
, target
, indx
, size
)
722 char *source
, *target
;
731 srclen
= STRLEN (source
);
732 if (srclen
>= (int)(*size
- *indx
))
735 n
= (n
+ DEFAULT_ARRAY_SIZE
) - (n
% DEFAULT_ARRAY_SIZE
);
736 target
= (char *)xrealloc (target
, (*size
= n
));
739 FASTCOPY (source
, target
+ *indx
, srclen
);
741 target
[*indx
] = '\0';
750 /* Append the textual representation of NUMBER to TARGET.
751 INDX and SIZE are as in SUB_APPEND_STRING. */
753 sub_append_number (number
, target
, indx
, size
)
761 temp
= itos (number
);
762 return (sub_append_string (temp
, target
, indx
, size
));
766 /* Extract a substring from STRING, starting at SINDEX and ending with
767 one of the characters in CHARLIST. Don't make the ending character
768 part of the string. Leave SINDEX pointing at the ending character.
769 Understand about backslashes in the string. If (flags & SX_VARNAME)
770 is non-zero, and array variables have been compiled into the shell,
771 everything between a `[' and a corresponding `]' is skipped over.
772 If (flags & SX_NOALLOC) is non-zero, don't return the substring, just
773 update SINDEX. If (flags & SX_REQMATCH) is non-zero, the string must
774 contain a closing character from CHARLIST. */
776 string_extract (string
, sindex
, charlist
, flags
)
788 slen
= (MB_CUR_MAX
> 1) ? strlen (string
+ *sindex
) + *sindex
: 0;
791 while (c
= string
[i
])
800 #if defined (ARRAY_VARS)
801 else if ((flags
& SX_VARNAME
) && c
== '[')
804 /* If this is an array subscript, skip over it and continue. */
805 ni
= skipsubscript (string
, i
, 0);
806 if (string
[ni
] == ']')
810 else if (MEMBER (c
, charlist
))
816 ADVANCE_CHAR (string
, slen
, i
);
819 /* If we had to have a matching delimiter and didn't find one, return an
820 error and let the caller deal with it. */
821 if ((flags
& SX_REQMATCH
) && found
== 0)
824 return (&extract_string_error
);
827 temp
= (flags
& SX_NOALLOC
) ? (char *)NULL
: substring (string
, *sindex
, i
);
833 /* Extract the contents of STRING as if it is enclosed in double quotes.
834 SINDEX, when passed in, is the offset of the character immediately
835 following the opening double quote; on exit, SINDEX is left pointing after
836 the closing double quote. If STRIPDQ is non-zero, unquoted double
837 quotes are stripped and the string is terminated by a null byte.
838 Backslashes between the embedded double quotes are processed. If STRIPDQ
839 is zero, an unquoted `"' terminates the string. */
841 string_extract_double_quoted (string
, sindex
, flags
)
849 char *temp
, *ret
; /* The new string we return. */
850 int pass_next
, backquote
, si
; /* State variables for the machine. */
855 slen
= strlen (string
+ *sindex
) + *sindex
;
856 send
= string
+ slen
;
858 stripdq
= (flags
& SX_STRIPDQ
);
860 pass_next
= backquote
= dquote
= 0;
861 temp
= (char *)xmalloc (1 + slen
- *sindex
);
865 while (c
= string
[i
])
867 /* Process a character that was quoted by a backslash. */
870 /* XXX - take another look at this in light of Interp 221 */
873 ``The backslash shall retain its special meaning as an escape
874 character only when followed by one of the characters:
877 If STRIPDQ is zero, we handle the double quotes here and let
878 expand_word_internal handle the rest. If STRIPDQ is non-zero,
879 we have already been through one round of backslash stripping,
880 and want to strip these backslashes only if DQUOTE is non-zero,
881 indicating that we are inside an embedded double-quoted string. */
883 /* If we are in an embedded quoted string, then don't strip
884 backslashes before characters for which the backslash
885 retains its special meaning, but remove backslashes in
886 front of other characters. If we are not in an
887 embedded quoted string, don't strip backslashes at all.
888 This mess is necessary because the string was already
889 surrounded by double quotes (and sh has some really weird
891 The returned string will be run through expansion as if
892 it were double-quoted. */
893 if ((stripdq
== 0 && c
!= '"') ||
894 (stripdq
&& ((dquote
&& (sh_syntaxtab
[c
] & CBSDQUOTE
)) || dquote
== 0)))
899 COPY_CHAR_I (temp
, j
, string
, send
, i
);
903 /* A backslash protects the next character. The code just above
904 handles preserving the backslash in front of any character but
913 /* Inside backquotes, ``the portion of the quoted string from the
914 initial backquote and the characters up to the next backquote
915 that is not preceded by a backslash, having escape characters
916 removed, defines that command''. */
934 /* Pass everything between `$(' and the matching `)' or a quoted
935 ${ ... } pair through according to the Posix.2 specification. */
936 if (c
== '$' && ((string
[i
+ 1] == LPAREN
) || (string
[i
+ 1] == LBRACE
)))
941 if (string
[i
+ 1] == LPAREN
)
942 ret
= extract_command_subst (string
, &si
, (flags
& SX_COMPLETE
));
944 ret
= extract_dollar_brace_string (string
, &si
, Q_DOUBLE_QUOTES
, 0);
947 temp
[j
++] = string
[i
+ 1];
949 /* Just paranoia; ret will not be 0 unless no_longjmp_on_fatal_error
951 if (ret
== 0 && no_longjmp_on_fatal_error
)
954 ret
= string
+ i
+ 2;
957 for (t
= 0; ret
[t
]; t
++, j
++)
959 temp
[j
] = string
[si
];
974 /* Add any character but a double quote to the quoted string we're
977 goto add_one_character
;
991 /* Point to after the closing quote. */
999 /* This should really be another option to string_extract_double_quoted. */
1001 skip_double_quoted (string
, slen
, sind
, flags
)
1009 int pass_next
, backquote
, si
;
1012 pass_next
= backquote
= 0;
1014 while (c
= string
[i
])
1019 ADVANCE_CHAR (string
, slen
, i
);
1032 ADVANCE_CHAR (string
, slen
, i
);
1041 else if (c
== '$' && ((string
[i
+ 1] == LPAREN
) || (string
[i
+ 1] == LBRACE
)))
1044 if (string
[i
+ 1] == LPAREN
)
1045 ret
= extract_command_subst (string
, &si
, SX_NOALLOC
|(flags
&SX_COMPLETE
));
1047 ret
= extract_dollar_brace_string (string
, &si
, Q_DOUBLE_QUOTES
, SX_NOALLOC
);
1049 /* These can consume the entire string if they are unterminated */
1050 CHECK_STRING_OVERRUN (i
, si
, slen
, c
);
1057 ADVANCE_CHAR (string
, slen
, i
);
1070 /* Extract the contents of STRING as if it is enclosed in single quotes.
1071 SINDEX, when passed in, is the offset of the character immediately
1072 following the opening single quote; on exit, SINDEX is left pointing after
1073 the closing single quote. */
1074 static inline char *
1075 string_extract_single_quoted (string
, sindex
)
1084 /* Don't need slen for ADVANCE_CHAR unless multibyte chars possible. */
1085 slen
= (MB_CUR_MAX
> 1) ? strlen (string
+ *sindex
) + *sindex
: 0;
1087 while (string
[i
] && string
[i
] != '\'')
1088 ADVANCE_CHAR (string
, slen
, i
);
1090 t
= substring (string
, *sindex
, i
);
1099 /* Skip over a single-quoted string. We overload the SX_COMPLETE flag to mean
1100 that we are splitting out words for completion and have encountered a $'...'
1101 string, which allows backslash-escaped single quotes. */
1103 skip_single_quoted (string
, slen
, sind
, flags
)
1113 while (string
[c
] && string
[c
] != '\'')
1115 if ((flags
& SX_COMPLETE
) && string
[c
] == '\\' && string
[c
+1] == '\'' && string
[c
+2])
1116 ADVANCE_CHAR (string
, slen
, c
);
1117 ADVANCE_CHAR (string
, slen
, c
);
1125 /* Just like string_extract, but doesn't hack backslashes or any of
1126 that other stuff. Obeys CTLESC quoting. Used to do splitting on $IFS. */
1128 string_extract_verbatim (string
, slen
, sindex
, charlist
, flags
)
1136 #if defined (HANDLE_MULTIBYTE)
1144 if ((flags
& SX_NOCTLESC
) && charlist
[0] == '\'' && charlist
[1] == '\0')
1146 temp
= string_extract_single_quoted (string
, sindex
);
1147 --*sindex
; /* leave *sindex at separator character */
1153 /* See how the MBLEN and ADVANCE_CHAR macros work to understand why we need
1154 this only if MB_CUR_MAX > 1. */
1155 slen
= (MB_CUR_MAX
> 1) ? strlen (string
+ *sindex
) + *sindex
: 1;
1157 #if defined (HANDLE_MULTIBYTE)
1158 clen
= strlen (charlist
);
1161 while (c
= string
[i
])
1163 #if defined (HANDLE_MULTIBYTE)
1166 if ((flags
& SX_NOCTLESC
) == 0 && c
== CTLESC
)
1171 /* Even if flags contains SX_NOCTLESC, we let CTLESC quoting CTLNUL
1172 through, to protect the CTLNULs from later calls to
1173 remove_quoted_nulls. */
1174 else if ((flags
& SX_NOESCCTLNUL
) == 0 && c
== CTLESC
&& string
[i
+1] == CTLNUL
)
1180 #if defined (HANDLE_MULTIBYTE)
1181 mblength
= MBLEN (string
+ i
, slen
- i
);
1185 mblength
= mbtowc (&wc
, string
+ i
, slen
- i
);
1186 if (MB_INVALIDCH (mblength
))
1188 if (MEMBER (c
, charlist
))
1196 len
= mbstowcs (wcharlist
, charlist
, 0);
1199 wcharlist
= (wchar_t *)xmalloc (sizeof (wchar_t) * (len
+ 1));
1200 mbstowcs (wcharlist
, charlist
, len
+ 1);
1203 if (wcschr (wcharlist
, wc
))
1209 if (MEMBER (c
, charlist
))
1212 ADVANCE_CHAR (string
, slen
, i
);
1215 #if defined (HANDLE_MULTIBYTE)
1219 temp
= substring (string
, *sindex
, i
);
1225 /* Extract the $( construct in STRING, and return a new string.
1226 Start extracting at (SINDEX) as if we had just seen "$(".
1227 Make (SINDEX) get the position of the matching ")". )
1228 XFLAGS is additional flags to pass to other extraction functions. */
1230 extract_command_subst (string
, sindex
, xflags
)
1237 if (string
[*sindex
] == LPAREN
|| (xflags
& SX_COMPLETE
))
1238 return (extract_delimited_string (string
, sindex
, "$(", "(", ")", xflags
|SX_COMMAND
)); /*)*/
1241 xflags
|= (no_longjmp_on_fatal_error
? SX_NOLONGJMP
: 0);
1242 ret
= xparse_dolparen (string
, string
+*sindex
, sindex
, xflags
);
1247 /* Extract the $[ construct in STRING, and return a new string. (])
1248 Start extracting at (SINDEX) as if we had just seen "$[".
1249 Make (SINDEX) get the position of the matching "]". */
1251 extract_arithmetic_subst (string
, sindex
)
1255 return (extract_delimited_string (string
, sindex
, "$[", "[", "]", 0)); /*]*/
1258 #if defined (PROCESS_SUBSTITUTION)
1259 /* Extract the <( or >( construct in STRING, and return a new string.
1260 Start extracting at (SINDEX) as if we had just seen "<(".
1261 Make (SINDEX) get the position of the matching ")". */ /*))*/
1263 extract_process_subst (string
, starter
, sindex
, xflags
)
1270 return (extract_delimited_string (string
, sindex
, starter
, "(", ")", SX_COMMAND
));
1272 xflags
|= (no_longjmp_on_fatal_error
? SX_NOLONGJMP
: 0);
1273 return (xparse_dolparen (string
, string
+*sindex
, sindex
, xflags
));
1276 #endif /* PROCESS_SUBSTITUTION */
1278 #if defined (ARRAY_VARS)
1279 /* This can be fooled by unquoted right parens in the passed string. If
1280 each caller verifies that the last character in STRING is a right paren,
1281 we don't even need to call extract_delimited_string. */
1283 extract_array_assignment_list (string
, sindex
)
1290 slen
= strlen (string
); /* ( */
1291 if (string
[slen
- 1] == ')')
1293 ret
= substring (string
, *sindex
, slen
- 1);
1301 /* Extract and create a new string from the contents of STRING, a
1302 character string delimited with OPENER and CLOSER. SINDEX is
1303 the address of an int describing the current offset in STRING;
1304 it should point to just after the first OPENER found. On exit,
1305 SINDEX gets the position of the last character of the matching CLOSER.
1306 If OPENER is more than a single character, ALT_OPENER, if non-null,
1307 contains a character string that can also match CLOSER and thus
1308 needs to be skipped. */
1310 extract_delimited_string (string
, sindex
, opener
, alt_opener
, closer
, flags
)
1313 char *opener
, *alt_opener
, *closer
;
1319 int pass_character
, nesting_level
, in_comment
;
1320 int len_closer
, len_opener
, len_alt_opener
;
1323 slen
= strlen (string
+ *sindex
) + *sindex
;
1324 len_opener
= STRLEN (opener
);
1325 len_alt_opener
= STRLEN (alt_opener
);
1326 len_closer
= STRLEN (closer
);
1328 pass_character
= in_comment
= 0;
1333 while (nesting_level
)
1337 /* If a recursive call or a call to ADVANCE_CHAR leaves the index beyond
1338 the end of the string, catch it and cut the loop. */
1342 c
= string
[i
= slen
];
1353 ADVANCE_CHAR (string
, slen
, i
);
1357 if (pass_character
) /* previous char was backslash */
1360 ADVANCE_CHAR (string
, slen
, i
);
1364 /* Not exactly right yet; should handle shell metacharacters and
1365 multibyte characters, too. See COMMENT_BEGIN define in parse.y */
1366 if ((flags
& SX_COMMAND
) && c
== '#' && (i
== 0 || string
[i
- 1] == '\n' || shellblank (string
[i
- 1])))
1369 ADVANCE_CHAR (string
, slen
, i
);
1373 if (c
== CTLESC
|| c
== '\\')
1380 /* Process a nested command substitution, but only if we're parsing an
1381 arithmetic substitution. */
1382 if ((flags
& SX_COMMAND
) && string
[i
] == '$' && string
[i
+1] == LPAREN
)
1385 t
= extract_command_subst (string
, &si
, flags
|SX_NOALLOC
);
1390 /* Process a nested OPENER. */
1391 if (STREQN (string
+ i
, opener
, len_opener
))
1393 si
= i
+ len_opener
;
1394 t
= extract_delimited_string (string
, &si
, opener
, alt_opener
, closer
, flags
|SX_NOALLOC
);
1399 /* Process a nested ALT_OPENER */
1400 if (len_alt_opener
&& STREQN (string
+ i
, alt_opener
, len_alt_opener
))
1402 si
= i
+ len_alt_opener
;
1403 t
= extract_delimited_string (string
, &si
, alt_opener
, alt_opener
, closer
, flags
|SX_NOALLOC
);
1408 /* If the current substring terminates the delimited string, decrement
1409 the nesting level. */
1410 if (STREQN (string
+ i
, closer
, len_closer
))
1412 i
+= len_closer
- 1; /* move to last byte of the closer */
1414 if (nesting_level
== 0)
1418 /* Pass old-style command substitution through verbatim. */
1422 t
= string_extract (string
, &si
, "`", flags
|SX_NOALLOC
);
1427 /* Pass single-quoted and double-quoted strings through verbatim. */
1428 if (c
== '\'' || c
== '"')
1431 i
= (c
== '\'') ? skip_single_quoted (string
, slen
, si
, 0)
1432 : skip_double_quoted (string
, slen
, si
, 0);
1436 /* move past this character, which was not special. */
1437 ADVANCE_CHAR (string
, slen
, i
);
1440 if (c
== 0 && nesting_level
)
1442 if (no_longjmp_on_fatal_error
== 0)
1444 last_command_exit_value
= EXECUTION_FAILURE
;
1445 report_error (_("bad substitution: no closing `%s' in %s"), closer
, string
);
1446 exp_jump_to_top_level (DISCARD
);
1451 return (char *)NULL
;
1455 si
= i
- *sindex
- len_closer
+ 1;
1456 if (flags
& SX_NOALLOC
)
1457 result
= (char *)NULL
;
1460 result
= (char *)xmalloc (1 + si
);
1461 strncpy (result
, string
+ *sindex
, si
);
1469 /* Extract a parameter expansion expression within ${ and } from STRING.
1470 Obey the Posix.2 rules for finding the ending `}': count braces while
1471 skipping over enclosed quoted strings and command substitutions.
1472 SINDEX is the address of an int describing the current offset in STRING;
1473 it should point to just after the first `{' found. On exit, SINDEX
1474 gets the position of the matching `}'. QUOTED is non-zero if this
1475 occurs inside double quotes. */
1476 /* XXX -- this is very similar to extract_delimited_string -- XXX */
1478 extract_dollar_brace_string (string
, sindex
, quoted
, flags
)
1480 int *sindex
, quoted
, flags
;
1484 int pass_character
, nesting_level
, si
, dolbrace_state
;
1490 slen
= strlen (string
+ *sindex
) + *sindex
;
1492 /* The handling of dolbrace_state needs to agree with the code in parse.y:
1493 parse_matched_pair(). The different initial value is to handle the
1494 case where this function is called to parse the word in
1495 ${param op word} (SX_WORD). */
1496 dolbrace_state
= (flags
& SX_WORD
) ? DOLBRACE_WORD
: DOLBRACE_PARAM
;
1497 if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && (flags
& SX_POSIXEXP
))
1498 dolbrace_state
= DOLBRACE_QUOTE
;
1501 while (c
= string
[i
])
1506 ADVANCE_CHAR (string
, slen
, i
);
1510 /* CTLESCs and backslashes quote the next character. */
1511 if (c
== CTLESC
|| c
== '\\')
1518 if (string
[i
] == '$' && string
[i
+1] == LBRACE
)
1528 if (nesting_level
== 0)
1534 /* Pass the contents of old-style command substitutions through
1539 t
= string_extract (string
, &si
, "`", flags
|SX_NOALLOC
);
1541 CHECK_STRING_OVERRUN (i
, si
, slen
, c
);
1547 /* Pass the contents of new-style command substitutions and
1548 arithmetic substitutions through verbatim. */
1549 if (string
[i
] == '$' && string
[i
+1] == LPAREN
)
1552 t
= extract_command_subst (string
, &si
, flags
|SX_NOALLOC
);
1557 /* Pass the contents of double-quoted strings through verbatim. */
1561 i
= skip_double_quoted (string
, slen
, si
, 0);
1562 /* skip_XXX_quoted leaves index one past close quote */
1568 /*itrace("extract_dollar_brace_string: c == single quote flags = %d quoted = %d dolbrace_state = %d", flags, quoted, dolbrace_state);*/
1569 if (posixly_correct
&& shell_compatibility_level
> 42 && dolbrace_state
!= DOLBRACE_QUOTE
&& (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)))
1570 ADVANCE_CHAR (string
, slen
, i
);
1574 i
= skip_single_quoted (string
, slen
, si
, 0);
1580 /* move past this character, which was not special. */
1581 ADVANCE_CHAR (string
, slen
, i
);
1583 /* This logic must agree with parse.y:parse_matched_pair, since they
1584 share the same defines. */
1585 if (dolbrace_state
== DOLBRACE_PARAM
&& c
== '%' && (i
- *sindex
) > 1)
1586 dolbrace_state
= DOLBRACE_QUOTE
;
1587 else if (dolbrace_state
== DOLBRACE_PARAM
&& c
== '#' && (i
- *sindex
) > 1)
1588 dolbrace_state
= DOLBRACE_QUOTE
;
1589 else if (dolbrace_state
== DOLBRACE_PARAM
&& c
== '/' && (i
- *sindex
) > 1)
1590 dolbrace_state
= DOLBRACE_QUOTE2
; /* XXX */
1591 else if (dolbrace_state
== DOLBRACE_PARAM
&& c
== '^' && (i
- *sindex
) > 1)
1592 dolbrace_state
= DOLBRACE_QUOTE
;
1593 else if (dolbrace_state
== DOLBRACE_PARAM
&& c
== ',' && (i
- *sindex
) > 1)
1594 dolbrace_state
= DOLBRACE_QUOTE
;
1595 /* This is intended to handle all of the [:]op expansions and the substring/
1596 length/pattern removal/pattern substitution expansions. */
1597 else if (dolbrace_state
== DOLBRACE_PARAM
&& strchr ("#%^,~:-=?+/", c
) != 0)
1598 dolbrace_state
= DOLBRACE_OP
;
1599 else if (dolbrace_state
== DOLBRACE_OP
&& strchr ("#%^,~:-=?+/", c
) == 0)
1600 dolbrace_state
= DOLBRACE_WORD
;
1603 if (c
== 0 && nesting_level
)
1605 if (no_longjmp_on_fatal_error
== 0)
1607 last_command_exit_value
= EXECUTION_FAILURE
;
1608 report_error (_("bad substitution: no closing `%s' in %s"), "}", string
);
1609 exp_jump_to_top_level (DISCARD
);
1614 return ((char *)NULL
);
1618 result
= (flags
& SX_NOALLOC
) ? (char *)NULL
: substring (string
, *sindex
, i
);
1624 /* Remove backslashes which are quoting backquotes from STRING. Modifies
1625 STRING, and returns a pointer to it. */
1627 de_backslash (string
)
1630 register size_t slen
;
1631 register int i
, j
, prev_i
;
1634 slen
= strlen (string
);
1637 /* Loop copying string[i] to string[j], i >= j. */
1640 if (string
[i
] == '\\' && (string
[i
+ 1] == '`' || string
[i
+ 1] == '\\' ||
1641 string
[i
+ 1] == '$'))
1644 ADVANCE_CHAR (string
, slen
, i
);
1646 do string
[j
++] = string
[prev_i
++]; while (prev_i
< i
);
1657 /* Replace instances of \! in a string with !. */
1659 unquote_bang (string
)
1663 register char *temp
;
1665 temp
= (char *)xmalloc (1 + strlen (string
));
1667 for (i
= 0, j
= 0; (temp
[j
] = string
[i
]); i
++, j
++)
1669 if (string
[i
] == '\\' && string
[i
+ 1] == '!')
1675 strcpy (string
, temp
);
1680 #define CQ_RETURN(x) do { no_longjmp_on_fatal_error = oldjmp; return (x); } while (0)
1682 /* This function assumes s[i] == open; returns with s[ret] == close; used to
1683 parse array subscripts. FLAGS & 1 means to not attempt to skip over
1684 matched pairs of quotes or backquotes, or skip word expansions; it is
1685 intended to be used after expansion has been performed and during final
1686 assignment parsing (see arrayfunc.c:assign_compound_array_list()). */
1688 skip_matched_pair (string
, start
, open
, close
, flags
)
1690 int start
, open
, close
, flags
;
1692 int i
, pass_next
, backq
, si
, c
, count
, oldjmp
;
1697 slen
= strlen (string
+ start
) + start
;
1698 oldjmp
= no_longjmp_on_fatal_error
;
1699 no_longjmp_on_fatal_error
= 1;
1701 i
= start
+ 1; /* skip over leading bracket */
1703 pass_next
= backq
= 0;
1704 ss
= (char *)string
;
1705 while (c
= string
[i
])
1712 ADVANCE_CHAR (string
, slen
, i
);
1725 ADVANCE_CHAR (string
, slen
, i
);
1728 else if ((flags
& 1) == 0 && c
== '`')
1734 else if ((flags
& 1) == 0 && c
== open
)
1740 else if (c
== close
)
1748 else if ((flags
& 1) == 0 && (c
== '\'' || c
== '"'))
1750 i
= (c
== '\'') ? skip_single_quoted (ss
, slen
, ++i
, 0)
1751 : skip_double_quoted (ss
, slen
, ++i
, 0);
1752 /* no increment, the skip functions increment past the closing quote. */
1754 else if ((flags
&1) == 0 && c
== '$' && (string
[i
+1] == LPAREN
|| string
[i
+1] == LBRACE
))
1757 if (string
[si
] == '\0')
1760 if (string
[i
+1] == LPAREN
)
1761 temp
= extract_delimited_string (ss
, &si
, "$(", "(", ")", SX_NOALLOC
|SX_COMMAND
); /* ) */
1763 temp
= extract_dollar_brace_string (ss
, &si
, 0, SX_NOALLOC
);
1765 CHECK_STRING_OVERRUN (i
, si
, slen
, c
);
1768 if (string
[i
] == '\0') /* don't increment i past EOS in loop */
1774 ADVANCE_CHAR (string
, slen
, i
);
1780 #if defined (ARRAY_VARS)
1782 skipsubscript (string
, start
, flags
)
1786 return (skip_matched_pair (string
, start
, '[', ']', flags
));
1790 /* Skip characters in STRING until we find a character in DELIMS, and return
1791 the index of that character. START is the index into string at which we
1792 begin. This is similar in spirit to strpbrk, but it returns an index into
1793 STRING and takes a starting index. This little piece of code knows quite
1794 a lot of shell syntax. It's very similar to skip_double_quoted and other
1795 functions of that ilk. */
1797 skip_to_delim (string
, start
, delims
, flags
)
1803 int i
, pass_next
, backq
, dquote
, si
, c
, oldjmp
;
1804 int invert
, skipquote
, skipcmd
, noprocsub
, completeflag
;
1805 int arithexp
, skipcol
;
1807 char *temp
, open
[3];
1810 slen
= strlen (string
+ start
) + start
;
1811 oldjmp
= no_longjmp_on_fatal_error
;
1812 if (flags
& SD_NOJMP
)
1813 no_longjmp_on_fatal_error
= 1;
1814 invert
= (flags
& SD_INVERT
);
1815 skipcmd
= (flags
& SD_NOSKIPCMD
) == 0;
1816 noprocsub
= (flags
& SD_NOPROCSUB
);
1817 completeflag
= (flags
& SD_COMPLETE
) ? SX_COMPLETE
: 0;
1819 arithexp
= (flags
& SD_ARITHEXP
);
1823 pass_next
= backq
= dquote
= 0;
1824 while (c
= string
[i
])
1826 /* If this is non-zero, we should not let quote characters be delimiters
1827 and the current character is a single or double quote. We should not
1828 test whether or not it's a delimiter until after we skip single- or
1829 double-quoted strings. */
1830 skipquote
= ((flags
& SD_NOQUOTEDELIM
) && (c
== '\'' || c
=='"'));
1836 ADVANCE_CHAR (string
, slen
, i
);
1849 ADVANCE_CHAR (string
, slen
, i
);
1858 else if (arithexp
&& skipcol
&& c
== ':')
1864 else if (arithexp
&& c
== '?')
1870 else if (skipquote
== 0 && invert
== 0 && member (c
, delims
))
1872 /* the usual case is to use skip_xxx_quoted, but we don't skip over double
1873 quoted strings when looking for the history expansion character as a
1875 /* special case for programmable completion which takes place before
1876 parser converts backslash-escaped single quotes between $'...' to
1877 `regular' single-quoted strings. */
1878 else if (completeflag
&& i
> 0 && string
[i
-1] == '$' && c
== '\'')
1879 i
= skip_single_quoted (string
, slen
, ++i
, SX_COMPLETE
);
1881 i
= skip_single_quoted (string
, slen
, ++i
, 0);
1883 i
= skip_double_quoted (string
, slen
, ++i
, completeflag
);
1884 else if (c
== LPAREN
&& arithexp
)
1887 if (string
[si
] == '\0')
1890 temp
= extract_delimited_string (string
, &si
, "(", "(", ")", SX_NOALLOC
); /* ) */
1892 if (string
[i
] == '\0') /* don't increment i past EOS in loop */
1897 else if (c
== '$' && ((skipcmd
&& string
[i
+1] == LPAREN
) || string
[i
+1] == LBRACE
))
1900 if (string
[si
] == '\0')
1903 if (string
[i
+1] == LPAREN
)
1904 temp
= extract_delimited_string (string
, &si
, "$(", "(", ")", SX_NOALLOC
|SX_COMMAND
); /* ) */
1906 temp
= extract_dollar_brace_string (string
, &si
, 0, SX_NOALLOC
);
1908 if (string
[i
] == '\0') /* don't increment i past EOS in loop */
1913 #if defined (PROCESS_SUBSTITUTION)
1914 else if (skipcmd
&& noprocsub
== 0 && (c
== '<' || c
== '>') && string
[i
+1] == LPAREN
)
1917 if (string
[si
] == '\0')
1920 temp
= extract_delimited_string (string
, &si
, (c
== '<') ? "<(" : ">(", "(", ")", SX_COMMAND
|SX_NOALLOC
); /* )) */
1922 temp
= extract_process_subst (string
, (c
== '<') ? "<(" : ">(", &si
, 0);
1923 free (temp
); /* XXX - not using SX_NOALLOC here yet */
1926 if (string
[i
] == '\0')
1931 #endif /* PROCESS_SUBSTITUTION */
1932 #if defined (EXTENDED_GLOB)
1933 else if ((flags
& SD_EXTGLOB
) && extended_glob
&& string
[i
+1] == LPAREN
&& member (c
, "?*+!@"))
1936 if (string
[si
] == '\0')
1942 temp
= extract_delimited_string (string
, &si
, open
, "(", ")", SX_NOALLOC
); /* ) */
1945 if (string
[i
] == '\0') /* don't increment i past EOS in loop */
1951 else if ((flags
& SD_GLOB
) && c
== LBRACK
)
1954 if (string
[si
] == '\0')
1957 temp
= extract_delimited_string (string
, &si
, "[", "[", "]", SX_NOALLOC
); /* ] */
1960 if (string
[i
] == '\0') /* don't increment i past EOS in loop */
1965 else if ((skipquote
|| invert
) && (member (c
, delims
) == 0))
1968 ADVANCE_CHAR (string
, slen
, i
);
1974 #if defined (BANG_HISTORY)
1975 /* Skip to the history expansion character (delims[0]), paying attention to
1976 quoted strings and command and process substitution. This is a stripped-
1977 down version of skip_to_delims. The essential difference is that this
1978 resets the quoting state when starting a command substitution */
1980 skip_to_histexp (string
, start
, delims
, flags
)
1986 int i
, pass_next
, backq
, dquote
, si
, c
, oldjmp
;
1987 int histexp_comsub
, histexp_backq
, old_dquote
;
1989 char *temp
, open
[3];
1992 slen
= strlen (string
+ start
) + start
;
1993 oldjmp
= no_longjmp_on_fatal_error
;
1994 if (flags
& SD_NOJMP
)
1995 no_longjmp_on_fatal_error
= 1;
1997 histexp_comsub
= histexp_backq
= old_dquote
= 0;
2000 pass_next
= backq
= dquote
= 0;
2001 while (c
= string
[i
])
2008 ADVANCE_CHAR (string
, slen
, i
);
2017 else if (backq
&& c
== '`')
2021 dquote
= old_dquote
;
2029 old_dquote
= dquote
; /* simple - one level for now */
2034 /* When in double quotes, act as if the double quote is a member of
2035 history_no_expand_chars, like the history library does */
2036 else if (dquote
&& c
== delims
[0] && string
[i
+1] == '"')
2041 else if (c
== delims
[0])
2043 /* the usual case is to use skip_xxx_quoted, but we don't skip over double
2044 quoted strings when looking for the history expansion character as a
2046 else if (dquote
&& c
== '\'')
2052 i
= skip_single_quoted (string
, slen
, ++i
, 0);
2053 /* The posixly_correct test makes posix-mode shells allow double quotes
2054 to quote the history expansion character */
2055 else if (posixly_correct
== 0 && c
== '"')
2057 dquote
= 1 - dquote
;
2062 i
= skip_double_quoted (string
, slen
, ++i
, 0);
2063 #if defined (PROCESS_SUBSTITUTION)
2064 else if ((c
== '$' || c
== '<' || c
== '>') && string
[i
+1] == LPAREN
&& string
[i
+2] != LPAREN
)
2066 else if (c
== '$' && string
[i
+1] == LPAREN
&& string
[i
+2] != LPAREN
)
2069 if (string
[i
+2] == '\0')
2073 old_dquote
= dquote
;
2076 else if (histexp_comsub
&& c
== RPAREN
)
2079 dquote
= old_dquote
;
2083 else if (backq
) /* placeholder */
2085 ADVANCE_CHAR (string
, slen
, i
);
2089 ADVANCE_CHAR (string
, slen
, i
);
2094 #endif /* BANG_HISTORY */
2096 #if defined (READLINE)
2097 /* Return 1 if the portion of STRING ending at EINDEX is quoted (there is
2098 an unclosed quoted string), or if the character at EINDEX is quoted
2099 by a backslash. NO_LONGJMP_ON_FATAL_ERROR is used to flag that the various
2100 single and double-quoted string parsing functions should not return an
2101 error if there are unclosed quotes or braces. The characters that this
2102 recognizes need to be the same as the contents of
2103 rl_completer_quote_characters. */
2106 char_is_quoted (string
, eindex
)
2110 int i
, pass_next
, c
, oldjmp
;
2114 slen
= strlen (string
);
2115 oldjmp
= no_longjmp_on_fatal_error
;
2116 no_longjmp_on_fatal_error
= 1;
2125 if (i
>= eindex
) /* XXX was if (i >= eindex - 1) */
2127 ADVANCE_CHAR (string
, slen
, i
);
2136 else if (c
== '$' && string
[i
+1] == '\'' && string
[i
+2])
2139 i
= skip_single_quoted (string
, slen
, i
, SX_COMPLETE
);
2143 else if (c
== '\'' || c
== '"')
2145 i
= (c
== '\'') ? skip_single_quoted (string
, slen
, ++i
, 0)
2146 : skip_double_quoted (string
, slen
, ++i
, SX_COMPLETE
);
2149 /* no increment, the skip_xxx functions go one past end */
2152 ADVANCE_CHAR (string
, slen
, i
);
2159 unclosed_pair (string
, eindex
, openstr
)
2164 int i
, pass_next
, openc
, olen
;
2168 slen
= strlen (string
);
2169 olen
= strlen (openstr
);
2170 i
= pass_next
= openc
= 0;
2176 if (i
>= eindex
) /* XXX was if (i >= eindex - 1) */
2178 ADVANCE_CHAR (string
, slen
, i
);
2181 else if (string
[i
] == '\\')
2187 else if (STREQN (string
+ i
, openstr
, olen
))
2192 /* XXX - may want to handle $'...' specially here */
2193 else if (string
[i
] == '\'' || string
[i
] == '"')
2195 i
= (string
[i
] == '\'') ? skip_single_quoted (string
, slen
, i
, 0)
2196 : skip_double_quoted (string
, slen
, i
, SX_COMPLETE
);
2201 ADVANCE_CHAR (string
, slen
, i
);
2206 /* Split STRING (length SLEN) at DELIMS, and return a WORD_LIST with the
2207 individual words. If DELIMS is NULL, the current value of $IFS is used
2208 to split the string, and the function follows the shell field splitting
2209 rules. SENTINEL is an index to look for. NWP, if non-NULL,
2210 gets the number of words in the returned list. CWP, if non-NULL, gets
2211 the index of the word containing SENTINEL. Non-whitespace chars in
2212 DELIMS delimit separate fields. */
2214 split_at_delims (string
, slen
, delims
, sentinel
, flags
, nwp
, cwp
)
2218 int sentinel
, flags
;
2221 int ts
, te
, i
, nw
, cw
, ifs_split
, dflags
;
2222 char *token
, *d
, *d2
;
2223 WORD_LIST
*ret
, *tl
;
2225 if (string
== 0 || *string
== '\0')
2231 return ((WORD_LIST
*)NULL
);
2234 d
= (delims
== 0) ? ifs_value
: delims
;
2235 ifs_split
= delims
== 0;
2237 /* Make d2 the non-whitespace characters in delims */
2242 #if defined (HANDLE_MULTIBYTE)
2243 size_t mblength
= 1;
2247 slength
= strlen (delims
);
2248 d2
= (char *)xmalloc (slength
+ 1);
2252 #if defined (HANDLE_MULTIBYTE)
2253 mbstate_t state_bak
;
2255 mblength
= MBRLEN (delims
+ i
, slength
, &state
);
2256 if (MB_INVALIDCH (mblength
))
2258 else if (mblength
> 1)
2260 memcpy (d2
+ ts
, delims
+ i
, mblength
);
2263 slength
-= mblength
;
2267 if (whitespace (delims
[i
]) == 0)
2268 d2
[ts
++] = delims
[i
];
2276 ret
= (WORD_LIST
*)NULL
;
2278 /* Remove sequences of whitespace characters at the start of the string, as
2279 long as those characters are delimiters. */
2280 for (i
= 0; member (string
[i
], d
) && spctabnl (string
[i
]); i
++)
2282 if (string
[i
] == '\0')
2291 dflags
= flags
|SD_NOJMP
;
2294 te
= skip_to_delim (string
, ts
, d
, dflags
);
2296 /* If we have a non-whitespace delimiter character, use it to make a
2297 separate field. This is just about what $IFS splitting does and
2298 is closer to the behavior of the shell parser. */
2299 if (ts
== te
&& d2
&& member (string
[ts
], d2
))
2302 /* If we're using IFS splitting, the non-whitespace delimiter char
2303 and any additional IFS whitespace delimits a field. */
2305 while (member (string
[te
], d
) && spctabnl (string
[te
]))
2308 while (member (string
[te
], d2
))
2312 token
= substring (string
, ts
, te
);
2314 ret
= add_string_to_list (token
, ret
);
2318 if (sentinel
>= ts
&& sentinel
<= te
)
2321 /* If the cursor is at whitespace just before word start, set the
2322 sentinel word to the current word. */
2323 if (cwp
&& cw
== -1 && sentinel
== ts
-1)
2326 /* If the cursor is at whitespace between two words, make a new, empty
2327 word, add it before (well, after, since the list is in reverse order)
2328 the word we just added, and set the current word to that one. */
2329 if (cwp
&& cw
== -1 && sentinel
< ts
)
2331 tl
= make_word_list (make_word (""), ret
->next
);
2337 if (string
[te
] == 0)
2341 while (member (string
[i
], d
) && (ifs_split
|| spctabnl(string
[i
])))
2350 /* Special case for SENTINEL at the end of STRING. If we haven't found
2351 the word containing SENTINEL yet, and the index we're looking for is at
2352 the end of STRING (or past the end of the previously-found token,
2353 possible if the end of the line is composed solely of IFS whitespace)
2354 add an additional null argument and set the current word pointer to that. */
2355 if (cwp
&& cw
== -1 && (sentinel
>= slen
|| sentinel
>= te
))
2357 if (whitespace (string
[sentinel
- 1]))
2360 ret
= add_string_to_list (token
, ret
);
2373 return (REVERSE_LIST (ret
, WORD_LIST
*));
2375 #endif /* READLINE */
2379 /* Extract the name of the variable to bind to from the assignment string. */
2381 assignment_name (string
)
2387 offset
= assignment (string
, 0);
2389 return (char *)NULL
;
2390 temp
= substring (string
, 0, offset
);
2395 /* **************************************************************** */
2397 /* Functions to convert strings to WORD_LISTs and vice versa */
2399 /* **************************************************************** */
2401 /* Return a single string of all the words in LIST. SEP is the separator
2402 to put between individual elements of LIST in the output string. */
2404 string_list_internal (list
, sep
)
2408 register WORD_LIST
*t
;
2410 size_t word_len
, sep_len
, result_size
;
2413 return ((char *)NULL
);
2415 /* Short-circuit quickly if we don't need to separate anything. */
2416 if (list
->next
== 0)
2417 return (savestring (list
->word
->word
));
2419 /* This is nearly always called with either sep[0] == 0 or sep[1] == 0. */
2420 sep_len
= STRLEN (sep
);
2423 for (t
= list
; t
; t
= t
->next
)
2426 result_size
+= sep_len
;
2427 result_size
+= strlen (t
->word
->word
);
2430 r
= result
= (char *)xmalloc (result_size
+ 1);
2432 for (t
= list
; t
; t
= t
->next
)
2434 if (t
!= list
&& sep_len
)
2438 FASTCOPY (sep
, r
, sep_len
);
2445 word_len
= strlen (t
->word
->word
);
2446 FASTCOPY (t
->word
->word
, r
, word_len
);
2454 /* Return a single string of all the words present in LIST, separating
2455 each word with a space. */
2460 return (string_list_internal (list
, " "));
2463 /* An external interface that can be used by the rest of the shell to
2464 obtain a string containing the first character in $IFS. Handles all
2465 the multibyte complications. If LENP is non-null, it is set to the
2466 length of the returned string. */
2468 ifs_firstchar (lenp
)
2474 ret
= xmalloc (MB_LEN_MAX
+ 1);
2475 #if defined (HANDLE_MULTIBYTE)
2476 if (ifs_firstc_len
== 1)
2478 ret
[0] = ifs_firstc
[0];
2480 len
= ret
[0] ? 1 : 0;
2484 memcpy (ret
, ifs_firstc
, ifs_firstc_len
);
2485 ret
[len
= ifs_firstc_len
] = '\0';
2488 ret
[0] = ifs_firstc
;
2490 len
= ret
[0] ? 0 : 1;
2499 /* Return a single string of all the words present in LIST, obeying the
2500 quoting rules for "$*", to wit: (P1003.2, draft 11, 3.5.2) "If the
2501 expansion [of $*] appears within a double quoted string, it expands
2502 to a single field with the value of each parameter separated by the
2503 first character of the IFS variable, or by a <space> if IFS is unset." */
2505 string_list_dollar_star (list
)
2509 #if defined (HANDLE_MULTIBYTE)
2510 # if defined (__GNUC__)
2511 char sep
[MB_CUR_MAX
+ 1];
2519 #if defined (HANDLE_MULTIBYTE)
2520 # if !defined (__GNUC__)
2521 sep
= (char *)xmalloc (MB_CUR_MAX
+ 1);
2522 # endif /* !__GNUC__ */
2523 if (ifs_firstc_len
== 1)
2525 sep
[0] = ifs_firstc
[0];
2530 memcpy (sep
, ifs_firstc
, ifs_firstc_len
);
2531 sep
[ifs_firstc_len
] = '\0';
2534 sep
[0] = ifs_firstc
;
2538 ret
= string_list_internal (list
, sep
);
2539 #if defined (HANDLE_MULTIBYTE) && !defined (__GNUC__)
2545 /* Turn $@ into a string. If (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
2546 is non-zero, the $@ appears within double quotes, and we should quote
2547 the list before converting it into a string. If IFS is unset, and the
2548 word is not quoted, we just need to quote CTLESC and CTLNUL characters
2549 in the words in the list, because the default value of $IFS is
2550 <space><tab><newline>, IFS characters in the words in the list should
2551 also be split. If IFS is null, and the word is not quoted, we need
2552 to quote the words in the list to preserve the positional parameters
2554 Valid values for the FLAGS argument are the PF_ flags in command.h,
2555 the only one we care about is PF_ASSIGNRHS. $@ is supposed to expand
2556 to the positional parameters separated by spaces no matter what IFS is
2557 set to if in a context where word splitting is not performed. The only
2558 one that we didn't handle before is assignment statement arguments to
2559 declaration builtins like `declare'. */
2561 string_list_dollar_at (list
, quoted
, flags
)
2567 #if defined (HANDLE_MULTIBYTE)
2568 # if defined (__GNUC__)
2569 char sep
[MB_CUR_MAX
+ 1];
2572 # endif /* !__GNUC__ */
2578 /* XXX this could just be ifs = ifs_value; */
2579 ifs
= ifs_var
? value_cell (ifs_var
) : (char *)0;
2581 #if defined (HANDLE_MULTIBYTE)
2582 # if !defined (__GNUC__)
2583 sep
= (char *)xmalloc (MB_CUR_MAX
+ 1);
2584 # endif /* !__GNUC__ */
2585 /* XXX - bash-4.4/bash-5.0 testing PF_ASSIGNRHS */
2586 if (flags
& PF_ASSIGNRHS
)
2591 else if (ifs
&& *ifs
)
2593 if (ifs_firstc_len
== 1)
2595 sep
[0] = ifs_firstc
[0];
2600 memcpy (sep
, ifs_firstc
, ifs_firstc_len
);
2601 sep
[ifs_firstc_len
] = '\0';
2610 /* XXX - bash-4.4/bash-5.0 test PF_ASSIGNRHS */
2611 sep
[0] = ((flags
& PF_ASSIGNRHS
) || ifs
== 0 || *ifs
== 0) ? ' ' : *ifs
;
2615 /* XXX -- why call quote_list if ifs == 0? we can get away without doing
2616 it now that quote_escapes quotes spaces */
2617 tlist
= (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
|Q_PATQUOTE
))
2619 : list_quote_escapes (list
);
2621 ret
= string_list_internal (tlist
, sep
);
2622 #if defined (HANDLE_MULTIBYTE) && !defined (__GNUC__)
2628 /* Turn the positional parameters into a string, understanding quoting and
2629 the various subtleties of using the first character of $IFS as the
2630 separator. Calls string_list_dollar_at, string_list_dollar_star, and
2631 string_list as appropriate. */
2633 string_list_pos_params (pchar
, list
, quoted
)
2641 if (pchar
== '*' && (quoted
& Q_DOUBLE_QUOTES
))
2643 tlist
= quote_list (list
);
2644 word_list_remove_quoted_nulls (tlist
);
2645 ret
= string_list_dollar_star (tlist
);
2647 else if (pchar
== '*' && (quoted
& Q_HERE_DOCUMENT
))
2649 tlist
= quote_list (list
);
2650 word_list_remove_quoted_nulls (tlist
);
2651 ret
= string_list (tlist
);
2653 else if (pchar
== '*')
2655 /* Even when unquoted, string_list_dollar_star does the right thing
2656 making sure that the first character of $IFS is used as the
2658 ret
= string_list_dollar_star (list
);
2660 else if (pchar
== '@' && (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)))
2661 /* We use string_list_dollar_at, but only if the string is quoted, since
2662 that quotes the escapes if it's not, which we don't want. We could
2663 use string_list (the old code did), but that doesn't do the right
2664 thing if the first character of $IFS is not a space. We use
2665 string_list_dollar_star if the string is unquoted so we make sure that
2666 the elements of $@ are separated by the first character of $IFS for
2668 ret
= string_list_dollar_at (list
, quoted
, 0);
2669 else if (pchar
== '@')
2670 ret
= string_list_dollar_star (list
);
2672 ret
= string_list ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) ? quote_list (list
) : list
);
2677 /* Return the list of words present in STRING. Separate the string into
2678 words at any of the characters found in SEPARATORS. If QUOTED is
2679 non-zero then word in the list will have its quoted flag set, otherwise
2680 the quoted flag is left as make_word () deemed fit.
2682 This obeys the P1003.2 word splitting semantics. If `separators' is
2683 exactly <space><tab><newline>, then the splitting algorithm is that of
2684 the Bourne shell, which treats any sequence of characters from `separators'
2685 as a delimiter. If IFS is unset, which results in `separators' being set
2686 to "", no splitting occurs. If separators has some other value, the
2687 following rules are applied (`IFS white space' means zero or more
2688 occurrences of <space>, <tab>, or <newline>, as long as those characters
2689 are in `separators'):
2691 1) IFS white space is ignored at the start and the end of the
2693 2) Each occurrence of a character in `separators' that is not
2694 IFS white space, along with any adjacent occurrences of
2695 IFS white space delimits a field.
2696 3) Any nonzero-length sequence of IFS white space delimits a field.
2699 /* BEWARE! list_string strips null arguments. Don't call it twice and
2700 expect to have "" preserved! */
2702 /* This performs word splitting and quoted null character removal on
2705 (((separators)[0]) ? ((separators)[1] ? isifs(c) \
2706 : (c) == (separators)[0]) \
2710 list_string (string
, separators
, quoted
)
2711 register char *string
, *separators
;
2716 char *current_word
, *s
;
2717 int sindex
, sh_style_split
, whitesep
, xflags
;
2720 if (!string
|| !*string
)
2721 return ((WORD_LIST
*)NULL
);
2723 sh_style_split
= separators
&& separators
[0] == ' ' &&
2724 separators
[1] == '\t' &&
2725 separators
[2] == '\n' &&
2726 separators
[3] == '\0';
2727 for (xflags
= 0, s
= ifs_value
; s
&& *s
; s
++)
2729 if (*s
== CTLESC
) xflags
|= SX_NOCTLESC
;
2730 else if (*s
== CTLNUL
) xflags
|= SX_NOESCCTLNUL
;
2734 /* Remove sequences of whitespace at the beginning of STRING, as
2735 long as those characters appear in IFS. Do not do this if
2736 STRING is quoted or if there are no separator characters. */
2737 if (!quoted
|| !separators
|| !*separators
)
2739 for (s
= string
; *s
&& spctabnl (*s
) && issep (*s
); s
++);
2742 return ((WORD_LIST
*)NULL
);
2747 /* OK, now STRING points to a word that does not begin with white space.
2748 The splitting algorithm is:
2749 extract a word, stopping at a separator
2750 skip sequences of spc, tab, or nl as long as they are separators
2751 This obeys the field splitting rules in Posix.2. */
2752 slen
= (MB_CUR_MAX
> 1) ? STRLEN (string
) : 1;
2753 for (result
= (WORD_LIST
*)NULL
, sindex
= 0; string
[sindex
]; )
2755 /* Don't need string length in ADVANCE_CHAR or string_extract_verbatim
2756 unless multibyte chars are possible. */
2757 current_word
= string_extract_verbatim (string
, slen
, &sindex
, separators
, xflags
);
2758 if (current_word
== 0)
2761 /* If we have a quoted empty string, add a quoted null argument. We
2762 want to preserve the quoted null character iff this is a quoted
2763 empty string; otherwise the quoted null characters are removed
2765 if (QUOTED_NULL (current_word
))
2767 t
= alloc_word_desc ();
2768 t
->word
= make_quoted_char ('\0');
2769 t
->flags
|= W_QUOTED
|W_HASQUOTEDNULL
;
2770 result
= make_word_list (t
, result
);
2772 else if (current_word
[0] != '\0')
2774 /* If we have something, then add it regardless. However,
2775 perform quoted null character removal on the current word. */
2776 remove_quoted_nulls (current_word
);
2777 result
= add_string_to_list (current_word
, result
);
2778 result
->word
->flags
&= ~W_HASQUOTEDNULL
; /* just to be sure */
2779 if (quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
))
2780 result
->word
->flags
|= W_QUOTED
;
2783 /* If we're not doing sequences of separators in the traditional
2784 Bourne shell style, then add a quoted null argument. */
2785 else if (!sh_style_split
&& !spctabnl (string
[sindex
]))
2787 t
= alloc_word_desc ();
2788 t
->word
= make_quoted_char ('\0');
2789 t
->flags
|= W_QUOTED
|W_HASQUOTEDNULL
;
2790 result
= make_word_list (t
, result
);
2793 free (current_word
);
2795 /* Note whether or not the separator is IFS whitespace, used later. */
2796 whitesep
= string
[sindex
] && spctabnl (string
[sindex
]);
2798 /* Move past the current separator character. */
2802 ADVANCE_CHAR (string
, slen
, sindex
);
2805 /* Now skip sequences of space, tab, or newline characters if they are
2806 in the list of separators. */
2807 while (string
[sindex
] && spctabnl (string
[sindex
]) && issep (string
[sindex
]))
2810 /* If the first separator was IFS whitespace and the current character
2811 is a non-whitespace IFS character, it should be part of the current
2812 field delimiter, not a separate delimiter that would result in an
2813 empty field. Look at POSIX.2, 3.6.5, (3)(b). */
2814 if (string
[sindex
] && whitesep
&& issep (string
[sindex
]) && !spctabnl (string
[sindex
]))
2817 /* An IFS character that is not IFS white space, along with any
2818 adjacent IFS white space, shall delimit a field. (SUSv3) */
2819 while (string
[sindex
] && spctabnl (string
[sindex
]) && isifs (string
[sindex
]))
2823 return (REVERSE_LIST (result
, WORD_LIST
*));
2826 /* Parse a single word from STRING, using SEPARATORS to separate fields.
2827 ENDPTR is set to the first character after the word. This is used by
2830 This is never called with SEPARATORS != $IFS, and takes advantage of that.
2832 XXX - this function is very similar to list_string; they should be
2835 #define islocalsep(c) (local_cmap[(unsigned char)(c)] != 0)
2838 get_word_from_string (stringp
, separators
, endptr
)
2839 char **stringp
, *separators
, **endptr
;
2843 int sindex
, sh_style_split
, whitesep
, xflags
;
2844 unsigned char local_cmap
[UCHAR_MAX
+1]; /* really only need single-byte chars here */
2847 if (!stringp
|| !*stringp
|| !**stringp
)
2848 return ((char *)NULL
);
2850 sh_style_split
= separators
&& separators
[0] == ' ' &&
2851 separators
[1] == '\t' &&
2852 separators
[2] == '\n' &&
2853 separators
[3] == '\0';
2854 memset (local_cmap
, '\0', sizeof (local_cmap
));
2855 for (xflags
= 0, s
= separators
; s
&& *s
; s
++)
2857 if (*s
== CTLESC
) xflags
|= SX_NOCTLESC
;
2858 if (*s
== CTLNUL
) xflags
|= SX_NOESCCTLNUL
;
2859 local_cmap
[(unsigned char)*s
] = 1; /* local charmap of separators */
2865 /* Remove sequences of whitespace at the beginning of STRING, as
2866 long as those characters appear in SEPARATORS. This happens if
2867 SEPARATORS == $' \t\n' or if IFS is unset. */
2868 if (sh_style_split
|| separators
== 0)
2870 for (; *s
&& spctabnl (*s
) && islocalsep (*s
); s
++);
2872 /* If the string is nothing but whitespace, update it and return. */
2878 return ((char *)NULL
);
2882 /* OK, S points to a word that does not begin with white space.
2883 Now extract a word, stopping at a separator, save a pointer to
2884 the first character after the word, then skip sequences of spc,
2885 tab, or nl as long as they are separators.
2887 This obeys the field splitting rules in Posix.2. */
2889 /* Don't need string length in ADVANCE_CHAR unless multibyte chars are
2890 possible, but need it in string_extract_verbatim for bounds checking */
2892 current_word
= string_extract_verbatim (s
, slen
, &sindex
, separators
, xflags
);
2894 /* Set ENDPTR to the first character after the end of the word. */
2896 *endptr
= s
+ sindex
;
2898 /* Note whether or not the separator is IFS whitespace, used later. */
2899 whitesep
= s
[sindex
] && spctabnl (s
[sindex
]);
2901 /* Move past the current separator character. */
2905 ADVANCE_CHAR (s
, slen
, sindex
);
2908 /* Now skip sequences of space, tab, or newline characters if they are
2909 in the list of separators. */
2910 while (s
[sindex
] && spctabnl (s
[sindex
]) && islocalsep (s
[sindex
]))
2913 /* If the first separator was IFS whitespace and the current character is
2914 a non-whitespace IFS character, it should be part of the current field
2915 delimiter, not a separate delimiter that would result in an empty field.
2916 Look at POSIX.2, 3.6.5, (3)(b). */
2917 if (s
[sindex
] && whitesep
&& islocalsep (s
[sindex
]) && !spctabnl (s
[sindex
]))
2920 /* An IFS character that is not IFS white space, along with any adjacent
2921 IFS white space, shall delimit a field. */
2922 while (s
[sindex
] && spctabnl (s
[sindex
]) && islocalsep(s
[sindex
]))
2926 /* Update STRING to point to the next field. */
2927 *stringp
= s
+ sindex
;
2928 return (current_word
);
2931 /* Remove IFS white space at the end of STRING. Start at the end
2932 of the string and walk backwards until the beginning of the string
2933 or we find a character that's not IFS white space and not CTLESC.
2934 Only let CTLESC escape a white space character if SAW_ESCAPE is
2937 strip_trailing_ifs_whitespace (string
, separators
, saw_escape
)
2938 char *string
, *separators
;
2943 s
= string
+ STRLEN (string
) - 1;
2944 while (s
> string
&& ((spctabnl (*s
) && isifs (*s
)) ||
2945 (saw_escape
&& *s
== CTLESC
&& spctabnl (s
[1]))))
2953 /* Split STRING into words at whitespace. Obeys shell-style quoting with
2954 backslashes, single and double quotes. */
2956 list_string_with_quotes (string
)
2962 int c
, i
, tokstart
, len
;
2964 for (s
= string
; s
&& *s
&& spctabnl (*s
); s
++)
2966 if (s
== 0 || *s
== 0)
2967 return ((WORD_LIST
*)NULL
);
2971 list
= (WORD_LIST
*)NULL
;
2982 i
= skip_single_quoted (s
, s_len
, ++i
, 0);
2984 i
= skip_double_quoted (s
, s_len
, ++i
, 0);
2985 else if (c
== 0 || spctabnl (c
))
2987 /* We have found the end of a token. Make a word out of it and
2988 add it to the word list. */
2989 token
= substring (s
, tokstart
, i
);
2990 list
= add_string_to_list (token
, list
);
2992 while (spctabnl (s
[i
]))
3000 i
++; /* normal character */
3002 return (REVERSE_LIST (list
, WORD_LIST
*));
3006 /********************************************************/
3008 /* Functions to perform assignment statements */
3010 /********************************************************/
3012 #if defined (ARRAY_VARS)
3014 do_compound_assignment (name
, value
, flags
)
3019 int mklocal
, mkassoc
, mkglobal
;
3022 mklocal
= flags
& ASS_MKLOCAL
;
3023 mkassoc
= flags
& ASS_MKASSOC
;
3024 mkglobal
= flags
& ASS_MKGLOBAL
;
3026 if (mklocal
&& variable_context
)
3028 v
= find_variable (name
);
3029 if (v
&& ((readonly_p (v
) && (flags
& ASS_FORCE
) == 0) || noassign_p (v
)))
3031 if (v
&& readonly_p (v
))
3032 err_readonly (name
);
3033 return (v
); /* XXX */
3035 list
= expand_compound_array_assignment (v
, value
, flags
);
3037 v
= make_local_assoc_variable (name
);
3038 else if (v
== 0 || (array_p (v
) == 0 && assoc_p (v
) == 0) || v
->context
!= variable_context
)
3039 v
= make_local_array_variable (name
, 0);
3041 assign_compound_array_list (v
, list
, flags
);
3043 dispose_words (list
);
3045 /* In a function but forcing assignment in global context */
3046 else if (mkglobal
&& variable_context
)
3048 v
= find_global_variable (name
);
3049 if (v
&& ((readonly_p (v
) && (flags
& ASS_FORCE
) == 0) || noassign_p (v
)))
3051 if (v
&& readonly_p (v
))
3052 err_readonly (name
);
3053 return (v
); /* XXX */
3055 list
= expand_compound_array_assignment (v
, value
, flags
);
3056 if (v
== 0 && mkassoc
)
3057 v
= make_new_assoc_variable (name
);
3058 else if (v
&& mkassoc
&& assoc_p (v
) == 0)
3059 v
= convert_var_to_assoc (v
);
3061 v
= make_new_array_variable (name
);
3062 else if (v
&& mkassoc
== 0 && array_p (v
) == 0)
3063 v
= convert_var_to_array (v
);
3065 assign_compound_array_list (v
, list
, flags
);
3067 dispose_words (list
);
3071 v
= assign_array_from_string (name
, value
, flags
);
3072 if (v
&& ((readonly_p (v
) && (flags
& ASS_FORCE
) == 0) || noassign_p (v
)))
3074 if (v
&& readonly_p (v
))
3075 err_readonly (name
);
3076 return (v
); /* XXX */
3084 /* Given STRING, an assignment string, get the value of the right side
3085 of the `=', and bind it to the left side. If EXPAND is true, then
3086 perform parameter expansion, command substitution, and arithmetic
3087 expansion on the right-hand side. Perform tilde expansion in any
3088 case. Do not perform word splitting on the result of expansion. */
3090 do_assignment_internal (word
, expand
)
3091 const WORD_DESC
*word
;
3094 int offset
, appendop
, assign_list
, aflags
, retval
;
3095 char *name
, *value
, *temp
;
3097 #if defined (ARRAY_VARS)
3103 if (word
== 0 || word
->word
== 0)
3106 appendop
= assign_list
= aflags
= 0;
3107 string
= word
->word
;
3108 offset
= assignment (string
, 0);
3109 name
= savestring (string
);
3110 value
= (char *)NULL
;
3112 if (name
[offset
] == '=')
3114 if (name
[offset
- 1] == '+')
3117 name
[offset
- 1] = '\0';
3120 name
[offset
] = 0; /* might need this set later */
3121 temp
= name
+ offset
+ 1;
3123 #if defined (ARRAY_VARS)
3124 if (expand
&& (word
->flags
& W_COMPASSIGN
))
3126 assign_list
= ni
= 1;
3127 value
= extract_array_assignment_list (temp
, &ni
);
3131 if (expand
&& temp
[0])
3132 value
= expand_string_if_necessary (temp
, 0, expand_string_assignment
);
3134 value
= savestring (temp
);
3139 value
= (char *)xmalloc (1);
3143 if (echo_command_at_execute
)
3146 name
[offset
- 1] = '+';
3147 xtrace_print_assignment (name
, value
, assign_list
, 1);
3149 name
[offset
- 1] = '\0';
3152 #define ASSIGN_RETURN(r) do { FREE (value); free (name); return (r); } while (0)
3155 aflags
|= ASS_APPEND
;
3157 #if defined (ARRAY_VARS)
3158 if (t
= mbschr (name
, '[')) /*]*/
3162 report_error (_("%s: cannot assign list to array member"), name
);
3165 entry
= assign_array_element (name
, value
, aflags
);
3169 else if (assign_list
)
3171 if ((word
->flags
& W_ASSIGNARG
) && (word
->flags
& W_ASSNGLOBAL
) == 0)
3172 aflags
|= ASS_MKLOCAL
;
3173 if ((word
->flags
& W_ASSIGNARG
) && (word
->flags
& W_ASSNGLOBAL
))
3174 aflags
|= ASS_MKGLOBAL
;
3175 if (word
->flags
& W_ASSIGNASSOC
)
3176 aflags
|= ASS_MKASSOC
;
3177 entry
= do_compound_assignment (name
, value
, aflags
);
3180 #endif /* ARRAY_VARS */
3181 entry
= bind_variable (name
, value
, aflags
);
3183 stupidly_hack_special_variables (name
);
3185 /* Return 1 if the assignment seems to have been performed correctly. */
3186 if (entry
== 0 || readonly_p (entry
))
3187 retval
= 0; /* assignment failure */
3188 else if (noassign_p (entry
))
3190 last_command_exit_value
= EXECUTION_FAILURE
;
3191 retval
= 1; /* error status, but not assignment failure */
3196 if (entry
&& retval
!= 0 && noassign_p (entry
) == 0)
3197 VUNSETATTR (entry
, att_invisible
);
3199 ASSIGN_RETURN (retval
);
3202 /* Perform the assignment statement in STRING, and expand the
3203 right side by doing tilde, command and parameter expansion. */
3205 do_assignment (string
)
3210 td
.flags
= W_ASSIGNMENT
;
3213 return do_assignment_internal (&td
, 1);
3217 do_word_assignment (word
, flags
)
3221 return do_assignment_internal (word
, 1);
3224 /* Given STRING, an assignment string, get the value of the right side
3225 of the `=', and bind it to the left side. Do not perform any word
3226 expansions on the right hand side. */
3228 do_assignment_no_expand (string
)
3233 td
.flags
= W_ASSIGNMENT
;
3236 return (do_assignment_internal (&td
, 0));
3239 /***************************************************
3241 * Functions to manage the positional parameters *
3243 ***************************************************/
3245 /* Return the word list that corresponds to `$*'. */
3247 list_rest_of_args ()
3249 register WORD_LIST
*list
, *args
;
3252 /* Break out of the loop as soon as one of the dollar variables is null. */
3253 for (i
= 1, list
= (WORD_LIST
*)NULL
; i
< 10 && dollar_vars
[i
]; i
++)
3254 list
= make_word_list (make_bare_word (dollar_vars
[i
]), list
);
3256 for (args
= rest_of_args
; args
; args
= args
->next
)
3257 list
= make_word_list (make_bare_word (args
->word
->word
), list
);
3259 return (REVERSE_LIST (list
, WORD_LIST
*));
3265 register WORD_LIST
*list
;
3268 for (n
= 0; n
< 9 && dollar_vars
[n
+1]; n
++)
3270 for (list
= rest_of_args
; list
; list
= list
->next
)
3275 /* Return the value of a positional parameter. This handles values > 10. */
3277 get_dollar_var_value (ind
)
3284 temp
= dollar_vars
[ind
] ? savestring (dollar_vars
[ind
]) : (char *)NULL
;
3285 else /* We want something like ${11} */
3288 for (p
= rest_of_args
; p
&& ind
--; p
= p
->next
)
3290 temp
= p
? savestring (p
->word
->word
) : (char *)NULL
;
3295 /* Make a single large string out of the dollar digit variables,
3296 and the rest_of_args. If DOLLAR_STAR is 1, then obey the special
3297 case of "$*" with respect to IFS. */
3299 string_rest_of_args (dollar_star
)
3302 register WORD_LIST
*list
;
3305 list
= list_rest_of_args ();
3306 string
= dollar_star
? string_list_dollar_star (list
) : string_list (list
);
3307 dispose_words (list
);
3311 /* Return a string containing the positional parameters from START to
3312 END, inclusive. If STRING[0] == '*', we obey the rules for $*,
3313 which only makes a difference if QUOTED is non-zero. If QUOTED includes
3314 Q_HERE_DOCUMENT or Q_DOUBLE_QUOTES, this returns a quoted list, otherwise
3315 no quoting chars are added. */
3317 pos_params (string
, start
, end
, quoted
)
3319 int start
, end
, quoted
;
3321 WORD_LIST
*save
, *params
, *h
, *t
;
3325 /* see if we can short-circuit. if start == end, we want 0 parameters. */
3327 return ((char *)NULL
);
3329 save
= params
= list_rest_of_args ();
3330 if (save
== 0 && start
> 0)
3331 return ((char *)NULL
);
3333 if (start
== 0) /* handle ${@:0[:x]} specially */
3335 t
= make_word_list (make_word (dollar_vars
[0]), params
);
3339 for (i
= start
? 1 : 0; params
&& i
< start
; i
++)
3340 params
= params
->next
;
3343 dispose_words (save
);
3344 return ((char *)NULL
);
3346 for (h
= t
= params
; params
&& i
< end
; i
++)
3349 params
= params
->next
;
3352 t
->next
= (WORD_LIST
*)NULL
;
3354 ret
= string_list_pos_params (string
[0], h
, quoted
);
3359 dispose_words (save
);
3363 /******************************************************************/
3365 /* Functions to expand strings to strings or WORD_LISTs */
3367 /******************************************************************/
3369 #if defined (PROCESS_SUBSTITUTION)
3370 #define EXP_CHAR(s) (s == '$' || s == '`' || s == '<' || s == '>' || s == CTLESC || s == '~')
3372 #define EXP_CHAR(s) (s == '$' || s == '`' || s == CTLESC || s == '~')
3375 /* If there are any characters in STRING that require full expansion,
3376 then call FUNC to expand STRING; otherwise just perform quote
3377 removal if necessary. This returns a new string. */
3379 expand_string_if_necessary (string
, quoted
, func
)
3390 /* Don't need string length for ADVANCE_CHAR unless multibyte chars possible. */
3391 slen
= (MB_CUR_MAX
> 1) ? strlen (string
) : 0;
3395 if (EXP_CHAR (string
[i
]))
3397 else if (string
[i
] == '\'' || string
[i
] == '\\' || string
[i
] == '"')
3399 ADVANCE_CHAR (string
, slen
, i
);
3404 list
= (*func
) (string
, quoted
);
3407 ret
= string_list (list
);
3408 dispose_words (list
);
3413 else if (saw_quote
&& ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) == 0))
3414 ret
= string_quote_removal (string
, quoted
);
3416 ret
= savestring (string
);
3421 static inline char *
3422 expand_string_to_string_internal (string
, quoted
, func
)
3430 if (string
== 0 || *string
== '\0')
3431 return ((char *)NULL
);
3433 list
= (*func
) (string
, quoted
);
3436 ret
= string_list (list
);
3437 dispose_words (list
);
3446 expand_string_to_string (string
, quoted
)
3450 return (expand_string_to_string_internal (string
, quoted
, expand_string
));
3454 expand_string_unsplit_to_string (string
, quoted
)
3458 return (expand_string_to_string_internal (string
, quoted
, expand_string_unsplit
));
3462 expand_assignment_string_to_string (string
, quoted
)
3466 return (expand_string_to_string_internal (string
, quoted
, expand_string_assignment
));
3470 expand_arith_string (string
, quoted
)
3475 WORD_LIST
*list
, *tlist
;
3481 /* Don't need string length for ADVANCE_CHAR unless multibyte chars possible. */
3482 slen
= (MB_CUR_MAX
> 1) ? strlen (string
) : 0;
3486 if (EXP_CHAR (string
[i
]))
3488 else if (string
[i
] == '\'' || string
[i
] == '\\' || string
[i
] == '"')
3490 ADVANCE_CHAR (string
, slen
, i
);
3495 /* This is expanded version of expand_string_internal as it's called by
3496 expand_string_leave_quoted */
3497 td
.flags
= W_NOPROCSUB
; /* don't want process substitution */
3498 td
.word
= savestring (string
);
3499 list
= call_expand_word_internal (&td
, quoted
, 0, (int *)NULL
, (int *)NULL
);
3500 /* This takes care of the calls from expand_string_leave_quoted and
3504 tlist
= word_list_split (list
);
3505 dispose_words (list
);
3508 dequote_list (list
);
3510 /* This comes from expand_string_if_necessary */
3513 ret
= string_list (list
);
3514 dispose_words (list
);
3520 else if (saw_quote
&& (quoted
& Q_ARITH
))
3521 ret
= string_quote_removal (string
, quoted
);
3522 else if (saw_quote
&& ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) == 0))
3523 ret
= string_quote_removal (string
, quoted
);
3525 ret
= savestring (string
);
3530 #if defined (COND_COMMAND)
3531 /* Just remove backslashes in STRING. Returns a new string. */
3533 remove_backslashes (string
)
3538 r
= ret
= (char *)xmalloc (strlen (string
) + 1);
3539 for (s
= string
; s
&& *s
; )
3551 /* This needs better error handling. */
3552 /* Expand W for use as an argument to a unary or binary operator in a
3553 [[...]] expression. If SPECIAL is 1, this is the rhs argument
3554 to the != or == operator, and should be treated as a pattern. In
3555 this case, we quote the string specially for the globbing code. If
3556 SPECIAL is 2, this is an rhs argument for the =~ operator, and should
3557 be quoted appropriately for regcomp/regexec. The caller is responsible
3558 for removing the backslashes if the unquoted word is needed later. */
3560 cond_expand_word (w
, special
)
3568 if (w
->word
== 0 || w
->word
[0] == '\0')
3569 return ((char *)NULL
);
3571 expand_no_split_dollar_star
= 1;
3572 w
->flags
|= W_NOSPLIT2
;
3573 l
= call_expand_word_internal (w
, 0, 0, (int *)0, (int *)0);
3574 expand_no_split_dollar_star
= 0;
3577 if (special
== 0) /* LHS */
3580 r
= string_list (l
);
3584 /* Need to figure out whether or not we should call dequote_escapes
3585 or a new dequote_ctlnul function here, and under what
3587 qflags
= QGLOB_CVTNULL
;
3589 qflags
|= QGLOB_REGEXP
;
3590 word_list_remove_quoted_nulls (l
);
3591 p
= string_list (l
);
3592 r
= quote_string_for_globbing (p
, qflags
);
3604 /* Call expand_word_internal to expand W and handle error returns.
3605 A convenience function for functions that don't want to handle
3606 any errors or free any memory before aborting. */
3608 call_expand_word_internal (w
, q
, i
, c
, e
)
3614 result
= expand_word_internal (w
, q
, i
, c
, e
);
3615 if (result
== &expand_word_error
|| result
== &expand_word_fatal
)
3617 /* By convention, each time this error is returned, w->word has
3618 already been freed (it sometimes may not be in the fatal case,
3619 but that doesn't result in a memory leak because we're going
3620 to exit in most cases). */
3621 w
->word
= (char *)NULL
;
3622 last_command_exit_value
= EXECUTION_FAILURE
;
3623 exp_jump_to_top_level ((result
== &expand_word_error
) ? DISCARD
: FORCE_EOF
);
3631 /* Perform parameter expansion, command substitution, and arithmetic
3632 expansion on STRING, as if it were a word. Leave the result quoted.
3633 Since this does not perform word splitting, it leaves quoted nulls
3636 expand_string_internal (string
, quoted
)
3643 if (string
== 0 || *string
== 0)
3644 return ((WORD_LIST
*)NULL
);
3647 td
.word
= savestring (string
);
3649 tresult
= call_expand_word_internal (&td
, quoted
, 0, (int *)NULL
, (int *)NULL
);
3655 /* Expand STRING by performing parameter expansion, command substitution,
3656 and arithmetic expansion. Dequote the resulting WORD_LIST before
3657 returning it, but do not perform word splitting. The call to
3658 remove_quoted_nulls () is in here because word splitting normally
3659 takes care of quote removal. */
3661 expand_string_unsplit (string
, quoted
)
3667 if (string
== 0 || *string
== '\0')
3668 return ((WORD_LIST
*)NULL
);
3670 expand_no_split_dollar_star
= 1;
3671 value
= expand_string_internal (string
, quoted
);
3672 expand_no_split_dollar_star
= 0;
3678 remove_quoted_nulls (value
->word
->word
);
3679 value
->word
->flags
&= ~W_HASQUOTEDNULL
;
3681 dequote_list (value
);
3686 /* Expand the rhs of an assignment statement */
3688 expand_string_assignment (string
, quoted
)
3695 if (string
== 0 || *string
== '\0')
3696 return ((WORD_LIST
*)NULL
);
3698 expand_no_split_dollar_star
= 1;
3700 td
.flags
= W_ASSIGNRHS
;
3701 td
.word
= savestring (string
);
3702 value
= call_expand_word_internal (&td
, quoted
, 0, (int *)NULL
, (int *)NULL
);
3705 expand_no_split_dollar_star
= 0;
3711 remove_quoted_nulls (value
->word
->word
);
3712 value
->word
->flags
&= ~W_HASQUOTEDNULL
;
3714 dequote_list (value
);
3720 /* Expand one of the PS? prompt strings. This is a sort of combination of
3721 expand_string_unsplit and expand_string_internal, but returns the
3722 passed string when an error occurs. Might want to trap other calls
3723 to jump_to_top_level here so we don't endlessly loop. */
3725 expand_prompt_string (string
, quoted
, wflags
)
3733 if (string
== 0 || *string
== 0)
3734 return ((WORD_LIST
*)NULL
);
3737 td
.word
= savestring (string
);
3739 no_longjmp_on_fatal_error
= 1;
3740 value
= expand_word_internal (&td
, quoted
, 0, (int *)NULL
, (int *)NULL
);
3741 no_longjmp_on_fatal_error
= 0;
3743 if (value
== &expand_word_error
|| value
== &expand_word_fatal
)
3745 value
= make_word_list (make_bare_word (string
), (WORD_LIST
*)NULL
);
3753 remove_quoted_nulls (value
->word
->word
);
3754 value
->word
->flags
&= ~W_HASQUOTEDNULL
;
3756 dequote_list (value
);
3761 /* Expand STRING just as if you were expanding a word, but do not dequote
3762 the resultant WORD_LIST. This is called only from within this file,
3763 and is used to correctly preserve quoted characters when expanding
3764 things like ${1+"$@"}. This does parameter expansion, command
3765 substitution, arithmetic expansion, and word splitting. */
3767 expand_string_leave_quoted (string
, quoted
)
3774 if (string
== 0 || *string
== '\0')
3775 return ((WORD_LIST
*)NULL
);
3777 tlist
= expand_string_internal (string
, quoted
);
3781 tresult
= word_list_split (tlist
);
3782 dispose_words (tlist
);
3785 return ((WORD_LIST
*)NULL
);
3788 /* This does not perform word splitting or dequote the WORD_LIST
3791 expand_string_for_rhs (string
, quoted
, dollar_at_p
, expanded_p
)
3793 int quoted
, *dollar_at_p
, *expanded_p
;
3798 if (string
== 0 || *string
== '\0')
3799 return (WORD_LIST
*)NULL
;
3801 expand_no_split_dollar_star
= 1;
3802 td
.flags
= W_NOSPLIT2
; /* no splitting, remove "" and '' */
3804 tresult
= call_expand_word_internal (&td
, quoted
, 1, dollar_at_p
, expanded_p
);
3805 expand_no_split_dollar_star
= 0;
3810 /* Expand STRING just as if you were expanding a word. This also returns
3811 a list of words. Note that filename globbing is *NOT* done for word
3812 or string expansion, just when the shell is expanding a command. This
3813 does parameter expansion, command substitution, arithmetic expansion,
3814 and word splitting. Dequote the resultant WORD_LIST before returning. */
3816 expand_string (string
, quoted
)
3822 if (string
== 0 || *string
== '\0')
3823 return ((WORD_LIST
*)NULL
);
3825 result
= expand_string_leave_quoted (string
, quoted
);
3826 return (result
? dequote_list (result
) : result
);
3829 /***************************************************
3831 * Functions to handle quoting chars *
3833 ***************************************************/
3837 A string with s[0] == CTLNUL && s[1] == 0 is a quoted null string.
3838 The parser passes CTLNUL as CTLESC CTLNUL. */
3840 /* Quote escape characters in string s, but no other characters. This is
3841 used to protect CTLESC and CTLNUL in variable values from the rest of
3842 the word expansion process after the variable is expanded (word splitting
3843 and filename generation). If IFS is null, we quote spaces as well, just
3844 in case we split on spaces later (in the case of unquoted $@, we will
3845 eventually attempt to split the entire word on spaces). Corresponding
3846 code exists in dequote_escapes. Even if we don't end up splitting on
3847 spaces, quoting spaces is not a problem. This should never be called on
3848 a string that is quoted with single or double quotes or part of a here
3849 document (effectively double-quoted). */
3851 quote_escapes (string
)
3854 register char *s
, *t
;
3856 char *result
, *send
;
3857 int quote_spaces
, skip_ctlesc
, skip_ctlnul
;
3860 slen
= strlen (string
);
3861 send
= string
+ slen
;
3863 quote_spaces
= (ifs_value
&& *ifs_value
== 0);
3865 for (skip_ctlesc
= skip_ctlnul
= 0, s
= ifs_value
; s
&& *s
; s
++)
3866 skip_ctlesc
|= *s
== CTLESC
, skip_ctlnul
|= *s
== CTLNUL
;
3868 t
= result
= (char *)xmalloc ((slen
* 2) + 1);
3873 if ((skip_ctlesc
== 0 && *s
== CTLESC
) || (skip_ctlnul
== 0 && *s
== CTLNUL
) || (quote_spaces
&& *s
== ' '))
3875 COPY_CHAR_P (t
, s
, send
);
3883 list_quote_escapes (list
)
3886 register WORD_LIST
*w
;
3889 for (w
= list
; w
; w
= w
->next
)
3892 w
->word
->word
= quote_escapes (t
);
3898 /* Inverse of quote_escapes; remove CTLESC protecting CTLESC or CTLNUL.
3900 The parser passes us CTLESC as CTLESC CTLESC and CTLNUL as CTLESC CTLNUL.
3901 This is necessary to make unquoted CTLESC and CTLNUL characters in the
3902 data stream pass through properly.
3904 We need to remove doubled CTLESC characters inside quoted strings before
3905 quoting the entire string, so we do not double the number of CTLESC
3908 Also used by parts of the pattern substitution code. */
3910 dequote_escapes (string
)
3913 register char *s
, *t
, *s1
;
3915 char *result
, *send
;
3922 slen
= strlen (string
);
3923 send
= string
+ slen
;
3925 t
= result
= (char *)xmalloc (slen
+ 1);
3927 if (strchr (string
, CTLESC
) == 0)
3928 return (strcpy (result
, string
));
3930 quote_spaces
= (ifs_value
&& *ifs_value
== 0);
3935 if (*s
== CTLESC
&& (s
[1] == CTLESC
|| s
[1] == CTLNUL
|| (quote_spaces
&& s
[1] == ' ')))
3941 COPY_CHAR_P (t
, s
, send
);
3949 list_dequote_escapes (list
)
3952 register WORD_LIST
*w
;
3955 for (w
= list
; w
; w
= w
->next
)
3958 w
->word
->word
= dequote_escapes (t
);
3964 /* Return a new string with the quoted representation of character C.
3965 This turns "" into QUOTED_NULL, so the W_HASQUOTEDNULL flag needs to be
3966 set in any resultant WORD_DESC where this value is the word. */
3968 make_quoted_char (c
)
3973 temp
= (char *)xmalloc (3);
3988 /* Quote STRING, returning a new string. This turns "" into QUOTED_NULL, so
3989 the W_HASQUOTEDNULL flag needs to be set in any resultant WORD_DESC where
3990 this value is the word. */
3992 quote_string (string
)
3997 char *result
, *send
;
4001 result
= (char *)xmalloc (2);
4009 slen
= strlen (string
);
4010 send
= string
+ slen
;
4012 result
= (char *)xmalloc ((slen
* 2) + 1);
4014 for (t
= result
; string
< send
; )
4017 COPY_CHAR_P (t
, string
, send
);
4024 /* De-quote quoted characters in STRING. */
4026 dequote_string (string
)
4029 register char *s
, *t
;
4031 char *result
, *send
;
4035 if (string
[0] == CTLESC
&& string
[1] == 0)
4036 internal_inform ("dequote_string: string with bare CTLESC");
4039 slen
= strlen (string
);
4041 t
= result
= (char *)xmalloc (slen
+ 1);
4043 if (QUOTED_NULL (string
))
4049 /* A string consisting of only a single CTLESC should pass through unchanged */
4050 if (string
[0] == CTLESC
&& string
[1] == 0)
4057 /* If no character in the string can be quoted, don't bother examining
4058 each character. Just return a copy of the string passed to us. */
4059 if (strchr (string
, CTLESC
) == NULL
)
4060 return (strcpy (result
, string
));
4062 send
= string
+ slen
;
4072 COPY_CHAR_P (t
, s
, send
);
4079 /* Quote the entire WORD_LIST list. */
4084 register WORD_LIST
*w
;
4087 for (w
= list
; w
; w
= w
->next
)
4090 w
->word
->word
= quote_string (t
);
4092 w
->word
->flags
|= W_HASQUOTEDNULL
; /* XXX - turn on W_HASQUOTEDNULL here? */
4093 w
->word
->flags
|= W_QUOTED
;
4099 /* De-quote quoted characters in each word in LIST. */
4105 register WORD_LIST
*tlist
;
4107 for (tlist
= list
; tlist
; tlist
= tlist
->next
)
4109 s
= dequote_string (tlist
->word
->word
);
4110 if (QUOTED_NULL (tlist
->word
->word
))
4111 tlist
->word
->flags
&= ~W_HASQUOTEDNULL
;
4112 free (tlist
->word
->word
);
4113 tlist
->word
->word
= s
;
4118 /* Remove CTLESC protecting a CTLESC or CTLNUL in place. Return the passed
4121 remove_quoted_escapes (string
)
4128 t
= dequote_escapes (string
);
4136 /* Perform quoted null character removal on STRING. We don't allow any
4137 quoted null characters in the middle or at the ends of strings because
4138 of how expand_word_internal works. remove_quoted_nulls () turns
4139 STRING into an empty string iff it only consists of a quoted null,
4140 and removes all unquoted CTLNUL characters. */
4142 remove_quoted_nulls (string
)
4145 register size_t slen
;
4146 register int i
, j
, prev_i
;
4149 if (strchr (string
, CTLNUL
) == 0) /* XXX */
4150 return string
; /* XXX */
4152 slen
= strlen (string
);
4157 if (string
[i
] == CTLESC
)
4159 /* Old code had j++, but we cannot assume that i == j at this
4160 point -- what if a CTLNUL has already been removed from the
4161 string? We don't want to drop the CTLESC or recopy characters
4162 that we've already copied down. */
4163 i
++; string
[j
++] = CTLESC
;
4167 else if (string
[i
] == CTLNUL
)
4174 ADVANCE_CHAR (string
, slen
, i
);
4177 do string
[j
++] = string
[prev_i
++]; while (prev_i
< i
);
4187 /* Perform quoted null character removal on each element of LIST.
4188 This modifies LIST. */
4190 word_list_remove_quoted_nulls (list
)
4193 register WORD_LIST
*t
;
4195 for (t
= list
; t
; t
= t
->next
)
4197 remove_quoted_nulls (t
->word
->word
);
4198 t
->word
->flags
&= ~W_HASQUOTEDNULL
;
4202 /* **************************************************************** */
4204 /* Functions for Matching and Removing Patterns */
4206 /* **************************************************************** */
4208 #if defined (HANDLE_MULTIBYTE)
4209 #if 0 /* Currently unused */
4210 static unsigned char *
4211 mb_getcharlens (string
, len
)
4215 int i
, offset
, last
;
4222 ret
= (unsigned char *)xmalloc (len
);
4223 memset (ret
, 0, len
);
4224 while (string
[last
])
4226 ADVANCE_CHAR (string
, len
, offset
);
4227 ret
[last
] = offset
- last
;
4235 /* Remove the portion of PARAM matched by PATTERN according to OP, where OP
4236 can have one of 4 values:
4237 RP_LONG_LEFT remove longest matching portion at start of PARAM
4238 RP_SHORT_LEFT remove shortest matching portion at start of PARAM
4239 RP_LONG_RIGHT remove longest matching portion at end of PARAM
4240 RP_SHORT_RIGHT remove shortest matching portion at end of PARAM
4243 #define RP_LONG_LEFT 1
4244 #define RP_SHORT_LEFT 2
4245 #define RP_LONG_RIGHT 3
4246 #define RP_SHORT_RIGHT 4
4248 /* Returns its first argument if nothing matched; new memory otherwise */
4250 remove_upattern (param
, pattern
, op
)
4251 char *param
, *pattern
;
4254 register size_t len
;
4256 register char *p
, *ret
, c
;
4258 len
= STRLEN (param
);
4263 case RP_LONG_LEFT
: /* remove longest match at start */
4264 for (p
= end
; p
>= param
; p
--)
4267 if (strmatch (pattern
, param
, FNMATCH_EXTFLAG
) != FNM_NOMATCH
)
4270 return (savestring (p
));
4277 case RP_SHORT_LEFT
: /* remove shortest match at start */
4278 for (p
= param
; p
<= end
; p
++)
4281 if (strmatch (pattern
, param
, FNMATCH_EXTFLAG
) != FNM_NOMATCH
)
4284 return (savestring (p
));
4290 case RP_LONG_RIGHT
: /* remove longest match at end */
4291 for (p
= param
; p
<= end
; p
++)
4293 if (strmatch (pattern
, p
, FNMATCH_EXTFLAG
) != FNM_NOMATCH
)
4296 ret
= savestring (param
);
4303 case RP_SHORT_RIGHT
: /* remove shortest match at end */
4304 for (p
= end
; p
>= param
; p
--)
4306 if (strmatch (pattern
, p
, FNMATCH_EXTFLAG
) != FNM_NOMATCH
)
4309 ret
= savestring (param
);
4317 return (param
); /* no match, return original string */
4320 #if defined (HANDLE_MULTIBYTE)
4321 /* Returns its first argument if nothing matched; new memory otherwise */
4323 remove_wpattern (wparam
, wstrlen
, wpattern
, op
)
4334 case RP_LONG_LEFT
: /* remove longest match at start */
4335 for (n
= wstrlen
; n
>= 0; n
--)
4337 wc
= wparam
[n
]; wparam
[n
] = L
'\0';
4338 if (wcsmatch (wpattern
, wparam
, FNMATCH_EXTFLAG
) != FNM_NOMATCH
)
4341 return (wcsdup (wparam
+ n
));
4347 case RP_SHORT_LEFT
: /* remove shortest match at start */
4348 for (n
= 0; n
<= wstrlen
; n
++)
4350 wc
= wparam
[n
]; wparam
[n
] = L
'\0';
4351 if (wcsmatch (wpattern
, wparam
, FNMATCH_EXTFLAG
) != FNM_NOMATCH
)
4354 return (wcsdup (wparam
+ n
));
4360 case RP_LONG_RIGHT
: /* remove longest match at end */
4361 for (n
= 0; n
<= wstrlen
; n
++)
4363 if (wcsmatch (wpattern
, wparam
+ n
, FNMATCH_EXTFLAG
) != FNM_NOMATCH
)
4365 wc
= wparam
[n
]; wparam
[n
] = L
'\0';
4366 ret
= wcsdup (wparam
);
4373 case RP_SHORT_RIGHT
: /* remove shortest match at end */
4374 for (n
= wstrlen
; n
>= 0; n
--)
4376 if (wcsmatch (wpattern
, wparam
+ n
, FNMATCH_EXTFLAG
) != FNM_NOMATCH
)
4378 wc
= wparam
[n
]; wparam
[n
] = L
'\0';
4379 ret
= wcsdup (wparam
);
4387 return (wparam
); /* no match, return original string */
4389 #endif /* HANDLE_MULTIBYTE */
4392 remove_pattern (param
, pattern
, op
)
4393 char *param
, *pattern
;
4400 if (*param
== '\0' || pattern
== NULL
|| *pattern
== '\0') /* minor optimization */
4401 return (savestring (param
));
4403 #if defined (HANDLE_MULTIBYTE)
4406 wchar_t *ret
, *oret
;
4408 wchar_t *wparam
, *wpattern
;
4411 n
= xdupmbstowcs (&wpattern
, NULL
, pattern
);
4412 if (n
== (size_t)-1)
4414 xret
= remove_upattern (param
, pattern
, op
);
4415 return ((xret
== param
) ? savestring (param
) : xret
);
4417 n
= xdupmbstowcs (&wparam
, NULL
, param
);
4419 if (n
== (size_t)-1)
4422 xret
= remove_upattern (param
, pattern
, op
);
4423 return ((xret
== param
) ? savestring (param
) : xret
);
4425 oret
= ret
= remove_wpattern (wparam
, n
, wpattern
, op
);
4426 /* Don't bother to convert wparam back to multibyte string if nothing
4427 matched; just return copy of original string */
4432 return (savestring (param
));
4439 xret
= (char *)xmalloc (n
+ 1);
4440 memset (&ps
, '\0', sizeof (mbstate_t));
4441 n
= wcsrtombs (xret
, (const wchar_t **)&ret
, n
, &ps
);
4442 xret
[n
] = '\0'; /* just to make sure */
4449 xret
= remove_upattern (param
, pattern
, op
);
4450 return ((xret
== param
) ? savestring (param
) : xret
);
4454 /* Match PAT anywhere in STRING and return the match boundaries.
4455 This returns 1 in case of a successful match, 0 otherwise. SP
4456 and EP are pointers into the string where the match begins and
4457 ends, respectively. MTYPE controls what kind of match is attempted.
4458 MATCH_BEG and MATCH_END anchor the match at the beginning and end
4459 of the string, respectively. The longest match is returned. */
4461 match_upattern (string
, pat
, mtype
, sp
, ep
)
4468 register char *p
, *p1
, *npat
;
4472 /* If the pattern doesn't match anywhere in the string, go ahead and
4473 short-circuit right away. A minor optimization, saves a bunch of
4474 unnecessary calls to strmatch (up to N calls for a string of N
4475 characters) if the match is unsuccessful. To preserve the semantics
4476 of the substring matches below, we make sure that the pattern has
4477 `*' as first and last character, making a new pattern if necessary. */
4478 /* XXX - check this later if I ever implement `**' with special meaning,
4479 since this will potentially result in `**' at the beginning or end */
4481 if (pat
[0] != '*' || (pat
[0] == '*' && pat
[1] == LPAREN
&& extended_glob
) || pat
[len
- 1] != '*')
4483 int unescaped_backslash
;
4486 p
= npat
= (char *)xmalloc (len
+ 3);
4488 if (*p1
!= '*' || (*p1
== '*' && p1
[1] == LPAREN
&& extended_glob
))
4493 /* Need to also handle a pattern that ends with an unescaped backslash.
4494 For right now, we ignore it because the pattern matching code will
4495 fail the match anyway */
4496 /* If the pattern ends with a `*' we leave it alone if it's preceded by
4497 an even number of backslashes, but if it's escaped by a backslash
4498 we need to add another `*'. */
4499 if (p1
[-1] == '*' && (unescaped_backslash
= p1
[-2] == '\\'))
4502 while (pp
>= pat
&& *pp
-- == '\\')
4503 unescaped_backslash
= 1 - unescaped_backslash
;
4504 if (unescaped_backslash
)
4507 else if (p1
[-1] != '*')
4510 if (p1
[-1] != '*' || p1
[-2] == '\\')
4517 c
= strmatch (npat
, string
, FNMATCH_EXTFLAG
| FNMATCH_IGNCASE
);
4520 if (c
== FNM_NOMATCH
)
4523 len
= STRLEN (string
);
4526 mlen
= umatchlen (pat
, len
);
4531 for (p
= string
; p
<= end
; p
++)
4533 if (match_pattern_char (pat
, p
, FNMATCH_IGNCASE
))
4535 p1
= (mlen
== -1) ? end
: p
+ mlen
;
4536 /* p1 - p = length of portion of string to be considered
4537 p = current position in string
4538 mlen = number of characters consumed by match (-1 for entire string)
4540 we want to break immediately if the potential match len
4541 is greater than the number of characters remaining in the
4546 for ( ; p1
>= p
; p1
--)
4548 c
= *p1
; *p1
= '\0';
4549 if (strmatch (pat
, p
, FNMATCH_EXTFLAG
| FNMATCH_IGNCASE
) == 0)
4558 /* If MLEN != -1, we have a fixed length pattern. */
4569 if (match_pattern_char (pat
, string
, FNMATCH_IGNCASE
) == 0)
4572 for (p
= (mlen
== -1) ? end
: string
+ mlen
; p
>= string
; p
--)
4575 if (strmatch (pat
, string
, FNMATCH_EXTFLAG
| FNMATCH_IGNCASE
) == 0)
4583 /* If MLEN != -1, we have a fixed length pattern. */
4591 for (p
= end
- ((mlen
== -1) ? len
: mlen
); p
<= end
; p
++)
4593 if (strmatch (pat
, p
, FNMATCH_EXTFLAG
| FNMATCH_IGNCASE
) == 0)
4599 /* If MLEN != -1, we have a fixed length pattern. */
4610 #if defined (HANDLE_MULTIBYTE)
4612 #define WFOLD(c) (match_ignore_case && iswupper (c) ? towlower (c) : (c))
4614 /* Match WPAT anywhere in WSTRING and return the match boundaries.
4615 This returns 1 in case of a successful match, 0 otherwise. Wide
4616 character version. */
4618 match_wpattern (wstring
, indices
, wstrlen
, wpat
, mtype
, sp
, ep
)
4626 wchar_t wc
, *wp
, *nwpat
, *wp1
;
4629 int n
, n1
, n2
, simple
;
4631 simple
= (wpat
[0] != L
'\\' && wpat
[0] != L
'*' && wpat
[0] != L
'?' && wpat
[0] != L
'[');
4632 #if defined (EXTENDED_GLOB)
4634 simple
&= (wpat
[1] != L
'(' || (wpat
[0] != L
'*' && wpat
[0] != L
'?' && wpat
[0] != L
'+' && wpat
[0] != L
'!' && wpat
[0] != L
'@')); /*)*/
4637 /* If the pattern doesn't match anywhere in the string, go ahead and
4638 short-circuit right away. A minor optimization, saves a bunch of
4639 unnecessary calls to strmatch (up to N calls for a string of N
4640 characters) if the match is unsuccessful. To preserve the semantics
4641 of the substring matches below, we make sure that the pattern has
4642 `*' as first and last character, making a new pattern if necessary. */
4643 len
= wcslen (wpat
);
4644 if (wpat
[0] != L
'*' || (wpat
[0] == L
'*' && wpat
[1] == WLPAREN
&& extended_glob
) || wpat
[len
- 1] != L
'*')
4646 int unescaped_backslash
;
4649 wp
= nwpat
= (wchar_t *)xmalloc ((len
+ 3) * sizeof (wchar_t));
4651 if (*wp1
!= L
'*' || (*wp1
== '*' && wp1
[1] == WLPAREN
&& extended_glob
))
4653 while (*wp1
!= L
'\0')
4656 /* See comments above in match_upattern. */
4657 if (wp1
[-1] == L
'*' && (unescaped_backslash
= wp1
[-2] == L
'\\'))
4660 while (wpp
>= wpat
&& *wpp
-- == L
'\\')
4661 unescaped_backslash
= 1 - unescaped_backslash
;
4662 if (unescaped_backslash
)
4665 else if (wp1
[-1] != L
'*')
4668 if (wp1
[-1] != L
'*' || wp1
[-2] == L
'\\')
4675 len
= wcsmatch (nwpat
, wstring
, FNMATCH_EXTFLAG
| FNMATCH_IGNCASE
);
4678 if (len
== FNM_NOMATCH
)
4681 mlen
= wmatchlen (wpat
, wstrlen
);
4683 /* itrace("wmatchlen (%ls) -> %d", wpat, mlen); */
4687 for (n
= 0; n
<= wstrlen
; n
++)
4689 n2
= simple
? (WFOLD(*wpat
) == WFOLD(wstring
[n
])) : match_pattern_wchar (wpat
, wstring
+ n
, FNMATCH_IGNCASE
);
4692 n1
= (mlen
== -1) ? wstrlen
: n
+ mlen
;
4696 for ( ; n1
>= n
; n1
--)
4698 wc
= wstring
[n1
]; wstring
[n1
] = L
'\0';
4699 if (wcsmatch (wpat
, wstring
+ n
, FNMATCH_EXTFLAG
| FNMATCH_IGNCASE
) == 0)
4707 /* If MLEN != -1, we have a fixed length pattern. */
4717 if (match_pattern_wchar (wpat
, wstring
, FNMATCH_IGNCASE
) == 0)
4720 for (n
= (mlen
== -1) ? wstrlen
: mlen
; n
>= 0; n
--)
4722 wc
= wstring
[n
]; wstring
[n
] = L
'\0';
4723 if (wcsmatch (wpat
, wstring
, FNMATCH_EXTFLAG
| FNMATCH_IGNCASE
) == 0)
4731 /* If MLEN != -1, we have a fixed length pattern. */
4739 for (n
= wstrlen
- ((mlen
== -1) ? wstrlen
: mlen
); n
<= wstrlen
; n
++)
4741 if (wcsmatch (wpat
, wstring
+ n
, FNMATCH_EXTFLAG
| FNMATCH_IGNCASE
) == 0)
4744 *ep
= indices
[wstrlen
];
4747 /* If MLEN != -1, we have a fixed length pattern. */
4758 #endif /* HANDLE_MULTIBYTE */
4761 match_pattern (string
, pat
, mtype
, sp
, ep
)
4766 #if defined (HANDLE_MULTIBYTE)
4769 wchar_t *wstring
, *wpat
;
4771 size_t slen
, plen
, mslen
, mplen
;
4774 if (string
== 0 || pat
== 0 || *pat
== 0)
4777 #if defined (HANDLE_MULTIBYTE)
4780 if (mbsmbchar (string
) == 0 && mbsmbchar (pat
) == 0)
4781 return (match_upattern (string
, pat
, mtype
, sp
, ep
));
4783 n
= xdupmbstowcs (&wpat
, NULL
, pat
);
4784 if (n
== (size_t)-1)
4785 return (match_upattern (string
, pat
, mtype
, sp
, ep
));
4786 n
= xdupmbstowcs (&wstring
, &indices
, string
);
4787 if (n
== (size_t)-1)
4790 return (match_upattern (string
, pat
, mtype
, sp
, ep
));
4792 ret
= match_wpattern (wstring
, indices
, n
, wpat
, mtype
, sp
, ep
);
4802 return (match_upattern (string
, pat
, mtype
, sp
, ep
));
4806 getpatspec (c
, value
)
4811 return ((*value
== '#') ? RP_LONG_LEFT
: RP_SHORT_LEFT
);
4813 return ((*value
== '%') ? RP_LONG_RIGHT
: RP_SHORT_RIGHT
);
4816 /* Posix.2 says that the WORD should be run through tilde expansion,
4817 parameter expansion, command substitution and arithmetic expansion.
4818 This leaves the result quoted, so quote_string_for_globbing () has
4819 to be called to fix it up for strmatch (). If QUOTED is non-zero,
4820 it means that the entire expression was enclosed in double quotes.
4821 This means that quoting characters in the pattern do not make any
4822 special pattern characters quoted. For example, the `*' in the
4823 following retains its special meaning: "${foo#'*'}". */
4825 getpattern (value
, quoted
, expandpat
)
4827 int quoted
, expandpat
;
4834 /* There is a problem here: how to handle single or double quotes in the
4835 pattern string when the whole expression is between double quotes?
4836 POSIX.2 says that enclosing double quotes do not cause the pattern to
4837 be quoted, but does that leave us a problem with @ and array[@] and their
4838 expansions inside a pattern? */
4840 if (expandpat
&& (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && *tword
)
4843 pat
= string_extract_double_quoted (tword
, &i
, SX_STRIPDQ
);
4849 /* expand_string_for_rhs () leaves WORD quoted and does not perform
4851 l
= *value
? expand_string_for_rhs (value
,
4852 (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) ? Q_PATQUOTE
: quoted
,
4853 (int *)NULL
, (int *)NULL
)
4855 pat
= string_list (l
);
4859 tword
= quote_string_for_globbing (pat
, QGLOB_CVTNULL
);
4867 /* Handle removing a pattern from a string as a result of ${name%[%]value}
4868 or ${name#[#]value}. */
4870 variable_remove_pattern (value
, pattern
, patspec
, quoted
)
4871 char *value
, *pattern
;
4872 int patspec
, quoted
;
4876 tword
= remove_pattern (value
, pattern
, patspec
);
4883 list_remove_pattern (list
, pattern
, patspec
, itype
, quoted
)
4886 int patspec
, itype
, quoted
;
4892 for (new = (WORD_LIST
*)NULL
, l
= list
; l
; l
= l
->next
)
4894 tword
= remove_pattern (l
->word
->word
, pattern
, patspec
);
4895 w
= alloc_word_desc ();
4896 w
->word
= tword
? tword
: savestring ("");
4897 new = make_word_list (w
, new);
4900 l
= REVERSE_LIST (new, WORD_LIST
*);
4901 tword
= string_list_pos_params (itype
, l
, quoted
);
4908 parameter_list_remove_pattern (itype
, pattern
, patspec
, quoted
)
4911 int patspec
, quoted
;
4916 list
= list_rest_of_args ();
4918 return ((char *)NULL
);
4919 ret
= list_remove_pattern (list
, pattern
, patspec
, itype
, quoted
);
4920 dispose_words (list
);
4924 #if defined (ARRAY_VARS)
4926 array_remove_pattern (var
, pattern
, patspec
, varname
, quoted
)
4930 char *varname
; /* so we can figure out how it's indexed */
4940 /* compute itype from varname here */
4941 v
= array_variable_part (varname
, &ret
, 0);
4944 if (v
&& invisible_p (v
))
4945 return ((char *)NULL
);
4949 a
= (v
&& array_p (v
)) ? array_cell (v
) : 0;
4950 h
= (v
&& assoc_p (v
)) ? assoc_cell (v
) : 0;
4952 list
= a
? array_to_word_list (a
) : (h
? assoc_to_word_list (h
) : 0);
4954 return ((char *)NULL
);
4955 ret
= list_remove_pattern (list
, pattern
, patspec
, itype
, quoted
);
4956 dispose_words (list
);
4960 #endif /* ARRAY_VARS */
4963 parameter_brace_remove_pattern (varname
, value
, ind
, patstr
, rtype
, quoted
, flags
)
4964 char *varname
, *value
;
4967 int rtype
, quoted
, flags
;
4969 int vtype
, patspec
, starsub
;
4970 char *temp1
, *val
, *pattern
;
4974 return ((char *)NULL
);
4976 this_command_name
= varname
;
4978 vtype
= get_var_and_type (varname
, value
, ind
, quoted
, flags
, &v
, &val
);
4980 return ((char *)NULL
);
4982 starsub
= vtype
& VT_STARSUB
;
4983 vtype
&= ~VT_STARSUB
;
4985 patspec
= getpatspec (rtype
, patstr
);
4986 if (patspec
== RP_LONG_LEFT
|| patspec
== RP_LONG_RIGHT
)
4989 /* Need to pass getpattern newly-allocated memory in case of expansion --
4990 the expansion code will free the passed string on an error. */
4991 temp1
= savestring (patstr
);
4992 pattern
= getpattern (temp1
, quoted
, 1);
4995 temp1
= (char *)NULL
; /* shut up gcc */
4999 case VT_ARRAYMEMBER
:
5000 temp1
= remove_pattern (val
, pattern
, patspec
);
5001 if (vtype
== VT_VARIABLE
)
5005 val
= (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
))
5006 ? quote_string (temp1
)
5007 : quote_escapes (temp1
);
5012 #if defined (ARRAY_VARS)
5014 temp1
= array_remove_pattern (v
, pattern
, patspec
, varname
, quoted
);
5015 if (temp1
&& ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) == 0))
5017 val
= quote_escapes (temp1
);
5024 temp1
= parameter_list_remove_pattern (varname
[0], pattern
, patspec
, quoted
);
5025 if (temp1
&& ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) == 0))
5027 val
= quote_escapes (temp1
);
5039 string_var_assignment (v
, s
)
5043 char flags
[MAX_ATTRIBUTES
], *ret
, *val
;
5046 val
= sh_quote_reusable (s
, 0);
5047 i
= var_attribute_string (v
, 0, flags
);
5048 ret
= (char *)xmalloc (i
+ strlen (val
) + strlen (v
->name
) + 16 + MAX_ATTRIBUTES
);
5050 sprintf (ret
, "declare -%s %s=%s", flags
, v
->name
, val
);
5052 sprintf (ret
, "%s=%s", v
->name
, val
);
5057 #if defined (ARRAY_VARS)
5059 array_var_assignment (v
, itype
, quoted
)
5063 char *ret
, *val
, flags
[MAX_ATTRIBUTES
];
5067 return (char *)NULL
;
5068 val
= array_p (v
) ? array_to_assign (array_cell (v
), 0)
5069 : assoc_to_assign (assoc_cell (v
), 0);
5072 val
= (char *)xmalloc (3);
5079 ret
= (quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
)) ? quote_string (val
) : quote_escapes (val
);
5083 i
= var_attribute_string (v
, 0, flags
);
5084 ret
= (char *)xmalloc (i
+ strlen (val
) + strlen (v
->name
) + 16);
5085 sprintf (ret
, "declare -%s %s=%s", flags
, v
->name
, val
);
5092 pos_params_assignment (list
, itype
, quoted
)
5099 /* first, we transform the list to quote each word. */
5100 temp
= list_transform ('Q', (SHELL_VAR
*)0, list
, itype
, quoted
);
5101 ret
= (char *)xmalloc (strlen (temp
) + 8);
5102 strcpy (ret
, "set -- ");
5103 strcpy (ret
+ 7, temp
);
5109 string_transform (xc
, v
, s
)
5114 char *ret
, flags
[MAX_ATTRIBUTES
];
5117 if (((xc
== 'A' || xc
== 'a') && v
== 0) || (xc
!= 'a' && s
== 0))
5118 return (char *)NULL
;
5122 /* Transformations that interrogate the variable */
5124 i
= var_attribute_string (v
, 0, flags
);
5125 ret
= (i
> 0) ? savestring (flags
) : (char *)NULL
;
5128 ret
= string_var_assignment (v
, s
);
5130 /* Transformations that modify the variable's value */
5132 ret
= ansiexpand (s
, 0, strlen (s
), (int *)0);
5135 ret
= decode_prompt_string (s
);
5138 ret
= sh_quote_reusable (s
, 0);
5148 list_transform (xc
, v
, list
, itype
, quoted
)
5158 for (new = (WORD_LIST
*)NULL
, l
= list
; l
; l
= l
->next
)
5160 tword
= string_transform (xc
, v
, l
->word
->word
);
5161 w
= alloc_word_desc ();
5162 w
->word
= tword
? tword
: savestring (""); /* XXX */
5163 new = make_word_list (w
, new);
5166 l
= REVERSE_LIST (new, WORD_LIST
*);
5167 tword
= string_list_pos_params (itype
, l
, quoted
);
5174 parameter_list_transform (xc
, itype
, quoted
)
5182 list
= list_rest_of_args ();
5184 return ((char *)NULL
);
5186 return (pos_params_assignment (list
, itype
, quoted
));
5187 ret
= list_transform (xc
, (SHELL_VAR
*)0, list
, itype
, quoted
);
5188 dispose_words (list
);
5192 #if defined (ARRAY_VARS)
5194 array_transform (xc
, var
, varname
, quoted
)
5197 char *varname
; /* so we can figure out how it's indexed */
5207 /* compute itype from varname here */
5208 v
= array_variable_part (varname
, &ret
, 0);
5211 if (v
&& invisible_p (v
))
5212 return ((char *)NULL
);
5217 return (array_var_assignment (v
, itype
, quoted
));
5219 a
= (v
&& array_p (v
)) ? array_cell (v
) : 0;
5220 h
= (v
&& assoc_p (v
)) ? assoc_cell (v
) : 0;
5222 list
= a
? array_to_word_list (a
) : (h
? assoc_to_word_list (h
) : 0);
5224 return ((char *)NULL
);
5225 ret
= list_transform (xc
, v
, list
, itype
, quoted
);
5226 dispose_words (list
);
5230 #endif /* ARRAY_VARS */
5233 parameter_brace_transform (varname
, value
, ind
, xform
, rtype
, quoted
, flags
)
5234 char *varname
, *value
;
5237 int rtype
, quoted
, flags
;
5244 if (value
== 0 && xc
!= 'A' && xc
!= 'a')
5245 return ((char *)NULL
);
5247 this_command_name
= varname
;
5249 vtype
= get_var_and_type (varname
, value
, ind
, quoted
, flags
, &v
, &val
);
5251 return ((char *)NULL
);
5253 /* check for valid values of xc */
5256 case 'a': /* expand to a string with just attributes */
5257 case 'A': /* expand as an assignment statement with attributes */
5258 case 'E': /* expand like $'...' */
5259 case 'P': /* expand like prompt string */
5260 case 'Q': /* quote reusably */
5263 return &expand_param_error
;
5266 temp1
= (char *)NULL
; /* shut up gcc */
5267 switch (vtype
& ~VT_STARSUB
)
5270 case VT_ARRAYMEMBER
:
5271 temp1
= string_transform (xc
, v
, val
);
5272 if (vtype
== VT_VARIABLE
)
5276 val
= (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
))
5277 ? quote_string (temp1
)
5278 : quote_escapes (temp1
);
5283 #if defined (ARRAY_VARS)
5285 temp1
= array_transform (xc
, v
, varname
, quoted
);
5286 if (temp1
&& ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) == 0))
5288 val
= quote_escapes (temp1
);
5295 temp1
= parameter_list_transform (xc
, varname
[0], quoted
);
5296 if (temp1
&& ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) == 0))
5298 val
= quote_escapes (temp1
);
5308 /*******************************************
5310 * Functions to expand WORD_DESCs *
5312 *******************************************/
5314 /* Expand WORD, performing word splitting on the result. This does
5315 parameter expansion, command substitution, arithmetic expansion,
5316 word splitting, and quote removal. */
5319 expand_word (word
, quoted
)
5323 WORD_LIST
*result
, *tresult
;
5325 tresult
= call_expand_word_internal (word
, quoted
, 0, (int *)NULL
, (int *)NULL
);
5326 result
= word_list_split (tresult
);
5327 dispose_words (tresult
);
5328 return (result
? dequote_list (result
) : result
);
5331 /* Expand WORD, but do not perform word splitting on the result. This
5332 does parameter expansion, command substitution, arithmetic expansion,
5333 and quote removal. */
5335 expand_word_unsplit (word
, quoted
)
5341 expand_no_split_dollar_star
= 1;
5342 #if defined (HANDLE_MULTIBYTE)
5343 if (ifs_firstc
[0] == 0)
5345 if (ifs_firstc
== 0)
5347 word
->flags
|= W_NOSPLIT
;
5348 word
->flags
|= W_NOSPLIT2
;
5349 result
= call_expand_word_internal (word
, quoted
, 0, (int *)NULL
, (int *)NULL
);
5350 expand_no_split_dollar_star
= 0;
5352 return (result
? dequote_list (result
) : result
);
5355 /* Perform shell expansions on WORD, but do not perform word splitting or
5356 quote removal on the result. Virtually identical to expand_word_unsplit;
5357 could be combined if implementations don't diverge. */
5359 expand_word_leave_quoted (word
, quoted
)
5365 expand_no_split_dollar_star
= 1;
5366 #if defined (HANDLE_MULTIBYTE)
5367 if (ifs_firstc
[0] == 0)
5369 if (ifs_firstc
== 0)
5371 word
->flags
|= W_NOSPLIT
;
5372 word
->flags
|= W_NOSPLIT2
;
5373 result
= call_expand_word_internal (word
, quoted
, 0, (int *)NULL
, (int *)NULL
);
5374 expand_no_split_dollar_star
= 0;
5379 #if defined (PROCESS_SUBSTITUTION)
5381 /*****************************************************************/
5383 /* Hacking Process Substitution */
5385 /*****************************************************************/
5387 #if !defined (HAVE_DEV_FD)
5388 /* Named pipes must be removed explicitly with `unlink'. This keeps a list
5389 of FIFOs the shell has open. unlink_fifo_list will walk the list and
5390 unlink all of them. add_fifo_list adds the name of an open FIFO to the
5391 list. NFIFO is a count of the number of FIFOs in the list. */
5392 #define FIFO_INCR 20
5399 static struct temp_fifo
*fifo_list
= (struct temp_fifo
*)NULL
;
5401 static int fifo_list_size
;
5409 copy_fifo_list (sizep
)
5414 return (char *)NULL
;
5418 add_fifo_list (pathname
)
5421 if (nfifo
>= fifo_list_size
- 1)
5423 fifo_list_size
+= FIFO_INCR
;
5424 fifo_list
= (struct temp_fifo
*)xrealloc (fifo_list
,
5425 fifo_list_size
* sizeof (struct temp_fifo
));
5428 fifo_list
[nfifo
].file
= savestring (pathname
);
5436 if ((fifo_list
[i
].proc
== -1) || (kill(fifo_list
[i
].proc
, 0) == -1))
5438 unlink (fifo_list
[i
].file
);
5439 free (fifo_list
[i
].file
);
5440 fifo_list
[i
].file
= (char *)NULL
;
5441 fifo_list
[i
].proc
= -1;
5453 for (i
= saved
= 0; i
< nfifo
; i
++)
5455 if ((fifo_list
[i
].proc
== -1) || (kill(fifo_list
[i
].proc
, 0) == -1))
5457 unlink (fifo_list
[i
].file
);
5458 free (fifo_list
[i
].file
);
5459 fifo_list
[i
].file
= (char *)NULL
;
5460 fifo_list
[i
].proc
= -1;
5466 /* If we didn't remove some of the FIFOs, compact the list. */
5469 for (i
= j
= 0; i
< nfifo
; i
++)
5470 if (fifo_list
[i
].file
)
5472 fifo_list
[j
].file
= fifo_list
[i
].file
;
5473 fifo_list
[j
].proc
= fifo_list
[i
].proc
;
5482 /* Take LIST, which is a bitmap denoting active FIFOs in fifo_list
5483 from some point in the past, and close all open FIFOs in fifo_list
5484 that are not marked as active in LIST. If LIST is NULL, close
5485 everything in fifo_list. LSIZE is the number of elements in LIST, in
5486 case it's larger than fifo_list_size (size of fifo_list). */
5488 close_new_fifos (list
, lsize
)
5496 unlink_fifo_list ();
5500 for (i
= 0; i
< lsize
; i
++)
5501 if (list
[i
] == 0 && i
< fifo_list_size
&& fifo_list
[i
].proc
!= -1)
5504 for (i
= lsize
; i
< fifo_list_size
; i
++)
5525 tname
= sh_mktmpname ("sh-np", MT_USERANDOM
|MT_USETMPDIR
);
5526 if (mkfifo (tname
, 0600) < 0)
5529 return ((char *)NULL
);
5532 add_fifo_list (tname
);
5536 #else /* HAVE_DEV_FD */
5538 /* DEV_FD_LIST is a bitmap of file descriptors attached to pipes the shell
5539 has open to children. NFDS is a count of the number of bits currently
5540 set in DEV_FD_LIST. TOTFDS is a count of the highest possible number
5542 static char *dev_fd_list
= (char *)NULL
;
5544 static int totfds
; /* The highest possible number of open files. */
5565 for (i
= 0; nfds
&& i
< totfds
; i
++)
5572 copy_fifo_list (sizep
)
5577 if (nfds
== 0 || totfds
== 0)
5581 return (char *)NULL
;
5586 ret
= (char *)xmalloc (totfds
);
5587 return (memcpy (ret
, dev_fd_list
, totfds
));
5594 if (dev_fd_list
== 0 || fd
>= totfds
)
5599 totfds
= getdtablesize ();
5600 if (totfds
< 0 || totfds
> 256)
5605 dev_fd_list
= (char *)xrealloc (dev_fd_list
, totfds
);
5606 memset (dev_fd_list
+ ofds
, '\0', totfds
- ofds
);
5609 dev_fd_list
[fd
] = 1;
5616 return 0; /* used for cleanup; not needed with /dev/fd */
5629 if (dev_fd_list
[fd
])
5632 dev_fd_list
[fd
] = 0;
5645 for (i
= 0; nfds
&& i
< totfds
; i
++)
5651 /* Take LIST, which is a snapshot copy of dev_fd_list from some point in
5652 the past, and close all open fds in dev_fd_list that are not marked
5653 as open in LIST. If LIST is NULL, close everything in dev_fd_list.
5654 LSIZE is the number of elements in LIST, in case it's larger than
5655 totfds (size of dev_fd_list). */
5657 close_new_fifos (list
, lsize
)
5665 unlink_fifo_list ();
5669 for (i
= 0; i
< lsize
; i
++)
5670 if (list
[i
] == 0 && i
< totfds
&& dev_fd_list
[i
])
5673 for (i
= lsize
; i
< totfds
; i
++)
5677 #if defined (NOTDEF)
5678 print_dev_fd_list ()
5682 fprintf (stderr
, "pid %ld: dev_fd_list:", (long)getpid ());
5685 for (i
= 0; i
< totfds
; i
++)
5688 fprintf (stderr
, " %d", i
);
5690 fprintf (stderr
, "\n");
5695 make_dev_fd_filename (fd
)
5698 char *ret
, intbuf
[INT_STRLEN_BOUND (int) + 1], *p
;
5700 ret
= (char *)xmalloc (sizeof (DEV_FD_PREFIX
) + 8);
5702 strcpy (ret
, DEV_FD_PREFIX
);
5703 p
= inttostr (fd
, intbuf
, sizeof (intbuf
));
5704 strcpy (ret
+ sizeof (DEV_FD_PREFIX
) - 1, p
);
5710 #endif /* HAVE_DEV_FD */
5712 /* Return a filename that will open a connection to the process defined by
5713 executing STRING. HAVE_DEV_FD, if defined, means open a pipe and return
5714 a filename in /dev/fd corresponding to a descriptor that is one of the
5715 ends of the pipe. If not defined, we use named pipes on systems that have
5716 them. Systems without /dev/fd and named pipes are out of luck.
5718 OPEN_FOR_READ_IN_CHILD, if 1, means open the named pipe for reading or
5719 use the read end of the pipe and dup that file descriptor to fd 0 in
5720 the child. If OPEN_FOR_READ_IN_CHILD is 0, we open the named pipe for
5721 writing or use the write end of the pipe in the child, and dup that
5722 file descriptor to fd 1 in the child. The parent does the opposite. */
5725 process_substitute (string
, open_for_read_in_child
)
5727 int open_for_read_in_child
;
5732 #if defined (HAVE_DEV_FD)
5733 int parent_pipe_fd
, child_pipe_fd
;
5735 #endif /* HAVE_DEV_FD */
5736 #if defined (JOB_CONTROL)
5737 pid_t old_pipeline_pgrp
;
5740 if (!string
|| !*string
|| wordexp_only
)
5741 return ((char *)NULL
);
5743 #if !defined (HAVE_DEV_FD)
5744 pathname
= make_named_pipe ();
5745 #else /* HAVE_DEV_FD */
5746 if (pipe (fildes
) < 0)
5748 sys_error ("%s", _("cannot make pipe for process substitution"));
5749 return ((char *)NULL
);
5751 /* If OPEN_FOR_READ_IN_CHILD == 1, we want to use the write end of
5752 the pipe in the parent, otherwise the read end. */
5753 parent_pipe_fd
= fildes
[open_for_read_in_child
];
5754 child_pipe_fd
= fildes
[1 - open_for_read_in_child
];
5755 /* Move the parent end of the pipe to some high file descriptor, to
5756 avoid clashes with FDs used by the script. */
5757 parent_pipe_fd
= move_to_high_fd (parent_pipe_fd
, 1, 64);
5759 pathname
= make_dev_fd_filename (parent_pipe_fd
);
5760 #endif /* HAVE_DEV_FD */
5764 sys_error ("%s", _("cannot make pipe for process substitution"));
5765 return ((char *)NULL
);
5768 old_pid
= last_made_pid
;
5770 #if defined (JOB_CONTROL)
5771 old_pipeline_pgrp
= pipeline_pgrp
;
5772 if (pipeline_pgrp
== 0 || (subshell_environment
& (SUBSHELL_PIPE
|SUBSHELL_FORK
|SUBSHELL_ASYNC
)) == 0)
5773 pipeline_pgrp
= shell_pgrp
;
5775 #endif /* JOB_CONTROL */
5777 pid
= make_child ((char *)NULL
, 1);
5780 reset_terminating_signals (); /* XXX */
5781 free_pushed_string_input ();
5782 /* Cancel traps, in trap.c. */
5783 restore_original_signals (); /* XXX - what about special builtins? bash-4.2 */
5784 QUIT
; /* catch any interrupts we got post-fork */
5785 setup_async_signals ();
5786 subshell_environment
|= SUBSHELL_COMSUB
|SUBSHELL_PROCSUB
;
5788 /* if we're expanding a redirection, we shouldn't have access to the
5789 temporary environment, but commands in the subshell should have
5790 access to their own temporary environment. */
5791 if (expanding_redir
)
5792 flush_temporary_env ();
5795 #if defined (JOB_CONTROL)
5796 set_sigchld_handler ();
5797 stop_making_children ();
5798 /* XXX - should we only do this in the parent? (as in command subst) */
5799 pipeline_pgrp
= old_pipeline_pgrp
;
5801 stop_making_children ();
5802 #endif /* JOB_CONTROL */
5806 sys_error ("%s", _("cannot make child for process substitution"));
5808 #if defined (HAVE_DEV_FD)
5809 close (parent_pipe_fd
);
5810 close (child_pipe_fd
);
5811 #endif /* HAVE_DEV_FD */
5812 return ((char *)NULL
);
5817 #if defined (JOB_CONTROL)
5818 if (last_procsub_child
)
5819 discard_last_procsub_child ();
5820 last_procsub_child
= restore_pipeline (0);
5823 #if !defined (HAVE_DEV_FD)
5824 fifo_list
[nfifo
-1].proc
= pid
;
5827 last_made_pid
= old_pid
;
5829 #if defined (JOB_CONTROL) && defined (PGRP_PIPE)
5831 #endif /* JOB_CONTROL && PGRP_PIPE */
5833 #if defined (HAVE_DEV_FD)
5834 close (child_pipe_fd
);
5835 #endif /* HAVE_DEV_FD */
5840 set_sigint_handler ();
5842 #if defined (JOB_CONTROL)
5843 set_job_control (0);
5844 #endif /* JOB_CONTROL */
5846 #if !defined (HAVE_DEV_FD)
5847 /* Open the named pipe in the child. */
5848 fd
= open (pathname
, open_for_read_in_child
? O_RDONLY
: O_WRONLY
);
5851 /* Two separate strings for ease of translation. */
5852 if (open_for_read_in_child
)
5853 sys_error (_("cannot open named pipe %s for reading"), pathname
);
5855 sys_error (_("cannot open named pipe %s for writing"), pathname
);
5859 if (open_for_read_in_child
)
5861 if (sh_unset_nodelay_mode (fd
) < 0)
5863 sys_error (_("cannot reset nodelay mode for fd %d"), fd
);
5867 #else /* HAVE_DEV_FD */
5869 #endif /* HAVE_DEV_FD */
5871 /* Discard buffered stdio output before replacing the underlying file
5873 if (open_for_read_in_child
== 0)
5876 if (dup2 (fd
, open_for_read_in_child
? 0 : 1) < 0)
5878 sys_error (_("cannot duplicate named pipe %s as fd %d"), pathname
,
5879 open_for_read_in_child
? 0 : 1);
5883 if (fd
!= (open_for_read_in_child
? 0 : 1))
5886 /* Need to close any files that this process has open to pipes inherited
5888 if (current_fds_to_close
)
5890 close_fd_bitmap (current_fds_to_close
);
5891 current_fds_to_close
= (struct fd_bitmap
*)NULL
;
5894 #if defined (HAVE_DEV_FD)
5895 /* Make sure we close the parent's end of the pipe and clear the slot
5896 in the fd list so it is not closed later, if reallocated by, for
5897 instance, pipe(2). */
5898 close (parent_pipe_fd
);
5899 dev_fd_list
[parent_pipe_fd
] = 0;
5900 #endif /* HAVE_DEV_FD */
5902 /* subshells shouldn't have this flag, which controls using the temporary
5903 environment for variable lookups. We have already flushed the temporary
5904 environment above in the case we're expanding a redirection, so processes
5905 executed by this command need to be able to set it independently of their
5907 expanding_redir
= 0;
5909 remove_quoted_escapes (string
);
5912 result
= parse_and_execute (string
, "process substitution", (SEVAL_NONINT
|SEVAL_NOHIST
));
5915 #if !defined (HAVE_DEV_FD)
5916 /* Make sure we close the named pipe in the child before we exit. */
5917 close (open_for_read_in_child
? 0 : 1);
5918 #endif /* !HAVE_DEV_FD */
5920 last_command_exit_value
= result
;
5921 result
= run_exit_trap ();
5925 #endif /* PROCESS_SUBSTITUTION */
5927 /***********************************/
5929 /* Command Substitution */
5931 /***********************************/
5934 read_comsub (fd
, quoted
, rflag
)
5938 char *istring
, buf
[128], *bufp
, *s
;
5939 int istring_index
, istring_size
, c
, tflag
, skip_ctlesc
, skip_ctlnul
;
5943 istring
= (char *)NULL
;
5944 istring_index
= istring_size
= bufn
= tflag
= 0;
5946 for (skip_ctlesc
= skip_ctlnul
= 0, s
= ifs_value
; s
&& *s
; s
++)
5947 skip_ctlesc
|= *s
== CTLESC
, skip_ctlnul
|= *s
== CTLNUL
;
5951 /* Read the output of the command through the pipe. This may need to be
5952 changed to understand multibyte characters in the future. */
5959 bufn
= zread (fd
, buf
, sizeof (buf
));
5971 internal_warning ("%s", _("command substitution: ignored null byte in input"));
5978 /* Add the character to ISTRING, possibly after resizing it. */
5979 RESIZE_MALLOCED_BUFFER (istring
, istring_index
, 2, istring_size
, DEFAULT_ARRAY_SIZE
);
5981 /* This is essentially quote_string inline */
5982 if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) /* || c == CTLESC || c == CTLNUL */)
5983 istring
[istring_index
++] = CTLESC
;
5984 /* Escape CTLESC and CTLNUL in the output to protect those characters
5985 from the rest of the word expansions (word splitting and globbing.)
5986 This is essentially quote_escapes inline. */
5987 else if (skip_ctlesc
== 0 && c
== CTLESC
)
5989 tflag
|= W_HASCTLESC
;
5990 istring
[istring_index
++] = CTLESC
;
5992 else if ((skip_ctlnul
== 0 && c
== CTLNUL
) || (c
== ' ' && (ifs_value
&& *ifs_value
== 0)))
5993 istring
[istring_index
++] = CTLESC
;
5995 istring
[istring_index
++] = c
;
5998 #if defined (__CYGWIN__)
5999 if (c
== '\n' && istring_index
> 1 && istring
[istring_index
- 2] == '\r')
6002 istring
[istring_index
- 1] = '\n';
6009 istring
[istring_index
] = '\0';
6011 /* If we read no output, just return now and save ourselves some
6013 if (istring_index
== 0)
6018 return (char *)NULL
;
6021 /* Strip trailing newlines from the output of the command. */
6022 if (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
))
6024 while (istring_index
> 0)
6026 if (istring
[istring_index
- 1] == '\n')
6030 /* If the newline was quoted, remove the quoting char. */
6031 if (istring
[istring_index
- 1] == CTLESC
)
6037 istring
[istring_index
] = '\0';
6040 strip_trailing (istring
, istring_index
- 1, 1);
6047 /* Perform command substitution on STRING. This returns a WORD_DESC * with the
6048 contained string possibly quoted. */
6050 command_substitute (string
, quoted
)
6054 pid_t pid
, old_pid
, old_pipeline_pgrp
, old_async_pid
;
6056 int result
, fildes
[2], function_value
, pflags
, rc
, tflag
;
6059 istring
= (char *)NULL
;
6061 /* Don't fork () if there is no need to. In the case of no command to
6062 run, just return NULL. */
6064 for (s
= string
; s
&& *s
&& (shellblank (*s
) || *s
== '\n'); s
++)
6066 if (s
== 0 || *s
== 0)
6067 return ((WORD_DESC
*)NULL
);
6069 if (!string
|| !*string
|| (string
[0] == '\n' && !string
[1]))
6070 return ((WORD_DESC
*)NULL
);
6073 if (wordexp_only
&& read_but_dont_execute
)
6075 last_command_exit_value
= EX_WEXPCOMSUB
;
6076 jump_to_top_level (EXITPROG
);
6079 /* We're making the assumption here that the command substitution will
6080 eventually run a command from the file system. Since we'll run
6081 maybe_make_export_env in this subshell before executing that command,
6082 the parent shell and any other shells it starts will have to remake
6083 the environment. If we make it before we fork, other shells won't
6084 have to. Don't bother if we have any temporary variable assignments,
6085 though, because the export environment will be remade after this
6086 command completes anyway, but do it if all the words to be expanded
6087 are variable assignments. */
6088 if (subst_assign_varlist
== 0 || garglist
== 0)
6089 maybe_make_export_env (); /* XXX */
6091 /* Flags to pass to parse_and_execute() */
6092 pflags
= (interactive
&& sourcelevel
== 0) ? SEVAL_RESETLINE
: 0;
6094 /* Pipe the output of executing STRING into the current shell. */
6095 if (pipe (fildes
) < 0)
6097 sys_error ("%s", _("cannot make pipe for command substitution"));
6101 old_pid
= last_made_pid
;
6102 #if defined (JOB_CONTROL)
6103 old_pipeline_pgrp
= pipeline_pgrp
;
6104 /* Don't reset the pipeline pgrp if we're already a subshell in a pipeline. */
6105 if ((subshell_environment
& SUBSHELL_PIPE
) == 0)
6106 pipeline_pgrp
= shell_pgrp
;
6107 cleanup_the_pipeline ();
6108 #endif /* JOB_CONTROL */
6110 old_async_pid
= last_asynchronous_pid
;
6111 pid
= make_child ((char *)NULL
, subshell_environment
&SUBSHELL_ASYNC
);
6112 last_asynchronous_pid
= old_async_pid
;
6116 /* Reset the signal handlers in the child, but don't free the
6117 trap strings. Set a flag noting that we have to free the
6118 trap strings if we run trap to change a signal disposition. */
6119 reset_signal_handlers ();
6122 kill (getpid (), SIGINT
);
6123 CLRINTERRUPT
; /* if we're ignoring SIGINT somehow */
6125 QUIT
; /* catch any interrupts we got post-fork */
6126 subshell_environment
|= SUBSHELL_RESETTRAP
;
6129 #if defined (JOB_CONTROL)
6130 /* XXX DO THIS ONLY IN PARENT ? XXX */
6131 set_sigchld_handler ();
6132 stop_making_children ();
6134 pipeline_pgrp
= old_pipeline_pgrp
;
6136 stop_making_children ();
6137 #endif /* JOB_CONTROL */
6141 sys_error (_("cannot make child for command substitution"));
6144 last_made_pid
= old_pid
;
6149 return ((WORD_DESC
*)NULL
);
6154 /* The currently executing shell is not interactive. */
6157 set_sigint_handler (); /* XXX */
6159 free_pushed_string_input ();
6161 /* Discard buffered stdio output before replacing the underlying file
6165 if (dup2 (fildes
[1], 1) < 0)
6167 sys_error ("%s", _("command_substitute: cannot duplicate pipe as fd 1"));
6168 exit (EXECUTION_FAILURE
);
6171 /* If standard output is closed in the parent shell
6172 (such as after `exec >&-'), file descriptor 1 will be
6173 the lowest available file descriptor, and end up in
6174 fildes[0]. This can happen for stdin and stderr as well,
6175 but stdout is more important -- it will cause no output
6176 to be generated from this command. */
6177 if ((fildes
[1] != fileno (stdin
)) &&
6178 (fildes
[1] != fileno (stdout
)) &&
6179 (fildes
[1] != fileno (stderr
)))
6182 if ((fildes
[0] != fileno (stdin
)) &&
6183 (fildes
[0] != fileno (stdout
)) &&
6184 (fildes
[0] != fileno (stderr
)))
6188 /* Let stdio know the fd may have changed from text to binary mode, and
6189 make sure to preserve stdout line buffering. */
6190 freopen (NULL
, "w", stdout
);
6191 sh_setlinebuf (stdout
);
6192 #endif /* __CYGWIN__ */
6194 /* This is a subshell environment. */
6195 subshell_environment
|= SUBSHELL_COMSUB
;
6197 /* Many shells do not appear to inherit the -v option for command
6199 change_flag ('v', FLAG_OFF
);
6201 /* When inherit_errexit option is not enabled, command substitution does
6202 not inherit the -e flag. It is enabled when Posix mode is enabled */
6203 if (inherit_errexit
== 0)
6205 builtin_ignoring_errexit
= 0;
6206 change_flag ('e', FLAG_OFF
);
6210 /* If we are expanding a redirection, we can dispose of any temporary
6211 environment we received, since redirections are not supposed to have
6212 access to the temporary environment. We will have to see whether this
6213 affects temporary environments supplied to `eval', but the temporary
6214 environment gets copied to builtin_env at some point. */
6215 if (expanding_redir
)
6217 flush_temporary_env ();
6218 expanding_redir
= 0;
6221 remove_quoted_escapes (string
);
6223 startup_state
= 2; /* see if we can avoid a fork */
6224 /* Give command substitution a place to jump back to on failure,
6225 so we don't go back up to main (). */
6226 result
= setjmp_nosigs (top_level
);
6228 /* If we're running a command substitution inside a shell function,
6229 trap `return' so we don't return from the function in the subshell
6230 and go off to never-never land. */
6231 if (result
== 0 && return_catch_flag
)
6232 function_value
= setjmp_nosigs (return_catch
);
6236 if (result
== ERREXIT
)
6237 rc
= last_command_exit_value
;
6238 else if (result
== EXITPROG
)
6239 rc
= last_command_exit_value
;
6241 rc
= EXECUTION_FAILURE
;
6242 else if (function_value
)
6243 rc
= return_catch_value
;
6247 rc
= parse_and_execute (string
, "command substitution", pflags
|SEVAL_NOHIST
);
6251 last_command_exit_value
= rc
;
6252 rc
= run_exit_trap ();
6253 #if defined (PROCESS_SUBSTITUTION)
6254 unlink_fifo_list ();
6260 #if defined (JOB_CONTROL) && defined (PGRP_PIPE)
6262 #endif /* JOB_CONTROL && PGRP_PIPE */
6267 istring
= read_comsub (fildes
[0], quoted
, &tflag
);
6271 current_command_subst_pid
= pid
;
6272 last_command_exit_value
= wait_for (pid
);
6273 last_command_subst_pid
= pid
;
6274 last_made_pid
= old_pid
;
6276 #if defined (JOB_CONTROL)
6277 /* If last_command_exit_value > 128, then the substituted command
6278 was terminated by a signal. If that signal was SIGINT, then send
6279 SIGINT to ourselves. This will break out of loops, for instance. */
6280 if (last_command_exit_value
== (128 + SIGINT
) && last_command_exit_signal
== SIGINT
)
6281 kill (getpid (), SIGINT
);
6283 /* wait_for gives the terminal back to shell_pgrp. If some other
6284 process group should have it, give it away to that group here.
6285 pipeline_pgrp is non-zero only while we are constructing a
6286 pipeline, so what we are concerned about is whether or not that
6287 pipeline was started in the background. A pipeline started in
6288 the background should never get the tty back here. We duplicate
6289 the conditions that wait_for tests to make sure we only give
6290 the terminal back to pipeline_pgrp under the conditions that wait_for
6291 gave it to shell_pgrp. If wait_for doesn't mess with the terminal
6292 pgrp, we should not either. */
6293 if (interactive
&& pipeline_pgrp
!= (pid_t
)0 && running_in_background
== 0 &&
6294 (subshell_environment
& (SUBSHELL_ASYNC
|SUBSHELL_PIPE
)) == 0)
6295 give_terminal_to (pipeline_pgrp
, 0);
6296 #endif /* JOB_CONTROL */
6298 ret
= alloc_word_desc ();
6299 ret
->word
= istring
;
6306 /********************************************************
6308 * Utility functions for parameter expansion *
6310 ********************************************************/
6312 #if defined (ARRAY_VARS)
6315 array_length_reference (s
)
6326 var
= array_variable_part (s
, &t
, &len
);
6328 /* If unbound variables should generate an error, report one and return
6330 if ((var
== 0 || invisible_p (var
) || (assoc_p (var
) == 0 && array_p (var
) == 0)) && unbound_vars_is_error
)
6334 last_command_exit_value
= EXECUTION_FAILURE
;
6339 else if (var
== 0 || invisible_p (var
))
6342 /* We support a couple of expansions for variables that are not arrays.
6343 We'll return the length of the value for v[0], and 1 for v[@] or
6344 v[*]. Return 0 for everything else. */
6346 array
= array_p (var
) ? array_cell (var
) : (ARRAY
*)NULL
;
6347 h
= assoc_p (var
) ? assoc_cell (var
) : (HASH_TABLE
*)NULL
;
6349 if (ALL_ELEMENT_SUB (t
[0]) && t
[1] == ']')
6352 return (h
? assoc_num_elements (h
) : 0);
6353 else if (array_p (var
))
6354 return (array
? array_num_elements (array
) : 0);
6356 return (var_isset (var
) ? 1 : 0);
6362 akey
= expand_assignment_string_to_string (t
, 0); /* [ */
6364 if (akey
== 0 || *akey
== 0)
6366 err_badarraysub (t
);
6370 t
= assoc_reference (assoc_cell (var
), akey
);
6375 ind
= array_expand_index (var
, t
, len
);
6376 /* negative subscripts to indexed arrays count back from end */
6377 if (var
&& array_p (var
) && ind
< 0)
6378 ind
= array_max_index (array_cell (var
)) + 1 + ind
;
6381 err_badarraysub (t
);
6385 t
= array_reference (array
, ind
);
6387 t
= (ind
== 0) ? value_cell (var
) : (char *)NULL
;
6390 len
= MB_STRLEN (t
);
6393 #endif /* ARRAY_VARS */
6396 valid_brace_expansion_word (name
, var_is_special
)
6400 if (DIGIT (*name
) && all_digits (name
))
6402 else if (var_is_special
)
6404 #if defined (ARRAY_VARS)
6405 else if (valid_array_reference (name
, 0))
6407 #endif /* ARRAY_VARS */
6408 else if (legal_identifier (name
))
6415 chk_atstar (name
, quoted
, quoted_dollar_atp
, contains_dollar_at
)
6418 int *quoted_dollar_atp
, *contains_dollar_at
;
6424 if (quoted_dollar_atp
)
6425 *quoted_dollar_atp
= 0;
6426 if (contains_dollar_at
)
6427 *contains_dollar_at
= 0;
6431 /* check for $@ and $* */
6432 if (name
[0] == '@' && name
[1] == 0)
6434 if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && quoted_dollar_atp
)
6435 *quoted_dollar_atp
= 1;
6436 if (contains_dollar_at
)
6437 *contains_dollar_at
= 1;
6440 else if (name
[0] == '*' && name
[1] == '\0' && quoted
== 0)
6442 if (contains_dollar_at
)
6443 *contains_dollar_at
= 1;
6447 /* Now check for ${array[@]} and ${array[*]} */
6448 #if defined (ARRAY_VARS)
6449 else if (valid_array_reference (name
, 0))
6451 temp1
= mbschr (name
, '[');
6452 if (temp1
&& temp1
[1] == '@' && temp1
[2] == ']')
6454 if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && quoted_dollar_atp
)
6455 *quoted_dollar_atp
= 1;
6456 if (contains_dollar_at
)
6457 *contains_dollar_at
= 1;
6460 /* ${array[*]}, when unquoted, should be treated like ${array[@]},
6461 which should result in separate words even when IFS is unset. */
6462 if (temp1
&& temp1
[1] == '*' && temp1
[2] == ']' && quoted
== 0)
6464 if (contains_dollar_at
)
6465 *contains_dollar_at
= 1;
6473 /* Parameter expand NAME, and return a new string which is the expansion,
6474 or NULL if there was no expansion.
6475 VAR_IS_SPECIAL is non-zero if NAME is one of the special variables in
6476 the shell, e.g., "@", "$", "*", etc. QUOTED, if non-zero, means that
6477 NAME was found inside of a double-quoted expression. */
6479 parameter_brace_expand_word (name
, var_is_special
, quoted
, pflags
, indp
)
6481 int var_is_special
, quoted
, pflags
;
6498 /* Handle multiple digit arguments, as in ${11}. */
6499 if (legal_number (name
, &arg_index
))
6501 tt
= get_dollar_var_value (arg_index
);
6503 temp
= (*tt
&& (quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
)))
6505 : quote_escapes (tt
);
6507 temp
= (char *)NULL
;
6510 else if (var_is_special
) /* ${@} */
6513 tt
= (char *)xmalloc (2 + strlen (name
));
6514 tt
[sindex
= 0] = '$';
6515 strcpy (tt
+ 1, name
);
6517 ret
= param_expand (tt
, &sindex
, quoted
, (int *)NULL
, (int *)NULL
,
6518 (int *)NULL
, (int *)NULL
, pflags
);
6521 #if defined (ARRAY_VARS)
6522 else if (valid_array_reference (name
, 0))
6525 if (pflags
& PF_ASSIGNRHS
)
6527 var
= array_variable_part (name
, &tt
, (int *)0);
6528 if (ALL_ELEMENT_SUB (tt
[0]) && tt
[1] == ']')
6530 /* Only treat as double quoted if array variable */
6531 if (var
&& (array_p (var
) || assoc_p (var
)))
6532 /* XXX - bash-4.4/bash-5.0 pass AV_ASSIGNRHS */
6533 temp
= array_value (name
, quoted
|Q_DOUBLE_QUOTES
, AV_ASSIGNRHS
, &atype
, &ind
);
6535 temp
= array_value (name
, quoted
, 0, &atype
, &ind
);
6538 temp
= array_value (name
, quoted
, 0, &atype
, &ind
);
6541 temp
= array_value (name
, quoted
, 0, &atype
, &ind
);
6542 if (atype
== 0 && temp
)
6544 temp
= (*temp
&& (quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
)))
6545 ? quote_string (temp
)
6546 : quote_escapes (temp
);
6547 rflags
|= W_ARRAYIND
;
6551 else if (atype
== 1 && temp
&& QUOTED_NULL (temp
) && (quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
)))
6552 rflags
|= W_HASQUOTEDNULL
;
6555 else if (var
= find_variable (name
))
6557 if (var_isset (var
) && invisible_p (var
) == 0)
6559 #if defined (ARRAY_VARS)
6561 temp
= assoc_reference (assoc_cell (var
), "0");
6562 else if (array_p (var
))
6563 temp
= array_reference (array_cell (var
), 0);
6565 temp
= value_cell (var
);
6567 temp
= value_cell (var
);
6571 temp
= (*temp
&& (quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
)))
6572 ? quote_string (temp
)
6573 : quote_escapes (temp
);
6576 temp
= (char *)NULL
;
6578 else if (var
= find_variable_last_nameref (name
, 0))
6580 temp
= nameref_cell (var
);
6581 #if defined (ARRAY_VARS)
6582 /* Handle expanding nameref whose value is x[n] */
6583 if (temp
&& *temp
&& valid_array_reference (temp
, 0))
6586 goto expand_arrayref
;
6590 /* y=2 ; typeset -n x=y; echo ${x} is not the same as echo ${2} in ksh */
6591 if (temp
&& *temp
&& legal_identifier (temp
) == 0)
6593 last_command_exit_value
= EXECUTION_FAILURE
;
6594 report_error (_("%s: invalid variable name for name reference"), temp
);
6595 temp
= &expand_param_error
;
6598 temp
= (char *)NULL
;
6601 temp
= (char *)NULL
;
6605 ret
= alloc_word_desc ();
6607 ret
->flags
|= rflags
;
6613 parameter_brace_find_indir (name
, var_is_special
, quoted
, find_nameref
)
6615 int var_is_special
, quoted
, find_nameref
;
6621 if (find_nameref
&& var_is_special
== 0 && (v
= find_variable_last_nameref (name
, 0)) &&
6622 nameref_p (v
) && (t
= nameref_cell (v
)) && *t
)
6623 return (savestring (t
));
6625 /* If var_is_special == 0, and name is not an array reference, this does
6626 more expansion than necessary. It should really look up the variable's
6627 value and not try to expand it. */
6628 w
= parameter_brace_expand_word (name
, var_is_special
, quoted
, PF_IGNUNBOUND
, 0);
6630 /* Have to dequote here if necessary */
6633 temp
= (quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
))
6634 ? dequote_string (t
)
6635 : dequote_escapes (t
);
6639 dispose_word_desc (w
);
6644 /* Expand an indirect reference to a variable: ${!NAME} expands to the
6645 value of the variable whose name is the value of NAME. */
6647 parameter_brace_expand_indir (name
, var_is_special
, quoted
, quoted_dollar_atp
, contains_dollar_at
)
6649 int var_is_special
, quoted
;
6650 int *quoted_dollar_atp
, *contains_dollar_at
;
6656 /* See if it's a nameref first, behave in ksh93-compatible fashion.
6657 There is at least one incompatibility: given ${!foo[0]} where foo=bar,
6658 bash performs an indirect lookup on foo[0] and expands the result;
6659 ksh93 expands bar[0]. We could do that here -- there are enough usable
6660 primitives to do that -- but do not at this point. */
6661 if (var_is_special
== 0 && (v
= find_variable_last_nameref (name
, 0)))
6663 if (nameref_p (v
) && (t
= nameref_cell (v
)) && *t
)
6665 w
= alloc_word_desc ();
6666 w
->word
= savestring (t
);
6672 t
= parameter_brace_find_indir (name
, var_is_special
, quoted
, 0);
6674 chk_atstar (t
, quoted
, quoted_dollar_atp
, contains_dollar_at
);
6676 return (WORD_DESC
*)NULL
;
6678 if (valid_brace_expansion_word (t
, SPECIAL_VAR (t
, 0)) == 0)
6680 report_error (_("%s: bad substitution"), t
);
6682 w
= alloc_word_desc ();
6683 w
->word
= &expand_param_error
;
6688 w
= parameter_brace_expand_word (t
, SPECIAL_VAR(t
, 0), quoted
, 0, 0);
6694 /* Expand the right side of a parameter expansion of the form ${NAMEcVALUE},
6695 depending on the value of C, the separating character. C can be one of
6696 "-", "+", or "=". QUOTED is true if the entire brace expression occurs
6697 between double quotes. */
6699 parameter_brace_expand_rhs (name
, value
, c
, quoted
, pflags
, qdollaratp
, hasdollarat
)
6701 int c
, quoted
, pflags
, *qdollaratp
, *hasdollarat
;
6705 char *t
, *t1
, *temp
, *vname
;
6706 int l_hasdollat
, sindex
;
6708 /*itrace("parameter_brace_expand_rhs: %s:%s pflags = %d", name, value, pflags);*/
6709 /* If the entire expression is between double quotes, we want to treat
6710 the value as a double-quoted string, with the exception that we strip
6711 embedded unescaped double quotes (for sh backwards compatibility). */
6712 if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && *value
)
6715 temp
= string_extract_double_quoted (value
, &sindex
, SX_STRIPDQ
);
6720 w
= alloc_word_desc ();
6722 /* XXX was 0 not quoted */
6723 l
= *temp
? expand_string_for_rhs (temp
, quoted
, &l_hasdollat
, (int *)NULL
)
6726 *hasdollarat
= l_hasdollat
|| (l
&& l
->next
);
6731 /* If l->next is not null, we know that TEMP contained "$@", since that
6732 is the only expansion that creates more than one word. */
6733 if (qdollaratp
&& ((l_hasdollat
&& quoted
) || l
->next
))
6735 /*itrace("parameter_brace_expand_rhs: %s:%s: l != NULL, set *qdollaratp", name, value);*/
6739 /* The expansion of TEMP returned something. We need to treat things
6740 slightly differently if L_HASDOLLAT is non-zero. If we have "$@",
6741 the individual words have already been quoted. We need to turn them
6742 into a string with the words separated by the first character of
6743 $IFS without any additional quoting, so string_list_dollar_at won't
6744 do the right thing. If IFS is null, we want "$@" to split into
6745 separate arguments, not be concatenated, so we use string_list_internal
6746 and mark the word to be split on spaces later. We use
6747 string_list_dollar_star for "$@" otherwise. */
6748 if (l
->next
&& ifs_is_null
)
6750 temp
= string_list_internal (l
, " ");
6751 w
->flags
|= W_SPLITSPACE
;
6754 temp
= (l_hasdollat
|| l
->next
) ? string_list_dollar_star (l
) : string_list (l
);
6756 /* If we have a quoted null result (QUOTED_NULL(temp)) and the word is
6757 a quoted null (l->next == 0 && QUOTED_NULL(l->word->word)), the
6758 flags indicate it (l->word->flags & W_HASQUOTEDNULL), and the
6759 expansion is quoted (quoted & (Q_HERE_DOCUMENT|Q_DOUBLE_QUOTES))
6760 (which is more paranoia than anything else), we need to return the
6761 quoted null string and set the flags to indicate it. */
6762 if (l
->next
== 0 && (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && QUOTED_NULL (temp
) && QUOTED_NULL (l
->word
->word
) && (l
->word
->flags
& W_HASQUOTEDNULL
))
6764 w
->flags
|= W_HASQUOTEDNULL
;
6765 /*itrace("parameter_brace_expand_rhs (%s:%s): returning quoted null, turning off qdollaratp", name, value);*/
6766 /* If we return a quoted null with L_HASDOLLARAT, we either have a
6767 construct like "${@-$@}" or "${@-${@-$@}}" with no positional
6768 parameters or a quoted expansion of "$@" with $1 == ''. In either
6769 case, we don't want to enable special handling of $@. */
6770 if (qdollaratp
&& l_hasdollat
)
6775 else if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && l_hasdollat
)
6777 /* Posix interp 221 changed the rules on this. The idea is that
6778 something like "$xxx$@" should expand the same as "${foo-$xxx$@}"
6779 when foo and xxx are unset. The problem is that it's not in any
6780 way backwards compatible and few other shells do it. We're eventually
6781 going to try and split the difference (heh) a little bit here. */
6782 /* l_hasdollat == 1 means we saw a quoted dollar at. */
6784 /* The brace expansion occurred between double quotes and there was
6785 a $@ in TEMP. It does not matter if the $@ is quoted, as long as
6786 it does not expand to anything. In this case, we want to return
6787 a quoted empty string. Posix interp 888 */
6788 temp
= make_quoted_char ('\0');
6789 w
->flags
|= W_HASQUOTEDNULL
;
6790 /*itrace("parameter_brace_expand_rhs (%s:%s): returning quoted null", name, value);*/
6793 temp
= (char *)NULL
;
6795 if (c
== '-' || c
== '+')
6802 t
= temp
? savestring (temp
) : savestring ("");
6803 t1
= dequote_string (t
);
6809 (legal_variable_starter ((unsigned char)name
[1]) || DIGIT (name
[1]) || VALID_INDIR_PARAM (name
[1])))
6811 vname
= parameter_brace_find_indir (name
+ 1, SPECIAL_VAR (name
, 1), quoted
, 1);
6812 if (vname
== 0 || *vname
== 0)
6814 report_error (_("%s: invalid indirect expansion"), name
);
6817 return &expand_wdesc_error
;
6819 if (legal_identifier (vname
) == 0)
6821 report_error (_("%s: invalid variable name"), vname
);
6824 return &expand_wdesc_error
;
6828 #if defined (ARRAY_VARS)
6829 if (valid_array_reference (vname
, 0))
6830 assign_array_element (vname
, t1
, 0);
6832 #endif /* ARRAY_VARS */
6833 bind_variable (vname
, t1
, 0);
6835 stupidly_hack_special_variables (vname
);
6840 /* From Posix group discussion Feb-March 2010. Issue 7 0000221 */
6847 /* Deal with the right hand side of a ${name:?value} expansion in the case
6848 that NAME is null or not set. If VALUE is non-null it is expanded and
6849 used as the error message to print, otherwise a standard message is
6852 parameter_brace_expand_error (name
, value
)
6858 last_command_exit_value
= EXECUTION_FAILURE
; /* ensure it's non-zero */
6859 if (value
&& *value
)
6861 l
= expand_string (value
, 0);
6862 temp
= string_list (l
);
6863 report_error ("%s: %s", name
, temp
? temp
: ""); /* XXX was value not "" */
6868 report_error (_("%s: parameter null or not set"), name
);
6870 /* Free the data we have allocated during this expansion, since we
6871 are about to longjmp out. */
6876 /* Return 1 if NAME is something for which parameter_brace_expand_length is
6879 valid_length_expression (name
)
6882 return (name
[1] == '\0' || /* ${#} */
6883 ((sh_syntaxtab
[(unsigned char) name
[1]] & CSPECVAR
) && name
[2] == '\0') || /* special param */
6884 (DIGIT (name
[1]) && all_digits (name
+ 1)) || /* ${#11} */
6885 #if defined (ARRAY_VARS)
6886 valid_array_reference (name
+ 1, 0) || /* ${#a[7]} */
6888 legal_identifier (name
+ 1)); /* ${#PS1} */
6891 /* Handle the parameter brace expansion that requires us to return the
6892 length of a parameter. */
6894 parameter_brace_expand_length (name
)
6898 intmax_t number
, arg_index
;
6900 #if defined (ARRAY_VARS)
6904 if (name
[1] == '\0') /* ${#} */
6905 number
= number_of_args ();
6906 else if (DOLLAR_AT_STAR (name
[1]) && name
[2] == '\0') /* ${#@}, ${#*} */
6907 number
= number_of_args ();
6908 else if ((sh_syntaxtab
[(unsigned char) name
[1]] & CSPECVAR
) && name
[2] == '\0')
6910 /* Take the lengths of some of the shell's special parameters. */
6914 t
= which_set_flags ();
6917 t
= itos (last_command_exit_value
);
6920 t
= itos (dollar_dollar_pid
);
6923 if (last_asynchronous_pid
== NO_PID
)
6924 t
= (char *)NULL
; /* XXX - error if set -u set? */
6926 t
= itos (last_asynchronous_pid
);
6929 t
= itos (number_of_args ());
6932 number
= STRLEN (t
);
6935 #if defined (ARRAY_VARS)
6936 else if (valid_array_reference (name
+ 1, 0))
6937 number
= array_length_reference (name
+ 1);
6938 #endif /* ARRAY_VARS */
6943 if (legal_number (name
+ 1, &arg_index
)) /* ${#1} */
6945 t
= get_dollar_var_value (arg_index
);
6946 if (t
== 0 && unbound_vars_is_error
)
6948 number
= MB_STRLEN (t
);
6951 #if defined (ARRAY_VARS)
6952 else if ((var
= find_variable (name
+ 1)) && (invisible_p (var
) == 0) && (array_p (var
) || assoc_p (var
)))
6955 t
= assoc_reference (assoc_cell (var
), "0");
6957 t
= array_reference (array_cell (var
), 0);
6958 if (t
== 0 && unbound_vars_is_error
)
6960 number
= MB_STRLEN (t
);
6965 newname
= savestring (name
);
6967 list
= expand_string (newname
, Q_DOUBLE_QUOTES
);
6968 t
= list
? string_list (list
) : (char *)NULL
;
6971 dispose_words (list
);
6973 number
= t
? MB_STRLEN (t
) : 0;
6981 /* Skip characters in SUBSTR until DELIM. SUBSTR is an arithmetic expression,
6982 so we do some ad-hoc parsing of an arithmetic expression to find
6983 the first DELIM, instead of using strchr(3). Two rules:
6984 1. If the substring contains a `(', read until closing `)'.
6985 2. If the substring contains a `?', read past one `:' for each `?'.
6986 The SD_ARITHEXP flag to skip_to_delim takes care of doing this.
6990 skiparith (substr
, delim
)
7000 i
= skip_to_delim (substr
, 0, delims
, SD_ARITHEXP
);
7001 return (substr
+ i
);
7004 /* Verify and limit the start and end of the desired substring. If
7005 VTYPE == 0, a regular shell variable is being used; if it is 1,
7006 then the positional parameters are being used; if it is 2, then
7007 VALUE is really a pointer to an array variable that should be used.
7008 Return value is 1 if both values were OK, 0 if there was a problem
7009 with an invalid expression, or -1 if the values were out of range. */
7011 verify_substring_values (v
, value
, substr
, vtype
, e1p
, e2p
)
7013 char *value
, *substr
;
7015 intmax_t *e1p
, *e2p
;
7017 char *t
, *temp1
, *temp2
;
7020 #if defined (ARRAY_VARS)
7025 /* duplicate behavior of strchr(3) */
7026 t
= skiparith (substr
, ':');
7027 if (*t
&& *t
== ':')
7032 temp1
= expand_arith_string (substr
, Q_DOUBLE_QUOTES
);
7033 *e1p
= evalexp (temp1
, &expok
);
7038 len
= -1; /* paranoia */
7042 case VT_ARRAYMEMBER
:
7043 len
= MB_STRLEN (value
);
7046 len
= number_of_args () + 1;
7048 len
++; /* add one arg if counting from $0 */
7050 #if defined (ARRAY_VARS)
7052 /* For arrays, the first value deals with array indices. Negative
7053 offsets count from one past the array's maximum index. Associative
7054 arrays treat the number of elements as the maximum index. */
7058 len
= assoc_num_elements (h
) + (*e1p
< 0);
7063 len
= array_max_index (a
) + (*e1p
< 0); /* arrays index from 0 to n - 1 */
7069 if (len
== -1) /* paranoia */
7072 if (*e1p
< 0) /* negative offsets count from end */
7075 if (*e1p
> len
|| *e1p
< 0)
7078 #if defined (ARRAY_VARS)
7079 /* For arrays, the second offset deals with the number of elements. */
7080 if (vtype
== VT_ARRAYVAR
)
7081 len
= assoc_p (v
) ? assoc_num_elements (h
) : array_num_elements (a
);
7087 temp2
= savestring (t
);
7088 temp1
= expand_arith_string (temp2
, Q_DOUBLE_QUOTES
);
7091 *e2p
= evalexp (temp1
, &expok
);
7096 if ((vtype
== VT_ARRAYVAR
|| vtype
== VT_POSPARMS
) && *e2p
< 0)
7098 /* bash-4.3: allow positional parameter length < 0 to count backwards
7099 from end of positional parameters */
7100 if (vtype
== VT_ARRAYVAR
&& *e2p
< 0)
7103 internal_error (_("%s: substring expression < 0"), t
);
7106 #if defined (ARRAY_VARS)
7107 /* In order to deal with sparse arrays, push the intelligence about how
7108 to deal with the number of elements desired down to the array-
7109 specific functions. */
7110 if (vtype
!= VT_ARRAYVAR
)
7116 if (*e2p
< 0 || *e2p
< *e1p
)
7118 internal_error (_("%s: substring expression < 0"), t
);
7123 *e2p
+= *e1p
; /* want E2 chars starting at E1 */
7134 /* Return the type of variable specified by VARNAME (simple variable,
7135 positional param, or array variable). Also return the value specified
7136 by VARNAME (value of a variable or a reference to an array element).
7137 QUOTED is the standard description of quoting state, using Q_* defines.
7138 FLAGS is currently a set of flags to pass to array_value. If IND is
7139 non-null and not INTMAX_MIN, and FLAGS includes AV_USEIND, IND is
7140 passed to array_value so the array index is not computed again.
7141 If this returns VT_VARIABLE, the caller assumes that CTLESC and CTLNUL
7142 characters in the value are quoted with CTLESC and takes appropriate
7143 steps. For convenience, *VALP is set to the dequoted VALUE. */
7145 get_var_and_type (varname
, value
, ind
, quoted
, flags
, varp
, valp
)
7146 char *varname
, *value
;
7152 int vtype
, want_indir
;
7158 want_indir
= *varname
== '!' &&
7159 (legal_variable_starter ((unsigned char)varname
[1]) || DIGIT (varname
[1])
7160 || VALID_INDIR_PARAM (varname
[1]));
7162 vname
= parameter_brace_find_indir (varname
+1, SPECIAL_VAR (varname
, 1), quoted
, 1);
7163 /* XXX - what if vname == 0 || *vname == 0 ? */
7169 vtype
= VT_VARIABLE
;
7170 *varp
= (SHELL_VAR
*)NULL
;
7171 *valp
= (char *)NULL
;
7175 /* This sets vtype to VT_VARIABLE or VT_POSPARMS */
7176 vtype
= STR_DOLLAR_AT_STAR (vname
);
7177 if (vtype
== VT_POSPARMS
&& vname
[0] == '*')
7178 vtype
|= VT_STARSUB
;
7179 *varp
= (SHELL_VAR
*)NULL
;
7181 #if defined (ARRAY_VARS)
7182 if (valid_array_reference (vname
, 0))
7184 v
= array_variable_part (vname
, &temp
, (int *)0);
7185 /* If we want to signal array_value to use an already-computed index,
7186 set LIND to that index */
7187 lind
= (ind
!= INTMAX_MIN
&& (flags
& AV_USEIND
)) ? ind
: 0;
7188 if (v
&& invisible_p (v
))
7190 vtype
= VT_ARRAYMEMBER
;
7191 *varp
= (SHELL_VAR
*)NULL
;
7192 *valp
= (char *)NULL
;
7194 if (v
&& (array_p (v
) || assoc_p (v
)))
7196 if (ALL_ELEMENT_SUB (temp
[0]) && temp
[1] == ']')
7198 /* Callers have to differentiate between indexed and associative */
7199 vtype
= VT_ARRAYVAR
;
7201 vtype
|= VT_STARSUB
;
7202 *valp
= array_p (v
) ? (char *)array_cell (v
) : (char *)assoc_cell (v
);
7206 vtype
= VT_ARRAYMEMBER
;
7207 *valp
= array_value (vname
, Q_DOUBLE_QUOTES
, flags
, (int *)NULL
, &lind
);
7211 else if (v
&& (ALL_ELEMENT_SUB (temp
[0]) && temp
[1] == ']'))
7213 vtype
= VT_VARIABLE
;
7215 if (quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
))
7216 *valp
= dequote_string (value
);
7218 *valp
= dequote_escapes (value
);
7222 vtype
= VT_ARRAYMEMBER
;
7224 *valp
= array_value (vname
, Q_DOUBLE_QUOTES
, flags
, (int *)NULL
, &lind
);
7227 else if ((v
= find_variable (vname
)) && (invisible_p (v
) == 0) && (assoc_p (v
) || array_p (v
)))
7229 vtype
= VT_ARRAYMEMBER
;
7231 *valp
= assoc_p (v
) ? assoc_reference (assoc_cell (v
), "0") : array_reference (array_cell (v
), 0);
7236 if (value
&& vtype
== VT_VARIABLE
)
7238 *varp
= find_variable (vname
);
7239 if (quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
))
7240 *valp
= dequote_string (value
);
7242 *valp
= dequote_escapes (value
);
7254 /******************************************************/
7256 /* Functions to extract substrings of variable values */
7258 /******************************************************/
7260 #if defined (HANDLE_MULTIBYTE)
7261 /* Character-oriented rather than strictly byte-oriented substrings. S and
7262 E, rather being strict indices into STRING, indicate character (possibly
7263 multibyte character) positions that require calculation.
7264 Used by the ${param:offset[:length]} expansion. */
7266 mb_substring (string
, s
, e
)
7276 /* Don't need string length in ADVANCE_CHAR unless multibyte chars possible. */
7277 slen
= (MB_CUR_MAX
> 1) ? STRLEN (string
) : 0;
7280 while (string
[start
] && i
--)
7281 ADVANCE_CHAR (string
, slen
, start
);
7284 while (string
[stop
] && i
--)
7285 ADVANCE_CHAR (string
, slen
, stop
);
7286 tt
= substring (string
, start
, stop
);
7291 /* Process a variable substring expansion: ${name:e1[:e2]}. If VARNAME
7292 is `@', use the positional parameters; otherwise, use the value of
7293 VARNAME. If VARNAME is an array variable, use the array elements. */
7296 parameter_brace_substring (varname
, value
, ind
, substr
, quoted
, flags
)
7297 char *varname
, *value
;
7303 int vtype
, r
, starsub
;
7304 char *temp
, *val
, *tt
, *oname
;
7307 if (value
== 0 && ((varname
[0] != '@' && varname
[0] != '*') || varname
[1]))
7308 return ((char *)NULL
);
7310 oname
= this_command_name
;
7311 this_command_name
= varname
;
7313 vtype
= get_var_and_type (varname
, value
, ind
, quoted
, flags
, &v
, &val
);
7316 this_command_name
= oname
;
7317 return ((char *)NULL
);
7320 starsub
= vtype
& VT_STARSUB
;
7321 vtype
&= ~VT_STARSUB
;
7323 r
= verify_substring_values (v
, val
, substr
, vtype
, &e1
, &e2
);
7324 this_command_name
= oname
;
7327 if (vtype
== VT_VARIABLE
)
7329 return ((r
== 0) ? &expand_param_error
: (char *)NULL
);
7335 case VT_ARRAYMEMBER
:
7336 #if defined (HANDLE_MULTIBYTE)
7338 tt
= mb_substring (val
, e1
, e2
);
7341 tt
= substring (val
, e1
, e2
);
7343 if (vtype
== VT_VARIABLE
)
7345 if (quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
))
7346 temp
= quote_string (tt
);
7348 temp
= tt
? quote_escapes (tt
) : (char *)NULL
;
7352 tt
= pos_params (varname
, e1
, e2
, quoted
);
7353 if ((quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
)) == 0)
7355 temp
= tt
? quote_escapes (tt
) : (char *)NULL
;
7361 #if defined (ARRAY_VARS)
7364 /* we convert to list and take first e2 elements starting at e1th
7365 element -- officially undefined for now */
7366 temp
= assoc_subrange (assoc_cell (v
), e1
, e2
, starsub
, quoted
);
7368 /* We want E2 to be the number of elements desired (arrays can be sparse,
7369 so verify_substring_values just returns the numbers specified and we
7370 rely on array_subrange to understand how to deal with them). */
7371 temp
= array_subrange (array_cell (v
), e1
, e2
, starsub
, quoted
);
7372 /* array_subrange now calls array_quote_escapes as appropriate, so the
7373 caller no longer needs to. */
7377 temp
= (char *)NULL
;
7383 /****************************************************************/
7385 /* Functions to perform pattern substitution on variable values */
7387 /****************************************************************/
7391 shouldexp_replacement (s
)
7396 for (p
= s
; p
&& *p
; p
++)
7408 pat_subst (string
, pat
, rep
, mflags
)
7409 char *string
, *pat
, *rep
;
7412 char *ret
, *s
, *e
, *str
, *rstr
, *mstr
;
7413 int rptr
, mtype
, rxpand
, mlen
;
7414 size_t rsize
, l
, replen
, rslen
;
7417 return (savestring (""));
7419 mtype
= mflags
& MATCH_TYPEMASK
;
7421 #if 0 /* bash-4.2 ? */
7422 rxpand
= (rep
&& *rep
) ? shouldexp_replacement (rep
) : 0;
7428 * 1. A null pattern with mtype == MATCH_BEG means to prefix STRING
7429 * with REP and return the result.
7430 * 2. A null pattern with mtype == MATCH_END means to append REP to
7431 * STRING and return the result.
7432 * 3. A null STRING with a matching pattern means to append REP to
7433 * STRING and return the result.
7434 * These don't understand or process `&' in the replacement string.
7436 if ((pat
== 0 || *pat
== 0) && (mtype
== MATCH_BEG
|| mtype
== MATCH_END
))
7438 replen
= STRLEN (rep
);
7439 l
= STRLEN (string
);
7440 ret
= (char *)xmalloc (replen
+ l
+ 2);
7442 strcpy (ret
, string
);
7443 else if (mtype
== MATCH_BEG
)
7446 strcpy (ret
+ replen
, string
);
7450 strcpy (ret
, string
);
7451 strcpy (ret
+ l
, rep
);
7455 else if (*string
== 0 && (match_pattern (string
, pat
, mtype
, &s
, &e
) != 0))
7457 replen
= STRLEN (rep
);
7458 ret
= (char *)xmalloc (replen
+ 1);
7466 ret
= (char *)xmalloc (rsize
= 64);
7469 for (replen
= STRLEN (rep
), rptr
= 0, str
= string
; *str
;)
7471 if (match_pattern (str
, pat
, mtype
, &s
, &e
) == 0)
7479 mstr
= xmalloc (mlen
+ 1);
7480 for (x
= 0; x
< mlen
; x
++)
7483 rstr
= strcreplace (rep
, '&', mstr
, 0);
7485 rslen
= strlen (rstr
);
7493 RESIZE_MALLOCED_BUFFER (ret
, rptr
, (l
+ rslen
), rsize
, 64);
7495 /* OK, now copy the leading unmatched portion of the string (from
7496 str to s) to ret starting at rptr (the current offset). Then copy
7497 the replacement string at ret + rptr + (s - str). Increment
7498 rptr (if necessary) and str and go on. */
7501 strncpy (ret
+ rptr
, str
, l
);
7506 strncpy (ret
+ rptr
, rstr
, rslen
);
7509 str
= e
; /* e == end of match */
7514 if (((mflags
& MATCH_GLOBREP
) == 0) || mtype
!= MATCH_ANY
)
7519 /* On a zero-length match, make sure we copy one character, since
7520 we increment one character to avoid infinite recursion. */
7521 RESIZE_MALLOCED_BUFFER (ret
, rptr
, 1, rsize
, 64);
7522 ret
[rptr
++] = *str
++;
7523 e
++; /* avoid infinite recursion on zero-length match */
7527 /* Now copy the unmatched portion of the input string */
7530 RESIZE_MALLOCED_BUFFER (ret
, rptr
, STRLEN(str
) + 1, rsize
, 64);
7531 strcpy (ret
+ rptr
, str
);
7539 /* Do pattern match and replacement on the positional parameters. */
7541 pos_params_pat_subst (string
, pat
, rep
, mflags
)
7542 char *string
, *pat
, *rep
;
7545 WORD_LIST
*save
, *params
;
7550 save
= params
= list_rest_of_args ();
7552 return ((char *)NULL
);
7554 for ( ; params
; params
= params
->next
)
7556 ret
= pat_subst (params
->word
->word
, pat
, rep
, mflags
);
7557 w
= alloc_word_desc ();
7558 w
->word
= ret
? ret
: savestring ("");
7559 dispose_word (params
->word
);
7563 pchar
= (mflags
& MATCH_STARSUB
) == MATCH_STARSUB
? '*' : '@';
7564 qflags
= (mflags
& MATCH_QUOTED
) == MATCH_QUOTED
? Q_DOUBLE_QUOTES
: 0;
7566 ret
= string_list_pos_params (pchar
, save
, qflags
);
7568 dispose_words (save
);
7573 /* Perform pattern substitution on VALUE, which is the expansion of
7574 VARNAME. PATSUB is an expression supplying the pattern to match
7575 and the string to substitute. QUOTED is a flags word containing
7576 the type of quoting currently in effect. */
7578 parameter_brace_patsub (varname
, value
, ind
, patsub
, quoted
, pflags
, flags
)
7579 char *varname
, *value
;
7582 int quoted
, pflags
, flags
;
7584 int vtype
, mflags
, starsub
, delim
;
7585 char *val
, *temp
, *pat
, *rep
, *p
, *lpatsub
, *tt
;
7589 return ((char *)NULL
);
7591 this_command_name
= varname
;
7593 vtype
= get_var_and_type (varname
, value
, ind
, quoted
, flags
, &v
, &val
);
7595 return ((char *)NULL
);
7597 starsub
= vtype
& VT_STARSUB
;
7598 vtype
&= ~VT_STARSUB
;
7601 /* PATSUB is never NULL when this is called. */
7604 mflags
|= MATCH_GLOBREP
;
7608 /* Malloc this because expand_string_if_necessary or one of the expansion
7609 functions in its call chain may free it on a substitution error. */
7610 lpatsub
= savestring (patsub
);
7612 if (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
))
7613 mflags
|= MATCH_QUOTED
;
7616 mflags
|= MATCH_STARSUB
;
7618 if (pflags
& PF_ASSIGNRHS
)
7619 mflags
|= MATCH_ASSIGNRHS
;
7621 /* If the pattern starts with a `/', make sure we skip over it when looking
7622 for the replacement delimiter. */
7623 delim
= skip_to_delim (lpatsub
, ((*patsub
== '/') ? 1 : 0), "/", 0);
7624 if (lpatsub
[delim
] == '/')
7627 rep
= lpatsub
+ delim
+ 1;
7632 if (rep
&& *rep
== '\0')
7635 /* Perform the same expansions on the pattern as performed by the
7636 pattern removal expansions. */
7637 pat
= getpattern (lpatsub
, quoted
, 1);
7641 /* We want to perform quote removal on the expanded replacement even if
7642 the entire expansion is double-quoted because the parser and string
7643 extraction functions treated quotes in the replacement string as
7644 special. THIS IS NOT BACKWARDS COMPATIBLE WITH BASH-4.2. */
7645 if (shell_compatibility_level
> 42)
7646 rep
= expand_string_if_necessary (rep
, quoted
& ~(Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
), expand_string_unsplit
);
7647 /* This is the bash-4.2 code. */
7648 else if ((mflags
& MATCH_QUOTED
) == 0)
7649 rep
= expand_string_if_necessary (rep
, quoted
, expand_string_unsplit
);
7651 rep
= expand_string_to_string_internal (rep
, quoted
, expand_string_unsplit
);
7654 /* ksh93 doesn't allow the match specifier to be a part of the expanded
7655 pattern. This is an extension. Make sure we don't anchor the pattern
7656 at the beginning or end of the string if we're doing global replacement,
7659 if (mflags
& MATCH_GLOBREP
)
7660 mflags
|= MATCH_ANY
;
7661 else if (pat
&& pat
[0] == '#')
7663 mflags
|= MATCH_BEG
;
7666 else if (pat
&& pat
[0] == '%')
7668 mflags
|= MATCH_END
;
7672 mflags
|= MATCH_ANY
;
7674 /* OK, we now want to substitute REP for PAT in VAL. If
7675 flags & MATCH_GLOBREP is non-zero, the substitution is done
7676 everywhere, otherwise only the first occurrence of PAT is
7677 replaced. The pattern matching code doesn't understand
7678 CTLESC quoting CTLESC and CTLNUL so we use the dequoted variable
7679 values passed in (VT_VARIABLE) so the pattern substitution
7680 code works right. We need to requote special chars after
7681 we're done for VT_VARIABLE and VT_ARRAYMEMBER, and for the
7682 other cases if QUOTED == 0, since the posparams and arrays
7683 indexed by * or @ do special things when QUOTED != 0. */
7688 case VT_ARRAYMEMBER
:
7689 temp
= pat_subst (val
, p
, rep
, mflags
);
7690 if (vtype
== VT_VARIABLE
)
7694 tt
= (mflags
& MATCH_QUOTED
) ? quote_string (temp
) : quote_escapes (temp
);
7700 temp
= pos_params_pat_subst (val
, p
, rep
, mflags
);
7701 if (temp
&& (mflags
& MATCH_QUOTED
) == 0)
7703 tt
= quote_escapes (temp
);
7708 #if defined (ARRAY_VARS)
7710 temp
= assoc_p (v
) ? assoc_patsub (assoc_cell (v
), p
, rep
, mflags
)
7711 : array_patsub (array_cell (v
), p
, rep
, mflags
);
7712 /* Don't call quote_escapes anymore; array_patsub calls
7713 array_quote_escapes as appropriate before adding the
7714 space separators; ditto for assoc_patsub. */
7726 /****************************************************************/
7728 /* Functions to perform case modification on variable values */
7730 /****************************************************************/
7732 /* Do case modification on the positional parameters. */
7735 pos_params_modcase (string
, pat
, modop
, mflags
)
7740 WORD_LIST
*save
, *params
;
7745 save
= params
= list_rest_of_args ();
7747 return ((char *)NULL
);
7749 for ( ; params
; params
= params
->next
)
7751 ret
= sh_modcase (params
->word
->word
, pat
, modop
);
7752 w
= alloc_word_desc ();
7753 w
->word
= ret
? ret
: savestring ("");
7754 dispose_word (params
->word
);
7758 pchar
= (mflags
& MATCH_STARSUB
) == MATCH_STARSUB
? '*' : '@';
7759 qflags
= (mflags
& MATCH_QUOTED
) == MATCH_QUOTED
? Q_DOUBLE_QUOTES
: 0;
7761 ret
= string_list_pos_params (pchar
, save
, qflags
);
7762 dispose_words (save
);
7767 /* Perform case modification on VALUE, which is the expansion of
7768 VARNAME. MODSPEC is an expression supplying the type of modification
7769 to perform. QUOTED is a flags word containing the type of quoting
7770 currently in effect. */
7772 parameter_brace_casemod (varname
, value
, ind
, modspec
, patspec
, quoted
, flags
)
7773 char *varname
, *value
;
7778 int vtype
, starsub
, modop
, mflags
, x
;
7779 char *val
, *temp
, *pat
, *p
, *lpat
, *tt
;
7783 return ((char *)NULL
);
7785 this_command_name
= varname
;
7787 vtype
= get_var_and_type (varname
, value
, ind
, quoted
, flags
, &v
, &val
);
7789 return ((char *)NULL
);
7791 starsub
= vtype
& VT_STARSUB
;
7792 vtype
&= ~VT_STARSUB
;
7796 if (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
))
7797 mflags
|= MATCH_QUOTED
;
7799 mflags
|= MATCH_STARSUB
;
7804 x
= p
&& p
[0] == modspec
;
7805 modop
= x
? CASE_UPPER
: CASE_UPFIRST
;
7808 else if (modspec
== ',')
7810 x
= p
&& p
[0] == modspec
;
7811 modop
= x
? CASE_LOWER
: CASE_LOWFIRST
;
7814 else if (modspec
== '~')
7816 x
= p
&& p
[0] == modspec
;
7817 modop
= x
? CASE_TOGGLEALL
: CASE_TOGGLE
;
7821 lpat
= p
? savestring (p
) : 0;
7822 /* Perform the same expansions on the pattern as performed by the
7823 pattern removal expansions. FOR LATER */
7824 pat
= lpat
? getpattern (lpat
, quoted
, 1) : 0;
7826 /* OK, now we do the case modification. */
7830 case VT_ARRAYMEMBER
:
7831 temp
= sh_modcase (val
, pat
, modop
);
7832 if (vtype
== VT_VARIABLE
)
7836 tt
= (mflags
& MATCH_QUOTED
) ? quote_string (temp
) : quote_escapes (temp
);
7843 temp
= pos_params_modcase (val
, pat
, modop
, mflags
);
7844 if (temp
&& (mflags
& MATCH_QUOTED
) == 0)
7846 tt
= quote_escapes (temp
);
7852 #if defined (ARRAY_VARS)
7854 temp
= assoc_p (v
) ? assoc_modcase (assoc_cell (v
), pat
, modop
, mflags
)
7855 : array_modcase (array_cell (v
), pat
, modop
, mflags
);
7856 /* Don't call quote_escapes; array_modcase calls array_quote_escapes
7857 as appropriate before adding the space separators; ditto for
7869 /* Check for unbalanced parens in S, which is the contents of $(( ... )). If
7870 any occur, this must be a nested command substitution, so return 0.
7871 Otherwise, return 1. A valid arithmetic expression must always have a
7872 ( before a matching ), so any cases where there are more right parens
7873 means that this must not be an arithmetic expression, though the parser
7874 will not accept it without a balanced total number of parens. */
7876 chk_arithsub (s
, len
)
7888 else if (s
[i
] == RPAREN
)
7898 ADVANCE_CHAR (s
, len
, i
);
7904 ADVANCE_CHAR (s
, len
, i
);
7908 i
= skip_single_quoted (s
, len
, ++i
, 0);
7912 i
= skip_double_quoted ((char *)s
, len
, ++i
, 0);
7917 return (count
== 0);
7920 /****************************************************************/
7922 /* Functions to perform parameter expansion on a string */
7924 /****************************************************************/
7926 /* ${[#][!]name[[:][^[^]][,[,]]#[#]%[%]-=?+[word][:e1[:e2]]]} */
7928 parameter_brace_expand (string
, indexp
, quoted
, pflags
, quoted_dollar_atp
, contains_dollar_at
)
7930 int *indexp
, quoted
, pflags
, *quoted_dollar_atp
, *contains_dollar_at
;
7932 int check_nullness
, var_is_set
, var_is_null
, var_is_special
;
7933 int want_substring
, want_indir
, want_patsub
, want_casemod
;
7934 char *name
, *value
, *temp
, *temp1
;
7935 WORD_DESC
*tdesc
, *ret
;
7936 int t_index
, sindex
, c
, tflag
, modspec
, all_element_arrayref
;
7940 temp
= temp1
= value
= (char *)NULL
;
7941 var_is_set
= var_is_null
= var_is_special
= check_nullness
= 0;
7942 want_substring
= want_indir
= want_patsub
= want_casemod
= 0;
7944 all_element_arrayref
= 0;
7948 /* ${#var} doesn't have any of the other parameter expansions on it. */
7949 if (string
[t_index
] == '#' && legal_variable_starter (string
[t_index
+1])) /* {{ */
7950 name
= string_extract (string
, &t_index
, "}", SX_VARNAME
);
7952 #if defined (CASEMOD_EXPANSIONS)
7953 /* To enable case-toggling expansions using the `~' operator character
7954 change the 1 to 0. */
7955 # if defined (CASEMOD_CAPCASE)
7956 name
= string_extract (string
, &t_index
, "#%^,~:-=?+/@}", SX_VARNAME
);
7958 name
= string_extract (string
, &t_index
, "#%^,:-=?+/@}", SX_VARNAME
);
7959 # endif /* CASEMOD_CAPCASE */
7961 name
= string_extract (string
, &t_index
, "#%:-=?+/@}", SX_VARNAME
);
7962 #endif /* CASEMOD_EXPANSIONS */
7964 /* Handle ${@[stuff]} now that @ is a word expansion operator. Not exactly
7965 the cleanest code ever. */
7966 if (*name
== 0 && sindex
== t_index
&& string
[sindex
] == '@')
7968 name
= (char *)xrealloc (name
, 2);
7973 else if (*name
== '!' && t_index
> sindex
&& string
[t_index
] == '@' && string
[t_index
+1] == '}')
7975 name
= (char *)xrealloc (name
, t_index
- sindex
+ 2);
7976 name
[t_index
- sindex
] = '@';
7977 name
[t_index
- sindex
+ 1] = '\0';
7986 /* If the name really consists of a special variable, then make sure
7987 that we have the entire name. We don't allow indirect references
7988 to special variables except `#', `?', `@' and `*'. This clause is
7989 designed to handle ${#SPECIAL} and ${!SPECIAL}, not anything more
7991 if ((sindex
== t_index
&& VALID_SPECIAL_LENGTH_PARAM (string
[t_index
])) ||
7992 (sindex
== t_index
&& string
[sindex
] == '#' && VALID_SPECIAL_LENGTH_PARAM (string
[sindex
+ 1])) ||
7993 (sindex
== t_index
- 1 && string
[sindex
] == '!' && VALID_INDIR_PARAM (string
[t_index
])))
7996 temp1
= string_extract (string
, &t_index
, "#%:-=?+/@}", 0);
7997 name
= (char *)xrealloc (name
, 3 + (strlen (temp1
)));
7998 *name
= string
[sindex
];
7999 if (string
[sindex
] == '!')
8001 /* indirect reference of $#, $?, $@, or $* */
8002 name
[1] = string
[sindex
+ 1];
8003 strcpy (name
+ 2, temp1
);
8006 strcpy (name
+ 1, temp1
);
8011 /* Find out what character ended the variable name. Then
8012 do the appropriate thing. */
8013 if (c
= string
[sindex
])
8016 /* If c is followed by one of the valid parameter expansion
8017 characters, move past it as normal. If not, assume that
8018 a substring specification is being given, and do not move
8020 if (c
== ':' && VALID_PARAM_EXPAND_CHAR (string
[sindex
]))
8023 if (c
= string
[sindex
])
8026 else if (c
== ':' && string
[sindex
] != RBRACE
)
8028 else if (c
== '/' /* && string[sindex] != RBRACE */) /* XXX */
8030 #if defined (CASEMOD_EXPANSIONS)
8031 else if (c
== '^' || c
== ',' || c
== '~')
8038 /* Catch the valid and invalid brace expressions that made it through the
8040 /* ${#-} is a valid expansion and means to take the length of $-.
8041 Similarly for ${#?} and ${##}... */
8042 if (name
[0] == '#' && name
[1] == '\0' && check_nullness
== 0 &&
8043 VALID_SPECIAL_LENGTH_PARAM (c
) && string
[sindex
] == RBRACE
)
8045 name
= (char *)xrealloc (name
, 3);
8048 c
= string
[sindex
++];
8051 /* ...but ${#%}, ${#:}, ${#=}, ${#+}, and ${#/} are errors. */
8052 if (name
[0] == '#' && name
[1] == '\0' && check_nullness
== 0 &&
8053 member (c
, "%:=+/") && string
[sindex
] == RBRACE
)
8055 temp
= (char *)NULL
;
8056 goto bad_substitution
; /* XXX - substitution error */
8059 /* Indirect expansion begins with a `!'. A valid indirect expansion is
8060 either a variable name, one of the positional parameters or a special
8061 variable that expands to one of the positional parameters. */
8062 want_indir
= *name
== '!' &&
8063 (legal_variable_starter ((unsigned char)name
[1]) || DIGIT (name
[1])
8064 || VALID_INDIR_PARAM (name
[1]));
8066 /* Determine the value of this variable. */
8068 /* Check for special variables, directly referenced. */
8069 if (SPECIAL_VAR (name
, want_indir
))
8072 /* Check for special expansion things, like the length of a parameter */
8073 if (*name
== '#' && name
[1])
8075 /* If we are not pointing at the character just after the
8076 closing brace, then we haven't gotten all of the name.
8077 Since it begins with a special character, this is a bad
8078 substitution. Also check NAME for validity before trying
8080 if (string
[sindex
- 1] != RBRACE
|| (valid_length_expression (name
) == 0))
8082 temp
= (char *)NULL
;
8083 goto bad_substitution
; /* substitution error */
8086 number
= parameter_brace_expand_length (name
);
8087 if (number
== INTMAX_MIN
&& unbound_vars_is_error
)
8089 last_command_exit_value
= EXECUTION_FAILURE
;
8090 err_unboundvar (name
+1);
8092 return (interactive_shell
? &expand_wdesc_error
: &expand_wdesc_fatal
);
8098 return (&expand_wdesc_error
);
8101 ret
= alloc_word_desc ();
8102 ret
->word
= itos (number
);
8107 /* ${@} is identical to $@. */
8108 if (name
[0] == '@' && name
[1] == '\0')
8110 if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && quoted_dollar_atp
)
8111 *quoted_dollar_atp
= 1;
8113 if (contains_dollar_at
)
8114 *contains_dollar_at
= 1;
8116 tflag
|= W_DOLLARAT
;
8119 /* Process ${!PREFIX*} expansion. */
8120 if (want_indir
&& string
[sindex
- 1] == RBRACE
&&
8121 (string
[sindex
- 2] == '*' || string
[sindex
- 2] == '@') &&
8122 legal_variable_starter ((unsigned char) name
[1]))
8127 temp1
= savestring (name
+ 1);
8128 number
= strlen (temp1
);
8129 temp1
[number
- 1] = '\0';
8130 x
= all_variables_matching_prefix (temp1
);
8131 xlist
= strvec_to_word_list (x
, 0, 0);
8132 if (string
[sindex
- 2] == '*')
8133 temp
= string_list_dollar_star (xlist
);
8136 temp
= string_list_dollar_at (xlist
, quoted
, 0);
8137 if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && quoted_dollar_atp
)
8138 *quoted_dollar_atp
= 1;
8139 if (contains_dollar_at
)
8140 *contains_dollar_at
= 1;
8142 tflag
|= W_DOLLARAT
;
8145 dispose_words (xlist
);
8151 ret
= alloc_word_desc ();
8153 ret
->flags
= tflag
; /* XXX */
8157 #if defined (ARRAY_VARS)
8158 /* Process ${!ARRAY[@]} and ${!ARRAY[*]} expansion. */ /* [ */
8159 if (want_indir
&& string
[sindex
- 1] == RBRACE
&&
8160 string
[sindex
- 2] == ']' && valid_array_reference (name
+1, 0))
8164 temp1
= savestring (name
+ 1);
8165 x
= array_variable_name (temp1
, &x1
, (int *)0); /* [ */
8167 if (ALL_ELEMENT_SUB (x1
[0]) && x1
[1] == ']')
8169 temp
= array_keys (temp1
, quoted
); /* handles assoc vars too */
8172 if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && quoted_dollar_atp
)
8173 *quoted_dollar_atp
= 1;
8174 if (contains_dollar_at
)
8175 *contains_dollar_at
= 1;
8177 tflag
|= W_DOLLARAT
;
8184 ret
= alloc_word_desc ();
8186 ret
->flags
= tflag
; /* XXX */
8192 #endif /* ARRAY_VARS */
8194 /* Make sure that NAME is valid before trying to go on. */
8195 if (valid_brace_expansion_word (want_indir
? name
+ 1 : name
,
8196 var_is_special
) == 0)
8198 temp
= (char *)NULL
;
8199 goto bad_substitution
; /* substitution error */
8204 tdesc
= parameter_brace_expand_indir (name
+ 1, var_is_special
, quoted
, quoted_dollar_atp
, contains_dollar_at
);
8205 if (tdesc
== &expand_wdesc_error
|| tdesc
== &expand_wdesc_fatal
)
8207 temp
= (char *)NULL
;
8208 goto bad_substitution
;
8210 /* Turn off the W_ARRAYIND flag because there is no way for this function
8211 to return the index we're supposed to be using. */
8212 if (tdesc
&& tdesc
->flags
)
8213 tdesc
->flags
&= ~W_ARRAYIND
;
8216 tdesc
= parameter_brace_expand_word (name
, var_is_special
, quoted
, PF_IGNUNBOUND
|(pflags
&(PF_NOSPLIT2
|PF_ASSIGNRHS
)), &ind
);
8221 tflag
= tdesc
->flags
;
8222 dispose_word_desc (tdesc
);
8227 if (temp
== &expand_param_error
|| temp
== &expand_param_fatal
)
8231 return (temp
== &expand_param_error
? &expand_wdesc_error
: &expand_wdesc_fatal
);
8234 #if defined (ARRAY_VARS)
8235 if (valid_array_reference (name
, 0))
8241 /* If in a context where word splitting will not take place, treat as
8242 if double-quoted. Has effects with $* and ${array[*]} */
8243 if (pflags
& PF_ASSIGNRHS
)
8244 qflags
|= Q_DOUBLE_QUOTES
;
8245 chk_atstar (name
, qflags
, quoted_dollar_atp
, contains_dollar_at
);
8246 /* We duplicate a little code here */
8247 t
= mbschr (name
, '[');
8248 if (t
&& ALL_ELEMENT_SUB (t
[1]) && t
[2] == ']')
8249 all_element_arrayref
= 1;
8253 var_is_set
= temp
!= (char *)0;
8254 var_is_null
= check_nullness
&& (var_is_set
== 0 || *temp
== 0);
8255 /* XXX - this may not need to be restricted to special variables */
8257 var_is_null
|= var_is_set
&& var_is_special
&& (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && QUOTED_NULL (temp
);
8259 /* Get the rest of the stuff inside the braces. */
8260 if (c
&& c
!= RBRACE
)
8262 /* Extract the contents of the ${ ... } expansion
8263 according to the Posix.2 rules. */
8264 value
= extract_dollar_brace_string (string
, &sindex
, quoted
, (c
== '%' || c
== '#' || c
=='/' || c
== '^' || c
== ',' || c
==':') ? SX_POSIXEXP
|SX_WORD
: SX_WORD
);
8265 if (string
[sindex
] == RBRACE
)
8268 goto bad_substitution
; /* substitution error */
8271 value
= (char *)NULL
;
8275 /* All the cases where an expansion can possibly generate an unbound
8277 if (want_substring
|| want_patsub
|| want_casemod
|| c
== '#' || c
== '%' || c
== RBRACE
)
8279 if (var_is_set
== 0 && unbound_vars_is_error
&& ((name
[0] != '@' && name
[0] != '*') || name
[1]) && all_element_arrayref
== 0)
8281 last_command_exit_value
= EXECUTION_FAILURE
;
8282 err_unboundvar (name
);
8286 return (interactive_shell
? &expand_wdesc_error
: &expand_wdesc_fatal
);
8290 /* If this is a substring spec, process it and add the result. */
8293 temp1
= parameter_brace_substring (name
, temp
, ind
, value
, quoted
, (tflag
& W_ARRAYIND
) ? AV_USEIND
: 0);
8298 if (temp1
== &expand_param_error
)
8299 return (&expand_wdesc_error
);
8300 else if (temp1
== &expand_param_fatal
)
8301 return (&expand_wdesc_fatal
);
8303 ret
= alloc_word_desc ();
8305 /* We test quoted_dollar_atp because we want variants with double-quoted
8306 "$@" to take a different code path. In fact, we make sure at the end
8307 of expand_word_internal that we're only looking at these flags if
8308 quoted_dollar_at == 0. */
8310 (quoted_dollar_atp
== 0 || *quoted_dollar_atp
== 0) &&
8311 QUOTED_NULL (temp1
) && (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)))
8312 ret
->flags
|= W_QUOTED
|W_HASQUOTEDNULL
;
8315 else if (want_patsub
)
8317 temp1
= parameter_brace_patsub (name
, temp
, ind
, value
, quoted
, pflags
, (tflag
& W_ARRAYIND
) ? AV_USEIND
: 0);
8322 if (temp1
== &expand_param_error
)
8323 return (&expand_wdesc_error
);
8324 else if (temp1
== &expand_param_fatal
)
8325 return (&expand_wdesc_fatal
);
8327 ret
= alloc_word_desc ();
8330 (quoted_dollar_atp
== 0 || *quoted_dollar_atp
== 0) &&
8331 QUOTED_NULL (temp1
) && (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)))
8332 ret
->flags
|= W_QUOTED
|W_HASQUOTEDNULL
;
8335 #if defined (CASEMOD_EXPANSIONS)
8336 else if (want_casemod
)
8338 temp1
= parameter_brace_casemod (name
, temp
, ind
, modspec
, value
, quoted
, (tflag
& W_ARRAYIND
) ? AV_USEIND
: 0);
8343 if (temp1
== &expand_param_error
)
8344 return (&expand_wdesc_error
);
8345 else if (temp1
== &expand_param_fatal
)
8346 return (&expand_wdesc_fatal
);
8348 ret
= alloc_word_desc ();
8351 (quoted_dollar_atp
== 0 || *quoted_dollar_atp
== 0) &&
8352 QUOTED_NULL (temp1
) && (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)))
8353 ret
->flags
|= W_QUOTED
|W_HASQUOTEDNULL
;
8358 /* Do the right thing based on which character ended the variable name. */
8364 last_command_exit_value
= EXECUTION_FAILURE
;
8365 report_error (_("%s: bad substitution"), string
? string
: "??");
8369 if (shell_compatibility_level
<= 43)
8370 return &expand_wdesc_error
;
8372 return ((posixly_correct
&& interactive_shell
== 0) ? &expand_wdesc_fatal
: &expand_wdesc_error
);
8378 temp1
= parameter_brace_transform (name
, temp
, ind
, value
, c
, quoted
, (tflag
& W_ARRAYIND
) ? AV_USEIND
: 0);
8382 if (temp1
== &expand_param_error
|| temp1
== &expand_param_fatal
)
8384 last_command_exit_value
= EXECUTION_FAILURE
;
8385 report_error (_("%s: bad substitution"), string
? string
: "??");
8386 return (temp1
== &expand_param_error
? &expand_wdesc_error
: &expand_wdesc_fatal
);
8389 ret
= alloc_word_desc ();
8391 if (temp1
&& QUOTED_NULL (temp1
) && (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)))
8392 ret
->flags
|= W_QUOTED
|W_HASQUOTEDNULL
;
8395 case '#': /* ${param#[#]pattern} */
8396 case '%': /* ${param%[%]pattern} */
8397 if (value
== 0 || *value
== '\0' || temp
== 0 || *temp
== '\0')
8402 temp1
= parameter_brace_remove_pattern (name
, temp
, ind
, value
, c
, quoted
, (tflag
& W_ARRAYIND
) ? AV_USEIND
: 0);
8407 ret
= alloc_word_desc ();
8409 if (temp1
&& QUOTED_NULL (temp1
) && (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)))
8410 ret
->flags
|= W_QUOTED
|W_HASQUOTEDNULL
;
8417 if (var_is_set
&& var_is_null
== 0)
8419 /* If the operator is `+', we don't want the value of the named
8420 variable for anything, just the value of the right hand side. */
8423 /* XXX -- if we're double-quoted and the named variable is "$@",
8424 we want to turn off any special handling of "$@" --
8425 we're not using it, so whatever is on the rhs applies. */
8426 if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && quoted_dollar_atp
)
8427 *quoted_dollar_atp
= 0;
8428 if (contains_dollar_at
)
8429 *contains_dollar_at
= 0;
8434 /* From Posix discussion on austin-group list. Issue 221
8435 requires that backslashes escaping `}' inside
8436 double-quoted ${...} be removed. */
8437 if (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
))
8438 quoted
|= Q_DOLBRACE
;
8439 ret
= parameter_brace_expand_rhs (name
, value
, c
,
8443 contains_dollar_at
);
8444 /* XXX - fix up later, esp. noting presence of
8445 W_HASQUOTEDNULL in ret->flags */
8449 temp
= (char *)NULL
;
8455 /* Otherwise do nothing; just use the value in TEMP. */
8457 else /* VAR not set or VAR is NULL. */
8460 temp
= (char *)NULL
;
8461 if (c
== '=' && var_is_special
)
8463 last_command_exit_value
= EXECUTION_FAILURE
;
8464 report_error (_("$%s: cannot assign in this way"), name
);
8467 return &expand_wdesc_error
;
8471 parameter_brace_expand_error (name
, value
);
8472 return (interactive_shell
? &expand_wdesc_error
: &expand_wdesc_fatal
);
8476 /* XXX -- if we're double-quoted and the named variable is "$@",
8477 we want to turn off any special handling of "$@" --
8478 we're not using it, so whatever is on the rhs applies. */
8479 if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && quoted_dollar_atp
)
8480 *quoted_dollar_atp
= 0;
8481 if (contains_dollar_at
)
8482 *contains_dollar_at
= 0;
8484 /* From Posix discussion on austin-group list. Issue 221 requires
8485 that backslashes escaping `}' inside double-quoted ${...} be
8487 if (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
))
8488 quoted
|= Q_DOLBRACE
;
8489 ret
= parameter_brace_expand_rhs (name
, value
, c
, quoted
, pflags
,
8491 contains_dollar_at
);
8492 /* XXX - fix up later, esp. noting presence of
8493 W_HASQUOTEDNULL in tdesc->flags */
8504 ret
= alloc_word_desc ();
8511 /* Expand a single ${xxx} expansion. The braces are optional. When
8512 the braces are used, parameter_brace_expand() does the work,
8513 possibly calling param_expand recursively. */
8515 param_expand (string
, sindex
, quoted
, expanded_something
,
8516 contains_dollar_at
, quoted_dollar_at_p
, had_quoted_null_p
,
8519 int *sindex
, quoted
, *expanded_something
, *contains_dollar_at
;
8520 int *quoted_dollar_at_p
, *had_quoted_null_p
, pflags
;
8522 char *temp
, *temp1
, uerror
[3], *savecmd
;
8523 int zindex
, t_index
, expok
;
8528 WORD_DESC
*tdesc
, *ret
;
8531 /*itrace("param_expand: `%s' pflags = %d", string+*sindex, pflags);*/
8533 c
= string
[++zindex
];
8535 temp
= (char *)NULL
;
8536 ret
= tdesc
= (WORD_DESC
*)NULL
;
8539 /* Do simple cases first. Switch on what follows '$'. */
8553 temp1
= dollar_vars
[TODIGIT (c
)];
8554 if (unbound_vars_is_error
&& temp1
== (char *)NULL
)
8559 last_command_exit_value
= EXECUTION_FAILURE
;
8560 err_unboundvar (uerror
);
8561 return (interactive_shell
? &expand_wdesc_error
: &expand_wdesc_fatal
);
8564 temp
= (*temp1
&& (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)))
8565 ? quote_string (temp1
)
8566 : quote_escapes (temp1
);
8568 temp
= (char *)NULL
;
8572 /* $$ -- pid of the invoking shell. */
8574 temp
= itos (dollar_dollar_pid
);
8577 /* $# -- number of positional parameters. */
8579 temp
= itos (number_of_args ());
8582 /* $? -- return value of the last synchronous command. */
8584 temp
= itos (last_command_exit_value
);
8587 /* $- -- flags supplied to the shell on invocation or by `set'. */
8589 temp
= which_set_flags ();
8592 /* $! -- Pid of the last asynchronous command. */
8594 /* If no asynchronous pids have been created, expand to nothing.
8595 If `set -u' has been executed, and no async processes have
8596 been created, this is an expansion error. */
8597 if (last_asynchronous_pid
== NO_PID
)
8599 if (expanded_something
)
8600 *expanded_something
= 0;
8601 temp
= (char *)NULL
;
8602 if (unbound_vars_is_error
)
8607 last_command_exit_value
= EXECUTION_FAILURE
;
8608 err_unboundvar (uerror
);
8609 return (interactive_shell
? &expand_wdesc_error
: &expand_wdesc_fatal
);
8613 temp
= itos (last_asynchronous_pid
);
8616 /* The only difference between this and $@ is when the arg is quoted. */
8617 case '*': /* `$*' */
8618 list
= list_rest_of_args ();
8621 /* According to austin-group posix proposal by Geoff Clare in
8622 <20090505091501.GA10097@squonk.masqnet> of 5 May 2009:
8624 "The shell shall write a message to standard error and
8625 immediately exit when it tries to expand an unset parameter
8626 other than the '@' and '*' special parameters."
8629 if (list
== 0 && unbound_vars_is_error
&& (pflags
& PF_IGNUNBOUND
) == 0)
8634 last_command_exit_value
= EXECUTION_FAILURE
;
8635 err_unboundvar (uerror
);
8636 return (interactive_shell
? &expand_wdesc_error
: &expand_wdesc_fatal
);
8640 /* If there are no command-line arguments, this should just
8641 disappear if there are other characters in the expansion,
8642 even if it's quoted. */
8643 if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && list
== 0)
8644 temp
= (char *)NULL
;
8645 else if (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
|Q_PATQUOTE
))
8647 /* If we have "$*" we want to make a string of the positional
8648 parameters, separated by the first character of $IFS, and
8649 quote the whole string, including the separators. If IFS
8650 is unset, the parameters are separated by ' '; if $IFS is
8651 null, the parameters are concatenated. */
8652 temp
= (quoted
& (Q_DOUBLE_QUOTES
|Q_PATQUOTE
)) ? string_list_dollar_star (list
) : string_list (list
);
8655 temp1
= (quoted
& Q_DOUBLE_QUOTES
) ? quote_string (temp
) : temp
;
8657 tflag
|= W_HASQUOTEDNULL
;
8665 /* We check whether or not we're eventually going to split $* here,
8666 for example when IFS is empty and we are processing the rhs of
8667 an assignment statement. In that case, we don't separate the
8668 arguments at all. Otherwise, if the $* is not quoted it is
8670 # if defined (HANDLE_MULTIBYTE)
8671 if (expand_no_split_dollar_star
&& ifs_firstc
[0] == 0)
8673 if (expand_no_split_dollar_star
&& ifs_firstc
== 0)
8675 temp
= string_list_dollar_star (list
);
8678 temp
= string_list_dollar_at (list
, quoted
, 0);
8679 if (quoted
== 0 && (ifs_is_set
== 0 || ifs_is_null
))
8680 tflag
|= W_SPLITSPACE
;
8681 /* If we're not quoted but we still don't want word splitting, make
8682 we quote the IFS characters to protect them from splitting (e.g.,
8683 when $@ is in the string as well). */
8684 else if (temp
&& quoted
== 0 && ifs_is_set
&& (pflags
& PF_ASSIGNRHS
))
8686 temp1
= quote_string (temp
);
8692 if (expand_no_split_dollar_star
== 0 && contains_dollar_at
)
8693 *contains_dollar_at
= 1;
8696 dispose_words (list
);
8699 /* When we have "$@" what we want is "$1" "$2" "$3" ... This
8700 means that we have to turn quoting off after we split into
8701 the individually quoted arguments so that the final split
8702 on the first character of $IFS is still done. */
8703 case '@': /* `$@' */
8704 list
= list_rest_of_args ();
8707 /* According to austin-group posix proposal by Geoff Clare in
8708 <20090505091501.GA10097@squonk.masqnet> of 5 May 2009:
8710 "The shell shall write a message to standard error and
8711 immediately exit when it tries to expand an unset parameter
8712 other than the '@' and '*' special parameters."
8715 if (list
== 0 && unbound_vars_is_error
&& (pflags
& PF_IGNUNBOUND
) == 0)
8720 last_command_exit_value
= EXECUTION_FAILURE
;
8721 err_unboundvar (uerror
);
8722 return (interactive_shell
? &expand_wdesc_error
: &expand_wdesc_fatal
);
8726 /* We want to flag the fact that we saw this. We can't turn
8727 off quoting entirely, because other characters in the
8728 string might need it (consider "\"$@\""), but we need some
8729 way to signal that the final split on the first character
8730 of $IFS should be done, even though QUOTED is 1. */
8731 /* XXX - should this test include Q_PATQUOTE? */
8732 if (quoted_dollar_at_p
&& (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)))
8733 *quoted_dollar_at_p
= 1;
8734 if (contains_dollar_at
)
8735 *contains_dollar_at
= 1;
8737 /* We want to separate the positional parameters with the first
8738 character of $IFS in case $IFS is something other than a space.
8739 We also want to make sure that splitting is done no matter what --
8740 according to POSIX.2, this expands to a list of the positional
8741 parameters no matter what IFS is set to. */
8742 /* XXX - what to do when in a context where word splitting is not
8743 performed? Even when IFS is not the default, posix seems to imply
8744 that we behave like unquoted $* ? Maybe we should use PF_NOSPLIT2
8746 /* XXX - bash-4.4/bash-5.0 passing PFLAGS */
8747 temp
= string_list_dollar_at (list
, (pflags
& PF_ASSIGNRHS
) ? (quoted
|Q_DOUBLE_QUOTES
) : quoted
, pflags
);
8749 tflag
|= W_DOLLARAT
;
8750 dispose_words (list
);
8754 tdesc
= parameter_brace_expand (string
, &zindex
, quoted
, pflags
,
8756 contains_dollar_at
);
8758 if (tdesc
== &expand_wdesc_error
|| tdesc
== &expand_wdesc_fatal
)
8760 temp
= tdesc
? tdesc
->word
: (char *)0;
8763 /* Quoted nulls should be removed if there is anything else
8765 /* Note that we saw the quoted null so we can add one back at
8766 the end of this function if there are no other characters
8767 in the string, discard TEMP, and go on. The exception to
8768 this is when we have "${@}" and $1 is '', since $@ needs
8769 special handling. */
8770 if (tdesc
&& tdesc
->word
&& (tdesc
->flags
& W_HASQUOTEDNULL
) && QUOTED_NULL (temp
))
8772 if (had_quoted_null_p
)
8773 *had_quoted_null_p
= 1;
8774 if (*quoted_dollar_at_p
== 0)
8777 tdesc
->word
= temp
= (char *)NULL
;
8785 /* Do command or arithmetic substitution. */
8787 /* We have to extract the contents of this paren substitution. */
8788 t_index
= zindex
+ 1;
8789 /* XXX - might want to check for string[t_index+2] == LPAREN and parse
8790 as arithmetic substitution immediately. */
8791 temp
= extract_command_subst (string
, &t_index
, (pflags
&PF_COMPLETE
) ? SX_COMPLETE
: 0);
8794 /* For Posix.2-style `$(( ))' arithmetic substitution,
8795 extract the expression and pass it to the evaluator. */
8796 if (temp
&& *temp
== LPAREN
)
8800 temp2
= savestring (temp1
);
8801 t_index
= strlen (temp2
) - 1;
8803 if (temp2
[t_index
] != RPAREN
)
8809 /* Cut off ending `)' */
8810 temp2
[t_index
] = '\0';
8812 if (chk_arithsub (temp2
, t_index
) == 0)
8816 internal_warning (_("future versions of the shell will force evaluation as an arithmetic substitution"));
8821 /* Expand variables found inside the expression. */
8822 temp1
= expand_arith_string (temp2
, Q_DOUBLE_QUOTES
|Q_ARITH
);
8826 /* No error messages. */
8827 savecmd
= this_command_name
;
8828 this_command_name
= (char *)NULL
;
8829 number
= evalexp (temp1
, &expok
);
8830 this_command_name
= savecmd
;
8835 if (interactive_shell
== 0 && posixly_correct
)
8837 last_command_exit_value
= EXECUTION_FAILURE
;
8838 return (&expand_wdesc_fatal
);
8841 return (&expand_wdesc_error
);
8843 temp
= itos (number
);
8848 if (pflags
& PF_NOCOMSUB
)
8849 /* we need zindex+1 because string[zindex] == RPAREN */
8850 temp1
= substring (string
, *sindex
, zindex
+1);
8853 tdesc
= command_substitute (temp
, quoted
);
8854 temp1
= tdesc
? tdesc
->word
: (char *)NULL
;
8856 dispose_word_desc (tdesc
);
8862 /* Do POSIX.2d9-style arithmetic substitution. This will probably go
8863 away in a future bash release. */
8865 /* Extract the contents of this arithmetic substitution. */
8866 t_index
= zindex
+ 1;
8867 temp
= extract_arithmetic_subst (string
, &t_index
);
8871 temp
= savestring (string
);
8872 if (expanded_something
)
8873 *expanded_something
= 0;
8877 /* Do initial variable expansion. */
8878 temp1
= expand_arith_string (temp
, Q_DOUBLE_QUOTES
|Q_ARITH
);
8883 /* Find the variable in VARIABLE_LIST. */
8884 temp
= (char *)NULL
;
8886 for (t_index
= zindex
; (c
= string
[zindex
]) && legal_variable_char (c
); zindex
++)
8888 temp1
= (zindex
> t_index
) ? substring (string
, t_index
, zindex
) : (char *)NULL
;
8890 /* If this isn't a variable name, then just output the `$'. */
8891 if (temp1
== 0 || *temp1
== '\0')
8894 temp
= (char *)xmalloc (2);
8897 if (expanded_something
)
8898 *expanded_something
= 0;
8902 /* If the variable exists, return its value cell. */
8903 var
= find_variable (temp1
);
8905 if (var
&& invisible_p (var
) == 0 && var_isset (var
))
8907 #if defined (ARRAY_VARS)
8908 if (assoc_p (var
) || array_p (var
))
8910 temp
= array_p (var
) ? array_reference (array_cell (var
), 0)
8911 : assoc_reference (assoc_cell (var
), "0");
8913 temp
= (*temp
&& (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)))
8914 ? quote_string (temp
)
8915 : quote_escapes (temp
);
8916 else if (unbound_vars_is_error
)
8917 goto unbound_variable
;
8922 temp
= value_cell (var
);
8924 temp
= (*temp
&& (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)))
8925 ? quote_string (temp
)
8926 : quote_escapes (temp
);
8933 else if (var
&& (invisible_p (var
) || var_isset (var
) == 0))
8934 temp
= (char *)NULL
;
8935 else if ((var
= find_variable_last_nameref (temp1
, 0)) && var_isset (var
) && invisible_p (var
) == 0)
8937 temp
= nameref_cell (var
);
8938 #if defined (ARRAY_VARS)
8939 if (temp
&& *temp
&& valid_array_reference (temp
, 0))
8941 tdesc
= parameter_brace_expand_word (temp
, SPECIAL_VAR (temp
, 0), quoted
, pflags
, (arrayind_t
*)NULL
);
8942 if (tdesc
== &expand_wdesc_error
|| tdesc
== &expand_wdesc_fatal
)
8949 /* y=2 ; typeset -n x=y; echo $x is not the same as echo $2 in ksh */
8950 if (temp
&& *temp
&& legal_identifier (temp
) == 0)
8952 last_command_exit_value
= EXECUTION_FAILURE
;
8953 report_error (_("%s: invalid variable name for name reference"), temp
);
8954 return (&expand_wdesc_error
); /* XXX */
8957 temp
= (char *)NULL
;
8960 temp
= (char *)NULL
;
8963 if (unbound_vars_is_error
)
8965 last_command_exit_value
= EXECUTION_FAILURE
;
8966 err_unboundvar (temp1
);
8975 last_command_exit_value
= EXECUTION_FAILURE
;
8976 return ((unbound_vars_is_error
&& interactive_shell
== 0)
8977 ? &expand_wdesc_fatal
8978 : &expand_wdesc_error
);
8989 ret
= alloc_word_desc ();
8990 ret
->flags
= tflag
; /* XXX */
8997 invalidate_cached_quoted_dollar_at ()
8999 dispose_words (cached_quoted_dollar_at
);
9000 cached_quoted_dollar_at
= 0;
9003 /* Make a word list which is the result of parameter and variable
9004 expansion, command substitution, arithmetic substitution, and
9005 quote removal of WORD. Return a pointer to a WORD_LIST which is
9006 the result of the expansion. If WORD contains a null word, the
9007 word list returned is also null.
9009 QUOTED contains flag values defined in shell.h.
9011 ISEXP is used to tell expand_word_internal that the word should be
9012 treated as the result of an expansion. This has implications for
9013 how IFS characters in the word are treated.
9015 CONTAINS_DOLLAR_AT and EXPANDED_SOMETHING are return values; when non-null
9016 they point to an integer value which receives information about expansion.
9017 CONTAINS_DOLLAR_AT gets non-zero if WORD contained "$@", else zero.
9018 EXPANDED_SOMETHING get non-zero if WORD contained any parameter expansions,
9021 This only does word splitting in the case of $@ expansion. In that
9022 case, we split on ' '. */
9024 /* Values for the local variable quoted_state. */
9026 #define PARTIALLY_QUOTED 1
9027 #define WHOLLY_QUOTED 2
9030 expand_word_internal (word
, quoted
, isexp
, contains_dollar_at
, expanded_something
)
9033 int *contains_dollar_at
;
9034 int *expanded_something
;
9039 /* The intermediate string that we build while expanding. */
9042 /* The current size of the above object. */
9043 size_t istring_size
;
9045 /* Index into ISTRING. */
9048 /* Temporary string storage. */
9051 /* The text of WORD. */
9052 register char *string
;
9054 /* The size of STRING. */
9057 /* The index into STRING. */
9060 /* This gets 1 if we see a $@ while quoted. */
9061 int quoted_dollar_at
;
9063 /* One of UNQUOTED, PARTIALLY_QUOTED, or WHOLLY_QUOTED, depending on
9064 whether WORD contains no quoting characters, a partially quoted
9065 string (e.g., "xx"ab), or is fully quoted (e.g., "xxab"). */
9069 int had_quoted_null
;
9070 int has_dollar_at
, temp_has_dollar_at
;
9071 int split_on_spaces
;
9073 int pflags
; /* flags passed to param_expand */
9076 int assignoff
; /* If assignment, offset of `=' */
9078 register unsigned char c
; /* Current character. */
9079 int t_index
; /* For calls to string_extract_xxx. */
9085 /* OK, let's see if we can optimize a common idiom: "$@" */
9086 if (STREQ (word
->word
, "\"$@\"") &&
9087 (word
->flags
== (W_HASDOLLAR
|W_QUOTED
)) &&
9088 dollar_vars
[1]) /* XXX - check IFS here as well? */
9090 if (contains_dollar_at
)
9091 *contains_dollar_at
= 1;
9092 if (expanded_something
)
9093 *expanded_something
= 1;
9094 if (cached_quoted_dollar_at
)
9095 return (copy_word_list (cached_quoted_dollar_at
));
9096 list
= list_rest_of_args ();
9097 list
= quote_list (list
);
9098 cached_quoted_dollar_at
= copy_word_list (list
);
9102 istring
= (char *)xmalloc (istring_size
= DEFAULT_INITIAL_ARRAY_SIZE
);
9103 istring
[istring_index
= 0] = '\0';
9104 quoted_dollar_at
= had_quoted_null
= has_dollar_at
= 0;
9105 split_on_spaces
= 0;
9106 quoted_state
= UNQUOTED
;
9108 string
= word
->word
;
9110 goto finished_with_string
;
9111 mb_cur_max
= MB_CUR_MAX
;
9113 /* Don't need the string length for the SADD... and COPY_ macros unless
9114 multibyte characters are possible. */
9115 string_size
= (mb_cur_max
> 1) ? strlen (string
) : 1;
9117 if (contains_dollar_at
)
9118 *contains_dollar_at
= 0;
9122 /* Begin the expansion. */
9128 /* Case on top-level character. */
9132 goto finished_with_string
;
9136 #if HANDLE_MULTIBYTE
9137 if (mb_cur_max
> 1 && string
[sindex
])
9139 SADD_MBQCHAR_BODY(temp
, string
, sindex
, string_size
);
9144 temp
= (char *)xmalloc (3);
9146 temp
[1] = c
= string
[sindex
];
9157 istring
= sub_append_string (temp
, istring
, &istring_index
, &istring_size
);
9163 #if defined (PROCESS_SUBSTITUTION)
9164 /* Process substitution. */
9168 /* bash-4.4/bash-5.0
9169 XXX - technically this should only be expanded at the start
9171 if (string
[++sindex
] != LPAREN
|| (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) || (word
->flags
& (W_DQUOTE
|W_NOPROCSUB
)) || posixly_correct
)
9173 sindex
--; /* add_character: label increments sindex */
9177 t_index
= sindex
+ 1; /* skip past both '<' and LPAREN */
9179 temp1
= extract_process_subst (string
, (c
== '<') ? "<(" : ">(", &t_index
, 0); /*))*/
9182 /* If the process substitution specification is `<()', we want to
9183 open the pipe for writing in the child and produce output; if
9184 it is `>()', we want to open the pipe for reading in the child
9185 and consume input. */
9186 temp
= temp1
? process_substitute (temp1
, (c
== '>')) : (char *)0;
9190 goto dollar_add_string
;
9192 #endif /* PROCESS_SUBSTITUTION */
9195 /* Posix.2 section 3.6.1 says that tildes following `=' in words
9196 which are not assignment statements are not expanded. If the
9197 shell isn't in posix mode, though, we perform tilde expansion
9198 on `likely candidate' unquoted assignment statements (flags
9199 include W_ASSIGNMENT but not W_QUOTED). A likely candidate
9200 contains an unquoted :~ or =~. Something to think about: we
9201 now have a flag that says to perform tilde expansion on arguments
9202 to `assignment builtins' like declare and export that look like
9203 assignment statements. We now do tilde expansion on such words
9204 even in POSIX mode. */
9205 if (word
->flags
& (W_ASSIGNRHS
|W_NOTILDE
))
9207 if (isexp
== 0 && (word
->flags
& (W_NOSPLIT
|W_NOSPLIT2
)) == 0 && isifs (c
))
9208 goto add_ifs_character
;
9212 /* If we're not in posix mode or forcing assignment-statement tilde
9213 expansion, note where the `=' appears in the word and prepare to
9214 do tilde expansion following the first `='. */
9215 if ((word
->flags
& W_ASSIGNMENT
) &&
9216 (posixly_correct
== 0 || (word
->flags
& W_TILDEEXP
)) &&
9217 assignoff
== -1 && sindex
> 0)
9219 if (sindex
== assignoff
&& string
[sindex
+1] == '~') /* XXX */
9220 word
->flags
|= W_ITILDE
;
9222 else if ((word
->flags
& W_ASSIGNMENT
) &&
9223 (posixly_correct
== 0 || (word
->flags
& W_TILDEEXP
)) &&
9224 string
[sindex
+1] == '~')
9225 word
->flags
|= W_ITILDE
;
9228 /* XXX - bash-4.4/bash-5.0 */
9229 if (word
->flags
& W_ASSIGNARG
)
9230 word
->flags
|= W_ASSIGNRHS
; /* affects $@ */
9232 if (isexp
== 0 && (word
->flags
& (W_NOSPLIT
|W_NOSPLIT2
)) == 0 && isifs (c
))
9233 goto add_ifs_character
;
9238 if (word
->flags
& W_NOTILDE
)
9240 if (isexp
== 0 && (word
->flags
& (W_NOSPLIT
|W_NOSPLIT2
)) == 0 && isifs (c
))
9241 goto add_ifs_character
;
9246 if ((word
->flags
& (W_ASSIGNMENT
|W_ASSIGNRHS
|W_TILDEEXP
)) &&
9247 string
[sindex
+1] == '~')
9248 word
->flags
|= W_ITILDE
;
9250 if (isexp
== 0 && (word
->flags
& (W_NOSPLIT
|W_NOSPLIT2
)) == 0 && isifs (c
))
9251 goto add_ifs_character
;
9256 /* If the word isn't supposed to be tilde expanded, or we're not
9257 at the start of a word or after an unquoted : or = in an
9258 assignment statement, we don't do tilde expansion. If we don't want
9259 tilde expansion when expanding words to be passed to the arithmetic
9260 evaluator, remove the check for Q_ARITH. */
9261 if ((word
->flags
& (W_NOTILDE
|W_DQUOTE
)) ||
9262 (sindex
> 0 && ((word
->flags
& W_ITILDE
) == 0)) ||
9263 ((quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
)) && ((quoted
& Q_ARITH
) == 0)))
9265 word
->flags
&= ~W_ITILDE
;
9266 if (isexp
== 0 && (word
->flags
& (W_NOSPLIT
|W_NOSPLIT2
)) == 0 && isifs (c
) && (quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
)) == 0)
9267 goto add_ifs_character
;
9272 if (word
->flags
& W_ASSIGNRHS
)
9274 else if (word
->flags
& (W_ASSIGNMENT
|W_TILDEEXP
))
9279 temp
= bash_tilde_find_word (string
+ sindex
, tflag
, &t_index
);
9281 word
->flags
&= ~W_ITILDE
;
9283 if (temp
&& *temp
&& t_index
> 0)
9285 temp1
= bash_tilde_expand (temp
, tflag
);
9286 if (temp1
&& *temp1
== '~' && STREQ (temp
, temp1
))
9290 goto add_character
; /* tilde expansion failed */
9295 goto add_quoted_string
; /* XXX was add_string */
9304 if (expanded_something
)
9305 *expanded_something
= 1;
9307 temp_has_dollar_at
= 0;
9308 pflags
= (word
->flags
& W_NOCOMSUB
) ? PF_NOCOMSUB
: 0;
9309 if (word
->flags
& W_NOSPLIT2
)
9310 pflags
|= PF_NOSPLIT2
;
9311 if (word
->flags
& W_ASSIGNRHS
)
9312 pflags
|= PF_ASSIGNRHS
;
9313 if (word
->flags
& W_COMPLETE
)
9314 pflags
|= PF_COMPLETE
;
9315 tword
= param_expand (string
, &sindex
, quoted
, expanded_something
,
9316 &temp_has_dollar_at
, "ed_dollar_at
,
9317 &had_quoted_null
, pflags
);
9318 has_dollar_at
+= temp_has_dollar_at
;
9319 split_on_spaces
+= (tword
->flags
& W_SPLITSPACE
);
9321 if (tword
== &expand_wdesc_error
|| tword
== &expand_wdesc_fatal
)
9325 return ((tword
== &expand_wdesc_error
) ? &expand_word_error
9326 : &expand_word_fatal
);
9328 if (contains_dollar_at
&& has_dollar_at
)
9329 *contains_dollar_at
= 1;
9331 if (tword
&& (tword
->flags
& W_HASQUOTEDNULL
))
9332 had_quoted_null
= 1;
9334 temp
= tword
? tword
->word
: (char *)NULL
;
9335 dispose_word_desc (tword
);
9337 /* Kill quoted nulls; we will add them back at the end of
9338 expand_word_internal if nothing else in the string */
9339 if (had_quoted_null
&& temp
&& QUOTED_NULL (temp
))
9342 temp
= (char *)NULL
;
9348 case '`': /* Backquoted command substitution. */
9352 temp
= string_extract (string
, &sindex
, "`", SX_REQMATCH
);
9353 /* The test of sindex against t_index is to allow bare instances of
9354 ` to pass through, for backwards compatibility. */
9355 if (temp
== &extract_string_error
|| temp
== &extract_string_fatal
)
9357 if (sindex
- 1 == t_index
)
9362 last_command_exit_value
= EXECUTION_FAILURE
;
9363 report_error (_("bad substitution: no closing \"`\" in %s") , string
+t_index
);
9366 return ((temp
== &extract_string_error
) ? &expand_word_error
9367 : &expand_word_fatal
);
9370 if (expanded_something
)
9371 *expanded_something
= 1;
9373 if (word
->flags
& W_NOCOMSUB
)
9374 /* sindex + 1 because string[sindex] == '`' */
9375 temp1
= substring (string
, t_index
, sindex
+ 1);
9378 de_backslash (temp
);
9379 tword
= command_substitute (temp
, quoted
);
9380 temp1
= tword
? tword
->word
: (char *)NULL
;
9382 dispose_word_desc (tword
);
9386 goto dollar_add_string
;
9390 if (string
[sindex
+ 1] == '\n')
9396 c
= string
[++sindex
];
9398 if (quoted
& Q_HERE_DOCUMENT
)
9400 else if (quoted
& Q_DOUBLE_QUOTES
)
9405 /* From Posix discussion on austin-group list: Backslash escaping
9406 a } in ${...} is removed. Issue 0000221 */
9407 if ((quoted
& Q_DOLBRACE
) && c
== RBRACE
)
9409 SCOPY_CHAR_I (twochars
, CTLESC
, c
, string
, sindex
, string_size
);
9411 /* This is the fix for " $@\ " */
9412 else if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && ((sh_syntaxtab
[c
] & tflag
) == 0) && isexp
== 0 && isifs (c
))
9414 RESIZE_MALLOCED_BUFFER (istring
, istring_index
, 2, istring_size
,
9415 DEFAULT_ARRAY_SIZE
);
9416 istring
[istring_index
++] = CTLESC
;
9417 istring
[istring_index
++] = '\\';
9418 istring
[istring_index
] = '\0';
9420 SCOPY_CHAR_I (twochars
, CTLESC
, c
, string
, sindex
, string_size
);
9422 else if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) && ((sh_syntaxtab
[c
] & tflag
) == 0))
9424 SCOPY_CHAR_I (twochars
, '\\', c
, string
, sindex
, string_size
);
9429 sindex
--; /* add_character: label increments sindex */
9434 SCOPY_CHAR_I (twochars
, CTLESC
, c
, string
, sindex
, string_size
);
9439 /* BEFORE jumping here, we need to increment sindex if appropriate */
9440 RESIZE_MALLOCED_BUFFER (istring
, istring_index
, 2, istring_size
,
9441 DEFAULT_ARRAY_SIZE
);
9442 istring
[istring_index
++] = twochars
[0];
9443 istring
[istring_index
++] = twochars
[1];
9444 istring
[istring_index
] = '\0';
9449 if ((quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
)) && ((quoted
& Q_ARITH
) == 0))
9453 temp
= string_extract_double_quoted (string
, &sindex
, (word
->flags
& W_COMPLETE
) ? SX_COMPLETE
: 0);
9455 /* If the quotes surrounded the entire string, then the
9456 whole word was quoted. */
9457 quoted_state
= (t_index
== 1 && string
[sindex
] == '\0')
9463 tword
= alloc_word_desc ();
9466 /* XXX - bash-4.4/bash-5.0 */
9467 if (word
->flags
& W_ASSIGNARG
)
9468 tword
->flags
|= word
->flags
& (W_ASSIGNARG
|W_ASSIGNRHS
); /* affects $@ */
9469 if (word
->flags
& W_COMPLETE
)
9470 tword
->flags
|= W_COMPLETE
; /* for command substitutions */
9471 if (word
->flags
& W_NOCOMSUB
)
9472 tword
->flags
|= W_NOCOMSUB
;
9473 if (word
->flags
& W_NOPROCSUB
)
9474 tword
->flags
|= W_NOPROCSUB
;
9476 temp
= (char *)NULL
;
9478 temp_has_dollar_at
= 0; /* XXX */
9479 /* Need to get W_HASQUOTEDNULL flag through this function. */
9480 list
= expand_word_internal (tword
, Q_DOUBLE_QUOTES
, 0, &temp_has_dollar_at
, (int *)NULL
);
9481 has_dollar_at
+= temp_has_dollar_at
;
9483 if (list
== &expand_word_error
|| list
== &expand_word_fatal
)
9487 /* expand_word_internal has already freed temp_word->word
9488 for us because of the way it prints error messages. */
9489 tword
->word
= (char *)NULL
;
9490 dispose_word (tword
);
9494 dispose_word (tword
);
9496 /* "$@" (a double-quoted dollar-at) expands into nothing,
9497 not even a NULL word, when there are no positional
9499 if (list
== 0 && temp_has_dollar_at
) /* XXX - was has_dollar_at */
9505 /* If we get "$@", we know we have expanded something, so we
9506 need to remember it for the final split on $IFS. This is
9507 a special case; it's the only case where a quoted string
9508 can expand into more than one word. It's going to come back
9509 from the above call to expand_word_internal as a list with
9510 a single word, in which all characters are quoted and
9511 separated by blanks. What we want to do is to turn it back
9512 into a list for the next piece of code. */
9514 dequote_list (list
);
9516 if (list
&& list
->word
&& (list
->word
->flags
& W_HASQUOTEDNULL
))
9517 had_quoted_null
= 1; /* XXX */
9519 if (temp_has_dollar_at
) /* XXX - was has_dollar_at */
9522 if (contains_dollar_at
)
9523 *contains_dollar_at
= 1;
9524 if (expanded_something
)
9525 *expanded_something
= 1;
9530 /* What we have is "". This is a minor optimization. */
9532 list
= (WORD_LIST
*)NULL
;
9535 /* The code above *might* return a list (consider the case of "$@",
9536 where it returns "$1", "$2", etc.). We can't throw away the
9537 rest of the list, and we have to make sure each word gets added
9538 as quoted. We test on tresult->next: if it is non-NULL, we
9539 quote the whole list, save it to a string with string_list, and
9540 add that string. We don't need to quote the results of this
9541 (and it would be wrong, since that would quote the separators
9542 as well), so we go directly to add_string. */
9547 /* Testing quoted_dollar_at makes sure that "$@" is
9548 split correctly when $IFS does not contain a space. */
9549 temp
= quoted_dollar_at
9550 ? string_list_dollar_at (list
, Q_DOUBLE_QUOTES
, 0)
9551 : string_list (quote_list (list
));
9552 dispose_words (list
);
9557 temp
= savestring (list
->word
->word
);
9558 tflag
= list
->word
->flags
;
9559 dispose_words (list
);
9561 /* If the string is not a quoted null string, we want
9562 to remove any embedded unquoted CTLNUL characters.
9563 We do not want to turn quoted null strings back into
9564 the empty string, though. We do this because we
9565 want to remove any quoted nulls from expansions that
9566 contain other characters. For example, if we have
9567 x"$*"y or "x$*y" and there are no positional parameters,
9568 the $* should expand into nothing. */
9569 /* We use the W_HASQUOTEDNULL flag to differentiate the
9570 cases: a quoted null character as above and when
9571 CTLNUL is contained in the (non-null) expansion
9572 of some variable. We use the had_quoted_null flag to
9573 pass the value through this function to its caller. */
9574 if ((tflag
& W_HASQUOTEDNULL
) && QUOTED_NULL (temp
) == 0)
9575 remove_quoted_nulls (temp
); /* XXX */
9579 temp
= (char *)NULL
;
9581 /* We do not want to add quoted nulls to strings that are only
9582 partially quoted; we can throw them away. The exception to
9583 this is when we are going to be performing word splitting,
9584 since we have to preserve a null argument if the next character
9585 will cause word splitting. */
9586 if (temp
== 0 && quoted_state
== PARTIALLY_QUOTED
&& (word
->flags
& (W_NOSPLIT
|W_NOSPLIT2
)))
9594 temp
= quote_string (temp
);
9602 sindex
--; /* add_character: label increments sindex */
9609 if ((quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
)))
9613 temp
= string_extract_single_quoted (string
, &sindex
);
9615 /* If the entire STRING was surrounded by single quotes,
9616 then the string is wholly quoted. */
9617 quoted_state
= (t_index
== 1 && string
[sindex
] == '\0')
9621 /* If all we had was '', it is a null expansion. */
9625 temp
= (char *)NULL
;
9628 remove_quoted_escapes (temp
); /* ??? */
9630 /* We do not want to add quoted nulls to strings that are only
9631 partially quoted; such nulls are discarded. See above for the
9632 exception, which is when the string is going to be split. */
9633 if (temp
== 0 && (quoted_state
== PARTIALLY_QUOTED
) && (word
->flags
& (W_NOSPLIT
|W_NOSPLIT2
)))
9636 /* If we have a quoted null expansion, add a quoted NULL to istring. */
9640 sindex
--; /* add_character: label increments sindex */
9644 goto add_quoted_string
;
9649 /* This is the fix for " $@ " */
9651 if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) || (isexp
== 0 && isifs (c
) && (word
->flags
& (W_NOSPLIT
|W_NOSPLIT2
)) == 0))
9653 if (string
[sindex
]) /* from old goto dollar_add_string */
9662 #if HANDLE_MULTIBYTE
9668 SADD_MBQCHAR_BODY(temp
, string
, sindex
, string_size
);
9673 twochars
[0] = CTLESC
;
9680 SADD_MBCHAR (temp
, string
, sindex
, string_size
);
9683 RESIZE_MALLOCED_BUFFER (istring
, istring_index
, 1, istring_size
,
9684 DEFAULT_ARRAY_SIZE
);
9685 istring
[istring_index
++] = c
;
9686 istring
[istring_index
] = '\0';
9688 /* Next character. */
9693 finished_with_string
:
9694 /* OK, we're ready to return. If we have a quoted string, and
9695 quoted_dollar_at is not set, we do no splitting at all; otherwise
9696 we split on ' '. The routines that call this will handle what to
9697 do if nothing has been expanded. */
9699 /* Partially and wholly quoted strings which expand to the empty
9700 string are retained as an empty arguments. Unquoted strings
9701 which expand to the empty string are discarded. The single
9702 exception is the case of expanding "$@" when there are no
9703 positional parameters. In that case, we discard the expansion. */
9705 /* Because of how the code that handles "" and '' in partially
9706 quoted strings works, we need to make ISTRING into a QUOTED_NULL
9707 if we saw quoting characters, but the expansion was empty.
9708 "" and '' are tossed away before we get to this point when
9709 processing partially quoted strings. This makes "" and $xxx""
9710 equivalent when xxx is unset. We also look to see whether we
9711 saw a quoted null from a ${} expansion and add one back if we
9714 /* If we expand to nothing and there were no single or double quotes
9715 in the word, we throw it away. Otherwise, we return a NULL word.
9716 The single exception is for $@ surrounded by double quotes when
9717 there are no positional parameters. In that case, we also throw
9720 if (*istring
== '\0')
9722 if (quoted_dollar_at
== 0 && (had_quoted_null
|| quoted_state
== PARTIALLY_QUOTED
))
9724 istring
[0] = CTLNUL
;
9726 tword
= make_bare_word (istring
);
9727 tword
->flags
|= W_HASQUOTEDNULL
; /* XXX */
9728 list
= make_word_list (tword
, (WORD_LIST
*)NULL
);
9729 if (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
))
9730 tword
->flags
|= W_QUOTED
;
9732 /* According to sh, ksh, and Posix.2, if a word expands into nothing
9733 and a double-quoted "$@" appears anywhere in it, then the entire
9735 /* XXX - exception appears to be that quoted null strings result in
9737 else if (quoted_state
== UNQUOTED
|| quoted_dollar_at
)
9738 list
= (WORD_LIST
*)NULL
;
9742 tword
= make_bare_word (istring
);
9743 if (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
))
9744 tword
->flags
|= W_QUOTED
;
9745 list
= make_word_list (tword
, (WORD_LIST
*)NULL
);
9749 list
= (WORD_LIST
*)NULL
;
9752 else if (word
->flags
& W_NOSPLIT
)
9754 tword
= make_bare_word (istring
);
9755 if (word
->flags
& W_ASSIGNMENT
)
9756 tword
->flags
|= W_ASSIGNMENT
; /* XXX */
9757 if (word
->flags
& W_COMPASSIGN
)
9758 tword
->flags
|= W_COMPASSIGN
; /* XXX */
9759 if (word
->flags
& W_NOGLOB
)
9760 tword
->flags
|= W_NOGLOB
; /* XXX */
9761 if (word
->flags
& W_NOBRACE
)
9762 tword
->flags
|= W_NOBRACE
; /* XXX */
9763 if (word
->flags
& W_NOEXPAND
)
9764 tword
->flags
|= W_NOEXPAND
; /* XXX */
9765 if (quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
))
9766 tword
->flags
|= W_QUOTED
;
9767 if (had_quoted_null
&& QUOTED_NULL (istring
))
9768 tword
->flags
|= W_HASQUOTEDNULL
;
9769 list
= make_word_list (tword
, (WORD_LIST
*)NULL
);
9776 ifs_chars
= (quoted_dollar_at
|| has_dollar_at
) ? ifs_value
: (char *)NULL
;
9778 /* If we have $@, we need to split the results no matter what. If
9779 IFS is unset or NULL, string_list_dollar_at has separated the
9780 positional parameters with a space, so we split on space (we have
9781 set ifs_chars to " \t\n" above if ifs is unset). If IFS is set,
9782 string_list_dollar_at has separated the positional parameters
9783 with the first character of $IFS, so we split on $IFS. If
9784 SPLIT_ON_SPACES is set, we expanded $* (unquoted) with IFS either
9785 unset or null, and we want to make sure that we split on spaces
9786 regardless of what else has happened to IFS since the expansion,
9787 or we expanded "$@" with IFS null and we need to split the positional
9788 parameters into separate words. */
9789 if (split_on_spaces
)
9790 list
= list_string (istring
, " ", 1); /* XXX quoted == 1? */
9791 /* If we have $@ (has_dollar_at != 0) and we are in a context where we
9792 don't want to split the result (W_NOSPLIT2), and we are not quoted,
9793 we have already separated the arguments with the first character of
9794 $IFS. In this case, we want to return a list with a single word
9795 with the separator possibly replaced with a space (it's what other
9797 quoted_dollar_at is internal to this function and is set if we are
9798 passed an argument that is unquoted (quoted == 0) but we encounter a
9799 double-quoted $@ while expanding it. */
9800 else if (has_dollar_at
&& quoted_dollar_at
== 0 && ifs_chars
&& quoted
== 0 && (word
->flags
& W_NOSPLIT2
))
9802 /* Only split and rejoin if we have to */
9803 if (*ifs_chars
&& *ifs_chars
!= ' ')
9805 list
= list_string (istring
, *ifs_chars
? ifs_chars
: " ", 1);
9806 tstring
= string_list (list
);
9810 tword
= make_bare_word (tstring
);
9811 if (tstring
!= istring
)
9813 goto set_word_flags
;
9815 /* This is the attempt to make $* in an assignment context (a=$*) and
9816 array variables subscripted with * in an assignment context (a=${foo[*]})
9817 behave similarly. It has side effects that, though they increase
9818 compatibility with other shells, are not backwards compatible. */
9820 else if (has_dollar_at
&& quoted
== 0 && ifs_chars
&& (word
->flags
& W_ASSIGNRHS
))
9822 tword
= make_bare_word (istring
);
9823 goto set_word_flags
;
9826 else if (has_dollar_at
&& ifs_chars
)
9827 list
= list_string (istring
, *ifs_chars
? ifs_chars
: " ", 1);
9830 tword
= make_bare_word (istring
);
9832 if ((quoted
& (Q_DOUBLE_QUOTES
|Q_HERE_DOCUMENT
)) || (quoted_state
== WHOLLY_QUOTED
))
9833 tword
->flags
|= W_QUOTED
;
9834 if (word
->flags
& W_ASSIGNMENT
)
9835 tword
->flags
|= W_ASSIGNMENT
;
9836 if (word
->flags
& W_COMPASSIGN
)
9837 tword
->flags
|= W_COMPASSIGN
;
9838 if (word
->flags
& W_NOGLOB
)
9839 tword
->flags
|= W_NOGLOB
;
9840 if (word
->flags
& W_NOBRACE
)
9841 tword
->flags
|= W_NOBRACE
;
9842 if (word
->flags
& W_NOEXPAND
)
9843 tword
->flags
|= W_NOEXPAND
;
9844 if (had_quoted_null
&& QUOTED_NULL (istring
))
9845 tword
->flags
|= W_HASQUOTEDNULL
; /* XXX */
9846 list
= make_word_list (tword
, (WORD_LIST
*)NULL
);
9854 /* **************************************************************** */
9856 /* Functions for Quote Removal */
9858 /* **************************************************************** */
9860 /* Perform quote removal on STRING. If QUOTED > 0, assume we are obeying the
9861 backslash quoting rules for within double quotes or a here document. */
9863 string_quote_removal (string
, quoted
)
9868 char *r
, *result_string
, *temp
, *send
;
9869 int sindex
, tindex
, dquote
;
9873 /* The result can be no longer than the original string. */
9874 slen
= strlen (string
);
9875 send
= string
+ slen
;
9877 r
= result_string
= (char *)xmalloc (slen
+ 1);
9879 for (dquote
= sindex
= 0; c
= string
[sindex
];)
9884 c
= string
[++sindex
];
9890 if (((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) || dquote
) && (sh_syntaxtab
[c
] & CBSDQUOTE
) == 0)
9895 SCOPY_CHAR_M (r
, string
, send
, sindex
);
9899 if ((quoted
& (Q_HERE_DOCUMENT
|Q_DOUBLE_QUOTES
)) || dquote
)
9905 tindex
= sindex
+ 1;
9906 temp
= string_extract_single_quoted (string
, &tindex
);
9917 dquote
= 1 - dquote
;
9923 return (result_string
);
9928 /* Perform quote removal on word WORD. This allocates and returns a new
9931 word_quote_removal (word
, quoted
)
9938 t
= string_quote_removal (word
->word
, quoted
);
9939 w
= alloc_word_desc ();
9940 w
->word
= t
? t
: savestring ("");
9944 /* Perform quote removal on all words in LIST. If QUOTED is non-zero,
9945 the members of the list are treated as if they are surrounded by
9946 double quotes. Return a new list, or NULL if LIST is NULL. */
9948 word_list_quote_removal (list
, quoted
)
9952 WORD_LIST
*result
, *t
, *tresult
, *e
;
9954 for (t
= list
, result
= (WORD_LIST
*)NULL
; t
; t
= t
->next
)
9956 tresult
= make_word_list (word_quote_removal (t
->word
, quoted
), (WORD_LIST
*)NULL
);
9958 result
= (WORD_LIST
*) list_append (result
, tresult
);
9961 result
= e
= tresult
;
9974 /*******************************************
9976 * Functions to perform word splitting *
9978 *******************************************/
9988 ifs_value
= (v
&& value_cell (v
)) ? value_cell (v
) : " \t\n";
9990 ifs_is_set
= ifs_var
!= 0;
9991 ifs_is_null
= ifs_is_set
&& (*ifs_value
== 0);
9993 /* Should really merge ifs_cmap with sh_syntaxtab. XXX - doesn't yet
9994 handle multibyte chars in IFS */
9995 memset (ifs_cmap
, '\0', sizeof (ifs_cmap
));
9996 for (t
= ifs_value
; t
&& *t
; t
++)
10002 #if defined (HANDLE_MULTIBYTE)
10003 if (ifs_value
== 0)
10005 ifs_firstc
[0] = '\0';
10006 ifs_firstc_len
= 1;
10011 ifs_len
= strnlen (ifs_value
, MB_CUR_MAX
);
10012 ifs_firstc_len
= MBLEN (ifs_value
, ifs_len
);
10013 if (ifs_firstc_len
== 1 || ifs_firstc_len
== 0 || MB_INVALIDCH (ifs_firstc_len
))
10015 ifs_firstc
[0] = ifs_value
[0];
10016 ifs_firstc
[1] = '\0';
10017 ifs_firstc_len
= 1;
10020 memcpy (ifs_firstc
, ifs_value
, ifs_firstc_len
);
10023 ifs_firstc
= ifs_value
? *ifs_value
: 0;
10033 /* This splits a single word into a WORD LIST on $IFS, but only if the word
10034 is not quoted. list_string () performs quote removal for us, even if we
10035 don't do any splitting. */
10037 word_split (w
, ifs_chars
)
10047 xifs
= ((w
->flags
& W_QUOTED
) || ifs_chars
== 0) ? "" : ifs_chars
;
10048 result
= list_string (w
->word
, xifs
, w
->flags
& W_QUOTED
);
10051 result
= (WORD_LIST
*)NULL
;
10056 /* Perform word splitting on LIST and return the RESULT. It is possible
10057 to return (WORD_LIST *)NULL. */
10059 word_list_split (list
)
10062 WORD_LIST
*result
, *t
, *tresult
, *e
;
10064 for (t
= list
, result
= (WORD_LIST
*)NULL
; t
; t
= t
->next
)
10066 tresult
= word_split (t
->word
, ifs_value
);
10068 result
= e
= tresult
;
10079 /**************************************************
10081 * Functions to expand an entire WORD_LIST *
10083 **************************************************/
10085 /* Do any word-expansion-specific cleanup and jump to top_level */
10087 exp_jump_to_top_level (v
)
10090 set_pipestatus_from_exit (last_command_exit_value
);
10092 /* Cleanup code goes here. */
10093 expand_no_split_dollar_star
= 0; /* XXX */
10094 expanding_redir
= 0;
10095 assigning_in_environment
= 0;
10097 if (parse_and_execute_level
== 0)
10098 top_level_cleanup (); /* from sig.c */
10100 jump_to_top_level (v
);
10103 /* Put NLIST (which is a WORD_LIST * of only one element) at the front of
10104 ELIST, and set ELIST to the new list. */
10105 #define PREPEND_LIST(nlist, elist) \
10106 do { nlist->next = elist; elist = nlist; } while (0)
10108 /* Separate out any initial variable assignments from TLIST. If set -k has
10109 been executed, remove all assignment statements from TLIST. Initial
10110 variable assignments and other environment assignments are placed
10111 on SUBST_ASSIGN_VARLIST. */
10113 separate_out_assignments (tlist
)
10116 register WORD_LIST
*vp
, *lp
;
10119 return ((WORD_LIST
*)NULL
);
10121 if (subst_assign_varlist
)
10122 dispose_words (subst_assign_varlist
); /* Clean up after previous error */
10124 subst_assign_varlist
= (WORD_LIST
*)NULL
;
10127 /* Separate out variable assignments at the start of the command.
10128 Loop invariant: vp->next == lp
10129 Loop postcondition:
10130 lp = list of words left after assignment statements skipped
10131 tlist = original list of words
10133 while (lp
&& (lp
->word
->flags
& W_ASSIGNMENT
))
10139 /* If lp != tlist, we have some initial assignment statements.
10140 We make SUBST_ASSIGN_VARLIST point to the list of assignment
10141 words and TLIST point to the remaining words. */
10144 subst_assign_varlist
= tlist
;
10145 /* ASSERT(vp->next == lp); */
10146 vp
->next
= (WORD_LIST
*)NULL
; /* terminate variable list */
10147 tlist
= lp
; /* remainder of word list */
10150 /* vp == end of variable list */
10151 /* tlist == remainder of original word list without variable assignments */
10153 /* All the words in tlist were assignment statements */
10154 return ((WORD_LIST
*)NULL
);
10156 /* ASSERT(tlist != NULL); */
10157 /* ASSERT((tlist->word->flags & W_ASSIGNMENT) == 0); */
10159 /* If the -k option is in effect, we need to go through the remaining
10160 words, separate out the assignment words, and place them on
10161 SUBST_ASSIGN_VARLIST. */
10162 if (place_keywords_in_env
)
10164 WORD_LIST
*tp
; /* tp == running pointer into tlist */
10169 /* Loop Invariant: tp->next == lp */
10170 /* Loop postcondition: tlist == word list without assignment statements */
10173 if (lp
->word
->flags
& W_ASSIGNMENT
)
10175 /* Found an assignment statement, add this word to end of
10176 subst_assign_varlist (vp). */
10177 if (!subst_assign_varlist
)
10178 subst_assign_varlist
= vp
= lp
;
10185 /* Remove the word pointed to by LP from TLIST. */
10186 tp
->next
= lp
->next
;
10187 /* ASSERT(vp == lp); */
10188 lp
->next
= (WORD_LIST
*)NULL
;
10201 #define WEXP_VARASSIGN 0x001
10202 #define WEXP_BRACEEXP 0x002
10203 #define WEXP_TILDEEXP 0x004
10204 #define WEXP_PARAMEXP 0x008
10205 #define WEXP_PATHEXP 0x010
10207 /* All of the expansions, including variable assignments at the start of
10209 #define WEXP_ALL (WEXP_VARASSIGN|WEXP_BRACEEXP|WEXP_TILDEEXP|WEXP_PARAMEXP|WEXP_PATHEXP)
10211 /* All of the expansions except variable assignments at the start of
10213 #define WEXP_NOVARS (WEXP_BRACEEXP|WEXP_TILDEEXP|WEXP_PARAMEXP|WEXP_PATHEXP)
10215 /* All of the `shell expansions': brace expansion, tilde expansion, parameter
10216 expansion, command substitution, arithmetic expansion, word splitting, and
10218 #define WEXP_SHELLEXP (WEXP_BRACEEXP|WEXP_TILDEEXP|WEXP_PARAMEXP)
10220 /* Take the list of words in LIST and do the various substitutions. Return
10221 a new list of words which is the expanded list, and without things like
10222 variable assignments. */
10225 expand_words (list
)
10228 return (expand_word_list_internal (list
, WEXP_ALL
));
10231 /* Same as expand_words (), but doesn't hack variable or environment
10234 expand_words_no_vars (list
)
10237 return (expand_word_list_internal (list
, WEXP_NOVARS
));
10241 expand_words_shellexp (list
)
10244 return (expand_word_list_internal (list
, WEXP_SHELLEXP
));
10248 glob_expand_word_list (tlist
, eflags
)
10252 char **glob_array
, *temp_string
;
10253 register int glob_index
;
10254 WORD_LIST
*glob_list
, *output_list
, *disposables
, *next
;
10257 output_list
= disposables
= (WORD_LIST
*)NULL
;
10258 glob_array
= (char **)NULL
;
10261 /* For each word, either globbing is attempted or the word is
10262 added to orig_list. If globbing succeeds, the results are
10263 added to orig_list and the word (tlist) is added to the list
10264 of disposable words. If globbing fails and failed glob
10265 expansions are left unchanged (the shell default), the
10266 original word is added to orig_list. If globbing fails and
10267 failed glob expansions are removed, the original word is
10268 added to the list of disposable words. orig_list ends up
10269 in reverse order and requires a call to REVERSE_LIST to
10270 be set right. After all words are examined, the disposable
10271 words are freed. */
10272 next
= tlist
->next
;
10274 /* If the word isn't an assignment and contains an unquoted
10275 pattern matching character, then glob it. */
10276 if ((tlist
->word
->flags
& W_NOGLOB
) == 0 &&
10277 unquoted_glob_pattern_p (tlist
->word
->word
))
10279 glob_array
= shell_glob_filename (tlist
->word
->word
);
10281 /* Handle error cases.
10282 I don't think we should report errors like "No such file
10283 or directory". However, I would like to report errors
10284 like "Read failed". */
10286 if (glob_array
== 0 || GLOB_FAILED (glob_array
))
10288 glob_array
= (char **)xmalloc (sizeof (char *));
10289 glob_array
[0] = (char *)NULL
;
10292 /* Dequote the current word in case we have to use it. */
10293 if (glob_array
[0] == NULL
)
10295 temp_string
= dequote_string (tlist
->word
->word
);
10296 free (tlist
->word
->word
);
10297 tlist
->word
->word
= temp_string
;
10300 /* Make the array into a word list. */
10301 glob_list
= (WORD_LIST
*)NULL
;
10302 for (glob_index
= 0; glob_array
[glob_index
]; glob_index
++)
10304 tword
= make_bare_word (glob_array
[glob_index
]);
10305 glob_list
= make_word_list (tword
, glob_list
);
10310 output_list
= (WORD_LIST
*)list_append (glob_list
, output_list
);
10311 PREPEND_LIST (tlist
, disposables
);
10313 else if (fail_glob_expansion
!= 0)
10315 last_command_exit_value
= EXECUTION_FAILURE
;
10316 report_error (_("no match: %s"), tlist
->word
->word
);
10317 exp_jump_to_top_level (DISCARD
);
10319 else if (allow_null_glob_expansion
== 0)
10321 /* Failed glob expressions are left unchanged. */
10322 PREPEND_LIST (tlist
, output_list
);
10326 /* Failed glob expressions are removed. */
10327 PREPEND_LIST (tlist
, disposables
);
10332 /* Dequote the string. */
10333 temp_string
= dequote_string (tlist
->word
->word
);
10334 free (tlist
->word
->word
);
10335 tlist
->word
->word
= temp_string
;
10336 PREPEND_LIST (tlist
, output_list
);
10339 strvec_dispose (glob_array
);
10340 glob_array
= (char **)NULL
;
10346 dispose_words (disposables
);
10349 output_list
= REVERSE_LIST (output_list
, WORD_LIST
*);
10351 return (output_list
);
10354 #if defined (BRACE_EXPANSION)
10356 brace_expand_word_list (tlist
, eflags
)
10360 register char **expansions
;
10362 WORD_LIST
*disposables
, *output_list
, *next
;
10366 for (disposables
= output_list
= (WORD_LIST
*)NULL
; tlist
; tlist
= next
)
10368 next
= tlist
->next
;
10370 if (tlist
->word
->flags
& W_NOBRACE
)
10372 /*itrace("brace_expand_word_list: %s: W_NOBRACE", tlist->word->word);*/
10373 PREPEND_LIST (tlist
, output_list
);
10377 if ((tlist
->word
->flags
& (W_COMPASSIGN
|W_ASSIGNARG
)) == (W_COMPASSIGN
|W_ASSIGNARG
))
10379 /*itrace("brace_expand_word_list: %s: W_COMPASSIGN|W_ASSIGNARG", tlist->word->word);*/
10380 PREPEND_LIST (tlist
, output_list
);
10384 /* Only do brace expansion if the word has a brace character. If
10385 not, just add the word list element to BRACES and continue. In
10386 the common case, at least when running shell scripts, this will
10387 degenerate to a bunch of calls to `mbschr', and then what is
10388 basically a reversal of TLIST into BRACES, which is corrected
10389 by a call to REVERSE_LIST () on BRACES when the end of TLIST
10391 if (mbschr (tlist
->word
->word
, LBRACE
))
10393 expansions
= brace_expand (tlist
->word
->word
);
10395 for (eindex
= 0; temp_string
= expansions
[eindex
]; eindex
++)
10397 w
= alloc_word_desc ();
10398 w
->word
= temp_string
;
10400 /* If brace expansion didn't change the word, preserve
10401 the flags. We may want to preserve the flags
10402 unconditionally someday -- XXX */
10403 if (STREQ (temp_string
, tlist
->word
->word
))
10404 w
->flags
= tlist
->word
->flags
;
10406 w
= make_word_flags (w
, temp_string
);
10408 output_list
= make_word_list (w
, output_list
);
10412 /* Add TLIST to the list of words to be freed after brace
10413 expansion has been performed. */
10414 PREPEND_LIST (tlist
, disposables
);
10417 PREPEND_LIST (tlist
, output_list
);
10421 dispose_words (disposables
);
10424 output_list
= REVERSE_LIST (output_list
, WORD_LIST
*);
10426 return (output_list
);
10430 #if defined (ARRAY_VARS)
10431 /* Take WORD, a compound associative array assignment, and internally run
10432 'declare -A w', where W is the variable name portion of WORD. */
10434 make_internal_declare (word
, option
, cmd
)
10443 w
= make_word (word
);
10445 t
= assignment (w
->word
, 0);
10446 if (w
->word
[t
] == '=')
10449 if (w
->word
[t
- 1] == '+') /* cut off any append op */
10450 w
->word
[t
- 1] = '\0';
10453 wl
= make_word_list (w
, (WORD_LIST
*)NULL
);
10454 wl
= make_word_list (make_word (option
), wl
);
10456 r
= declare_builtin (wl
);
10458 dispose_words (wl
);
10464 shell_expand_word_list (tlist
, eflags
)
10468 WORD_LIST
*expanded
, *orig_list
, *new_list
, *next
, *temp_list
, *wcmd
;
10469 int expanded_something
, has_dollar_at
;
10472 /* We do tilde expansion all the time. This is what 1003.2 says. */
10473 new_list
= (WORD_LIST
*)NULL
;
10474 for (wcmd
= tlist
; wcmd
; wcmd
= wcmd
->next
)
10475 if (wcmd
->word
->flags
& W_ASSNBLTIN
)
10478 for (orig_list
= tlist
; tlist
; tlist
= next
)
10480 temp_string
= tlist
->word
->word
;
10482 next
= tlist
->next
;
10484 #if defined (ARRAY_VARS)
10485 /* If this is a compound array assignment to a builtin that accepts
10486 such assignments (e.g., `declare'), take the assignment and perform
10487 it separately, handling the semantics of declarations inside shell
10488 functions. This avoids the double-evaluation of such arguments,
10489 because `declare' does some evaluation of compound assignments on
10491 if ((tlist
->word
->flags
& (W_COMPASSIGN
|W_ASSIGNARG
)) == (W_COMPASSIGN
|W_ASSIGNARG
))
10494 char opts
[16], opti
;
10497 if (tlist
->word
->flags
& (W_ASSIGNASSOC
|W_ASSNGLOBAL
|W_ASSIGNARRAY
))
10498 opts
[opti
++] = '-';
10500 if ((tlist
->word
->flags
& (W_ASSIGNASSOC
|W_ASSNGLOBAL
)) == (W_ASSIGNASSOC
|W_ASSNGLOBAL
))
10502 opts
[opti
++] = 'g';
10503 opts
[opti
++] = 'A';
10505 else if (tlist
->word
->flags
& W_ASSIGNASSOC
)
10506 opts
[opti
++] = 'A';
10507 else if ((tlist
->word
->flags
& (W_ASSIGNARRAY
|W_ASSNGLOBAL
)) == (W_ASSIGNARRAY
|W_ASSNGLOBAL
))
10509 opts
[opti
++] = 'g';
10510 opts
[opti
++] = 'a';
10512 else if (tlist
->word
->flags
& W_ASSIGNARRAY
)
10513 opts
[opti
++] = 'a';
10514 else if (tlist
->word
->flags
& W_ASSNGLOBAL
)
10515 opts
[opti
++] = 'g';
10517 /* If we have special handling note the integer attribute and others
10518 that transform the value upon assignment. What we do is take all
10519 of the option arguments and scan through them looking for options
10520 that cause such transformations, and add them to the `opts' array. */
10521 /* if (opti > 0) */
10527 memset (omap
, '\0', sizeof (omap
));
10528 for (l
= orig_list
->next
; l
!= tlist
; l
= l
->next
)
10530 if (l
->word
->word
[0] != '-')
10531 break; /* non-option argument */
10532 if (l
->word
->word
[0] == '-' && l
->word
->word
[1] == '-' && l
->word
->word
[2] == 0)
10533 break; /* -- signals end of options */
10534 for (oind
= 1; l
->word
->word
[oind
]; oind
++)
10535 switch (l
->word
->word
[oind
])
10541 omap
[l
->word
->word
[oind
]] = 1;
10543 opts
[opti
++] = '-';
10550 for (oind
= 0; oind
< sizeof (omap
); oind
++)
10552 opts
[opti
++] = oind
;
10558 t
= make_internal_declare (tlist
->word
->word
, opts
, wcmd
? wcmd
->word
->word
: (char *)0);
10559 if (t
!= EXECUTION_SUCCESS
)
10561 last_command_exit_value
= t
;
10562 exp_jump_to_top_level (DISCARD
);
10566 t
= do_word_assignment (tlist
->word
, 0);
10569 last_command_exit_value
= EXECUTION_FAILURE
;
10570 exp_jump_to_top_level (DISCARD
);
10573 /* Now transform the word as ksh93 appears to do and go on */
10574 t
= assignment (tlist
->word
->word
, 0);
10575 tlist
->word
->word
[t
] = '\0';
10576 if (tlist
->word
->word
[t
- 1] == '+')
10577 tlist
->word
->word
[t
- 1] = '\0'; /* cut off append op */
10578 tlist
->word
->flags
&= ~(W_ASSIGNMENT
|W_NOSPLIT
|W_COMPASSIGN
|W_ASSIGNARG
|W_ASSIGNASSOC
|W_ASSIGNARRAY
);
10582 expanded_something
= 0;
10583 expanded
= expand_word_internal
10584 (tlist
->word
, 0, 0, &has_dollar_at
, &expanded_something
);
10586 if (expanded
== &expand_word_error
|| expanded
== &expand_word_fatal
)
10588 /* By convention, each time this error is returned,
10589 tlist->word->word has already been freed. */
10590 tlist
->word
->word
= (char *)NULL
;
10592 /* Dispose our copy of the original list. */
10593 dispose_words (orig_list
);
10594 /* Dispose the new list we're building. */
10595 dispose_words (new_list
);
10597 last_command_exit_value
= EXECUTION_FAILURE
;
10598 if (expanded
== &expand_word_error
)
10599 exp_jump_to_top_level (DISCARD
);
10601 exp_jump_to_top_level (FORCE_EOF
);
10604 /* Don't split words marked W_NOSPLIT. */
10605 if (expanded_something
&& (tlist
->word
->flags
& W_NOSPLIT
) == 0)
10607 temp_list
= word_list_split (expanded
);
10608 dispose_words (expanded
);
10612 /* If no parameter expansion, command substitution, process
10613 substitution, or arithmetic substitution took place, then
10614 do not do word splitting. We still have to remove quoted
10615 null characters from the result. */
10616 word_list_remove_quoted_nulls (expanded
);
10617 temp_list
= expanded
;
10620 expanded
= REVERSE_LIST (temp_list
, WORD_LIST
*);
10621 new_list
= (WORD_LIST
*)list_append (expanded
, new_list
);
10625 dispose_words (orig_list
);
10628 new_list
= REVERSE_LIST (new_list
, WORD_LIST
*);
10633 /* The workhorse for expand_words () and expand_words_no_vars ().
10634 First arg is LIST, a WORD_LIST of words.
10635 Second arg EFLAGS is a flags word controlling which expansions are
10638 This does all of the substitutions: brace expansion, tilde expansion,
10639 parameter expansion, command substitution, arithmetic expansion,
10640 process substitution, word splitting, and pathname expansion, according
10641 to the bits set in EFLAGS. Words with the W_QUOTED or W_NOSPLIT bits
10642 set, or for which no expansion is done, do not undergo word splitting.
10643 Words with the W_NOGLOB bit set do not undergo pathname expansion; words
10644 with W_NOBRACE set do not undergo brace expansion (see
10645 brace_expand_word_list above). */
10647 expand_word_list_internal (list
, eflags
)
10651 WORD_LIST
*new_list
, *temp_list
;
10655 tempenv_assign_error
= 0;
10657 return ((WORD_LIST
*)NULL
);
10659 garglist
= new_list
= copy_word_list (list
);
10660 if (eflags
& WEXP_VARASSIGN
)
10662 garglist
= new_list
= separate_out_assignments (new_list
);
10665 if (subst_assign_varlist
)
10667 /* All the words were variable assignments, so they are placed
10668 into the shell's environment. */
10669 for (temp_list
= subst_assign_varlist
; temp_list
; temp_list
= temp_list
->next
)
10671 savecmd
= this_command_name
;
10672 this_command_name
= (char *)NULL
; /* no arithmetic errors */
10673 tint
= do_word_assignment (temp_list
->word
, 0);
10674 this_command_name
= savecmd
;
10675 /* Variable assignment errors in non-interactive shells
10676 running in Posix.2 mode cause the shell to exit. */
10679 last_command_exit_value
= EXECUTION_FAILURE
;
10680 if (interactive_shell
== 0 && posixly_correct
)
10681 exp_jump_to_top_level (FORCE_EOF
);
10683 exp_jump_to_top_level (DISCARD
);
10686 dispose_words (subst_assign_varlist
);
10687 subst_assign_varlist
= (WORD_LIST
*)NULL
;
10689 return ((WORD_LIST
*)NULL
);
10693 /* Begin expanding the words that remain. The expansions take place on
10694 things that aren't really variable assignments. */
10696 #if defined (BRACE_EXPANSION)
10697 /* Do brace expansion on this word if there are any brace characters
10699 if ((eflags
& WEXP_BRACEEXP
) && brace_expansion
&& new_list
)
10700 new_list
= brace_expand_word_list (new_list
, eflags
);
10701 #endif /* BRACE_EXPANSION */
10703 /* Perform the `normal' shell expansions: tilde expansion, parameter and
10704 variable substitution, command substitution, arithmetic expansion,
10705 and word splitting. */
10706 new_list
= shell_expand_word_list (new_list
, eflags
);
10708 /* Okay, we're almost done. Now let's just do some filename
10712 if ((eflags
& WEXP_PATHEXP
) && disallow_filename_globbing
== 0)
10713 /* Glob expand the word list unless globbing has been disabled. */
10714 new_list
= glob_expand_word_list (new_list
, eflags
);
10716 /* Dequote the words, because we're not performing globbing. */
10717 new_list
= dequote_list (new_list
);
10720 if ((eflags
& WEXP_VARASSIGN
) && subst_assign_varlist
)
10722 sh_wassign_func_t
*assign_func
;
10723 int is_special_builtin
, is_builtin_or_func
;
10725 /* If the remainder of the words expand to nothing, Posix.2 requires
10726 that the variable and environment assignments affect the shell's
10728 assign_func
= new_list
? assign_in_env
: do_word_assignment
;
10729 tempenv_assign_error
= 0;
10731 is_builtin_or_func
= (new_list
&& new_list
->word
&& (find_shell_builtin (new_list
->word
->word
) || find_function (new_list
->word
->word
)));
10732 /* Posix says that special builtins exit if a variable assignment error
10733 occurs in an assignment preceding it. */
10734 is_special_builtin
= (posixly_correct
&& new_list
&& new_list
->word
&& find_special_builtin (new_list
->word
->word
));
10736 for (temp_list
= subst_assign_varlist
; temp_list
; temp_list
= temp_list
->next
)
10738 savecmd
= this_command_name
;
10739 this_command_name
= (char *)NULL
;
10740 assigning_in_environment
= (assign_func
== assign_in_env
);
10741 tint
= (*assign_func
) (temp_list
->word
, is_builtin_or_func
);
10742 assigning_in_environment
= 0;
10743 this_command_name
= savecmd
;
10744 /* Variable assignment errors in non-interactive shells running
10745 in Posix.2 mode cause the shell to exit. */
10748 if (assign_func
== do_word_assignment
)
10750 last_command_exit_value
= EXECUTION_FAILURE
;
10751 if (interactive_shell
== 0 && posixly_correct
&& is_special_builtin
)
10752 exp_jump_to_top_level (FORCE_EOF
);
10754 exp_jump_to_top_level (DISCARD
);
10757 tempenv_assign_error
++;
10761 dispose_words (subst_assign_varlist
);
10762 subst_assign_varlist
= (WORD_LIST
*)NULL
;