commands.c

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