windows-xp/Source/XPSP1/NT/enduser/stuff/itircl/common/btree/btlookup.c

/*****************************************************************************
 *                                                                            *
 *  BTLOOKUP.C                                                                *
 *                                                                            *
 *  Copyright (C) Microsoft Corporation 1989 - 1994.                          *
 *  All Rights reserved.                                                      *
 *                                                                            *
 ******************************************************************************
 *                                                                            *
 *  Module Intent                                                             *
 *   Btree lookup and helper functions.                                       *
 *                                                                            *
 ******************************************************************************
 *                                                                            *
 *  Current Owner:  UNDONE                                                    *
 *                                                                            *
 *****************************************************************************/

static char s_aszModule[] = __FILE__;   /* For error report */

#include <mvopsys.h>
#include <orkin.h>
#include <misc.h>
#include <iterror.h>
#include <wrapstor.h>
#include <_mvutil.h>


/***************************************************************************
 *
 *                      Private Functions
 *
 ***************************************************************************/

/***************************************************************************
 *
 *      @doc    INTERNAL
 *
 *      @func   SHORT PASCAL FAR | CbSizeRec |
 *              Get the size of a record.
 *
 *      @parm   QV | qRec |
 *              the record to be sized
 *
 *      @parm   QBTHR | qbthr |
 *              btree header containing record format string
 *
 *      @rdesc  size of the record in bytes
 *              If we've never computed the size before, we do so by looking
 *              at the record format string in the btree header.  If the
 *              record is fixed size, we store the size in the header for
 *              next time.  If it isn't fixed size, we have to look at the
 *              actual record to determine its size.
 *
 ***************************************************************************/

PUBLIC SHORT PASCAL FAR CbSizeRec(QV qRec, QBTHR qbthr)
{
	CHAR  ch;
	QCH   qchFormat = qbthr->bth.rgchFormat;
	SHORT   cb = 0;
	BOOL  fFixedSize;
	LPBYTE lpb;

	if (qbthr->cbRecordSize)
		return qbthr->cbRecordSize;

	fFixedSize = TRUE;

	for (qchFormat++; ch = *qchFormat; qchFormat++)
	{
		switch (ch)
		{
			case '0': case '1': case '2': case '3': case '4':
			case '5': case '6': case '7': case '8': case '9':
			  cb += ch - '0';
			  break;

			case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
			  cb += ch + 10 - 'a';
			  break;

			case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
			  cb += ch + 10 - 'A';
			  break;

			// Variable length File Offset value (minimum 3 bytes)
			case FMT_VNUM_FO:
			  lpb=((LPBYTE)qRec)+cb;
			  cb++;
			  while ((*(lpb++))&0x80)
				cb++;

			  fFixedSize = FALSE;
			  break;
			
			case FMT_BYTE_PREFIX:
			  cb += sizeof(BYTE) + *((QB)qRec + cb);
			  fFixedSize = FALSE;
			  break;

			case FMT_WORD_PREFIX:
			  cb += sizeof(SHORT) + *((QW)qRec + cb);
			  fFixedSize = FALSE;
			  break;

			case FMT_SZ:
			  cb += (SHORT) STRLEN((QB)qRec + cb) + 1;
			  fFixedSize = FALSE;
			  break;

			default:
			  /* error */
			  assert(FALSE);
			  break;
		}
	}

	if (fFixedSize)
	{
		qbthr->cbRecordSize = cb;
	}

	return cb;
}

/***************************************************************************
 *
 *      @doc    INTERNAL
 *
 *      @func   BOOL PASCAL FAR | FReadBlock |
 *              Read a block from the btree file into the cache block.
 *
 *      @parm   QCB | qcb |
 *              qcb->bk        - bk of block to read
 *              qcb->db     - receives block read in from file
 *              qcb->bFlags - fCacheValid flag set, all others cleared
 *
 *      @parm   QBTHR | qbthr |
 *              qbthr->cbBlock - size of disk block to read
 *
 *      @rdesc  S_OK or other errors
 *
 *              Notes: Doesn't know about real cache, just this block
 *
 ***************************************************************************/

PUBLIC HRESULT PASCAL FAR FReadBlock(QCB qcb, QBTHR qbthr)
{
	LONG  l;
    HRESULT  errb;
	FILEOFFSET foSeek;

	if (qcb->bk >= qbthr->bth.bkEOF)
	{
		return E_ASSERT;
	}

	foSeek=FoFromBk(qcb->bk, qbthr);
	if (!FoEquals(FoSeekHf(qbthr->hf, foSeek, wFSSeekSet, &errb),foSeek))
	{
		return (E_FILESEEK);
	}

	l = qbthr->bth.cbBlock;
	errb = S_OK;
    
	if (LcbReadHf(qbthr->hf, &(qcb->db), (LONG)qbthr->bth.cbBlock,
	    &errb) != l)
	{
		if (errb == S_OK)
			return (E_FILEINVALID);		
		return errb;
	}
	qcb->bFlags = fCacheValid;
	qcb->db.cbSlack = SWAPWORD(qcb->db.cbSlack);
	qcb->db.cKeys = SWAPWORD(qcb->db.cKeys);

	return (S_OK);
}

/***************************************************************************
 *
 *      @doc    INTERNAL
 *
 *      @func   HRESULT PASCAL FAR | RcWriteBlock |
 *              Write a cached block to a file.
 *
 *      @parm   QCB | qcb |
 *              qcb->db the block to write
 *              qcb->bk bk of block to write
 *
 *      @parm   QBTHR | qbthr |
 *              qbthr->hf we write to this file
 *
 *      @rdesc  S_OK or other errors
 *              Side Effects: Fatal exit on read or seek failure.
 *
 *              Note: Don't reset dirty flag, because everyone who wants
 *              that done does it themselves. (?)
 *
 ***************************************************************************/

PUBLIC HRESULT PASCAL FAR  RcWriteBlock(QCB qcb, QBTHR qbthr)
{
#ifdef MOSMAP // {
	// Disable function
	return ERR_NOTSUPPORTED;
#else // } {
    HRESULT errb;
    FILEOFFSET foSeek;
	
	if (qcb->bk >= qbthr->bth.bkEOF)
		return E_ASSERT;
	if ((qcb->db.cbSlack  > qbthr->bth.cbBlock) || (qcb->db.cbSlack<0))
		return E_ASSERT;
#if 0
	if (qcb->db.cKeys*8+qcb->db.cbSlack > qbthr->bth.cbBlock)
		return E_ASSERT;
#endif
	

	foSeek=FoFromBk(qcb->bk, qbthr);
    errb = S_OK;             
	if (!FoEquals(FoSeekHf(qbthr->hf, foSeek, wFSSeekSet, &errb),foSeek) )
	{
		return(errb);
	}

	LcbWriteHf(qbthr->hf, &(qcb->db), (LONG)qbthr->bth.cbBlock, &errb);
	
	return errb;
#endif //}
}

/***************************************************************************
 *
 *      @doc    INTERNAL
 *
 *      @func   QCB PASCAL FAR | QFromBk |
 *              Convert a BK into a pointer to a cache block.  Cache the
 *              block at the given level, if it isn't there already.
 *
 *      @parm   BK | bk |
 *              BK to convert
 *
 *      @parm   SHORT | wLevel |
 *              btree level
 *      @parm   QBTHR | qbthr |
 *              Ptr to B-tree struct. State in: btree cache is locked
 *
 *      @rdesc  pointer to the cache block, with all fields up to date
 *              or NULL on I/O error
 *              state OUT:  block will be in cache at specified level; cache locked
 *
 ***************************************************************************/

PUBLIC QCB PASCAL FAR QFromBk(BK bk, SHORT wLevel, QBTHR qbthr, PHRESULT phr)
{
	QCB  qcb;
    HRESULT   fRet;

	if (wLevel < 0 || wLevel >= qbthr->bth.cLevels || bk >= qbthr->bth.bkEOF)
	{
		SetErrCode (phr, E_ASSERT);
		return(NULL);
	}
	

	qcb = QCacheBlock(qbthr, wLevel);

	if (!(qcb->bFlags & fCacheValid) || bk != qcb->bk)
	{
		/* requested block is not cached */

		if ((qcb->bFlags & fCacheDirty) && (qcb->bFlags & fCacheValid))
		{
			if ((fRet = RcWriteBlock(qcb, qbthr)) != S_OK)
			{
			    SetErrCode (phr, fRet);
				return NULL;
			}
		}

		qcb->bk = bk;
		if ((fRet = FReadBlock(qcb, qbthr)) != S_OK)
		{
			SetErrCode (phr, fRet);
			return NULL;
		}                               
	}
	return qcb;
}


/***************************************************************************
 *
 *      @doc    INTERNAL
 *
 *      @func   HRESULT PASCAL FAR | RcFlushCache |
 *              Write out dirty cache blocks
 *
 *      @parm   QBTHR | qbthr |
 *              qCache is locked
 *
 *      @rdesc    rc
 *              state OUT:  btree file is up to date.  cache block dirty flags reset
 *
 ***************************************************************************/

PUBLIC HRESULT PASCAL FAR RcFlushCache(QBTHR qbthr)
{
#ifdef MOSMAP // {
	// Disable function
	return ERR_SUCCESSS;
#else // } {
	SHORT   i;
	QB    qb;
	HRESULT    rc = S_OK;
    const SHORT iMax = qbthr->bth.cLevels;

    // We need to traverse this list in reverse order so the
    // nodes are actually written in numeric order
    qb = qbthr->qCache + CbCacheBlock(qbthr) * (iMax - 1);
	for (i = 0; i < iMax; i++, qb -= CbCacheBlock(qbthr))
	{

		if ((((QCB)qb)->bFlags & (fCacheDirty | fCacheValid)) ==
			(fCacheValid | fCacheDirty))
		{

			if ((rc = RcWriteBlock((QCB)qb, qbthr)) != S_OK)
				break;
			((QCB)qb)->bFlags &= ~fCacheDirty;
		}
	}

	return rc;
#endif //}
}

/***************************************************************************
 *
 *                      Public Functions
 *
 ***************************************************************************/

/***************************************************************************
 *
 *      @doc    INTERNAL
 *
 *      @func   HRESULT PASCAL FAR | RcLookupByKeyAux |
 *              Look up a key in a btree and retrieve the data.
 *              state IN:   cache is unlocked
 *
 *      @parm   HBT | hbt |
 *              btree handle
 *
 *      @parm   KEY | key |
 *              key we are looking up
 *
 *      @parm   QBTPOS | qbtpos |
 *              pointer to buffer for pos; use NULL if not wanted
 *
 *      @parm   QV | qData |
 *              pointer to buffer for record; NULL if not wanted
 *
 *      @parm   BOOL | fInsert |
 *              TRUE: if key would lie between two blocks, pos refers to proper
 *                      place to insert it
 *              FALSE: pos returned will be valid unless key > all keys in btree
 *
 *      @rdesc  S_OK if found, E_NOTEXIST if not found;
 *              other errors like ERR_MEMORY
 *              key found:
 *                      qbtpos  - btpos for this key
 *                      qData   - record for this key
 *
 *              key not found:
 *                      qbtpos  - btpos for first key > this key
 *                      qData   - record for first key > this key
 *
 *              key not found, no keys in btree > key:
 *                      qbtpos  - invalid (qbtpos->bk == bkNil)
 *                      qData   - undefined
 *      state OUT:  All ancestor blocks back to root are cached
 *
 ***************************************************************************/

PUBLIC HRESULT PASCAL FAR RcLookupByKeyAux(HBT hbt, KEY key,
	QBTPOS qbtpos, QV qData, BOOL fInsert)
{
	QBTHR qbthr;
	SHORT   wLevel;
	BK    bk;
	HRESULT    rc;
	HRESULT  errb;


	if (hbt == NULL)
		return E_INVALIDARG;

	qbthr = _GLOBALLOCK(hbt);

	if (qbthr->bth.cLevels <= 0)
	{
		rc = E_NOTEXIST;
exit0:
		_GLOBALUNLOCK(hbt);
		return rc;
	}

	if (qbthr->ghCache == NULL)
	{

		if ((rc = RcMakeCache(qbthr)) != S_OK)
			goto exit0;
	}

	qbthr->qCache = _GLOBALLOCK(qbthr->ghCache);

	/* Look in the top level */
	
	for (wLevel = 0, bk = qbthr->bth.bkRoot;
		bk != bkNil && wLevel < qbthr->bth.cLevels - 1; wLevel++)
	{
		bk = qbthr->BkScanInternal(bk, key, wLevel, qbthr, NULL, &errb);                
	}

	if (bk == bkNil)
	{
		rc = E_NOTEXIST;
exit1:
		_GLOBALUNLOCK(qbthr->ghCache);
		goto exit0;
	}
	
	if (((rc = qbthr->RcScanLeaf(bk, key, wLevel, qbthr,
		qData, qbtpos)) == E_NOTEXIST) &&
		qbtpos != NULL && !fInsert)
	{
	QCB qcb;        

		errb = S_OK; 
		qcb = QFromBk(qbtpos->bk, (SHORT)(qbthr->bth.cLevels - 1),
		    qbthr, &errb);
		if (errb != S_OK)
            rc = errb;

		if (qcb != NULL)
		{
			if (qcb != NULL && qbtpos->cKey == qcb->db.cKeys)
			{
				if (qbtpos->bk == qbthr->bth.bkLast)
				{
					qbtpos->bk = bkNil;
				}
				else {
					qbtpos->bk = SWAPLONG(BkNext(qcb));
					qbtpos->cKey = 0;
					qbtpos->iKey = 2 * sizeof(BK);
				}
			}
		}
	}

	goto exit1;
}

/***************************************************************************
 *
 *      @doc    INTERNAL
 *
 *      @func   WORD PASCAL FAR | WGetNextNEntries |
 *              Get a series of keys, data, or both from btree
 *
 *      @parm   HBT | hbt | B-tree handle
 *
 *      @parm   WORD | wFlags |
 *              Any one of the following flags (they may be combined, in which case
 *              the data will be of the form [Key Flag]* (keys and flags interleaved).
 *
 *      @flag GETNEXT_KEYS | Key fields will be returned
 *      @flag GETNEXT_RECS | Data records will be returned
 *      @flag GETNEXT_RESET | Ignore value in qbtpos and start from first entry
 *      @parm   WORD | wNumEntries | Max number of entries to retrieve.  It may
 *              be the case that fewer entries are returned.
 *
 *      @parm   QBTPOS | qbtpos |
 *              pointer to buffer containing starting point for retrieval, or NULL
 *              to start from the beginning and not care where we left off.  Call
 *              <f WGetNextN> multiple times to get the next items in the series
 *              if <P qbtpos> is valid.
 *
 *      @parm   QV | qvBuffer
 *              Pointer to buffer for record retrieved data.
 *
 *      @parm   LONG | lBufSize
 *              Maximum number of bytes contained in buffer.
 *
 *      @parm   PHRESULT | lpErrb
 *              Error return code.  Valid if returned value not equal to <P wNumEntries>.
 *
 *      @rdesc  Number of entries returned in buffer.
 *
 ***************************************************************************/

WORD PASCAL FAR wGetNextNEntries(HBT hbt, WORD wFlags, WORD wNumEntries, QBTPOS qbtpos, 
	QV qvBuffer, LONG lBufSize, PHRESULT phr)
{
	QBTHR   qbthr;
	BK      bk;
	QCB     qcb;
	SHORT   cbKey, cbRec;
	QB      qb;
	QB              qbBuffer=(QB)qvBuffer;
	HRESULT      rc;
	int             iKeyCurrent;
	int             cKey;
	WORD    wEntriesFilled=0;

	if (hbt == NULL)
	{       SetErrCode(phr,E_INVALIDARG);
		return wEntriesFilled;
	}

	qbthr = _GLOBALLOCK(hbt);

	if (qbthr->bth.lcEntries == (LONG)0)
	{
		SetErrCode(phr, E_NOTEXIST);
exit0:
		_GLOBALUNLOCK(hbt);
		return wEntriesFilled;
	}
	qbthr->qCache = _GLOBALLOCK(qbthr->ghCache);

	if (qbthr->ghCache == NULL)
	{
		if ((rc = RcMakeCache(qbthr)) != S_OK) 
		{       
			SetErrCode(phr, rc);
			goto exit0;
		}
	}

	if ((!qbtpos) || (wFlags&GETNEXT_RESET))        // Start from first
	{       if ((bk = qbthr->bth.bkFirst) == bkNil)
		{

			SetErrCode(phr, E_ASSERT);
exit1:
			_GLOBALUNLOCK(qbthr->ghCache);
			goto exit0;
		}
		if ((qcb = QFromBk(bk, (SHORT)(qbthr->bth.cLevels - 1), qbthr,
	    phr)) == NULL)
		{               
			goto exit1;
		}
		iKeyCurrent=2 * sizeof(BK);
		qb = qcb->db.rgbBlock + iKeyCurrent;
		cKey=0;
	}
	else    // Start from qbtpos
	{
		if (!FValidPos(qbtpos))
		{
			SetErrCode(phr,E_ASSERT);
			goto exit0;
		}
		bk=qbtpos->bk;
		if ((qcb = QFromBk(bk, (SHORT)(qbthr->bth.cLevels - 1),
		    qbthr, phr)) == NULL)
		{
			goto exit1;                     
		}
		
		if (qbtpos->cKey==qcb->db.cKeys)
		{
			SetErrCode(phr, E_NOTEXIST);
			goto exit1;
		}

		assert(qbtpos->cKey < qcb->db.cKeys);
		assert(qbtpos->cKey >= 0);
		assert(qbtpos->iKey >= 2 * sizeof(BK));
		assert(qbtpos->iKey <= (SHORT)(qbthr->bth.cbBlock - sizeof(DISK_BLOCK)));

		cKey=qbtpos->cKey;
		iKeyCurrent=qbtpos->iKey;
		qb = qcb->db.rgbBlock + iKeyCurrent;

	}

	// keep getting data and filling, and fix qbtpos to next valid spot
	while (wNumEntries--)
	{       
		cbKey = CbSizeKey((KEY)qb, qbthr, TRUE);        
		if (wFlags&GETNEXT_KEYS)
		{       
			if (cbKey>lBufSize)
			{
				break;
			}
			QVCOPY(qbBuffer, qb,(LONG)cbKey);
			qbBuffer+=cbKey;
			lBufSize-=cbKey;
		}
		iKeyCurrent+=cbKey;
		qb+=cbKey;
		cbRec = CbSizeRec(qb, qbthr);
		if (wFlags&GETNEXT_RECS)
		{
			if (cbRec>lBufSize)
			{       iKeyCurrent-=cbKey;
				lBufSize-=cbKey;
				break;                          
			}
			QVCOPY(qbBuffer,qb,(LONG)cbRec);
			qbBuffer+=cbRec;
			lBufSize-=cbRec;
		}
		iKeyCurrent+=cbRec;
		qb+=cbRec;

		wEntriesFilled++;
		cKey++;
		
		if (cKey>=qcb->db.cKeys)        // Must advance to next block!
		{
			BK bkNew = SWAPLONG(BkNext(qcb));
			if (bkNew == bkNil)     // Back up to last key in btree
			{       //cKey--;
				//iKeyCurrent-=cbKey+cbRec;
				break;
			}
			if ((qcb = QFromBk(bkNew, (SHORT)(qbthr->bth.cLevels - 1),
			    qbthr, phr)) == NULL)
			{
				goto exit1;
			}
			
			iKeyCurrent=2 * sizeof(BK);
			qb = qcb->db.rgbBlock + iKeyCurrent;
			cKey=0;
			bk=bkNew;
		}
	}

	if (qbtpos != NULL) 
	{
		qbtpos->bk = bk;
		qbtpos->iKey = iKeyCurrent;
		qbtpos->cKey = cKey;
	}
	
	goto exit1;

}

/***************************************************************************
 *
 *      @doc    INTERNAL
 *
 *      @func   HRESULT PASCAL FAR | RcFirstHbt |
 *              Get first key and record from btree.
 *
 *      @parm   HBT | hbt | B-tree handle
 *
 *      @parm   KEY | key |
 *              points to buffer big enough to hold a key (256 bytes is more
 *              than enough)
 *
 *      @parm   QV | qvRec
 *              pointer to buffer for record or NULL if not wanted
 *
 *      @parm   QBTPOS | qbtpos |
 *              pointer to buffer for btpos or NULL if not wanted
 *
 *      @rdesc  S_OK if anything found, else error code.
 *              key   - key copied here
 *              qvRec - record copied here
 *              qbtpos- btpos of first entry copied here
 *
 ***************************************************************************/

PUBLIC HRESULT PASCAL FAR RcFirstHbt(HBT hbt, KEY key, QV qvRec, QBTPOS qbtpos)
{
	QBTHR qbthr;
	BK    bk;
	QCB   qcb;
	SHORT   cbKey, cbRec;
	QB    qb;
	HRESULT    rc;
    HRESULT  errb;


	if (hbt == NULL)
		return E_INVALIDARG;

	qbthr = _GLOBALLOCK(hbt);

	if (qbthr->bth.lcEntries == (LONG)0)
	{
		rc = E_NOTEXIST;

exit0:
		_GLOBALUNLOCK(hbt);
		return rc;
	}

	if ((bk = qbthr->bth.bkFirst) == bkNil)
	{
		rc = E_ASSERT;
		goto exit0;
	}

	if (qbthr->ghCache == NULL)
	{
		if ((rc = RcMakeCache(qbthr)) != S_OK) 
			goto exit0;
	}

	qbthr->qCache = _GLOBALLOCK(qbthr->ghCache);

	if ((qcb = QFromBk(bk, (SHORT)(qbthr->bth.cLevels - 1), qbthr,
	    &errb)) == NULL)
	{
		rc = errb;
exit1:
		_GLOBALUNLOCK(qbthr->ghCache);
		goto exit0;
	}

	qb = qcb->db.rgbBlock + 2 * sizeof(BK);

	cbKey = CbSizeKey((KEY)qb, qbthr, TRUE);
	if ((QV)key != NULL) QVCOPY((QV)key, qb, (LONG)cbKey);
	qb += cbKey;

	cbRec = CbSizeRec(qb, qbthr);
	if (qvRec != NULL)
		QVCOPY(qvRec, qb, (LONG)cbRec);

	if (qbtpos != NULL) 
	{
		qbtpos->bk = bk;
		qbtpos->iKey = 2 * sizeof(BK);
		qbtpos->cKey = 0;
	}

	rc = S_OK;
	goto exit1;
}

/***************************************************************************
 *
 *      @doc    INTERNAL
 *
 *      @func   HRESULT PASCAL FAR | RcLastHbt |
 *              Get last key and record from btree.
 *
 *      @parm   HBT | hbt | B-tree handle
 *
 *      @parm   KEY | key |
 *              points to buffer big enough to hold a key (256 bytes
 *              is more than enough)
 *
 *      @parm   QV | qvRec |
 *              points to buffer big enough for record
 *
 *      @rdesc  S_OK if anything found, else error code.
 *              key   - key copied here
 *              qvRec - record copied here
 *
 ***************************************************************************/

PUBLIC HRESULT PASCAL FAR RcLastHbt(HBT hbt, KEY key, QV qvRec, QBTPOS qbtpos)
{
	QBTHR qbthr;
	BK    bk;
	QCB   qcb;
	SHORT   cbKey, cbRec, cKey;
	QB    qb;
	HRESULT    rc;
    HRESULT  errb;


	if (hbt == NULL)
		return E_INVALIDARG;

	qbthr = _GLOBALLOCK(hbt);

	if (qbthr->bth.lcEntries == (LONG)0)
	{
		rc = E_NOTEXIST;
exit0:
		_GLOBALUNLOCK(hbt);
		return rc;
	}

	if ((bk = qbthr->bth.bkLast) ==bkNil)
	{
		rc = E_ASSERT;
		goto exit0;
	}

	if (qbthr->ghCache == NULL)
	{
		if ((rc = RcMakeCache(qbthr)) != S_OK) 
			goto exit0;
	}

	qbthr->qCache = _GLOBALLOCK(qbthr->ghCache);

	if ((qcb = QFromBk(bk, (SHORT)(qbthr->bth.cLevels - 1),
	    qbthr, &errb)) == NULL)
	{
		rc = errb;
exit1:
		_GLOBALUNLOCK(qbthr->ghCache);
		goto exit0;
	}

	qb = qcb->db.rgbBlock + 2 * sizeof(BK);

	for (cKey = 0; cKey < qcb->db.cKeys - 1; cKey++)
	{
		qb += CbSizeKey((KEY)qb, qbthr, TRUE);
		qb += CbSizeRec(qb, qbthr);
	}
	
	cbKey = CbSizeKey((KEY)qb, qbthr, FALSE);
	if ((QV)key != NULL)
	    QVCOPY((QV)key, qb, (LONG)cbKey); // decompress

	cbRec = CbSizeRec(qb + cbKey, qbthr);
	if (qvRec != NULL)
		QVCOPY(qvRec, qb + cbKey, (LONG)cbRec);

	if (qbtpos != NULL)
	{
		qbtpos->bk = bk;
		qbtpos->iKey = (int)(qb - (QB)qcb->db.rgbBlock);
		qbtpos->cKey = cKey;
	}

	rc = S_OK;
	goto exit1;
}

/***************************************************************************
 *
 *      @doc    INTERNAL
 *
 *      @func   HRESULT FAR PASCAL | RcLookupByPos |
 *              Map a pos into a key and rec (both optional).
 *
 *      @parm   HBT | hbt |
 *              the btree
 *
 *      @parm   QBTPOS | qbtpos 
 *              pointer to pos
 *
 *      @rdesc  S_OK or errors
 *              key   - if not (KEY)NULL, key copied here, not to exceed iLen 
 *              qRec  - if not NULL, record copied here
 *
 ***************************************************************************/

PUBLIC HRESULT FAR PASCAL RcLookupByPos(HBT hbt, QBTPOS qbtpos,
	 KEY key, int   iLen, QV qRec)
{

	QBTHR qbthr;
	QCB   qcbLeaf;
	QB    qb;
	HRESULT    rc;
    HRESULT  errb;


	/* Sanity check */

	if (!FValidPos(qbtpos))
		return E_ASSERT;
	if (hbt == NULL)
		return E_INVALIDARG;

	qbthr = _GLOBALLOCK(hbt);

	if (qbthr->bth.cLevels <= 0)
	{
		rc = E_NOTEXIST;
exit0:
		_GLOBALUNLOCK(hbt);
		return rc;
	}

	if (qbthr->ghCache == NULL)
	{
		if ((rc = RcMakeCache(qbthr)) != S_OK)
			goto exit0;
	}

	qbthr->qCache = _GLOBALLOCK(qbthr->ghCache);
	if ((qcbLeaf = QFromBk(qbtpos->bk, (SHORT)(qbthr->bth.cLevels - 1),
	    qbthr, &errb)) == NULL)
	{

		rc = errb;
exit1:
		_GLOBALUNLOCK(qbthr->ghCache);
		goto exit0;
	}


	assert(qbtpos->cKey < qcbLeaf->db.cKeys);
	assert(qbtpos->cKey >= 0);
	assert(qbtpos->iKey >= 2 * sizeof(BK));
	assert(qbtpos->iKey <= (SHORT)(qbthr->bth.cbBlock - sizeof(DISK_BLOCK)));


	qb = qcbLeaf->db.rgbBlock + qbtpos->iKey;

	if (key != (KEY)NULL)
	{
		QVCOPY((QV)key, qb, (LONG)min(iLen,CbSizeKey((KEY)qb, qbthr, FALSE))); /* need to decompress */
		qb += CbSizeKey(key, qbthr, TRUE);
	}

	if (qRec != NULL)
	{
		QVCOPY(qRec, qb, (LONG)CbSizeRec(qb, qbthr));
	}

	rc = S_OK;
	goto exit1;
}

/***************************************************************************
 *
 *      @doc    INTERNAL
 *
 *      @func   HRESULT PASCAL FAR | RcNextPos |
 *              get the next record from the btree
 *              Next means the next key lexicographically from the key
 *              most recently inserted or looked up
 *              Won't work if we looked up a key and it wasn't there
 *
 *              STATE IN: a record has been read from or written to the file
 *                      since the last deletion
 *
 *
 *      @parm   HBT | hbt | B-tree handle
 *
 *      @rdesc  S_OK; E_NOTEXIST if no successor record
 *              args OUT:   key   - next key copied to here
 *                      qvRec - record gets copied here
 *
 ***************************************************************************/

PUBLIC HRESULT PASCAL FAR RcNextPos(HBT hbt, QBTPOS qbtposIn, QBTPOS qbtposOut)
{
	LONG l;

	return RcOffsetPos(hbt, qbtposIn, (LONG)1, &l, qbtposOut);
}

/***************************************************************************
 *
 *      @dos    INTERNAL
 *
 *      @func   HRESULT PASCAL FAR | RcOffsetPos |
 *              pos, offset from the previous pos by specified amount. 
 *              If not possible (i.e. prev of first) return real amount offset
 *              and a pos.
 *
 *      @parm    HBT | hbt |
 *              handle to btree
 *
 *      @parm   QBTPOS | qbtposIn |
 *              position we want an offset from
 *
 *      @parm   LONGD | lcOffset |
 *              amount to offset (+ or - OK)
 *
 *      @rdesc  rc
 *              args OUT:   qbtposOut       - new position offset by *qcRealOffset
 *                      *qlcRealOffset  - equal to lcOffset if legal, otherwise
 *                      as close as is legal
 *
 ***************************************************************************/
PUBLIC HRESULT PASCAL FAR RcOffsetPos(HBT hbt, QBTPOS qbtposIn,
	LONG lcOffset, QL qlcRealOffset, QBTPOS qbtposOut)
{
	QBTHR   qbthr;
	HRESULT      rc = S_OK;
	SHORT     c;
	LONG    lcKey, lcDelta = (LONG)0;
	QCB     qcb;
	BK      bk;
	QB      qb;
    HRESULT    errb;

	if (!FValidPos(qbtposIn))
		return E_ASSERT;

	if (hbt == NULL || qlcRealOffset == NULL)
		return E_INVALIDARG;

	bk = qbtposIn->bk;

	qbthr = _GLOBALLOCK(hbt);

	if (qbthr->bth.cLevels <= 0)
	{
		rc = E_NOTEXIST;
exit0:
		_GLOBALUNLOCK(hbt);
		return rc;
	}

	if (qbthr->ghCache == NULL)
	{
		if ((rc = RcMakeCache(qbthr)) != S_OK)
		{
			goto exit0;
		}
	}

	qbthr->qCache = _GLOBALLOCK(qbthr->ghCache); // >>>>what if no entries??


	if ((qcb = QFromBk(qbtposIn->bk,
		(SHORT)(qbthr->bth.cLevels - 1), qbthr, &errb)) == NULL)
	{
		rc = errb;

exit1:
		_GLOBALUNLOCK(qbthr->ghCache);
		goto exit0;
	}

	lcKey = qbtposIn->cKey + lcOffset;

	/* chase prev to find the right block */
	while (lcKey < 0)
	{
		bk = SWAPLONG(BkPrev(qcb));
		if (bk == bkNil)
		{
			bk = qcb->bk;
			lcDelta = lcKey;
			lcKey = 0;
			break;
		}
		if ((qcb = QFromBk(bk, (SHORT)(qbthr->bth.cLevels - 1),
		    qbthr, &errb)) == NULL)
		{
			rc = errb; 
			goto exit1;
		}
		lcKey += qcb->db.cKeys;
	}

	/* chase next to find the right block */
	while (lcKey >= qcb->db.cKeys)
	{
		lcKey -= qcb->db.cKeys;
		bk = SWAPLONG(BkNext(qcb));
		if (bk == bkNil)
		{
			bk = qcb->bk;
			lcDelta = lcKey + 1;
			lcKey = qcb->db.cKeys - 1;
			break;
		}
		if ((qcb = QFromBk(bk, (SHORT)(qbthr->bth.cLevels - 1),
		    qbthr, &errb)) == NULL)
		{
			rc = errb;
			goto exit1;
		}
	}

	
	if (bk == qbtposIn->bk && lcKey >= qbtposIn->cKey)
	{
		c = (SHORT) qbtposIn->cKey;
		qb = qcb->db.rgbBlock + qbtposIn->iKey;
	}
	else
	{
		c = 0;
		qb = qcb->db.rgbBlock + 2 * sizeof(BK);
	}

	while ((LONG)c < lcKey)
	{
		qb += CbSizeKey((KEY)qb, qbthr, TRUE);
		qb += CbSizeRec(qb, qbthr);
		c++;
	}

	if (qbtposOut != NULL)
	{
		qbtposOut->bk = bk;
		qbtposOut->iKey = (int)(qb - (QB)qcb->db.rgbBlock);
		qbtposOut->cKey = c;
	}

	*qlcRealOffset = lcOffset - lcDelta;

	rc = (lcDelta ? E_NOTEXIST: S_OK);
	goto exit1;
}


/* EOF */