1 /* $NetBSD: for.c,v 1.52 2016/02/18 18:29:14 christos Exp $ */
4 * Copyright (c) 1992, The Regents of the University of California.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 static char rcsid[] = "$NetBSD: for.c,v 1.52 2016/02/18 18:29:14 christos Exp $";
35 #include <sys/cdefs.h>
38 static char sccsid[] = "@(#)for.c 8.1 (Berkeley) 6/6/93";
40 __RCSID("$NetBSD: for.c,v 1.52 2016/02/18 18:29:14 christos Exp $");
47 * Functions to handle loops in a makefile.
50 * For_Eval Evaluate the loop in the passed line.
51 * For_Run Run accumulated loop
64 #define FOR_SUB_ESCAPE_CHAR 1
65 #define FOR_SUB_ESCAPE_BRACE 2
66 #define FOR_SUB_ESCAPE_PAREN 4
69 * For statements are of the form:
71 * .for <variable> in <varlist>
75 * The trick is to look for the matching end inside for for loop
76 * To do that, we count the current nesting level of the for loops.
77 * and the .endfor statements, accumulating all the statements between
78 * the initial .for loop and the matching .endfor;
79 * then we evaluate the for loop for each variable in the varlist.
81 * Note that any nested fors are just passed through; they get handled
82 * recursively in For_Eval when we're expanding the enclosing for in
86 static int forLevel = 0; /* Nesting level */
89 * State of a for loop.
92 Buffer buf; /* Body of loop */
93 strlist_t vars; /* Iteration variables */
94 strlist_t items; /* Substitution items */
100 static For *accumFor; /* Loop being accumulated */
105 make_str(const char *ptr, int len)
109 new_ptr = bmake_malloc(len + 1);
110 memcpy(new_ptr, ptr, len);
118 Buf_Destroy(&arg->buf, TRUE);
119 strlist_clean(&arg->vars);
120 strlist_clean(&arg->items);
121 free(arg->parse_buf);
127 *-----------------------------------------------------------------------
129 * Evaluate the for loop in the passed line. The line
131 * .for <variable> in <varlist>
137 * 0: Not a .for statement, parse the line
138 * 1: We found a for loop
139 * -1: A .for statement with a bad syntax error, discard.
144 *-----------------------------------------------------------------------
150 char *ptr = line, *sub;
154 char **words, *word_buf;
157 /* Skip the '.' and any following whitespace */
158 for (ptr++; *ptr && isspace((unsigned char) *ptr); ptr++)
162 * If we are not in a for loop quickly determine if the statement is
165 if (ptr[0] != 'f' || ptr[1] != 'o' || ptr[2] != 'r' ||
166 !isspace((unsigned char) ptr[3])) {
167 if (ptr[0] == 'e' && strncmp(ptr+1, "ndfor", 5) == 0) {
168 Parse_Error(PARSE_FATAL, "for-less endfor");
176 * we found a for loop, and now we are going to parse it.
179 new_for = bmake_malloc(sizeof *new_for);
180 memset(new_for, 0, sizeof *new_for);
182 /* Grab the variables. Terminate on "in". */
183 for (;; ptr += len) {
184 while (*ptr && isspace((unsigned char) *ptr))
187 Parse_Error(PARSE_FATAL, "missing `in' in for");
191 for (len = 1; ptr[len] && !isspace((unsigned char)ptr[len]); len++)
193 if (len == 2 && ptr[0] == 'i' && ptr[1] == 'n') {
198 new_for->short_var = 1;
199 strlist_add_str(&new_for->vars, make_str(ptr, len), len);
202 if (strlist_num(&new_for->vars) == 0) {
203 Parse_Error(PARSE_FATAL, "no iteration variables in for");
208 while (*ptr && isspace((unsigned char) *ptr))
212 * Make a list with the remaining words
213 * The values are substituted as ${:U<value>...} so we must \ escape
214 * characters that break that syntax.
215 * Variables are fully expanded - so it is safe for escape $.
216 * We can't do the escapes here - because we don't know whether
217 * we are substuting into ${...} or $(...).
219 sub = Var_Subst(NULL, ptr, VAR_GLOBAL, VARF_WANTRES);
222 * Split into words allowing for quoted strings.
224 words = brk_string(sub, &nwords, FALSE, &word_buf);
229 for (n = 0; n < nwords; n++) {
234 while ((ch = *ptr++)) {
239 escapes |= FOR_SUB_ESCAPE_CHAR;
242 escapes |= FOR_SUB_ESCAPE_PAREN;
245 escapes |= FOR_SUB_ESCAPE_BRACE;
250 * We have to dup words[n] to maintain the semantics of
253 strlist_add_str(&new_for->items, bmake_strdup(words[n]), escapes);
259 if ((len = strlist_num(&new_for->items)) > 0 &&
260 len % (n = strlist_num(&new_for->vars))) {
261 Parse_Error(PARSE_FATAL,
262 "Wrong number of words (%d) in .for substitution list"
263 " with %d vars", len, n);
265 * Return 'success' so that the body of the .for loop is
267 * Remove all items so that the loop doesn't iterate.
269 strlist_clean(&new_for->items);
273 Buf_Init(&new_for->buf, 0);
280 * Add another line to a .for loop.
281 * Returns 0 when the matching .endfor is reached.
285 For_Accum(char *line)
291 for (ptr++; *ptr && isspace((unsigned char) *ptr); ptr++)
294 if (strncmp(ptr, "endfor", 6) == 0 &&
295 (isspace((unsigned char) ptr[6]) || !ptr[6])) {
297 (void)fprintf(debug_file, "For: end for %d\n", forLevel);
300 } else if (strncmp(ptr, "for", 3) == 0 &&
301 isspace((unsigned char) ptr[3])) {
304 (void)fprintf(debug_file, "For: new loop %d\n", forLevel);
308 Buf_AddBytes(&accumFor->buf, strlen(line), line);
309 Buf_AddByte(&accumFor->buf, '\n');
315 *-----------------------------------------------------------------------
317 * Run the for loop, imitating the actions of an include file
325 *-----------------------------------------------------------------------
329 for_var_len(const char *var)
331 char ch, var_start, var_end;
337 /* just escape the $ */
340 if (var_start == '(')
342 else if (var_start == '{')
345 /* Single char variable */
349 for (len = 1; (ch = var[len++]) != 0;) {
352 else if (ch == var_end && --depth == 0)
356 /* Variable end not found, escape the $ */
361 for_substitute(Buffer *cmds, strlist_t *items, unsigned int item_no, char ech)
363 const char *item = strlist_str(items, item_no);
367 /* If there were no escapes, or the only escape is the other variable
368 * terminator, then just substitute the full string */
369 if (!(strlist_info(items, item_no) &
370 (ech == ')' ? ~FOR_SUB_ESCAPE_BRACE : ~FOR_SUB_ESCAPE_PAREN))) {
371 Buf_AddBytes(cmds, strlen(item), item);
375 /* Escape ':', '$', '\\' and 'ech' - removed by :U processing */
376 while ((ch = *item++) != 0) {
378 len = for_var_len(item);
380 Buf_AddBytes(cmds, len + 1, item - 1);
384 Buf_AddByte(cmds, '\\');
385 } else if (ch == ':' || ch == '\\' || ch == ech)
386 Buf_AddByte(cmds, '\\');
387 Buf_AddByte(cmds, ch);
392 For_Iterate(void *v_arg, size_t *ret_len)
403 if (arg->sub_next + strlist_num(&arg->vars) > strlist_num(&arg->items)) {
404 /* No more iterations */
409 free(arg->parse_buf);
410 arg->parse_buf = NULL;
413 * Scan the for loop body and replace references to the loop variables
414 * with variable references that expand to the required text.
415 * Using variable expansions ensures that the .for loop can't generate
416 * syntax, and that the later parsing will still see a variable.
417 * We assume that the null variable will never be defined.
419 * The detection of substitions of the loop control variable is naive.
420 * Many of the modifiers use \ to escape $ (not $) so it is possible
421 * to contrive a makefile where an unwanted substitution happens.
424 cmd_cp = Buf_GetAll(&arg->buf, &len);
425 body_end = cmd_cp + len;
426 Buf_Init(&cmds, len + 256);
427 for (cp = cmd_cp; (cp = strchr(cp, '$')) != NULL;) {
430 if ((ch == '(' && (ech = ')')) || (ch == '{' && (ech = '}'))) {
432 /* Check variable name against the .for loop variables */
433 STRLIST_FOREACH(var, &arg->vars, i) {
434 len = strlist_info(&arg->vars, i);
435 if (memcmp(cp, var, len) != 0)
437 if (cp[len] != ':' && cp[len] != ech && cp[len] != '\\')
439 /* Found a variable match. Replace with :U<value> */
440 Buf_AddBytes(&cmds, cp - cmd_cp, cmd_cp);
441 Buf_AddBytes(&cmds, 2, ":U");
444 for_substitute(&cmds, &arg->items, arg->sub_next + i, ech);
451 /* Probably a single character name, ignore $$ and stupid ones. {*/
452 if (!arg->short_var || strchr("}):$", ch) != NULL) {
456 STRLIST_FOREACH(var, &arg->vars, i) {
457 if (var[0] != ch || var[1] != 0)
459 /* Found a variable match. Replace with ${:U<value>} */
460 Buf_AddBytes(&cmds, cp - cmd_cp, cmd_cp);
461 Buf_AddBytes(&cmds, 3, "{:U");
463 for_substitute(&cmds, &arg->items, arg->sub_next + i, /*{*/ '}');
464 Buf_AddBytes(&cmds, 1, "}");
468 Buf_AddBytes(&cmds, body_end - cmd_cp, cmd_cp);
470 cp = Buf_Destroy(&cmds, FALSE);
472 (void)fprintf(debug_file, "For: loop body:\n%s", cp);
474 arg->sub_next += strlist_num(&arg->vars);
477 *ret_len = strlen(cp);
489 if (strlist_num(&arg->items) == 0) {
490 /* Nothing to expand - possibly due to an earlier syntax error. */
495 Parse_SetInput(NULL, lineno, -1, For_Iterate, arg);