Click above to get retro games delivered to your door ever month!

 spawnv()                Execute Program Using Argument Array

 #include   <process.h>
 #include   <stdio.h>

 int        spawnv(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

    spawnv() 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 (valid in OS/2 protected mode only).

      P_NOWAITO     Execute parent process concurrently with child
                    process and ignore wait() and cwait() calls against
                    child process (valid in OS/2 protected mode only).

      P_OVERLAY     Overlay child process in memory occupied by parent
                    process.  This is equivalent to using the execv()
                    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 spawnv() searches for 'pathname' and, if
    it is not found, it first appends ".COM" and searches again, followed
    by ".EXE" if still not found.

    '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 maximum length of the combined strings forming the argument list
    passed to the child process must not exceed 128 bytes.  This includes
    "n" (for 0 to n arguments) space characters (required to separate the
    arguments), but does not include the null ('\0') terminating
    character.

    Returns:    When the mode is P_NOWAIT or P_NOWAITO, the spawn
                functions return the process ID. To obtain the exit code
                for a process spawned with P_NOWAIT, call wait() or
                cwait() and specify the process ID. No exit code can be
                obtained for P_NOWAITO.

                When the mode is P_WAIT, 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.

                On error, -1 is returned 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 spawn call is made remains open in the
                child process.  This includes 'stdin','stdout', 'stderr',
                'stdaux', and 'stdprn'.

                The environment of the calling process is inherited by
                the child.

                The translation modes of open files are not preserved in
                a call to spawnv().  setmode() can be used in the child
                process to set the desired translation modes.

                Signal settings are reset to the default in the child
                process; they are not preserved.

 Portability:   OS/2 or MS-DOS 3.0 and higher only.

   -------------------------------- Example ---------------------------------

    The following statements transfer execution to the child process
    "child.exe" and pass it the three arguments "child", "arg1", and
    "arg2".  The exit status of the child is printed upon return.

           #include <process.h>    /* for 'spawnv' 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};

           main()
           {
               int result;

               result = spawnv(P_WAIT, "child.exe", args);
               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);
               }
           }