Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

1358 lines
48 KiB

/* SCCSID = %W% %E% */
/*
* Copyright Microsoft Corporation, 1983-1987
*
* This Module contains Proprietary Information of Microsoft
* Corporation and should be treated as Confidential.
*/
/****************************************************************
* *
* LIBRARY PROCESSING ROUTINES *
* *
****************************************************************/
#include <minlit.h> /* Types and constants */
#include <bndtrn.h> /* Types and constants */
#include <bndrel.h> /* Types and constants */
#include <lnkio.h> /* Linker I/O definitions */
#include <lnkmsg.h> /* Error messages */
#include <extern.h> /* External declarations */
#include <stdlib.h>
#if OSMSDOS
#include <dos.h> /* DOS interface definitions */
#if CPU286
#define INCL_BASE
#include <os2.h> /* OS/2 interface definitions */
#if defined(M_I86LM)
#undef NEAR
#define NEAR
#endif
#endif
#endif
#define DICHDR 0xF1 /* Dictionary header type (F1H) */
#if OSXENIX
#define ShrOpenRd(f) fopen(f,RDBIN)
#endif
#if NEWIO
#include <errno.h> /* System error codes */
#endif
#define PNSORTMAX 512 /* Maximum # modules can be sorted */
typedef struct _edmt /* Extended Dictionary Module Table */
{
WORD page;
WORD list;
}
edmt;
LOCAL FTYPE fUndefHit; /* found this undef in the library */
LOCAL FTYPE fFileExtracted; /* Took file from library flag */
LOCAL FTYPE fUndefsSeen; /* True if externals seen in library */
LOCAL WORD ipnMac; /* Count of page numbers in sort table */
LOCAL WORD *pnSort; /* Sort table for library page numbers */
/* f(ifh) = pointer to dictionary */
LOCAL WORD mpifhcpnHash[IFHLIBMAX];
/* f(ifh) = # pages in hash table */
LOCAL BYTE mpifhAlign[IFHLIBMAX];
/* f(ifh) = lib alignment factor */
LOCAL RBTYPE vrpNewList; /* List of unprocessed files */
LOCAL FTYPE vfLibOpen; /* Library open flag */
#if M_BYTESWAP OR defined( _WIN32 )
#define getfarword getword /* This assumes no far data */
#else
#define getfarword(x) (((WORD FAR *)(x))[0])
#endif
/*
* INTERFACE WITH ASSEMBLY LANGUAGE FUNCTION
*/
WORD libAlign; /* Library alignment factor */
WORD libcpnHash; /* Length of hash table in pages */
BYTE FAR *mpifhDict[IFHLIBMAX];
/*
* FUNCTION PROTOTYPES
*/
LOCAL unsigned char NEAR OpenLibrary(unsigned char *sbLib);
LOCAL void NEAR FreeDictionary(void);
#if CPU8086 OR CPU286
LOCAL WORD NEAR readfar(int fh, char FAR *buf,int n);
#endif
LOCAL void NEAR GetDictionary(void);
LOCAL WORD NEAR GetLib(void);
LOCAL void ProcessAnUndef(APROPNAMEPTR papropUndef,
RBTYPE rhte,
RBTYPE rprop,
WORD fNewHte);
LOCAL int cdecl FGtNum(const WORD *pn1, const WORD *pn2);
LOCAL void NEAR LookMod(edmt *modtab,unsigned short iMod);
LOCAL void NEAR LookPage(edmt *modtab,unsigned short cMod,unsigned short page);
LOCAL void NEAR ProcExtDic(char *pExtDic);
LOCAL char * NEAR GetExtDic(void);
#if NEW_LIB_SEARCH
/// undef lookaside list
typedef struct tag_UND
{
struct tag_UND * pNext;
APROPNAMEPTR papropUndef;
DWORD dwLibMask;
RBTYPE rhte;
} UND;
#define C_UNDS_POOL 128
typedef struct tag_UNDPOOL
{
struct tag_UNDPOOL *pNext;
UND und[C_UNDS_POOL];
} UNDPOOL;
// pool storage management variables
UNDPOOL *pundpoolCur;
UNDPOOL *pundpoolHead;
int iundPool = C_UNDS_POOL;
UND * pundFree;
UND * pundListHead;
#define FUndefsLeft() (pundListHead != NULL)
void StoreUndef(APROPNAMEPTR, RBTYPE, RBTYPE, WORD);
#else
#define FUndefsLeft() (fUndefsSeen)
#endif
FTYPE fStoreUndefsInLookaside = FALSE;
/////
#if NOASM
LOCAL WORD NEAR rolw(WORD x, WORD n) /* Rotate word left */
{
return(LO16BITS((x << n) | ((x >> (WORDLN - n)) & ~(~0 << n))));
}
LOCAL WORD NEAR rorw(WORD x, WORD n) /* Rotate word right */
{
return(LO16BITS((x << (WORDLN - n)) | ((x >> n) & ~(~0 << (WORDLN - n)))));
}
#endif
#if OSMSDOS
BSTYPE NEAR ShrOpenRd(pname)
char *pname; /* Name of file (null-terminated) */
{
int fh; /* File handle */
#if NEWIO
if(mpifhfh[ifhLibCur])
{
fh = mpifhfh[ifhLibCur];
/* If dictionary not allocated, seek to beginning since we're
* somewhere else now.
*/
if(!mpifhDict[ifhLibCur])
if (_lseek(fh,0L,0) == -1) {
return NULL;
}
}
else
fh = SmartOpen(pname,ifhLibCur);
if(fh > 0)
{
fflush(bsInput);
bsInput->_file = (char) fh;
return(bsInput);
}
else
return(NULL);
#else
if((fh = _sopen(pname,O_RDONLY | O_BINARY,SH_DENYWR)) < 0)
return(NULL);
return(fdopen(fh,RDBIN));
#endif
}
#endif /* OSMSDOS */
#pragma check_stack(on)
/****************************************************************
* *
* OpenLibrary: *
* *
* This function takes as its arguments a pointer to the text *
* of the name of the library to open, a count of the bytes in *
* that name, an index into a global table in which to place *
* the file handle for the opened library. It returns TRUE if *
* it succeeds, FALSE if it fails to open the file; and it *
* dies gracefully if the file is not a valid library. *
* *
****************************************************************/
LOCAL FTYPE NEAR OpenLibrary(sbLib)
BYTE *sbLib; /* Library name */
{
SBTYPE libnam; /* Library name */
WORD reclen; /* Library header record length */
BSTYPE bsLib; /* File stream pointer for library */
memcpy(libnam,&sbLib[1],min(sizeof(libnam), B2W(sbLib[0])));
/* Copy library name */
libnam[B2W(sbLib[0])] = '\0'; /* Null-terminate name */
/* WARNING: do not assign bsInput to NULL if open fails, it
* screws up NEWIO.
*/
if((bsLib = ShrOpenRd(libnam)) != NULL)
{ /* If open successful */
bsInput = bsLib;
/* If dictionary already allocated, no need to do anything */
if(mpifhDict[ifhLibCur])
return((FTYPE) TRUE);
#if OSMSDOS
/* Reduce buffer size. We can avoid calling setvbuf() because
* everything is set up properly at this point.
*/
#if OWNSTDIO
bsInput->_bsize = 512;
#else
setvbuf(bsInput, bsInput->_base, _IOFBF, 512);
#endif
#endif
if(getc(bsInput) == LIBHDR) /* If we have a library */
{
reclen = (WORD) (3 + WSGets());
/* Get record length */
for(libAlign = 15; libAlign &&
!(reclen & (1 << libAlign)); --libAlign);
/* Calculate alignment factor */
mpifhAlign[ifhLibCur] = (BYTE) libAlign;
if(libAlign >= 4 && reclen == (WORD) (1 << libAlign))
{ /* Check legality of alignment */
libHTAddr = (long) WSGets();
libHTAddr += (long) WSGets() << WORDLN;
/* Get the offset of the hash table */
if (libHTAddr <= 0L)
Fatal(ER_badlib,libnam);
if ((mpifhcpnHash[ifhLibCur] = WSGets()) <= 0)
/* Get size of hash table in pages */
Fatal(ER_badlib,libnam);
#if OSMSDOS
/* Restore big buffer size. Avoid calling setvbuf(). */
#if OWNSTDIO
bsInput->_bsize = LBUFSIZ;
#else
setvbuf(bsInput, bsInput->_base, _IOFBF, LBUFSIZ);
#endif
#endif
return((FTYPE) TRUE); /* Success */
}
}
Fatal(ER_badlib,libnam);
}
return(FALSE); /* Failure */
}
#pragma check_stack(off)
/*
* LookupLibSym: look up a symbol in library dictionary
*
* The minimum page size is 16, so we can return paragraph offsets.
* This is a win because offsets are stored as paragraphs in the
* sorting table anyway. Also, the majority of libraries have page
* size of 16.
*
* Parameters:
* char *psb - pointer to length-prefixed string
* Returns:
* Long paragraph offset to location of module which defines
* the symbol, or 0L if not found.
*/
#if NOASM
LOCAL WORD NEAR LookupLibSym(psb)
BYTE *psb; /* Symbol to look up */
{
WORD i1; /* First hash value */
WORD d1; /* First hash delta */
WORD i2; /* Second hash value */
WORD d2; /* Second hash delta */
WORD pn; /* Page number */
WORD dpn; /* Page number delta */
WORD pslot; /* Page slot */
WORD dpslot; /* Page slot delta */
WORD ipn; /* Initial page number */
BYTE FAR *hpg;
#if NOASM
WORD ch1; /* Character */
WORD ch2; /* Character */
char *pc1; /* Character pointer */
char *pc2; /* Character pointer */
WORD length; /* Symbol length */
#endif
#if LIBDEBUG
OutSb(stderr,psb);
fprintf(stderr," is wanted; dictionary is %d pages\r\n",libcpnHash);
#endif
#if NOASM
length = B2W(psb[0]); /* Get symbol length */
pc1 = (char *) psb; /* Initialize */
pc2 = (char *) &psb[B2W(psb[0])]; /* Initialize */
i1 = 0; /* Initialize */
d1 = 0; /* Initialize */
i2 = 0; /* Initialize */
d2 = 0; /* Initialize */
while(length--) /* Hashing loop */
{
ch1 = (WORD) (B2W(*pc1++) | 040);/* Force to lower case */
ch2 = (WORD) (B2W(*pc2--) | 040);/* Force to lower case */
i1 = (WORD) (rolw(i1,2) ^ ch1); /* Hash */
d1 = (WORD) (rolw(d1,2) ^ ch2); /* Hash */
i2 = (WORD) (rorw(i2,2) ^ ch2); /* Hash */
d2 = (WORD) (rorw(d2,2) ^ ch1); /* Hash */
}
#else
i1 = libhash(psb,&d1,&i2,&d2); /* Hash */
#endif
pn = (WORD) (i1 % libcpnHash); /* Calculate page number index */
if(!(dpn = (WORD) (d1 % libcpnHash))) dpn = 1;
/* Calculate page number delta */
pslot = (WORD) (i2 % CSLOTMAX); /* Calculate page slot index */
if(!(dpslot = (WORD) (d2 % CSLOTMAX))) dpslot = 1;
/* Calculate page slot delta */
#if LIBDEBUG
fprintf(stderr,"page index %d, delta %d, bucket index %d, delta %d\r\n",
pn,dpn,pslot,dpslot);
#endif
ipn = pn; /* Remember initial page number */
for(;;) /* Search loop */
{
#if LIBDEBUG
fprintf(stderr,"Page %d:\r\n",pn);
#endif
// Get pointer to the dictionary page
hpg = mpifhDict[ifhLibCur] + (pn << LG2PAG);
for(i2 = 0; i2 < CSLOTMAX; ++i2)/* Loop to check slots */
{
#if LIBDEBUG
fprintf(stderr,"Bucket %d %sempty, page %sfull\r\n",
pslot,hpg[pslot]? "not ": "",
B2W(hpg[CSLOTMAX]) == 0xFF? "": "not ");
#endif
if(!(i1 = (WORD) (B2W(hpg[pslot]) << 1)))
{ /* If slot is empty */
if(B2W(hpg[CSLOTMAX]) == 0xFF) break;
/* If page is full, break */
return(0); /* Search failed */
}
#if LIBDEBUG
fprintf(stderr," Comparing ");
OutSb(stderr,psb);
fprintf(stderr," to ");
OutSb(stderr,&hpg[i1]);
fprintf(stderr," %signoring case\r\n",fIgnoreCase? "": "not ");
#endif
if(psb[0] == hpg[i1] && SbNewComp(psb,&hpg[i1],fIgnoreCase))
{ /* If symbols match */
#if LIBDEBUG
fprintf(stderr,"Match found in slot %d\r\n",i2 >> 1);
#endif
i1 += (WORD) (B2W(hpg[i1]) + 1); /* Skip over name */
i1 = getfarword(&hpg[i1]);
/* Get page number of module */
return(i1); /* Return page number of module */
}
if((pslot += dpslot) >= CSLOTMAX) pslot -= CSLOTMAX;
/* Try next slot */
}
if((pn += dpn) >= libcpnHash) pn -= libcpnHash;
/* Try next page */
if (ipn == pn) return(0); /* Once around without finding it */
}
}
#endif /*NOASM*/
/*
* FreeDictionary : free space allocated for dictionaries
*/
LOCAL void NEAR FreeDictionary ()
{
WORD i;
for (i = 0; i < ifhLibMac; ++i)
if (mpifhDict[i])
FFREE(mpifhDict[i]);
}
#if CPU8086 OR CPU286
/*
* readfar : read() with a far buffer
*
* Emulate read() except use a far buffer. Call the system
* directly.
*
* Returns:
* 0 if error, else number of bytes read.
*/
LOCAL WORD NEAR readfar (fh, buf, n)
int fh; /* File handle */
char FAR *buf; /* Buffer to store bytes in */
int n; /* # bytes to read */
{
#if OSMSDOS
unsigned bytesread; /* Number of bytes read */
#if CPU8086
if (_dos_read(fh, buf, n, &bytesread))
return(0);
return(bytesread);
#else
if(DosRead(fh,buf,n,(unsigned FAR *) &bytesread))
return(0);
return(bytesread);
#endif
#endif /* OSMSDOS */
#if OSXENIX
char mybuf[PAGLEN];
int cppage;
char *p;
while(n > 0)
{
cppage = n > PAGLEN ? PAGLEN : n;
if(read(fh,mybuf,cppage) != cppage)
return(0);
n -= cppage;
for(p = mybuf; p < mybuf[cppage]; *buf++ = *p++);
}
#endif
}
#endif
LOCAL void NEAR GetDictionary ()
{
unsigned cb;
#if CPU8086 OR CPU286
// If there is more than 128 pages in dictionary return,
// because the dictionary is bigger than 64k
if (libcpnHash >= 128)
return;
#endif
cb = libcpnHash << LG2PAG;
mpifhDict[ifhLibCur] = GetMem(cb);
// Go to the dictionary and read it in a single call
#if defined(M_I386) || defined( _WIN32 )
if (fseek(bsInput, libHTAddr, 0))
Fatal(ER_badlib,1 + GetPropName(FetchSym(mpifhrhte[ifhLibCur],FALSE)));
if (fread(mpifhDict[ifhLibCur], 1, cb, bsInput) != (int) cb)
Fatal(ER_badlib,1 + GetPropName(FetchSym(mpifhrhte[ifhLibCur],FALSE)));
#else
_lseek(fileno(bsInput), libHTAddr, 0);
if (readfar(fileno(bsInput), mpifhDict[ifhLibCur], cb) != cb)
Fatal(ER_badlib,1 + GetPropName(FetchSym(mpifhrhte[ifhLibCur],FALSE)));
#endif
}
#pragma check_stack(on)
LOCAL WORD NEAR GetLib(void) /* Open the next library in list */
{
AHTEPTR pahteLib; /* Pointer to library name */
#if OSMSDOS
SBTYPE sbLib; /* Library name */
SBTYPE sbNew; /* New parts to library name */
#endif
if(mpifhrhte[ifhLibCur] == RHTENIL) /* If this library is to be skipped */
{
return(FALSE); /* No library opened */
}
for(;;) /* Loop to open library */
{
pahteLib = (AHTEPTR ) FetchSym(mpifhrhte[ifhLibCur],FALSE);
/* Get name from hash table */
if(OpenLibrary(GetFarSb(pahteLib->cch))) break;
/* Break if lib opened okay */
if(fNoprompt)
Fatal(ER_libopn,1 + GetFarSb(pahteLib->cch));
else
{
sbLib[0] = '\0'; /* No string yet */
UpdateFileParts(sbLib,GetFarSb(pahteLib->cch));
(*pfPrompt)(sbNew,ER_libopn, /* Prompt for new filespec */
(int) (__int64) (1 + GetFarSb(pahteLib->cch)),
P_EnterNewFileSpec, 0);
}
if(fNoprompt || !sbNew[0])
{
mpifhrhte[ifhLibCur] = RHTENIL;
/* Do not bother next time */
return(FALSE); /* Unsuccessful */
}
#if OSMSDOS
UpdateFileParts(sbLib,sbNew); /* Update file name with new parts */
PropSymLookup(sbLib,ATTRFIL,TRUE);
/* Add library to symbol table */
mpifhrhte[ifhLibCur] = vrhte; /* Save virtual address */
AddLibPath(ifhLibCur); /* Add default path spec, maybe */
#endif
}
vfLibOpen = (FTYPE) TRUE; /* A library is open */
libcpnHash = mpifhcpnHash[ifhLibCur];
libAlign = mpifhAlign[ifhLibCur];
if (mpifhDict[ifhLibCur] == NULL) /* If dictionary not allocated, do it */
GetDictionary();
return(TRUE); /* Success */
}
#pragma check_stack(off)
/****************************************************************
* *
* ProcessAnUndef: *
* *
* This function takes as its arguments two pointers, two *
* RBTYPEs, and a flag. It does not return a meaningful *
* value. Most of the parameters to this function are *
* dummies; this function's address is passed as a parameter, *
* and its parameter list must match those of all the *
* functions whose addresses can be passed as a parameter to *
* the same function to which ProcessAnUndef's address is *
* passed. Called by EnSyms. *
* *
****************************************************************/
LOCAL void ProcessAnUndef(APROPNAMEPTR papropUndef,
RBTYPE rhte,
RBTYPE rprop__NotUsed__,
WORD fNewHte__NotUsed__)
{
AHTEPTR pahte; /* Pointer to hash table entry */
WORD pn; /* Library page number */
APROPUNDEFPTR pUndef;
ATTRTYPE attr;
#if NOT NEWSYM
SBTYPE sb; /* Undefined symbol */
#endif
fUndefHit = FALSE;
pUndef = (APROPUNDEFPTR ) papropUndef;
attr = pUndef->au_flags;
// don't pull out any "weak" externs or unused aliased externals
if (((attr & WEAKEXT) && !(attr & UNDECIDED)) ||
((attr & SUBSTITUTE) && !(attr & SEARCH_LIB)))
{
fUndefHit = TRUE; // this item is effectively resolved...
return;
}
fUndefsSeen = (FTYPE) TRUE; /* Set flag */
if(!mpifhDict[ifhLibCur] && !vfLibOpen)
return; /* Return if unable to get library */
pahte = (AHTEPTR ) FetchSym(rhte,FALSE);
/* Fetch name from symbol table */
#if NOT NEWSYM
memcpy(sb,pahte->cch,B2W(pahte->cch[0]) + 1);
/* Copy name */
#endif
#if LIBDEBUG
fprintf(stdout,"Looking for '%s' - ", 1+GetFarSb(pahte->cch));
fflush(stdout);
#endif
#if NEWSYM
if(pn = LookupLibSym(GetFarSb(pahte->cch)))
#else
if(pn = LookupLibSym(sb)) /* If symbol defined in this library */
#endif
{
fUndefHit = TRUE;
#if LIBDEBUG
fprintf(stdout,"Symbol found at page %xH\r\n", pn);
fflush(stdout);
#endif
/* We now try to stuff the page number (pn) into a table that will
* be sorted later.
*/
if (ipnMac < PNSORTMAX)
{
pnSort[ipnMac++] = pn;
return;
}
/*
* No room to save the file offset so save file directly.
*/
pahte = (AHTEPTR ) FetchSym(mpifhrhte[ifhLibCur],FALSE);
/*
* If SaveInput returns 0, then module was seen before. Means
* that dictionary says symbol is defined in this module but
* for some reason, such as IMPDEF, the definition wasn't
* accepted. In this case, we return.
*/
if(!SaveInput(GetFarSb(pahte->cch), (long)pn << libAlign, ifhLibCur, 0))
return;
/*
* If first module extracted, save start of file list.
*/
if(!fFileExtracted)
{
vrpNewList = vrpropTailFile;
fFileExtracted = (FTYPE) TRUE;
}
}
#if LIBDEBUG
else
{
fprintf(stdout, "Symbol NOT found\r\n"); /* Debug message */
fflush(stdout);
}
#endif
}
#if NEW_LIB_SEARCH
void StoreUndef(APROPNAMEPTR papropUndef, RBTYPE rhte,
RBTYPE rprop, WORD fNewHte)
{
UND * pund;
APROPUNDEFPTR pUndef;
ATTRTYPE attr;
pUndef = (APROPUNDEFPTR ) papropUndef;
attr = pUndef->au_flags;
// don't pull out any "weak" externs or unused aliased externals
if (((attr & WEAKEXT) && !(attr & UNDECIDED)) ||
((attr & SUBSTITUTE) && !(attr & SEARCH_LIB)))
return;
#ifdef LIBDEBUG
{
AHTEPTR pahte;
pahte = (AHTEPTR) FetchSym(rhte,FALSE);
fprintf(stdout,"Adding '%s'\r\n", 1+GetFarSb(pahte->cch));
fflush(stdout);
}
#endif
if (pundFree) // check free list
{
pund = pundFree;
pundFree = pundFree->pNext;
}
else if (iundPool < C_UNDS_POOL) // check pool
{
pund = &pundpoolCur->und[iundPool];
iundPool++;
}
else
{
// allocate new pool...
pundpoolCur = (UNDPOOL *)GetMem(sizeof(UNDPOOL));
pundpoolCur->pNext = pundpoolHead;
pundpoolHead = pundpoolCur;
pund = &pundpoolCur->und[0];
iundPool = 1; // entry zero is already used up
}
pund->dwLibMask = 0;
pund->pNext = pundListHead;
pund->papropUndef = papropUndef;
pund->rhte = rhte;
pundListHead = pund;
}
#endif
/*
* Greater-than comparator to be used by Sort routine.
*/
LOCAL int cdecl FGtNum(const WORD *pn1, const WORD *pn2)
{
if (*pn1 < *pn2)
return(-1);
if (*pn1 > *pn2)
return(1);
return(0);
}
/************************************************************************
* Extended Dictionary
*
* The extended dictionary occurs at the end of the regular dictionary
* and contains a first-level dependency tree for all the modules
* in the library.
************************************************************************/
#define LIBEXD 0xf2 /* Library EXtended Dictionary */
/****************************************************************
* *
* Extended Dictionary Format: *
* *
* *
* BYTE =0xF2 Extended Dictionary header *
* WORD length of extended dictionary in bytes *
* excluding 1st 3 bytes *
* *
* Start of ext. dictionary: *
* *
* WORD number of modules in library = N *
* *
* Module table, indexed by module number, with N + 1 fixed- *
* length entries: *
* *
* WORD module page number *
* WORD offset from start of ext. dictionary to list *
* of required modules *
* *
* Last entry is null. *
* *
* Module dependency lists, N variable-length lists: *
* *
* WORD list length (number of required modules) *
* WORD module index, 0-based; this is index to module *
* . . . table at the begin of ext. dictionary. *
* . . . *
* *
* *
****************************************************************/
/*
* LookMod : look up a module by index in the extended dictionary
*
* Get the list of modules required by the given module. If not
* already marked, save index in sorting table (which will be
* converted to page number later) and mark the entry in the
* module table as seen by setting the low bit of the list offset.
*
* Parameters:
* modtab: Pointer to module table
* iMod: Index into table, 0-based
*/
LOCAL void NEAR LookMod (edmt *modtab, WORD iMod)
{
WORD *pw; /* Pointer to list of indexes */
WORD n; /* List counter */
/*
* Get the pointer to the list. Mask off low bit since it is used
* as a marker.
*/
pw = (WORD *) ((char *) modtab + (modtab[iMod].list & ~1));
/*
* For every entry in the list, if the corresponding entry in the
* module table is not marked, save the index in pnSort and mark
* the entry in the module table.
*/
for(n = *pw++; n--; pw++)
{
if(!(modtab[*pw].list & 1))
{
/*
* Check for table overflow.
*/
if(ipnMac == PNSORTMAX)
return;
pnSort[ipnMac++] = *pw;
modtab[*pw].list |= 1;
}
}
}
/*
* LookPage : Look up a module in the module table by page number
*
* Use binary search. If page is found, call LookMod() on the
* matching entry.
*
* Parameters:
* modtab: Pointer to module table
* cMod: Number of entries in table
* page: Page number
* ASSUMES:
* The highest entry in the table has a page number of 0xffff.
*/
LOCAL void NEAR LookPage (edmt *modtab, WORD cMod, WORD page)
{
WORD mid; /* Current mid point */
WORD lo, hi; /* Current low and high points */
lo = 0; /* Table is 0-based. */
hi = (WORD) (cMod - 1);
while(lo <= hi)
{
if(modtab[mid = (WORD) ((lo + hi) >> 1)].page == page)
{
modtab[mid].list |= 1;
LookMod(modtab,mid);
return;
}
else if(modtab[mid].page < page)
lo = (WORD) (mid + 1);
else
hi = (WORD) (mid - 1);
}
}
/*
* ProcExtDic : Process Extended Dictionary
*
* Store in pnSort all the secondary modules required by
* the modules obtained from the regular dictionary lookup.
*
* Parameters:
* pExtDic: Pointer to extended dictionary
*/
LOCAL void NEAR ProcExtDic (pExtDic)
char *pExtDic;
{
WORD *p;
WORD *pEnd;
WORD cMod;
edmt *modtab;
cMod = getword(pExtDic);
modtab = (edmt *) (pExtDic + 2);
/* For the binary search algorithm, we make an artifical last entry
* with a page # at least as high as anything else.
*/
modtab[cMod].page = 0xffff;
/* Process by page numbers */
for(p = pnSort, pEnd = &pnSort[ipnMac]; p < pEnd; ++p)
LookPage(modtab, cMod, *p);
/* Now pnSort from pEnd to lfaSort[ipnMac] contains module
* index numbers. Process by index number and convert to page.
*/
for( ; p < &pnSort[ipnMac]; ++p)
{
LookMod(modtab,*p);
*p = modtab[*p].page;
}
}
/*
* GetExtDic - Get Extended Dictionary
*/
LOCAL char * NEAR GetExtDic ()
{
char *p;
int length;
if(!vfLibOpen)
if(!GetLib())
return(NULL);
/* WARNING: we must just have read dictionary for this to work,
* otherwise an fseek() is required here.
*/
if (!mpifhDict[ifhLibCur])
{
fflush(bsInput);
if (fseek(bsInput, libHTAddr + (libcpnHash << LG2PAG), 0))
Fatal(ER_badlib,1 + GetPropName(FetchSym(mpifhrhte[ifhLibCur],FALSE)));
}
if(getc(bsInput) != LIBEXD)
return(NULL);
if((p = GetMem(length = WSGets())) != NULL)
if(fread(p,1,length,bsInput) != length)
{
FreeMem(p);
p = NULL;
}
return(p);
}
char *pExtDic = NULL; /* Pointer to extended dictionary */
/****************************************************************
* *
* LibrarySearch: *
* *
* This function takes no arguments. It searches all open *
* libraries to resolve undefined externals. It does not *
* return a meaningful value. *
* *
****************************************************************/
void NEAR LibrarySearch(void)
{
RBTYPE vrpTmpFileFirst;
WORD ifhLibMacInit; /* Initial number of libs to search */
FTYPE searchMore; /* Search continue flag */
WORD bufpnSort[PNSORTMAX];
/* Actual space for pnSort */
SBTYPE sbLibname; /* Name of current library */
AHTEPTR pahte; /* Pointer to hash table entry */
REGISTER WORD i;
FTYPE fLibPass1 = (FTYPE) TRUE;
/* True if on 1st pass thru libs */
FTYPE *fUsedInPass1; /* True if lib used in 1st pass thru libs */
FTYPE fFirstTime; /* True if lib seen for the first time */
extern FTYPE fNoExtDic; /* True if /NOEXTDICTIONARY */
#if NEW_LIB_SEARCH
UND *pund; /* pointer in undef lookaside list */
UND *pundPrev; /* pointer to previous undef entry */
UND *pundNext; /* pointer to next undef entry */
#endif
fUndefsSeen = (FTYPE) TRUE; /* There are undefined externals */
vfLibOpen = FALSE; /* No libraries open yet */
pnSort = bufpnSort; /* Initialize sort table pointer */
ifhLibMacInit = ifhLibMac;
fUsedInPass1 = (FTYPE *) GetMem(ifhLibMac * sizeof(FTYPE));
if (fUsedInPass1 != NULL)
memset(fUsedInPass1, TRUE, ifhLibMac);
#if NEW_LIB_SEARCH
// build up the the lookaside list
EnSyms(StoreUndef,ATTRUND);
fStoreUndefsInLookaside = TRUE;
#endif
do /* Loop to search libraries */
{
searchMore = FALSE; /* Assume on final pass */
for(ifhLibCur = 0; ifhLibCur < ifhLibMac && FUndefsLeft(); ++ifhLibCur)
{ /* While undefs and libraries */
#if NEW_LIB_SEARCH
DWORD libMask = (1<<ifhLibCur);
if (pundListHead->dwLibMask & libMask)
continue; // no need to search this library
// the first item in the list has already
// been searched...
#endif
if(!GetLib())
continue;
/*
* If this is first pass through the libraries and /NOEXT was
* not given, try to get the extended dictionary. We assume that
* if there is one then only one library pass is needed.
*/
if(fLibPass1 && !fNoExtDic)
pExtDic = GetExtDic();
else
pExtDic = NULL;
/* If no extended dictionary, reduce buffer size because more
* seeking will be done. This will affect remaining libraries
* in search; we don't care about mixed extended and non-
* extended libraries.
*/
if(!pExtDic)
setvbuf(bsInput,bsInput->_base,_IOFBF,1024);
pahte = (AHTEPTR ) FetchSym(mpifhrhte[ifhLibCur],FALSE);
/* Get library name */
memcpy(sbLibname,GetFarSb(pahte->cch),B2W(pahte->cch[0])+1);
#if WIN_3 OR C8_IDE
sbLibname[B2W(*sbLibname)+1] = '\0';
#endif
#if WIN_3
StatMsgWin( "%s\r\n", sbLibname+1);
#endif
#if C8_IDE
if(fC8IDE)
{
sprintf(msgBuf, "@I4%s\r\n", sbLibname+1);
_write(fileno(stderr), msgBuf, strlen(msgBuf));
}
#endif
fFirstTime = (FTYPE) TRUE;
while(FUndefsLeft()) /* While there are undefs seen */
{
fFileExtracted = FALSE; /* Assume we won't take anything */
fUndefsSeen = FALSE; /* Assume no more undefs */
ipnMac = 0; /* Initialize sort table count */
#if NOT NEW_LIB_SEARCH
EnSyms(ProcessAnUndef,ATTRUND);
#else
pund = pundListHead;
pundPrev = NULL;
while (pund)
{
if (pund->dwLibMask & libMask)
{
break; // since items are added to the head,
// as soon as we find one item that has
// already been searched, the rest have
// also already been searched...
// pundPrev = pund;
// pund = pund->pNext;
// continue;
}
pundNext = pund->pNext;
if (pund->papropUndef->an_attr == ATTRUND)
ProcessAnUndef(pund->papropUndef, pund->rhte, 0, 0);
else
fUndefHit = TRUE; // no longer undefined -- remove
if (fUndefHit)
{
// remove this item from the undef list...
if (pundPrev)
pundPrev->pNext = pundNext;
else
pundListHead = pundNext;
pund->pNext = pundFree;
pundFree = pund;
}
else
{
pund->dwLibMask |= libMask;
pundPrev = pund;
}
pund = pundNext;
}
#endif
/* Try to resolve references */
/* If no modules obtained, exit loop. */
if(!ipnMac)
{
#if NEWIO
if (fLibPass1)
{
/*
* If this library is seen for the first time in
* the first pass thru libraries and we don't
* pull out any modules from it, then close this
* library, because there are big chances this
* library is not needed.
*/
if (fFirstTime)
{
_close(mpifhfh[ifhLibCur]);
mpifhfh[ifhLibCur] = 0;
/*
* Mark it also as not used in pass 1
* so, we can closed it also in the
* next passes thru libs.
*/
if (fUsedInPass1)
fUsedInPass1[ifhLibCur] = FALSE;
}
}
else if (fUsedInPass1 && !fUsedInPass1[ifhLibCur])
{
/*
* In pass "n" thru libs close libraries
* not used in pass 1.
*/
_close(mpifhfh[ifhLibCur]);
mpifhfh[ifhLibCur] = 0;
}
#endif
break;
}
fFirstTime = FALSE; /* No longer first time seen */
/* If extended dictionary present, process it. */
if(pExtDic)
ProcExtDic(pExtDic);
/* Sort modules by page offset. */
qsort(pnSort, ipnMac, sizeof(WORD),
(int (__cdecl *)(const void *, const void *)) FGtNum);
/*
* Save each module represented in the table.
*/
for (i = 0; i < ipnMac; i++)
{
/*
* If SaveInput returns 0, the module was already seen. See
* above comment in ProcessAnUndef().
*/
if(!SaveInput(sbLibname, (long)pnSort[i] << libAlign, ifhLibCur, 0))
continue;
if(!fFileExtracted) /* If no files extracted yet */
{
vrpNewList = vrpropTailFile;
/* Save start of file list */
fFileExtracted = (FTYPE) TRUE;
/* We have extracted a file */
}
}
if(!fFileExtracted)
break; /* If we didn't take anything, break */
/* Library might not be open because we may have searched
* an already-loaded dictionary. If necessary, re-open
* library.
*/
if(!vfLibOpen)
GetLib();
searchMore = (FTYPE) TRUE; /* Otherwise it's worth another pass */
vrpTmpFileFirst = rprop1stFile;
/* Save head of module list */
rprop1stFile = vrpNewList;
/* Put new modules at head of list */
fLibPass = (FTYPE) TRUE; /* Processing object from library */
DrivePass(ProcP1); /* Do pass 1 on object from library */
fLibPass = FALSE; /* No longer processing lib. object */
rprop1stFile = vrpTmpFileFirst;
/* Restore original head of list */
if (fUsedInPass1 && ifhLibMacInit < ifhLibMac)
{
/* DrivePass added more libraries to search */
/* Reallocate fUsedInPass1 */
FTYPE *p; /* Temporary pointer */
p = (FTYPE *) GetMem(ifhLibMac * sizeof(FTYPE));
if (p == NULL)
{
FFREE(fUsedInPass1);
fUsedInPass1 = NULL;
}
else
{
memset(p, TRUE, ifhLibMac);
memcpy(p, fUsedInPass1, ifhLibMacInit);
FFREE(fUsedInPass1);
fUsedInPass1 = p;
}
ifhLibMacInit = ifhLibMac;
}
}
/* Free space for extended dictionary if present */
if(pExtDic)
FFREE(pExtDic);
if(vfLibOpen)
{
#if NOT NEWIO
fclose(bsInput); /* Close the library */
#endif
vfLibOpen = FALSE; /* No library open */
}
}
/* No longer on 1st pass thru libraries. */
fLibPass1 = FALSE;
}
while(searchMore && FUndefsLeft()); /* Do until search done */
FreeMem(fUsedInPass1);
FreeDictionary(); /* Free dictionary space */
/*
* Restore large buffer size in case it was reduced.
*/
setvbuf(bsInput,bsInput->_base,_IOFBF,LBUFSIZ);
#if NEW_LIB_SEARCH
fStoreUndefsInLookaside = FALSE;
while (pundpoolHead)
{
pundpoolCur = pundpoolHead->pNext;
FFREE(pundpoolHead);
pundpoolHead = pundpoolCur;
}
#endif
}
#if CMDMSDOS
/*
* GetLibAll:
*
* Process all the modules in a given library in Pass 1.
* Create property cells for them and insert into the file list.
*/
void NEAR GetLibAll(sbLib)
BYTE *sbLib;
{
WORD ifh; /* (fake) library index */
long lfa; /* Current file offset */
IOVTYPE iov; /* Overlay number */
RBTYPE rbFileNext; /* Pointer to next file property */
RBTYPE rbFileNew; /* Pointer to new file property */
APROPFILEPTR apropFile, apropFilePrev;
BYTE *sbInput; /* Asciiz filename */
int fh; /* File handle */
fDrivePass = FALSE;
sbInput = sbLib + 1;
/* Get the ifh, iov, and pointer to the next file from the current
* file pointer.
*/
apropFile = (APROPFILEPTR ) FetchSym(vrpropFile,TRUE);
ifh = apropFile->af_ifh;
iov = apropFile->af_iov;
rbFileNext = apropFile->af_FNxt;
#if NEWIO
fh = SmartOpen(sbInput,ifh);
if (fh <= 0 && lpszLIB != NULL)
fh = SearchPathLink(lpszLIB, sbInput, ifh, TRUE);
if (fh > 0)
{
fflush(bsInput);
bsInput->_file = (char) fh;
}
else
Fatal(ER_fileopn,sbInput);
#else
if((bsInput = fopen(sbInput,RDBIN)) == NULL)
Fatal(ER_fileopn,sbInput);
#endif
if(getc(bsInput) != LIBHDR) /* Check for valid record type */
Fatal(ER_badlib,sbInput);
cbRec = (WORD) (3 + WSGets()); /* Get record length */
for(libAlign = 15; libAlign && !(cbRec & (1 << libAlign)); --libAlign);
/* Calculate alignment factor */
fDrivePass = (FTYPE) TRUE;
/* Reset current file's lfa from 0 to offset of 1st module */
apropFile->af_lfa = lfa = 1L << libAlign;
/* Go to the first module */
if (fseek(bsInput,lfa,0))
Fatal(ER_badlib,sbInput);
/* Process the library as follows: Process the current module.
* Go to the next module; if it starts with DICHDR then we're
* done. Else, create a new file property cell for the next
* module, insert it in the file list, and go to start of loop.
*/
rect = (WORD) getc(bsInput);
while (rect != DICHDR)
{
ungetc(rect, bsInput);
lfaLast = apropFile->af_lfa = ftell(bsInput);
ProcP1();
while (TYPEOF(rect) != MODEND)
{
rect = (WORD) getc(bsInput);
if (fseek(bsInput, (cbRec = WSGets()), 1))
Fatal(ER_badlib,sbInput);
}
do
{
rect = (WORD) getc(bsInput);
}
while (rect != THEADR && rect != DICHDR && rect != EOF);
if (rect == DICHDR)
{
if (rbFileNext == RHTENIL)
vrpropTailFile = vrpropFile;
#if NOT NEWIO
fclose(bsInput);
#else
rbFilePrev = vrpropFile;
#endif
return;
}
if (rect == EOF)
Fatal(ER_libeof);
// Make a new file property cell
apropFile = (APROPFILEPTR ) PropAdd(vrhteFile, ATTRFIL);
rbFileNew = vrprop;
#if ILINK
apropFile->af_imod = ++imodCur; // allocate a module number
apropFile->af_cont = 0;
apropFile->af_ientOnt = 0;
#endif
apropFile->af_rMod = 0;
apropFile->af_ifh = (char) ifh;
apropFile->af_iov = (IOVTYPE) iov;
apropFile->af_FNxt = rbFileNext;
#if SYMDEB
apropFile->af_publics = NULL;
apropFile->af_Src = NULL;
apropFile->af_SrcLast = NULL;
apropFile->af_cvInfo = NULL;
#endif
apropFile->af_ComDat = 0L;
apropFile->af_ComDatLast = 0L;
MARKVP();
// Get the just-processed property file cell
apropFilePrev = (APROPFILEPTR ) FetchSym(vrpropFile,TRUE);
apropFilePrev->af_FNxt = rbFileNew;
vrpropFile = rbFileNew;
};
// Remove an empty Lib from the chain of files
if (vrpropFile == rprop1stFile)
{
// If the empty lib is first on list
rprop1stFile = rbFileNext;
}
else
{
#if NEWIO
apropFilePrev = (APROPFILEPTR)FetchSym(rbFilePrev, TRUE);
apropFilePrev->af_FNxt = apropFile->af_FNxt;
#endif
}
#if NEWIO
if (rbFileNext == RHTENIL)
vrpropTailFile = rbFilePrev; // In case we removed the last file
_close(fileno(bsInput));
rbFilePrev = vrpropFile;
#endif
}
#endif /*CMDMSDOS*/