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

spawn...(modeflag, pathname, arg-list | arg-array[,envp]);

    Like the exec...() functions, the eight spawn...() functions load and
    execute a new program, known as a child process.  There must be
    sufficient memory to load and execute the child process.

    The spawn family of functions differ from the exec family in only one
    particular: They have an additional argument, 'modeflag'.  This
    argument specifies whether the parent process will be overlaid in
    memory by the child process (thereby destroying the parent); run
    concurrently with the child; or suspended until the child process
    terminates.  The first option--overlaying the parent in memory--is
    equivalent to the corresponding exec function.

    All eight of the spawn functions perform the same operation; they
    differ only in how arguments are passed, the use of the DOS PATH in
    searching for the program to be run ('pathname'), and the use of the
    DOS environment. The eight functions offer various combinations of
    argument passing, use of the DOS PATH, and the environment:

                  Arguments to Child                         Passes New
                     Passed As            Searches DOS       Environment
    Function       List    Array         PATH for Child        String

    spawnl()         .
    spawnle()        .                                             .
    spawnlp()        .                          .
    spawnlpe()       .                          .                  .
    spawnv()                  .
    spawnve()                 .                                    .
    spawnvp()                 .                 .
    spawnvpe()                .                 .                  .


  Arguments:    Arguments are passed to the new process by including one
                or more pointers to character strings in the spawn()
                call. The character strings can be passed either as a
                list of separate arguments, or as an array of pointers.
                Spawn functions with an 'l' in their name use the list
                method; functions with a 'v' pass an array of pointers:

                The spawn functions that use a list to pass arguments to
                the child process are usually used when the number of
                arguments is known in advance. In this case, the first
                argument in the list is by convention a pointer to
                'pathname', while the remaining arguments in the list
                point to character strings that constitute the argument
                list of the child process. The last pointer must be NULL,
                to mark the end of the list.

                The spawn functions that use an array of pointers to pass
                arguments to the child process are used when the number
                of arguments is not known in advance. The first pointer
                in the array usually points to 'pathname', and the last
                must be a NULL pointer.

       PATH:    The spawn functions with a 'p' in their name search for
                'pathname' using the DOS PATH environment variable.

Environment:    Four of the spawn functions--spawnl, spawnlp, spawnv, and
                spawnvp--allow the child process to inherit the calling
                program's environment. The other four functions--those
                with an 'e' at the end of their name (spawnle, spawnlpe,
                spawnve, and spawnvpe)--allow the calling program to
                alter the called program's environment by passing a list
                of environment settings in the 'envp' argument.

    For details on using the spawn() functions, see the entry for the
    particular function you're interested in.