_exec, _wexec Fonctions

Chaque fonction dans cette famille charge et exécute un nouveau processus :

La lettre à la fin du nom de fonction détermine la variance.

Notes

Chaque fonction _exec charge et exécute un nouveau processus. Toutes les _exec fonctions utilisent la même fonction de système d’exploitation (CreateProcess). Les fonctions _exec gèrent automatiquement des arguments de chaîne de caractères multioctets de façon appropriée, en identifiant des séquences de caractères multioctets selon la page de codes multioctets actuellement utilisée. Les fonctions _wexec sont des versions à caractères larges des fonctions _exec. Les _wexec fonctions se comportent de la même façon que leurs _exec équivalents familiaux, sauf qu’elles ne gèrent pas les chaînes de caractères multioctets.

Mappages de routines de texte générique

Le paramètre cmdname spécifie le fichier à exécuter comme nouveau processus. Il peut spécifier un chemin d'accès complet (depuis la racine), un chemin d'accès partiel (depuis le répertoire de travail actif) ou un nom de fichier. Si cmdname elle n’a pas d’extension de nom de fichier ou ne se termine pas par un point (.), la _exec fonction recherche le fichier nommé. Si la recherche n'aboutit pas, elle tente le même nom de base avec l'extension de nom de fichier .com, puis avec les extensions de nom de fichier .exe, .bat et .cmd. Si cmdname a une extension de nom de fichier, seule cette extension est employée dans la recherche. Si cmdname se termine par un point, la fonction _exec recherche cmdname sans extension de nom de fichier. _execlp, _execlpe, _execvp et _execvpe recherchent cmdname (en utilisant les mêmes procédures) dans les répertoires spécifiés par la variable d'environnement PATH. Si cmdname contient un spécificateur de lecteur ou des barres obliques (autrement dit, s’il s’agit d’un chemin relatif), l’appel _exec recherche uniquement le fichier spécifié ; le chemin d’accès n’est pas recherché.

Les paramètres sont passés au nouveau processus en fournissant un ou plusieurs pointeurs vers des chaînes de caractères comme paramètres dans l'appel de fonction _exec. Ces chaînes de caractères forment la liste de paramètres du nouveau processus. La longueur combinée des paramètres d'environnement hérités et des chaînes qui forment la liste de paramètres du nouveau processus ne doit pas dépasser 32 kilo-octets. Le caractère de fin NULL (\0) de chaque chaîne n’est pas inclus dans le nombre, mais les caractères d’espace (insérés automatiquement pour séparer les paramètres) sont comptabilisés.

Les fonctions _exec valident leurs paramètres. Si les paramètres attendus sont des pointeurs Null, des chaînes vides ou omis, les _exec fonctions appellent le gestionnaire de paramètres non valide, comme décrit dans la validation des paramètres. Si l'exécution est autorisée à se poursuivre, ces fonctions définissent errno avec la valeur EINVAL et retournent -1. Aucun nouveau processus n'est exécuté.

Les pointeurs d'argument peuvent être passés comme paramètres distincts (dans _execl, _execle, _execlp et _execlpe) ou comme tableau de pointeurs (dans _execv, _execve, _execvp et _execvpe). Au moins un paramètre, arg0doit être passé au nouveau processus ; ce paramètre est argv[0] du nouveau processus. Généralement, ce paramètre est une copie de cmdname. (Une autre valeur ne produit pas d’erreur.)

Les appels de fonctions _execl, _execle, _execlp et _execlpe sont généralement utilisés quand le nombre de paramètres est connu à l'avance. Le paramètre arg0 est généralement un pointeur vers cmdname. Les paramètres arg1 à argn pointent vers les chaînes de caractères qui forment la nouvelle liste de paramètres. Un pointeur Null doit suivre argn pour marquer la fin de la liste de paramètres.

Les appels de fonctions _execv, _execve, _execvp et _execvpe sont utiles quand le nombre de paramètres du nouveau processus est variable. Les pointeurs vers les paramètres sont passés comme tableau, argv. Le paramètre argv[0] est généralement un pointeur vers cmdname. Les paramètres argv[1] à argv[n] pointent vers les chaînes de caractères qui forment la nouvelle liste de paramètres. Le paramètre argv[n+1] doit être un NULL pointeur pour marquer la fin de la liste des paramètres.

Les fichiers qui sont ouverts quand un appel de fonction _exec est effectué restent ouverts dans le nouveau processus. Dans les appels de fonctions _execl, _execlp, _execv et _execvp, le nouveau processus hérite de l'environnement du processus appelant. Les appels de fonctions _execle, _execlpe, _execve et _execvpe modifient l'environnement du nouveau processus en passant une liste de paramètres d'environnement via le paramètre envp. envp est un tableau de pointeurs de caractères, dont chaque élément (excepté le dernier) pointe vers une chaîne terminée par le caractère Null définissant une variable d'environnement. Une telle chaîne a généralement la forme NAME=value où NAME est le nom d’une variable d’environnement et value est la valeur de chaîne selon laquelle cette variable est définie. (Les value guillemets doubles ne sont pas placés entre guillemets.) L’élément final du envp tableau doit être NULL. Quand envp lui-même a la valeur NULL, le nouveau processus hérite des paramètres d'environnement du processus appelant.

Un programme exécuté avec l’une des _exec fonctions est toujours chargé en mémoire, comme si le champ d’allocation maximal dans l’en-tête de fichier .exe du programme a été défini sur la valeur par défaut de 0xFFFFH.

Les _exec appels ne conservent pas les modes de traduction des fichiers ouverts. Si le nouveau processus doit utiliser des fichiers hérités du processus appelant, utilisez la _setmode routine pour définir le mode de traduction de ces fichiers en mode souhaité. Vous devez explicitement vider (à l'aide de fflush ou de _flushall) ou fermer tout flux avant l'appel de fonction _exec. Les paramètres de signal ne sont pas conservés dans les nouveaux processus créés par des appels à _exec des routines. Les paramètres de signal sont réinitialisés à la valeur par défaut dans le nouveau processus.

Exemple

// crt_args.c
// Illustrates the following variables used for accessing
// command-line arguments and environment variables:
// argc  argv  envp
// This program will be executed by crt_exec which follows.

#include <stdio.h>

int main( int argc,  // Number of strings in array argv
char *argv[],       // Array of command-line argument strings
char **envp )       // Array of environment variable strings
{
    int count;

    // Display each command-line argument.
    printf( "\nCommand-line arguments:\n" );
    for( count = 0; count < argc; count++ )
        printf( "  argv[%d]   %s\n", count, argv[count] );

    // Display each environment variable.
    printf( "\nEnvironment variables:\n" );
    while( *envp != NULL )
        printf( "  %s\n", *(envp++) );

    return;
}

Lancez le programme suivant pour exécuter Crt_args.exe :

// crt_exec.c
// Illustrates the different versions of exec, including
//      _execl          _execle          _execlp          _execlpe
//      _execv          _execve          _execvp          _execvpe
//
// Although CRT_EXEC.C can exec any program, you can verify how
// different versions handle arguments and environment by
// compiling and specifying the sample program CRT_ARGS.C. See
// "_spawn, _wspawn Functions" for examples of the similar spawn
// functions.

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

char *my_env[] =     // Environment for exec?e
{
   "THIS=environment will be",
   "PASSED=to new process by",
   "the EXEC=functions",
   NULL
};

int main( int ac, char* av[] )
{
   char *args[4];
   int ch;
   if( ac != 3 ){
      fprintf( stderr, "Usage: %s <program> <number (1-8)>\n", av[0] );
      return;
   }

   // Arguments for _execv?
   args[0] = av[1];
   args[1] = "exec??";
   args[2] = "two";
   args[3] = NULL;

   switch( atoi( av[2] ) )
   {
   case 1:
      _execl( av[1], av[1], "_execl", "two", NULL );
      break;
   case 2:
      _execle( av[1], av[1], "_execle", "two", NULL, my_env );
      break;
   case 3:
      _execlp( av[1], av[1], "_execlp", "two", NULL );
      break;
   case 4:
      _execlpe( av[1], av[1], "_execlpe", "two", NULL, my_env );
      break;
   case 5:
      _execv( av[1], args );
      break;
   case 6:
      _execve( av[1], args, my_env );
      break;
   case 7:
      _execvp( av[1], args );
      break;
   case 8:
      _execvpe( av[1], args, my_env );
      break;
   default:
      break;
   }

   // This point is reached only if exec fails.
   printf( "\nProcess was not execed." );
   exit( 0 );
}

Spécifications

En-tête : process.h

Voir aussi

Processus et contrôle d’environnement
abort
atexit
exit, , _Exit_exit
_onexit, _onexit_m
_spawn, fonctions _wspawn
system, _wsystem