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