DetailPage-MSS-KB

Knowledge Base

Artikel-ID: 155763 - Geändert am: Montag, 11. Juli 2005 - Version: 2.3

 

Auf dieser Seite

Zusammenfassung

Als Entwickler müssen Sie auf die ein 16-bit dynamic-link Bibliothek (DLL) aus der Win32-Anwendung bereitgestellte Funktionen zugreifen. Dies gilt vor allem wenn Sie nicht den Quellcode für die DLL verfügen, damit Sie auf Win32 portieren zu können. Dieser Artikel beschreibt den Mechanismus, mit dem 32-Bit-DLLs 16-Bit-DLLs aufrufen können. Der Mechanismus wird aufgerufen, einen Thunk und die Methode unter Microsoft Windows 95, Windows 98 und Windows Millennium Edition wird einen flachen Thunk aufgerufen.

Die folgenden beschreibt die drei wichtigsten Schritte erstellen einen flachen Thunk beteiligt:
  1. Erstellen Sie das Thunk Skript.
  2. Erstellen Sie die 32-Bit-DLL.
  3. Erstellen Sie die 16-Bit-DLL.

Weitere Informationen

Ein flacher Thunk besteht aus einer 32-Bit- und einer 16-Bit-DLL, die zusammenarbeiten. Eine Win32-Anwendung ruft die 32-Bit-DLL und die 32-Bit-DLL ruft eine exportierte Funktion in der 16-Bit-DLL. Wenn die Funktion in der 16-Bit-DLL zurückgegeben wird, gibt es zurück an die 32-Bit-DLL, die wiederum zurück an die Win32-Anwendung zurückgibt zurück. Die 32-Bit- und 16-Bit-DLLs Arbeit durch Aufrufen der Windows 95-32-Bit- und 16-Bit-Kernels, behandeln alle die Low-Level erforderlichen Details zum Umstieg von 32-Bit-16-Bit-Code und zurück.

Entwerfen einen neuen flachen Thunk umfasst das Erstellen eines Thunk-Skript (.thk-Datei). Dieses Skript wird mit dem Compiler Thunk in eine Datei Assemblersprache kompiliert, die Sie dann zweimal; einmal mit jedem der beiden Flags der DIS_32 und DIS_16 zusammengestellt wird. Dadurch können Sie die 32-Bit- und 16-Bit-Objektmodule erstellen. Diese Objektmodule-werden in den 32-Bit- und 16-Bit-DLLs verknüpft. Das folgende Diagramm fasst zusammen, die Dateien beim Erstellen von DLLs:
                         +------------+
                         | 32to16.thk |
                         +------------+
                               |
                         +------------+
                         | 32to16.asm |
                         +------------+
                           /         \ 
                  -DIS_32 /           \ -DIS_16
                        /              \ 
                  +-----------+  +-----------+
                  | 32THK.obj |  | 16THK.obj |
                  +-----------+  +-----------+
                        /                 \ 
        +-------+    +-------+             +-------+
        | APP32 | -> | DLL32 | -- THUNK -- | DLL16 |
        +-------+    +-------+             +-------+
				

Tools, die Festplatte Thunks erstellen erforderlich

  • Microsoft Visual C++ Version 1.5 x 16-Bit-Compiler für der 16-Bit-Seite den Thunk erstellen. Der Thunk die 16-Bit-Seite ist eine 16-Bit-DLL.
  • Microsoft Visual C++ Version 2.x oder höher (32-Bit)-Compiler zum Erstellen der 32-Bit-Seite der Thunk. Die 32-Bit-Seite der Thunk ist eine 32-Bit-DLL.
  • Thunk-Compiler (Thunk.exe) aus dem Microsoft Win32-SDK für die Kompilierung Thunk-Skripts.
  • Microsoft Macro Assembler (MASM) BESCHRIEBEN, Version 6.1 oder höher für das Zusammenstellen der Assemblersprache Ausgabe der Compiler Thunk.
  • 16-Bit-RC.exe Datei aus dem Verzeichnis BINW16 von Microsoft Win32-SDK zum Kennzeichnen des Thunk 16-Bit-DLL als Version 4.0.

Erstellen das Skript Thunk

Sie müssen ein Skript erstellen, die vom Compiler Thunk verwendet werden können, um einen Thunk zu erstellen. Ein Thunk-Skript ist eine Textdatei, die Typdefinitionen, die Funktionsprototypen der Funktionen, die Sie über Thunks aufrufen möchten und eine Spezifikation von der Richtung der Parameter für jede Funktion enthält. Einige Funktionen erfordern beispielsweise die Eingabe-und Ausgabeparameter, während andere nur Eingabeparameter erfordern. Thunk-Skripts verwenden spezielle Syntax beschreiben Sie, ob Eingabeparameter, Ausgabe oder Eingabe und Ausgabe.

Ein Thunk-Skript für 32-> 16 Thunks beginnt mit der folgenden Anweisung:
enablemapdirect3216 = True;
Der Compiler Thunk erwartet, dass die 32-Bit-Seite der Thunk als __stdcall deklariert ist und dass die 16-Bit-Seite __far __pascal. (WINAPI Deklaration übernimmt dies auf beiden Seiten.) Die __cdecl und Aufrufkonventionen __fastcall werden vom Compiler Thunk nicht unterstützt. Beachten Sie jedoch, dass der Compiler Thunk keine tatsächlich die Schlüsselwörter __far, __pascal oder __stdcall akzeptiert; Sie werden angenommen.

Das folgende Beispiel zeigt ein Thunk-Skript für eine Funktion, die keine Parameter besitzt:
   enablemapdirect3216 = true;

   void MyThunk16()
   {
   }
				
die entsprechende Deklaration wäre:
   C   language:  void WINAPI MyThunk16(void);
   C++ language:  extern "C" void WINAPI MyThunk16();
				
die folgenden Beispielskript beschreibt eine Funktion, nimmt zwei Parameter und gibt einen Wert zurück. Der zweite Parameter ist ein Ausgabeparameter, der einen Zeiger enthält, der zurück an der 32-Bit-DLL übergeben wird.
   enablemapdirect3216 = true;

   typedef int   BOOL;
   typedef char *LPSTR;

   BOOL MyThunk16(LPSTR lpstrInput, LPSTR lpstrOutput)
   {
      lpstrInput  = input;    // optional; input is default
      lpstrOutput = output;
   }
				
die Anweisung "LpstrOutput = Ausgabe" wird der Compiler Thunk angewiesen, dass die 16-Bit-Funktion eine Adresse zurückgibt, die von einem Selektor: Offset-Zeiger in eine lineare 32-Bit-Adresse konvertiert werden muss.

Das folgende Thunk-Skript verwendet komplexere Parameter Typen wie z. B. Strukturen. In diesem Beispiel wird auch die Angabe von Eingabe-und Ausgabeparameter veranschaulicht.
   enablemapdirect1632 = true;

   typedef unsigned int UINT;
   typedef char *LPSTR;

   typedef struct _POINT {
      UINT x;
      UINT y;
   }POINT, *LPPOINT;

   typedef struct _CIRCLE {
      POINT center;
      UINT  radius;
   }CIRCLE, *LPCIRCLE;

   void MyThunk32( LPCIRCLE lpCircleInOut)
   {
      lpCircleInOut = inout;
   }
				
die Anweisung "LpCircleInOut = inout" weist den Compiler Skript, das this-Zeiger für Eingabe und Ausgabe verwendet werden. Dies veranlasst den Compiler Thunk LpCircleInOut von einer linearen 32-Bit-Adresse in einen Selektor: Offset-Zeiger umwandeln, wenn die Funktion aufgerufen wird und dann zu einer linearen 32-Bit-Adresse zurück, wenn die Funktion zurückgegeben wird. Die Konvertierung wird von der vom Compiler Thunk erstellten Thunk behandelt.

Den Compiler Thunk verwenden

Die Compiler Thunk-Verwendung lautet wie folgt:
<inputfile>Thunk.exe/<outputfile> <eingabedatei> -o-Optionen
Die folgende Befehlszeile veranschaulicht, wie eine 32-> 16 Thunk Skript kompilieren. Diese Zeile führt ein Thunk-Skript mit dem Namen 32to16.thk und erzeugt eine Assemblersprache-Datei mit dem Namen 32to16.asm.
Thunk -t Thk 32to16.thk o - 32to16.asm
Die "-t Thk „ Option weist den Compiler Thunk an Präfix die Thunk Funktionen in der Assemblersprache-Datei mit"Thk_". Dieses Präfix wird beim Verknüpfen von mehreren Thunk-Skripts in einem Paar von DLLs verwendet und eignet sich zum Erstellen von ein Paar von DLLs, die beide 32-> 16 und 16-> 32 Thunks enthalten. Jedes Skript Thunk sollte ein eindeutiges Präfix verfügen.

Die 32-Bit-DLL

  1. In der DllMain-Funktion der 32-Bit-DLL, müssen Sie einen Aufruf einer Funktion, die vom mit dem Namen thk_ThunkConnect32 für jeden Grund (DwReason) DllMain aufgerufen wird, wie hier gezeigt Thunk-Compiler erstellt ("Thk" ist das Präfix aus der Thunk -t Compilerschalter):
          // prototype for function in .obj file from the thunk script
          BOOL WINAPI thk_ThunkConnect32(LPSTR     lpDll16,
                                         LPSTR     lpDll32,
                                         HINSTANCE hDllInst,
                                         DWORD     dwReason);
    
          BOOL WINAPI DllMain(HINSTANCE hDLLInst,
                              DWORD     dwReason,
                              LPVOID    lpvReserved)
          {
             if (!thk_ThunkConnect32("DLL16.DLL", "DLL32.DLL",
                                     hDLLInst, dwReason))
             {
                return FALSE;
             }
             switch (dwReason)
             {
                case DLL_PROCESS_ATTACH:
                   break;
    
                case DLL_PROCESS_DETACH:
                   break;
    
                case DLL_THREAD_ATTACH:
                   break;
    
                case DLL_THREAD_DETACH:
                   break;
             }
             return TRUE;
          }
    						
  2. Nehmen Sie die folgenden Zeilen in der EXPORTS-Abschnitt der Moduldefinitionsdatei (.def), für die 32-Bit-DLL. Zum Beispiel:
          
       thk_ThunkData32
    						
  3. Exportieren Sie die Funktionen, die die Win32-Anwendung aufruft. Sie können entweder die 32-Bit-DLL-Moduldefinitionsdatei (.def) oder das __declspec(dllexport)-Schlüsselwort verwenden. Achten Sie die Funktionen deklariert und als __stdcall (oder WINAPI) definiert sind. Wenn die 32-Bit-DLL in C++ geschrieben ist, müssen Sie die Funktionen als Extern "C" deklariert werden.
  4. Kompilieren das Thunk-Skript wie folgt (falls noch nicht kompiliert):
          thunk -t thk 32to16.thk -o 32to16.asm
    						
  5. Zusammenstellen der Assemblersprache Datei vom Compiler Thunk als eine 32-Bit-Objektmodul. Zum Beispiel:
          ml /DIS_32 /c /W3 /nologo /coff /Fo thk32.obj 32to16.asm
    						
  6. Verknüpfen Sie dieses Objektmodul als Teil der 32-Bit-DLL.
  7. Verknüpfen Sie die Thunk32.lib-Bibliothek als Teil der 32-bit-DLL. Dies ist die 32-bit importieren Bibliothek in Win32 SDK, Verweise auf die 32-bit thunking APIs enthält, die der Code vom Compiler Thunk erstellten verwendet, bereitgestellt.

Die 16-Bit-DLL

  1. Die 16-Bit-DLL muss eine Funktion namens "DllEntryPoint." exportieren. Diese Funktion muss einen Aufruf einer Funktion, die vom mit dem Namen thk__ThunkConnect16 Thunk-Compiler erstellt, ("Thk" ist das Präfix aus der Thunk -t Compilerschalter) jedes Mal, wenn DllEntryPoint aufgerufen wird:
          // prototype for function in .obj file from the thunk script
          BOOL WINAPI __export thk_ThunkConnect16(LPSTR lpDll16,
                                                  LPSTR lpDll32,
                                                  WORD  hInst,
                                                  DWORD dwReason);
    
          BOOL WINAPI __export DllEntryPoint(DWORD dwReason,
                                             WORD  hInst,
                                             WORD  wDS,
                                             WORD  wHeapSize,
                                             DWORD dwReserved1,
                                             WORD  wReserved 2)
          {
             if (!thk_ThunkConnect16("DLL16.DLL",
                                     "DLL32.DLL",
                                     hInst,
                                     dwReason))
             {
                return FALSE;
             }
             return TRUE;
          }
    						
  2. Nehmen Sie die folgenden Zeilen in der Moduldefinitionsdatei (.def) im Abschnitt IMPORTS für die 16-Bit-DLL. Zum Beispiel:
          C16ThkSL01      = KERNEL.631
          ThunkConnect16  = KERNEL.651
    						
  3. Nehmen Sie die folgenden Zeilen in EXPORTS-Abschnitt der Moduldefinitionsdatei (.def) für die 16-Bit-DLL. THK_THUNKDATA16 wird in der Objektdatei definiert, die aus der Ausgabe der Compiler Thunk zusammengestellt wird. Beide dieser Symbole müssen das RESIDENTNAME-Schlüsselwort, jedoch können Ordnungszahl.
          THK_THUNKDATA16 @1  RESIDENTNAME
          DllEntryPoint   @2  RESIDENTNAME
    						
  4. Hinzufügen der Thunk-Funktionen zu die EXPORTS-Anweisung in der 16-Bit-DLL-Moduldefinitionsdatei (.def). Achten Sie deklariert und als __far __pascal __export (oder WINAPI __export) definiert sind. Wenn die DLL in C++ geschrieben ist, müssen Sie als Extern "C" deklariert. Der Thunk die 32-Bit-Seite aufruft diese Funktionen.
  5. Kompilieren das Thunk-Skript wie folgt (falls noch nicht kompiliert):
          thunk -t thk 32to16.thk -o 32to16.asm
    						
  6. Zusammenstellen der Assemblersprache Datei vom Compiler Thunk als Objektmodul 16-Bit. Zum Beispiel:
          ml /DIS_16 /c /W3 /nologo /Fo thk16.obj 32to16.asm
    						
  7. Verknüpfen Sie dieses Objektmodul als Teil der 16-Bit-DLL.
  8. Markieren Sie die 16-Bit-DLL als Version 4.0. Dazu müssen, verwenden Sie den Ressourcencompiler (RC.exe). Die folgende Zeile zeigt die Syntax:
    RC-40 < dll-datei >
    Diese Option-40 ist in der mit dem Win32-SDK enthaltene Ressourcencompiler verfügbar.

    Hinweis : Stellen Sie sicher die RC.exe Datei im Verzeichnis BINW16 verwenden, so dass die DLL mit Version 4.0 gekennzeichnet ist. Die RC.exe-Datei, die im Lieferumfang von 16-Bit-Versionen von Microsoft Visual C++ markiert die DLL nicht als Version 4.0.

Informationsquellen

Informationen zum flache Thunks Debuggen finden Sie in folgendem Artikel der Microsoft Knowledge Base:
133722  (http://support.microsoft.com/kb/133722/EN-US/ ) Gewusst wie: Festplatte Thunks Debuggen

Die Informationen in diesem Artikel beziehen sich auf:
  • Microsoft Win32 Application Programming Interface, wenn verwendet mit:
    • Microsoft Windows 95
    • Microsoft Windows 98 Standard Edition
    • Microsoft Windows Millennium Edition
    • Microsoft Platform Software Development Kit January 2000 Edition
Keywords: 
kbmt kbapi kbhowto kbkernbase kbnetwork kbprogramming kbthunks kbtshoot KB155763 KbMtde
Maschinell übersetzter ArtikelMaschinell übersetzter Artikel
Wichtig: Dieser Artikel wurde maschinell und nicht von einem Menschen übersetzt. Die Microsoft Knowledge Base ist sehr umfangreich und ihre Inhalte werden ständig ergänzt beziehungsweise überarbeitet. Um Ihnen dennoch alle Inhalte auf Deutsch anbieten zu können, werden viele Artikel nicht von Menschen, sondern von Übersetzungsprogrammen übersetzt, die kontinuierlich optimiert werden. Doch noch sind maschinell übersetzte Texte in der Regel nicht perfekt, insbesondere hinsichtlich Grammatik und des Einsatzes von Fremdwörtern sowie Fachbegriffen. Microsoft übernimmt keine Gewähr für die sprachliche Qualität oder die technische Richtigkeit der Übersetzungen und ist nicht für Probleme haftbar, die direkt oder indirekt durch Übersetzungsfehler oder die Verwendung der übersetzten Inhalte durch Kunden entstehen könnten.
Den englischen Originalartikel können Sie über folgenden Link abrufen: 155763  (http://support.microsoft.com/kb/155763/en-us/ )
Microsoft stellt Ihnen die in der Knowledge Base angebotenen Artikel und Informationen als Service-Leistung zur Verfügung. Microsoft übernimmt keinerlei Gewährleistung dafür, dass die angebotenen Artikel und Informationen auch in Ihrer Einsatzumgebung die erwünschten Ergebnisse erzielen. Die Entscheidung darüber, ob und in welcher Form Sie die angebotenen Artikel und Informationen nutzen, liegt daher allein bei Ihnen. Mit Ausnahme der gesetzlichen Haftung für Vorsatz ist jede Haftung von Microsoft im Zusammenhang mit Ihrer Nutzung dieser Artikel oder Informationen ausgeschlossen.
Freigeben
Weitere Supportoptionen
Microsoft Community-Supportforen
Kontaktieren Sie uns direkt
Zertifizierten Partner finden
Microsoft Store
Folgen Sie uns: