campo-sirio/cb/source/i4remove.c

1313 lines
45 KiB
C
Raw Normal View History

/* i4remove.c (c)Copyright Sequiter Software Inc., 1988-1996. All rights reserved. */
#include "d4all.h"
#ifndef S4UNIX
#ifdef __TURBOC__
#pragma hdrstop
#endif
#endif
#ifndef S4CLIENT
#ifndef S4OFF_WRITE
#ifndef S4INDEX_OFF
int tfile4remove( TAG4FILE *t4, const unsigned char *ptr, const long rec )
{
int rc ;
#ifdef E4PARM_LOW
if ( t4 == 0 )
return error4( 0, e4parm_null, E95404 ) ;
#endif
rc = tfile4go( t4, ptr, rec, 0 ) ; /* returns -1 if error4code( codeBase ) < 0 */
if ( rc < 0 )
return error4stack( t4->codeBase, rc, E95404 ) ;
if ( rc )
return r4entry ;
return tfile4removeCurrent( t4 ) ;
}
int tfile4removeCalc( TAG4FILE *t4, long rec )
{
unsigned char *ptr ;
#ifdef E4PARM_LOW
if ( t4 == 0 )
return error4( 0, e4parm_null, E95405 ) ;
#endif
if ( error4code( t4->codeBase ) < 0 )
return e4codeBase ;
tfile4exprKey( t4, &ptr ) ;
return tfile4remove( t4, ptr, rec ) ;
}
#ifndef N4OTHER
#ifdef S4FOX
/* remove the (current) branch block */
int tfile4removeBranch( TAG4FILE *t4, B4BLOCK *blockOn )
{
long lNode, rNode ;
INDEX4FILE *i4 ;
#ifdef S4BYTE_SWAP
char *swapPtr ;
S4LONG longVal ;
short shortVal ;
int i ;
#endif
i4 = t4->indexFile ;
if ( blockOn == (B4BLOCK *)l4first( &t4->blocks ) )
{
/* Root Block, do not delete */
#ifdef E4ANALYZE
if ( blockOn->header.leftNode != -1 || blockOn->header.rightNode != -1 || blockOn->header.nKeys != 1 )
return error4describe( t4->codeBase, e4info, E80401, tfile4alias( t4 ), i4->file.name, 0 ) ;
#endif
memset( blockOn->data, 0, B4BLOCK_SIZE - sizeof(B4STD_HEADER) - sizeof(B4NODE_HEADER) ) ;
if ( !b4leaf( blockOn ) ) /* if not a leaf, then reset nodeHdr too */
{
memset( (void *)&blockOn->nodeHdr, 0, sizeof(B4NODE_HEADER) ) ;
b4leafInit( blockOn ) ;
}
else
blockOn->nodeHdr.freeSpace = B4BLOCK_SIZE - sizeof( B4STD_HEADER ) - sizeof( B4NODE_HEADER ) ;
blockOn->header.nKeys = 0 ;
blockOn->header.leftNode = -1 ;
blockOn->header.rightNode = -1 ;
blockOn->keyOn = -1 ;
blockOn->builtOn = -1 ;
blockOn->header.nodeAttribute = 3 ; /* root and leaf */
blockOn->changed = 1 ;
}
else /* This block is to be deleted */
{
lNode = blockOn->header.leftNode ;
rNode = blockOn->header.rightNode ;
l4remove( &t4->blocks, blockOn ) ;
if ( index4shrink( i4, blockOn->fileBlock ) < 0 )
return 0 ;
blockOn->changed = 0 ;
if ( lNode != -1L )
{
if ( file4readAll( &i4->file, I4MULTIPLY*lNode, &blockOn->header, B4BLOCK_SIZE) < 0 )
return 0 ;
#ifdef S4BYTE_SWAP
blockOn->header.nodeAttribute = x4reverseShort( (void *)&blockOn->header.nodeAttribute ) ;
blockOn->header.nKeys = x4reverseShort( (void *)&blockOn->header.nKeys ) ;
blockOn->header.leftNode = x4reverseLong( (void *)&blockOn->header.leftNode ) ;
blockOn->header.rightNode = x4reverseLong( (void *)&blockOn->header.rightNode ) ;
/* if block is a leaf */
if (blockOn->header.nodeAttribute >= 2 )
{
blockOn->nodeHdr.freeSpace = x4reverseShort( (void *)&blockOn->nodeHdr.freeSpace ) ;
longVal = x4reverseLong( (void *)&blockOn->nodeHdr.recNumMask[0] ) ;
memcpy( (void *)&blockOn->nodeHdr.recNumMask[0], (void *)&longVal, sizeof(long) ) ;
}
else /* if block is a branch */
{
shortVal = blockOn->tag->header.keyLen + sizeof(S4LONG) ;
/* position swapPtr to end of first key expression */
swapPtr = (char *) &blockOn->nodeHdr.freeSpace + blockOn->tag->header.keyLen ;
/* move through all B4KEY's to swap 'long's */
for ( i = 0 ; i < (int) blockOn->header.nKeys ; i++ )
{
longVal = x4reverseLong( (void *)swapPtr ) ;
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
swapPtr += sizeof(S4LONG) ;
longVal = x4reverseLong( (void *)swapPtr ) ;
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
swapPtr += shortVal ;
}
}
#endif
blockOn->fileBlock = lNode ;
blockOn->header.rightNode = rNode ;
blockOn->changed = 1 ;
b4flush( blockOn ) ;
}
if ( rNode != -1L )
{
if ( file4readAll( &i4->file, I4MULTIPLY*rNode, &blockOn->header, B4BLOCK_SIZE) < 0 )
return 0 ;
#ifdef S4BYTE_SWAP
blockOn->header.nodeAttribute = x4reverseShort( (void *)&blockOn->header.nodeAttribute ) ;
blockOn->header.nKeys = x4reverseShort( (void *)&blockOn->header.nKeys ) ;
blockOn->header.leftNode = x4reverseLong( (void *)&blockOn->header.leftNode ) ;
blockOn->header.rightNode = x4reverseLong( (void *)&blockOn->header.rightNode ) ;
/* if block is a leaf */
if (blockOn->header.nodeAttribute >= 2 )
{
blockOn->nodeHdr.freeSpace = x4reverseShort( (void *)&blockOn->nodeHdr.freeSpace ) ;
longVal = x4reverseLong( (void *)blockOn->nodeHdr.recNumMask ) ;
memcpy( (void *)blockOn->nodeHdr.recNumMask, (void *)&longVal, sizeof(long) ) ;
}
else /* if block is a branch */
{
shortVal = blockOn->tag->header.keyLen + sizeof(S4LONG) ;
/* position swapPtr to end of first key expression */
swapPtr = (char *) &blockOn->nodeHdr.freeSpace + blockOn->tag->header.keyLen ;
/* move through all B4KEY's to swap 'long's */
for ( i = 0 ; i < (int) blockOn->header.nKeys ; i++ )
{
longVal = x4reverseLong( (void *)swapPtr ) ;
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
swapPtr += sizeof(S4LONG) ;
longVal = x4reverseLong( (void *)swapPtr ) ;
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
swapPtr += shortVal ;
}
}
#endif
blockOn->fileBlock = rNode ;
blockOn->header.leftNode = lNode ;
blockOn->changed = 1 ;
b4flush( blockOn ) ;
}
return b4free( blockOn ) ;
}
return 0 ;
}
#endif
/* Remove the current key */
int tfile4removeCurrent( TAG4FILE *t4 )
{
B4BLOCK *blockOn ;
INDEX4FILE *i4 ;
#ifdef S4FOX
void *newKeyInfo ;
long rec = 0L ;
int blRemoved, lessThanLast ;
#else
int removeDone, updateReqd ;
B4BLOCK *blockIterate ;
#endif
i4 = t4->indexFile ;
#ifdef S4FOX
i4->tagIndex->header.version = i4->versionOld+1 ;
newKeyInfo = 0 ;
for ( blockOn = (B4BLOCK *)t4->blocks.lastNode ; blockOn ; )
{
blRemoved = 0 ;
if ( newKeyInfo == 0 ) /* then delete entry */
{
if ( b4lastpos( blockOn ) == 0 )
{
if ( blockOn != (B4BLOCK *)l4first( &t4->blocks ) )
blRemoved = 1 ;
tfile4removeBranch( t4, blockOn ) ;
blockOn = (B4BLOCK *)t4->blocks.lastNode ;
}
else
{
lessThanLast = 0 ;
if ( blockOn->keyOn < b4lastpos( blockOn ) )
lessThanLast = 1 ;
b4remove( blockOn ) ;
if ( lessThanLast )
return 0 ;
/* On last entry */
b4goEof( blockOn ) ;
blockOn->keyOn-- ; /* update keyOn for goint to last spot */
newKeyInfo = b4keyKey( blockOn, blockOn->keyOn ) ;
rec = b4recNo( blockOn, blockOn->keyOn ) ;
}
}
else /* Adjust entry */
{
if ( b4brReplace( blockOn, (unsigned char *)newKeyInfo, rec ) < 0 )
return -1 ;
if ( blockOn->keyOn != b4lastpos( blockOn ) ) /* not on end key, so exit, else continue */
return 0 ;
}
if ( !blRemoved )
{
blockOn = (B4BLOCK *)blockOn->link.p ;
if ( blockOn == (B4BLOCK *)t4->blocks.lastNode )
break ;
}
}
#endif
#ifdef S4MDX
removeDone = 0 ;
updateReqd = 0 ;
i4->changed = 1 ;
t4->changed = 1 ;
t4->header.version++ ;
blockIterate = (B4BLOCK *)l4last( &t4->blocks ) ;
for ( ;; )
{
blockOn = blockIterate ;
if ( blockOn == 0 )
break ;
blockIterate = (B4BLOCK *)l4prev( &t4->blocks, blockIterate ) ; /* Calculate the previous block while the current block exists. */
if ( !removeDone ) /* either removing or else updating */
{
if ( b4lastpos( blockOn ) == 0 ) /* delete block */
{
if ( blockOn == (B4BLOCK *)l4first( &t4->blocks ) ) /* root block, don't delete */
{
blockOn->changed = 1 ;
blockOn->keyOn = 0 ;
memset( (void *)&blockOn->nKeys, 0, i4->header.blockRw ) ;
if (t4->filter ) /* must modify the filter setting for dBASE IV compatibility */
{
file4write( &t4->indexFile->file, t4->headerOffset+sizeof(t4->header)+222, (char *)"\0", (int)1 ) ;
t4->hasKeys = 0 ;
#ifdef S4MDX
t4->hadKeys = 1 ;
#endif
}
return 0 ;
}
else
{
l4remove( &t4->blocks, blockOn ) ;
if ( index4shrink( i4, blockOn->fileBlock) < 0 )
return -1 ;
b4free( blockOn ) ;
blockOn = 0 ;
}
}
else /* just remove entry */
{
if ( blockIterate && blockOn->keyOn == b4lastpos( blockOn ) && b4lastpos( blockOn ) > 0 ) /* save to become last key of the block for parent update */
{
memcpy( t4->codeBase->savedKey, b4keyKey( blockOn, blockOn->nKeys - 1 - b4leaf(blockOn) ), t4->header.keyLen ) ;
updateReqd = 1 ;
}
else
updateReqd = 0 ;
b4remove( blockOn ) ;
if ( !b4leaf( blockOn ) && b4lastpos( blockOn ) == 0 ) /* branch with only one entry, so have the entry take place of this block */
{
if (blockOn == (B4BLOCK *)l4first( &t4->blocks ) ) /* the entry becomes the new root */
{
/* first update the tags root */
t4->header.root = b4key( blockOn, 0 )->num ;
#ifdef S4BYTE_SWAP
t4->header.root = x4reverseLong( (void *)&t4->header.root ) ;
#endif
file4write( &t4->indexFile->file, t4->headerOffset, (void *)&t4->header.root, sizeof(t4->header.root) ) ;
#ifdef S4BYTE_SWAP
t4->header.root = x4reverseLong( (void *)&t4->header.root ) ;
#endif
updateReqd = 0 ;
}
else /* remove this branch block */
{
blockIterate->changed = 1 ;
b4key( blockIterate, blockIterate->keyOn )->num = b4key( blockOn, 0 )->num ;
}
l4remove( &t4->blocks, blockOn ) ;
if ( index4shrink( t4->indexFile, blockOn->fileBlock) < 0 )
return -1 ;
blockOn->changed = 0 ;
b4free( blockOn ) ;
blockOn = 0 ;
}
else
blockOn->keyOn = b4lastpos( blockOn ) ;
if ( !updateReqd )
return 0 ;
removeDone = 1 ;
}
}
else /* Adjust entry - at most one update will be required in MDX */
{
if ( blockOn->keyOn < b4lastpos( blockOn ) )
{
blockOn->changed = 1 ;
memcpy( b4keyKey( blockOn, blockOn->keyOn), t4->codeBase->savedKey, t4->header.keyLen ) ;
return 0 ;
}
}
}
#endif
return 0 ;
}
#endif /* ifndef N4OTHER */
#ifdef S4CLIPPER
int tfile4balanceBranch( TAG4FILE *, B4BLOCK * ) ;
static int tfile4removeRef( TAG4FILE *t4 )
{
B4KEY_DATA *myKeyData ;
B4BLOCK *blockOn, *blockUp, *neighborBlock ;
long reference, neighborRef ;
int i, rc ;
blockOn = (B4BLOCK *)t4->blocks.lastNode ;
tfile4up( t4 ) ;
blockUp = (B4BLOCK *)t4->blocks.lastNode ;
if ( blockUp == 0 ) /* root block only, so reference doesn't exist */
{
/* reset the block */
short offset = ( t4->header.keysMax + 2 + ( (t4->header.keysMax/2)*2 != t4->header.keysMax ) ) * sizeof(short) ;
for ( i = 0 ; i <= t4->header.keysMax ; i++ )
blockOn->pointers[i] = (short)( t4->header.groupLen * i ) + offset ;
return 0 ;
}
else /* delete the block */
{
tfile4shrink( t4, blockOn->fileBlock ) ;
l4pop( &t4->saved ) ;
blockOn->changed = 0 ;
b4free( blockOn ) ;
blockOn = 0 ;
}
blockOn = blockUp ;
myKeyData = (B4KEY_DATA *)u4allocEr( t4->codeBase, t4->header.groupLen ) ;
if ( myKeyData == 0 )
return e4memory ;
if ( blockOn->keyOn >= blockOn->nKeys )
memcpy( &(myKeyData->num), &( b4key( blockOn, blockOn->keyOn - 1 )->num), sizeof(long) + t4->header.keyLen ) ;
else
memcpy( &(myKeyData->num), &( b4key( blockOn, blockOn->keyOn )->num), sizeof(long) + t4->header.keyLen ) ;
if ( blockOn->nKeys == 1 )
{
/* take the branch, and put in place of me, then delete and add me */
if ( blockOn->keyOn >= blockOn->nKeys )
reference = (long)b4key( blockOn, 0 )->pointer ;
else
reference = (long)b4key( blockOn, 1 )->pointer ;
b4remove( blockOn ) ;
if ( t4->blocks.nLink == 1 ) /* root block, so reference will take over */
{
tfile4shrink( t4, blockOn->fileBlock ) ;
tfile4up( t4 ) ;
l4pop(&t4->saved ) ;
blockOn->changed = 0 ;
b4free( blockOn ) ;
blockOn = (B4BLOCK *)t4->blocks.lastNode ;
t4->header.root = reference ;
}
else /* special case -- blocks contain very large keys. try balancing */
{
tfile4up( t4 ) ;
blockUp = (B4BLOCK *)t4->blocks.lastNode ;
if ( blockUp->keyOn == 0 )
{
/* move one right neighbour into left */
neighborRef = (long)b4key( blockUp, 1 )->pointer ;
neighborBlock = b4alloc( t4, neighborRef ) ;
if ( neighborBlock == 0 )
{
u4free( myKeyData ) ;
return e4memory ;
}
if ( i4readBlock( &t4->file, neighborRef, 0, neighborBlock ) < 0 )
{
b4free( neighborBlock ) ;
neighborBlock = 0 ;
u4free( myKeyData ) ;
return -1 ;
}
if ( neighborBlock->nKeys == t4->header.keysMax ) /* already maxed out, must shift */
{
/* borrow for the current block */
reference = b4key( blockOn, 0 )->pointer ;
blockOn->keyOn = 0 ;
b4insert( blockOn, b4keyKey( blockUp, 0 ), b4recNo( blockUp, 0 ), reference / 512 ) ;
memcpy( b4keyKey( blockUp, 0 ), b4keyKey( neighborBlock, 0 ), t4->header.keyLen ) ;
b4key( blockUp, 0 )->num = b4key( neighborBlock, 0 )->num ;
b4key( blockOn, 1 )->pointer = b4key( neighborBlock, 0 )->pointer ;
neighborBlock->keyOn = 0 ;
b4remove( neighborBlock ) ;
blockUp->changed = 1 ;
blockOn->changed = 1 ;
neighborBlock->changed = 1 ;
b4flush( neighborBlock ) ;
b4free( neighborBlock ) ;
neighborBlock = 0 ;
}
else
{
/* move current reference over, and delete from parent */
neighborBlock->keyOn = 0 ;
b4insert( neighborBlock, b4keyKey( blockUp, blockUp->keyOn ), b4key( blockUp, blockUp->keyOn )->num, b4key( blockOn, 0 )->pointer / 512 ) ;
b4remove( blockUp ) ;
#ifdef E4INDEX_VERIFY
if ( (B4BLOCK *)t4->saved.lastNode != blockOn )
return error4( t4->codeBase, e4index, E81601 ) ;
#endif
l4pop( &t4->saved ) ;
blockOn->changed = 0 ;
tfile4shrink( t4, blockOn->fileBlock ) ;
b4free( blockOn ) ;
blockOn = 0 ;
blockUp->changed = 1 ;
neighborBlock->changed = 1 ;
/* now check that parent is still valid */
if ( blockUp->nKeys == 0 ) /* just removed last entry... */
{
if ( t4->header.root == blockUp->fileBlock * 512 )
{
tfile4shrink( t4, blockUp->fileBlock ) ;
l4pop(&t4->blocks ) ; /* remov ourselves */
reference = (long)b4key( blockUp, 0 )->pointer ;
blockUp->changed = 0 ;
b4free( blockUp ) ;
blockOn = 0 ;
l4add( &t4->blocks, neighborBlock ) ;
t4->header.root = reference ;
}
else
{
b4flush( neighborBlock ) ;
b4free( neighborBlock ) ;
neighborBlock = 0 ;
tfile4balanceBranch( t4, blockUp ) ;
}
}
else /* save and free */
{
b4flush( neighborBlock ) ;
b4free( neighborBlock ) ;
neighborBlock = 0 ;
}
}
}
else
{
/* move to left neighbor */
neighborRef = (long)b4key( blockUp, blockUp->keyOn - 1 )->pointer ;
neighborBlock = b4alloc( t4, neighborRef ) ;
if ( neighborBlock == 0 )
{
u4free( myKeyData ) ;
return e4memory ;
}
if ( i4readBlock( &t4->file, neighborRef, 0, neighborBlock ) < 0 )
{
b4free( neighborBlock ) ;
neighborBlock = 0 ;
u4free( myKeyData ) ;
return -1 ;
}
if ( neighborBlock->nKeys == t4->header.keysMax ) /* already maxed out */
{
/* borrow for the current block */
blockOn->keyOn = 0 ;
reference = b4key( blockOn, 0 )->pointer ;
b4insert( blockOn, b4keyKey( blockUp, blockUp->keyOn - 1 ), b4key( blockUp, blockUp->keyOn - 1 )->num, b4key( neighborBlock, neighborBlock->nKeys )->pointer / 512 ) ;
memcpy( b4keyKey( blockUp, blockUp->keyOn - 1 ), b4keyKey( neighborBlock, neighborBlock->nKeys - 1 ), t4->header.keyLen ) ;
b4key( blockUp, blockUp->keyOn - 1 )->num = b4key( neighborBlock, neighborBlock->nKeys - 1 )->num ;
b4key( blockOn, 1 )->pointer = reference ;
neighborBlock->nKeys-- ;
blockUp->changed = 1 ;
blockOn->changed = 1 ;
neighborBlock->changed = 1 ;
b4flush( neighborBlock ) ;
b4free( neighborBlock ) ;
neighborBlock = 0 ;
}
else
{
/* move current reference over, and delete from parent */
neighborBlock->keyOn = neighborBlock->nKeys ;
/* just re-insert the last key, then change the values */
b4insert( neighborBlock, b4keyKey( neighborBlock, neighborBlock->keyOn - 1 ),
b4key( neighborBlock, neighborBlock->keyOn - 1 )->num,
b4key( neighborBlock, neighborBlock->keyOn )->pointer / 512 ) ;
memcpy( b4keyKey( neighborBlock, neighborBlock->nKeys - 1 ), b4keyKey( blockUp, blockUp->keyOn - 1 ), t4->header.keyLen ) ;
b4key( neighborBlock, neighborBlock->nKeys - 1 )->num = b4key( blockUp, blockUp->keyOn - 1 )->num ;
b4key( neighborBlock, neighborBlock->nKeys )->pointer = b4key( blockOn, 0 )->pointer ;
#ifdef E4INDEX_VERIFY
if ( (B4BLOCK *)t4->saved.lastNode != blockOn )
return error4( t4->codeBase, e4index, E81601 ) ;
#endif
l4pop( &t4->saved ) ;
blockOn->changed = 0 ;
tfile4shrink( t4, blockOn->fileBlock ) ;
b4free( blockOn ) ;
blockOn = 0 ;
b4key( blockUp, blockUp->keyOn )->pointer = b4key( blockUp, blockUp->keyOn - 1 )->pointer ;
blockUp->keyOn-- ;
b4remove( blockUp ) ;
blockUp->changed = 1 ;
neighborBlock->changed = 1 ;
/* now check that parent is still valid */
if ( blockUp->nKeys == 0 ) /* just removed last entry... */
{
if ( t4->header.root == blockUp->fileBlock * 512 )
{
reference = (long)b4key( blockUp, 0 )->pointer ;
tfile4shrink( t4, blockUp->fileBlock ) ;
l4pop(&t4->blocks ) ; /* remov ourselves */
blockUp->changed = 0 ;
b4free( blockUp ) ;
blockUp = 0 ;
l4add( &t4->blocks, neighborBlock ) ;
t4->header.root = reference ;
}
else
{
b4flush( neighborBlock ) ;
b4free( neighborBlock ) ;
neighborBlock = 0 ;
tfile4balanceBranch( t4, blockUp ) ;
}
}
else /* save and free */
{
b4flush( neighborBlock ) ;
b4free( neighborBlock ) ;
neighborBlock = 0 ;
}
}
}
}
}
else /* just remove myself, add later */
{
b4remove( blockOn ) ;
if ( blockOn->nKeys < t4->header.keysHalf && blockOn->fileBlock != t4->header.root ) /* if not root may have to balance the tree */
{
if ( tfile4balanceBranch( t4, blockOn ) < 0 )
{
u4free( myKeyData ) ;
return -1 ;
}
}
}
/* now add the removed reference back into the index */
rc = tfile4add( t4, (unsigned char *)myKeyData->value, myKeyData->num, 0 ) ;
u4free( myKeyData ) ;
return rc ;
}
static int tfile4balanceBlock( TAG4FILE *t4, B4BLOCK *parent, B4BLOCK *b4, B4BLOCK *b4temp, char isRight, char balanceMode )
{
B4KEY_DATA *bdata, *bdata2 ;
int avg, i ;
long tempFb, reference ;
if ( balanceMode == 2 && b4leaf( b4temp ) )
return error4( t4->codeBase, e4index, E81601 ) ;
else
{
if ( b4temp->nKeys + b4->nKeys < t4->header.keysMax )
{
if ( isRight )
{
if ( balanceMode == 2 )
{
b4->keyOn = 0 ;
parent->keyOn-- ;
bdata = b4key( parent, parent->keyOn ) ;
if ( b4->keyOn == 0 && b4->nKeys == 0 ) /* must do reference as well */
{
reference = b4key( b4, 0 )->pointer ;
b4insert( b4, bdata->value, bdata->num, b4key( b4temp, b4temp->nKeys )->pointer / 512 ) ;
b4key( b4, 1 ) ->pointer = reference ;
}
else
b4insert( b4, bdata->value, bdata->num, b4key( b4temp, b4temp->nKeys )->pointer / 512 ) ;
for ( i = b4temp->nKeys - 1 ; i >= 0 ; i-- )
{
b4->keyOn = 0 ;
bdata = b4key( b4temp, i ) ;
b4insert( b4, bdata->value, bdata->num, bdata->pointer / 512 ) ;
}
b4temp->changed = 0 ;
tfile4shrink( t4, b4temp->fileBlock ) ;
b4remove( parent ) ;
if ( parent->nKeys < t4->header.keysHalf )
tfile4balanceBranch( t4, parent ) ;
}
else
{
for ( i = 0 ; i < b4->nKeys ; i++ )
{
b4goEof( b4temp ) ;
bdata = b4key( b4, i ) ;
b4insert( b4temp, bdata->value, bdata->num, 0L ) ;
}
t4->codeBase->doIndexVerify = 0 ; /* avoid verify errors due to our partial removal */
do
{
tfile4down( t4 ) ;
if ( t4->blocks.lastNode == 0 )
break ;
} while( !b4leaf( (B4BLOCK *)t4->blocks.lastNode ) ) ; /* don't use tfile4block() due to borland problems */
t4->codeBase->doIndexVerify = 1 ;
b4flush( b4temp ) ;
if ( tfile4removeRef( t4 ) != 0 ) /* will delete b4 and will remove and re-add the reference if required */
return -1 ;
}
}
else
{
/* put parent entry, then all but one child, then last child to parent */
b4goEof( b4 ) ;
if ( balanceMode == 2 )
{
b4temp->keyOn = 0 ;
bdata = b4key( parent, parent->keyOn ) ;
b4insert( b4temp, bdata->value, bdata->num, b4key( b4, b4->nKeys )->pointer / 512 ) ;
for ( i = b4->nKeys - 1 ; i >= 0 ; i-- )
{
b4temp->keyOn = 0 ;
bdata = b4key( b4, i ) ;
b4insert( b4temp, bdata->value, bdata->num, bdata->pointer / 512 ) ;
}
tfile4shrink( t4, b4->fileBlock ) ;
l4pop( &t4->saved ) ;
b4->changed = 0 ;
b4free( b4 ) ;
b4 = 0 ;
b4flush( b4temp ) ;
b4remove( parent ) ;
if ( parent->nKeys < t4->header.keysHalf )
tfile4balanceBranch( t4, parent ) ;
}
else
{
bdata = b4key( parent, parent->keyOn ) ;
if ( b4->keyOn == 0 && b4->nKeys == 0 ) /* must do reference as well */
{
reference = b4key( b4, 0 )->pointer ;
b4insert( b4, bdata->value, bdata->num, 0L ) ;
b4key( b4, 1 ) ->pointer = reference ;
}
else
b4insert( b4, bdata->value, bdata->num, 0L ) ;
for ( i = 0 ; i < b4temp->nKeys - 1 ; i++ )
{
b4goEof( b4 ) ;
bdata = b4key( b4temp, i ) ;
b4insert( b4, bdata->value, bdata->num, 0L ) ;
}
bdata = b4key( parent, parent->keyOn ) ;
bdata2 = b4key( b4temp, b4temp->nKeys - 1 ) ;
memcpy( bdata->value, bdata2->value, t4->header.keyLen ) ;
memcpy( &( bdata->num ), &bdata2->num, sizeof( long ) ) ;
parent->keyOn++ ;
parent->changed = 1 ;
t4->codeBase->doIndexVerify = 0 ; /* avoid verify errors due to our partial removal */
b4flush( b4 ) ;
do
{
if ( tfile4down( t4 ) == 1 )
break ;
} while( ((B4BLOCK *)t4->blocks.lastNode)->fileBlock != b4temp->fileBlock ) ;
t4->codeBase->doIndexVerify = 1 ;
if ( tfile4removeRef( t4 ) != 0 ) /* will delete b4temp and will remove and re-add the reference if required */
return -1 ;
b4temp->changed = 0 ;
}
}
}
else /* will have to redistribute keys */
{
avg = ( b4->nKeys + b4temp->nKeys + 1 ) / 2 ;
if ( avg < t4->header.keysHalf )
avg = t4->header.keysHalf ;
if ( isRight )
{
b4->keyOn = 0 ;
parent->keyOn-- ;
bdata = b4key( parent, parent->keyOn ) ;
if ( balanceMode == 2 )
{
if ( b4->nKeys == 0 )
{
tempFb = b4key( b4, 0 )->pointer ;
b4insert( b4, bdata->value, bdata->num, b4key( b4temp, b4temp->nKeys )->pointer / 512 ) ;
b4append( b4, tempFb / 512 ) ;
}
else
b4insert( b4, bdata->value, bdata->num, b4key( b4temp, b4temp->nKeys )->pointer / 512 ) ;
}
else
b4insert( b4, bdata->value, bdata->num, 0L ) ;
while ( b4temp->nKeys > avg && b4->nKeys < avg )
{
b4->keyOn = 0 ;
b4temp->keyOn = b4temp->nKeys - 1 ;
bdata = b4key( b4temp, b4temp->keyOn ) ;
if ( balanceMode == 2 )
b4insert( b4, bdata->value, bdata->num, bdata->pointer / 512 ) ;
else
b4insert( b4, bdata->value, bdata->num, 0L ) ;
b4remove( b4temp ) ;
}
b4temp->keyOn = b4temp->nKeys - 1 ;
}
else
{
b4goEof( b4 ) ;
if ( balanceMode == 2 )
{
bdata = b4key( b4, b4->nKeys ) ;
bdata2 = b4key( parent, parent->keyOn ) ;
memcpy( bdata->value, bdata2->value, t4->header.keyLen ) ;
memcpy( &(bdata->num), &bdata2->num, sizeof( long ) ) ;
b4->nKeys++ ;
}
else
{
bdata = b4key( parent, parent->keyOn ) ;
b4insert( b4, bdata->value, bdata->num, 0L ) ;
}
while ( b4->nKeys - (balanceMode == 2) < avg )
{
b4goEof( b4 ) ;
b4temp->keyOn = 0 ;
bdata = b4key( b4temp, b4temp->keyOn ) ;
if ( balanceMode == 2 )
b4insert( b4, bdata->value, bdata->num, bdata->pointer / 512 ) ;
else
b4insert( b4, bdata->value, bdata->num, 0L ) ;
b4remove( b4temp ) ;
}
if ( balanceMode == 2 )
{
b4->nKeys-- ;
b4->keyOn-- ;
}
b4temp->keyOn = 0 ;
}
/* and add a key back to the parent */
bdata = b4key( parent, parent->keyOn ) ;
if ( balanceMode == 2 )
{
if ( isRight )
bdata2 = b4key( b4temp, b4temp->nKeys - 1 ) ;
else
bdata2 = b4key( b4, b4->nKeys ) ;
memcpy( bdata->value, bdata2->value, t4->header.keyLen ) ;
memcpy( &(bdata->num), &bdata2->num, sizeof( long ) ) ;
if ( isRight )
{
b4temp->keyOn = b4temp->nKeys ;
b4remove( b4temp ) ;
}
}
else
{
bdata2 = b4key( b4temp, b4temp->keyOn ) ;
memcpy( bdata->value, bdata2->value, t4->header.keyLen ) ;
memcpy( &(bdata->num), &bdata2->num, sizeof( long ) ) ;
b4remove( b4temp ) ;
}
parent->changed = 1 ;
b4flush( b4temp ) ;
}
}
return 0 ;
}
static int tfile4balanceBranchLeaf( TAG4FILE *t4, B4BLOCK *parent, B4BLOCK *branch, B4BLOCK *leaf )
{
B4BLOCK *b4temp ;
long newFileBlock ;
B4KEY_DATA *key ;
t4->header.version++ ;
newFileBlock = tfile4extend( t4 ) ;
b4temp = b4alloc( t4, newFileBlock ) ;
if ( b4temp == 0 )
return -1 ;
key = b4key( b4temp, 0 ) ;
key->pointer = leaf->fileBlock * I4MULTIPLY ;
b4temp->changed = 1 ;
key = b4key( parent, parent->keyOn ) ;
#ifdef E4ANALYZE_ALL
if ( key->pointer != leaf->fileBlock * I4MULTIPLY )
return error4( t4->codeBase, e4index, E95407 ) ;
#endif
key->pointer = newFileBlock * I4MULTIPLY ;
parent->changed = 1 ;
l4add( &t4->blocks, b4temp ) ;
return tfile4balanceBlock( t4, parent, b4temp, branch, 1, 2 ) ;
}
/* if doFull is true, the whole branch set will be balanced, not just the current leaf block and reqd. Also, this will balance top down instead of the other way. */
int tfile4balance( TAG4FILE *t4, B4BLOCK *b4, int doFull )
{
B4BLOCK *b4temp, *parent ;
long tempFb ;
int rc, noKeys, doRightSpecial ;
char isRight, balanceMode ; /* balanceMode = 0 for done, 1 for leaf, and 2 for branch */
B4KEY_DATA *myKeyData ;
if ( !b4leaf( b4 ) )
return 0 ;
b4temp = b4alloc( t4, 0L ) ;
if ( b4temp == 0 )
return -1 ;
if ( doFull )
{
tfile4upToRoot( t4 ) ;
balanceMode = 2 ; /* branch */
}
else
balanceMode = 1 ; /* leaf */
noKeys = 0 ;
while ( balanceMode != 0 || doFull )
{
if ( doFull )
{
parent = (B4BLOCK *)t4->blocks.lastNode ;
if ( noKeys == 0 )
parent->keyOn = parent->nKeys ;
rc = tfile4down( t4 ) ;
if ( rc == 1 ) /* make sure siblings are also leafs */
{
tfile4up( t4 ) ;
parent = (B4BLOCK *)t4->blocks.lastNode ;
if ( parent != 0 )
{
if ( parent->keyOn > 0 )
{
tempFb = (long)b4key( parent, parent->keyOn - 1 )->pointer ;
if ( i4readBlock( &t4->file, tempFb, 0, b4temp ) < 0 )
{
b4free( b4temp ) ;
return -1 ;
}
if ( b4leaf( b4temp ) == 0 && b4leaf( b4 ) == 1 )
{
rc = tfile4balanceBranchLeaf( t4, parent, b4temp, b4 ) ;
b4free( b4temp ) ;
return rc ;
}
}
}
break ;
}
else
if ( noKeys == 1 ) /* need to check the siblings to make sure also branches */
{
tfile4up( t4 ) ;
parent = (B4BLOCK *)t4->blocks.lastNode ;
if ( parent != 0 )
{
if ( parent->keyOn > 0 )
{
tempFb = (long)b4key( parent, parent->keyOn - 1 )->pointer ;
if ( i4readBlock( &t4->file, tempFb, 0, b4temp ) < 0 )
{
b4free( b4temp ) ;
return -1 ;
}
if ( b4leaf( b4temp ) == 0 && b4leaf( b4 ) == 1 )
{
rc = tfile4balanceBranchLeaf( t4, parent, b4temp, b4 ) ;
b4free( b4temp ) ;
return rc ;
}
if ( b4leaf( b4temp ) == 1 && b4leaf( b4 ) == 0 )
{
rc = tfile4balanceBranchLeaf( t4, parent, b4, b4temp ) ;
b4free( b4temp ) ;
return rc ;
}
}
else
{
parent->keyOn = 0 ;
tempFb = (long)b4key( parent, parent->keyOn + 1 )->pointer ;
if ( i4readBlock( &t4->file, tempFb, 0, b4temp ) < 0 )
{
b4free( b4temp ) ;
return -1 ;
}
if ( b4leaf( b4temp ) == 0 && b4leaf( b4 ) == 1 )
{
rc = tfile4balanceBranchLeaf( t4, parent, b4temp, b4 ) ;
b4free( b4temp ) ;
return rc ;
}
if ( b4leaf( b4temp ) == 1 && b4leaf( b4 ) == 0 )
{
rc = tfile4balanceBranchLeaf( t4, parent, b4, b4temp ) ;
b4free( b4temp ) ;
return rc ;
}
}
}
if ( b4leaf( b4 ) )
break ;
tfile4down( t4 ) ;
tfile4down( t4 ) ;
b4 = (B4BLOCK *)t4->blocks.lastNode ;
tfile4up( t4 ) ;
continue ;
}
if ( rc < 0 )
return -1 ;
b4 = (B4BLOCK *)t4->blocks.lastNode ;
b4->keyOn = b4->nKeys ;
if ( b4->nKeys >= t4->header.keysHalf )
continue ;
if ( b4leaf( b4 ) )
balanceMode = 1 ;
tempFb = b4key( parent, parent->keyOn - 1 )->pointer ;
isRight = 1 ;
}
else
{
if ( balanceMode == 2 ) /* branch */
{
b4 = parent ;
while( t4->blocks.lastNode != (LINK4 *)b4 ) /* re-align ourselves */
tfile4up( t4 ) ;
}
tfile4up( t4 ) ;
parent = (B4BLOCK *)t4->blocks.lastNode ;
if ( parent == 0 ) /* root block */
{
tfile4down( t4 ) ;
parent = (B4BLOCK *)t4->blocks.lastNode ;
if ( !b4leaf( parent ) && parent->nKeys == 0 ) /* remove */
{
tempFb = (long)b4key( parent, 0 )->pointer ;
tfile4shrink( t4, parent->fileBlock ) ;
tfile4up( t4 ) ;
l4pop( &t4->saved ) ;
parent->changed = 0 ;
b4free( parent ) ;
parent = 0 ;
t4->header.root = tempFb ;
tfile4down( t4 ) ;
}
break ;
}
if ( parent->nKeys == 0 ) /* try to replace parent with ourself */
return error4describe( t4->codeBase, e4index, E81601, tfile4alias( t4 ), 0, 0 ) ;
if ( b4->nKeys >= t4->header.keysHalf )
{
balanceMode = 0 ;
continue ;
}
isRight = (parent->keyOn == parent->nKeys ) ;
if ( isRight )
tempFb = b4key( parent, parent->keyOn - 1 )->pointer ;
else
tempFb = b4key( parent, parent->keyOn + 1 )->pointer ;
}
b4temp->fileBlock = tempFb ;
for ( ;; )
{
if ( i4readBlock( &t4->file, tempFb, 0, b4temp ) < 0 )
{
b4free( b4temp ) ;
return -1 ;
}
if ( balanceMode == 2 || b4leaf( b4temp ) ) /* if branch mode or leaf mode and leaf block found */
break ;
if ( isRight )
tempFb = b4key( b4temp, b4temp->nKeys )->pointer ;
else
tempFb = b4key( b4temp, 0 )->pointer ;
}
/* save a key position for after-seek */
myKeyData = (B4KEY_DATA *)u4allocEr( t4->codeBase, t4->header.groupLen ) ;
if ( myKeyData == 0 )
return e4memory ;
doRightSpecial = 0 ;
if ( b4->nKeys == 0 ) /* can't do a seek on, so after just go to far left */
{
noKeys = 1 ;
if ( isRight == 1 && parent != 0 ) /* get parents key, since performing a right-op */
{
memcpy( &(myKeyData->num), &( b4key( parent, parent->nKeys - 1 )->num), sizeof(long) + t4->header.keyLen ) ;
doRightSpecial = 1 ;
}
else
memcpy( &(myKeyData->num), &( b4key( b4temp, 0 )->num), sizeof(long) + t4->header.keyLen ) ;
}
else
{
noKeys = 0 ;
if ( b4->keyOn > 0 )
memcpy( &(myKeyData->num), &( b4key( b4, 0 )->num), sizeof(long) + t4->header.keyLen ) ;
else
memcpy( &(myKeyData->num), &( b4key( b4, 1 )->num), sizeof(long) + t4->header.keyLen ) ;
}
if ( tfile4balanceBlock( t4, parent, b4, b4temp, isRight, balanceMode ) < 0 )
{
u4free( myKeyData ) ;
return -1 ;
}
/* need to re-find position */
rc = tfile4go( t4, myKeyData->value, myKeyData->num, 0 ) ; /* returns -1 if error4code( codeBase ) < 0 */
if ( noKeys == 1 ) /* can't find position, so just go to far left */
{
for ( ;; )
{
b4 = tfile4block( t4 ) ;
if ( b4->nKeys < t4->header.keysHalf || b4leaf( b4 ) )
{
if ( doRightSpecial == 1 ) /* in this case, don't reset position, just go up */
while ( tfile4up( t4 ) != 1 ) ;
else
tfile4upToRoot( t4 ) ;
balanceMode = 2 ;
doFull = 1 ;
break ;
}
if ( doRightSpecial == 1 )
{
b4->keyOn = b4->nKeys ;
tfile4down( t4 ) ;
}
else
if ( tfile4skip( t4, 1L ) != 1L )
break ;
}
}
b4 = tfile4block( t4 ) ;
u4free( myKeyData ) ;
if ( rc < 0 )
return rc ;
if ( b4 == 0 ) /* in theory should never happen, but would maybe mean done */
return 0 ;
parent = (B4BLOCK *)b4->link.p ;
if ( parent == 0 || b4leaf( parent ) ) /* no parent */
break ;
if ( parent == b4 ) /* move down one to avoid problems (b4 should never be root) */
{
if ( tfile4down( t4 ) == 0 )
{
b4 = (B4BLOCK *)t4->blocks.lastNode ;
tfile4up( t4 ) ;
}
}
if ( balanceMode != 2 || noKeys != 1 )
{
if ( doFull )
{
if ( b4leaf( b4 ) )
balanceMode = 0 ;
}
else
{
if ( parent->nKeys < t4->header.keysHalf ) /* do parent as well */
balanceMode = 2 ;
else
balanceMode = 0 ;
}
}
}
b4free( b4temp ) ;
return 0 ;
}
int tfile4getReplaceEntry( TAG4FILE *t4, B4KEY_DATA *insertSpot, B4BLOCK *saveBlock )
{
int rc ;
B4BLOCK *blockOn ;
blockOn = saveBlock ;
if ( b4leaf( blockOn ) )
return 0 ;
blockOn->keyOn = blockOn->keyOn + 1 ;
while ( !b4leaf( blockOn ) )
{
rc = tfile4down( t4 ) ;
if ( rc < 0 || rc == 2 )
return -1 ;
blockOn = (B4BLOCK *)t4->blocks.lastNode ;
}
memcpy( &insertSpot->num, &(b4key( blockOn, blockOn->keyOn )->num), sizeof(long) + t4->header.keyLen ) ;
saveBlock->changed = 1 ;
b4remove( blockOn ) ;
if ( blockOn->nKeys < t4->header.keysHalf && blockOn->fileBlock != t4->header.root ) /* if not root may have to balance the tree */
if ( tfile4balance( t4, blockOn, 0 ) < 0 )
return -1 ;
return 1 ;
}
int tfile4balanceBranch( TAG4FILE *t4, B4BLOCK *b4 )
{
B4BLOCK *parent, *b4temp ;
int rc ;
char isRight ;
long tempFb, reference ;
#ifdef E4ANALYZE
if ( b4leaf( b4 ) )
return error4describe( t4->codeBase, e4index, E95406, tfile4alias( t4 ), 0, 0 ) ;
#endif
if ( b4 == (B4BLOCK *)l4first( &t4->blocks ) )
{
if ( b4->nKeys == 0 ) /* empty, so just remove */
{
reference = (long)b4key( b4, 0 )->pointer ;
b4->changed = 0 ;
tfile4shrink( t4, b4->fileBlock ) ;
tfile4up( t4 ) ;
l4pop(&t4->saved ) ;
b4free( b4 ) ;
b4 = 0 ;
t4->header.root = reference ;
}
return 0 ;
}
tfile4up( t4 ) ;
parent = (B4BLOCK *)t4->blocks.lastNode ;
#ifdef E4ANALYZE
if ( b4key( parent, parent->keyOn )->pointer != I4MULTIPLY * b4->fileBlock )
return error4describe( t4->codeBase, e4index, E95406, tfile4alias( t4 ), 0, 0 ) ;
#endif
if ( parent->keyOn == parent->nKeys )
{
tempFb = b4key( parent, parent->keyOn - 1 )->pointer ;
isRight = 1 ;
}
else
{
tempFb = b4key( parent, parent->keyOn + 1 )->pointer ;
isRight = 0 ;
}
b4temp = b4alloc( t4, 0L ) ;
if ( b4temp == 0 )
return error4stack( t4->codeBase, e4memory, E95406 ) ;
rc = i4readBlock( &t4->file, tempFb, 0, b4temp ) ;
if ( rc < 0 )
{
b4free( b4temp ) ;
return error4stack( t4->codeBase, rc, E95406 ) ;
}
rc = tfile4balanceBlock( t4, parent, b4, b4temp, isRight, 2 ) ;
b4free( b4temp ) ;
if ( rc < 0 )
return error4stack( t4->codeBase, rc, E95406 ) ;
return 0 ;
}
int tfile4removeCurrent( TAG4FILE *t4 )
{
B4BLOCK *blockOn ;
t4->header.version = (short)( t4->header.oldVersion + 1L ) ;
blockOn = (B4BLOCK *)t4->blocks.lastNode ;
#ifdef E4ANALYZE
if ( b4lastpos( blockOn ) == -b4leaf( blockOn ) )
return error4describe( t4->codeBase, e4index, E85401, tfile4alias( t4 ), 0, 0 ) ;
#endif
switch( tfile4getReplaceEntry( t4, b4key( blockOn, blockOn->keyOn ), blockOn ) )
{
case 0 : /* leaf delete */
b4remove( blockOn ) ;
if ( blockOn->nKeys == 0 ) /* last entry deleted! -- remove upward reference */
{
if ( tfile4removeRef( t4 ) != 0 )
return -1 ;
}
else
{
if ( blockOn->nKeys < t4->header.keysHalf && blockOn->fileBlock != t4->header.root ) /* if not root may have to balance the tree */
return tfile4balance( t4, blockOn, 0 ) ;
}
break ;
case 1 : /* branch delete */
if( tfile4block( t4 )->nKeys == 0 ) /* removed the last key of */
if ( tfile4removeRef( t4 ) != 0 )
return -1 ;
break ;
default:
return error4describe( t4->codeBase, e4index, E81601, tfile4alias( t4 ), 0, 0 ) ;
}
return 0 ;
}
#endif /* S4CLIPPER */
#endif /* S4INDEX_OFF */
#endif /* S4OFF_WRITE */
#endif