917 lines
26 KiB
C
917 lines
26 KiB
C
|
/* d4data.h (c)Copyright Sequiter Software Inc., 1990-1994. All rights reserved. */
|
||
|
|
|
||
|
|
extern char v4buffer[257] ;
|
||
|
|
|
||
|
|
#ifdef S464BIT
|
||
|
|
#define S4LONG int
|
||
|
|
#else
|
||
|
|
#define S4LONG long
|
||
|
|
#endif
|
||
|
|
|
||
|
|
typedef int S4CALL S4CMP_FUNCTION( S4CMP_PARM, S4CMP_PARM, size_t) ;
|
||
|
|
|
||
|
|
#ifdef __SC__
|
||
|
|
typedef void _cdecl C4DTOK( char S4PTR *, double ) ;
|
||
|
|
typedef void _cdecl C4STOK( char S4PTR *, char S4PTR *, int ) ;
|
||
|
|
#else
|
||
|
|
typedef void C4DTOK( char S4PTR *, double ) ;
|
||
|
|
typedef void C4STOK( char S4PTR *, char S4PTR *, int ) ;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
struct DATA4_st ;
|
||
|
|
struct F4MEMO_st ;
|
||
|
|
struct INDEX4_st ;
|
||
|
|
struct TAG4_st ;
|
||
|
|
#ifdef __cplusplus
|
||
|
|
class S4CLASS FILE4 ;
|
||
|
|
#else
|
||
|
|
struct FILE4_st ;
|
||
|
|
#endif
|
||
|
|
#ifdef __cplusplus
|
||
|
|
class S4CLASS CODE4 ;
|
||
|
|
#else
|
||
|
|
struct CODE4_st ;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
#ifdef S4WINDOWS
|
||
|
|
#ifdef S4WIN32
|
||
|
|
typedef struct _declspec(dllexport) l4link_st
|
||
|
|
#else
|
||
|
|
typedef struct _export l4link_st
|
||
|
|
#endif
|
||
|
|
#else
|
||
|
|
typedef struct l4link_st
|
||
|
|
#endif
|
||
|
|
#else
|
||
|
|
typedef struct l4link_st
|
||
|
|
#endif
|
||
|
|
{
|
||
|
|
struct l4link_st S4PTR *n, S4PTR *p ;
|
||
|
|
} LINK4 ;
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
class S4CLASS LIST4
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
#else
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
#endif
|
||
|
|
LINK4 S4PTR *last_node ; /* The last Link */
|
||
|
|
void S4PTR *selected ;
|
||
|
|
int n_link ; /* The number of links in the list */
|
||
|
|
#ifdef __cplusplus
|
||
|
|
} ;
|
||
|
|
#else
|
||
|
|
} LIST4 ;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
LINK4 link ;
|
||
|
|
double data ; /* Make sure it is on a boundry good for at least a double */
|
||
|
|
} Y4CHUNK ;
|
||
|
|
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
LINK4 link ;
|
||
|
|
|
||
|
|
LIST4 chunks ; /* Chunks of pieces */
|
||
|
|
LIST4 pieces ; /* A list of available memory pieces */
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
CODE4 S4PTR *code_base ;
|
||
|
|
#else
|
||
|
|
struct CODE4_st *code_base ;
|
||
|
|
#endif
|
||
|
|
int unit_start; /* The starting # of entries for the Memory Type */
|
||
|
|
unsigned unit_size ; /* The size of each allocated piece */
|
||
|
|
int unit_expand ; /* The expansion # of entries for the Memory Type */
|
||
|
|
int n_repeat ; /* The number of times entry returned for 'new' */
|
||
|
|
/* If n_repeat is '-1', it is a temporary entry. */
|
||
|
|
int n_used ; /* The number of entries used */
|
||
|
|
} MEM4 ;
|
||
|
|
|
||
|
|
typedef struct OPT4BLOCK_st
|
||
|
|
{
|
||
|
|
LINK4 link ;
|
||
|
|
LINK4 lru_link ;
|
||
|
|
char changed ;
|
||
|
|
unsigned len ;
|
||
|
|
|
||
|
|
/* these next 2 elements must match the OPT4CMP structure above */
|
||
|
|
#ifdef __cplusplus
|
||
|
|
FILE4 S4PTR *file ;
|
||
|
|
#else
|
||
|
|
struct FILE4_st *file ;
|
||
|
|
#endif
|
||
|
|
long pos ;
|
||
|
|
|
||
|
|
void S4PTR *data ;
|
||
|
|
} OPT4BLOCK ;
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
typedef struct S4CLASS
|
||
|
|
#else
|
||
|
|
typedef struct
|
||
|
|
#endif
|
||
|
|
{
|
||
|
|
int num_buffers ;
|
||
|
|
unsigned long block_size ;
|
||
|
|
unsigned long buffer_size ;
|
||
|
|
unsigned long hash_trail ; /* where last optimized file ended */
|
||
|
|
unsigned long num_blocks ;
|
||
|
|
|
||
|
|
LIST4 avail ;
|
||
|
|
LIST4 dbf_lru ;
|
||
|
|
LIST4 index_lru ;
|
||
|
|
LIST4 other_lru ;
|
||
|
|
LIST4 S4PTR *prio[3] ;
|
||
|
|
|
||
|
|
unsigned char old_mode ;
|
||
|
|
unsigned char do_update ;
|
||
|
|
unsigned char check_count ;
|
||
|
|
unsigned char dummy_char ;
|
||
|
|
int min_link ;
|
||
|
|
void S4PTR* S4PTR* buffers ;
|
||
|
|
OPT4BLOCK S4PTR *blocks ;
|
||
|
|
char block_power ;
|
||
|
|
char num_shift ;
|
||
|
|
unsigned long num_lists ;
|
||
|
|
unsigned long mask ;
|
||
|
|
LIST4 S4PTR *lists ;
|
||
|
|
unsigned max_blocks ;
|
||
|
|
|
||
|
|
LIST4 opt_files ;
|
||
|
|
|
||
|
|
char is_skip ;
|
||
|
|
char force_current ; /* switch forces a read of current contents */
|
||
|
|
|
||
|
|
char S4PTR *read_buffer ;
|
||
|
|
unsigned long read_start_pos ;
|
||
|
|
int in_read_buf ;
|
||
|
|
|
||
|
|
char S4PTR *write_buffer ;
|
||
|
|
unsigned long write_start_pos ;
|
||
|
|
unsigned long write_cur_pos ;
|
||
|
|
unsigned write_block_count ; /* is the buffer full? */
|
||
|
|
#ifdef __cplusplus
|
||
|
|
FILE4 S4PTR *write_file ;
|
||
|
|
#else
|
||
|
|
struct FILE4_st S4PTR *write_file ; /* which file has the write buffer? */
|
||
|
|
#endif
|
||
|
|
} OPT4 ;
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
class S4CLASS CODE4
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
#else
|
||
|
|
typedef struct CODE4_st
|
||
|
|
{
|
||
|
|
#endif
|
||
|
|
unsigned hWnd ; /* For use under Microsoft Windows */
|
||
|
|
unsigned hInst ;
|
||
|
|
|
||
|
|
LIST4 data_list ; /* A list of open data files. */
|
||
|
|
int default_unique_error ; /* e4unique, r4unique, r4unique_continue */
|
||
|
|
char date_format[20]; /* Longest is September 15, 1990 */
|
||
|
|
|
||
|
|
unsigned mem_size_block ; /* Block size (bytes) for memo and index files */
|
||
|
|
unsigned mem_size_sort_pool ; /* The default pool size for sorting */
|
||
|
|
unsigned mem_size_sort_buffer ;/* The default file buffer size when sorting */
|
||
|
|
unsigned mem_size_buffer ; /* Pack, Zap */
|
||
|
|
unsigned mem_size_memo ;
|
||
|
|
unsigned mem_size_memo_expr ;
|
||
|
|
|
||
|
|
int mem_expand_block ; /* Expanding block memory allocation */
|
||
|
|
int mem_expand_data ; /* Expanding data file allocation */
|
||
|
|
int mem_expand_index ; /* Expanding index file allocation */
|
||
|
|
int mem_expand_tag ; /* Expanding index file allocation */
|
||
|
|
|
||
|
|
unsigned mem_start_data ; /* Initial data file allocation */
|
||
|
|
unsigned mem_start_block ; /* Initial block memory allocation for index files */
|
||
|
|
unsigned mem_start_index ; /* Initial index file allocation */
|
||
|
|
unsigned mem_start_tag ; /* Initial index file allocation */
|
||
|
|
unsigned mem_start_buffer ;
|
||
|
|
unsigned long mem_start_max ;
|
||
|
|
|
||
|
|
/* True/False Flags */
|
||
|
|
int auto_open ; /* Automatic production index file opening */
|
||
|
|
int create_error ; /* Do 'file4create' error ? */
|
||
|
|
int off_error ; /* Show error messages? */
|
||
|
|
int exclusive ; /* how should files be opened? */
|
||
|
|
int file_flush ; /* force hard file flush during write */
|
||
|
|
int expr_error ;
|
||
|
|
int field_name_error ;
|
||
|
|
int go_error ; /* Do 'd4go' error ? */
|
||
|
|
int open_error ; /* Do 'file4open' error ? */
|
||
|
|
int optimize ; /* should files be automatically bufferred? */
|
||
|
|
int read_lock ; /* Do lock when reading database ? */
|
||
|
|
int read_only ;
|
||
|
|
int relate_error ; /* do relate4terminate error when no match and relate4terminate selected */
|
||
|
|
int safety ; /* File create with safety ? */
|
||
|
|
int skip_error ; /* Do 'DataIndex::skip' error ? */
|
||
|
|
int tag_name_error;
|
||
|
|
|
||
|
|
int lock_attempts ; /* How many times to attempt locks. */
|
||
|
|
|
||
|
|
MEM4 S4PTR *index_memory ;
|
||
|
|
MEM4 S4PTR *data_memory ;
|
||
|
|
MEM4 S4PTR *tag_memory ;
|
||
|
|
MEM4 S4PTR *calc_memory ;
|
||
|
|
MEM4 S4PTR *bitmap_memory ;
|
||
|
|
LIST4 calc_list ;
|
||
|
|
|
||
|
|
MEM4 S4PTR *total_memory ;
|
||
|
|
LIST4 total_list ; /* A list of T4TOTAL */
|
||
|
|
LIST4 font_list;
|
||
|
|
int num_reports ;
|
||
|
|
int s4cr2;
|
||
|
|
|
||
|
|
int error_code ;
|
||
|
|
int debug_int ; /* used to check structure integrity (set to 0x5281) */
|
||
|
|
|
||
|
|
short pageno;
|
||
|
|
|
||
|
|
char S4PTR *field_buffer ; /* used by the f4str() function */
|
||
|
|
unsigned buf_len ;
|
||
|
|
|
||
|
|
char S4PTR *expr_work_buf ; /* used by expression parsing */
|
||
|
|
unsigned expr_buf_len ;
|
||
|
|
|
||
|
|
char S4PTR *stored_key ; /* used by the expr4key() function */
|
||
|
|
unsigned stored_key_len ;
|
||
|
|
|
||
|
|
int bitmap_disable ; /* used for testing purposes to test disabled bitmaps */
|
||
|
|
int do_index_verify ; /* for internal purposes only at this point */
|
||
|
|
|
||
|
|
#ifndef S4OPTIMIZE_OFF
|
||
|
|
int optimize_write ;
|
||
|
|
OPT4 opt ;
|
||
|
|
int has_opt, do_opt ;
|
||
|
|
unsigned int mode ;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef S4CLIPPER
|
||
|
|
int numeric_str_len ; /* the default length for clipper index files */
|
||
|
|
int decimals ; /* the default # decimals for clipper index files */
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef S4OS2SEM
|
||
|
|
#ifdef S4OS2
|
||
|
|
#ifndef S4IBMOS2
|
||
|
|
#ifndef __WATCOMC__
|
||
|
|
HMTX hmtx_mem, hmtx_expr ;
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
char saved_key[I4MAX_KEY_SIZE + 2 * sizeof(long)] ; /* used by i4remove.c, i4tag.c and i4addtag.c, i4version_check, t4version_check */
|
||
|
|
#ifdef __cplusplus
|
||
|
|
} ;
|
||
|
|
#else
|
||
|
|
} CODE4 ;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
class S4CLASS FILE4
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
#else
|
||
|
|
typedef struct FILE4_st
|
||
|
|
{
|
||
|
|
#endif
|
||
|
|
#ifndef S4OPTIMIZE_OFF
|
||
|
|
LINK4 link ; /* set to 0 if file not optimized */
|
||
|
|
long hash_init ;
|
||
|
|
long len ; /* internal if optimized */
|
||
|
|
char type ; /* dbf, index, other */
|
||
|
|
char buffer_writes ; /* are writes being bufferred? */
|
||
|
|
int do_buffer ; /* is the file bufferring on? */
|
||
|
|
#endif
|
||
|
|
char S4PTR *name ;
|
||
|
|
CODE4 S4PTR *code_base ;
|
||
|
|
int hand ;
|
||
|
|
char is_temp ; /* True if it is a temporary file */
|
||
|
|
|
||
|
|
/* is_exclusive and is_read_only both on indicate 'r' attribute on file */
|
||
|
|
/* is_read_only only on indicates user access is limited to read only */
|
||
|
|
/* if is_exclusive, will do full bufferring, if is_read_only, will avoid */
|
||
|
|
/* performing any disk writes */
|
||
|
|
|
||
|
|
char is_exclusive ; /* True if opened exclusive */
|
||
|
|
char is_read_only ; /* True if file is read only */
|
||
|
|
char do_alloc_free ;
|
||
|
|
char write_buffer ; /* buffer writes where possible */
|
||
|
|
char file_created ; /* false if the file has not been created yet - i.e. if a memory-only file */
|
||
|
|
|
||
|
|
|
||
|
|
#ifdef S4DEBUG_DEV
|
||
|
|
char dup_name[255] ;
|
||
|
|
int has_dup ;
|
||
|
|
int in_use ;
|
||
|
|
#endif
|
||
|
|
#ifdef __cplusplus
|
||
|
|
} ;
|
||
|
|
#else
|
||
|
|
} FILE4 ;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
FILE4 file ;
|
||
|
|
short block_size ; /* Bytes */
|
||
|
|
struct DATA4_st S4PTR *data ;
|
||
|
|
int file_lock ; /* True if file is locked */
|
||
|
|
} MEMO4FILE ;
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
class S4CLASS FILE4SEQ_READ
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
#else
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
#endif
|
||
|
|
FILE4 S4PTR *file ;
|
||
|
|
|
||
|
|
long pos ; /* The next position to read from */
|
||
|
|
char S4PTR *buffer ;
|
||
|
|
unsigned next_read_len ;
|
||
|
|
unsigned total ; /* Total buffer length */
|
||
|
|
unsigned working ; /* Temporary working buffer length (to help align write) */
|
||
|
|
unsigned avail ; /* # of bytes currently available */
|
||
|
|
#ifdef __cplusplus
|
||
|
|
} ;
|
||
|
|
#else
|
||
|
|
} FILE4SEQ_READ ;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef __cplusplus
|
||
|
|
class S4CLASS FILE4SEQ_WRITE
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
#else
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
#endif
|
||
|
|
FILE4 S4PTR *file ;
|
||
|
|
|
||
|
|
long pos ; /* The next position to read from */
|
||
|
|
char S4PTR *buffer ;
|
||
|
|
unsigned total ; /* Total buffer length */
|
||
|
|
unsigned working ; /* Temporary working buffer length (to help align write) */
|
||
|
|
unsigned avail ; /* # of bytes left in working buffer */
|
||
|
|
#ifdef __cplusplus
|
||
|
|
} ;
|
||
|
|
#else
|
||
|
|
} FILE4SEQ_WRITE ;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
typedef struct /* Data File Format */
|
||
|
|
{
|
||
|
|
char name[11] ;
|
||
|
|
char type ;
|
||
|
|
char filler[4] ;
|
||
|
|
unsigned char len ;
|
||
|
|
unsigned char dec ;
|
||
|
|
char filler2[13] ;
|
||
|
|
char has_tag ;
|
||
|
|
} FIELD4IMAGE ;
|
||
|
|
|
||
|
|
typedef struct /* Internal Structure and Field Routines. */
|
||
|
|
{
|
||
|
|
char name[11] ;
|
||
|
|
unsigned len ;
|
||
|
|
int dec ;
|
||
|
|
int type ;
|
||
|
|
int offset ;
|
||
|
|
struct DATA4_st S4PTR *data ;
|
||
|
|
struct F4MEMO_st S4PTR *memo ;
|
||
|
|
#ifdef S4VBASIC
|
||
|
|
int debug_int ; /* used to check structure integrity (set to 0x5281) */
|
||
|
|
#endif
|
||
|
|
} FIELD4 ;
|
||
|
|
|
||
|
|
typedef struct F4MEMO_st
|
||
|
|
{
|
||
|
|
int is_changed ;
|
||
|
|
|
||
|
|
int status ; /* 0 - Current contents, 1 - Unknown */
|
||
|
|
char S4PTR *contents ;
|
||
|
|
unsigned len ;
|
||
|
|
unsigned len_max ;
|
||
|
|
FIELD4 S4PTR *field ;
|
||
|
|
} F4MEMO ;
|
||
|
|
|
||
|
|
typedef struct /* Creating Data File */
|
||
|
|
{
|
||
|
|
char S4PTR *name ;
|
||
|
|
int type ;
|
||
|
|
unsigned int len ;
|
||
|
|
unsigned int dec ;
|
||
|
|
} FIELD4INFO ;
|
||
|
|
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
/* Database Header Information */
|
||
|
|
char version ; /* 83H with .dbt, 03H without */
|
||
|
|
char yy ; /* Last Update */
|
||
|
|
char mm ;
|
||
|
|
char dd ;
|
||
|
|
S4LONG num_recs ;
|
||
|
|
unsigned short header_len; /* Header Length, Indicates start of data */
|
||
|
|
unsigned short record_len;
|
||
|
|
char zero[16] ;
|
||
|
|
char has_mdx ; /* 1 for true */
|
||
|
|
char dummy ;
|
||
|
|
char zero2[2] ;
|
||
|
|
} DATA4HEADER_FULL ;
|
||
|
|
|
||
|
|
typedef struct DATA4_st
|
||
|
|
{
|
||
|
|
LINK4 link ;
|
||
|
|
|
||
|
|
/* Database Header Information */
|
||
|
|
char version ; /* 83H with .dbt, 03H without */
|
||
|
|
char yy ; /* Last Update */
|
||
|
|
char mm ;
|
||
|
|
char dd ;
|
||
|
|
S4LONG num_recs ;
|
||
|
|
unsigned short header_len; /* Header Length, Indicates start of data */
|
||
|
|
|
||
|
|
char S4PTR *record ; /* Data allocated with 'u4alloc' */
|
||
|
|
char S4PTR *record_old ; /* Data allocated with 'u4alloc' */
|
||
|
|
/* Extra byte added for temporary CTRL_Z */
|
||
|
|
unsigned record_width ;
|
||
|
|
int record_changed ; /* T/F */
|
||
|
|
S4LONG rec_num ; /* Record number; -1 unknown; 0 for append */
|
||
|
|
S4LONG rec_num_old ; /* Record number, -1 none present; 0 for append */
|
||
|
|
|
||
|
|
FILE4 file ;
|
||
|
|
char alias[11] ;
|
||
|
|
|
||
|
|
char memo_validated ; /* Can we be sure memo id #'s are up to date. */
|
||
|
|
|
||
|
|
CODE4 S4PTR *code_base ;
|
||
|
|
char has_mdx ; /* Has an MDX file attached to it */
|
||
|
|
|
||
|
|
FIELD4 S4PTR *fields ; /* An array of field pointers */
|
||
|
|
int n_fields ; /* The number of data fields in the database */
|
||
|
|
|
||
|
|
F4MEMO S4PTR *fields_memo ; /* A list of fields to be flushed */
|
||
|
|
int n_fields_memo ; /* The number of memo files in the database */
|
||
|
|
|
||
|
|
long locked_record ; /* 'locks' data when 'n_locks <= 1' */
|
||
|
|
long S4PTR *locks ;
|
||
|
|
int n_locks ; /* Number of elements in 'locks' allocated */
|
||
|
|
int num_locked ; /* Number of records locked */
|
||
|
|
int file_lock ; /* True if entire file is locked */
|
||
|
|
int append_lock ; /* True if the file is locked for appending */
|
||
|
|
|
||
|
|
int file_changed ; /* True if the file has been changed since */
|
||
|
|
/* the header has been updated. */
|
||
|
|
|
||
|
|
LIST4 indexes ;
|
||
|
|
int bof_flag, eof_flag ; /* Beginning/End of File flags */
|
||
|
|
|
||
|
|
short block_size ;
|
||
|
|
MEMO4FILE memo_file ; /* Memo file handle */
|
||
|
|
#ifdef S4VBASIC
|
||
|
|
int debug_int ; /* used to check structure integrity (set to 0x5281) */
|
||
|
|
#endif
|
||
|
|
#ifndef S4SINGLE
|
||
|
|
long minCount ; /* used as a minimum record count for various functions */
|
||
|
|
#endif
|
||
|
|
long count ; /* a fairly current record count on the database */
|
||
|
|
/* used by relate module, by put here for compatibility with report writer... */
|
||
|
|
} DATA4 ;
|
||
|
|
|
||
|
|
typedef void S4OPERATOR(void) ;
|
||
|
|
|
||
|
|
typedef struct E4INFO_st
|
||
|
|
{
|
||
|
|
FIELD4 S4PTR *field_ptr ;
|
||
|
|
char S4PTR *p1 ;
|
||
|
|
int len ; /* Length */
|
||
|
|
int num_entries ; /* Number of entries in sub-expression */
|
||
|
|
int num_parms ;
|
||
|
|
int result_pos ; /* The position in the result array for result. */
|
||
|
|
int i1 ; /* Could be constant position. 'i1' and 'result_pos'
|
||
|
|
and 'function_i' and 'function'
|
||
|
|
must be at last position due to memcmp() in e4is_tag() */
|
||
|
|
int function_i ;
|
||
|
|
S4OPERATOR S4PTR *function ;
|
||
|
|
} E4INFO ;
|
||
|
|
|
||
|
|
typedef struct e4expr_st
|
||
|
|
{
|
||
|
|
E4INFO S4PTR *info ;
|
||
|
|
int info_n ;
|
||
|
|
char S4PTR *source ;
|
||
|
|
char S4PTR *constants ;
|
||
|
|
int len ;
|
||
|
|
int type ;
|
||
|
|
#ifdef S4CLIPPER
|
||
|
|
int key_dec ; /* used for CLIPPER version */
|
||
|
|
int key_len ;
|
||
|
|
#endif
|
||
|
|
DATA4 S4PTR *data ;
|
||
|
|
CODE4 S4PTR *code_base ;
|
||
|
|
|
||
|
|
int len_eval ; /* This is the length of the buffer needed for evaluation. */
|
||
|
|
int num_parms ; /* This is the # of parameter positions used in evaluation. */
|
||
|
|
char has_trim ; /* special case for key evaluation */
|
||
|
|
} EXPR4 ;
|
||
|
|
|
||
|
|
#ifdef N4OTHER
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
long pointer ; /* =0L if record, not pointer */
|
||
|
|
long num ;
|
||
|
|
char value[1] ; /* The key size is variable */
|
||
|
|
} B4KEY_DATA ;
|
||
|
|
#else
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
S4LONG num ;
|
||
|
|
char value[1] ; /* The key size is variable */
|
||
|
|
} B4KEY_DATA ;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef S4FOX
|
||
|
|
/* the following structure is used only on the leaf nodes of the tree structure */
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
short free_space ; /* # bytes available in node */
|
||
|
|
unsigned char rec_num_mask[4] ; /* record number mask */
|
||
|
|
unsigned char dup_byte_cnt ; /* duplicate byte mask count */
|
||
|
|
unsigned char trail_byte_cnt ; /* Trailing byte mask count */
|
||
|
|
unsigned char rec_num_len ; /* # bits used for record number */
|
||
|
|
unsigned char dup_cnt_len ; /* # bits used for duplicate count */
|
||
|
|
unsigned char trail_cnt_len ; /* # bits used for trail count */
|
||
|
|
unsigned char info_len ; /* # bytes for holding record number, */
|
||
|
|
} B4NODE_HEADER ;
|
||
|
|
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
short node_attribute ; /* 0=index, 1=root, 2=leaf */
|
||
|
|
short n_keys ; /* Block Image starts here */
|
||
|
|
long left_node ; /* -1 if not present */
|
||
|
|
long right_node ; /* -1 if not present */
|
||
|
|
} B4STD_HEADER ;
|
||
|
|
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
LINK4 link ;
|
||
|
|
struct TAG4_st S4PTR *tag ;
|
||
|
|
|
||
|
|
int changed ;
|
||
|
|
long file_block ; /* Identifies block within index file */
|
||
|
|
int key_on ; /* The current key within the block */
|
||
|
|
int cur_trail_cnt ; /* current value used for seeking */
|
||
|
|
int cur_dup_cnt ; /* current value used for seeking */
|
||
|
|
int dup_pos ; /* bit offset into the info for the duplicate data */
|
||
|
|
int trail_pos ; /* bit offset into the info for the trail data */
|
||
|
|
int rec_pos ; /* bit offset into the info for the record # data */
|
||
|
|
char *cur_pos ; /* current position into the data (starts at end) */
|
||
|
|
|
||
|
|
int built_on ; /* the 'current' key value (i.e. key really 'on') */
|
||
|
|
char S4PTR *built_pos ; /* position where built on */
|
||
|
|
B4KEY_DATA S4PTR *built_key ;
|
||
|
|
|
||
|
|
B4STD_HEADER header ;
|
||
|
|
B4NODE_HEADER node_hdr ; /* only if the block is a leaf */
|
||
|
|
char data[1] ; /* the remaining data */
|
||
|
|
} B4BLOCK ;
|
||
|
|
|
||
|
|
#endif /* ifdef S4FOX */
|
||
|
|
|
||
|
|
#ifndef S4FOX
|
||
|
|
|
||
|
|
#ifdef S4NDX
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
long root ;
|
||
|
|
long eof ;
|
||
|
|
char n1_dummy ;
|
||
|
|
char type ;
|
||
|
|
char n2_dummy[2] ;
|
||
|
|
short key_len ;
|
||
|
|
short keys_max ; /* Maximum # of keys per block; <= 100 */
|
||
|
|
short int_or_date ; /* TRUE (1) if Numeric or Date Key */
|
||
|
|
short group_len ; /* key_len plus 8 increased to a multiple of 2 */
|
||
|
|
short dummy ;
|
||
|
|
short unique ; /* TRUE if Unique */
|
||
|
|
|
||
|
|
/* char expression[256] ; */
|
||
|
|
/* long version ; */
|
||
|
|
} I4IND_HEAD_WRITE;
|
||
|
|
#else
|
||
|
|
#ifdef S4CLIPPER
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
short sign ;
|
||
|
|
short version ;
|
||
|
|
long root ; /* Root Block */
|
||
|
|
long eof ; /* First Free Block Pointer */
|
||
|
|
short group_len ; /* Key Length + 2*sizeof(long) */
|
||
|
|
short key_len ; /* Key Length */
|
||
|
|
short key_dec ; /* Number of Decimals in Key */
|
||
|
|
short keys_max ; /* Maximum # of keys per block; <= 100 */
|
||
|
|
short keys_half ; /* Maximum # of keys per half block */
|
||
|
|
|
||
|
|
/* char expression[256]; The index expression corresponding to the database. */
|
||
|
|
/* short unique ; TRUE if Unique */
|
||
|
|
} I4IND_HEAD_WRITE;
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef S4NDX
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
long old_version ;
|
||
|
|
int header_offset ;
|
||
|
|
|
||
|
|
long root ;
|
||
|
|
long eof ;
|
||
|
|
char n1_dummy ;
|
||
|
|
char type ;
|
||
|
|
char n2_dummy[2] ;
|
||
|
|
short key_len ;
|
||
|
|
short keys_max ; /* Maximum # of keys per block; <= 100 */
|
||
|
|
short int_or_date ; /* TRUE (1) if Numeric or Date Key */
|
||
|
|
short group_len ; /* key_len plus 8 increased to a multiple of 2 */
|
||
|
|
short dummy ;
|
||
|
|
short unique ; /* TRUE if Unique */
|
||
|
|
/* char expression[256] ; */
|
||
|
|
long version ;
|
||
|
|
} T4HEADER ;
|
||
|
|
#else
|
||
|
|
#ifdef S4CLIPPER
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
long old_version ;
|
||
|
|
int header_offset ;
|
||
|
|
long virtual_eof ; /* The next available file block */
|
||
|
|
short sign ;
|
||
|
|
short version ;
|
||
|
|
long root ; /* Root Block */
|
||
|
|
long eof ; /* First Free Block Pointer */
|
||
|
|
short group_len ; /* Key Length + 2*sizeof(long) */
|
||
|
|
short key_len ; /* Key Length */
|
||
|
|
short key_dec ; /* Number of Decimals in Key */
|
||
|
|
short keys_max ; /* Maximum # of keys per block; <= 100 */
|
||
|
|
short keys_half ; /* Maximum # of keys per half block */
|
||
|
|
/* char expression[256] ; The index expression corresponding to the database. */
|
||
|
|
short unique ; /* TRUE if Unique */
|
||
|
|
short descending ; /* The descending flag corresponding to the index file */
|
||
|
|
/* char filter[256] ; The filter(for) expression corresponding to the database. */
|
||
|
|
} T4HEADER ;
|
||
|
|
#else
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
char two ; /* Version number (currently 2) */
|
||
|
|
char yymmdd[3] ; /* Date of last reindex */
|
||
|
|
char data_name[12] ; /* Name of associated data file */
|
||
|
|
char dummy1[4] ; /* extra 4 bytes for data-names-not used in DOS */
|
||
|
|
short block_chunks ; /* Block Size 1 to 32 (512 byte chunks) */
|
||
|
|
short block_rw ; /* Block Read/Write Size in bytes */
|
||
|
|
char is_production ; /* 1 if production index, else 0 */
|
||
|
|
char num_slots ; /* number possible tags (48) */
|
||
|
|
short slot_size ; /* number bytes/tag slot (32) */
|
||
|
|
short num_tags ;
|
||
|
|
short dummy2 ;
|
||
|
|
S4LONG eof ;
|
||
|
|
S4LONG free_list ; /* start of the free list */
|
||
|
|
char zero[4] ;
|
||
|
|
char create_date[3]; /* not used by CodeBase */
|
||
|
|
char blank ;
|
||
|
|
} I4HEADER ;
|
||
|
|
#endif /* ifdef S4CLIPPER */
|
||
|
|
#endif /* ifdef S4NDX */
|
||
|
|
#endif /* ifndef S4FOX */
|
||
|
|
|
||
|
|
|
||
|
|
#ifndef S4FOX
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
LINK4 link ;
|
||
|
|
struct TAG4_st S4PTR *tag ;
|
||
|
|
|
||
|
|
long file_block ; /* Identifies block within index file */
|
||
|
|
int changed ;
|
||
|
|
int key_on ; /* The current key within the block */
|
||
|
|
|
||
|
|
short n_keys ; /* Block Image starts here */
|
||
|
|
#ifdef S4NDX
|
||
|
|
char dummy[2] ;
|
||
|
|
B4KEY_DATA data ;
|
||
|
|
#else
|
||
|
|
#ifdef S4CLIPPER
|
||
|
|
short pointers[( B4BLOCK_SIZE / 2 - 1 )] ;
|
||
|
|
B4KEY_DATA S4PTR *data ;
|
||
|
|
#else
|
||
|
|
char dummy[6] ;
|
||
|
|
B4KEY_DATA info ;
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
} B4BLOCK ;
|
||
|
|
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
S4LONG header_pos ; /* Header position (in 512 byte chunks) */
|
||
|
|
char tag[10] ;
|
||
|
|
short x1000 ; /* used for dBASE/SQL expression type - dBASE only allowed for CBPP 1.0x */
|
||
|
|
char left_chld ;
|
||
|
|
char right_chld ;
|
||
|
|
char parent ;
|
||
|
|
char x2 ;
|
||
|
|
char index_type ;
|
||
|
|
char zeros[11] ;
|
||
|
|
} T4DESC ;
|
||
|
|
#endif /* ifndef S4FOX */
|
||
|
|
|
||
|
|
#ifndef N4OTHER
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
#ifdef S4FOX
|
||
|
|
S4LONG root ; /* -1 means unknown */
|
||
|
|
S4LONG free_list ; /* start of the free list (-1 if none) */
|
||
|
|
unsigned S4LONG version ; /* used multi-user only */
|
||
|
|
short key_len ; /* Key Length */
|
||
|
|
unsigned char type_code; /* 0x01 Uniq; 0x08 For Clause; 0x32 Compact; 0x80 Compound */
|
||
|
|
unsigned char signature ; /* unused */
|
||
|
|
|
||
|
|
/* char dummy2[482] ; unused */
|
||
|
|
char dummy3[4] ;
|
||
|
|
short descending ; /* 1 = descending, 0 = ascending */
|
||
|
|
short filter_pos ; /* not used, == to expr_len */
|
||
|
|
short filter_len ; /* length of filter clause */
|
||
|
|
short expr_pos ; /* not used, == to 0 */
|
||
|
|
short expr_len ; /* length of expression */
|
||
|
|
/* char expr_pool[512] ; expression and filter pool */
|
||
|
|
#else
|
||
|
|
S4LONG root ; /* -1 means unknown */
|
||
|
|
char dummy1[4] ;
|
||
|
|
char type_code; /* 0x10 Normal; 0x58 Uniq,Desc; 0x50 Uniq; 0x18 Desc */
|
||
|
|
char type ; /* N,D, or C (F is type N) */
|
||
|
|
char dummy2[2] ;
|
||
|
|
short key_len ;
|
||
|
|
short keys_max ; /* Maximum # of keys per block; <= 100 */
|
||
|
|
char dummy3[2] ; /* 1 if Numeric or Date Key (NDX only) */
|
||
|
|
short group_len ; /* key_len plus 4 (MDX); plus 8 (NDX) */
|
||
|
|
unsigned char version ;
|
||
|
|
char dummy4 ;
|
||
|
|
short unique ; /* 0x4000 (TRUE)if Unique */
|
||
|
|
|
||
|
|
/* Note, 'expr_key[220]' comes after 'unique' and */
|
||
|
|
/* 'expr_filter[220]' comes at position 0x2FA */
|
||
|
|
#endif
|
||
|
|
} T4HEADER ;
|
||
|
|
#endif /* ifndef N4OTHER */
|
||
|
|
|
||
|
|
typedef struct TAG4_st
|
||
|
|
{
|
||
|
|
LINK4 link ;
|
||
|
|
|
||
|
|
EXPR4 S4PTR *expr ;
|
||
|
|
EXPR4 S4PTR *filter ;
|
||
|
|
int unique_error; /* Is rewriting a unique key an error ? */
|
||
|
|
struct INDEX4_st S4PTR *index ;
|
||
|
|
S4CMP_FUNCTION *cmp ;
|
||
|
|
C4STOK S4PTR *stok ; /* Conversion for 'seek' */
|
||
|
|
C4DTOK S4PTR *dtok ; /* Conversion for 'seek' */
|
||
|
|
CODE4 S4PTR *code_base ;
|
||
|
|
char alias[11] ;
|
||
|
|
char has_keys ;
|
||
|
|
LIST4 blocks ;
|
||
|
|
|
||
|
|
FILE4 file ;
|
||
|
|
int file_locked ;
|
||
|
|
|
||
|
|
T4HEADER header ;
|
||
|
|
long header_offset ; /* Offset in file to the tag's header info. */
|
||
|
|
int root_write ; /* True if 'header.root' needs to be written */
|
||
|
|
int key_dec ;
|
||
|
|
LIST4 saved ;
|
||
|
|
int debug_int ; /* used to check structure integrity (set to 0x5281) */
|
||
|
|
#ifdef S4MDX
|
||
|
|
char had_keys ;
|
||
|
|
#endif
|
||
|
|
#ifdef S4FOX
|
||
|
|
char p_char ;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef S4CLIPPER
|
||
|
|
long check_eof ; /* used for debug purposes to verify eof length */
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#ifdef S4MDX
|
||
|
|
long changed ;
|
||
|
|
#endif
|
||
|
|
#ifdef S4UNIX
|
||
|
|
int key_type ;
|
||
|
|
#endif
|
||
|
|
} TAG4 ;
|
||
|
|
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
char S4PTR *name ;
|
||
|
|
char S4PTR *expression ;
|
||
|
|
char S4PTR *filter ;
|
||
|
|
int unique ;
|
||
|
|
unsigned int descending ;
|
||
|
|
} TAG4INFO ;
|
||
|
|
|
||
|
|
typedef struct INDEX4_st
|
||
|
|
{
|
||
|
|
LINK4 link ;
|
||
|
|
|
||
|
|
FILE4 file ;
|
||
|
|
DATA4 S4PTR *data ;
|
||
|
|
CODE4 S4PTR *code_base ;
|
||
|
|
LIST4 tags ;
|
||
|
|
char alias[11] ;
|
||
|
|
|
||
|
|
#ifdef S4FOX
|
||
|
|
TAG4 S4PTR *tag_index ; /* the tags are a tag in the index file! */
|
||
|
|
long eof ;
|
||
|
|
#else
|
||
|
|
#ifdef N4OTHER
|
||
|
|
char S4PTR *path ;
|
||
|
|
#else
|
||
|
|
I4HEADER header ;
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
|
||
|
|
MEM4 S4PTR *block_memory ;
|
||
|
|
int file_locked ; /* True if locked */
|
||
|
|
#ifdef S4FOX
|
||
|
|
unsigned long version_old ;
|
||
|
|
#else
|
||
|
|
#ifdef S4MDX
|
||
|
|
long changed ;
|
||
|
|
#else
|
||
|
|
long version_old ;
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
} INDEX4 ;
|
||
|
|
|
||
|
|
|
||
|
|
/* Memo File Structures */
|
||
|
|
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
#ifdef S4MFOX
|
||
|
|
S4LONG next_block ; /* Memo Entry 1,2, ... */
|
||
|
|
char usused[2] ;
|
||
|
|
short block_size ; /* Bytes */
|
||
|
|
#else
|
||
|
|
#ifdef S4MNDX
|
||
|
|
long next_block ; /* Memo Entry 1,2, ... */
|
||
|
|
#else
|
||
|
|
S4LONG next_block ; /* Memo Entry 1,2, ... */
|
||
|
|
S4LONG zero ;
|
||
|
|
char file_name[8] ;
|
||
|
|
short zero2 ;
|
||
|
|
short x102 ;
|
||
|
|
short block_size ; /* Bytes */
|
||
|
|
short zero3 ;
|
||
|
|
#endif
|
||
|
|
#endif
|
||
|
|
} MEMO4HEADER ;
|
||
|
|
|
||
|
|
#ifndef S4MNDX
|
||
|
|
#ifndef S4MFOX
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
S4LONG next ; /* The next free block area */
|
||
|
|
S4LONG num ; /* The number of free blocks in the free block area */
|
||
|
|
int to_disk ; /* TRUE if this information needs to be written to disk */
|
||
|
|
S4LONG block_no ; /* The current block number */
|
||
|
|
} MEMO4CHAIN_ENTRY ;
|
||
|
|
#endif /* ifndef S4MFOX */
|
||
|
|
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
#ifdef S4MFOX
|
||
|
|
long type ; /* 0 for picture, 1 for text -- picture not supported */
|
||
|
|
long num_chars ; /* Including the 'MemoBlock' */
|
||
|
|
#else
|
||
|
|
short minus_one ; /* '-1' for dBASE IV */
|
||
|
|
short start_pos ;
|
||
|
|
S4LONG num_chars ; /* Including the 'MemoBlock' */
|
||
|
|
#endif
|
||
|
|
} MEMO4BLOCK ;
|
||
|
|
#endif /* ifndef S4MNDX */
|
||
|
|
|
||
|
|
typedef struct
|
||
|
|
{
|
||
|
|
unsigned char sig_dig ; /* The number of significant digits; 52 is zero */
|
||
|
|
unsigned char digit_info ; /* contains one, len and sign */
|
||
|
|
unsigned char bcd[10] ;
|
||
|
|
} C4BCD ;
|