/* 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 ;