spawnve()                Execute Program Using Arg Array, Environment
 
 #include   <process.h>
 #include   <stdio.h>
 
 int        spawnve(modeflag,pathname,argv);
 int        modeflag;                    Execution mode for parent process
 char       *pathname;                   Path name of file to be executed
 char       *argv[];                     Array of pointers to arguments
 
    spawnve() loads and executes a new child process.  'modeflag'
    determines what action the parent process will take after the new
    process is loaded; it should be set to one of the following values
    (defined in <process.h>):
 
        P_WAIT      Wait for child process to finish.
 
        P_NOWAIT    Execute parent process concurrently with child
                    process. (This is not currently implemented, and will
                    return an error value).
 
        P_OVERLAY   Overlay child process in memory occupied by parent
                    process.  This is equivalent to using the execl()
                    function.
 
    'pathname' specifies the file name of the child process.  If
    'pathname' has a file name extension, then only that file is searched
    for. If 'pathname' ends with a period (.), then 'pathname' without an
    extension is searched for.  If 'pathname' has no extension and does
    not end with a period, then spawnve() searches for 'pathname' and, if
    it is not found, appends ".EXE" and searches again.
 
    'argv' points to an array of pointers; the pointers in turn point to
    the strings that are passed to the child process as command line
    parameters.  The 'argv' array is terminated by a NULL pointer at
    'argv[n+1]'. 'argv[0]' must not be NULL, and is usually set to
    'pathname'.
 
    The combined length of all the strings forming the argument list
    passed to the child process must not exceed 128 bytes.  This includes
    "n" (for 0-n arguments) and space characters (required to separate
    the arguments), but does not include the null ('\0') terminating
    character.
 
    'envp' points to an array of pointers that in turn point to strings
    that define environment variables.  These strings usually have the
    form:  "ENVVAR=value", where "ENVVAR" is the name of the environment
    variable and "value' is the string value to set it to.  The 'envp'
    array is terminated by a NULL pointer.  If 'envp' is NULL, then the
    child process acquires the environment of the calling process.
 
    Returns:    The spawn functions return the exit status of the child
                process.  The exit status is zero if the process
                terminated normally and the child process did not call
                the exit routine with a nonzero argument. The child
                process can set the exit status to a nonzero value by
                calling exit() with the desired return value.
 
                If not set by the child process, a positive exit status
                indicates an error by an abort() or an interrupt.
 
                A return value of -1 indicates an error, and errno is set
                to one of the following:
 
                    E2BIG       Argument list or environment list too big.
                                  (List > 128 bytes, or environment > 32k)
                    EINVAL      Invalid 'modeflag' argument
                    ENOENT      File or path not found.
                    ENOEXEC     File not executable.
                    ENOMEM      Not enough memory.
 
                A child process spawned with 'modeflag' set to P_OVERLAY
                does not return to the calling process.
 
      Notes:    Any file open when an exec call is made remains open in
                the child process.  This includes 'stdin','stdout',
                'stderr', 'stdaux', and 'stdprn'.
 
                spawnve() does not preserve the translation modes of open
                files.  Use setmode() in the child process to set the
                desired translation modes.
 
                Signal settings are not preserved.  They are reset to the
                default in the child process.
 
  -------------------------------- Example ---------------------------------
 
    The following statements transfer execution to the child process
    "child.exe" and pass it the three arguments "child", "arg1", and
    "arg2".  The PATH environment variable is set to "C:\\TEST" for the
    child process.  The exit status of the child is printed upon return.
 
        #include <process.h>    /* for 'spawnve' and 'P_WAIT' */
        #include <stdio.h>      /* for 'printf' and 'NULL' */
        #include <stdlib.h>     /* for 'errno' */
        #include <errno.h>      /* for 'ENOENT' and 'ENOMEM' */
 
        char *args[] = {"child", "arg1", "arg2", NULL};
        char *env[] = {"PATH=C:\\TEST", NULL};
 
        main()
        {
            int result;
 
            result = spawnve(P_WAIT, "child.exe", args, env);
            if (result != -1)
                printf("exit status of child.exe = %d\n", result);
            else {
                if (errno == ENOENT)
                    printf("child.exe not found in current directory\n");
                else if (errno == ENOMEM)
                    printf("not enough memory to execute child.exe\n");
                else
                    printf("error #%d trying to spawn child.exe\n", errno);
            }
        }

Seealso:


 spawn...() 
 exec...()