Merge in some changes that Harti made to patch 7.49
[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. Neither the name of the University nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  * @(#)for.c    8.1 (Berkeley) 6/6/93
33  * $FreeBSD: src/usr.bin/make/for.c,v 1.35 2005/02/10 14:39:05 harti Exp $
34  * $DragonFly: src/usr.bin/make/for.c,v 1.34 2005/02/28 12:00:10 okumoto Exp $
35  */
36
37 /*-
38  * for.c --
39  *      Functions to handle loops in a makefile.
40  *
41  * Interface:
42  *      For_Eval        Evaluate the loop in the passed line.
43  *      For_Run         Run accumulated loop
44  *
45  */
46
47 #include <ctype.h>
48 #include <stdlib.h>
49 #include <string.h>
50
51 #include "buf.h"
52 #include "dir.h"
53 #include "for.h"
54 #include "globals.h"
55 #include "lst.h"
56 #include "make.h"
57 #include "parse.h"
58 #include "util.h"
59 #include "var.h"
60
61 /*
62  * For statements are of the form:
63  *
64  * .for <variable> in <varlist>
65  * ...
66  * .endfor
67  *
68  * The trick is to look for the matching end inside for for loop
69  * To do that, we count the current nesting level of the for loops.
70  * and the .endfor statements, accumulating all the statements between
71  * the initial .for loop and the matching .endfor;
72  * then we evaluate the for loop for each variable in the varlist.
73  */
74
75 static int      forLevel = 0;   /* Nesting level */
76 static char     *forVar;        /* Iteration variable */
77 static Buffer   *forBuf;        /* Commands in loop */
78 static Lst      forLst;         /* List of items */
79
80 /*
81  * State of a for loop.
82  */
83 typedef struct _For {
84         Buffer  *buf;           /* Unexpanded buffer */
85         char    *var;           /* Index name */
86         Lst     lst;            /* List of variables */
87         int     lineno;         /* Line # */
88 } For;
89
90 /*-
91  *-----------------------------------------------------------------------
92  * For_Eval --
93  *      Evaluate the for loop in the passed line. The line
94  *      looks like this:
95  *          .for <variable> in <varlist>
96  *
97  * Results:
98  *      TRUE: We found a for loop, or we are inside a for loop
99  *      FALSE: We did not find a for loop, or we found the end of the for
100  *             for loop.
101  *
102  * Side Effects:
103  *      None.
104  *
105  *-----------------------------------------------------------------------
106  */
107 int
108 For_Eval(char *line)
109 {
110         char    *ptr;
111         char    *sub;
112         char    *wrd;
113         int     level;  /* Level at which to report errors. */
114
115         ptr = line;
116         level = PARSE_FATAL;
117
118         if (forLevel == 0) {
119                 /*
120                  * maybe start of a for loop
121                  */
122                 Buffer  *buf;
123                 Buffer  *buf1;
124                 size_t  varlen;
125
126                 for (ptr++; *ptr && isspace((unsigned char)*ptr); ptr++)
127                         ;
128                 /*
129                  * If we are not in a for loop quickly determine if
130                  * the statement is 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                         ;
149                 Buf_AppendRange(buf, wrd, ptr);
150
151                 forVar = (char *)Buf_GetAll(buf, &varlen);
152                 if (varlen == 0) {
153                         /* XXXHB Buf_Destroy(buf, TRUE) */
154                         Parse_Error(level, "missing variable in for");
155                         return (0);
156                 }
157                 Buf_Destroy(buf, FALSE);
158
159                 while (*ptr && isspace((unsigned char)*ptr))
160                         ptr++;
161
162                 /*
163                  * Grab the `in'
164                  */
165                 if (ptr[0] != 'i' || ptr[1] != 'n' ||
166                     !isspace((unsigned char)ptr[2])) {
167                         /* XXXHB free(forVar) */
168                         Parse_Error(level, "missing `in' in for");
169                         printf("%s\n", ptr);
170                         return (0);
171                 }
172                 ptr += 3;
173
174                 while (*ptr && isspace((unsigned char)*ptr))
175                         ptr++;
176
177                 /*
178                  * Make a list with the remaining words
179                  */
180                 Lst_Init(&forLst);
181                 buf = Buf_Init(0);
182
183                 buf1 = Var_Subst(NULL, ptr, VAR_CMD, FALSE);
184                 sub = Buf_GetAll(buf1, NULL);
185                 Buf_Destroy(buf1, FALSE);
186
187                 for (ptr = sub; *ptr && isspace((unsigned char)*ptr); ptr++)
188                         ;
189
190                 for (wrd = ptr; *ptr; ptr++) {
191                         if (isspace((unsigned char)*ptr)) {
192                                 Buf_AppendRange(buf, wrd, ptr);
193                                 Buf_AddByte(buf, (Byte)'\0');
194                                 Lst_AtFront(&forLst, Buf_GetAll(buf, &varlen));
195                                 Buf_Destroy(buf, FALSE);
196                                 buf = Buf_Init(0);
197                                 while (*ptr && isspace((unsigned char)*ptr))
198                                         ptr++;
199                                 wrd = ptr--;
200                         }
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
218         if (*ptr == '.') {
219                 /*
220                  * Need to check for 'endfor' and 'for' to find the end
221                  * of our loop or to find embedded for loops.
222                  */
223                 for (ptr++; *ptr && isspace((unsigned char)*ptr); ptr++)
224                         ;
225
226                 if (strncmp(ptr, "endfor", 6) == 0 &&
227                     (isspace((unsigned char)ptr[6]) || !ptr[6])) {
228                         DEBUGF(FOR, ("For: end for %d\n", forLevel));
229                         if (--forLevel < 0) {
230                                 Parse_Error(level, "for-less endfor");
231                                 return (0);
232                         }
233
234                 } else if (strncmp(ptr, "for", 3) == 0 &&
235                     isspace((unsigned char)ptr[3])) {
236                         forLevel++;
237                         DEBUGF(FOR, ("For: new loop %d\n", forLevel));
238                 }
239         }
240
241         if (forLevel != 0) {
242                 /*
243                  * Still in loop - append the line
244                  */
245                 Buf_Append(forBuf, line);
246                 Buf_AddByte(forBuf, (Byte)'\n');
247                 return (1);
248         }
249
250         return (0);
251 }
252
253 /*-
254  *-----------------------------------------------------------------------
255  * For_Run --
256  *      Run the for loop, immitating the actions of an include file
257  *
258  * Results:
259  *      None.
260  *
261  * Side Effects:
262  *      The values of the variables forLst, forVar and forBuf are freed.
263  *
264  *-----------------------------------------------------------------------
265  */
266 void
267 For_Run(int lineno)
268 {
269         Lst             values; /* list of values for the variable */
270         char            *var;   /* the variable's name */
271         Buffer          *buf;   /* the contents of the for loop */
272         const char      *val;   /* current value of loop variable */
273         LstNode         *ln;
274         Buffer          *buf1;
275         char            *str;
276
277         if (forVar == NULL || forBuf == NULL)
278                 return;
279
280         /* copy the global variables to have them free for embedded fors */
281         var = forVar;
282         buf = forBuf;
283         Lst_Init(&values);
284         Lst_Concat(&values, &forLst, LST_CONCLINK);
285
286         forVar = NULL;
287         forBuf = NULL;
288
289         LST_FOREACH(ln, &values) {
290                 val = Lst_Datum(ln);
291                 Var_Set(var, val, VAR_GLOBAL);
292
293                 DEBUGF(FOR, ("--- %s = %s\n", var, val));
294
295                 buf1 = Var_Subst(var, (char *)Buf_GetAll(buf, NULL),
296                     VAR_GLOBAL, FALSE);
297                 str = Buf_GetAll(buf1, NULL);
298                 Buf_Destroy(buf1, FALSE);
299
300                 Parse_FromString(str, lineno);
301                 Var_Delete(var, VAR_GLOBAL);
302         }
303
304         free(var);
305         Lst_Destroy(&values, free);
306         Buf_Destroy(buf, TRUE);
307 }