src/commands.c

   1 /* Command processing for GNU Make.
   2 Copyright (C) 1988-2022 Free Software Foundation, Inc.
   3 This file is part of GNU Make.
   4
   5 GNU Make is free software; you can redistribute it and/or modify it under the
   6 terms of the GNU General Public License as published by the Free Software
   7 Foundation; either version 3 of the License, or (at your option) any later
   8 version.
   9
  10 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
  11 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  12 A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License along with
  15 this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 #include "makeint.h"
  18 #include "filedef.h"
  19 #include "os.h"
  20 #include "dep.h"
  21 #include "variable.h"
  22 #include "job.h"
  23 #include "commands.h"
  24 #ifdef WINDOWS32
  25 #include <windows.h>
  26 #include "w32err.h"
  27 #endif
  28
  29 #if VMS
  30 # define FILE_LIST_SEPARATOR (vms_comma_separator ? ',' : ' ')
  31 #else
  32 # define FILE_LIST_SEPARATOR ' '
  33 #endif
  34 \f
  35
  36 static unsigned long
  37 dep_hash_1 (const void *key)
  38 {
  39   const struct dep *d = key;
  40   return_STRING_HASH_1 (dep_name (d));
  41 }
  42
  43 static unsigned long
  44 dep_hash_2 (const void *key)
  45 {
  46   const struct dep *d = key;
  47   return_STRING_HASH_2 (dep_name (d));
  48 }
  49
  50 static int
  51 dep_hash_cmp (const void *x, const void *y)
  52 {
  53   const struct dep *dx = x;
  54   const struct dep *dy = y;
  55   return strcmp (dep_name (dx), dep_name (dy));
  56 }
  57
  58 /* Set FILE's automatic variables up.
  59  * Use STEM to set $*.
  60  * If STEM is 0, then set FILE->STEM and $* to the target name with any
  61  * suffix in the .SUFFIXES list stripped off.  */
  62
  63 void
  64 set_file_variables (struct file *file, const char *stem)
  65 {
  66   struct dep *d;
  67   const char *at, *percent, *star, *less;
  68
  69 #ifndef NO_ARCHIVES
  70   /* If the target is an archive member 'lib(member)',
  71      then $@ is 'lib' and $% is 'member'.  */
  72
  73   if (ar_name (file->name))
  74     {
  75       size_t len;
  76       const char *cp;
  77       char *p;
  78
  79       cp = strchr (file->name, '(');
  80       p = alloca (cp - file->name + 1);
  81       memcpy (p, file->name, cp - file->name);
  82       p[cp - file->name] = '\0';
  83       at = p;
  84       len = strlen (cp + 1);
  85       p = alloca (len);
  86       memcpy (p, cp + 1, len - 1);
  87       p[len - 1] = '\0';
  88       percent = p;
  89     }
  90   else
  91 #endif  /* NO_ARCHIVES.  */
  92     {
  93       at = file->name;
  94       percent = "";
  95     }
  96
  97   /* $* is the stem from an implicit or static pattern rule.  */
  98   if (stem == 0)
  99     {
 100       /* In Unix make, $* is set to the target name with
 101          any suffix in the .SUFFIXES list stripped off for
 102          explicit rules.  We store this in the 'stem' member.  */
 103       const char *name;
 104       size_t len;
 105
 106 #ifndef NO_ARCHIVES
 107       if (ar_name (file->name))
 108         {
 109           name = strchr (file->name, '(') + 1;
 110           len = strlen (name) - 1;
 111         }
 112       else
 113 #endif
 114         {
 115           name = file->name;
 116           len = strlen (name);
 117         }
 118
 119       for (d = enter_file (strcache_add (".SUFFIXES"))->deps; d ; d = d->next)
 120         {
 121           const char *dn = dep_name (d);
 122           size_t slen = strlen (dn);
 123           if (len > slen && memcmp (dn, name + (len - slen), slen) == 0)
 124             {
 125               file->stem = stem = strcache_add_len (name, len - slen);
 126               break;
 127             }
 128         }
 129       if (d == 0)
 130         file->stem = stem = "";
 131     }
 132   star = stem;
 133
 134   /* $< is the first not order-only dependency.  */
 135   less = "";
 136   for (d = file->deps; d != 0; d = d->next)
 137     if (!d->ignore_mtime && !d->ignore_automatic_vars && !d->need_2nd_expansion)
 138       {
 139         less = dep_name (d);
 140         break;
 141       }
 142
 143   if (file->cmds != 0 && file->cmds == default_file->cmds)
 144     /* This file got its commands from .DEFAULT.
 145        In this case $< is the same as $@.  */
 146     less = at;
 147
 148 #define DEFINE_VARIABLE(name, len, value) \
 149   (void) define_variable_for_file (name,len,value,o_automatic,0,file)
 150
 151   /* Define the variables.  */
 152
 153   DEFINE_VARIABLE ("<", 1, less);
 154   DEFINE_VARIABLE ("*", 1, star);
 155   DEFINE_VARIABLE ("@", 1, at);
 156   DEFINE_VARIABLE ("%", 1, percent);
 157
 158   /* Compute the values for $^, $+, $?, and $|.  */
 159
 160   {
 161     static char *plus_value=0, *bar_value=0, *qmark_value=0;
 162     static size_t plus_max=0, bar_max=0, qmark_max=0;
 163
 164     size_t qmark_len, plus_len, bar_len;
 165     char *cp;
 166     char *caret_value;
 167     char *qp;
 168     char *bp;
 169     size_t len;
 170
 171     struct hash_table dep_hash;
 172     void **slot;
 173
 174     /* Compute first the value for $+, which is supposed to contain
 175        duplicate dependencies as they were listed in the makefile.  */
 176
 177     plus_len = 0;
 178     bar_len = 0;
 179     for (d = file->deps; d != 0; d = d->next)
 180       {
 181         if (!d->need_2nd_expansion && !d->ignore_automatic_vars)
 182           {
 183             if (d->ignore_mtime)
 184               bar_len += strlen (dep_name (d)) + 1;
 185             else
 186               plus_len += strlen (dep_name (d)) + 1;
 187           }
 188       }
 189
 190     if (bar_len == 0)
 191       bar_len++;
 192
 193     if (plus_len == 0)
 194       plus_len++;
 195
 196     if (plus_len > plus_max)
 197       plus_value = xrealloc (plus_value, plus_max = plus_len);
 198
 199     cp = plus_value;
 200
 201     qmark_len = plus_len + 1;   /* Will be this or less.  */
 202     for (d = file->deps; d != 0; d = d->next)
 203       if (! d->ignore_mtime && ! d->need_2nd_expansion && ! d->ignore_automatic_vars)
 204         {
 205           const char *c = dep_name (d);
 206
 207 #ifndef NO_ARCHIVES
 208           if (ar_name (c))
 209             {
 210               c = strchr (c, '(') + 1;
 211               len = strlen (c) - 1;
 212             }
 213           else
 214 #endif
 215             len = strlen (c);
 216
 217           cp = mempcpy (cp, c, len);
 218           *cp++ = FILE_LIST_SEPARATOR;
 219           if (! (d->changed || always_make_flag))
 220             qmark_len -= len + 1;       /* Don't space in $? for this one.  */
 221         }
 222
 223     /* Kill the last space and define the variable.  */
 224
 225     cp[cp > plus_value ? -1 : 0] = '\0';
 226     DEFINE_VARIABLE ("+", 1, plus_value);
 227
 228     /* Compute the values for $^, $?, and $|.  */
 229
 230     cp = caret_value = plus_value; /* Reuse the buffer; it's big enough.  */
 231
 232     if (qmark_len > qmark_max)
 233       qmark_value = xrealloc (qmark_value, qmark_max = qmark_len);
 234     qp = qmark_value;
 235
 236     if (bar_len > bar_max)
 237       bar_value = xrealloc (bar_value, bar_max = bar_len);
 238     bp = bar_value;
 239
 240     /* Make sure that no dependencies are repeated in $^, $?, and $|.  It
 241        would be natural to combine the next two loops but we can't do it
 242        because of a situation where we have two dep entries, the first
 243        is order-only and the second is normal (see below).  */
 244
 245     hash_init (&dep_hash, 500, dep_hash_1, dep_hash_2, dep_hash_cmp);
 246
 247     for (d = file->deps; d != 0; d = d->next)
 248       {
 249         if (d->need_2nd_expansion || d->ignore_automatic_vars)
 250           continue;
 251
 252         slot = hash_find_slot (&dep_hash, d);
 253         if (HASH_VACANT (*slot))
 254           hash_insert_at (&dep_hash, d, slot);
 255         else
 256           {
 257             /* Check if the two prerequisites have different ignore_mtime.
 258                If so then we need to "upgrade" one that is order-only.  */
 259
 260             struct dep* hd = (struct dep*) *slot;
 261
 262             if (d->ignore_mtime != hd->ignore_mtime)
 263               d->ignore_mtime = hd->ignore_mtime = 0;
 264           }
 265       }
 266
 267     for (d = file->deps; d != 0; d = d->next)
 268       {
 269         const char *c;
 270
 271         if (d->need_2nd_expansion || d->ignore_automatic_vars || hash_find_item (&dep_hash, d) != d)
 272           continue;
 273
 274         c = dep_name (d);
 275 #ifndef NO_ARCHIVES
 276         if (ar_name (c))
 277           {
 278             c = strchr (c, '(') + 1;
 279             len = strlen (c) - 1;
 280           }
 281         else
 282 #endif
 283           len = strlen (c);
 284
 285         if (d->ignore_mtime)
 286           {
 287             bp = mempcpy (bp, c, len);
 288             *bp++ = FILE_LIST_SEPARATOR;
 289           }
 290         else
 291           {
 292             cp = mempcpy (cp, c, len);
 293             *cp++ = FILE_LIST_SEPARATOR;
 294             if (d->changed || always_make_flag)
 295               {
 296                 qp = mempcpy (qp, c, len);
 297                 *qp++ = FILE_LIST_SEPARATOR;
 298               }
 299           }
 300       }
 301
 302     hash_free (&dep_hash, 0);
 303
 304     /* Kill the last spaces and define the variables.  */
 305
 306     cp[cp > caret_value ? -1 : 0] = '\0';
 307     DEFINE_VARIABLE ("^", 1, caret_value);
 308
 309     qp[qp > qmark_value ? -1 : 0] = '\0';
 310     DEFINE_VARIABLE ("?", 1, qmark_value);
 311
 312     bp[bp > bar_value ? -1 : 0] = '\0';
 313     DEFINE_VARIABLE ("|", 1, bar_value);
 314   }
 315
 316 #undef  DEFINE_VARIABLE
 317 }
 318 \f
 319 /* Chop CMDS up into individual command lines if necessary.
 320    Also set the 'lines_flags' and 'any_recurse' members.  */
 321
 322 void
 323 chop_commands (struct commands *cmds)
 324 {
 325   unsigned short nlines;
 326   unsigned short i;
 327   char **lines;
 328
 329   /* If we don't have any commands, or we already parsed them, never mind.  */
 330   if (!cmds || cmds->command_lines != NULL)
 331     return;
 332
 333   /* Chop CMDS->commands up into lines in CMDS->command_lines.  */
 334
 335   if (one_shell)
 336     {
 337       size_t l = strlen (cmds->commands);
 338
 339       nlines = 1;
 340       lines = xmalloc (nlines * sizeof (char *));
 341       lines[0] = xstrdup (cmds->commands);
 342
 343       /* Strip the trailing newline.  */
 344       if (l > 0 && lines[0][l-1] == '\n')
 345         lines[0][l-1] = '\0';
 346     }
 347   else
 348     {
 349       const char *p = cmds->commands;
 350       size_t max = 5;
 351
 352       nlines = 0;
 353       lines = xmalloc (max * sizeof (char *));
 354       while (*p != '\0')
 355         {
 356           const char *end = p;
 357         find_end:;
 358           end = strchr (end, '\n');
 359           if (end == NULL)
 360             end = p + strlen (p);
 361           else if (end > p && end[-1] == '\\')
 362             {
 363               int backslash = 1;
 364               if (end > p + 1)
 365                 {
 366                   const char *b;
 367                   for (b = end - 2; b >= p && *b == '\\'; --b)
 368                     backslash = !backslash;
 369                 }
 370               if (backslash)
 371                 {
 372                   ++end;
 373                   goto find_end;
 374                 }
 375             }
 376
 377           if (nlines == USHRT_MAX)
 378             ON (fatal, &cmds->fileinfo,
 379                 _("Recipe has too many lines (limit %hu)"), nlines);
 380
 381           if (nlines == max)
 382             {
 383               max += 2;
 384               lines = xrealloc (lines, max * sizeof (char *));
 385             }
 386
 387           lines[nlines++] = xstrndup (p, (size_t) (end - p));
 388           p = end;
 389           if (*p != '\0')
 390             ++p;
 391         }
 392     }
 393
 394   /* Finally, set the corresponding CMDS->lines_flags elements and the
 395      CMDS->any_recurse flag.  */
 396
 397   cmds->ncommand_lines = nlines;
 398   cmds->command_lines = lines;
 399
 400   cmds->any_recurse = 0;
 401   cmds->lines_flags = xmalloc (nlines);
 402
 403   for (i = 0; i < nlines; ++i)
 404     {
 405       unsigned char flags = 0;
 406       const char *p = lines[i];
 407
 408       while (ISBLANK (*p) || *p == '-' || *p == '@' || *p == '+')
 409         switch (*(p++))
 410           {
 411           case '+':
 412             flags |= COMMANDS_RECURSE;
 413             break;
 414           case '@':
 415             flags |= COMMANDS_SILENT;
 416             break;
 417           case '-':
 418             flags |= COMMANDS_NOERROR;
 419             break;
 420           }
 421
 422       /* If no explicit '+' was given, look for MAKE variable references.  */
 423       if (! ANY_SET (flags, COMMANDS_RECURSE)
 424           && (strstr (p, "$(MAKE)") != 0 || strstr (p, "${MAKE}") != 0))
 425         flags |= COMMANDS_RECURSE;
 426
 427       cmds->lines_flags[i] = flags;
 428       cmds->any_recurse |= ANY_SET (flags, COMMANDS_RECURSE) ? 1 : 0;
 429     }
 430 }
 431 \f
 432 /* Execute the commands to remake FILE.  If they are currently executing,
 433    return or have already finished executing, just return.  Otherwise,
 434    fork off a child process to run the first command line in the sequence.  */
 435
 436 void
 437 execute_file_commands (struct file *file)
 438 {
 439   const char *p;
 440
 441   /* Don't go through all the preparations if
 442      the commands are nothing but whitespace.  */
 443
 444   for (p = file->cmds->commands; *p != '\0'; ++p)
 445     if (!ISSPACE (*p) && *p != '-' && *p != '@' && *p != '+')
 446       break;
 447   if (*p == '\0')
 448     {
 449       /* If there are no commands, assume everything worked.  */
 450       set_command_state (file, cs_running);
 451       file->update_status = us_success;
 452       notice_finished_file (file);
 453       return;
 454     }
 455
 456   /* First set the automatic variables according to this file.  */
 457
 458   initialize_file_variables (file, 0);
 459
 460   set_file_variables (file, file->stem);
 461
 462   /* Some systems don't support overwriting a loaded object so if this one
 463      unload it before remaking.  Keep its name in .LOADED: it will be rebuilt
 464      and loaded again.  If rebuilding or loading again fail, then we'll exit
 465      anyway and it won't matter.  */
 466   if (file->loaded && unload_file (file->name) == 0)
 467     {
 468       file->loaded = 0;
 469       file->unloaded = 1;
 470     }
 471
 472   /* Start the commands running.  */
 473   new_job (file);
 474 }
 475 \f
 476 /* This is set while we are inside fatal_error_signal,
 477    so things can avoid nonreentrant operations.  */
 478
 479 volatile sig_atomic_t handling_fatal_signal = 0;
 480
 481 /* Handle fatal signals.  */
 482
 483 void
 484 fatal_error_signal (int sig)
 485 {
 486 #ifdef __MSDOS__
 487   extern int dos_status, dos_command_running;
 488
 489   if (dos_command_running)
 490     {
 491       /* That was the child who got the signal, not us.  */
 492       dos_status |= (sig << 8);
 493       return;
 494     }
 495   remove_intermediates (1);
 496   exit (EXIT_FAILURE);
 497 #else /* not __MSDOS__ */
 498 #ifdef _AMIGA
 499   remove_intermediates (1);
 500   if (sig == SIGINT)
 501      fputs (_("*** Break.\n"), stderr);
 502
 503   exit (10);
 504 #else /* not Amiga */
 505 #ifdef WINDOWS32
 506   extern HANDLE main_thread;
 507
 508   /* Windows creates a separate thread for handling Ctrl+C, so we need
 509      to suspend the main thread, or else we will have race conditions
 510      when both threads call reap_children.  */
 511   if (main_thread)
 512     {
 513       DWORD susp_count = SuspendThread (main_thread);
 514
 515       if (susp_count != 0)
 516         fprintf (stderr, "SuspendThread: suspend count = %lu\n", susp_count);
 517       else if (susp_count == (DWORD)-1)
 518         {
 519           DWORD ierr = GetLastError ();
 520
 521           fprintf (stderr, "SuspendThread: error %lu: %s\n",
 522                    ierr, map_windows32_error_to_string (ierr));
 523         }
 524     }
 525 #endif
 526   handling_fatal_signal = 1;
 527
 528   /* Set the handling for this signal to the default.
 529      It is blocked now while we run this handler.  */
 530   signal (sig, SIG_DFL);
 531
 532   temp_stdin_unlink ();
 533   osync_clear ();
 534   jobserver_clear ();
 535
 536   /* A termination signal won't be sent to the entire
 537      process group, but it means we want to kill the children.  */
 538
 539   if (sig == SIGTERM)
 540     {
 541       struct child *c;
 542       for (c = children; c != 0; c = c->next)
 543         if (!c->remote && c->pid > 0)
 544           (void) kill (c->pid, SIGTERM);
 545     }
 546
 547   /* If we got a signal that means the user
 548      wanted to kill make, remove pending targets.  */
 549
 550   if (sig == SIGTERM || sig == SIGINT
 551 #ifdef SIGHUP
 552     || sig == SIGHUP
 553 #endif
 554 #ifdef SIGQUIT
 555     || sig == SIGQUIT
 556 #endif
 557     )
 558     {
 559       struct child *c;
 560
 561       /* Remote children won't automatically get signals sent
 562          to the process group, so we must send them.  */
 563       for (c = children; c != 0; c = c->next)
 564         if (c->remote && c->pid > 0)
 565           (void) remote_kill (c->pid, sig);
 566
 567       for (c = children; c != 0; c = c->next)
 568         delete_child_targets (c);
 569
 570       /* Clean up the children.  We don't just use the call below because
 571          we don't want to print the "Waiting for children" message.  */
 572       while (job_slots_used > 0)
 573         reap_children (1, 0);
 574     }
 575   else
 576     /* Wait for our children to die.  */
 577     while (job_slots_used > 0)
 578       reap_children (1, 1);
 579
 580   /* Delete any non-precious intermediate files that were made.  */
 581
 582   remove_intermediates (1);
 583
 584 #ifdef SIGQUIT
 585   if (sig == SIGQUIT)
 586     /* We don't want to send ourselves SIGQUIT, because it will
 587        cause a core dump.  Just exit instead.  */
 588     exit (MAKE_TROUBLE);
 589 #endif
 590
 591 #ifdef WINDOWS32
 592   if (main_thread)
 593     CloseHandle (main_thread);
 594   /* Cannot call W32_kill with a pid (it needs a handle).  The exit
 595      status of 130 emulates what happens in Bash.  */
 596   exit (130);
 597 #else
 598   /* Signal the same code; this time it will really be fatal.  The signal
 599      will be unblocked when we return and arrive then to kill us.  */
 600   if (kill (make_pid (), sig) < 0)
 601     pfatal_with_name ("kill");
 602 #endif /* not WINDOWS32 */
 603 #endif /* not Amiga */
 604 #endif /* not __MSDOS__  */
 605 }
 606 \f
 607 /* Delete FILE unless it's precious or not actually a file (phony),
 608    and it has changed on disk since we last stat'd it.  */
 609
 610 static void
 611 delete_target (struct file *file, const char *on_behalf_of)
 612 {
 613   struct stat st;
 614   int e;
 615
 616   if (file->precious || file->phony)
 617     return;
 618
 619 #ifndef NO_ARCHIVES
 620   if (ar_name (file->name))
 621     {
 622       time_t file_date = (file->last_mtime == NONEXISTENT_MTIME
 623                           ? (time_t) -1
 624                           : (time_t) FILE_TIMESTAMP_S (file->last_mtime));
 625       if (ar_member_date (file->name) != file_date)
 626         {
 627           if (on_behalf_of)
 628             OSS (error, NILF,
 629                  _("*** [%s] Archive member '%s' may be bogus; not deleted"),
 630                  on_behalf_of, file->name);
 631           else
 632             OS (error, NILF,
 633                 _("*** Archive member '%s' may be bogus; not deleted"),
 634                 file->name);
 635         }
 636       return;
 637     }
 638 #endif
 639
 640   EINTRLOOP (e, stat (file->name, &st));
 641   if (e == 0
 642       && S_ISREG (st.st_mode)
 643       && FILE_TIMESTAMP_STAT_MODTIME (file->name, st) != file->last_mtime)
 644     {
 645       if (on_behalf_of)
 646         OSS (error, NILF,
 647              _("*** [%s] Deleting file '%s'"), on_behalf_of, file->name);
 648       else
 649         OS (error, NILF, _("*** Deleting file '%s'"), file->name);
 650       if (unlink (file->name) < 0
 651           && errno != ENOENT)   /* It disappeared; so what.  */
 652         perror_with_name ("unlink: ", file->name);
 653     }
 654 }
 655
 656
 657 /* Delete all non-precious targets of CHILD unless they were already deleted.
 658    Set the flag in CHILD to say they've been deleted.  */
 659
 660 void
 661 delete_child_targets (struct child *child)
 662 {
 663   struct dep *d;
 664
 665   if (child->deleted || child->pid < 0)
 666     return;
 667
 668   /* Delete the target file if it changed.  */
 669   delete_target (child->file, NULL);
 670
 671   /* Also remove any non-precious targets listed in the 'also_make' member.  */
 672   for (d = child->file->also_make; d != 0; d = d->next)
 673     delete_target (d->file, child->file->name);
 674
 675   child->deleted = 1;
 676 }
 677 \f
 678 /* Print out the commands in CMDS.  */
 679
 680 void
 681 print_commands (const struct commands *cmds)
 682 {
 683   const char *s;
 684
 685   fputs (_("#  recipe to execute"), stdout);
 686
 687   if (cmds->fileinfo.filenm == 0)
 688     puts (_(" (built-in):"));
 689   else
 690     printf (_(" (from '%s', line %lu):\n"),
 691             cmds->fileinfo.filenm, cmds->fileinfo.lineno);
 692
 693   s = cmds->commands;
 694   while (*s != '\0')
 695     {
 696       const char *end;
 697       int bs;
 698
 699       /* Print one full logical recipe line: find a non-escaped newline.  */
 700       for (end = s, bs = 0; *end != '\0'; ++end)
 701         {
 702           if (*end == '\n' && !bs)
 703             break;
 704
 705           bs = *end == '\\' ? !bs : 0;
 706         }
 707
 708       printf ("%c%.*s\n", cmd_prefix, (int) (end - s), s);
 709
 710       s = end + (end[0] == '\n');
 711     }
 712 }