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.23 2005/01/24 05:13:58 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         sub = Var_Subst(NULL, ptr, VAR_CMD, FALSE);
 181
 182         for (ptr = sub; *ptr && isspace((unsigned char)*ptr); ptr++)
 183             continue;
 184
 185         for (wrd = ptr; *ptr; ptr++)
 186             if (isspace((unsigned char)*ptr)) {
 187                 Buf_AppendRange(buf, wrd, ptr);
 188                 Lst_AtFront(&forLst, Buf_GetAll(buf, &varlen));
 189                 Buf_Destroy(buf, FALSE);
 190                 buf = Buf_Init(0);
 191                 while (*ptr && isspace((unsigned char)*ptr))
 192                     ptr++;
 193                 wrd = ptr--;
 194             }
 195         DEBUGF(FOR, ("For: Iterator %s List %s\n", forVar, sub));
 196         if (ptr - wrd > 0) {
 197             Buf_AppendRange(buf, wrd, ptr);
 198             Lst_AtFront(&forLst, Buf_GetAll(buf, &varlen));
 199             Buf_Destroy(buf, FALSE);
 200         } else {
 201             Buf_Destroy(buf, TRUE);
 202         }
 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_Append(forBuf, 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 }