1/*	$NetBSD: for.c,v 1.47 2010/02/06 20:37:13 dholland Exp $	*/
2
3/*
4 * Copyright (c) 1992, The Regents of the University of California.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
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.
18 *
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
29 * SUCH DAMAGE.
30 */
31
32#ifndef MAKE_NATIVE
33static char rcsid[] = "$NetBSD: for.c,v 1.47 2010/02/06 20:37:13 dholland Exp $";
34#else
35#include <sys/cdefs.h>
36#ifndef lint
37#if 0
38static char sccsid[] = "@(#)for.c	8.1 (Berkeley) 6/6/93";
39#else
40__RCSID("$NetBSD: for.c,v 1.47 2010/02/06 20:37:13 dholland Exp $");
41#endif
42#endif /* not lint */
43#endif
44
45/*-
46 * for.c --
47 *	Functions to handle loops in a makefile.
48 *
49 * Interface:
50 *	For_Eval 	Evaluate the loop in the passed line.
51 *	For_Run		Run accumulated loop
52 *
53 */
54
55#include    <assert.h>
56#include    <ctype.h>
57
58#include    "make.h"
59#include    "hash.h"
60#include    "dir.h"
61#include    "buf.h"
62#include    "strlist.h"
63
64#define FOR_SUB_ESCAPE_CHAR  1
65#define FOR_SUB_ESCAPE_BRACE 2
66#define FOR_SUB_ESCAPE_PAREN 4
67
68/*
69 * For statements are of the form:
70 *
71 * .for <variable> in <varlist>
72 * ...
73 * .endfor
74 *
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.
80 *
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
83 * For_Run.
84 */
85
86static int  	  forLevel = 0;  	/* Nesting level	*/
87
88/*
89 * State of a for loop.
90 */
91typedef struct _For {
92    Buffer	  buf;			/* Body of loop		*/
93    strlist_t     vars;			/* Iteration variables	*/
94    strlist_t     items;		/* Substitution items */
95    char          *parse_buf;
96    int           short_var;
97    int           sub_next;
98} For;
99
100static For        *accumFor;            /* Loop being accumulated */
101
102
103
104static char *
105make_str(const char *ptr, int len)
106{
107	char *new_ptr;
108
109	new_ptr = bmake_malloc(len + 1);
110	memcpy(new_ptr, ptr, len);
111	new_ptr[len] = 0;
112	return new_ptr;
113}
114
115static void
116For_Free(For *arg)
117{
118    Buf_Destroy(&arg->buf, TRUE);
119    strlist_clean(&arg->vars);
120    strlist_clean(&arg->items);
121    free(arg->parse_buf);
122
123    free(arg);
124}
125
126/*-
127 *-----------------------------------------------------------------------
128 * For_Eval --
129 *	Evaluate the for loop in the passed line. The line
130 *	looks like this:
131 *	    .for <variable> in <varlist>
132 *
133 * Input:
134 *	line		Line to parse
135 *
136 * Results:
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.
140 *
141 * Side Effects:
142 *	None.
143 *
144 *-----------------------------------------------------------------------
145 */
146int
147For_Eval(char *line)
148{
149    For *new_for;
150    char *ptr = line, *sub;
151    int len;
152    int escapes;
153    unsigned char ch;
154
155    /* Skip the '.' and any following whitespace */
156    for (ptr++; *ptr && isspace((unsigned char) *ptr); ptr++)
157	continue;
158
159    /*
160     * If we are not in a for loop quickly determine if the statement is
161     * a for.
162     */
163    if (ptr[0] != 'f' || ptr[1] != 'o' || ptr[2] != 'r' ||
164	    !isspace((unsigned char) ptr[3])) {
165	if (ptr[0] == 'e' && strncmp(ptr+1, "ndfor", 5) == 0) {
166	    Parse_Error(PARSE_FATAL, "for-less endfor");
167	    return -1;
168	}
169	return 0;
170    }
171    ptr += 3;
172
173    /*
174     * we found a for loop, and now we are going to parse it.
175     */
176
177    new_for = bmake_malloc(sizeof *new_for);
178    memset(new_for, 0, sizeof *new_for);
179
180    /* Grab the variables. Terminate on "in". */
181    for (;; ptr += len) {
182	while (*ptr && isspace((unsigned char) *ptr))
183	    ptr++;
184	if (*ptr == '\0') {
185	    Parse_Error(PARSE_FATAL, "missing `in' in for");
186	    For_Free(new_for);
187	    return -1;
188	}
189	for (len = 1; ptr[len] && !isspace((unsigned char)ptr[len]); len++)
190	    continue;
191	if (len == 2 && ptr[0] == 'i' && ptr[1] == 'n') {
192	    ptr += 2;
193	    break;
194	}
195	if (len == 1)
196	    new_for->short_var = 1;
197	strlist_add_str(&new_for->vars, make_str(ptr, len), len);
198    }
199
200    if (strlist_num(&new_for->vars) == 0) {
201	Parse_Error(PARSE_FATAL, "no iteration variables in for");
202	For_Free(new_for);
203	return -1;
204    }
205
206    while (*ptr && isspace((unsigned char) *ptr))
207	ptr++;
208
209    /*
210     * Make a list with the remaining words
211     * The values are substituted as ${:U<value>...} so we must \ escape
212     * characters that break that syntax.
213     * Variables are fully expanded - so it is safe for escape $.
214     * We can't do the escapes here - because we don't know whether
215     * we are substuting into ${...} or $(...).
216     */
217    sub = Var_Subst(NULL, ptr, VAR_GLOBAL, FALSE);
218
219    for (ptr = sub;; ptr += len) {
220	while (*ptr && isspace((unsigned char)*ptr))
221	    ptr++;
222	if (*ptr == 0)
223	    break;
224	escapes = 0;
225	for (len = 0; (ch = ptr[len]) != 0 && !isspace(ch); len++) {
226	    if (ch == ':' || ch == '$' || ch == '\\')
227		escapes |= FOR_SUB_ESCAPE_CHAR;
228	    else if (ch == ')')
229		escapes |= FOR_SUB_ESCAPE_PAREN;
230	    else if (ch == /*{*/ '}')
231		escapes |= FOR_SUB_ESCAPE_BRACE;
232	}
233	strlist_add_str(&new_for->items, make_str(ptr, len), escapes);
234    }
235
236    free(sub);
237
238    if (strlist_num(&new_for->items) % strlist_num(&new_for->vars)) {
239	Parse_Error(PARSE_FATAL,
240		"Wrong number of words (%d) in .for substitution list"
241		" with %d vars",
242		strlist_num(&new_for->items), strlist_num(&new_for->vars));
243	/*
244	 * Return 'success' so that the body of the .for loop is accumulated.
245	 * Remove all items so that the loop doesn't iterate.
246	 */
247	strlist_clean(&new_for->items);
248    }
249
250    Buf_Init(&new_for->buf, 0);
251    accumFor = new_for;
252    forLevel = 1;
253    return 1;
254}
255
256/*
257 * Add another line to a .for loop.
258 * Returns 0 when the matching .endfor is reached.
259 */
260
261int
262For_Accum(char *line)
263{
264    char *ptr = line;
265
266    if (*ptr == '.') {
267
268	for (ptr++; *ptr && isspace((unsigned char) *ptr); ptr++)
269	    continue;
270
271	if (strncmp(ptr, "endfor", 6) == 0 &&
272		(isspace((unsigned char) ptr[6]) || !ptr[6])) {
273	    if (DEBUG(FOR))
274		(void)fprintf(debug_file, "For: end for %d\n", forLevel);
275	    if (--forLevel <= 0)
276		return 0;
277	} else if (strncmp(ptr, "for", 3) == 0 &&
278		 isspace((unsigned char) ptr[3])) {
279	    forLevel++;
280	    if (DEBUG(FOR))
281		(void)fprintf(debug_file, "For: new loop %d\n", forLevel);
282	}
283    }
284
285    Buf_AddBytes(&accumFor->buf, strlen(line), line);
286    Buf_AddByte(&accumFor->buf, '\n');
287    return 1;
288}
289
290
291/*-
292 *-----------------------------------------------------------------------
293 * For_Run --
294 *	Run the for loop, imitating the actions of an include file
295 *
296 * Results:
297 *	None.
298 *
299 * Side Effects:
300 *	None.
301 *
302 *-----------------------------------------------------------------------
303 */
304
305static int
306for_var_len(const char *var)
307{
308    char ch, var_start, var_end;
309    int depth;
310    int len;
311
312    var_start = *var;
313    if (var_start == 0)
314	/* just escape the $ */
315	return 0;
316
317    if (var_start == '(')
318	var_end = ')';
319    else if (var_start == '{')
320	var_end = '}';
321    else
322	/* Single char variable */
323	return 1;
324
325    depth = 1;
326    for (len = 1; (ch = var[len++]) != 0;) {
327	if (ch == var_start)
328	    depth++;
329	else if (ch == var_end && --depth == 0)
330	    return len;
331    }
332
333    /* Variable end not found, escape the $ */
334    return 0;
335}
336
337static void
338for_substitute(Buffer *cmds, strlist_t *items, unsigned int item_no, char ech)
339{
340    const char *item = strlist_str(items, item_no);
341    int len;
342    char ch;
343
344    /* If there were no escapes, or the only escape is the other variable
345     * terminator, then just substitute the full string */
346    if (!(strlist_info(items, item_no) &
347	    (ech == ')' ? ~FOR_SUB_ESCAPE_BRACE : ~FOR_SUB_ESCAPE_PAREN))) {
348	Buf_AddBytes(cmds, strlen(item), item);
349	return;
350    }
351
352    /* Escape ':', '$', '\\' and 'ech' - removed by :U processing */
353    while ((ch = *item++) != 0) {
354	if (ch == '$') {
355	    len = for_var_len(item);
356	    if (len != 0) {
357		Buf_AddBytes(cmds, len + 1, item - 1);
358		item += len;
359		continue;
360	    }
361	    Buf_AddByte(cmds, '\\');
362	} else if (ch == ':' || ch == '\\' || ch == ech)
363	    Buf_AddByte(cmds, '\\');
364	Buf_AddByte(cmds, ch);
365    }
366}
367
368static char *
369For_Iterate(void *v_arg, size_t *ret_len)
370{
371    For *arg = v_arg;
372    int i, len;
373    char *var;
374    char *cp;
375    char *cmd_cp;
376    char *body_end;
377    char ch;
378    Buffer cmds;
379
380    if (arg->sub_next + strlist_num(&arg->vars) > strlist_num(&arg->items)) {
381	/* No more iterations */
382	For_Free(arg);
383	return NULL;
384    }
385
386    free(arg->parse_buf);
387    arg->parse_buf = NULL;
388
389    /*
390     * Scan the for loop body and replace references to the loop variables
391     * with variable references that expand to the required text.
392     * Using variable expansions ensures that the .for loop can't generate
393     * syntax, and that the later parsing will still see a variable.
394     * We assume that the null variable will never be defined.
395     *
396     * The detection of substitions of the loop control variable is naive.
397     * Many of the modifiers use \ to escape $ (not $) so it is possible
398     * to contrive a makefile where an unwanted substitution happens.
399     */
400
401    cmd_cp = Buf_GetAll(&arg->buf, &len);
402    body_end = cmd_cp + len;
403    Buf_Init(&cmds, len + 256);
404    for (cp = cmd_cp; (cp = strchr(cp, '$')) != NULL;) {
405	char ech;
406	ch = *++cp;
407	if ((ch == '(' && (ech = ')')) || (ch == '{' && (ech = '}'))) {
408	    cp++;
409	    /* Check variable name against the .for loop variables */
410	    STRLIST_FOREACH(var, &arg->vars, i) {
411		len = strlist_info(&arg->vars, i);
412		if (memcmp(cp, var, len) != 0)
413		    continue;
414		if (cp[len] != ':' && cp[len] != ech && cp[len] != '\\')
415		    continue;
416		/* Found a variable match. Replace with :U<value> */
417		Buf_AddBytes(&cmds, cp - cmd_cp, cmd_cp);
418		Buf_AddBytes(&cmds, 2, ":U");
419		cp += len;
420		cmd_cp = cp;
421		for_substitute(&cmds, &arg->items, arg->sub_next + i, ech);
422		break;
423	    }
424	    continue;
425	}
426	if (ch == 0)
427	    break;
428	/* Probably a single character name, ignore $$ and stupid ones. {*/
429	if (!arg->short_var || strchr("}):$", ch) != NULL) {
430	    cp++;
431	    continue;
432	}
433	STRLIST_FOREACH(var, &arg->vars, i) {
434	    if (var[0] != ch || var[1] != 0)
435		continue;
436	    /* Found a variable match. Replace with ${:U<value>} */
437	    Buf_AddBytes(&cmds, cp - cmd_cp, cmd_cp);
438	    Buf_AddBytes(&cmds, 3, "{:U");
439	    cmd_cp = ++cp;
440	    for_substitute(&cmds, &arg->items, arg->sub_next + i, /*{*/ '}');
441	    Buf_AddBytes(&cmds, 1, "}");
442	    break;
443	}
444    }
445    Buf_AddBytes(&cmds, body_end - cmd_cp, cmd_cp);
446
447    cp = Buf_Destroy(&cmds, FALSE);
448    if (DEBUG(FOR))
449	(void)fprintf(debug_file, "For: loop body:\n%s", cp);
450
451    arg->sub_next += strlist_num(&arg->vars);
452
453    arg->parse_buf = cp;
454    *ret_len = strlen(cp);
455    return cp;
456}
457
458void
459For_Run(int lineno)
460{
461    For *arg;
462
463    arg = accumFor;
464    accumFor = NULL;
465
466    if (strlist_num(&arg->items) == 0) {
467        /* Nothing to expand - possibly due to an earlier syntax error. */
468        For_Free(arg);
469        return;
470    }
471
472    Parse_SetInput(NULL, lineno, -1, For_Iterate, arg);
473}
474