Jak volání 16bitový kód z 32bitové kódu v systému Windows 95, Windows 98 a Windows ME

Překlady článku Překlady článku
ID článku: 155763 - Produkty, které se vztahují k tomuto článku.
Rozbalit všechny záložky | Minimalizovat všechny záložky

Na této stránce

Souhrn

Jako vývojář můžete přístup funkce poskytované dynamická knihovna 16 bitů (DLL) z aplikace Win32. To platí zejména při nemáte zdrojový kód pro DLL, že port k Win32. Tento článek pojednává o mechanismus, podle kterého dll 32bitová volání 16bitových dll. Mechanismus je volána thunk a metoda implementována v části Microsoft Windows 95, Windows 98 a Windows ME se nazývá nestrukturované thunk.

Následující část popisuje tři hlavní kroky účastní vytváření plochý thunk:
  1. Vytvořte skript thunk.
  2. Sestavit 32bitové DLL.
  3. Sestavit DLL 16 bitů.

Další informace

Plochý thunk se skládá z 32bitové a 16bitové DLL, které spolupracují. Aplikace typu Win32 volání DLL 32bitové a 32bitové DLL volá exportovaná funkce v DLL 16 bitů. Vrátí funkce v DLL 16bitového vrátí zpět do 32bitové DLL, které zase vrátí zpět do aplikace typu Win32. 32Bitové a 16bitové dll práci voláním jádrech 95 32bitové verze systému Windows a 16bitové zpracovávat všechny podrobnosti nižší úrovně, které je nutné provést přechod z 32bitového do 16bitového kódu a zpět.

Navrhování nových plochý thunk zahrnuje vytvoření skriptu thunk (.thk soubor). Tento skript je zkompilován s kompilátorem jádro souboru sestavení jazyk, který je potom sestaven dvakrát; jednou s každou dva příznaky - DIS_32 a - DIS_16. Umožňuje vytvořit objekt 16bitové a 32bitové moduly. Tyto moduly objektu jsou propojeny v DLL 32bitové a 16bitové, respektive. Následující diagram shrnuje soubory zahrnuté v budově dll:
                         +------------+
                         | 32to16.thk |
                         +------------+
                               |
                         +------------+
                         | 32to16.asm |
                         +------------+
                           /         \ 
                  -DIS_32 /           \ -DIS_16
                        /              \ 
                  +-----------+  +-----------+
                  | 32THK.obj |  | 16THK.obj |
                  +-----------+  +-----------+
                        /                 \ 
        +-------+    +-------+             +-------+
        | APP32 | -> | DLL32 | -- THUNK -- | DLL16 |
        +-------+    +-------+             +-------+
				

Nástroje potřebné k tvorbě Flat Thunks

  • Microsoft Visual C++ verze 1.5 x kompilátoru (16 bitů) pro 16bitové stranu vytváření thunk. Strana 16bitové thunk je 16bitové DLL.
  • Microsoft Visual C++ verze 2.x nebo vyšší kompilátoru (32 bitů) pro vytváření 32bitové straně thunk Strana 32bitové thunk je 32bitové DLL.
  • Kompilátor thunk (Thunk.exe) z Microsoft Win32 SDK pro kompilaci skriptů thunk.
  • Microsoft makro Assembler (MASM) verze 6.1 nebo vyšší pro montáž sestavení jazyk výstup kompilátoru thunk.
  • 16bitové rc.exe z adresáře BINW16 Microsoft Win32 SDK pro soubor označení thunk 16bitové DLL jako verze 4.0.

Vytváření skriptů jádro

Potřebujete vytvořit skript, který lze použít k vytvoření thunk kompilátorem jádro. Thunk skript je textový soubor obsahující definice typu prototypy funkce funkcí, které chcete volat prostřednictvím thunks a specifikace směr parametry pro jednotlivé funkce. Například některé funkce vyžadují vstupní a výstupní parametry, zatímco jiné pouze může vyžadovat vstupní parametry. Skripty thunk použít speciální syntaxi popsat, zda jsou parametry vstupní, výstupní, nebo vstup i výstup.

Thunk skriptu pro 32-> 16 thunks začíná následující příkaz:
enablemapdirect3216 = true;
Kompilátor jádro očekává, že je 32bitové straně thunk deklarován jako __stdcall a 16bitové straně je __far __pascal. (Deklarace WINAPI činnostem to na obou stranách.) __Cdecl a __fastcall konvence volání nejsou podporovány kompilátorem jádro. Upozorňujeme však, kompilátor jádro __far, __pascal nebo __stdcall klíčová slova skutečně nepřijímá; jejich předpokládá.

Následující příklad ukazuje thunk skriptu pro funkci nemá žádné parametry:
   enablemapdirect3216 = true;

   void MyThunk16()
   {
   }
				
by ekvivalentní deklarace:
   C   language:  void WINAPI MyThunk16(void);
   C++ language:  extern "C" void WINAPI MyThunk16();
				
následující příklad skriptu popisuje funkce, která trvá dva parametry a vrátí hodnotu. Druhý parametr je výstupní parametr, který obsahuje ukazatel je předán 32bitové DLL.
   enablemapdirect3216 = true;

   typedef int   BOOL;
   typedef char *LPSTR;

   BOOL MyThunk16(LPSTR lpstrInput, LPSTR lpstrOutput)
   {
      lpstrInput  = input;    // optional; input is default
      lpstrOutput = output;
   }
				
Příkazu "lpstrOutput výstup =" informuje kompilátor jádro 16bitové funkce vrátí adresu, která potřebuje převést z volič: Posun ukazatele na 32bitovou adresu lineární.

Následující skript thunk používá složitější typy parametrů jako například struktur. Tento příklad také ukazuje, jak určit vstupní a výstupní parametry.
   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;
   }
				
Příkazu "lpCircleInOut vstup a výstup =" informuje kompilátor skript, který tento ukazatel bude použit pro vstup a výstup. To způsobí, že kompilátor jádro převést lpCircleInOut z lineární 32bitovou adresu na volič: Posun ukazatele při volání funkce a potom zpět lineární 32bitovou adresu při vrátí funkce. Převod je zpracována vytvořen kompilátor jádro thunk.

Pomocí kompilátoru jádro

Kompilátor využití jádro je následující:
thunk.exe/možnosti <inputfile>-o <outputfile>
Na příkazovém řádku následující příkaz ukazuje, jak kompilovat 32-> 16 thunk skriptu. Tento řádek trvá thunk skript s názvem 32to16.thk a vytvoří soubor sestavení jazyk s názvem 32to16.asm.
thunk -t thk 32to16.thk -o 32to16.asm
"-T thk" možnost informuje kompilátor jádro k předponu funkce thunk v sestavení jazyk souboru s "thk_" Tato předpona se používá při propojování více skriptů thunk do dvojice dll a je užitečné při vytváření dvojici dll, které obsahují obě 32-> 16 a 16-> 32 thunks. Každý skript thunk by měl mít jedinečnou předponu.

Vytváření DLL 32bitové

  1. Ve funkci DllMain 32bitové DLL, musíte provést volání funkce vytvořen kompilátor jádro názvem thk_ThunkConnect32 pro každých důvod (dwReason) DllMain nazývá, jak je znázorněno zde ("thk" je předpona od přepínače -t jádro kompilátoru):
          // 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. Zahrnout následující řádky v oddílu EXPORTUJE soubor definice (DEF.) modulu pro 32bitové DLL. Například:
          
       thk_ThunkData32
    						
  3. Exportovat funkcí aplikace Win32 volá. Můžete buď použít soubor definice (DEF.) modulu DLL 32bitové nebo klíčové slovo __declspec(dllexport). Ujistěte se, že funkce jsou deklarovány a definován jako __stdcall (nebo WINAPI). Pokud DLL 32bitové zapsána v C++, nezapomeňte deklarovat jako externí "C" také funkce.
  4. (Pokud není již zkompilovaný) způsobem kompilace skriptu thunk:
          thunk -t thk 32to16.thk -o 32to16.asm
    						
  5. Sestavit soubor sestavení jazyk vyrobeno kompilátor jádro jako 32bitové objektu modulu. Například:
          ml /DIS_32 /c /W3 /nologo /coff /Fo thk32.obj 32to16.asm
    						
  6. Tento modul objektu jako součást DLL 32bitové propojit.
  7. Propojení knihovny Thunk32.lib jako část 32bitové DLL. Toto je import 32bitové knihovny poskytované Win32 SDK, která obsahuje odkazy na 32bitové thunking API, která používá kód vytvořen jádro kompilátoru.

Vytváření 16bitové DLL

  1. DLL 16bitového nutné exportovat funkci s názvem "DllEntryPoint" Tato funkce je nutné provést volání funkce vytvořen s názvem thk__ThunkConnect16 kompilátor jádro ("thk" je předpona od přepínače -t jádro kompilátoru) při každém nazývá DllEntryPoint:
          // 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. Zahrnout následující řádky v oddílu IMPORTUJE soubor definice (DEF.) modulu pro 16bitové DLL. Například:
          C16ThkSL01      = KERNEL.631
          ThunkConnect16  = KERNEL.651
    						
  3. Zahrnout následující řádky v oddílu EXPORTUJE soubor definice (DEF.) modulu pro 16bitové DLL. THK_THUNKDATA16 je definována v objektu souboru, který je sestaven z výstupu kompilátoru jádro. Obě tyto symboly musí mít klíčové slovo RESIDENTNAME, ale může mít libovolnou pořadové číslo.
          THK_THUNKDATA16 @1  RESIDENTNAME
          DllEntryPoint   @2  RESIDENTNAME
    						
  4. Přidat funkce thunk příkaz EXPORTUJE soubor DLL 16bitového modulu definice (DEF.). Ujistěte se, že jsou deklarovány a definován jako __far __pascal __export (nebo WINAPI __export). Pokud DLL je zapsána v C++, nezapomeňte deklarovat jako externí i "C". 32Bitové straně thunk volání těchto funkcí.
  5. (Pokud není již zkompilovaný) způsobem kompilace skriptu thunk:
          thunk -t thk 32to16.thk -o 32to16.asm
    						
  6. Sestavit soubor sestavení jazyk vyrobeno kompilátor jádro jako 16bitové objektu modulu. Například:
          ml /DIS_16 /c /W3 /nologo /Fo thk16.obj 32to16.asm
    						
  7. Tento modul objektu jako součást DLL 16bitového propojit.
  8. DLL 16bitového označit jako verze 4.0. Použijte kompilátor prostředku (rc.exe). Následující řádek zobrazuje syntaxi:
    RC-40 < soubor DLL >
    Tato možnost-40 je k dispozici v kompilátoru zdrojů je poskytován s Win32 SDK.

    Poznámka: Zkontrolujte použití souboru rc.exe v adresáři BINW16 tak, aby DLL označeny verze 4.0. Rc.exe soubor, který se dodává s 16bitové verze Microsoft Visual C++ neoznačí DLL jako verze 4.0.

Odkazy

Informace o ladění plochý thunks naleznete v následujícím článku databáze Microsoft Knowledge Base:
133722Jak Debug Flat Thunks

Vlastnosti

ID článku: 155763 - Poslední aktualizace: 11. července 2005 - Revize: 2.3
Informace v tomto článku jsou určeny pro produkt:
  • Microsoft Win32 Application Programming Interface na těchto platformách
    • Microsoft Windows 95
    • Microsoft Windows 98 Standard Edition
    • Microsoft Windows Millennium Edition
    • Microsoft Platform Software Development Kit-January 2000 Edition
Klíčová slova: 
kbmt kbapi kbhowto kbkernbase kbnetwork kbprogramming kbthunks kbtshoot KB155763 KbMtcs
Strojově přeložený článek
Důležité: Tento článek byl přeložen pomocí software společnosti Microsoft na strojový překlad, ne profesionálním překladatelem. Společnost Microsoft nabízí jak články přeložené překladatelem, tak články přeložené pomocí software na strojový překlad, takže všechny články ve Znalostní databázi (Knowledge Base) jsou dostupné v češtině. Překlad pomocí software na strojový překlad ale není bohužel vždy dokonalý. Obsahuje chyby ve skloňování slov, skladbě vět, nebo gramatice, podobně jako když cizinci dělají chyby při mluvení v češtině. Společnost Microsoft není právně zodpovědná za nepřesnosti, chyby nebo škody vzniklé chybami v překladu, nebo při použití nepřesně přeložených instrukcí v článku zákazníkem. Společnost Microsoft aktualizuje software na strojový překlad, aby byl počet chyb omezen na minimum.
Projděte si také anglickou verzi článku:155763

Dejte nám zpětnou vazbu

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com