C DLL header files
C does not have import units like Delphi, but an optional static import library (with accompanying header and definition file). From the C DLL we can generate a static import .LIB file with IMPLIB, and the .DEF file with IMPDEF (these tools are part of any C/C++ developing environment). It is the header file that is the most interesting part, since this defines which functions and which parameters are to be linked in. Most C DLLs will therefore ship with the .DLL and .H files only (we can regenerate the rest).
To illustrate the task of header conversion, let's check out a sample C DLL header file, and do the conversion by hand. As an example that everybody will have access to, I choose the WING.H header file from the 16-bit WING.DLL that Mircosoft provides to developers:

 /*********************************************************************\
 *
 * wing.h - WinG functions, types, and definitions
 *
 *          Copyright (c) 1994 Microsoft Corp. All rights reserved.
 *
 \********************************************************************/
 
 #ifndef _INC_WING
 #define _INC_WING

 #ifndef _INC_WINDOWS
 #include     /* Include windows.h if not already included */
 #endif

 #ifdef __cplusplus
 extern "C" {            /* Assume C declarations for C++ */
 #endif

 #if defined(WIN32) || defined(_WIN32)
 #define WINGAPI WINAPI
 #else
 #define WINGAPI WINAPI _loadds
 #endif

 /***** WingDC and WinGBitmap ****************************************/

 HDC WINGAPI WinGCreateDC( void );

 BOOL WINGAPI WinGRecommendDIBFormat( BITMAPINFO FAR *pFormat );

 HBITMAP WINGAPI WinGCreateBitmap( HDC WinGDC, BITMAPINFO const FAR *pHeader,
         void FAR *FAR *ppBits );

 void FAR *WINGAPI WinGGetDIBPointer( HBITMAP WinGBitmap,
         BITMAPINFO FAR *pHeader );

 UINT WINGAPI WinGGetDIBColorTable( HDC WinGDC, UINT StartIndex,
         UINT NumberOfEntries, RGBQUAD FAR *pColors );

 UINT WINGAPI WinGSetDIBColorTable( HDC WinGDC, UINT StartIndex,
         UINT NumberOfEntries, RGBQUAD const FAR *pColors );

 /***** Halftoning ***************************************************/

 HPALETTE WINGAPI WinGCreateHalftonePalette( void );

 typedef enum WING_DITHER_TYPE
 {
     WING_DISPERSED_4x4,
     WING_DISPERSED_8x8,
     WING_CLUSTERED_4x4
 } WING_DITHER_TYPE;

 HBRUSH WINGAPI WinGCreateHalftoneBrush( HDC Context, COLORREF crColor,
         WING_DITHER_TYPE DitherType );

 /***** Blts *********************************************************/

 BOOL WINGAPI WinGBitBlt( HDC hdcDest, int nXOriginDest,
         int nYOriginDest, int nWidthDest, int nHeightDest, HDC hdcSrc,
         int nXOriginSrc, int nYOriginSrc );

 BOOL WINGAPI WinGStretchBlt( HDC hdcDest, int nXOriginDest,
         int nYOriginDest, int nWidthDest, int nHeightDest, HDC hdcSrc,
         int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc );

 #ifdef __cplusplus
 }                       /* End of extern "C" */
 #endif

 #endif // _INC_WING

Type Conversion
When converting C function prototypes to Pascal equivalent declarations, it's important to substitute the C function and argument types with the correct Pascal types. I often use a Type Translation Table for this, like the following in table 1 (optional parts on the C-side are noted between square brackets):

It's also nice to have access to the translation of the special WINDOWS.H types, which is already done by Borland, and can be found in WINTYPES.PAS (it's a rewarding experience to compare these two files with each other - you'll learn a lot about C and Pascal conversion issues).
Now that we've handled the standard built-in (and Windows) types, let's look at the C type definition of WING_DITHER_TYPE that is present in the WING.H file.

 typedef enum WING_DITHER_TYPE
 {
     WING_DISPERSED_4x4,
     WING_DISPERSED_8x8,
     WING_CLUSTERED_4x4
 } WING_DITHER_TYPE;

 type
   WING_DITHER_TYPE =
    (WING_DISPERSED_4x4,
     WING_DISPERSED_8x8,
     WING_CLUSTERED_4x4);

C Functions
Now that we've seen C to Pascal type conversion, we can start to convert a few of the functions that are defined in the C header file, like the WinGCreateDC function:

 HDC WINGAPI WinGCreateDC( void );

 function WinGCreateDC: HDC; {$IFDEF WIN32} stdcall; {$ENDIF}
          external 'WING' index 1001;

 var WinGCreateDC: function: HDC; {$IFDEF WIN32} stdcall; {$ENDIF}

 function WinGRecommendDIBFormat(pFormat: PBitmapInfo): Bool; {$IFDEF WIN32} stdcall; {$ENDIF}
          external 'WING' index 1002;

 function WinGCreateBitmap(WinGDC: HDC;
                           Const pHeader: PBitmapInfo;
                           ppBits: PPointer): HBITMAP; {$IFDEF WIN32} stdcall; {$ENDIF}
          external 'WING' index 1003;

 function WinGCreateHalftoneBrush(Context: HDC;
                                  crColor: TColorRef;
                                  DitherType: WING_DITHER_TYPE): HBRUSH; {$IFDEF WIN32} stdcall; {$ENDIF}
          external 'WING' index 1008;

Compiler Directives
As I've said, compiler directives are the last and often most difficult task to convert. It's often important to keep in mind what the target of the converted unit will be - win16 or win32 for example, so you can eliminate a lot of conversions will you're scanning compiler directives (you won't need to convert everything in the #ifdef WIN32 section if you are working on a 16-bit import unit only, of course.