commands.c

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