root/campo-sirio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
campo-sirio/cb5/i4tag.c

1521 lines
35 KiB
C
Raw Normal View History

This commit was generated by cvs2svn to compensate for changes in r975, which included commits to RCS files with non-trunk default branches. git-svn-id: svn://10.65.10.50/trunk@976 c028cbd2-c16b-5b4b-a496-9718f37d4682
1995-02-06 15:33:45 +00:00
/* i4tag.c (c)Copyright Sequiter Software Inc., 1990-1994. All rights reserved. */
#include "d4all.h"
#ifndef S4UNIX
#ifdef __TURBOC__
#pragma hdrstop
#endif
#endif
/*#ifndef S4LANGUAGE */
/*#ifndef u4memcmp */
/*int S4CALL u4memcmp( S4CMP_PARM p1, S4CMP_PARM p2, size_t len ) */
/*{ */
/* return memcmp( p1, p2, len ) ; */
/*} */
/*#endif */
/*#endif */
#ifndef S4INDEX_OFF
#include <time.h>
#ifdef S4HAS_DESCENDING
long S4FUNCTION t4dskip( TAG4 *t4, long num_skip )
{
if ( t4->header.descending )
return -t4skip( t4, -num_skip ) ;
else
return t4skip( t4, num_skip ) ;
}
#endif
void S4FUNCTION t4out_of_date( TAG4 *t4 )
{
#ifdef S4SINGLE
#ifdef S4DEBUG_DEV
e4describe( t4->code_base, e4index, t4->alias, "t4out_of_date()", "index file can't be out of date with S4SINGLE, so corrupt" ) ;
#endif
e4( t4->code_base, e4index, t4->alias ) ;
#else
time_t old_time ;
/* first make sure we are at a potential read conflict situation (otherwise must be corrupt file) */
#ifdef N4OTHER
if ( t4lock_test( t4 ) )
#else
if ( i4lock_test( t4->index ) )
#endif
{
#ifdef S4DEBUG_DEV
e4describe( t4->code_base, e4index, t4->alias, "t4out_of_date()", "index file can't be out of date since is exclusive, locked, or dos read-only" ) ;
#endif
e4( t4->code_base, e4index, t4->alias ) ;
}
/* wait a second and refresh */
time( &old_time) ;
while ( time( (time_t *)0 ) <= old_time) ;
#ifdef N4OTHER
file4refresh( &t4->file ) ;
#else
file4refresh( &t4->index->file ) ;
#endif
#endif
}
/* uses parent to determine if an inconsistancy has arisen */
/* return -1 = error, 0 = success, 1 = inconsistant */
int S4FUNCTION i4read_block( FILE4 *file, long block_no, B4BLOCK *parent, B4BLOCK *block )
{
int rc ;
TAG4 *tag ;
#ifdef S4CLIPPER
#ifdef S4INDEX_VERIFY
int i, j ;
#endif
#endif
#ifdef S4BYTE_SWAP
char *swap_ptr ;
int i ;
S4LONG long_val ;
#ifdef S4FOX
short short_val ;
#endif
#endif
#ifndef S4FOX
#ifndef S4CLIPPER
/* i.e. if ndx or mdx */
int par_on, blk_on, eq ;
#ifdef S4MDX
if ( file4read_all( file, I4MULTIPLY * block_no, &block->n_keys, block->tag->index->header.block_rw ) < 0 )
return -1 ;
#ifdef S4BYTE_SWAP
/* swap the num_keys value */
block->n_keys = x4reverse_short( (void *)&block->n_keys ) ;
/* position swap_ptr at beginning of B4KEY's */
swap_ptr = (char *)&block->n_keys ;
swap_ptr += 6 + sizeof(short) ;
/* move through all B4KEY's to swap 'long' */
for ( i = 0 ; i < (int) block->n_keys ; i++ )
{
long_val = x4reverse_long( (void *)swap_ptr ) ;
memcpy( swap_ptr, (void *) &long_val, sizeof(S4LONG) ) ;
swap_ptr += block->tag->header.group_len ;
}
/* mark last_pointer */
if ( !b4leaf( block ) )
{
long_val = x4reverse_long( (void *)swap_ptr ) ;
memcpy( swap_ptr, (void *) &long_val, sizeof(S4LONG) ) ;
}
#endif
#endif
#ifdef S4NDX
if ( file4read_all( file, I4MULTIPLY * block_no, &block->n_keys, B4BLOCK_SIZE ) < 0 )
return -1 ;
block->file_block = block_no ;
/*BYTE_SWAP!!!*/
#endif
#endif
#endif
rc = 0 ;
tag = block->tag ;
#ifdef S4FOX
if ( file4read_all( file, I4MULTIPLY * block_no, &block->header, B4BLOCK_SIZE) < 0 )
return -1 ;
#ifdef S4BYTE_SWAP
block->header.node_attribute = x4reverse_short( (void *)&block->header.node_attribute ) ;
block->header.n_keys = x4reverse_short( (void *)&block->header.n_keys ) ;
block->header.left_node = x4reverse_long( (void *)&block->header.left_node ) ;
block->header.right_node = x4reverse_long( (void *)&block->header.right_node ) ;
/* if block is a leaf */
if (block->header.node_attribute >= 2 )
{
block->node_hdr.free_space = x4reverse_short( (void *)&block->node_hdr.free_space ) ;
long_val = x4reverse_long( (void *)&block->node_hdr.rec_num_mask[0] ) ;
memcpy( (void *)&block->node_hdr.rec_num_mask[0], (void *)&long_val, sizeof(S4LONG) ) ;
}
else /* if block is a branch */
{
short_val = block->tag->header.key_len + sizeof(S4LONG) ;
/* position swap_ptr to end of first key expression */
swap_ptr = (char *) &block->node_hdr.free_space + block->tag->header.key_len ;
/* move through all B4KEY's to swap 'long's */
for ( i = 0 ; i < (int) block->header.n_keys ; i++ )
{
long_val = x4reverse_long( (void *)swap_ptr ) ;
memcpy( swap_ptr, (void *) &long_val, sizeof(S4LONG) ) ;
swap_ptr += sizeof(S4LONG) ;
long_val = x4reverse_long( (void *)swap_ptr ) ;
memcpy( swap_ptr, (void *) &long_val, sizeof(S4LONG) ) ;
swap_ptr += short_val ;
}
}
#endif
#endif
#ifdef S4CLIPPER
if ( file4read_all( file, block_no, &block->n_keys, B4BLOCK_SIZE ) < 0 )
return -1 ;
#ifdef S4BYTE_SWAP
block->n_keys = x4reverse_short( (void *)&block->n_keys ) ;
/* BYTE_SWAP!!! */
#endif
block->file_block = block_no/512 ;
#endif
if ( tag->code_base->do_index_verify == 0 )
return rc ;
#ifdef N4OTHER
if ( block->n_keys == 0 )
#ifdef S4NDX
if ( tag->header.root != block->file_block ) /* block has no keys but is not the root, must be a problem... */
#endif
#ifdef S4CLIPPER
if ( tag->header.root != block->file_block * I4MULTIPLY ) /* block has no keys but is not the root, must be a problem... */
#endif
#else
#ifdef S4FOX
if ( block->header.n_keys == 0 ) /* added to free list... therefore bad */
if ( tag->header.root != block_no ) /* block has no keys but is not the root, must be a problem... */
#else
if ( block->n_keys == 0 ) /* added to free list... therefore bad */
if ( tag->header.root != block_no ) /* block has no keys but is not the root, must be a problem... */
#endif
#endif
return 1 ;
if ( parent != 0 ) /* check consistancy */
{
#ifndef S4FOX
#ifndef S4CLIPPER
/* i.e. if ndx or mdx */
eq = 0 ;
blk_on = block->n_keys - 1 ;
if ( parent->key_on >= parent->n_keys )
{
par_on = parent->n_keys - 1 ;
eq = 1 ;
}
else
par_on = parent->key_on ;
if ( !b4leaf( block ) )
{
blk_on = 0 ;
if ( eq != 1 )
{
if ( par_on == 0 )
eq = 2 ;
else
{
eq = 1 ;
par_on-- ;
}
}
}
switch( eq )
{
case 0:
if ( tag->cmp( b4key_key( parent, par_on ), b4key_key( block, blk_on ), tag->header.key_len ) != 0 )
rc = 1 ;
break ;
case 1:
if ( tag->cmp( b4key_key( parent, par_on ), b4key_key( block, blk_on ), tag->header.key_len ) > 0 )
rc = 1 ;
break ;
case 2:
if ( tag->cmp( b4key_key( parent, par_on ), b4key_key( block, blk_on ), tag->header.key_len ) < 0 )
rc = 1 ;
break ;
#ifdef S4DEBUG
default:
e4severe( e4info, E4_I4READ_BLOCK ) ;
#endif
}
#endif
#endif
#ifdef S4FOX
if ( rc == 0 )
if ( b4recno( parent, parent->key_on) != b4recno( block, block->header.n_keys - 1 ) )
rc = 1 ;
#endif
if ( rc == 0 )
{
#ifdef S4INDEX_VERIFY
if ( b4verify( block ) == -1 )
e4describe( block->tag->code_base, e4index, block->tag->alias, "i4read_block()-block", "" ) ;
if ( b4verify( parent ) == -1 )
e4describe( parent->tag->code_base, e4index, parent->tag->alias, "i4read_block()-parent", "" ) ;
#endif
}
#ifdef S4CLIPPER
if ( rc == 0 )
{
if ( parent->key_on < parent->n_keys )
{
if ( tag->cmp( b4key_key( parent, parent->key_on ), b4key_key( block, block->n_keys - 1 ), tag->header.key_len ) < 0 )
rc = 1 ;
}
else
{
if ( tag->cmp( b4key_key( parent, parent->key_on - 1 ), b4key_key( block, 0 ), tag->header.key_len ) > 0 )
rc = 1 ;
}
}
#endif
}
if ( rc == 1 )
#ifdef N4OTHER
if ( t4lock_test( tag ) == 1 ) /* corrupt */
#else
if ( i4lock_test( tag->index ) == 1 ) /* corrupt */
#endif
{
#ifdef S4DEBUG_DEV
e4describe( tag->code_base, e4index, tag->alias, "i4read_block()", "Parent-leaf mismatch, index not out of date since exclusive, locked, or read-only" ) ;
#endif
e4( tag->code_base, e4index, E4_INFO_CIF ) ;
}
return rc ;
}
int S4FUNCTION t4expr_key( TAG4 *tag, char **ptr_ptr )
{
int len ;
#ifdef S4CLIPPER
int old_dec ;
old_dec = tag->code_base->decimals ;
tag->code_base->decimals = tag->header.key_dec ;
#endif
len = expr4key( tag->expr, ptr_ptr ) ;
#ifdef S4CLIPPER
tag->code_base->decimals = old_dec ;
#endif
return len ;
}
int S4FUNCTION t4go( TAG4 *t4, char *ptr, long rec_num )
{
int rc ;
#ifdef S4HAS_DESCENDING
int old_desc ;
old_desc = t4->header.descending ;
t4->header.descending = 0 ;
#endif
rc = t4go2( t4, ptr, rec_num ) ;
#ifdef S4HAS_DESCENDING
t4->header.descending = (short) old_desc ;
#endif
return rc ;
}
#ifndef N4OTHER
#ifdef S4FOX
#ifdef S4HAS_DESCENDING
void S4FUNCTION t4descending( TAG4 *tag, int setting )
{
tag->header.descending = (short)setting ;
}
#endif
void t4str_to_fox( char *result, char *input_ptr, int input_ptr_len )
{
t4dbl_to_fox( result, c4atod( input_ptr, input_ptr_len ) ) ;
}
void t4dtstr_to_fox( char *result, char *input_ptr, int input_ptr_len )
{
t4dbl_to_fox( result, (double) date4long( input_ptr ) ) ;
}
int S4FUNCTION t4rl_bottom( TAG4 *t4 )
{
int rc ;
B4BLOCK *block_on ;
if ( t4->code_base->error_code < 0 )
return -1 ;
do
{
rc = t4up_to_root( t4 ) ;
if ( rc < 0 )
return -1 ;
if ( rc != 2 )
{
b4go( t4block( t4 ), t4block( t4 )->header.n_keys - 1 ) ;
do
{
rc = t4down( t4 ) ;
if ( rc < 0 )
return -1 ;
b4go( t4block( t4 ), t4block( t4 )->header.n_keys - 1 ) ;
} while ( rc == 0 ) ;
}
if ( rc == 2 ) /* failed due to read while locked */
t4out_of_date( t4 ) ;
} while ( rc == 2 ) ;
block_on = t4block(t4) ;
if ( block_on->key_on > 0 )
{
b4go_eof( block_on ) ;
block_on->key_on-- ; /* update key_on after going to last spot */
}
return 0 ;
}
int S4FUNCTION t4bottom( TAG4 *t4 )
{
#ifdef S4DEBUG
if ( t4 == 0 )
e4severe( e4parm, E4_T4BOTTOM ) ;
#endif
if ( t4->code_base->error_code < 0 )
return -1 ;
if ( t4->header.descending ) /* if descending, go bottom means go top */
return t4rl_top( t4 ) ;
else
return t4rl_bottom( t4 ) ;
}
#else /* if not S4FOX */
int S4FUNCTION t4bottom( TAG4 *t4 )
{
int rc ;
B4BLOCK *block_on ;
#ifdef S4DEBUG
if ( t4 == 0 )
e4severe( e4parm, E4_T4BOTTOM ) ;
#endif
if ( t4->code_base->error_code < 0 )
return -1 ;
rc = 2 ;
while ( rc == 2 )
{
rc = t4up_to_root( t4 ) ;
if ( rc < 0 )
return -1 ;
if ( rc != 2 )
{
b4go_eof( t4block(t4) ) ;
do
{
rc = t4down( t4 ) ;
if ( rc < 0 )
return -1 ;
b4go_eof( t4block(t4) ) ;
} while ( rc == 0 ) ;
}
if ( rc == 2 ) /* failed due to read while locked */
t4out_of_date( t4 ) ;
}
block_on = t4block(t4) ;
if ( block_on->key_on > 0 )
block_on->key_on = block_on->n_keys-1 ;
return 0 ;
}
#endif /* ifdef S4FOX */
B4BLOCK *S4FUNCTION t4block( TAG4 *t4 )
{
#ifdef S4DEBUG
if ( t4 == 0 )
e4severe( e4parm, E4_T4BLOCK ) ;
if ( t4->blocks.last_node == 0 )
e4severe( e4info, E4_T4BLOCK ) ;
#endif
return (B4BLOCK *)t4->blocks.last_node ;
}
/* Returns 2 - cannot go down due to out of date blocks 1 - Cannot move down; 0 - Success; -1 Error */
int S4FUNCTION t4down( TAG4 *t4 )
{
long block_down ;
B4BLOCK *block_on, *pop_block, *new_block, *parent ;
INDEX4 *i4 ;
int rc ;
#ifdef S4DEBUG
if ( t4 == 0 )
e4severe( e4parm, E4_T4DOWN ) ;
#endif
if ( t4->code_base->error_code < 0 )
return -1 ;
i4 = t4->index ;
block_on = (B4BLOCK *)t4->blocks.last_node ;
if ( block_on == 0 ) /* Read the root block */
{
if ( t4->header.root <= 0L )
{
if ( file4read_all( &i4->file, t4->header_offset, &t4->header.root,sizeof(t4->header.root)) < 0 )
return -1 ;
#ifdef S4BYTE_SWAP
t4->header.root = x4reverse_long( (void *)&t4->header.root ) ;
#endif
}
block_down = t4->header.root ;
}
else
{
if ( b4leaf( block_on ) )
return 1 ;
#ifdef S4FOX
#ifdef S4UNIX
memcpy( (void *)&block_down,(void *)(((unsigned char *)&block_on->node_hdr)
+ (block_on->key_on+1)*(2*sizeof(S4LONG) + t4->header.key_len) - sizeof(S4LONG)), sizeof(S4LONG) ) ;
block_down = x4reverse_long( (void *)&block_down ) ;
#else
block_down = x4reverse_long( (void *)( ((unsigned char *)&block_on->node_hdr)
+ (block_on->key_on+1)*(2*sizeof(S4LONG) + t4->header.key_len) - sizeof(S4LONG) ) ) ;
#endif
#else
block_down = b4key(block_on,block_on->key_on)->num ;
#endif
#ifdef S4DEBUG
if ( block_down <= 0L )
e4severe( e4info, E4_INFO_ILF ) ;
#endif
}
/* Get memory for the new block */
pop_block = (B4BLOCK *)l4pop( &t4->saved ) ;
if ( pop_block == 0 )
{
new_block = b4alloc( t4, block_down) ;
if ( new_block == 0 )
return -1 ;
}
else
new_block = pop_block ;
parent = (B4BLOCK *)l4last( &t4->blocks ) ;
l4add( &t4->blocks, new_block ) ;
if ( pop_block == 0 || new_block->file_block != block_down )
{
if ( b4flush(new_block) < 0 )
return -1 ;
rc = i4read_block( &i4->file, block_down, parent, new_block ) ;
if ( rc < 0 )
return rc ;
if ( rc == 1 )
{
l4remove( &t4->blocks, new_block ) ;
l4add( &t4->saved, new_block ) ;
return 2 ;
}
new_block->file_block = block_down ;
#ifdef S4FOX
new_block->built_on = -1 ;
#endif
/* flush blocks, don't delete */
for( block_on = 0 ;; )
{
block_on = (B4BLOCK *)l4next(&t4->saved,block_on) ;
if ( block_on == 0 )
break ;
if ( b4flush(block_on) < 0 )
return -1 ;
block_on->file_block = -1 ; /* make it invalid */
}
}
#ifdef S4FOX
b4top( new_block ) ;
#else
new_block->key_on = 0 ;
#endif
return 0 ;
}
int S4FUNCTION t4eof( TAG4 *t4 )
{
B4BLOCK *b4 ;
#ifdef S4DEBUG
if ( t4 == 0 )
e4severe( e4parm, E4_T4EOF ) ;
#endif
b4 = t4block( t4 ) ;
#ifdef S4DEBUG
if ( b4 == 0 )
e4severe( e4result, E4_T4EOF ) ;
#endif
#ifdef S4FOX
return( (b4->key_on >= b4->header.n_keys) || (b4->header.n_keys == 0) ) ;
#else
return( b4->key_on >= b4->n_keys ) ;
#endif
}
#ifndef S4OFF_WRITE
int S4FUNCTION t4update( TAG4 *t4 )
{
B4BLOCK *block_on ;
#ifdef S4DEBUG
if ( t4 == 0 )
e4severe( e4parm, E4_T4UPDATE ) ;
#endif
if ( t4->code_base->error_code < 0 )
return -1 ;
for( block_on = 0 ;; )
{
block_on = (B4BLOCK *)l4next(&t4->saved,block_on) ;
if ( block_on == 0 )
break ;
if ( b4flush(block_on) < 0 )
return -1 ;
}
for( block_on = 0 ;; )
{
block_on = (B4BLOCK *)l4next(&t4->blocks,block_on) ;
if ( block_on == 0 )
break ;
if ( b4flush(block_on) < 0 )
return -1 ;
}
if ( t4->root_write )
{
#ifdef S4BYTE_SWAP
t4->header.root = x4reverse_long( (void *)&t4->header.root ) ;
#endif
if ( file4write( &t4->index->file, t4->header_offset, &t4->header.root, sizeof(t4->header.root)) < 0 )
return -1 ;
#ifdef S4BYTE_SWAP
t4->header.root = x4reverse_long( (void *)&t4->header.root ) ;
#endif
t4->root_write = 0 ;
}
return 0 ;
}
#endif /* S4OFF_WRITE */
int S4FUNCTION t4free_all( TAG4 *t4 )
{
#ifdef S4DEBUG
if ( t4 == 0 )
e4severe( e4parm, E4_T4FREE_ALL ) ;
#endif
while ( t4up( t4 ) == 0 ) ;
return t4free_saved( t4 ) ;
}
int S4FUNCTION t4free_saved( TAG4 *t4 )
{
B4BLOCK *block_on ;
if ( t4update( t4 ) < 0 )
return -1 ;
for ( ;; )
{
block_on = (B4BLOCK *)l4pop( &t4->saved ) ;
if ( block_on == 0 )
return 0 ;
if ( b4flush( block_on) < 0 )
return -1 ;
b4free( block_on ) ;
}
}
int S4FUNCTION t4go2( TAG4 *t4, char *ptr, long rec_num )
{
#ifdef S4FOX
B4BLOCK *block_on ;
int rc, rc2, k_len = t4->header.key_len ;
unsigned long rec ;
char has_skipped ;
#else
int rc ;
long rec, rec_save ;
B4BLOCK *block_on ;
#endif
#ifdef S4DEBUG
if ( t4 == 0 || ptr == 0 || rec_num < 1 )
e4severe( e4parm, E4_T4GO ) ;
#endif
if ( t4->code_base->error_code < 0 )
return -1 ;
#ifdef S4FOX
rec = x4reverse_long( (void *)&rec_num ) ;
if ( t4->code_base->error_code < 0 )
return -1 ;
do
{
/* Do initial search, moving up only as far as necessary */
rc2 = t4up_to_root( t4 ) ;
if ( rc2 < 0 )
return -1 ;
if ( rc2 != 2 )
{
for(;;) /* Repeat until found */
{
block_on = (B4BLOCK *)t4->blocks.last_node ;
#ifdef S4DEBUG
if ( block_on == 0 )
e4severe( e4info, E4_T4GO ) ;
#endif
if ( b4leaf(block_on) )
{
rc = b4seek( block_on, (char *)ptr, k_len ) ;
if ( rc ) /* leaf seek did not end in perfect find */
return rc ;
/* now do the seek for recno on the leaf block */
block_on = (B4BLOCK *)t4->blocks.last_node ;
rec = t4recno( t4 ) ;
if ( rec == (unsigned long)rec_num )
return 0 ;
/*
if ( rec > (unsigned long)rec_num )
for(;;)
{
rec = t4recno( t4 ) ;
if ( rec == (unsigned long)rec_num )
return 0 ;
if ( x4dup_cnt( block_on, block_on->key_on ) + x4trail_cnt( block_on, block_on->key_on ) != t4->header.key_len )
{
block_on->cur_dup_cnt = x4dup_cnt( block_on, block_on->key_on ) ;
return r4found ;
}
if ( rec < (unsigned long)rec_num )
{
rc = (int)t4skip(t4,1L) ;
if ( rc == -1 )
return -1 ;
return r4found ;
}
rc = (int)t4skip(t4,-1L) ;
if ( rc == 1 )
return -1 ;
if ( rc == 0 )
return r4found ;
}
else
{
*/
has_skipped = 0 ;
for(;;)
{
rec = t4recno( t4 ) ;
if ( rec == (unsigned long)rec_num )
return 0 ;
if ( rec > (unsigned long)rec_num )
{
if ( !has_skipped )
block_on->cur_dup_cnt = x4dup_cnt( block_on, block_on->key_on ) ;
return r4found ;
}
has_skipped = 1 ;
rc = (int)t4skip(t4,1L) ;
if ( rc == -1 )
return -1 ;
if ( rc == 0 )
{
b4go_eof( t4block(t4) ) ;
return r4found ;
}
if ( x4dup_cnt( block_on, block_on->key_on ) + x4trail_cnt( block_on, block_on->key_on )
!= t4->header.key_len ) /* case where key changed */
return r4found ;
/* } */
}
}
else
{
rc = b4r_brseek( block_on, (char *)ptr, k_len, rec ) ;
if ( rc == 0 && t4->header.type_code & 0x01 )
if ( b4recno( t4block(t4), t4block(t4)->key_on ) != rec_num )
return r4found ;
}
rc2 = t4down( t4 ) ;
if ( rc2 < 0 )
return -1 ;
if ( rc2 == 2 )
{
t4out_of_date( t4 ) ;
break ;
}
}
}
} while ( rc2 == 2 ) ;
return 0 ;
#endif
#ifndef S4FOX
rc = t4seek( t4, ptr, t4->header.key_len ) ;
if ( rc )
return rc ;
rec_save = t4recno( t4 ) ;
if ( rec_save == rec_num )
return 0 ;
/* else find the far end, and then skip back to where now or find */
t4up_to_root( t4 ) ;
for( ;; )
{
block_on = (B4BLOCK *)t4->blocks.last_node ;
#ifdef S4DEBUG
if ( block_on == 0 )
e4severe( e4info, E4_T4GO ) ;
#endif
rc = b4seek( block_on, ptr, t4->header.key_len ) ;
while( rc == 0 ) /* perfect find, check next */
{
if ( b4skip( block_on, 1L ) == 0 )
break ;
if ( (*t4->cmp)( b4key_key( block_on, block_on->key_on ), ptr, t4->header.key_len ) != 0 )
break ;
}
if ( b4leaf( block_on ) )
{
if ( t4recno( t4 ) == rec_num && rc == 0 ) /* found */
return 0 ;
if ( t4recno( t4 ) == rec_save ) /* didn't move */
return r4found ;
break ;
}
t4down( t4 ) ;
}
for(;;)
{
rc = (int)b4skip( t4block( t4 ), -1L ) ;
if ( rc == 0 ) /* try previous tag */
{
if ( t4skip( t4, -1L ) == 0 )
return r4found ;
}
rec = t4recno( t4 ) ;
if ( rec == rec_save ) /* failed to find */
return r4found ;
if ( rec == rec_num )
return 0 ;
}
#endif
}
B4KEY_DATA *S4FUNCTION t4key_data( TAG4 *t4 )
{
B4BLOCK *b4 ;
b4 = (B4BLOCK *)t4->blocks.last_node ;
return b4key( b4, b4->key_on ) ;
}
long S4FUNCTION t4recno( TAG4 *t4 )
{
B4BLOCK *block_on ;
#ifdef S4DEBUG
if ( t4 == 0 )
e4severe( e4parm, E4_T4RECNO ) ;
#endif
block_on = (B4BLOCK *)t4->blocks.last_node ;
if ( block_on == 0 )
return -2L ;
#ifdef S4FOX
if ( block_on->key_on >= block_on->header.n_keys )
return -1 ;
#else
if ( !b4leaf( block_on ) )
return -2L ;
#endif
return b4recno( block_on, block_on->key_on ) ;
}
int S4FUNCTION t4seek( TAG4 *t4, void *ptr, int len_ptr )
{
int rc ;
B4BLOCK *block_on ;
#ifdef S4FOX
int inc_pos, d_set ;
unsigned char *c_ptr ;
d_set = 0 ;
c_ptr = (unsigned char *)ptr ;
#endif
#ifdef S4DEBUG
if ( t4 == 0 || ptr == 0 )
e4severe( e4parm, E4_T4SEEK ) ;
if ( len_ptr != t4->header.key_len && t4type( t4 ) != r4str )
e4severe( e4parm, E4_T4SEEK ) ;
#endif
if ( t4->code_base->error_code < 0 )
return -1 ;
#ifndef S4OPTIMIZE_OFF
#ifndef S4DETECT_OFF
t4->index->code_base->mode |= 0x08 ;
#endif
#endif
#ifdef S4DEBUG
if ( len_ptr != t4->header.key_len && t4type( t4 ) != r4str )
e4severe( e4parm, E4_T4SEEK ) ;
#endif
if ( len_ptr > t4->header.key_len )
len_ptr = t4->header.key_len ;
#ifdef S4FOX
if ( t4->header.descending ) /* look for current item less one: */
{
for( inc_pos = len_ptr-1 ; d_set == 0 && inc_pos >=0 ; inc_pos-- )
if ( c_ptr[inc_pos] != 0xFF )
{
c_ptr[inc_pos]++ ;
d_set = 1 ;
}
}
#endif
rc = 3 ;
for( ;; ) /* Repeat until found */
{
while ( rc >= 2 )
{
if ( rc == 2 )
t4out_of_date( t4 ) ;
rc = t4up_to_root( t4 ) ;
if ( rc < 0 )
return -1 ;
}
block_on = (B4BLOCK *)t4->blocks.last_node ;
#ifdef S4DEBUG
if ( block_on == 0 )
e4severe( e4info, E4_T4SEEK ) ;
#endif
rc = b4seek( block_on, (char *)ptr, len_ptr ) ;
if ( b4leaf(block_on) )
break ;
rc = t4down( t4 ) ;
if ( rc < 0 )
return -1 ;
}
#ifdef S4FOX
if ( t4->header.descending ) /* must go back one! */
{
c_ptr[inc_pos+1]-- ; /* reset the search_ptr ; */
if ( d_set )
{
if ( block_on->header.n_keys == 0 )
rc = 0 ;
else
{
if ( block_on->key_on == 0 ) /* special case, must balance tree */
{
rc = (int)t4skip( t4, -1L ) ;
t4go( t4, t4key_data( t4 )->value, t4recno( t4 ) ) ;
}
else
rc = (int)t4skip( t4, -1L ) ;
}
if ( rc == 0L ) /* bof = eof condition */
{
b4go_eof( block_on ) ;
rc = r4eof ;
}
else
{
b4go( t4block( t4 ), t4block( t4 )->key_on ) ;
if ( (u4memcmp)( (void *)b4key_key( t4block( t4 ), t4block( t4 )->key_on ), ptr, len_ptr ) )
rc = r4after ;
else
rc = 0 ; /* successful find */
}
}
else
{
if ( rc == 0 ) /* the item was found, so go top, */
t4top( t4 ) ;
else /* otherwise want an eof type condition */
{
b4go_eof( block_on ) ;
rc = r4eof ;
}
}
}
#endif
return rc ;
}
long S4FUNCTION t4skip( TAG4 *t4, long num_skip )
{
long num_left ;
B4BLOCK *block_on ;
int rc ;
#ifdef S4FOX
int save_dups ;
long go_to ;
#else
int sign ;
#endif
#ifdef S4DEBUG
if ( t4 == 0 )
e4severe( e4parm, E4_T4SKIP ) ;
#endif
if ( t4->code_base->error_code < 0 )
return -1 ;
#ifndef S4OPTIMIZE_OFF
#ifndef S4DETECT_OFF
t4->index->code_base->mode |= 0x04 ;
#endif
#endif
num_left = num_skip ;
block_on = (B4BLOCK *)t4->blocks.last_node ;
if ( block_on == 0 )
{
if ( t4top(t4) < 0 )
return -num_skip ;
block_on = (B4BLOCK *)t4->blocks.last_node ;
}
#ifdef S4DEBUG
if ( ! b4leaf(block_on) )
e4severe( e4info, E4_T4SKIP ) ;
#endif
#ifdef S4FOX
for(;;)
{
num_left -= b4skip( block_on, num_left ) ;
if ( num_left == 0 ) /* Success */
return( num_skip ) ;
if ( num_left > 0 )
go_to = block_on->header.right_node ;
else
go_to = block_on->header.left_node ;
if ( go_to == -1 )
{
if ( num_skip > 0 )
{
save_dups = t4block( t4 )->cur_dup_cnt ;
rc = t4bottom(t4) ;
t4block( t4 )->cur_dup_cnt = save_dups ;
if ( rc < 0 )
return -num_skip ;
}
else
if ( t4top(t4) < 0 )
return -num_skip ;
return (num_skip - num_left) ;
}
if ( b4flush( block_on ) < 0 )
return -num_skip ;
/* save the current key in case skip fails -- for leaf blocks only */
if ( b4leaf( block_on ) )
memcpy( t4->code_base->saved_key, (void *)b4key_key( block_on, block_on->header.n_keys - 1 ), t4->header.key_len ) ;
rc = i4read_block( &t4->index->file, go_to, 0, block_on ) ;
if ( rc < 0 )
return -num_skip ;
if ( rc == 1 ) /* failed on i/o, seek current spot to make valid */
{
#ifndef S4OPTIMIZE_OFF
#ifndef S4SINGLE
file4refresh( &t4->index->file ) ;
#endif
#endif
rc = t4seek( t4, t4->code_base->saved_key, t4->header.key_len ) ;
if ( rc < 0 )
return -num_skip ;
if ( rc == r4after ) /* means skipped 1 ahead */
num_left-- ;
}
block_on->file_block = go_to ;
block_on->built_on = -1 ;
b4top( block_on ) ;
if ( num_left < 0 )
num_left += block_on->header.n_keys ;
else
num_left -= 1 ; /* moved to the next entry */
}
#endif
#ifndef S4FOX
if ( num_skip < 0)
sign = -1 ;
else
sign = 1 ;
for(;;)
{
/* save the current key in case skip fails -- for leaf blocks only */
if ( b4leaf( block_on ) )
memcpy( t4->code_base->saved_key, b4key_key( block_on, block_on->key_on ), t4->header.key_len ) ;
while ( ( rc = t4down( t4 ) ) == 0 )
if ( sign < 0 )
{
block_on = t4block( t4 ) ;
b4go_eof( block_on ) ;
if ( b4leaf( block_on) )
{
block_on->key_on-- ;
#ifdef S4DEBUG
if ( block_on->key_on < 0 )
e4severe( e4info, E4_T4SKIP ) ;
#endif
}
}
if ( rc < 0 )
return -num_skip ;
if ( rc == 2 ) /* failed on i/o, seek current spot to make valid */
{
t4out_of_date( t4 ) ;
rc = t4seek( t4, t4->code_base->saved_key, t4->header.key_len ) ;
if ( rc < 0 )
return -num_skip ;
if ( rc == r4after ) /* means skipped 1 ahead */
num_left-- ;
continue ;
}
block_on = t4block( t4 ) ;
if (rc < 0 ) /* Error */
return( -num_skip ) ;
num_left -= b4skip( block_on, num_left ) ;
if ( num_left == 0) /* Success */
return( num_skip ) ;
do /* Skip 1 to the next leaf block */
{
if ( (B4BLOCK *)block_on->link.p == block_on )
{
if ( num_skip > 0 )
{
if ( t4bottom( t4 ) < 0 )
return -num_skip ;
}
else
if ( t4top(t4) < 0 )
return -num_skip ;
return( num_skip - num_left ) ;
}
else
t4up(t4) ;
block_on = (B4BLOCK *)t4->blocks.last_node ;
} while ( b4skip( block_on, (long) sign) != sign) ;
num_left -= sign ;
}
#endif
}
#ifndef S4OFF_WRITE
B4BLOCK *S4FUNCTION t4split( TAG4 *t4, B4BLOCK *old_block )
{
long new_file_block ;
B4BLOCK *new_block ;
#ifndef S4FOX
int tot_len, new_len ;
#endif
if ( t4->code_base->error_code < 0 )
return 0 ;
#ifdef S4INDEX_VERIFY
if ( b4verify( old_block ) == -1 )
e4describe( old_block->tag->code_base, e4index, old_block->tag->alias, "t4split()-before split", "" ) ;
#endif
new_file_block = i4extend( t4->index ) ;
new_block = b4alloc( t4, new_file_block ) ;
if ( new_block == 0 ) return 0 ;
new_block->changed = 1 ;
old_block->changed = 1 ;
#ifdef S4FOX
if ( b4leaf( old_block ) )
t4leaf_split( t4, old_block, new_block ) ;
else
t4branch_split( t4, old_block, new_block ) ;
new_block->header.right_node = old_block->header.right_node ;
new_block->header.left_node = old_block->file_block ;
old_block->header.right_node = new_block->file_block ;
if ( new_block->header.right_node != -1 ) /* must change left ptr for next block over */
{
#ifdef S4BYTE_SWAP
new_block->file_block = x4reverse_long( (void *)&new_block->file_block ) ;
#endif
file4write( &t4->index->file, new_block->header.right_node + 2*sizeof(short),
&new_block->file_block, sizeof( new_block->header.left_node ) ) ;
#ifdef S4BYTE_SWAP
new_block->file_block = x4reverse_long( (void *)&new_block->file_block ) ;
#endif
}
#else
/* NNNNOOOO N - New, O - Old */
new_block->n_keys = (short)((old_block->n_keys+1)/2) ;
old_block->n_keys -= new_block->n_keys ;
new_block->key_on = old_block->key_on ;
tot_len = t4->index->header.block_rw - sizeof(old_block->n_keys) - sizeof(old_block->dummy) ;
new_len = new_block->n_keys * t4->header.group_len ;
memcpy( (void *)b4key(new_block,0), (void *)b4key(old_block,0), new_len ) ;
memmove( b4key(old_block,0), b4key(old_block,new_block->n_keys), tot_len - new_len ) ;
old_block->key_on = old_block->key_on - new_block->n_keys ;
#endif
return new_block ;
}
#ifdef S4FOX
void S4FUNCTION t4branch_split( TAG4 *t4, B4BLOCK *old_block, B4BLOCK *new_block )
{
int new_len, n_new_keys ;
int g_len = t4->header.key_len + 2*sizeof( long ) ;
char *o_pos ;
/* NNNNOOOO N - New, O - Old */
n_new_keys = ( old_block->header.n_keys + 1 ) / 2 ;
if ( old_block->key_on > n_new_keys )
n_new_keys-- ;
new_block->header.n_keys = (short)n_new_keys ;
old_block->header.n_keys -= (short)n_new_keys ;
new_len = new_block->header.n_keys * g_len ;
o_pos = ((char *)&old_block->node_hdr) + g_len * old_block->header.n_keys ;
memcpy( (void *)&new_block->node_hdr, o_pos, new_len ) ;
new_block->header.node_attribute = 0 ;
old_block->header.node_attribute = 0 ;
new_block->key_on = old_block->key_on - old_block->header.n_keys ;
/* clear the old data */
memset( o_pos, 0, new_len ) ;
}
void S4FUNCTION t4leaf_split( TAG4 *t4, B4BLOCK *old_block, B4BLOCK *new_block )
{
char *obd_pos, *obi_pos ;
unsigned char buffer[6] ;
int len, n_keys ;
int k_len = t4->header.key_len ;
int i_len = old_block->node_hdr.info_len ;
int b_len = B4BLOCK_SIZE - (sizeof(old_block->header)) - (sizeof(old_block->node_hdr))
- old_block->header.n_keys * i_len
- old_block->node_hdr.free_space ;
int old_dup = old_block->cur_dup_cnt ;
b4top( old_block ) ;
n_keys = old_block->header.n_keys / 2 ;
for ( len = 0 ; len < old_block->header.n_keys - n_keys ; len++ )
b4skip( old_block, 1L ) ;
/* build the key 1st key of the new block from one past new end of old block */
b4key( old_block, old_block->key_on ) ;
/* copy the general information */
memcpy( (void *)&new_block->header, (void *)&old_block->header,
(sizeof( old_block->header)) + (sizeof(old_block->node_hdr)) ) ;
/* put 1st key of new block */
new_block->cur_trail_cnt = b4calc_blanks( old_block->built_key->value, k_len, t4->p_char ) ;
len = k_len - new_block->cur_trail_cnt ;
new_block->cur_pos = ((char *)&new_block->header) + B4BLOCK_SIZE - len ;
memcpy( new_block->cur_pos, old_block->built_key->value, len ) ;
/* copy remaining key data */
obd_pos = ((char *)&old_block->header) + B4BLOCK_SIZE - b_len ;
len = old_block->cur_pos - obd_pos ;
new_block->cur_pos -= len ;
memcpy( new_block->cur_pos, obd_pos, len ) ;
/* copy the info data */
obi_pos = old_block->data + old_block->key_on * i_len ;
memcpy( new_block->data, obi_pos, n_keys * i_len ) ;
/* clear the old data */
b4skip( old_block, -1L ) ; /* go to new last entry */
#ifdef S4DEBUG
if ( obd_pos < obi_pos )
e4severe( e4info, E4_INFO_BMC ) ;
#endif
memset( obi_pos, 0, old_block->cur_pos - obi_pos ) ;
/* now reset the place new info data for the first key */
memset( new_block->data, 0, i_len ) ;
x4put_info( &new_block->node_hdr, buffer, old_block->built_key->num, new_block->cur_trail_cnt, 0 ) ;
memcpy( new_block->data, (void *)buffer, i_len ) ;
new_block->header.n_keys = (short)n_keys ;
old_block->header.n_keys -= (short)n_keys ;
new_block->header.node_attribute = 2 ;
old_block->header.node_attribute = 2 ;
new_block->node_hdr.free_space = (short) (new_block->cur_pos - new_block->data
- new_block->header.n_keys * i_len) ;
old_block->node_hdr.free_space = (short) (old_block->cur_pos - old_block->data
- old_block->header.n_keys * i_len) ;
old_block->built_on = -1 ;
new_block->built_on = -1 ;
b4top( old_block ) ;
b4top( new_block ) ;
/* make sure dup_cnt is updated on blocks for insert */
new_block->cur_dup_cnt = old_dup ;
old_block->cur_dup_cnt = old_dup ;
}
#endif
#endif /* S4OFF_WRITE */
#ifdef S4FOX
int S4FUNCTION t4rl_top( TAG4 *t4 )
{
int rc ;
if ( t4->code_base->error_code < 0 )
return -1 ;
do
{
rc = t4up_to_root( t4 ) ;
if ( rc < 0 )
return -1 ;
if ( rc != 2 )
{
do
{
b4top( (B4BLOCK *)t4->blocks.last_node ) ;
if ( (rc = t4down(t4)) < 0 )
return -1 ;
} while ( rc == 0 ) ;
}
if ( rc == 2 ) /* failed due to read while locked */
t4out_of_date( t4 ) ;
} while ( rc == 2 ) ;
return 0 ;
}
int S4FUNCTION t4top( TAG4 *t4 )
{
#ifdef S4DEBUG
if ( t4 == 0 )
e4severe( e4parm, E4_T4TOP ) ;
#endif
if ( t4->code_base->error_code < 0 )
return -1 ;
if ( t4->header.descending ) /* if descending, go top means go bottom */
return t4rl_bottom( t4 ) ;
else
return t4rl_top( t4 ) ;
}
#else
int S4FUNCTION t4top( TAG4 *t4 )
{
int rc ;
#ifdef S4DEBUG
if ( t4 == 0 )
e4severe( e4parm, E4_T4TOP ) ;
#endif
if ( t4->code_base->error_code < 0 )
return -1 ;
do
{
rc = t4up_to_root( t4 ) ;
if ( rc < 0 )
return -1 ;
if ( rc != 2 )
{
((B4BLOCK *)t4->blocks.last_node)->key_on = 0 ;
do
{
if ( (rc = t4down(t4)) < 0 )
return -1 ;
((B4BLOCK *)t4->blocks.last_node)->key_on = 0 ;
} while ( rc == 0 ) ;
}
if ( rc == 2 ) /* failed due to read while locked */
t4out_of_date( t4 ) ;
} while ( rc == 2 ) ;
return 0 ;
}
#endif
int S4FUNCTION t4up( TAG4 *t4 )
{
#ifdef S4DEBUG
if ( t4 == 0 )
e4severe( e4parm, E4_T4UP ) ;
#endif
if ( t4->blocks.last_node == 0 )
return 1 ;
l4add( &t4->saved, l4pop(&t4->blocks) ) ;
return 0 ;
}
int S4FUNCTION t4up_to_root( TAG4 *t4 )
{
LINK4 *link_on ;
#ifdef S4DEBUG
if ( t4 == 0 )
e4severe( e4parm, E4_T4UP_TO_ROOT ) ;
#endif
for ( ;; )
{
link_on = (LINK4 *)l4pop( &t4->blocks ) ;
if ( link_on == 0 )
return t4down( t4 ) ;
l4add( &t4->saved, link_on ) ;
}
}
#endif /* N4OTHER */
#endif /* S4INDEX_OFF */
#ifdef S4VB_DOS
int t4go_v( TAG4 *t4, char *key, long rec_no )
{
return t4go( t4, c4str(key), rec_no ) ;
}
int t4seek_v( TAG4 *t4, char *seek_val, int key_len )
{
return t4seek( t4, v4str(seek_val), key_len) ;
}
#endif
int S4FUNCTION t4go_eof( TAG4 *t4 )
{
int rc ;
rc = t4bottom( t4 ) ;
if ( rc != 0 )
return rc ;
#ifdef S4FOX
if ( t4block(t4)->header.n_keys != 0 )
t4block(t4)->key_on = t4block(t4)->header.n_keys ;
#else
t4block(t4)->key_on++ ;
#endif
return 0 ;
}
Reference in New Issue Copy Permalink