a3b97d75b1
which included commits to RCS files with non-trunk default branches. git-svn-id: svn://10.65.10.50/trunk@1014 c028cbd2-c16b-5b4b-a496-9718f37d4682
1669 lines
39 KiB
C
Executable File
1669 lines
39 KiB
C
Executable File
/* i4ntag.c (c)Copyright Sequiter Software Inc., 1990-1994. All rights reserved. */
|
|
|
|
#include "d4all.h"
|
|
#ifndef S4UNIX
|
|
#ifdef __TURBOC__
|
|
#pragma hdrstop
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef S4INDEX_OFF
|
|
|
|
#include <time.h>
|
|
|
|
int S4FUNCTION t4type( TAG4 *t4 )
|
|
{
|
|
#ifdef S4FOX
|
|
return t4->expr->type ;
|
|
#endif
|
|
#ifdef S4CLIPPER
|
|
return t4->expr->type ;
|
|
#endif
|
|
#ifdef S4NDX
|
|
return t4->header.type ;
|
|
#endif
|
|
#ifdef S4MDX
|
|
return t4->header.type ;
|
|
#endif
|
|
}
|
|
|
|
#ifdef N4OTHER
|
|
|
|
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 ;
|
|
}
|
|
|
|
#ifdef S4CLIPPER
|
|
int S4FUNCTION t4rl_bottom( TAG4 *t4 )
|
|
#else
|
|
int S4FUNCTION t4bottom( TAG4 *t4 )
|
|
#endif
|
|
{
|
|
int rc ;
|
|
B4BLOCK *block_on ;
|
|
|
|
#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 )
|
|
{
|
|
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 ) ;
|
|
} while ( rc == 2 ) ;
|
|
|
|
block_on = t4block(t4) ;
|
|
if ( block_on->key_on > 0 )
|
|
block_on->key_on = block_on->n_keys-1 ;
|
|
|
|
#ifdef S4DEBUG
|
|
if ( block_on->key_on < 0 ) e4severe( e4info, E4_T4BOTTOM ) ;
|
|
#endif
|
|
|
|
return 0 ;
|
|
}
|
|
|
|
#ifdef S4CLIPPER
|
|
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 ) ;
|
|
}
|
|
#endif
|
|
|
|
#ifdef S4CLIPPER
|
|
#ifdef S4HAS_DESCENDING
|
|
void S4FUNCTION t4descending( TAG4 *tag, int setting )
|
|
{
|
|
tag->header.descending = setting ;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
/* Returns 1 - Cannot move down; 0 - Success; -1 Error */
|
|
int S4FUNCTION t4down( TAG4 *t4 )
|
|
{
|
|
long block_down ;
|
|
B4BLOCK *block_on, *pop_block, *new_block, *parent ;
|
|
int rc ;
|
|
#ifdef S4BYTE_SWAP
|
|
char *swap_ptr ;
|
|
int i ;
|
|
short short_val ;
|
|
long long_val ;
|
|
#endif
|
|
|
|
#ifdef S4DEBUG
|
|
if ( t4 == 0 )
|
|
e4severe( e4parm, E4_T4DOWN ) ;
|
|
#endif
|
|
|
|
if ( t4->code_base->error_code < 0 )
|
|
return -1 ;
|
|
|
|
block_on = (B4BLOCK *)t4->blocks.last_node ;
|
|
|
|
if ( block_on == 0 ) /* Read the root block */
|
|
{
|
|
if ( t4->header.root <= 0L )
|
|
{
|
|
#ifdef S4NDX
|
|
if ( file4read_all( &t4->file, t4->header.header_offset, &t4->header.root, 2*sizeof(long)) < 0 )
|
|
return -1 ;
|
|
#else
|
|
#ifdef S4CLIPPER
|
|
if ( file4read_all( &t4->file, t4->header.header_offset + 2*sizeof(short), &t4->header.root, 2*sizeof(long)) < 0 )
|
|
return -1 ;
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef S4BYTE_SWAP
|
|
t4->header.root = x4reverse_long( (void *)&t4->header.root ) ;
|
|
t4->header.eof = x4reverse_long( (void *)&t4->header.eof ) ;
|
|
#endif
|
|
}
|
|
block_down = t4->header.root ;
|
|
}
|
|
else
|
|
{
|
|
if ( b4leaf( block_on ) )
|
|
return 1 ;
|
|
block_down = b4key( block_on, block_on->key_on )->pointer ;
|
|
#ifdef S4DEBUG
|
|
if ( block_down <= 0L )
|
|
e4severe( e4info, E4_INFO_ILF ) ;
|
|
#endif
|
|
}
|
|
|
|
/* Get memory for the new block */
|
|
pop_block = (B4BLOCK *)l4pop( &t4->saved ) ;
|
|
new_block = pop_block ;
|
|
if ( new_block == 0 )
|
|
new_block = b4alloc( t4, block_down ) ;
|
|
if ( new_block == 0 )
|
|
return -1 ;
|
|
parent = (B4BLOCK *)l4last( &t4->blocks ) ;
|
|
l4add( &t4->blocks, new_block ) ;
|
|
|
|
#ifdef S4NDX
|
|
if ( pop_block == 0 || new_block->file_block != block_down )
|
|
#else
|
|
if ( pop_block == 0 || new_block->file_block*I4MULTIPLY != block_down )
|
|
#endif
|
|
{
|
|
if ( new_block->changed == 1 )
|
|
if ( b4flush(new_block) < 0 )
|
|
return -1 ;
|
|
|
|
rc = i4read_block( &t4->file, block_down, parent, new_block ) ;
|
|
|
|
if ( rc < 0 )
|
|
return -1 ;
|
|
|
|
if ( rc == 1 )
|
|
{
|
|
l4remove( &t4->blocks, new_block ) ;
|
|
l4add( &t4->saved, new_block ) ;
|
|
return 2 ;
|
|
}
|
|
|
|
#ifdef S4BYTE_SWAP
|
|
#ifdef S4NDX
|
|
swap_ptr = (void *)&new_block->n_keys ;
|
|
|
|
short_val = x4reverse_short( (void *)swap_ptr ) ;
|
|
memcpy( swap_ptr, (void *) &short_val, sizeof(short) ) ;
|
|
|
|
swap_ptr += 2 + sizeof(short) ;
|
|
|
|
for ( i = 0 ; i < (*(short *)swap) ; i++ )
|
|
{
|
|
long_val = x4reverse_long( (void *)swap_ptr ) ;
|
|
memcpy( swap_ptr, (void *) &long_val, sizeof(long) ) ;
|
|
long_val = x4reverse_long( (void *)(swap_ptr+sizeof(long)) ) ;
|
|
memcpy( swap_ptr+sizeof(long), (void *) &long_val, sizeof(long) ) ;
|
|
swap_ptr += r4->group_len ;
|
|
}
|
|
|
|
long_val = x4reverse_long( (void *)swap_ptr ) ;
|
|
memcpy( swap_ptr, (void *) &long_val, sizeof(long) ) ;
|
|
#endif
|
|
|
|
#ifdef S4CLIPPER
|
|
swap_ptr = (void *)&new_block->n_keys ;
|
|
|
|
short_val = x4reverse_short( (void *)swap_ptr ) ;
|
|
memcpy( swap_ptr, (void *) &short_val, sizeof(short) ) ;
|
|
|
|
swap_ptr += 2 ;
|
|
/* swap the short pointers to B4KEY_DATA */
|
|
for ( i = 0 ; i <= t4->header.keys_max ; i++ )
|
|
{
|
|
short_val = x4reverse_short( (void *)swap_ptr ) ;
|
|
memcpy( swap_ptr, (void *) &short_val, sizeof(short) ) ;
|
|
swap_ptr += sizeof(short) ;
|
|
}
|
|
/* swap the B4KEY_DATA's */
|
|
for ( i = 0 ; i < t4->header.keys_max ; i++ )
|
|
{
|
|
long_val = x4reverse_long( (void *)swap_ptr ) ;
|
|
memcpy( swap_ptr, (void *) &long_val, sizeof(long) ) ;
|
|
long_val = x4reverse_long( (void *)(swap_ptr+sizeof(long)) ) ;
|
|
memcpy( swap_ptr+sizeof(long), (void *) &long_val, sizeof(long) ) ;
|
|
swap_ptr += t4->header.group_len ;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
for ( ;; )
|
|
{
|
|
block_on = (B4BLOCK *)l4pop( &t4->saved ) ;
|
|
if ( block_on == 0 )
|
|
break ;
|
|
if ( b4flush(block_on) < 0 )
|
|
return -1 ;
|
|
b4free( block_on ) ;
|
|
}
|
|
}
|
|
|
|
new_block->key_on = 0 ;
|
|
return 0 ;
|
|
}
|
|
|
|
int S4FUNCTION t4eof( TAG4 *t4 )
|
|
{
|
|
B4BLOCK *b4 ;
|
|
|
|
#ifdef S4DEBUG
|
|
if ( t4 == 0 )
|
|
e4severe( e4parm, E4_T4EOF ) ;
|
|
#endif
|
|
|
|
b4 = t4block( t4 ) ;
|
|
return ( b4->key_on >= b4->n_keys ) ;
|
|
}
|
|
|
|
#ifndef S4OFF_WRITE
|
|
int S4FUNCTION t4flush( TAG4 *t4 )
|
|
{
|
|
int rc ;
|
|
|
|
#ifdef S4DEBUG
|
|
if ( t4 == 0 )
|
|
e4severe( e4parm, E4_T4FLUSH ) ;
|
|
#endif
|
|
|
|
rc = t4update( t4 ) ;
|
|
#ifndef S4OPTIMIZE_OFF
|
|
if ( rc )
|
|
rc = file4flush( &t4->file ) ;
|
|
#endif
|
|
return rc ;
|
|
}
|
|
#endif
|
|
|
|
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 ;
|
|
#ifndef S4OFF_WRITE
|
|
if ( b4flush( block_on ) < 0 )
|
|
return -1 ;
|
|
#endif
|
|
b4free( block_on ) ;
|
|
}
|
|
}
|
|
|
|
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 S4NDX
|
|
if ( !b4leaf( block_on ) )
|
|
return -2L ;
|
|
#else
|
|
if ( block_on->key_on >= block_on->n_keys )
|
|
return -1 ;
|
|
#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 S4CLIPPER
|
|
int upper_fnd, upper_aft, inc_pos, d_set ;
|
|
unsigned char *c_ptr ;
|
|
#ifndef S4OPTIMIZE_OFF
|
|
#ifndef S4DETECT_OFF
|
|
int sv_mode ;
|
|
#endif
|
|
#endif
|
|
|
|
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
|
|
|
|
if ( len_ptr > t4->header.key_len )
|
|
len_ptr = t4->header.key_len ;
|
|
|
|
#ifdef S4CLIPPER
|
|
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 ) ;
|
|
#ifdef S4CLIPPER
|
|
upper_fnd = 0 ;
|
|
upper_aft = 0 ;
|
|
#endif
|
|
|
|
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 ) ;
|
|
#ifdef S4NDX
|
|
if ( b4leaf( block_on ) )
|
|
break ;
|
|
#else
|
|
#ifdef S4CLIPPER
|
|
if ( b4leaf( block_on ) )
|
|
{
|
|
if ( rc == r4after && upper_aft && block_on->key_on >= block_on->n_keys )
|
|
while( upper_aft-- > 1 )
|
|
t4up( t4 ) ;
|
|
if ( rc == 0 || !upper_fnd )
|
|
break ;
|
|
|
|
while( upper_fnd-- > 1 )
|
|
t4up( t4 ) ;
|
|
rc = 0 ;
|
|
break ;
|
|
}
|
|
if ( rc == 0 )
|
|
{
|
|
upper_fnd = 1 ;
|
|
upper_aft = 0 ;
|
|
}
|
|
else
|
|
if ( rc == r4after && !upper_fnd && !( block_on->key_on >= block_on->n_keys ) )
|
|
upper_aft = 1 ;
|
|
#endif
|
|
#endif
|
|
|
|
rc = t4down( t4 ) ;
|
|
if ( rc < 0 )
|
|
return -1 ;
|
|
|
|
#ifdef S4CLIPPER
|
|
if ( upper_fnd )
|
|
upper_fnd++ ;
|
|
if ( upper_aft )
|
|
upper_aft++ ;
|
|
#endif
|
|
}
|
|
#ifdef S4CLIPPER
|
|
if ( t4->header.descending ) /* must go back one! */
|
|
{
|
|
c_ptr[inc_pos+1]-- ; /* reset the search_ptr ; */
|
|
if ( d_set )
|
|
{
|
|
#ifndef S4OPTIMIZE_OFF
|
|
#ifndef S4DETECT_OFF
|
|
sv_mode = t4->code_base->mode ;
|
|
#endif
|
|
#endif
|
|
|
|
rc = (int)t4skip( t4, -1L ) ;
|
|
#ifndef S4OPTIMIZE_OFF
|
|
#ifndef S4DETECT_OFF
|
|
t4->code_base->mode = sv_mode ;
|
|
#endif
|
|
#endif
|
|
if ( rc == 0L ) /* bof = eof condition */
|
|
{
|
|
b4go_eof( block_on ) ;
|
|
rc = r4eof ;
|
|
}
|
|
else
|
|
{
|
|
/* b4go( t4block( t4 ), t4block( t4 )->key_on ) ; */
|
|
if ( (u4memcmp)( 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 )
|
|
{
|
|
int rc, sign ;
|
|
B4BLOCK *block_on ;
|
|
|
|
#ifdef S4NDX
|
|
long num_left = num_skip ;
|
|
#endif
|
|
#ifdef S4CLIPPER
|
|
long j ;
|
|
#endif
|
|
|
|
#ifdef S4DEBUG
|
|
if ( t4 == 0 )
|
|
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 |= 0x04 ;
|
|
#endif
|
|
#endif
|
|
|
|
if ( num_skip < 0)
|
|
sign = -1 ;
|
|
else
|
|
sign = 1 ;
|
|
|
|
block_on = (B4BLOCK *)t4->blocks.last_node ;
|
|
if ( block_on == 0 )
|
|
{
|
|
rc = t4top( t4 ) ;
|
|
if ( rc < 0 )
|
|
return -num_skip ;
|
|
block_on = (B4BLOCK *)t4->blocks.last_node ;
|
|
}
|
|
|
|
#ifdef S4NDX
|
|
#ifdef S4DEBUG
|
|
if ( !b4leaf( block_on ) )
|
|
e4severe( e4info, E4_T4SKIP ) ;
|
|
#endif
|
|
|
|
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 */
|
|
{
|
|
#ifdef S4DEBUG
|
|
if ( t4->blocks.last_node == 0 )
|
|
e4severe( e4result, E4_T4SKIP ) ;
|
|
#endif
|
|
if ( l4prev( &t4->blocks, t4->blocks.last_node ) == 0 ) /* root block */
|
|
{
|
|
if ( num_skip > 0 )
|
|
{
|
|
if ( t4bottom( t4 ) < 0 )
|
|
return -num_skip ;
|
|
}
|
|
else
|
|
if ( t4top( t4 ) < 0 )
|
|
return -num_skip ;
|
|
|
|
return( num_skip - num_left ) ;
|
|
}
|
|
t4up( t4 ) ;
|
|
block_on = (B4BLOCK *)t4->blocks.last_node ;
|
|
} while ( b4skip( block_on, (long) sign) != sign) ;
|
|
num_left -= sign ;
|
|
}
|
|
#else
|
|
#ifdef S4CLIPPER
|
|
for( j = num_skip; j != 0; j -= sign ) /* skip 1 * num_skip */
|
|
{
|
|
if ( b4leaf(block_on) )
|
|
{
|
|
if ( b4skip( block_on, (long) sign) != sign ) /* go up */
|
|
{
|
|
int go_on = 1 ;
|
|
while ( go_on )
|
|
{
|
|
if ( l4prev( &t4->blocks, t4->blocks.last_node ) == 0 ) /* root block */
|
|
{
|
|
if ( num_skip > 0 )
|
|
{
|
|
if ( t4bottom( t4 ) < 0 ) return -num_skip ;
|
|
}
|
|
else
|
|
if ( t4top( t4 ) < 0 ) return -num_skip ;
|
|
|
|
return ( num_skip - j ) ;
|
|
}
|
|
|
|
rc = t4up( t4 ) ;
|
|
block_on = t4block( t4 ) ;
|
|
if ( rc != 0 ) return -1 ;
|
|
|
|
if ( sign > 0 ) /* forward skipping */
|
|
{
|
|
if ( !( block_on->key_on >= block_on->n_keys ) )
|
|
go_on = 0 ;
|
|
}
|
|
else /* backward skipping */
|
|
{
|
|
if ( ! (block_on->key_on == 0) )
|
|
{
|
|
b4skip( block_on, -1L ) ;
|
|
go_on = 0 ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( sign > 0 )
|
|
b4skip( block_on, 1L ) ;
|
|
|
|
/* 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-- ;
|
|
}
|
|
}
|
|
if ( rc < 0 )
|
|
return -num_skip ;
|
|
|
|
if ( rc == 2 ) /* failed on i/o, seek current spot to make valid */
|
|
{
|
|
#ifndef S4OPTIMIZE_OFF
|
|
#ifndef S4SINGLE
|
|
file4refresh( &t4->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 */
|
|
j-- ;
|
|
}
|
|
|
|
block_on = t4block( t4 ) ;
|
|
}
|
|
}
|
|
return num_skip ;
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
#ifndef S4OFF_WRITE
|
|
#ifdef S4NDX
|
|
B4BLOCK *S4FUNCTION t4split( TAG4 *t4, B4BLOCK *old_block )
|
|
{
|
|
long new_file_block ;
|
|
B4BLOCK *new_block ;
|
|
int new_len ;
|
|
|
|
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 = t4extend( t4 ) ;
|
|
new_block = b4alloc( t4, new_file_block ) ;
|
|
if ( new_block == 0 )
|
|
return 0 ;
|
|
|
|
new_block->changed = 1 ;
|
|
old_block->changed = 1 ;
|
|
|
|
/* NNNNOOOO N - New, O - Old */
|
|
new_block->n_keys = ( old_block->n_keys )/2 ;
|
|
old_block->n_keys -= new_block->n_keys ;
|
|
|
|
new_len = new_block->n_keys * t4->header.group_len ;
|
|
|
|
memmove( b4key(new_block,0), b4key(old_block, old_block->n_keys ), new_len+ (sizeof(long)*(!(b4leaf( old_block )) ) ) ) ;
|
|
new_block->key_on = old_block->key_on - old_block->n_keys ;
|
|
|
|
old_block->n_keys -= !( b4leaf( old_block ) ) ;
|
|
|
|
return new_block ;
|
|
}
|
|
#else
|
|
#ifdef S4CLIPPER
|
|
/* NTX only needs to do a copy and adjust the index pointers */
|
|
/* if extra_old is true then the extra key is placed in old, otherwise in new */
|
|
B4BLOCK *S4FUNCTION t4split( TAG4 *t4, B4BLOCK *old_block, int extra_old )
|
|
{
|
|
long new_file_block ;
|
|
B4BLOCK *new_block ;
|
|
int is_branch ;
|
|
|
|
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 = t4extend( t4 ) ;
|
|
new_block = b4alloc( t4, new_file_block ) ;
|
|
if ( new_block == 0 )
|
|
return 0 ;
|
|
|
|
new_block->changed = 1 ;
|
|
old_block->changed = 1 ;
|
|
|
|
memcpy( new_block->data, old_block->data, B4BLOCK_SIZE - ( t4->header.keys_max + 2 ) * sizeof(short) ) ;
|
|
|
|
if ( extra_old )
|
|
{
|
|
new_block->n_keys = old_block->n_keys / 2 ;
|
|
old_block->n_keys -= new_block->n_keys ;
|
|
}
|
|
else
|
|
{
|
|
new_block->n_keys = old_block->n_keys ;
|
|
old_block->n_keys = old_block->n_keys / 2 ;
|
|
new_block->n_keys -= old_block->n_keys ;
|
|
if ( old_block->n_keys == new_block->n_keys )
|
|
{
|
|
new_block->n_keys++ ;
|
|
old_block->n_keys-- ;
|
|
}
|
|
}
|
|
|
|
is_branch = !b4leaf( old_block ) ;
|
|
|
|
memcpy( new_block->pointers, &old_block->pointers[old_block->n_keys + is_branch],
|
|
new_block->n_keys * sizeof(short) ) ;
|
|
memcpy( &new_block->pointers[new_block->n_keys], old_block->pointers,
|
|
(old_block->n_keys + is_branch) * sizeof(short) ) ;
|
|
|
|
if ( is_branch == 0 ) /* leaf blocks need one more copy */
|
|
new_block->pointers[t4->header.keys_max] = old_block->pointers[t4->header.keys_max] ;
|
|
|
|
new_block->key_on = old_block->key_on - old_block->n_keys - is_branch ;
|
|
new_block->n_keys -= is_branch ;
|
|
|
|
return new_block ;
|
|
}
|
|
#endif
|
|
#endif
|
|
#endif /* S4OFF_WRITE */
|
|
|
|
#ifdef S4CLIPPER
|
|
int S4FUNCTION t4rl_top( TAG4 *t4 )
|
|
#else
|
|
int S4FUNCTION t4top( TAG4 *t4 )
|
|
#endif
|
|
{
|
|
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 ;
|
|
}
|
|
|
|
#ifdef S4CLIPPER
|
|
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 ) ;
|
|
}
|
|
#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 ;
|
|
}
|
|
|
|
#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 ;
|
|
|
|
if ( t4update_header( t4 ) < 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 ) ;
|
|
t4->header.eof = x4reverse_long( (void *)&t4->header.eof ) ;
|
|
#endif
|
|
#ifdef S4NDX
|
|
if ( file4write( &t4->file, t4->header_offset, &t4->header.root, 2 * sizeof(long) ) < 0 )
|
|
return -1 ;
|
|
#else
|
|
#ifdef S4CLIPPER
|
|
if ( file4write( &t4->file, t4->header_offset + 2*sizeof( short ),
|
|
&t4->header.root, 2*sizeof(long) ) < 0 ) return -1 ;
|
|
#endif
|
|
#endif
|
|
#ifdef S4BYTE_SWAP
|
|
t4->header.root = x4reverse_long( (void *)&t4->header.root ) ;
|
|
t4->header.eof = x4reverse_long( (void *)&t4->header.eof ) ;
|
|
#endif
|
|
t4->root_write = 0 ;
|
|
}
|
|
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
|
|
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 ) ;
|
|
}
|
|
}
|
|
|
|
int S4FUNCTION t4close( TAG4 *t4 )
|
|
{
|
|
int final_rc ;
|
|
int save_attempts ;
|
|
DATA4 *d4 ;
|
|
|
|
#ifdef S4VBASIC
|
|
if ( c4parm_check( t4->code_base, 1, E4_T4CLOSE ) )
|
|
return -1 ;
|
|
#endif
|
|
|
|
final_rc = e4set( t4->code_base, 0 ) ;
|
|
save_attempts = t4->code_base->lock_attempts ;
|
|
d4 = t4->index->data ;
|
|
|
|
t4->code_base->lock_attempts = -1 ;
|
|
|
|
if ( d4 )
|
|
if ( d4update( d4 ) < 0 )
|
|
final_rc = e4set( t4->code_base, 0 ) ;
|
|
|
|
#ifndef S4SINGLE
|
|
if ( t4->file_locked )
|
|
{
|
|
file4unlock( &t4->file, L4LOCK_POS, L4LOCK_POS ) ;
|
|
t4->file_locked = 0 ;
|
|
}
|
|
#endif
|
|
|
|
t4free_all( t4 ) ;
|
|
|
|
if ( file4open_test( &t4->file ) )
|
|
if ( file4close( &t4->file ) < 0 )
|
|
final_rc = e4set( t4->code_base, 0 ) ;
|
|
|
|
t4->code_base->lock_attempts = save_attempts ;
|
|
e4set( t4->code_base, final_rc ) ;
|
|
|
|
return final_rc ;
|
|
}
|
|
|
|
#ifndef S4OFF_WRITE
|
|
long S4FUNCTION t4extend( TAG4 *t4 )
|
|
{
|
|
long old_eof ;
|
|
CODE4 *c4 = t4->index->code_base ;
|
|
|
|
if ( c4->error_code < 0 )
|
|
return -1 ;
|
|
|
|
#ifdef S4DEBUG
|
|
if ( t4->header.version == t4->header.old_version )
|
|
e4severe( e4info, E4_T4EXTEND ) ;
|
|
#endif
|
|
|
|
old_eof = t4->header.eof ;
|
|
|
|
#ifdef S4NDX
|
|
#ifdef S4DEBUG
|
|
if (old_eof <= 0L ) e4severe( e4info, E4_T4EXTEND ) ;
|
|
#endif
|
|
|
|
t4->header.eof += B4BLOCK_SIZE / I4MULTIPLY ;
|
|
t4->root_write = 1 ;
|
|
return old_eof ;
|
|
#else
|
|
#ifdef S4CLIPPER
|
|
#ifdef S4SINGLE
|
|
if ( old_eof != 0 ) /* case where free-list exists */
|
|
t4->header.eof = 0L ;
|
|
else
|
|
{
|
|
#endif
|
|
old_eof = file4len( &t4->file ) ;
|
|
#ifdef S4DEBUG
|
|
if ( old_eof <= t4->check_eof )
|
|
e4severe( e4info, E4_T4EXTEND ) ;
|
|
t4->check_eof = old_eof ;
|
|
#endif
|
|
file4len_set( &t4->file, file4len( &t4->file ) + 1024 ) ; /* and extend the file */
|
|
#ifdef S4SINGLE
|
|
}
|
|
#endif
|
|
return old_eof/512 ;
|
|
#endif
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
int S4FUNCTION t4go2( TAG4 *t4, char *ptr, long rec_num )
|
|
{
|
|
int rc ;
|
|
long rec ;
|
|
#ifndef S4OPTIMIZE_OFF
|
|
#ifndef S4DETECT_OFF
|
|
int sv_mode ;
|
|
#endif
|
|
#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 ;
|
|
|
|
rc = t4seek( t4, ptr, t4->header.key_len ) ;
|
|
if ( rc )
|
|
return rc ;
|
|
|
|
for(;;)
|
|
{
|
|
rec = t4recno( t4 ) ;
|
|
if (rec == rec_num )
|
|
return 0 ;
|
|
|
|
#ifndef S4OPTIMIZE_OFF
|
|
#ifndef S4DETECT_OFF
|
|
sv_mode = t4->code_base->mode ;
|
|
#endif
|
|
#endif
|
|
rc = (int)t4skip( t4, 1L ) ;
|
|
#ifndef S4OPTIMIZE_OFF
|
|
#ifndef S4DETECT_OFF
|
|
t4->code_base->mode = sv_mode ;
|
|
#endif
|
|
#endif
|
|
if ( rc == -1 )
|
|
return -1 ;
|
|
if ( rc == 0 )
|
|
{
|
|
b4go_eof( t4block( t4 ) ) ;
|
|
return r4found ;
|
|
}
|
|
|
|
if ( (*t4->cmp)( t4key_data( t4 )->value, ptr, t4->header.key_len ) )
|
|
return r4found ;
|
|
}
|
|
}
|
|
|
|
TAG4 *S4FUNCTION t4open( DATA4 *d4, INDEX4 *i4ndx, char *file_name )
|
|
{
|
|
CODE4 *c4 ;
|
|
INDEX4 *i4 ;
|
|
char buf[258], buffer[1024] ;
|
|
char expr_buf[I4MAX_EXPR_SIZE + 1] ;
|
|
#ifdef S4CLIPPER
|
|
char *ptr, garbage ;
|
|
#endif
|
|
TAG4 *t4 ;
|
|
int rc, len ;
|
|
FILE4SEQ_READ seq_read ;
|
|
#ifdef S4DEBUG
|
|
int old_tag_err ;
|
|
#endif
|
|
|
|
#ifdef S4VBASIC
|
|
if ( c4parm_check( d4, 2, E4_T4OPEN ) )
|
|
return 0 ;
|
|
#endif
|
|
|
|
#ifdef S4DEBUG
|
|
if ( d4 == 0 || file_name == 0 )
|
|
e4severe( e4parm, E4_T4OPEN ) ;
|
|
|
|
u4name_piece( buf, sizeof( buf ), file_name, 0, 0 ) ;
|
|
old_tag_err = d4->code_base->tag_name_error ;
|
|
d4->code_base->tag_name_error = 0 ;
|
|
if ( d4tag( d4, buf ) )
|
|
{
|
|
e4( d4->code_base, e4info, E4_INFO_TAO ) ;
|
|
d4->code_base->tag_name_error = old_tag_err ;
|
|
return 0 ;
|
|
}
|
|
d4->code_base->tag_name_error = old_tag_err ;
|
|
d4->code_base->error_code = 0 ;
|
|
#endif
|
|
|
|
if ( d4->code_base->error_code < 0 )
|
|
return 0 ;
|
|
|
|
c4 = d4->code_base ;
|
|
|
|
if ( i4ndx == 0 ) /* must create an index for the tag */
|
|
{
|
|
if ( c4->index_memory == 0 )
|
|
{
|
|
c4->index_memory = mem4create( c4, c4->mem_start_index, sizeof( INDEX4 ), c4->mem_expand_index, 0 ) ;
|
|
if ( c4->index_memory == 0 )
|
|
return 0 ;
|
|
}
|
|
|
|
i4 = (INDEX4 *)mem4alloc( c4->index_memory ) ;
|
|
if ( i4 == 0 )
|
|
{
|
|
e4( c4, e4memory, 0 ) ;
|
|
return 0 ;
|
|
}
|
|
|
|
i4->code_base = c4 = d4->code_base ;
|
|
u4name_piece( i4->alias, sizeof( i4->alias ), file_name, 0, 0 ) ;
|
|
}
|
|
else
|
|
i4 = i4ndx ;
|
|
|
|
if ( i4->block_memory == 0 )
|
|
i4->block_memory = mem4create( c4, c4->mem_start_block,
|
|
(sizeof(B4BLOCK)) + B4BLOCK_SIZE -
|
|
(sizeof(B4KEY_DATA)) - (sizeof(short)) - (sizeof(char[2])),
|
|
c4->mem_expand_block, 0 ) ;
|
|
|
|
if ( i4->block_memory == 0 )
|
|
{
|
|
i4close( i4 ) ;
|
|
if ( i4ndx == 0 )
|
|
mem4free( c4->index_memory, i4 ) ;
|
|
return 0 ;
|
|
}
|
|
|
|
if ( c4->tag_memory == 0 )
|
|
{
|
|
c4->tag_memory = mem4create( c4, c4->mem_start_tag, sizeof(TAG4),
|
|
c4->mem_expand_tag, 0 ) ;
|
|
if ( c4->tag_memory == 0 )
|
|
{
|
|
if ( i4ndx == 0 )
|
|
mem4free( c4->index_memory, i4 ) ;
|
|
return 0 ;
|
|
}
|
|
}
|
|
|
|
t4 = (TAG4 *)mem4alloc( c4->tag_memory ) ;
|
|
if ( t4 == 0 )
|
|
{
|
|
e4( c4, e4memory, 0 ) ;
|
|
if ( i4ndx == 0 )
|
|
mem4free( c4->index_memory, i4 ) ;
|
|
return 0 ;
|
|
}
|
|
|
|
u4ncpy( buf, file_name, sizeof( buf ) ) ;
|
|
c4upper(buf) ;
|
|
|
|
#ifdef S4NDX
|
|
#ifdef S4UNIX
|
|
u4name_ext( buf, sizeof(buf), "ndx", 0 ) ;
|
|
#else
|
|
u4name_ext( buf, sizeof(buf), "NDX", 0 ) ;
|
|
#endif
|
|
#else
|
|
#ifdef S4CLIPPER
|
|
#ifdef S4UNIX
|
|
u4name_ext( buf, sizeof(buf), "ntx", 0 ) ;
|
|
#else
|
|
u4name_ext( buf, sizeof(buf), "NTX", 0 ) ;
|
|
#endif
|
|
#endif
|
|
#endif
|
|
|
|
rc = file4open( &t4->file, c4, buf, 1 ) ;
|
|
if ( rc != 0 )
|
|
{
|
|
if ( i4ndx == 0 )
|
|
mem4free( c4->index_memory, i4 ) ;
|
|
mem4free( c4->tag_memory, t4 ) ;
|
|
return 0 ;
|
|
}
|
|
|
|
file4seq_read_init( &seq_read, &t4->file, 0, buffer, 1024 ) ;
|
|
#ifdef S4NDX
|
|
if ( file4seq_read_all( &seq_read, &t4->header.root, sizeof(I4IND_HEAD_WRITE) ) < 0 )
|
|
{
|
|
if ( i4ndx == 0 )
|
|
mem4free( c4->index_memory, i4 ) ;
|
|
file4close( &t4->file ) ;
|
|
mem4free( c4->tag_memory, t4 ) ;
|
|
return 0 ;
|
|
}
|
|
|
|
#ifdef S4BYTE_SWAP
|
|
t4->header.root = x4reverse_long( (void *)&t4->header.root ) ;
|
|
t4->header.eof = x4reverse_long( (void *)&t4->header.eof ) ;
|
|
t4->header.key_len = x4reverse_short( (void *)&t4->header.key_len ) ;
|
|
t4->header.keys_max = x4reverse_short( (void *)&t4->header.keys_max ) ;
|
|
t4->header.int_or_date = x4reverse_short( (void *)&t4->header.int_or_date ) ;
|
|
t4->header.group_len = x4reverse_short( (void *)&t4->header.group_len ) ;
|
|
t4->header.dummy = x4reverse_short( (void *)&t4->header.dummy ) ;
|
|
t4->header.unique = x4reverse_short( (void *)&t4->header.unique ) ;
|
|
#endif
|
|
t4->header.type = 0 ;
|
|
#else
|
|
#ifdef S4CLIPPER
|
|
if ( file4seq_read_all( &seq_read, &t4->header.sign, sizeof(I4IND_HEAD_WRITE) ) < 0 )
|
|
{
|
|
if ( i4ndx == 0 )
|
|
mem4free( c4->index_memory, i4 ) ;
|
|
file4close( &t4->file ) ;
|
|
mem4free( c4->tag_memory, t4 ) ;
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
#ifdef S4BYTE_SWAP
|
|
t4->header.sign = x4reverse_short( (void *)&t4->header.sign ) ;
|
|
t4->header.version = x4reverse_short( (void *)&t4->header.version ) ;
|
|
t4->header.root = x4reverse_long( (void *)&t4->header.root ) ;
|
|
t4->header.eof = x4reverse_long( (void *)&t4->header.eof ) ;
|
|
t4->header.group_len = x4reverse_short( (void *)&t4->header.group_len ) ;
|
|
t4->header.key_len = x4reverse_short( (void *)&t4->header.key_len ) ;
|
|
t4->header.key_dec = x4reverse_short( (void *)&t4->header.key_dec ) ;
|
|
t4->header.keys_max = x4reverse_short( (void *)&t4->header.keys_max ) ;
|
|
t4->header.keys_half = x4reverse_short( (void *)&t4->header.keys_half ) ;
|
|
#endif
|
|
#endif
|
|
t4->header.header_offset = 0 ;
|
|
|
|
/* Perform some checks */
|
|
if ( t4->header.key_len > I4MAX_KEY_SIZE ||
|
|
t4->header.key_len <= 0 ||
|
|
#ifdef S4CLIPPER
|
|
t4->header.keys_max != 2* t4->header.keys_half ||
|
|
t4->header.keys_half <= 0 ||
|
|
t4->header.group_len != t4->header.key_len+ 8 ||
|
|
(t4->header.sign != 0x6 && t4->header.sign != 0x106) )
|
|
#else
|
|
t4->header.key_len+8 > t4->header.group_len ||
|
|
t4->header.keys_max < 4 ||
|
|
t4->header.keys_max > 50 ||
|
|
t4->header.eof <= 0L )
|
|
#endif
|
|
{
|
|
#ifdef S4DEBUG_DEV
|
|
e4describe( c4, e4index, buf, "t4open()", "perform check failure" ) ;
|
|
#endif
|
|
e4( c4, e4index, buf ) ;
|
|
if ( i4ndx == 0 )
|
|
mem4free( c4->index_memory, i4 ) ;
|
|
file4close( &t4->file ) ;
|
|
mem4free( c4->tag_memory, t4 ) ;
|
|
return 0 ;
|
|
}
|
|
|
|
t4->index = i4 ;
|
|
t4->code_base = c4 ;
|
|
t4->cmp = (S4CMP_FUNCTION *)u4memcmp ;
|
|
t4->header.root = -1 ;
|
|
t4->header.old_version = t4->header.version ;
|
|
|
|
u4name_piece( t4->alias, sizeof(t4->alias), file_name, 0, 0 ) ;
|
|
#ifdef S4UNIX
|
|
c4upper( t4->alias ) ;
|
|
#endif
|
|
|
|
file4seq_read_all( &seq_read, expr_buf, sizeof( expr_buf ) - 1 ) ;
|
|
c4trim_n( expr_buf, sizeof( expr_buf ) ) ;
|
|
t4->expr = expr4parse( d4, expr_buf ) ;
|
|
if ( t4->expr == 0 )
|
|
{
|
|
if ( i4ndx == 0 )
|
|
mem4free( c4->index_memory, i4 ) ;
|
|
file4close( &t4->file ) ;
|
|
mem4free( c4->tag_memory, t4 ) ;
|
|
return 0 ;
|
|
}
|
|
#ifdef S4CLIPPER
|
|
t4->expr->key_len = t4->header.key_len ;
|
|
t4->expr->key_dec = t4->header.key_dec ;
|
|
#endif
|
|
|
|
len = expr4key_len( t4->expr ) ;
|
|
if ( len < 0 )
|
|
{
|
|
e4describe( c4, e4info, E4_T4OPEN, E4_INFO_KEY, (char *)0 ) ;
|
|
if ( i4ndx == 0 )
|
|
mem4free( c4->index_memory, i4 ) ;
|
|
file4close( &t4->file ) ;
|
|
mem4free( c4->tag_memory, t4 ) ;
|
|
return 0 ;
|
|
}
|
|
|
|
#ifdef S4NDX
|
|
t4->header.type = (char) expr4type(t4->expr) ;
|
|
if ( t4->header.key_len != (short) len )
|
|
{
|
|
#ifdef S4DEBUG_DEV
|
|
e4describe( c4, e4index, i4->file.name, "t4open()", "expression/header length mismatch" ) ;
|
|
#endif
|
|
e4( c4, e4index, i4->file.name ) ;
|
|
if ( i4ndx == 0 )
|
|
mem4free( c4->index_memory, i4 ) ;
|
|
file4close( &t4->file ) ;
|
|
mem4free( c4->tag_memory, t4 ) ;
|
|
return 0 ;
|
|
}
|
|
#else
|
|
#ifdef S4CLIPPER
|
|
file4seq_read_all( &seq_read, &t4->header.unique, sizeof( t4->header.unique ) ) ;
|
|
file4seq_read_all( &seq_read, &garbage, sizeof( garbage ) ) ;
|
|
file4seq_read_all( &seq_read, &t4->header.descending, sizeof( t4->header.descending ) ) ;
|
|
#ifdef S4BYTE_SWAP
|
|
t4->header.unique = x4reverse_short( (void *)&t4->header.unique ) ;
|
|
t4->header.descending = x4reverse_short( (void *)&t4->header.descending ) ;
|
|
#endif
|
|
file4seq_read_all( &seq_read, expr_buf, sizeof( expr_buf ) - 1 ) ;
|
|
c4trim_n( expr_buf, sizeof( expr_buf ) ) ;
|
|
if ( expr_buf[0] != 0 )
|
|
{
|
|
t4->filter = expr4parse( d4, expr_buf ) ;
|
|
if ( t4->filter != 0 )
|
|
{
|
|
len = expr4key( t4->filter, &ptr ) ;
|
|
if ( len < 0 )
|
|
{
|
|
if ( i4ndx == 0 )
|
|
mem4free( c4->index_memory, i4 ) ;
|
|
file4close( &t4->file ) ;
|
|
mem4free( c4->tag_memory, t4 ) ;
|
|
return 0 ;
|
|
}
|
|
if ( expr4type( t4->filter ) != 'L' )
|
|
{
|
|
if ( i4ndx == 0 )
|
|
mem4free( c4->index_memory, i4 ) ;
|
|
file4close( &t4->file ) ;
|
|
mem4free( c4->tag_memory, t4 ) ;
|
|
#ifdef S4DEBUG_DEV
|
|
e4describe( c4, e4index, E4_INDEX_FIL, i4->file.name, "Filter expression not logical" ) ;
|
|
#endif
|
|
e4describe( c4, e4index, E4_INDEX_FIL, i4->file.name, (char *) 0 ) ;
|
|
return 0 ;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif
|
|
#endif
|
|
|
|
if( t4->header.unique )
|
|
t4->unique_error = c4->default_unique_error ;
|
|
l4add( &i4->tags, t4 ) ; /* add the tag to its index list */
|
|
|
|
#ifdef S4NDX
|
|
t4init_seek_conv(t4,t4->header.type) ;
|
|
#else
|
|
#ifdef S4CLIPPER
|
|
t4init_seek_conv( t4, (char) expr4type(t4->expr) ) ;
|
|
#endif
|
|
#endif
|
|
|
|
if ( i4->block_memory == 0 )
|
|
i4->block_memory = mem4create( c4, c4->mem_start_block,
|
|
(sizeof(B4BLOCK)) + B4BLOCK_SIZE -
|
|
(sizeof(B4KEY_DATA)) - (sizeof(short)) - (sizeof(char[2])),
|
|
c4->mem_expand_block, 0 ) ;
|
|
|
|
if ( i4->block_memory == 0 )
|
|
{
|
|
e4( c4, e4memory, E4_T4OPEN ) ;
|
|
if ( i4ndx == 0 )
|
|
mem4free( c4->index_memory, i4 ) ;
|
|
file4close( &t4->file ) ;
|
|
mem4free( c4->tag_memory, t4 ) ;
|
|
return 0 ;
|
|
}
|
|
|
|
if ( i4ndx == 0 )
|
|
{
|
|
i4->data = d4 ;
|
|
l4add( &d4->indexes, i4 ) ;
|
|
}
|
|
|
|
#ifndef S4OPTIMIZE_OFF
|
|
file4optimize( &t4->file, c4->optimize, OPT4INDEX ) ;
|
|
#endif
|
|
|
|
return t4 ;
|
|
}
|
|
|
|
#ifndef S4OFF_WRITE
|
|
#ifdef S4CLIPPER
|
|
int S4FUNCTION t4shrink( TAG4 *t4, long block_no )
|
|
{
|
|
#ifdef S4SINGLE
|
|
t4->header.eof = block_no * 512 ;
|
|
#endif
|
|
return 0 ;
|
|
}
|
|
#endif
|
|
|
|
int S4FUNCTION t4update_header( TAG4 *t4 )
|
|
{
|
|
#ifdef S4BYTE_SWAP
|
|
I4IND_HEAD_WRITE swap ;
|
|
#endif
|
|
if ( t4->index->code_base->error_code < 0 )
|
|
return -1 ;
|
|
|
|
/* t4->header.version = t4->header.old_version + 2 ; */
|
|
|
|
if ( t4->header.old_version != t4->header.version )
|
|
{
|
|
#ifdef S4NDX
|
|
#ifdef S4BYTE_SWAP
|
|
swap.root = x4reverse_long( (void *)&t4->header.root ) ;
|
|
swap.eof = x4reverse_long( (void *)&t4->header.eof ) ;
|
|
swap.key_len = x4reverse_short( (void *)&t4->header.key_len ) ;
|
|
swap.keys_max = x4reverse_short( (void *)&t4->header.keys_max ) ;
|
|
swap.int_or_date = x4reverse_short( (void *)&t4->header.int_or_date ) ;
|
|
swap.group_len = x4reverse_short( (void *)&t4->header.group_len ) ;
|
|
swap.dummy = x4reverse_short( (void *)&t4->header.dummy ) ;
|
|
swap.unique = x4reverse_short( (void *)&t4->header.unique ) ;
|
|
|
|
if ( file4write(&t4->file, 0L, &swap, sizeof(I4IND_HEAD_WRITE)) < 0) return -1 ;
|
|
|
|
t4->header.version = x4reverse_long( (void *)&t4->header.version ) ;
|
|
if ( file4write(&t4->file, sizeof(I4IND_HEAD_WRITE) + I4MAX_EXPR_SIZE,
|
|
&t4->header.version, sizeof(t4->header.version)) < 0) return -1 ;
|
|
t4->header.version = x4reverse_long( (void *)&t4->header.version ) ;
|
|
#else
|
|
if ( file4write(&t4->file, 0L, &t4->header.root, sizeof(I4IND_HEAD_WRITE) ) < 0 )
|
|
return -1 ;
|
|
if ( file4write(&t4->file, sizeof(I4IND_HEAD_WRITE) + I4MAX_EXPR_SIZE,
|
|
&t4->header.version, sizeof(t4->header.version)) < 0) return -1 ;
|
|
#endif
|
|
#else
|
|
#ifdef S4CLIPPER
|
|
#ifdef S4BYTE_SWAP
|
|
swap.sign = x4reverse_short( (void *)&t4->header.sign ) ;
|
|
swap.version = x4reverse_short( (void *)&t4->header.version ) ;
|
|
swap.root = x4reverse_long( (void *)&t4->header.root ) ;
|
|
swap.eof = x4reverse_long( (void *)&t4->header.eof ) ;
|
|
swap.group_len = x4reverse_short( (void *)&t4->header.group_len ) ;
|
|
swap.key_len = x4reverse_short( (void *)&t4->header.key_len ) ;
|
|
swap.key_dec = x4reverse_short( (void *)&t4->header.key_dec ) ;
|
|
swap.keys_max = x4reverse_short( (void *)&t4->header.keys_max ) ;
|
|
swap.keys_half = x4reverse_short( (void *)&t4->header.keys_half ) ;
|
|
|
|
if ( file4write(&t4->file, 0L, &swap, 2 * sizeof( long ) + 2 * sizeof( short ) ) < 0)
|
|
return -1 ;
|
|
|
|
t4->header.unique = x4reverse_short( (void *)&t4->header.unique ) ;
|
|
if ( file4write(&t4->file, sizeof(I4IND_HEAD_WRITE) + I4MAX_EXPR_SIZE, &t4->header.unique, sizeof(t4->header.unique)) < 0)
|
|
return -1 ;
|
|
t4->header.unique = x4reverse_short( (void *)&t4->header.unique ) ;
|
|
|
|
t4->header.descending = x4reverse_short( (void *)&t4->header.descending ) ;
|
|
if ( file4write(&t4->file, sizeof(I4IND_HEAD_WRITE) + I4MAX_EXPR_SIZE + sizeof(t4->header.unique) + 1, &t4->header.descending, sizeof(t4->header.descending)) < 0)
|
|
return -1 ;
|
|
t4->header.descending = x4reverse_short( (void *)&t4->header.descending ) ;
|
|
#else
|
|
if ( file4write(&t4->file, 0L, &t4->header.sign, 2 * sizeof( long ) + 2 * sizeof( short ) ) < 0)
|
|
return -1 ;
|
|
if ( file4write(&t4->file, sizeof(I4IND_HEAD_WRITE) + I4MAX_EXPR_SIZE, &t4->header.unique, sizeof(t4->header.unique)) < 0)
|
|
return -1 ;
|
|
if ( file4write(&t4->file, sizeof(I4IND_HEAD_WRITE) + I4MAX_EXPR_SIZE + sizeof(t4->header.unique) + 1, &t4->header.descending, sizeof(t4->header.descending)) < 0)
|
|
return -1 ;
|
|
#endif
|
|
#endif
|
|
#endif
|
|
t4->header.old_version = t4->header.version ;
|
|
}
|
|
return 0;
|
|
}
|
|
#endif /* S4OFF_WRITE */
|
|
|
|
int S4FUNCTION t4do_version_check( TAG4 *t4, int do_seek, int update_version )
|
|
{
|
|
#ifndef S4SINGLE
|
|
int rc, need_seek ;
|
|
B4BLOCK *b4 ;
|
|
|
|
#ifdef S4DEBUG
|
|
if ( t4 == 0 )
|
|
e4severe( e4parm, E4_T4DO_VERSION ) ;
|
|
#endif
|
|
|
|
if ( t4->code_base->error_code < 0 )
|
|
return -1 ;
|
|
|
|
if ( t4->file.is_exclusive )
|
|
return 0 ;
|
|
|
|
#ifndef S4OPTIMIZE_OFF
|
|
/* make sure read from disk */
|
|
if ( t4->file.do_buffer )
|
|
t4->code_base->opt.force_current = 1 ;
|
|
#endif
|
|
|
|
#ifdef S4NDX
|
|
rc = file4read_all( &t4->file, sizeof(I4IND_HEAD_WRITE) + I4MAX_EXPR_SIZE,
|
|
&t4->header.version, sizeof(t4->header.version ) ) ;
|
|
#ifndef S4OPTIMIZE_OFF
|
|
if ( t4->file.do_buffer )
|
|
t4->code_base->opt.force_current = 0 ;
|
|
#endif
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
|
|
#ifdef S4BYTE_SWAP
|
|
t4->header.version = x4reverse_long( (void *)&t4->header.version ) ;
|
|
#endif
|
|
#else
|
|
rc = file4read_all( &t4->file, 0L, &t4->header.sign, 2 * sizeof( short ) + 2 * sizeof( long ) ) ;
|
|
#ifndef S4OPTIMIZE_OFF
|
|
if ( t4->file.do_buffer )
|
|
t4->code_base->opt.force_current = 0 ;
|
|
#endif
|
|
if ( rc < 0 )
|
|
return rc ;
|
|
#ifdef S4BYTE_SWAP
|
|
t4->header.sign = x4reverse_short( (void *)&t4->header.sign ) ;
|
|
t4->header.version = x4reverse_short( (void *)&t4->header.version ) ;
|
|
t4->header.root = x4reverse_long( (void *)&t4->header.root ) ;
|
|
t4->header.eof = x4reverse_long( (void *)&t4->header.eof ) ;
|
|
t4->header.group_len = x4reverse_short( (void *)&t4->header.group_len ) ;
|
|
t4->header.key_len = x4reverse_short( (void *)&t4->header.key_len ) ;
|
|
t4->header.key_dec = x4reverse_short( (void *)&t4->header.key_dec ) ;
|
|
t4->header.keys_max = x4reverse_short( (void *)&t4->header.keys_max ) ;
|
|
t4->header.keys_half = x4reverse_short( (void *)&t4->header.keys_half ) ;
|
|
#endif
|
|
#endif
|
|
|
|
if ( t4->header.version == t4->header.old_version )
|
|
return 0 ;
|
|
|
|
if ( update_version == 1 )
|
|
t4->header.old_version = t4->header.version ;
|
|
else
|
|
t4->header.version = t4->header.old_version ;
|
|
|
|
/* remember the old position */
|
|
need_seek = 0 ;
|
|
if ( do_seek )
|
|
{
|
|
b4 = t4block( t4 ) ;
|
|
if ( b4 != 0 )
|
|
{
|
|
if ( t4eof( t4 ) )
|
|
need_seek = 2 ;
|
|
else
|
|
if ( b4leaf( b4 ) && b4->n_keys != 0 )
|
|
{
|
|
memcpy( t4->code_base->saved_key, b4key( b4, b4->key_on ), t4->header.key_len + 2 * sizeof( long ) ) ;
|
|
need_seek = 1 ;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( t4free_all( t4 ) < 0 ) /* Should be a memory operation only */
|
|
e4severe( e4result, E4_T4DO_VERSION ) ;
|
|
|
|
switch( need_seek )
|
|
{
|
|
case 1:
|
|
#ifdef S4DEBUG_DEV
|
|
if ( t4go( t4, ((B4KEY_DATA *)t4->code_base->saved_key)->value, ((B4KEY_DATA *)t4->code_base->saved_key)->num ) != 0 )
|
|
e4severe( e4index, "t4go() failed in t4do_version_check()" ) ;
|
|
#else
|
|
t4go( t4, ((B4KEY_DATA *)t4->code_base->saved_key)->value, ((B4KEY_DATA *)t4->code_base->saved_key)->num ) ;
|
|
#endif
|
|
break ;
|
|
case 2:
|
|
t4go_eof( t4 ) ;
|
|
break ;
|
|
}
|
|
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
int S4FUNCTION t4version_check( TAG4 *t4, int do_seek, int update_version )
|
|
{
|
|
#ifndef S4OPTIMIZE_OFF
|
|
if ( t4->index->file.do_buffer == 0 )
|
|
#endif
|
|
#ifndef S4SINGLE
|
|
if ( t4lock_test( t4 ) == 0 )
|
|
#endif
|
|
return t4do_version_check( t4, do_seek, update_version ) ;
|
|
return 0 ;
|
|
}
|
|
|
|
#endif /* N4OTHER */
|
|
#endif /* S4INDEX_OFF */
|
|
|
|
|
|
#ifdef S4VB_DOS
|
|
#ifdef N4OTHER
|
|
|
|
TAG4 S4PTR* S4FUNCTION t4open_v(DATA4 *d4, char *name)
|
|
{
|
|
return t4open( d4, 0, c4str(name) ) ;
|
|
}
|
|
|
|
#endif
|
|
#endif
|