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, 2008, 2009,
4 2010 Free Software Foundation, Inc.
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 #if !defined(HAVE_UNISTD_H) && !defined(WINDOWS32)
189 /* Different systems have different requirements for pid_t.
190 Plus we have to support gettext string translation... Argh. */
194 static char pidstring
[100];
195 #if defined(WINDOWS32) && (__GNUC__ > 3 || _MSC_VER > 1300)
196 /* %Id is only needed for 64-builds, which were not supported by
197 older versions of Windows compilers. */
198 sprintf (pidstring
, "%Id", pid
);
200 sprintf (pidstring
, "%lu", (unsigned long) pid
);
205 int getloadavg (double loadavg
[], int nelem
);
206 int start_remote_job (char **argv
, char **envp
, int stdin_fd
, int *is_remote
,
207 int *id_ptr
, int *used_stdin
);
208 int start_remote_job_p (int);
209 int remote_status (int *exit_code_ptr
, int *signal_ptr
, int *coredump_ptr
,
212 RETSIGTYPE
child_handler (int);
213 static void free_child (struct child
*);
214 static void start_job_command (struct child
*child
);
215 static int load_too_high (void);
216 static int job_next_command (struct child
*);
217 static int start_waiting_job (struct child
*);
219 /* Chain of all live (or recently deceased) children. */
221 struct child
*children
= 0;
223 /* Number of children currently running. */
225 unsigned int job_slots_used
= 0;
227 /* Nonzero if the `good' standard input is in use. */
229 static int good_stdin_used
= 0;
231 /* Chain of children waiting to run until the load average goes down. */
233 static struct child
*waiting_jobs
= 0;
235 /* Non-zero if we use a *real* shell (always so on Unix). */
239 /* Number of jobs started in the current second. */
241 unsigned long job_counter
= 0;
243 /* Number of jobserver tokens this instance is currently using. */
245 unsigned int jobserver_tokens
= 0;
249 * The macro which references this function is defined in make.h.
252 w32_kill(pid_t pid
, int sig
)
254 return ((process_kill((HANDLE
)pid
, sig
) == TRUE
) ? 0 : -1);
257 /* This function creates a temporary file name with an extension specified
259 * Return an xmalloc'ed string of a newly created temp file and its
260 * file descriptor, or die. */
262 create_batch_file (char const *base
, int unixy
, int *fd
)
264 const char *const ext
= unixy
? "sh" : "bat";
265 const char *error_string
= NULL
;
266 char temp_path
[MAXPATHLEN
]; /* need to know its length */
267 unsigned path_size
= GetTempPath(sizeof temp_path
, temp_path
);
270 const unsigned sizemax
= strlen (base
) + strlen (ext
) + 10;
274 path_size
= GetCurrentDirectory (sizeof temp_path
, temp_path
);
278 while (path_size
> 0 &&
279 path_size
+ sizemax
< sizeof temp_path
&&
282 unsigned size
= sprintf (temp_path
+ path_size
,
284 temp_path
[path_size
- 1] == '\\' ? "" : "\\",
286 HANDLE h
= CreateFile (temp_path
, /* file name */
287 GENERIC_READ
| GENERIC_WRITE
, /* desired access */
288 0, /* no share mode */
289 NULL
, /* default security attributes */
290 CREATE_NEW
, /* creation disposition */
291 FILE_ATTRIBUTE_NORMAL
| /* flags and attributes */
292 FILE_ATTRIBUTE_TEMPORARY
, /* we'll delete it */
293 NULL
); /* no template file */
295 if (h
== INVALID_HANDLE_VALUE
)
297 const DWORD er
= GetLastError();
299 if (er
== ERROR_FILE_EXISTS
|| er
== ERROR_ALREADY_EXISTS
)
302 /* the temporary path is not guaranteed to exist */
303 else if (path_is_dot
== 0)
305 path_size
= GetCurrentDirectory (sizeof temp_path
, temp_path
);
311 error_string
= map_windows32_error_to_string (er
);
317 const unsigned final_size
= path_size
+ size
+ 1;
318 char *const path
= xmalloc (final_size
);
319 memcpy (path
, temp_path
, final_size
);
320 *fd
= _open_osfhandle ((intptr_t)h
, 0);
325 for (p
= path
; (ch
= *p
) != 0; ++p
)
329 return path
; /* good return */
334 if (error_string
== NULL
)
335 error_string
= _("Cannot create a temporary file\n");
336 fatal (NILF
, error_string
);
341 #endif /* WINDOWS32 */
344 /* returns whether path is assumed to be a unix like shell. */
346 _is_unixy_shell (const char *path
)
348 /* list of non unix shells */
349 const char *known_os2shells
[] = {
361 /* find the rightmost '/' or '\\' */
362 const char *name
= strrchr (path
, '/');
363 const char *p
= strrchr (path
, '\\');
366 if (name
&& p
) /* take the max */
367 name
= (name
> p
) ? name
: p
;
368 else if (p
) /* name must be 0 */
370 else if (!name
) /* name and p must be 0 */
373 if (*name
== '/' || *name
== '\\') name
++;
376 while (known_os2shells
[i
] != NULL
) {
377 if (strcasecmp (name
, known_os2shells
[i
]) == 0)
378 return 0; /* not a unix shell */
382 /* in doubt assume a unix like shell */
387 /* determines whether path looks to be a Bourne-like shell. */
389 is_bourne_compatible_shell (const char *path
)
391 /* list of known unix (Bourne-like) shells */
392 const char *unix_shells
[] = {
404 /* find the rightmost '/' or '\\' */
405 const char *name
= strrchr (path
, '/');
406 char *p
= strrchr (path
, '\\');
408 if (name
&& p
) /* take the max */
409 name
= (name
> p
) ? name
: p
;
410 else if (p
) /* name must be 0 */
412 else if (!name
) /* name and p must be 0 */
415 if (*name
== '/' || *name
== '\\') name
++;
417 /* this should be able to deal with extensions on Windows-like systems */
418 for (i
= 0; unix_shells
[i
] != NULL
; i
++) {
419 len
= strlen(unix_shells
[i
]);
420 #if defined(WINDOWS32) || defined(__MSDOS__)
421 if ((strncasecmp (name
, unix_shells
[i
], len
) == 0) &&
422 (strlen(name
) >= len
&& (name
[len
] == '\0' || name
[len
] == '.')))
424 if ((strncmp (name
, unix_shells
[i
], len
) == 0) &&
425 (strlen(name
) >= len
&& name
[len
] == '\0'))
427 return 1; /* a known unix-style shell */
430 /* if not on the list, assume it's not a Bourne-like shell */
435 /* Write an error message describing the exit status given in
436 EXIT_CODE, EXIT_SIG, and COREDUMP, for the target TARGET_NAME.
437 Append "(ignored)" if IGNORED is nonzero. */
440 child_error (const char *target_name
,
441 int exit_code
, int exit_sig
, int coredump
, int ignored
)
443 if (ignored
&& silent_flag
)
447 if (!(exit_code
& 1))
449 (ignored
? _("*** [%s] Error 0x%x (ignored)")
450 : _("*** [%s] Error 0x%x")),
451 target_name
, exit_code
);
454 error (NILF
, ignored
? _("[%s] Error %d (ignored)") :
455 _("*** [%s] Error %d"),
456 target_name
, exit_code
);
458 error (NILF
, "*** [%s] %s%s",
459 target_name
, strsignal (exit_sig
),
460 coredump
? _(" (core dumped)") : "");
465 /* Handle a dead child. This handler may or may not ever be installed.
467 If we're using the jobserver feature, we need it. First, installing it
468 ensures the read will interrupt on SIGCHLD. Second, we close the dup'd
469 read FD to ensure we don't enter another blocking read without reaping all
470 the dead children. In this case we don't need the dead_children count.
472 If we don't have either waitpid or wait3, then make is unreliable, but we
473 use the dead_children count to reap children as best we can. */
475 static unsigned int dead_children
= 0;
478 child_handler (int sig UNUSED
)
489 /* The signal handler must called only once! */
490 signal (SIGCHLD
, SIG_DFL
);
493 /* This causes problems if the SIGCHLD interrupts a printf().
494 DB (DB_JOBS, (_("Got a SIGCHLD; %u unreaped children.\n"), dead_children));
498 extern int shell_function_pid
, shell_function_completed
;
500 /* Reap all dead children, storing the returned status and the new command
501 state (`cs_finished') in the `file' member of the `struct child' for the
502 dead child, and removing the child from the chain. In addition, if BLOCK
503 nonzero, we block in this function until we've reaped at least one
504 complete child, waiting for it to die if necessary. If ERR is nonzero,
505 print an error message first. */
508 reap_children (int block
, int err
)
512 /* Initially, assume we have some. */
517 # define REAP_MORE reap_more
519 # define REAP_MORE dead_children
524 We have at least one child outstanding OR a shell function in progress,
526 We're blocking for a complete child OR there are more children to reap
528 we'll keep reaping children. */
530 while ((children
!= 0 || shell_function_pid
!= 0)
531 && (block
|| REAP_MORE
))
535 int exit_code
, exit_sig
, coredump
;
536 register struct child
*lastc
, *c
;
538 int any_remote
, any_local
;
543 static int printed
= 0;
545 /* We might block for a while, so let the user know why.
546 Only print this message once no matter how many jobs are left. */
549 error (NILF
, _("*** Waiting for unfinished jobs...."));
553 /* We have one less dead child to reap. As noted in
554 child_handler() above, this count is completely unimportant for
555 all modern, POSIX-y systems that support wait3() or waitpid().
556 The rest of this comment below applies only to early, broken
557 pre-POSIX systems. We keep the count only because... it's there...
559 The test and decrement are not atomic; if it is compiled into:
560 register = dead_children - 1;
561 dead_children = register;
562 a SIGCHLD could come between the two instructions.
563 child_handler increments dead_children.
564 The second instruction here would lose that increment. But the
565 only effect of dead_children being wrong is that we might wait
566 longer than necessary to reap a child, and lose some parallelism;
567 and we might print the "Waiting for unfinished jobs" message above
568 when not necessary. */
570 if (dead_children
> 0)
574 any_local
= shell_function_pid
!= 0;
575 for (c
= children
; c
!= 0; c
= c
->next
)
577 any_remote
|= c
->remote
;
578 any_local
|= ! c
->remote
;
579 DB (DB_JOBS
, (_("Live child %p (%s) PID %s %s\n"),
580 c
, c
->file
->name
, pid2str (c
->pid
),
581 c
->remote
? _(" (remote)") : ""));
587 /* First, check for remote children. */
589 pid
= remote_status (&exit_code
, &exit_sig
, &coredump
, 0);
594 /* We got a remote child. */
598 /* A remote status command failed miserably. Punt. */
600 pfatal_with_name ("remote_status");
604 /* No remote children. Check for local children. */
605 #if !defined(__MSDOS__) && !defined(_AMIGA) && !defined(WINDOWS32)
609 vmsWaitForChildren (&status
);
614 pid
= WAIT_NOHANG (&status
);
617 EINTRLOOP(pid
, wait (&status
));
625 /* The wait*() failed miserably. Punt. */
626 pfatal_with_name ("wait");
630 /* We got a child exit; chop the status word up. */
631 exit_code
= WEXITSTATUS (status
);
632 exit_sig
= WIFSIGNALED (status
) ? WTERMSIG (status
) : 0;
633 coredump
= WCOREDUMP (status
);
635 /* If we have started jobs in this second, remove one. */
641 /* No local children are dead. */
644 if (!block
|| !any_remote
)
647 /* Now try a blocking wait for a remote child. */
648 pid
= remote_status (&exit_code
, &exit_sig
, &coredump
, 1);
650 goto remote_status_lose
;
652 /* No remote children either. Finally give up. */
655 /* We got a remote child. */
658 #endif /* !__MSDOS__, !Amiga, !WINDOWS32. */
661 /* Life is very different on MSDOS. */
664 exit_code
= WEXITSTATUS (status
);
665 if (exit_code
== 0xff)
667 exit_sig
= WIFSIGNALED (status
) ? WTERMSIG (status
) : 0;
669 #endif /* __MSDOS__ */
673 status
= amiga_status
;
674 exit_code
= amiga_status
;
687 /* Record the thread ID of the main process, so that we
688 could suspend it in the signal handler. */
691 hcTID
= GetCurrentThread ();
692 hcPID
= GetCurrentProcess ();
693 if (!DuplicateHandle (hcPID
, hcTID
, hcPID
, &main_thread
, 0,
694 FALSE
, DUPLICATE_SAME_ACCESS
))
696 DWORD e
= GetLastError ();
698 "Determine main thread ID (Error %ld: %s)\n",
699 e
, map_windows32_error_to_string(e
));
702 DB (DB_VERBOSE
, ("Main thread handle = %p\n", main_thread
));
705 /* wait for anything to finish */
706 hPID
= process_wait_for_any();
710 /* was an error found on this process? */
711 werr
= process_last_err(hPID
);
714 exit_code
= process_exit_code(hPID
);
717 fprintf(stderr
, "make (e=%d): %s",
718 exit_code
, map_windows32_error_to_string(exit_code
));
721 exit_sig
= process_signal(hPID
);
723 /* cleanup process */
724 process_cleanup(hPID
);
730 #endif /* WINDOWS32 */
733 /* Check if this is the child of the `shell' function. */
734 if (!remote
&& pid
== shell_function_pid
)
736 /* It is. Leave an indicator for the `shell' function. */
737 if (exit_sig
== 0 && exit_code
== 127)
738 shell_function_completed
= -1;
740 shell_function_completed
= 1;
744 child_failed
= exit_sig
!= 0 || exit_code
!= 0;
746 /* Search for a child matching the deceased one. */
748 for (c
= children
; c
!= 0; lastc
= c
, c
= c
->next
)
749 if (c
->remote
== remote
&& c
->pid
== pid
)
753 /* An unknown child died.
754 Ignore it; it was inherited from our invoker. */
757 DB (DB_JOBS
, (child_failed
758 ? _("Reaping losing child %p PID %s %s\n")
759 : _("Reaping winning child %p PID %s %s\n"),
760 c
, pid2str (c
->pid
), c
->remote
? _(" (remote)") : ""));
762 if (c
->sh_batch_file
) {
763 DB (DB_JOBS
, (_("Cleaning up temp batch file %s\n"),
766 /* just try and remove, don't care if this fails */
767 remove (c
->sh_batch_file
);
769 /* all done with memory */
770 free (c
->sh_batch_file
);
771 c
->sh_batch_file
= NULL
;
774 /* If this child had the good stdin, say it is now free. */
778 dontcare
= c
->dontcare
;
780 if (child_failed
&& !c
->noerror
&& !ignore_errors_flag
)
782 /* The commands failed. Write an error message,
783 delete non-precious targets, and abort. */
784 static int delete_on_error
= -1;
787 child_error (c
->file
->name
, exit_code
, exit_sig
, coredump
, 0);
789 c
->file
->update_status
= 2;
790 if (delete_on_error
== -1)
792 struct file
*f
= lookup_file (".DELETE_ON_ERROR");
793 delete_on_error
= f
!= 0 && f
->is_target
;
795 if (exit_sig
!= 0 || delete_on_error
)
796 delete_child_targets (c
);
802 /* The commands failed, but we don't care. */
803 child_error (c
->file
->name
,
804 exit_code
, exit_sig
, coredump
, 1);
808 /* If there are more commands to run, try to start them. */
809 if (job_next_command (c
))
811 if (handling_fatal_signal
)
813 /* Never start new commands while we are dying.
814 Since there are more commands that wanted to be run,
815 the target was not completely remade. So we treat
816 this as if a command had failed. */
817 c
->file
->update_status
= 2;
821 /* Check again whether to start remotely.
822 Whether or not we want to changes over time.
823 Also, start_remote_job may need state set up
824 by start_remote_job_p. */
825 c
->remote
= start_remote_job_p (0);
826 start_job_command (c
);
827 /* Fatal signals are left blocked in case we were
828 about to put that child on the chain. But it is
829 already there, so it is safe for a fatal signal to
830 arrive now; it will clean up this child's targets. */
832 if (c
->file
->command_state
== cs_running
)
833 /* We successfully started the new command.
834 Loop to reap more children. */
838 if (c
->file
->update_status
!= 0)
839 /* We failed to start the commands. */
840 delete_child_targets (c
);
843 /* There are no more commands. We got through them all
844 without an unignored error. Now the target has been
845 successfully updated. */
846 c
->file
->update_status
= 0;
849 /* When we get here, all the commands for C->file are finished
850 (or aborted) and C->file->update_status contains 0 or 2. But
851 C->file->command_state is still cs_running if all the commands
852 ran; notice_finish_file looks for cs_running to tell it that
853 it's interesting to check the file's modtime again now. */
855 if (! handling_fatal_signal
)
856 /* Notice if the target of the commands has been changed.
857 This also propagates its values for command_state and
858 update_status to its also_make files. */
859 notice_finished_file (c
->file
);
861 DB (DB_JOBS
, (_("Removing child %p PID %s%s from chain.\n"),
862 c
, pid2str (c
->pid
), c
->remote
? _(" (remote)") : ""));
864 /* Block fatal signals while frobnicating the list, so that
865 children and job_slots_used are always consistent. Otherwise
866 a fatal signal arriving after the child is off the chain and
867 before job_slots_used is decremented would believe a child was
868 live and call reap_children again. */
871 /* There is now another slot open. */
872 if (job_slots_used
> 0)
875 /* Remove the child from the chain and free it. */
879 lastc
->next
= c
->next
;
885 /* If the job failed, and the -k flag was not given, die,
886 unless we are already in the process of dying. */
887 if (!err
&& child_failed
&& !dontcare
&& !keep_going_flag
&&
888 /* fatal_error_signal will die with the right signal. */
889 !handling_fatal_signal
)
892 /* Only block for one child. */
899 /* Free the storage allocated for CHILD. */
902 free_child (struct child
*child
)
904 if (!jobserver_tokens
)
905 fatal (NILF
, "INTERNAL: Freeing child %p (%s) but no tokens left!\n",
906 child
, child
->file
->name
);
908 /* If we're using the jobserver and this child is not the only outstanding
909 job, put a token back into the pipe for it. */
911 if (job_fds
[1] >= 0 && jobserver_tokens
> 1)
916 /* Write a job token back to the pipe. */
918 EINTRLOOP (r
, write (job_fds
[1], &token
, 1));
920 pfatal_with_name (_("write jobserver"));
922 DB (DB_JOBS
, (_("Released token for child %p (%s).\n"),
923 child
, child
->file
->name
));
928 if (handling_fatal_signal
) /* Don't bother free'ing if about to die. */
931 if (child
->command_lines
!= 0)
933 register unsigned int i
;
934 for (i
= 0; i
< child
->file
->cmds
->ncommand_lines
; ++i
)
935 free (child
->command_lines
[i
]);
936 free (child
->command_lines
);
939 if (child
->environment
!= 0)
941 register char **ep
= child
->environment
;
944 free (child
->environment
);
951 extern sigset_t fatal_signal_set
;
958 (void) sigprocmask (SIG_BLOCK
, &fatal_signal_set
, (sigset_t
*) 0);
960 # ifdef HAVE_SIGSETMASK
961 (void) sigblock (fatal_signal_mask
);
971 sigemptyset (&empty
);
972 sigprocmask (SIG_SETMASK
, &empty
, (sigset_t
*) 0);
976 #ifdef MAKE_JOBSERVER
978 job_noop (int sig UNUSED
)
981 /* Set the child handler action flags to FLAGS. */
983 set_child_handler_action_flags (int set_handler
, int set_alarm
)
988 /* The child handler must be turned off here. */
989 signal (SIGCHLD
, SIG_DFL
);
992 memset (&sa
, '\0', sizeof sa
);
993 sa
.sa_handler
= child_handler
;
994 sa
.sa_flags
= set_handler
? 0 : SA_RESTART
;
996 sigaction (SIGCHLD
, &sa
, NULL
);
998 #if defined SIGCLD && SIGCLD != SIGCHLD
999 sigaction (SIGCLD
, &sa
, NULL
);
1004 /* If we're about to enter the read(), set an alarm to wake up in a
1005 second so we can check if the load has dropped and we can start more
1006 work. On the way out, turn off the alarm and set SIG_DFL. */
1007 alarm (set_handler
? 1 : 0);
1008 sa
.sa_handler
= set_handler
? job_noop
: SIG_DFL
;
1010 sigaction (SIGALRM
, &sa
, NULL
);
1017 /* Start a job to run the commands specified in CHILD.
1018 CHILD is updated to reflect the commands and ID of the child process.
1020 NOTE: On return fatal signals are blocked! The caller is responsible
1021 for calling `unblock_sigs', once the new child is safely on the chain so
1022 it can be cleaned up in the event of a fatal signal. */
1025 start_job_command (struct child
*child
)
1027 #if !defined(_AMIGA) && !defined(WINDOWS32)
1028 static int bad_stdin
= -1;
1031 /* Must be volatile to silence bogus GCC warning about longjmp/vfork. */
1039 /* If we have a completely empty commandset, stop now. */
1040 if (!child
->command_ptr
)
1043 /* Combine the flags parsed for the line itself with
1044 the flags specified globally for this target. */
1045 flags
= (child
->file
->command_flags
1046 | child
->file
->cmds
->lines_flags
[child
->command_line
- 1]);
1048 p
= child
->command_ptr
;
1049 child
->noerror
= ((flags
& COMMANDS_NOERROR
) != 0);
1054 flags
|= COMMANDS_SILENT
;
1056 flags
|= COMMANDS_RECURSE
;
1059 else if (!isblank ((unsigned char)*p
))
1064 /* Update the file's command flags with any new ones we found. We only
1065 keep the COMMANDS_RECURSE setting. Even this isn't 100% correct; we are
1066 now marking more commands recursive than should be in the case of
1067 multiline define/endef scripts where only one line is marked "+". In
1068 order to really fix this, we'll have to keep a lines_flags for every
1069 actual line, after expansion. */
1070 child
->file
->cmds
->lines_flags
[child
->command_line
- 1]
1071 |= flags
& COMMANDS_RECURSE
;
1073 /* Figure out an argument list from this command line. */
1080 argv
= construct_command_argv (p
, &end
, child
->file
,
1081 child
->file
->cmds
->lines_flags
[child
->command_line
- 1],
1082 &child
->sh_batch_file
);
1085 child
->command_ptr
= NULL
;
1089 child
->command_ptr
= end
;
1093 /* If -q was given, say that updating `failed' if there was any text on the
1094 command line, or `succeeded' otherwise. The exit status of 1 tells the
1095 user that -q is saying `something to do'; the exit status for a random
1097 if (argv
!= 0 && question_flag
&& !(flags
& COMMANDS_RECURSE
))
1103 child
->file
->update_status
= 1;
1104 notice_finished_file (child
->file
);
1108 if (touch_flag
&& !(flags
& COMMANDS_RECURSE
))
1110 /* Go on to the next command. It might be the recursive one.
1111 We construct ARGV only to find the end of the command line. */
1126 execute_by_shell
= 0; /* in case construct_command_argv sets it */
1128 /* This line has no commands. Go to the next. */
1129 if (job_next_command (child
))
1130 start_job_command (child
);
1133 /* No more commands. Make sure we're "running"; we might not be if
1134 (e.g.) all commands were skipped due to -n. */
1135 set_command_state (child
->file
, cs_running
);
1136 child
->file
->update_status
= 0;
1137 notice_finished_file (child
->file
);
1142 /* Print out the command. If silent, we call `message' with null so it
1143 can log the working directory before the command's own error messages
1146 message (0, (just_print_flag
|| (!(flags
& COMMANDS_SILENT
) && !silent_flag
))
1147 ? "%s" : (char *) 0, p
);
1149 /* Tell update_goal_chain that a command has been started on behalf of
1150 this target. It is important that this happens here and not in
1151 reap_children (where we used to do it), because reap_children might be
1152 reaping children from a different target. We want this increment to
1153 guaranteedly indicate that a command was started for the dependency
1154 chain (i.e., update_file recursion chain) we are processing. */
1158 /* Optimize an empty command. People use this for timestamp rules,
1159 so avoid forking a useless shell. Do this after we increment
1160 commands_started so make still treats this special case as if it
1161 performed some action (makes a difference as to what messages are
1164 #if !defined(VMS) && !defined(_AMIGA)
1166 #if defined __MSDOS__ || defined (__EMX__)
1167 unixy_shell
/* the test is complicated and we already did it */
1169 (argv
[0] && is_bourne_compatible_shell(argv
[0]))
1171 && (argv
[1] && argv
[1][0] == '-'
1173 ((argv
[1][1] == 'c' && argv
[1][2] == '\0')
1175 (argv
[1][1] == 'e' && argv
[1][2] == 'c' && argv
[1][3] == '\0')))
1176 && (argv
[2] && argv
[2][0] == ':' && argv
[2][1] == '\0')
1183 #endif /* !VMS && !_AMIGA */
1185 /* If -n was given, recurse to get the next line in the sequence. */
1187 if (just_print_flag
&& !(flags
& COMMANDS_RECURSE
))
1196 /* Flush the output streams so they won't have things written twice. */
1202 #if !defined(WINDOWS32) && !defined(_AMIGA) && !defined(__MSDOS__)
1204 /* Set up a bad standard input that reads from a broken pipe. */
1206 if (bad_stdin
== -1)
1208 /* Make a file descriptor that is the read end of a broken pipe.
1209 This will be used for some children's standard inputs. */
1213 /* Close the write side. */
1214 (void) close (pd
[1]);
1215 /* Save the read side. */
1218 /* Set the descriptor to close on exec, so it does not litter any
1219 child's descriptor table. When it is dup2'd onto descriptor 0,
1220 that descriptor will not close on exec. */
1221 CLOSE_ON_EXEC (bad_stdin
);
1225 #endif /* !WINDOWS32 && !_AMIGA && !__MSDOS__ */
1227 /* Decide whether to give this child the `good' standard input
1228 (one that points to the terminal or whatever), or the `bad' one
1229 that points to the read side of a broken pipe. */
1231 child
->good_stdin
= !good_stdin_used
;
1232 if (child
->good_stdin
)
1233 good_stdin_used
= 1;
1240 /* Set up the environment for the child. */
1241 if (child
->environment
== 0)
1242 child
->environment
= target_environment (child
->file
);
1245 #if !defined(__MSDOS__) && !defined(_AMIGA) && !defined(WINDOWS32)
1248 /* start_waiting_job has set CHILD->remote if we can start a remote job. */
1251 int is_remote
, id
, used_stdin
;
1252 if (start_remote_job (argv
, child
->environment
,
1253 child
->good_stdin
? 0 : bad_stdin
,
1254 &is_remote
, &id
, &used_stdin
))
1255 /* Don't give up; remote execution may fail for various reasons. If
1256 so, simply run the job locally. */
1260 if (child
->good_stdin
&& !used_stdin
)
1262 child
->good_stdin
= 0;
1263 good_stdin_used
= 0;
1265 child
->remote
= is_remote
;
1272 /* Fork the child process. */
1274 char **parent_environ
;
1282 if (!child_execute_job (argv
, child
)) {
1284 perror_with_name ("vfork", "");
1290 parent_environ
= environ
;
1293 /* If we aren't running a recursive command and we have a jobserver
1294 pipe, close it before exec'ing. */
1295 if (!(flags
& COMMANDS_RECURSE
) && job_fds
[0] >= 0)
1297 CLOSE_ON_EXEC (job_fds
[0]);
1298 CLOSE_ON_EXEC (job_fds
[1]);
1301 CLOSE_ON_EXEC (job_rfd
);
1303 /* Never use fork()/exec() here! Use spawn() instead in exec_command() */
1304 child
->pid
= child_execute_job (child
->good_stdin
? 0 : bad_stdin
, 1,
1305 argv
, child
->environment
);
1310 perror_with_name ("spawn", "");
1314 /* undo CLOSE_ON_EXEC() after the child process has been started */
1315 if (!(flags
& COMMANDS_RECURSE
) && job_fds
[0] >= 0)
1317 fcntl (job_fds
[0], F_SETFD
, 0);
1318 fcntl (job_fds
[1], F_SETFD
, 0);
1321 fcntl (job_rfd
, F_SETFD
, 0);
1323 #else /* !__EMX__ */
1325 child
->pid
= vfork ();
1326 environ
= parent_environ
; /* Restore value child may have clobbered. */
1327 if (child
->pid
== 0)
1329 /* We are the child side. */
1332 /* If we aren't running a recursive command and we have a jobserver
1333 pipe, close it before exec'ing. */
1334 if (!(flags
& COMMANDS_RECURSE
) && job_fds
[0] >= 0)
1342 #ifdef SET_STACK_SIZE
1343 /* Reset limits, if necessary. */
1344 if (stack_limit
.rlim_cur
)
1345 setrlimit (RLIMIT_STACK
, &stack_limit
);
1348 child_execute_job (child
->good_stdin
? 0 : bad_stdin
, 1,
1349 argv
, child
->environment
);
1351 else if (child
->pid
< 0)
1355 perror_with_name ("vfork", "");
1358 # endif /* !__EMX__ */
1362 #else /* __MSDOS__ or Amiga or WINDOWS32 */
1370 /* We call `system' to do the job of the SHELL, since stock DOS
1371 shell is too dumb. Our `system' knows how to handle long
1372 command lines even if pipes/redirection is needed; it will only
1373 call COMMAND.COM when its internal commands are used. */
1374 if (execute_by_shell
)
1376 char *cmdline
= argv
[0];
1377 /* We don't have a way to pass environment to `system',
1378 so we need to save and restore ours, sigh... */
1379 char **parent_environ
= environ
;
1381 environ
= child
->environment
;
1383 /* If we have a *real* shell, tell `system' to call
1384 it to do everything for us. */
1387 /* A *real* shell on MSDOS may not support long
1388 command lines the DJGPP way, so we must use `system'. */
1389 cmdline
= argv
[2]; /* get past "shell -c" */
1392 dos_command_running
= 1;
1393 proc_return
= system (cmdline
);
1394 environ
= parent_environ
;
1395 execute_by_shell
= 0; /* for the next time */
1399 dos_command_running
= 1;
1400 proc_return
= spawnvpe (P_WAIT
, argv
[0], argv
, child
->environment
);
1403 /* Need to unblock signals before turning off
1404 dos_command_running, so that child's signals
1405 will be treated as such (see fatal_error_signal). */
1407 dos_command_running
= 0;
1409 /* If the child got a signal, dos_status has its
1410 high 8 bits set, so be careful not to alter them. */
1411 if (proc_return
== -1)
1414 dos_status
|= (proc_return
& 0xff);
1416 child
->pid
= dos_pid
++;
1418 #endif /* __MSDOS__ */
1420 amiga_status
= MyExecute (argv
);
1423 child
->pid
= amiga_pid
++;
1424 if (amiga_batch_file
)
1426 amiga_batch_file
= 0;
1427 DeleteFile (amiga_bname
); /* Ignore errors. */
1435 /* make UNC paths safe for CreateProcess -- backslash format */
1437 if (arg0
&& arg0
[0] == '/' && arg0
[1] == '/')
1438 for ( ; arg0
&& *arg0
; arg0
++)
1442 /* make sure CreateProcess() has Path it needs */
1443 sync_Path_environment();
1445 hPID
= process_easy(argv
, child
->environment
);
1447 if (hPID
!= INVALID_HANDLE_VALUE
)
1448 child
->pid
= (pid_t
) hPID
;
1453 _("process_easy() failed to launch process (e=%ld)\n"),
1454 process_last_err(hPID
));
1455 for (i
= 0; argv
[i
]; i
++)
1456 fprintf(stderr
, "%s ", argv
[i
]);
1457 fprintf(stderr
, _("\nCounted %d args in failed launch\n"), i
);
1461 #endif /* WINDOWS32 */
1462 #endif /* __MSDOS__ or Amiga or WINDOWS32 */
1464 /* Bump the number of jobs started in this second. */
1467 /* We are the parent side. Set the state to
1468 say the commands are running and return. */
1470 set_command_state (child
->file
, cs_running
);
1472 /* Free the storage used by the child's argument list. */
1481 child
->file
->update_status
= 2;
1482 notice_finished_file (child
->file
);
1486 /* Try to start a child running.
1487 Returns nonzero if the child was started (and maybe finished), or zero if
1488 the load was too high and the child was put on the `waiting_jobs' chain. */
1491 start_waiting_job (struct child
*c
)
1493 struct file
*f
= c
->file
;
1495 /* If we can start a job remotely, we always want to, and don't care about
1496 the local load average. We record that the job should be started
1497 remotely in C->remote for start_job_command to test. */
1499 c
->remote
= start_remote_job_p (1);
1501 /* If we are running at least one job already and the load average
1502 is too high, make this one wait. */
1504 && ((job_slots_used
> 0 && load_too_high ())
1506 || (process_used_slots () >= MAXIMUM_WAIT_OBJECTS
)
1510 /* Put this child on the chain of children waiting for the load average
1512 set_command_state (f
, cs_running
);
1513 c
->next
= waiting_jobs
;
1518 /* Start the first command; reap_children will run later command lines. */
1519 start_job_command (c
);
1521 switch (f
->command_state
)
1525 DB (DB_JOBS
, (_("Putting child %p (%s) PID %s%s on the chain.\n"),
1526 c
, c
->file
->name
, pid2str (c
->pid
),
1527 c
->remote
? _(" (remote)") : ""));
1529 /* One more job slot is in use. */
1534 case cs_not_started
:
1535 /* All the command lines turned out to be empty. */
1536 f
->update_status
= 0;
1540 notice_finished_file (f
);
1545 assert (f
->command_state
== cs_finished
);
1552 /* Create a `struct child' for FILE and start its commands running. */
1555 new_job (struct file
*file
)
1557 struct commands
*cmds
= file
->cmds
;
1562 /* Let any previously decided-upon jobs that are waiting
1563 for the load to go down start before this new one. */
1564 start_waiting_jobs ();
1566 /* Reap any children that might have finished recently. */
1567 reap_children (0, 0);
1569 /* Chop the commands up into lines if they aren't already. */
1570 chop_commands (cmds
);
1572 /* Expand the command lines and store the results in LINES. */
1573 lines
= xmalloc (cmds
->ncommand_lines
* sizeof (char *));
1574 for (i
= 0; i
< cmds
->ncommand_lines
; ++i
)
1576 /* Collapse backslash-newline combinations that are inside variable
1577 or function references. These are left alone by the parser so
1578 that they will appear in the echoing of commands (where they look
1579 nice); and collapsed by construct_command_argv when it tokenizes.
1580 But letting them survive inside function invocations loses because
1581 we don't want the functions to see them as part of the text. */
1583 char *in
, *out
, *ref
;
1585 /* IN points to where in the line we are scanning.
1586 OUT points to where in the line we are writing.
1587 When we collapse a backslash-newline combination,
1588 IN gets ahead of OUT. */
1590 in
= out
= cmds
->command_lines
[i
];
1591 while ((ref
= strchr (in
, '$')) != 0)
1593 ++ref
; /* Move past the $. */
1596 /* Copy the text between the end of the last chunk
1597 we processed (where IN points) and the new chunk
1598 we are about to process (where REF points). */
1599 memmove (out
, in
, ref
- in
);
1601 /* Move both pointers past the boring stuff. */
1605 if (*ref
== '(' || *ref
== '{')
1607 char openparen
= *ref
;
1608 char closeparen
= openparen
== '(' ? ')' : '}';
1612 *out
++ = *in
++; /* Copy OPENPAREN. */
1613 /* IN now points past the opening paren or brace.
1614 Count parens or braces until it is matched. */
1618 if (*in
== closeparen
&& --count
< 0)
1620 else if (*in
== '\\' && in
[1] == '\n')
1622 /* We have found a backslash-newline inside a
1623 variable or function reference. Eat it and
1624 any following whitespace. */
1627 for (p
= in
- 1; p
> ref
&& *p
== '\\'; --p
)
1631 /* There were two or more backslashes, so this is
1632 not really a continuation line. We don't collapse
1633 the quoting backslashes here as is done in
1634 collapse_continuations, because the line will
1635 be collapsed again after expansion. */
1639 /* Skip the backslash, newline and
1640 any following whitespace. */
1641 in
= next_token (in
+ 2);
1643 /* Discard any preceding whitespace that has
1644 already been written to the output. */
1646 && isblank ((unsigned char)out
[-1]))
1649 /* Replace it all with a single space. */
1655 if (*in
== openparen
)
1664 /* There are no more references in this line to worry about.
1665 Copy the remaining uninteresting text to the output. */
1667 memmove (out
, in
, strlen (in
) + 1);
1669 /* Finally, expand the line. */
1670 lines
[i
] = allocated_variable_expand_for_file (cmds
->command_lines
[i
],
1674 /* Start the command sequence, record it in a new
1675 `struct child', and add that to the chain. */
1677 c
= xcalloc (sizeof (struct child
));
1679 c
->command_lines
= lines
;
1680 c
->sh_batch_file
= NULL
;
1682 /* Cache dontcare flag because file->dontcare can be changed once we
1683 return. Check dontcare inheritance mechanism for details. */
1684 c
->dontcare
= file
->dontcare
;
1686 /* Fetch the first command line to be run. */
1687 job_next_command (c
);
1689 /* Wait for a job slot to be freed up. If we allow an infinite number
1690 don't bother; also job_slots will == 0 if we're using the jobserver. */
1693 while (job_slots_used
== job_slots
)
1694 reap_children (1, 0);
1696 #ifdef MAKE_JOBSERVER
1697 /* If we are controlling multiple jobs make sure we have a token before
1698 starting the child. */
1700 /* This can be inefficient. There's a decent chance that this job won't
1701 actually have to run any subprocesses: the command script may be empty
1702 or otherwise optimized away. It would be nice if we could defer
1703 obtaining a token until just before we need it, in start_job_command.
1704 To do that we'd need to keep track of whether we'd already obtained a
1705 token (since start_job_command is called for each line of the job, not
1706 just once). Also more thought needs to go into the entire algorithm;
1707 this is where the old parallel job code waits, so... */
1709 else if (job_fds
[0] >= 0)
1716 DB (DB_JOBS
, ("Need a job token; we %shave children\n",
1717 children
? "" : "don't "));
1719 /* If we don't already have a job started, use our "free" token. */
1720 if (!jobserver_tokens
)
1723 /* Read a token. As long as there's no token available we'll block.
1724 We enable interruptible system calls before the read(2) so that if
1725 we get a SIGCHLD while we're waiting, we'll return with EINTR and
1726 we can process the death(s) and return tokens to the free pool.
1728 Once we return from the read, we immediately reinstate restartable
1729 system calls. This allows us to not worry about checking for
1730 EINTR on all the other system calls in the program.
1732 There is one other twist: there is a span between the time
1733 reap_children() does its last check for dead children and the time
1734 the read(2) call is entered, below, where if a child dies we won't
1735 notice. This is extremely serious as it could cause us to
1736 deadlock, given the right set of events.
1738 To avoid this, we do the following: before we reap_children(), we
1739 dup(2) the read FD on the jobserver pipe. The read(2) call below
1740 uses that new FD. In the signal handler, we close that FD. That
1741 way, if a child dies during the section mentioned above, the
1742 read(2) will be invoked with an invalid FD and will return
1743 immediately with EBADF. */
1745 /* Make sure we have a dup'd FD. */
1748 DB (DB_JOBS
, ("Duplicate the job FD\n"));
1749 job_rfd
= dup (job_fds
[0]);
1752 /* Reap anything that's currently waiting. */
1753 reap_children (0, 0);
1755 /* Kick off any jobs we have waiting for an opportunity that
1756 can run now (ie waiting for load). */
1757 start_waiting_jobs ();
1759 /* If our "free" slot has become available, use it; we don't need an
1761 if (!jobserver_tokens
)
1764 /* There must be at least one child already, or we have no business
1765 waiting for a token. */
1767 fatal (NILF
, "INTERNAL: no children as we go to sleep on read\n");
1769 /* Set interruptible system calls, and read() for a job token. */
1770 set_child_handler_action_flags (1, waiting_jobs
!= NULL
);
1771 got_token
= read (job_rfd
, &token
, 1);
1772 saved_errno
= errno
;
1773 set_child_handler_action_flags (0, waiting_jobs
!= NULL
);
1775 /* If we got one, we're done here. */
1778 DB (DB_JOBS
, (_("Obtained token for child %p (%s).\n"),
1783 /* If the error _wasn't_ expected (EINTR or EBADF), punt. Otherwise,
1784 go back and reap_children(), and try again. */
1785 errno
= saved_errno
;
1786 if (errno
!= EINTR
&& errno
!= EBADF
)
1787 pfatal_with_name (_("read jobs pipe"));
1789 DB (DB_JOBS
, ("Read returned EBADF.\n"));
1795 /* The job is now primed. Start it running.
1796 (This will notice if there is in fact no recipe.) */
1797 if (cmds
->fileinfo
.filenm
)
1798 DB (DB_BASIC
, (_("Invoking recipe from %s:%lu to update target `%s'.\n"),
1799 cmds
->fileinfo
.filenm
, cmds
->fileinfo
.lineno
,
1802 DB (DB_BASIC
, (_("Invoking builtin recipe to update target `%s'.\n"),
1806 start_waiting_job (c
);
1808 if (job_slots
== 1 || not_parallel
)
1809 /* Since there is only one job slot, make things run linearly.
1810 Wait for the child to die, setting the state to `cs_finished'. */
1811 while (file
->command_state
== cs_running
)
1812 reap_children (1, 0);
1817 /* Move CHILD's pointers to the next command for it to execute.
1818 Returns nonzero if there is another command. */
1821 job_next_command (struct child
*child
)
1823 while (child
->command_ptr
== 0 || *child
->command_ptr
== '\0')
1825 /* There are no more lines in the expansion of this line. */
1826 if (child
->command_line
== child
->file
->cmds
->ncommand_lines
)
1828 /* There are no more lines to be expanded. */
1829 child
->command_ptr
= 0;
1833 /* Get the next line to run. */
1834 child
->command_ptr
= child
->command_lines
[child
->command_line
++];
1839 /* Determine if the load average on the system is too high to start a new job.
1840 The real system load average is only recomputed once a second. However, a
1841 very parallel make can easily start tens or even hundreds of jobs in a
1842 second, which brings the system to its knees for a while until that first
1843 batch of jobs clears out.
1845 To avoid this we use a weighted algorithm to try to account for jobs which
1846 have been started since the last second, and guess what the load average
1847 would be now if it were computed.
1849 This algorithm was provided by Thomas Riedl <thomas.riedl@siemens.com>,
1852 ! calculate something load-oid and add to the observed sys.load,
1853 ! so that latter can catch up:
1854 ! - every job started increases jobctr;
1855 ! - every dying job decreases a positive jobctr;
1856 ! - the jobctr value gets zeroed every change of seconds,
1857 ! after its value*weight_b is stored into the 'backlog' value last_sec
1858 ! - weight_a times the sum of jobctr and last_sec gets
1859 ! added to the observed sys.load.
1861 ! The two weights have been tried out on 24 and 48 proc. Sun Solaris-9
1862 ! machines, using a several-thousand-jobs-mix of cpp, cc, cxx and smallish
1863 ! sub-shelled commands (rm, echo, sed...) for tests.
1864 ! lowering the 'direct influence' factor weight_a (e.g. to 0.1)
1865 ! resulted in significant excession of the load limit, raising it
1866 ! (e.g. to 0.5) took bad to small, fast-executing jobs and didn't
1867 ! reach the limit in most test cases.
1869 ! lowering the 'history influence' weight_b (e.g. to 0.1) resulted in
1870 ! exceeding the limit for longer-running stuff (compile jobs in
1871 ! the .5 to 1.5 sec. range),raising it (e.g. to 0.5) overrepresented
1872 ! small jobs' effects.
1876 #define LOAD_WEIGHT_A 0.25
1877 #define LOAD_WEIGHT_B 0.25
1880 load_too_high (void)
1882 #if defined(__MSDOS__) || defined(VMS) || defined(_AMIGA) || defined(__riscos__)
1885 static double last_sec
;
1886 static time_t last_now
;
1891 /* sub_proc.c cannot wait for more than MAXIMUM_WAIT_OBJECTS children */
1892 if (process_used_slots () >= MAXIMUM_WAIT_OBJECTS
)
1896 if (max_load_average
< 0)
1899 /* Find the real system load average. */
1901 if (getloadavg (&load
, 1) != 1)
1903 static int lossage
= -1;
1904 /* Complain only once for the same error. */
1905 if (lossage
== -1 || errno
!= lossage
)
1908 /* An errno value of zero means getloadavg is just unsupported. */
1910 _("cannot enforce load limits on this operating system"));
1912 perror_with_name (_("cannot enforce load limit: "), "getloadavg");
1919 /* If we're in a new second zero the counter and correct the backlog
1920 value. Only keep the backlog for one extra second; after that it's 0. */
1924 if (last_now
== now
- 1)
1925 last_sec
= LOAD_WEIGHT_B
* job_counter
;
1933 /* Try to guess what the load would be right now. */
1934 guess
= load
+ (LOAD_WEIGHT_A
* (job_counter
+ last_sec
));
1936 DB (DB_JOBS
, ("Estimated system load = %f (actual = %f) (max requested = %f)\n",
1937 guess
, load
, max_load_average
));
1939 return guess
>= max_load_average
;
1943 /* Start jobs that are waiting for the load to be lower. */
1946 start_waiting_jobs (void)
1950 if (waiting_jobs
== 0)
1955 /* Check for recently deceased descendants. */
1956 reap_children (0, 0);
1958 /* Take a job off the waiting list. */
1960 waiting_jobs
= job
->next
;
1962 /* Try to start that job. We break out of the loop as soon
1963 as start_waiting_job puts one back on the waiting list. */
1965 while (start_waiting_job (job
) && waiting_jobs
!= 0);
1972 /* EMX: Start a child process. This function returns the new pid. */
1973 # if defined __EMX__
1975 child_execute_job (int stdin_fd
, int stdout_fd
, char **argv
, char **envp
)
1978 /* stdin_fd == 0 means: nothing to do for stdin;
1979 stdout_fd == 1 means: nothing to do for stdout */
1980 int save_stdin
= (stdin_fd
!= 0) ? dup (0) : 0;
1981 int save_stdout
= (stdout_fd
!= 1) ? dup (1): 1;
1983 /* < 0 only if dup() failed */
1985 fatal (NILF
, _("no more file handles: could not duplicate stdin\n"));
1986 if (save_stdout
< 0)
1987 fatal (NILF
, _("no more file handles: could not duplicate stdout\n"));
1989 /* Close unnecessary file handles for the child. */
1990 if (save_stdin
!= 0)
1991 CLOSE_ON_EXEC (save_stdin
);
1992 if (save_stdout
!= 1)
1993 CLOSE_ON_EXEC (save_stdout
);
1995 /* Connect the pipes to the child process. */
1997 (void) dup2 (stdin_fd
, 0);
1999 (void) dup2 (stdout_fd
, 1);
2001 /* stdin_fd and stdout_fd must be closed on exit because we are
2002 still in the parent process */
2004 CLOSE_ON_EXEC (stdin_fd
);
2006 CLOSE_ON_EXEC (stdout_fd
);
2008 /* Run the command. */
2009 pid
= exec_command (argv
, envp
);
2011 /* Restore stdout/stdin of the parent and close temporary FDs. */
2014 if (dup2 (save_stdin
, 0) != 0)
2015 fatal (NILF
, _("Could not restore stdin\n"));
2022 if (dup2 (save_stdout
, 1) != 1)
2023 fatal (NILF
, _("Could not restore stdout\n"));
2025 close (save_stdout
);
2031 #elif !defined (_AMIGA) && !defined (__MSDOS__) && !defined (VMS)
2034 Replace the current process with one executing the command in ARGV.
2035 STDIN_FD and STDOUT_FD are used as the process's stdin and stdout; ENVP is
2036 the environment of the new program. This function does not return. */
2038 child_execute_job (int stdin_fd
, int stdout_fd
, char **argv
, char **envp
)
2041 (void) dup2 (stdin_fd
, 0);
2043 (void) dup2 (stdout_fd
, 1);
2045 (void) close (stdin_fd
);
2047 (void) close (stdout_fd
);
2049 /* Run the command. */
2050 exec_command (argv
, envp
);
2052 #endif /* !AMIGA && !__MSDOS__ && !VMS */
2053 #endif /* !WINDOWS32 */
2056 /* Replace the current process with one running the command in ARGV,
2057 with environment ENVP. This function does not return. */
2059 /* EMX: This function returns the pid of the child process. */
2065 exec_command (char **argv
, char **envp
)
2068 /* to work around a problem with signals and execve: ignore them */
2070 signal (SIGCHLD
,SIG_IGN
);
2072 /* Run the program. */
2073 execve (argv
[0], argv
, envp
);
2074 perror_with_name ("execve: ", argv
[0]);
2075 _exit (EXIT_FAILURE
);
2081 int exit_code
= EXIT_FAILURE
;
2083 /* make sure CreateProcess() has Path it needs */
2084 sync_Path_environment();
2086 /* launch command */
2087 hPID
= process_easy(argv
, envp
);
2089 /* make sure launch ok */
2090 if (hPID
== INVALID_HANDLE_VALUE
)
2094 _("process_easy() failed to launch process (e=%ld)\n"),
2095 process_last_err(hPID
));
2096 for (i
= 0; argv
[i
]; i
++)
2097 fprintf(stderr
, "%s ", argv
[i
]);
2098 fprintf(stderr
, _("\nCounted %d args in failed launch\n"), i
);
2102 /* wait and reap last child */
2103 hWaitPID
= process_wait_for_any();
2106 /* was an error found on this process? */
2107 err
= process_last_err(hWaitPID
);
2110 exit_code
= process_exit_code(hWaitPID
);
2113 fprintf(stderr
, "make (e=%d, rc=%d): %s",
2114 err
, exit_code
, map_windows32_error_to_string(err
));
2116 /* cleanup process */
2117 process_cleanup(hWaitPID
);
2119 /* expect to find only last pid, warn about other pids reaped */
2120 if (hWaitPID
== hPID
)
2124 char *pidstr
= xstrdup (pid2str ((pid_t
)hWaitPID
));
2127 _("make reaped child pid %s, still waiting for pid %s\n"),
2128 pidstr
, pid2str ((pid_t
)hPID
));
2133 /* return child's exit code as our exit code */
2136 #else /* !WINDOWS32 */
2142 /* Be the user, permanently. */
2147 /* Run the program. */
2148 pid
= spawnvpe (P_NOWAIT
, argv
[0], argv
, envp
);
2153 /* the file might have a strange shell extension */
2154 if (errno
== ENOENT
)
2159 /* Run the program. */
2161 execvp (argv
[0], argv
);
2163 # endif /* !__EMX__ */
2168 error (NILF
, _("%s: Command not found"), argv
[0]);
2172 /* The file is not executable. Try it as a shell script. */
2173 extern char *getenv ();
2180 /* Do not use $SHELL from the environment */
2181 struct variable
*p
= lookup_variable ("SHELL", 5);
2187 shell
= getenv ("SHELL");
2190 shell
= default_shell
;
2193 while (argv
[argc
] != 0)
2201 new_argv
= alloca ((1 + argc
+ 1) * sizeof (char *));
2202 new_argv
[0] = shell
;
2213 new_argv
[i
] = argv
[0];
2216 new_argv
[i
+ argc
] = argv
[argc
];
2221 pid
= spawnvpe (P_NOWAIT
, shell
, new_argv
, envp
);
2225 execvp (shell
, new_argv
);
2227 if (errno
== ENOENT
)
2228 error (NILF
, _("%s: Shell program not found"), shell
);
2230 perror_with_name ("execvp: ", shell
);
2236 /* this nasty error was driving me nuts :-( */
2237 error (NILF
, _("spawnvpe: environment space might be exhausted"));
2242 perror_with_name ("execvp: ", argv
[0]);
2251 #endif /* !WINDOWS32 */
2254 #else /* On Amiga */
2255 void exec_command (char **argv
)
2260 void clean_tmp (void)
2262 DeleteFile (amiga_bname
);
2265 #endif /* On Amiga */
2268 /* Figure out the argument list necessary to run LINE as a command. Try to
2269 avoid using a shell. This routine handles only ' quoting, and " quoting
2270 when no backslash, $ or ` characters are seen in the quotes. Starting
2271 quotes may be escaped with a backslash. If any of the characters in
2272 sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[]
2273 is the first word of a line, the shell is used.
2275 If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
2276 If *RESTP is NULL, newlines will be ignored.
2278 SHELL is the shell to use, or nil to use the default shell.
2279 IFS is the value of $IFS, or nil (meaning the default).
2281 FLAGS is the value of lines_flags for this command line. It is
2282 used in the WINDOWS32 port to check whether + or $(MAKE) were found
2283 in this command line, in which case the effect of just_print_flag
2287 construct_command_argv_internal (char *line
, char **restp
, char *shell
,
2288 char *shellflags
, char *ifs
, int flags
,
2289 char **batch_filename_ptr
)
2292 /* MSDOS supports both the stock DOS shell and ports of Unixy shells.
2293 We call `system' for anything that requires ``slow'' processing,
2294 because DOS shells are too dumb. When $SHELL points to a real
2295 (unix-style) shell, `system' just calls it to do everything. When
2296 $SHELL points to a DOS shell, `system' does most of the work
2297 internally, calling the shell only for its internal commands.
2298 However, it looks on the $PATH first, so you can e.g. have an
2299 external command named `mkdir'.
2301 Since we call `system', certain characters and commands below are
2302 actually not specific to COMMAND.COM, but to the DJGPP implementation
2303 of `system'. In particular:
2305 The shell wildcard characters are in DOS_CHARS because they will
2306 not be expanded if we call the child via `spawnXX'.
2308 The `;' is in DOS_CHARS, because our `system' knows how to run
2309 multiple commands on a single line.
2311 DOS_CHARS also include characters special to 4DOS/NDOS, so we
2312 won't have to tell one from another and have one more set of
2313 commands and special characters. */
2314 static char sh_chars_dos
[] = "*?[];|<>%^&()";
2315 static char *sh_cmds_dos
[] = { "break", "call", "cd", "chcp", "chdir", "cls",
2316 "copy", "ctty", "date", "del", "dir", "echo",
2317 "erase", "exit", "for", "goto", "if", "md",
2318 "mkdir", "path", "pause", "prompt", "rd",
2319 "rmdir", "rem", "ren", "rename", "set",
2320 "shift", "time", "type", "ver", "verify",
2323 static char sh_chars_sh
[] = "#;\"*?[]&|<>(){}$`^";
2324 static char *sh_cmds_sh
[] = { "cd", "echo", "eval", "exec", "exit", "login",
2325 "logout", "set", "umask", "wait", "while",
2326 "for", "case", "if", ":", ".", "break",
2327 "continue", "export", "read", "readonly",
2328 "shift", "times", "trap", "switch", "unset",
2333 #elif defined (__EMX__)
2334 static char sh_chars_dos
[] = "*?[];|<>%^&()";
2335 static char *sh_cmds_dos
[] = { "break", "call", "cd", "chcp", "chdir", "cls",
2336 "copy", "ctty", "date", "del", "dir", "echo",
2337 "erase", "exit", "for", "goto", "if", "md",
2338 "mkdir", "path", "pause", "prompt", "rd",
2339 "rmdir", "rem", "ren", "rename", "set",
2340 "shift", "time", "type", "ver", "verify",
2343 static char sh_chars_os2
[] = "*?[];|<>%^()\"'&";
2344 static char *sh_cmds_os2
[] = { "call", "cd", "chcp", "chdir", "cls", "copy",
2345 "date", "del", "detach", "dir", "echo",
2346 "endlocal", "erase", "exit", "for", "goto", "if",
2347 "keys", "md", "mkdir", "move", "path", "pause",
2348 "prompt", "rd", "rem", "ren", "rename", "rmdir",
2349 "set", "setlocal", "shift", "start", "time",
2350 "type", "ver", "verify", "vol", ":", 0 };
2352 static char sh_chars_sh
[] = "#;\"*?[]&|<>(){}$`^~'";
2353 static char *sh_cmds_sh
[] = { "echo", "cd", "eval", "exec", "exit", "login",
2354 "logout", "set", "umask", "wait", "while",
2355 "for", "case", "if", ":", ".", "break",
2356 "continue", "export", "read", "readonly",
2357 "shift", "times", "trap", "switch", "unset",
2362 #elif defined (_AMIGA)
2363 static char sh_chars
[] = "#;\"|<>()?*$`";
2364 static char *sh_cmds
[] = { "cd", "eval", "if", "delete", "echo", "copy",
2365 "rename", "set", "setenv", "date", "makedir",
2366 "skip", "else", "endif", "path", "prompt",
2367 "unset", "unsetenv", "version",
2369 #elif defined (WINDOWS32)
2370 static char sh_chars_dos
[] = "\"|&<>";
2371 static char *sh_cmds_dos
[] = { "assoc", "break", "call", "cd", "chcp",
2372 "chdir", "cls", "color", "copy", "ctty",
2373 "date", "del", "dir", "echo", "echo.",
2374 "endlocal", "erase", "exit", "for", "ftype",
2375 "goto", "if", "if", "md", "mkdir", "path",
2376 "pause", "prompt", "rd", "rem", "ren",
2377 "rename", "rmdir", "set", "setlocal",
2378 "shift", "time", "title", "type", "ver",
2379 "verify", "vol", ":", 0 };
2380 static char sh_chars_sh
[] = "#;\"*?[]&|<>(){}$`^";
2381 static char *sh_cmds_sh
[] = { "cd", "eval", "exec", "exit", "login",
2382 "logout", "set", "umask", "wait", "while", "for",
2383 "case", "if", ":", ".", "break", "continue",
2384 "export", "read", "readonly", "shift", "times",
2385 "trap", "switch", "test",
2386 #ifdef BATCH_MODE_ONLY_SHELL
2392 #elif defined(__riscos__)
2393 static char sh_chars
[] = "";
2394 static char *sh_cmds
[] = { 0 };
2395 #else /* must be UNIX-ish */
2396 static char sh_chars
[] = "#;\"*?[]&|<>(){}$`^~!";
2397 static char *sh_cmds
[] = { ".", ":", "break", "case", "cd", "continue",
2398 "eval", "exec", "exit", "export", "for", "if",
2399 "login", "logout", "read", "readonly", "set",
2400 "shift", "switch", "test", "times", "trap",
2401 "ulimit", "umask", "unset", "wait", "while", 0 };
2402 # ifdef HAVE_DOS_PATHS
2403 /* This is required if the MSYS/Cygwin ports (which do not define
2404 WINDOWS32) are compiled with HAVE_DOS_PATHS defined, which uses
2405 sh_chars_sh[] directly (see below). */
2406 static char *sh_chars_sh
= sh_chars
;
2407 # endif /* HAVE_DOS_PATHS */
2413 int instring
, word_has_equals
, seen_nonequals
, last_argument_was_empty
;
2414 char **new_argv
= 0;
2420 sh_cmds
= sh_cmds_dos
;
2421 sh_chars
= sh_chars_dos
;
2423 sh_cmds
= sh_cmds_sh
;
2424 sh_chars
= sh_chars_sh
;
2426 #endif /* WINDOWS32 */
2431 /* Make sure not to bother processing an empty line. */
2432 while (isblank ((unsigned char)*line
))
2437 if (shellflags
== 0)
2438 shellflags
= posix_pedantic
? "-ec" : "-c";
2440 /* See if it is safe to parse commands internally. */
2442 shell
= default_shell
;
2444 else if (strcmp (shell
, default_shell
))
2446 char *s1
= _fullpath (NULL
, shell
, 0);
2447 char *s2
= _fullpath (NULL
, default_shell
, 0);
2449 slow_flag
= strcmp ((s1
? s1
: ""), (s2
? s2
: ""));
2458 #else /* not WINDOWS32 */
2459 #if defined (__MSDOS__) || defined (__EMX__)
2460 else if (strcasecmp (shell
, default_shell
))
2462 extern int _is_unixy_shell (const char *_path
);
2464 DB (DB_BASIC
, (_("$SHELL changed (was `%s', now `%s')\n"),
2465 default_shell
, shell
));
2466 unixy_shell
= _is_unixy_shell (shell
);
2467 /* we must allocate a copy of shell: construct_command_argv() will free
2468 * shell after this function returns. */
2469 default_shell
= xstrdup (shell
);
2473 sh_chars
= sh_chars_sh
;
2474 sh_cmds
= sh_cmds_sh
;
2478 sh_chars
= sh_chars_dos
;
2479 sh_cmds
= sh_cmds_dos
;
2481 if (_osmode
== OS2_MODE
)
2483 sh_chars
= sh_chars_os2
;
2484 sh_cmds
= sh_cmds_os2
;
2488 #else /* !__MSDOS__ */
2489 else if (strcmp (shell
, default_shell
))
2491 #endif /* !__MSDOS__ && !__EMX__ */
2492 #endif /* not WINDOWS32 */
2495 for (ap
= ifs
; *ap
!= '\0'; ++ap
)
2496 if (*ap
!= ' ' && *ap
!= '\t' && *ap
!= '\n')
2499 if (shellflags
!= 0)
2500 if (shellflags
[0] != '-'
2501 || ((shellflags
[1] != 'c' || shellflags
[2] != '\0')
2502 && (shellflags
[1] != 'e' || shellflags
[2] != 'c' || shellflags
[3] != '\0')))
2505 i
= strlen (line
) + 1;
2507 /* More than 1 arg per character is impossible. */
2508 new_argv
= xmalloc (i
* sizeof (char *));
2510 /* All the args can fit in a buffer as big as LINE is. */
2511 ap
= new_argv
[0] = argstr
= xmalloc (i
);
2514 /* I is how many complete arguments have been found. */
2516 instring
= word_has_equals
= seen_nonequals
= last_argument_was_empty
= 0;
2517 for (p
= line
; *p
!= '\0'; ++p
)
2523 /* Inside a string, just copy any char except a closing quote
2524 or a backslash-newline combination. */
2528 if (ap
== new_argv
[0] || *(ap
-1) == '\0')
2529 last_argument_was_empty
= 1;
2531 else if (*p
== '\\' && p
[1] == '\n')
2533 /* Backslash-newline is handled differently depending on what
2534 kind of string we're in: inside single-quoted strings you
2535 keep them; in double-quoted strings they disappear.
2536 For DOS/Windows/OS2, if we don't have a POSIX shell,
2537 we keep the pre-POSIX behavior of removing the
2538 backslash-newline. */
2540 #if defined (__MSDOS__) || defined (__EMX__) || defined (WINDOWS32)
2551 else if (*p
== '\n' && restp
!= NULL
)
2553 /* End of the command line. */
2557 /* Backslash, $, and ` are special inside double quotes.
2558 If we see any of those, punt.
2559 But on MSDOS, if we use COMMAND.COM, double and single
2560 quotes have the same effect. */
2561 else if (instring
== '"' && strchr ("\\$`", *p
) != 0 && unixy_shell
)
2566 else if (strchr (sh_chars
, *p
) != 0)
2567 /* Not inside a string, but it's a special char. */
2569 else if (one_shell
&& *p
== '\n')
2570 /* In .ONESHELL mode \n is a separator like ; or && */
2573 else if (*p
== '.' && p
[1] == '.' && p
[2] == '.' && p
[3] != '.')
2574 /* `...' is a wildcard in DJGPP. */
2578 /* Not a special char. */
2582 /* Equals is a special character in leading words before the
2583 first word with no equals sign in it. This is not the case
2584 with sh -k, but we never get here when using nonstandard
2586 if (! seen_nonequals
&& unixy_shell
)
2588 word_has_equals
= 1;
2593 /* Backslash-newline has special case handling, ref POSIX.
2594 We're in the fastpath, so emulate what the shell would do. */
2597 /* Throw out the backslash and newline. */
2600 /* If there's nothing in this argument yet, skip any
2601 whitespace before the start of the next word. */
2602 if (ap
== new_argv
[i
])
2603 p
= next_token (p
+ 1) - 1;
2605 else if (p
[1] != '\0')
2607 #ifdef HAVE_DOS_PATHS
2608 /* Only remove backslashes before characters special to Unixy
2609 shells. All other backslashes are copied verbatim, since
2610 they are probably DOS-style directory separators. This
2611 still leaves a small window for problems, but at least it
2612 should work for the vast majority of naive users. */
2615 /* A dot is only special as part of the "..."
2617 if (strneq (p
+ 1, ".\\.\\.", 5))
2625 if (p
[1] != '\\' && p
[1] != '\''
2626 && !isspace ((unsigned char)p
[1])
2627 && strchr (sh_chars_sh
, p
[1]) == 0)
2628 /* back up one notch, to copy the backslash */
2630 #endif /* HAVE_DOS_PATHS */
2632 /* Copy and skip the following char. */
2645 /* End of the command line. */
2650 /* Newlines are not special. */
2656 /* We have the end of an argument.
2657 Terminate the text of the argument. */
2660 last_argument_was_empty
= 0;
2662 /* Update SEEN_NONEQUALS, which tells us if every word
2663 heretofore has contained an `='. */
2664 seen_nonequals
|= ! word_has_equals
;
2665 if (word_has_equals
&& ! seen_nonequals
)
2666 /* An `=' in a word before the first
2667 word without one is magical. */
2669 word_has_equals
= 0; /* Prepare for the next word. */
2671 /* If this argument is the command name,
2672 see if it is a built-in shell command.
2673 If so, have the shell handle it. */
2677 for (j
= 0; sh_cmds
[j
] != 0; ++j
)
2679 if (streq (sh_cmds
[j
], new_argv
[0]))
2682 /* Non-Unix shells are case insensitive. */
2684 && strcasecmp (sh_cmds
[j
], new_argv
[0]) == 0)
2690 /* Ignore multiple whitespace chars. */
2691 p
= next_token (p
) - 1;
2702 /* Let the shell deal with an unterminated quote. */
2705 /* Terminate the last argument and the argument list. */
2708 if (new_argv
[i
][0] != '\0' || last_argument_was_empty
)
2715 for (j
= 0; sh_cmds
[j
] != 0; ++j
)
2716 if (streq (sh_cmds
[j
], new_argv
[0]))
2720 if (new_argv
[0] == 0)
2722 /* Line was empty. */
2731 /* We must use the shell. */
2735 /* Free the old argument list we were working on. */
2741 execute_by_shell
= 1; /* actually, call `system' if shell isn't unixy */
2750 buffer
= xmalloc (strlen (line
)+1);
2753 for (dptr
=buffer
; *ptr
; )
2755 if (*ptr
== '\\' && ptr
[1] == '\n')
2757 else if (*ptr
== '@') /* Kludge: multiline commands */
2767 new_argv
= xmalloc (2 * sizeof (char *));
2768 new_argv
[0] = buffer
;
2771 #else /* Not Amiga */
2774 * Not eating this whitespace caused things like
2778 * which gave the shell fits. I think we have to eat
2779 * whitespace here, but this code should be considered
2780 * suspicious if things start failing....
2783 /* Make sure not to bother processing an empty line. */
2784 while (isspace ((unsigned char)*line
))
2788 #endif /* WINDOWS32 */
2791 /* SHELL may be a multi-word command. Construct a command line
2792 "$(SHELL) $(.SHELLFLAGS) LINE", with all special chars in LINE escaped.
2793 Then recurse, expanding this command line to get the final
2796 unsigned int shell_len
= strlen (shell
);
2797 unsigned int line_len
= strlen (line
);
2798 unsigned int sflags_len
= strlen (shellflags
);
2799 char *command_ptr
= NULL
; /* used for batch_mode_shell mode */
2802 # ifdef __EMX__ /* is this necessary? */
2804 shellflags
[0] = '/'; /* "/c" */
2807 /* In .ONESHELL mode we are allowed to throw the entire current
2808 recipe string at a single shell and trust that the user
2809 has configured the shell and shell flags, and formatted
2810 the string, appropriately. */
2813 /* If the shell is Bourne compatible, we must remove and ignore
2814 interior special chars [@+-] because they're meaningless to
2815 the shell itself. If, however, we're in .ONESHELL mode and
2816 have changed SHELL to something non-standard, we should
2817 leave those alone because they could be part of the
2818 script. In this case we must also leave in place
2819 any leading [@+-] for the same reason. */
2821 /* Remove and ignore interior prefix chars [@+-] because they're
2822 meaningless given a single shell. */
2823 #if defined __MSDOS__ || defined (__EMX__)
2824 if (unixy_shell
) /* the test is complicated and we already did it */
2826 if (is_bourne_compatible_shell(shell
))
2829 const char *f
= line
;
2832 /* Copy the recipe, removing and ignoring interior prefix chars
2833 [@+-]: they're meaningless in .ONESHELL mode. */
2834 while (f
[0] != '\0')
2838 /* This is the start of a new recipe line.
2839 Skip whitespace and prefix characters. */
2840 while (isblank (*f
) || *f
== '-' || *f
== '@' || *f
== '+')
2843 /* Copy until we get to the next logical recipe line. */
2851 /* On unescaped newline, we're done with this line. */
2852 if (f
[-1] == '\n' && ! esc
)
2855 /* Something else: reset the escape sequence. */
2863 new_argv
= xmalloc (4 * sizeof (char *));
2864 new_argv
[0] = xstrdup(shell
);
2865 new_argv
[1] = xstrdup(shellflags
);
2871 new_line
= alloca (shell_len
+ 1 + sflags_len
+ 1
2872 + (line_len
*2) + 1);
2874 memcpy (ap
, shell
, shell_len
);
2877 memcpy (ap
, shellflags
, sflags_len
);
2881 for (p
= line
; *p
!= '\0'; ++p
)
2883 if (restp
!= NULL
&& *p
== '\n')
2888 else if (*p
== '\\' && p
[1] == '\n')
2890 /* POSIX says we keep the backslash-newline. If we don't have a
2891 POSIX shell on DOS/Windows/OS2, mimic the pre-POSIX behavior
2892 and remove the backslash/newline. */
2893 #if defined (__MSDOS__) || defined (__EMX__) || defined (WINDOWS32)
2894 # define PRESERVE_BSNL unixy_shell
2896 # define PRESERVE_BSNL 1
2901 /* Only non-batch execution needs another backslash,
2902 because it will be passed through a recursive
2903 invocation of this function. */
2904 if (!batch_mode_shell
)
2912 /* DOS shells don't know about backslash-escaping. */
2913 if (unixy_shell
&& !batch_mode_shell
&&
2914 (*p
== '\\' || *p
== '\'' || *p
== '"'
2915 || isspace ((unsigned char)*p
)
2916 || strchr (sh_chars
, *p
) != 0))
2919 else if (unixy_shell
&& strneq (p
, "...", 3))
2921 /* The case of `...' wildcard again. */
2922 strcpy (ap
, "\\.\\.\\");
2929 if (ap
== new_line
+ shell_len
+ sflags_len
+ 2)
2930 /* Line was empty. */
2935 /* Some shells do not work well when invoked as 'sh -c xxx' to run a
2936 command line (e.g. Cygnus GNUWIN32 sh.exe on WIN32 systems). In these
2937 cases, run commands via a script file. */
2938 if (just_print_flag
&& !(flags
& COMMANDS_RECURSE
)) {
2939 /* Need to allocate new_argv, although it's unused, because
2940 start_job_command will want to free it and its 0'th element. */
2941 new_argv
= xmalloc(2 * sizeof (char *));
2942 new_argv
[0] = xstrdup ("");
2944 } else if ((no_default_sh_exe
|| batch_mode_shell
) && batch_filename_ptr
) {
2947 int id
= GetCurrentProcessId();
2950 /* create a file name */
2951 sprintf(fbuf
, "make%d", id
);
2952 *batch_filename_ptr
= create_batch_file (fbuf
, unixy_shell
, &temp_fd
);
2954 DB (DB_JOBS
, (_("Creating temporary batch file %s\n"),
2955 *batch_filename_ptr
));
2957 /* Create a FILE object for the batch file, and write to it the
2958 commands to be executed. Put the batch file in TEXT mode. */
2959 _setmode (temp_fd
, _O_TEXT
);
2960 batch
= _fdopen (temp_fd
, "wt");
2962 fputs ("@echo off\n", batch
);
2963 fputs (command_ptr
, batch
);
2964 fputc ('\n', batch
);
2966 DB (DB_JOBS
, (_("Batch file contents:%s\n\t%s\n"),
2967 !unixy_shell
? "\n\t@echo off" : "", command_ptr
));
2970 new_argv
= xmalloc(3 * sizeof (char *));
2972 new_argv
[0] = xstrdup (shell
);
2973 new_argv
[1] = *batch_filename_ptr
; /* only argv[0] gets freed later */
2975 new_argv
[0] = xstrdup (*batch_filename_ptr
);
2980 #endif /* WINDOWS32 */
2983 new_argv
= construct_command_argv_internal (new_line
, 0, 0, 0, 0,
2987 else if (!unixy_shell
)
2989 /* new_line is local, must not be freed therefore
2990 We use line here instead of new_line because we run the shell
2992 size_t line_len
= strlen (line
);
2995 memcpy (new_line
, line
, line_len
+ 1);
2996 /* Replace all backslash-newline combination and also following tabs.
2997 Important: stop at the first '\n' because that's what the loop above
2998 did. The next line starting at restp[0] will be executed during the
2999 next call of this function. */
3000 while (*q
!= '\0' && *q
!= '\n')
3002 if (q
[0] == '\\' && q
[1] == '\n')
3003 q
+= 2; /* remove '\\' and '\n' */
3009 # ifndef NO_CMD_DEFAULT
3010 if (strnicmp (new_line
, "echo", 4) == 0
3011 && (new_line
[4] == ' ' || new_line
[4] == '\t'))
3013 /* the builtin echo command: handle it separately */
3014 size_t echo_len
= line_len
- 5;
3015 char *echo_line
= new_line
+ 5;
3017 /* special case: echo 'x="y"'
3018 cmd works this way: a string is printed as is, i.e., no quotes
3019 are removed. But autoconf uses a command like echo 'x="y"' to
3020 determine whether make works. autoconf expects the output x="y"
3021 so we will do exactly that.
3022 Note: if we do not allow cmd to be the default shell
3023 we do not need this kind of voodoo */
3024 if (echo_line
[0] == '\''
3025 && echo_line
[echo_len
- 1] == '\''
3026 && strncmp (echo_line
+ 1, "ac_maketemp=",
3027 strlen ("ac_maketemp=")) == 0)
3029 /* remove the enclosing quotes */
3030 memmove (echo_line
, echo_line
+ 1, echo_len
- 2);
3031 echo_line
[echo_len
- 2] = '\0';
3037 /* Let the shell decide what to do. Put the command line into the
3038 2nd command line argument and hope for the best ;-) */
3039 size_t sh_len
= strlen (shell
);
3041 /* exactly 3 arguments + NULL */
3042 new_argv
= xmalloc (4 * sizeof (char *));
3043 /* Exactly strlen(shell) + strlen("/c") + strlen(line) + 3 times
3044 the trailing '\0' */
3045 new_argv
[0] = xmalloc (sh_len
+ line_len
+ 5);
3046 memcpy (new_argv
[0], shell
, sh_len
+ 1);
3047 new_argv
[1] = new_argv
[0] + sh_len
+ 1;
3048 memcpy (new_argv
[1], "/c", 3);
3049 new_argv
[2] = new_argv
[1] + 3;
3050 memcpy (new_argv
[2], new_line
, line_len
+ 1);
3054 #elif defined(__MSDOS__)
3057 /* With MSDOS shells, we must construct the command line here
3058 instead of recursively calling ourselves, because we
3059 cannot backslash-escape the special characters (see above). */
3060 new_argv
= xmalloc (sizeof (char *));
3061 line_len
= strlen (new_line
) - shell_len
- sflags_len
- 2;
3062 new_argv
[0] = xmalloc (line_len
+ 1);
3063 strncpy (new_argv
[0],
3064 new_line
+ shell_len
+ sflags_len
+ 2, line_len
);
3065 new_argv
[0][line_len
] = '\0';
3069 fatal (NILF
, _("%s (line %d) Bad shell context (!unixy && !batch_mode_shell)\n"),
3070 __FILE__
, __LINE__
);
3073 #endif /* ! AMIGA */
3079 /* Figure out the argument list necessary to run LINE as a command. Try to
3080 avoid using a shell. This routine handles only ' quoting, and " quoting
3081 when no backslash, $ or ` characters are seen in the quotes. Starting
3082 quotes may be escaped with a backslash. If any of the characters in
3083 sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[]
3084 is the first word of a line, the shell is used.
3086 If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
3087 If *RESTP is NULL, newlines will be ignored.
3089 FILE is the target whose commands these are. It is used for
3090 variable expansion for $(SHELL) and $(IFS). */
3093 construct_command_argv (char *line
, char **restp
, struct file
*file
,
3094 int cmd_flags
, char **batch_filename_ptr
)
3096 char *shell
, *ifs
, *shellflags
;
3108 && (isspace ((unsigned char)*cptr
)))
3113 && (!isspace((unsigned char)*cptr
)))
3118 argv
= xmalloc (argc
* sizeof (char *));
3127 && (isspace ((unsigned char)*cptr
)))
3131 DB (DB_JOBS
, ("argv[%d] = [%s]\n", argc
, cptr
));
3132 argv
[argc
++] = cptr
;
3134 && (!isspace((unsigned char)*cptr
)))
3141 /* Turn off --warn-undefined-variables while we expand SHELL and IFS. */
3142 int save
= warn_undefined_variables_flag
;
3143 warn_undefined_variables_flag
= 0;
3145 shell
= allocated_variable_expand_for_file ("$(SHELL)", file
);
3148 * Convert to forward slashes so that construct_command_argv_internal()
3152 char *p
= w32ify (shell
, 0);
3158 static const char *unixroot
= NULL
;
3159 static const char *last_shell
= "";
3160 static int init
= 0;
3163 unixroot
= getenv ("UNIXROOT");
3164 /* unixroot must be NULL or not empty */
3165 if (unixroot
&& unixroot
[0] == '\0') unixroot
= NULL
;
3169 /* if we have an unixroot drive and if shell is not default_shell
3170 (which means it's either cmd.exe or the test has already been
3171 performed) and if shell is an absolute path without drive letter,
3172 try whether it exists e.g.: if "/bin/sh" does not exist use
3173 "$UNIXROOT/bin/sh" instead. */
3174 if (unixroot
&& shell
&& strcmp (shell
, last_shell
) != 0
3175 && (shell
[0] == '/' || shell
[0] == '\\'))
3177 /* trying a new shell, check whether it exists */
3178 size_t size
= strlen (shell
);
3179 char *buf
= xmalloc (size
+ 7);
3180 memcpy (buf
, shell
, size
);
3181 memcpy (buf
+ size
, ".exe", 5); /* including the trailing '\0' */
3182 if (access (shell
, F_OK
) != 0 && access (buf
, F_OK
) != 0)
3184 /* try the same for the unixroot drive */
3185 memmove (buf
+ 2, buf
, size
+ 5);
3186 buf
[0] = unixroot
[0];
3187 buf
[1] = unixroot
[1];
3188 if (access (buf
, F_OK
) == 0)
3189 /* we have found a shell! */
3199 #endif /* __EMX__ */
3201 shellflags
= allocated_variable_expand_for_file ("$(.SHELLFLAGS)", file
);
3202 ifs
= allocated_variable_expand_for_file ("$(IFS)", file
);
3204 warn_undefined_variables_flag
= save
;
3207 argv
= construct_command_argv_internal (line
, restp
, shell
, shellflags
, ifs
,
3208 cmd_flags
, batch_filename_ptr
);
3217 #if !defined(HAVE_DUP2) && !defined(_AMIGA)
3219 dup2 (int old
, int new)
3234 #endif /* !HAVE_DUP2 && !_AMIGA */
3236 /* On VMS systems, include special VMS functions. */
3239 #include "vmsjobs.c"