Como chamar código de 32 bits do código de 16 bits no Windows 95, Windows 98 ou Windows Millennium Edition

1. Criando o script de conversão.
2. Criando a DLL de 16 bits.
3. Criando a DLL de 32 bits.

Voltar para o início

                       +------------+
                       | 16to32.THK |
                       +------------+
                             |
                       +------------+
                       | 16to32.ASM |
                       +------------+
                        /          \ 
               -DIS_16 /            \ -DIS_32
                      /              \ 
                 +-----------+ +-----------+
                 | 16THK.OBJ | | 32THK.OBJ |
                 +-----------+ +-----------+
                       /                  \ 
      +-------+    +-------+             +-------+
      | APP16 | -> | DLL16 | -- THUNK -- | DLL32 |
      +-------+    +-------+             +-------+
				

Voltar para o início

Ferramentas necessárias para criar Thunks simples

1. Microsoft Visual C++ 1.5 x (compilador de 16 bits) para o lado 16 bits da conversão. O lado de 16 bits da conversão é uma DLL de 16 bits.
2. Microsoft Visual C++ 2.x ou superior (compilador de 32 bits) para o lado de 32 bits da conversão. O lado de 32 bits da conversão é uma DLL de 32 bits.
3. Compilador de conversão (thunk.exe) do Microsoft Win32 SDK para compilar scripts de conversão.
4. Macro de Microsoft Assembler (MASM) versão 6.1 ou superior para montar a saída de linguagem assembly do compilador de conversão.
5. RC.EXE 16 bits do diretório BINW16 do Microsoft Win32 SDK para marcar a DLL de conversão de 16 bits como versão 4.0.

Voltar para o início

Criar o Script Thunk

   enablemapdirect1632 = true;

   void MyThunk32()
   {
   }
				

   C   language:    void WINAPI MyThunk32(void);
   C++ Language:    extern "C" void WINAPI MyThunk32();
				

   enablemapdirect1632 = true;

   typedef int   BOOL;
   typedef char *LPSTR;

   BOOL MyThunk32(LPSTR lpstrInput, LPSTR lpstrOutput)
   {
      lpstrInput  = input;   // optional; input is default
      lpstrOutput = output;
   }
				

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

Voltar para o início

Usando o compilador Thunk

Voltar para o início

Criando a DLL de 16 bits

1. A DLL de 16 bits deve exportar uma função chamada "DllEntryPoint". Esta função deve fazer uma chamada para uma função criada pelo compilador conversão chamado thk_ThunkConnect16 ("thk" é o prefixo do comutador conversão compilador -t) toda vez que é chamado de DllEntryPoint:

      // prototype for function in .OBJ from the thunk script
      BOOL WINAPI __export thk_ThunkConnect16(LPSTR lpDll16,
                                              LPSTR lpDll32,
                                              WORD  hInst,
                                              DWORD dwReason);
   
       BOOL WINAPI thk_thunkConnect16(LPSTR, LPSTR, WORD, DWORD);
   
       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. Inclua as seguintes linhas na seção IMPORTAÇÕES do arquivo de definição (DEF) módulo para a DLL de 16 bits:

      C16ThkSL01      = KERNEL.631
      ThunkConnect16  = KERNEL.651
   						

3. Inclua as seguintes linhas na seção EXPORTS do arquivo de definição (.def) módulo para a DLL de 16 bits. THK_THUNKDATA16 é definido no arquivo do objeto montado da saída do compilador de conversão. Ambos esses símbolos deve ter a palavra-chave RESIDENTNAME, mas pode ter qualquer número ordinal:

      THK_THUNKDATA16 @1  RESIDENTNAME
      DllEntryPoint   @2  RESIDENTNAME
   						

4. Adicione as funções de conversão que o aplicativo Win16 chamará à instrução EXPORTS do arquivo de definição (DEF) de módulo da DLL de 16 bits. Certifique-se eles são declarados e definidos como __pascal __far __export (ou WINAPI __export). Se a DLL está escrita em C++, certifique-se de declará-los como extern "C".
5. Compilar a conversão da seguinte maneira (se ainda não compilado):

      thunk -t thk 16to32.thk -o 16to32.asm
   						

6. Em seguida, monte o arquivo de linguagem assembly gerado pelo compilador conversão como um módulo de objeto de 16 bits. A linha a seguir mostra um exemplo:

   ml /DIS_16 /c /W3 /nologo /Fo thk16.obj 16to32.asm
   						

7. Vincule este módulo de objeto como parte da DLL de 16 bits.
8. Marcar a DLL de 16 bits como versão 4.0. Para fazer isso, use o compilador de recurso (RC.EXE). A linha a seguir mostra a sintaxe:
   rc 40 º < arquivo DLL >
   Esta opção de 40 º está disponível no compilador de recurso é fornecido com o Win32 SDK.
   
   Observação : Certifique-se usar RC.EXE no diretório BINW16 para que a DLL é marcada com versão 4.0. RC.EXE que acompanha as versões de 16 bits do Microsoft Visual C++ não marcará a DLL como versão 4.0.

Voltar para o início

Criando a DLL de 32 bits

1. No DllMain de sua DLL de 32 bits, você deve fazer uma chamada para uma função criada pelo compilador conversão chamado thk_ThunkConnect32 sempre DllMain é chamado, como mostrado aqui ("thk" é o prefixo do compilador do conversão - t opção):

      // prototype for function in .OBJ from the thunk script
      BOOL WINAPI thk_ThunkConnect32 (LPSTR     lpDll16,
                                      LPTSR     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. Inclua as seguintes linhas na seção EXPORTS do arquivo de definição (.def) módulo para a DLL de 32 bits:

   thk_ThunkData32
   						

3. Exporte as funções para o qual você é conversão. Você pode usar o arquivo de definição (DEF) de módulo da DLL de 32 bits ou a palavra-chave __declspec(dllexport). Certifique-se eles são declarados e definidos como __stdcall. Se a DLL de 32 bits está escrita em C++, certifique-se de declará-los como extern "C". Essas funções são chamadas por lado da conversão 16 bits.
4. Compilar o script de conversão da seguinte maneira (se ainda não compilado):

   thunk -t thk 16to32.thk -o 16to32.asm
   						

5. Monte o arquivo de linguagem assembly gerado pelo compilador conversão como um módulo de objeto de 32 bits. A linha a seguir mostra um exemplo:

   ml /DIS_32 /c /W3 /nologo /coff /Fo thk32.obj 16to32.asm
   						

6. Vincule este módulo de objeto como parte da DLL de 32 bits.
7. Vincule thunk32.lib como parte da DLL de 32 bits. Isso é a biblioteca de importação de 32 bits fornecida no SDK do Win32 que contém referências para as APIs de conversão (thunking) de 32 bits que usa o código criado pelo compilador conversão.

Voltar para o início