2431 lines
67 KiB
C
Executable File
2431 lines
67 KiB
C
Executable File
/* b4block.c (c)Copyright Sequiter Software Inc., 1988-1996. All rights reserved. */
|
|
|
|
#include "d4all.h"
|
|
#ifdef __TURBOC__
|
|
#pragma hdrstop
|
|
#endif /* __TURBOC__ */
|
|
|
|
short S4FUNCTION x4reverseShort( const void *val )
|
|
{
|
|
unsigned char out[2] ;
|
|
const unsigned char *atVal ;
|
|
|
|
atVal = (const unsigned char *)val ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( val == 0 )
|
|
{
|
|
error4( 0, e4parm, E90439 ) ;
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
|
|
out[0] = atVal[1] ;
|
|
out[1] = atVal[0] ;
|
|
|
|
return (*(short *)out ) ;
|
|
}
|
|
|
|
S4LONG x4reverseLong( const void *val )
|
|
{
|
|
unsigned char out[4] ;
|
|
|
|
unsigned const char *atVal ;
|
|
atVal = (const unsigned char *)val ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( val == 0 )
|
|
{
|
|
error4( 0, e4parm, E90439 ) ;
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
|
|
#ifdef S4BYTEORDER_2301
|
|
out[0] = atVal[2] ;
|
|
out[1] = atVal[3] ;
|
|
out[2] = atVal[0] ;
|
|
out[3] = atVal[1] ;
|
|
#else
|
|
out[0] = atVal[3] ;
|
|
out[1] = atVal[2] ;
|
|
out[2] = atVal[1] ;
|
|
out[3] = atVal[0] ;
|
|
#endif
|
|
|
|
return *(S4LONG *)out ;
|
|
}
|
|
|
|
#ifndef S4CLIENT
|
|
int b4calcBlanks( const unsigned char *keyVal, const int len, const unsigned char pChar )
|
|
{
|
|
int a ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( keyVal == 0 || len < 0 )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
for ( a = len ; a > 0; a-- )
|
|
if ( keyVal[a-1] != pChar )
|
|
return ( len - a ) ;
|
|
return len ; /* all blanks */
|
|
}
|
|
#endif /* S4CLIENT */
|
|
|
|
#ifndef S4INDEX_OFF
|
|
#ifndef S4CLIENT
|
|
|
|
B4BLOCK *b4alloc( TAG4FILE *t4, const long fb )
|
|
{
|
|
B4BLOCK *b4 ;
|
|
#ifdef S4CLIPPER
|
|
short offset ;
|
|
int i ;
|
|
#endif /* S4CLIPPER */
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( t4 == 0 )
|
|
{
|
|
error4( 0, e4parm, E90438 ) ;
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
|
|
#ifdef S4CLIPPER
|
|
b4 = (B4BLOCK *)mem4alloc2( t4->blockMemory, t4->codeBase ) ;
|
|
#else
|
|
b4 = (B4BLOCK *)mem4alloc2( t4->indexFile->blockMemory, t4->codeBase ) ;
|
|
#endif
|
|
if ( b4 == 0 )
|
|
{
|
|
error4( t4->codeBase, e4memory, E90438 ) ;
|
|
return 0 ;
|
|
}
|
|
|
|
b4->tag = t4 ;
|
|
b4->fileBlock = fb ;
|
|
|
|
#ifdef S4CLIPPER
|
|
offset = ( b4->tag->header.keysMax + 2 +
|
|
(( b4->tag->header.keysMax / 2) * 2 != b4->tag->header.keysMax ) )
|
|
* sizeof(short) ;
|
|
for ( i = 0 ; i <= b4->tag->header.keysMax ; i++ )
|
|
b4->pointers[i] = (short)(( b4->tag->header.groupLen * i )) + offset ;
|
|
b4->data = (B4KEY_DATA *) ((char *)&b4->nKeys + b4->pointers[0]) ; /* first entry */
|
|
#endif /* S4CLIPPER */
|
|
|
|
#ifdef S4FOX
|
|
/* b4->builtKey = (B4KEY_DATA *)u4allocEr( t4->codeBase, (long)sizeof(long) + t4->header.keyLen + 1 ) ; */
|
|
b4->builtKey = (B4KEY_DATA *)mem4alloc2( t4->builtKeyMemory, t4->codeBase ) ;
|
|
b4->builtOn = -1 ;
|
|
#endif /* S4FOX */
|
|
|
|
return b4 ;
|
|
}
|
|
|
|
int b4free( B4BLOCK *b4 )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
#ifdef S4FOX
|
|
#ifdef E4ANALYZE
|
|
if ( b4->changed )
|
|
return error4( b4->tag->codeBase, e4info, E90438 ) ;
|
|
#endif
|
|
mem4free( b4->tag->builtKeyMemory, b4->builtKey ) ;
|
|
#endif /* S4FOX */
|
|
|
|
#ifdef S4CLIPPER
|
|
mem4free( b4->tag->blockMemory, b4 ) ;
|
|
#else
|
|
mem4free( b4->tag->indexFile->blockMemory, b4 ) ;
|
|
#endif
|
|
return 0 ;
|
|
}
|
|
|
|
#ifdef S4MDX
|
|
|
|
/* S4MDX */
|
|
#ifndef S4OFF_WRITE
|
|
int b4flush( B4BLOCK *b4 )
|
|
{
|
|
int rc ;
|
|
INDEX4FILE *i4 ;
|
|
TAG4FILE *t4file ;
|
|
#ifdef S4BYTE_SWAP
|
|
char *swap, *swapPtr ;
|
|
int i ;
|
|
S4LONG longVal ;
|
|
short shortVal ;
|
|
#endif /* S4BYTE_SWAP */
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
if ( b4->changed )
|
|
{
|
|
#ifdef E4INDEX_VERIFY
|
|
if ( b4verify( b4 ) == -1 )
|
|
error4describe( b4->tag->codeBase, e4index, E90438, b4->tag->alias, 0, 0 ) ;
|
|
#endif
|
|
t4file = b4->tag ;
|
|
i4 = t4file->indexFile ;
|
|
|
|
#ifdef S4BYTE_SWAP
|
|
swap = (char *)u4allocEr( t4file->codeBase, t4file->indexFile->header.blockRw ) ;
|
|
if ( swap == 0 )
|
|
return error4stack( t4file->codeBase, e4memory, E90438 ) ;
|
|
|
|
memcpy( (void *)swap, (void *)&b4->nKeys, t4file->indexFile->header.blockRw ) ;
|
|
|
|
/* position swapPtr at beginning of B4KEY's */
|
|
swapPtr = swap ;
|
|
swapPtr += 6 + sizeof(short) ;
|
|
|
|
/* move through all B4KEY's to swap 'long' */
|
|
for ( i = 0 ; i < (*(short *)swap) ; i++ )
|
|
{
|
|
longVal = x4reverseLong( (void *)swapPtr ) ;
|
|
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
|
|
swapPtr += t4file->header.groupLen ;
|
|
}
|
|
|
|
/* mark lastPointer */
|
|
if ( !b4leaf( b4 ) )
|
|
{
|
|
longVal = x4reverseLong( (void *)swapPtr ) ;
|
|
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
|
|
}
|
|
|
|
/* swap the numKeys value */
|
|
shortVal = x4reverseShort( (void *)swap ) ;
|
|
memcpy( swap, (void *) &shortVal, sizeof(short) ) ;
|
|
|
|
#ifndef S4OFF_OPTIMIZE
|
|
i4->readBlockTag = t4file ;
|
|
#endif
|
|
rc = file4write( &i4->file, (long)b4->fileBlock*I4MULTIPLY, swap, i4->header.blockRw ) ;
|
|
#ifndef S4OFF_OPTIMIZE
|
|
i4->readBlockTag = 0 ;
|
|
#endif
|
|
u4free( swap ) ;
|
|
#else
|
|
#ifndef S4OFF_OPTIMIZE
|
|
i4->readBlockTag = t4file ;
|
|
#endif
|
|
rc = file4write( &i4->file, (long)b4->fileBlock*I4MULTIPLY, &b4->nKeys, i4->header.blockRw ) ;
|
|
#ifndef S4OFF_OPTIMIZE
|
|
i4->readBlockTag = 0 ;
|
|
#endif
|
|
#endif /* S4BYTE_SWAP */
|
|
|
|
if ( rc < 0 )
|
|
return error4stack( t4file->codeBase, rc, E90438 ) ;
|
|
b4->changed = 0 ;
|
|
}
|
|
return 0 ;
|
|
}
|
|
#endif /* S4OFF_WRITE */
|
|
|
|
/* S4MDX */
|
|
#ifndef S4INLINE
|
|
void b4goEof( B4BLOCK *b4 )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
{
|
|
error4( 0, e4parm_null, E90438 ) ;
|
|
return ;
|
|
}
|
|
#endif
|
|
|
|
b4->keyOn = b4numKeys( b4 ) ;
|
|
}
|
|
#endif /* S4INLINE */
|
|
|
|
/* S4MDX */
|
|
#ifndef S4OFF_WRITE
|
|
int b4insert( B4BLOCK *b4, const void *k, const long r )
|
|
{
|
|
#ifdef S464BIT
|
|
S4LONG tempR ;
|
|
#endif
|
|
int leftLen ;
|
|
B4KEY_DATA *dataPtr, *nextPtr ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || k == 0 || r <= 0L )
|
|
return error4( b4->tag->codeBase, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
dataPtr = b4key( b4, b4->keyOn ) ;
|
|
nextPtr = b4key( b4, b4->keyOn+1 ) ;
|
|
leftLen = b4->tag->indexFile->header.blockRw - ( b4->keyOn + 1 ) * b4->tag->header.groupLen - sizeof(short) - sizeof(char[6]) ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( b4->keyOn < 0 || b4->keyOn > b4numKeys( b4 ) || leftLen < 0 )
|
|
return error4( b4->tag->codeBase, e4info, E90438 ) ;
|
|
#endif
|
|
|
|
c4memmove( nextPtr, dataPtr, leftLen ) ;
|
|
b4->nKeys++ ;
|
|
memcpy( dataPtr->value, k, b4->tag->header.keyLen ) ;
|
|
#ifdef S464BIT
|
|
tempR = (S4LONG) r ;
|
|
memcpy( (void *)&dataPtr->num, (void *)&tempR, sizeof(tempR) ) ;
|
|
#else
|
|
memcpy( (void *)&dataPtr->num, (void *)&r, sizeof(r) ) ;
|
|
#endif
|
|
b4->changed = 1 ;
|
|
|
|
return 0 ;
|
|
}
|
|
#endif /* S4OFF_WRITE */
|
|
|
|
/* S4MDX */
|
|
/* based on the actual stored-data (from file) only, determine whether or
|
|
not a leaf. Used by file optimization routines */
|
|
int b4dataLeaf( void *data, TAG4FILE *tag )
|
|
{
|
|
short nKeys ;
|
|
char *info ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( data == 0 || tag == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
nKeys = * ((short *)data) ;
|
|
info = (char *)data + ( sizeof( short ) + 6 ) ;
|
|
|
|
return ( ((B4KEY_DATA *)((char *)info + tag->header.groupLen * nKeys))->num == 0L ) ;
|
|
}
|
|
|
|
/* S4MDX */
|
|
#ifndef S4INLINE
|
|
B4KEY_DATA *b4key( const B4BLOCK *b4, const int iKey )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || iKey < 0 )
|
|
{
|
|
error4( 0, e4parm, E90438 ) ;
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
|
|
return (B4KEY_DATA *)((char *)&b4->info.num + b4->tag->header.groupLen * iKey) ;
|
|
}
|
|
|
|
/* S4MDX */
|
|
unsigned char *b4keyKey( B4BLOCK *b4, const int iKey )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || iKey < 0 )
|
|
{
|
|
error4( 0, e4parm, E90438 ) ;
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
|
|
return (unsigned char *)(((B4KEY_DATA *)((char *)&b4->info.num + b4->tag->header.groupLen * iKey ))->value ) ;
|
|
}
|
|
|
|
/* S4MDX */
|
|
int b4lastpos( const B4BLOCK *b4 )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
return ( ( b4leaf( b4 ) ) ? ( b4numKeys( b4 ) - 1 ) : ( b4numKeys( b4 ) ) ) ;
|
|
}
|
|
|
|
/* S4MDX */
|
|
int b4leaf( const B4BLOCK *b4 )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
return( b4key( b4, b4numKeys( b4 ) )->num == 0L ) ;
|
|
}
|
|
|
|
/* S4MDX */
|
|
long b4recNo( const B4BLOCK *b4, const int i )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || i < 0 )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
return b4key( b4, i )->num ;
|
|
}
|
|
#endif /* S4INLINE */
|
|
|
|
/* S4MDX */
|
|
#ifndef S4OFF_WRITE
|
|
int b4remove( B4BLOCK *b4 )
|
|
{
|
|
B4KEY_DATA *keyCur, *keyNext ;
|
|
int leftLen ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
keyCur = b4key( b4, b4->keyOn ) ;
|
|
keyNext = b4key( b4, b4->keyOn + 1 ) ;
|
|
|
|
leftLen = b4->tag->indexFile->header.blockRw - sizeof( b4->nKeys ) - sizeof( b4->dummy )
|
|
- ( b4->keyOn + 1 ) * b4->tag->header.groupLen ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( b4->keyOn < 0 || b4->keyOn > b4lastpos( b4 ) )
|
|
return error4( b4->tag->codeBase, e4info, E90438 ) ;
|
|
#endif
|
|
|
|
if ( leftLen > 0 )
|
|
c4memmove( keyCur, keyNext, leftLen ) ;
|
|
|
|
b4->nKeys-- ;
|
|
b4->changed = 1 ;
|
|
|
|
if ( b4leaf( b4 ) )
|
|
memset( b4keyKey( b4, b4numKeys( b4 ) ), 0, b4->tag->header.keyLen ) ;
|
|
#ifdef E4ANALYZE
|
|
else
|
|
if ( b4numKeys( b4 ) < b4->tag->header.keysMax )
|
|
memset( b4keyKey( b4, b4numKeys( b4 ) ), 0, b4->tag->header.keyLen ) ;
|
|
#endif
|
|
|
|
return 0 ;
|
|
}
|
|
#endif /* S4OFF_WRITE */
|
|
|
|
/* S4MDX */
|
|
int b4seek( B4BLOCK *b4, const char *searchValue, const int len )
|
|
{
|
|
int rc, keyLower, keyUpper, saveRc, keyCur ;
|
|
S4CMP_FUNCTION *cmp;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || searchValue == 0 || len < 0 )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
/* keyCur must be between keyLower and keyUpper */
|
|
keyLower = -1 ;
|
|
keyUpper = b4numKeys( b4 ) ;
|
|
|
|
cmp = b4->tag->cmp ;
|
|
|
|
if ( keyUpper == 0 )
|
|
{
|
|
b4->keyOn = 0 ;
|
|
return r4after ;
|
|
}
|
|
|
|
saveRc = 1 ;
|
|
|
|
for( ;; ) /* Repeat until the key is found */
|
|
{
|
|
keyCur = (keyUpper + keyLower) / 2 ;
|
|
rc = (*cmp)( b4keyKey(b4,keyCur), searchValue, len ) ;
|
|
|
|
if ( rc >= 0 )
|
|
{
|
|
keyUpper = keyCur ;
|
|
saveRc = rc ;
|
|
}
|
|
else
|
|
keyLower = keyCur ;
|
|
|
|
if ( keyLower >= (keyUpper-1) ) /* then there is no exact match */
|
|
{
|
|
b4->keyOn = keyUpper ;
|
|
if ( saveRc )
|
|
return r4after ;
|
|
return 0 ;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* S4MDX */
|
|
int b4skip( B4BLOCK *b4, const long n )
|
|
{
|
|
int numLeft ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
{
|
|
error4( 0, e4parm_null, E90438 ) ;
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
|
|
if ( n > 0 )
|
|
{
|
|
numLeft = b4numKeys( b4 ) - b4->keyOn ;
|
|
if ( b4leaf( b4 ) )
|
|
if ( numLeft != 0 )
|
|
numLeft -- ;
|
|
}
|
|
else
|
|
numLeft = -b4->keyOn ;
|
|
|
|
if ( ( n <= 0L ) ? ( (long)numLeft <= n ) : ( (long)numLeft >= n) )
|
|
{
|
|
b4->keyOn = b4->keyOn + (int)n ;
|
|
return (int)n ;
|
|
}
|
|
else
|
|
{
|
|
b4->keyOn = b4->keyOn + numLeft ;
|
|
return numLeft ;
|
|
}
|
|
}
|
|
#endif /* S4MDX */
|
|
|
|
#ifdef S4FOX
|
|
|
|
/* S4FOX */
|
|
void b4leafInit( B4BLOCK *b4 )
|
|
{
|
|
TAG4FILE *t4 ;
|
|
int tLen ;
|
|
unsigned int cLen, keyLen ;
|
|
unsigned long ff, rLen ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
{
|
|
error4( 0, e4parm_null, E90438 ) ;
|
|
return ;
|
|
}
|
|
#endif
|
|
|
|
t4 = b4->tag ;
|
|
keyLen = (unsigned int)t4->header.keyLen ;
|
|
ff = 0xFFFFFFFFL ;
|
|
|
|
for ( cLen = 0 ; keyLen ; keyLen >>= 1, cLen++ ) ;
|
|
|
|
b4->nodeHdr.trailCntLen = b4->nodeHdr.dupCntLen = (unsigned char)cLen ;
|
|
|
|
b4->nodeHdr.trailByteCnt = (unsigned char)((unsigned char)0xFF >> (8 - cLen % 8) ) ;
|
|
b4->nodeHdr.dupByteCnt = b4->nodeHdr.trailByteCnt ;
|
|
|
|
rLen = (unsigned long)dfile4recCount( b4->tag->indexFile->dataFile, -2L ) ;
|
|
|
|
for ( cLen = 0 ; rLen ; rLen>>=1, cLen++ ) ;
|
|
|
|
b4->nodeHdr.recNumLen = (unsigned char) (cLen + (( 8 - ( 2 * (unsigned int)b4->nodeHdr.trailCntLen % 8 )) % 8)) ;
|
|
if ( b4->nodeHdr.recNumLen < 12 )
|
|
b4->nodeHdr.recNumLen = 12 ;
|
|
|
|
for( tLen = b4->nodeHdr.recNumLen + b4->nodeHdr.trailCntLen + b4->nodeHdr.dupCntLen ;
|
|
(tLen / 8)*8 != tLen ; tLen++, b4->nodeHdr.recNumLen++ ) ; /* make at an 8-bit offset */
|
|
|
|
rLen = ff >> ( sizeof(long)*8 - b4->nodeHdr.recNumLen ) ;
|
|
memcpy( (void *)&b4->nodeHdr.recNumMask[0], (void *)&rLen, sizeof(long) ) ;
|
|
|
|
b4->nodeHdr.infoLen = (unsigned char)((unsigned int)(b4->nodeHdr.recNumLen + b4->nodeHdr.trailCntLen + b4->nodeHdr.dupCntLen) / 8) ;
|
|
b4->nodeHdr.freeSpace = B4BLOCK_SIZE - sizeof( B4STD_HEADER ) - sizeof( B4NODE_HEADER ) ;
|
|
}
|
|
|
|
/* S4FOX */
|
|
int b4calcDups( const unsigned char *ptr1, const unsigned char *ptr2, const int len )
|
|
{
|
|
int a ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( ptr1 == 0 || ptr2 == 0 || len < 0 )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
for ( a = 0 ; a < len; a++ )
|
|
if ( ptr1[a] != ptr2[a] )
|
|
return a ;
|
|
return len ; /* all duplicates */
|
|
}
|
|
|
|
/* S4FOX */
|
|
long x4recNo( const B4BLOCK *b4, const int numInBlock )
|
|
{
|
|
#ifdef S4DATA_ALIGN
|
|
unsigned long longPtr ;
|
|
unsigned long longVal ;
|
|
#else
|
|
unsigned long * lPtr ;
|
|
#ifdef S4DO_BYTEORDER
|
|
unsigned long longTemp ;
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || numInBlock < 0 )
|
|
return error4( 0, e4parm, E90439 ) ;
|
|
#endif
|
|
|
|
#ifdef S4DATA_ALIGN
|
|
memcpy( (void *)&longPtr , b4->data + numInBlock * b4->nodeHdr.infoLen , sizeof(long) ) ;
|
|
#ifdef S4DO_BYTEORDER
|
|
longPtr = (unsigned long)x4reverseLong( (void *)&longPtr ) ;
|
|
#endif
|
|
memcpy( (void *)&longVal , (void *)&b4->nodeHdr.recNumMask[0], sizeof(unsigned long) ) ;
|
|
return ( longPtr & longVal ) ;
|
|
#else
|
|
#ifdef S4DO_BYTEORDER
|
|
longTemp = *(unsigned long *)( b4->data + numInBlock * b4->nodeHdr.infoLen ) ;
|
|
longTemp = (unsigned long)x4reverseLong( (void *)&longTemp ) ;
|
|
return ( longTemp & *(unsigned long *)&b4->nodeHdr.recNumMask[0] ) ;
|
|
#else
|
|
lPtr = (unsigned long *)( b4->data + numInBlock * b4->nodeHdr.infoLen ) ;
|
|
return ( *lPtr & *(unsigned long *)&b4->nodeHdr.recNumMask[0] ) ;
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
/* S4FOX */
|
|
int x4dupCnt( const B4BLOCK *b4, const int numInBlock )
|
|
{
|
|
int pos ;
|
|
#ifdef S4DATA_ALIGN
|
|
unsigned long longPtr ;
|
|
#else
|
|
unsigned long *lPtr ;
|
|
#ifdef S4DO_BYTEORDER
|
|
unsigned long longVal ;
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || numInBlock < 0 )
|
|
return error4( 0, e4parm, E90439 ) ;
|
|
#endif
|
|
|
|
if ( b4->nodeHdr.infoLen > 4 ) /* > size of long, so must do careful shifting and copying */
|
|
{
|
|
#ifdef E4ANALYZE
|
|
if ( b4->nodeHdr.recNumLen <= 16 )
|
|
return error4( b4->tag->codeBase, e4info, E80401 ) ;
|
|
#endif
|
|
#ifdef S4DATA_ALIGN
|
|
memcpy( (void *)&longPtr , b4->data + numInBlock * b4->nodeHdr.infoLen + 2, sizeof(long) ) ;
|
|
#else
|
|
lPtr = (unsigned long *)( b4->data + numInBlock * b4->nodeHdr.infoLen + 2 ) ;
|
|
#endif
|
|
pos = b4->nodeHdr.recNumLen - 16 ;
|
|
}
|
|
else
|
|
{
|
|
#ifdef S4DATA_ALIGN
|
|
memcpy( (void *)&longPtr , b4->data + numInBlock * b4->nodeHdr.infoLen , sizeof(long) ) ;
|
|
#else
|
|
lPtr = (unsigned long *)( b4->data + numInBlock * b4->nodeHdr.infoLen ) ;
|
|
#endif
|
|
pos = b4->nodeHdr.recNumLen ;
|
|
}
|
|
|
|
#ifdef S4DATA_ALIGN
|
|
#ifdef S4DO_BYTEORDER
|
|
longPtr = x4reverseLong( (void *)&longPtr ) ;
|
|
#endif
|
|
return (int)( ( longPtr >> pos ) & b4->nodeHdr.dupByteCnt ) ;
|
|
#else
|
|
#ifdef S4DO_BYTEORDER
|
|
longVal = *lPtr ;
|
|
longVal = x4reverseLong( (void *)&longVal) ;
|
|
return (int)( ( longVal >> pos ) & b4->nodeHdr.dupByteCnt ) ;
|
|
#else
|
|
return (int)( ( *lPtr >> pos ) & b4->nodeHdr.dupByteCnt ) ;
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
/* S4FOX */
|
|
int x4trailCnt( const B4BLOCK *b4, const int numInBlock )
|
|
{
|
|
int pos ;
|
|
#ifdef S4DATA_ALIGN
|
|
unsigned long longPtr ;
|
|
#else
|
|
unsigned long *lPtr ;
|
|
#ifdef S4DO_BYTEORDER
|
|
unsigned long longVal ;
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || numInBlock < 0 )
|
|
return error4( 0, e4parm, E90439 ) ;
|
|
#endif
|
|
|
|
if ( b4->nodeHdr.infoLen > 4 ) /* > size of long, so must do careful shifting and copying */
|
|
{
|
|
#ifdef E4ANALYZE
|
|
if ( b4->nodeHdr.recNumLen <= 16 )
|
|
return error4( b4->tag->codeBase, e4info, E90438 ) ;
|
|
#endif
|
|
#ifdef S4DATA_ALIGN
|
|
memcpy( (void *)&longPtr , b4->data + numInBlock * b4->nodeHdr.infoLen + 2, sizeof(long) ) ;
|
|
#else
|
|
lPtr = (unsigned long *)( b4->data + numInBlock * b4->nodeHdr.infoLen + 2 ) ;
|
|
#endif
|
|
pos = b4->nodeHdr.recNumLen - 16 + b4->nodeHdr.dupCntLen ;
|
|
}
|
|
else
|
|
{
|
|
#ifdef S4DATA_ALIGN
|
|
memcpy( (void *)&longPtr , b4->data + numInBlock * b4->nodeHdr.infoLen , sizeof(long) ) ;
|
|
#else
|
|
lPtr = (unsigned long *)( b4->data + numInBlock * b4->nodeHdr.infoLen ) ;
|
|
#endif
|
|
pos = b4->nodeHdr.recNumLen + b4->nodeHdr.dupCntLen;
|
|
}
|
|
|
|
#ifdef S4DATA_ALIGN
|
|
#ifdef S4DO_BYTEORDER
|
|
longPtr = x4reverseLong( (void *)&longPtr ) ;
|
|
#endif
|
|
return (int)( ( longPtr >> pos ) & b4->nodeHdr.trailByteCnt ) ;
|
|
#else
|
|
#ifdef S4DO_BYTEORDER
|
|
longVal = *lPtr ;
|
|
longVal = x4reverseLong( (void *)&longVal) ;
|
|
return (int)( ( longVal >> pos ) & b4->nodeHdr.trailByteCnt ) ;
|
|
#endif
|
|
return (int)( ( *lPtr >> pos ) & b4->nodeHdr.trailByteCnt ) ;
|
|
#endif
|
|
}
|
|
|
|
/* S4FOX */
|
|
#ifndef S4OFF_WRITE
|
|
|
|
int x4putInfo( const B4NODE_HEADER *b4nodeHdr, void *buffer, const long rec, const int trail, const int dupCnt )
|
|
{
|
|
int pos ;
|
|
#ifdef S4DO_BYTEORDER
|
|
#ifndef S4DATA_ALIGN
|
|
long longTemp ;
|
|
#endif
|
|
#endif
|
|
#ifdef S4DATA_ALIGN
|
|
char unixBuf[6] ;
|
|
char unixBuf2[4] ;
|
|
long longVal, longTemp ;
|
|
int doShift = 0 ;
|
|
#else
|
|
unsigned char *buf ;
|
|
unsigned long *lPtr ;
|
|
#endif
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4nodeHdr == 0 || buffer == 0 || rec < 0 || trail < 0 || dupCnt < 0 )
|
|
return error4( 0, e4parm, E90439 ) ;
|
|
#endif
|
|
|
|
#ifdef S4DATA_ALIGN
|
|
memset( unixBuf, 0, 6 ) ;
|
|
memcpy( (void *)&longTemp , (void *)&b4nodeHdr->recNumMask[0], sizeof(long) ) ;
|
|
longVal = rec & longTemp ;
|
|
#ifdef S4DO_BYTEORDER
|
|
longVal = x4reverseLong( (void *)&longVal ) ;
|
|
#endif
|
|
memcpy( unixBuf, (void *)&longVal, sizeof(long) ) ;
|
|
#else
|
|
buf = (unsigned char *) buffer ;
|
|
lPtr = (unsigned long *)buf ;
|
|
memset( buf, 0, 6 ) ;
|
|
*lPtr = rec & *(long *)&b4nodeHdr->recNumMask[0] ;
|
|
#ifdef S4DO_BYTEORDER
|
|
*lPtr = x4reverseLong( (void *)lPtr ) ;
|
|
#endif
|
|
#endif
|
|
|
|
if ( b4nodeHdr->infoLen > 4 ) /* > size of long, so must do careful shifting and copying */
|
|
{
|
|
#ifdef E4ANALYZE
|
|
if ( b4nodeHdr->recNumLen <= 16 )
|
|
return error4( 0, e4info, E80401 ) ;
|
|
#endif
|
|
#ifndef S4DATA_ALIGN
|
|
lPtr = (unsigned long *)( buf + 2 ) ; /* start at new pos */
|
|
#else
|
|
doShift = 1 ;
|
|
#endif
|
|
pos = b4nodeHdr->recNumLen - 16 ;
|
|
}
|
|
else
|
|
pos = b4nodeHdr->recNumLen ;
|
|
|
|
#ifdef S4DATA_ALIGN
|
|
longVal = ((unsigned long)dupCnt) << pos ;
|
|
pos += b4nodeHdr->dupCntLen ;
|
|
longVal |= ((unsigned long)trail) << pos ;
|
|
#ifdef S4DO_BYTEORDER
|
|
longVal = x4reverseLong( (void *)&longVal ) ;
|
|
#endif
|
|
memcpy( unixBuf2, (void *)&longVal, sizeof(long) ) ;
|
|
if (doShift)
|
|
{
|
|
unixBuf[2] |= unixBuf2[0] ; /* must OR bytes 2 and 3 of 'buf' */
|
|
unixBuf[3] |= unixBuf2[1] ;
|
|
unixBuf[4] = unixBuf2[2] ;
|
|
unixBuf[5] = unixBuf2[3] ;
|
|
}
|
|
else
|
|
{
|
|
unixBuf[0] |= unixBuf2[0] ;
|
|
unixBuf[1] |= unixBuf2[1] ;
|
|
unixBuf[2] |= unixBuf2[2] ;
|
|
unixBuf[3] |= unixBuf2[3] ;
|
|
}
|
|
memcpy( (void *)buffer, unixBuf, 6 ) ;
|
|
#else
|
|
#ifdef S4DO_BYTEORDER
|
|
longTemp = ((unsigned long)dupCnt) << pos ;
|
|
pos += b4nodeHdr->dupCntLen ;
|
|
longTemp |= ((unsigned long)trail) << pos ;
|
|
longTemp = x4reverseLong( (void *)&longTemp ) ;
|
|
*lPtr |= longTemp ;
|
|
#else
|
|
*lPtr |= ((unsigned long)dupCnt) << pos ;
|
|
pos += b4nodeHdr->dupCntLen ;
|
|
*lPtr |= ((unsigned long)trail) << pos ;
|
|
#endif
|
|
#endif
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
/* S4FOX */
|
|
int b4insertLeaf( B4BLOCK *b4, const void *vkeyData, const long rec )
|
|
{
|
|
int leftBlanks, rightBlanks, leftDups, rightDups, leftLen, rightLen, reqdLen, movLen, oldRec, rc, oldRightDups, extraDups, saveDups ;
|
|
unsigned char buffer[6], iLen ;
|
|
unsigned char *keyData ;
|
|
char *infoPos, a, b ;
|
|
int keyLen ;
|
|
unsigned int recLen ;
|
|
unsigned long mask ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || vkeyData == 0 || rec < 0L )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
iLen = b4->nodeHdr.infoLen ;
|
|
keyData = (unsigned char *)vkeyData ;
|
|
keyLen = b4->tag->header.keyLen ;
|
|
b4->builtOn = -1 ;
|
|
|
|
/* if the record is > than the mask, must reset the block with new parameters: */
|
|
b = sizeof( long ) * 8 ;
|
|
mask = 0x01L << (b-1) ; /* set leftmost bit */
|
|
|
|
for( recLen = 0, a = 0 ; a < b ; a++ )
|
|
{
|
|
if ( rec & mask )
|
|
{
|
|
recLen = (unsigned int)((int)b - a) ;
|
|
break ;
|
|
}
|
|
mask >>= 1 ;
|
|
}
|
|
|
|
while ( recLen > b4->nodeHdr.recNumLen )
|
|
{
|
|
oldRec = b4->keyOn ;
|
|
saveDups = b4->curDupCnt ;
|
|
rc = b4reindex( b4 ) ;
|
|
if (rc )
|
|
return rc ;
|
|
iLen = b4->nodeHdr.infoLen ;
|
|
b4top( b4 ) ;
|
|
b4skip( b4, (long)oldRec ) ;
|
|
b4->curDupCnt = saveDups ;
|
|
}
|
|
|
|
if ( b4->tag->indexFile->dataFile->version != 0x30 && b4->tag->codeBase->compatibility == 26 )
|
|
{
|
|
/* FoxPro 2.6 always has no blanks if filters exist (at least for
|
|
character tags */
|
|
if ( b4->tag->filter != 0 )
|
|
leftBlanks = 0 ;
|
|
else
|
|
leftBlanks = b4calcBlanks( keyData, keyLen, b4->tag->pChar ) ;
|
|
}
|
|
else
|
|
leftBlanks = b4calcBlanks( keyData, keyLen, b4->tag->pChar ) ;
|
|
|
|
if ( b4numKeys( b4 ) == 0 )
|
|
{
|
|
if( b4->nodeHdr.freeSpace == 0 ) /* block needs initialization */
|
|
{
|
|
b4leafInit( b4 ) ;
|
|
iLen = b4->nodeHdr.infoLen ;
|
|
}
|
|
leftDups = 0 ;
|
|
reqdLen = keyLen - leftBlanks ;
|
|
b4->keyOn = 0 ;
|
|
b4->curPos = ((char *)&b4->header) + B4BLOCK_SIZE - reqdLen ;
|
|
memcpy( b4->curPos, keyData, (unsigned int)reqdLen ) ; /* key */
|
|
x4putInfo( &b4->nodeHdr, buffer, rec, leftBlanks, 0 ) ;
|
|
memcpy( b4->data, (void *)buffer, iLen ) ;
|
|
}
|
|
else
|
|
{
|
|
if ( b4->keyOn == b4numKeys( b4 ) ) /* at end */
|
|
{
|
|
leftDups = b4->curDupCnt ;
|
|
reqdLen = keyLen - leftBlanks - b4->curDupCnt ;
|
|
if ( (int)b4->nodeHdr.freeSpace < ( reqdLen + (int)iLen ) ) /* no room to add */
|
|
return 1 ;
|
|
b4->curPos -= reqdLen ;
|
|
memcpy( b4->curPos, keyData + b4->curDupCnt, (unsigned int)reqdLen ) ; /* key */
|
|
x4putInfo( &b4->nodeHdr, buffer, rec, leftBlanks, leftDups ) ;
|
|
memcpy( b4->data + b4->keyOn * iLen , (void *)buffer, iLen ) ;
|
|
}
|
|
else
|
|
{
|
|
rightBlanks = x4trailCnt( b4, b4->keyOn ) ;
|
|
|
|
if ( b4->keyOn == 0 ) /* insert at top */
|
|
{
|
|
oldRightDups = 0 ;
|
|
rightDups = b4calcDups( keyData, (unsigned char *)b4->curPos, keyLen - ( rightBlanks > leftBlanks ? rightBlanks : leftBlanks ) ) ;
|
|
extraDups = rightDups ;
|
|
leftDups = 0 ;
|
|
}
|
|
else /* insert in middle of block */
|
|
{
|
|
oldRightDups = x4dupCnt( b4, b4->keyOn) ;
|
|
extraDups = b4calcDups( keyData + oldRightDups, (unsigned char *)b4->curPos, keyLen - ( rightBlanks > leftBlanks ? rightBlanks : leftBlanks ) - oldRightDups ) ;
|
|
rightDups = oldRightDups + extraDups ;
|
|
leftDups = b4->curDupCnt ;
|
|
}
|
|
|
|
#ifdef E4ANALYZE_ALL
|
|
if ( b4->tag->header.typeCode & 0x01 )
|
|
if ( leftDups == b4->tag->header.keyLen || rightDups == b4->tag->header.keyLen )
|
|
return error4( b4->tag->codeBase, e4info, E80402 ) ;
|
|
#endif
|
|
|
|
rightLen = keyLen - rightBlanks - rightDups ;
|
|
leftLen = keyLen - leftDups - leftBlanks ;
|
|
reqdLen = leftLen - extraDups ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( reqdLen < 0 )
|
|
return error4( b4->tag->codeBase, e4info, E80401 ) ;
|
|
#endif
|
|
|
|
if ( (int)b4->nodeHdr.freeSpace < (reqdLen + (int)iLen) ) /* no room to add */
|
|
return 1 ;
|
|
|
|
if ( reqdLen != 0 ) /* shift data over */
|
|
{
|
|
movLen = B4BLOCK_SIZE - sizeof( B4STD_HEADER ) - iLen * b4numKeys( b4 )
|
|
- sizeof( B4NODE_HEADER ) - b4->nodeHdr.freeSpace
|
|
- ( ( (char *)&b4->header ) + B4BLOCK_SIZE - b4->curPos ) ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( movLen < 0 )
|
|
return error4( b4->tag->codeBase, e4info, E80401 ) ;
|
|
#endif
|
|
|
|
/* move and put keys */
|
|
c4memmove( b4->curPos - movLen - reqdLen, b4->curPos - movLen, (unsigned int)movLen ) ;
|
|
}
|
|
b4->curPos += ( keyLen - rightBlanks - oldRightDups ) ;
|
|
memcpy( b4->curPos - leftLen - rightLen, b4->curPos - ( keyLen - rightDups - rightBlanks ), (unsigned int)rightLen ) ;
|
|
b4->curPos -= leftLen ;
|
|
memcpy( b4->curPos, keyData + leftDups, (unsigned int)leftLen ) ;
|
|
|
|
/* move and put info */
|
|
infoPos = b4->data + ( b4->keyOn ) * iLen ;
|
|
c4memmove( infoPos + iLen, infoPos, (unsigned int)(iLen * ( b4numKeys( b4 ) - b4->keyOn ) ) ) ;
|
|
x4putInfo( &b4->nodeHdr, buffer, rec, leftBlanks, leftDups ) ;
|
|
memcpy( infoPos, (void *)buffer, iLen ) ;
|
|
x4putInfo( &b4->nodeHdr, buffer, x4recNo( b4, b4->keyOn + 1 ), rightBlanks, rightDups ) ;
|
|
memcpy( infoPos + iLen, (void *)buffer, iLen ) ;
|
|
}
|
|
}
|
|
|
|
b4->changed = 1 ;
|
|
b4->header.nKeys++ ;
|
|
b4->nodeHdr.freeSpace -= (short) (reqdLen + (int)iLen ) ;
|
|
b4->curDupCnt = leftDups ;
|
|
b4->curTrailCnt = leftBlanks ;
|
|
return 0 ;
|
|
}
|
|
|
|
/* S4FOX */
|
|
/* returns 1 if unable to move keys around to make room */
|
|
static int b4insertBranchBalance( B4BLOCK *b4 )
|
|
{
|
|
B4BLOCK *left, *right, *parent ;
|
|
char *oPos, *nPos ;
|
|
int gLen = b4->tag->header.keyLen + 2 * sizeof( long ) ;
|
|
int rc ;
|
|
|
|
if ( b4numKeys( b4 ) != 2 ) /* only perform in tight situations */
|
|
return 1;
|
|
|
|
parent = (B4BLOCK *)l4prev( &b4->tag->blocks, b4 ) ;
|
|
if ( parent == 0 ) /* no parent, so working on a root block, allow split */
|
|
return 1 ;
|
|
|
|
if ( b4->keyOn == 0L ) /* try adding to right neighbor */
|
|
{
|
|
if ( parent->keyOn == b4numKeys( parent ) - 1 ) /* parent doesn't share blocks */
|
|
return 1 ;
|
|
|
|
if ( b4->header.rightNode == 0 ) /* no neighbor */
|
|
return 1 ;
|
|
|
|
right = b4alloc( b4->tag, b4->header.rightNode ) ;
|
|
if ( right == 0 )
|
|
return 1 ;
|
|
rc = i4readBlock( &b4->tag->indexFile->file, b4->header.rightNode, 0, right ) ;
|
|
if ( rc < 0 )
|
|
{
|
|
b4free( right ) ;
|
|
return 1 ;
|
|
}
|
|
|
|
if ( b4numKeys( right ) >= 2 ) /* already full */
|
|
{
|
|
b4free( right ) ;
|
|
return 1 ;
|
|
}
|
|
|
|
nPos = ((char *)&right->nodeHdr) + gLen * b4numKeys( right ) ;
|
|
oPos = ((char *)&right->nodeHdr) ;
|
|
memcpy( nPos, oPos, gLen * b4numKeys( right ) ) ;
|
|
|
|
nPos = ((char *)&right->nodeHdr) ;
|
|
oPos = ((char *)&b4->nodeHdr) + gLen * ( b4numKeys( b4 ) - 1 ) ;
|
|
memcpy( nPos, oPos, gLen ) ;
|
|
b4->header.nKeys-- ;
|
|
right->header.nKeys++ ;
|
|
|
|
nPos = ((char *)&parent->nodeHdr) + gLen * ( parent->keyOn ) ;
|
|
oPos = ((char *)&b4->nodeHdr ) + gLen * ( b4numKeys( b4 ) - 1 ) ;
|
|
memcpy( nPos, oPos, b4->tag->header.keyLen + sizeof( long ) ) ;
|
|
parent->changed = 1 ;
|
|
right->changed = 1 ;
|
|
b4flush( right ) ;
|
|
b4free( right ) ;
|
|
}
|
|
else /* try adding to left neighbor */
|
|
{
|
|
if ( parent->keyOn == 0 ) /* parent doesn't share blocks */
|
|
return 1 ;
|
|
|
|
if ( b4->header.leftNode == 0 ) /* no neighbor */
|
|
return 1 ;
|
|
|
|
left = b4alloc( b4->tag, b4->header.leftNode ) ;
|
|
if ( left == 0 )
|
|
return 1 ;
|
|
rc = i4readBlock( &b4->tag->indexFile->file, b4->header.leftNode, 0, left ) ;
|
|
if ( rc < 0 )
|
|
{
|
|
b4free( left ) ;
|
|
return 1 ;
|
|
}
|
|
|
|
if ( b4numKeys( left ) >= 2 ) /* already full */
|
|
{
|
|
b4free( left ) ;
|
|
return 1 ;
|
|
}
|
|
|
|
nPos = ((char *)&left->nodeHdr) + gLen * b4numKeys( left ) ;
|
|
oPos = ((char *)&b4->nodeHdr) ;
|
|
memcpy( nPos, oPos, gLen ) ;
|
|
|
|
b4->header.nKeys-- ;
|
|
|
|
nPos = ((char *)&b4->nodeHdr) ;
|
|
oPos = ((char *)&b4->nodeHdr) + gLen * b4numKeys( b4 ) ;
|
|
memcpy( nPos, oPos, gLen * b4numKeys( b4 ) ) ;
|
|
|
|
b4->keyOn-- ;
|
|
left->header.nKeys++ ;
|
|
|
|
nPos = ((char *)&parent->nodeHdr) + gLen * ( parent->keyOn - 1 ) ;
|
|
oPos = ((char *)&left->nodeHdr ) + gLen * ( b4numKeys( left ) - 1 ) ;
|
|
memcpy( nPos, oPos, b4->tag->header.keyLen + sizeof( long ) ) ;
|
|
parent->changed = 1 ;
|
|
left->changed = 1 ;
|
|
b4flush( left ) ;
|
|
b4free( left ) ;
|
|
}
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
/* S4FOX */
|
|
int b4insertBranch( B4BLOCK *b4, const void *k, const long r1, const long rin2, const char newFlag )
|
|
{
|
|
int leftLen, moveLen, gLen ;
|
|
char *dataPtr, *nextPtr ;
|
|
long r, r2 ;
|
|
|
|
gLen = b4->tag->header.keyLen + 2 * sizeof(long) ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || k == 0 || r1 <= 0L || rin2 < 0 )
|
|
return error4( b4->tag->codeBase, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
leftLen = B4BLOCK_SIZE - sizeof( b4->header ) - gLen * b4numKeys( b4 ) ;
|
|
if ( leftLen < gLen ) /* not enough room */
|
|
{
|
|
/* if only 2 keys in branch, try to do some swapping with neighbor */
|
|
if ( b4insertBranchBalance( b4 ) == 1 )
|
|
return 1 ;
|
|
}
|
|
|
|
dataPtr = ((char *)&b4->nodeHdr) + b4->keyOn * gLen ;
|
|
nextPtr = dataPtr + gLen ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( b4->keyOn < 0 || b4->keyOn > b4numKeys( b4 ) )
|
|
return error4( 0, e4info, E90438 ) ;
|
|
#endif
|
|
|
|
moveLen = gLen * ( b4numKeys( b4 ) - b4->keyOn ) ;
|
|
|
|
c4memmove( nextPtr, dataPtr, (unsigned int)moveLen ) ;
|
|
b4->header.nKeys++ ;
|
|
memcpy( dataPtr, k, (unsigned int)b4->tag->header.keyLen ) ;
|
|
memset( dataPtr + gLen - 2*sizeof(long), 0, sizeof(long) ) ;
|
|
|
|
r2 = x4reverseLong( (void *)&rin2 ) ;
|
|
memcpy( dataPtr + gLen - 2*sizeof(long), (void *)&r2, sizeof(long) ) ;
|
|
|
|
r = x4reverseLong( (void *)&r1 ) ;
|
|
|
|
if ( !newFlag && (b4->keyOn + 1) != b4numKeys( b4 ) )
|
|
memcpy( nextPtr + gLen - sizeof(long), (void *)&r, sizeof(long) ) ;
|
|
else
|
|
memcpy( dataPtr + gLen - sizeof(long), (void *)&r, sizeof(long) ) ;
|
|
|
|
b4->changed = 1 ;
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
/* S4FOX */
|
|
#ifndef S4INLINE
|
|
int b4insert( B4BLOCK *b4, const void *keyData, const long rec, const long rec2, const char newFlag )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || keyData == 0 || rec <= 0L || rec2 < 0 )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
return ( b4leaf( b4 ) ? b4insertLeaf( b4, keyData, rec ) : b4insertBranch( b4, keyData, rec, rec2, newFlag ) ) ;
|
|
}
|
|
#endif
|
|
|
|
/* S4FOX */
|
|
int b4reindex( B4BLOCK *b4 )
|
|
{
|
|
int i, dupCnt, trail ;
|
|
int niLen = b4->nodeHdr.infoLen + 1 ;
|
|
unsigned char buffer[6] ;
|
|
long rec ;
|
|
int spaceReqd ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
spaceReqd = b4numKeys( b4 ) ; /* 1 byte extra for each record */
|
|
if ( spaceReqd > b4->nodeHdr.freeSpace ) /* not enough room */
|
|
return 1 ;
|
|
|
|
for ( i = b4numKeys( b4 ) - 1 ; i >= 0 ; i-- )
|
|
{
|
|
dupCnt = x4dupCnt( b4, i ) ;
|
|
trail = x4trailCnt( b4, i ) ;
|
|
rec = x4recNo( b4, i ) ;
|
|
memset( b4->data + i * niLen, 0, (unsigned int)niLen ) ;
|
|
|
|
b4->nodeHdr.recNumLen += 8 ; /* for the new info */
|
|
b4->nodeHdr.infoLen++ ;
|
|
x4putInfo( &b4->nodeHdr, buffer, rec, trail, dupCnt ) ;
|
|
b4->nodeHdr.recNumLen -= 8 ; /* to get the old info */
|
|
b4->nodeHdr.infoLen-- ;
|
|
memcpy( b4->data + i * niLen, (void *)buffer, (unsigned int)niLen ) ;
|
|
}
|
|
|
|
memcpy( (void *)&rec, (void *)&b4->nodeHdr.recNumMask[0], sizeof(long) ) ;
|
|
rec |= (0x000000FFL << b4->nodeHdr.recNumLen ) ;
|
|
memcpy( (void *)&b4->nodeHdr.recNumMask[0], (void *)&rec, sizeof(long) ) ;
|
|
|
|
b4->nodeHdr.infoLen++ ;
|
|
b4->nodeHdr.recNumLen += 8 ;
|
|
b4->nodeHdr.freeSpace -= b4numKeys( b4 ) ;
|
|
return 0 ;
|
|
}
|
|
|
|
/* S4FOX */
|
|
int b4flush( B4BLOCK *b4 )
|
|
{
|
|
int rc ;
|
|
INDEX4FILE *i4 ;
|
|
TAG4FILE *t4file ;
|
|
#ifdef S4BYTE_SWAP
|
|
char swap[B4BLOCK_SIZE] ;
|
|
char *swapPtr ;
|
|
int i ;
|
|
S4LONG longVal ;
|
|
short shortVal ;
|
|
#endif
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
if ( b4->changed )
|
|
{
|
|
t4file = b4->tag ;
|
|
i4 = t4file->indexFile ;
|
|
|
|
#ifdef S4BYTE_SWAP
|
|
memcpy( (void *)swap, (void *)&b4->header.nodeAttribute, B4BLOCK_SIZE ) ;
|
|
|
|
/* position at either B4NODE_HEADER (leaf) or data (branch) */
|
|
swapPtr = swap + 2 * sizeof( short) + 2 * sizeof(S4LONG) ;
|
|
|
|
/* if block is a leaf */
|
|
if (b4->header.nodeAttribute >= 2 )
|
|
{
|
|
/* swap B4NODE_HEADER members */
|
|
shortVal = x4reverseShort( (void *)swapPtr ) ; /* freeSpace */
|
|
memcpy( swapPtr, (void *) &shortVal, sizeof(short) ) ;
|
|
swapPtr += sizeof(short) ;
|
|
|
|
longVal = x4reverseLong( (void *)swapPtr ) ; /* recNumMask */
|
|
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
|
|
}
|
|
else /* if block is a branch */
|
|
{
|
|
shortVal = t4file->header.keyLen + sizeof(S4LONG) ;
|
|
|
|
/* position swapPtr to end of first key expression */
|
|
swapPtr += t4file->header.keyLen ;
|
|
|
|
/* move through all B4KEY's to swap 'long's */
|
|
for ( i = 0 ; i < (int)b4numKeys( b4 ) ; 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 ;
|
|
}
|
|
}
|
|
|
|
/* reposition to B4STD_HEADER and swap members */
|
|
swapPtr = swap ;
|
|
|
|
shortVal = x4reverseShort( (void *)swapPtr ) ; /* nodeAttribute */
|
|
memcpy( swapPtr, (void *) &shortVal, sizeof(short) ) ;
|
|
swapPtr += sizeof(short) ;
|
|
|
|
shortVal = x4reverseShort( (void *)swapPtr ) ; /* nKeys */
|
|
memcpy( swapPtr, (void *) &shortVal, sizeof(short) ) ;
|
|
swapPtr += sizeof(short) ;
|
|
|
|
longVal = x4reverseLong( (void *)swapPtr ) ; /* leftNode */
|
|
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
|
|
swapPtr += sizeof(S4LONG) ;
|
|
|
|
longVal = x4reverseLong( (void *)swapPtr ) ; /* rightNode */
|
|
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
|
|
swapPtr += sizeof(S4LONG) ;
|
|
|
|
#ifndef S4OFF_OPTIMIZE
|
|
i4->readBlockTag = t4file ;
|
|
#endif
|
|
rc = file4write( &i4->file, (long)b4->fileBlock * I4MULTIPLY, swap, B4BLOCK_SIZE ) ;
|
|
#ifndef S4OFF_OPTIMIZE
|
|
i4->readBlockTag = 0 ;
|
|
#endif
|
|
#else
|
|
#ifndef S4OFF_OPTIMIZE
|
|
i4->readBlockTag = t4file ;
|
|
#endif
|
|
rc = file4write( &i4->file, (long)b4->fileBlock * I4MULTIPLY, &b4->header.nodeAttribute, B4BLOCK_SIZE ) ;
|
|
#ifndef S4OFF_OPTIMIZE
|
|
i4->readBlockTag = 0 ;
|
|
#endif
|
|
#endif
|
|
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
b4->changed = 0 ;
|
|
}
|
|
return 0 ;
|
|
}
|
|
#endif /* S4OFF_WRITE */
|
|
|
|
#ifndef S4INLINE
|
|
/* S4FOX */
|
|
int b4go( B4BLOCK *b4, const int iKey )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || iKey < 0 )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
return b4skip( b4, iKey - b4->keyOn ) ;
|
|
}
|
|
#endif /* S4INLINE */
|
|
|
|
/* S4FOX */
|
|
int b4top( B4BLOCK *b4 )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
b4->keyOn = 0 ;
|
|
if ( b4leaf( b4 ) )
|
|
{
|
|
b4->curDupCnt = 0 ;
|
|
b4->curPos = ((char *)&b4->header) + B4BLOCK_SIZE - b4->tag->header.keyLen + x4trailCnt( b4, 0 ) ;
|
|
}
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
/* S4FOX */
|
|
void b4goEof( B4BLOCK *b4 )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
{
|
|
error4( 0, e4parm_null, E90438 ) ;
|
|
return ;
|
|
}
|
|
#endif
|
|
|
|
b4->keyOn = b4numKeys( b4 ) ;
|
|
b4->curPos = ((char *)&b4->header) + sizeof( B4STD_HEADER ) + sizeof( B4NODE_HEADER )
|
|
+ b4numKeys( b4 ) * b4->nodeHdr.infoLen + b4->nodeHdr.freeSpace ;
|
|
}
|
|
|
|
/* S4FOX */
|
|
B4KEY_DATA *b4key( B4BLOCK *b4, const int iKey )
|
|
{
|
|
int len, kLen ;
|
|
char *val ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || iKey > b4numKeys( b4 ) || iKey < 0 )
|
|
{
|
|
error4( 0, e4parm, E90438 ) ;
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
|
|
if ( iKey == b4->builtOn ) /* already there! */
|
|
return b4->builtKey ;
|
|
|
|
val = (char *)(&b4->builtKey->value[0]) ;
|
|
kLen = b4->tag->header.keyLen ;
|
|
|
|
if ( b4->header.nodeAttribute >= 2 ) /* leaf */
|
|
{
|
|
if ( b4->builtOn > iKey || b4->builtOn == -1 )
|
|
{
|
|
b4->builtOn = -1 ;
|
|
b4->builtPos = ((char *)&b4->header) + B4BLOCK_SIZE ;
|
|
}
|
|
|
|
for ( ; b4->builtOn != iKey ; )
|
|
{
|
|
b4->builtOn++ ;
|
|
b4->curDupCnt = x4dupCnt( b4, b4->builtOn ) ;
|
|
b4->curTrailCnt = x4trailCnt( b4, b4->builtOn ) ;
|
|
len = kLen - b4->curDupCnt - b4->curTrailCnt ;
|
|
#ifdef E4ANALYZE
|
|
if (len < 0 || len > kLen || ( b4->builtPos - len ) < b4->data )
|
|
{
|
|
error4( b4->tag->codeBase, e4info, E80401 ) ;
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
b4->builtPos -= len ;
|
|
memcpy( val + b4->curDupCnt, b4->builtPos, (unsigned int)len ) ;
|
|
memset( val + kLen - b4->curTrailCnt, b4->tag->pChar, (unsigned int)b4->curTrailCnt ) ;
|
|
}
|
|
b4->builtKey->num = x4recNo( b4, iKey ) ;
|
|
}
|
|
else /* branch */
|
|
{
|
|
memcpy( val, (((char *)&b4->nodeHdr) + iKey*(2*sizeof( long ) + kLen ) ), (unsigned int)kLen ) ;
|
|
b4->builtKey->num = x4reverseLong( (void *)( ((unsigned char *)&b4->nodeHdr)
|
|
+ (iKey+1)*(2*sizeof(long) + kLen) - sizeof(long) ) ) ;
|
|
}
|
|
return b4->builtKey ;
|
|
}
|
|
|
|
/* S4FOX */
|
|
/* based on the actual stored-data (from file) only, determine whether or
|
|
not a leaf. Used by file optimization routines */
|
|
#ifdef P4ARGS_USED
|
|
#pragma argsused
|
|
#endif
|
|
int b4dataLeaf( void *data, TAG4FILE *tag )
|
|
{
|
|
B4STD_HEADER *header ;
|
|
#ifdef E4PARM_LOW
|
|
if ( data == 0 || tag == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
header = (B4STD_HEADER *)data ;
|
|
|
|
return( header->nodeAttribute >= 2 ) ;
|
|
}
|
|
|
|
#ifndef S4INLINE
|
|
/* S4FOX */
|
|
unsigned char *b4keyKey( B4BLOCK *b4, const int iKey )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
{
|
|
error4( 0, e4parm_null, E90438 ) ;
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
|
|
return (unsigned char *)b4key( b4, iKey )->value ;
|
|
}
|
|
|
|
/* S4FOX */
|
|
int b4lastpos( const B4BLOCK *b4 )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
return b4numKeys( b4 ) - 1 ;
|
|
}
|
|
|
|
/* S4FOX */
|
|
int b4leaf( const B4BLOCK *b4 )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
return( b4->header.nodeAttribute >= 2 ) ;
|
|
}
|
|
#endif /* S4INLINE */
|
|
|
|
/* S4FOX */
|
|
long b4recNo( const B4BLOCK *b4, const int i )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || i < 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
if ( b4->header.nodeAttribute >= 2 ) /* leaf */
|
|
return x4recNo( b4, i ) ;
|
|
else /* branch */
|
|
return (unsigned long)x4reverseLong( (void *)(((unsigned char *)&b4->nodeHdr) +
|
|
i * (2*sizeof(long) + b4->tag->header.keyLen) + b4->tag->header.keyLen ) ) ;
|
|
}
|
|
|
|
/* S4FOX */
|
|
#ifndef S4OFF_WRITE
|
|
int b4brReplace( B4BLOCK *b4, const unsigned char *str, const long r )
|
|
{
|
|
int keyLen ;
|
|
char *putPl ;
|
|
long rec ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || str == 0 || r < 0 )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
keyLen = b4->tag->header.keyLen ;
|
|
putPl = ( (char *)&b4->nodeHdr ) + b4->keyOn * ( 2 * sizeof( long ) + keyLen ) ;
|
|
memcpy( putPl, str, (unsigned int)keyLen ) ;
|
|
memcpy( b4->builtKey->value, str, (unsigned int)keyLen ) ;
|
|
memset( putPl + keyLen, 0, sizeof(long) ) ;
|
|
rec = x4reverseLong( (void *)&r ) ;
|
|
memcpy( putPl + keyLen, (void *)&rec, sizeof(long) ) ;
|
|
|
|
b4->changed = 1 ;
|
|
|
|
return 0 ;
|
|
}
|
|
#endif /* S4OFF_WRITE */
|
|
|
|
/* S4FOX */
|
|
int b4rBrseek( B4BLOCK *b4, const char *searchValue, const int len, const long recNo )
|
|
{
|
|
int rc, keyLen ;
|
|
#ifdef S4DO_BYTEORDER
|
|
long longVal, lrecNo ;
|
|
#endif
|
|
#ifdef E4ANALYZE_ALL
|
|
long swapped ;
|
|
#endif
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || searchValue == 0 || len < 0 )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
#ifdef E4ANALYZE_ALL
|
|
/* incoming rec is swapped, so unswap it to see if it is valid */
|
|
swapped = recNo ;
|
|
swapped = x4reverseShort( &swapped ) ;
|
|
if ( swapped < 0 )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
rc = b4seek( b4, searchValue, len ) ;
|
|
|
|
keyLen = b4->tag->header.keyLen ;
|
|
if ( rc == 0 ) /* string matches, so search on recNo */
|
|
for(;;)
|
|
{
|
|
#ifdef S4DO_BYTEORDER
|
|
lrecNo = x4reverseLong( (void *)&recNo ) ;
|
|
longVal = x4reverseLong( (void *)(((char *)&b4->nodeHdr) + b4->keyOn * ( 2 * sizeof(long) + keyLen) + keyLen ) ) ;
|
|
if ( c4memcmp( (void *)&lrecNo, (void *)&longVal, sizeof(long) ) <= 0
|
|
#else
|
|
if ( c4memcmp( (void *)&recNo, ((char *)&b4->nodeHdr) + b4->keyOn * ( 2 * sizeof(long) + keyLen) + keyLen, sizeof(long) ) <= 0
|
|
#endif
|
|
|| b4->keyOn >= ( b4numKeys( b4 ) - 1 ) ) /* best match, so done */
|
|
break ;
|
|
else
|
|
if( b4->keyOn < b4numKeys( b4 ) )
|
|
b4skip( b4, 1L ) ;
|
|
|
|
if ( u4memcmp( (void *)b4keyKey(b4,b4->keyOn), searchValue, (unsigned int)len ) ) /* the key has changed, so stop here */
|
|
break ;
|
|
}
|
|
|
|
return rc ;
|
|
}
|
|
|
|
/* S4FOX */
|
|
int b4seek( B4BLOCK *b4, const char *searchValue, const int len )
|
|
{
|
|
int rc, keyLower, keyUpper, saveRc, keyCur, groupVal ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || searchValue == 0 || len < 0 )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
if ( b4numKeys( b4 ) == 0 )
|
|
{
|
|
b4->keyOn = 0 ;
|
|
return r4after ;
|
|
}
|
|
|
|
if ( b4leaf( b4 ) )
|
|
return b4leafSeek( b4, searchValue, len ) ;
|
|
|
|
/* keyCur must be between keyLower and keyUpper */
|
|
keyLower = -1 ;
|
|
keyUpper = b4numKeys( b4 ) - 1 ;
|
|
|
|
saveRc = 1 ;
|
|
groupVal = 2 * sizeof( long ) + b4->tag->header.keyLen ;
|
|
|
|
for(;;) /* Repeat until the key is found */
|
|
{
|
|
keyCur = (keyUpper + keyLower) / 2 ;
|
|
rc = u4memcmp( (((char *)&b4->nodeHdr) + keyCur * groupVal ), searchValue, (unsigned int)len ) ;
|
|
|
|
if ( rc >= 0 )
|
|
{
|
|
keyUpper = keyCur ;
|
|
saveRc = rc ;
|
|
}
|
|
else
|
|
keyLower = keyCur ;
|
|
|
|
if ( keyLower >= (keyUpper-1) ) /* then there is no exact match */
|
|
{
|
|
b4->keyOn = keyUpper ; /* branch block, just change keyOn */
|
|
if ( saveRc )
|
|
return r4after ;
|
|
return 0 ;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef S4VFP_KEY
|
|
int u4tailCmp( S4CMP_PARM dataPtr, S4CMP_PARM searchPtr, size_t sLen )
|
|
{
|
|
unsigned char *data = (unsigned char *)dataPtr ;
|
|
unsigned char *search = (unsigned char *)searchPtr ;
|
|
unsigned int on ;
|
|
|
|
for ( on = 0 ; on < sLen ; on++ )
|
|
if ( search[on] !=17 || ( data[on] >= 10 && data[on] != 17 ) )
|
|
break ;
|
|
|
|
return on ;
|
|
}
|
|
#endif
|
|
|
|
/* S4FOX */
|
|
int b4leafSeek( B4BLOCK *b4, const char *searchValue, const int l )
|
|
{
|
|
int done, len, trailCnt, duplicates, bytesSame, compareLen, keyLen, originalLen, significantBytes, cLen ;
|
|
#ifdef S4VFP_KEY
|
|
int skippedSpaces ;
|
|
#endif
|
|
char allBlank ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || searchValue == 0 || l < 0 )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
originalLen = len = l ;
|
|
keyLen = b4->tag->header.keyLen ;
|
|
#ifdef S4VFP_KEY
|
|
if ( tfile4vfpKey( b4->tag ) && b4->tag->expr->type == r4str )
|
|
for ( ; len > 0 && searchValue[len-1] == 17 ; len-- ) ;
|
|
skippedSpaces = ( len == originalLen ) ? 0 : 1 ;
|
|
#endif
|
|
len -= b4calcBlanks( (unsigned char *)searchValue, len, b4->tag->pChar ) ; /* don't compare blank bytes */
|
|
if ( len == 0 ) /* if all blanks, watch for records < blank */
|
|
{
|
|
len = originalLen ;
|
|
allBlank = 1 ;
|
|
}
|
|
else
|
|
allBlank = 0 ;
|
|
duplicates = 0 ;
|
|
b4top( b4 ) ;
|
|
|
|
for(;;)
|
|
{
|
|
if ( b4->curDupCnt == duplicates )
|
|
{
|
|
significantBytes = keyLen - x4trailCnt( b4, b4->keyOn ) ;
|
|
if ( allBlank && significantBytes == 0 ) /* found a blank record */
|
|
len = 0 ;
|
|
compareLen = ( len < significantBytes ? len : significantBytes ) - b4->curDupCnt ;
|
|
bytesSame = (*b4->tag->cmp)( b4->curPos, searchValue + b4->curDupCnt, (unsigned int)compareLen ) ;
|
|
|
|
if ( bytesSame == -1 )
|
|
return r4after ;
|
|
if ( bytesSame == compareLen )
|
|
{
|
|
if ( (b4->curDupCnt + bytesSame == len)) /* unless binary character, for sure done */
|
|
{
|
|
if ( len == originalLen )
|
|
done = 1 ;
|
|
else /* in case of binary, we may not be done if values < blank */
|
|
{
|
|
trailCnt = x4trailCnt( b4, b4->keyOn ) ;
|
|
if ( significantBytes > trailCnt + len ) /* significant bytes beyond the trail, so check binary */
|
|
{ /* for a VFP_KEY this should never happen as key functions should guarantee l <= keyLen */
|
|
cLen = keyLen - trailCnt ;
|
|
if ( originalLen - len < cLen )
|
|
cLen = originalLen - len ;
|
|
if ( c4memcmp( b4->curPos + compareLen, searchValue + len, (unsigned int)cLen ) < 0 ) /* binaries */
|
|
done = 0 ;
|
|
else
|
|
done = 1 ;
|
|
}
|
|
else
|
|
done = 1 ;
|
|
}
|
|
|
|
if ( done == 1 )
|
|
{
|
|
if ( len != originalLen && significantBytes > len )
|
|
{
|
|
#ifdef S4VFP_KEY
|
|
if ( skippedSpaces )
|
|
{
|
|
cLen = originalLen - ( len < significantBytes ? len : significantBytes ) ;
|
|
if ( u4tailCmp( b4->curPos + compareLen, searchValue + len, cLen ) != cLen )
|
|
return r4after ;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
if ( significantBytes < originalLen )
|
|
return r4after ;
|
|
#ifdef E4ANALYZE
|
|
if ( len > originalLen )
|
|
return error4( b4->tag->codeBase, e4info, E90438 ) ;
|
|
#endif
|
|
if ( (*b4->tag->cmp)( b4->curPos + compareLen, searchValue + len, (unsigned int)(originalLen - len) ) != (originalLen - len) )
|
|
return r4after ;
|
|
}
|
|
}
|
|
if ( allBlank != 1 ) /* not all blanks, so significants matter */
|
|
b4->curDupCnt += bytesSame ;
|
|
else
|
|
b4->curDupCnt = 0 ;
|
|
return 0 ;
|
|
}
|
|
}
|
|
}
|
|
|
|
b4->curDupCnt += bytesSame ;
|
|
}
|
|
|
|
b4->keyOn++ ;
|
|
if ( b4->keyOn >= b4numKeys( b4 ) )
|
|
return r4after ;
|
|
duplicates = x4dupCnt( b4, b4->keyOn ) ;
|
|
b4->curPos -= keyLen - duplicates - x4trailCnt( b4, b4->keyOn ) ;
|
|
if ( b4->curDupCnt > duplicates )
|
|
{
|
|
if ( allBlank ) /* must reset the duplicates in this case only */
|
|
{
|
|
b4->curDupCnt = duplicates ;
|
|
if ( x4trailCnt( b4, b4->keyOn ) == len ) /* blank key found */
|
|
return 0 ;
|
|
}
|
|
return r4after ;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* S4FOX */
|
|
#ifndef S4OFF_WRITE
|
|
int b4removeLeaf( B4BLOCK *b4 )
|
|
{
|
|
int oldDup, leftDup, leftTrail, keyLen, removeLen, newDup, oldBytes, newBytes, movLen, leftBytes ;
|
|
unsigned char buffer[6], iLen ;
|
|
char *oldPos, *infoPos ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
b4->builtOn = -1 ;
|
|
|
|
if ( b4numKeys( b4 ) == 1 ) /* removing last key */
|
|
{
|
|
b4->nodeHdr.freeSpace = B4BLOCK_SIZE - sizeof( B4NODE_HEADER ) - sizeof( B4STD_HEADER ) ;
|
|
memset( b4->data, 0, (unsigned int)b4->nodeHdr.freeSpace ) ;
|
|
b4->header.nKeys = 0 ;
|
|
b4->keyOn = 0 ;
|
|
b4->curPos = ((char *)&b4->header) + B4BLOCK_SIZE ;
|
|
b4->changed = 1 ;
|
|
return 0 ;
|
|
}
|
|
|
|
keyLen = b4->tag->header.keyLen ;
|
|
iLen = b4->nodeHdr.infoLen ;
|
|
oldDup = x4dupCnt( b4, b4->keyOn) ;
|
|
|
|
if ( b4->keyOn == b4numKeys( b4 ) - 1 ) /* at end */
|
|
{
|
|
removeLen = keyLen - oldDup - x4trailCnt( b4, b4->keyOn ) ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( removeLen < 0 )
|
|
return error4( b4->tag->codeBase, e4info, E80401 ) ;
|
|
#endif
|
|
|
|
memset( b4->curPos, 0, (unsigned int)removeLen ) ;
|
|
memset( b4->data + b4->keyOn * iLen, 0, iLen ) ;
|
|
b4->keyOn-- ;
|
|
}
|
|
else
|
|
{
|
|
oldBytes = keyLen - oldDup - x4trailCnt( b4, b4->keyOn ) ;
|
|
oldPos = b4->curPos ;
|
|
b4skip( b4, 1L ) ;
|
|
leftDup = x4dupCnt( b4, b4->keyOn) ;
|
|
leftTrail = x4trailCnt( b4, b4->keyOn ) ;
|
|
newDup = oldDup < leftDup ? oldDup : leftDup ;
|
|
leftBytes = keyLen - leftTrail - leftDup ;
|
|
newBytes = keyLen - leftTrail - newDup ;
|
|
|
|
memcpy( b4->builtKey->value, oldPos, (unsigned int)(leftDup - newDup) ) ; /* copy prev dup bytes between the 2 keys only */
|
|
memcpy( b4->builtKey->value + ( leftDup - newDup ), b4->curPos, (unsigned int)leftBytes ) ;
|
|
memcpy( oldPos + oldBytes - newBytes, b4->builtKey->value, (unsigned int)newBytes ) ;
|
|
|
|
removeLen = oldBytes + leftBytes - newBytes ;
|
|
#ifdef E4ANALYZE
|
|
if ( removeLen < 0 )
|
|
return error4( b4->tag->codeBase, e4info, E80401 ) ;
|
|
#endif
|
|
|
|
movLen = B4BLOCK_SIZE - sizeof( B4STD_HEADER ) - iLen * b4numKeys( b4 )
|
|
- sizeof( B4NODE_HEADER ) - b4->nodeHdr.freeSpace
|
|
- ( ( (char *)&b4->header ) + B4BLOCK_SIZE - b4->curPos ) ;
|
|
#ifdef E4ANALYZE
|
|
if ( movLen < 0 )
|
|
return error4( b4->tag->codeBase, e4info, E80401 ) ;
|
|
#endif
|
|
|
|
c4memmove( b4->curPos - movLen + removeLen, b4->curPos - movLen, (unsigned int)movLen ) ;
|
|
|
|
memset( b4->curPos - movLen, 0, (unsigned int)removeLen ) ;
|
|
b4->keyOn-- ;
|
|
|
|
/* move and put info */
|
|
infoPos = b4->data + ( b4->keyOn ) * iLen ;
|
|
c4memmove( infoPos, infoPos + iLen, (unsigned int)(iLen * ( b4numKeys( b4 ) - b4->keyOn ) ) ) ;
|
|
x4putInfo( &b4->nodeHdr, buffer, x4recNo( b4, b4->keyOn ), leftTrail, (unsigned int)newDup ) ;
|
|
memcpy( infoPos, (void *)buffer, iLen ) ;
|
|
memset( b4->data + (b4numKeys( b4 ) - 1 ) * iLen, 0, iLen ) ;
|
|
}
|
|
b4->changed = 1 ;
|
|
b4->curPos += removeLen ;
|
|
b4->header.nKeys-- ;
|
|
b4->nodeHdr.freeSpace += (short)( (int)iLen + removeLen ) ;
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
/* S4FOX */
|
|
int b4remove( B4BLOCK *b4 )
|
|
{
|
|
char *keyCur ;
|
|
int len, iLen ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
if( b4->header.nodeAttribute >= 2 ) /* leaf */
|
|
b4removeLeaf( b4 ) ;
|
|
else
|
|
{
|
|
iLen = b4->tag->header.keyLen + 2 * sizeof( long ) ;
|
|
keyCur = ((char *)&b4->nodeHdr) + iLen * b4->keyOn ;
|
|
len = (b4numKeys( b4 ) - b4->keyOn - 1) * iLen ;
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( b4->keyOn < 0 || b4->keyOn > b4lastpos( b4 ) ||
|
|
len < 0 || (unsigned)len > (B4BLOCK_SIZE - sizeof(B4STD_HEADER) - (unsigned)iLen ))
|
|
return error4( b4->tag->codeBase, e4info, E90438 ) ;
|
|
#endif
|
|
|
|
if ( len > 0 )
|
|
c4memmove( keyCur, keyCur + iLen, (unsigned int)len ) ;
|
|
|
|
b4->header.nKeys-- ;
|
|
memset( ((char *)&b4->nodeHdr) + b4numKeys( b4 ) * iLen, 0, (unsigned int)iLen ) ;
|
|
b4->changed = 1 ;
|
|
}
|
|
|
|
return 0 ;
|
|
}
|
|
#endif /* S4OFF_WRITE */
|
|
|
|
/* S4FOX */
|
|
int b4skip( B4BLOCK *b4, const long num )
|
|
{
|
|
int numSkipped, kLen, nKeys ;
|
|
long n ;
|
|
|
|
n = num ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
nKeys = b4numKeys( b4 ) ;
|
|
|
|
if ( b4->header.nodeAttribute < 2 ) /* branch */
|
|
{
|
|
if ( n > 0 )
|
|
numSkipped = nKeys - b4->keyOn ;
|
|
else
|
|
numSkipped = -b4->keyOn ;
|
|
|
|
if ( ( n <= 0L ) ? (numSkipped <= (int)n) : (numSkipped >= (int)n) )
|
|
{
|
|
b4->keyOn += (int)n ;
|
|
return (int)n ;
|
|
}
|
|
else
|
|
{
|
|
b4->keyOn += numSkipped ;
|
|
return numSkipped ;
|
|
}
|
|
}
|
|
else /* leaf */
|
|
{
|
|
if ( nKeys == 0 )
|
|
return 0 ;
|
|
kLen = b4->tag->header.keyLen ;
|
|
if (n > 0 )
|
|
{
|
|
if ( b4->keyOn + n >= nKeys )
|
|
{
|
|
b4->curPos = ((char *)&b4->header ) + sizeof( B4STD_HEADER ) + sizeof( B4NODE_HEADER )
|
|
+ b4->nodeHdr.infoLen * nKeys + b4->nodeHdr.freeSpace ;
|
|
n = (long)nKeys - (long)b4->keyOn - ( b4->keyOn != nKeys ) ;
|
|
b4->keyOn = nKeys ;
|
|
return (int)n ;
|
|
}
|
|
for( numSkipped = (int)n ; numSkipped != 0 ; numSkipped-- )
|
|
{
|
|
b4->keyOn++ ;
|
|
b4->curPos -= ( kLen - x4dupCnt( b4, b4->keyOn ) - x4trailCnt( b4, b4->keyOn ) ) ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( b4->keyOn + n < 0 )
|
|
{
|
|
n = -b4->keyOn ;
|
|
b4->keyOn = 0 ;
|
|
b4->curPos = ((char *)&b4->header ) + B4BLOCK_SIZE - kLen + x4trailCnt( b4, b4->keyOn ) ;
|
|
return (int) n ;
|
|
}
|
|
for( numSkipped = (int)n ; numSkipped != 0 ; numSkipped++ )
|
|
{
|
|
b4->curPos += ( kLen - x4dupCnt( b4, b4->keyOn ) - x4trailCnt( b4, b4->keyOn ) ) ;
|
|
b4->keyOn-- ;
|
|
}
|
|
}
|
|
|
|
return (int) n ;
|
|
}
|
|
}
|
|
#endif /* S4FOX */
|
|
|
|
#ifdef S4CLIPPER
|
|
|
|
#ifndef S4OFF_WRITE
|
|
int b4flush( B4BLOCK *b4 )
|
|
{
|
|
int rc ;
|
|
#ifdef S4BYTE_SWAP
|
|
char *swap, *swapPtr ;
|
|
int i ;
|
|
S4LONG longVal ;
|
|
short shortVal ;
|
|
#endif
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
if ( b4->changed )
|
|
{
|
|
#ifdef E4INDEX_VERIFY
|
|
if ( b4verify( b4 ) == -1 )
|
|
error4describe( b4->tag->codeBase, e4index, E90438, b4->tag->alias, 0, 0 ) ;
|
|
#endif
|
|
|
|
#ifdef S4BYTE_SWAP
|
|
swap = (char *)u4allocEr( b4->tag->codeBase, B4BLOCK_SIZE ) ;
|
|
if ( swap == 0 )
|
|
return -1 ;
|
|
|
|
memcpy( (void *)swap, (void *)&b4->nKeys, B4BLOCK_SIZE ) ;
|
|
|
|
/* position swapPtr at beginning of pointers */
|
|
shortVal = x4reverseShort( (void *)swap ) ;
|
|
memcpy( swap, (void *) &shortVal, sizeof(short) ) ;
|
|
|
|
swapPtr = swap + 2 ;
|
|
|
|
/* swap the short pointers to B4KEY_DATA */
|
|
for ( i = 0 ; i < b4->tag->header.keysMax ; i++ )
|
|
{
|
|
shortVal = x4reverseShort( (void *)swapPtr ) ;
|
|
memcpy( swapPtr, (void *) &shortVal, sizeof(short) ) ;
|
|
swapPtr += sizeof(short) ;
|
|
}
|
|
/* swap the B4KEY_DATA's */
|
|
for ( i = 0 ; i < b4->tag->header.keysMax ; i++ )
|
|
{
|
|
longVal = x4reverseLong( (void *)swapPtr ) ;
|
|
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
|
|
longVal = x4reverseLong( (void *)swapPtr+sizeof(S4LONG) ) ;
|
|
memcpy( swapPtr+sizeof(S4LONG), (void *) &longVal, sizeof(S4LONG) ) ;
|
|
swapPtr += b4->tag->header.groupLen ;
|
|
}
|
|
|
|
#ifndef S4OFF_OPTIMIZE
|
|
b4->tag->indexFile->readBlockTag = b4->tag ;
|
|
#endif
|
|
rc = file4write( &b4->tag->file, (long)b4->fileBlock*I4MULTIPLY, swap, B4BLOCK_SIZE ) ;
|
|
#ifndef S4OFF_OPTIMIZE
|
|
b4->tag->indexFile->->readBlockTag = 0 ;
|
|
#endif
|
|
u4free( swap ) ;
|
|
#else
|
|
#ifndef S4OFF_OPTIMIZE
|
|
b4->tag->readBlockTag = b4->tag ;
|
|
#endif
|
|
rc = file4write( &b4->tag->file, (long)b4->fileBlock*I4MULTIPLY, &b4->nKeys, B4BLOCK_SIZE ) ;
|
|
#ifndef S4OFF_OPTIMIZE
|
|
b4->tag->readBlockTag = 0 ;
|
|
#endif
|
|
#endif
|
|
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
b4->changed = 0 ;
|
|
}
|
|
return 0 ;
|
|
}
|
|
|
|
int b4append( B4BLOCK *b4, const long pointer )
|
|
{
|
|
long adjPointer = pointer * 512 ;
|
|
B4KEY_DATA *dataPtr ;
|
|
#ifdef E4ANALYZE
|
|
int leftLen ;
|
|
#endif
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || pointer < 1L )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( b4leaf( b4 ) )
|
|
return error4( b4->tag->codeBase, e4info, E90438 ) ;
|
|
#endif
|
|
|
|
b4goEof( b4 ) ;
|
|
dataPtr = b4key( b4, b4->keyOn ) ;
|
|
|
|
#ifdef E4ANALYZE
|
|
leftLen = B4BLOCK_SIZE - b4->keyOn * b4->tag->header.groupLen -
|
|
sizeof(short) - sizeof(char[2]) - sizeof(pointer) ;
|
|
if ( b4->keyOn < 0 || b4->keyOn != b4numKeys( b4 ) || leftLen < 0 )
|
|
return error4( b4->tag->codeBase, e4info, E90438 ) ;
|
|
#endif
|
|
|
|
memcpy( &dataPtr->pointer, &adjPointer, sizeof(pointer) ) ;
|
|
b4->changed = 1 ;
|
|
#ifdef E4INDEX_VERIFY
|
|
if ( b4verify( b4 ) == -1 )
|
|
return error4describe( b4->tag->codeBase, e4index, E90438, b4->tag->alias, 0, 0 ) ;
|
|
#endif
|
|
|
|
return 0 ;
|
|
}
|
|
#endif /* S4OFF_WRITE */
|
|
|
|
#ifndef S4OFF_WRITE
|
|
int b4append2( B4BLOCK *b4, const void *k, const long r, const long pointer )
|
|
{
|
|
unsigned short temp ;
|
|
B4KEY_DATA *dataPtr ;
|
|
long adjPointer ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || k == 0 || r < 0L || pointer < 0L )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
b4goEof( b4 ) ;
|
|
|
|
if ( b4numKeys( b4 ) > 0 )
|
|
{
|
|
if ( !b4leaf( b4 ) ) /* insert after branch */
|
|
b4->keyOn++ ;
|
|
else
|
|
if ( b4->keyOn + !b4leaf( b4 ) < b4->tag->header.keysMax )
|
|
{
|
|
temp = b4->pointers[b4numKeys( b4 )+1] ;
|
|
b4->pointers[b4numKeys( b4 )+1] = b4->pointers[b4numKeys( b4 )] ;
|
|
b4->pointers[b4numKeys( b4 )] = temp ;
|
|
}
|
|
}
|
|
|
|
dataPtr = b4key( b4, b4->keyOn ) ;
|
|
adjPointer = pointer * 512 ;
|
|
b4->nKeys++ ;
|
|
|
|
memcpy( dataPtr->value, k, b4->tag->header.groupLen-2*sizeof(long) ) ;
|
|
memcpy( &dataPtr->num, &r, sizeof(r) ) ;
|
|
memcpy( &dataPtr->pointer, &adjPointer, sizeof(pointer) ) ;
|
|
b4->changed = 1 ;
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
/* clipper just puts at end and inserts into the index part */
|
|
int b4insert( B4BLOCK *b4, const void *k, const long r, const long pointer )
|
|
{
|
|
short temp, insertPos ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || k == 0 || r < 0L || pointer < 0L )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
insertPos = b4->keyOn ;
|
|
|
|
/* put at block end: */
|
|
b4append2( b4, k, r, pointer ) ;
|
|
|
|
temp = b4->pointers[b4->keyOn] ; /* save the placed position */
|
|
c4memmove( &b4->pointers[insertPos+1], &b4->pointers[insertPos], sizeof(short) * ( b4lastpos( b4 ) - insertPos -
|
|
(!b4leaf( b4 ) && b4numKeys( b4 ) < 2 ) ) ) ;
|
|
b4->pointers[insertPos] = temp ;
|
|
if ( b4leaf( b4 ) )
|
|
if ( b4key( b4, b4numKeys( b4 ) )->pointer != 0 )
|
|
b4key( b4, b4numKeys( b4 ) )->pointer = 0L ;
|
|
|
|
return 0 ;
|
|
}
|
|
#endif /* S4OFF_WRITE */
|
|
|
|
#ifndef S4INLINE
|
|
/* goes to one past the end of the block */
|
|
void b4goEof( B4BLOCK *b4 )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
{
|
|
error4( 0, e4parm_null, E90438 ) ;
|
|
return ;
|
|
}
|
|
#endif
|
|
|
|
b4->keyOn = b4numKeys( b4 ) ;
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
B4KEY_DATA *b4key( const B4BLOCK *b4, const int iKey )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || iKey < 0 )
|
|
{
|
|
error4( 0, e4parm, E90438 ) ;
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
|
|
#ifdef E4ANALYZE
|
|
if ( iKey > 2 + b4->tag->header.keysMax )
|
|
{
|
|
error4( b4->tag->codeBase, e4parm, E90438 ) ;
|
|
return 0 ;
|
|
}
|
|
if ( ( b4->pointers[iKey] < (short)((sizeof(short)) * ( b4->tag->header.keysMax + 1 ) ) ) ||
|
|
( b4->pointers[iKey] > B4BLOCK_SIZE - b4->tag->header.keyLen ) )
|
|
{
|
|
error4( b4->tag->codeBase, e4info, E90438 ) ;
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
return (B4KEY_DATA *)((char *)&b4->nKeys + b4->pointers[iKey] ) ;
|
|
}
|
|
|
|
unsigned char *b4keyKey( B4BLOCK *b4, const int iKey )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || iKey < 0 )
|
|
{
|
|
error4( 0, e4parm, E90438 ) ;
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
return (unsigned char *) b4key( b4, iKey )->value ;
|
|
}
|
|
|
|
int b4lastpos( const B4BLOCK *b4 )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
return ( ( b4leaf( b4 ) ) ? ( b4numKeys( b4 ) - 1 ) : ( b4numKeys( b4 ) ) ) ;
|
|
}
|
|
|
|
int b4leaf( const B4BLOCK *b4 )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
return( b4key( b4, 0 )->pointer == 0L ) ;
|
|
}
|
|
|
|
long b4recNo( const B4BLOCK *b4, const int i )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || i < 0 )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
return b4key( b4, i )->num ;
|
|
}
|
|
#endif /* S4INLINE */
|
|
|
|
/* S4CLIPPER */
|
|
/* based on the actual stored-data (from file) only, determine whether or
|
|
not a leaf. Used by file optimization routines */
|
|
int b4dataLeaf( void *data, TAG4FILE *tag )
|
|
{
|
|
B4KEY_DATA *keyData ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( data == 0 || tag == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
keyData = (B4KEY_DATA *)( (char *)data + *((short *)((char *)data + sizeof(short))) ) ;
|
|
|
|
return( keyData->pointer == 0L ) ;
|
|
}
|
|
|
|
/* S4CLIPPER */
|
|
int b4remove( B4BLOCK *b4 )
|
|
{
|
|
short temp ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
/* just delete this entry */
|
|
temp = b4->pointers[b4->keyOn] ;
|
|
if ( b4leaf( b4 ) && ( b4->keyOn + !b4leaf( b4 ) < b4->tag->header.keysMax ) )
|
|
{
|
|
c4memmove( &b4->pointers[b4->keyOn], &b4->pointers[b4->keyOn+1],
|
|
sizeof(short) * (b4lastpos( b4 ) - b4->keyOn + 1) ) ;
|
|
b4->pointers[b4lastpos( b4 )+1] = temp ;
|
|
}
|
|
else
|
|
{
|
|
c4memmove( &b4->pointers[b4->keyOn], &b4->pointers[b4->keyOn+1],
|
|
sizeof(short) * (b4lastpos( b4 ) - b4->keyOn) ) ;
|
|
b4->pointers[b4lastpos( b4 )] = temp ;
|
|
}
|
|
b4->nKeys-- ;
|
|
b4->changed = 1 ;
|
|
|
|
if ( b4leaf( b4 ) )
|
|
memset( b4key( b4, b4lastpos( b4 ) + 1 ), 0, b4->tag->header.keyLen + 2 * sizeof( long ) ) ;
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
int b4room( const B4BLOCK *b4 )
|
|
{
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
if ( b4leaf( b4 ) )
|
|
return ( b4numKeys( b4 ) < b4->tag->header.keysMax ) ;
|
|
|
|
return( ( b4numKeys( b4 ) < b4->tag->header.keysMax ) && ( ( B4BLOCK_SIZE -
|
|
b4numKeys( b4 ) * b4->tag->header.groupLen - sizeof(short) - 2*sizeof(char)) >= sizeof(long) ) ) ;
|
|
}
|
|
|
|
int b4seek( B4BLOCK *b4, const char *searchValue, const int len )
|
|
{
|
|
int rc, saveRc, keyCur, keyLower, keyUpper ;
|
|
S4CMP_FUNCTION *cmp = b4->tag->cmp ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 || searchValue == 0 || len < 0 )
|
|
return error4( 0, e4parm, E90438 ) ;
|
|
#endif
|
|
|
|
/* keyOn must be between keyLower and keyUpper */
|
|
keyLower = -1 ;
|
|
keyUpper = b4numKeys( b4 ) ;
|
|
|
|
if ( keyUpper == 0 )
|
|
{
|
|
b4->keyOn = 0 ;
|
|
return r4after ;
|
|
}
|
|
|
|
saveRc = 1 ;
|
|
|
|
for(;;) /* Repeat until the key is found */
|
|
{
|
|
keyCur = (keyUpper + keyLower) / 2 ;
|
|
rc = (*cmp)( b4keyKey(b4,keyCur), searchValue, len ) ;
|
|
|
|
if ( rc >= 0 )
|
|
{
|
|
keyUpper = keyCur ;
|
|
saveRc = rc ;
|
|
}
|
|
else
|
|
keyLower = keyCur ;
|
|
|
|
if ( keyLower >= (keyUpper-1) ) /* then there is no exact match */
|
|
{
|
|
b4->keyOn = keyUpper ;
|
|
if ( saveRc )
|
|
return r4after ;
|
|
return 0 ;
|
|
}
|
|
}
|
|
}
|
|
|
|
int b4skip( B4BLOCK *b4, const long n )
|
|
{
|
|
int numLeft ;
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
if ( n > 0 )
|
|
{
|
|
numLeft = b4numKeys( b4 ) - b4->keyOn ;
|
|
if ( b4leaf( b4 ) )
|
|
if ( numLeft != 0 )
|
|
numLeft -- ;
|
|
}
|
|
else
|
|
numLeft = -b4->keyOn ;
|
|
|
|
if ( ( n <= 0L ) ? ( (long)numLeft <= n ) : ( (long)numLeft >= n ) )
|
|
{
|
|
b4->keyOn = b4->keyOn + (int) n ;
|
|
return (int) n ;
|
|
}
|
|
else
|
|
{
|
|
b4->keyOn = b4->keyOn + numLeft ;
|
|
return numLeft ;
|
|
}
|
|
}
|
|
#endif /* S4CLIPPER */
|
|
|
|
#ifdef E4INDEX_VERIFY
|
|
int b4verify( B4BLOCK *b4 )
|
|
{
|
|
int i ;
|
|
#ifdef S4CLIPPER
|
|
int j ;
|
|
long val ;
|
|
#endif
|
|
#ifdef S4FOX
|
|
int holdDup, holdTrail ;
|
|
#else
|
|
int iType ;
|
|
#endif
|
|
|
|
#ifdef E4PARM_LOW
|
|
if ( b4 == 0 )
|
|
return error4( 0, e4parm_null, E90438 ) ;
|
|
#endif
|
|
|
|
#ifdef S4FOX
|
|
holdDup = b4->curDupCnt ;
|
|
holdTrail = b4->curTrailCnt ;
|
|
#endif
|
|
|
|
if ( b4->tag->codeBase->doIndexVerify == 0 )
|
|
return 0 ;
|
|
|
|
#ifdef S4CLIPPER
|
|
/* block internal verification... */
|
|
for ( i = 0 ; i < b4->tag->header.keysMax ; i++ )
|
|
for ( j = i + 1 ; j <= b4->tag->header.keysMax ; j++ )
|
|
if ( b4->pointers[i] == b4->pointers[j] )
|
|
#ifdef E4ANALYZE_ALL
|
|
return error4describe( b4->tag->codeBase, e4index, E80403, b4->tag->alias, 0, 0 ) ;
|
|
#else
|
|
return error4( b4->tag->codeBase, e4index, E80403 ) ;
|
|
#endif
|
|
|
|
/* validate key count */
|
|
if ( b4numKeys( b4 ) < b4->tag->header.keysHalf && b4->tag->header.root / 512 != b4->fileBlock && b4->tag->header.keysHalf > 1 ) /* allowed if only max 2 keys per index block */
|
|
return error4describe( b4->tag->codeBase, e4index, E85709, b4->tag->alias, 0, 0 ) ;
|
|
#endif
|
|
|
|
/* all keys in a given block should be of the same type... - branch = 1 */
|
|
#ifndef S4FOX
|
|
iType = b4leaf( b4 ) ? 0 : 1 ;
|
|
#endif
|
|
|
|
/* key order verification */
|
|
#ifdef S4CLIPPER
|
|
for ( i = 0 ; i <= b4numKeys( b4 ) ; i++ )
|
|
{
|
|
val = b4key( b4, i )->pointer ;
|
|
if ( ( b4key( b4, i )->pointer ? 1 : 0 ) != iType )
|
|
#ifdef E4ANALYZE_ALL
|
|
return error4describe( b4->tag->codeBase, E80405, e4index, b4->tag->alias, 0, 0 ) ;
|
|
#else
|
|
return error4( b4->tag->codeBase, e4index, E80405 ) ;
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
for ( i = 0 ; i < b4numKeys( b4 ) - 1 ; i++ )
|
|
{
|
|
#ifdef S4FOX
|
|
if ( u4keycmp( b4keyKey( b4, i), b4keyKey( b4, i + 1 ), (unsigned)b4->tag->header.keyLen, (unsigned)b4->tag->header.keyLen, 0, &b4->tag->vfpInfo ) > 0 )
|
|
#else
|
|
if ( (*b4->tag->cmp)( b4keyKey( b4, i ), b4keyKey( b4, i + 1 ), b4->tag->header.keyLen ) > 0 )
|
|
#endif
|
|
#ifdef E4ANALYZE_ALL
|
|
return error4describe( b4->tag->codeBase, e4index, E80406, b4->tag->alias, 0, 0 ) ;
|
|
#else
|
|
return error4( b4->tag->codeBase, e4index, E80406 ) ;
|
|
#endif
|
|
}
|
|
|
|
#ifdef S4FOX
|
|
b4->curDupCnt = holdDup ;
|
|
b4->curTrailCnt = holdTrail ;
|
|
#endif
|
|
|
|
return 0 ;
|
|
}
|
|
#endif /* E4INDEX_VERIFY */
|
|
#endif /* S4CLIENT */
|
|
#endif /* S4INDEX_OFF */
|