Source code of Windows XP (NT5)
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.
 
 
 
 
 
 

568 lines
20 KiB

/* SCCSID = %W% %E% */
/*
* Copyright Microsoft Corporation, 1983-1987
*
* This Module contains Proprietary Information of Microsoft
* Corporation and should be treated as Confidential.
*/
/****************************************************************
* *
* NEWSTR.C *
* *
* Routines concerning filenames, strings. *
* *
****************************************************************/
#include <minlit.h> /* Types, constants, macros */
#include <bndtrn.h> /* More of the same */
#include <bndrel.h> /* More of the same */
#include <lnkio.h> /* Linker I/O definitions */
#include <lnkmsg.h> /* Error messages */
#include <extern.h> /* External declarations */
#include <undname.h>
/*
* LOCAL FUNCTION PROTOTYPES
*/
LOCAL unsigned short NEAR Find(unsigned char *s1,
unsigned char b,
unsigned short n);
LOCAL void NEAR DelimParts(unsigned char *psb,
unsigned short *pi1,
unsigned short *pi2,
unsigned short *pi3);
/****************************************************************
* *
* Find: *
* *
* This function takes as its arguments a byte pointer s1, and *
* a BYTE b, and a WORD n. It scans at most n bytes of s1 *
* looking for an occurrence of b. If it finds one, it *
* returns its offset from the beginning of s1, and if it does *
* not, it returns the value INIL. *
* *
****************************************************************/
LOCAL WORD NEAR Find(s1,b,n) /* Find matching byte */
REGISTER BYTE *s1; /* Pointer to a byte string */
BYTE b; /* Search target */
WORD n; /* Length of s1 */
{
REGISTER WORD i; /* Counter */
i = 0; /* Initialize */
#if ECS
if (b < 0x40) /* b cannot be part of ECS */
{
#endif
while(n--) /* While not at end of string */
{
if(*s1++ == b) return(i); /* If match found, return position */
++i; /* Increment counter */
}
return(INIL); /* No match */
#if ECS
}
#endif
#if ECS || defined(_MBCS)
/* We have to worry about ECS */
while(n--)
{
if(*s1++ == b) return(i);
++i;
if (IsLeadByte(s1[-1])) /* If we were on a lead byte */
{ /* Advance an extra byte */
s1++;
i++;
n--;
}
}
return(INIL); /* No match */
#endif /* ECS */
}
WORD IFind(sb,b)
BYTE *sb; /* Pointer to length-prefixed string */
BYTE b; /* Search target */
{
return(Find(&sb[1],b,B2W(sb[0]))); /* Call Find() to do the work */
}
/****************************************************************
* *
* BreakLine: *
* *
* This function takes as its arguments an SBTYPE, a pointer *
* to a function, and a character used as a delimiter. It *
* It parses the SBTYPE, applying the given function to every *
* substring delimited by the given delimiter. The function *
* does not return a meaningful value. *
* *
****************************************************************/
void BreakLine(psb,pfunc,sepchar)
BYTE *psb; /* String to parse */
void (*pfunc)(BYTE *);/* Function pointer */
char sepchar; /* Delimiter */
{
SBTYPE substr; /* Substring */
REGISTER WORD ibeg; /* Index variable */
REGISTER WORD ilen; /* Substring length */
ibeg = 1; /* Initialize */
while(ibeg <= B2W(psb[0])) /* While not at end of string */
{
ilen = Find(&psb[ibeg],sepchar,(WORD)(B2W(psb[0]) - ibeg + 1));
/* Get index of sepchar in string */
if(ilen == INIL) ilen = B2W(psb[0]) - ibeg + 1;
/* Len is all that's left if no sep */
memcpy(&substr[1],&psb[ibeg],ilen);
/* Copy substring into substr */
substr[0] = (BYTE) ilen; /* Store the length */
ibeg += ilen + 1; /* Skip over substring and delimiter */
(*pfunc)(substr); /* Call the specified function */
}
}
#pragma check_stack(on)
/****************************************************************
* *
* UpdateFileParts: *
* *
* "Inherit file pieces from a master template and specify *
* missing Update. Inherit four pieces: disk drive, path, *
* file name, extension." *
* *
* Inputs: psbOld pointer to "old sb that specifies *
* pieces of a file name." *
* psbUpdate pointer to "new pieces." *
* *
* Output: psbOld "updated to reflect missing *
* update." *
* *
****************************************************************/
void UpdateFileParts(psbOld,psbUpdate)
BYTE *psbOld; /* Name to be updated */
BYTE *psbUpdate; /* The update */
{
char oldDrive[_MAX_DRIVE];
char oldDir[_MAX_DIR];
char oldFname[_MAX_FNAME];
char oldExt[_MAX_EXT];
char updDrive[_MAX_DRIVE];
char updDir[_MAX_DIR];
char updFname[_MAX_FNAME];
char updExt[_MAX_EXT];
char *newDrive;
char *newDir;
char *newFname;
char *newExt;
char newPath[_MAX_PATH];
int newPathLen;
psbOld[psbOld[0]+1] = '\0';
_splitpath(&psbOld[1], oldDrive, oldDir, oldFname, oldExt);
psbUpdate[psbUpdate[0]+1] = '\0';
_splitpath(&psbUpdate[1], updDrive, updDir, updFname, updExt);
// Select components of the updated file path
if (updDrive[0] != '\0')
newDrive = updDrive;
else
newDrive = oldDrive;
if ((updDir[0] != '\0') && !(updDir[0] == '/' && updDir[1] == '\0'))
newDir = updDir; /* This above is a fix for bug # 46 */
else
newDir = oldDir;
// If newDir points to UNC name then forget about drive spec
if ((newDir[0] == '\\') && (newDir[1] == '\\'))
newDrive = NULL;
if (updFname[0] != '\0')
newFname = updFname;
else
newFname = oldFname;
if (updExt[0] != '\0')
newExt = updExt;
else
newExt = oldExt;
_makepath(newPath, newDrive, newDir, newFname, newExt);
newPathLen = strlen(newPath);
if (newPathLen > SBLEN - 1)
newPathLen = SBLEN - 1;
memcpy(&psbOld[1], newPath, newPathLen);
psbOld[0] = (BYTE) newPathLen;
if (newPathLen < SBLEN - 1)
psbOld[newPathLen + 1] = '\0';
else
{
psbOld[SBLEN - 1] = '\0';
OutWarn(ER_fntoolong, psbOld + 1);
fflush(stdout);
}
}
#pragma check_stack(off)
#if OVERLAYS OR SYMDEB
/*
* StripDrivePath (sb)
*
* Strip drive and path from a filename.
* Return pointer to new name, minus drive and path (if any).
*/
BYTE *StripDrivePath(sb)
BYTE *sb; /* Length-prefixed filename */
{
StripPath(sb); /* Strip path from name */
if (sb[2] != ':') /* If there is no drive */
return(sb); /* return it as is */
sb[2] = (BYTE) ((sb[0]) - 2); /* Adjust length byte, move it */
return(&sb[2]); /* Return minus drive */
}
#endif
/****************************************************************
* *
* SbCompare: *
* *
* Compares two length-prefixed strings. Returns true if they *
* match. *
* *
* NOTE: When comparison is case-insensitive note that letters *
* will match regardless of case, but, in addition, '{' will *
* match '[', '|' will match '\', '}' will match ']', and *
* '~' will match '^'. *
* *
* NOTE: This routine does not know about DBCS. *
* *
****************************************************************/
WORD SbCompare(ps1,ps2,fncs)
REGISTER BYTE *ps1; /* Pointer to symbol */
REGISTER BYTE *ps2; /* Pointer to symbol */
WORD fncs; /* True if not case-sensitive */
{
WORD length; /* No. of char.s to compare */
if(*ps1 != *ps2) return(FALSE); /* Lengths must match */
length = B2W(*ps1); /* Get length */
if (!fncs) /* If case-sensitive */
{ /* Simple string comparison */
while (length && (*++ps1 == *++ps2))
length--;
return(length ? FALSE : TRUE); /* Success iff nothing left */
}
while(length--)
{
if(*++ps1 == *++ps2) continue; /* Bytes match */
if((*ps1 & 0137) != (*ps2 & 0137)) return(FALSE);
}
return(TRUE); /* They match */
}
#if OSEGEXE
/****************************************************************
* *
* SbUcase: *
* *
* Force a length-prefixed string to upper case. *
* Does not check for punctuation characters. *
* *
****************************************************************/
void SbUcase(sb)
REGISTER BYTE *sb; /* Length-prefixed string */
{
REGISTER int length;
#ifdef _MBCS
sb[B2W(sb[0])+1] = '\0';
_mbsupr (sb + 1);
#else
/* Loop through symbol, changing lower to upper case. */
for(length = B2W(*sb++); length > 0; --length, ++sb)
{
#if ECS
/* If lead byte character, skip two bytes */
if(IsLeadByte(*sb))
{
--length;
++sb;
continue;
}
#endif
if(*sb >= 'a' && *sb <= 'z')
*sb -= 'a' - 'A';
}
#endif
}
#endif
/*
* SbSuffix:
*
* Tell if one length-prefixed string is a suffix of another.
*/
FTYPE SbSuffix(sb,sbSuf,fIgnoreCase)
REGISTER BYTE *sb; /* String */
REGISTER BYTE *sbSuf; /* Suffix */
WORD fIgnoreCase; /* True if case is to be ignored */
{
WORD suflen; /* Suffix length */
/* Get suffix length. If longer than string, return false. */
suflen = B2W(sbSuf[0]);
if(suflen > B2W(sb[0])) return(FALSE);
/*
* Point to end of suffix and end of string. Loop backwards
* until mismatch or end of suffix.
*/
sbSuf = &sbSuf[suflen];
sb = &sb[B2W(sb[0])];
while(suflen--)
{
if(!fIgnoreCase)
{
if(*sb-- != *sbSuf--) return(FALSE);
}
else if((*sb-- | 0x20) != (*sbSuf-- | 0x20)) return(FALSE);
}
return((FTYPE) TRUE);
}
#if NEWSYM
#if !defined( M_I386 ) && !defined( _WIN32 )
/*** GetFarSb - copy a far length-prefixed string
*
* Purpose:
* Copy a far length-prefixed string into a near static buffer.
* Terminate with null byte.
* Return a pointer to the the buffer.
*
* Input:
* psb - pointer to the far string
*
* Output:
* Pointer to the near buffer.
*
* Exceptions:
* None.
*
* Notes:
* Don't call this function twice in the row to get two far strings,
* because the second call will overwite the first string.
*
*************************************************************************/
char *GetFarSb(BYTE FAR *lpsb)
{
static BYTE sb[SBLEN+1]; /* 1 extra for the null byte */
sb[0] = lpsb[0];
FMEMCPY((BYTE FAR *) &sb[1], &lpsb[1], B2W(lpsb[0]));
if (sb[0] + 1 < sizeof(sb))
sb[sb[0] + 1] = 0; /* Some routines expect a terminating 0 */
else
sb[SBLEN] = 0;
return(sb);
}
#endif
#endif
/****************************************************************
* *
* ProcObject: *
* *
* This function takes as its argument a pointer to a length- *
* prefixed string containing the name of an object file. It *
* processes that file name. It does not return a meaningful *
* value. *
* *
****************************************************************/
void ProcObject(psbObj)/* Process object file name */
REGISTER BYTE *psbObj; /* Object file name */
{
SBTYPE sbFile; /* File name */
#if OVERLAYS
FTYPE frparen; /* True if trailing paren found */
FTYPE flparen; /* True if leading paren found */
#endif
#if CMDMSDOS
BYTE sbExt[5];
#endif
#if OVERLAYS
if(psbObj[B2W(psbObj[0])] == ')') /* If trailing parenthesis found */
{
frparen = (FTYPE) TRUE; /* Set flag true */
--psbObj[0]; /* Delete parenthesis */
}
else frparen = FALSE; /* Else set flag false */
if(psbObj[0] && psbObj[1] == '(') /* If leading parenthesis found */
{
flparen = (FTYPE) TRUE; /* Set flag true */
psbObj[1] = (BYTE) (psbObj[0] - 1);/* Delete parenthesis */
++psbObj;
}
else flparen = FALSE; /* Else set flag false */
#endif
#if CMDMSDOS
PeelFlags(psbObj); /* Process flags, if any */
#if OVERLAYS
if(psbObj[B2W(psbObj[0])] == ')') /* If trailing parenthesis found */
{
if(frparen) Fatal(ER_nstrpar);
/* Cannot nest parentheses */
frparen = (FTYPE) TRUE; /* Set flag true */
--psbObj[0]; /* Delete parenthesis */
}
#endif
#endif
#if OVERLAYS
if(flparen) /* If leading parenthesis */
{
if(fInOverlay) Fatal(ER_nstlpar);
/* Check if in overlay already */
fInOverlay = (FTYPE) TRUE; /* Set flag */
fOverlays = (FTYPE) TRUE; /* Set flag */
}
#endif
if(psbObj[0]) /* If object name length not zero */
{
#if DEBUG /* If debugging on */
fprintf(stderr," Object "); /* Message */
OutSb(stderr,psbObj); /* File name */
NEWLINE(stderr); /* Newline */
#endif /* End debugging code */
#if CMDMSDOS
memcpy(sbFile,sbDotObj,5); /* Put extension in sbFile */
UpdateFileParts(sbFile,psbObj); /* Add extension to name */
#endif
#if CMDXENIX
memcpy(sbFile,psbObj,B2W(psbObj[0]) + 1);
/* Leave name unchanged */
#endif
#if CMDMSDOS
/* If file has extension ".LIB" then save it as a library
* from which all modules will be extracted.
*/
sbExt[0] = 4;
memcpy(sbExt+1,&sbFile[B2W(sbFile[0])-3],4);
if (SbCompare(sbExt, sbDotLib, TRUE))
{
if(ifhLibMac >= IFHLIBMAX) Fatal(ER_libmax);
/* Mark name pointer nil so library won't be searched. */
mpifhrhte[ifhLibMac] = RHTENIL;
SaveInput(sbFile,0L,ifhLibMac++,(WORD)(fInOverlay? iovMac: 0));
}
else
#endif
SaveInput(sbFile,0L,(WORD) FHNIL,(WORD)(fInOverlay? iovMac: 0));
/* Save input file name and address */
}
#if OVERLAYS
if(frparen) /* If trailing parenthesis */
{
if(!fInOverlay) Fatal(ER_unmrpar);
/* Check parentheses */
fInOverlay = FALSE; /* No longer specifying overlay */
if(++iovMac > IOVMAX) Fatal(ER_ovlmax);
/* Increment overlay counter */
}
#endif
}
/*
* fPathChr (ch)
*
* Tells whether or not a given character is a path character.
*
*/
FTYPE fPathChr(ch)
char ch;
{
#if OSXENIX
if (ch == '/')
#else
if (ch == '/' || ch == '\\')
#endif
return((FTYPE) TRUE);
return(FALSE);
}
/*** UndecorateSb - undecorate name
*
* Purpose:
* Undecorate length prefixed name.
*
* Input:
* sbSrc - length prefixed decorated name
* sbDst - length prefixed undecorated name
* cbDst - size of sbDst
*
* Output:
* If undecoration is successfull the sbDst contains undecorated
* C++ name, else the sbSrc is copied to the sbDst.
*
* Exceptions:
* None.
*
* Notes:
* None.
*
*************************************************************************/
void UndecorateSb(char FAR *sbSrc, char FAR *sbDst, unsigned cbDst)
{
char FAR *pUndecor;
unsigned len;
// Make sure that decorated string is zero-terminated
if (sbSrc[0] < sizeof(SBTYPE))
sbSrc[sbSrc[0] + 1] = '\0';
else
sbSrc[sizeof(SBTYPE) - 1] = '\0';
pUndecor = __unDName(NULL, (pcchar_t) &sbSrc[1], 0, &malloc, &free, 0);
if (pUndecor == NULL)
{
// Undecorator failed
FMEMCPY(sbDst, sbSrc, sbSrc[0] + 1);
}
else
{
// Add length to the undecorated name
len = FSTRLEN(pUndecor);
len = cbDst - 2 >= len ? len : cbDst - 2;
FMEMCPY(&sbDst[1], pUndecor, len);
sbDst[0] = (BYTE) len;
sbDst[len + 1] = '\0';
FFREE(pUndecor);
}
}