3b45d27d64202366be1f6e9ff01f47798db1c878
[dragonfly.git] / usr.bin / make / for.c
1 /*
2  * Copyright (c) 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Christos Zoulas.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. All advertising materials mentioning features or use of this software
17  *    must display the following acknowledgement:
18  *      This product includes software developed by the University of
19  *      California, Berkeley and its contributors.
20  * 4. Neither the name of the University nor the names of its contributors
21  *    may be used to endorse or promote products derived from this software
22  *    without specific prior written permission.
23  *
24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34  * SUCH DAMAGE.
35  *
36  * @(#)for.c    8.1 (Berkeley) 6/6/93
37  * $FreeBSD: src/usr.bin/make/for.c,v 1.10 1999/09/11 13:08:01 hoek Exp $
38  * $DragonFly: src/usr.bin/make/for.c,v 1.20 2005/01/24 05:09:30 okumoto Exp $
39  */
40
41 /*-
42  * for.c --
43  *      Functions to handle loops in a makefile.
44  *
45  * Interface:
46  *      For_Eval        Evaluate the loop in the passed line.
47  *      For_Run         Run accumulated loop
48  *
49  */
50
51 #include <ctype.h>
52 #include <stdlib.h>
53 #include <string.h>
54
55 #include "buf.h"
56 #include "dir.h"
57 #include "for.h"
58 #include "globals.h"
59 #include "lst.h"
60 #include "make.h"
61 #include "parse.h"
62 #include "util.h"
63 #include "var.h"
64
65 /*
66  * For statements are of the form:
67  *
68  * .for <variable> in <varlist>
69  * ...
70  * .endfor
71  *
72  * The trick is to look for the matching end inside for for loop
73  * To do that, we count the current nesting level of the for loops.
74  * and the .endfor statements, accumulating all the statements between
75  * the initial .for loop and the matching .endfor;
76  * then we evaluate the for loop for each variable in the varlist.
77  */
78
79 static int        forLevel = 0;         /* Nesting level        */
80 static char      *forVar;               /* Iteration variable   */
81 static Buffer    *forBuf;               /* Commands in loop     */
82 static Lst      forLst;         /* List of items        */
83
84 /*
85  * State of a for loop.
86  */
87 typedef struct _For {
88     Buffer        *buf;                 /* Unexpanded buffer    */
89     char*         var;                  /* Index name           */
90     Lst           lst;                  /* List of variables    */
91     int           lineno;               /* Line #               */
92 } For;
93
94 static int ForExec(void *, void *);
95
96 /*-
97  *-----------------------------------------------------------------------
98  * For_Eval --
99  *      Evaluate the for loop in the passed line. The line
100  *      looks like this:
101  *          .for <variable> in <varlist>
102  *
103  * Results:
104  *      TRUE: We found a for loop, or we are inside a for loop
105  *      FALSE: We did not find a for loop, or we found the end of the for
106  *             for loop.
107  *
108  * Side Effects:
109  *      None.
110  *
111  *-----------------------------------------------------------------------
112  */
113 int
114 For_Eval(char *line)
115 {
116     char            *ptr = line, *sub, *wrd;
117     int             level;      /* Level at which to report errors. */
118
119     level = PARSE_FATAL;
120
121
122     if (forLevel == 0) {
123         Buffer      *buf;
124         size_t varlen;
125
126         for (ptr++; *ptr && isspace((unsigned char)*ptr); ptr++)
127             continue;
128         /*
129          * If we are not in a for loop quickly determine if the statement is
130          * a for.
131          */
132         if (ptr[0] != 'f' || ptr[1] != 'o' || ptr[2] != 'r' ||
133             !isspace((unsigned char)ptr[3]))
134             return (FALSE);
135         ptr += 3;
136
137         /*
138          * we found a for loop, and now we are going to parse it.
139          */
140         while (*ptr && isspace((unsigned char)*ptr))
141             ptr++;
142
143         /*
144          * Grab the variable
145          */
146         buf = Buf_Init(0);
147         for (wrd = ptr; *ptr && !isspace((unsigned char)*ptr); ptr++)
148             continue;
149         Buf_AddBytes(buf, ptr - wrd, (Byte *)wrd);
150
151         forVar = (char *)Buf_GetAll(buf, &varlen);
152         if (varlen == 0) {
153             Parse_Error(level, "missing variable in for");
154             return (0);
155         }
156         Buf_Destroy(buf, FALSE);
157
158         while (*ptr && isspace((unsigned char)*ptr))
159             ptr++;
160
161         /*
162          * Grab the `in'
163          */
164         if (ptr[0] != 'i' || ptr[1] != 'n' ||
165             !isspace((unsigned char)ptr[2])) {
166             Parse_Error(level, "missing `in' in for");
167             printf("%s\n", ptr);
168             return (0);
169         }
170         ptr += 3;
171
172         while (*ptr && isspace((unsigned char)*ptr))
173             ptr++;
174
175         /*
176          * Make a list with the remaining words
177          */
178         Lst_Init(&forLst);
179         buf = Buf_Init(0);
180         sub = Var_Subst(NULL, ptr, VAR_CMD, FALSE);
181
182 #define ADDWORD() \
183         Buf_AddBytes(buf, ptr - wrd, (Byte *)wrd), \
184         Lst_AtFront(&forLst, Buf_GetAll(buf, &varlen)), \
185         Buf_Destroy(buf, FALSE)
186
187         for (ptr = sub; *ptr && isspace((unsigned char)*ptr); ptr++)
188             continue;
189
190         for (wrd = ptr; *ptr; ptr++)
191             if (isspace((unsigned char)*ptr)) {
192                 ADDWORD();
193                 buf = Buf_Init(0);
194                 while (*ptr && isspace((unsigned char)*ptr))
195                     ptr++;
196                 wrd = ptr--;
197             }
198         DEBUGF(FOR, ("For: Iterator %s List %s\n", forVar, sub));
199         if (ptr - wrd > 0)
200             ADDWORD();
201         else
202             Buf_Destroy(buf, TRUE);
203         free(sub);
204
205         forBuf = Buf_Init(0);
206         forLevel++;
207         return (1);
208     }
209     else if (*ptr == '.') {
210
211         for (ptr++; *ptr && isspace((unsigned char)*ptr); ptr++)
212             continue;
213
214         if (strncmp(ptr, "endfor", 6) == 0 &&
215             (isspace((unsigned char)ptr[6]) || !ptr[6])) {
216             DEBUGF(FOR, ("For: end for %d\n", forLevel));
217             if (--forLevel < 0) {
218                 Parse_Error(level, "for-less endfor");
219                 return (0);
220             }
221         }
222         else if (strncmp(ptr, "for", 3) == 0 &&
223                  isspace((unsigned char)ptr[3])) {
224             forLevel++;
225             DEBUGF(FOR, ("For: new loop %d\n", forLevel));
226         }
227     }
228
229     if (forLevel != 0) {
230         Buf_AddBytes(forBuf, strlen(line), (Byte *)line);
231         Buf_AddByte(forBuf, (Byte)'\n');
232         return (1);
233     }
234     else {
235         return (0);
236     }
237 }
238
239 /*-
240  *-----------------------------------------------------------------------
241  * ForExec --
242  *      Expand the for loop for this index and push it in the Makefile
243  *
244  * Results:
245  *      None.
246  *
247  * Side Effects:
248  *      None.
249  *
250  *-----------------------------------------------------------------------
251  */
252 static int
253 ForExec(void *namep, void *argp)
254 {
255     char *name = namep;
256     For *arg = argp;
257
258     Var_Set(arg->var, name, VAR_GLOBAL);
259     DEBUGF(FOR, ("--- %s = %s\n", arg->var, name));
260     Parse_FromString(Var_Subst(arg->var, (char *)Buf_GetAll(arg->buf, NULL),
261                                VAR_GLOBAL, FALSE), arg->lineno);
262     Var_Delete(arg->var, VAR_GLOBAL);
263
264     return (0);
265 }
266
267 /*-
268  *-----------------------------------------------------------------------
269  * For_Run --
270  *      Run the for loop, immitating the actions of an include file
271  *
272  * Results:
273  *      None.
274  *
275  * Side Effects:
276  *      None.
277  *
278  *-----------------------------------------------------------------------
279  */
280 void
281 For_Run(int lineno)
282 {
283     For arg;
284
285     if (forVar == NULL || forBuf == NULL)
286         return;
287     arg.var = forVar;
288     arg.buf = forBuf;
289
290     /* move the forLst to the arg to get it free for nested for's */
291     Lst_Init(&arg.lst);
292     Lst_Concat(&arg.lst, &forLst, LST_CONCLINK);
293
294     arg.lineno = lineno;
295     forVar = NULL;
296     forBuf = NULL;
297
298     Lst_ForEach(&arg.lst, ForExec, &arg);
299
300     free(arg.var);
301     Lst_Destroy(&arg.lst, free);
302     Buf_Destroy(arg.buf, TRUE);
303 }