root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cb/source/r4reinde.c

2062 lines
65 KiB
C
Raw Normal View History

Codebase git-svn-id: svn://10.65.10.50/trunk@4679 c028cbd2-c16b-5b4b-a496-9718f37d4682
1997-06-16 13:01:08 +00:00
/* r4reinde.c (c)Copyright Sequiter Software Inc., 1988-1996. All rights reserved. */
#include "d4all.h"
#ifdef __TURBOC__
#pragma hdrstop
#endif /* __TURBOC__ */
#ifndef S4OFF_WRITE
#ifndef S4INDEX_OFF
#ifndef S4CLIENT
#ifndef S4OFF_TRAN
void i4deleteRemoveKeys( INDEX4 *index )
{
TAG4 *tagOn ;
TAG4KEY_REMOVED *removed ;
for( tagOn = 0 ;; )
{
tagOn = (TAG4 *)l4next( &index->tags, tagOn ) ;
if ( tagOn == 0 )
break ;
for ( ;; )
{
removed =(TAG4KEY_REMOVED *)l4first( &tagOn->removedKeys ) ;
if ( removed == 0 )
break ;
l4remove( &tagOn->removedKeys, removed ) ;
u4free( removed ) ;
}
}
}
#endif /* S4OFF_TRAN */
#endif /* S4CLIENT */
#ifndef N4OTHER
#ifdef S4CLIENT
int S4FUNCTION i4reindex( INDEX4 *index )
{
int rc ;
CONNECTION4 *connection ;
CONNECTION4REINDEX_INFO_OUT *out ;
CODE4 *c4 ;
DATA4 *d4 ;
#ifdef S4VBASIC
if ( c4parm_check( index, 0, E92101 ) )
return -1 ;
#endif /* S4VBASIC */
#ifdef E4PARM_HIGH
if ( index == 0 )
return error4( 0, e4parm_null, E92101 ) ;
#endif
d4 = index->data ;
if ( error4code( d4->codeBase ) < 0 )
return e4codeBase ;
rc = 0 ;
connection = d4->dataFile->connection ;
if ( connection == 0 )
return e4connection ;
c4 = d4->codeBase ;
rc = connection4assign( connection, CON4INDEX_REINDEX, data4clientId( d4 ), data4serverId( d4 ) ) ;
if ( rc < 0 )
return rc ;
connection4addData( connection, index->indexFile->accessName, sizeof( index->indexFile->accessName ), 0 ) ;
rc = connection4repeat( connection, -2, -1, -1, d4 ) ;
if ( rc == r4locked )
return r4locked ;
if ( rc != 0 )
return connection4error( connection, c4, rc, E92101 ) ;
if ( connection4len( connection ) != sizeof( CONNECTION4REINDEX_INFO_OUT ) )
return error4( c4, e4packetLen, E92101 ) ;
out = (CONNECTION4REINDEX_INFO_OUT *)connection4data( connection ) ;
if ( out->lockedDatafile == 1 )
d4->dataFile->fileLock = d4 ;
d4->recNum = -1 ;
d4->recNumOld = -1 ;
memset( d4->record, ' ', dfile4recWidth( d4->dataFile ) ) ;
return 0 ;
}
#else
#include "r4reinde.h"
int S4FUNCTION i4reindex( INDEX4 *i4 )
{
R4REINDEX reindex ;
INDEX4FILE *indexFile ;
CODE4 *c4 ;
TAG4 *tagOn ;
int rc ;
DATA4 *data ;
#ifndef S4OPTIMIZE_OFF
#ifdef S4LOW_MEMORY
int hasOpt ;
#endif
#endif
#ifdef S4FOX
B4BLOCK *block ;
long rNode, goTo ;
char tagName[LEN4TAG_ALIAS + 1] ;
long i ;
int len ;
#ifdef S4BYTE_SWAP
char *swapPtr ;
S4LONG longVal ;
short shortVal ;
#endif
#endif /* S4FOX */
#ifdef S4VBASIC
if ( c4parm_check( i4, 0, E92101 ) )
return -1 ;
#endif /* S4VBASIC */
#ifdef E4PARM_HIGH
if ( i4 == 0 )
return error4( 0, e4parm_null, E92101 ) ;
#endif
c4 = i4->codeBase ;
#ifdef E4ANALYZE
if ( c4 == 0 )
return error4( 0, e4struct, E92101 ) ;
#endif
if ( error4code( c4 ) < 0 )
return e4codeBase ;
indexFile = i4->indexFile ;
data = i4->data ;
#ifndef S4OPTIMIZE_OFF
#ifdef S4LOW_MEMORY
hasOpt = c4->hasOpt ;
code4optSuspend( c4 ) ;
#endif
#endif
#ifndef S4SINGLE
rc = d4lockAll( data ) ;
if ( rc )
return rc ;
#endif /* S4SINGLE */
#ifndef S4OFF_TRAN
/* reindex is allowed, but need to fix-up any unique settings */
i4deleteRemoveKeys( i4 ) ;
#endif
for( ;; )
{
rc = r4reindexInit( &reindex, i4, i4->indexFile ) ;
if ( rc < 0 )
break ;
rc = r4reindexTagHeadersCalc( &reindex ) ;
if ( rc < 0 )
break ;
rc = r4reindexBlocksAlloc(&reindex ) ;
if ( rc < 0 )
break ;
#ifndef S4SINGLE
#ifdef S4FOX
if ( indexFile->file.lowAccessMode != OPEN4DENY_RW )
indexFile->tagIndex->header.version = indexFile->versionOld + 1 ;
#endif
#endif
#ifdef E4ANALYZE
if ( i4->tags.nLink != indexFile->tags.nLink )
{
rc = e4struct ;
break ;
}
#endif
#ifdef S4FOX
reindex.nBlocksUsed = 0 ;
tagName[LEN4TAG_ALIAS] = '\0' ;
if ( indexFile->tagIndex->header.typeCode >= 64 ) /* if .cdx */
{
reindex.tag = indexFile->tagIndex ;
rc = sort4init( &reindex.sort, c4, indexFile->tagIndex->header.keyLen, 0 ) ;
if ( rc < 0 )
break ;
reindex.sort.cmp = (S4CMP_FUNCTION *)u4memcmp ;
for( tagOn = 0, i = 1 ; ; i++ )
{
tagOn = (TAG4 *)l4next( &i4->tags, tagOn ) ;
if ( tagOn == 0 )
break ;
len = strlen( tfile4alias( tagOn->tagFile ) ) ;
memset( tagName, ' ', LEN4TAG_ALIAS ) ;
memcpy( tagName, tfile4alias( tagOn->tagFile ), (unsigned int)len ) ;
rc = sort4put( &reindex.sort, 2 * B4BLOCK_SIZE * i, tagName, "" ) ;
if ( rc < 0 )
break ;
#ifdef E4MISC
reindex.keyCount++ ;
#endif /* E4MISC */
}
if ( rc < 0 )
break ;
rc = r4reindexWriteKeys( &reindex, e4unique ) ; /* tag index should have no uniques */
if ( rc != 0 )
{
r4reindexFree( &reindex ) ;
break ;
}
}
else
if ( reindex.nTags > 1 ) /* should only be 1 tag in an .idx */
{
rc = e4index ;
break ;
}
#endif /* S4FOX */
for( tagOn = 0 ; ; )
{
tagOn = (TAG4 *)l4next( &i4->tags, tagOn ) ;
if ( tagOn == 0 )
break ;
reindex.tag = tagOn->tagFile ;
#ifdef S4FOX
reindex.nBlocksUsed = 0 ;
#else /* S4MDX */
reindex.tag->header.version++ ;
#endif /* S4FOX */
rc = expr4context( tagOn->tagFile->expr, data ) ;
if ( rc < 0 )
break ;
if ( tagOn->tagFile->filter != 0 )
{
rc = expr4context( tagOn->tagFile->filter, data ) ;
if ( rc < 0 )
break ;
}
rc = r4reindexSupplyKeys( &reindex ) ;
if ( rc )
{
r4reindexFree( &reindex ) ;
break ;
}
rc = r4reindexWriteKeys( &reindex, t4unique( tagOn ) ) ;
if ( rc )
{
r4reindexFree( &reindex ) ;
break ;
}
}
if ( rc != 0 ) /* r4unique or error */
break ;
rc = r4reindexTagHeadersWrite( &reindex ) ;
if ( rc < 0 )
break ;
#ifdef S4FOX
/* now must fix the right node branches for all blocks by moving leftwards */
for( tagOn = 0 ; ; )
{
tagOn = (TAG4 *)l4next( &i4->tags, tagOn ) ;
if ( tagOn == 0 )
break ;
for( tfile4rlBottom( tagOn->tagFile ) ; tagOn->tagFile->blocks.lastNode ; tfile4up( tagOn->tagFile ) )
{
block = tfile4block( tagOn->tagFile ) ;
goTo = block->header.leftNode ;
while ( goTo != -1 )
{
#ifdef E4DEBUG
if ( goTo <= 0 ) /* invalid value, esp. zero */
return error4( c4, e4struct, E92101 ) ;
#endif
rNode = block->fileBlock ;
if ( block->changed )
{
rc = b4flush( block ) ;
if ( rc < 0 )
break ;
}
rc = file4readAll( &indexFile->file, I4MULTIPLY*goTo, &block->header, B4BLOCK_SIZE ) ;
if ( rc < 0 )
break ;
#ifdef S4BYTE_SWAP
block->header.nodeAttribute = x4reverseShort( (void *)&block->header.nodeAttribute ) ;
block->header.nKeys = x4reverseShort( (void *)&block->header.nKeys ) ;
block->header.leftNode = x4reverseLong( (void *)&block->header.leftNode ) ;
block->header.rightNode = x4reverseLong( (void *)&block->header.rightNode ) ;
if (block->header.nodeAttribute >= 2 ) /* if block is a leaf */
{
block->nodeHdr.freeSpace = x4reverseShort( (void *)&block->nodeHdr.freeSpace ) ;
longVal = x4reverseLong( (void *)&block->nodeHdr.recNumMask[0] ) ;
memcpy( (void *)&block->nodeHdr.recNumMask[0], (void *)&longVal, sizeof(S4LONG) ) ;
}
else /* if block is a branch */
{
shortVal = block->tag->header.keyLen + sizeof(S4LONG) ;
/* position swapPtr to end of first key expression */
swapPtr = (char *) &block->nodeHdr.freeSpace + block->tag->header.keyLen ;
/* move through all B4KEY's to swap 'long's */
for ( i = 0 ; i < (int) block->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
block->fileBlock = goTo ;
if ( block->header.rightNode != rNode ) /* if a bad value */
{
block->header.rightNode = rNode ;
block->changed = 1 ;
}
goTo = block->header.leftNode ;
}
if ( rc < 0 )
break ;
block->builtOn = -1 ;
rc = b4top( block ) ;
if ( rc < 0 )
break ;
}
if ( rc < 0 )
break ;
}
if ( rc < 0 )
break ;
#endif /* S4FOX */
r4reindexFree( &reindex ) ;
#ifndef S4OPTIMIZE_OFF
#ifdef S4LOW_MEMORY
if ( hasOpt )
code4optRestart( c4 ) ;
#endif
#endif
break ;
}
if ( rc < 0 )
return error4stack( c4, (short)rc, E92101 ) ;
data->recNum = -1 ;
data->recNumOld = -1 ;
memset( data->record, ' ', dfile4recWidth( data->dataFile ) ) ;
return rc ;
}
int r4reindexInit( R4REINDEX *r4, INDEX4 *i4, INDEX4FILE *indexFile )
{
#ifdef E4PARM_LOW
if ( r4 == 0 || i4 == 0 || indexFile == 0 )
return error4( 0, e4parm_null, E92102 ) ;
#endif
memset( (void *)r4, 0, sizeof( R4REINDEX ) ) ;
r4->indexFile = indexFile ;
r4->data = i4->data ;
r4->dataFile = indexFile->dataFile ;
r4->codeBase = i4->codeBase ;
r4->minKeysmax = INT_MAX ;
r4->startBlock = 0 ;
r4->sort.file.hand = -1 ;
#ifndef S4FOX
r4->blocklen = indexFile->header.blockRw ;
#endif /* S4FOX */
r4->bufferLen = i4->codeBase->memSizeSortBuffer ;
if ( r4->bufferLen < 1024 )
r4->bufferLen = 1024 ;
r4->buffer = (char *)u4allocEr( i4->codeBase, (long)r4->bufferLen ) ;
if ( r4->buffer == 0 )
return e4memory ;
#ifdef S4FOX
r4->lastblock = 1024 ; /* leave space for the index header block */
#endif /* S4FOX */
return 0 ;
}
void r4reindexFree( R4REINDEX *r4 )
{
u4free( r4->buffer ) ;
u4free( r4->startBlock ) ;
sort4free( &r4->sort ) ;
}
int r4reindexBlocksAlloc( R4REINDEX *r4 )
{
long onCount ;
#ifdef E4PARM_LOW
if ( r4 == 0 )
return error4( 0, e4parm_null, E92102 ) ;
#endif
#ifdef E4MISC
if ( (unsigned)r4->minKeysmax > INT_MAX )
return error4( r4->codeBase, e4info, E92102 ) ;
#endif
/* Calculate the block stack height */
onCount = dfile4recCount( r4->dataFile, -2 ) ;
if ( onCount < 0 )
return error4stack( r4->codeBase, (short)onCount, E92102 ) ;
for ( r4->nBlocks = 2; onCount != 0L; r4->nBlocks++ )
onCount /= r4->minKeysmax ;
if ( r4->startBlock == 0 )
{
#ifdef S4FOX
r4->startBlock = (R4BLOCK_DATA *)u4allocEr( r4->codeBase, (long)B4BLOCK_SIZE * r4->nBlocks ) ;
#endif /* S4FOX */
#ifdef S4MDX
r4->startBlock = (R4BLOCK_DATA *)u4allocEr( r4->codeBase, (long)r4->blocklen * r4->nBlocks ) ;
#endif /* S4MDX */
}
if ( r4->startBlock == 0 )
return e4memory ;
return 0 ;
}
int r4reindexSupplyKeys( R4REINDEX *r4 )
{
FILE4SEQ_READ seqRead ;
EXPR4 *filter ;
unsigned char *keyResult ;
int rc, *filterResult ;
long count, iRec ;
DATA4FILE *dataFile ;
TAG4FILE *t4 ;
#ifndef S4MEMO_OFF
int i ;
#endif
#ifdef E4PARM_LOW
if ( r4 == 0 )
return error4( 0, e4parm_null, E92102 ) ;
#endif
dataFile = r4->dataFile ;
t4 = r4->tag ;
#ifdef E4MISC
r4->keyCount = 0L ;
#endif /* E4MISC */
rc =sort4init( &r4->sort, r4->codeBase, t4->header.keyLen, 0 ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
#ifdef S4FOX
r4->sort.cmp = (S4CMP_FUNCTION *)u4memcmp ;
#endif /* S4FOX */
#ifdef S4MDX
r4->sort.cmp = (S4CMP_FUNCTION *)t4->cmp ;
#endif /* S4MDX */
filter = t4->filter ;
count = dfile4recCount( dataFile, -2L ) ;
if ( count < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
rc = expr4context( r4->tag->expr, r4->data ) ;
if ( rc < 0 )
return rc ;
if ( r4->tag->filter != 0 )
{
rc = expr4context( r4->tag->filter, r4->data ) ;
if ( rc < 0 )
return rc ;
}
#ifdef S4ADVANCE_READ
file4seqReadInitDo( &seqRead, &dataFile->file, dfile4recordPosition( dataFile, 1L ), r4->buffer, r4->bufferLen, 1 ) ;
#else
file4seqReadInit( &seqRead, &dataFile->file, dfile4recordPosition( dataFile, 1L ), r4->buffer, r4->bufferLen ) ;
#endif
for ( iRec = 1L; iRec <= count; iRec++ )
{
rc = file4seqReadAll( &seqRead, dataFile->record, dfile4recWidth( dataFile ) ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
r4->data->recNum = iRec ;
#ifndef S4MEMO_OFF
for ( i = 0; i < dataFile->nFieldsMemo; i++ )
f4memoReset( r4->data->fieldsMemo[i].field ) ;
#endif /* S4MEMO_OFF */
if ( filter )
{
rc = expr4vary( filter, (char **)&filterResult ) ;
if ( rc < 0 )
{
#ifdef S4ADVANCE_READ
file4seqReadInitUndo( &seqRead ) ;
#endif
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
}
#ifdef E4MISC
if ( expr4type( filter ) != r4log )
{
#ifdef S4ADVANCE_READ
file4seqReadInitUndo( &seqRead ) ;
#endif
return error4( r4->codeBase, e4result, E92102 ) ;
}
#endif /* E4MISC */
if ( ! *filterResult )
continue ;
t4->hasKeys = 1 ;
#ifdef S4MDX
t4->hadKeys = 0 ;
#endif
}
tfile4exprKey( t4, &keyResult ) ;
rc = sort4put( &r4->sort, iRec, keyResult, "" ) ;
if ( rc < 0 )
{
#ifdef S4ADVANCE_READ
file4seqReadInitUndo( &seqRead ) ;
#endif
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
}
#ifdef E4MISC
r4->keyCount++ ;
#endif /* E4MISC */
}
#ifdef S4ADVANCE_READ
file4seqReadInitUndo( &seqRead ) ;
#endif
return 0 ;
}
int r4reindexTagHeadersCalc( R4REINDEX *r4 )
{
TAG4FILE *tag ;
int rc ;
CODE4 *c4 ;
#ifdef S4FOX
#ifdef S4DATA_ALIGN
unsigned int size, delta ;
#endif
int keysmax, exprType ;
#endif /* S4FOX */
#ifdef E4PARM_LOW
if ( r4 == 0 )
return error4( 0, e4parm_null, E92102 ) ;
#endif
c4 = r4->codeBase ;
r4->nTags = 0 ;
for( tag = 0 ;; )
{
tag = (TAG4FILE *)l4next( &r4->indexFile->tags, tag ) ;
if ( tag == 0 )
break ;
rc = tfile4freeAll( tag ) ;
if ( rc < 0 )
return error4stack( c4, (short)rc, E92102 ) ;
expr4context( tag->expr, r4->data ) ;
tag->header.keyLen = (short)expr4keyLen( tag->expr ) ;
#ifdef S4FOX
#ifdef S4DATA_ALIGN
size = (unsigned int)sizeof(long) + tag->header.keyLen ;
delta = 4 - size % 4 ;
tag->builtKeyMemory = mem4create( c4, 3, size + delta, 2, 0 ) ;
#else
tag->builtKeyMemory = mem4create( c4, 3, (unsigned int)sizeof(long) + tag->header.keyLen + 1, 2, 0 ) ;
#endif
exprType = expr4type( tag->expr ) ;
if ( exprType < 0 )
return error4stack( c4, (short)rc, E92102 ) ;
tfile4initSeekConv( tag, exprType ) ;
if ( tag->header.keyLen < 0 )
return error4( c4, e4index, E92102 ) ;
keysmax = ( B4BLOCK_SIZE - sizeof(B4STD_HEADER) ) / ( tag->header.keyLen + 2*sizeof(long) ) ;
if ( keysmax < r4->minKeysmax )
r4->minKeysmax = keysmax ;
#endif /* S4FOX */
#ifdef S4MDX
if ( tag->header.keyLen < 0 )
return error4( c4, e4index, E92102 ) ;
rc = expr4type( tag->expr ) ;
if ( rc < 0 )
return error4( c4, rc, E92102 ) ;
tag->header.type = (char)rc ;
if ( tag->header.type == r4dateDoub )
tag->header.type = r4date ;
if ( tag->header.type == r4numDoub )
tag->header.type = r4num ;
tfile4initSeekConv( tag, tag->header.type ) ;
tag->header.groupLen = (short)(tag->header.keyLen+ 2*sizeof(S4LONG)-1) ;
tag->header.groupLen-= (short)(tag->header.groupLen % sizeof(S4LONG)) ;
tag->header.keysMax = (short)((r4->indexFile->header.blockRw - sizeof(short)
- 6 - sizeof(S4LONG)) / tag->header.groupLen) ;
if ( tag->header.keysMax < r4->minKeysmax )
r4->minKeysmax = tag->header.keysMax ;
tag->hasKeys = 0 ;
tag->hadKeys = 1 ;
#endif /* S4MDX */
r4->nTags++ ;
}
#ifdef S4FOX
if ( r4->indexFile->tagIndex->header.typeCode >= 64 )
{
r4->lastblock += ((long)r4->nTags-1)*2*B4BLOCK_SIZE + B4BLOCK_SIZE ;
tfile4initSeekConv( r4->indexFile->tagIndex, r4str ) ;
}
else
r4->lastblock -= B4BLOCK_SIZE ;
#endif /* S4FOX */
#ifdef S4MDX
r4->lastblockInc = r4->indexFile->header.blockRw/ 512 ;
r4->lastblock = 4 + (r4->nTags-1)*r4->lastblockInc ;
#endif /* S4MDX */
return 0 ;
}
TAG4FILE *r4reindexFindITag( R4REINDEX *r4, const int tagNum )
{
/* First 'iTag' starts at '1' for this specific routine */
TAG4FILE *tagOn ;
int iTag ;
#ifdef E4PARM_LOW
if ( r4 == 0 || tagNum <= 0 )
{
error4( 0, e4parm, E92102 ) ;
return 0 ;
}
#endif
iTag = tagNum ;
tagOn = (TAG4FILE *)l4first( &r4->indexFile->tags ) ;
while ( --iTag >= 1 )
{
tagOn = (TAG4FILE *) l4next( &r4->indexFile->tags, tagOn ) ;
if ( tagOn == 0 )
return 0 ;
}
return tagOn ;
}
#ifdef S4MDX
#define GARBAGE_LEN 518
int r4reindexTagHeadersWrite( R4REINDEX *r4 )
{
/* First, calculate the T4DESC.leftChld, T4DESC.rightChld values, T4DESC.parent values */
int rc, higher[49], lower[49], parent[49] ;
TAG4FILE *tagOn, *tagPtr ;
INDEX4FILE *i4 ;
DATA4 *d4 ;
CODE4 *c4 ;
int nTag, iTag, jField, len, saveCode ;
T4DESC tagInfo ;
const char *ptr ;
#ifdef S4BYTE_SWAP
I4HEADER swapHeader ;
T4HEADER swapTagHeader ;
#endif /* S4BYTE_SWAP */
#ifdef E4PARM_LOW
if ( r4 == 0 )
return error4( 0, e4parm_null, E92102 ) ;
#endif
memset( (void *)higher, 0, sizeof( higher ) ) ;
memset( (void *)lower, 0, sizeof( lower ) ) ;
memset( (void *)parent, 0, sizeof( parent ) ) ;
i4 = r4->indexFile ;
d4 = r4->data ;
c4 = r4->codeBase ;
#ifdef E4ANALYZE
if ( i4 == 0 || d4 == 0 )
return error4( c4, e4struct, E92102 ) ;
#endif
tagOn = (TAG4FILE *) l4first( &i4->tags ) ;
if ( tagOn != 0 )
{
nTag = 1 ;
for ( ;; )
{
tagOn = (TAG4FILE *)l4next( &i4->tags, tagOn) ;
if ( tagOn == 0 )
break ;
nTag++ ;
iTag = 1 ;
for (;;)
{
tagPtr = r4reindexFindITag( r4, iTag ) ;
#ifdef E4MISC
if ( tagPtr == 0 || iTag < 0 || iTag >= 48 || nTag > 48 )
return error4( c4, e4result, E92102 ) ;
#endif /* E4MISC */
if ( u4memcmp( tagOn->alias, tagPtr->alias, sizeof(tagOn->alias)) < 0)
{
if ( lower[iTag] == 0 )
{
lower[iTag] = nTag ;
parent[nTag] = iTag ;
break ;
}
else
iTag = lower[iTag] ;
}
else
{
if ( higher[iTag] == 0 )
{
higher[iTag] = nTag ;
parent[nTag] = iTag ;
break ;
}
else
iTag = higher[iTag] ;
}
}
}
}
/* Now write the headers */
file4seqWriteInit( &r4->seqwrite, &i4->file, 0L, r4->buffer, r4->bufferLen ) ;
i4->header.eof = r4->lastblock + r4->lastblockInc ;
i4->header.freeList = 0L ;
u4yymmdd( i4->header.yymmdd ) ;
#ifdef S4BYTE_SWAP
memcpy( (void *)&swapHeader, (void *)&i4->header, sizeof(I4HEADER) ) ;
swapHeader.blockChunks = x4reverseShort( (void *)&swapHeader.blockChunks ) ;
swapHeader.blockRw = x4reverseShort( (void *)&swapHeader.blockRw ) ;
swapHeader.slotSize = x4reverseShort( (void *)&swapHeader.slotSize ) ;
swapHeader.numTags = x4reverseShort( (void *)&swapHeader.numTags ) ;
swapHeader.eof = x4reverseLong( (void *)&swapHeader.eof ) ;
swapHeader.freeList = x4reverseLong( (void *)&swapHeader.freeList ) ;
rc = file4seqWrite( &r4->seqwrite, &swapHeader, sizeof(I4HEADER) ) ;
#else
rc = file4seqWrite( &r4->seqwrite, &i4->header, sizeof(I4HEADER) ) ;
#endif /* S4BYTE_SWAP */
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
rc = file4seqWriteRepeat( &r4->seqwrite, 512-sizeof(I4HEADER)+17, 0 ) ;
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
/* There is a 0x01 on byte 17 of the first 32 bytes. */
rc = file4seqWrite( &r4->seqwrite, "\001", 1 ) ;
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
rc = file4seqWriteRepeat( &r4->seqwrite, 14, 0 ) ;
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
tagOn = (TAG4FILE *) l4first( &i4->tags ) ;
for ( iTag = 0; iTag < 47; iTag++ )
{
memset( (void *)&tagInfo, 0, sizeof(tagInfo) ) ;
if ( iTag < r4->nTags )
{
tagInfo.headerPos = 4 + (long) iTag * r4->lastblockInc ;
tagOn->headerOffset = tagInfo.headerPos * 512 ;
memcpy( (void *)tagInfo.tag, tagOn->alias, sizeof(tagInfo.tag) ) ;
tagInfo.indexType = tagOn->header.type ;
#ifdef S4BYTE_SWAP
tagInfo.headerPos = x4reverseLong( (void *)&tagInfo.headerPos ) ;
tagInfo.x1000 = 0x0010 ;
#else
tagInfo.x1000 = 0x1000 ;
#endif /* S4BYTE_SWAP */
tagInfo.x2 = 2 ;
tagInfo.leftChld = (char) lower[iTag+1] ;
tagInfo.rightChld = (char) higher[iTag+1] ;
tagInfo.parent = (char) parent[iTag+1] ;
if ( i4->header.isProduction )
{
saveCode = c4->errFieldName ;
c4->errFieldName = 0 ;
jField = d4fieldNumber( d4, tagOn->expr->source ) ;
c4->errFieldName = saveCode ;
if ( jField > 0 )
{
rc = file4write( &r4->dataFile->file, ( jField + 1 ) * sizeof( FIELD4IMAGE ) - 1, "\001", 1 ) ;
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
}
}
tagOn = (TAG4FILE *)l4next( &i4->tags, tagOn ) ;
}
rc = file4seqWrite( &r4->seqwrite, &tagInfo, sizeof( T4DESC ) ) ;
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
}
for (tagOn = 0 ;; )
{
tagOn = (TAG4FILE *)l4next( &i4->tags, tagOn ) ;
if ( tagOn == 0 )
break ;
#ifdef S4BYTE_SWAP
memcpy( (void *)&swapTagHeader, (void *)&tagOn->header, sizeof(T4HEADER) ) ;
swapTagHeader.root = x4reverseLong( (void *)&swapTagHeader.root ) ;
swapTagHeader.keyLen = x4reverseShort( (void *)&swapTagHeader.keyLen ) ;
swapTagHeader.keysMax = x4reverseShort( (void *)&swapTagHeader.keysMax ) ;
swapTagHeader.groupLen = x4reverseShort( (void *)&swapTagHeader.groupLen ) ;
swapTagHeader.unique = x4reverseShort( (void *)&swapTagHeader.unique ) ;
rc = file4seqWrite( &r4->seqwrite, &swapTagHeader, sizeof( T4HEADER ) ) ;
#else
rc = file4seqWrite( &r4->seqwrite, &tagOn->header, sizeof( T4HEADER ) ) ;
#endif /* S4BYTE_SWAP */
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
ptr = tagOn->expr->source ;
len = strlen( ptr ) ;
rc = file4seqWrite( &r4->seqwrite, ptr, len) ;
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
rc = file4seqWriteRepeat( &r4->seqwrite, 221-len, 0 ) ;
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
if( tagOn->filter != 0 )
{
rc = file4seqWriteRepeat( &r4->seqwrite, 1, 1 ) ;
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
if ( tagOn->hasKeys )
rc = file4seqWriteRepeat( &r4->seqwrite, 1, 1 ) ;
else
rc = file4seqWriteRepeat( &r4->seqwrite, 1, 0 ) ;
}
else
rc = file4seqWriteRepeat( &r4->seqwrite, 2, 0 ) ;
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
/* write extra space up to filter write point */
rc = file4seqWriteRepeat( &r4->seqwrite, GARBAGE_LEN-3 , 0 ) ;
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
if ( tagOn->filter == 0 )
len = 0 ;
else
{
ptr = tagOn->filter->source ;
len = strlen(ptr) ;
rc = file4seqWrite( &r4->seqwrite, ptr, len ) ;
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
}
rc = file4seqWriteRepeat( &r4->seqwrite, r4->blocklen - GARBAGE_LEN - len - 220 - sizeof(tagOn->header), 0 ) ;
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
}
rc = file4lenSet( &i4->file, i4->header.eof * 512) ;
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
rc = file4seqWriteFlush( &r4->seqwrite ) ;
if ( rc < 0 )
return error4stack( c4, rc, E92102 ) ;
return 0 ;
}
int r4reindexWriteKeys( R4REINDEX *r4, short int errUnique )
{
TAG4FILE *t4 ;
char lastKey[I4MAX_KEY_SIZE], *keyData ;
int isUnique, rc, isFirst ;
void *dummyPtr ;
long keyRec ;
#ifdef E4PARM_LOW
if ( r4 == 0 )
return error4( 0, e4parm_null, E92102 ) ;
#endif
t4 = r4->tag ;
r4->grouplen = t4->header.groupLen ;
r4->valuelen = t4->header.keyLen ;
r4->keysmax = t4->header.keysMax ;
memset( (void *)r4->startBlock, 0, r4->nBlocks*r4->blocklen ) ;
rc = sort4getInit( &r4->sort ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, rc, E92102 ) ;
file4seqWriteInit( &r4->seqwrite, &r4->indexFile->file, (r4->lastblock+r4->lastblockInc)*512, r4->buffer,r4->bufferLen) ;
#ifdef E4MISC
if ( I4MAX_KEY_SIZE < r4->sort.sortLen )
return error4( r4->codeBase, e4index, E82102 ) ;
#endif
isFirst = 1 ;
isUnique = t4->header.unique ;
for(;;) /* For each key to write */
{
rc = sort4get( &r4->sort, &keyRec, (void **) &keyData, &dummyPtr) ;
if ( rc < 0 )
return error4stack( r4->codeBase, rc, E92102 ) ;
#ifdef E4MISC
if ( r4->keyCount < 0L || r4->keyCount == 0L && rc != 1 || r4->keyCount > 0L && rc == 1 )
return error4( r4->codeBase, e4info, E92102 ) ;
r4->keyCount-- ;
#endif
if ( rc == 1 ) /* No more keys */
{
rc = r4reindexFinish( r4 ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, rc, E92102 ) ;
rc = file4seqWriteFlush( &r4->seqwrite ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, rc, E92102 ) ;
break ;
}
if ( isUnique )
{
if( isFirst )
isFirst = 0 ;
else
if ( (*t4->cmp)( keyData, lastKey, r4->sort.sortLen) == 0 )
{
switch( errUnique )
{
case e4unique:
return error4describe( r4->codeBase, e4unique, E82103, t4->alias, (char *)0, (char *)0 ) ;
case r4unique:
return r4unique ;
default:
continue ;
}
}
memcpy( lastKey, keyData, r4->sort.sortLen ) ;
}
/* Add the key */
rc = r4reindexAdd( r4, keyRec, (unsigned char *)keyData ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, rc, E92102 ) ;
}
/* Now complete the tag header info. */
t4->header.root = r4->lastblock ;
return 0 ;
}
int r4reindexAdd( R4REINDEX *r4, const long rec, const unsigned char *keyValue )
{
B4KEY_DATA *keyTo ;
R4BLOCK_DATA *startBlock ;
int rc ;
#ifdef E4ANALYZE
long dif ;
#endif
#ifdef E4PARM_LOW
if ( r4 == 0 || rec < 0 || keyValue == 0 )
return error4( 0, e4parm, E92102 ) ;
#endif
startBlock = r4->startBlock ;
if ( startBlock->nKeys >= r4->keysmax )
{
rc = r4reindexTodisk( r4 ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, rc, E92102 ) ;
memset( (void *)startBlock, 0, r4->blocklen ) ;
}
keyTo = (B4KEY_DATA *)( startBlock->info + (startBlock->nKeys++) * r4->grouplen ) ;
#ifdef E4ANALYZE
dif = (char *) keyTo - (char *) startBlock ;
if ( ((unsigned)dif + r4->grouplen) > r4->blocklen || dif < 0 )
return error4( r4->codeBase, e4index, E92102 ) ;
#endif
keyTo->num = rec ;
memcpy( (void *)keyTo->value, keyValue, r4->valuelen ) ;
return 0 ;
}
int r4reindexFinish( R4REINDEX *r4 )
{
R4BLOCK_DATA *block ;
int iBlock, rc ;
B4KEY_DATA *keyTo ;
#ifdef E4ANALYZE
long dif ;
#endif
#ifdef E4PARM_LOW
if ( r4 == 0 )
return error4( 0, e4parm_null, E92102 ) ;
#endif
#ifdef S4BYTE_SWAP
char *swap, *swapPtr ;
int i ;
S4LONG longVal ;
short shortVal ;
swap = (char *)u4allocEr( r4->codeBase, r4->blocklen ) ;
if ( swap == 0 )
return error4stack( r4->codeBase, e4memory, E92102 ) ;
memcpy( (void *)swap, (void *)r4->startBlock, r4->blocklen ) ;
/* 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 += r4->grouplen ;
}
/* swap the numKeys value */
shortVal = x4reverseShort( (void *)swap ) ;
memcpy( swap, (void *)&shortVal, sizeof(short) ) ;
rc = file4seqWrite( &r4->seqwrite, swap ,r4->blocklen ) ;
if ( rc < 0 )
{
u4free( swap ) ;
return error4stack( r4->codeBase, rc, E92102 ) ;
}
#else
rc = file4seqWrite( &r4->seqwrite, r4->startBlock, r4->blocklen ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, rc, E92102 ) ;
#endif /* S4BYTE_SWAP */
r4->lastblock += r4->lastblockInc ;
block = r4->startBlock ;
for( iBlock=1; iBlock < r4->nBlocks; iBlock++ )
{
block = (R4BLOCK_DATA *)( (char *)block + r4->blocklen ) ;
if ( block->nKeys >= 1 )
{
keyTo = (B4KEY_DATA *) (block->info + block->nKeys*r4->grouplen) ;
#ifdef E4ANALYZE
dif = (char *) keyTo - (char *) block ;
if ( ( (unsigned)dif + sizeof( long ) ) > r4->blocklen || dif < 0 )
return error4( r4->codeBase, e4index, E92102 ) ;
#endif
keyTo->num = r4->lastblock ;
#ifdef S4BYTE_SWAP
memcpy( (void *)swap, (void *)block, r4->blocklen ) ;
/* 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 += r4->grouplen ;
}
/* this is a branch */
longVal = x4reverseLong( (void *)swapPtr ) ;
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
/* swap the numKeys value */
shortVal = x4reverseShort( (void *)swap ) ;
memcpy( swap, (void *) &shortVal, sizeof(short) ) ;
rc = file4seqWrite( &r4->seqwrite, swap, r4->blocklen ) ;
if ( rc < 0 )
{
u4free( swap ) ;
return error4stack( r4->codeBase, rc, E92102 ) ;
}
#else
rc = file4seqWrite( &r4->seqwrite, block, r4->blocklen ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, rc, E92102 ) ;
#endif /* S4BYTE_SWAP */
r4->lastblock += r4->lastblockInc ;
}
}
#ifdef S4BYTE_SWAP
u4free( swap ) ;
#endif /* S4BYTE_SWAP */
return 0 ;
}
int r4reindexTodisk( R4REINDEX *r4 )
{
R4BLOCK_DATA *block ;
int iBlock, rc ;
B4KEY_DATA *keyOn, *keyTo ;
#ifdef E4ANALYZE
long dif ;
#endif
#ifdef S4BYTE_SWAP
char *swap, *swapPtr ;
int i ;
S4LONG longVal ;
short shortVal ;
#endif /* S4BYTE_SWAP */
#ifdef E4PARM_LOW
if ( r4 == 0 )
return error4( 0, e4parm_null, E92102 ) ;
#endif
/* Writes out the current block and adds references to higher blocks */
block = r4->startBlock ;
iBlock= 0 ;
keyOn = (B4KEY_DATA *) (block->info + (block->nKeys-1) * r4->grouplen) ;
#ifdef E4ANALYZE
dif = (char *) keyOn - (char *) block ;
if ( ( (unsigned)dif + r4->grouplen ) > r4->blocklen || dif < 0 )
return error4( r4->codeBase, e4result, E92102 ) ;
#endif /* E4ANALYZE */
for(;;)
{
#ifdef S4BYTE_SWAP
swap = (char *) u4allocEr( r4->codeBase, r4->blocklen + sizeof(S4LONG) ) ;
if ( swap == 0 )
return error4stack( r4->codeBase, e4memory, E92102 ) ;
memcpy( (void *)swap, (void *)block, r4->blocklen ) ;
/* 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 += r4->grouplen ;
}
longVal = x4reverseLong( (void *)swapPtr ) ;
memcpy( swapPtr, (void *) &longVal, sizeof(S4LONG) ) ;
/* swap the numKeys value */
shortVal = x4reverseShort( (void *)swap ) ;
memcpy( swap, (void *) &shortVal, sizeof(short) ) ;
rc = file4seqWrite( &r4->seqwrite, swap, r4->blocklen) ;
u4free( swap ) ;
#else
rc = file4seqWrite( &r4->seqwrite, block, r4->blocklen ) ;
#endif /* S4BYTE_SWAP */
if ( rc < 0 )
return error4stack( r4->codeBase, rc, E92102 ) ;
if ( iBlock )
memset( (void *)block, 0, r4->blocklen ) ;
r4->lastblock += r4->lastblockInc ;
block = (R4BLOCK_DATA *) ((char *)block + r4->blocklen) ;
iBlock++ ;
#ifdef E4ANALYZE
if ( iBlock >= r4->nBlocks )
return error4( r4->codeBase, e4info, E92102 ) ;
#endif /* E4ANALYZE */
keyTo = (B4KEY_DATA *) (block->info + block->nKeys * r4->grouplen) ;
#ifdef E4ANALYZE
dif = (char *) keyTo - (char *) block ;
if ( ( (unsigned)dif + sizeof( long ) ) > r4->blocklen || dif < 0 )
return error4( r4->codeBase, e4result, E92102 ) ;
#endif /* E4ANALYZE */
keyTo->num = r4->lastblock ;
if ( block->nKeys < r4->keysmax )
{
block->nKeys++ ;
#ifdef E4ANALYZE
if ( ((unsigned)dif+r4->grouplen) > r4->blocklen )
return error4( r4->codeBase, e4result, E92102 ) ;
#endif /* E4ANALYZE */
memcpy( keyTo->value, keyOn->value, r4->valuelen ) ;
return 0 ;
}
}
}
#endif /* ifdef S4MDX */
#ifdef S4FOX
int r4reindexTagHeadersWrite( R4REINDEX *r4 )
{
TAG4FILE *tagOn ;
INDEX4FILE *i4file ;
int rc, totLen, iTag ;
unsigned int exprHdrLen ;
const char *ptr ;
#ifdef S4BYTE_SWAP
T4HEADER swapTagHeader ;
#endif
#ifdef E4PARM_LOW
if ( r4 == 0 )
return error4( 0, e4parm_null, E92102 ) ;
#endif
iTag = 2 ;
i4file = r4->indexFile ;
/* Now write the headers */
file4seqWriteInit( &r4->seqwrite, &i4file->file, 0L, r4->buffer, r4->bufferLen ) ;
i4file->tagIndex->header.freeList = 0L ;
exprHdrLen = 5 * sizeof(short) ;
i4file->eof = r4->lastblock + B4BLOCK_SIZE ;
if ( i4file->tagIndex->header.typeCode >= 64 )
{
#ifdef S4BYTE_SWAP
memcpy( (void *)&swapTagHeader, (void *)&i4file->tagIndex->header, sizeof(T4HEADER) ) ;
swapTagHeader.root = x4reverseLong( (void *)&swapTagHeader.root ) ;
swapTagHeader.freeList = x4reverseLong( (void *)&swapTagHeader.freeList ) ;
swapTagHeader.version = x4reverseLong( (void *)&swapTagHeader.version ) ;
swapTagHeader.keyLen = x4reverseShort( (void *)&swapTagHeader.keyLen ) ;
swapTagHeader.descending = x4reverseShort( (void *)&swapTagHeader.descending ) ;
swapTagHeader.filterPos = x4reverseShort( (void *)&swapTagHeader.filterPos ) ;
swapTagHeader.filterLen = x4reverseShort( (void *)&swapTagHeader.filterLen ) ;
swapTagHeader.exprPos = x4reverseShort( (void *)&swapTagHeader.exprPos ) ;
swapTagHeader.exprLen = x4reverseShort( (void *)&swapTagHeader.exprLen ) ;
rc = file4seqWrite( &r4->seqwrite, &swapTagHeader, LEN4HEADER_WR ) ; /* write first header part */
#else
rc = file4seqWrite( &r4->seqwrite, &i4file->tagIndex->header, LEN4HEADER_WR ) ; /* write first header part */
#endif
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
rc = file4seqWriteRepeat( &r4->seqwrite, 478L, 0 ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
rc = file4seqWrite( &r4->seqwrite, &i4file->tagIndex->header.sortSeq, 8 ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
#ifdef S4BYTE_SWAP
rc = file4seqWrite( &r4->seqwrite, &swapTagHeader.descending, exprHdrLen ) ;
#else
rc = file4seqWrite( &r4->seqwrite, &i4file->tagIndex->header.descending, exprHdrLen ) ;
#endif
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
rc = file4seqWriteRepeat( &r4->seqwrite, 512L, 0 ) ; /* no expression */
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
}
for ( tagOn = 0 ;; )
{
tagOn = (TAG4FILE *)l4next( &i4file->tags, tagOn ) ;
if ( tagOn == 0 )
break ;
if ( i4file->tagIndex->header.typeCode >= 64 )
tagOn->headerOffset = ((long)iTag) * B4BLOCK_SIZE ;
else
tagOn->headerOffset = 0L ;
#ifdef S4BYTE_SWAP
memcpy( (void *)&swapTagHeader, (void *)&tagOn->header, sizeof(T4HEADER) ) ;
swapTagHeader.root = x4reverseLong( (void *)&swapTagHeader.root ) ;
swapTagHeader.freeList = x4reverseLong( (void *)&swapTagHeader.freeList ) ;
swapTagHeader.version = x4reverseLong( (void *)&swapTagHeader.version ) ;
swapTagHeader.keyLen = x4reverseShort( (void *)&swapTagHeader.keyLen ) ;
swapTagHeader.descending = x4reverseShort( (void *)&swapTagHeader.descending ) ;
swapTagHeader.filterPos = x4reverseShort( (void *)&swapTagHeader.filterPos ) ;
swapTagHeader.filterLen = x4reverseShort( (void *)&swapTagHeader.filterLen ) ;
swapTagHeader.exprPos = x4reverseShort( (void *)&swapTagHeader.exprPos ) ;
swapTagHeader.exprLen = x4reverseShort( (void *)&swapTagHeader.exprLen ) ;
rc = file4seqWrite( &r4->seqwrite, &swapTagHeader, LEN4HEADER_WR ) ;
#else
rc = file4seqWrite( &r4->seqwrite, &tagOn->header, LEN4HEADER_WR ) ;
#endif
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
rc = file4seqWriteRepeat( &r4->seqwrite, 478L, 0 ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
rc = file4seqWrite( &r4->seqwrite, &tagOn->header.sortSeq, 8 ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
#ifdef S4BYTE_SWAP
rc = file4seqWrite( &r4->seqwrite, &swapTagHeader.descending, exprHdrLen ) ;
#else
rc = file4seqWrite( &r4->seqwrite, &tagOn->header.descending, exprHdrLen ) ;
#endif
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
ptr = tagOn->expr->source ;
totLen = tagOn->header.exprLen ;
rc = file4seqWrite( &r4->seqwrite, ptr, (unsigned int)tagOn->header.exprLen ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
if ( tagOn->filter != 0 )
{
ptr = tagOn->filter->source ;
file4seqWrite( &r4->seqwrite, ptr, (unsigned int)tagOn->header.filterLen ) ;
totLen += tagOn->header.filterLen ;
}
rc = file4seqWriteRepeat( &r4->seqwrite, (long)B4BLOCK_SIZE - totLen, 0 );
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
iTag += 2 ;
}
rc = file4lenSet( &i4file->file, i4file->eof ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
rc = file4seqWriteFlush( &r4->seqwrite ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, rc, E92102 ) ;
return 0 ;
}
int r4reindexWriteKeys( R4REINDEX *r4, short int errUnique )
{
char lastKey[I4MAX_KEY_SIZE] ;
unsigned char *keyData ;
int isUnique, rc, cLen, tLen, lastTrail ;
int onCount, isFirst ;
unsigned short int kLen ;
void *dummyPtr ;
long keyRec, recCount ;
TAG4FILE *t4 ;
unsigned long ff ;
unsigned long rLen ;
R4BLOCK_DATA *r4block ;
#ifdef E4PARM_LOW
if ( r4 == 0 )
return error4( 0, e4parm_null, E92102 ) ;
#endif
t4 = r4->tag ;
kLen = (unsigned short int)t4->header.keyLen ;
ff = 0xFFFFFFFFL ;
isFirst = 1 ;
memset( lastKey, r4->tag->pChar, kLen ) ;
for ( cLen = 0 ; kLen ; kLen >>= 1, cLen++ ) ;
kLen = (unsigned short int)t4->header.keyLen ; /* reset the key length */
r4->nodeHdr.trailCntLen = r4->nodeHdr.dupCntLen = (unsigned char)cLen ;
r4->nodeHdr.trailByteCnt = (unsigned char)(0xFF >> ( 8 - ((cLen / 8) * 8 + cLen % 8))) ;
r4->nodeHdr.dupByteCnt = r4->nodeHdr.trailByteCnt ;
recCount = dfile4recCount( r4->dataFile, -2L ) ;
if ( recCount < 0 )
return error4stack( r4->codeBase, (short)recCount, E92102 ) ;
rLen = (unsigned long)recCount ;
for ( cLen = 0 ; rLen ; rLen>>=1, cLen++ ) ;
r4->nodeHdr.recNumLen = (unsigned char) cLen ;
if ( r4->nodeHdr.recNumLen < 12 )
r4->nodeHdr.recNumLen = 12 ;
for( tLen = r4->nodeHdr.recNumLen + r4->nodeHdr.trailCntLen + r4->nodeHdr.dupCntLen ;
(tLen / 8)*8 != tLen ; tLen++, r4->nodeHdr.recNumLen++ ) ; /* make at an 8-bit offset */
rLen = ff >> ( sizeof(long)*8 - r4->nodeHdr.recNumLen ) ;
memcpy( (void *)&r4->nodeHdr.recNumMask[0], (void *)&rLen, sizeof(long) ) ;
r4->nodeHdr.infoLen = (unsigned char)((unsigned int)(r4->nodeHdr.recNumLen + r4->nodeHdr.trailCntLen + r4->nodeHdr.dupCntLen) / 8) ;
r4->valuelen = t4->header.keyLen ;
r4->grouplen = t4->header.keyLen + 2*sizeof(long) ;
memset( (void *)r4->startBlock, 0, (unsigned int)r4->nBlocks * B4BLOCK_SIZE ) ;
#ifdef S4FOX
for ( r4block = r4->startBlock, onCount = 0 ; onCount < r4->nBlocks;
r4block = (R4BLOCK_DATA *) ( (char *)r4block + B4BLOCK_SIZE), onCount++ )
{
memset( (void *)r4block, 0, B4BLOCK_SIZE ) ;
r4block->header.leftNode = -1 ;
r4block->header.rightNode = -1 ;
}
#endif /* S4FOX */
r4->nodeHdr.freeSpace = B4BLOCK_SIZE - sizeof( B4STD_HEADER ) - sizeof( B4NODE_HEADER ) ;
r4->keysmax = (B4BLOCK_SIZE - sizeof( B4STD_HEADER ) ) / (unsigned)r4->grouplen ;
#ifdef E4ANALYZE
if ( r4->nodeHdr.freeSpace <= 0 || r4->keysmax <= 0 )
return error4( r4->codeBase, e4index, E92102 ) ;
#endif
rc = sort4getInit( &r4->sort ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
file4seqWriteInit( &r4->seqwrite, &r4->indexFile->file, r4->lastblock+B4BLOCK_SIZE, r4->buffer, r4->bufferLen ) ;
#ifdef E4MISC
if ( I4MAX_KEY_SIZE < r4->sort.sortLen )
return error4( r4->codeBase, e4index, E92102 ) ;
#endif /* E4MISC */
lastTrail = kLen ; /* default is no available duplicates */
isUnique = t4->header.typeCode & 0x01 ;
for( ;; ) /* For each key to write */
{
rc = sort4get( &r4->sort, &keyRec, (void **) &keyData, &dummyPtr ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
#ifdef E4MISC
if ( r4->keyCount < 0L || r4->keyCount == 0L && rc != 1 || r4->keyCount > 0L && rc == 1 )
return error4( r4->codeBase, e4info, E92102 ) ;
r4->keyCount-- ;
#endif /* E4MISC */
if ( rc == 1 ) /* No more keys */
{
rc = r4reindexFinish( r4, lastKey ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
rc = file4seqWriteFlush( &r4->seqwrite ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
break ;
}
if ( isUnique )
{
if( isFirst )
isFirst = 0 ;
else
if ( u4memcmp( keyData, lastKey, r4->sort.sortLen) == 0 )
{
switch( errUnique )
{
case e4unique:
case e4candidate:
return error4describe( r4->codeBase, e4unique, E82103, t4->alias, (char *)0, (char *)0 ) ;
case r4unique:
case r4candidate:
return r4unique ;
default:
continue ;
}
}
}
/* Add the key */
rc = r4reindexAdd( r4, keyRec, keyData, lastKey, &lastTrail ) ;
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
memcpy( lastKey, keyData, r4->sort.sortLen ) ;
}
/* Now complete the tag header info. */
t4->header.root = r4->lastblock ;
return 0 ;
}
/* for compact leaf nodes only */
int r4reindexAdd( R4REINDEX *r4, const long rec, const unsigned char *keyValue, const char *lastKey, int *lastTrail )
{
R4BLOCK_DATA *startBlock ;
int rc, dupCnt, trail, kLen, iLen, len ;
unsigned char buffer[6] ;
char *infoPos ;
#ifdef E4PARM_LOW
if ( r4 == 0 || rec < 0 || keyValue == 0 )
return error4( 0, e4parm, E92102 ) ;
#endif
startBlock = r4->startBlock ;
kLen = r4->valuelen ;
iLen = r4->nodeHdr.infoLen ;
if ( startBlock->header.nKeys == 0 ) /* reset */
{
dupCnt = 0 ;
r4->curPos = ((char *)startBlock) + B4BLOCK_SIZE ;
memcpy( ((char *)startBlock) + sizeof( B4STD_HEADER ), (void *)&r4->nodeHdr, sizeof( B4NODE_HEADER ) ) ;
startBlock->header.nodeAttribute |= 2 ; /* leaf block */
*lastTrail = kLen ;
}
else
dupCnt = b4calcDups( keyValue,(const unsigned char*)lastKey, kLen ) ;
if ( dupCnt > kLen - *lastTrail ) /* don't allow duplicating trail bytes */
dupCnt = kLen - *lastTrail ;
if ( dupCnt == kLen ) /* duplicate key */
trail = 0 ;
else
{
if ( d4version( r4->data ) != 0x30 && r4->codeBase->compatibility == 26 && r4->tag->filter != 0 )
trail = 0 ;
else
trail = b4calcBlanks( keyValue, kLen, r4->tag->pChar ) ;
}
*lastTrail = trail ;
if ( dupCnt > kLen - *lastTrail ) /* watch for case where < ' ' exissts */
dupCnt = kLen - *lastTrail ;
len = kLen - dupCnt - trail ;
if ( r4->nodeHdr.freeSpace < iLen + len )
{
rc = r4reindexTodisk(r4, lastKey) ;
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
r4->nodeHdr.freeSpace = B4BLOCK_SIZE - sizeof( B4STD_HEADER ) - sizeof( B4NODE_HEADER ) ;
dupCnt = 0 ;
r4->curPos = ((char *)startBlock) + B4BLOCK_SIZE ;
memcpy( ((char *)&startBlock->header) + sizeof( B4STD_HEADER ), (void *)&r4->nodeHdr, sizeof( B4NODE_HEADER ) ) ;
startBlock->header.nodeAttribute |= 2 ; /* leaf block */
if ( d4version( r4->data ) != 0x30 && r4->codeBase->compatibility == 26 && r4->tag->filter != 0 )
trail = 0 ;
else
trail = b4calcBlanks( keyValue, kLen, r4->tag->pChar ) ;
len = kLen - trail ;
}
r4->curPos -= len ;
memcpy( r4->curPos, keyValue + dupCnt, (unsigned int)len ) ;
infoPos = ((char *)&startBlock->header) + sizeof(B4STD_HEADER) + sizeof(B4NODE_HEADER) + startBlock->header.nKeys * iLen ;
x4putInfo( &r4->nodeHdr, buffer, rec, trail, dupCnt ) ;
memcpy( infoPos, (void *)buffer, (unsigned int)iLen ) ;
r4->nodeHdr.freeSpace -= (unsigned char) ( len + iLen ) ;
startBlock->header.nKeys++ ;
return 0 ;
}
int r4reindexFinish( R4REINDEX *r4, char *keyValue )
{
R4BLOCK_DATA *block ;
int rc, iBlock ;
long revLb, lRecno ;
char *keyTo ;
#ifdef S4DATA_ALIGN
long longTemp ;
#endif
#ifdef S4BYTE_SWAP
char swap[B4BLOCK_SIZE] ;
char *swapPtr ;
int i ;
S4LONG longVal ;
short shortVal ;
#endif
#ifdef E4PARM_LOW
if ( r4 == 0 )
return error4( 0, e4parm_null, E92102 ) ;
#endif
block = r4->startBlock ;
if ( r4->nBlocksUsed <= 1 ) /* just output first block */
{
memcpy( ((char *)block) + sizeof( B4STD_HEADER ), (void *)&r4->nodeHdr, sizeof( B4NODE_HEADER ) ) ;
block->header.nodeAttribute |= (short)3 ; /* leaf and root block */
#ifdef S4BYTE_SWAP
memcpy( (void *)swap, (void *)block, B4BLOCK_SIZE ) ;
/* position at either B4NODE_HEADER (leaf) or data (branch) */
swapPtr = swap + 2 * sizeof( short) + 2 * sizeof(S4LONG) ;
if (block->header.nodeAttribute >= 2 ) /* if block is a leaf */
{
/* 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 = r4->tag->header.keyLen + sizeof(S4LONG) ;
/* position swapPtr to end of first key expression */
swapPtr += r4->tag->header.keyLen ;
/* move through all B4KEY's to swap 'long's */
for ( i = 0 ; i < (int)block->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 ;
}
}
/* 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) ;
rc = file4seqWrite( &r4->seqwrite, swap,B4BLOCK_SIZE ) ;
#else
rc = file4seqWrite( &r4->seqwrite, block,B4BLOCK_SIZE ) ;
#endif
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
r4->lastblock += B4BLOCK_SIZE ;
}
else
{
memcpy( (void *)&lRecno, (void *) (((char *)(&block->header)) + sizeof(B4STD_HEADER)
+ sizeof(B4NODE_HEADER) + (block->header.nKeys - 1) * r4->nodeHdr.infoLen), sizeof( long ) ) ;
#ifdef S4DO_BYTEORDER
lRecno = x4reverseLong( (void *)&lRecno ) ;
#endif
#ifdef S4DATA_ALIGN
memcpy( (void *)&longTemp, (void *)&r4->nodeHdr.recNumMask[0], sizeof(S4LONG) ) ;
lRecno &= longTemp ;
#else
lRecno &= *(long *)&r4->nodeHdr.recNumMask[0] ;
#endif
if ( block->header.nodeAttribute >= 2 ) /* if leaf, record freeSpace */
memcpy( ((char *)block) + sizeof( B4STD_HEADER ), (void *)&r4->nodeHdr, sizeof( B4NODE_HEADER ) ) ;
#ifdef S4BYTE_SWAP
memcpy( (void *)swap, (void *)r4->startBlock, B4BLOCK_SIZE ) ;
/* position at either B4NODE_HEADER (leaf) or data (branch) */
swapPtr = swap + 2 * sizeof( short) + 2 * sizeof(S4LONG) ;
if (block->header.nodeAttribute >= 2 ) /* if block is a leaf */
{
/* 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 = r4->tag->header.keyLen + sizeof(S4LONG) ;
/* position swapPtr to end of first key expression */
swapPtr += r4->tag->header.keyLen ;
/* move through all B4KEY's to swap 'long's */
for ( i = 0 ; i < (int) block->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 ;
}
}
/* 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) ;
rc = file4seqWrite( &r4->seqwrite, swap,B4BLOCK_SIZE ) ;
#else
rc = file4seqWrite(&r4->seqwrite, r4->startBlock,B4BLOCK_SIZE ) ;
#endif
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
r4->lastblock += B4BLOCK_SIZE ;
lRecno = x4reverseLong( (void *)&lRecno ) ;
for( iBlock=1; iBlock < r4->nBlocksUsed ; iBlock++ )
{
block = (R4BLOCK_DATA *) ((char *)block + B4BLOCK_SIZE) ;
keyTo = ((char *) (&block->header)) + sizeof(B4STD_HEADER) + block->header.nKeys * r4->grouplen ;
block->header.nKeys++ ;
#ifdef E4MISC
if ( (char *) keyTo - (char *) block + r4->grouplen > B4BLOCK_SIZE ||
(char *) keyTo - (char *) block < 0 )
return error4( r4->codeBase, e4result, E92102 ) ;
#endif /* E4MISC */
memcpy( keyTo, (void *)keyValue, (unsigned int)r4->valuelen ) ;
keyTo += r4->valuelen ;
memcpy( keyTo, (void *)&lRecno, sizeof( long ) ) ;
revLb = x4reverseLong( (void *)&r4->lastblock ) ;
memcpy( keyTo + sizeof( long ), (void *)&revLb, sizeof( long ) ) ;
if ( iBlock == r4->nBlocksUsed - 1 )
block->header.nodeAttribute = 1 ; /* root block */
#ifdef S4BYTE_SWAP
memcpy( (void *)swap, (void *)block, B4BLOCK_SIZE ) ;
/* position at either B4NODE_HEADER (leaf) or data (branch) */
swapPtr = swap + 2 * sizeof( short) + 2 * sizeof(S4LONG) ;
if (block->header.nodeAttribute >= 2 ) /* if block is a leaf */
{
/* 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 = r4->tag->header.keyLen + sizeof(S4LONG) ;
/* position swapPtr to end of first key expression */
swapPtr += r4->tag->header.keyLen ;
/* move through all B4KEY's to swap 'long's */
for ( i = 0 ; i < (int) block->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 ;
}
}
/* 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) ;
rc = file4seqWrite( &r4->seqwrite, swap, B4BLOCK_SIZE ) ;
#else
rc = file4seqWrite( &r4->seqwrite, block, B4BLOCK_SIZE ) ;
#endif
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
r4->lastblock += B4BLOCK_SIZE ;
}
}
return 0 ;
}
/* Writes out the current block and adds references to higher blocks */
int r4reindexTodisk( R4REINDEX *r4, const char *keyValue )
{
R4BLOCK_DATA *block ;
long lRecno, revLb ;
int tnUsed, rc ;
char *keyTo ;
#ifdef S4DATA_ALIGN
long longTemp ;
#endif
#ifdef S4BYTE_SWAP
char swap[B4BLOCK_SIZE] ;
char *swapPtr ;
int i ;
S4LONG longVal ;
short shortVal ;
#endif
#ifdef E4ANALYZE
int iBlock ;
iBlock = 0 ;
#endif
#ifdef E4PARM_LOW
if ( r4 == 0 )
return error4( 0, e4parm_null, E92102 ) ;
#endif
block = r4->startBlock ;
tnUsed = 1 ;
memcpy( (void *)&lRecno, ((unsigned char *) (&block->header)) + sizeof(B4STD_HEADER)
+ sizeof(B4NODE_HEADER) + (block->header.nKeys - 1) * r4->nodeHdr.infoLen, sizeof( long ) ) ;
#ifdef S4DO_BYTEORDER
lRecno = x4reverseLong( (void *)&lRecno ) ;
#endif
#ifdef S4DATA_ALIGN
memcpy( (void *)&longTemp, (void *)&r4->nodeHdr.recNumMask[0], sizeof(S4LONG) ) ;
lRecno &= longTemp ;
#else
lRecno &= *(long *)&r4->nodeHdr.recNumMask[0] ;
#endif
lRecno = x4reverseLong( (void *)&lRecno ) ;
for(;;)
{
tnUsed++ ;
r4->lastblock += B4BLOCK_SIZE ;
/* next line only works when on leaf branches... */
block->header.rightNode = r4->lastblock + B4BLOCK_SIZE ;
if ( block->header.nodeAttribute >= 2 ) /* if leaf, record freeSpace */
memcpy( ((char *)block) + sizeof( B4STD_HEADER ), (void *)&r4->nodeHdr.freeSpace, sizeof( r4->nodeHdr.freeSpace ) ) ;
#ifdef S4BYTE_SWAP
memcpy( (void *)swap, (void *)block, 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 (r4->startBlock->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 = r4->tag->header.keyLen + sizeof(S4LONG) ;
/* position swapPtr to end of first key expression */
swapPtr += r4->tag->header.keyLen ;
/* move through all B4KEY's to swap 'long's */
for ( i = 0 ; i < (int) block->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 ;
}
}
/* 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) ;
rc = file4seqWrite( &r4->seqwrite, swap, B4BLOCK_SIZE ) ;
#else
rc = file4seqWrite( &r4->seqwrite, block, B4BLOCK_SIZE ) ;
#endif
if ( rc < 0 )
return error4stack( r4->codeBase, (short)rc, E92102 ) ;
memset( (void *)block, 0, B4BLOCK_SIZE ) ;
block->header.leftNode = r4->lastblock ;
block->header.rightNode = -1 ;
block = (R4BLOCK_DATA *) ((char *)block + B4BLOCK_SIZE) ;
#ifdef E4ANALYZE
iBlock++ ;
if ( iBlock >= r4->nBlocks )
return error4( r4->codeBase, e4info, E92102 ) ;
#endif /* E4ANALYZE */
if ( block->header.nKeys < r4->keysmax )
{
keyTo = ((char *) (&block->header)) + sizeof(B4STD_HEADER) + block->header.nKeys * r4->grouplen ;
block->header.nKeys++ ;
#ifdef E4ANALYZE
if ( (char *) keyTo - (char *) block + r4->grouplen > B4BLOCK_SIZE || (char *) keyTo - (char *) block < 0 )
return error4( r4->codeBase, e4result, E92102 ) ;
#endif /* E4ANALYZE */
memcpy( keyTo, (void *)keyValue, (unsigned int)r4->valuelen ) ;
keyTo += r4->valuelen ;
memcpy( keyTo, (void *)&lRecno, sizeof( long ) ) ;
revLb = x4reverseLong( (void *)&r4->lastblock ) ;
memcpy( keyTo + sizeof( long ), (void *)&revLb, sizeof( long ) ) ;
if ( block->header.nKeys < r4->keysmax ) /* then done, else do next one up */
{
if ( tnUsed > r4->nBlocksUsed )
r4->nBlocksUsed = tnUsed ;
return 0 ;
}
}
#ifdef E4ANALYZE
else /* should never occur */
return error4( r4->codeBase, e4result, E92102 ) ;
#endif /* E4ANALYZE */
}
}
#endif /* S4FOX */
#endif /* S4CLIENT */
#endif /* N4OTHER */
#endif /* S4INDEX_OFF */
#endif /* S4WRITE_OFF */
Reference in New Issue Copy Permalink