1 /* Job execution and handling for GNU Make.
2 Copyright (C) 1988, 89, 90, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
3 This file is part of GNU Make.
5 GNU Make is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
10 GNU Make is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with GNU Make; see the file COPYING. If not, write to
17 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
26 /* Default shell to use. */
27 char default_shell
[] = "/bin/sh";
31 static int dos_pid
= 123;
32 static int dos_status
;
33 static char *dos_bname
;
34 static char *dos_bename
;
35 static int dos_batch_file
;
39 /* If NGROUPS_MAX == 0 then try other methods for finding a real value. */
40 #if defined (NGROUPS_MAX) && NGROUPS_MAX == 0
42 #endif /* NGROUPS_MAX == 0 */
46 #define GET_NGROUPS_MAX sysconf (_SC_NGROUPS_MAX)
47 #else /* Not POSIX. */
48 #define NGROUPS_MAX NGROUPS
52 #ifdef HAVE_SYS_WAIT_H
57 #define WAIT_NOHANG(status) waitpid (-1, (status), WNOHANG)
58 #else /* Don't have waitpid. */
63 #define WAIT_NOHANG(status) wait3 ((status), WNOHANG, (struct rusage *) 0)
64 #endif /* Have wait3. */
65 #endif /* Have waitpid. */
67 #if !defined (wait) && !defined (POSIX)
71 #ifndef HAVE_UNION_WAIT
76 #define WTERMSIG(x) ((x) & 0x7f)
79 #define WCOREDUMP(x) ((x) & 0x80)
82 #define WEXITSTATUS(x) (((x) >> 8) & 0xff)
85 #define WIFSIGNALED(x) (WTERMSIG (x) != 0)
88 #define WIFEXITED(x) (WTERMSIG (x) == 0)
91 #else /* Have `union wait'. */
93 #define WAIT_T union wait
95 #define WTERMSIG(x) ((x).w_termsig)
98 #define WCOREDUMP(x) ((x).w_coredump)
101 #define WEXITSTATUS(x) ((x).w_retcode)
104 #define WIFSIGNALED(x) (WTERMSIG(x) != 0)
107 #define WIFEXITED(x) (WTERMSIG(x) == 0)
110 #endif /* Don't have `union wait'. */
113 #ifndef HAVE_UNISTD_H
115 extern int execve ();
116 extern void _exit ();
117 extern int geteuid (), getegid ();
118 extern int setgid (), getgid ();
121 #ifndef getdtablesize
122 #ifdef HAVE_GETDTABLESIZE
123 extern int getdtablesize ();
125 #ifdef HAVE_SYSCONF_OPEN_MAX
126 #define getdtablesize() ((int) sysconf (_SC_OPEN_MAX))
128 #include <sys/param.h>
129 #define getdtablesize() NOFILE
130 #if !defined (NOFILE) && defined (NOFILES_MAX)
131 /* SCO 3.2 "devsys 4.2" defines NOFILES_{MIN,MAX} in lieu of NOFILE. */
132 #define NOFILE NOFILES_MAX
138 extern int getloadavg ();
139 extern int start_remote_job_p ();
140 extern int start_remote_job (), remote_status ();
142 RETSIGTYPE
child_handler ();
143 static void free_child (), start_job_command ();
144 static int load_too_high (), job_next_command ();
146 /* Chain of all live (or recently deceased) children. */
148 struct child
*children
= 0;
150 /* Number of children currently running. */
152 unsigned int job_slots_used
= 0;
154 /* Nonzero if the `good' standard input is in use. */
156 static int good_stdin_used
= 0;
158 /* Chain of children waiting to run until the load average goes down. */
160 static struct child
*waiting_jobs
= 0;
162 /* Write an error message describing the exit status given in
163 EXIT_CODE, EXIT_SIG, and COREDUMP, for the target TARGET_NAME.
164 Append "(ignored)" if IGNORED is nonzero. */
167 child_error (target_name
, exit_code
, exit_sig
, coredump
, ignored
)
169 int exit_code
, exit_sig
, coredump
;
173 error (ignored
? "[%s] Error %d (ignored)" :
175 target_name
, exit_code
);
177 error ("*** [%s] %s%s",
178 target_name
, strsignal (exit_sig
),
179 coredump
? " (core dumped)" : "");
182 static unsigned int dead_children
= 0;
184 /* Notice that a child died.
185 reap_children should be called when convenient. */
193 printf ("Got a SIGCHLD; %d unreaped children.\n", dead_children
);
196 extern int shell_function_pid
, shell_function_completed
;
198 /* Reap dead children, storing the returned status and the new command
199 state (`cs_finished') in the `file' member of the `struct child' for the
200 dead child, and removing the child from the chain. If BLOCK nonzero,
201 reap at least one child, waiting for it to die if necessary. If ERR is
202 nonzero, print an error message first. */
205 reap_children (block
, err
)
210 while ((children
!= 0 || shell_function_pid
!= 0) &&
211 (block
|| dead_children
> 0))
215 int exit_code
, exit_sig
, coredump
;
216 register struct child
*lastc
, *c
;
218 int any_remote
, any_local
;
220 if (err
&& dead_children
== 0)
222 /* We might block for a while, so let the user know why. */
224 error ("*** Waiting for unfinished jobs....");
227 /* We have one less dead child to reap.
228 The test and decrement are not atomic; if it is compiled into:
229 register = dead_children - 1;
230 dead_children = register;
231 a SIGCHLD could come between the two instructions.
232 child_handler increments dead_children.
233 The second instruction here would lose that increment. But the
234 only effect of dead_children being wrong is that we might wait
235 longer than necessary to reap a child, and lose some parallelism;
236 and we might print the "Waiting for unfinished jobs" message above
237 when not necessary. */
239 if (dead_children
!= 0)
243 any_local
= shell_function_pid
!= -1;
244 for (c
= children
; c
!= 0; c
= c
->next
)
246 any_remote
|= c
->remote
;
247 any_local
|= ! c
->remote
;
249 printf ("Live child 0x%08lx PID %d%s\n",
250 (unsigned long int) c
,
251 c
->pid
, c
->remote
? " (remote)" : "");
254 /* First, check for remote children. */
256 pid
= remote_status (&exit_code
, &exit_sig
, &coredump
, 0);
266 pfatal_with_name ("remote_status");
271 /* No remote children. Check for local children. */
277 pid
= WAIT_NOHANG (&status
);
280 pid
= wait (&status
);
291 pfatal_with_name ("wait");
295 /* No local children. */
296 if (block
&& any_remote
)
298 /* Now try a blocking wait for a remote child. */
299 pid
= remote_status (&exit_code
, &exit_sig
, &coredump
, 1);
301 goto remote_status_lose
;
303 /* No remote children either. Finally give up. */
306 /* We got a remote child. */
314 /* Chop the status word up. */
315 exit_code
= WEXITSTATUS (status
);
316 exit_sig
= WIFSIGNALED (status
) ? WTERMSIG (status
) : 0;
317 coredump
= WCOREDUMP (status
);
320 /* Life is very different on MSDOS. */
323 exit_code
= dos_status
;
326 #endif /* Not MSDOS. */
329 /* We got a remote child. */
332 /* Check if this is the child of the `shell' function. */
333 if (!remote
&& pid
== shell_function_pid
)
335 /* It is. Leave an indicator for the `shell' function. */
336 if (exit_sig
== 0 && exit_code
== 127)
337 shell_function_completed
= -1;
339 shell_function_completed
= 1;
343 child_failed
= exit_sig
!= 0 || exit_code
!= 0;
345 /* Search for a child matching the deceased one. */
347 for (c
= children
; c
!= 0; lastc
= c
, c
= c
->next
)
348 if (c
->remote
== remote
&& c
->pid
== pid
)
353 /* An unknown child died. */
355 sprintf (buf
, "Unknown%s job %d", remote
? " remote" : "", pid
);
357 child_error (buf
, exit_code
, exit_sig
, coredump
,
360 error ("%s finished.", buf
);
365 printf ("Reaping %s child 0x%08lx PID %d%s\n",
366 child_failed
? "losing" : "winning",
367 (unsigned long int) c
,
368 c
->pid
, c
->remote
? " (remote)" : "");
370 /* If this child had the good stdin, say it is now free. */
374 if (child_failed
&& !c
->noerror
&& !ignore_errors_flag
)
376 /* The commands failed. Write an error message,
377 delete non-precious targets, and abort. */
378 static int delete_on_error
= -1;
379 child_error (c
->file
->name
, exit_code
, exit_sig
, coredump
, 0);
380 c
->file
->update_status
= 2;
381 if (delete_on_error
== -1)
383 struct file
*f
= lookup_file (".DELETE_ON_ERROR");
384 delete_on_error
= f
!= 0 && f
->is_target
;
386 if (exit_sig
!= 0 || delete_on_error
)
387 delete_child_targets (c
);
393 /* The commands failed, but we don't care. */
394 child_error (c
->file
->name
,
395 exit_code
, exit_sig
, coredump
, 1);
399 /* If there are more commands to run, try to start them. */
400 if (job_next_command (c
))
402 if (handling_fatal_signal
)
404 /* Never start new commands while we are dying.
405 Since there are more commands that wanted to be run,
406 the target was not completely remade. So we treat
407 this as if a command had failed. */
408 c
->file
->update_status
= 2;
412 /* Check again whether to start remotely.
413 Whether or not we want to changes over time.
414 Also, start_remote_job may need state set up
415 by start_remote_job_p. */
416 c
->remote
= start_remote_job_p ();
417 start_job_command (c
);
418 if (c
->file
->command_state
== cs_running
)
419 /* We successfully started the new command.
420 Loop to reap more children. */
424 if (c
->file
->update_status
!= 0)
425 /* We failed to start the commands. */
426 delete_child_targets (c
);
429 /* There are no more commands. We got through them all
430 without an unignored error. Now the target has been
431 successfully updated. */
432 c
->file
->update_status
= 0;
435 /* When we get here, all the commands for C->file are finished
436 (or aborted) and C->file->update_status contains 0 or 2. But
437 C->file->command_state is still cs_running if all the commands
438 ran; notice_finish_file looks for cs_running to tell it that
439 it's interesting to check the file's modtime again now. */
441 if (! handling_fatal_signal
)
442 /* Notice if the target of the commands has been changed.
443 This also propagates its values for command_state and
444 update_status to its also_make files. */
445 notice_finished_file (c
->file
);
448 printf ("Removing child 0x%08lx PID %d%s from chain.\n",
449 (unsigned long int) c
,
450 c
->pid
, c
->remote
? " (remote)" : "");
452 /* Remove the child from the chain and free it. */
456 lastc
->next
= c
->next
;
457 if (! handling_fatal_signal
) /* Avoid nonreentrancy. */
460 /* There is now another slot open. */
463 /* If the job failed, and the -k flag was not given, die,
464 unless we are already in the process of dying. */
465 if (!err
&& child_failed
&& !keep_going_flag
)
469 /* Only block for one child. */
474 /* Free the storage allocated for CHILD. */
478 register struct child
*child
;
480 if (child
->command_lines
!= 0)
482 register unsigned int i
;
483 for (i
= 0; i
< child
->file
->cmds
->ncommand_lines
; ++i
)
484 free (child
->command_lines
[i
]);
485 free ((char *) child
->command_lines
);
488 if (child
->environment
!= 0)
490 register char **ep
= child
->environment
;
493 free ((char *) child
->environment
);
496 free ((char *) child
);
507 extern sigset_t fatal_signal_set
;
513 sigemptyset (&empty
);
514 sigprocmask (SIG_SETMASK
, &empty
, (sigset_t
*) 0);
519 /* Start a job to run the commands specified in CHILD.
520 CHILD is updated to reflect the commands and ID of the child process. */
523 start_job_command (child
)
524 register struct child
*child
;
526 static int bad_stdin
= -1;
531 /* Combine the flags parsed for the line itself with
532 the flags specified globally for this target. */
533 flags
= (child
->file
->command_flags
534 | child
->file
->cmds
->lines_flags
[child
->command_line
- 1]);
536 p
= child
->command_ptr
;
537 child
->noerror
= flags
& COMMANDS_NOERROR
;
541 flags
|= COMMANDS_SILENT
;
543 flags
|= COMMANDS_RECURSE
;
546 else if (!isblank (*p
) && *p
!= '+')
551 /* If -q was given, just say that updating `failed'. The exit status of
552 1 tells the user that -q is saying `something to do'; the exit status
553 for a random error is 2. */
554 if (question_flag
&& !(flags
& COMMANDS_RECURSE
))
556 child
->file
->update_status
= 1;
557 notice_finished_file (child
->file
);
561 /* There may be some preceding whitespace left if there
562 was nothing but a backslash on the first line. */
565 /* Figure out an argument list from this command line. */
569 argv
= construct_command_argv (p
, &end
, child
->file
);
571 child
->command_ptr
= NULL
;
575 child
->command_ptr
= end
;
579 if (touch_flag
&& !(flags
& COMMANDS_RECURSE
))
581 /* Go on to the next command. It might be the recursive one.
582 We construct ARGV only to find the end of the command line. */
584 free ((char *) argv
);
591 /* This line has no commands. Go to the next. */
592 if (job_next_command (child
))
593 start_job_command (child
);
596 /* No more commands. All done. */
597 child
->file
->update_status
= 0;
598 notice_finished_file (child
->file
);
603 /* Print out the command. */
605 if (just_print_flag
|| (!(flags
& COMMANDS_SILENT
) && !silent_flag
))
608 /* Tell update_goal_chain that a command has been started on behalf of
609 this target. It is important that this happens here and not in
610 reap_children (where we used to do it), because reap_children might be
611 reaping children from a different target. We want this increment to
612 guaranteedly indicate that a command was started for the dependency
613 chain (i.e., update_file recursion chain) we are processing. */
617 /* If -n was given, recurse to get the next line in the sequence. */
619 if (just_print_flag
&& !(flags
& COMMANDS_RECURSE
))
622 free ((char *) argv
);
626 /* Flush the output streams so they won't have things written twice. */
631 /* Set up a bad standard input that reads from a broken pipe. */
635 /* Make a file descriptor that is the read end of a broken pipe.
636 This will be used for some children's standard inputs. */
640 /* Close the write side. */
641 (void) close (pd
[1]);
642 /* Save the read side. */
647 /* Decide whether to give this child the `good' standard input
648 (one that points to the terminal or whatever), or the `bad' one
649 that points to the read side of a broken pipe. */
651 child
->good_stdin
= !good_stdin_used
;
652 if (child
->good_stdin
)
657 /* Set up the environment for the child. */
658 if (child
->environment
== 0)
659 child
->environment
= target_environment (child
->file
);
663 /* start_waiting_job has set CHILD->remote if we can start a remote job. */
666 int is_remote
, id
, used_stdin
;
667 if (start_remote_job (argv
, child
->environment
,
668 child
->good_stdin
? 0 : bad_stdin
,
669 &is_remote
, &id
, &used_stdin
))
673 if (child
->good_stdin
&& !used_stdin
)
675 child
->good_stdin
= 0;
678 child
->remote
= is_remote
;
684 /* Fork the child process. */
686 char **parent_environ
;
689 (void) sigprocmask (SIG_BLOCK
, &fatal_signal_set
, (sigset_t
*) 0);
691 #ifdef HAVE_SIGSETMASK
692 (void) sigblock (fatal_signal_mask
);
697 parent_environ
= environ
;
698 child
->pid
= vfork ();
699 environ
= parent_environ
; /* Restore value child may have clobbered. */
702 /* We are the child side. */
704 child_execute_job (child
->good_stdin
? 0 : bad_stdin
, 1,
705 argv
, child
->environment
);
707 else if (child
->pid
< 0)
711 perror_with_name ("vfork", "");
717 dos_status
= spawnvpe (P_WAIT
, argv
[0], argv
, child
->environment
);
719 child
->pid
= dos_pid
++;
723 remove (dos_bname
); /* Ignore errors. */
724 if (access (dos_bename
, 0))
730 #endif /* Not MSDOS. */
732 /* We are the parent side. Set the state to
733 say the commands are running and return. */
735 set_command_state (child
->file
, cs_running
);
737 /* Free the storage used by the child's argument list. */
740 free ((char *) argv
);
745 child
->file
->update_status
= 2;
746 notice_finished_file (child
->file
);
749 /* Try to start a child running.
750 Returns nonzero if the child was started (and maybe finished), or zero if
751 the load was too high and the child was put on the `waiting_jobs' chain. */
754 start_waiting_job (c
)
757 /* If we can start a job remotely, we always want to, and don't care about
758 the local load average. We record that the job should be started
759 remotely in C->remote for start_job_command to test. */
761 c
->remote
= start_remote_job_p ();
763 /* If this job is to be started locally, and we are already running
764 some jobs, make this one wait if the load average is too high. */
765 if (!c
->remote
&& job_slots_used
> 0 && load_too_high ())
767 /* Put this child on the chain of children waiting
768 for the load average to go down. */
769 set_command_state (c
->file
, cs_running
);
770 c
->next
= waiting_jobs
;
775 /* Start the first command; reap_children will run later command lines. */
776 start_job_command (c
);
778 switch (c
->file
->command_state
)
783 printf ("Putting child 0x%08lx PID %05d%s on the chain.\n",
784 (unsigned long int) c
,
785 c
->pid
, c
->remote
? " (remote)" : "");
787 /* One more job slot is in use. */
793 /* All the command lines turned out to be empty. */
794 c
->file
->update_status
= 0;
798 notice_finished_file (c
->file
);
803 assert (c
->file
->command_state
== cs_finished
);
810 /* Create a `struct child' for FILE and start its commands running. */
814 register struct file
*file
;
816 register struct commands
*cmds
= file
->cmds
;
817 register struct child
*c
;
819 register unsigned int i
;
821 /* Let any previously decided-upon jobs that are waiting
822 for the load to go down start before this new one. */
823 start_waiting_jobs ();
825 /* Reap any children that might have finished recently. */
826 reap_children (0, 0);
828 /* Chop the commands up into lines if they aren't already. */
829 chop_commands (cmds
);
832 /* Wait for a job slot to be freed up. */
833 while (job_slots_used
== job_slots
)
834 reap_children (1, 0);
836 /* Expand the command lines and store the results in LINES. */
837 lines
= (char **) xmalloc (cmds
->ncommand_lines
* sizeof (char *));
838 for (i
= 0; i
< cmds
->ncommand_lines
; ++i
)
840 /* Collapse backslash-newline combinations that are inside variable
841 or function references. These are left alone by the parser so
842 that they will appear in the echoing of commands (where they look
843 nice); and collapsed by construct_command_argv when it tokenizes.
844 But letting them survive inside function invocations loses because
845 we don't want the functions to see them as part of the text. */
847 char *in
, *out
, *ref
;
849 /* IN points to where in the line we are scanning.
850 OUT points to where in the line we are writing.
851 When we collapse a backslash-newline combination,
852 IN gets ahead out OUT. */
854 in
= out
= cmds
->command_lines
[i
];
855 while ((ref
= index (in
, '$')) != 0)
857 ++ref
; /* Move past the $. */
860 /* Copy the text between the end of the last chunk
861 we processed (where IN points) and the new chunk
862 we are about to process (where REF points). */
863 bcopy (in
, out
, ref
- in
);
865 /* Move both pointers past the boring stuff. */
869 if (*ref
== '(' || *ref
== '{')
871 char openparen
= *ref
;
872 char closeparen
= openparen
== '(' ? ')' : '}';
876 *out
++ = *in
++; /* Copy OPENPAREN. */
877 /* IN now points past the opening paren or brace.
878 Count parens or braces until it is matched. */
882 if (*in
== closeparen
&& --count
< 0)
884 else if (*in
== '\\' && in
[1] == '\n')
886 /* We have found a backslash-newline inside a
887 variable or function reference. Eat it and
888 any following whitespace. */
891 for (p
= in
- 1; p
> ref
&& *p
== '\\'; --p
)
895 /* There were two or more backslashes, so this is
896 not really a continuation line. We don't collapse
897 the quoting backslashes here as is done in
898 collapse_continuations, because the line will
899 be collapsed again after expansion. */
903 /* Skip the backslash, newline and
904 any following whitespace. */
905 in
= next_token (in
+ 2);
907 /* Discard any preceding whitespace that has
908 already been written to the output. */
909 while (out
> ref
&& isblank (out
[-1]))
912 /* Replace it all with a single space. */
918 if (*in
== openparen
)
927 /* There are no more references in this line to worry about.
928 Copy the remaining uninteresting text to the output. */
932 /* Finally, expand the line. */
933 lines
[i
] = allocated_variable_expand_for_file (cmds
->command_lines
[i
],
937 /* Start the command sequence, record it in a new
938 `struct child', and add that to the chain. */
940 c
= (struct child
*) xmalloc (sizeof (struct child
));
942 c
->command_lines
= lines
;
947 /* Fetch the first command line to be run. */
948 job_next_command (c
);
950 /* The job is now primed. Start it running.
951 (This will notice if there are in fact no commands.) */
952 start_waiting_job (c
);
955 /* Since there is only one job slot, make things run linearly.
956 Wait for the child to die, setting the state to `cs_finished'. */
957 while (file
->command_state
== cs_running
)
958 reap_children (1, 0);
961 /* Move CHILD's pointers to the next command for it to execute.
962 Returns nonzero if there is another command. */
965 job_next_command (child
)
968 while (child
->command_ptr
== 0 || *child
->command_ptr
== '\0')
970 /* There are no more lines in the expansion of this line. */
971 if (child
->command_line
== child
->file
->cmds
->ncommand_lines
)
973 /* There are no more lines to be expanded. */
974 child
->command_ptr
= 0;
978 /* Get the next line to run. */
979 child
->command_ptr
= child
->command_lines
[child
->command_line
++];
990 extern int getloadavg ();
993 if (max_load_average
< 0)
997 if (getloadavg (&load
, 1) != 1)
999 static int lossage
= -1;
1000 /* Complain only once for the same error. */
1001 if (lossage
== -1 || errno
!= lossage
)
1004 /* An errno value of zero means getloadavg is just unsupported. */
1005 error ("cannot enforce load limits on this operating system");
1007 perror_with_name ("cannot enforce load limit: ", "getloadavg");
1014 return load
>= max_load_average
;
1018 /* Start jobs that are waiting for the load to be lower. */
1021 start_waiting_jobs ()
1025 if (waiting_jobs
== 0)
1030 /* Check for recently deceased descendants. */
1031 reap_children (0, 0);
1033 /* Take a job off the waiting list. */
1035 waiting_jobs
= job
->next
;
1037 /* Try to start that job. We break out of the loop as soon
1038 as start_waiting_job puts one back on the waiting list. */
1039 } while (start_waiting_job (job
) && waiting_jobs
!= 0);
1042 /* Replace the current process with one executing the command in ARGV.
1043 STDIN_FD and STDOUT_FD are used as the process's stdin and stdout; ENVP is
1044 the environment of the new program. This function does not return. */
1047 child_execute_job (stdin_fd
, stdout_fd
, argv
, envp
)
1048 int stdin_fd
, stdout_fd
;
1049 char **argv
, **envp
;
1052 (void) dup2 (stdin_fd
, 0);
1054 (void) dup2 (stdout_fd
, 1);
1056 /* Free up file descriptors. */
1059 int max
= getdtablesize ();
1060 for (d
= 3; d
< max
; ++d
)
1064 /* Run the command. */
1065 exec_command (argv
, envp
);
1068 /* Replace the current process with one running the command in ARGV,
1069 with environment ENVP. This function does not return. */
1072 exec_command (argv
, envp
)
1073 char **argv
, **envp
;
1075 /* Be the user, permanently. */
1078 /* Run the program. */
1080 execvp (argv
[0], argv
);
1085 error ("%s: Command not found", argv
[0]);
1089 /* The file is not executable. Try it as a shell script. */
1090 extern char *getenv ();
1095 shell
= getenv ("SHELL");
1097 shell
= default_shell
;
1100 while (argv
[argc
] != 0)
1103 new_argv
= (char **) alloca ((1 + argc
+ 1) * sizeof (char *));
1104 new_argv
[0] = shell
;
1105 new_argv
[1] = program
;
1108 new_argv
[1 + argc
] = argv
[argc
];
1112 execvp (shell
, new_argv
);
1113 if (errno
== ENOENT
)
1114 error ("%s: Shell program not found", shell
);
1116 perror_with_name ("execvp: ", shell
);
1121 perror_with_name ("execvp: ", argv
[0]);
1128 /* Figure out the argument list necessary to run LINE as a command. Try to
1129 avoid using a shell. This routine handles only ' quoting, and " quoting
1130 when no backslash, $ or ` characters are seen in the quotes. Starting
1131 quotes may be escaped with a backslash. If any of the characters in
1132 sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[]
1133 is the first word of a line, the shell is used.
1135 If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
1136 If *RESTP is NULL, newlines will be ignored.
1138 SHELL is the shell to use, or nil to use the default shell.
1139 IFS is the value of $IFS, or nil (meaning the default). */
1142 construct_command_argv_internal (line
, restp
, shell
, ifs
)
1143 char *line
, **restp
;
1147 static char sh_chars
[] = "\"|<>";
1148 static char *sh_cmds
[] = { "break", "call", "cd", "chcp", "chdir", "cls",
1149 "copy", "ctty", "date", "del", "dir", "echo",
1150 "erase", "exit", "for", "goto", "if", "if", "md",
1151 "mkdir", "path", "pause", "prompt", "rem", "ren",
1152 "rename", "set", "shift", "time", "type",
1153 "ver", "verify", "vol", ":", 0 };
1155 static char sh_chars
[] = "#;\"*?[]&|<>(){}$`^";
1156 static char *sh_cmds
[] = { "cd", "eval", "exec", "exit", "login",
1157 "logout", "set", "umask", "wait", "while", "for",
1158 "case", "if", ":", ".", "break", "continue",
1159 "export", "read", "readonly", "shift", "times",
1160 "trap", "switch", 0 };
1166 int instring
, word_has_equals
, seen_nonequals
;
1167 char **new_argv
= 0;
1172 /* Make sure not to bother processing an empty line. */
1173 while (isblank (*line
))
1178 /* See if it is safe to parse commands internally. */
1180 shell
= default_shell
;
1181 else if (strcmp (shell
, default_shell
))
1185 for (ap
= ifs
; *ap
!= '\0'; ++ap
)
1186 if (*ap
!= ' ' && *ap
!= '\t' && *ap
!= '\n')
1189 i
= strlen (line
) + 1;
1191 /* More than 1 arg per character is impossible. */
1192 new_argv
= (char **) xmalloc (i
* sizeof (char *));
1194 /* All the args can fit in a buffer as big as LINE is. */
1195 ap
= new_argv
[0] = (char *) xmalloc (i
);
1198 /* I is how many complete arguments have been found. */
1200 instring
= word_has_equals
= seen_nonequals
= 0;
1201 for (p
= line
; *p
!= '\0'; ++p
)
1209 /* Inside a string, just copy any char except a closing quote
1210 or a backslash-newline combination. */
1213 else if (*p
== '\\' && p
[1] == '\n')
1214 goto swallow_escaped_newline
;
1215 else if (*p
== '\n' && restp
!= NULL
)
1217 /* End of the command line. */
1221 /* Backslash, $, and ` are special inside double quotes.
1222 If we see any of those, punt. */
1223 else if (instring
== '"' && index ("\\$`", *p
) != 0)
1228 else if (index (sh_chars
, *p
) != 0)
1229 /* Not inside a string, but it's a special char. */
1232 /* Not a special char. */
1236 /* Equals is a special character in leading words before the
1237 first word with no equals sign in it. This is not the case
1238 with sh -k, but we never get here when using nonstandard
1240 if (! seen_nonequals
)
1242 word_has_equals
= 1;
1247 /* Backslash-newline combinations are eaten. */
1250 swallow_escaped_newline
:
1252 /* Eat the backslash, the newline, and following whitespace,
1253 replacing it all with a single space. */
1256 /* If there is a tab after a backslash-newline,
1257 remove it from the source line which will be echoed,
1258 since it was most likely used to line
1259 up the continued line with the previous one. */
1267 if (ap
!= new_argv
[i
])
1268 /* Treat this as a space, ending the arg.
1269 But if it's at the beginning of the arg, it should
1270 just get eaten, rather than becoming an empty arg. */
1273 p
= next_token (p
) - 1;
1276 else if (p
[1] != '\0')
1277 /* Copy and skip the following char. */
1289 /* End of the command line. */
1294 /* Newlines are not special. */
1301 /* We have the end of an argument.
1302 Terminate the text of the argument. */
1306 /* Update SEEN_NONEQUALS, which tells us if every word
1307 heretofore has contained an `='. */
1308 seen_nonequals
|= ! word_has_equals
;
1309 if (word_has_equals
&& ! seen_nonequals
)
1310 /* An `=' in a word before the first
1311 word without one is magical. */
1313 word_has_equals
= 0; /* Prepare for the next word. */
1315 /* If this argument is the command name,
1316 see if it is a built-in shell command.
1317 If so, have the shell handle it. */
1321 for (j
= 0; sh_cmds
[j
] != 0; ++j
)
1322 if (streq (sh_cmds
[j
], new_argv
[0]))
1326 /* Ignore multiple whitespace chars. */
1328 /* Next iteration should examine the first nonwhite char. */
1340 /* Let the shell deal with an unterminated quote. */
1343 /* Terminate the last argument and the argument list. */
1346 if (new_argv
[i
][0] != '\0')
1353 for (j
= 0; sh_cmds
[j
] != 0; ++j
)
1354 if (streq (sh_cmds
[j
], new_argv
[0]))
1358 if (new_argv
[0] == 0)
1359 /* Line was empty. */
1365 /* We must use the shell. */
1369 /* Free the old argument list we were working on. */
1380 dos_bname
= tempnam (".", "mk");
1381 for (i
= 0; dos_bname
[i
] != '\0'; ++i
)
1382 if (dos_bname
[i
] == '/')
1383 dos_bname
[i
] = '\\';
1384 dos_bename
= (char *) xmalloc (strlen (dos_bname
) + 5);
1385 strcpy (dos_bename
, dos_bname
);
1386 strcat (dos_bname
, ".bat");
1387 strcat (dos_bename
, ".err");
1389 batch
= fopen (dos_bename
, "w"); /* Create a file. */
1392 batch
= fopen (dos_bname
, "w");
1393 fputs ("@echo off\n", batch
);
1394 fputs (line
, batch
);
1395 fprintf (batch
, "\nif errorlevel 1 del %s\n", dos_bename
);
1397 new_argv
= (char **) xmalloc(2 * sizeof(char *));
1398 new_argv
[0] = strdup (dos_bname
);
1401 #else /* Not MSDOS. */
1403 /* SHELL may be a multi-word command. Construct a command line
1404 "SHELL -c LINE", with all special chars in LINE escaped.
1405 Then recurse, expanding this command line to get the final
1408 unsigned int shell_len
= strlen (shell
);
1409 static char minus_c
[] = " -c ";
1410 unsigned int line_len
= strlen (line
);
1412 char *new_line
= (char *) alloca (shell_len
+ (sizeof (minus_c
) - 1)
1413 + (line_len
* 2) + 1);
1416 bcopy (shell
, ap
, shell_len
);
1418 bcopy (minus_c
, ap
, sizeof (minus_c
) - 1);
1419 ap
+= sizeof (minus_c
) - 1;
1420 for (p
= line
; *p
!= '\0'; ++p
)
1422 if (restp
!= NULL
&& *p
== '\n')
1427 else if (*p
== '\\' && p
[1] == '\n')
1429 /* Eat the backslash, the newline, and following whitespace,
1430 replacing it all with a single space (which is escaped
1434 /* If there is a tab after a backslash-newline,
1435 remove it from the source line which will be echoed,
1436 since it was most likely used to line
1437 up the continued line with the previous one. */
1448 if (*p
== '\\' || *p
== '\'' || *p
== '"'
1450 || index (sh_chars
, *p
) != 0)
1456 new_argv
= construct_command_argv_internal (new_line
, (char **) NULL
,
1457 (char *) 0, (char *) 0);
1464 /* Figure out the argument list necessary to run LINE as a command. Try to
1465 avoid using a shell. This routine handles only ' quoting, and " quoting
1466 when no backslash, $ or ` characters are seen in the quotes. Starting
1467 quotes may be escaped with a backslash. If any of the characters in
1468 sh_chars[] is seen, or any of the builtin commands listed in sh_cmds[]
1469 is the first word of a line, the shell is used.
1471 If RESTP is not NULL, *RESTP is set to point to the first newline in LINE.
1472 If *RESTP is NULL, newlines will be ignored.
1474 FILE is the target whose commands these are. It is used for
1475 variable expansion for $(SHELL) and $(IFS). */
1478 construct_command_argv (line
, restp
, file
)
1479 char *line
, **restp
;
1486 /* Turn off --warn-undefined-variables while we expand SHELL and IFS. */
1487 int save
= warn_undefined_variables_flag
;
1488 warn_undefined_variables_flag
= 0;
1490 shell
= allocated_variable_expand_for_file ("$(SHELL)", file
);
1491 ifs
= allocated_variable_expand_for_file ("$(IFS)", file
);
1493 warn_undefined_variables_flag
= save
;
1496 argv
= construct_command_argv_internal (line
, restp
, shell
, ifs
);