- Convert negative logic, so code is easyer to read.
[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.28 2005/01/31 08:30:51 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_AppendRange(buf, wrd, ptr);
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         {
181             Buffer *buf1;
182
183             buf1 = Var_Subst(NULL, ptr, VAR_CMD, FALSE);
184             sub = Buf_GetAll(buf1, NULL);
185             Buf_Destroy(buf1, FALSE);
186         }
187
188         for (ptr = sub; *ptr && isspace((unsigned char)*ptr); ptr++)
189             continue;
190
191         for (wrd = ptr; *ptr; ptr++)
192             if (isspace((unsigned char)*ptr)) {
193                 Buf_AppendRange(buf, wrd, ptr);
194                 Buf_AddByte(buf, (Byte)'\0');
195                 Lst_AtFront(&forLst, Buf_GetAll(buf, &varlen));
196                 Buf_Destroy(buf, FALSE);
197                 buf = Buf_Init(0);
198                 while (*ptr && isspace((unsigned char)*ptr))
199                     ptr++;
200                 wrd = ptr--;
201             }
202         DEBUGF(FOR, ("For: Iterator %s List %s\n", forVar, sub));
203         if (ptr - wrd > 0) {
204             Buf_AppendRange(buf, wrd, ptr);
205             Buf_AddByte(buf, (Byte)'\0');
206             Lst_AtFront(&forLst, Buf_GetAll(buf, &varlen));
207             Buf_Destroy(buf, FALSE);
208         } else {
209             Buf_Destroy(buf, TRUE);
210         }
211         free(sub);
212
213         forBuf = Buf_Init(0);
214         forLevel++;
215         return (1);
216     }
217     else if (*ptr == '.') {
218
219         for (ptr++; *ptr && isspace((unsigned char)*ptr); ptr++)
220             continue;
221
222         if (strncmp(ptr, "endfor", 6) == 0 &&
223             (isspace((unsigned char)ptr[6]) || !ptr[6])) {
224             DEBUGF(FOR, ("For: end for %d\n", forLevel));
225             if (--forLevel < 0) {
226                 Parse_Error(level, "for-less endfor");
227                 return (0);
228             }
229         }
230         else if (strncmp(ptr, "for", 3) == 0 &&
231                  isspace((unsigned char)ptr[3])) {
232             forLevel++;
233             DEBUGF(FOR, ("For: new loop %d\n", forLevel));
234         }
235     }
236
237     if (forLevel != 0) {
238         Buf_Append(forBuf, line);
239         Buf_AddByte(forBuf, (Byte)'\n');
240         return (1);
241     }
242     else {
243         return (0);
244     }
245 }
246
247 /*-
248  *-----------------------------------------------------------------------
249  * ForExec --
250  *      Expand the for loop for this index and push it in the Makefile
251  *
252  * Results:
253  *      None.
254  *
255  * Side Effects:
256  *      None.
257  *
258  *-----------------------------------------------------------------------
259  */
260 static int
261 ForExec(void *namep, void *argp)
262 {
263     char        *name = namep;
264     For         *arg = argp;
265     Buffer      *buf;
266     char        *str;
267
268     Var_Set(arg->var, name, VAR_GLOBAL);
269     DEBUGF(FOR, ("--- %s = %s\n", arg->var, name));
270
271     buf = Var_Subst(arg->var,
272                     (char *)Buf_GetAll(arg->buf, NULL), VAR_GLOBAL, FALSE);
273     str = Buf_GetAll(buf, NULL);
274     Buf_Destroy(buf, FALSE);
275
276     Parse_FromString(str, arg->lineno);
277     Var_Delete(arg->var, VAR_GLOBAL);
278
279     return (0);
280 }
281
282 /*-
283  *-----------------------------------------------------------------------
284  * For_Run --
285  *      Run the for loop, immitating the actions of an include file
286  *
287  * Results:
288  *      None.
289  *
290  * Side Effects:
291  *      None.
292  *
293  *-----------------------------------------------------------------------
294  */
295 void
296 For_Run(int lineno)
297 {
298     For arg;
299
300     if (forVar == NULL || forBuf == NULL)
301         return;
302     arg.var = forVar;
303     arg.buf = forBuf;
304
305     /* move the forLst to the arg to get it free for nested for's */
306     Lst_Init(&arg.lst);
307     Lst_Concat(&arg.lst, &forLst, LST_CONCLINK);
308
309     arg.lineno = lineno;
310     forVar = NULL;
311     forBuf = NULL;
312
313     Lst_ForEach(&arg.lst, ForExec, &arg);
314
315     free(arg.var);
316     Lst_Destroy(&arg.lst, free);
317     Buf_Destroy(arg.buf, TRUE);
318 }