Come chiamata di codice a 16 bit dal codice a 32 bit in Windows 95, Windows 98 e Windows Me

Traduzione articoli Traduzione articoli
Identificativo articolo: 155763 - Visualizza i prodotti a cui si riferisce l?articolo.
Espandi tutto | Chiudi tutto

In questa pagina

Sommario

QualitÓ di sviluppatore, Ŕ necessario accedere alle funzionalitÓ fornite da una libreria a collegamento dinamico 16 bit (DLL) dall'applicazione Win32. Questo vale in particolare quando non si dispone del codice sorgente per la DLL in modo che Ŕ possibile porting a Win32. In questo articolo viene descritto il meccanismo in base al quale DLL a 32 bit possono chiamare DLL a 16 bit. Il meccanismo viene definito un thunk e il metodo implementato in Microsoft Windows 95, Windows 98 e Windows Millennium Edition viene chiamato il un thunk flat.

Di seguito vengono descritti i tre passaggi principali di creazione di un thunk flat:
  1. Creare lo script di thunk.
  2. Creare la DLL a 32 bit.
  3. Creare la DLL a 16 bit.

Informazioni

Un thunk flat Ŕ costituito da 32 bit e una DLL a 16 bit che lavorano insieme. Un'applicazione Win32 chiama la DLL a 32 bit, e la DLL a 32 bit si chiama una funzione esportata nella DLL a 16 bit. Quando la funzione nella DLL a 16 bit restituisce, viene restituito al DLL a 32 bit, che a sua volta restituisce all'applicazione di Win32. Chiamando il kernel di Windows 95 a 32 bit e a 16 bit per gestire tutti i dettagli di basso livello necessari per effettuare la transizione dal codice a 16 bit a 32 bit e viceversa lavoro DLL a 32 bit e 16 bit.

Progettazione di un nuovo thunk flat prevede la creazione un script di thunk (.thk file). Questo script viene compilato con il compilatore thunk in un file di linguaggio assembly, che viene quindi raccolto due volte; una volta con ciascuno dei due flag di - DIS_32 e - DIS_16. Questo consente di creare entrambi i moduli di oggetto a 32 bit e 16 bit. Questi moduli di oggetto sono collegati rispettivamente nelle DLL a 32 bit e 16 bit. Nel diagramma riportato di seguito sono riepilogati i file coinvolti nella creazione di DLL:
                         +------------+
                         | 32to16.thk |
                         +------------+
                               |
                         +------------+
                         | 32to16.asm |
                         +------------+
                           /         \ 
                  -DIS_32 /           \ -DIS_16
                        /              \ 
                  +-----------+  +-----------+
                  | 32THK.obj |  | 16THK.obj |
                  +-----------+  +-----------+
                        /                 \ 
        +-------+    +-------+             +-------+
        | APP32 | -> | DLL32 | -- THUNK -- | DLL16 |
        +-------+    +-------+             +-------+
				

Strumenti necessari per creare il thunk flat

  • Microsoft Visual c ++ versione 1.5 x compilatore lato della creazione il thunk 16-bit (16 bit). Il lato di 16 bit del thunk Ŕ una DLL a 16 bit.
  • Microsoft Visual c ++ versione 2.x o superiore compilatore per (a 32 bit) per la creazione lato del thunk 32 bit. Il lato di 32 bit del thunk Ŕ una DLL a 32 bit.
  • Compilatore di thunk (Thunk.exe) da Microsoft Win32 SDK per la compilazione script thunk.
  • Microsoft Macro Assembler (MASM) versione 6.1 o versione successiva per assemblare l'output di linguaggio assembly del compilatore thunk.
  • 16-bit RC.exe file dalla directory di Microsoft Win32 SDK BINW16 per contrassegnare il thunk 16-bit DLL versione 4.0.

Creazione di script il thunk

╚ necessario creare uno script che pu˛ essere utilizzato dal compilatore thunk per creare un thunk. Uno script di thunk Ŕ un file di testo che contiene le definizioni di tipo, i prototipi delle funzioni che si desidera chiamare tramite thunk e una specifica della direzione dei parametri per ciascuna funzione. Ad esempio, alcune funzioni richiedono parametri di sia input e output, mentre altri potrebbe richiedere solo i parametri di input. Gli script di thunk utilizzano una sintassi speciale per descrivere se i parametri sono di input, output, o input e output.

Uno script di thunk per 32-> 16 thunk inizia con la seguente istruzione:
enablemapdirect3216 = true;
Il compilatore thunk prevede che il lato di 32 bit del thunk viene dichiarato come __stdcall, e che il lato di 16 bit Ŕ __pascal __far. (La dichiarazione WINAPI si occupa di questo su entrambi i lati.) __Cdecl le convenzioni di chiamata __fastcall non sono supportate dal compilatore thunk. Si noti, tuttavia, che il compilatore thunk non effettivamente accetta le parole chiave __far, __pascal o __stdcall, verranno considerati.

Nell'esempio seguente viene riportato uno script di thunk per una funzione che non dispone di parametri:
   enablemapdirect3216 = true;

   void MyThunk16()
   {
   }
				
sarebbe la dichiarazione equivalente:
   C   language:  void WINAPI MyThunk16(void);
   C++ language:  extern "C" void WINAPI MyThunk16();
				
lo script di esempio riportato di seguito descrive una funzione che accetta due parametri e restituisce un valore. Il secondo parametro Ŕ un parametro di output che contiene un puntatore che viene passato alla DLL a 32 bit.
   enablemapdirect3216 = true;

   typedef int   BOOL;
   typedef char *LPSTR;

   BOOL MyThunk16(LPSTR lpstrInput, LPSTR lpstrOutput)
   {
      lpstrInput  = input;    // optional; input is default
      lpstrOutput = output;
   }
				
l'istruzione "lpstrOutput = output" indica al compilatore di thunk che la funzione di 16 bit restituisce un indirizzo che deve essere convertito da un puntatore selettore: offset in un indirizzo lineare a 32 bit.

Lo script seguente thunk utilizza tipi di parametro pi¨ complessi, ad esempio le strutture. In questo esempio viene inoltre illustrato come specificare parametri di input e 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;
   }
				
l'istruzione "lpCircleInOut = parametro inout" indica al compilatore dello script da utilizzare per input e output di questo puntatore. Questo fa sý che il compilatore thunk convertire lpCircleInOut da un indirizzo lineare a 32 bit in un puntatore di selettore: offset quando viene chiamata la funzione e quindi nuovamente un indirizzo lineare a 32 bit quando la funzione restituisce. La conversione viene gestita da creato dal compilatore thunk thunk.

Utilizzando il compilatore thunk

L'utilizzo del compilatore thunk Ŕ la seguente:
thunk.exe opzione <outputfile> <inputfile> -o
Riga di comando riportata di seguito viene illustrato come compilare un 32-> script thunk 16. Questa riga richiede uno script di thunk denominato 32to16.thk e produce un file di linguaggio assembly denominato 32to16.asm.
thunk -t thk 32to16.thk -o 32to16.asm
Il "-t thk" opzione indica al compilatore di thunk di prefisso le funzioni di thunk per il file di linguaggio assembly con "thk_." Questo prefisso viene utilizzato quando si collegano pi¨ script thunk in una coppia di DLL e risulta utile per creare una coppia di DLL che contengono entrambi 32-> 16 e 16-> 32 thunk. Ogni script thunk necessario un prefisso univoco.

Generazione della DLL a 32 bit

  1. In funzione DllMain della DLL a 32 bit, Ŕ necessario effettuare una chiamata a una funzione creata dal compilatore thunk denominato thk_ThunkConnect32 per ogni motivo (dwReason) DllMain viene chiamato, come illustrato di seguito (il "thk" Ŕ il prefisso dal commutatore thunk del compilatore -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. Includere le seguenti righe nella sezione EXPORTS del file di definizione (DEF) modulo per la DLL a 32 bit. Ad esempio:
          
       thk_ThunkData32
    						
  3. Esportare le funzioni che chiama l'applicazione Win32. ╚ possibile utilizzare file di definizione (DEF) di modulo della DLL a 32 bit o la parola chiave __declspec (dllexport). Assicurarsi che le funzioni vengono dichiarate e definite come __stdcall (o WINAPI). Se la DLL a 32 bit Ŕ scritto in c ++, accertarsi di dichiarare le funzioni come extern "C".
  4. Compilare come segue lo script di thunk (se non Ŕ giÓ compilato):
          thunk -t thk 32to16.thk -o 32to16.asm
    						
  5. Consente di assemblare il file di linguaggio assembly generato dal compilatore thunk come modulo di oggetto a 32 bit. Ad esempio:
          ml /DIS_32 /c /W3 /nologo /coff /Fo thk32.obj 32to16.asm
    						
  6. Collegare il modulo di oggetto come parte della DLL a 32 bit.
  7. Collegare la libreria Thunk32.lib come parte della DLL a 32 bit. Si tratta di libreria di importazione di 32 bit fornita nel SDK di Win32 che contiene riferimenti alle API thunk di 32 bit che utilizza il codice creato dal compilatore thunk.

Generazione della DLL a 16 bit

  1. La DLL a 16 bit Ŕ necessario esportare una funzione denominata "DllEntryPoint." Questa funzione deve effettuare una chiamata una funzione creata dal compilatore thunk denominato thk__ThunkConnect16 ("thk" Ŕ il prefisso dall'opzione -t del compilatore thunk) ogni volta che viene chiamato 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. Includere le seguenti righe nella sezione IMPORTS del file di definizione (DEF) modulo per la DLL a 16 bit. Ad esempio:
          C16ThkSL01      = KERNEL.631
          ThunkConnect16  = KERNEL.651
    						
  3. Includere le seguenti righe nella sezione EXPORTS del file di definizione (DEF) modulo per la DLL a 16 bit. THK_THUNKDATA16 Ŕ definito nel file oggetto che Ŕ stato creato dall'output del compilatore thunk. Entrambi questi simboli deve avere la parola chiave RESIDENTNAME, ma si pu˛ avere qualsiasi numero ordinale.
          THK_THUNKDATA16 @1  RESIDENTNAME
          DllEntryPoint   @2  RESIDENTNAME
    						
  4. Aggiungere le funzioni di thunk all'istruzione EXPORTS del file di definizione (DEF) di modulo della DLL a 16 bit. Assicurarsi che siano dichiarati e definiti come __pascal __far __export (o WINAPI __export). Se la DLL Ŕ scritta in c ++, assicurarsi di dichiararli come extern "C". Il lato di 32 bit del thunk chiama queste funzioni.
  5. Compilare come segue lo script di thunk (se non Ŕ giÓ compilato):
          thunk -t thk 32to16.thk -o 32to16.asm
    						
  6. Consente di assemblare il file di linguaggio assembly generato dal compilatore thunk come modulo di oggetto di 16 bit. Ad esempio:
          ml /DIS_16 /c /W3 /nologo /Fo thk16.obj 32to16.asm
    						
  7. Collegare il modulo di oggetto come parte della DLL a 16 bit.
  8. Contrassegnare la DLL a 16 bit come versione 4.0. Per effettuare questa operazione, utilizzare il compilatore di risorse (RC.exe). La riga seguente viene illustrata la sintassi:
    RC-40 < file DLL >
    Questa opzione-40 Ŕ disponibile nel compilatore di risorse viene fornito con Win32 SDK.

    Nota : assicurarsi di utilizzare il file di RC.exe nella directory BINW16 in modo che la DLL contrassegnata con la versione 4.0. Il file RC.exe viene fornito con le versioni a 16 bit di Microsoft Visual c ++, la DLL non verrÓ contrassegnati come versione 4.0.

Riferimenti

Per informazioni su come eseguire il debug thunk flat, fare riferimento al seguente articolo della Microsoft Knowledge Base riportato di seguito:
133722How to: debug flat thunk

ProprietÓ

Identificativo articolo: 155763 - Ultima modifica: lunedý 11 luglio 2005 - Revisione: 2.3
Le informazioni in questo articolo si applicano a:
  • Microsoft Win32 Application Programming Interfaceáalle seguenti piattaforme
    • Microsoft Windows 95
    • Microsoft Windows 98 Standard Edition
    • Microsoft Windows Millennium Edition
    • Microsoft Platform Software Development Kit-edizione gennaio 2000
Chiavi:á
kbmt kbapi kbhowto kbkernbase kbnetwork kbprogramming kbthunks kbtshoot KB155763 KbMtit
Traduzione automatica articoli
Il presente articolo Ŕ stato tradotto tramite il software di traduzione automatica di Microsoft e non da una persona. Microsoft offre sia articoli tradotti da persone fisiche sia articoli tradotti automaticamente da un software, in modo da rendere disponibili tutti gli articoli presenti nella nostra Knowledge Base nella lingua madre dell?utente. Tuttavia, un articolo tradotto in modo automatico non Ŕ sempre perfetto. Potrebbe contenere errori di sintassi, di grammatica o di utilizzo dei vocaboli, pi¨ o meno allo stesso modo di come una persona straniera potrebbe commettere degli errori parlando una lingua che non Ŕ la sua. Microsoft non Ŕ responsabile di alcuna imprecisione, errore o danno cagionato da qualsiasi traduzione non corretta dei contenuti o dell?utilizzo degli stessi fatto dai propri clienti. Microsoft, inoltre, aggiorna frequentemente il software di traduzione automatica.
Clicca qui per visualizzare la versione originale in inglese dell?articolo: 155763
LE INFORMAZIONI CONTENUTE NELLA MICROSOFT KNOWLEDGE BASE SONO FORNITE SENZA GARANZIA DI ALCUN TIPO, IMPLICITA OD ESPLICITA, COMPRESA QUELLA RIGUARDO ALLA COMMERCIALIZZAZIONE E/O COMPATIBILITA' IN IMPIEGHI PARTICOLARI. L'UTENTE SI ASSUME L'INTERA RESPONSABILITA' PER L'UTILIZZO DI QUESTE INFORMAZIONI. IN NESSUN CASO MICROSOFT CORPORATION E I SUOI FORNITORI SI RENDONO RESPONSABILI PER DANNI DIRETTI, INDIRETTI O ACCIDENTALI CHE POSSANO PROVOCARE PERDITA DI DENARO O DI DATI, ANCHE SE MICROSOFT O I SUOI FORNITORI FOSSERO STATI AVVISATI. IL DOCUMENTO PUO' ESSERE COPIATO E DISTRIBUITO ALLE SEGUENTI CONDIZIONI: 1) IL TESTO DEVE ESSERE COPIATO INTEGRALMENTE E TUTTE LE PAGINE DEVONO ESSERE INCLUSE. 2) I PROGRAMMI SE PRESENTI, DEVONO ESSERE COPIATI SENZA MODIFICHE, 3) IL DOCUMENTO DEVE ESSERE DISTRIBUITO INTERAMENTE IN OGNI SUA PARTE. 4) IL DOCUMENTO NON PUO' ESSERE DISTRIBUITO A SCOPO DI LUCRO.

Invia suggerimenti

 

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