Changeset 511

Timestamp:

Aug 2, 2003, 5:57:20 AM (22 years ago)

Author:

bird

Message:

backup commit...

Location:

trunk/src/emx/src/emxomf

Files:

• emxomfld.c (modified) (8 diffs, 1 prop)
• weakld.c (modified) (55 diffs, 1 prop)
• weakld.h (modified) (3 diffs, 1 prop)

trunk/src/emx/src/emxomf/emxomfld.c

@@ -456 +456 @@
 
 
-/* finds the full path of a library or object file, after check 
-   default extentions an such. 
-      
+/* finds the full path of a library or object file, after check
+   default extentions an such.
+
    Object files will be searched for using the LIB env.var if not found.
-   
+
    Library hacks:
      1. file with .lib extention.
@@ -477 +477 @@
   FILE *        phFile;
   char          cchname = strlen (pszname);
-    
+
   /* Plain name first - the easist option */
   memcpy (pszfullname, pszname, cchname + 1);
@@ -501 +501 @@
   /* Search LIBS. */
   if (!strpbrk (pszname, ":\\/"))
-    { 
+    {
       int           ffound;
       const char *  pszend;
@@ -602 +602 @@
   PWLD    pwld;
 
-  pwld = wld_create (WLDC_VERBOSE);
+  pwld = wldCreate (WLDC_VERBOSE);
   if (pwld)
     {
@@ -614 +614 @@
           static const char * objexts[] = { ".obj", ".o", NULL };
           phfile = find_objlib (szname, pcur->name, objexts, TRUE);
-          rc = wld_add_object (pwld, phfile, szname);
+          rc = wldAddObject (pwld, phfile, szname);
         }
 
@@ -621 +621 @@
         {
           phfile = fopen (def_fname, "r");
-          rc = wld_add_deffile (pwld, phfile, def_fname);
+          rc = wldAddDefFile (pwld, phfile, def_fname);
         }
 
@@ -629 +629 @@
           static const char * libexts[] = { ".lib", ".a", NULL };
           phfile = find_objlib (szname, pcur->name, libexts, TRUE);
-          rc = wld_add_library (pwld, phfile, szname);
+          rc = wldAddLibrary (pwld, phfile, szname);
           free(pcur->name);
           pcur->name = xstrdup(szname);
         }
 
+      /* complete pass 1 */
+      if (!rc)
+      {
+          rc = wldPass1 (pwld);
+          /* ignore unresolved externals for now. */
+          if (rc == 42)
+              rc = 0;
+      }
+
       /* generate weak aliases. */
       if (!rc)
-        rc = wld_generate_weakobj (pwld, weakobj_fname);
+        rc = wldGenerateWeakobj (pwld, weakobj_fname);
       if (!rc && weakobj_fname[0])
         add_name_list (&add_obj_fnames, weakobj_fname);
 
       /* cleanup the linker */
-      wld_destroy (pwld);  
+      wldDestroy (pwld);
     }
   else
@@ -917 +926 @@
   make_env ();
 
-  /* Do the weak prelinking unless GCC_WEAKSYMS are set. 
+  /* Do the weak prelinking unless GCC_WEAKSYMS are set.
      Important that this is done after make_env(). */
 

trunk/src/emx/src/emxomf/weakld.c

@@ -1 @@
-/* $Id$
- *
+/* $Id$ */
+/** @file
  * Weak Symbol Pre-Linker.
  *
@@ -55 +55 @@
 
 #ifdef DEBUG
-
 #define SYMDBG(pSym, pszMsg)    symDbg(pSym, pszMsg);
+#define WLDDBG(a)               wldDbg a
+#define WLDDBG2(a)              wldDbg a
 #else
 #define SYMDBG(pSym, pszMsg)    do {} while (0)
-#endif 
+#define WLDDBG(a)               do {} while (0)
+#define WLDDBG2(a)              do {} while (0)
+#endif
 
 
@@ -87 +90 @@
 *   Structures and Typedefs                                                    *
 *******************************************************************************/
+/** @group OMF stuff
+ * @{ */
+
+/** OMF record header. */
+#pragma pack(1)
+typedef struct OMFREC
+{
+  unsigned char     chType;
+  unsigned short    cb;
+} OMFREC, *POMFREC;
+#pragma pack()
+
+
+/** OMF library header. */
+#pragma pack(1)
+typedef struct OMFLIBHDR
+{
+  unsigned char     chType;
+  unsigned short    cb;
+  unsigned long     offDict;
+  unsigned short    cDictBlocks;
+  unsigned char     fchFlags;
+} OMFLIBHDR, *POMFLIBHDR;
+#pragma pack()
+/** @} */
+
+
 /**
  * Library structure
@@ -96 +126 @@
     /** Filehandle if open */
     FILE *      phFile;
+    /** Pointer to extended dictiorary. */
+    void *      pDict;
+    /** Library header. */
+    OMFLIBHDR   LibHdr;
     /** Linked list next pointer. */
     struct wldlib * pNext;
@@ -289 +323 @@
 
     /** Linked list (FIFO) of libraries to be searched in the link. */
-    PWLDMOD             pLibs;
-    PWLDMOD *           ppLibsAdd;
+    PWLDLIB             pLibs;
+    PWLDLIB *           ppLibsAdd;
 
     /** string pool for miscellaneous string. */
@@ -301 +335 @@
 
 
-/** @group OMF stuff
- * @{ */
-
-/** OMF record header. */
-#pragma pack(1)
-typedef struct OMFREC
-{
-  unsigned char     chType;
-  unsigned short    cb;
-} OMFREC, *POMFREC;
-#pragma pack()
-
-
-/** OMF library header. */
-#pragma pack(1)
-typedef struct OMFLIBHDR
-{
-  unsigned char     chType;
-  unsigned short    cb;
-  unsigned long     offDict;
-  unsigned short    cDictBlocks;
-  unsigned char     fchFlags;
-} OMFLIBHDR, *POMFLIBHDR;
-#pragma pack()
-
-/** @} */
 
 
@@ -332 +340 @@
 extern void *xmalloc (size_t n);
 
+/** @group Weak LD - Linker Methods (Private)
+ * @{ */
+static void         wldDbg(const char *pszFormat, ...);
 static void         wldInfo(const char *pszFormat, ...);
 static int          wldErr(PWLD pWld, const char *pszFormat, ...);
 static void         wldIntErr(PWLD pWld, PWLDMOD pMod, const char *pszFile, unsigned iLine, const char *pszFunction);
+static unsigned     pass1ReadOMFMod(PWLD pWld, PWLDMOD pMod, int fLibSearch);
+/** @} */
+
+/** @group Weak LD - Library Methods (Private)
+ * @{ */
+static FILE *       libOpen(PWLDLIB pLib);
+static void         libClose(PWLDLIB pLib);
+static int          libLoadDict(PWLDLIB pLib);
+static void         libCloseDict(PWLDLIB pLib);
+static int          libTryLoadSymbolThruDictionary(PWLD pWld, PWLDLIB pLib, PWLDSYM pSym, unsigned *pcLoaded);
+static int          libLoadUndefSymbols(PWLD pWld, PWLDLIB pLib, PWLDSYM pSym, unsigned *pcLoaded);
+static int          libErr(PWLDLIB pLib, const char *pszFormat, ...);
+static void         libWarn(PWLDLIB pLib, const char *pszFormat, ...);
+/** @} */
+
+/** @group Weak LD - Module Methods (Private)
+ * @{ */
+static FILE *       modOpen(PWLDMOD pMod);
+static void         modClose(PWLDMOD pMod);
 static int          modErr(PWLDMOD pMod, const char *pszFormat, ...);
 static void         modWarn(PWLDMOD pMod, const char *pszFormat, ...);
-static FILE *       modOpen(PWLDMOD pMod);
-static void         modClose(PWLDMOD pMod);
-
-static inline unsigned hash(const char* pszSym, unsigned cch);
+/** @} */
+
+/** @group Weak LD - Symbole Methods (Private)
+ * @{ */
+typedef int (*PFNSYMENUM)(PWLD pWld, PWLDSYM pSym, void *pvUser);
+static int          symHaveUndefined(PWLD pWld);
+static int          symEnum(PWLD pWld, PWLDSYMTAB pSymTab, unsigned fFlags, unsigned fMask, PFNSYMENUM pfnEnum, void *pvUser);
+static int          symPrintUnDefEnum(PWLD pWld, PWLDSYM pSym, void *pvUser);
+static int          symMatchUnDef(PWLD pWld, const unsigned char *pachPascalString, PWLDSYM pSym);
+/** Pointed to by the pvUser parameter of symSearchLibEnum(). */
+typedef struct symSearchLibEnum_param
+{
+    /** Set if there are more undefined symbols. */
+    int         fMore;
+    /** Library to search for symbols in. */
+    PWLDLIB     pLib;
+    /** Number modules which was loaded. */
+    unsigned    cLoaded;
+} WLDSLEPARAM, *PWLDSLEPARAM;
+static int          symSearchLibEnum(PWLD pWld, PWLDSYM pSym, void *pvUser);
+static inline unsigned symHash(const char* pszSym, unsigned cch);
 static void         symDbg(PWLDSYM pSym, const char *pszMsg);
+static PWLDSYM      symAdd(PWLD pWld, PWLDMOD pMod, unsigned fFlags, const char *pachName, int cchName, PWLDSYMACTION peAction);
+static PWLDSYM      symAddImport(PWLD pWld, PWLDMOD pMod, int fLibSearch,
+                                 const char *pachIntName, int cchIntName,
+                                 const char *pachModName, int cchModName,
+                                 unsigned uOrdinal);
+static PWLDSYM symAddExport(PWLD pWld, PWLDMOD pMod, int fLibSearch,
+                            unsigned    fExport,
+                            unsigned    cExpWords,
+                            const char *pachExpName, int cchExpName,
+                            const char *pachIntName, int cchIntName,
+                            unsigned uOrdinal);
+static PWLDSYM symAddPublic(PWLD pWld, PWLDMOD pMod, int fLibSearch,
+                            const char *pachName, int cchName,
+                            unsigned long ulValue, int iSegment, int iGroup);
+static PWLDSYM symAddUnDef(PWLD pWld, PWLDMOD pMod, int fLibSearch,
+                           const char *pachName, int cchName);
+static PWLDSYM symAddAlias(PWLD pWld, PWLDMOD pMod, int fLibSearch,
+                           const char *pachAliasName, int cchAliasName,
+                           const char *pachName, int cchName);
+static PWLDSYM symAddComdef(PWLD pWld, PWLDMOD pMod, int fLibSearch,
+                            const char *pachName, int cchName,
+                            signed long cElements, signed long cbElement);
+/** @} */
 
 
@@ -352 +422 @@
 *******************************************************************************/
 
-
-/**
- * Put out a info message.
+#ifdef DEBUG
+/**
+ * Put out a debug message.
  * @param   pszFormat   Format string.
  * @param   ...         Format arguments.
  */
-static void         wldInfo(const char *pszFormat, ...)
+static void         wldDbg(const char *pszFormat, ...)
 {
     va_list     args;
-    fprintf(stderr, "weakld: info: ");
+    fprintf(stderr, "weakld: dbg: ");
 
     va_start(args, pszFormat);
@@ -369 +439 @@
         fputc('\n', stderr);
 }
+#endif
 
 /**
@@ -375 +446 @@
  * @param   ...         Format arguments.
  */
+static void         wldInfo(const char *pszFormat, ...)
+{
+    va_list     args;
+    fprintf(stderr, "weakld: info: ");
+
+    va_start(args, pszFormat);
+    vfprintf(stderr, pszFormat, args);
+    va_end(args);
+    if (pszFormat[strlen(pszFormat) - 1] != '\n')
+        fputc('\n', stderr);
+}
+
+/**
+ * Put out a info message.
+ * @param   pszFormat   Format string.
+ * @param   ...         Format arguments.
+ */
 static int          wldErr(PWLD pWld, const char *pszFormat, ...)
 {
     va_list     args;
     fprintf(stderr, "weakld: error: ");
-    
+
     va_start(args, pszFormat);
     vfprintf(stderr, pszFormat, args);
@@ -415 +503 @@
 
 
-/**
- * Report error in module.
- * @param   pMod        Pointer to module to report error on.
- * @param   pszFormat   Format string.
- * @param   ...         Format arguments.
- */
-static int      modErr(PWLDMOD pMod, const char *pszFormat, ...)
+
+
+
+
+
+
+
+/**
+ * Open this library file.
+ *
+ * @returns Pointer to open file stream.
+ * @returns NULL on failure.
+ * @param   pLib    Library to open.
+ */
+static FILE *       libOpen(PWLDLIB pLib)
+{
+    if (!pLib->phFile)
+    {
+        pLib->phFile = fopen(pLib->pszLibName, "rb");
+        if (pLib->phFile)
+            libErr(pLib, "Failed to open library.");
+    }
+    return pLib->phFile;
+}
+
+/**
+ * Close this library file.
+ * @param   pLib    Library to close.
+ */
+static void         libClose(PWLDLIB pLib)
+{
+    if (!pLib->phFile)
+    {
+        fclose(pLib->phFile);
+        pLib->phFile = NULL;
+    }
+}
+
+/**
+ * Load the dictionar for this library into memory.
+ *
+ * @returns 0 if we successfully loaded the dictionary.
+ * @returns -1 if we fail to read the dictionary into memory.
+ * @returns 1 if there is no dictionary.
+ * @param   pLib    Library which dictionary is to be loaded.
+ * @remark  This method will open the library. libClose() must be
+ *          called after this function is used.
+ */
+static int          libLoadDict(PWLDLIB pLib)
+{
+    FILE *phFile;
+
+    /* been here, done that? */
+    if (pLib->pDict)
+        return 0;
+
+    /* check if it acutally is a library and have an ext dict */
+    if (    pLib->LibHdr.chType != LIBHDR
+        ||  pLib->LibHdr.offDict != 0
+        ||  pLib->LibHdr.cDictBlocks != 0)
+        return 1;
+
+    /* ensure it's open. */
+    phFile = libOpen(pLib);
+    if (!phFile)
+        return -1;
+
+    /* position us */
+    if (fseek(phFile, pLib->LibHdr.offDict, SEEK_SET))
+        return libErr(pLib, "Failed to seek to extended dictionary (offset %d).", pLib->LibHdr.offDict);
+
+    /* read it */
+    pLib->pDict = xmalloc(pLib->LibHdr.cDictBlocks * 512);
+    if (fread(pLib->pDict, 512, pLib->LibHdr.cDictBlocks, phFile) == pLib->LibHdr.cDictBlocks)
+        return 0;
+    libErr(pLib, "Failed to read extended dictionary.");
+    free(pLib->pDict);
+    pLib->pDict = NULL;
+    return -1;
+}
+
+/**
+ * This closes the extended dictionary.
+ *
+ * @param   pLib    Library which extended dictionary should be closed.
+ * @remark  Will not close the library file, libClose() must be used for that.
+ */
+static void         libCloseDict(PWLDLIB pLib)
+{
+    if (pLib->pDict)
+    {
+        free(pLib->pDict);
+        pLib->pDict = NULL;
+    }
+}
+
+
+/**
+ * Does a dictionary lookup on an undefined name.
+ *
+ * @returns 0 on non failure.
+ * @returns 42 if not found.
+ * @returns -1 on link abort error.
+ * @param   pWld    Linker instance.
+ * @param   pLib    Library to search.
+ * @param   pSym    Undefined symbol to search for.
+ * @param   pcLoaded    Number of modules which was loaded from this library.
+ */
+static int          libTryLoadSymbolThruDictionary(PWLD pWld, PWLDLIB pLib, PWLDSYM pSym, unsigned *pcLoaded)
+{
+    //return 42;
+    return libLoadUndefSymbols(pWld, pLib, pSym, pcLoaded); /* @todo implement this function! */
+}
+
+
+/**
+ * Read thru an module looking for definitions for undef symbols.
+ * If a definition is found we'll load the module containing it.
+ *
+ * @returns 0 on non failure.
+ * @returns 42 if none found.
+ * @returns -1 on link abort error.
+ * @param   pWld    Linker instance.
+ * @param   pLib    Library to search.
+ * @param   pSym    Undefined symbol to search for.
+ *                  If NULL we'll try and see if any defined global symbol we
+ *                  encounter is undefined.
+ * @param   pcLoaded    Number of modules which was loaded from this library.
+ */
+static int          libLoadUndefSymbols(PWLD pWld, PWLDLIB pLib, PWLDSYM pSym, unsigned *pcLoaded)
+{
+    FILE *          phFile = pLib->phFile;
+    unsigned char   uchEnd1, uchEnd2;
+    OMFREC          OmfRec;
+    off_t           offCurMod;
+    int             fSkipRestOfModule = 0;
+    /* generic stuff */
+    unsigned long   ul;
+    signed long     l2, l3;
+    unsigned short  us, us2, us3;
+    unsigned char   uch, uch2;
+
+
+    /* Position the library at the first module record. */
+    if (fseek(phFile, pLib->LibHdr.chType == LIBHDR ? pLib->LibHdr.cb + 3 : 0, SEEK_SET))
+        return libErr(pLib, "Error when seeking to first module.");
+
+    if (pLib->LibHdr.chType != LIBHDR)
+    {
+        uchEnd1 = MODEND;
+        uchEnd2 = MODEND | REC32;
+    }
+    else
+        uchEnd1 = uchEnd2 = LIBEND;
+
+    OmfRec.chType = uchEnd1;
+    fread(&OmfRec, sizeof(OmfRec), 1, phFile);
+    while (OmfRec.chType != uchEnd1 &&  OmfRec.chType != uchEnd2)
+    {
+        int fRead = 0;
+        int fLoad = 0;
+        switch (OmfRec.chType)
+        {
+            case THEADR:
+                fSkipRestOfModule = 0;
+                offCurMod = ftell(phFile) - sizeof(OmfRec);
+                break;
+
+            /* read */
+            case PUBDEF: case PUBDEF | REC32:
+            case ALIAS:  case ALIAS  | REC32:
+            case COMDEF: case COMDEF | REC32:
+            case COMDAT: case COMDAT | REC32:
+            case COMENT: case COMENT | REC32:
+                fRead = !fSkipRestOfModule;
+                break;
+        }
+
+        if (fRead)
+        {
+            unsigned char   achBuffer[OMF_MAX_REC + 8];
+            union
+            {
+                unsigned char *     puch;
+                signed char *       pch;
+                unsigned short *    pus;
+                signed short *      ps;
+                unsigned long *     pul;
+                signed long *       pl;
+                void *              pv;
+            } u, u1, u2;
+
+            /** macro for getting a OMF index out of the buffer */
+            #define OMF_GETINDEX()  (*u.puch & 0x80 ? ((*u.pch++ & 0x7f) << 8) + *u.pch++ : *u.pch++)
+            #define OMF_BYTE()      (*u.puch++)
+            #define OMF_WORD()      (*u.pus++)
+            #define OMF_24BITWORD() (OMF_BYTE() | (OMF_WORD() << 8))
+            #define OMF_DWORD()     (*u.pul++)
+            #define OMF_MORE()      (u.puch - &achBuffer[0] < (int)OmfRec.cb - 1 && !fLoad) /* (different from the next) */
+            #define OMF_IS32BIT()   ((OmfRec.chType & REC32) != 0)
+            #define OMF_GETTYPELEN(l) \
+                do                                                       \
+                {                                                        \
+                    l = OMF_BYTE();                                      \
+                    if (l > 128)                                         \
+                        switch (l)                                       \
+                        {                                                \
+                            case 0x81: l = OMF_WORD(); break;            \
+                            case 0x84: l = OMF_24BITWORD(); break;       \
+                            case 0x88: l = OMF_DWORD(); break;           \
+                            default:                                     \
+                                libErr(pLib, "Invalid type length!");/* (different from the next) */ \
+                                return -1;                               \
+                        }                                                \
+                } while (0)
+
+            u.pv = &achBuffer[0];
+
+            /* read it */
+            if (fread(achBuffer, OmfRec.cb, 1, phFile) != 1)
+            {
+                libErr(pLib, "Read error. (2)");
+                break;
+            }
+
+            /* extract public symbols. */
+            switch (OmfRec.chType)
+            {
+                case COMENT: case COMENT | REC32:
+                    switch (*++u.pch)
+                    {
+                        case CLASS_PASS:
+                            fSkipRestOfModule = 1;
+                            break;
+                        case CLASS_OMFEXT:
+                        {
+                            switch (OMF_BYTE())
+                            {   /*
+                                 * Import definition.
+                                 */
+                                case OMFEXT_IMPDEF:
+                                {
+                                    uch = OMF_BYTE();               /* flags */
+                                    u1 = u; u.pch += 1 + *u.puch;   /* internal name */
+                                    u2 = u; u.pch += 1 + *u.puch;   /* module name */
+                                    ul = 0;                         /* ordinal */
+                                    if (uch & 1)
+                                        ul = OMF_WORD();
+                                    if (symMatchUnDef(pWld, u1.pch, pSym))
+                                        fLoad = 1;
+                                    break;
+                                }
+                            }
+                        }
+                    } /* comment class */
+                    break;
+
+                case PUBDEF: case PUBDEF | REC32:
+                {
+                    us2 = OMF_GETINDEX();           /* group index */
+                    us3 = OMF_GETINDEX();           /* segment index */
+                    if (!us3)
+                        us = OMF_WORD();            /* base frame - ignored */
+                    while (OMF_MORE())
+                    {
+                        u1 = u; u.pch += 1 + *u.puch;   /* public name */
+                        ul = OMF_IS32BIT() ? OMF_DWORD() : OMF_WORD();
+                        us = OMF_GETINDEX();            /* typeindex */
+                        if (symMatchUnDef(pWld, u1.pch, pSym))
+                            fLoad = 1;
+                    }
+                    break;
+                }
+
+                case ALIAS: case ALIAS | REC32:
+                {
+                    while (OMF_MORE())
+                    {
+                        u1 = u; u.pch += 1 + *u.puch;   /* alias name */
+                        u2 = u; u.pch += 1 + *u.puch;   /* substitutt name. */
+                        if (symMatchUnDef(pWld, u1.pch, pSym))
+                            fLoad = 1;
+                    }
+                    break;
+                }
+
+                case COMDEF: case COMDEF | REC32:
+                {
+                    while (OMF_MORE())
+                    {
+                        u1 = u; u.pch += 1 + *u.puch;   /* communal name (specs say 1-2 length...) */
+                        us2 = OMF_GETINDEX();           /* typeindex */
+                        uch2 = OMF_BYTE();              /* date type */
+                        switch (uch2)
+                        {
+                            case COMDEF_TYPEFAR:
+                                OMF_GETTYPELEN(l2);     /* number of elements */
+                                OMF_GETTYPELEN(l3);     /* element size */
+                                break;
+                            case COMDEF_TYPENEAR:
+                                l2 = 1;                 /* number of elements */
+                                OMF_GETTYPELEN(l3);     /* element size */
+                                break;
+                            default:
+                                libErr(pLib, "Invalid COMDEF type %x.", (int)uch2);
+                                return -1;
+                        }
+                        if (symMatchUnDef(pWld, u1.pch, pSym))
+                            fLoad = 1;
+                    }
+                    break;
+                }
+
+                case COMDAT: case COMDAT | REC32:
+                {
+                    /* @todo */
+                    break;
+                }
+            } /* switch */
+
+            #undef OMF_GETINDEX
+            #undef OMF_BYTE
+            #undef OMF_WORD
+            #undef OMF_24BITWORD
+            #undef OMF_DWORD
+            #undef OMF_MORE
+            #undef OMF_IS32BIT
+            #undef OMF_GETTYPELEN
+
+            /*
+             * Shall we load this module?
+             */
+            if (fLoad)
+            {
+                off_t   offSave = ftell(phFile);
+                PWLDMOD pMod;
+                int     rc;
+
+                pMod = xmalloc(sizeof(*pMod));
+                memset(pMod, 0, sizeof(*pMod));
+                pMod->off = offCurMod;
+                pMod->pLib = pLib;
+                pMod->phFile = phFile;
+                *pWld->ppObjsAdd = pMod;
+                pWld->ppObjsAdd = &pMod->pNext;
+
+                rc = pass1ReadOMFMod(pWld, pMod, 0);
+                if (rc)
+                {
+                    libErr(pLib, "Failed when reading module at offset %x.", offCurMod);
+                    return rc;
+                }
+
+                /* if one symbol, we're done now */
+                if (pSym)
+                    return 0;
+
+                /* Resume searching, but skip the rest of this one */
+                fSkipRestOfModule = 1;
+                fseek(phFile, offSave, SEEK_SET);
+            }
+        }
+        else
+        {
+            off_t   offSkip = OmfRec.cb;
+            /* Skip to next record. */
+            if (OmfRec.chType == MODEND || OmfRec.chType == (MODEND | REC32))
+            {
+                unsigned    cbPage = pLib->LibHdr.cb + 3;
+                off_t       off = ftell(phFile) + offSkip;
+                off -= cbPage * (off / cbPage); /* don't trust this to be 2**n. */
+                if (off)
+                    offSkip += cbPage - off;
+            }
+            if (fseek(phFile, offSkip, SEEK_CUR))
+            {
+                libErr(pLib, "Seek error.");
+                break;
+            }
+        }
+
+        /* next header */
+        if (fread(&OmfRec, sizeof(OmfRec), 1, phFile) != 1)
+        {
+            libErr(pLib, "Read error.");
+            break;
+        }
+    }
+
+
+    return 42;
+}
+
+
+/**
+ * Put out an error for this library.
+ * @param   pLib        Library which the warning occured in.
+ * @param   pszFormat   Message format.
+ * @param   ...         Format args.
+ */
+static int          libErr(PWLDLIB pLib, const char *pszFormat, ...)
 {
     va_list     args;
-    if (pMod->pLib)
-        fprintf(stderr, "weakld: %s(%s) - error: ", pMod->pLib->pszLibName, pMod->pszModName);
-    else
-        fprintf(stderr, "weakld: %s - error: ", pMod->pszModName);
+    fprintf(stderr, "weakld: %s: error: ", pLib->pszLibName);
 
     va_start(args, pszFormat);
@@ -437 +916 @@
 }
 
-
-/**
- * Report warning in module.
- * @param   pMod        Pointer to module to report warning on.
- * @param   pszFormat   Format string.
- * @param   ...         Format arguments.
- */
-static void     modWarn(PWLDMOD pMod, const char *pszFormat, ...)
+/**
+ * Put out a warning for this library.
+ * @param   pLib        Library which the warning occured in.
+ * @param   pszFormat   Message format.
+ * @param   ...         Format args.
+ */
+static void         libWarn(PWLDLIB pLib, const char *pszFormat, ...)
 {
     va_list     args;
-    if (pMod->pLib)
-        fprintf(stderr, "weakld: %s(%s) - warning: ", pMod->pLib->pszLibName, pMod->pszModName);
-    else
-        fprintf(stderr, "weakld: %s - warning: ", pMod->pszModName);
+    fprintf(stderr, "weakld: %s: warning: ", pLib->pszLibName);
 
     va_start(args, pszFormat);
@@ -458 +933 @@
         fputc('\n', stderr);
 }
+
+
+
+
+
+
+
+
+
 
 
@@ -507 +991 @@
 }
 
-
 /**
  * Closes the module.
@@ -522 +1005 @@
 }
 
-
-typedef int (*PFNSYMENUM)(PWLD pWld, PWLDSYM pSym, void *pvUser);
+/**
+ * Report error in module.
+ * @param   pMod        Pointer to module to report error on.
+ * @param   pszFormat   Format string.
+ * @param   ...         Format arguments.
+ */
+static int      modErr(PWLDMOD pMod, const char *pszFormat, ...)
+{
+    va_list     args;
+    if (pMod->pLib)
+        fprintf(stderr, "weakld: %s(%s) - error: ", pMod->pLib->pszLibName, pMod->pszModName);
+    else
+        fprintf(stderr, "weakld: %s - error: ", pMod->pszModName);
+
+    va_start(args, pszFormat);
+    vfprintf(stderr, pszFormat, args);
+    va_end(args);
+    if (pszFormat[strlen(pszFormat) - 1] != '\n')
+        fputc('\n', stderr);
+    return -1;
+}
+
+/**
+ * Report warning in module.
+ * @param   pMod        Pointer to module to report warning on.
+ * @param   pszFormat   Format string.
+ * @param   ...         Format arguments.
+ */
+static void     modWarn(PWLDMOD pMod, const char *pszFormat, ...)
+{
+    va_list     args;
+    if (pMod->pLib)
+        fprintf(stderr, "weakld: %s(%s) - warning: ", pMod->pLib->pszLibName, pMod->pszModName);
+    else
+        fprintf(stderr, "weakld: %s - warning: ", pMod->pszModName);
+
+    va_start(args, pszFormat);
+    vfprintf(stderr, pszFormat, args);
+    va_end(args);
+    if (pszFormat[strlen(pszFormat) - 1] != '\n')
+        fputc('\n', stderr);
+}
+
+
+
 
 /**
@@ -548 +1074 @@
             if ((pSym->fFlags & fMask) == fFlags)
             {
-                rc = pfnEnum(pWld, pSym, pvUser);    
+                rc = pfnEnum(pWld, pSym, pvUser);
                 if (rc)
                     return rc;
@@ -557 +1083 @@
     return 0;
 }
+
+
+/**
+ * Worker for wldHaveUndefined().
+ * @returns 42 and halts the search.
+ * @param   pWld    Linker instance.
+ * @param   pSym    Symbol.
+ * @param   pvUser  Pointer to a FILE stream.
+ */
+static int symHaveUndefinedEnum(PWLD pWld, PWLDSYM pSym, void *pvUser)
+{
+    return 42;
+}
+
+/**
+ * Checks if there is unresovled symbols in the link.
+ *
+ * @returns 1 if there is undefined symbols
+ * @returns 0 if all symbols are defined.
+ * @param   pWld    Linker instance.
+ */
+static int symHaveUndefined(PWLD pWld)
+{
+    return symEnum(pWld, &pWld->Global, WLDSF_UNDEF, WLDSF_TYPEMASK | WLDSF_WEAK, symHaveUndefinedEnum, NULL) == 42;
+}
+
+
+/**
+ * Enumerates the current undefined externals and try to resolve
+ * them using the current library passed in the pvUser structure.
+ * @returns
+ * @param   pWld    Linker instance.
+ * @param   pSym    Undefined symbol.
+ * @param   pvUser  Pointer to a WLDSLEPARAM structure.
+ *                  fMore will be set
+ */
+static int symSearchLibEnum(PWLD pWld, PWLDSYM pSym, void *pvUser)
+{
+    int             rc;
+    unsigned        cLoaded = 0;
+    PWLDSLEPARAM    pParam = (PWLDSLEPARAM)pvUser;
+
+    SYMDBG(pSym, "Searching for");
+
+    /*
+     * If we have a dictionary, we'll us it.
+     */
+    if (pParam->pLib->pDict)
+        rc = libTryLoadSymbolThruDictionary(pWld, pParam->pLib, pSym, &cLoaded);
+    else
+        rc = libLoadUndefSymbols(pWld, pParam->pLib, pSym, &cLoaded);
+
+    /* Housekeeping. */
+    pParam->cLoaded += cLoaded;
+    if (rc == 42) /* more undef from the load. */
+    {
+        pParam->fMore = 1;
+        rc = 0;
+    }
+
+    return rc;
+}
+
+/**
+ * Worker for enumerating unresolved symbols.
+ *
+ * @returns 0
+ * @param   pWld    Linker instance.
+ * @param   pSym    Undefined symbol.
+ * @param   pvUser  NULL
+ */
+static int          symPrintUnDefEnum(PWLD pWld, PWLDSYM pSym, void *pvUser)
+{
+    PWLDMOD pMod = pSym->pMod;
+
+    if (pMod)
+        modErr(pMod, "Unresolved symbol '%s'.", pSym->pszName);
+    else
+        wldErr(pWld, "Unresolved symbol '%s'.", pSym->pszName);
+    return 0;
+}
+
+/**
+ * Prints unresolved symbols.
+ *
+ * @param   pWld    Linker instance.
+ */
+static void         symPrintUnDefs(PWLD pWld)
+{
+    symEnum(pWld, &pWld->Global, WLDSF_UNDEF, WLDSF_TYPEMASK | WLDSF_WEAK, symPrintUnDefEnum, NULL);
+}
+
+/**
+ * Checks the OMF encoded name with the specified undefined
+ * symbol, or all undefined symbols.
+ *
+ * @returns 1 if symbol matches.
+ * @returns 0 if symbol mis-matches.
+ * @param   pWld                Linker instance.
+ * @param   pachPascalString    OMF encoded string.
+ * @param   pSym                If NULL match all, if !NULL match this.
+ */
+static int          symMatchUnDef(PWLD pWld, const unsigned char *pachPascalString, PWLDSYM pSym)
+{
+    int         cch = *pachPascalString;
+    const char *psz = pachPascalString + 1;
+    int (*pfn)(const char *, const char *, size_t) = (pWld->fFlags & WLDC_CASE_INSENSITIVE) ? strnicmp : strncmp;
+
+    if (pSym)
+        return !pfn(pSym->pszName, psz, cch) && !pSym->pszName[cch];
+    else
+    {
+#if 1   /* hashed */
+        unsigned uHash = symHash(psz, cch);
+        for (pSym = pWld->Global.ap[uHash]; pSym; pSym = pSym->pHashNext)
+        {
+            if ((pSym->fFlags & (WLDSF_TYPEMASK | WLDSF_WEAK)) == WLDSF_UNDEF)
+            {
+                if (!pfn(pSym->pszName, psz, cch) && !pSym->pszName[cch])
+                    return 1;
+            }
+        }
+#else
+        /* raw */
+        int i;
+        for (i = 0; i < sizeof(pWld->Global.ap) / sizeof(pWld->Global.ap[0]); i++)
+        {
+            for (pSym = pWld->Global.ap[i]; pSym; pSym = pSym->pHashNext);
+            {
+                if ((pSym->fFlags & (WLDSF_TYPEMASK | WLDSF_WEAK)) == WLDSF_UNDEF)
+                {
+                    if (!pfn(pSym->pszName, psz, cch) && !pSym->pszName[cch])
+                        return 1;
+                }
+            }
+        }
+#endif
+    }
+    return 0;
+}
+
+
+
+
+
 
 
@@ -596 +1267 @@
     fprintf(stderr, "\n");
 }
-#endif 
+#endif
 
 
@@ -604 +1275 @@
  * @param   pszSym  Symbol to calculate it for.
  * @param   cch     Symbol length.
- */
-static inline unsigned hash(const char* pszSym, unsigned cch)
+ * @todo    This ain't respecting case sensitivity.
+ */
+static inline unsigned symHash(const char* pszSym, unsigned cch)
 {
     unsigned uHash = 0;
-    while (cch && *pszSym && *pszSym != '$')
+    while (     cch
+           &&   (pszSym[0] != '$' || pszSym[1] != 'w' || pszSym[2] != '$')
+             )
     {
         uHash = uHash * 65599 + *pszSym;
@@ -625 +1299 @@
  *
  * We'll simply return existing symbol when:
- *      1. adding a UNDEF where a PUBLIC or COMM exists.
+ *      1. adding a UNDEF where a PUBLIC or COMM or !WEAK UNDEF exists.
  *      2. adding a WKEXT where a PUBLIC or COMM exists.
  *      3. adding a WKEXT where a UNDEF which isn't UNCERTAIN exists.
- *      4. adding a COMM where a !WEAK COMM exists. 
+ *      4. adding a COMM where a !WEAK COMM exists.
  *      5. adding a WEAK PUBLIC or WEAK COMM where a PUBLIC or COMM exists.
  *
@@ -693 +1367 @@
             break;
         }
-    uHash = hash(pachName, cchName);
     pszName = (pWld->fFlags & WLDC_CASE_INSENSITIVE ? strpool_addnu : strpool_addn)(pWld->pStrMisc, pachName, cchName);
+    uHash = symHash(pszName, cchName);
 
     /* search for existing symbol  */
@@ -721 +1395 @@
         pWld->Global.ap[uHash] = pSym;
         if (peAction) *peAction = WLDSA_NEW;
+        WLDDBG2(("symAdd: New symbol '%s'", pSym->pszName));
     }
     else
@@ -730 +1405 @@
          *      2. adding a WKEXT where a PUBLIC or COMM exists.
          *      3. adding a WKEXT where a UNDEF which isn't UNCERTAIN exists.
-         *      4. adding a COMM where a !WEAK COMM exists. 
+         *      4. adding a COMM where a !WEAK COMM exists.
          *      5. adding a WEAK PUBLIC or WEAK COMM where a PUBLIC or COMM exists.
          */
         if ( (     /* 1 */
                 (fFlags & WLDSF_TYPEMASK) == WLDSF_UNDEF
-             && ((pSym->fFlags & WLDSF_TYPEMASK) == WLDSF_PUBLIC || (pSym->fFlags & WLDSF_TYPEMASK) == WLDSF_COMM)
+             && ((pSym->fFlags & WLDSF_TYPEMASK) == WLDSF_PUBLIC || (pSym->fFlags & WLDSF_TYPEMASK) == WLDSF_COMM
+                 || (pSym->fFlags & (WLDSF_TYPEMASK | WLDSF_WEAK)) == WLDSF_UNDEF)
             ) || ( /* 2 */
                 (fFlags & WLDSF_TYPEMASK) == WLDSF_WKEXT
@@ -751 +1427 @@
         {
             if (peAction) *peAction = WLDSA_OLD;
+            WLDDBG2(("symAdd: Old symbol '%s'", pSym->pszName));
         }
         /*
@@ -763 +1440 @@
             modWarn(pMod, "Ignoring import '%s' as it's defined already.", pszName);
             if (peAction) *peAction = WLDSA_OLD;
+            WLDDBG2(("symAdd: Old symbol '%s'", pSym->pszName));
         }
         /*
@@ -792 +1470 @@
             pSym->fFlags = (pSym->fFlags & ~(WLDSF_TYPEMASK | WLDSF_WEAK | WLDSF_UNCERTAIN | WLDSF_LIBSEARCH)) | fFlags;
             if (peAction) *peAction = WLDSA_UP;
+            WLDDBG2(("symAdd: Upgraded symbol '%s'", pSym->pszName));
         }
         /*
@@ -811 +1490 @@
             if (peAction) *peAction = WLDSA_UP;
             memset(&pSym->u, 0, sizeof(pSym->u));
+            WLDDBG2(("symAdd: Upgraded symbol '%s'", pSym->pszName));
         }
         /*
@@ -820 +1500 @@
         else
         {
-            modErr(pMod, "Duplicate symbol '%s'.", pszName);
+            modErr(pMod, "Duplicate symbol '%s' ('%s').", pszName, pSym->pszName);
             if (pSym->pMod)
                 modErr(pSym->pMod, "Previous symbol defined in this module.");
@@ -1131 +1811 @@
     if (!pSym)
         return NULL;
-    
+
     cbElement *= (cElements > 0 ? cElements : 1); /* make it a size */
     switch (eAction)
@@ -1153 +1833 @@
             WLDINTERR(pWld, pMod);
     }
-    
+
     return pSym;
 }
@@ -1185 +1865 @@
     int             i;
     unsigned long   ul;
-    signed long     l, l2, l3;
+    signed long     l2, l3;
     unsigned short  us, us2, us3;
-    unsigned char   uch, uch2, uch3;
-
+    unsigned char   uch, uch2;
+
+    /* We're counting indexes from 1, so add dummy zero entry. */
+    papExts = xmalloc(sizeof(papExts[0])*64);
+    papExts[0] = NULL;
+    cExts = 1;
 
 
@@ -1208 +1892 @@
             void *              pv;
         } u, u1, u2, u3;
-        
+
         /** macro for getting a OMF index out of the buffer */
         #define OMF_GETINDEX()  (*u.puch & 0x80 ? ((*u.pch++ & 0x7f) << 8) + *u.pch++ : *u.pch++)
@@ -1233 +1917 @@
             } while (0)
 
-
         u.pv = &achBuffer[0];
 
@@ -1267 +1950 @@
             case COMDAT: case COMDAT | REC32:
             case COMENT: case COMENT | REC32:
+            case THEADR: case THEADR | REC32:
             case LIBHDR:
                 break;
@@ -1283 +1967 @@
         switch (OmfRec.chType)
         {
+            case THEADR:
+            {
+                if (!pMod->pszModName)
+                {
+                    pMod->pszModName = strpool_addn(pWld->pStrMisc, u.pch + 1, *u.puch);
+                    WLDINFO(pWld, ("%s", pMod->pszModName));
+                }
+                break;
+            }
+
             case COMENT: case COMENT | REC32:
                 switch (*++u.pch)
@@ -1381 +2075 @@
                     if (!pSym) goto failure;
                     SYMDBG(pSym, "EXTDEF");
+                    /* put into array of externals */
+                    if (!(cExts % 64))
+                    {
+                        cExts += 64;
+                        papExts = xrealloc(papExts, sizeof(papExts[0]) * cExts);
+                    }
+                    papExts[cExts++] = pSym;
                 }
                 break;
@@ -1396 +2097 @@
                     ul = OMF_IS32BIT() ? OMF_DWORD() : OMF_WORD();
                     us = OMF_GETINDEX();            /* typeindex */
-                    pSym = symAddPublic(pWld, pMod, fLibSearch, u1.puch + 1, *u1.puch, 
+                    pSym = symAddPublic(pWld, pMod, fLibSearch, u1.puch + 1, *u1.puch,
                                         ul, us3, us2);
                     if (!pSym) goto failure;
@@ -1410 +2111 @@
                     u1 = u; u.pch += 1 + *u.puch;   /* alias name */
                     u2 = u; u.pch += 1 + *u.puch;   /* substitutt name. */
-                    pSym = symAddAlias(pWld, pMod, fLibSearch, 
-                                       u1.puch + 1, *u1.puch, 
+                    pSym = symAddAlias(pWld, pMod, fLibSearch,
+                                       u1.puch + 1, *u1.puch,
                                        u2.puch + 1, *u2.puch);
                     if (!pSym) goto failure;
@@ -1433 +2134 @@
                             break;
                         case COMDEF_TYPENEAR:
-                            l2 = 1;                 /* number of elements */  
-                            OMF_GETTYPELEN(l3);     /* element size */        
+                            l2 = 1;                 /* number of elements */
+                            OMF_GETTYPELEN(l3);     /* element size */
                             break;
                         default:
@@ -1441 +2142 @@
                     }
 
-                    pSym = symAddComdef(pWld, pMod, fLibSearch, 
-                                        u1.puch + 1, *u1.puch, 
+                    pSym = symAddComdef(pWld, pMod, fLibSearch,
+                                        u1.puch + 1, *u1.puch,
                                         l2, l3);
                     if (!pSym) goto failure;
@@ -1481 +2182 @@
     /* Make all the EXTDEFs uncertain. */
     for (i = 0; i < cExts; i++)
-        papExts[i]->fFlags &= ~WLDSF_UNCERTAIN;
+        if (papExts[i])
+            papExts[i]->fFlags &= ~WLDSF_UNCERTAIN;
 
     return 0;
@@ -1511 +2213 @@
  * @param   fFlags  Linker flags as defined by enum wld_create_flags.
  */
-PWLD    wld_create(int fFlags)
+PWLD    wldCreate(int fFlags)
 {
     PWLD    pWld = xmalloc(sizeof(*pWld));
@@ -1519 +2221 @@
     pWld->fFlags = fFlags;
     pWld->pStrMisc = strpool_init();
-    pWld->ppLibsAdd = &pWld->pObjs;
-    pWld->ppObjsAdd = &pWld->pLibs;
+    pWld->ppObjsAdd = &pWld->pObjs;
+    pWld->ppLibsAdd = &pWld->pLibs;
 
     /* done */
@@ -1535 +2237 @@
  * @param   pWld    Linker instance to destroy.
  */
-int     wld_destroy(PWLD pWld)
+int     wldDestroy(PWLD pWld)
 {
     if (!pWld)
@@ -1565 +2267 @@
  *          or wld_generate_weaklib()!
  */
-int     wld_add_object(PWLD pWld, FILE *phFile, const char *pszName)
+int     wldAddObject(PWLD pWld, FILE *phFile, const char *pszName)
 {
     OMFREC  OmfRec = {0,0};
@@ -1655 +2357 @@
  *          or wld_generate_weaklib()!
  */
-int     wld_add_deffile(PWLD pWld, FILE *phFile, const char *pszName)
+int     wldAddDefFile(PWLD pWld, FILE *phFile, const char *pszName)
 {
     if (!phFile)
@@ -1685 +2387 @@
  * @author  Don't call wld_add_library after wld_generate_weaklib()!
  */
-int     wld_add_library(PWLD pWld, FILE *phFile, const char *pszName)
-{
+int     wldAddLibrary(PWLD pWld, FILE *phFile, const char *pszName)
+{
+    PWLDLIB     pLib;
+    int         rc = 0;
+
     if (!phFile)
         phFile = fopen(pszName, "r");
@@ -1697 +2402 @@
         fprintf(stderr, "weakld: info: adding library %s\n", pszName);
 
-    return 0;
+    /* add it to the link, do nothing till we're asked to do the searching. */
+    pLib = xmalloc(sizeof(*pLib));
+    pLib->phFile = phFile;
+    pLib->pszLibName = strpool_add(pWld->pStrMisc, pszName);
+    pLib->pNext = NULL;
+
+    /* read the library header. */
+    if (    !fseek(phFile, 0, SEEK_SET)
+        &&  fread(&pLib->LibHdr, sizeof(OMFREC), 1, phFile) == 1
+        &&  (   pLib->LibHdr.chType != LIBHDR
+             || fread(&pLib->LibHdr.offDict, sizeof(pLib->LibHdr) - sizeof(OMFREC), 1, phFile) == 1
+                )
+        )
+    {
+        /* link it in */
+        *pWld->ppLibsAdd = pLib;
+        pWld->ppLibsAdd = &pLib->pNext;
+        libClose(pLib);
+    }
+    else
+    {
+        /* We failed. */
+        libErr(pLib, "Invalid library format or read error.");
+        fclose(phFile);
+        free(pLib);
+        rc = -1;
+    }
+
+    return rc;
+}
+
+
+/**
+ * Does the linker pass one - chiefly library search as .def and .obj is
+ * already processed as pass 1.
+ *
+ * @returns 0 on success (all symbols resolved)
+ * @returns 42 if there are unresolved symbols.
+ * @returns Something else on all other errors.
+ * @param   pWld    Linker Instance.
+ */
+int     wldPass1(PWLD pWld)
+{
+    int     fMore;
+    int     cLoaded;
+    int     fFirstTime = 1;
+
+    WLDINFO(pWld, ("Pass 1"));
+    do
+    {
+        PWLDLIB     pLib;
+
+        cLoaded = fMore = 0;
+        for (pLib = pWld->pLibs; pLib; pLib = pLib->pNext)
+        {
+            int         rc;
+            WLDSLEPARAM param;
+            WLDINFO(pWld, ("%s", pLib->pszLibName));
+
+            /*
+             * Open the library
+             */
+            if (!libOpen(pLib))
+                continue;
+
+            /*
+             * Load extended dictionary if we wanna use it.
+             */
+            if (fFirstTime && !(pWld->fFlags & WLDC_NO_EXTENDED_DICTIONARY_SEARCH))
+                libLoadDict(pLib);
+            else
+                libCloseDict(pLib);
+
+            /*
+             * Enumerate undefined symbols and try load them from this library.
+             */
+            do
+            {
+                param.fMore = FALSE;
+                param.cLoaded = 0;
+                param.pLib = pLib;
+                if (pLib->pDict)
+                    rc = symEnum(pWld, &pWld->Global, WLDSF_UNDEF, WLDSF_TYPEMASK | WLDSF_WEAK, symSearchLibEnum, &param);
+                else
+                {
+                    rc = libLoadUndefSymbols(pWld, pLib, NULL, &param.cLoaded);
+                    if (rc == 42)
+                    {
+                        param.fMore = 1;
+                        rc = 0;
+                    }
+                }
+                cLoaded += param.cLoaded;
+                if (!param.fMore && param.cLoaded)
+                    param.fMore = symHaveUndefined(pWld);
+            } while (!rc && param.cLoaded > 0);
+
+            /* close it */
+            libClose(pLib);
+            if (rc && rc != 42)
+                return rc;
+        }
+
+        /* We only trust this if it's set. */
+        fMore = symHaveUndefined(pWld);
+        fFirstTime = 0;
+    } while (fMore && cLoaded > 0);
+
+    /* @todo: proper warning? */
+    if (fMore)
+        symPrintUnDefs(pWld);
+
+    return fMore ? 42 : 0;
 }
 
@@ -1740 +2557 @@
         {
             wldErr(pWld, "Error occured while writing weak aliases. (1)");
-            return -1;  
+            return -1;
         }
 
@@ -1751 +2568 @@
         {
             wldErr(pWld, "Error occured while writing weak aliases (2).");
-            return -1;  
+            return -1;
         }
 
@@ -1762 +2579 @@
         {
             wldErr(pWld, "Error occured while writing weak aliases (3).");
-            return -1;  
+            return -1;
         }
 
@@ -1771 +2588 @@
         {
             wldErr(pWld, "Error occured while writing weak aliases (4).");
-            return -1;  
+            return -1;
         }
     }
@@ -1790 +2607 @@
  *                  This is an empty string if no weak symbols were found!
  */
-int     wld_generate_weakobj(PWLD pWld, char *pszName)
+int     wldGenerateWeakobj(PWLD pWld, char *pszName)
 {
     char *      psz;
     FILE *      phFile;
-    int         rc = -1;
-
+    int         rc;
+
+    /* generate the file */
     *pszName = '\0';
     psz = _tempnam(NULL, "weako");
@@ -1806 +2624 @@
         tmpnam(pszName);
     strcat(pszName, "wk.obj");
-
-    if (pWld->fFlags & WLDC_VERBOSE)
-        fprintf(stderr, "weakld: info: generating weakobj object file '%s'.\n", pszName);
+    WLDINFO(pWld, ("Generating weakobj object file '%s'.", pszName));
+
 
     /* open the file */
@@ -1837 +2654 @@
         /* Make aliases  */
         offAlias = ftell(phFile);       /* save this to see if anything is added. */
-        rc = symEnum(pWld, &pWld->Global, 
+        rc = symEnum(pWld, &pWld->Global,
                      WLDSF_WEAK, WLDSF_WEAK,
                      weakobjEnum, phFile);

trunk/src/emx/src/emxomf/weakld.h

@@ -1 @@
-/* $Id$
+/* $Id$ */
+/** @file
  *
  * Weak Pre-Linker.
@@ -30 +31 @@
 *******************************************************************************/
 struct wld;
+/** Weak LD Instance Pointer. */
 typedef struct wld * PWLD;
 
@@ -47 +49 @@
 *   Functions                                                                  *
 *******************************************************************************/
-PWLD    wld_create(int fFlags);
-int     wld_add_object(PWLD pWld, FILE *phFile, const char *pszName);
-int     wld_add_deffile(PWLD pWld, FILE *phFile, const char *pszName);
-int     wld_add_library(PWLD pWld, FILE *phFile, const char *pszName);
-int     wld_generate_weakobj(PWLD pwld, char *pszName);
-int     wld_destroy(PWLD pWld);
+/** @group Weak LD - Public methods.
+ * @{ */
+PWLD    wldCreate(int fFlags);
+int     wldAddObject(PWLD pWld, FILE *phFile, const char *pszName);
+int     wldAddDefFile(PWLD pWld, FILE *phFile, const char *pszName);
+int     wldAddLibrary(PWLD pWld, FILE *phFile, const char *pszName);
+int     wldPass1(PWLD pWld);
+int     wldGenerate_weakobj(PWLD pwld, char *pszName);
+int     wldDestroy(PWLD pWld);
+/** @} */
 
 #endif