mirror of
https://git.savannah.gnu.org/git/make.git
synced 2024-11-25 04:35:44 +00:00
757849cd93
* output.c (error, fatal, message): Take an extra argument specifying how many bytes are used by the formatted arguments. (get_buffer): New function that allocates the requested buffer size. Remove msc_vsnprintf(), vfmtconcat(), and fmtconcat() as unneeded. * makeint.h: Declare various helper macros for generating output. * *.c: Change all error(), fatal(), message() calls to use the macros, or pass the extra length argument directly.
719 lines
19 KiB
C
719 lines
19 KiB
C
/* --------------- Moved here from job.c ---------------
|
|
This file must be #included in job.c, as it accesses static functions.
|
|
|
|
Copyright (C) 1996-2013 Free Software Foundation, Inc.
|
|
This file is part of GNU Make.
|
|
|
|
GNU Make is free software; you can redistribute it and/or modify it under the
|
|
terms of the GNU General Public License as published by the Free Software
|
|
Foundation; either version 3 of the License, or (at your option) any later
|
|
version.
|
|
|
|
GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
|
|
A PARTICULAR PURPOSE. See the GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along with
|
|
this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
|
#include <string.h>
|
|
#include <descrip.h>
|
|
#include <clidef.h>
|
|
|
|
char *vmsify (char *name, int type);
|
|
|
|
static int vms_jobsefnmask = 0;
|
|
|
|
/* Wait for nchildren children to terminate */
|
|
static void
|
|
vmsWaitForChildren(int *status)
|
|
{
|
|
while (1)
|
|
{
|
|
if (!vms_jobsefnmask)
|
|
{
|
|
*status = 0;
|
|
return;
|
|
}
|
|
|
|
*status = sys$wflor (32, vms_jobsefnmask);
|
|
}
|
|
return;
|
|
}
|
|
|
|
/* Set up IO redirection. */
|
|
|
|
char *
|
|
vms_redirect (struct dsc$descriptor_s *desc, char *fname, char *ibuf)
|
|
{
|
|
char *fptr;
|
|
|
|
ibuf++;
|
|
while (isspace ((unsigned char)*ibuf))
|
|
ibuf++;
|
|
fptr = ibuf;
|
|
while (*ibuf && !isspace ((unsigned char)*ibuf))
|
|
ibuf++;
|
|
*ibuf = 0;
|
|
if (strcmp (fptr, "/dev/null") != 0)
|
|
{
|
|
strcpy (fname, vmsify (fptr, 0));
|
|
if (strchr (fname, '.') == 0)
|
|
strcat (fname, ".");
|
|
}
|
|
desc->dsc$w_length = strlen (fname);
|
|
desc->dsc$a_pointer = fname;
|
|
desc->dsc$b_dtype = DSC$K_DTYPE_T;
|
|
desc->dsc$b_class = DSC$K_CLASS_S;
|
|
|
|
if (*fname == 0)
|
|
printf (_("Warning: Empty redirection\n"));
|
|
return ibuf;
|
|
}
|
|
|
|
|
|
/* found apostrophe at (p-1)
|
|
inc p until after closing apostrophe.
|
|
*/
|
|
|
|
char *
|
|
vms_handle_apos (char *p)
|
|
{
|
|
int alast;
|
|
|
|
#define SEPCHARS ",/()= "
|
|
|
|
alast = 0;
|
|
|
|
while (*p != 0)
|
|
if (*p == '"')
|
|
if (alast)
|
|
{
|
|
alast = 0;
|
|
p++;
|
|
}
|
|
else
|
|
{
|
|
p++;
|
|
if (strchr (SEPCHARS, *p))
|
|
break;
|
|
alast = 1;
|
|
}
|
|
else
|
|
p++;
|
|
|
|
return p;
|
|
}
|
|
|
|
static int ctrlYPressed= 0;
|
|
/* This is called at main or AST level. It is at AST level for DONTWAITFORCHILD
|
|
and at main level otherwise. In any case it is called when a child process
|
|
terminated. At AST level it won't get interrupted by anything except a
|
|
inner mode level AST.
|
|
*/
|
|
int
|
|
vmsHandleChildTerm(struct child *child)
|
|
{
|
|
int status;
|
|
register struct child *lastc, *c;
|
|
int child_failed;
|
|
|
|
vms_jobsefnmask &= ~(1 << (child->efn - 32));
|
|
|
|
lib$free_ef (&child->efn);
|
|
if (child->comname)
|
|
{
|
|
if (!ISDB (DB_JOBS) && !ctrlYPressed)
|
|
unlink (child->comname);
|
|
free (child->comname);
|
|
}
|
|
|
|
(void) sigblock (fatal_signal_mask);
|
|
|
|
child_failed = !(child->cstatus & 1 || ((child->cstatus & 7) == 0));
|
|
|
|
/* Search for a child matching the deceased one. */
|
|
lastc = 0;
|
|
#if defined(RECURSIVEJOBS) /* I've had problems with recursive stuff and process handling */
|
|
for (c = children; c != 0 && c != child; lastc = c, c = c->next)
|
|
;
|
|
#else
|
|
c = child;
|
|
#endif
|
|
|
|
if (child_failed && !c->noerror && !ignore_errors_flag)
|
|
{
|
|
/* The commands failed. Write an error message,
|
|
delete non-precious targets, and abort. */
|
|
child_error (c, c->cstatus, 0, 0, 0);
|
|
c->file->update_status = us_failed;
|
|
delete_child_targets (c);
|
|
}
|
|
else
|
|
{
|
|
if (child_failed)
|
|
{
|
|
/* The commands failed, but we don't care. */
|
|
child_error (c, c->cstatus, 0, 0, 1);
|
|
child_failed = 0;
|
|
}
|
|
|
|
#if defined(RECURSIVEJOBS) /* I've had problems with recursive stuff and process handling */
|
|
/* If there are more commands to run, try to start them. */
|
|
start_job (c);
|
|
|
|
switch (c->file->command_state)
|
|
{
|
|
case cs_running:
|
|
/* Successfully started. */
|
|
break;
|
|
|
|
case cs_finished:
|
|
if (c->file->update_status != us_success)
|
|
/* We failed to start the commands. */
|
|
delete_child_targets (c);
|
|
break;
|
|
|
|
default:
|
|
OS (error, NILF,
|
|
_("internal error: '%s' command_state"), c->file->name);
|
|
abort ();
|
|
break;
|
|
}
|
|
#endif /* RECURSIVEJOBS */
|
|
}
|
|
|
|
/* Set the state flag to say the commands have finished. */
|
|
c->file->command_state = cs_finished;
|
|
notice_finished_file (c->file);
|
|
|
|
#if defined(RECURSIVEJOBS) /* I've had problems with recursive stuff and process handling */
|
|
/* Remove the child from the chain and free it. */
|
|
if (lastc == 0)
|
|
children = c->next;
|
|
else
|
|
lastc->next = c->next;
|
|
free_child (c);
|
|
#endif /* RECURSIVEJOBS */
|
|
|
|
/* There is now another slot open. */
|
|
if (job_slots_used > 0)
|
|
--job_slots_used;
|
|
|
|
/* If the job failed, and the -k flag was not given, die. */
|
|
if (child_failed && !keep_going_flag)
|
|
die (EXIT_FAILURE);
|
|
|
|
(void) sigsetmask (sigblock (0) & ~(fatal_signal_mask));
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* VMS:
|
|
Spawn a process executing the command in ARGV and return its pid. */
|
|
|
|
#define MAXCMDLEN 200
|
|
|
|
/* local helpers to make ctrl+c and ctrl+y working, see below */
|
|
#include <iodef.h>
|
|
#include <libclidef.h>
|
|
#include <ssdef.h>
|
|
|
|
static int ctrlMask= LIB$M_CLI_CTRLY;
|
|
static int oldCtrlMask;
|
|
static int setupYAstTried= 0;
|
|
static unsigned short int chan= 0;
|
|
|
|
static void
|
|
reEnableAst(void)
|
|
{
|
|
lib$enable_ctrl (&oldCtrlMask,0);
|
|
}
|
|
|
|
static int
|
|
astYHandler (void)
|
|
{
|
|
struct child *c;
|
|
for (c = children; c != 0; c = c->next)
|
|
sys$delprc (&c->pid, 0, 0);
|
|
ctrlYPressed= 1;
|
|
kill (getpid(),SIGQUIT);
|
|
return SS$_NORMAL;
|
|
}
|
|
|
|
static void
|
|
tryToSetupYAst(void)
|
|
{
|
|
$DESCRIPTOR(inputDsc,"SYS$COMMAND");
|
|
int status;
|
|
struct {
|
|
short int status, count;
|
|
int dvi;
|
|
} iosb;
|
|
unsigned short int loc_chan;
|
|
|
|
setupYAstTried++;
|
|
|
|
if (chan)
|
|
loc_chan= chan;
|
|
else
|
|
{
|
|
status= sys$assign(&inputDsc,&loc_chan,0,0);
|
|
if (!(status&SS$_NORMAL))
|
|
{
|
|
lib$signal(status);
|
|
return;
|
|
}
|
|
}
|
|
status= sys$qiow (0, loc_chan, IO$_SETMODE|IO$M_CTRLYAST,&iosb,0,0,
|
|
astYHandler,0,0,0,0,0);
|
|
if (status==SS$_NORMAL)
|
|
status= iosb.status;
|
|
if (status!=SS$_NORMAL)
|
|
{
|
|
if (!chan)
|
|
sys$dassgn(loc_chan);
|
|
if (status!=SS$_ILLIOFUNC && status!=SS$_NOPRIV)
|
|
lib$signal(status);
|
|
return;
|
|
}
|
|
|
|
/* called from AST handler ? */
|
|
if (setupYAstTried>1)
|
|
return;
|
|
if (atexit(reEnableAst))
|
|
fprintf (stderr,
|
|
_("-warning, you may have to re-enable CTRL-Y handling from DCL.\n"));
|
|
status= lib$disable_ctrl (&ctrlMask, &oldCtrlMask);
|
|
if (!(status&SS$_NORMAL))
|
|
{
|
|
lib$signal(status);
|
|
return;
|
|
}
|
|
if (!chan)
|
|
chan = loc_chan;
|
|
}
|
|
|
|
int
|
|
child_execute_job (char *argv, struct child *child)
|
|
{
|
|
int i;
|
|
static struct dsc$descriptor_s cmddsc;
|
|
static struct dsc$descriptor_s pnamedsc;
|
|
static struct dsc$descriptor_s ifiledsc;
|
|
static struct dsc$descriptor_s ofiledsc;
|
|
static struct dsc$descriptor_s efiledsc;
|
|
int have_redirection = 0;
|
|
int have_append = 0;
|
|
int have_newline = 0;
|
|
|
|
int spflags = CLI$M_NOWAIT;
|
|
int status;
|
|
char *cmd = alloca (strlen (argv) + 512), *p, *q;
|
|
char ifile[256], ofile[256], efile[256];
|
|
int comnamelen;
|
|
char procname[100];
|
|
int in_string;
|
|
|
|
/* Parse IO redirection. */
|
|
|
|
ifile[0] = 0;
|
|
ofile[0] = 0;
|
|
efile[0] = 0;
|
|
child->comname = NULL;
|
|
|
|
DB (DB_JOBS, ("child_execute_job (%s)\n", argv));
|
|
|
|
while (isspace ((unsigned char)*argv))
|
|
argv++;
|
|
|
|
if (*argv == 0)
|
|
return 0;
|
|
|
|
sprintf (procname, "GMAKE_%05x", getpid () & 0xfffff);
|
|
pnamedsc.dsc$w_length = strlen(procname);
|
|
pnamedsc.dsc$a_pointer = procname;
|
|
pnamedsc.dsc$b_dtype = DSC$K_DTYPE_T;
|
|
pnamedsc.dsc$b_class = DSC$K_CLASS_S;
|
|
|
|
in_string = 0;
|
|
/* Handle comments and redirection. */
|
|
for (p = argv, q = cmd; *p; p++, q++)
|
|
{
|
|
if (*p == '"')
|
|
in_string = !in_string;
|
|
if (in_string)
|
|
{
|
|
*q = *p;
|
|
continue;
|
|
}
|
|
switch (*p)
|
|
{
|
|
case '#':
|
|
*p-- = 0;
|
|
*q-- = 0;
|
|
break;
|
|
case '\\':
|
|
p++;
|
|
if (*p == '\n')
|
|
p++;
|
|
if (isspace ((unsigned char)*p))
|
|
{
|
|
do { p++; } while (isspace ((unsigned char)*p));
|
|
p--;
|
|
}
|
|
*q = *p;
|
|
break;
|
|
case '<':
|
|
p = vms_redirect (&ifiledsc, ifile, p);
|
|
*q = ' ';
|
|
have_redirection = 1;
|
|
break;
|
|
case '>':
|
|
have_redirection = 1;
|
|
if (*(p-1) == '2')
|
|
{
|
|
q--;
|
|
if (strncmp (p, ">&1", 3) == 0)
|
|
{
|
|
p += 3;
|
|
strcpy (efile, "sys$output");
|
|
efiledsc.dsc$w_length = strlen(efile);
|
|
efiledsc.dsc$a_pointer = efile;
|
|
efiledsc.dsc$b_dtype = DSC$K_DTYPE_T;
|
|
efiledsc.dsc$b_class = DSC$K_CLASS_S;
|
|
}
|
|
else
|
|
p = vms_redirect (&efiledsc, efile, p);
|
|
}
|
|
else
|
|
{
|
|
if (*(p+1) == '>')
|
|
{
|
|
have_append = 1;
|
|
p += 1;
|
|
}
|
|
p = vms_redirect (&ofiledsc, ofile, p);
|
|
}
|
|
*q = ' ';
|
|
break;
|
|
case '\n':
|
|
have_newline = 1;
|
|
default:
|
|
*q = *p;
|
|
break;
|
|
}
|
|
}
|
|
*q = *p;
|
|
while (isspace ((unsigned char)*--q))
|
|
*q = '\0';
|
|
|
|
if (strncmp (cmd, "builtin_", 8) == 0)
|
|
{
|
|
child->pid = 270163;
|
|
child->efn = 0;
|
|
child->cstatus = 1;
|
|
|
|
DB (DB_JOBS, (_("BUILTIN [%s][%s]\n"), cmd, cmd+8));
|
|
|
|
p = cmd + 8;
|
|
|
|
if ((*(p) == 'c')
|
|
&& (*(p+1) == 'd')
|
|
&& ((*(p+2) == ' ') || (*(p+2) == '\t')))
|
|
{
|
|
p += 3;
|
|
while ((*p == ' ') || (*p == '\t'))
|
|
p++;
|
|
DB (DB_JOBS, (_("BUILTIN CD %s\n"), p));
|
|
if (chdir (p))
|
|
return 0;
|
|
else
|
|
return 1;
|
|
}
|
|
else if ((*(p) == 'r')
|
|
&& (*(p+1) == 'm')
|
|
&& ((*(p+2) == ' ') || (*(p+2) == '\t')))
|
|
{
|
|
int in_arg;
|
|
|
|
/* rm */
|
|
p += 3;
|
|
while ((*p == ' ') || (*p == '\t'))
|
|
p++;
|
|
in_arg = 1;
|
|
|
|
DB (DB_JOBS, (_("BUILTIN RM %s\n"), p));
|
|
while (*p)
|
|
{
|
|
switch (*p)
|
|
{
|
|
case ' ':
|
|
case '\t':
|
|
if (in_arg)
|
|
{
|
|
*p++ = ';';
|
|
in_arg = 0;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
p++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf (_("Unknown builtin command '%s'\n"), cmd);
|
|
fflush (stdout);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* Create a *.com file if either the command is too long for
|
|
lib$spawn, or the command contains a newline, or if redirection
|
|
is desired. Forcing commands with newlines into DCLs allows to
|
|
store search lists on user mode logicals. */
|
|
|
|
if (strlen (cmd) > MAXCMDLEN
|
|
|| (have_redirection != 0)
|
|
|| (have_newline != 0))
|
|
{
|
|
FILE *outfile;
|
|
char c;
|
|
char *sep;
|
|
int alevel = 0; /* apostrophe level */
|
|
|
|
if (strlen (cmd) == 0)
|
|
{
|
|
printf (_("Error, empty command\n"));
|
|
fflush (stdout);
|
|
return 0;
|
|
}
|
|
|
|
outfile = output_tmpfile (&child->comname, "sys$scratch:CMDXXXXXX.COM");
|
|
if (outfile == 0)
|
|
pfatal_with_name (_("fopen (temporary file)"));
|
|
comnamelen = strlen (child->comname);
|
|
|
|
if (ifile[0])
|
|
{
|
|
fprintf (outfile, "$ assign/user %s sys$input\n", ifile);
|
|
DB (DB_JOBS, (_("Redirected input from %s\n"), ifile));
|
|
ifiledsc.dsc$w_length = 0;
|
|
}
|
|
|
|
if (efile[0])
|
|
{
|
|
fprintf (outfile, "$ define sys$error %s\n", efile);
|
|
DB (DB_JOBS, (_("Redirected error to %s\n"), efile));
|
|
efiledsc.dsc$w_length = 0;
|
|
}
|
|
|
|
if (ofile[0])
|
|
if (have_append)
|
|
{
|
|
fprintf (outfile, "$ set noon\n");
|
|
fprintf (outfile, "$ define sys$output %.*s\n", comnamelen-3, child->comname);
|
|
DB (DB_JOBS, (_("Append output to %s\n"), ofile));
|
|
ofiledsc.dsc$w_length = 0;
|
|
}
|
|
else
|
|
{
|
|
fprintf (outfile, "$ define sys$output %s\n", ofile);
|
|
DB (DB_JOBS, (_("Redirected output to %s\n"), ofile));
|
|
ofiledsc.dsc$w_length = 0;
|
|
}
|
|
|
|
p = sep = q = cmd;
|
|
for (c = '\n'; c; c = *q++)
|
|
{
|
|
switch (c)
|
|
{
|
|
case '\n':
|
|
/* At a newline, skip any whitespace around a leading $
|
|
from the command and issue exactly one $ into the DCL. */
|
|
while (isspace ((unsigned char)*p))
|
|
p++;
|
|
if (*p == '$')
|
|
p++;
|
|
while (isspace ((unsigned char)*p))
|
|
p++;
|
|
fwrite (p, 1, q - p, outfile);
|
|
fputc ('$', outfile);
|
|
fputc (' ', outfile);
|
|
/* Reset variables. */
|
|
p = sep = q;
|
|
break;
|
|
|
|
/* Nice places for line breaks are after strings, after
|
|
comma or space and before slash. */
|
|
case '"':
|
|
q = vms_handle_apos (q);
|
|
sep = q;
|
|
break;
|
|
case ',':
|
|
case ' ':
|
|
sep = q;
|
|
break;
|
|
case '/':
|
|
case '\0':
|
|
sep = q - 1;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if (sep - p > 78)
|
|
{
|
|
/* Enough stuff for a line. */
|
|
fwrite (p, 1, sep - p, outfile);
|
|
p = sep;
|
|
if (*sep)
|
|
{
|
|
/* The command continues. */
|
|
fputc ('-', outfile);
|
|
}
|
|
fputc ('\n', outfile);
|
|
}
|
|
}
|
|
|
|
if (*p)
|
|
{
|
|
fwrite (p, 1, --q - p, outfile);
|
|
fputc ('\n', outfile);
|
|
}
|
|
|
|
if (have_append)
|
|
{
|
|
fprintf (outfile, "$ deassign sys$output ! 'f$verify(0)\n");
|
|
fprintf (outfile, "$ append:=append\n");
|
|
fprintf (outfile, "$ delete:=delete\n");
|
|
fprintf (outfile, "$ append/new %.*s %s\n", comnamelen-3, child->comname, ofile);
|
|
fprintf (outfile, "$ delete %.*s;*\n", comnamelen-3, child->comname);
|
|
DB (DB_JOBS, (_("Append %.*s and cleanup\n"), comnamelen-3, child->comname));
|
|
}
|
|
|
|
fclose (outfile);
|
|
|
|
sprintf (cmd, "$ @%s", child->comname);
|
|
|
|
DB (DB_JOBS, (_("Executing %s instead\n"), cmd));
|
|
}
|
|
|
|
cmddsc.dsc$w_length = strlen(cmd);
|
|
cmddsc.dsc$a_pointer = cmd;
|
|
cmddsc.dsc$b_dtype = DSC$K_DTYPE_T;
|
|
cmddsc.dsc$b_class = DSC$K_CLASS_S;
|
|
|
|
child->efn = 0;
|
|
while (child->efn < 32 || child->efn > 63)
|
|
{
|
|
status = lib$get_ef ((unsigned long *)&child->efn);
|
|
if (!(status & 1))
|
|
{
|
|
if (child->comname)
|
|
{
|
|
if (!ISDB (DB_JOBS))
|
|
unlink (child->comname);
|
|
free (child->comname);
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
sys$clref (child->efn);
|
|
|
|
vms_jobsefnmask |= (1 << (child->efn - 32));
|
|
|
|
/*
|
|
LIB$SPAWN [command-string]
|
|
[,input-file]
|
|
[,output-file]
|
|
[,flags]
|
|
[,process-name]
|
|
[,process-id] [,completion-status-address] [,byte-integer-event-flag-num]
|
|
[,AST-address] [,varying-AST-argument]
|
|
[,prompt-string] [,cli] [,table]
|
|
*/
|
|
|
|
#ifndef DONTWAITFORCHILD
|
|
/*
|
|
* Code to make ctrl+c and ctrl+y working.
|
|
* The problem starts with the synchronous case where after lib$spawn is
|
|
* called any input will go to the child. But with input re-directed,
|
|
* both control characters won't make it to any of the programs, neither
|
|
* the spawning nor to the spawned one. Hence the caller needs to spawn
|
|
* with CLI$M_NOWAIT to NOT give up the input focus. A sys$waitfr
|
|
* has to follow to simulate the wanted synchronous behaviour.
|
|
* The next problem is ctrl+y which isn't caught by the crtl and
|
|
* therefore isn't converted to SIGQUIT (for a signal handler which is
|
|
* already established). The only way to catch ctrl+y, is an AST
|
|
* assigned to the input channel. But ctrl+y handling of DCL needs to be
|
|
* disabled, otherwise it will handle it. Not to mention the previous
|
|
* ctrl+y handling of DCL needs to be re-established before make exits.
|
|
* One more: At the time of LIB$SPAWN signals are blocked. SIGQUIT will
|
|
* make it to the signal handler after the child "normally" terminates.
|
|
* This isn't enough. It seems reasonable for simple command lines like
|
|
* a 'cc foobar.c' spawned in a subprocess but it is unacceptable for
|
|
* spawning make. Therefore we need to abort the process in the AST.
|
|
*
|
|
* Prior to the spawn it is checked if an AST is already set up for
|
|
* ctrl+y, if not one is set up for a channel to SYS$COMMAND. In general
|
|
* this will work except if make is run in a batch environment, but there
|
|
* nobody can press ctrl+y. During the setup the DCL handling of ctrl+y
|
|
* is disabled and an exit handler is established to re-enable it.
|
|
* If the user interrupts with ctrl+y, the assigned AST will fire, force
|
|
* an abort to the subprocess and signal SIGQUIT, which will be caught by
|
|
* the already established handler and will bring us back to common code.
|
|
* After the spawn (now /nowait) a sys$waitfr simulates the /wait and
|
|
* enables the ctrl+y be delivered to this code. And the ctrl+c too,
|
|
* which the crtl converts to SIGINT and which is caught by the common
|
|
* signal handler. Because signals were blocked before entering this code
|
|
* sys$waitfr will always complete and the SIGQUIT will be processed after
|
|
* it (after termination of the current block, somewhere in common code).
|
|
* And SIGINT too will be delayed. That is ctrl+c can only abort when the
|
|
* current command completes. Anyway it's better than nothing :-)
|
|
*/
|
|
|
|
if (!setupYAstTried)
|
|
tryToSetupYAst();
|
|
status = lib$spawn (&cmddsc, /* cmd-string */
|
|
(ifiledsc.dsc$w_length == 0)?0:&ifiledsc, /* input-file */
|
|
(ofiledsc.dsc$w_length == 0)?0:&ofiledsc, /* output-file */
|
|
&spflags, /* flags */
|
|
&pnamedsc, /* proc name */
|
|
&child->pid, &child->cstatus, &child->efn,
|
|
0, 0,
|
|
0, 0, 0);
|
|
if (status & 1)
|
|
{
|
|
status= sys$waitfr (child->efn);
|
|
vmsHandleChildTerm(child);
|
|
}
|
|
#else
|
|
status = lib$spawn (&cmddsc,
|
|
(ifiledsc.dsc$w_length == 0)?0:&ifiledsc,
|
|
(ofiledsc.dsc$w_length == 0)?0:&ofiledsc,
|
|
&spflags,
|
|
&pnamedsc,
|
|
&child->pid, &child->cstatus, &child->efn,
|
|
vmsHandleChildTerm, child,
|
|
0, 0, 0);
|
|
#endif
|
|
|
|
if (!(status & 1))
|
|
{
|
|
printf (_("Error spawning, %d\n") ,status);
|
|
fflush (stdout);
|
|
switch (status)
|
|
{
|
|
case 0x1c:
|
|
errno = EPROCLIM;
|
|
break;
|
|
default:
|
|
errno = EFAIL;
|
|
}
|
|
}
|
|
|
|
return (status & 1);
|
|
}
|