contrib/bmake/for.c

   1 /*      $NetBSD: for.c,v 1.168 2022/06/12 16:09:21 rillig 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 /*
  33  * Handling of .for/.endfor loops in a makefile.
  34  *
  35  * For loops have the form:
  36  *
  37  *      .for <varname...> in <value...>
  38  *      # the body
  39  *      .endfor
  40  *
  41  * When a .for line is parsed, the following lines are copied to the body of
  42  * the .for loop, until the corresponding .endfor line is reached.  In this
  43  * phase, the body is not yet evaluated.  This also applies to any nested
  44  * .for loops.
  45  *
  46  * After reaching the .endfor, the values from the .for line are grouped
  47  * according to the number of variables.  For each such group, the unexpanded
  48  * body is scanned for variable expressions, and those that match the
  49  * variable names are replaced with expressions of the form ${:U...}.  After
  50  * that, the body is treated like a file from an .include directive.
  51  *
  52  * Interface:
  53  *      For_Eval        Evaluate the loop in the passed line.
  54  *
  55  *      For_Run         Run accumulated loop
  56  */
  57
  58 #include "make.h"
  59
  60 /*      "@(#)for.c      8.1 (Berkeley) 6/6/93"  */
  61 MAKE_RCSID("$NetBSD: for.c,v 1.168 2022/06/12 16:09:21 rillig Exp $");
  62
  63
  64 typedef struct ForLoop {
  65         Vector /* of 'char *' */ vars; /* Iteration variables */
  66         SubstringWords items;   /* Substitution items */
  67         Buffer body;            /* Unexpanded body of the loop */
  68         unsigned int nextItem;  /* Where to continue iterating */
  69 } ForLoop;
  70
  71
  72 static ForLoop *accumFor;       /* Loop being accumulated */
  73
  74
  75 static ForLoop *
  76 ForLoop_New(void)
  77 {
  78         ForLoop *f = bmake_malloc(sizeof *f);
  79
  80         Vector_Init(&f->vars, sizeof(char *));
  81         SubstringWords_Init(&f->items);
  82         Buf_Init(&f->body);
  83         f->nextItem = 0;
  84
  85         return f;
  86 }
  87
  88 void
  89 ForLoop_Free(ForLoop *f)
  90 {
  91         while (f->vars.len > 0)
  92                 free(*(char **)Vector_Pop(&f->vars));
  93         Vector_Done(&f->vars);
  94
  95         SubstringWords_Free(f->items);
  96         Buf_Done(&f->body);
  97
  98         free(f);
  99 }
 100
 101 char *
 102 ForLoop_Details(ForLoop *f)
 103 {
 104         size_t i, n;
 105         const char **vars;
 106         const Substring *items;
 107         Buffer buf;
 108
 109         n = f->vars.len;
 110         vars = f->vars.items;
 111         assert(f->nextItem >= n);
 112         items = f->items.words + f->nextItem - n;
 113
 114         Buf_Init(&buf);
 115         for (i = 0; i < n; i++) {
 116                 if (i > 0)
 117                         Buf_AddStr(&buf, ", ");
 118                 Buf_AddStr(&buf, vars[i]);
 119                 Buf_AddStr(&buf, " = ");
 120                 Buf_AddBytesBetween(&buf, items[i].start, items[i].end);
 121         }
 122         return Buf_DoneData(&buf);
 123 }
 124
 125 static bool
 126 ForLoop_ParseVarnames(ForLoop *f, const char **pp)
 127 {
 128         const char *p = *pp;
 129
 130         for (;;) {
 131                 size_t len;
 132
 133                 cpp_skip_whitespace(&p);
 134                 if (*p == '\0') {
 135                         Parse_Error(PARSE_FATAL, "missing `in' in for");
 136                         return false;
 137                 }
 138
 139                 /*
 140                  * XXX: This allows arbitrary variable names;
 141                  * see directive-for.mk.
 142                  */
 143                 for (len = 1; p[len] != '\0' && !ch_isspace(p[len]); len++)
 144                         continue;
 145
 146                 if (len == 2 && p[0] == 'i' && p[1] == 'n') {
 147                         p += 2;
 148                         break;
 149                 }
 150
 151                 *(char **)Vector_Push(&f->vars) = bmake_strldup(p, len);
 152                 p += len;
 153         }
 154
 155         if (f->vars.len == 0) {
 156                 Parse_Error(PARSE_FATAL, "no iteration variables in for");
 157                 return false;
 158         }
 159
 160         *pp = p;
 161         return true;
 162 }
 163
 164 static bool
 165 ForLoop_ParseItems(ForLoop *f, const char *p)
 166 {
 167         char *items;
 168
 169         cpp_skip_whitespace(&p);
 170
 171         if (Var_Subst(p, SCOPE_GLOBAL, VARE_WANTRES, &items) != VPR_OK) {
 172                 Parse_Error(PARSE_FATAL, "Error in .for loop items");
 173                 return false;
 174         }
 175
 176         f->items = Substring_Words(items, false);
 177         free(items);
 178
 179         if (f->items.len == 1 && Substring_IsEmpty(f->items.words[0]))
 180                 f->items.len = 0;       /* .for var in ${:U} */
 181
 182         if (f->items.len % f->vars.len != 0) {
 183                 Parse_Error(PARSE_FATAL,
 184                     "Wrong number of words (%u) in .for "
 185                     "substitution list with %u variables",
 186                     (unsigned)f->items.len, (unsigned)f->vars.len);
 187                 return false;
 188         }
 189
 190         return true;
 191 }
 192
 193 static bool
 194 IsFor(const char *p)
 195 {
 196         return p[0] == 'f' && p[1] == 'o' && p[2] == 'r' && ch_isspace(p[3]);
 197 }
 198
 199 static bool
 200 IsEndfor(const char *p)
 201 {
 202         return p[0] == 'e' && strncmp(p, "endfor", 6) == 0 &&
 203                (p[6] == '\0' || ch_isspace(p[6]));
 204 }
 205
 206 /*
 207  * Evaluate the for loop in the passed line. The line looks like this:
 208  *      .for <varname...> in <value...>
 209  *
 210  * Results:
 211  *      0       not a .for directive
 212  *      1       found a .for directive
 213  *      -1      erroneous .for directive
 214  */
 215 int
 216 For_Eval(const char *line)
 217 {
 218         const char *p;
 219         ForLoop *f;
 220
 221         p = line + 1;           /* skip the '.' */
 222         cpp_skip_whitespace(&p);
 223
 224         if (IsFor(p)) {
 225                 p += 3;
 226
 227                 f = ForLoop_New();
 228                 if (!ForLoop_ParseVarnames(f, &p)) {
 229                         ForLoop_Free(f);
 230                         return -1;
 231                 }
 232                 if (!ForLoop_ParseItems(f, p))
 233                         f->items.len = 0;       /* don't iterate */
 234
 235                 accumFor = f;
 236                 return 1;
 237         } else if (IsEndfor(p)) {
 238                 Parse_Error(PARSE_FATAL, "for-less endfor");
 239                 return -1;
 240         } else
 241                 return 0;
 242 }
 243
 244 /*
 245  * Add another line to the .for loop that is being built up.
 246  * Returns false when the matching .endfor is reached.
 247  */
 248 bool
 249 For_Accum(const char *line, int *forLevel)
 250 {
 251         const char *p = line;
 252
 253         if (*p == '.') {
 254                 p++;
 255                 cpp_skip_whitespace(&p);
 256
 257                 if (IsEndfor(p)) {
 258                         DEBUG1(FOR, "For: end for %d\n", *forLevel);
 259                         if (--*forLevel == 0)
 260                                 return false;
 261                 } else if (IsFor(p)) {
 262                         (*forLevel)++;
 263                         DEBUG1(FOR, "For: new loop %d\n", *forLevel);
 264                 }
 265         }
 266
 267         Buf_AddStr(&accumFor->body, line);
 268         Buf_AddByte(&accumFor->body, '\n');
 269         return true;
 270 }
 271
 272 /*
 273  * When the body of a '.for i' loop is prepared for an iteration, each
 274  * occurrence of $i in the body is replaced with ${:U...}, inserting the
 275  * value of the item.  If this item contains a '$', it may be the start of a
 276  * variable expression.  This expression is copied verbatim, its length is
 277  * determined here, in a rather naive way, ignoring escape characters and
 278  * funny delimiters in modifiers like ':S}from}to}'.
 279  */
 280 static size_t
 281 ExprLen(const char *s, const char *e)
 282 {
 283         char expr_open, expr_close;
 284         int depth;
 285         const char *p;
 286
 287         if (s == e)
 288                 return 0;       /* just escape the '$' */
 289
 290         expr_open = s[0];
 291         if (expr_open == '(')
 292                 expr_close = ')';
 293         else if (expr_open == '{')
 294                 expr_close = '}';
 295         else
 296                 return 1;       /* Single char variable */
 297
 298         depth = 1;
 299         for (p = s + 1; p != e; p++) {
 300                 if (*p == expr_open)
 301                         depth++;
 302                 else if (*p == expr_close && --depth == 0)
 303                         return (size_t)(p + 1 - s);
 304         }
 305
 306         /* Expression end not found, escape the $ */
 307         return 0;
 308 }
 309
 310 /*
 311  * The .for loop substitutes the items as ${:U<value>...}, which means
 312  * that characters that break this syntax must be backslash-escaped.
 313  */
 314 static bool
 315 NeedsEscapes(Substring value, char endc)
 316 {
 317         const char *p;
 318
 319         for (p = value.start; p != value.end; p++) {
 320                 if (*p == ':' || *p == '$' || *p == '\\' || *p == endc ||
 321                     *p == '\n')
 322                         return true;
 323         }
 324         return false;
 325 }
 326
 327 /*
 328  * While expanding the body of a .for loop, write the item in the ${:U...}
 329  * expression, escaping characters as needed.  The result is later unescaped
 330  * by ApplyModifier_Defined.
 331  */
 332 static void
 333 AddEscaped(Buffer *cmds, Substring item, char endc)
 334 {
 335         const char *p;
 336         char ch;
 337
 338         if (!NeedsEscapes(item, endc)) {
 339                 Buf_AddBytesBetween(cmds, item.start, item.end);
 340                 return;
 341         }
 342
 343         for (p = item.start; p != item.end;) {
 344                 ch = *p;
 345                 if (ch == '$') {
 346                         size_t len = ExprLen(p + 1, item.end);
 347                         if (len != 0) {
 348                                 /*
 349                                  * XXX: Should a '\' be added here?
 350                                  * See directive-for-escape.mk, ExprLen.
 351                                  */
 352                                 Buf_AddBytes(cmds, p, 1 + len);
 353                                 p += 1 + len;
 354                                 continue;
 355                         }
 356                         Buf_AddByte(cmds, '\\');
 357                 } else if (ch == ':' || ch == '\\' || ch == endc)
 358                         Buf_AddByte(cmds, '\\');
 359                 else if (ch == '\n') {
 360                         Parse_Error(PARSE_FATAL, "newline in .for value");
 361                         ch = ' ';       /* prevent newline injection */
 362                 }
 363                 Buf_AddByte(cmds, ch);
 364                 p++;
 365         }
 366 }
 367
 368 /*
 369  * When expanding the body of a .for loop, replace the variable name of an
 370  * expression like ${i} or ${i:...} or $(i) or $(i:...) with ":Uvalue".
 371  */
 372 static void
 373 ForLoop_SubstVarLong(ForLoop *f, unsigned int firstItem, Buffer *body,
 374                      const char **pp, char endc, const char **inout_mark)
 375 {
 376         size_t i;
 377         const char *start = *pp;
 378         const char **vars = Vector_Get(&f->vars, 0);
 379
 380         for (i = 0; i < f->vars.len; i++) {
 381                 const char *p = start;
 382
 383                 if (!cpp_skip_string(&p, vars[i]))
 384                         continue;
 385                 /* XXX: why test for backslash here? */
 386                 if (*p != ':' && *p != endc && *p != '\\')
 387                         continue;
 388
 389                 /*
 390                  * Found a variable match.  Skip over the variable name and
 391                  * instead add ':U<value>' to the current body.
 392                  */
 393                 Buf_AddBytesBetween(body, *inout_mark, start);
 394                 Buf_AddStr(body, ":U");
 395                 AddEscaped(body, f->items.words[firstItem + i], endc);
 396
 397                 *inout_mark = p;
 398                 *pp = p;
 399                 return;
 400         }
 401 }
 402
 403 /*
 404  * When expanding the body of a .for loop, replace single-character
 405  * variable expressions like $i with their ${:U...} expansion.
 406  */
 407 static void
 408 ForLoop_SubstVarShort(ForLoop *f, unsigned int firstItem, Buffer *body,
 409                       const char *p, const char **inout_mark)
 410 {
 411         const char ch = *p;
 412         const char **vars;
 413         size_t i;
 414
 415         /* Skip $$ and stupid ones. */
 416         if (ch == '}' || ch == ')' || ch == ':' || ch == '$')
 417                 return;
 418
 419         vars = Vector_Get(&f->vars, 0);
 420         for (i = 0; i < f->vars.len; i++) {
 421                 const char *varname = vars[i];
 422                 if (varname[0] == ch && varname[1] == '\0')
 423                         goto found;
 424         }
 425         return;
 426
 427 found:
 428         Buf_AddBytesBetween(body, *inout_mark, p);
 429         *inout_mark = p + 1;
 430
 431         /* Replace $<ch> with ${:U<value>} */
 432         Buf_AddStr(body, "{:U");
 433         AddEscaped(body, f->items.words[firstItem + i], '}');
 434         Buf_AddByte(body, '}');
 435 }
 436
 437 /*
 438  * Compute the body for the current iteration by copying the unexpanded body,
 439  * replacing the expressions for the iteration variables on the way.
 440  *
 441  * Using variable expressions ensures that the .for loop can't generate
 442  * syntax, and that the later parsing will still see a variable.
 443  * This code assumes that the variable with the empty name will never be
 444  * defined, see unit-tests/varname-empty.mk for more details.
 445  *
 446  * The detection of substitutions of the loop control variables is naive.
 447  * Many of the modifiers use '\$' instead of '$$' to escape '$', so it is
 448  * possible to contrive a makefile where an unwanted substitution happens.
 449  */
 450 static void
 451 ForLoop_SubstBody(ForLoop *f, unsigned int firstItem, Buffer *body)
 452 {
 453         const char *p, *end;
 454         const char *mark;       /* where the last substitution left off */
 455
 456         Buf_Clear(body);
 457
 458         mark = f->body.data;
 459         end = f->body.data + f->body.len;
 460         for (p = mark; (p = strchr(p, '$')) != NULL;) {
 461                 if (p[1] == '{' || p[1] == '(') {
 462                         char endc = p[1] == '{' ? '}' : ')';
 463                         p += 2;
 464                         ForLoop_SubstVarLong(f, firstItem, body,
 465                             &p, endc, &mark);
 466                 } else if (p[1] != '\0') {
 467                         ForLoop_SubstVarShort(f, firstItem, body,
 468                             p + 1, &mark);
 469                         p += 2;
 470                 } else
 471                         break;
 472         }
 473
 474         Buf_AddBytesBetween(body, mark, end);
 475 }
 476
 477 /*
 478  * Compute the body for the current iteration by copying the unexpanded body,
 479  * replacing the expressions for the iteration variables on the way.
 480  */
 481 bool
 482 For_NextIteration(ForLoop *f, Buffer *body)
 483 {
 484         if (f->nextItem == f->items.len)
 485                 return false;
 486
 487         f->nextItem += (unsigned int)f->vars.len;
 488         ForLoop_SubstBody(f, f->nextItem - (unsigned int)f->vars.len, body);
 489         DEBUG1(FOR, "For: loop body:\n%s", body->data);
 490         return true;
 491 }
 492
 493 /* Run the .for loop, imitating the actions of an include file. */
 494 void
 495 For_Run(unsigned headLineno, unsigned bodyReadLines)
 496 {
 497         Buffer buf;
 498         ForLoop *f = accumFor;
 499         accumFor = NULL;
 500
 501         if (f->items.len > 0) {
 502                 Buf_Init(&buf);
 503                 Parse_PushInput(NULL, headLineno, bodyReadLines, buf, f);
 504         } else
 505                 ForLoop_Free(f);
 506 }