home *** CD-ROM | disk | FTP | other *** search
/ OpenStep (Enterprise) / OpenStepENTCD.toast / OEDEV / GNUSRC.Z / job.c < prev    next >
C/C++ Source or Header  |  1996-04-16  |  44KB  |  1,657 lines
  1. /* Job execution and handling for GNU Make.
  2. Copyright (C) 1988, 89, 90, 91, 92, 93, 94, 1995 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 "commands.h"
  21. #include "job.h"
  22. #include "file.h"
  23. #include "variable.h"
  24. #include <assert.h>
  25.  
  26. /* Default shell to use.  */
  27. #ifdef WIN32
  28. #include <windows.h>
  29. #include <stdlib.h>
  30. #include <fcntl.h>
  31. /* assume that a shell of some sort exists,  */
  32. /* but make no assumptions about where it is */
  33. /* located.                                  */
  34. char default_shell[] = "sh";
  35. #else
  36. char default_shell[] = "/bin/sh";
  37. #endif
  38.  
  39. #if defined (__MSDOS__) || defined (WIN32)
  40. #include <process.h>
  41. static int dos_pid = 123;
  42. static int dos_status;
  43. static char *dos_bname;
  44. static char *dos_bename;
  45. static int dos_batch_file;
  46. #endif /* MSDOS.  */
  47.  
  48.  
  49. /* If NGROUPS_MAX == 0 then try other methods for finding a real value.  */
  50. #if defined (NGROUPS_MAX) && NGROUPS_MAX == 0
  51. #undef NGROUPS_MAX
  52. #endif /* NGROUPS_MAX == 0 */
  53.  
  54. #ifndef    NGROUPS_MAX
  55. #ifdef    POSIX
  56. #define    GET_NGROUPS_MAX    sysconf (_SC_NGROUPS_MAX)
  57. #else    /* Not POSIX.  */
  58. #define    NGROUPS_MAX    NGROUPS
  59. #endif    /* POSIX.  */
  60. #endif
  61.  
  62. #ifdef    HAVE_SYS_WAIT_H
  63. #include <sys/wait.h>
  64. #endif
  65.  
  66. #ifdef    HAVE_WAITPID
  67. #define    WAIT_NOHANG(status)    waitpid (-1, (status), WNOHANG)
  68. #else    /* Don't have waitpid.  */
  69. #ifdef    HAVE_WAIT3
  70. #ifndef    wait3
  71. extern int wait3 ();
  72. #endif
  73. #define    WAIT_NOHANG(status)    wait3 ((status), WNOHANG, (struct rusage *) 0)
  74. #endif    /* Have wait3.  */
  75. #endif    /* Have waitpid.  */
  76.  
  77. #if    !defined (wait) && !defined (POSIX)
  78. extern int wait ();
  79. #endif
  80.  
  81. #ifndef    HAVE_UNION_WAIT
  82.  
  83. #define    WAIT_T int
  84.  
  85. #ifndef    WTERMSIG
  86. #define WTERMSIG(x) ((x) & 0x7f)
  87. #endif
  88. #ifndef    WCOREDUMP
  89. #define WCOREDUMP(x) ((x) & 0x80)
  90. #endif
  91. #ifndef    WEXITSTATUS
  92. #define WEXITSTATUS(x) (((x) >> 8) & 0xff)
  93. #endif
  94. #ifndef    WIFSIGNALED
  95. #define WIFSIGNALED(x) (WTERMSIG (x) != 0)
  96. #endif
  97. #ifndef    WIFEXITED
  98. #define WIFEXITED(x) (WTERMSIG (x) == 0)
  99. #endif
  100.  
  101. #else    /* Have `union wait'.  */
  102.  
  103. #define WAIT_T union wait
  104. #ifndef    WTERMSIG
  105. #define WTERMSIG(x)    ((x).w_termsig)
  106. #endif
  107. #ifndef    WCOREDUMP
  108. #define WCOREDUMP(x)    ((x).w_coredump)
  109. #endif
  110. #ifndef WEXITSTATUS
  111. #define WEXITSTATUS(x)    ((x).w_retcode)
  112. #endif
  113. #ifndef    WIFSIGNALED
  114. #define    WIFSIGNALED(x)    (WTERMSIG(x) != 0)
  115. #endif
  116. #ifndef    WIFEXITED
  117. #define    WIFEXITED(x)    (WTERMSIG(x) == 0)
  118. #endif
  119.  
  120. #endif    /* Don't have `union wait'.  */
  121.  
  122.  
  123. #ifndef    HAVE_UNISTD_H
  124. extern int dup2 ();
  125. extern int execve ();
  126. extern void _exit ();
  127. extern int geteuid (), getegid ();
  128. #ifndef WIN32
  129. extern int setgid (), getgid ();
  130. #endif
  131. #endif
  132.  
  133. #ifndef    getdtablesize
  134. #ifdef HAVE_GETDTABLESIZE
  135. extern int getdtablesize ();
  136. #else
  137. #ifdef HAVE_SYSCONF_OPEN_MAX
  138. #define getdtablesize()        ((int) sysconf (_SC_OPEN_MAX))
  139. #else
  140. #include <sys/param.h>
  141. #define getdtablesize() NOFILE
  142. #if !defined (NOFILE) && defined (NOFILES_MAX)
  143. /* SCO 3.2 "devsys 4.2" defines NOFILES_{MIN,MAX} in lieu of NOFILE.  */
  144. #define NOFILE    NOFILES_MAX
  145. #endif
  146. #endif
  147. #endif
  148. #endif
  149.  
  150. extern int getloadavg ();
  151. extern int start_remote_job_p ();
  152. extern int start_remote_job (), remote_status ();
  153.  
  154. RETSIGTYPE child_handler ();
  155. static void free_child (), start_job_command ();
  156. static int load_too_high (), job_next_command ();
  157.  
  158. /* Chain of all live (or recently deceased) children.  */
  159.  
  160. struct child *children = 0;
  161.  
  162. /* Number of children currently running.  */
  163.  
  164. unsigned int job_slots_used = 0;
  165.  
  166. /* Nonzero if the `good' standard input is in use.  */
  167.  
  168. static int good_stdin_used = 0;
  169.  
  170. /* Chain of children waiting to run until the load average goes down.  */
  171.  
  172. static struct child *waiting_jobs = 0;
  173.  
  174. /* Write an error message describing the exit status given in
  175.    EXIT_CODE, EXIT_SIG, and COREDUMP, for the target TARGET_NAME.
  176.    Append "(ignored)" if IGNORED is nonzero.  */
  177.  
  178. static void
  179. child_error (target_name, exit_code, exit_sig, coredump, ignored)
  180.      char *target_name;
  181.      int exit_code, exit_sig, coredump;
  182.      int ignored;
  183. {
  184.   if (exit_sig == 0)
  185.     error (ignored ? "[%s] Error %d (ignored)" :
  186.        "*** [%s] Error %d",
  187.        target_name, exit_code);
  188.   else
  189.     error ("*** [%s] %s%s",
  190.        target_name, strsignal (exit_sig),
  191.        coredump ? " (core dumped)" : "");
  192. }
  193.  
  194. static unsigned int dead_children = 0;
  195.  
  196. /* Notice that a child died.
  197.    reap_children should be called when convenient.  */
  198. RETSIGTYPE
  199. child_handler (sig)
  200.      int sig;
  201. {
  202.   ++dead_children;
  203.  
  204.   if (debug_flag)
  205.     printf ("Got a SIGCHLD; %d unreaped children.\n", dead_children);
  206. }
  207.  
  208. extern int shell_function_pid, shell_function_completed;
  209.  
  210. /* Reap dead children, storing the returned status and the new command
  211.    state (`cs_finished') in the `file' member of the `struct child' for the
  212.    dead child, and removing the child from the chain.  If BLOCK nonzero,
  213.    reap at least one child, waiting for it to die if necessary.  If ERR is
  214.    nonzero, print an error message first.  */
  215.  
  216. void
  217. reap_children (block, err)
  218.      int block, err;
  219. {
  220.   WAIT_T status;
  221.  
  222.   while ((children != 0 || shell_function_pid != 0) &&
  223.      (block || dead_children > 0))
  224.     {
  225.       int remote = 0;
  226.       register int pid;
  227.       int exit_code, exit_sig, coredump;
  228.       register struct child *lastc, *c;
  229.       int child_failed;
  230.       int any_remote, any_local;
  231.  
  232.       if (err && dead_children == 0)
  233.     {
  234.       /* We might block for a while, so let the user know why.  */
  235.       fflush (stdout);
  236.       error ("*** Waiting for unfinished jobs....");
  237.     }
  238.  
  239.       /* We have one less dead child to reap.
  240.      The test and decrement are not atomic; if it is compiled into:
  241.          register = dead_children - 1;
  242.         dead_children = register;
  243.      a SIGCHLD could come between the two instructions.
  244.      child_handler increments dead_children.
  245.      The second instruction here would lose that increment.  But the
  246.      only effect of dead_children being wrong is that we might wait
  247.      longer than necessary to reap a child, and lose some parallelism;
  248.      and we might print the "Waiting for unfinished jobs" message above
  249.      when not necessary.  */
  250.  
  251.       if (dead_children != 0)
  252.     --dead_children;
  253.  
  254.       any_remote = 0;
  255.       any_local = shell_function_pid != -1;
  256.       for (c = children; c != 0; c = c->next)
  257.     {
  258.       any_remote |= c->remote;
  259.       any_local |= ! c->remote;
  260.       if (debug_flag)
  261.         printf ("Live child 0x%08lx PID %d%s\n",
  262.             (unsigned long int) c,
  263.             c->pid, c->remote ? " (remote)" : "");
  264.     }
  265.  
  266.       /* First, check for remote children.  */
  267.       if (any_remote)
  268.     pid = remote_status (&exit_code, &exit_sig, &coredump, 0);
  269.       else
  270.     pid = 0;
  271.       if (pid < 0)
  272.     {
  273.     remote_status_lose:
  274. #ifdef    EINTR
  275.       if (errno == EINTR)
  276.         continue;
  277. #endif
  278.       pfatal_with_name ("remote_status");
  279.     }
  280.       else if (pid == 0)
  281.     {
  282. #if ! (defined (__MSDOS__) || defined (WIN32))
  283.       /* No remote children.  Check for local children.  */
  284.  
  285.       if (any_local)
  286.         {
  287. #ifdef    WAIT_NOHANG
  288.           if (!block)
  289.         pid = WAIT_NOHANG (&status);
  290.           else
  291. #endif
  292.         pid = wait (&status);
  293.         }
  294.       else
  295.         pid = 0;
  296.  
  297.       if (pid < 0)
  298.         {
  299. #ifdef    EINTR
  300.           if (errno == EINTR)
  301.         continue;
  302. #endif
  303.           pfatal_with_name ("wait");
  304.         }
  305.       else if (pid == 0)
  306.         {
  307.           /* No local children.  */
  308.           if (block && any_remote)
  309.         {
  310.           /* Now try a blocking wait for a remote child.  */
  311.           pid = remote_status (&exit_code, &exit_sig, &coredump, 1);
  312.           if (pid < 0)
  313.             goto remote_status_lose;
  314.           else if (pid == 0)
  315.             /* No remote children either.  Finally give up.  */
  316.             break;
  317.           else
  318.             /* We got a remote child.  */
  319.             remote = 1;
  320.         }
  321.           else
  322.         break;
  323.         }
  324.       else
  325.         {
  326.           /* Chop the status word up.  */
  327.           exit_code = WEXITSTATUS (status);
  328.           exit_sig = WIFSIGNALED (status) ? WTERMSIG (status) : 0;
  329.           coredump = WCOREDUMP (status);
  330.         }
  331. #else    /* MSDOS.  */
  332.       /* Life is very different on MSDOS.  */
  333.       pid = dos_pid - 1;
  334.       status = dos_status;
  335.       exit_code = dos_status;
  336.       exit_sig = 0;
  337.       coredump = 0;
  338. #endif    /* Not MSDOS.  */
  339.     }
  340.       else
  341.     /* We got a remote child.  */
  342.     remote = 1;
  343.  
  344.       /* Check if this is the child of the `shell' function.  */
  345.       if (!remote && pid == shell_function_pid)
  346.     {
  347.       /* It is.  Leave an indicator for the `shell' function.  */
  348.       if (exit_sig == 0 && exit_code == 127)
  349.         shell_function_completed = -1;
  350.       else
  351.         shell_function_completed = 1;
  352.       break;
  353.     }
  354.  
  355.       child_failed = exit_sig != 0 || exit_code != 0;
  356.  
  357.       /* Search for a child matching the deceased one.  */
  358.       lastc = 0;
  359.       for (c = children; c != 0; lastc = c, c = c->next)
  360.     if (c->remote == remote && c->pid == pid)
  361.       break;
  362.  
  363.       if (c == 0)
  364.     {
  365.       /* An unknown child died.  */
  366.       char buf[100];
  367.       sprintf (buf, "Unknown%s job %d", remote ? " remote" : "", pid);
  368.       if (child_failed)
  369.         child_error (buf, exit_code, exit_sig, coredump,
  370.              ignore_errors_flag);
  371.       else
  372.         error ("%s finished.", buf);
  373.     }
  374.       else
  375.     {
  376.       if (debug_flag)
  377.         printf ("Reaping %s child 0x%08lx PID %d%s\n",
  378.             child_failed ? "losing" : "winning",
  379.             (unsigned long int) c,
  380.             c->pid, c->remote ? " (remote)" : "");
  381.  
  382.       /* If this child had the good stdin, say it is now free.  */
  383.       if (c->good_stdin)
  384.         good_stdin_used = 0;
  385.  
  386.       if (child_failed && !c->noerror && !ignore_errors_flag)
  387.         {
  388.           /* The commands failed.  Write an error message,
  389.          delete non-precious targets, and abort.  */
  390.           static int delete_on_error = -1;
  391.           child_error (c->file->name, exit_code, exit_sig, coredump, 0);
  392.           c->file->update_status = 2;
  393.           if (delete_on_error == -1)
  394.         {
  395.           struct file *f = lookup_file (".DELETE_ON_ERROR");
  396.           delete_on_error = f != 0 && f->is_target;
  397.         }
  398.           if (exit_sig != 0 || delete_on_error)
  399.         delete_child_targets (c);
  400.         }
  401.       else
  402.         {
  403.           if (child_failed)
  404.         {
  405.           /* The commands failed, but we don't care.  */
  406.           child_error (c->file->name,
  407.                    exit_code, exit_sig, coredump, 1);
  408.           child_failed = 0;
  409.         }
  410.  
  411.           /* If there are more commands to run, try to start them.  */
  412.           if (job_next_command (c))
  413.         {
  414.           if (handling_fatal_signal)
  415.             {
  416.               /* Never start new commands while we are dying.
  417.              Since there are more commands that wanted to be run,
  418.              the target was not completely remade.  So we treat
  419.              this as if a command had failed.  */
  420.               c->file->update_status = 2;
  421.             }
  422.           else
  423.             {
  424.               /* Check again whether to start remotely.
  425.              Whether or not we want to changes over time.
  426.              Also, start_remote_job may need state set up
  427.              by start_remote_job_p.  */
  428.               c->remote = start_remote_job_p ();
  429.               start_job_command (c);
  430.               if (c->file->command_state == cs_running)
  431.             /* We successfully started the new command.
  432.                Loop to reap more children.  */
  433.             continue;
  434.             }
  435.  
  436.           if (c->file->update_status != 0)
  437.             /* We failed to start the commands.  */
  438.             delete_child_targets (c);
  439.         }
  440.           else
  441.         /* There are no more commands.  We got through them all
  442.            without an unignored error.  Now the target has been
  443.            successfully updated.  */
  444.         c->file->update_status = 0;
  445.         }
  446.  
  447.       /* When we get here, all the commands for C->file are finished
  448.          (or aborted) and C->file->update_status contains 0 or 2.  But
  449.          C->file->command_state is still cs_running if all the commands
  450.          ran; notice_finish_file looks for cs_running to tell it that
  451.          it's interesting to check the file's modtime again now.  */
  452.  
  453.       if (! handling_fatal_signal)
  454.         /* Notice if the target of the commands has been changed.
  455.            This also propagates its values for command_state and
  456.            update_status to its also_make files.  */
  457.         notice_finished_file (c->file);
  458.  
  459.       if (debug_flag)
  460.         printf ("Removing child 0x%08lx PID %d%s from chain.\n",
  461.             (unsigned long int) c,
  462.             c->pid, c->remote ? " (remote)" : "");
  463.  
  464.       /* Remove the child from the chain and free it.  */
  465.       if (lastc == 0)
  466.         children = c->next;
  467.       else
  468.         lastc->next = c->next;
  469.       if (! handling_fatal_signal) /* Avoid nonreentrancy.  */
  470.         free_child (c);
  471.  
  472.       /* There is now another slot open.  */
  473.       --job_slots_used;
  474.  
  475.       /* If the job failed, and the -k flag was not given, die,
  476.          unless we are already in the process of dying.  */
  477.       if (!err && child_failed && !keep_going_flag)
  478.         die (2);
  479.     }
  480.  
  481.       /* Only block for one child.  */
  482.       block = 0;
  483.     }
  484. }
  485.  
  486. /* Free the storage allocated for CHILD.  */
  487.  
  488. static void
  489. free_child (child)
  490.      register struct child *child;
  491. {
  492.   if (child->command_lines != 0)
  493.     {
  494.       register unsigned int i;
  495.       for (i = 0; i < child->file->cmds->ncommand_lines; ++i)
  496.     free (child->command_lines[i]);
  497.       free ((char *) child->command_lines);
  498.     }
  499.  
  500.   if (child->environment != 0)
  501.     {
  502.       register char **ep = child->environment;
  503.       while (*ep != 0)
  504.     free (*ep++);
  505.       free ((char *) child->environment);
  506.     }
  507.  
  508.   free ((char *) child);
  509. }
  510.  
  511. #ifdef    POSIX
  512. #if defined (__MSDOS__) || defined (WIN32)
  513. void
  514. unblock_sigs ()
  515. {
  516.   return;
  517. }
  518. #else
  519. extern sigset_t fatal_signal_set;
  520.  
  521. void
  522. unblock_sigs ()
  523. {
  524.   sigset_t empty;
  525.   sigemptyset (&empty);
  526.   sigprocmask (SIG_SETMASK, &empty, (sigset_t *) 0);
  527. }
  528. #endif
  529. #endif
  530.  
  531. /* Start a job to run the commands specified in CHILD.
  532.    CHILD is updated to reflect the commands and ID of the child process.  */
  533.  
  534. static void
  535. start_job_command (child)
  536.      register struct child *child;
  537. {
  538.   static int bad_stdin = -1;
  539.   register char *p;
  540.   int flags;
  541.   char **argv;
  542.  
  543.   /* Combine the flags parsed for the line itself with
  544.      the flags specified globally for this target.  */
  545.   flags = (child->file->command_flags
  546.        | child->file->cmds->lines_flags[child->command_line - 1]);
  547.  
  548.   p = child->command_ptr;
  549.   child->noerror = flags & COMMANDS_NOERROR;
  550.   while (*p != '\0')
  551.     {
  552.       if (*p == '@')
  553.     flags |= COMMANDS_SILENT;
  554.       else if (*p == '+')
  555.     flags |= COMMANDS_RECURSE;
  556.       else if (*p == '-')
  557.     child->noerror = 1;
  558.       else if (!isblank (*p) && *p != '+')
  559.     break;
  560.       ++p;
  561.     }
  562.  
  563.   /* If -q was given, just say that updating `failed'.  The exit status of
  564.      1 tells the user that -q is saying `something to do'; the exit status
  565.      for a random error is 2.  */
  566.   if (question_flag && !(flags & COMMANDS_RECURSE))
  567.     {  
  568.       child->file->update_status = 1;
  569.       notice_finished_file (child->file);
  570.       return;
  571.     }
  572.  
  573.   /* There may be some preceding whitespace left if there
  574.      was nothing but a backslash on the first line.  */
  575.   p = next_token (p);
  576.   
  577.   /* Figure out an argument list from this command line.  */
  578.   
  579.   {
  580.     char *end;
  581.     argv = construct_command_argv (p, &end, child->file);
  582.     if (end == NULL)
  583.       child->command_ptr = NULL;
  584.     else
  585.       {
  586.     *end++ = '\0';
  587.     child->command_ptr = end;
  588.       }
  589.   }
  590.  
  591.   if (touch_flag && !(flags & COMMANDS_RECURSE))
  592.     {
  593.       /* Go on to the next command.  It might be the recursive one.
  594.      We construct ARGV only to find the end of the command line.  */
  595.       free (argv[0]);
  596.       free ((char *) argv);
  597.       argv = 0;
  598.     }
  599.  
  600.   if (argv == 0)
  601.     {
  602.     next_command:
  603.       /* This line has no commands.  Go to the next.  */
  604.       if (job_next_command (child))
  605.     start_job_command (child);
  606.       else
  607.     {
  608.       /* No more commands.  All done.  */
  609.       child->file->update_status = 0;
  610.       notice_finished_file (child->file);
  611.     }
  612.       return;
  613.     }
  614.  
  615.   /* Print out the command.  */
  616.  
  617.   if (just_print_flag || (!(flags & COMMANDS_SILENT) && !silent_flag))
  618.     puts (p);
  619.  
  620.   /* Tell update_goal_chain that a command has been started on behalf of
  621.      this target.  It is important that this happens here and not in
  622.      reap_children (where we used to do it), because reap_children might be
  623.      reaping children from a different target.  We want this increment to
  624.      guaranteedly indicate that a command was started for the dependency
  625.      chain (i.e., update_file recursion chain) we are processing.  */
  626.  
  627.   ++commands_started;
  628.  
  629.   /* If -n was given, recurse to get the next line in the sequence.  */
  630.  
  631.   if (just_print_flag && !(flags & COMMANDS_RECURSE))
  632.     {
  633.       free (argv[0]);
  634.       free ((char *) argv);
  635.       goto next_command;
  636.     }
  637.  
  638.   /* Flush the output streams so they won't have things written twice.  */
  639.  
  640.   fflush (stdout);
  641.   fflush (stderr);
  642.   
  643.   /* Set up a bad standard input that reads from a broken pipe.  */
  644.  
  645.   if (bad_stdin == -1)
  646.     {
  647.       /* Make a file descriptor that is the read end of a broken pipe.
  648.      This will be used for some children's standard inputs.  */
  649.       int pd[2];
  650. #ifdef WIN32
  651.       if (pipe (pd, 8192, _O_BINARY) == 0)
  652. #else
  653.       if (pipe (pd) == 0)
  654. #endif
  655.     {
  656.       /* Close the write side.  */
  657.       (void) close (pd[1]);
  658.       /* Save the read side.  */
  659.       bad_stdin = pd[0];
  660.     }
  661.     }
  662.  
  663.   /* Decide whether to give this child the `good' standard input
  664.      (one that points to the terminal or whatever), or the `bad' one
  665.      that points to the read side of a broken pipe.  */
  666.  
  667.   child->good_stdin = !good_stdin_used;
  668.   if (child->good_stdin)
  669.     good_stdin_used = 1;
  670.  
  671.   child->deleted = 0;
  672.  
  673.   /* Set up the environment for the child.  */
  674.   if (child->environment == 0)
  675.     child->environment = target_environment (child->file);
  676.  
  677. // Why is this ifdefed?  MM
  678. #if ! (defined (__MSDOS__) || defined (WIN32))
  679.  
  680.   /* start_waiting_job has set CHILD->remote if we can start a remote job.  */
  681.   if (child->remote)
  682.     {
  683.       int is_remote, id, used_stdin;
  684.       if (start_remote_job (argv, child->environment,
  685.                 child->good_stdin ? 0 : bad_stdin,
  686.                 &is_remote, &id, &used_stdin))
  687.     goto error;
  688.       else
  689.     {
  690.       if (child->good_stdin && !used_stdin)
  691.         {
  692.           child->good_stdin = 0;
  693.           good_stdin_used = 0;
  694.         }
  695.       child->remote = is_remote;
  696.       child->pid = id;
  697.     }
  698.     }
  699.   else
  700.     {
  701.       /* Fork the child process.  */
  702.  
  703.       char **parent_environ;
  704.  
  705. #ifdef     POSIX
  706.       (void) sigprocmask (SIG_BLOCK, &fatal_signal_set, (sigset_t *) 0);
  707. #else
  708. #ifdef    HAVE_SIGSETMASK
  709.       (void) sigblock (fatal_signal_mask);
  710. #endif
  711. #endif
  712.  
  713.       child->remote = 0;
  714.       parent_environ = environ;
  715.       child->pid = vfork ();
  716.       environ = parent_environ;    /* Restore value child may have clobbered.  */
  717.       if (child->pid == 0)
  718.     {
  719.       /* We are the child side.  */
  720.       unblock_sigs ();
  721.       child_execute_job (child->good_stdin ? 0 : bad_stdin, 1,
  722.                  argv, child->environment);
  723.     }
  724.       else if (child->pid < 0)
  725.     {
  726.       /* Fork failed!  */
  727.       unblock_sigs ();
  728.       perror_with_name ("vfork", "");
  729.       goto error;
  730.     }
  731.     }
  732.  
  733. #else    /* MSDOS.  */
  734.  
  735.   dos_status = spawnvpe (P_WAIT, argv[0], argv, child->environment);
  736.   if (dos_status < 0 && _doserrno == ERROR_MORE_DATA) {
  737.       char** new_environment;
  738.     if (getenv("MAKEDEBUG"))
  739.         fprintf (stderr, "make:  warning:  spawn failed, invoking workaround\n");
  740.     new_environment = create_padded_environment (child->environment);
  741.       dos_status = spawnvpe (P_WAIT, argv[0], argv, new_environment);
  742.     release_padded_environment (new_environment);
  743.   }
  744.  
  745.   ++dead_children;
  746.   child->pid = dos_pid++;
  747.   if (dos_batch_file)
  748.    {
  749.      dos_batch_file = 0;
  750.      remove (dos_bname);    /* Ignore errors.  */
  751.      if (access (dos_bename, 0))
  752.        dos_status = 1;
  753.      else
  754.        dos_status = 0;
  755.      remove (dos_bename);
  756.    }
  757. #endif    /* Not MSDOS.  */
  758.  
  759.   /* We are the parent side.  Set the state to
  760.      say the commands are running and return.  */
  761.  
  762.   set_command_state (child->file, cs_running);
  763.  
  764.   /* Free the storage used by the child's argument list.  */
  765.  
  766.   free (argv[0]);
  767.   free ((char *) argv);
  768.  
  769.   return;
  770.  
  771.  error:
  772.   child->file->update_status = 2;
  773.   notice_finished_file (child->file);
  774. }
  775.  
  776. /* Try to start a child running.
  777.    Returns nonzero if the child was started (and maybe finished), or zero if
  778.    the load was too high and the child was put on the `waiting_jobs' chain.  */
  779.  
  780. static int
  781. start_waiting_job (c)
  782.      struct child *c;
  783. {
  784.   /* If we can start a job remotely, we always want to, and don't care about
  785.      the local load average.  We record that the job should be started
  786.      remotely in C->remote for start_job_command to test.  */
  787.  
  788.   c->remote = start_remote_job_p ();
  789.  
  790.   /* If this job is to be started locally, and we are already running
  791.      some jobs, make this one wait if the load average is too high.  */
  792.   if (!c->remote && job_slots_used > 0 && load_too_high ())
  793.     {
  794.       /* Put this child on the chain of children waiting
  795.      for the load average to go down.  */
  796.       set_command_state (c->file, cs_running);
  797.       c->next = waiting_jobs;
  798.       waiting_jobs = c;
  799.       return 0;
  800.     }
  801.  
  802.   /* Start the first command; reap_children will run later command lines.  */
  803.   start_job_command (c);
  804.  
  805.   switch (c->file->command_state)
  806.     {
  807.     case cs_running:
  808.       c->next = children;
  809.       if (debug_flag)
  810.     printf ("Putting child 0x%08lx PID %05d%s on the chain.\n",
  811.         (unsigned long int) c,
  812.         c->pid, c->remote ? " (remote)" : "");
  813.       children = c;
  814.       /* One more job slot is in use.  */
  815.       ++job_slots_used;
  816.       unblock_sigs ();
  817.       break;
  818.  
  819.     case cs_not_started:
  820.       /* All the command lines turned out to be empty.  */
  821.       c->file->update_status = 0;
  822.       /* FALLTHROUGH */
  823.  
  824.     case cs_finished:
  825.       notice_finished_file (c->file);
  826.       free_child (c);
  827.       break;
  828.  
  829.     default:
  830.       assert (c->file->command_state == cs_finished);
  831.       break;
  832.     }
  833.  
  834.   return 1;
  835. }
  836.  
  837. /* Create a `struct child' for FILE and start its commands running.  */
  838.  
  839. void
  840. new_job (file)
  841.      register struct file *file;
  842. {
  843.   register struct commands *cmds = file->cmds;
  844.   register struct child *c;
  845.   char **lines;
  846.   register unsigned int i;
  847.  
  848.   /* Let any previously decided-upon jobs that are waiting
  849.      for the load to go down start before this new one.  */
  850.   start_waiting_jobs ();
  851.  
  852.   /* Reap any children that might have finished recently.  */
  853.   reap_children (0, 0);
  854.  
  855.   /* Chop the commands up into lines if they aren't already.  */
  856.   chop_commands (cmds);
  857.  
  858.   if (job_slots != 0)
  859.     /* Wait for a job slot to be freed up.  */
  860.     while (job_slots_used == job_slots)
  861.       reap_children (1, 0);
  862.  
  863.   /* Expand the command lines and store the results in LINES.  */
  864.   lines = (char **) xmalloc (cmds->ncommand_lines * sizeof (char *));
  865.   for (i = 0; i < cmds->ncommand_lines; ++i)
  866.     {
  867.       /* Collapse backslash-newline combinations that are inside variable
  868.      or function references.  These are left alone by the parser so
  869.      that they will appear in the echoing of commands (where they look
  870.      nice); and collapsed by construct_command_argv when it tokenizes.
  871.      But letting them survive inside function invocations loses because
  872.      we don't want the functions to see them as part of the text.  */
  873.  
  874.       char *in, *out, *ref;
  875.  
  876.       /* IN points to where in the line we are scanning.
  877.      OUT points to where in the line we are writing.
  878.      When we collapse a backslash-newline combination,
  879.      IN gets ahead out OUT.  */
  880.  
  881.       in = out = cmds->command_lines[i];
  882.       while ((ref = index (in, '$')) != 0)
  883.     {
  884.       ++ref;        /* Move past the $.  */
  885.  
  886.       if (out != in)
  887.         /* Copy the text between the end of the last chunk
  888.            we processed (where IN points) and the new chunk
  889.            we are about to process (where REF points).  */
  890.         bcopy (in, out, ref - in);
  891.  
  892.       /* Move both pointers past the boring stuff.  */
  893.       out += ref - in;
  894.       in = ref;
  895.  
  896.       if (*ref == '(' || *ref == '{')
  897.         {
  898.           char openparen = *ref;
  899.           char closeparen = openparen == '(' ? ')' : '}';
  900.           int count;
  901.           char *p;
  902.  
  903.           *out++ = *in++;    /* Copy OPENPAREN.  */
  904.           /* IN now points past the opening paren or brace.
  905.          Count parens or braces until it is matched.  */
  906.           count = 0;
  907.           while (*in != '\0')
  908.         {
  909.           if (*in == closeparen && --count < 0)
  910.             break;
  911.           else if (*in == '\\' && in[1] == '\n')
  912.             {
  913.               /* We have found a backslash-newline inside a
  914.              variable or function reference.  Eat it and
  915.              any following whitespace.  */
  916.  
  917.               int quoted = 0;
  918.               for (p = in - 1; p > ref && *p == '\\'; --p)
  919.             quoted = !quoted;
  920.  
  921.               if (quoted)
  922.             /* There were two or more backslashes, so this is
  923.                not really a continuation line.  We don't collapse
  924.                the quoting backslashes here as is done in
  925.                collapse_continuations, because the line will
  926.                be collapsed again after expansion.  */
  927.             *out++ = *in++;
  928.               else
  929.             {
  930.               /* Skip the backslash, newline and
  931.                  any following whitespace.  */
  932.               in = next_token (in + 2);
  933.  
  934.               /* Discard any preceding whitespace that has
  935.                  already been written to the output.  */
  936.               while (out > ref && isblank (out[-1]))
  937.                 --out;
  938.  
  939.               /* Replace it all with a single space.  */
  940.               *out++ = ' ';
  941.             }
  942.             }
  943.           else
  944.             {
  945.               if (*in == openparen)
  946.             ++count;
  947.  
  948.               *out++ = *in++;
  949.             }
  950.         }
  951.         }
  952.     }
  953.  
  954.       /* There are no more references in this line to worry about.
  955.      Copy the remaining uninteresting text to the output.  */
  956.       if (out != in)
  957.     strcpy (out, in);
  958.  
  959.       /* Finally, expand the line.  */
  960.       lines[i] = allocated_variable_expand_for_file (cmds->command_lines[i],
  961.                              file);
  962.     }
  963.  
  964. #if NeXT || NeXT_PDO
  965.   if (next_flag & NEXT_VPATH_FLAG) {
  966.       for (i = 0; i < cmds->ncommand_lines; ++i) {
  967.       char *line;
  968.       if (lines[i] != 0) {
  969.           line = allocated_vpath_expand_for_file (lines[i], file);
  970.           free (lines[i]);
  971.           lines[i] = line;
  972.       }
  973.       }
  974.   }
  975. #endif    /* NeXT || NeXT_PDO */
  976.  
  977.   /* Start the command sequence, record it in a new
  978.      `struct child', and add that to the chain.  */
  979.  
  980.   c = (struct child *) xmalloc (sizeof (struct child));
  981.   c->file = file;
  982.   c->command_lines = lines;
  983.   c->command_line = 0;
  984.   c->command_ptr = 0;
  985.   c->environment = 0;
  986.  
  987.   /* Fetch the first command line to be run.  */
  988.   job_next_command (c);
  989.  
  990.   /* The job is now primed.  Start it running.
  991.      (This will notice if there are in fact no commands.)  */
  992.   start_waiting_job (c);
  993.  
  994.   if (job_slots == 1)
  995.     /* Since there is only one job slot, make things run linearly.
  996.        Wait for the child to die, setting the state to `cs_finished'.  */
  997.     while (file->command_state == cs_running)
  998.       reap_children (1, 0);
  999. }
  1000.  
  1001. /* Move CHILD's pointers to the next command for it to execute.
  1002.    Returns nonzero if there is another command.  */
  1003.  
  1004. static int
  1005. job_next_command (child)
  1006.      struct child *child;
  1007. {
  1008.   while (child->command_ptr == 0 || *child->command_ptr == '\0')
  1009.     {
  1010.       /* There are no more lines in the expansion of this line.  */
  1011.       if (child->command_line == child->file->cmds->ncommand_lines)
  1012.     {
  1013.       /* There are no more lines to be expanded.  */
  1014.       child->command_ptr = 0;
  1015.       return 0;
  1016.     }
  1017.       else
  1018.     /* Get the next line to run.  */
  1019.     child->command_ptr = child->command_lines[child->command_line++];
  1020.     }
  1021.   return 1;
  1022. }
  1023.  
  1024. static int
  1025. load_too_high ()
  1026. {
  1027. #if defined (__MSDOS__) || defined (WIN32)
  1028.   return 1;
  1029. #else
  1030.   extern int getloadavg ();
  1031.   double load;
  1032.  
  1033.   if (max_load_average < 0)
  1034.     return 0;
  1035.  
  1036.   make_access ();
  1037.   if (getloadavg (&load, 1) != 1)
  1038.     {
  1039.       static int lossage = -1;
  1040.       /* Complain only once for the same error.  */
  1041.       if (lossage == -1 || errno != lossage)
  1042.     {
  1043.       if (errno == 0)
  1044.         /* An errno value of zero means getloadavg is just unsupported.  */
  1045.         error ("cannot enforce load limits on this operating system");
  1046.       else
  1047.         perror_with_name ("cannot enforce load limit: ", "getloadavg");
  1048.     }
  1049.       lossage = errno;
  1050.       load = 0;
  1051.     }
  1052.   user_access ();
  1053.  
  1054.   return load >= max_load_average;
  1055. #endif
  1056. }
  1057.  
  1058. /* Start jobs that are waiting for the load to be lower.  */
  1059.  
  1060. void
  1061. start_waiting_jobs ()
  1062. {
  1063.   struct child *job;
  1064.  
  1065.   if (waiting_jobs == 0)
  1066.     return;
  1067.  
  1068.   do
  1069.     {
  1070.       /* Check for recently deceased descendants.  */
  1071.       reap_children (0, 0);
  1072.  
  1073.       /* Take a job off the waiting list.  */
  1074.       job = waiting_jobs;
  1075.       waiting_jobs = job->next;
  1076.  
  1077.       /* Try to start that job.  We break out of the loop as soon
  1078.      as start_waiting_job puts one back on the waiting list.  */
  1079.     } while (start_waiting_job (job) && waiting_jobs != 0);
  1080. }
  1081.  
  1082. /* Replace the current process with one executing the command in ARGV.
  1083.    STDIN_FD and STDOUT_FD are used as the process's stdin and stdout; ENVP is
  1084.    the environment of the new program.  This function does not return.  */
  1085.  
  1086. void
  1087. child_execute_job (stdin_fd, stdout_fd, argv, envp)
  1088.      int stdin_fd, stdout_fd;
  1089.      char **argv, **envp;
  1090. {
  1091.   if (stdin_fd != 0)
  1092.     (void) dup2 (stdin_fd, 0);
  1093.   if (stdout_fd != 1)
  1094.     (void) dup2 (stdout_fd, 1);
  1095.  
  1096.   /* Free up file descriptors.  */
  1097.   {
  1098.     register int d;
  1099.     int max = getdtablesize ();
  1100.     for (d = 3; d < max; ++d)
  1101.       (void) close (d);
  1102.   }
  1103.  
  1104.   /* Run the command.  */
  1105.   exec_command (argv, envp);
  1106. }
  1107.  
  1108. /* Replace the current process with one running the command in ARGV,
  1109.    with environment ENVP.  This function does not return.  */
  1110.  
  1111. void
  1112. exec_command (argv, envp)
  1113.      char **argv, **envp;
  1114. {
  1115.   /* Be the user, permanently.  */
  1116.   child_access ();
  1117.  
  1118.   /* Run the program.  */
  1119.   environ = envp;
  1120.   execvp (argv[0], argv);
  1121.   
  1122.   switch (errno)
  1123.     {
  1124.     case ENOENT:
  1125.       error ("%s: Command not found", argv[0]);
  1126.       break;
  1127.     case ENOEXEC:
  1128.       {
  1129.     /* The file is not executable.  Try it as a shell script.  */
  1130.     extern char *getenv ();
  1131.     char *shell;
  1132.     char **new_argv;
  1133.     int argc;
  1134.  
  1135.     shell = getenv ("SHELL");
  1136.     if (shell == 0)
  1137.       shell = default_shell;
  1138.  
  1139.     argc = 1;
  1140.     while (argv[argc] != 0)
  1141.       ++argc;
  1142.  
  1143.     new_argv = (char **) alloca ((1 + argc + 1) * sizeof (char *));
  1144.     new_argv[0] = shell;
  1145.     new_argv[1] = program;
  1146.     while (argc > 0)
  1147.       {
  1148.         new_argv[1 + argc] = argv[argc];
  1149.         --argc;
  1150.       }
  1151.  
  1152.     execvp (shell, new_argv);
  1153.     if (errno == ENOENT)
  1154.       error ("%s: Shell program not found", shell);
  1155.     else
  1156.       perror_with_name ("execvp: ", shell);
  1157.     break;
  1158.       }
  1159.  
  1160.     default:
  1161.       perror_with_name ("execvp: ", argv[0]);
  1162.       break;
  1163.     }
  1164.  
  1165.   _exit (127);
  1166. }
  1167.  
  1168. /* Figure out the argument list necessary to run LINE as a command.  Try to
  1169.    avoid using a shell.  This routine handles only ' quoting, and " quoting
  1170.    when no backslash, $ or ` characters are seen in the quotes.  Starting
  1171.    quotes may be escaped with a backslash.  If any of the characters in
  1172.    sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[]
  1173.    is the first word of a line, the shell is used.
  1174.  
  1175.    If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
  1176.    If *RESTP is NULL, newlines will be ignored.
  1177.  
  1178.    SHELL is the shell to use, or nil to use the default shell.
  1179.    IFS is the value of $IFS, or nil (meaning the default).  */
  1180.  
  1181. static char **
  1182. construct_command_argv_internal (line, restp, shell, ifs)
  1183.      char *line, **restp;
  1184.      char *shell, *ifs;
  1185. {
  1186. #ifdef __MSDOS__ /* but not NT */
  1187.   static char sh_chars[] = "\"|<>";
  1188.   static char *sh_cmds[] = { "break", "call", "cd", "chcp", "chdir", "cls",
  1189.                  "copy", "ctty", "date", "del", "dir", "echo",
  1190.                  "erase", "exit", "for", "goto", "if", "if", "md",
  1191.                  "mkdir", "path", "pause", "prompt", "rem", "ren",
  1192.                  "rename", "set", "shift", "time", "type",
  1193.                  "ver", "verify", "vol", ":", 0 };
  1194. #else
  1195.   static char sh_chars[] = "#;\"*?[]&|<>(){}$`^";
  1196.   static char *sh_cmds[] = { "cd", "eval", "exec", "exit", "login",
  1197.                  "logout", "set", "umask", "wait", "while", "for",
  1198.                  "case", "if", ":", ".", "break", "continue",
  1199.                  "export", "read", "readonly", "shift", "times",
  1200.                  "trap", "switch", 0 };
  1201. #endif
  1202.   register int i;
  1203.   register char *p;
  1204.   register char *ap;
  1205.   char *end;
  1206.   int instring, word_has_equals, seen_nonequals;
  1207.   char **new_argv = 0;
  1208.  
  1209.   if (restp != NULL)
  1210.     *restp = NULL;
  1211.  
  1212.   /* Make sure not to bother processing an empty line.  */
  1213.   while (isblank (*line))
  1214.     ++line;
  1215.   if (*line == '\0')
  1216.     return 0;
  1217.  
  1218.   /* See if it is safe to parse commands internally.  */
  1219.   if (shell == 0)
  1220.     shell = default_shell;
  1221.   else if (strcmp (shell, default_shell))
  1222.     goto slow;
  1223.  
  1224.   if (ifs != 0)
  1225.     for (ap = ifs; *ap != '\0'; ++ap)
  1226.       if (*ap != ' ' && *ap != '\t' && *ap != '\n')
  1227.     goto slow;
  1228.  
  1229.   i = strlen (line) + 1;
  1230.  
  1231.   /* More than 1 arg per character is impossible.  */
  1232.   new_argv = (char **) xmalloc (i * sizeof (char *));
  1233.  
  1234. #ifndef WIN32
  1235.   /* All the args can fit in a buffer as big as LINE is.   */
  1236.   ap = new_argv[0] = (char *) xmalloc (i);
  1237. #else
  1238.   /* All the args can fit in a buffer as big as 2*LINE is.
  1239.   (We must double the buffer because construct_command_argv()
  1240.   may have to escape our quotes and backslashes. */
  1241.   ap = new_argv[0] = (char *) xmalloc (i*2);
  1242. #endif
  1243.   end = ap + i;
  1244.  
  1245.   /* I is how many complete arguments have been found.  */
  1246.   i = 0;
  1247.   instring = word_has_equals = seen_nonequals = 0;
  1248.   for (p = line; *p != '\0'; ++p)
  1249.     {
  1250.       if (ap > end)
  1251.     abort ();
  1252.  
  1253.       if (instring)
  1254.     {
  1255.     string_char:
  1256.       /* Inside a string, just copy any char except a closing quote
  1257.          or a backslash-newline combination.  */
  1258.       if (*p == instring)
  1259.         instring = 0;
  1260.       else if (*p == '\\' && p[1] == '\n')
  1261.         goto swallow_escaped_newline;
  1262.       else if (*p == '\n' && restp != NULL)
  1263.         {
  1264.           /* End of the command line.  */
  1265.           *restp = p;
  1266.           goto end_of_line;
  1267.         }
  1268.       /* Backslash, $, and ` are special inside double quotes.
  1269.          If we see any of those, punt.  */
  1270.       else if (instring == '"' && index ("\\$`", *p) != 0)
  1271.         goto slow;
  1272.       else
  1273.         *ap++ = *p;
  1274.     }
  1275.       else if (index (sh_chars, *p) != 0)
  1276.     /* Not inside a string, but it's a special char.  */
  1277.     goto slow;
  1278.       else
  1279.     /* Not a special char.  */
  1280.     switch (*p)
  1281.       {
  1282.       case '=':
  1283.         /* Equals is a special character in leading words before the
  1284.            first word with no equals sign in it.  This is not the case
  1285.            with sh -k, but we never get here when using nonstandard
  1286.            shell flags.  */
  1287.         if (! seen_nonequals)
  1288.           goto slow;
  1289.         word_has_equals = 1;
  1290.         *ap++ = '=';
  1291.         break;
  1292.  
  1293.       case '\\':
  1294.         /* Backslash-newline combinations are eaten.  */
  1295.         if (p[1] == '\n')
  1296.           {
  1297.           swallow_escaped_newline:
  1298.  
  1299.         /* Eat the backslash, the newline, and following whitespace,
  1300.            replacing it all with a single space.  */
  1301.         p += 2;
  1302.  
  1303.         /* If there is a tab after a backslash-newline,
  1304.            remove it from the source line which will be echoed,
  1305.            since it was most likely used to line
  1306.            up the continued line with the previous one.  */
  1307.         if (*p == '\t')
  1308.           strcpy (p, p + 1);
  1309.  
  1310.         if (instring)
  1311.           goto string_char;
  1312.         else
  1313.           {
  1314.             if (ap != new_argv[i])
  1315.               /* Treat this as a space, ending the arg.
  1316.              But if it's at the beginning of the arg, it should
  1317.              just get eaten, rather than becoming an empty arg. */
  1318.               goto end_of_arg;
  1319.             else
  1320.               p = next_token (p) - 1;
  1321.           }
  1322.           }
  1323.         else if (p[1] != '\0')
  1324.           /* Copy and skip the following char.  */
  1325.           *ap++ = *++p;
  1326.         break;
  1327.  
  1328.       case '\'':
  1329.       case '"':
  1330.         instring = *p;
  1331.         break;
  1332.  
  1333.       case '\n':
  1334.         if (restp != NULL)
  1335.           {
  1336.         /* End of the command line.  */
  1337.         *restp = p;
  1338.         goto end_of_line;
  1339.           }
  1340.         else
  1341.           /* Newlines are not special.  */
  1342.           *ap++ = '\n';
  1343.         break;
  1344.  
  1345.       case ' ':
  1346.       case '\t':
  1347.       end_of_arg:
  1348.         /* We have the end of an argument.
  1349.            Terminate the text of the argument.  */
  1350.         *ap++ = '\0';
  1351.         new_argv[++i] = ap;
  1352.  
  1353.         /* Update SEEN_NONEQUALS, which tells us if every word
  1354.            heretofore has contained an `='.  */
  1355.         seen_nonequals |= ! word_has_equals;
  1356.         if (word_has_equals && ! seen_nonequals)
  1357.           /* An `=' in a word before the first
  1358.          word without one is magical.  */
  1359.           goto slow;
  1360.         word_has_equals = 0; /* Prepare for the next word.  */
  1361.  
  1362.         /* If this argument is the command name,
  1363.            see if it is a built-in shell command.
  1364.            If so, have the shell handle it.  */
  1365.         if (i == 1)
  1366.           {
  1367.         register int j;
  1368.         for (j = 0; sh_cmds[j] != 0; ++j)
  1369.           if (streq (sh_cmds[j], new_argv[0]))
  1370.             goto slow;
  1371.           }
  1372.  
  1373.         /* Ignore multiple whitespace chars.  */
  1374.         p = next_token (p);
  1375.         /* Next iteration should examine the first nonwhite char.  */
  1376.         --p;
  1377.         break;
  1378.  
  1379.       default:
  1380.         *ap++ = *p;
  1381.         break;
  1382.       }
  1383.     }
  1384.  end_of_line:
  1385.  
  1386.   if (instring)
  1387.     /* Let the shell deal with an unterminated quote.  */
  1388.     goto slow;
  1389.  
  1390.   /* Terminate the last argument and the argument list.  */
  1391.  
  1392.   *ap = '\0';
  1393.   if (new_argv[i][0] != '\0')
  1394.     ++i;
  1395.   new_argv[i] = 0;
  1396.  
  1397.   if (i == 1)
  1398.     {
  1399.       register int j;
  1400.       for (j = 0; sh_cmds[j] != 0; ++j)
  1401.     if (streq (sh_cmds[j], new_argv[0]))
  1402.       goto slow;
  1403.     }
  1404.  
  1405.   if (new_argv[0] == 0)
  1406.     /* Line was empty.  */
  1407.     return 0;
  1408.   else
  1409.     return new_argv;
  1410.  
  1411.  slow:;
  1412.   /* We must use the shell.  */
  1413.  
  1414.   if (new_argv != 0)
  1415.     {
  1416.       /* Free the old argument list we were working on.  */
  1417.       free (new_argv[0]);
  1418.       free (new_argv);
  1419.     }
  1420.  
  1421. #ifdef __MSDOS__ /* but not NT */
  1422.    {
  1423.      FILE *batch;
  1424.      dos_batch_file = 1;
  1425.      if (dos_bname == 0)
  1426.        {
  1427.      dos_bname = tempnam (".", "mk");
  1428.      for (i = 0; dos_bname[i] != '\0'; ++i)
  1429.        if (dos_bname[i] == '/')
  1430.          dos_bname[i] = '\\';
  1431.      dos_bename = (char *) xmalloc (strlen (dos_bname) + 5);
  1432.      strcpy (dos_bename, dos_bname);
  1433.      strcat (dos_bname, ".bat");
  1434.      strcat (dos_bename, ".err");
  1435.        }
  1436.      batch = fopen (dos_bename, "w"); /* Create a file.  */
  1437.      if (batch != NULL)
  1438.        fclose (batch);
  1439.      batch = fopen (dos_bname, "w");
  1440.      fputs ("@echo off\n", batch);
  1441.      fputs (line, batch);
  1442.      fprintf (batch, "\nif errorlevel 1 del %s\n", dos_bename);
  1443.      fclose (batch);
  1444.      new_argv = (char **) xmalloc(2 * sizeof(char *));
  1445.      new_argv[0] = strdup (dos_bname);
  1446.      new_argv[1] = 0;
  1447.    }
  1448. #else
  1449.   {
  1450.     /* SHELL may be a multi-word command.  Construct a command line
  1451.        "SHELL -ce LINE", with all special chars in LINE escaped.
  1452.        Then recurse, expanding this command line to get the final
  1453.        argument list.  */
  1454.     
  1455.     unsigned int shell_len = strlen (shell);
  1456.     static char minus_c[] = " -ce ";
  1457.     unsigned int line_len = strlen (line);
  1458.     
  1459.     char *new_line = (char *) alloca (shell_len + (sizeof (minus_c) - 1)
  1460.                       + (line_len * 2) + 1);
  1461.     
  1462.     ap = new_line;
  1463.     bcopy (shell, ap, shell_len);
  1464.     ap += shell_len;
  1465. #ifdef WIN32
  1466.     if (stricmp (shell, "cmd.exe") == 0)
  1467.       {
  1468.       minus_c[1] = '/';  /* cmd.exe uses /, not - for options */
  1469.       minus_c[3] = ' ';  /* cmd.exe does not recognize -e option */
  1470.       }
  1471. #endif /* WIN32 */
  1472.     bcopy (minus_c, ap, sizeof (minus_c) - 1);
  1473.     ap += sizeof (minus_c) - 1;
  1474.     for (p = line; *p != '\0'; ++p)
  1475.       {
  1476.     if (restp != NULL && *p == '\n')
  1477.       {
  1478.         *restp = p;
  1479.         break;
  1480.       }
  1481.     else if (*p == '\\' && p[1] == '\n')
  1482.       {
  1483.         /* Eat the backslash, the newline, and following whitespace,
  1484.            replacing it all with a single space (which is escaped
  1485.            from the shell).  */
  1486.         p += 2;
  1487.  
  1488.         /* If there is a tab after a backslash-newline,
  1489.            remove it from the source line which will be echoed,
  1490.            since it was most likely used to line
  1491.            up the continued line with the previous one.  */
  1492.         if (*p == '\t')
  1493.           strcpy (p, p + 1);
  1494.  
  1495.         p = next_token (p);
  1496.         --p;
  1497.         *ap++ = '\\';
  1498.         *ap++ = ' ';
  1499.         continue;
  1500.       }
  1501.  
  1502.     if (*p == '\\' || *p == '\'' || *p == '"'
  1503.         || isspace (*p)
  1504.         || index (sh_chars, *p) != 0)
  1505.       *ap++ = '\\';
  1506.     *ap++ = *p;
  1507.       }
  1508.     *ap = '\0';
  1509.     
  1510.     new_argv = construct_command_argv_internal (new_line, (char **) NULL,
  1511.                         (char *) 0, (char *) 0);
  1512.   }
  1513. #endif    /* MSDOS.  */
  1514.  
  1515.   return new_argv;
  1516. }
  1517.  
  1518. /* Figure out the argument list necessary to run LINE as a command.  Try to
  1519.    avoid using a shell.  This routine handles only ' quoting, and " quoting
  1520.    when no backslash, $ or ` characters are seen in the quotes.  Starting
  1521.    quotes may be escaped with a backslash.  If any of the characters in
  1522.    sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[]
  1523.    is the first word of a line, the shell is used.
  1524.  
  1525.    If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
  1526.    If *RESTP is NULL, newlines will be ignored.
  1527.  
  1528.    FILE is the target whose commands these are.  It is used for
  1529.    variable expansion for $(SHELL) and $(IFS).  */
  1530.  
  1531. char **
  1532. construct_command_argv (line, restp, file)
  1533.      char *line, **restp;
  1534.      struct file *file;
  1535. {
  1536. #ifdef WIN32
  1537.   static int count = 0;
  1538. #endif
  1539.   char *shell, *ifs;
  1540.   char **argv;
  1541.  
  1542.   {
  1543.     /* Turn off --warn-undefined-variables while we expand SHELL and IFS.  */
  1544.     int save = warn_undefined_variables_flag;
  1545.     warn_undefined_variables_flag = 0;
  1546.  
  1547.     shell = allocated_variable_expand_for_file ("$(SHELL)", file);
  1548.     ifs = allocated_variable_expand_for_file ("$(IFS)", file);
  1549.  
  1550.     warn_undefined_variables_flag = save;
  1551.   }
  1552.  
  1553. #ifdef WIN32
  1554.   count++;
  1555.   /* we must force the "slow expansion" in construct_command_argv_internal
  1556.      for all cases, since "commands" may actually be shellscripts which can
  1557.      only be invoked from within a 'sh -e ...' command.  The simplest way
  1558.      to do this is to ensure that shell != default_shell when we call
  1559.      construct_command_argv_internal().  We have to use the counter to
  1560.      ensure that we only do this for the top-level invocation, not for any
  1561.      recursive invocations (else we'd get infinite recursion).
  1562.      */
  1563.   if (count==1 && !strcmp (shell, default_shell))
  1564.     {
  1565.     free (shell);
  1566.     shell = malloc (strlen (default_shell) + 5);
  1567.     sprintf (shell, "%s.exe", default_shell);
  1568.     }
  1569.   argv = construct_command_argv_internal (line, restp, shell, ifs);
  1570.   count--;
  1571. #else
  1572.   argv = construct_command_argv_internal (line, restp, shell, ifs);
  1573. #endif
  1574.  
  1575. #ifdef WIN32
  1576.   if (argv)
  1577.     {
  1578.     /* spawnvpe performs limited escape-substitution,
  1579.     so we must escape the " and the \ if it is followed
  1580.     by a ", and we must enclose the argument in ". */
  1581.  
  1582.     /* for reasons which are unclear to me, allocating a
  1583.     new buffer causes the program to crash later on, so
  1584.     I will do some fancy footwork to avoid it. */
  1585.   
  1586.     int i, size;
  1587.     char *buffer;
  1588.     const char *p;
  1589.     char *q;
  1590.  
  1591.     /* first, determine size of buffer */
  1592.     for (i=size=0; argv[i]; i++)
  1593.       size += strlen (argv[i]) + 1;
  1594.  
  1595.     /* then copy the data */
  1596.     buffer = alloca (size);
  1597.     for (i=0, q=buffer; argv[i]; i++, q+=strlen (q)+1)
  1598.       strcpy (q, (const char *)argv[i]);
  1599.     assert (q - buffer == size);
  1600.  
  1601.     p = buffer + strlen (buffer) + 1;
  1602.     q = argv[0] + strlen (argv[0]) + 1;
  1603.     assert (p-buffer == q-argv[0]);
  1604.     for (i=1; argv[i]; i++) 
  1605.       {
  1606.       if (*p == '"' || *p == '\'' || strcspn (p, "\\\"' \t\n") == strlen (p))
  1607.         {
  1608.         argv[i] = q;
  1609.         strcpy (q, p);
  1610.         q += strlen (argv[i]) + 1;
  1611.         p += strlen (argv[i]) + 1;
  1612.         }
  1613.       else
  1614.         {
  1615.         argv[i] = q;
  1616.         *q++ = '"';
  1617.         while (*p)
  1618.           {
  1619.           if (*p == '"') *q++ = '\\';
  1620.           if (*p == '\\' && *(p+1) == '"') *q++ = '\\';
  1621.           if (*p == '\\' && *(p+1) == '\\') *q++ = '\\';
  1622.           *q++ = *p++;
  1623.           }
  1624.         *q++ = '"';
  1625.         assert (*p == '\0');
  1626.         *q++ = *p++;
  1627.         }
  1628.       }
  1629.     }
  1630. #endif
  1631.  
  1632.   free (shell);
  1633.   free (ifs);
  1634.  
  1635.   return argv;
  1636. }
  1637.  
  1638. #ifndef    HAVE_DUP2
  1639. int
  1640. dup2 (old, new)
  1641.      int old, new;
  1642. {
  1643.   int fd;
  1644.  
  1645.   (void) close (new);
  1646.   fd = dup (old);
  1647.   if (fd != new)
  1648.     {
  1649.       (void) close (fd);
  1650.       errno = EMFILE;
  1651.       return -1;
  1652.     }
  1653.  
  1654.   return fd;
  1655. }
  1656. #endif
  1657.