Header File 

process.h  

Category 

Process Control Routines 

Prototype 

int execl(char *path, char *arg0 *arg1, ..., *argn, NULL); 

int _wexecl(wchar_t *path, wchar_t *arg0 *arg1, ..., *argn, NULL); 

int execle(char *path, char *arg0, *arg1, ..., *argn, NULL, char **env); 

int _wexecle(wchar_t *path, wchar_t *arg0, *arg1, ..., *argn, NULL, wchar_t **env); 

int execlp(char *path, char *arg0,*arg1, ..., *argn, NULL); 

int _wexeclp(wchar_t *path, wchar_t *arg0,*arg1, ..., *argn, NULL); 

int execlpe(char *path, char *arg0, *arg1, ..., *argn, NULL, char **env); 

int _wexeclpe(wchar_t *path, wchar_t *arg0, *arg1, ..., *argn, NULL, wchar_t **env); 

int execv(char *path, char *argv[]); 

int _wexecv(wchar_t *path, wchar_t *argv[]); 

int execve(char *path, char *argv[], char **env); 

int _wexecve(wchar_t *path, wchar_t *argv[], wchar_t **env); 

int execvp(char *path, char *argv[]); 

int _wexecvp(wchar_t *path, wchar_t *argv[]); 

int execvpe(char *path, char *argv[], char **env); 

int _wexecvpe(wchar_t *path, wchar_t *argv[], wchar_t **env); 

Description 

Loads and runs other programs. 

The functions in the exec... family load and run (execute) other programs, known as child processes. When an exec... call succeeds, the child process overlays the parent process. There must be sufficient memory available for loading and executing the child process. 

path is the file name of the called child process. The exec... functions search for path using the standard search algorithm:

• If no explicit extension is given, the functions search for the file as given. If the file is not found, they add .EXE and search again. If not found, they add .COM and search again. If found, the command processor, COMSPEC (Windows) or COMMAND.COM (DOS), is used to run the batch file.
• If an explicit extension or a period is given, the functions search for the file exactly as given.

Each function in the exec... family must have one of the two argument-specifying suffixes (either l or v). The path search and environment inheritance suffixes (p and e) are optional; for example:

• execl is an exec... function that takes separate arguments, searches only the root or current directory for the child, and passes on the parent's environment to the child.
• execvpe is an exec... function that takes an array of argument pointers, incorporates PATH in its search for the child process, and accepts the env argument for altering the child's environment.

path is available for the child process. 

When the l suffix is used, arg0 usually points to path, and arg1, ..., argn point to character strings that form the new list of arguments. A mandatory null following argn marks the end of the list. 

When the e suffix is used, you pass a list of new environment settings through the argument env. This environment argument is an array of character pointers. Each element points to a null-terminated character string of the form 

envvar = value 

where envvar is the name of an environment variable, and value is the string value to which envvar is set. The last element in env is null. When env is null, the child inherits the parents' environment settings. 

The combined length of arg0 + arg1 + ... + argn (or of argv[0] + argv[1] + ... + argn[n]), including space characters that separate the arguments, must be less than 260 bytes. Null terminators are not counted. 

When an exec... function call is made, any open files remain open in the child process. 

Return Value 

If successful, the exec... functions do not return. On error, the exec... functions return -1, and the global variable errno is set to one of the following values:

Example

/* execl() example */
#include <stdio.h>
#include <process.h>
 
int main(int argc, char *argv[])
{
  int loop;
  printf("%s running...\n\n", argv[0]);
 
  if (argc == 1) {    /* check for only one command-line parameter */
    printf("%s calling itself again...\n", argv[0]);
    execl(argv[0], argv[0], "ONE", "TWO", "THREE", NULL);
    perror("EXEC:");
    exit(1);
  }
  printf("%s called with arguments:\n", argv[0]);
  for (loop = 1; loop <= argc; loop++)
    puts(argv[loop]);       /* Display all command-line parameters */
  return 0;
}