warden/early-roguelike
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
early-roguelike/urogue/dict.c
John "Elwin" Edwards d1422feb80 Fix a few more miscellaneous compiler warnings.
2021-05-01 09:51:30 -04:00

1158 lines
41 KiB
C
Raw Blame History

/*
dict.c
UltraRogue: The Ultimate Adventure in the Dungeons of Doom
Copyright (C) 1995 Herb Chong
All rights reserved.
See the file LICENSE.TXT for full copyright and licensing information.
*/
/******************
** Change history:
**
** (AK:04/03/95) - In dict_create, initialize hook for extensions to dictionary structure.
** (AK:04/04/95) - In dict_insert, only set any_ptr when a new string entry is created.
** (AK:04/17/95) - Added dict_union and dict_merge.
** (AK:04/18/95) - In dict_create, added code to create signature,
** table of contents, and parameter array.
** (AK:04/18/95) - Revised dict_load, dict_save
** (AK:04/18/95) - Added dict_import
**
******************/
#include <stdlib.h>
#include <string.h>
#if !defined(OS2) && !defined(_WIN32)
#include <unistd.h>
#endif
#include "dict.h"
#include "dictutil.h"
#define BUFLEN 300
/*************************************************************************
* Generic dictionary and hash table functions for word and
* string storage.
*
* Implements generic dictionary management by using a
* hash table with direct chaining. All terms are stored in a
* separate, unsorted, string table. When inserting into the
* hash table exceeds the current size, allocate a new hash table
* and rehash the old contents into the new table. When the string
* table fills, append more empty entries onto the old table and
* continue adding. Inserting a string that already exists increments
* the count for the string. Deleting a string only decrements the
* count to no less than 0. This will allow a 0 occurence string to be
* retrieved. To remove the 0 occurence string table entries, you must
* rebuild the dictionary. Merging from one dictionary to a new one will
* do this because it only copies nonzero occurences.
*
* Assumptions:
* unsigned long >= 32 bits
* int >= 16 bits
* char == 8 bits
* number of entries < 2^28
*************************************************************************/
/*************************************************************************
* hash_string: calculate hash value for string, modified
* version of hashpjw() from the new Dragon book.
*
* s - string to calculate hash for
*
* Returns: hash value
*************************************************************************/
static unsigned long hash_string(const char *s)
{
unsigned long h = 0;
unsigned long g = 0;
while (*s) {
h <<= 4;
h += *s++;
if ((g = h & 0xf0000000) != 0)
h ^= g >> 24;
}
return h ^ g;
}
/*************************************************************************
* dict_create: create a dictionary and initialize its structures
*
* toc_size - number of entries in table of contents ( >= 4 )
* initial_string_count - number of strings to hold as initial allocation
* initial_hash_chains - size of hash table, must be power of 4
* max_chain_length - max number of elements in hash chain before signalling growth
*
* Returns: pointer to dictionary
* NULL - error creating dictionary
* non-NULL - sucessful creation
*************************************************************************/
DICTIONARY *dict_create(
const long toc_size,
const long initial_string_count,
const long initial_hash_chains,
const long max_chain_length )
{
DICTIONARY *dtemp = NULL;
STRING_ENTRY *stemp = NULL;
long *ltemp = NULL;
char *sltemp;
long i, j, tocsize;
/* check for a power of 4 in number of initial hash entries */
switch(initial_hash_chains) {
case 0x00000004:
case 0x00000010:
case 0x00000040:
case 0x00000100:
case 0x00000400:
case 0x00001000:
case 0x00004000:
case 0x00010000:
case 0x00040000:
case 0x00100000:
case 0x00400000:
case 0x01000000:
case 0x04000000:
break;
default:
return NULL;
}
/* Allocate the dictionary structure */
if ((dtemp = (DICTIONARY *)malloc(sizeof(DICTIONARY))) == NULL)
goto err_exit;
/* string count has to be within range */
j = initial_string_count;
if (j > 0x04000000)
return NULL;
/* force a reasonable value */
if (j < 100)
j = 100;
/* Allocate the string table and string array */
if ((stemp = (STRING_ENTRY *)malloc(sizeof(STRING_ENTRY) * j)) == NULL)
goto err_exit;
if ((sltemp = (char *)malloc(8 * j)) == NULL)
goto err_exit;
/* Allocate the hash table */
if ((ltemp = (long *)malloc(sizeof(long) * initial_hash_chains)) == NULL)
goto err_exit;
/* Allocate the parameter array */
if ( (dtemp->parm = (DICT_PARM_ENTRY *)malloc(14*sizeof(DICT_PARM_ENTRY))) == NULL)
goto err_exit;
/* Allocate the signature structure */
if ( (dtemp->sig=(DICT_SIG*)malloc(sizeof(DICT_SIG))) == NULL )
goto err_exit;
/* Allocate the Table of Contents */
tocsize = toc_size;
if ( tocsize < 4 )
tocsize = 4;
dtemp->sig->toc_size = tocsize;
if ( (dtemp->toc=(DICT_TOC_ENTRY*)malloc(dtemp->sig->toc_size*sizeof(DICT_TOC_ENTRY))) == NULL )
goto err_exit;
dtemp->check_value = DICT_VALIDATE; /* validation value */
dtemp->flags = DICT_NONE; /* no flags set */
dtemp->entry_count = 0; /* nothing in either table */
dtemp->string_table = stemp; /* connect string table */
dtemp->string_max = j; /* size of string table */
dtemp->scan_string_index = DICT_ENTRY_NONE; /* not pointing to anything in scan */
dtemp->string_growth_count = 0; /* haven't grown any */
dtemp->string_array = sltemp; /* character array for strings */
dtemp->array_size = j * 8; /* how many bytes available */
dtemp->array_used = 0; /* nothing used yet */
dtemp->array_growth_count = 0; /* haven't grown any */
/* force maximum hash chain length to a reasonable value */
i = max_chain_length;
if (i < 1 || i > 200)
i = 200;
dtemp->chains = ltemp; /* connect hash table */
dtemp->longest_chain_length = 0; /* nothing in table yet */
dtemp->allowable_chain_length = i; /* chain length limit */
dtemp->table_size = initial_hash_chains; /* size of hash table */
dtemp->hash_mask = initial_hash_chains - 1; /* mask for mod() function */
dtemp->hash_growth_count = 0; /* haven't grown any */
/* string table is empty */
for (i = 0 ; i < j ; i++) {
dtemp->string_table[i].string_offset = DICT_ENTRY_NONE;
dtemp->string_table[i].count = 0;
dtemp->string_table[i].next = DICT_ENTRY_NONE;
dtemp->string_table[i].flags = 0;
dtemp->string_table[i].hash_value = 0;
}
/* no entries chained */
for (i = 0; i < initial_hash_chains; i++)
dtemp->chains[i] = DICT_ENTRY_NONE;
/* Initialize hook to extended dictionary structure */
dtemp->ext = NULL;
/* Set up the parameter array */
if ( dict_set_parm_ids(dtemp) == FALSE )
goto err_exit;
if ( dict_set_parm_values(dtemp) == FALSE )
goto err_exit;
/* Set up the Table of Contents */
strcpy( dtemp->toc[0].id , "PARM" );
dtemp->toc[0].size = dtemp->sig->nparms * sizeof(DICT_PARM_ENTRY);
dtemp->toc[0].ptr = dtemp->parm;
dtemp->toc[0].type = 0;
strcpy( dtemp->toc[1].id , "HASH" );
dtemp->toc[1].size = dtemp->table_size * sizeof(long);
dtemp->toc[1].ptr = dtemp->chains;
dtemp->toc[1].type = 0;
strcpy( dtemp->toc[2].id , "STTB" );
dtemp->toc[2].size = dtemp->string_max * sizeof(char);
dtemp->toc[2].ptr = dtemp->string_table;
dtemp->toc[2].type = 0;
strcpy( dtemp->toc[3].id , "STAR" );
dtemp->toc[3].size = dtemp->array_size * sizeof(STRING_ENTRY);
dtemp->toc[3].ptr = dtemp->string_array;
dtemp->toc[3].type = 0;
/* Set up the signature */
dtemp->sig->check_value = DICT_VALIDATE;
dtemp->sig->toc_size = tocsize;
dtemp->sig->nparms = 14;
return dtemp;
/* error exit - saves duplicate code */
err_exit:
dict_destroy( dtemp );
return NULL;
}
/*************************************************************************
* dict_destroy: discard a dictionary and its contents
* multiple calls to destroy the same dictionary is safe
*
* dict - pointer to a dictionary to discard
*
* Returns: status code
* TRUE - dictionary destroyed
* FALSE - error when destroying dictionary
* Note: Does free the dictionary structure itself.
*************************************************************************/
BOOLEANC dict_destroy(DICTIONARY *dict)
{
int i;
/* have to point to something */
if (dict == NULL)
return FALSE;
/* check value has to be OK */
if (dict->check_value != DICT_VALIDATE)
return FALSE;
if ( (dict->sig==NULL) || (dict->toc==NULL) || (dict->parm==NULL) )
return FALSE;
/* Free the type=0 tables */
for ( i = 0 ; i < dict->sig->toc_size ; i++ ) {
if ( dict->toc[i].ptr != NULL && dict->toc[i].type == 0 )
free( dict->toc[i].ptr );
} /* endfor */
/* Free the Table of Contents and signature */
free( dict->toc );
free( dict->sig );
/* Free the dictionary structure itself */
free( dict );
return TRUE;
}
/*************************************************************************
* dict_insert: add entries into the dictionary, growing as necessary
*
* dict - pointer to dictionary to insert into
* s - string to insert
* count - count of occurences of string
* flags - flag bits associated with the string
* number - pointer to long to return word number
*
* Returns: pointer to new entry in dictionary
* NULL - error during insert
* non-NULL - pointer to inserted or updated entry
*
* Notes: if the entry already exists, increment the count.
* If NULL is returned, the dictionary state can no longer
* be trusted. Terminating with an error code would be
* safest.
*************************************************************************/
STRING_ENTRY *dict_insert(DICTIONARY *dict, char *s,
const long occurences, const unsigned long flags,
void *any_ptr, long *number)
{
unsigned long hash_value;
long hash_index;
long string_index = -1;
long he2;
int chain_len;
/* have to point to something */
if (dict == NULL)
return FALSE;
/* check value has to be OK */
if (dict->check_value != DICT_VALIDATE)
return FALSE;
/* must have a string */
if (s == NULL) {
*number = -1;
return FALSE;
}
/* must be non-NULL */
if (s[0] == '\0') {
*number = -1;
return FALSE;
}
/* figure out which chain it should go into */
hash_value = hash_string(s);
hash_index = hash_value & dict->hash_mask;
/* look for the entry in the chain */
for (he2 = dict->chains[hash_index], chain_len = 0; he2 != DICT_ENTRY_NONE;
he2 = dict->string_table[he2].next, chain_len++) {
char *sa = &dict->string_array[dict->string_table[he2].string_offset];
/* compare hash_value and then string, in that order, for speed */
if (dict->string_table[he2].hash_value == hash_value && !strcmp(s, sa)) {
string_index = he2;
break;
}
}
/* string wasn't found */
if (string_index < 0) {
/* make sure there is room in string entry table */
if (dict->entry_count + 1 > dict->string_max) {
/* make new table 20% bigger */
dict->string_max = (dict->string_max * 6) / 5;
dict->string_table = (STRING_ENTRY *)realloc(dict->string_table,
sizeof(STRING_ENTRY) * dict->string_max);
if (dict->string_table == NULL)
return NULL;
dict->string_growth_count++;
}
string_index = dict->entry_count;
dict->entry_count++;
/* make sure there is room in the string array */
if (dict->array_used + (long)strlen(s) + 1 > dict->array_size) {
dict->array_size = (dict->array_size * 6) / 5;
dict->string_array = (char *) realloc(dict->string_array,
dict->array_size);
if (dict->string_array == NULL)
return NULL;
}
/* fill in starting values */
strcpy(&dict->string_array[dict->array_used], s);
dict->string_table[string_index].string_offset = dict->array_used;
dict->array_used += (long) strlen(s) + 1;
dict->string_table[string_index].count = 0 ;
dict->string_table[string_index].flags = DICT_NONE;
dict->string_table[string_index].any_ptr = any_ptr; /* (AK:04/04/95) */
dict->string_table[string_index].hash_value = hash_value;
/* hook entry at beginning of chain */
dict->string_table[string_index].next = dict->chains[hash_index];
dict->chains[hash_index] = string_index;
/* record chain lengths */
chain_len++;
if (chain_len > dict->longest_chain_length)
dict->longest_chain_length = chain_len;
/* if a chain is too long */
if (chain_len > dict->allowable_chain_length) {
long new_size = dict->table_size * 4;
long new_mask = new_size - 1;
long *hetemp;
long i;
int longest_chain;
if ((hetemp = (long *)malloc(sizeof(long) * new_size)) == NULL)
return NULL;
/* hash table chains are empty */
for (i = 0; i < new_size; i++)
hetemp[i] = DICT_ENTRY_NONE;
/* reset all chains */
for (i = 0; i < dict->entry_count; i++)
dict->string_table[i].next = DICT_ENTRY_NONE;
/* recreate hash table entries by reinserting all strings */
for (i = 0; i < dict->entry_count; i++) {
long he = dict->string_table[i].hash_value & new_mask;
dict->string_table[i].next = hetemp[he];
hetemp[he] = i;
}
/* find longest chain length */
for (i = 0, longest_chain = 0; i < new_size; i++) {
int len;
long cur;
for (cur = hetemp[i], len = 0; cur != DICT_ENTRY_NONE;
cur = dict->string_table[cur].next)
len++;
;
if (len > longest_chain)
longest_chain = len;
}
/* delete old table and attach new one */
free(dict->chains);
dict->chains = hetemp;
dict->longest_chain_length = longest_chain;
dict->table_size = new_size;
dict->hash_mask = new_mask;
/* keep track of growth */
dict->hash_growth_count++;
}
}
dict->string_table[string_index].count += occurences;
dict->string_table[string_index].flags |= flags;
*number = string_index;
return &dict->string_table[string_index];
}
/*************************************************************************
* dict_delete: deletes an entry from the dictionary
* (Actually, only decrements the entry's count)
*
* dict - pointer to dictionary to delete
* s - string to find and delete
* count - count to decrement entry by
*
* Returns: status code
* TRUE - entry has been deleted
* FALSE - entry wasn't found or error occured
*************************************************************************/
BOOLEANC dict_delete(const DICTIONARY *dict, const char *s, const long count)
{
STRING_ENTRY *se;
long n;
/* find the string */
if ((se = dict_search(dict, s, &n)) == NULL)
return FALSE;
/* decrement count and make sure it stays valid */
se->count -= count;
if (se->count < 0)
se->count = 0;
return TRUE;
}
/*************************************************************************
* dict_search: look for entries in the dictionary
*
* dict - pointer to dictionary to search
* s - string to search for
* number - pointer to long to return string number
*
* Returns: pointer to string entry
* NULL - entry not found
* non-NULL - pointer to string entry
*************************************************************************/
STRING_ENTRY *dict_search(const DICTIONARY *dict, const char *s,
long *number)
{
unsigned long hash_value;
long hash_index;
long string_index = -1;
long he;
/* have to point to something */
if (dict == NULL)
return NULL;
/* check value has to be OK */
if (dict->check_value != DICT_VALIDATE)
return NULL;
/* must have a string */
if (s == NULL) {
*number = -1;
return NULL;
}
/* must be non-NULL */
if (s[0] == '\0') {
*number = -1;
return FALSE;
}
/* figure out which chain it should be in */
hash_value = hash_string(s);
hash_index = hash_value & dict->hash_mask;
/* look for the entry in the chain */
for (he = dict->chains[hash_index]; he != DICT_ENTRY_NONE;
he = dict->string_table[he].next) {
char *sa = (char*)(&dict->string_array[dict->string_table[he].string_offset]);
/* compare hash_value and then string, in that order, for speed */
if (dict->string_table[he].hash_value == hash_value && !strcmp(s, sa)) {
string_index = he;
break;
}
}
if (string_index < 0) {
*number = -1;
return NULL;
}
*number = string_index;
return dict->string_table+string_index;
}
/*************************************************************************
* dict_union: merges contents of 2 dictionaries into
* a third
*
* dict1 - pointer to dictionary 1
* dict2 - pointer to dictionary 2
*
* Returns: dictionary pointer
* NULL - failed to merge
* non-NULL - pointer to new dictionary
*
* Notes: entries of the same string have their counts
* added and their flags ORed together.
*************************************************************************/
DICTIONARY *dict_union( const DICTIONARY *dict1 , const DICTIONARY *dict2 )
{
DICTIONARY *dict = NULL;
STRING_ENTRY *se, *se2;
long initial_string_count, initial_hash_chains, max_chain_length;
long i, string_index;
/***********
** Initialize the new dictionary.
***********/
if ( dict1==NULL || dict2==NULL )
goto err_exit;
if ((dict=(DICTIONARY *)malloc(sizeof(DICTIONARY))) == NULL)
goto err_exit;
initial_string_count = dict1->string_max;
initial_hash_chains = dict1->table_size;
max_chain_length = dict1->allowable_chain_length;
dict = dict_create( 4,
initial_string_count,
initial_hash_chains,
max_chain_length );
/***********
** Copy the entries from dict1 into the new dictionary.
***********/
for ( i = 0 ; i < dict1->entry_count ; i++ ) {
se = (STRING_ENTRY*)&dict1->string_table[i];
if ( se->count > 0 ) {
se2 = dict_insert(
dict,
dict1->string_array+se->string_offset,
se->count,
se->flags,
NULL,
&string_index );
if ( se2 == NULL )
goto err_exit;
} /* endif */
} /* endfor */
/* Merge the entries from dict2 into the new dictionary. */
if ( dict_merge(dict,dict2,FALSE) == FALSE )
goto err_exit;
/* Success. Return a pointer to the new dictionary. */
return( dict );
/* Failure. Ignominiously erase our tracks and return NULL. */
err_exit:
dict_destroy( dict );
return NULL;
}
/*************************************************************************
* dict_merge: merges the contents of a dictionary into
* another one, updating the contents of the destination
*
* dst - dictionary to update
* src - dictionary to add
* move - boolean flag
* TRUE - move to dest
* FALSE - copy to dest
*
* Returns: status code
* TRUE - merge completed
* FALSE - error on merge
*
* Notes: entries of the same string have their counts
* added. At the end of a move, src is empty. If there
* is an error during a move, the contents of both
* dictionaries cannot be trusted.
*************************************************************************/
BOOLEANC dict_merge(const DICTIONARY *dst, const DICTIONARY *src, const BOOLEANC move)
{
STRING_ENTRY *se, *se2;
DICTIONARY *dict1, *dict2;
long i, string_index, index;
dict1 = (DICTIONARY*)src;
dict2 = (DICTIONARY*)dst;
/***********
** Copy the dictionary entries into the new dictionary.
***********/
for ( i = 0 ; i < dict1->entry_count ; i++ ) {
se = (STRING_ENTRY*)&dict1->string_table[i];
if ( se->count > 0 ) {
se2 = dict_insert(
dict2,
dict1->string_array+se->string_offset,
se->count,
se->flags,
NULL,
&string_index );
if ( se2 == NULL )
goto err_exit;
} /* endif */
} /* endfor */
/***********
** Set up the dictionary parameter vector.
***********/
if ( dict_set_parm_values(dict2) == FALSE )
return( FALSE );
/***********
** Update the table of contents.
** PARM HASH STTB STAR
***********/
if ( (index=dict_toc_index(dict2,"HASH")) == -1)
goto err_exit;
dict2->toc[index].size = dict2->table_size * sizeof(long);
dict2->toc[index].ptr = dict2->chains;
if ( (index=dict_toc_index(dict2,"STTB")) == -1)
goto err_exit;
dict2->toc[index].size = dict2->string_max * sizeof(char);
dict2->toc[index].ptr = dict2->string_table;
if ( (index=dict_toc_index(dict2,"STAR")) == -1)
goto err_exit;
dict2->toc[index].size = dict2->array_size * sizeof(STRING_ENTRY);
dict2->toc[index].ptr = dict2->string_array;
/***********
** Update the signature
***********/
dict2->sig->checksum =
compute_checksum( 4*sizeof(DICT_TOC_ENTRY) , (char*)(dict2->toc) );
/***********
** If this is a move, destroy the source dictionary
***********/
if ( move == TRUE )
if ( dict_destroy(dict1) == FALSE )
goto err_exit;
/***********
** Success
***********/
return( TRUE );
/***********
** Failure
***********/
err_exit:
dict_destroy( dict2 );
return FALSE;
}
/*************************************************************************
* dict_string_by_number: return string pointer for
* a given string number
*
* number - string number
*
* Returns: pointer to string entry
* NULL - entry not found
* non-NULL - pointer to string entry
*************************************************************************/
STRING_ENTRY *dict_string_by_number(const DICTIONARY *dict, const long number)
{
if (dict == NULL)
return NULL;
/* check value has to be OK */
if (dict->check_value != DICT_VALIDATE)
return NULL;
/* string number has to be within range */
if (number < 0 || number >= dict->entry_count)
return NULL;
return dict->string_table+number;
}
/*************************************************************************
* dict_scan_begin: begin a scan of the dictionary
*
* dict - pointer to dictionary to scan
*
* Returns: status code
* TRUE - scan initialized
* FALSE - error
*
* Notes: if a scan is already in progress, it is
* abandoned and the scan is reset to the
* beginning.
*************************************************************************/
BOOLEANC dict_scan_begin(DICTIONARY *dict)
{
/* have to point to something */
if (dict == NULL)
return FALSE;
/* check value has to be OK */
if (dict->check_value != DICT_VALIDATE)
return FALSE;
/* point to first entry in string table */
dict->scan_string_index = 0;
return TRUE;
}
/*************************************************************************
* dict_scan_next: get the next entry in a scan
*
* dict - pointer to dictionary to continue scanning
*
* Returns: pointer to string entry
* NULL - no more entries
* non-NULL - next string entry
*************************************************************************/
STRING_ENTRY *dict_scan_next(DICTIONARY *dict)
{
/* have to point to something */
if (dict == NULL)
return NULL;
/* check value has to be OK */
if (dict->check_value != DICT_VALIDATE)
return NULL;
/* scan index has to be within range */
if (dict->scan_string_index < 0
|| dict->scan_string_index > dict->entry_count)
return NULL;
/* for first non-empty table entry */
while (dict->scan_string_index < dict->entry_count
&& dict->string_table[dict->scan_string_index].count == 0)
dict->scan_string_index++;
/* past end of table? */
if (dict->scan_string_index >= dict->entry_count)
return NULL;
return &dict->string_table[dict->scan_string_index++];
}
/*************************************************************************
* dict_load - load a compiled dictionary into memory
* creates a new dictionary
*
* fname - fully qualified file name
*
* Returns: pointer to created dictionary structure
* (NULL on failure)
*************************************************************************/
DICTIONARY *dict_load(const char *fname)
{
DICTIONARY *dict = NULL;
int code, index;
FILE *fi;
int ntoc;
if ( (fi=fopen((char*)fname,"rb")) == NULL ) {
signal_error( "dict_load: could not open file" , (char*)fname , 0 );
goto err_exit;
} /* endif */
if ((dict = (DICTIONARY *)malloc(sizeof(DICTIONARY))) == NULL) {
/* signal_error( "dict_load: alloc failed" , "" , 0 ); */
goto err_exit;
} /* endif */
/* Read the dictionary signature record */
if ((dict->sig = (DICT_SIG *)malloc(sizeof(DICT_SIG))) == NULL) {
goto err_exit;
} /* endif */
code = block_read( fi , (char*)(dict->sig) , sizeof(DICT_SIG) , 0 );
if ( code == -1 ) {
signal_error( "dict_load: could not read signature" , (char*)fname , 0 );
goto err_exit;
} /* endif */
if ( dict->sig->check_value != DICT_VALIDATE ) {
signal_error( "dict_load: could not validate file" , (char*)fname , 0 );
goto err_exit;
} /* endif */
dict->check_value = dict->sig->check_value;
/* Read the dictionary Table of Contents */
ntoc = dict->sig->toc_size;
dict->toc = (DICT_TOC_ENTRY *) malloc( ntoc * sizeof(DICT_TOC_ENTRY) );
if ( dict->toc == NULL ) {
signal_error( "dict_load: alloc of TOC failed" , "" , 0 );
goto err_exit;
} /* endif */
code = block_read( fi ,
(char*)(dict->toc) ,
ntoc * sizeof(DICT_TOC_ENTRY) ,
sizeof(DICT_SIG) );
if ( code == -1 ) {
signal_error( "dict_load: could not read Table of Contents" , (char*)fname , 0 );
goto err_exit;
} /* endif */
/* Read the dictionary parameters */
dict->parm = (DICT_PARM_ENTRY *)
dict_load_block( dict , "PARM" , fi , NULL );
if ( dict->parm == NULL ) {
signal_error( "dict_load: could not load parameter table" , "" , 0 );
goto err_exit;
} /* endif */
index = dict_toc_index( dict , "PARM" );
dict->sig->nparms = dict->toc[index].size / sizeof(DICT_PARM_ENTRY);
/* Set the parameter values in the dictionary structure */
if ( dict_set_parm_variables(dict) == FALSE )
goto err_exit;
/* Load the string array */
dict->string_array = (char *)
dict_load_block( dict , "STAR" , fi , NULL );
if ( dict->string_array == NULL ) {
signal_error( "dict_load: could not load string array" , (char*)fname , 0 );
goto err_exit;
} /* endif */
/* Load the string table */
dict->string_table = (STRING_ENTRY *)
dict_load_block( dict , "STTB" , fi , NULL );
if ( dict->string_table == NULL ) {
signal_error( "dict_load: could not load string table" , (char*)fname , 0 );
goto err_exit;
} /* endif */
/* Load the hash table */
dict->chains = (long *)
dict_load_block( dict , "HASH" , fi , NULL );
if ( dict->chains == NULL ) {
signal_error( "dict_load: could not load hash table" , (char*)fname , 0 );
goto err_exit;
} /* endif */
/* Initialize the hook for dictionary extensions */
dict->ext = NULL;
/* Success */
fclose( fi );
return( dict );
/* Failure */
err_exit:
if ( fi != NULL )
fclose( fi );
dict_destroy( dict );
return NULL;
}
/*************************************************************************
* dict_save - save a dictionary from memory into a file
*
* dict - pointer to dictionary to save
* fname - full qualified file name prefix of dictionary
*
* Returns: status code
* TRUE - dictionary was saved sucessfully
* FALSE - error during save
*************************************************************************/
BOOLEANC dict_save( DICTIONARY *dict, const char *fname )
{
int index, ret_code;
FILE *fo = NULL;
/* Have to be pointing at a valid dictionary */
if ( dict == NULL || dict->sig->check_value != DICT_VALIDATE )
goto err_exit;
/* Open the file for output */
if ( (fo=fopen((char*)fname,"wb")) == NULL )
goto err_exit;
/* Make the table of contents entries current */
/* Note: This will not be necessary once the data is stored in EVECTORs */
if ( (index=dict_toc_index(dict,"PARM")) == -1 )
goto err_exit;
dict->toc[index].size = dict->sig->nparms * sizeof(DICT_PARM_ENTRY);
dict->toc[index].ptr = dict->parm;
if ( (index=dict_toc_index(dict,"STAR")) == -1 )
goto err_exit;
dict->toc[index].size = dict->array_size * sizeof(char);
dict->toc[index].ptr = dict->string_array;
if ( (index=dict_toc_index(dict,"STTB")) == -1 )
goto err_exit;
dict->toc[index].size = dict->string_max * sizeof(STRING_ENTRY);
dict->toc[index].ptr = dict->string_table;
if ( (index=dict_toc_index(dict,"HASH")) == -1 )
goto err_exit;
dict->toc[index].size = dict->table_size * sizeof(long);
dict->toc[index].ptr = dict->chains;
/* Reset the TOC offsets and checksums for ALL tables */
/* (not just type=0 tables) */
dict_reset_toc_offsets( dict );
/* Set the dictionary parm structure from the parameter values */
if ( dict_set_parm_values(dict) == FALSE )
goto err_exit;
/* Save the signature */
dict->sig->checksum = compute_checksum( sizeof(DICT_SIG) , (char*)(dict->sig) );
ret_code = block_write( fo ,
(char*)dict->sig ,
sizeof(DICT_SIG) );
if ( ret_code == -1 )
goto err_exit;
/* Save the table of contents */
ret_code = block_write( fo,
(char*)dict->toc,
dict->sig->toc_size * sizeof(DICT_TOC_ENTRY) );
if ( ret_code == -1 )
goto err_exit;
/* Save the tables */
/* For now, only save type=0 tables */
for ( index = 0 ; index < dict->sig->toc_size ; index++ ) {
if ( dict->toc[index].type == 0 ) { /* Ordinary table */
ret_code = dict_save_block( dict , dict->toc[index].id , fo );
if ( ret_code == FALSE )
goto err_exit;
} /* endif */
} /* endfor */
/* Success */
fclose( fo );
return TRUE;
/* Failure */
err_exit:
if ( fo != NULL )
fclose( fo );
return FALSE;
}
/*************************************************************************
* dict_import: read in an ASCII dictionary.
*
* dict_fname - name of dictionary file
* parameters to create a DICTIONARY structure (see dict_create)
*
* Returns: pointer to created DICTIONARY structure
* (NULL on failure)
*
*************************************************************************/
DICTIONARY *dict_import( const char *dict_fname ,
const long initial_string_count ,
const long initial_hash_entries ,
const long max_chain_length )
{
DICTIONARY *dict;
char buffer[BUFLEN], ch;
int index, c, c0;
long number;
FILE *fi = NULL;
/***********
** Dictionary setup.
***********/
dict = dict_create( 4,
initial_string_count ,
initial_hash_entries ,
max_chain_length );
if ( dict == NULL )
goto err_exit;
/***********
** Read the dictionary file
** Each line should have one word or a string delimited by '|'
***********/
if ( (fi=fopen(dict_fname,"r")) == NULL )
goto err_exit;
while( fgets(buffer,BUFLEN,fi) != NULL ) {
c0 = 0;
/* Skip to non-blank */
while ( (c0<BUFLEN-2) && (buffer[c0]==' ') ) ++c0;
if ( buffer[c0] == '|' ) {
c = ++c0;
ch = '|';
} else {
c = c0;
ch = ' ';
} /* endif */
/* Scan to blank or matching '|' */
while ( (c<BUFLEN-1) && (buffer[c]!='\0') &&
(buffer[c]!='\n') && (buffer[c]!=ch) )
++c;
buffer[c] = '\0';
/* Insert the word */
if ( dict_insert(dict,buffer+c0,1,0,NULL,&number) == NULL )
goto err_exit;
} /* endwhile */
/***********
** Fill in the dictionary parameter vector.
***********/
if ( dict_set_parm_values(dict) == FALSE )
goto err_exit;
/***********
** Update the table of contents for HASH STTB STAR
***********/
if ( (index=dict_toc_index(dict,"HASH")) == -1 )
goto err_exit;
dict->toc[index].size = dict->table_size * sizeof(long);
if ( (index=dict_toc_index(dict,"STTB")) == -1 )
goto err_exit;
dict->toc[index].size = dict->string_max * sizeof(char);
if ( (index=dict_toc_index(dict,"STAR")) == -1 )
goto err_exit;
dict->toc[index].size = dict->array_size * sizeof(STRING_ENTRY);
/* Success. Return a pointer to the new dictionary. */
fclose(fi);
return( dict );
/* Failure. Ignominiously erase our tracks and return NULL. */
err_exit:
if ( fi != NULL )
fclose(fi);
dict_destroy( dict );
return NULL;
}
/*************************************************************************
* dict_export - save an extended dictionary from memory into
* an ASCII file
*
* dict - pointer to dictionary to save
* fname - full qualified file name prefix of dictionary
*
* Returns: status code
* TRUE - dictionary was saved sucessfully
* FALSE - error during save
*
*************************************************************************/
BOOLEANC dict_export( DICTIONARY *dict , const char *fname )
{
FILE *fp = NULL;
STRING_ENTRY *se;
int i;
/* have to point to something */
if (dict == NULL)
goto err_exit;
/* check value has to be OK */
if (dict->check_value != DICT_VALIDATE)
goto err_exit;
/* must have a filename */
if (fname == NULL)
goto err_exit;
fp = fopen( (char*)fname , "w" );
if ( fp == NULL )
goto err_exit;
for ( i = 0 ; i < dict->entry_count ; i++ ) {
se = &dict->string_table[i];
fprintf( fp , "|%s|\n" , dict->string_array + se->string_offset );
} /* endfor */
fclose( fp );
/* Success. */
fclose(fp);
return TRUE;
/* Failure. */
err_exit:
if ( fp != NULL )
fclose(fp);
dict_destroy( dict );
return FALSE;
}
Reference in a new issue View git blame Copy permalink