_exec, _wexec Funktionen

Jede Funktion in dieser Familie lädt einen neuen Prozess und führt ihn aus:

Der Buchstabe am Ende des Funktionsnamens bestimmt die Variante.

Hinweise

Jede _exec-Funktion lädt einen neuen Prozess und führt ihn aus. Alle _exec Funktionen verwenden dieselbe Betriebssystemfunktion (CreateProcess). Die _exec-Funktionen behandeln ggf. automatisch Argumente mit Multibyte-Zeichenfolgen, wobei Multibyte-Zeichensequenzen entsprechend der derzeit verwendeten Multibyte-Codepage erkannt werden. Die _wexec-Funktionen sind Breitzeichenversionen der _exec-Funktionen. Die _wexec Funktionen verhalten sich identisch mit ihren _exec Familienentsprechungen, mit der Ausnahme, dass sie keine Multibyte-Zeichenzeichenfolgen verarbeiten.

Mapping generischer Textroutinen

Der cmdname-Parameter gibt die Datei an, die als neuer Prozess ausgeführt werden soll. Er kann einen vollständigen Pfad (ausgehend vom Stamm), einen partiellen Pfad (im aktuellen Arbeitsverzeichnis) oder einen Dateinamen angeben. Wenn cmdname keine Dateinamenerweiterung vorhanden ist oder nicht mit einem Punkt (.) endet, sucht die _exec Funktion nach der benannten Datei. Wenn die Suche fehlschlägt, versucht die Funktion denselben Basisnamen mit der COM-Dateinamenerweiterung und dann mit den EXE-, BAT- und CMD-Dateinamenerweiterungen. Wenn cmdname eine Dateinamenerweiterung hat, wird nur diese Erweiterung in der Suche verwendet. Wenn cmdname mit einem Punkt endet, sucht die _exec-Funktion nach cmdname ohne Dateinamenerweiterung. _execlp, _execlpe, _execvp und _execvpe suchen in den Verzeichnissen, die durch die cmdname-Umgebungsvariable angegeben werden, nach PATH (mithilfe des gleichen Verfahrens). Wenn cmdname ein Laufwerksbezeichner oder Schrägstriche (d. h. wenn es sich um einen relativen Pfad handelt) enthält, sucht der _exec Aufruf nur nach der angegebenen Datei. Der Pfad wird nicht durchsucht.

Parameter werden an den neuen Prozess übergeben, indem ein oder mehrere Zeiger als Parameter im _exec-Aufruf an die Zeichenfolgen übergeben werden. Diese Zeichenfolgen bilden die Parameterliste für den neuen Prozess. Die kombinierte Länge der geerbten Umgebungseinstellungen und der Zeichenfolgen, die die Parameterliste für den neuen Prozess bilden, darf 32 KB nicht überschreiten. Das Endzeichen NULL (\0) für jede Zeichenfolge ist nicht in der Anzahl enthalten, aber Leerzeichen (automatisch eingefügt, um die Parameter zu trennen) werden gezählt.

Die _exec-Funktionen überprüfen ihre Parameter. Wenn es sich bei den erwarteten Parametern um NULL-Zeiger, leere Zeichenfolgen oder ausgelassen handelt, rufen die _exec Funktionen den ungültigen Parameterhandler auf, wie in der Parameterüberprüfung beschrieben. Wenn die weitere Ausführung zugelassen wird, stellen diese Funktionen errno auf EINVAL ein und geben -1 zurück. Es wird kein neuer Prozess ausgeführt.

Die Argumentzeiger können als separate Parameter übergeben werden (in _execl, _execle, _execlp und _execlpe) oder als ein Array von Zeigern (in _execv, _execve, _execvp und _execvpe). Mindestens ein Parameter arg0muss an den neuen Prozess übergeben werden. Dieser Parameter ist argv[0] der neue Prozess. Normalerweise ist dieser Parameter eine Kopie von cmdname. (Ein anderer Wert erzeugt keinen Fehler.)

Die _execl-, _execle-, _execlp- und _execlpe-Aufrufe werden normalerweise verwendet, wenn die Anzahl der Parameter im Voraus bekannt ist. Der arg0-Parameter ist normalerweise ein Zeiger auf cmdname. Die Parameter von arg1 bis argn weisen auf die Zeichenfolgen hin, aus denen die neue Parameterliste besteht. Ein NULL-Zeiger muss argn folgen, um das Ende der Parameterliste zu markieren.

Die _execv-, _execve-, _execvp- und _execvpe-Aufrufe sind nützlich, wenn die Anzahl der Parameter im neuen Prozess variabel ist. Zeiger auf Parameter werden als Array, nämlich argv, übergeben. Der argv[0]-Parameter ist normalerweise ein Zeiger auf cmdname. Die Parameter von argv[1] bis argv[n] weisen auf die Zeichenfolgen hin, aus denen die neue Parameterliste besteht. Der Parameter argv[n+1] muss ein NULL Zeiger sein, um das Ende der Parameterliste zu markieren.

Dateien, die beim Aufrufen von _exec geöffnet waren, bleiben im neuen Prozess geöffnet. Bei _execl-, _execlp-, _execv- und _execvp-Aufrufen erbt der neue Prozess die Umgebung des aufrufenden Prozesses. _execle-, _execlpe-, _execve- und _execvpe-Aufrufe ändern die Umgebung für den neuen Prozess, indem eine Liste der Umgebungseinstellungen durch den envp-Parameter übergeben wird. envp ist ein Array von Zeichenzeigern, von denen jedes Element (außer dem letzten Element) auf eine auf NULL endende Zeichenfolge verweist, die eine Umgebungsvariable definiert. Solch eine Zeichenfolge hat normalerweise die Form NAME=value, wobei NAME der Name einer Umgebungsvariable und value der Zeichenfolgenwert ist, für den diese Variable festgelegt wird. (Dies value ist nicht in doppelte Anführungszeichen eingeschlossen.) Das letzte Element des envp Arrays sollte sein NULL. Wenn envp selbst NULL ist, erbt der neue Prozess die Umgebungseinstellungen des aufrufenden Prozesses.

Ein Programm, das mit einer der _exec Funktionen ausgeführt wird, wird immer in den Speicher geladen, als ob das maximale Zuordnungsfeld im .exe Dateiheader des Programms auf den Standardwert festgelegt 0xFFFFHwurde.

Die _exec Aufrufe behalten die Übersetzungsmodi geöffneter Dateien nicht bei. Wenn der neue Prozess Dateien verwenden muss, die vom aufrufenden Prozess geerbt wurden, verwenden Sie die _setmode Routine, um den Übersetzungsmodus dieser Dateien auf den gewünschten Modus festzulegen. Vor dem fflush-Funktionsaufruf müssen Sie jeden Stream explizit leeren (mithilfe von _flushall oder _exec) oder explizit schließen. Signaleinstellungen bleiben in neuen Prozessen, die durch Aufrufe von _exec Routinen erstellt werden, nicht erhalten. Die Signaleinstellungen werden im neuen Prozess auf die Standardwerte zurückgesetzt.

Beispiel

// 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;
}

Führen Sie das folgende Programm aus, um "Crt_args.exe" auszuführen:

// 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 );
}

Anforderungen

Header: process.h

Siehe auch

Prozess- und Umgebungskontrolle
abort
atexit
exit, _Exit_exit
_onexit, _onexit_m
_spawn, _wspawn Funktionen
system, _wsystem