//-------------------------------------------------------------------------
// Desc:	B-tree block combining
// Tabs:	3
//
//		Copyright (c) 1992-2006 Novell, Inc. All Rights Reserved.
//
//		This program is free software; you can redistribute it and/or
//		modify it under the terms of version 2 of the GNU General Public
//		License as published by the Free Software Foundation.
//
//		This program is distributed in the hope that it will be useful,
//		but WITHOUT ANY WARRANTY; without even the implied warranty of
//		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//		GNU General Public License for more details.
//
//		You should have received a copy of the GNU General Public License
//		along with this program; if not, contact Novell, Inc.
//
//		To contact Novell about this file by physical or electronic mail,
//		you may find current contact information at www.novell.com
//
// $Id: fscomblk.cpp 12283 2006-01-19 14:53:15 -0700 (Thu, 19 Jan 2006) dsanders $
//-------------------------------------------------------------------------

#include "flaimsys.h"

FSTATIC FLMINT FSBlkCompressPKC(
	BTSK_p			pStack,
	FLMBYTE *		pTempPKCBuf);


/*
Desc:  	Build a PKC buffer for a single element
Return:	Length used within the PKC buffer
*/
FINLINE FLMUINT FSElmBuildPKC(
	FLMBYTE *		pPkcBuf,
	FLMBYTE *		pElement,
	FLMBYTE *		pElmPkcBuf,
	FLMUINT			uiElmOvhd)
{
	FLMUINT			uiPkc;
	FLMUINT		   uiKeyLen;
	
	if( uiElmOvhd == BNE_DATA_OVHD)
		return 0;

	uiKeyLen = (FLMUINT)(BBE_GET_KL( pElement ));

	if( (uiPkc = (FLMUINT)(BBE_GET_PKC( pElement))) != 0)
	{
		f_memmove( pPkcBuf, pElmPkcBuf, uiPkc );
	}
	if( uiPkc + uiKeyLen > BBE_PKC_MAX)
		uiKeyLen = (FLMUINT)(BBE_PKC_MAX - uiPkc);

	f_memmove( &pPkcBuf[ uiPkc ], &pElement[ uiElmOvhd ], uiKeyLen );

	return( uiPkc + uiKeyLen);
}


/****************************************************************************
Desc:		Try to combine two blocks into a single block.  The algorithm will
			alternate tring the block to the right or uiLeft of the 'target' block.
			The bsCurElm MUST be positioned to the current element.  The bsCurElm
			may be at the very end of the block not pointing to an element.  If
			so then if blocks are combine bsCurElm should then be valid.
Notes: 	Remember that this can be called on any level of the btree.
****************************************************************************/
RCODE FSCombineBlks(
	FDB *				pDb,
	LFILE *			pLFile,
	BTSK_p *			pStackRV	/* Stack may change on you */
	)
{
	RCODE			   rc = FERR_OK;
	BTSK_p			pStack = *pStackRV;
	SCACHE *			pLeftCache;
	SCACHE *			pRightCache;
	FLMBYTE *		pLeftBlk;
	FLMBYTE *		pRightBlk;
	FLMBYTE *		pBlk = pStack->pBlk;
	FLMBOOL			bReleaseLeft = FALSE;
	FLMBOOL			bReleaseRight = FALSE;
	FLMUINT			uiLeftBlkAddr;
	FLMUINT			uiRightBlkAddr;
	FLMUINT			uiLeftBlkEnd;
	FLMUINT			uiRightBlkEnd;
	FLMUINT			uiBlkAddr = pStack->uiBlkAddr;
	FLMUINT			uiBlkEnd = pStack->uiBlkEnd;
	FLMUINT        uiCurElm = pStack->uiCurElm;
	FLMUINT			uiElmOvhd = pStack->uiElmOvhd;
	FLMUINT			uiBlkSize;
	FLMUINT			uiPosToElm = 0;
	FLMUINT			uiPosToBlk = 0;
	FLMUINT			uiSplitPoint;
	FLMUINT			uiTargetSplitPoint;
	FLMINT			iTemp;
	FLMINT			iDelta;
	BTSK			   tempStack;
	FLMBYTE			pPkcBuf[ BBE_PKC_MAX ];
	DB_STATS *		pDbStats;

	f_yieldCPU();				/* NLM - release cpu */

	/* Return if either block is leftmost or rightmost block */
	uiLeftBlkAddr  = (FLMUINT) FB2UD( &pBlk[ BH_PREV_BLK ]);
	uiRightBlkAddr = (FLMUINT) FB2UD( &pBlk[ BH_NEXT_BLK ]);
	if( ( uiLeftBlkAddr == BT_END) || ( uiRightBlkAddr == BT_END))
	{
		goto Exit;		// Should return SUCCESS
	}

	uiBlkSize = pDb->pFile->FileHdr.uiBlockSize - uiElmOvhd;

	/* Read in left and right blocks - make sure all cache ptrs are valid */

	if( RC_BAD( rc = ScaGetBlock( pDb, pLFile, BHT_LEAF, uiLeftBlkAddr, NULL,
								&pLeftCache)))
	{
		goto Exit;
	}
	bReleaseLeft = TRUE;

	if( RC_BAD( rc = ScaGetBlock( pDb, pLFile, BHT_LEAF, uiRightBlkAddr, NULL,
								&pRightCache)))
	{
		goto Exit;
	}
	bReleaseRight = TRUE;

	/* Determine if there is room without compressing first elm in current blk*/
	pLeftBlk  = pLeftCache->pucBlk;
	uiLeftBlkEnd  = (FLMUINT) FB2UW( &pLeftBlk[ BH_BLK_END ]);
	pRightBlk = pRightCache->pucBlk;
	uiRightBlkEnd = (FLMUINT) FB2UW( &pRightBlk[ BH_BLK_END ]);

	/* Don't want to fill too tight - so don't subtract BH_OVHD from sum */
	if( uiLeftBlkEnd + uiBlkEnd + uiRightBlkEnd > uiBlkSize + uiBlkSize)
	{
FSCB_Unpin:
		if( bReleaseRight)
		{
			ScaReleaseCache( pRightCache, FALSE);
			bReleaseRight = FALSE;
		}
		if( bReleaseLeft)
		{
			ScaReleaseCache( pLeftCache, FALSE);
			bReleaseLeft = FALSE;
		}

		if( RC_OK( rc = FSGetBlock( pDb, pLFile, uiBlkAddr, pStack)))
		{
			pStack->uiCurElm = uiCurElm;
			/* bsKeyBuf[] could have been wiped out in a scanTo call! */
			FSBlkBuildPKC( pStack, pStack->pKeyBuf, FSBBPKC_AT_CURELM);
		}
		goto Exit;
	}

	/**---------------------------------------------------------------------
	*** This is a very good yet extreamly tricky algorithm!
	***	If the delta (difference in size) of the left and right blocks
	*** is more than the size of the middle block the entire middle will
	***	will be moved to the left or right block that is not very full.
	***	Otherwise, uiTargetSplitPoint will be computed to be around the
	*** point that will place elements in both blocks to fill the left
	*** and right blocks to about the same point.
	*** NOTE: Read the comments if all is fuzzy.
	***--------------------------------------------------------------------*/

	iTemp = uiBlkEnd - BH_OVHD + BBE_PKC_MAX;	/* temp is max. bytes to move */
	uiTargetSplitPoint = 0;

	if( uiLeftBlkEnd < uiRightBlkEnd )			/* Put most in the left block */
	{
		iDelta = uiRightBlkEnd - uiLeftBlkEnd;
		if( iTemp <= iDelta)
			pStack->uiCurElm = uiBlkEnd;		/* Put all in the left block */
		else
			uiTargetSplitPoint = BH_OVHD + iDelta + ((iTemp - iDelta) >> 1);
	}
	else												/* Put most in the right block */
	{
		iDelta = uiLeftBlkEnd - uiRightBlkEnd;
		if( iTemp <= iDelta )
			pStack->uiCurElm = BH_OVHD;			/* Put all in right block */
		else
			uiTargetSplitPoint = BH_OVHD + ((iTemp - iDelta) >> 1);
	}

	if( uiTargetSplitPoint)						/* If try to divide into both blocks */
	{
		pStack->uiCurElm = uiTargetSplitPoint;

		/* Scan AFTER targetSplitPoint */
		if( RC_BAD(rc = FSBtScanTo( pStack, NULL, 0, 0)))
			goto Exit;
	
		/**-----------------------------------------------------------------
		*** Last check to see if elements will fit in both blocks.
		*** This is still a chance that all elements will go to one block
		***----------------------------------------------------------------*/
		if( ( uiLeftBlkEnd + (pStack->uiCurElm - BH_OVHD) > uiBlkSize ) ||
			 ( uiRightBlkEnd + (uiBlkEnd - pStack->uiCurElm) + BBE_PKC_MAX > uiBlkSize ))
			goto FSCB_Unpin;
	}

	/* We are now guarenteed to fit!!! - log blocks and start moving */

	if( (pDbStats = pDb->pDbStats) != NULL)
	{
		LFILE_STATS *		pLFileStats;

		if( (pLFileStats = fdbGetLFileStatPtr( pDb, pLFile)) != NULL)
		{
			pLFileStats->bHaveStats =
			pDbStats->bHaveStats = TRUE;
			pLFileStats->ui64BlockCombines++;
		}
	}

	if( RC_BAD( rc = ScaLogPhysBlk( pDb, &pLeftCache )))
		goto Exit;
	pLeftBlk  = pLeftCache->pucBlk;

	uiSplitPoint = pStack->uiCurElm;
	if( uiSplitPoint != BH_OVHD )				/* Elements to move into LEFT block? */
	{
		FLMUINT		uiCompressBytes;
		FLMUINT		uiBytesAdded = uiSplitPoint - BH_OVHD;
	
		tempStack.pSCache = pLeftCache;
		tempStack.pBlk = pLeftCache->pucBlk;
		FSBlkToStack( &tempStack );
		tempStack.uiKeyBufSize = MAX_KEY_SIZ;

		/* Algorithm could call the move routine if it wasn't for uiCompressBytes */
		f_memmove( &pLeftBlk[ uiLeftBlkEnd ], &pBlk[ BH_OVHD ], uiBytesAdded );
		tempStack.uiCurElm = uiLeftBlkEnd;

		uiLeftBlkEnd += uiBytesAdded;
		tempStack.uiBlkEnd = uiLeftBlkEnd;
		UW2FBA( uiLeftBlkEnd, &pLeftBlk[ BH_BLK_END ]);
	
		uiCompressBytes = FSBlkCompressPKC( &tempStack, pPkcBuf );
		if( uiCompressBytes == 0xFFFF)	/* Special case that shouldn't happen. */
		{
			rc = RC_SET( FERR_DATA_ERROR);
			goto Exit;
		}
		if( uiCurElm < uiSplitPoint )
		{
			uiPosToBlk = uiLeftBlkAddr;
			uiPosToElm = (FLMUINT)((uiLeftBlkEnd - uiBytesAdded) + uiCurElm - BH_OVHD);

			// NOTE: uiCompressBytes should be zero for fixed element blocks - see
			// FSBlkCompressPKC

			if( uiCurElm != BH_OVHD )
				uiPosToElm -= uiCompressBytes;
		}
	}
	UD2FBA( uiRightBlkAddr, &pLeftBlk[ BH_NEXT_BLK ] );
	ScaReleaseCache( pLeftCache, FALSE);
	bReleaseLeft = FALSE;

	/**-------------------------------------------------------------------
	***		WOW - done with the left block.  Move the rest of the data
	***		into the right block.  Be carefull to compress the first
	***		element of the right block and decompress the element that
	***		is at the split point in the middle (deleted) block.
	***------------------------------------------------------------------*/

	if( RC_BAD( rc = ScaLogPhysBlk( pDb, &pRightCache )))
		goto Exit;
	pRightBlk = pRightCache->pucBlk;

	if( uiSplitPoint != uiBlkEnd )					/* Elements to move into RIGHT block? */
	{
		FLMBYTE *		pSplitPoint = &pBlk[ uiSplitPoint ];
		tempStack.pSCache = pRightCache;
		tempStack.pBlk = pRightCache->pucBlk;
		FSBlkToStack( &tempStack );
		tempStack.uiKeyBufSize = MAX_KEY_SIZ;
		
		/* Setup to position to current block and element at end of routine */
		if( uiCurElm >= uiSplitPoint )
		{
			uiPosToBlk = uiRightBlkAddr;
			uiPosToElm = (FLMUINT)((uiCurElm - uiSplitPoint) + BH_OVHD);

			// No PKC in fixed element blocks.

			if( uiCurElm != uiSplitPoint && tempStack.uiElmOvhd != BNE_DATA_OVHD)
			{
				uiPosToElm += BBE_GET_PKC( pSplitPoint );
			}
		}
		/**---------------------------------------------------------------
		*** If ScanTo() doesn't match uiCurElm exact then current element
		*** does not have the proper stuff in the pkc buffer or bsKeyBuf
		***--------------------------------------------------------------*/
		/* pStack->uiCurElm is uiSplitPoint */
		FSBlkBuildPKC( pStack, pPkcBuf, FSBBPKC_AT_CURELM );
		if( RC_BAD( rc = FSBlkMoveElms( &tempStack, pSplitPoint,
												 (FLMUINT)(uiBlkEnd - uiSplitPoint), pPkcBuf )))
			goto Exit;
	}

	UD2FBA( uiLeftBlkAddr, &pRightBlk[ BH_PREV_BLK ] );
	ScaReleaseCache( pRightCache, FALSE);
	bReleaseRight = FALSE;

	/* Now we can free the current block - blkFixLinks may work instead */

	rc = FSBlockFree( pDb, pStack->pSCache);
	pStack->pSCache = NULL;
	pStack->pBlk = NULL;
	if( RC_BAD( rc))
		return( rc );

	/**----------------------------------------------------------------------
	***		Now the hard part. Go to the parent & delete the current element.
	***		Go to the previous element and modify to reflect the new last
	***		element in the left block.
	***---------------------------------------------------------------------*/

	if( RC_BAD( rc = FSDelParentElm( pDb, pLFile, &pStack )))
		return( rc );

	if( uiSplitPoint != BH_OVHD )				/* Is there is new stuff in left blk?*/
	{
		/* Position and fixup the parent elements */
		if( RC_OK(rc = FSGetBlock( pDb, pLFile, uiLeftBlkAddr, pStack)))
		{
			rc = FSNewLastBlkElm( pDb, pLFile, &pStack,
										 FSNLBE_GREATER | FSNLBE_POSITION );
		}
	}

	/**------------------------------------------------------
	*** Position the pStack to where you should be.
	*** The parent element is pointing to the right block.
	***-----------------------------------------------------*/
	if( RC_OK( rc ))
	{
		/* Read in position block and position to current element */
		if( RC_OK(rc = FSGetBlock( pDb, pLFile, uiPosToBlk, pStack)))
		{
			pStack->uiCurElm = uiPosToElm;
			if( uiPosToBlk == uiLeftBlkAddr )
			{
				rc = FSAdjustStack( pDb, pLFile, pStack, FALSE);
			}
			/**--------------------------------------------
			***  This line must	be explained!
			***  We should really be replacing the original
			***  PKC buffer into what was there before this
			***  routine was called.  This works because
			***  delete/insert pairs call scanTo before the 
			***  insert.  
			***--------------------------------------------*/
			FSBlkBuildPKC( pStack, pStack->pKeyBuf, FSBBPKC_AT_CURELM );
		}
	}
	*pStackRV = pStack;
Exit:
	if( bReleaseLeft)
	{
		ScaReleaseCache( pLeftCache, FALSE);
	}
	if( bReleaseRight)
	{
		ScaReleaseCache( pRightCache, FALSE);
	}
	return( rc );
}

/****************************************************************************
Desc:	Move 1 or more elements into the bsCurElm location within a block.
		Everything MUST fit.  Will compress the element coming in as well
		as the element at bsCurElm.  This will also work if you are moving
		data down within the same block.
****************************************************************************/
RCODE FSBlkMoveElms(
	BTSK_p    	pStack,			/* Stack containing block to accept data*/
	FLMBYTE *  	pInsertElm,		/* Element(s) to insert into block */
	FLMUINT   	uiInsElmLen,	/* Length of the Element(s) */
	FLMBYTE *	pElmPkcBuf		/* PKC buffer for element if elm has PKC*/
	)
{
	FLMBYTE *	pBlk = pStack->pBlk;
	FLMUINT    	uiCurElm = pStack->uiCurElm;
	FLMUINT		uiElmOvhd = pStack->uiElmOvhd;
	FLMUINT    	uiBytesInPkc;

	FLMBYTE    	pInsertElmPckBuf[ BBE_PKC_MAX ];
	FLMUINT    	uiMovedKeyLen,  uiMovedPkc;
	FLMUINT    	uiTemp;
	FLMUINT    	uiNewBlkEnd;
	FLMUINT    	uiInsertElmKeyLen;
	FLMINT    	iDistanceToShiftDown;
	FLMUINT    	uiAreaToShiftDown;
	FLMBYTE		pPkcBuf[ BBE_PKC_MAX ];
	FLMUINT    	uiInsertElmPkc;
	FLMUINT    	uiInsertElmPkcLen;

	if( uiElmOvhd == BNE_DATA_OVHD)
	{
		if( (uiAreaToShiftDown = (pStack->uiBlkEnd - uiCurElm)) > 0)
		{
			shiftN( &pBlk[ uiCurElm ], uiAreaToShiftDown, uiInsElmLen);
		}
		f_memmove( &pBlk[ uiCurElm], pInsertElm, uiInsElmLen);
		pStack->uiBlkEnd += uiInsElmLen;
		UW2FBA( pStack->uiBlkEnd, &pBlk[ BH_BLK_END ]);
		goto Exit;
	}

	// ELSE Normal complex move with previos key count (PKC)

	/* Puts up to BBE_PKC_MAX bytes in pPkcBuf[] only */
	uiBytesInPkc = FSBlkBuildPKC( pStack, pPkcBuf, FSBBPKC_BEFORE_CURELM );

	/* Compute real pkc for element */
	uiInsertElmPkcLen = FSElmBuildPKC( pInsertElmPckBuf, pInsertElm, pElmPkcBuf, uiElmOvhd );

	uiMovedPkc = FSElmComparePKC( pPkcBuf, uiBytesInPkc, pInsertElmPckBuf, uiInsertElmPkcLen );

	/**----------------------------------------------------------------
	*** Compute how much area pInsertElm[] will take when moved,
	*** compute uiBlkEnd and move most of the element except the key
	***---------------------------------------------------------------*/
	uiInsertElmKeyLen  = (FLMUINT)(BBE_GET_KL( pInsertElm ));
	uiInsertElmPkc     = (FLMUINT)(BBE_GET_PKC( pInsertElm ));
	uiMovedKeyLen = (FLMUINT)(uiInsertElmKeyLen + uiInsertElmPkc - uiMovedPkc);
	iDistanceToShiftDown = (FLMINT)(uiInsElmLen + uiMovedKeyLen - uiInsertElmKeyLen);
	if( (uiAreaToShiftDown = (FLMUINT)(pStack->uiBlkEnd - uiCurElm)) > 0)
	{
		shiftN( &pBlk[ uiCurElm ], uiAreaToShiftDown, iDistanceToShiftDown );
	}

	uiNewBlkEnd = (FLMUINT)(pStack->uiBlkEnd + iDistanceToShiftDown);
	UW2FBA( uiNewBlkEnd, &pBlk[ BH_BLK_END ]);
	pStack->uiBlkEnd = uiNewBlkEnd;

	/* Move the first pInsertElm[] overhead values and key to where to be inserted*/
	FSSetElmOvhd( &pBlk[uiCurElm], uiElmOvhd, uiMovedPkc, uiMovedKeyLen, pInsertElm);

	/**--------------------------------------------------------------
	*** The tricky part is to move the key!
	*** The key could move in 2 parts pInsertElmPckBuf and pInsertElm[]
	***-------------------------------------------------------------*/

	if( uiMovedKeyLen + uiMovedPkc > BBE_PKC_MAX )		/* Key not entirely in pPkcBuf[] */
	{
		/* Move all that is in the pPkcBuf[] */
		f_memcpy( &pBlk[ uiCurElm + uiElmOvhd ],
						&pInsertElmPckBuf[ uiMovedPkc ],
						uiTemp = (FLMUINT)(BBE_PKC_MAX - uiMovedPkc) );

		/* Move the rest that is in the element */
		f_memmove( &pBlk[ uiCurElm + uiElmOvhd + uiTemp ],
						&pInsertElm[ uiElmOvhd + uiInsertElmKeyLen - (uiMovedKeyLen - uiTemp) ],
						uiMovedKeyLen - uiTemp );
	}
	else if( uiMovedKeyLen)
	{
		/* Entire key fits within the pPkcBuf[] */
		f_memcpy( &pBlk[ uiCurElm + uiElmOvhd ], 
						&pInsertElmPckBuf[ uiMovedPkc ], uiMovedKeyLen );
	}
	/* Move the rest of the element(s) over to the block */
	uiTemp = uiElmOvhd + uiInsertElmKeyLen;
	f_memmove( &pBlk[ uiCurElm + uiElmOvhd + uiMovedKeyLen ],	/* Better move HIGH-LOW */
						&pInsertElm[ uiTemp ], uiInsElmLen - uiTemp );

	/**---------------------------------------------------------------
	*** Now - if uiAreaToShiftDown has a value then position to the 
	*** old uiCurElm and try to compress more out of the element
	***--------------------------------------------------------------*/

	if( uiAreaToShiftDown)
	{
		pStack->uiCurElm = uiCurElm + iDistanceToShiftDown;
		/* Could change pStack->wBlkEnd */
		FSBlkCompressPKC( pStack, pPkcBuf );
	}
	pStack->uiCurElm = uiCurElm;	/* Points to start of inserted element(s) */

Exit:
	return( FERR_OK );
}

/****************************************************************************
Desc:		Build the PKC portion scanning in a block to but not
			including pStack->uiCurElm
Notes:	General routine for split and combine code.
			More setup needed if you are calling FSBtInsert() or FSBlkInsElm().
			This routine is fastest known way to build PKC from any element.
****************************************************************************/
FLMUINT FSBlkBuildPKC(
	BTSK_p			pStack,
	FLMBYTE *		pPkcBuf,
	FLMUINT			uiFlags
	)
{
	FLMUINT			uiMoveArea;
	FLMUINT			uiPkc;
	FLMUINT			uiTargetCurElm;
	FLMUINT			uiElmOvhd		= pStack->uiElmOvhd;
	FLMUINT			uiCurElm;
	FLMUINT			uiElmKeyLen;
	FLMBYTE *		pCurElm;

	if( uiElmOvhd == BNE_DATA_OVHD)
	{
		return 0;
	}
	/* Code below is fastest way to position to bsCurElm */
	uiTargetCurElm = pStack->uiCurElm;
	uiMoveArea = uiPkc = 0;
	uiCurElm = BH_OVHD;
	while( uiCurElm < uiTargetCurElm)
	{
FSBB_one_more_time:

		pCurElm = &pStack->pBlk[ uiCurElm ];
		uiElmKeyLen = (FLMUINT)(BBE_GET_KL( pCurElm));
		if( uiElmKeyLen )
		{
			/* Move minimum data over to the pPkcBuf[] */
			uiPkc = (FLMUINT)(BBE_GET_PKC( pCurElm ));
			uiMoveArea = ((uiPkc + uiElmKeyLen) > BBE_PKC_MAX)
						  ? (BBE_PKC_MAX - uiPkc)
						  : uiElmKeyLen;

			/* Most common uiMoveArea value for data records & numeric keys */
			if( uiMoveArea == 1)
				pPkcBuf[ uiPkc ] = pCurElm[ uiElmOvhd ];
			else if( uiMoveArea )
			{
				f_memmove( &pPkcBuf[ uiPkc ], &pCurElm[ uiElmOvhd ], uiMoveArea);
			}
		}

		if( pStack->uiBlkType == BHT_LEAF)
		{
			/* Goto the next element in the block */
			uiCurElm += BBE_GET_RL( pCurElm);
		}
		else if( BNE_IS_DOMAIN( pCurElm))			/* Non-leaf block */
		{
			uiCurElm += BNE_DOMAIN_LEN;
		}
		uiCurElm += uiElmOvhd + uiElmKeyLen;
	}

	/* Hit the target current element */
	if( uiFlags == FSBBPKC_AT_CURELM)
	{
		/* Copy the current element into the pPkcBuf[] */
		uiFlags = FSBBPKC_BEFORE_CURELM;
		goto FSBB_one_more_time;
	}		
	
	return( uiPkc + uiMoveArea);
}

/****************************************************************************
Desc:  	Compress out (or in) the PKC bytes in the current element
Notes: 	pTempPkcBuf passed in only to save pStack space.
****************************************************************************/
FSTATIC FLMINT FSBlkCompressPKC(
	BTSK_p			pStack,
	FLMBYTE *		pTempPkcBuf
	)
{
	FLMUINT			uiTempPkcLen;
	FLMUINT			uiPkcBufLen;
	FLMUINT			uiCurPkc, uiTruePkc;
	FLMINT			iCompressBytes = 0;
	FLMBYTE *		pCurElm;
	FLMBYTE			pPkcBuf[ BBE_PKC_MAX ];

	if( pStack->uiElmOvhd == BNE_DATA_OVHD)
		goto Exit;

	/* Build the PKC buffer from the block */
	uiTempPkcLen = FSBlkBuildPKC( pStack, pTempPkcBuf, FSBBPKC_BEFORE_CURELM);

	/**-------------------------------------------------------
	*** Position to the current element and build its own
	*** pkc buffer.  Compare and see if equals the current
	*** element's pkc value.  If not compress/decompress
	***------------------------------------------------------*/

	pCurElm = &pStack->pBlk[ pStack->uiCurElm ];
	uiCurPkc    = (FLMUINT)(BBE_GET_PKC( pCurElm));
	uiPkcBufLen = FSElmBuildPKC( pPkcBuf, pCurElm, pTempPkcBuf, pStack->uiElmOvhd);

	uiTruePkc = FSElmComparePKC( pTempPkcBuf, uiTempPkcLen, pPkcBuf, uiPkcBufLen);

	if( uiTruePkc != uiCurPkc)
	{
		FLMBYTE *	pBlk = pStack->pBlk;
		FLMUINT		uiCurElm  = pStack->uiCurElm;
		FLMUINT		uiBlkEnd  = pStack->uiBlkEnd;
		FLMUINT		uiElmOvhd = pStack->uiElmOvhd;
		FLMUINT		keyLen    = (FLMUINT)(BBE_GET_KL(pCurElm));
		FLMUINT		uiTemp;

		if( uiTruePkc > uiCurPkc)
		{
			/* Need to compress out some more bytes */
			iCompressBytes = uiTruePkc - uiCurPkc;
			uiTemp = uiCurElm + uiElmOvhd + iCompressBytes;
			shiftN( &pBlk[ uiTemp ], (FLMUINT)(uiBlkEnd - uiTemp),
				(FLMINT)(-iCompressBytes));

			/* Reassign the element overhead */
			FSSetElmOvhd( pCurElm, uiElmOvhd,
										(FLMUINT)(uiCurPkc + iCompressBytes),
										(FLMUINT)(keyLen - iCompressBytes),
										pCurElm);
			uiBlkEnd -= iCompressBytes;
		}
		else /* uiTruePkc < uiCurPkc */
		{
			return( 0xFFFF); /* FERR_BTREE_ERROR Cannot ever happen right now */
		}
		UW2FBA( uiBlkEnd, &pBlk[ BH_BLK_END ]);
		pStack->uiBlkEnd = uiBlkEnd;
	}
Exit:
	return( iCompressBytes);
}