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

 exec...(pathname, arg-list | arg-arrayl [,envp])

    The eight exec...() functions each load and execute a new program, or
    child process.  Because the child process is placed in the memory
    currently occupied by the calling program, there must be enough
    available memory to load and execute the new program.

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

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

    execl()         .
    execle()        .                                             .
    execlp()        .                          .
    execlpe()       .                          .                  .
    execv()                  .
    execve()                 .                                    .
    execvp()                 .                 .
    execvpe()                .                 .                  .


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

                    The exec 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 exec 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'; the last must be a NULL pointer.

          PATH:     If an explicit extension is given, the file is
                    searched for only as given.

                    If no extension is given, the file is first searched
                    for as given. If the file is not found, the extension
                    .COM is added and that file is searched for. If,
                    again, it is not found, .EXE is added and that file
                    is searched for.

                    The exec functions with a 'p' in their name search
                    for 'pathname' in the current directory. If the file
                    is not found, the DOS PATH environment variable is
                    used.

   Environment:     Four of the exec functions--execl, execlp, execv, and
                    execvp--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
                    (execle, execlpe, execve, and execvpe)--allow the
                    calling program to alter the child program's
                    environment by passing a list of environment settings
                    in the envp argument.

    For details on using the exec() functions, see the entry for the
    particular function that interests you.


         Notes:     The exec functions are a special case of the more
                    general spawn...() functions. The spawn functions
                    include an additional argument, 'modeflag', that
                    determines whether the calling (parent) program will
                    be suspended while the child is running, executed
                    concurrently, or overlaid. The last option (overlaid)
                    is equivalent to the exec function. See the spawn
                    functions for additional details.