1 /* Job execution and handling 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
5 This file is part of GNU Make.
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
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.
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/>. */
32 /* Default shell to use. */
36 char *default_shell
= "sh.exe";
37 int no_default_sh_exe
= 1;
38 int batch_mode_shell
= 1;
41 #elif defined (_AMIGA)
43 char default_shell
[] = "";
44 extern int MyExecute (char **);
45 int batch_mode_shell
= 0;
47 #elif defined (__MSDOS__)
49 /* The default shell is a pointer so we can change it if Makefile
50 says so. It is without an explicit path so we get a chance
51 to search the $PATH for it (since MSDOS doesn't have standard
52 directories we could trust). */
53 char *default_shell
= "command.com";
54 int batch_mode_shell
= 0;
56 #elif defined (__EMX__)
58 char *default_shell
= "/bin/sh";
59 int batch_mode_shell
= 0;
64 char default_shell
[] = "";
65 int batch_mode_shell
= 0;
67 #elif defined (__riscos__)
69 char default_shell
[] = "";
70 int batch_mode_shell
= 0;
74 char default_shell
[] = "/bin/sh";
75 int batch_mode_shell
= 0;
81 static int execute_by_shell
;
82 static int dos_pid
= 123;
84 int dos_command_running
;
85 #endif /* __MSDOS__ */
88 # include <proto/dos.h>
89 static int amiga_pid
= 123;
90 static int amiga_status
;
91 static char amiga_bname
[32];
92 static int amiga_batch_file
;
97 # include <processes.h>
100 # include <lib$routines.h>
101 static void vmsWaitForChildren (int *);
105 # include <windows.h>
107 # include <process.h>
108 # include "sub_proc.h"
110 # include "pathstuff.h"
111 #endif /* WINDOWS32 */
114 # include <process.h>
117 #if defined (HAVE_SYS_WAIT_H) || defined (HAVE_UNION_WAIT)
118 # include <sys/wait.h>
122 # define WAIT_NOHANG(status) waitpid (-1, (status), WNOHANG)
123 #else /* Don't have waitpid. */
128 # define WAIT_NOHANG(status) wait3 ((status), WNOHANG, (struct rusage *) 0)
129 # endif /* Have wait3. */
130 #endif /* Have waitpid. */
132 #if !defined (wait) && !defined (POSIX)
136 #ifndef HAVE_UNION_WAIT
141 # define WTERMSIG(x) ((x) & 0x7f)
144 # define WCOREDUMP(x) ((x) & 0x80)
147 # define WEXITSTATUS(x) (((x) >> 8) & 0xff)
150 # define WIFSIGNALED(x) (WTERMSIG (x) != 0)
153 # define WIFEXITED(x) (WTERMSIG (x) == 0)
156 #else /* Have `union wait'. */
158 # define WAIT_T union wait
160 # define WTERMSIG(x) ((x).w_termsig)
163 # define WCOREDUMP(x) ((x).w_coredump)
166 # define WEXITSTATUS(x) ((x).w_retcode)
169 # define WIFSIGNALED(x) (WTERMSIG(x) != 0)
172 # define WIFEXITED(x) (WTERMSIG(x) == 0)
175 #endif /* Don't have `union wait'. */
177 #ifndef HAVE_UNISTD_H
189 int getloadavg (double loadavg
[], int nelem
);
190 int start_remote_job (char **argv
, char **envp
, int stdin_fd
, int *is_remote
,
191 int *id_ptr
, int *used_stdin
);
192 int start_remote_job_p (int);
193 int remote_status (int *exit_code_ptr
, int *signal_ptr
, int *coredump_ptr
,
196 RETSIGTYPE
child_handler (int);
197 static void free_child (struct child
*);
198 static void start_job_command (struct child
*child
);
199 static int load_too_high (void);
200 static int job_next_command (struct child
*);
201 static int start_waiting_job (struct child
*);
203 /* Chain of all live (or recently deceased) children. */
205 struct child
*children
= 0;
207 /* Number of children currently running. */
209 unsigned int job_slots_used
= 0;
211 /* Nonzero if the `good' standard input is in use. */
213 static int good_stdin_used
= 0;
215 /* Chain of children waiting to run until the load average goes down. */
217 static struct child
*waiting_jobs
= 0;
219 /* Non-zero if we use a *real* shell (always so on Unix). */
223 /* Number of jobs started in the current second. */
225 unsigned long job_counter
= 0;
227 /* Number of jobserver tokens this instance is currently using. */
229 unsigned int jobserver_tokens
= 0;
233 * The macro which references this function is defined in make.h.
236 w32_kill(int pid
, int sig
)
238 return ((process_kill((HANDLE
)pid
, sig
) == TRUE
) ? 0 : -1);
241 /* This function creates a temporary file name with an extension specified
243 * Return an xmalloc'ed string of a newly created temp file and its
244 * file descriptor, or die. */
246 create_batch_file (char const *base
, int unixy
, int *fd
)
248 const char *const ext
= unixy
? "sh" : "bat";
249 const char *error
= NULL
;
250 char temp_path
[MAXPATHLEN
]; /* need to know its length */
251 unsigned path_size
= GetTempPath(sizeof temp_path
, temp_path
);
254 const unsigned sizemax
= strlen (base
) + strlen (ext
) + 10;
258 path_size
= GetCurrentDirectory (sizeof temp_path
, temp_path
);
262 while (path_size
> 0 &&
263 path_size
+ sizemax
< sizeof temp_path
&&
266 unsigned size
= sprintf (temp_path
+ path_size
,
268 temp_path
[path_size
- 1] == '\\' ? "" : "\\",
270 HANDLE h
= CreateFile (temp_path
, /* file name */
271 GENERIC_READ
| GENERIC_WRITE
, /* desired access */
272 0, /* no share mode */
273 NULL
, /* default security attributes */
274 CREATE_NEW
, /* creation disposition */
275 FILE_ATTRIBUTE_NORMAL
| /* flags and attributes */
276 FILE_ATTRIBUTE_TEMPORARY
, /* we'll delete it */
277 NULL
); /* no template file */
279 if (h
== INVALID_HANDLE_VALUE
)
281 const DWORD er
= GetLastError();
283 if (er
== ERROR_FILE_EXISTS
|| er
== ERROR_ALREADY_EXISTS
)
286 /* the temporary path is not guaranteed to exist */
287 else if (path_is_dot
== 0)
289 path_size
= GetCurrentDirectory (sizeof temp_path
, temp_path
);
295 error
= map_windows32_error_to_string (er
);
301 const unsigned final_size
= path_size
+ size
+ 1;
302 char *const path
= xmalloc (final_size
);
303 memcpy (path
, temp_path
, final_size
);
304 *fd
= _open_osfhandle ((long)h
, 0);
309 for (p
= path
; (ch
= *p
) != 0; ++p
)
313 return path
; /* good return */
319 error
= _("Cannot create a temporary file\n");
325 #endif /* WINDOWS32 */
328 /* returns whether path is assumed to be a unix like shell. */
330 _is_unixy_shell (const char *path
)
332 /* list of non unix shells */
333 const char *known_os2shells
[] = {
345 /* find the rightmost '/' or '\\' */
346 const char *name
= strrchr (path
, '/');
347 const char *p
= strrchr (path
, '\\');
350 if (name
&& p
) /* take the max */
351 name
= (name
> p
) ? name
: p
;
352 else if (p
) /* name must be 0 */
354 else if (!name
) /* name and p must be 0 */
357 if (*name
== '/' || *name
== '\\') name
++;
360 while (known_os2shells
[i
] != NULL
) {
361 if (strcasecmp (name
, known_os2shells
[i
]) == 0)
362 return 0; /* not a unix shell */
366 /* in doubt assume a unix like shell */
372 /* Write an error message describing the exit status given in
373 EXIT_CODE, EXIT_SIG, and COREDUMP, for the target TARGET_NAME.
374 Append "(ignored)" if IGNORED is nonzero. */
377 child_error (const char *target_name
,
378 int exit_code
, int exit_sig
, int coredump
, int ignored
)
380 if (ignored
&& silent_flag
)
384 if (!(exit_code
& 1))
386 (ignored
? _("*** [%s] Error 0x%x (ignored)")
387 : _("*** [%s] Error 0x%x")),
388 target_name
, exit_code
);
391 error (NILF
, ignored
? _("[%s] Error %d (ignored)") :
392 _("*** [%s] Error %d"),
393 target_name
, exit_code
);
395 error (NILF
, "*** [%s] %s%s",
396 target_name
, strsignal (exit_sig
),
397 coredump
? _(" (core dumped)") : "");
402 /* Handle a dead child. This handler may or may not ever be installed.
404 If we're using the jobserver feature, we need it. First, installing it
405 ensures the read will interrupt on SIGCHLD. Second, we close the dup'd
406 read FD to ensure we don't enter another blocking read without reaping all
407 the dead children. In this case we don't need the dead_children count.
409 If we don't have either waitpid or wait3, then make is unreliable, but we
410 use the dead_children count to reap children as best we can. */
412 static unsigned int dead_children
= 0;
415 child_handler (int sig UNUSED
)
426 /* The signal handler must called only once! */
427 signal (SIGCHLD
, SIG_DFL
);
430 /* This causes problems if the SIGCHLD interrupts a printf().
431 DB (DB_JOBS, (_("Got a SIGCHLD; %u unreaped children.\n"), dead_children));
435 extern int shell_function_pid
, shell_function_completed
;
437 /* Reap all dead children, storing the returned status and the new command
438 state (`cs_finished') in the `file' member of the `struct child' for the
439 dead child, and removing the child from the chain. In addition, if BLOCK
440 nonzero, we block in this function until we've reaped at least one
441 complete child, waiting for it to die if necessary. If ERR is nonzero,
442 print an error message first. */
445 reap_children (int block
, int err
)
449 /* Initially, assume we have some. */
454 # define REAP_MORE reap_more
456 # define REAP_MORE dead_children
461 We have at least one child outstanding OR a shell function in progress,
463 We're blocking for a complete child OR there are more children to reap
465 we'll keep reaping children. */
467 while ((children
!= 0 || shell_function_pid
!= 0)
468 && (block
|| REAP_MORE
))
472 int exit_code
, exit_sig
, coredump
;
473 register struct child
*lastc
, *c
;
475 int any_remote
, any_local
;
480 static int printed
= 0;
482 /* We might block for a while, so let the user know why.
483 Only print this message once no matter how many jobs are left. */
486 error (NILF
, _("*** Waiting for unfinished jobs...."));
490 /* We have one less dead child to reap. As noted in
491 child_handler() above, this count is completely unimportant for
492 all modern, POSIX-y systems that support wait3() or waitpid().
493 The rest of this comment below applies only to early, broken
494 pre-POSIX systems. We keep the count only because... it's there...
496 The test and decrement are not atomic; if it is compiled into:
497 register = dead_children - 1;
498 dead_children = register;
499 a SIGCHLD could come between the two instructions.
500 child_handler increments dead_children.
501 The second instruction here would lose that increment. But the
502 only effect of dead_children being wrong is that we might wait
503 longer than necessary to reap a child, and lose some parallelism;
504 and we might print the "Waiting for unfinished jobs" message above
505 when not necessary. */
507 if (dead_children
> 0)
511 any_local
= shell_function_pid
!= 0;
512 for (c
= children
; c
!= 0; c
= c
->next
)
514 any_remote
|= c
->remote
;
515 any_local
|= ! c
->remote
;
516 DB (DB_JOBS
, (_("Live child 0x%08lx (%s) PID %ld %s\n"),
517 (unsigned long int) c
, c
->file
->name
,
518 (long) c
->pid
, c
->remote
? _(" (remote)") : ""));
524 /* First, check for remote children. */
526 pid
= remote_status (&exit_code
, &exit_sig
, &coredump
, 0);
531 /* We got a remote child. */
535 /* A remote status command failed miserably. Punt. */
537 pfatal_with_name ("remote_status");
541 /* No remote children. Check for local children. */
542 #if !defined(__MSDOS__) && !defined(_AMIGA) && !defined(WINDOWS32)
546 vmsWaitForChildren (&status
);
551 pid
= WAIT_NOHANG (&status
);
554 EINTRLOOP(pid
, wait (&status
));
562 /* The wait*() failed miserably. Punt. */
563 pfatal_with_name ("wait");
567 /* We got a child exit; chop the status word up. */
568 exit_code
= WEXITSTATUS (status
);
569 exit_sig
= WIFSIGNALED (status
) ? WTERMSIG (status
) : 0;
570 coredump
= WCOREDUMP (status
);
572 /* If we have started jobs in this second, remove one. */
578 /* No local children are dead. */
581 if (!block
|| !any_remote
)
584 /* Now try a blocking wait for a remote child. */
585 pid
= remote_status (&exit_code
, &exit_sig
, &coredump
, 1);
587 goto remote_status_lose
;
589 /* No remote children either. Finally give up. */
592 /* We got a remote child. */
595 #endif /* !__MSDOS__, !Amiga, !WINDOWS32. */
598 /* Life is very different on MSDOS. */
601 exit_code
= WEXITSTATUS (status
);
602 if (exit_code
== 0xff)
604 exit_sig
= WIFSIGNALED (status
) ? WTERMSIG (status
) : 0;
606 #endif /* __MSDOS__ */
610 status
= amiga_status
;
611 exit_code
= amiga_status
;
624 /* Record the thread ID of the main process, so that we
625 could suspend it in the signal handler. */
628 hcTID
= GetCurrentThread ();
629 hcPID
= GetCurrentProcess ();
630 if (!DuplicateHandle (hcPID
, hcTID
, hcPID
, &main_thread
, 0,
631 FALSE
, DUPLICATE_SAME_ACCESS
))
633 DWORD e
= GetLastError ();
635 "Determine main thread ID (Error %ld: %s)\n",
636 e
, map_windows32_error_to_string(e
));
639 DB (DB_VERBOSE
, ("Main thread handle = 0x%08lx\n",
640 (unsigned long)main_thread
));
643 /* wait for anything to finish */
644 hPID
= process_wait_for_any();
648 /* was an error found on this process? */
649 werr
= process_last_err(hPID
);
652 exit_code
= process_exit_code(hPID
);
655 fprintf(stderr
, "make (e=%d): %s",
656 exit_code
, map_windows32_error_to_string(exit_code
));
659 exit_sig
= process_signal(hPID
);
661 /* cleanup process */
662 process_cleanup(hPID
);
668 #endif /* WINDOWS32 */
671 /* Check if this is the child of the `shell' function. */
672 if (!remote
&& pid
== shell_function_pid
)
674 /* It is. Leave an indicator for the `shell' function. */
675 if (exit_sig
== 0 && exit_code
== 127)
676 shell_function_completed
= -1;
678 shell_function_completed
= 1;
682 child_failed
= exit_sig
!= 0 || exit_code
!= 0;
684 /* Search for a child matching the deceased one. */
686 for (c
= children
; c
!= 0; lastc
= c
, c
= c
->next
)
687 if (c
->remote
== remote
&& c
->pid
== pid
)
691 /* An unknown child died.
692 Ignore it; it was inherited from our invoker. */
695 DB (DB_JOBS
, (child_failed
696 ? _("Reaping losing child 0x%08lx PID %ld %s\n")
697 : _("Reaping winning child 0x%08lx PID %ld %s\n"),
698 (unsigned long int) c
, (long) c
->pid
,
699 c
->remote
? _(" (remote)") : ""));
701 if (c
->sh_batch_file
) {
702 DB (DB_JOBS
, (_("Cleaning up temp batch file %s\n"),
705 /* just try and remove, don't care if this fails */
706 remove (c
->sh_batch_file
);
708 /* all done with memory */
709 free (c
->sh_batch_file
);
710 c
->sh_batch_file
= NULL
;
713 /* If this child had the good stdin, say it is now free. */
717 dontcare
= c
->dontcare
;
719 if (child_failed
&& !c
->noerror
&& !ignore_errors_flag
)
721 /* The commands failed. Write an error message,
722 delete non-precious targets, and abort. */
723 static int delete_on_error
= -1;
726 child_error (c
->file
->name
, exit_code
, exit_sig
, coredump
, 0);
728 c
->file
->update_status
= 2;
729 if (delete_on_error
== -1)
731 struct file
*f
= lookup_file (".DELETE_ON_ERROR");
732 delete_on_error
= f
!= 0 && f
->is_target
;
734 if (exit_sig
!= 0 || delete_on_error
)
735 delete_child_targets (c
);
741 /* The commands failed, but we don't care. */
742 child_error (c
->file
->name
,
743 exit_code
, exit_sig
, coredump
, 1);
747 /* If there are more commands to run, try to start them. */
748 if (job_next_command (c
))
750 if (handling_fatal_signal
)
752 /* Never start new commands while we are dying.
753 Since there are more commands that wanted to be run,
754 the target was not completely remade. So we treat
755 this as if a command had failed. */
756 c
->file
->update_status
= 2;
760 /* Check again whether to start remotely.
761 Whether or not we want to changes over time.
762 Also, start_remote_job may need state set up
763 by start_remote_job_p. */
764 c
->remote
= start_remote_job_p (0);
765 start_job_command (c
);
766 /* Fatal signals are left blocked in case we were
767 about to put that child on the chain. But it is
768 already there, so it is safe for a fatal signal to
769 arrive now; it will clean up this child's targets. */
771 if (c
->file
->command_state
== cs_running
)
772 /* We successfully started the new command.
773 Loop to reap more children. */
777 if (c
->file
->update_status
!= 0)
778 /* We failed to start the commands. */
779 delete_child_targets (c
);
782 /* There are no more commands. We got through them all
783 without an unignored error. Now the target has been
784 successfully updated. */
785 c
->file
->update_status
= 0;
788 /* When we get here, all the commands for C->file are finished
789 (or aborted) and C->file->update_status contains 0 or 2. But
790 C->file->command_state is still cs_running if all the commands
791 ran; notice_finish_file looks for cs_running to tell it that
792 it's interesting to check the file's modtime again now. */
794 if (! handling_fatal_signal
)
795 /* Notice if the target of the commands has been changed.
796 This also propagates its values for command_state and
797 update_status to its also_make files. */
798 notice_finished_file (c
->file
);
800 DB (DB_JOBS
, (_("Removing child 0x%08lx PID %ld%s from chain.\n"),
801 (unsigned long int) c
, (long) c
->pid
,
802 c
->remote
? _(" (remote)") : ""));
804 /* Block fatal signals while frobnicating the list, so that
805 children and job_slots_used are always consistent. Otherwise
806 a fatal signal arriving after the child is off the chain and
807 before job_slots_used is decremented would believe a child was
808 live and call reap_children again. */
811 /* There is now another slot open. */
812 if (job_slots_used
> 0)
815 /* Remove the child from the chain and free it. */
819 lastc
->next
= c
->next
;
825 /* If the job failed, and the -k flag was not given, die,
826 unless we are already in the process of dying. */
827 if (!err
&& child_failed
&& !dontcare
&& !keep_going_flag
&&
828 /* fatal_error_signal will die with the right signal. */
829 !handling_fatal_signal
)
832 /* Only block for one child. */
839 /* Free the storage allocated for CHILD. */
842 free_child (struct child
*child
)
844 if (!jobserver_tokens
)
845 fatal (NILF
, "INTERNAL: Freeing child 0x%08lx (%s) but no tokens left!\n",
846 (unsigned long int) child
, child
->file
->name
);
848 /* If we're using the jobserver and this child is not the only outstanding
849 job, put a token back into the pipe for it. */
851 if (job_fds
[1] >= 0 && jobserver_tokens
> 1)
856 /* Write a job token back to the pipe. */
858 EINTRLOOP (r
, write (job_fds
[1], &token
, 1));
860 pfatal_with_name (_("write jobserver"));
862 DB (DB_JOBS
, (_("Released token for child 0x%08lx (%s).\n"),
863 (unsigned long int) child
, child
->file
->name
));
868 if (handling_fatal_signal
) /* Don't bother free'ing if about to die. */
871 if (child
->command_lines
!= 0)
873 register unsigned int i
;
874 for (i
= 0; i
< child
->file
->cmds
->ncommand_lines
; ++i
)
875 free (child
->command_lines
[i
]);
876 free (child
->command_lines
);
879 if (child
->environment
!= 0)
881 register char **ep
= child
->environment
;
884 free (child
->environment
);
891 extern sigset_t fatal_signal_set
;
898 (void) sigprocmask (SIG_BLOCK
, &fatal_signal_set
, (sigset_t
*) 0);
900 # ifdef HAVE_SIGSETMASK
901 (void) sigblock (fatal_signal_mask
);
911 sigemptyset (&empty
);
912 sigprocmask (SIG_SETMASK
, &empty
, (sigset_t
*) 0);
916 #ifdef MAKE_JOBSERVER
918 job_noop (int sig UNUSED
)
921 /* Set the child handler action flags to FLAGS. */
923 set_child_handler_action_flags (int set_handler
, int set_alarm
)
928 /* The child handler must be turned off here. */
929 signal (SIGCHLD
, SIG_DFL
);
932 memset (&sa
, '\0', sizeof sa
);
933 sa
.sa_handler
= child_handler
;
934 sa
.sa_flags
= set_handler
? 0 : SA_RESTART
;
936 sigaction (SIGCHLD
, &sa
, NULL
);
938 #if defined SIGCLD && SIGCLD != SIGCHLD
939 sigaction (SIGCLD
, &sa
, NULL
);
944 /* If we're about to enter the read(), set an alarm to wake up in a
945 second so we can check if the load has dropped and we can start more
946 work. On the way out, turn off the alarm and set SIG_DFL. */
947 alarm (set_handler
? 1 : 0);
948 sa
.sa_handler
= set_handler
? job_noop
: SIG_DFL
;
950 sigaction (SIGALRM
, &sa
, NULL
);
957 /* Start a job to run the commands specified in CHILD.
958 CHILD is updated to reflect the commands and ID of the child process.
960 NOTE: On return fatal signals are blocked! The caller is responsible
961 for calling `unblock_sigs', once the new child is safely on the chain so
962 it can be cleaned up in the event of a fatal signal. */
965 start_job_command (struct child
*child
)
967 #if !defined(_AMIGA) && !defined(WINDOWS32)
968 static int bad_stdin
= -1;
978 /* If we have a completely empty commandset, stop now. */
979 if (!child
->command_ptr
)
982 /* Combine the flags parsed for the line itself with
983 the flags specified globally for this target. */
984 flags
= (child
->file
->command_flags
985 | child
->file
->cmds
->lines_flags
[child
->command_line
- 1]);
987 p
= child
->command_ptr
;
988 child
->noerror
= ((flags
& COMMANDS_NOERROR
) != 0);
993 flags
|= COMMANDS_SILENT
;
995 flags
|= COMMANDS_RECURSE
;
998 else if (!isblank ((unsigned char)*p
))
1003 /* Update the file's command flags with any new ones we found. We only
1004 keep the COMMANDS_RECURSE setting. Even this isn't 100% correct; we are
1005 now marking more commands recursive than should be in the case of
1006 multiline define/endef scripts where only one line is marked "+". In
1007 order to really fix this, we'll have to keep a lines_flags for every
1008 actual line, after expansion. */
1009 child
->file
->cmds
->lines_flags
[child
->command_line
- 1]
1010 |= flags
& COMMANDS_RECURSE
;
1012 /* Figure out an argument list from this command line. */
1019 argv
= construct_command_argv (p
, &end
, child
->file
,
1020 child
->file
->cmds
->lines_flags
[child
->command_line
- 1],
1021 &child
->sh_batch_file
);
1024 child
->command_ptr
= NULL
;
1028 child
->command_ptr
= end
;
1032 /* If -q was given, say that updating `failed' if there was any text on the
1033 command line, or `succeeded' otherwise. The exit status of 1 tells the
1034 user that -q is saying `something to do'; the exit status for a random
1036 if (argv
!= 0 && question_flag
&& !(flags
& COMMANDS_RECURSE
))
1042 child
->file
->update_status
= 1;
1043 notice_finished_file (child
->file
);
1047 if (touch_flag
&& !(flags
& COMMANDS_RECURSE
))
1049 /* Go on to the next command. It might be the recursive one.
1050 We construct ARGV only to find the end of the command line. */
1065 execute_by_shell
= 0; /* in case construct_command_argv sets it */
1067 /* This line has no commands. Go to the next. */
1068 if (job_next_command (child
))
1069 start_job_command (child
);
1072 /* No more commands. Make sure we're "running"; we might not be if
1073 (e.g.) all commands were skipped due to -n. */
1074 set_command_state (child
->file
, cs_running
);
1075 child
->file
->update_status
= 0;
1076 notice_finished_file (child
->file
);
1081 /* Print out the command. If silent, we call `message' with null so it
1082 can log the working directory before the command's own error messages
1085 message (0, (just_print_flag
|| (!(flags
& COMMANDS_SILENT
) && !silent_flag
))
1086 ? "%s" : (char *) 0, p
);
1088 /* Tell update_goal_chain that a command has been started on behalf of
1089 this target. It is important that this happens here and not in
1090 reap_children (where we used to do it), because reap_children might be
1091 reaping children from a different target. We want this increment to
1092 guaranteedly indicate that a command was started for the dependency
1093 chain (i.e., update_file recursion chain) we are processing. */
1097 /* Optimize an empty command. People use this for timestamp rules,
1098 so avoid forking a useless shell. Do this after we increment
1099 commands_started so make still treats this special case as if it
1100 performed some action (makes a difference as to what messages are
1103 #if !defined(VMS) && !defined(_AMIGA)
1105 #if defined __MSDOS__ || defined (__EMX__)
1106 unixy_shell
/* the test is complicated and we already did it */
1108 (argv
[0] && !strcmp (argv
[0], "/bin/sh"))
1111 && argv
[1][0] == '-' && argv
[1][1] == 'c' && argv
[1][2] == '\0')
1112 && (argv
[2] && argv
[2][0] == ':' && argv
[2][1] == '\0')
1119 #endif /* !VMS && !_AMIGA */
1121 /* If -n was given, recurse to get the next line in the sequence. */
1123 if (just_print_flag
&& !(flags
& COMMANDS_RECURSE
))
1132 /* Flush the output streams so they won't have things written twice. */
1138 #if !defined(WINDOWS32) && !defined(_AMIGA) && !defined(__MSDOS__)
1140 /* Set up a bad standard input that reads from a broken pipe. */
1142 if (bad_stdin
== -1)
1144 /* Make a file descriptor that is the read end of a broken pipe.
1145 This will be used for some children's standard inputs. */
1149 /* Close the write side. */
1150 (void) close (pd
[1]);
1151 /* Save the read side. */
1154 /* Set the descriptor to close on exec, so it does not litter any
1155 child's descriptor table. When it is dup2'd onto descriptor 0,
1156 that descriptor will not close on exec. */
1157 CLOSE_ON_EXEC (bad_stdin
);
1161 #endif /* !WINDOWS32 && !_AMIGA && !__MSDOS__ */
1163 /* Decide whether to give this child the `good' standard input
1164 (one that points to the terminal or whatever), or the `bad' one
1165 that points to the read side of a broken pipe. */
1167 child
->good_stdin
= !good_stdin_used
;
1168 if (child
->good_stdin
)
1169 good_stdin_used
= 1;
1176 /* Set up the environment for the child. */
1177 if (child
->environment
== 0)
1178 child
->environment
= target_environment (child
->file
);
1181 #if !defined(__MSDOS__) && !defined(_AMIGA) && !defined(WINDOWS32)
1184 /* start_waiting_job has set CHILD->remote if we can start a remote job. */
1187 int is_remote
, id
, used_stdin
;
1188 if (start_remote_job (argv
, child
->environment
,
1189 child
->good_stdin
? 0 : bad_stdin
,
1190 &is_remote
, &id
, &used_stdin
))
1191 /* Don't give up; remote execution may fail for various reasons. If
1192 so, simply run the job locally. */
1196 if (child
->good_stdin
&& !used_stdin
)
1198 child
->good_stdin
= 0;
1199 good_stdin_used
= 0;
1201 child
->remote
= is_remote
;
1208 /* Fork the child process. */
1210 char **parent_environ
;
1218 if (!child_execute_job (argv
, child
)) {
1220 perror_with_name ("vfork", "");
1226 parent_environ
= environ
;
1229 /* If we aren't running a recursive command and we have a jobserver
1230 pipe, close it before exec'ing. */
1231 if (!(flags
& COMMANDS_RECURSE
) && job_fds
[0] >= 0)
1233 CLOSE_ON_EXEC (job_fds
[0]);
1234 CLOSE_ON_EXEC (job_fds
[1]);
1237 CLOSE_ON_EXEC (job_rfd
);
1239 /* Never use fork()/exec() here! Use spawn() instead in exec_command() */
1240 child
->pid
= child_execute_job (child
->good_stdin
? 0 : bad_stdin
, 1,
1241 argv
, child
->environment
);
1246 perror_with_name ("spawn", "");
1250 /* undo CLOSE_ON_EXEC() after the child process has been started */
1251 if (!(flags
& COMMANDS_RECURSE
) && job_fds
[0] >= 0)
1253 fcntl (job_fds
[0], F_SETFD
, 0);
1254 fcntl (job_fds
[1], F_SETFD
, 0);
1257 fcntl (job_rfd
, F_SETFD
, 0);
1259 #else /* !__EMX__ */
1261 child
->pid
= vfork ();
1262 environ
= parent_environ
; /* Restore value child may have clobbered. */
1263 if (child
->pid
== 0)
1265 /* We are the child side. */
1268 /* If we aren't running a recursive command and we have a jobserver
1269 pipe, close it before exec'ing. */
1270 if (!(flags
& COMMANDS_RECURSE
) && job_fds
[0] >= 0)
1278 #ifdef SET_STACK_SIZE
1279 /* Reset limits, if necessary. */
1280 if (stack_limit
.rlim_cur
)
1281 setrlimit (RLIMIT_STACK
, &stack_limit
);
1284 child_execute_job (child
->good_stdin
? 0 : bad_stdin
, 1,
1285 argv
, child
->environment
);
1287 else if (child
->pid
< 0)
1291 perror_with_name ("vfork", "");
1294 # endif /* !__EMX__ */
1298 #else /* __MSDOS__ or Amiga or WINDOWS32 */
1306 /* We call `system' to do the job of the SHELL, since stock DOS
1307 shell is too dumb. Our `system' knows how to handle long
1308 command lines even if pipes/redirection is needed; it will only
1309 call COMMAND.COM when its internal commands are used. */
1310 if (execute_by_shell
)
1312 char *cmdline
= argv
[0];
1313 /* We don't have a way to pass environment to `system',
1314 so we need to save and restore ours, sigh... */
1315 char **parent_environ
= environ
;
1317 environ
= child
->environment
;
1319 /* If we have a *real* shell, tell `system' to call
1320 it to do everything for us. */
1323 /* A *real* shell on MSDOS may not support long
1324 command lines the DJGPP way, so we must use `system'. */
1325 cmdline
= argv
[2]; /* get past "shell -c" */
1328 dos_command_running
= 1;
1329 proc_return
= system (cmdline
);
1330 environ
= parent_environ
;
1331 execute_by_shell
= 0; /* for the next time */
1335 dos_command_running
= 1;
1336 proc_return
= spawnvpe (P_WAIT
, argv
[0], argv
, child
->environment
);
1339 /* Need to unblock signals before turning off
1340 dos_command_running, so that child's signals
1341 will be treated as such (see fatal_error_signal). */
1343 dos_command_running
= 0;
1345 /* If the child got a signal, dos_status has its
1346 high 8 bits set, so be careful not to alter them. */
1347 if (proc_return
== -1)
1350 dos_status
|= (proc_return
& 0xff);
1352 child
->pid
= dos_pid
++;
1354 #endif /* __MSDOS__ */
1356 amiga_status
= MyExecute (argv
);
1359 child
->pid
= amiga_pid
++;
1360 if (amiga_batch_file
)
1362 amiga_batch_file
= 0;
1363 DeleteFile (amiga_bname
); /* Ignore errors. */
1371 /* make UNC paths safe for CreateProcess -- backslash format */
1373 if (arg0
&& arg0
[0] == '/' && arg0
[1] == '/')
1374 for ( ; arg0
&& *arg0
; arg0
++)
1378 /* make sure CreateProcess() has Path it needs */
1379 sync_Path_environment();
1381 hPID
= process_easy(argv
, child
->environment
);
1383 if (hPID
!= INVALID_HANDLE_VALUE
)
1384 child
->pid
= (int) hPID
;
1389 _("process_easy() failed to launch process (e=%ld)\n"),
1390 process_last_err(hPID
));
1391 for (i
= 0; argv
[i
]; i
++)
1392 fprintf(stderr
, "%s ", argv
[i
]);
1393 fprintf(stderr
, _("\nCounted %d args in failed launch\n"), i
);
1397 #endif /* WINDOWS32 */
1398 #endif /* __MSDOS__ or Amiga or WINDOWS32 */
1400 /* Bump the number of jobs started in this second. */
1403 /* We are the parent side. Set the state to
1404 say the commands are running and return. */
1406 set_command_state (child
->file
, cs_running
);
1408 /* Free the storage used by the child's argument list. */
1417 child
->file
->update_status
= 2;
1418 notice_finished_file (child
->file
);
1422 /* Try to start a child running.
1423 Returns nonzero if the child was started (and maybe finished), or zero if
1424 the load was too high and the child was put on the `waiting_jobs' chain. */
1427 start_waiting_job (struct child
*c
)
1429 struct file
*f
= c
->file
;
1431 /* If we can start a job remotely, we always want to, and don't care about
1432 the local load average. We record that the job should be started
1433 remotely in C->remote for start_job_command to test. */
1435 c
->remote
= start_remote_job_p (1);
1437 /* If we are running at least one job already and the load average
1438 is too high, make this one wait. */
1440 && ((job_slots_used
> 0 && load_too_high ())
1442 || (process_used_slots () >= MAXIMUM_WAIT_OBJECTS
)
1446 /* Put this child on the chain of children waiting for the load average
1448 set_command_state (f
, cs_running
);
1449 c
->next
= waiting_jobs
;
1454 /* Start the first command; reap_children will run later command lines. */
1455 start_job_command (c
);
1457 switch (f
->command_state
)
1461 DB (DB_JOBS
, (_("Putting child 0x%08lx (%s) PID %ld%s on the chain.\n"),
1462 (unsigned long int) c
, c
->file
->name
,
1463 (long) c
->pid
, c
->remote
? _(" (remote)") : ""));
1465 /* One more job slot is in use. */
1470 case cs_not_started
:
1471 /* All the command lines turned out to be empty. */
1472 f
->update_status
= 0;
1476 notice_finished_file (f
);
1481 assert (f
->command_state
== cs_finished
);
1488 /* Create a `struct child' for FILE and start its commands running. */
1491 new_job (struct file
*file
)
1493 struct commands
*cmds
= file
->cmds
;
1498 /* Let any previously decided-upon jobs that are waiting
1499 for the load to go down start before this new one. */
1500 start_waiting_jobs ();
1502 /* Reap any children that might have finished recently. */
1503 reap_children (0, 0);
1505 /* Chop the commands up into lines if they aren't already. */
1506 chop_commands (cmds
);
1508 /* Expand the command lines and store the results in LINES. */
1509 lines
= xmalloc (cmds
->ncommand_lines
* sizeof (char *));
1510 for (i
= 0; i
< cmds
->ncommand_lines
; ++i
)
1512 /* Collapse backslash-newline combinations that are inside variable
1513 or function references. These are left alone by the parser so
1514 that they will appear in the echoing of commands (where they look
1515 nice); and collapsed by construct_command_argv when it tokenizes.
1516 But letting them survive inside function invocations loses because
1517 we don't want the functions to see them as part of the text. */
1519 char *in
, *out
, *ref
;
1521 /* IN points to where in the line we are scanning.
1522 OUT points to where in the line we are writing.
1523 When we collapse a backslash-newline combination,
1524 IN gets ahead of OUT. */
1526 in
= out
= cmds
->command_lines
[i
];
1527 while ((ref
= strchr (in
, '$')) != 0)
1529 ++ref
; /* Move past the $. */
1532 /* Copy the text between the end of the last chunk
1533 we processed (where IN points) and the new chunk
1534 we are about to process (where REF points). */
1535 memmove (out
, in
, ref
- in
);
1537 /* Move both pointers past the boring stuff. */
1541 if (*ref
== '(' || *ref
== '{')
1543 char openparen
= *ref
;
1544 char closeparen
= openparen
== '(' ? ')' : '}';
1548 *out
++ = *in
++; /* Copy OPENPAREN. */
1549 /* IN now points past the opening paren or brace.
1550 Count parens or braces until it is matched. */
1554 if (*in
== closeparen
&& --count
< 0)
1556 else if (*in
== '\\' && in
[1] == '\n')
1558 /* We have found a backslash-newline inside a
1559 variable or function reference. Eat it and
1560 any following whitespace. */
1563 for (p
= in
- 1; p
> ref
&& *p
== '\\'; --p
)
1567 /* There were two or more backslashes, so this is
1568 not really a continuation line. We don't collapse
1569 the quoting backslashes here as is done in
1570 collapse_continuations, because the line will
1571 be collapsed again after expansion. */
1575 /* Skip the backslash, newline and
1576 any following whitespace. */
1577 in
= next_token (in
+ 2);
1579 /* Discard any preceding whitespace that has
1580 already been written to the output. */
1582 && isblank ((unsigned char)out
[-1]))
1585 /* Replace it all with a single space. */
1591 if (*in
== openparen
)
1600 /* There are no more references in this line to worry about.
1601 Copy the remaining uninteresting text to the output. */
1605 /* Finally, expand the line. */
1606 lines
[i
] = allocated_variable_expand_for_file (cmds
->command_lines
[i
],
1610 /* Start the command sequence, record it in a new
1611 `struct child', and add that to the chain. */
1613 c
= xmalloc (sizeof (struct child
));
1614 memset (c
, '\0', sizeof (struct child
));
1616 c
->command_lines
= lines
;
1617 c
->sh_batch_file
= NULL
;
1619 /* Cache dontcare flag because file->dontcare can be changed once we
1620 return. Check dontcare inheritance mechanism for details. */
1621 c
->dontcare
= file
->dontcare
;
1623 /* Fetch the first command line to be run. */
1624 job_next_command (c
);
1626 /* Wait for a job slot to be freed up. If we allow an infinite number
1627 don't bother; also job_slots will == 0 if we're using the jobserver. */
1630 while (job_slots_used
== job_slots
)
1631 reap_children (1, 0);
1633 #ifdef MAKE_JOBSERVER
1634 /* If we are controlling multiple jobs make sure we have a token before
1635 starting the child. */
1637 /* This can be inefficient. There's a decent chance that this job won't
1638 actually have to run any subprocesses: the command script may be empty
1639 or otherwise optimized away. It would be nice if we could defer
1640 obtaining a token until just before we need it, in start_job_command.
1641 To do that we'd need to keep track of whether we'd already obtained a
1642 token (since start_job_command is called for each line of the job, not
1643 just once). Also more thought needs to go into the entire algorithm;
1644 this is where the old parallel job code waits, so... */
1646 else if (job_fds
[0] >= 0)
1653 DB (DB_JOBS
, ("Need a job token; we %shave children\n",
1654 children
? "" : "don't "));
1656 /* If we don't already have a job started, use our "free" token. */
1657 if (!jobserver_tokens
)
1660 /* Read a token. As long as there's no token available we'll block.
1661 We enable interruptible system calls before the read(2) so that if
1662 we get a SIGCHLD while we're waiting, we'll return with EINTR and
1663 we can process the death(s) and return tokens to the free pool.
1665 Once we return from the read, we immediately reinstate restartable
1666 system calls. This allows us to not worry about checking for
1667 EINTR on all the other system calls in the program.
1669 There is one other twist: there is a span between the time
1670 reap_children() does its last check for dead children and the time
1671 the read(2) call is entered, below, where if a child dies we won't
1672 notice. This is extremely serious as it could cause us to
1673 deadlock, given the right set of events.
1675 To avoid this, we do the following: before we reap_children(), we
1676 dup(2) the read FD on the jobserver pipe. The read(2) call below
1677 uses that new FD. In the signal handler, we close that FD. That
1678 way, if a child dies during the section mentioned above, the
1679 read(2) will be invoked with an invalid FD and will return
1680 immediately with EBADF. */
1682 /* Make sure we have a dup'd FD. */
1685 DB (DB_JOBS
, ("Duplicate the job FD\n"));
1686 job_rfd
= dup (job_fds
[0]);
1689 /* Reap anything that's currently waiting. */
1690 reap_children (0, 0);
1692 /* Kick off any jobs we have waiting for an opportunity that
1693 can run now (ie waiting for load). */
1694 start_waiting_jobs ();
1696 /* If our "free" slot has become available, use it; we don't need an
1698 if (!jobserver_tokens
)
1701 /* There must be at least one child already, or we have no business
1702 waiting for a token. */
1704 fatal (NILF
, "INTERNAL: no children as we go to sleep on read\n");
1706 /* Set interruptible system calls, and read() for a job token. */
1707 set_child_handler_action_flags (1, waiting_jobs
!= NULL
);
1708 got_token
= read (job_rfd
, &token
, 1);
1709 saved_errno
= errno
;
1710 set_child_handler_action_flags (0, waiting_jobs
!= NULL
);
1712 /* If we got one, we're done here. */
1715 DB (DB_JOBS
, (_("Obtained token for child 0x%08lx (%s).\n"),
1716 (unsigned long int) c
, c
->file
->name
));
1720 /* If the error _wasn't_ expected (EINTR or EBADF), punt. Otherwise,
1721 go back and reap_children(), and try again. */
1722 errno
= saved_errno
;
1723 if (errno
!= EINTR
&& errno
!= EBADF
)
1724 pfatal_with_name (_("read jobs pipe"));
1726 DB (DB_JOBS
, ("Read returned EBADF.\n"));
1732 /* The job is now primed. Start it running.
1733 (This will notice if there is in fact no recipe.) */
1734 if (cmds
->fileinfo
.filenm
)
1735 DB (DB_BASIC
, (_("Invoking recipe from %s:%lu to update target `%s'.\n"),
1736 cmds
->fileinfo
.filenm
, cmds
->fileinfo
.lineno
,
1739 DB (DB_BASIC
, (_("Invoking builtin recipe to update target `%s'.\n"),
1743 start_waiting_job (c
);
1745 if (job_slots
== 1 || not_parallel
)
1746 /* Since there is only one job slot, make things run linearly.
1747 Wait for the child to die, setting the state to `cs_finished'. */
1748 while (file
->command_state
== cs_running
)
1749 reap_children (1, 0);
1754 /* Move CHILD's pointers to the next command for it to execute.
1755 Returns nonzero if there is another command. */
1758 job_next_command (struct child
*child
)
1760 while (child
->command_ptr
== 0 || *child
->command_ptr
== '\0')
1762 /* There are no more lines in the expansion of this line. */
1763 if (child
->command_line
== child
->file
->cmds
->ncommand_lines
)
1765 /* There are no more lines to be expanded. */
1766 child
->command_ptr
= 0;
1770 /* Get the next line to run. */
1771 child
->command_ptr
= child
->command_lines
[child
->command_line
++];
1776 /* Determine if the load average on the system is too high to start a new job.
1777 The real system load average is only recomputed once a second. However, a
1778 very parallel make can easily start tens or even hundreds of jobs in a
1779 second, which brings the system to its knees for a while until that first
1780 batch of jobs clears out.
1782 To avoid this we use a weighted algorithm to try to account for jobs which
1783 have been started since the last second, and guess what the load average
1784 would be now if it were computed.
1786 This algorithm was provided by Thomas Riedl <thomas.riedl@siemens.com>,
1789 ! calculate something load-oid and add to the observed sys.load,
1790 ! so that latter can catch up:
1791 ! - every job started increases jobctr;
1792 ! - every dying job decreases a positive jobctr;
1793 ! - the jobctr value gets zeroed every change of seconds,
1794 ! after its value*weight_b is stored into the 'backlog' value last_sec
1795 ! - weight_a times the sum of jobctr and last_sec gets
1796 ! added to the observed sys.load.
1798 ! The two weights have been tried out on 24 and 48 proc. Sun Solaris-9
1799 ! machines, using a several-thousand-jobs-mix of cpp, cc, cxx and smallish
1800 ! sub-shelled commands (rm, echo, sed...) for tests.
1801 ! lowering the 'direct influence' factor weight_a (e.g. to 0.1)
1802 ! resulted in significant excession of the load limit, raising it
1803 ! (e.g. to 0.5) took bad to small, fast-executing jobs and didn't
1804 ! reach the limit in most test cases.
1806 ! lowering the 'history influence' weight_b (e.g. to 0.1) resulted in
1807 ! exceeding the limit for longer-running stuff (compile jobs in
1808 ! the .5 to 1.5 sec. range),raising it (e.g. to 0.5) overrepresented
1809 ! small jobs' effects.
1813 #define LOAD_WEIGHT_A 0.25
1814 #define LOAD_WEIGHT_B 0.25
1817 load_too_high (void)
1819 #if defined(__MSDOS__) || defined(VMS) || defined(_AMIGA) || defined(__riscos__)
1822 static double last_sec
;
1823 static time_t last_now
;
1828 /* sub_proc.c cannot wait for more than MAXIMUM_WAIT_OBJECTS children */
1829 if (process_used_slots () >= MAXIMUM_WAIT_OBJECTS
)
1833 if (max_load_average
< 0)
1836 /* Find the real system load average. */
1838 if (getloadavg (&load
, 1) != 1)
1840 static int lossage
= -1;
1841 /* Complain only once for the same error. */
1842 if (lossage
== -1 || errno
!= lossage
)
1845 /* An errno value of zero means getloadavg is just unsupported. */
1847 _("cannot enforce load limits on this operating system"));
1849 perror_with_name (_("cannot enforce load limit: "), "getloadavg");
1856 /* If we're in a new second zero the counter and correct the backlog
1857 value. Only keep the backlog for one extra second; after that it's 0. */
1861 if (last_now
== now
- 1)
1862 last_sec
= LOAD_WEIGHT_B
* job_counter
;
1870 /* Try to guess what the load would be right now. */
1871 guess
= load
+ (LOAD_WEIGHT_A
* (job_counter
+ last_sec
));
1873 DB (DB_JOBS
, ("Estimated system load = %f (actual = %f) (max requested = %f)\n",
1874 guess
, load
, max_load_average
));
1876 return guess
>= max_load_average
;
1880 /* Start jobs that are waiting for the load to be lower. */
1883 start_waiting_jobs (void)
1887 if (waiting_jobs
== 0)
1892 /* Check for recently deceased descendants. */
1893 reap_children (0, 0);
1895 /* Take a job off the waiting list. */
1897 waiting_jobs
= job
->next
;
1899 /* Try to start that job. We break out of the loop as soon
1900 as start_waiting_job puts one back on the waiting list. */
1902 while (start_waiting_job (job
) && waiting_jobs
!= 0);
1909 /* EMX: Start a child process. This function returns the new pid. */
1910 # if defined __EMX__
1912 child_execute_job (int stdin_fd
, int stdout_fd
, char **argv
, char **envp
)
1915 /* stdin_fd == 0 means: nothing to do for stdin;
1916 stdout_fd == 1 means: nothing to do for stdout */
1917 int save_stdin
= (stdin_fd
!= 0) ? dup (0) : 0;
1918 int save_stdout
= (stdout_fd
!= 1) ? dup (1): 1;
1920 /* < 0 only if dup() failed */
1922 fatal (NILF
, _("no more file handles: could not duplicate stdin\n"));
1923 if (save_stdout
< 0)
1924 fatal (NILF
, _("no more file handles: could not duplicate stdout\n"));
1926 /* Close unnecessary file handles for the child. */
1927 if (save_stdin
!= 0)
1928 CLOSE_ON_EXEC (save_stdin
);
1929 if (save_stdout
!= 1)
1930 CLOSE_ON_EXEC (save_stdout
);
1932 /* Connect the pipes to the child process. */
1934 (void) dup2 (stdin_fd
, 0);
1936 (void) dup2 (stdout_fd
, 1);
1938 /* stdin_fd and stdout_fd must be closed on exit because we are
1939 still in the parent process */
1941 CLOSE_ON_EXEC (stdin_fd
);
1943 CLOSE_ON_EXEC (stdout_fd
);
1945 /* Run the command. */
1946 pid
= exec_command (argv
, envp
);
1948 /* Restore stdout/stdin of the parent and close temporary FDs. */
1951 if (dup2 (save_stdin
, 0) != 0)
1952 fatal (NILF
, _("Could not restore stdin\n"));
1959 if (dup2 (save_stdout
, 1) != 1)
1960 fatal (NILF
, _("Could not restore stdout\n"));
1962 close (save_stdout
);
1968 #elif !defined (_AMIGA) && !defined (__MSDOS__) && !defined (VMS)
1971 Replace the current process with one executing the command in ARGV.
1972 STDIN_FD and STDOUT_FD are used as the process's stdin and stdout; ENVP is
1973 the environment of the new program. This function does not return. */
1975 child_execute_job (int stdin_fd
, int stdout_fd
, char **argv
, char **envp
)
1978 (void) dup2 (stdin_fd
, 0);
1980 (void) dup2 (stdout_fd
, 1);
1982 (void) close (stdin_fd
);
1984 (void) close (stdout_fd
);
1986 /* Run the command. */
1987 exec_command (argv
, envp
);
1989 #endif /* !AMIGA && !__MSDOS__ && !VMS */
1990 #endif /* !WINDOWS32 */
1993 /* Replace the current process with one running the command in ARGV,
1994 with environment ENVP. This function does not return. */
1996 /* EMX: This function returns the pid of the child process. */
2002 exec_command (char **argv
, char **envp
)
2005 /* to work around a problem with signals and execve: ignore them */
2007 signal (SIGCHLD
,SIG_IGN
);
2009 /* Run the program. */
2010 execve (argv
[0], argv
, envp
);
2011 perror_with_name ("execve: ", argv
[0]);
2012 _exit (EXIT_FAILURE
);
2018 int exit_code
= EXIT_FAILURE
;
2020 /* make sure CreateProcess() has Path it needs */
2021 sync_Path_environment();
2023 /* launch command */
2024 hPID
= process_easy(argv
, envp
);
2026 /* make sure launch ok */
2027 if (hPID
== INVALID_HANDLE_VALUE
)
2031 _("process_easy() failed to launch process (e=%ld)\n"),
2032 process_last_err(hPID
));
2033 for (i
= 0; argv
[i
]; i
++)
2034 fprintf(stderr
, "%s ", argv
[i
]);
2035 fprintf(stderr
, _("\nCounted %d args in failed launch\n"), i
);
2039 /* wait and reap last child */
2040 hWaitPID
= process_wait_for_any();
2043 /* was an error found on this process? */
2044 err
= process_last_err(hWaitPID
);
2047 exit_code
= process_exit_code(hWaitPID
);
2050 fprintf(stderr
, "make (e=%d, rc=%d): %s",
2051 err
, exit_code
, map_windows32_error_to_string(err
));
2053 /* cleanup process */
2054 process_cleanup(hWaitPID
);
2056 /* expect to find only last pid, warn about other pids reaped */
2057 if (hWaitPID
== hPID
)
2061 _("make reaped child pid %ld, still waiting for pid %ld\n"),
2062 (DWORD
)hWaitPID
, (DWORD
)hPID
);
2065 /* return child's exit code as our exit code */
2068 #else /* !WINDOWS32 */
2074 /* Be the user, permanently. */
2079 /* Run the program. */
2080 pid
= spawnvpe (P_NOWAIT
, argv
[0], argv
, envp
);
2085 /* the file might have a strange shell extension */
2086 if (errno
== ENOENT
)
2091 /* Run the program. */
2093 execvp (argv
[0], argv
);
2095 # endif /* !__EMX__ */
2100 error (NILF
, _("%s: Command not found"), argv
[0]);
2104 /* The file is not executable. Try it as a shell script. */
2105 extern char *getenv ();
2112 /* Do not use $SHELL from the environment */
2113 struct variable
*p
= lookup_variable ("SHELL", 5);
2119 shell
= getenv ("SHELL");
2122 shell
= default_shell
;
2125 while (argv
[argc
] != 0)
2133 new_argv
= alloca ((1 + argc
+ 1) * sizeof (char *));
2134 new_argv
[0] = shell
;
2145 new_argv
[i
] = argv
[0];
2148 new_argv
[i
+ argc
] = argv
[argc
];
2153 pid
= spawnvpe (P_NOWAIT
, shell
, new_argv
, envp
);
2157 execvp (shell
, new_argv
);
2159 if (errno
== ENOENT
)
2160 error (NILF
, _("%s: Shell program not found"), shell
);
2162 perror_with_name ("execvp: ", shell
);
2168 /* this nasty error was driving me nuts :-( */
2169 error (NILF
, _("spawnvpe: environment space might be exhausted"));
2174 perror_with_name ("execvp: ", argv
[0]);
2183 #endif /* !WINDOWS32 */
2186 #else /* On Amiga */
2187 void exec_command (char **argv
)
2192 void clean_tmp (void)
2194 DeleteFile (amiga_bname
);
2197 #endif /* On Amiga */
2200 /* Figure out the argument list necessary to run LINE as a command. Try to
2201 avoid using a shell. This routine handles only ' quoting, and " quoting
2202 when no backslash, $ or ` characters are seen in the quotes. Starting
2203 quotes may be escaped with a backslash. If any of the characters in
2204 sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[]
2205 is the first word of a line, the shell is used.
2207 If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
2208 If *RESTP is NULL, newlines will be ignored.
2210 SHELL is the shell to use, or nil to use the default shell.
2211 IFS is the value of $IFS, or nil (meaning the default).
2213 FLAGS is the value of lines_flags for this command line. It is
2214 used in the WINDOWS32 port to check whether + or $(MAKE) were found
2215 in this command line, in which case the effect of just_print_flag
2219 construct_command_argv_internal (char *line
, char **restp
, char *shell
,
2220 char *ifs
, int flags
,
2221 char **batch_filename_ptr
)
2224 /* MSDOS supports both the stock DOS shell and ports of Unixy shells.
2225 We call `system' for anything that requires ``slow'' processing,
2226 because DOS shells are too dumb. When $SHELL points to a real
2227 (unix-style) shell, `system' just calls it to do everything. When
2228 $SHELL points to a DOS shell, `system' does most of the work
2229 internally, calling the shell only for its internal commands.
2230 However, it looks on the $PATH first, so you can e.g. have an
2231 external command named `mkdir'.
2233 Since we call `system', certain characters and commands below are
2234 actually not specific to COMMAND.COM, but to the DJGPP implementation
2235 of `system'. In particular:
2237 The shell wildcard characters are in DOS_CHARS because they will
2238 not be expanded if we call the child via `spawnXX'.
2240 The `;' is in DOS_CHARS, because our `system' knows how to run
2241 multiple commands on a single line.
2243 DOS_CHARS also include characters special to 4DOS/NDOS, so we
2244 won't have to tell one from another and have one more set of
2245 commands and special characters. */
2246 static char sh_chars_dos
[] = "*?[];|<>%^&()";
2247 static char *sh_cmds_dos
[] = { "break", "call", "cd", "chcp", "chdir", "cls",
2248 "copy", "ctty", "date", "del", "dir", "echo",
2249 "erase", "exit", "for", "goto", "if", "md",
2250 "mkdir", "path", "pause", "prompt", "rd",
2251 "rmdir", "rem", "ren", "rename", "set",
2252 "shift", "time", "type", "ver", "verify",
2255 static char sh_chars_sh
[] = "#;\"*?[]&|<>(){}$`^";
2256 static char *sh_cmds_sh
[] = { "cd", "echo", "eval", "exec", "exit", "login",
2257 "logout", "set", "umask", "wait", "while",
2258 "for", "case", "if", ":", ".", "break",
2259 "continue", "export", "read", "readonly",
2260 "shift", "times", "trap", "switch", "unset",
2265 #elif defined (__EMX__)
2266 static char sh_chars_dos
[] = "*?[];|<>%^&()";
2267 static char *sh_cmds_dos
[] = { "break", "call", "cd", "chcp", "chdir", "cls",
2268 "copy", "ctty", "date", "del", "dir", "echo",
2269 "erase", "exit", "for", "goto", "if", "md",
2270 "mkdir", "path", "pause", "prompt", "rd",
2271 "rmdir", "rem", "ren", "rename", "set",
2272 "shift", "time", "type", "ver", "verify",
2275 static char sh_chars_os2
[] = "*?[];|<>%^()\"'&";
2276 static char *sh_cmds_os2
[] = { "call", "cd", "chcp", "chdir", "cls", "copy",
2277 "date", "del", "detach", "dir", "echo",
2278 "endlocal", "erase", "exit", "for", "goto", "if",
2279 "keys", "md", "mkdir", "move", "path", "pause",
2280 "prompt", "rd", "rem", "ren", "rename", "rmdir",
2281 "set", "setlocal", "shift", "start", "time",
2282 "type", "ver", "verify", "vol", ":", 0 };
2284 static char sh_chars_sh
[] = "#;\"*?[]&|<>(){}$`^~'";
2285 static char *sh_cmds_sh
[] = { "echo", "cd", "eval", "exec", "exit", "login",
2286 "logout", "set", "umask", "wait", "while",
2287 "for", "case", "if", ":", ".", "break",
2288 "continue", "export", "read", "readonly",
2289 "shift", "times", "trap", "switch", "unset",
2294 #elif defined (_AMIGA)
2295 static char sh_chars
[] = "#;\"|<>()?*$`";
2296 static char *sh_cmds
[] = { "cd", "eval", "if", "delete", "echo", "copy",
2297 "rename", "set", "setenv", "date", "makedir",
2298 "skip", "else", "endif", "path", "prompt",
2299 "unset", "unsetenv", "version",
2301 #elif defined (WINDOWS32)
2302 static char sh_chars_dos
[] = "\"|&<>";
2303 static char *sh_cmds_dos
[] = { "break", "call", "cd", "chcp", "chdir", "cls",
2304 "copy", "ctty", "date", "del", "dir", "echo",
2305 "erase", "exit", "for", "goto", "if", "if", "md",
2306 "mkdir", "path", "pause", "prompt", "rd", "rem",
2307 "ren", "rename", "rmdir", "set", "shift", "time",
2308 "type", "ver", "verify", "vol", ":", 0 };
2309 static char sh_chars_sh
[] = "#;\"*?[]&|<>(){}$`^";
2310 static char *sh_cmds_sh
[] = { "cd", "eval", "exec", "exit", "login",
2311 "logout", "set", "umask", "wait", "while", "for",
2312 "case", "if", ":", ".", "break", "continue",
2313 "export", "read", "readonly", "shift", "times",
2314 "trap", "switch", "test",
2315 #ifdef BATCH_MODE_ONLY_SHELL
2321 #elif defined(__riscos__)
2322 static char sh_chars
[] = "";
2323 static char *sh_cmds
[] = { 0 };
2324 #else /* must be UNIX-ish */
2325 static char sh_chars
[] = "#;\"*?[]&|<>(){}$`^~!";
2326 static char *sh_cmds
[] = { ".", ":", "break", "case", "cd", "continue",
2327 "eval", "exec", "exit", "export", "for", "if",
2328 "login", "logout", "read", "readonly", "set",
2329 "shift", "switch", "test", "times", "trap",
2330 "umask", "wait", "while", 0 };
2331 # ifdef HAVE_DOS_PATHS
2332 /* This is required if the MSYS/Cygwin ports (which do not define
2333 WINDOWS32) are compiled with HAVE_DOS_PATHS defined, which uses
2334 sh_chars_sh[] directly (see below). */
2335 static char *sh_chars_sh
= sh_chars
;
2336 # endif /* HAVE_DOS_PATHS */
2342 int instring
, word_has_equals
, seen_nonequals
, last_argument_was_empty
;
2343 char **new_argv
= 0;
2349 sh_cmds
= sh_cmds_dos
;
2350 sh_chars
= sh_chars_dos
;
2352 sh_cmds
= sh_cmds_sh
;
2353 sh_chars
= sh_chars_sh
;
2355 #endif /* WINDOWS32 */
2360 /* Make sure not to bother processing an empty line. */
2361 while (isblank ((unsigned char)*line
))
2366 /* See if it is safe to parse commands internally. */
2368 shell
= default_shell
;
2370 else if (strcmp (shell
, default_shell
))
2372 char *s1
= _fullpath (NULL
, shell
, 0);
2373 char *s2
= _fullpath (NULL
, default_shell
, 0);
2375 slow_flag
= strcmp ((s1
? s1
: ""), (s2
? s2
: ""));
2384 #else /* not WINDOWS32 */
2385 #if defined (__MSDOS__) || defined (__EMX__)
2386 else if (strcasecmp (shell
, default_shell
))
2388 extern int _is_unixy_shell (const char *_path
);
2390 DB (DB_BASIC
, (_("$SHELL changed (was `%s', now `%s')\n"),
2391 default_shell
, shell
));
2392 unixy_shell
= _is_unixy_shell (shell
);
2393 /* we must allocate a copy of shell: construct_command_argv() will free
2394 * shell after this function returns. */
2395 default_shell
= xstrdup (shell
);
2399 sh_chars
= sh_chars_sh
;
2400 sh_cmds
= sh_cmds_sh
;
2404 sh_chars
= sh_chars_dos
;
2405 sh_cmds
= sh_cmds_dos
;
2407 if (_osmode
== OS2_MODE
)
2409 sh_chars
= sh_chars_os2
;
2410 sh_cmds
= sh_cmds_os2
;
2414 #else /* !__MSDOS__ */
2415 else if (strcmp (shell
, default_shell
))
2417 #endif /* !__MSDOS__ && !__EMX__ */
2418 #endif /* not WINDOWS32 */
2421 for (ap
= ifs
; *ap
!= '\0'; ++ap
)
2422 if (*ap
!= ' ' && *ap
!= '\t' && *ap
!= '\n')
2425 i
= strlen (line
) + 1;
2427 /* More than 1 arg per character is impossible. */
2428 new_argv
= xmalloc (i
* sizeof (char *));
2430 /* All the args can fit in a buffer as big as LINE is. */
2431 ap
= new_argv
[0] = argstr
= xmalloc (i
);
2434 /* I is how many complete arguments have been found. */
2436 instring
= word_has_equals
= seen_nonequals
= last_argument_was_empty
= 0;
2437 for (p
= line
; *p
!= '\0'; ++p
)
2443 /* Inside a string, just copy any char except a closing quote
2444 or a backslash-newline combination. */
2448 if (ap
== new_argv
[0] || *(ap
-1) == '\0')
2449 last_argument_was_empty
= 1;
2451 else if (*p
== '\\' && p
[1] == '\n')
2453 /* Backslash-newline is handled differently depending on what
2454 kind of string we're in: inside single-quoted strings you
2455 keep them; in double-quoted strings they disappear.
2456 For DOS/Windows/OS2, if we don't have a POSIX shell,
2457 we keep the pre-POSIX behavior of removing the
2458 backslash-newline. */
2460 #if defined (__MSDOS__) || defined (__EMX__) || defined (WINDOWS32)
2471 else if (*p
== '\n' && restp
!= NULL
)
2473 /* End of the command line. */
2477 /* Backslash, $, and ` are special inside double quotes.
2478 If we see any of those, punt.
2479 But on MSDOS, if we use COMMAND.COM, double and single
2480 quotes have the same effect. */
2481 else if (instring
== '"' && strchr ("\\$`", *p
) != 0 && unixy_shell
)
2486 else if (strchr (sh_chars
, *p
) != 0)
2487 /* Not inside a string, but it's a special char. */
2490 else if (*p
== '.' && p
[1] == '.' && p
[2] == '.' && p
[3] != '.')
2491 /* `...' is a wildcard in DJGPP. */
2495 /* Not a special char. */
2499 /* Equals is a special character in leading words before the
2500 first word with no equals sign in it. This is not the case
2501 with sh -k, but we never get here when using nonstandard
2503 if (! seen_nonequals
&& unixy_shell
)
2505 word_has_equals
= 1;
2510 /* Backslash-newline has special case handling, ref POSIX.
2511 We're in the fastpath, so emulate what the shell would do. */
2514 /* Throw out the backslash and newline. */
2517 /* If there's nothing in this argument yet, skip any
2518 whitespace before the start of the next word. */
2519 if (ap
== new_argv
[i
])
2520 p
= next_token (p
+ 1) - 1;
2522 else if (p
[1] != '\0')
2524 #ifdef HAVE_DOS_PATHS
2525 /* Only remove backslashes before characters special to Unixy
2526 shells. All other backslashes are copied verbatim, since
2527 they are probably DOS-style directory separators. This
2528 still leaves a small window for problems, but at least it
2529 should work for the vast majority of naive users. */
2532 /* A dot is only special as part of the "..."
2534 if (strneq (p
+ 1, ".\\.\\.", 5))
2542 if (p
[1] != '\\' && p
[1] != '\''
2543 && !isspace ((unsigned char)p
[1])
2544 && strchr (sh_chars_sh
, p
[1]) == 0)
2545 /* back up one notch, to copy the backslash */
2547 #endif /* HAVE_DOS_PATHS */
2549 /* Copy and skip the following char. */
2562 /* End of the command line. */
2567 /* Newlines are not special. */
2573 /* We have the end of an argument.
2574 Terminate the text of the argument. */
2577 last_argument_was_empty
= 0;
2579 /* Update SEEN_NONEQUALS, which tells us if every word
2580 heretofore has contained an `='. */
2581 seen_nonequals
|= ! word_has_equals
;
2582 if (word_has_equals
&& ! seen_nonequals
)
2583 /* An `=' in a word before the first
2584 word without one is magical. */
2586 word_has_equals
= 0; /* Prepare for the next word. */
2588 /* If this argument is the command name,
2589 see if it is a built-in shell command.
2590 If so, have the shell handle it. */
2594 for (j
= 0; sh_cmds
[j
] != 0; ++j
)
2596 if (streq (sh_cmds
[j
], new_argv
[0]))
2599 /* Non-Unix shells are case insensitive. */
2601 && strcasecmp (sh_cmds
[j
], new_argv
[0]) == 0)
2607 /* Ignore multiple whitespace chars. */
2608 p
= next_token (p
) - 1;
2619 /* Let the shell deal with an unterminated quote. */
2622 /* Terminate the last argument and the argument list. */
2625 if (new_argv
[i
][0] != '\0' || last_argument_was_empty
)
2632 for (j
= 0; sh_cmds
[j
] != 0; ++j
)
2633 if (streq (sh_cmds
[j
], new_argv
[0]))
2637 if (new_argv
[0] == 0)
2639 /* Line was empty. */
2648 /* We must use the shell. */
2652 /* Free the old argument list we were working on. */
2658 execute_by_shell
= 1; /* actually, call `system' if shell isn't unixy */
2667 buffer
= xmalloc (strlen (line
)+1);
2670 for (dptr
=buffer
; *ptr
; )
2672 if (*ptr
== '\\' && ptr
[1] == '\n')
2674 else if (*ptr
== '@') /* Kludge: multiline commands */
2684 new_argv
= xmalloc (2 * sizeof (char *));
2685 new_argv
[0] = buffer
;
2688 #else /* Not Amiga */
2691 * Not eating this whitespace caused things like
2695 * which gave the shell fits. I think we have to eat
2696 * whitespace here, but this code should be considered
2697 * suspicious if things start failing....
2700 /* Make sure not to bother processing an empty line. */
2701 while (isspace ((unsigned char)*line
))
2705 #endif /* WINDOWS32 */
2707 /* SHELL may be a multi-word command. Construct a command line
2708 "SHELL -c LINE", with all special chars in LINE escaped.
2709 Then recurse, expanding this command line to get the final
2712 unsigned int shell_len
= strlen (shell
);
2714 static char minus_c
[] = " -c ";
2716 static char minus_c
[] = "";
2718 unsigned int line_len
= strlen (line
);
2720 char *new_line
= alloca (shell_len
+ (sizeof (minus_c
)-1)
2721 + (line_len
*2) + 1);
2722 char *command_ptr
= NULL
; /* used for batch_mode_shell mode */
2724 # ifdef __EMX__ /* is this necessary? */
2726 minus_c
[1] = '/'; /* " /c " */
2730 memcpy (ap
, shell
, shell_len
);
2732 memcpy (ap
, minus_c
, sizeof (minus_c
) - 1);
2733 ap
+= sizeof (minus_c
) - 1;
2735 for (p
= line
; *p
!= '\0'; ++p
)
2737 if (restp
!= NULL
&& *p
== '\n')
2742 else if (*p
== '\\' && p
[1] == '\n')
2744 /* POSIX says we keep the backslash-newline. If we don't have a
2745 POSIX shell on DOS/Windows/OS2, mimic the pre-POSIX behavior
2746 and remove the backslash/newline. */
2747 #if defined (__MSDOS__) || defined (__EMX__) || defined (WINDOWS32)
2748 # define PRESERVE_BSNL unixy_shell
2750 # define PRESERVE_BSNL 1
2755 /* Only non-batch execution needs another backslash,
2756 because it will be passed through a recursive
2757 invocation of this function. */
2758 if (!batch_mode_shell
)
2766 /* DOS shells don't know about backslash-escaping. */
2767 if (unixy_shell
&& !batch_mode_shell
&&
2768 (*p
== '\\' || *p
== '\'' || *p
== '"'
2769 || isspace ((unsigned char)*p
)
2770 || strchr (sh_chars
, *p
) != 0))
2773 else if (unixy_shell
&& strneq (p
, "...", 3))
2775 /* The case of `...' wildcard again. */
2776 strcpy (ap
, "\\.\\.\\");
2783 if (ap
== new_line
+ shell_len
+ sizeof (minus_c
) - 1)
2784 /* Line was empty. */
2789 /* Some shells do not work well when invoked as 'sh -c xxx' to run a
2790 command line (e.g. Cygnus GNUWIN32 sh.exe on WIN32 systems). In these
2791 cases, run commands via a script file. */
2792 if (just_print_flag
&& !(flags
& COMMANDS_RECURSE
)) {
2793 /* Need to allocate new_argv, although it's unused, because
2794 start_job_command will want to free it and its 0'th element. */
2795 new_argv
= xmalloc(2 * sizeof (char *));
2796 new_argv
[0] = xstrdup ("");
2798 } else if ((no_default_sh_exe
|| batch_mode_shell
) && batch_filename_ptr
) {
2801 int id
= GetCurrentProcessId();
2804 /* create a file name */
2805 sprintf(fbuf
, "make%d", id
);
2806 *batch_filename_ptr
= create_batch_file (fbuf
, unixy_shell
, &temp_fd
);
2808 DB (DB_JOBS
, (_("Creating temporary batch file %s\n"),
2809 *batch_filename_ptr
));
2811 /* Create a FILE object for the batch file, and write to it the
2812 commands to be executed. Put the batch file in TEXT mode. */
2813 _setmode (temp_fd
, _O_TEXT
);
2814 batch
= _fdopen (temp_fd
, "wt");
2816 fputs ("@echo off\n", batch
);
2817 fputs (command_ptr
, batch
);
2818 fputc ('\n', batch
);
2820 DB (DB_JOBS
, (_("Batch file contents:%s\n\t%s\n"),
2821 !unixy_shell
? "\n\t@echo off" : "", command_ptr
));
2824 new_argv
= xmalloc(3 * sizeof (char *));
2826 new_argv
[0] = xstrdup (shell
);
2827 new_argv
[1] = *batch_filename_ptr
; /* only argv[0] gets freed later */
2829 new_argv
[0] = xstrdup (*batch_filename_ptr
);
2834 #endif /* WINDOWS32 */
2836 new_argv
= construct_command_argv_internal (new_line
, 0, 0, 0, flags
, 0);
2838 else if (!unixy_shell
)
2840 /* new_line is local, must not be freed therefore
2841 We use line here instead of new_line because we run the shell
2843 size_t line_len
= strlen (line
);
2846 memcpy (new_line
, line
, line_len
+ 1);
2847 /* replace all backslash-newline combination and also following tabs */
2850 if (q
[0] == '\\' && q
[1] == '\n')
2851 q
+= 2; /* remove '\\' and '\n' */
2857 # ifndef NO_CMD_DEFAULT
2858 if (strnicmp (new_line
, "echo", 4) == 0
2859 && (new_line
[4] == ' ' || new_line
[4] == '\t'))
2861 /* the builtin echo command: handle it separately */
2862 size_t echo_len
= line_len
- 5;
2863 char *echo_line
= new_line
+ 5;
2865 /* special case: echo 'x="y"'
2866 cmd works this way: a string is printed as is, i.e., no quotes
2867 are removed. But autoconf uses a command like echo 'x="y"' to
2868 determine whether make works. autoconf expects the output x="y"
2869 so we will do exactly that.
2870 Note: if we do not allow cmd to be the default shell
2871 we do not need this kind of voodoo */
2872 if (echo_line
[0] == '\''
2873 && echo_line
[echo_len
- 1] == '\''
2874 && strncmp (echo_line
+ 1, "ac_maketemp=",
2875 strlen ("ac_maketemp=")) == 0)
2877 /* remove the enclosing quotes */
2878 memmove (echo_line
, echo_line
+ 1, echo_len
- 2);
2879 echo_line
[echo_len
- 2] = '\0';
2885 /* Let the shell decide what to do. Put the command line into the
2886 2nd command line argument and hope for the best ;-) */
2887 size_t sh_len
= strlen (shell
);
2889 /* exactly 3 arguments + NULL */
2890 new_argv
= xmalloc (4 * sizeof (char *));
2891 /* Exactly strlen(shell) + strlen("/c") + strlen(line) + 3 times
2892 the trailing '\0' */
2893 new_argv
[0] = xmalloc (sh_len
+ line_len
+ 5);
2894 memcpy (new_argv
[0], shell
, sh_len
+ 1);
2895 new_argv
[1] = new_argv
[0] + sh_len
+ 1;
2896 memcpy (new_argv
[1], "/c", 3);
2897 new_argv
[2] = new_argv
[1] + 3;
2898 memcpy (new_argv
[2], new_line
, line_len
+ 1);
2902 #elif defined(__MSDOS__)
2905 /* With MSDOS shells, we must construct the command line here
2906 instead of recursively calling ourselves, because we
2907 cannot backslash-escape the special characters (see above). */
2908 new_argv
= xmalloc (sizeof (char *));
2909 line_len
= strlen (new_line
) - shell_len
- sizeof (minus_c
) + 1;
2910 new_argv
[0] = xmalloc (line_len
+ 1);
2911 strncpy (new_argv
[0],
2912 new_line
+ shell_len
+ sizeof (minus_c
) - 1, line_len
);
2913 new_argv
[0][line_len
] = '\0';
2917 fatal (NILF
, _("%s (line %d) Bad shell context (!unixy && !batch_mode_shell)\n"),
2918 __FILE__
, __LINE__
);
2921 #endif /* ! AMIGA */
2927 /* Figure out the argument list necessary to run LINE as a command. Try to
2928 avoid using a shell. This routine handles only ' quoting, and " quoting
2929 when no backslash, $ or ` characters are seen in the quotes. Starting
2930 quotes may be escaped with a backslash. If any of the characters in
2931 sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[]
2932 is the first word of a line, the shell is used.
2934 If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
2935 If *RESTP is NULL, newlines will be ignored.
2937 FILE is the target whose commands these are. It is used for
2938 variable expansion for $(SHELL) and $(IFS). */
2941 construct_command_argv (char *line
, char **restp
, struct file
*file
,
2942 int cmd_flags
, char **batch_filename_ptr
)
2956 && (isspace ((unsigned char)*cptr
)))
2961 && (!isspace((unsigned char)*cptr
)))
2966 argv
= xmalloc (argc
* sizeof (char *));
2975 && (isspace ((unsigned char)*cptr
)))
2979 DB (DB_JOBS
, ("argv[%d] = [%s]\n", argc
, cptr
));
2980 argv
[argc
++] = cptr
;
2982 && (!isspace((unsigned char)*cptr
)))
2989 /* Turn off --warn-undefined-variables while we expand SHELL and IFS. */
2990 int save
= warn_undefined_variables_flag
;
2991 warn_undefined_variables_flag
= 0;
2993 shell
= allocated_variable_expand_for_file ("$(SHELL)", file
);
2996 * Convert to forward slashes so that construct_command_argv_internal()
3000 char *p
= w32ify (shell
, 0);
3006 static const char *unixroot
= NULL
;
3007 static const char *last_shell
= "";
3008 static int init
= 0;
3011 unixroot
= getenv ("UNIXROOT");
3012 /* unixroot must be NULL or not empty */
3013 if (unixroot
&& unixroot
[0] == '\0') unixroot
= NULL
;
3017 /* if we have an unixroot drive and if shell is not default_shell
3018 (which means it's either cmd.exe or the test has already been
3019 performed) and if shell is an absolute path without drive letter,
3020 try whether it exists e.g.: if "/bin/sh" does not exist use
3021 "$UNIXROOT/bin/sh" instead. */
3022 if (unixroot
&& shell
&& strcmp (shell
, last_shell
) != 0
3023 && (shell
[0] == '/' || shell
[0] == '\\'))
3025 /* trying a new shell, check whether it exists */
3026 size_t size
= strlen (shell
);
3027 char *buf
= xmalloc (size
+ 7);
3028 memcpy (buf
, shell
, size
);
3029 memcpy (buf
+ size
, ".exe", 5); /* including the trailing '\0' */
3030 if (access (shell
, F_OK
) != 0 && access (buf
, F_OK
) != 0)
3032 /* try the same for the unixroot drive */
3033 memmove (buf
+ 2, buf
, size
+ 5);
3034 buf
[0] = unixroot
[0];
3035 buf
[1] = unixroot
[1];
3036 if (access (buf
, F_OK
) == 0)
3037 /* we have found a shell! */
3047 #endif /* __EMX__ */
3049 ifs
= allocated_variable_expand_for_file ("$(IFS)", file
);
3051 warn_undefined_variables_flag
= save
;
3054 argv
= construct_command_argv_internal (line
, restp
, shell
, ifs
,
3055 cmd_flags
, batch_filename_ptr
);
3063 #if !defined(HAVE_DUP2) && !defined(_AMIGA)
3065 dup2 (int old
, int new)
3080 #endif /* !HAPE_DUP2 && !_AMIGA */
3082 /* On VMS systems, include special VMS functions. */
3085 #include "vmsjobs.c"