windows-xp/Source/XPSP1/NT/sdktools/link16/newstr.c

/* 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);
    }
}