//  sl.cxx -- all routines to work with the source line information
//
//  Copyright <C> 1991, Microsoft Corporation
//
//  Revisions:
//
//      19-Dec-91 Davidgra
//          [00] Cache in SLFLineToAddr & SLLineFromAddr
//
//      03-Jan-92 ArthurC
//          [01] Added argument to SLFLineToAddr
//
//      01-Dec-94 BryanT
//          Merge with NT codebase.
//
//  Purpose:
//      To query information for the source module, source file, and
//      source line information tables.

#include "shinc.hpp"
#pragma hdrstop

#define cbndsAllocBlock 512
typedef struct _BNDS {
    WORD ilnStart;
    WORD ilnEnd;
} BNDS; // BouNDS
typedef BNDS *LPBNDS;

LOCAL   HST     HstFromLpmds (LPMDS);
LOCAL   BOOL    FCheckSLOrder (LPSL);
LOCAL   LPBNDS  BuildBounds (WORD, LPUL, LPW);

__inline VOID   SortSM (LPSM);
__inline VOID   SortSL (LPSL);
__inline WORD   FindPosition (LPBNDS, WORD, LPUL, ULONG);
__inline LPBNDS InsertBlock (WORD, WORD, LPBNDS, LPW, LPW);
__inline WORD   ScanBlock (LPUL, WORD, WORD, ULONG);
__inline VOID   SortOffFromBounds (WORD, LPBNDS, WORD, LPUL);
__inline VOID   SortLnFromBounds (WORD, LPBNDS, WORD, LPW);
__inline VOID   SortFromBounds (WORD, LPBNDS, WORD, LPV, WORD);

#define SIZEOFBASE          4
#define SIZEOFSTARTEND      8
#define SIZEOFLINENUMBER    2
#define SIZEOFHEADER        4
#define SIZEOFSEG           2
#define SIZEOFNAME          2


//  Internal support routines
//  Low level routines to tranverse the source module, source file and
//  source line information tables
//
//  List of internal support functions

LPW
PsegFromSMIndex (
    LPSM lpsm,
    WORD iseg
    )
{
    assert (lpsm != NULL)
    assert (iseg < lpsm->cSeg);

    return ((LPW)
        ((CHAR *) lpsm +
         SIZEOFHEADER +
         (SIZEOFBASE * lpsm->cFile) +
         (SIZEOFSTARTEND * lpsm->cSeg) +
         (SIZEOFSEG * iseg)
       )
    );
}


// GetSMBounds
//
//  Purpose:  Get the segment number and start/end offset pair for the
//              segment (iseg) contributing to the module lpsm.
//  Input:
//      lpsmCur - pointer to the current source module table.
//      iseg    - the index of the segment contributing to
//                the module to get the bounds for.
//
//  Returns  a pointer to a start/end offset pair

__inline LPOFP
GetSMBounds (
    LPSM  lpsm,
    WORD  iSeg
    )
{
    assert (lpsm != NULL);
    assert (iSeg < lpsm->cSeg);

    return ((LPOFP) ((CHAR *) lpsm +
            SIZEOFHEADER +
            (SIZEOFBASE * lpsm->cFile) +
            (sizeof (OFP) * iSeg)));
}


LPW
PsegFromSFIndex (
    LPSM lpsm,
    LPSF lpsf,
    WORD iseg
    )
{
    ULONG ulBase = 0;

    assert (lpsf != NULL)
    assert (iseg < lpsf->cSeg);

    ulBase = *((ULONG *) ((LPCH)lpsf + SIZEOFHEADER + (SIZEOFBASE * iseg)));

    return (LPW) ((LPCH) lpsm + ulBase);
}

//  GetSFBounds
//
//  Purpose:  Get the next/first start address from the Source File table.
//
//  Input:
//      lpsmCur     -   pointer to the current source module table.
//      lpiStart    -   pointer to index of the current file pointer
//                       0 if getting first in list.
//      lpulNext    -   pointer to the next source file block.
//
//  Returns:
//      lpulNext    -   set to pointer to next source file. NULL
//                       if no more entries.

__inline LPOFP
GetSFBounds (
    LPSF lpsf,
    WORD iseg
    )
{
    assert (lpsf != NULL)
    assert (iseg < lpsf->cSeg);

    return (LPOFP) ((CHAR *) lpsf +
            SIZEOFHEADER +
            (SIZEOFBASE * lpsf->cSeg) +
            (sizeof (OFP) * iseg));
}


//  GetLpsfFromIndex
//
//  Purpose: From the current source module, and source file pointer find
//          the next one.
//
//  Input:
//      lpsmCur     -   pointer to the current source module table.
//      isfCur      -   index of the current file pointer
//                       0 if getting first in list.
//  Returns:
//      lpsfNext    -   set to pointer to next source file. NULL
//                       not found.

LPSF
GetLpsfFromIndex (
    LPSM lpsmCur,
    WORD iFile
    )
{
    LPSF lpsfNext = NULL;

    BOOL fRet = TRUE;

    assert (lpsmCur != NULL)

    if (lpsmCur && iFile < lpsmCur->cFile) {
        lpsfNext = (LPSF) ((CHAR *)lpsmCur + lpsmCur->baseSrcFile[iFile]);
    }
    return lpsfNext;
}


// LpsfFromAddr
//
// Purpose:  Find the pointer to the source file that the addr falls into
//
// Input:
//      lpaddr      -   pointer to address package
//      lpsf        -   pointer to lpsf that contain addr in range
//      lpsmCur     -   pointer to current source module table.
//
//  Returns:
//      lpsf        -   contain pointer to source file if addr is
//                      in range.  Unchanged if could not find file.

BOOL
FLpsfFromAddr (
    LPADDR lpaddr,
    LPSM lpsmCur,
    LPSF * plpsf,
    LPW lpwFileIndex,
    LPW lpwSegIndex
    )
{
    WORD iFile   = 0;
    BOOL fFound  = FALSE;

    assert (lpsmCur != (LPSM) NULL)
    assert (lpaddr != (LPADDR) NULL)

    while (iFile < lpsmCur->cFile && !fFound) {
        WORD iseg = 0;
        LPSF lpsf = GetLpsfFromIndex (lpsmCur, iFile);

        while (iseg < lpsf->cSeg && !fFound) {
            WORD  seg   = *PsegFromSFIndex (lpsmCur, lpsf, iseg);
            LPOFP lpofp = GetSFBounds (lpsf, iseg);

            if ((GetAddrSeg (*lpaddr) == seg) &&
                (GetAddrOff (*lpaddr) >= lpofp->offStart) &&
                (GetAddrOff (*lpaddr) <= lpofp->offEnd))
            {
                *lpwFileIndex = iFile;
                *lpwSegIndex  = iseg;
                *plpsf = lpsf;
                fFound = TRUE;
            }

            iseg++;
        }
        iFile++;
    }

    return fFound;
}


//  LpchGetName

__inline LPCH
LpchGetName (
    LPSF lpsf
    )
{
    LPCH lpch = NULL;

    assert (lpsf != NULL)

    lpch =  (LPCH) ((CHAR *)lpsf +
                    SIZEOFHEADER +
                    (SIZEOFBASE * lpsf->cSeg) +
                    (SIZEOFSTARTEND * lpsf->cSeg));

    return lpch;
}


//  LpsfFromName

short
IsfFromName (
    BOOL fExactMatch,
    short isfStart,
    LSZ lszName,
    LPMDS lpmds
    )
{
    short isfFound = -1;
    short isf = isfStart;
    LPEXG lpexg = (LPEXG) LLLock (lpmds->hexg);

    if (lpexg->lpefi) {
        CHAR szFileSrc [ _MAX_CVFNAME ];
        CHAR szExtSrc [ _MAX_CVEXT ];
        WORD cbName = 0;
        WORD cchName = 0;
        LSZ  lszFileExt = NULL;
        int  imds = lpmds->imds - 1;

        _tsplitpath(lszName, NULL, NULL, szFileSrc, szExtSrc);

        // If fExactMatch, the path must match the OMF
        if (fExactMatch) {
            cbName = _tcslen(lszName);
            cchName = _tcslen(lszName);
            lszFileExt = lszName;
        } else {
            cbName = _tcslen(szExtSrc) + _tcslen(szFileSrc);
            cchName = _tcslen(szExtSrc) + _tcslen(szFileSrc);
            lszFileExt = lszName + _tcslen(lszName) - cbName;
        }

        for (isf = isfStart; isf < (short) lpexg->rgculFile [ imds ]; isf++) {
            CHAR szPathOMF [ _MAX_CVPATH ];
            CHAR szFile [ _MAX_CVFNAME ];
            CHAR szExt [ _MAX_CVEXT ];

            _TXCHAR * lpch = (_TXCHAR *)
                lpexg->lpchFileNames +
                (lpexg->rgichFile [ (WORD) (lpexg->rgiulFile [ imds ]) + isf ]);

            // IMPORTANT NOTE:
            //
            // Below, it is VITAL for DBCS to use the number of CHARACTERS
            // to compare as opposed to the number of bytes or the DBCS
            // strnicmp will fail!

            if (!_tcsnicmp (lszFileExt, (_TXCHAR *) lpch + *lpch - cbName + 1, cchName)) {
                memset(szPathOMF, 0, _MAX_CVPATH);
                memcpy(szPathOMF, lpch + 1, *lpch);
                _tsplitpath(szPathOMF, NULL, NULL, szFile, szExt);
                if (!_tcsicmp (szFileSrc, szFile) &&
                     !_tcsicmp (szExtSrc, szExt))
                {
                    isfFound = isf;
                    break;
                }
            }
        }
    }

    LLUnlock (lpmds->hexg);

    return isfFound;
}


//  GetLpslFromIndex
//
//  Purpose:  Get the next line number entry

__inline LPSL
GetLpslFromIndex (
    LPSM lpsmCur,
    LPSF lpsfCur,
    WORD iSeg
    )
{
    LPSL lpsl = NULL;
    BOOL fRet = TRUE;

    assert (lpsfCur != NULL)

    if (iSeg < lpsfCur->cSeg) {
        lpsl = (LPSL) ((CHAR *)lpsmCur +
            lpsfCur->baseSrcLn [iSeg]);
    }
    return lpsl;
}


BOOL
FLpslFromAddr (
    LPADDR lpaddr,
    LPSM lpsm,
    LPSL * plpsl
    )
{
    WORD    iSeg        = 0;
    WORD    iSegCur     = 0;
    WORD    iFileCur    = 0;
    BOOL    fFound      = FALSE;
    BOOL    fRet        = FALSE;
    LPSF    lpsf        = NULL;

    assert (lpsm != NULL)
    assert (lpaddr != NULL)

    // First, do a high level pass to see if the address actually exists
    //  within the given module.

    while (iSeg < lpsm->cSeg) {

        WORD  seg   = *PsegFromSMIndex (lpsm, iSeg);
        LPOFP lpofp = GetSMBounds (lpsm, iSeg);

        if ((GetAddrSeg (*lpaddr) == seg) &&
             (GetAddrOff (*lpaddr) >= lpofp->offStart) &&
             (GetAddrOff (*lpaddr) <= lpofp->offEnd)
       ) {
            break;
        }

        iSeg++;
    }

    // We know it is in this module, so now find the correct file

    if (iSeg < lpsm->cSeg &&
         FLpsfFromAddr (lpaddr, lpsm, &lpsf, &iFileCur, &iSegCur))
    {
        *plpsl = GetLpslFromIndex (lpsm, lpsf, iSegCur);
        fRet   = TRUE;
    }

    return fRet;
}


//  OffsetFromIndex
//
//  Purpose:  Get the next line number entry

__inline BOOL
OffsetFromIndex (
    LPSL lpslCur,
    WORD iPair,
    ULONG * lpulOff
    )
{
    BOOL fRet = FALSE;

    assert (lpslCur != NULL)
    assert (lpulOff != NULL)

    if (iPair < lpslCur->cLnOff) {
        *lpulOff = lpslCur->offset [ iPair ];
        fRet = TRUE;
    }

    return fRet;
}


//  LineFromIndex
//
//  Purpose:  Get the next line number entry

__inline BOOL
LineFromIndex (
    LPSL lpslCur,
    WORD iPair,
    USHORT * lpusLine
    )
{
    BOOL    fRet = FALSE;
    ULONG   ul;

    assert (lpslCur != NULL)
    assert (lpusLine != NULL)

    if (iPair < lpslCur->cLnOff) {
        ul = (sizeof (LONG) * lpslCur->cLnOff) + (sizeof (WORD) * iPair);
        *lpusLine = *(USHORT *)((CHAR *) lpslCur->offset + ul);
        fRet = TRUE;
    }
    return fRet;
}


//
// Exported APIs
//


//  SLHmodFromHsf - Return the module in which a source file is used
//
//  Purpose:    Given a source file, return an HMOD indicating which
//              module it was compiled into.
//
//  Input:      hexe - handle to the EXE in which to look, or NULL for all
//              hsf - handle to source file for which to find module
//
//  Returns:    handle to the module into which this source file was
//              compiled
//
//  Notes:      REVIEW: BUG: It's possible (mainly in C++ but also in C)
//              for a source file to be used in more than one module
//              (e.g. a C++ header file with inline functions, or a C
//              header file with a static function).  This function just
//              finds the first one, which is very misleading.

HMOD
SLHmodFromHsf (
    HEXE hexe,
    HSF hsf
    )
{
    HEXE    hexeCur         = hexe;
    HMOD    hmod            = 0;
    LPSF    lpsfCur         = NULL;
    BOOL    fFound          = FALSE;
    LPMDS   lpmds           = NULL;
    WORD    iFile;

    if (hsf != HsfCache.Hsf) {
        // to get an Hmod from hsf we must loop through
        // exe's to Hmods and compare hsfs associated to the
        // hmod
        while (hexeCur = (hexe ? hexe : SHGetNextExe (hexeCur))) {
            while ((hmod = SHGetNextMod (hexeCur, hmod)) && !fFound) {
                lpmds = (LPMDS) hmod;
                if (lpmds != NULL && lpmds->hst) {
                    for (iFile = 0; iFile < ((LPSM) lpmds->hst)->cFile; iFile++) {
                        if (hsf == GetLpsfFromIndex ((LPSM)lpmds->hst, iFile)) {
                            HsfCache.Hmod = hmod;
                            HsfCache.Hsf = hsf;
                            fFound = TRUE;
                            break;
                        }
                    }
                }
            }

            if (hexe != (HEXE) NULL || fFound) {
                //
                // if given an exe to search don't go any further.
                //
                break;
            }
        }
    }
    return HsfCache.Hmod;
}


//  SLLineFromAddr - Return info about the source line for an address
//
//  Purpose:    Given an address return line number that corresponds.
//              Also return count bytes for the given line, and the delta
//              between the address that was passed in and the first byte
//              corresponding to this source line.
//
//  Input:      lpaddr - address for which we want source line info
//
//  Output:    *lpwLine - the (one-based) line for this address
//             *lpcb - the number of bytes of code that were generated
//                      for this source line
//             *lpdb - the offset of *lpaddr minus the offset for the
//                      beginning of the line
//
//  Returns:    TRUE if source was found, FALSE if not
//
//  Notes:
//      1.  add parameter for hexe start

BOOL
SLLineFromAddr (
    LPADDR      lpaddr,
    LPW         lpwLine,
    SHOFF * lpcb,
    SHOFF * lpdb
    )
{
    HMOD    hmod    = (HMOD) NULL;
    LPMDS   lpmds   = NULL;
    CXT     cxtT    = {0};
    LPSL    lpsl    = NULL;
    WORD    cPair;
    WORD    i;
    HEXE    hexe;
    UOFFSET maxOff  = CV_MAXOFFSET;
    BOOL    fRet    = FALSE;
    short   low;
    short   mid;
    short   high;
    ULONG   ulOff;
    USHORT  usLine;

    assert (lpaddr != NULL)
    assert (lpwLine != NULL)

    if (!ADDR_IS_LI (*lpaddr)) {
        SYUnFixupAddr (lpaddr);
    }

    if (emiAddr (*lpaddr) == emiAddr (AddrCache.addr) &&
        GetAddrSeg (*lpaddr) == GetAddrSeg (AddrCache.addr) &&
        GetAddrOff (*lpaddr) >= GetAddrOff (AddrCache.addr) &&
        GetAddrOff (*lpaddr) < GetAddrOff (AddrCache.addr) + AddrCache.cb - 1)
    {
        *lpwLine = AddrCache.wLine;
        if (lpcb) {
            *lpcb    = AddrCache.cb - 1;
        }

        if (lpdb) {
            *lpdb = GetAddrOff (*lpaddr) - GetAddrOff (AddrCache.addr);
        }

        return TRUE;
    }

    *lpwLine = 0;

    if (SHSetCxtMod (lpaddr, &cxtT) != NULL) {
        hmod = SHHMODFrompCXT (&cxtT);

        if (hmod != (HMOD) NULL &&
            (lpmds = (LPMDS) hmod) != NULL &&
            lpmds && HstFromLpmds (lpmds) &&
            FLpslFromAddr (lpaddr, (LPSM) lpmds->hst, &lpsl))
        {
            hexe  = SHHexeFromHmod (SHHMODFrompCXT (&cxtT));

            cPair = lpsl->cLnOff;

            for (i = 0; i < cPair; i++) {

                if (OffsetFromIndex (lpsl, i, &ulOff)) {
                    if (emiAddr (*lpaddr) == (HEMI) hexe) {
                        // set up for the search routine

                        low   = 0;
                        high  = lpsl->cLnOff - 1;

                        // binary search for the offset
                        while (low <= high) {
                            mid = (low + high) / 2;

                            if (OffsetFromIndex (lpsl, mid, &ulOff)) {
                                if (GetAddrOff (*lpaddr) < (UOFFSET) ulOff) {
                                    high = mid - 1;
                                } else if (GetAddrOff (*lpaddr) > (UOFFSET) ulOff) {
                                    low = mid + 1;
                                } else if (LineFromIndex (lpsl, mid, &usLine)) {
                                    *lpwLine = usLine;
                                    maxOff = 0;
                                    high = mid;
                                    goto found;
                                }
                            }
                        }

                        // if we didn't find it, get the closet but earlier line
                        // high should be one less than low.

                        if (OffsetFromIndex (lpsl, high, &ulOff)) {

                            if (low  &&
                                 ((GetAddrOff (*lpaddr) -
                                   (UOFFSET) ulOff) <
                                   maxOff)
                              ) {
                                maxOff = (UOFFSET) (GetAddrOff (*lpaddr) -
                                    (UOFFSET) ulOff);
                                if (LineFromIndex (lpsl, high, &usLine)) {
                                    *lpwLine = (WORD) usLine;
                                    //goto found;
                                }
                            }
                        }
                    }
                }
            }
        }
    }

found:

    if (*lpwLine != 0) {
        ULONG ulOff = 0;
        ULONG ulOffNext = 0;

        AddrCache.wLine = *lpwLine;

        AddrCache.cb = 0;

        while (AddrCache.cb == 0 && (high + 1 < (int) lpsl->cLnOff)) {

            if (OffsetFromIndex (lpsl, (WORD)(high + 1), &ulOffNext) &&
                 OffsetFromIndex (lpsl, high, &ulOff)) {

                AddrCache.cb = (int) (ulOffNext - ulOff);
                if (AddrCache.cb != 0) {
                    LineFromIndex (lpsl, high, lpwLine);
                    AddrCache.wLine = *lpwLine;
                    break;
                }
            }
            high += 1;
        }

        if (AddrCache.cb == 0) {
            LPSF lpsf  = NULL;
            WORD iFile = 0;
            WORD iseg  = 0;

            if (FLpsfFromAddr (lpaddr, (LPSM) lpmds->hst, &lpsf, &iFile, &iseg)
                    &&
                OffsetFromIndex (lpsl, high, &ulOff))
            {
                AddrCache.cb = (int) (GetSFBounds (lpsf, iseg)->offEnd - ulOff + 1);
            }
        }

        if (lpcb != NULL) {
            *lpcb = AddrCache.cb - 1;
        }

        if (lpdb != NULL) {
            if (OffsetFromIndex (lpsl, high, &ulOff)) {
                *lpdb = GetAddrOff (*lpaddr) - ulOff;
            }
        }

        AddrCache.addr = *lpaddr;
        SetAddrOff (&AddrCache.addr, ulOff);

        fRet = TRUE;
    }

    return fRet;
}


//  SLFLineToAddrExteneded - Return the address for a given source line
//
//  Purpose:    Given a line and filename derive an an address.  This is
//              an extended version of LineToAddr to be able to search through
//              a source line table when there are multiple entries in the
//              source line table for a single line.
//
//  Input:      hsf - handle to the source file
//              line - the source line
//             *piSegStart - segment table in hsf to start search at
//             *piEntryFind - find the nth entry in *piSegStart
//
//  Output:    *piSegStart - segment table in hsf line found at.  Only valid
//                             when TRUE is returned!
//             *piEntryFind - index to begin search in next call to this fn
//             *lpaddr - the address for this source line
//             *lpcbLn - the number of bytes of code that were generated
//                        for this source line
//              rgwNearestLines[] - The nearest line below ([0]) and above ([1])
//                                   which generated code.
//
//      *** Below means lower LINE NUMBER not where it
//          would be on the screen!!!!!
//
//  Returns:    TRUE for success, FALSE for failure
//
//  Exceptions: lpNearestLines may not be valid if the return value is TRUE

BOOL
SLFLineToAddrExtended (
    HSF     hsf,
    WORD    line,
    WORD  * piSegStart,
    WORD  * piEntryFind,
    LPADDR  lpaddr,
    SHOFF * lpcbLn,
    WORD  * rgwNearestLines
    )
{
    WORD    rgwRet[2];
    ADDR    addr = {0};
    SHOFF   cbln = 0;
    HMOD    hmod;
    BOOL    fRet = FALSE;
    LPSF    lpsf = NULL;
    WORD    cEntryRemain;

    if (piEntryFind) {
        cEntryRemain = *piEntryFind;
    } else {
        cEntryRemain = 0;
    }

    rgwRet[0] = 0;
    rgwRet[1] = 0x7FFF;
    lpsf = (LPSF) hsf;

    ADDR_IS_LI (addr) = TRUE;

    // We need to get a mod.

    if (hmod = SLHmodFromHsf ((HEXE) NULL, hsf)) {
        HEXE  hexe  = SHHexeFromHmod (hmod);
        LPMDS lpmds = (LPMDS) hmod;

        // Set the fFlat and fOff32 bits base on the exe
        HEXG hexg = ((LPEXE) LLLock (hexe))->hexg;
        LLUnlock (hexe);
        if (((LPEXG) LLLock (hexg))->fIsPE) {
            // REVIEW - billjoy - should we check machine type or something?
            ADDRLIN32 (addr);
        } else {
            // REVIEW - billjoy - should we check machine type or something?
            //ADDR????
        }
        LLUnlock (hexg);

        if ((lpmds != NULL) && (lpsf != NULL)) {

            WORD i;

            for (i = *piSegStart; !fRet && i < lpsf->cSeg; i++) {
                ULONG   ulOff;
                WORD    iLn;
                LPSL    lpsl = NULL;
                LPSL    lpslNear = NULL;
                WORD    wLine = 0;
                WORD    wLineNear = 0;

                lpsl = GetLpslFromIndex ((LPSM) lpmds->hst, lpsf, i);

                for (iLn = 0; iLn < lpsl->cLnOff; iLn++) {
                    //
                    // look through all of the lines in the table
                    //
                    BOOL fT = LineFromIndex (lpsl, iLn, &wLine);

                    assert (fT);
                    if (wLine == line) {
                        LPOFP   lpofp;

                        fT = OffsetFromIndex (lpsl, iLn, &ulOff);
                        assert (fT);

                        SetAddrOff (&addr, ulOff);
                        SetAddrSeg (&addr, lpsl->Seg);
                        emiAddr (addr) = (HEMI) hexe;

                        if (iLn + 1 < lpsl->cLnOff) {
                            //
                            // if the next line is in range
                            //
                            OffsetFromIndex(lpsl, (WORD)(iLn+1), &ulOff);
                            //
                            // if we have a next line get the range
                            // based on next line.
                            //

                            cbln = ulOff - GetAddrOff (addr);

                            if (cbln == (SHOFF) 0) {
                                if (wLine < rgwRet[1]) {
                                    rgwRet[1] = wLine;
                                }
                                continue;
                            }
                        } else {
                            // if we don't have a next line then
                            // get the range from the boundry

                            lpofp = GetSFBounds (lpsf, i);

                            // GetSFBounds offEnd is inclusive
                            // for the source range.  Need to
                            // add 1 for the count bytes!

                            cbln = lpofp->offEnd - ulOff + 1;

                            // the end information is probably the same as the
                            // beginning offset for the last line in the file.
                            // So for now I will make a wild guess at the
                            // size of average epilog code. 10 bytes.

                            if (!cbln) {
                                cbln = 10;
                            }
                        }

                        *piSegStart = i;
                        if (!cEntryRemain--) {
                            if (piEntryFind) {
                                *piEntryFind += 1;
                            }
                            fRet = TRUE;
                            break;
                        }
                    } else {
                        if (wLine < line) {
                            if (wLine > rgwRet[0]) {
                                rgwRet[0] = wLine;
                            }
                        } else {
                            if (wLine < rgwRet[1]) {
                                rgwRet[1] = wLine;
                            }
                        }
                    }
                }

                // If continuing search, reset to stop at 1st
                // entry in next table
                if (!fRet) {
                    cEntryRemain = 0;
                    if (piEntryFind) {
                        *piEntryFind = 0;
                    }
                }
            }
        }
    }

    if(lpaddr) {
        *lpaddr = addr;
    }
    if(lpcbLn) {
        *lpcbLn = cbln;
    }

    if(rgwNearestLines) {
        rgwNearestLines[0] = rgwRet[0];
        rgwNearestLines[1] = rgwRet[1];
    }

    return fRet;
}


//  SLFLineToAddr - Return the address for a given source line
//
//  Purpose:    Given a line and filename derive an an address.
//
//  Input:      hsf - handle to the source file
//              line - the source line
//
//  Output:    *lpaddr - the address for this source line
//             *lpcbLn - the number of bytes of code that were generated
//                        for this source line
//              rgwNearestLines[] - The nearest line below ([0]) and above ([1])
//                                   which generated code.
//
//   *** Below means lower LINE NUMBER not where it
//       would be on the screen!!!!!
//
//  Returns:    TRUE for success, FALSE for failure
//
//  Exceptions: lpNearestLines may not be valid if the return value is TRUE

BOOL
SLFLineToAddr (
    HSF     hsf,
    WORD    line,
    LPADDR  lpaddr,
    SHOFF * lpcbLn,
    WORD *  rgwNearestLines
    )
{
    if ((hsf  != LineCache.hsf) ||
        (line != LineCache.wLine))
    {
        WORD    iSegStart = 0;

        LineCache.fRet = SLFLineToAddrExtended(hsf,
                                         line,
                                         &iSegStart,
                                         NULL,
                                         &LineCache.addr,
                                         &LineCache.cbLn,
                                         LineCache.rgw);
        LineCache.hsf = hsf;
        LineCache.wLine = line;
    }

    if (lpaddr) {
        *lpaddr = LineCache.addr;
    }
    if (lpcbLn) {
        *lpcbLn = LineCache.cbLn;
    }
    if (rgwNearestLines) {
        rgwNearestLines[ 0 ] = LineCache.rgw [ 0 ];
        rgwNearestLines[ 1 ] = LineCache.rgw [ 1 ];
    }

    return LineCache.fRet;
}


//  SLFFileInHexe - Is specified file a source contributor to hexe?
//
//  Purpose:  Determine if the file specified will have source line
//             information in this exe.
//
//  Input:
//      hexe            Exe (hexg) to search
//      fExactMatch     If TRUE, lszFile and OMF path must match.  If FALSE,
//                      only the basename and extension must match.
//      lszFile         Name of file to search for in OMF
//
//  Returns:              TRUE if file is found in exe's OMF
//
//  Notes:  This is a FAST search.  Just go through the file
//          list from exg.lpchFileNames.

BOOL
SLFFileInHexe(
    HEXE hexe,
    BOOL fExactMatch,
    LSZ lszFile
    )
{
    BOOL    fRet = FALSE;
    LPEXG   lpexg;
    LPEXE   lpexe;

    assert(hexe);
    lpexe = (LPEXE)LLLock(hexe);

    // Make sure that there's and exg for this exe
    if (lpexg = (LPEXG)LLLock(lpexe->hexg)) {

        // The code below is copied from IsfFromName (FYI   -markbro)
        if (lpexg->lpchFileNames) {
            _TXCHAR * lpch = (_TXCHAR *)lpexg->lpchFileNames;
            _TXCHAR * lpchMax = lpch + lpexg->cbFileNames;
            CHAR    szFileSrc [ _MAX_CVFNAME ];
            CHAR    szExtSrc [ _MAX_CVEXT ];
            WORD    cbName = 0;
            WORD    cchName = 0;
            LSZ     lszFileExt = NULL;

            _splitpath(lszFile, NULL, NULL, szFileSrc, szExtSrc);

            // If fExactMatch, the path must match the OMF
            if (fExactMatch) {
                cbName = _tcslen(lszFile);
                cchName = _tcslen(lszFile);
                lszFileExt = lszFile;
            } else {
                cbName = _tcslen(szExtSrc) + _tcslen(szFileSrc);
                cchName = _tcslen(szExtSrc) + _tcslen(szFileSrc);
                lszFileExt = lszFile + _tcslen(lszFile) - cbName;
            }

            // Stop when we've found something or the end of the table is found.
            while(!fRet && lpch < lpchMax) {
                CHAR szPathOMF [ _MAX_CVPATH ];
                CHAR szFile [ _MAX_CVFNAME ];
                CHAR szExt [ _MAX_CVEXT ];

                // IMPORTANT NOTE:
                //
                // Below, it is VITAL for DBCS to use the number of CHARACTERS
                // to compare as opposed to the number of bytes or the DBCS
                // strnicmp will fail!

                if (!_tcsnicmp (lszFileExt, lpch + *lpch - cbName + 1, cchName)) {
                    memset(szPathOMF, 0, _MAX_CVPATH);
                    memcpy(szPathOMF, lpch + 1, *lpch);
                    _tsplitpath(szPathOMF, NULL, NULL, szFile, szExt);
                    if (!_tcsicmp (szFileSrc, szFile) &&
                        !_tcsicmp (szExtSrc, szExt))
                    {
                        fRet = TRUE;
                    }
                }

                // Skip to the next name in the table
                lpch += *lpch + 1;
            }
        }
        LLUnlock(lpexe->hexg);
    }

    LLUnlock(hexe);

    return fRet;
}


//  SLCAddrFromLine - get all addresses which match the requested line
//
//  Purpose: Given a line and filename derive all addresses within
//              the specified exe
//
//  Input:      hexe - exe/dll to search in (if NULL, use all)
//              hmod - module of hexe to search in (if NULL, use all in hexe)
//              lszFile - file name
//              line - the source line
//
//  Output:    *lplpslp - pointer to slp array (allocated by this function)
//              containing return value # of pairs
//
//  Returns:    number of pairs found in exe

int
SLCAddrFromLine (
    HEXE        hexeStart,
    HMOD        hmodStart,
    LSZ         lszFileT,
    WORD        line,
    LPSLP      *lplpslp
    )
{
    LPSLP   lpslp = (LPSLP)NULL;
    int     cslp = 0;
    HMOD    hmod = hmodStart;
    HEXE    hexe = hexeStart;
    int     iPass;
    char    szFileBuf[_MAX_PATH];
    LPSTR   lszFile;

    assert(lplpslp);
    assert(lszFileT);
    assert(*lszFileT != '\0');

    // If the filename is quoted, remove the quotes.
    if ((*lszFileT == '\"') && (*(lszFileT + _tcslen(lszFileT) - 1) == '\"')) {
        lszFile = szFileBuf;
        memcpy(lszFile, _tcsinc(lszFileT), _tcslen(lszFileT) - 2);
        lszFile[_tcslen(lszFileT)-2] = '\0';
    } else {
        lszFile = lszFileT;
    }

    if ((SlCache.cslp != -1) &&
        (hexeStart == SlCache.hexe) &&
        (hmodStart == SlCache.hmod) &&
        (line      == SlCache.line) &&
        (!_tcscmp(lszFile, SlCache.szFile)))
    {
        if ((SlCache.cslp == 0) ||
            !(lpslp = (LPSLP)MHAlloc(sizeof(SLP) * (SlCache.cslp))))
        {
            *lplpslp = NULL;
            return 0;
        }

        assert(SlCache.lpslp != NULL);

        memcpy(lpslp, SlCache.lpslp, sizeof(SLP) * SlCache.cslp);
        *lplpslp = lpslp;
        return SlCache.cslp;
    }

    // Two passes, first pass, see if there is an exact match.  If there aren't
    // any exact matches, try to match just the file.ext name.  When OMF file
    // names are fully qualified, we should expect to always find a match on
    // the first pass.  This will help out with the case where there are two
    // different file.ext's in the exes/dlls loaded.
    for(iPass = 0; iPass < 2 && !lpslp; ++iPass) {

        // Loop through all of the exes that we know about.  We may want
        // to change this later
        while(hexeStart || (hexe = SHGetNextExe(hexe))) {

            // Extra fast scan to see if the file is in the list of files for the exe
            if (SLFFileInHexe(hexe, (BOOL)!iPass, lszFile)) {

                while(hmodStart || (hmod = SHGetNextMod(hexe, hmod))) {
                    LPMDS   lpmds = (LPMDS) hmod;
                    short   isf;
                    short   isfNext = -1;

                    do {
                        isf = isfNext + 1;

                        // Search for the filename in the current module
                        isfNext = IsfFromName((BOOL)!iPass, isf, lszFile, lpmds);

                        if (isfNext != -1) {
                            HSF     hsf;
                            SHOFF   cb;
                            ADDR    addr;
                            WORD    iSeg = 0;
                            WORD    iEntry = 0;

                            hsf = (HSF)GetLpsfFromIndex(
                                (LPSM) HstFromLpmds(lpmds),
                                isfNext
                           );

                            // Reuse the original version.  Since we have gotten our
                            // own hsf, we know that we will get the correct line
                            // number table
                            while(SLFLineToAddrExtended(hsf,
                                                          line,
                                                          &iSeg,
                                                          &iEntry,
                                                          &addr,
                                                          &cb,
                                                          (LPW)NULL))
                            {
                                // This could be smarter to allocate blocks, but the
                                // regular case will be that this will only happen
                                // once rather than multiple times, so just eat up
                                // a little CPU for simplicity
                                if (lpslp) {
                                    lpslp = (LPSLP)MHRealloc(lpslp,
                                                    sizeof(SLP) * (cslp + 1));
                                }
                                else {
                                    lpslp = (LPSLP)MHAlloc(sizeof(SLP));
                                }

                                // Additional check to see that the allocation
                                // actually succeeded before copying the data
                                if (lpslp) {
                                    lpslp[ cslp ].cb = cb;
                                    lpslp[ cslp ].addr = addr;
                                    ++cslp;
                                }
                            }
                        }
                    } while(isfNext != -1);

                    // If a module is specified, then DON'T loop through the rest of
                    // the modules
                    if (hmodStart) {
                        break;
                    }
                }
            }

            // If a module is specified, DON'T loop through any of the remaining
            // modules or exes.  Also, if an exe is specified, don't go through
            // any mor exes either
            if (hmodStart || hexeStart) {
                break;
            }
        }
    }

    *lplpslp = lpslp;

    // Only free up if we need to
    if (SlCache.cslp < cslp) {
        if (SlCache.lpslp) {
            MHFree(SlCache.lpslp);
        }
        SlCache.lpslp = (LPSLP)MHAlloc(sizeof(SLP) * cslp);

        if (SlCache.lpslp == NULL) {
            return(0);
        }
    }

    if (cslp) {
        memcpy(SlCache.lpslp, lpslp, sizeof(SLP) * cslp);
    }

    _tcscpy(SlCache.szFile, lszFile);
    SlCache.hexe = hexeStart;
    SlCache.hmod = hmodStart;
    SlCache.line = line;
    SlCache.cslp = cslp;

    return cslp;
}


//  SLNameFromHsf - Return the filename for an HSF
//
//  Purpose:        Get the filename associated to an HSF
//
//  Input:          hsf - handle to a source file
//
//  Returns:        Length-prefixed pointer to the filename.
//                  *** NOTE *** This is an ST!!!  It's length-prefixed,
//                  and it's NOT guaranteed to be null-terminated!

LPCH
SLNameFromHsf (
    HSF hsf
    )
{
    LPCH    lpch = NULL;

    if (hsf) {
        lpch = LpchGetName ((LPSF) hsf);
    }
    return(lpch);
}


//  SLNameFromHmod - Return the filename for an HMOD
//
//  Purpose:        Get one filename associated with an HMOD.  Each module
//                  of a program may have many source files associated
//                  with it (e.g., "foo.hpp", "bar.hpp", and "foo.cpp"),
//                  depending on whether there is code in any included
//                  files.  The iFile parameter can be used to loop
//                  through all the files.
//
//  Input:          hmod - handle to a module
//                  iFile - ONE-based index indicating which filename to
//                     return
//
//  Returns:        Length-prefixed pointer to the filename.
//                  *** NOTE *** This is an ST!!!  It's length-prefixed,
//                  and it's NOT guaranteed to be null-terminated!
//
//  Notes:          The filenames are NOT in any special order (you can't
//                  assume, for example, that the last one is the "real"
//                  source file.)
//
//                  Also, unfortunately (due to the linker), there may be
//                  duplicates!!!  One module may have two occurrences of
//                  "foo.hpp".

#pragma optimize ("", off)
LPCH
SLNameFromHmod (
    HMOD hmod,
    WORD iFile
    )
{
    LPCH    lpch  = NULL;
    LPMDS   lpmds;
    LPEXG   lpexg;

    if ((lpmds = (LPMDS) hmod) &&
        (lpexg = (LPEXG) LLLock (lpmds->hexg)))
    {
        UINT imod = lpmds->imds - 1;

        if (imod < lpexg->cMod && iFile <= lpexg->rgculFile [imod]) {
            lpch = lpexg->lpchFileNames +
                (lpexg->rgichFile [(WORD) (lpexg->rgiulFile [imod]) + iFile - 1]);
        }

        LLUnlock (lpmds->hexg);
    }

    return lpch;
}
#pragma optimize ("", on)


//  SLFQueryModSrc - Query whether a module has symbolic information
//
//  Purpose:        Query whether a module has symbolic information
//
//  Input:          hmod - module to check for source
//
//  Returns:        TRUE if this module has symbolic information, FALSE
//                  if not

BOOL
SLFQueryModSrc (
    HMOD hmod
    )
{
    LPMDS lpmds = (LPMDS) hmod;

    BOOL  fRet = lpmds->hst != NULL || lpmds->ulhst;

    return fRet;
}


//  SLHsfFromPcxt - Return source file for a context
//
//  Purpose:        Return the source file that a particular CXT is from
//
//  Input:          pcxt - pointer to CXT for which to find source file
//
//  Returns:        handle to source file, or NULL if not found

HSF
SLHsfFromPcxt (
    PCXT pcxt
    )
{
    LPMDS   lpmds = (LPMDS) SHHMODFrompCXT(pcxt);
    WORD    iFile = 0;
    WORD    iSeg  = 0;
    LPSF    lpsf = NULL;

    if (lpmds != NULL && HstFromLpmds (lpmds) != NULL) {
        FLpsfFromAddr (SHpADDRFrompCXT (pcxt),
                        (LPSM) lpmds->hst,
                        &lpsf,
                        &iFile,
                        &iSeg);
    }

    return (HSF) lpsf;
}


//  SLHsfFromFile - return HSF for a given source filename
//
//  Purpose:        Given a module and a source filename, return the HSF
//                  that corresponds
//
//  Input:          hmod - module to check for this filename (can't be NULL)
//                  lszFile - filename and extension
//
//  Returns:        handle to source file, or NULL if not found
//
//  Notes:          ONLY the filename and extension of lszFile are
//                  matched!  There must be no path on the lszFile

HSF
SLHsfFromFile (
    HMOD hmod,
    LSZ  lszFile
    )
{
    // We need to handle the no-hit case w/o loading source info

    LPSF    lpsf = NULL;
    LPMDS   lpmds = (LPMDS) hmod;
    char    szFileBuf[_MAX_PATH];
    LPSTR   lszFileT;

    assert(lszFile);
    assert(*lszFile != '\0');

    // If the filename is quoted, remove the quotes.

    if ((*lszFile == '\"') && (*(lszFile + _tcslen(lszFile) - 1) == '\"')) {
        lszFileT = szFileBuf;
        memcpy(lszFileT, _tcsinc(lszFile), _tcslen(lszFile) - 2);
        lszFileT[_tcslen(lszFile)-2] = '\0';
    } else {
        lszFileT = lszFile;
    }

    if (lpmds != NULL) {
        short isf = IsfFromName (FALSE, 0, lszFileT, lpmds);

        if (isf != -1) {
            lpsf = GetLpsfFromIndex ((LPSM) HstFromLpmds (lpmds), isf);
        }
    }

    return lpsf;
}


LOCAL HST
HstFromLpmds (
    LPMDS lpmds
    )
{
    if (lpmds->hst != NULL) {
        return lpmds->hst;
    } else if (lpmds->pmod) {
        // Allocate space for this module's line number information,
        // then load it from the PDB and sort it.

        if (!ModQueryLines(lpmds->pmod, 0, (CB *)&lpmds->cbhst) ||
            !(lpmds->cbhst) ||
            !(lpmds->hst = MHAlloc(lpmds->cbhst)))
            return 0;

        if (ModQueryLines(lpmds->pmod, (PB)lpmds->hst, (CB *)&lpmds->cbhst)) {
            SortSM((LPSM)lpmds->hst);
            return lpmds->hst;
        } else {
            MHFree(lpmds->hst);
            lpmds->hst = 0;
            return 0;
        }
    } else if (lpmds->ulhst == 0) {
        return NULL;
    } else {
        assert(FALSE);          // We should never hit this code now
                                //  that we're mapped.
        LPEXG lpexg = (LPEXG) LLLock (lpmds->hexg);
        INT   hfile = SYOpen (lpexg->lszDebug);
        HST   hst   = MHAlloc ((UINT) lpmds->cbhst);

        if (hfile == -1 || hst == NULL) {
            LLUnlock (lpmds->hexg);
            return NULL;
        }

        if (SYSeek(hfile, lpmds->ulhst, SEEK_SET) != (LONG) lpmds->ulhst) {
            assert(FALSE);
        }

        if (SYReadFar (hfile, (LPB) hst, (UINT) lpmds->cbhst) != lpmds->cbhst) {
            assert (FALSE);
        }

        SYClose (hfile);

        lpmds->hst = hst;

        LLUnlock (lpmds->hexg);

        SortSM ((LPSM)hst);

        return hst;
    }
}


__inline VOID
SortSM (
    LPSM lpsm
    )
{
    short isf  = 0;
    LPSF  lpsf = NULL;

    while ((lpsf = GetLpsfFromIndex (lpsm, isf)) != NULL) {
        WORD isl = 0;
        LPSL lpsl = NULL;

        while ((lpsl = GetLpslFromIndex (lpsm, lpsf, isl)) != NULL) {
            if (!FCheckSLOrder (lpsl)) {
                SortSL (lpsl);
            }
            isl += 1;
        }
        isf += 1;
    }
}

BOOL
FCheckSLOrder (
    LPSL lpsl
    )
{
    BOOL fSorted  = TRUE;
    int  fChanged = FALSE;
    int  coff     = lpsl->cLnOff;
    LPUL rgoff    = lpsl->offset;
    LPW  rgln     = (LPW) &lpsl->offset [ coff ];
    int  ioff     = 0;

    for (ioff = 1; ioff < coff; ioff++) {
        if (rgoff [ioff] == rgoff[ioff-1]) {

            // Yes this is extremely slow, but it is safe, and the
            //  condition that causes this move should only happen
            //  in a very odd case when the QC back end screws up.

            memmove(&rgoff[ioff - 1],
                    &rgoff[ioff],
                    (coff - ioff) * sizeof(ULONG));

            memmove(&rgln[ioff - 1],
                    &rgln[ioff],
                    (coff - ioff) * sizeof(WORD));

            fChanged = TRUE;
            coff -= 1;
        }
        else if (rgoff [ ioff ] < rgoff [ ioff - 1 ]) {
            fSorted = FALSE;
        }
    }

    if (fChanged) {
        memmove(&rgoff[coff],
                rgln,
                coff * sizeof(WORD));

        lpsl->cLnOff = coff;
    }

    return fSorted;
}


__inline VOID
SortOffFromBounds (
    WORD cbnds,
    LPBNDS rgbnds,
    WORD coff,
    LPUL rgoff
    )
{
    SortFromBounds (cbnds, rgbnds, coff, rgoff, sizeof (ULONG));
}


__inline VOID
SortLnFromBounds (
    WORD cbnds,
    LPBNDS rgbnds,
    WORD cln,
    LPW rgln
    )
{
    SortFromBounds (cbnds, rgbnds, cln, rgln, sizeof (WORD));
}


__inline VOID
SortFromBounds (
    WORD cbnds,
    LPBNDS rgbnds,
    WORD cv,
    LPV rgv,
    WORD cbv
    )
{
    LPV  lpv    = MHAlloc (cbv * cv);
    WORD ibnds  = 0;
    WORD iv     = 0;

    if (lpv == NULL) {
        return;
    }

    for (ibnds = 0; ibnds < cbnds; ibnds++) {
        WORD cvT = rgbnds [ ibnds ].ilnEnd - rgbnds [ ibnds ].ilnStart + 1;

        memcpy(((LPB) lpv) + (iv * cbv),
               ((LPB) rgv) + (rgbnds[ibnds].ilnStart * cbv),
               cvT * cbv);

        iv += cvT;
    }

    memcpy(rgv, lpv, cbv * cv);

    MHFree(lpv);
}

__inline VOID
SortSL (
    LPSL lpsl
    )
{
    WORD   coff      = lpsl->cLnOff;
    LPUL   rgoff     = lpsl->offset;
    LPW    rgln      = (LPW) &lpsl->offset [ coff ];
    WORD   cbnds     = 0;
    LPBNDS rgbnds    = NULL;

    rgbnds = BuildBounds (coff, rgoff, &cbnds);
    if (rgbnds != NULL) {
        SortOffFromBounds (cbnds, rgbnds, coff, rgoff);
        SortLnFromBounds  (cbnds, rgbnds, coff, rgln );

        MHFree (rgbnds);
    }
}


__inline WORD
FindPosition (
    LPBNDS rgbnds,
    WORD cbnds,
    LPUL rgoff,
    ULONG uoff
    )
{
    WORD ibnds = 0;

    // This should be a binary search - but existing test cases
    //  contain so few blocks that I'm not going to bother right now

    while (ibnds < cbnds) {
        if (rgoff [ rgbnds [ ibnds ].ilnEnd ] > uoff) {
            break;
        }

        ibnds += 1;
    }

    return ibnds;
}


__inline LPBNDS
InsertBlock (
    WORD   ibnds,
    WORD   cbnds,
    LPBNDS rgbnds,
    LPW    lpcbndsMax,
    LPW    lpcbndsAlloc
    )
{
    if (*lpcbndsMax + cbnds > *lpcbndsAlloc) {
        // If the insert is going to run over the currently allocated
        //  block array, reallocate it to give more room

        rgbnds = (LPBNDS) MHRealloc(rgbnds, sizeof(BNDS) * (*lpcbndsAlloc + cbndsAllocBlock));

        *lpcbndsAlloc += cbndsAllocBlock;
    }

    if (ibnds < *lpcbndsMax) {

        // If we're somewhere in the middle of the array, we need
        //  to shift the remainder up in memory.
        memmove(&rgbnds[ibnds + cbnds],
                &rgbnds[ibnds],
                (*lpcbndsMax - ibnds) * sizeof(BNDS));
    }

    *lpcbndsMax += cbnds;

    return rgbnds;
}


__inline WORD
ScanBlock (
    LPUL rgoff,
    WORD coff,
    WORD ioff,
    ULONG uoffMax
    )
{
    while (ioff + 1 < coff &&
            rgoff [ ioff + 1 ] > rgoff [ ioff ] &&
            rgoff [ ioff + 1 ] < uoffMax)
    {
        ioff += 1;
    }

    return ioff;
}


LPBNDS
BuildBounds (
    WORD coff,
    LPUL rgoff,
    LPW lpcbnds
    )
{
    LPBNDS rgbnds     = (LPBNDS) MHAlloc (sizeof (BNDS) * cbndsAllocBlock);
    WORD   cbndsAlloc = cbndsAllocBlock;
    WORD   cbnds      = 0;
    WORD   ioff       = 0;

    while (ioff < coff) {
        ULONG uoffCurr  = rgoff [ ioff ];
        ULONG uoffMax   = 0;
        WORD  ibnds     = FindPosition (rgbnds, cbnds, rgoff, uoffCurr);

        if (ibnds == cbnds) {

            // We're after all other known blocks, so our max
            //  is "infinity"

            uoffMax = 0xFFFFFFFF;

            rgbnds = InsertBlock (ibnds, 1, rgbnds, &cbnds, &cbndsAlloc);

        } else if (rgoff [ rgbnds [ ibnds ].ilnStart ] > uoffCurr) {

            // We're at an insertion point, not in the middle of
            //  another block candidate

            uoffMax = rgoff [ rgbnds [ ibnds ].ilnStart ];

            rgbnds = InsertBlock (ibnds, 1, rgbnds, &cbnds, &cbndsAlloc);
        } else {

            // We're in the middle of another block candidate, so we
            //  must split it in two

            rgbnds = InsertBlock (ibnds, 2, rgbnds, &cbnds, &cbndsAlloc);

            // Start of ibnds is already set
            rgbnds [ ibnds ].ilnEnd = ScanBlock (
                rgoff,
                coff,
                rgbnds [ ibnds ].ilnStart,
                uoffCurr
           );

            rgbnds [ ibnds + 2 ].ilnStart = rgbnds [ ibnds ].ilnEnd + 1;
            // End of ibnds + 2 is already set

            uoffMax = rgoff [ rgbnds [ ibnds + 2 ].ilnStart ];

            ibnds += 1;
        }

        rgbnds [ ibnds ].ilnStart = ioff;
        rgbnds [ ibnds ].ilnEnd   = ScanBlock (rgoff, coff, ioff, uoffMax);

        ioff = rgbnds [ ibnds ].ilnEnd + 1;
    }

    *lpcbnds = cbnds;
    return rgbnds;
}