home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 4 / FreshFish_May-June1994.bin / bbs / gnu / make-3.70-src.lha / src / amiga / make-3.70 / commands.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-09-17  |  11.2 KB  |  472 lines
  1. /* Command processing for GNU Make.
  2. Copyright (C) 1988, 1989, 1991, 1992, 1993 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 "commands.h"
  22. #include "file.h"
  23. #include "variable.h"
  24. #include "job.h"
  25.  
  26. extern int remote_kill ();
  27.  
  28. #ifndef    HAVE_UNISTD_H
  29. extern int getpid ();
  30. #endif
  31.  
  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.   /* Make sure that no dependencies are repeated.  This does not
  120.      really matter for the purpose of updating targets, but it
  121.      might make some names be listed twice for $^ and $?.  */
  122.  
  123.   uniquize_deps (file->deps);
  124.  
  125.   /* Compute the values for $^ and $?.  */
  126.  
  127.   {
  128.     register unsigned int caret_len, qmark_len;
  129.     char *caret_value;
  130.     register char *cp;
  131.     char *qmark_value;
  132.     register char *qp;
  133.     register struct dep *d;
  134.     unsigned int len;
  135.  
  136.     caret_len = qmark_len = 0;
  137.     for (d = file->deps; d != 0; d = d->next)
  138.       {
  139.     register unsigned int i = strlen (dep_name (d)) + 1;
  140.     caret_len += i;
  141.     if (d->changed)
  142.       qmark_len += i;
  143.       }
  144.  
  145.     len = caret_len == 0 ? 1 : caret_len;
  146.     cp = caret_value = (char *) alloca (len);
  147.     len = qmark_len == 0 ? 1 : qmark_len;
  148.     qp = qmark_value = (char *) alloca (len);
  149.  
  150.     for (d = file->deps; d != 0; d = d->next)
  151.       {
  152.     char *c = dep_name (d);
  153.  
  154. #ifndef    NO_ARCHIVES
  155.     if (ar_name (c))
  156.       {
  157.         c = index (c, '(') + 1;
  158.         len = strlen (c) - 1;
  159.       }
  160.     else
  161. #endif
  162.       len = strlen (c);
  163.  
  164.     bcopy (c, cp, len);
  165.     cp += len;
  166.     *cp++ = ' ';
  167.  
  168.     if (d->changed)
  169.       {
  170.         bcopy (c, qp, len);
  171.         qp += len;
  172.         *qp++ = ' ';
  173.       }
  174.       }
  175.  
  176.     /* Kill the last spaces and define the variables.  */
  177.  
  178.     cp[cp > caret_value ? -1 : 0] = '\0';
  179.     DEFINE_VARIABLE ("^", 1, caret_value);
  180.  
  181.     qp[qp > qmark_value ? -1 : 0] = '\0';
  182.     DEFINE_VARIABLE ("?", 1, qmark_value);
  183.   }
  184.  
  185. #undef    DEFINE_VARIABLE
  186. }
  187.  
  188. /* Chop CMDS up into individual command lines if necessary.
  189.    Also set the `lines_flag' and `any_recurse' members.  */
  190.  
  191. void
  192. chop_commands (cmds)
  193.      register struct commands *cmds;
  194. {
  195.   if (cmds != 0 && cmds->command_lines == 0)
  196.     {
  197.       /* Chop CMDS->commands up into lines in CMDS->command_lines.
  198.      Also set the corresponding CMDS->lines_flags elements,
  199.      and the CMDS->any_recurse flag.  */
  200.       register char *p;
  201.       unsigned int nlines, idx;
  202.       char **lines;
  203.  
  204.       nlines = 5;
  205.       lines = (char **) xmalloc (5 * sizeof (char *));
  206.       idx = 0;
  207.       p = cmds->commands;
  208.       while (*p != '\0')
  209.     {
  210.       char *end = p;
  211.     find_end:;
  212.       end = index (end, '\n');
  213.       if (end == 0)
  214.         end = p + strlen (p);
  215.       else if (end > p && end[-1] == '\\')
  216.         {
  217.           int backslash = 1;
  218.           register char *b;
  219.           for (b = end - 2; b >= p && *b == '\\'; --b)
  220.         backslash = !backslash;
  221.           if (backslash)
  222.         {
  223.           ++end;
  224.           goto find_end;
  225.         }
  226.         }
  227.  
  228.       if (idx == nlines)
  229.         {
  230.           nlines += 2;
  231.           lines = (char **) xrealloc ((char *) lines,
  232.                       nlines * sizeof (char *));
  233.         }
  234.       lines[idx++] = savestring (p, end - p);
  235.       p = end;
  236.       if (*p != '\0')
  237.         ++p;
  238.     }
  239.  
  240.       if (idx != nlines)
  241.     {
  242.       nlines = idx;
  243.       lines = (char **) xrealloc ((char *) lines,
  244.                       nlines * sizeof (char *));
  245.     }
  246.  
  247.       cmds->ncommand_lines = nlines;
  248.       cmds->command_lines = lines;
  249.  
  250.       cmds->any_recurse = 0;
  251.       cmds->lines_flags = (char *) xmalloc (nlines);
  252.       for (idx = 0; idx < nlines; ++idx)
  253.     {
  254.       int flags = 0;
  255.  
  256.       for (p = lines[idx];
  257.            isblank (*p) || *p == '-' || *p == '@' || *p == '+';
  258.            ++p)
  259.         switch (*p)
  260.           {
  261.           case '+':
  262.         flags |= COMMANDS_RECURSE;
  263.         break;
  264.           case '@':
  265.         flags |= COMMANDS_SILENT;
  266.         break;
  267.           case '-':
  268.         flags |= COMMANDS_NOERROR;
  269.         break;
  270.           }
  271.       if (!(flags & COMMANDS_RECURSE))
  272.         {
  273.           unsigned int len = strlen (p);
  274.           if (sindex (p, len, "$(MAKE)", 7) != 0
  275.           || sindex (p, len, "${MAKE}", 7) != 0)
  276.         flags |= COMMANDS_RECURSE;
  277.         }
  278.  
  279.       cmds->lines_flags[idx] = flags;
  280.       cmds->any_recurse |= flags & COMMANDS_RECURSE;
  281.     }
  282.     }
  283. }
  284.  
  285. /* Execute the commands to remake FILE.  If they are currently executing,
  286.    return or have already finished executing, just return.  Otherwise,
  287.    fork off a child process to run the first command line in the sequence.  */
  288.  
  289. void
  290. execute_file_commands (file)
  291.      struct file *file;
  292. {
  293.   register char *p;
  294.  
  295.   /* Don't go through all the preparations if
  296.      the commands are nothing but whitespace.  */
  297.  
  298.   for (p = file->cmds->commands; *p != '\0'; ++p)
  299.     if (!isspace (*p) && *p != '-' && *p != '@')
  300.       break;
  301.   if (*p == '\0')
  302.     {
  303.       /* We are all out of commands.
  304.      If we have gotten this far, all the previous commands
  305.      have run successfully, so we have winning update status.  */
  306.       file->update_status = 0;
  307.       notice_finished_file (file);
  308.       return;
  309.     }
  310.  
  311.   /* First set the automatic variables according to this file.  */
  312.  
  313.   initialize_file_variables (file);
  314.  
  315.   set_file_variables (file);
  316.  
  317.   /* Start the commands running.  */
  318.   new_job (file);
  319. }
  320.  
  321. /* This is set while we are inside fatal_error_signal,
  322.    so things can avoid nonreentrant operations.  */
  323.  
  324. int handling_fatal_signal = 0;
  325.  
  326. /* Handle fatal signals.  */
  327.  
  328. RETSIGTYPE
  329. fatal_error_signal (sig)
  330.      int sig;
  331. {
  332.   handling_fatal_signal = 1;
  333.  
  334.   signal (sig, SIG_DFL);
  335. #ifdef    POSIX
  336.   {
  337.     sigset_t set;
  338.     sigemptyset (&set);
  339.     (void) sigprocmask (SIG_SETMASK, &set, (sigset_t *) 0);
  340.   }
  341. #else
  342. #ifdef    HAVE_SIGSETMASK
  343.   (void) sigsetmask (0);
  344. #endif
  345. #endif
  346.  
  347.   /* A termination signal won't be sent to the entire
  348.      process group, but it means we want to kill the children.  */
  349.  
  350.   if (sig == SIGTERM)
  351.     {
  352.       register struct child *c;
  353.       for (c = children; c != 0; c = c->next)
  354.     if (!c->remote)
  355.       (void) kill (c->pid, SIGTERM);
  356.     }
  357.  
  358.   /* If we got a signal that means the user
  359.      wanted to kill make, remove pending targets.  */
  360.  
  361.   if (sig == SIGTERM || sig == SIGINT || sig == SIGHUP || sig == SIGQUIT)
  362.     {
  363.       register struct child *c;
  364.  
  365.       /* Remote children won't automatically get signals sent
  366.      to the process group, so we must send them.  */
  367.       for (c = children; c != 0; c = c->next)
  368.     if (c->remote)
  369.       (void) remote_kill (c->pid, sig);
  370.  
  371.       for (c = children; c != 0; c = c->next)
  372.     delete_child_targets (c);
  373.  
  374.       /* Clean up the children.  We don't just use the call below because
  375.      we don't want to print the "Waiting for children" message.  */
  376.       while (job_slots_used > 0)
  377.     reap_children (1, 0);
  378.     }
  379.   else
  380.     /* Wait for our children to die.  */
  381.     while (job_slots_used > 0)
  382.       reap_children (1, 1);
  383.  
  384.   /* Delete any non-precious intermediate files that were made.  */
  385.  
  386.   remove_intermediates (1);
  387.  
  388.   if (sig == SIGQUIT)
  389.     /* We don't want to send ourselves SIGQUIT, because it will
  390.        cause a core dump.  Just exit instead.  */
  391.     exit (1);
  392.  
  393.   /* Signal the same code; this time it will really be fatal.  */
  394.   if (kill (getpid (), sig) < 0)
  395.     /* It shouldn't return, but if it does, die anyway.  */
  396.     pfatal_with_name ("kill");
  397. }
  398.  
  399. /* Delete all non-precious targets of CHILD unless they were already deleted.
  400.    Set the flag in CHILD to say they've been deleted.  */
  401.  
  402. void
  403. delete_child_targets (child)
  404.      struct child *child;
  405. {
  406.   struct stat st;
  407.   struct dep *d;
  408.  
  409.   if (child->deleted)
  410.     return;
  411.  
  412.   /* Delete the file unless it's precious or not actually a file (phony).  */
  413.   if (!child->file->precious && !child->file->phony
  414.       && stat (child->file->name, &st) == 0
  415.       && S_ISREG (st.st_mode)
  416.       && (time_t) st.st_mtime != child->file->last_mtime)
  417.     {
  418.       error ("*** Deleting file `%s'", child->file->name);
  419.       if (unlink (child->file->name) < 0)
  420.     perror_with_name ("unlink: ", child->file->name);
  421.     }
  422.  
  423.   /* Also remove any non-precious targets listed
  424.      in the `also_make' member.  */
  425.   for (d = child->file->also_make; d != 0; d = d->next)
  426.     if (!d->file->precious && !d->file->phony)
  427.       if (stat (d->file->name, &st) == 0
  428.       && S_ISREG (st.st_mode)
  429.       && (time_t) st.st_mtime != d->file->last_mtime)
  430.     {
  431.       error ("*** [%s] Deleting file `%s'", child->file->name,
  432.          d->file->name);
  433.       if (unlink (d->file->name) < 0)
  434.         perror_with_name ("unlink: ", d->file->name);
  435.     }
  436.  
  437.   child->deleted = 1;
  438. }
  439.  
  440. /* Print out the commands in CMDS.  */
  441.  
  442. void
  443. print_commands (cmds)
  444.      register struct commands *cmds;
  445. {
  446.   register char *s;
  447.  
  448.   fputs ("#  commands to execute", stdout);
  449.  
  450.   if (cmds->filename == 0)
  451.     puts (" (built-in):");
  452.   else
  453.     printf (" (from `%s', line %u):\n", cmds->filename, cmds->lineno);
  454.  
  455.   s = cmds->commands;
  456.   while (*s != '\0')
  457.     {
  458.       char *end;
  459.  
  460.       while (isspace (*s))
  461.     ++s;
  462.  
  463.       end = index (s, '\n');
  464.       if (end == 0)
  465.     end = s + strlen (s);
  466.  
  467.       printf ("\t%.*s\n", (int) (end - s), s);
  468.  
  469.       s = end;
  470.     }
  471. }
  472.