Como chamar código de 16 bits a partir do código de 32 bits no Windows 95, Windows 98 e Windows Me

Traduções de Artigos Traduções de Artigos
Artigo: 155763 - Ver produtos para os quais este artigo se aplica.
Expandir tudo | Reduzir tudo

Nesta página

Sumário

Como programador, poderá ser necessário aceder a funcionalidade fornecida por uma biblioteca de ligação dinâmica de 16 bits (DLL) da aplicação Win32. Isto é verdadeiro, particularmente quando não é necessário o código de origem para a DLL isso o pode a porta para Win32. Este artigo descreve o mecanismo pelo qual dll de 32 bits podem chamar dll de 16 bits. O mecanismo denomina-se um thunk e o método implementado no Microsoft Windows 95, Windows 98 e Windows Millennium Edition é designado por uma simples thunk.

A seguinte tabela descreve os três passos principais envolvidos na criação de uma simples thunk:
  1. Crie o script thunk.
  2. Crie a DLL de 32 bits.
  3. Crie a DLL de 16 bits.

Mais Informação

Uma simples thunk consiste de um 32-bit e uma DLL de 16 bits que funcionam em conjunto. Uma aplicação de Win32 chama a DLL de 32 bits, e a DLL de 32 bits chama uma função exportada a DLL de 16 bits. Quando a função na DLL de 16 bits devolve, devolve novamente para a DLL de 32 bits, que por sua vez devolve até a aplicação de Win32. 32 Bits e 16 bits dll trabalho chamando os Windows 95 32 bits e 16 bits kernels para processar todos os detalhes de nível inferior necessários para fazer a transição do código de 32 bits para 16 bits e novamente.

Criar um novo thunk simples envolve a criação de scripts thunk (.thk ficheiro). Este script é compilado com o compilador Thunk num ficheiro linguagem assembly, que, em seguida, é montado duas vezes; uma vez com cada um dos dois sinalizadores de - DIS_32 e - DIS_16. Isto permite-lhe criar módulos de objecto de 32 bits e 16 bits. Estes módulos de objectos estão ligados na DLL de 32 bits e 16 bits, respectivamente. O diagrama seguinte resume os ficheiros envolvidos na criação as DLL:
                         +------------+
                         | 32to16.thk |
                         +------------+
                               |
                         +------------+
                         | 32to16.asm |
                         +------------+
                           /         \ 
                  -DIS_32 /           \ -DIS_16
                        /              \ 
                  +-----------+  +-----------+
                  | 32THK.obj |  | 16THK.obj |
                  +-----------+  +-----------+
                        /                 \ 
        +-------+    +-------+             +-------+
        | APP32 | -> | DLL32 | -- THUNK -- | DLL16 |
        +-------+    +-------+             +-------+
				

Ferramentas necessárias para criar Thunks plano

  • Microsoft Visual C++ versão 1.5 x compilador (16 bits) para o lado 16-bit do criar o thunk. Lado do thunk 16-bit é uma DLL de 16-bit.
  • Microsoft Visual C++ versão 2.x ou superior (32 bits) de compilador para criar o lado do thunk 32 bits. O lado de 32 bits do thunk está uma DLL de 32 bits.
  • Thunk compilador (Thunk.exe) a partir do Microsoft Win32 SDK para compilar thunk scripts.
  • Macro de Microsoft Assembler (MASM) versão 6.1 ou superior para juntar o resultado de linguagem de assemblagem do compilador thunk.
  • 16-bit rc.exe ficheiro do directório BINW16 do Microsoft Win32 SDK para marcar a 16 bits thunk DLL como versão 4.0.

Criar o Script Thunk

Tem de criar um script que pode ser utilizado pelo compilador Thunk para criar um thunk. Um script thunk é um ficheiro de texto que contém definições de tipo de protótipos de função das funções que deseja chamar através de thunks e uma especificação da direcção de parâmetros para cada função. Por exemplo, algumas funções requerem parâmetros de entrada e saídos, enquanto outros só poderão necessitar de parâmetros de entrada. Thunk scripts utilizam sintaxe especial para descrever se parâmetros são entrados, saída, ou entrada e saída.

Um script thunk 32-> 16 thunks começa com a seguinte instrução:
enablemapdirect3216 = VERDADEIRO;
O compilador Thunk espera que lado do thunk 32 bits é declarado como __stdcall e de que o lado de 16 bits é __pascal __far. (Declaração WINAPI encarrega deste em ambos os lados.) Não são suportadas pelo compilador Thunk __cdecl os __fastcall convenções de chamada. No entanto, tenha em atenção que o compilador Thunk não aceita, na realidade, as palavras-chave __far, __pascal ou __stdcall; são considerados como.

O exemplo seguinte mostra um script thunk para uma função que não tem parâmetros:
   enablemapdirect3216 = true;

   void MyThunk16()
   {
   }
				
seria a declaração equivalente:
   C   language:  void WINAPI MyThunk16(void);
   C++ language:  extern "C" void WINAPI MyThunk16();
				
o script de exemplo seguinte descreve uma função que assume dois parâmetros e devolve um valor. O segundo parâmetro é um parâmetro de saída que contém um apontador que é transmitido para a DLL de 32 bits.
   enablemapdirect3216 = true;

   typedef int   BOOL;
   typedef char *LPSTR;

   BOOL MyThunk16(LPSTR lpstrInput, LPSTR lpstrOutput)
   {
      lpstrInput  = input;    // optional; input is default
      lpstrOutput = output;
   }
				
a instrução "lpstrOutput = saída" indica o compilador Thunk que a função de 16 bits devolve um endereço que tem de ser convertidos a partir de um ponteiro de selecção: Desvio um endereço linear de 32 bits.

O seguinte script de thunk utiliza tipos de parâmetro mais complexos, tais como estruturas. Este exemplo mostra também como especificar parâmetros de entrada e saídos.
   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;
   }
				
a instrução "lpCircleInOut = inout" indica o compilador de script que este ponteiro vai ser utilizado para entrada e saída. Isto faz com que o compilador Thunk converter lpCircleInOut de um endereço linear de 32 bits para um ponteiro de selecção: deslocamento quando a função é chamada e, em seguida, novamente para um endereço linear de 32 bits quando a função devolve. A conversão é tratada pelo thunk criado pelo compilador Thunk.

Utilizar o compilador Thunk

A utilização de compilador Thunk é:
Thunk.exe/opções <outputfile> <inputfile> -o
Linha de comandos seguinte mostra como compilar um 32-> script thunk 16. Esta linha tem um script thunk denominado 32to16.thk e produz um ficheiro de linguagem assembly denominado 32to16.asm.
Thunk -t thk 32to16.thk -o 32to16.asm
O "-t thk" opção informa o compilador Thunk como prefixo as funções thunk do ficheiro linguagem assembly "thk_." Este prefixo é utilizado quando ligar vários thunk scripts para um par de DLLs e é útil para criar um par de DLLs que contêm ambas as 32-> 16 e 16-> 32 thunks. Cada script thunk deve ter um prefixo exclusivo.

Criar a DLL de 32 bits

  1. A função DllMain a DLL de 32 bits, tem de estabelecer uma chamada para uma função criada pelo compilador Thunk denominado thk_ThunkConnect32 para cada motivo (dwReason) DllMain é chamado, tal como mostrado aqui ("thk" é o prefixo do parâmetro do Thunk compilador -t):
          // 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. Inclua as seguintes linhas na secção EXPORTS do ficheiro módulo (.def) de definição para a DLL de 32 bits. Por exemplo:
          
       thk_ThunkData32
    						
  3. Exporte as funções que chama a aplicação de Win32. Pode utilizar ficheiro de definição (.def) do módulo a DLL de 32 bits ou a palavra-chave __declspec(dllexport). Certifique-se as funções são declaradas e definidas como __stdcall (ou WINAPI). Se a DLL de 32 bits for escrita em C++, não se esqueça declarar as funções como bem externo "C".
  4. Compilar o script thunk maneira (se ainda não compilada):
          thunk -t thk 32to16.thk -o 32to16.asm
    						
  5. Monte o ficheiro de linguagem assembly produzido pelo compilador Thunk como um módulo de objecto de 32 bits. Por exemplo:
          ml /DIS_32 /c /W3 /nologo /coff /Fo thk32.obj 32to16.asm
    						
  6. Ligar este módulo de objecto como parte da DLL de 32 bits.
  7. Ligar a biblioteca Thunk32.lib como parte da DLL de 32 bits. Esta é a biblioteca de importação de 32 bits fornecida no Win32 SDK que contém referências a API thunking a 32 bits que utiliza o código criado pelo compilador Thunk.

Criar a DLL de 16 bits

  1. A DLL de 16 bits tem de exportar uma função com o nome "DllEntryPoint." Esta função deve efectuar uma chamada para uma função criada pelo compilador Thunk denominado thk__ThunkConnect16 ("thk" é o prefixo do parâmetro do Thunk compilador -t) sempre que DllEntryPoint é designado por:
          // 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. Inclua as seguintes linhas na secção IMPORTAÇÕES do ficheiro módulo (.def) de definição para a DLL de 16 bits. Por exemplo:
          C16ThkSL01      = KERNEL.631
          ThunkConnect16  = KERNEL.651
    						
  3. Inclua as seguintes linhas na secção EXPORTS do ficheiro módulo (.def) de definição para a DLL de 16 bits. THK_THUNKDATA16 está definido no ficheiro de objecto é montado a partir dos resultados do compilador Thunk. Ambos estes símbolos tem de ter a palavra-chave RESIDENTNAME, mas podem ter qualquer número ordinal.
          THK_THUNKDATA16 @1  RESIDENTNAME
          DllEntryPoint   @2  RESIDENTNAME
    						
  4. Adicione as funções thunk à instrução EXPORTS do ficheiro de definição (.def) do módulo a DLL de 16 bits. Certifique-se que são declarados e definidos como __pascal __far __export (ou WINAPI __export). Se a DLL for escrita em C++, não se esqueça declará-los como bem externo "C". Ao lado de 32 bits do thunk chama estas funções.
  5. Compilar o script thunk maneira (se ainda não compilada):
          thunk -t thk 32to16.thk -o 32to16.asm
    						
  6. Monte o ficheiro de linguagem assembly produzido pelo compilador Thunk como um módulo de objecto de 16 bits. Por exemplo:
          ml /DIS_16 /c /W3 /nologo /Fo thk16.obj 32to16.asm
    						
  7. Ligar este módulo de objecto como parte da DLL de 16 bits.
  8. Marca a DLL de 16 bits, versão 4.0. Para o fazer, utilize o compilador de recurso (rc.exe). A seguinte linha mostra a sintaxe:
    rc-40 < ficheiro DLL >
    Esta opção-40 está disponível no compilador de recursos é fornecido com o SDK do Win32.

    Nota : Se utilizar o ficheiro rc.exe no directório BINW16 para que a DLL estiver marcada com versão 4.0. O ficheiro rc.exe que é fornecido com versões de 16 bits do Microsoft Visual C++ não marca a DLL, versão 4.0.

Referências

Para obter informações sobre como depurar thunks simples, consulte o seguinte artigo na base de dados de conhecimento da Microsoft:
133722Como depurar Thunks plano

Propriedades

Artigo: 155763 - Última revisão: 11 de julho de 2005 - Revisão: 2.3
A informação contida neste artigo aplica-se a:
  • Microsoft Win32 Application Programming Interface nas seguintes plataformas
    • Microsoft Windows 95
    • Microsoft Windows 98 Standard Edition
    • Microsoft Windows Millennium Edition
    • Microsoft Platform Software Development Kit-January 2000 Edition
Palavras-chave: 
kbmt kbapi kbhowto kbkernbase kbnetwork kbprogramming kbthunks kbtshoot KB155763 KbMtpt
Tradução automática
IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine translation ou MT), não tendo sido portanto revisto ou traduzido por humanos. A Microsoft tem artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais. O objectivo é simples: oferecer em Português a totalidade dos artigos existentes na base de dados do suporte. Sabemos no entanto que a tradução automática não é sempre perfeita. Esta pode conter erros de vocabulário, sintaxe ou gramática? erros semelhantes aos que um estrangeiro realiza ao falar em Português. A Microsoft não é responsável por incoerências, erros ou estragos realizados na sequência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza actualizações frequentes ao software de tradução automática (MT). Obrigado.
Clique aqui para ver a versão em Inglês deste artigo: 155763

Submeter comentários

 

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