How To Call 32-bit Code from 16-bit Code Under Windows 95, Windows 98, or Windows Millennium Edition

1. Creating the thunk Script.
2. Building the 16-bit DLL.
3. Building the 32-bit DLL.

Back to the top

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

Back to the top

Tools Needed to Build Flat Thunks

1. Microsoft Visual C++ 1.5x (16-bit compiler) for the 16-bit side of the thunk. The 16-bit side of the thunk is a 16-bit DLL.
2. Microsoft Visual C++ 2.x or higher (32-bit compiler) for the 32-bit side of the thunk. The 32-bit side of the thunk is a 32-bit DLL.
3. Thunk compiler (thunk.exe) from the Microsoft Win32 SDK for compiling thunk scripts.
4. Microsoft Macro Assembler (MASM) version 6.1 or higher for assembling the assembly-language output of the thunk compiler.
5. The 16-bit RC.EXE from the BINW16 directory of the Microsoft Win32 SDK for marking the 16-bit thunk DLL as version 4.0.

Back to the top

Creating the Thunk Script

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

Back to the top

Using the Thunk Compiler

Back to the top

Building the 16-bit DLL

1. The 16-bit DLL must export a function named "DllEntryPoint". This function must make a call to a function created by the thunk compiler named thk_ThunkConnect16 ("thk" is the prefix from the thunk compiler -t switch) every time DllEntryPoint is called:

      // 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. Include the following lines in the IMPORTS section of the module definition (DEF) file for the 16-bit DLL:

      C16ThkSL01      = KERNEL.631
      ThunkConnect16  = KERNEL.651
   						

3. Include the following lines in the EXPORTS section of the module definition (.DEF) file for the 16-bit DLL. THK_THUNKDATA16 is defined in the object file that is assembled from the output of the thunk compiler. Both of these symbols must have the RESIDENTNAME keyword, but can have any ordinal number:

      THK_THUNKDATA16 @1  RESIDENTNAME
      DllEntryPoint   @2  RESIDENTNAME
   						

4. Add the thunk functions that the Win16 application will call to the EXPORTS statement of the 16-bit DLL's module definition (DEF) file. Be sure they are declared and defined as __far __pascal __export (or WINAPI __export). If the DLL is written in C++, be sure to declare them as extern "C" as well.
5. Compile the thunk as follows (if not already compiled):

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

6. Next, assemble the assembly-language file produced by the thunk compiler as a 16-bit object module. The following line shows an example:

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

7. Link this object module as part of the 16-bit DLL.
8. Mark the 16-bit DLL as version 4.0. To do this, use the resource compiler (RC.EXE). The following line shows the syntax:
   rc -40 <DLL file>
   This -40 option is available in the resource compiler that is provided with the Win32 SDK.
   
   NOTE: Be sure to use the RC.EXE in the BINW16 directory so that the DLL is marked with version 4.0. The RC.EXE that ships with 16-bit versions of Microsoft Visual C++ will not mark the DLL as version 4.0.

Back to the top

Building the 32-bit DLL

1. In the DllMain of your 32-bit DLL, you must make a call to a function created by the thunk compiler named thk_ThunkConnect32 every time DllMain is called, as shown here ("thk" is the prefix from the thunk compiler - t switch):

      // 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. Include the following lines in the EXPORTS section of the module definition (.DEF) file for the 32-bit DLL:

   thk_ThunkData32
   						

3. Export the functions to which you are thunking. You can use either the 32-bit DLL's module definition (DEF) file or the __declspec(dllexport) keyword. Be sure they are declared and defined as __stdcall. If the 32-bit DLL is written in C++, be sure to declare them as extern "C" as well. These functions are called by the 16-bit side of the thunk.
4. Compile the thunk script as follows (if not already compiled):

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

5. Assemble the assembly-language file produced by the thunk compiler as a 32-bit object module. The following line shows an example:

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

6. Link this object module as part of the 32-bit DLL.
7. Link thunk32.lib as part of the 32-bit DLL. This is the 32-bit import library provided in the Win32 SDK that contains references to the 32-bit thunking APIs that the code created by the thunk compiler uses.

Back to the top