1 /* $NetBSD: for.c,v 1.170 2022/09/03 00:50:07 rillig 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 * Handling of .for/.endfor loops in a makefile.
35 * For loops have the form:
37 * .for <varname...> in <value...>
41 * When a .for line is parsed, the following lines are copied to the body of
42 * the .for loop, until the corresponding .endfor line is reached. In this
43 * phase, the body is not yet evaluated. This also applies to any nested
46 * After reaching the .endfor, the values from the .for line are grouped
47 * according to the number of variables. For each such group, the unexpanded
48 * body is scanned for variable expressions, and those that match the
49 * variable names are replaced with expressions of the form ${:U...}. After
50 * that, the body is treated like a file from an .include directive.
53 * For_Eval Evaluate the loop in the passed line.
55 * For_Run Run accumulated loop
60 /* "@(#)for.c 8.1 (Berkeley) 6/6/93" */
61 MAKE_RCSID("$NetBSD: for.c,v 1.170 2022/09/03 00:50:07 rillig Exp $");
64 typedef struct ForLoop
{
65 Vector
/* of 'char *' */ vars
; /* Iteration variables */
66 SubstringWords items
; /* Substitution items */
67 Buffer body
; /* Unexpanded body of the loop */
68 unsigned int nextItem
; /* Where to continue iterating */
72 static ForLoop
*accumFor
; /* Loop being accumulated */
78 ForLoop
*f
= bmake_malloc(sizeof *f
);
80 Vector_Init(&f
->vars
, sizeof(char *));
81 SubstringWords_Init(&f
->items
);
89 ForLoop_Free(ForLoop
*f
)
91 while (f
->vars
.len
> 0)
92 free(*(char **)Vector_Pop(&f
->vars
));
93 Vector_Done(&f
->vars
);
95 SubstringWords_Free(f
->items
);
102 ForLoop_Details(ForLoop
*f
)
106 const Substring
*items
;
110 vars
= f
->vars
.items
;
111 assert(f
->nextItem
>= n
);
112 items
= f
->items
.words
+ f
->nextItem
- n
;
115 for (i
= 0; i
< n
; i
++) {
117 Buf_AddStr(&buf
, ", ");
118 Buf_AddStr(&buf
, vars
[i
]);
119 Buf_AddStr(&buf
, " = ");
120 Buf_AddBytesBetween(&buf
, items
[i
].start
, items
[i
].end
);
122 return Buf_DoneData(&buf
);
126 ForLoop_ParseVarnames(ForLoop
*f
, const char **pp
)
133 cpp_skip_whitespace(&p
);
135 Parse_Error(PARSE_FATAL
, "missing `in' in for");
140 * XXX: This allows arbitrary variable names;
141 * see directive-for.mk.
143 for (len
= 1; p
[len
] != '\0' && !ch_isspace(p
[len
]); len
++)
146 if (len
== 2 && p
[0] == 'i' && p
[1] == 'n') {
151 *(char **)Vector_Push(&f
->vars
) = bmake_strldup(p
, len
);
155 if (f
->vars
.len
== 0) {
156 Parse_Error(PARSE_FATAL
, "no iteration variables in for");
165 ForLoop_ParseItems(ForLoop
*f
, const char *p
)
169 cpp_skip_whitespace(&p
);
171 if (Var_Subst(p
, SCOPE_GLOBAL
, VARE_WANTRES
, &items
) != VPR_OK
) {
172 Parse_Error(PARSE_FATAL
, "Error in .for loop items");
176 f
->items
= Substring_Words(items
, false);
179 if (f
->items
.len
== 1 && Substring_IsEmpty(f
->items
.words
[0]))
180 f
->items
.len
= 0; /* .for var in ${:U} */
182 if (f
->items
.len
% f
->vars
.len
!= 0) {
183 Parse_Error(PARSE_FATAL
,
184 "Wrong number of words (%u) in .for "
185 "substitution list with %u variables",
186 (unsigned)f
->items
.len
, (unsigned)f
->vars
.len
);
196 return p
[0] == 'f' && p
[1] == 'o' && p
[2] == 'r' && ch_isspace(p
[3]);
200 IsEndfor(const char *p
)
202 return p
[0] == 'e' && strncmp(p
, "endfor", 6) == 0 &&
203 (p
[6] == '\0' || ch_isspace(p
[6]));
207 * Evaluate the for loop in the passed line. The line looks like this:
208 * .for <varname...> in <value...>
211 * 0 not a .for directive
212 * 1 found a .for directive
213 * -1 erroneous .for directive
216 For_Eval(const char *line
)
221 p
= line
+ 1; /* skip the '.' */
222 cpp_skip_whitespace(&p
);
228 if (!ForLoop_ParseVarnames(f
, &p
)) {
232 if (!ForLoop_ParseItems(f
, p
))
233 f
->items
.len
= 0; /* don't iterate */
237 } else if (IsEndfor(p
)) {
238 Parse_Error(PARSE_FATAL
, "for-less endfor");
245 * Add another line to the .for loop that is being built up.
246 * Returns false when the matching .endfor is reached.
249 For_Accum(const char *line
, int *forLevel
)
251 const char *p
= line
;
255 cpp_skip_whitespace(&p
);
258 DEBUG1(FOR
, "For: end for %d\n", *forLevel
);
259 if (--*forLevel
== 0)
261 } else if (IsFor(p
)) {
263 DEBUG1(FOR
, "For: new loop %d\n", *forLevel
);
267 Buf_AddStr(&accumFor
->body
, line
);
268 Buf_AddByte(&accumFor
->body
, '\n');
273 * When the body of a '.for i' loop is prepared for an iteration, each
274 * occurrence of $i in the body is replaced with ${:U...}, inserting the
275 * value of the item. If this item contains a '$', it may be the start of a
276 * variable expression. This expression is copied verbatim, its length is
277 * determined here, in a rather naive way, ignoring escape characters and
278 * funny delimiters in modifiers like ':S}from}to}'.
281 ExprLen(const char *s
, const char *e
)
283 char expr_open
, expr_close
;
288 return 0; /* just escape the '$' */
291 if (expr_open
== '(')
293 else if (expr_open
== '{')
296 return 1; /* Single char variable */
299 for (p
= s
+ 1; p
!= e
; p
++) {
302 else if (*p
== expr_close
&& --depth
== 0)
303 return (size_t)(p
+ 1 - s
);
306 /* Expression end not found, escape the $ */
311 * The .for loop substitutes the items as ${:U<value>...}, which means
312 * that characters that break this syntax must be backslash-escaped.
315 NeedsEscapes(Substring value
, char endc
)
319 for (p
= value
.start
; p
!= value
.end
; p
++) {
320 if (*p
== ':' || *p
== '$' || *p
== '\\' || *p
== endc
||
328 * While expanding the body of a .for loop, write the item in the ${:U...}
329 * expression, escaping characters as needed. The result is later unescaped
330 * by ApplyModifier_Defined.
333 AddEscaped(Buffer
*cmds
, Substring item
, char endc
)
338 if (!NeedsEscapes(item
, endc
)) {
339 Buf_AddBytesBetween(cmds
, item
.start
, item
.end
);
343 for (p
= item
.start
; p
!= item
.end
;) {
346 size_t len
= ExprLen(p
+ 1, item
.end
);
349 * XXX: Should a '\' be added here?
350 * See directive-for-escape.mk, ExprLen.
352 Buf_AddBytes(cmds
, p
, 1 + len
);
356 Buf_AddByte(cmds
, '\\');
357 } else if (ch
== ':' || ch
== '\\' || ch
== endc
)
358 Buf_AddByte(cmds
, '\\');
359 else if (ch
== '\n') {
360 Parse_Error(PARSE_FATAL
, "newline in .for value");
361 ch
= ' '; /* prevent newline injection */
363 Buf_AddByte(cmds
, ch
);
369 * When expanding the body of a .for loop, replace the variable name of an
370 * expression like ${i} or ${i:...} or $(i) or $(i:...) with ":Uvalue".
373 ForLoop_SubstVarLong(ForLoop
*f
, unsigned int firstItem
, Buffer
*body
,
374 const char **pp
, char endc
, const char **inout_mark
)
377 const char *start
= *pp
;
378 const char **vars
= Vector_Get(&f
->vars
, 0);
380 for (i
= 0; i
< f
->vars
.len
; i
++) {
381 const char *p
= start
;
383 if (!cpp_skip_string(&p
, vars
[i
]))
385 /* XXX: why test for backslash here? */
386 if (*p
!= ':' && *p
!= endc
&& *p
!= '\\')
390 * Found a variable match. Skip over the variable name and
391 * instead add ':U<value>' to the current body.
393 Buf_AddBytesBetween(body
, *inout_mark
, start
);
394 Buf_AddStr(body
, ":U");
395 AddEscaped(body
, f
->items
.words
[firstItem
+ i
], endc
);
404 * When expanding the body of a .for loop, replace single-character
405 * variable expressions like $i with their ${:U...} expansion.
408 ForLoop_SubstVarShort(ForLoop
*f
, unsigned int firstItem
, Buffer
*body
,
409 const char *p
, const char **inout_mark
)
415 /* Skip $$ and stupid ones. */
416 if (ch
== '}' || ch
== ')' || ch
== ':' || ch
== '$')
419 vars
= Vector_Get(&f
->vars
, 0);
420 for (i
= 0; i
< f
->vars
.len
; i
++) {
421 const char *varname
= vars
[i
];
422 if (varname
[0] == ch
&& varname
[1] == '\0')
428 Buf_AddBytesBetween(body
, *inout_mark
, p
);
431 /* Replace $<ch> with ${:U<value>} */
432 Buf_AddStr(body
, "{:U");
433 AddEscaped(body
, f
->items
.words
[firstItem
+ i
], '}');
434 Buf_AddByte(body
, '}');
438 * Compute the body for the current iteration by copying the unexpanded body,
439 * replacing the expressions for the iteration variables on the way.
441 * Using variable expressions ensures that the .for loop can't generate
442 * syntax, and that the later parsing will still see a variable.
443 * This code assumes that the variable with the empty name will never be
444 * defined, see unit-tests/varname-empty.mk for more details.
446 * The detection of substitutions of the loop control variables is naive.
447 * Many of the modifiers use '\$' instead of '$$' to escape '$', so it is
448 * possible to contrive a makefile where an unwanted substitution happens.
451 ForLoop_SubstBody(ForLoop
*f
, unsigned int firstItem
, Buffer
*body
)
454 const char *mark
; /* where the last substitution left off */
459 end
= f
->body
.data
+ f
->body
.len
;
460 for (p
= mark
; (p
= strchr(p
, '$')) != NULL
;) {
461 if (p
[1] == '{' || p
[1] == '(') {
462 char endc
= p
[1] == '{' ? '}' : ')';
464 ForLoop_SubstVarLong(f
, firstItem
, body
,
466 } else if (p
[1] != '\0') {
467 ForLoop_SubstVarShort(f
, firstItem
, body
,
474 Buf_AddBytesBetween(body
, mark
, end
);
478 * Compute the body for the current iteration by copying the unexpanded body,
479 * replacing the expressions for the iteration variables on the way.
482 For_NextIteration(ForLoop
*f
, Buffer
*body
)
484 if (f
->nextItem
== f
->items
.len
)
487 f
->nextItem
+= (unsigned int)f
->vars
.len
;
488 ForLoop_SubstBody(f
, f
->nextItem
- (unsigned int)f
->vars
.len
, body
);
489 DEBUG1(FOR
, "For: loop body:\n%s", body
->data
);
493 /* Break out of the .for loop. */
495 For_Break(ForLoop
*f
)
497 f
->nextItem
= (unsigned int)f
->items
.len
;
500 /* Run the .for loop, imitating the actions of an include file. */
502 For_Run(unsigned headLineno
, unsigned bodyReadLines
)
505 ForLoop
*f
= accumFor
;
508 if (f
->items
.len
> 0) {
510 Parse_PushInput(NULL
, headLineno
, bodyReadLines
, buf
, f
);