commands.c

   1 /* Command processing for GNU Make.
   2 Copyright (C) 1988,89,91,92,93,94,95,96,97 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
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2, or (at your option)
   8 any later version.
   9
  10 GNU Make is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with GNU Make; see the file COPYING.  If not, write to
  17 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  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
  26 extern int remote_kill PARAMS ((int id, int sig));
  27
  28 #ifndef HAVE_UNISTD_H
  29 extern int getpid ();
  30 #endif
  31 \f
  32 /* Set FILE's automatic variables up.  */
  33
  34 static void
  35 set_file_variables (file)
  36      register struct file *file;
  37 {
  38   register char *p;
  39   char *at, *percent, *star, *less;
  40
  41 #ifndef NO_ARCHIVES
  42   /* If the target is an archive member `lib(member)',
  43      then $@ is `lib' and $% is `member'.  */
  44
  45   if (ar_name (file->name))
  46     {
  47       unsigned int len;
  48       p = index (file->name, '(');
  49       at = (char *) alloca (p - file->name + 1);
  50       bcopy (file->name, at, p - file->name);
  51       at[p - file->name] = '\0';
  52       len = strlen (p + 1);
  53       percent = (char *) alloca (len);
  54       bcopy (p + 1, percent, len - 1);
  55       percent[len - 1] = '\0';
  56     }
  57   else
  58 #endif  /* NO_ARCHIVES.  */
  59     {
  60       at = file->name;
  61       percent = "";
  62     }
  63
  64   /* $* is the stem from an implicit or static pattern rule.  */
  65   if (file->stem == 0)
  66     {
  67       /* In Unix make, $* is set to the target name with
  68          any suffix in the .SUFFIXES list stripped off for
  69          explicit rules.  We store this in the `stem' member.  */
  70       register struct dep *d;
  71       char *name;
  72       unsigned int len;
  73
  74 #ifndef NO_ARCHIVES
  75       if (ar_name (file->name))
  76         {
  77           name = index (file->name, '(') + 1;
  78           len = strlen (name) - 1;
  79         }
  80       else
  81 #endif
  82         {
  83           name = file->name;
  84           len = strlen (name);
  85         }
  86
  87       for (d = enter_file (".SUFFIXES")->deps; d != 0; d = d->next)
  88         {
  89           unsigned int slen = strlen (dep_name (d));
  90           if (len > slen && !strncmp (dep_name (d), name + (len - slen), slen))
  91             {
  92               file->stem = savestring (name, len - slen);
  93               break;
  94             }
  95         }
  96       if (d == 0)
  97         file->stem = "";
  98     }
  99   star = file->stem;
 100
 101   /* $< is the first dependency.  */
 102   less = file->deps != 0 ? dep_name (file->deps) : "";
 103
 104   if (file->cmds == default_file->cmds)
 105     /* This file got its commands from .DEFAULT.
 106        In this case $< is the same as $@.  */
 107     less = at;
 108
 109 #define DEFINE_VARIABLE(name, len, value) \
 110   (void) define_variable_for_file (name, len, value, o_automatic, 0, file)
 111
 112   /* Define the variables.  */
 113
 114   DEFINE_VARIABLE ("<", 1, less);
 115   DEFINE_VARIABLE ("*", 1, star);
 116   DEFINE_VARIABLE ("@", 1, at);
 117   DEFINE_VARIABLE ("%", 1, percent);
 118
 119   /* Compute the values for $^, $+, and $?.  */
 120
 121   {
 122     register unsigned int qmark_len, plus_len;
 123     char *caret_value, *plus_value;
 124     register char *cp;
 125     char *qmark_value;
 126     register char *qp;
 127     register struct dep *d;
 128     unsigned int len;
 129
 130     /* Compute first the value for $+, which is supposed to contain
 131        duplicate dependencies as they were listed in the makefile.  */
 132
 133     plus_len = 0;
 134     for (d = file->deps; d != 0; d = d->next)
 135       plus_len += strlen (dep_name (d)) + 1;
 136
 137     len = plus_len == 0 ? 1 : plus_len;
 138     cp = plus_value = (char *) alloca (len);
 139
 140     qmark_len = plus_len;       /* Will be this or less.  */
 141     for (d = file->deps; d != 0; d = d->next)
 142       {
 143         char *c = dep_name (d);
 144
 145 #ifndef NO_ARCHIVES
 146         if (ar_name (c))
 147           {
 148             c = index (c, '(') + 1;
 149             len = strlen (c) - 1;
 150           }
 151         else
 152 #endif
 153           len = strlen (c);
 154
 155         bcopy (c, cp, len);
 156         cp += len;
 157 #if VMS
 158         *cp++ = ',';
 159 #else
 160         *cp++ = ' ';
 161 #endif
 162         if (! d->changed)
 163           qmark_len -= len + 1; /* Don't space in $? for this one.  */
 164       }
 165
 166     /* Kill the last space and define the variable.  */
 167
 168     cp[cp > plus_value ? -1 : 0] = '\0';
 169     DEFINE_VARIABLE ("+", 1, plus_value);
 170
 171     /* Make sure that no dependencies are repeated.  This does not
 172        really matter for the purpose of updating targets, but it
 173        might make some names be listed twice for $^ and $?.  */
 174
 175     uniquize_deps (file->deps);
 176
 177     /* Compute the values for $^ and $?.  */
 178
 179     cp = caret_value = plus_value; /* Reuse the buffer; it's big enough.  */
 180     len = qmark_len == 0 ? 1 : qmark_len;
 181     qp = qmark_value = (char *) alloca (len);
 182
 183     for (d = file->deps; d != 0; d = d->next)
 184       {
 185         char *c = dep_name (d);
 186
 187 #ifndef NO_ARCHIVES
 188         if (ar_name (c))
 189           {
 190             c = index (c, '(') + 1;
 191             len = strlen (c) - 1;
 192           }
 193         else
 194 #endif
 195           len = strlen (c);
 196
 197         bcopy (c, cp, len);
 198         cp += len;
 199 #if VMS
 200         *cp++ = ',';
 201 #else
 202         *cp++ = ' ';
 203 #endif
 204         if (d->changed)
 205           {
 206             bcopy (c, qp, len);
 207             qp += len;
 208 #if VMS
 209             *qp++ = ',';
 210 #else
 211             *qp++ = ' ';
 212 #endif
 213           }
 214       }
 215
 216     /* Kill the last spaces and define the variables.  */
 217
 218     cp[cp > caret_value ? -1 : 0] = '\0';
 219     DEFINE_VARIABLE ("^", 1, caret_value);
 220
 221     qp[qp > qmark_value ? -1 : 0] = '\0';
 222     DEFINE_VARIABLE ("?", 1, qmark_value);
 223   }
 224
 225 #undef  DEFINE_VARIABLE
 226 }
 227 \f
 228 /* Chop CMDS up into individual command lines if necessary.
 229    Also set the `lines_flag' and `any_recurse' members.  */
 230
 231 void
 232 chop_commands (cmds)
 233      register struct commands *cmds;
 234 {
 235   if (cmds != 0 && cmds->command_lines == 0)
 236     {
 237       /* Chop CMDS->commands up into lines in CMDS->command_lines.
 238          Also set the corresponding CMDS->lines_flags elements,
 239          and the CMDS->any_recurse flag.  */
 240       register char *p;
 241       unsigned int nlines, idx;
 242       char **lines;
 243
 244       nlines = 5;
 245       lines = (char **) xmalloc (5 * sizeof (char *));
 246       idx = 0;
 247       p = cmds->commands;
 248       while (*p != '\0')
 249         {
 250           char *end = p;
 251         find_end:;
 252           end = index (end, '\n');
 253           if (end == 0)
 254             end = p + strlen (p);
 255           else if (end > p && end[-1] == '\\')
 256             {
 257               int backslash = 1;
 258               register char *b;
 259               for (b = end - 2; b >= p && *b == '\\'; --b)
 260                 backslash = !backslash;
 261               if (backslash)
 262                 {
 263                   ++end;
 264                   goto find_end;
 265                 }
 266             }
 267
 268           if (idx == nlines)
 269             {
 270               nlines += 2;
 271               lines = (char **) xrealloc ((char *) lines,
 272                                           nlines * sizeof (char *));
 273             }
 274           lines[idx++] = savestring (p, end - p);
 275           p = end;
 276           if (*p != '\0')
 277             ++p;
 278         }
 279
 280       if (idx != nlines)
 281         {
 282           nlines = idx;
 283           lines = (char **) xrealloc ((char *) lines,
 284                                       nlines * sizeof (char *));
 285         }
 286
 287       cmds->ncommand_lines = nlines;
 288       cmds->command_lines = lines;
 289
 290       cmds->any_recurse = 0;
 291       cmds->lines_flags = (char *) xmalloc (nlines);
 292       for (idx = 0; idx < nlines; ++idx)
 293         {
 294           int flags = 0;
 295
 296           for (p = lines[idx];
 297                isblank (*p) || *p == '-' || *p == '@' || *p == '+';
 298                ++p)
 299             switch (*p)
 300               {
 301               case '+':
 302                 flags |= COMMANDS_RECURSE;
 303                 break;
 304               case '@':
 305                 flags |= COMMANDS_SILENT;
 306                 break;
 307               case '-':
 308                 flags |= COMMANDS_NOERROR;
 309                 break;
 310               }
 311           if (!(flags & COMMANDS_RECURSE))
 312             {
 313               unsigned int len = strlen (p);
 314               if (sindex (p, len, "$(MAKE)", 7) != 0
 315                   || sindex (p, len, "${MAKE}", 7) != 0)
 316                 flags |= COMMANDS_RECURSE;
 317             }
 318
 319           cmds->lines_flags[idx] = flags;
 320           cmds->any_recurse |= flags & COMMANDS_RECURSE;
 321         }
 322     }
 323 }
 324 \f
 325 /* Execute the commands to remake FILE.  If they are currently executing,
 326    return or have already finished executing, just return.  Otherwise,
 327    fork off a child process to run the first command line in the sequence.  */
 328
 329 void
 330 execute_file_commands (file)
 331      struct file *file;
 332 {
 333   register char *p;
 334
 335   /* Don't go through all the preparations if
 336      the commands are nothing but whitespace.  */
 337
 338   for (p = file->cmds->commands; *p != '\0'; ++p)
 339     if (!isspace (*p) && *p != '-' && *p != '@')
 340       break;
 341   if (*p == '\0')
 342     {
 343       /* We are all out of commands.
 344          If we have gotten this far, all the previous commands
 345          have run successfully, so we have winning update status.  */
 346       file->update_status = 0;
 347       notice_finished_file (file);
 348       return;
 349     }
 350
 351   /* First set the automatic variables according to this file.  */
 352
 353   initialize_file_variables (file);
 354
 355   set_file_variables (file);
 356
 357   /* Start the commands running.  */
 358   new_job (file);
 359 }
 360 \f
 361 /* This is set while we are inside fatal_error_signal,
 362    so things can avoid nonreentrant operations.  */
 363
 364 int handling_fatal_signal = 0;
 365
 366 /* Handle fatal signals.  */
 367
 368 RETSIGTYPE
 369 fatal_error_signal (sig)
 370      int sig;
 371 {
 372 #ifdef __MSDOS__
 373   extern int dos_status, dos_command_running;
 374
 375   if (dos_command_running)
 376     {
 377       /* That was the child who got the signal, not us.  */
 378       dos_status |= (sig << 8);
 379       return;
 380     }
 381   remove_intermediates (1);
 382   exit (1);
 383 #else /* not __MSDOS__ */
 384 #ifdef _AMIGA
 385   remove_intermediates (1);
 386   if (sig == SIGINT)
 387      fputs ("*** Break.\n", stderr);
 388
 389   exit (10);
 390 #else /* not Amiga */
 391   handling_fatal_signal = 1;
 392
 393   /* Set the handling for this signal to the default.
 394      It is blocked now while we run this handler.  */
 395   signal (sig, SIG_DFL);
 396
 397   /* A termination signal won't be sent to the entire
 398      process group, but it means we want to kill the children.  */
 399
 400   if (sig == SIGTERM)
 401     {
 402       register struct child *c;
 403       for (c = children; c != 0; c = c->next)
 404         if (!c->remote)
 405           (void) kill (c->pid, SIGTERM);
 406     }
 407
 408   /* If we got a signal that means the user
 409      wanted to kill make, remove pending targets.  */
 410
 411   if (sig == SIGTERM || sig == SIGINT
 412 #ifdef SIGHUP
 413     || sig == SIGHUP
 414 #endif
 415 #ifdef SIGQUIT
 416     || sig == SIGQUIT
 417 #endif
 418     )
 419     {
 420       register struct child *c;
 421
 422       /* Remote children won't automatically get signals sent
 423          to the process group, so we must send them.  */
 424       for (c = children; c != 0; c = c->next)
 425         if (c->remote)
 426           (void) remote_kill (c->pid, sig);
 427
 428       for (c = children; c != 0; c = c->next)
 429         delete_child_targets (c);
 430
 431       /* Clean up the children.  We don't just use the call below because
 432          we don't want to print the "Waiting for children" message.  */
 433       while (job_slots_used > 0)
 434         reap_children (1, 0);
 435     }
 436   else
 437     /* Wait for our children to die.  */
 438     while (job_slots_used > 0)
 439       reap_children (1, 1);
 440
 441   /* Delete any non-precious intermediate files that were made.  */
 442
 443   remove_intermediates (1);
 444
 445 #ifdef SIGQUIT
 446   if (sig == SIGQUIT)
 447     /* We don't want to send ourselves SIGQUIT, because it will
 448        cause a core dump.  Just exit instead.  */
 449     exit (EXIT_FAILURE);
 450 #endif
 451
 452   /* Signal the same code; this time it will really be fatal.  The signal
 453      will be unblocked when we return and arrive then to kill us.  */
 454   if (kill (getpid (), sig) < 0)
 455     pfatal_with_name ("kill");
 456 #endif /* not Amiga */
 457 #endif /* not __MSDOS__  */
 458 }
 459 \f
 460 /* Delete FILE unless it's precious or not actually a file (phony),
 461    and it has changed on disk since we last stat'd it.  */
 462
 463 static void
 464 delete_target (file, on_behalf_of)
 465      struct file *file;
 466      char *on_behalf_of;
 467 {
 468   struct stat st;
 469
 470   if (file->precious || file->phony)
 471     return;
 472
 473 #ifndef NO_ARCHIVES
 474   if (ar_name (file->name))
 475     {
 476       if (ar_member_date (file->name) != file->last_mtime)
 477         {
 478           if (on_behalf_of)
 479             error ("*** [%s] Archive member `%s' may be bogus; not deleted",
 480                    on_behalf_of, file->name);
 481           else
 482             error ("*** Archive member `%s' may be bogus; not deleted",
 483                    file->name);
 484         }
 485       return;
 486     }
 487 #endif
 488
 489   if (stat (file->name, &st) == 0
 490       && S_ISREG (st.st_mode)
 491       && (time_t) st.st_mtime != file->last_mtime)
 492     {
 493       if (on_behalf_of)
 494         error ("*** [%s] Deleting file `%s'", on_behalf_of, file->name);
 495       else
 496         error ("*** Deleting file `%s'", file->name);
 497       if (unlink (file->name) < 0
 498           && errno != ENOENT)   /* It disappeared; so what.  */
 499         perror_with_name ("unlink: ", file->name);
 500     }
 501 }
 502
 503
 504 /* Delete all non-precious targets of CHILD unless they were already deleted.
 505    Set the flag in CHILD to say they've been deleted.  */
 506
 507 void
 508 delete_child_targets (child)
 509      struct child *child;
 510 {
 511   struct dep *d;
 512
 513   if (child->deleted)
 514     return;
 515
 516   /* Delete the target file if it changed.  */
 517   delete_target (child->file, (char *) 0);
 518
 519   /* Also remove any non-precious targets listed in the `also_make' member.  */
 520   for (d = child->file->also_make; d != 0; d = d->next)
 521     delete_target (d->file, child->file->name);
 522
 523   child->deleted = 1;
 524 }
 525 \f
 526 /* Print out the commands in CMDS.  */
 527
 528 void
 529 print_commands (cmds)
 530      register struct commands *cmds;
 531 {
 532   register char *s;
 533
 534   fputs ("#  commands to execute", stdout);
 535
 536   if (cmds->filename == 0)
 537     puts (" (built-in):");
 538   else
 539     printf (" (from `%s', line %u):\n", cmds->filename, cmds->lineno);
 540
 541   s = cmds->commands;
 542   while (*s != '\0')
 543     {
 544       char *end;
 545
 546       while (isspace (*s))
 547         ++s;
 548
 549       end = index (s, '\n');
 550       if (end == 0)
 551         end = s + strlen (s);
 552
 553       printf ("\t%.*s\n", (int) (end - s), s);
 554
 555       s = end;
 556     }
 557 }