Annotation of early-roguelike/urogue/dict.c, Revision 1.1
1.1 ! rubenllo 1: /*
! 2: dict.c
! 3:
! 4: UltraRogue: The Ultimate Adventure in the Dungeons of Doom
! 5: Copyright (C) 1995 Herb Chong
! 6: All rights reserved.
! 7:
! 8: See the file LICENSE.TXT for full copyright and licensing information.
! 9: */
! 10:
! 11: /******************
! 12: ** Change history:
! 13: **
! 14: ** (AK:04/03/95) - In dict_create, initialize hook for extensions to dictionary structure.
! 15: ** (AK:04/04/95) - In dict_insert, only set any_ptr when a new string entry is created.
! 16: ** (AK:04/17/95) - Added dict_union and dict_merge.
! 17: ** (AK:04/18/95) - In dict_create, added code to create signature,
! 18: ** table of contents, and parameter array.
! 19: ** (AK:04/18/95) - Revised dict_load, dict_save
! 20: ** (AK:04/18/95) - Added dict_import
! 21: **
! 22: ******************/
! 23:
! 24: static char sccsid[] = "%W% %G%";
! 25:
! 26: #include <stdlib.h>
! 27: #include <string.h>
! 28: #if !defined(OS2) && !defined(_WIN32)
! 29: #include <unistd.h>
! 30: #endif
! 31:
! 32: #include "dict.h"
! 33: #include "dictutil.h"
! 34:
! 35: #define BUFLEN 300
! 36:
! 37: /*************************************************************************
! 38: * Generic dictionary and hash table functions for word and
! 39: * string storage.
! 40: *
! 41: * Implements generic dictionary management by using a
! 42: * hash table with direct chaining. All terms are stored in a
! 43: * separate, unsorted, string table. When inserting into the
! 44: * hash table exceeds the current size, allocate a new hash table
! 45: * and rehash the old contents into the new table. When the string
! 46: * table fills, append more empty entries onto the old table and
! 47: * continue adding. Inserting a string that already exists increments
! 48: * the count for the string. Deleting a string only decrements the
! 49: * count to no less than 0. This will allow a 0 occurence string to be
! 50: * retrieved. To remove the 0 occurence string table entries, you must
! 51: * rebuild the dictionary. Merging from one dictionary to a new one will
! 52: * do this because it only copies nonzero occurences.
! 53: *
! 54: * Assumptions:
! 55: * unsigned long >= 32 bits
! 56: * int >= 16 bits
! 57: * char == 8 bits
! 58: * number of entries < 2^28
! 59: *************************************************************************/
! 60:
! 61: /*************************************************************************
! 62: * hash_string: calculate hash value for string, modified
! 63: * version of hashpjw() from the new Dragon book.
! 64: *
! 65: * s - string to calculate hash for
! 66: *
! 67: * Returns: hash value
! 68: *************************************************************************/
! 69: static unsigned long hash_string(const char *s)
! 70: {
! 71: unsigned long h = 0;
! 72: unsigned long g = 0;
! 73:
! 74: while (*s) {
! 75: h <<= 4;
! 76: h += *s++;
! 77: if ((g = h & 0xf0000000) != 0)
! 78: h ^= g >> 24;
! 79: }
! 80: return h ^ g;
! 81: }
! 82:
! 83: /*************************************************************************
! 84: * dict_create: create a dictionary and initialize its structures
! 85: *
! 86: * toc_size - number of entries in table of contents ( >= 4 )
! 87: * initial_string_count - number of strings to hold as initial allocation
! 88: * initial_hash_chains - size of hash table, must be power of 4
! 89: * max_chain_length - max number of elements in hash chain before signalling growth
! 90: *
! 91: * Returns: pointer to dictionary
! 92: * NULL - error creating dictionary
! 93: * non-NULL - sucessful creation
! 94: *************************************************************************/
! 95:
! 96: DICTIONARY *dict_create(
! 97: const long toc_size,
! 98: const long initial_string_count,
! 99: const long initial_hash_chains,
! 100: const long max_chain_length )
! 101: {
! 102: DICTIONARY *dtemp = NULL;
! 103: STRING_ENTRY *stemp = NULL;
! 104: long *ltemp = NULL;
! 105: char *sltemp;
! 106: long i, j, tocsize;
! 107:
! 108: /* check for a power of 4 in number of initial hash entries */
! 109: switch(initial_hash_chains) {
! 110: case 0x00000004:
! 111: case 0x00000010:
! 112: case 0x00000040:
! 113: case 0x00000100:
! 114: case 0x00000400:
! 115: case 0x00001000:
! 116: case 0x00004000:
! 117: case 0x00010000:
! 118: case 0x00040000:
! 119: case 0x00100000:
! 120: case 0x00400000:
! 121: case 0x01000000:
! 122: case 0x04000000:
! 123: break;
! 124: default:
! 125: return NULL;
! 126: }
! 127:
! 128: /* Allocate the dictionary structure */
! 129: if ((dtemp = (DICTIONARY *)malloc(sizeof(DICTIONARY))) == NULL)
! 130: goto err_exit;
! 131:
! 132: /* string count has to be within range */
! 133: j = initial_string_count;
! 134: if (j > 0x04000000)
! 135: return NULL;
! 136:
! 137: /* force a reasonable value */
! 138: if (j < 100)
! 139: j = 100;
! 140:
! 141: /* Allocate the string table and string array */
! 142: if ((stemp = (STRING_ENTRY *)malloc(sizeof(STRING_ENTRY) * j)) == NULL)
! 143: goto err_exit;
! 144: if ((sltemp = (char *)malloc(8 * j)) == NULL)
! 145: goto err_exit;
! 146:
! 147: /* Allocate the hash table */
! 148: if ((ltemp = (long *)malloc(sizeof(long) * initial_hash_chains)) == NULL)
! 149: goto err_exit;
! 150:
! 151: /* Allocate the parameter array */
! 152: if ( (dtemp->parm = (DICT_PARM_ENTRY *)malloc(14*sizeof(DICT_PARM_ENTRY))) == NULL)
! 153: goto err_exit;
! 154:
! 155: /* Allocate the signature structure */
! 156: if ( (dtemp->sig=(DICT_SIG*)malloc(sizeof(DICT_SIG))) == NULL )
! 157: goto err_exit;
! 158:
! 159: /* Allocate the Table of Contents */
! 160: tocsize = toc_size;
! 161: if ( tocsize < 4 )
! 162: tocsize = 4;
! 163: dtemp->sig->toc_size = tocsize;
! 164: if ( (dtemp->toc=(DICT_TOC_ENTRY*)malloc(dtemp->sig->toc_size*sizeof(DICT_TOC_ENTRY))) == NULL )
! 165: goto err_exit;
! 166:
! 167: dtemp->check_value = DICT_VALIDATE; /* validation value */
! 168: dtemp->flags = DICT_NONE; /* no flags set */
! 169: dtemp->entry_count = 0; /* nothing in either table */
! 170:
! 171: dtemp->string_table = stemp; /* connect string table */
! 172: dtemp->string_max = j; /* size of string table */
! 173: dtemp->scan_string_index = DICT_ENTRY_NONE; /* not pointing to anything in scan */
! 174: dtemp->string_growth_count = 0; /* haven't grown any */
! 175:
! 176: dtemp->string_array = sltemp; /* character array for strings */
! 177: dtemp->array_size = j * 8; /* how many bytes available */
! 178: dtemp->array_used = 0; /* nothing used yet */
! 179: dtemp->array_growth_count = 0; /* haven't grown any */
! 180:
! 181: /* force maximum hash chain length to a reasonable value */
! 182: i = max_chain_length;
! 183: if (i < 1 || i > 200)
! 184: i = 200;
! 185: dtemp->chains = ltemp; /* connect hash table */
! 186: dtemp->longest_chain_length = 0; /* nothing in table yet */
! 187: dtemp->allowable_chain_length = i; /* chain length limit */
! 188: dtemp->table_size = initial_hash_chains; /* size of hash table */
! 189: dtemp->hash_mask = initial_hash_chains - 1; /* mask for mod() function */
! 190: dtemp->hash_growth_count = 0; /* haven't grown any */
! 191:
! 192: /* string table is empty */
! 193: for (i = 0 ; i < j ; i++) {
! 194: dtemp->string_table[i].string_offset = DICT_ENTRY_NONE;
! 195: dtemp->string_table[i].count = 0;
! 196: dtemp->string_table[i].next = DICT_ENTRY_NONE;
! 197: dtemp->string_table[i].flags = 0;
! 198: dtemp->string_table[i].hash_value = 0;
! 199: }
! 200:
! 201: /* no entries chained */
! 202: for (i = 0; i < initial_hash_chains; i++)
! 203: dtemp->chains[i] = DICT_ENTRY_NONE;
! 204:
! 205: /* Initialize hook to extended dictionary structure */
! 206: dtemp->ext = NULL;
! 207:
! 208: /* Set up the parameter array */
! 209: if ( dict_set_parm_ids(dtemp) == FALSE )
! 210: goto err_exit;
! 211: if ( dict_set_parm_values(dtemp) == FALSE )
! 212: goto err_exit;
! 213:
! 214: /* Set up the Table of Contents */
! 215: strcpy( dtemp->toc[0].id , "PARM" );
! 216: dtemp->toc[0].size = dtemp->sig->nparms * sizeof(DICT_PARM_ENTRY);
! 217: dtemp->toc[0].ptr = dtemp->parm;
! 218: dtemp->toc[0].type = 0;
! 219:
! 220: strcpy( dtemp->toc[1].id , "HASH" );
! 221: dtemp->toc[1].size = dtemp->table_size * sizeof(long);
! 222: dtemp->toc[1].ptr = dtemp->chains;
! 223: dtemp->toc[1].type = 0;
! 224:
! 225: strcpy( dtemp->toc[2].id , "STTB" );
! 226: dtemp->toc[2].size = dtemp->string_max * sizeof(char);
! 227: dtemp->toc[2].ptr = dtemp->string_table;
! 228: dtemp->toc[2].type = 0;
! 229:
! 230: strcpy( dtemp->toc[3].id , "STAR" );
! 231: dtemp->toc[3].size = dtemp->array_size * sizeof(STRING_ENTRY);
! 232: dtemp->toc[3].ptr = dtemp->string_array;
! 233: dtemp->toc[3].type = 0;
! 234:
! 235: /* Set up the signature */
! 236: dtemp->sig->check_value = DICT_VALIDATE;
! 237: dtemp->sig->toc_size = tocsize;
! 238: dtemp->sig->nparms = 14;
! 239:
! 240: return dtemp;
! 241:
! 242: /* error exit - saves duplicate code */
! 243: err_exit:
! 244:
! 245: dict_destroy( dtemp );
! 246: return NULL;
! 247: }
! 248:
! 249: /*************************************************************************
! 250: * dict_destroy: discard a dictionary and its contents
! 251: * multiple calls to destroy the same dictionary is safe
! 252: *
! 253: * dict - pointer to a dictionary to discard
! 254: *
! 255: * Returns: status code
! 256: * TRUE - dictionary destroyed
! 257: * FALSE - error when destroying dictionary
! 258: * Note: Does free the dictionary structure itself.
! 259: *************************************************************************/
! 260: BOOLEANC dict_destroy(DICTIONARY *dict)
! 261: {
! 262: int i;
! 263:
! 264: /* have to point to something */
! 265: if (dict == NULL)
! 266: return FALSE;
! 267:
! 268: /* check value has to be OK */
! 269: if (dict->check_value != DICT_VALIDATE)
! 270: return FALSE;
! 271:
! 272: if ( (dict->sig==NULL) || (dict->toc==NULL) || (dict->parm==NULL) )
! 273: return FALSE;
! 274:
! 275: /* Free the type=0 tables */
! 276: for ( i = 0 ; i < dict->sig->toc_size ; i++ ) {
! 277: if ( dict->toc[i].ptr != NULL && dict->toc[i].type == 0 )
! 278: free( dict->toc[i].ptr );
! 279: } /* endfor */
! 280:
! 281: /* Free the Table of Contents and signature */
! 282: free( dict->toc );
! 283: free( dict->sig );
! 284:
! 285: /* Free the dictionary structure itself */
! 286: free( dict );
! 287:
! 288: return TRUE;
! 289: }
! 290:
! 291: /*************************************************************************
! 292: * dict_insert: add entries into the dictionary, growing as necessary
! 293: *
! 294: * dict - pointer to dictionary to insert into
! 295: * s - string to insert
! 296: * count - count of occurences of string
! 297: * flags - flag bits associated with the string
! 298: * number - pointer to long to return word number
! 299: *
! 300: * Returns: pointer to new entry in dictionary
! 301: * NULL - error during insert
! 302: * non-NULL - pointer to inserted or updated entry
! 303: *
! 304: * Notes: if the entry already exists, increment the count.
! 305: * If NULL is returned, the dictionary state can no longer
! 306: * be trusted. Terminating with an error code would be
! 307: * safest.
! 308: *************************************************************************/
! 309: STRING_ENTRY *dict_insert(DICTIONARY *dict, char *s,
! 310: const long occurences, const unsigned long flags,
! 311: void *any_ptr, long *number)
! 312: {
! 313: unsigned long hash_value;
! 314: long hash_index;
! 315: long string_index = -1;
! 316: long he2;
! 317: int chain_len;
! 318:
! 319: /* have to point to something */
! 320: if (dict == NULL)
! 321: return FALSE;
! 322:
! 323: /* check value has to be OK */
! 324: if (dict->check_value != DICT_VALIDATE)
! 325: return FALSE;
! 326:
! 327: /* must have a string */
! 328: if (s == NULL) {
! 329: *number = -1;
! 330: return FALSE;
! 331: }
! 332:
! 333: /* must be non-NULL */
! 334: if (s[0] == '\0') {
! 335: *number = -1;
! 336: return FALSE;
! 337: }
! 338:
! 339: /* figure out which chain it should go into */
! 340: hash_value = hash_string(s);
! 341: hash_index = hash_value & dict->hash_mask;
! 342:
! 343: /* look for the entry in the chain */
! 344: for (he2 = dict->chains[hash_index], chain_len = 0; he2 != DICT_ENTRY_NONE;
! 345: he2 = dict->string_table[he2].next, chain_len++) {
! 346: char *sa = &dict->string_array[dict->string_table[he2].string_offset];
! 347:
! 348: /* compare hash_value and then string, in that order, for speed */
! 349: if (dict->string_table[he2].hash_value == hash_value && !strcmp(s, sa)) {
! 350: string_index = he2;
! 351: break;
! 352: }
! 353: }
! 354:
! 355: /* string wasn't found */
! 356: if (string_index < 0) {
! 357: /* make sure there is room in string entry table */
! 358: if (dict->entry_count + 1 > dict->string_max) {
! 359: /* make new table 20% bigger */
! 360: dict->string_max = (dict->string_max * 6) / 5;
! 361: dict->string_table = (STRING_ENTRY *)realloc(dict->string_table,
! 362: sizeof(STRING_ENTRY) * dict->string_max);
! 363: if (dict->string_table == NULL)
! 364: return NULL;
! 365: dict->string_growth_count++;
! 366: }
! 367: string_index = dict->entry_count;
! 368: dict->entry_count++;
! 369:
! 370: /* make sure there is room in the string array */
! 371: if (dict->array_used + (long)strlen(s) + 1 > dict->array_size) {
! 372: dict->array_size = (dict->array_size * 6) / 5;
! 373: dict->string_array = (char *) realloc(dict->string_array,
! 374: dict->array_size);
! 375: if (dict->string_array == NULL)
! 376: return NULL;
! 377: }
! 378:
! 379: /* fill in starting values */
! 380: strcpy(&dict->string_array[dict->array_used], s);
! 381: dict->string_table[string_index].string_offset = dict->array_used;
! 382: dict->array_used += (long) strlen(s) + 1;
! 383: dict->string_table[string_index].count = 0 ;
! 384: dict->string_table[string_index].flags = DICT_NONE;
! 385: dict->string_table[string_index].any_ptr = any_ptr; /* (AK:04/04/95) */
! 386: dict->string_table[string_index].hash_value = hash_value;
! 387:
! 388: /* hook entry at beginning of chain */
! 389: dict->string_table[string_index].next = dict->chains[hash_index];
! 390: dict->chains[hash_index] = string_index;
! 391:
! 392: /* record chain lengths */
! 393: chain_len++;
! 394: if (chain_len > dict->longest_chain_length)
! 395: dict->longest_chain_length = chain_len;
! 396:
! 397: /* if a chain is too long */
! 398: if (chain_len > dict->allowable_chain_length) {
! 399: long new_size = dict->table_size * 4;
! 400: long new_mask = new_size - 1;
! 401: long *hetemp;
! 402: long i;
! 403: int longest_chain;
! 404:
! 405: if ((hetemp = (long *)malloc(sizeof(long) * new_size)) == NULL)
! 406: return NULL;
! 407:
! 408: /* hash table chains are empty */
! 409: for (i = 0; i < new_size; i++)
! 410: hetemp[i] = DICT_ENTRY_NONE;
! 411:
! 412: /* reset all chains */
! 413: for (i = 0; i < dict->entry_count; i++)
! 414: dict->string_table[i].next = DICT_ENTRY_NONE;
! 415:
! 416: /* recreate hash table entries by reinserting all strings */
! 417: for (i = 0; i < dict->entry_count; i++) {
! 418: long he = dict->string_table[i].hash_value & new_mask;
! 419:
! 420: dict->string_table[i].next = hetemp[he];
! 421: hetemp[he] = i;
! 422: }
! 423:
! 424: /* find longest chain length */
! 425: for (i = 0, longest_chain = 0; i < new_size; i++) {
! 426: int len;
! 427: long cur;
! 428:
! 429: for (cur = hetemp[i], len = 0; cur != DICT_ENTRY_NONE;
! 430: cur = dict->string_table[cur].next)
! 431: len++;
! 432: ;
! 433: if (len > longest_chain)
! 434: longest_chain = len;
! 435: }
! 436:
! 437: /* delete old table and attach new one */
! 438: free(dict->chains);
! 439: dict->chains = hetemp;
! 440: dict->longest_chain_length = longest_chain;
! 441: dict->table_size = new_size;
! 442: dict->hash_mask = new_mask;
! 443:
! 444: /* keep track of growth */
! 445: dict->hash_growth_count++;
! 446: }
! 447: }
! 448:
! 449: dict->string_table[string_index].count += occurences;
! 450: dict->string_table[string_index].flags |= flags;
! 451: *number = string_index;
! 452:
! 453: return &dict->string_table[string_index];
! 454: }
! 455:
! 456: /*************************************************************************
! 457: * dict_delete: deletes an entry from the dictionary
! 458: * (Actually, only decrements the entry's count)
! 459: *
! 460: * dict - pointer to dictionary to delete
! 461: * s - string to find and delete
! 462: * count - count to decrement entry by
! 463: *
! 464: * Returns: status code
! 465: * TRUE - entry has been deleted
! 466: * FALSE - entry wasn't found or error occured
! 467: *************************************************************************/
! 468: BOOLEANC dict_delete(const DICTIONARY *dict, const char *s, const long count)
! 469: {
! 470: STRING_ENTRY *se;
! 471: long n;
! 472:
! 473: /* find the string */
! 474: if ((se = dict_search(dict, s, &n)) == NULL)
! 475: return FALSE;
! 476:
! 477: /* decrement count and make sure it stays valid */
! 478: se->count -= count;
! 479: if (se->count < 0)
! 480: se->count = 0;
! 481: return TRUE;
! 482: }
! 483:
! 484: /*************************************************************************
! 485: * dict_search: look for entries in the dictionary
! 486: *
! 487: * dict - pointer to dictionary to search
! 488: * s - string to search for
! 489: * number - pointer to long to return string number
! 490: *
! 491: * Returns: pointer to string entry
! 492: * NULL - entry not found
! 493: * non-NULL - pointer to string entry
! 494: *************************************************************************/
! 495: STRING_ENTRY *dict_search(const DICTIONARY *dict, const char *s,
! 496: long *number)
! 497: {
! 498: unsigned long hash_value;
! 499: long hash_index;
! 500: long string_index = -1;
! 501: long he;
! 502:
! 503: /* have to point to something */
! 504: if (dict == NULL)
! 505: return NULL;
! 506:
! 507: /* check value has to be OK */
! 508: if (dict->check_value != DICT_VALIDATE)
! 509: return NULL;
! 510:
! 511: /* must have a string */
! 512: if (s == NULL) {
! 513: *number = -1;
! 514: return NULL;
! 515: }
! 516:
! 517: /* must be non-NULL */
! 518: if (s[0] == '\0') {
! 519: *number = -1;
! 520: return FALSE;
! 521: }
! 522:
! 523: /* figure out which chain it should be in */
! 524: hash_value = hash_string(s);
! 525: hash_index = hash_value & dict->hash_mask;
! 526:
! 527: /* look for the entry in the chain */
! 528: for (he = dict->chains[hash_index]; he != DICT_ENTRY_NONE;
! 529: he = dict->string_table[he].next) {
! 530: char *sa = (char*)(&dict->string_array[dict->string_table[he].string_offset]);
! 531:
! 532: /* compare hash_value and then string, in that order, for speed */
! 533: if (dict->string_table[he].hash_value == hash_value && !strcmp(s, sa)) {
! 534: string_index = he;
! 535: break;
! 536: }
! 537: }
! 538: if (string_index < 0) {
! 539: *number = -1;
! 540: return NULL;
! 541: }
! 542:
! 543: *number = string_index;
! 544: return dict->string_table+string_index;
! 545: }
! 546:
! 547: /*************************************************************************
! 548: * dict_union: merges contents of 2 dictionaries into
! 549: * a third
! 550: *
! 551: * dict1 - pointer to dictionary 1
! 552: * dict2 - pointer to dictionary 2
! 553: *
! 554: * Returns: dictionary pointer
! 555: * NULL - failed to merge
! 556: * non-NULL - pointer to new dictionary
! 557: *
! 558: * Notes: entries of the same string have their counts
! 559: * added and their flags ORed together.
! 560: *************************************************************************/
! 561: DICTIONARY *dict_union( const DICTIONARY *dict1 , const DICTIONARY *dict2 )
! 562: {
! 563: DICTIONARY *dict = NULL;
! 564: STRING_ENTRY *se, *se2;
! 565: long initial_string_count, initial_hash_chains, max_chain_length;
! 566: long i, string_index;
! 567:
! 568: /***********
! 569: ** Initialize the new dictionary.
! 570: ***********/
! 571:
! 572: if ( dict1==NULL || dict2==NULL )
! 573: goto err_exit;
! 574: if ((dict=(DICTIONARY *)malloc(sizeof(DICTIONARY))) == NULL)
! 575: goto err_exit;
! 576:
! 577: initial_string_count = dict1->string_max;
! 578: initial_hash_chains = dict1->table_size;
! 579: max_chain_length = dict1->allowable_chain_length;
! 580: dict = dict_create( 4,
! 581: initial_string_count,
! 582: initial_hash_chains,
! 583: max_chain_length );
! 584:
! 585: /***********
! 586: ** Copy the entries from dict1 into the new dictionary.
! 587: ***********/
! 588:
! 589: for ( i = 0 ; i < dict1->entry_count ; i++ ) {
! 590: se = (STRING_ENTRY*)&dict1->string_table[i];
! 591: if ( se->count > 0 ) {
! 592: se2 = dict_insert(
! 593: dict,
! 594: dict1->string_array+se->string_offset,
! 595: se->count,
! 596: se->flags,
! 597: NULL,
! 598: &string_index );
! 599: if ( se2 == NULL )
! 600: goto err_exit;
! 601: } /* endif */
! 602: } /* endfor */
! 603:
! 604: /* Merge the entries from dict2 into the new dictionary. */
! 605: if ( dict_merge(dict,dict2,FALSE) == FALSE )
! 606: goto err_exit;
! 607:
! 608: /* Success. Return a pointer to the new dictionary. */
! 609: return( dict );
! 610:
! 611: /* Failure. Ignominiously erase our tracks and return NULL. */
! 612: err_exit:
! 613: dict_destroy( dict );
! 614: return NULL;
! 615: }
! 616:
! 617: /*************************************************************************
! 618: * dict_merge: merges the contents of a dictionary into
! 619: * another one, updating the contents of the destination
! 620: *
! 621: * dst - dictionary to update
! 622: * src - dictionary to add
! 623: * move - boolean flag
! 624: * TRUE - move to dest
! 625: * FALSE - copy to dest
! 626: *
! 627: * Returns: status code
! 628: * TRUE - merge completed
! 629: * FALSE - error on merge
! 630: *
! 631: * Notes: entries of the same string have their counts
! 632: * added. At the end of a move, src is empty. If there
! 633: * is an error during a move, the contents of both
! 634: * dictionaries cannot be trusted.
! 635: *************************************************************************/
! 636: BOOLEANC dict_merge(const DICTIONARY *dst, const DICTIONARY *src, const BOOLEANC move)
! 637: {
! 638: STRING_ENTRY *se, *se2;
! 639: DICTIONARY *dict1, *dict2;
! 640: long i, string_index, index;
! 641:
! 642: dict1 = (DICTIONARY*)src;
! 643: dict2 = (DICTIONARY*)dst;
! 644:
! 645: /***********
! 646: ** Copy the dictionary entries into the new dictionary.
! 647: ***********/
! 648:
! 649: for ( i = 0 ; i < dict1->entry_count ; i++ ) {
! 650: se = (STRING_ENTRY*)&dict1->string_table[i];
! 651: if ( se->count > 0 ) {
! 652: se2 = dict_insert(
! 653: dict2,
! 654: dict1->string_array+se->string_offset,
! 655: se->count,
! 656: se->flags,
! 657: NULL,
! 658: &string_index );
! 659: if ( se2 == NULL )
! 660: goto err_exit;
! 661: } /* endif */
! 662: } /* endfor */
! 663:
! 664: /***********
! 665: ** Set up the dictionary parameter vector.
! 666: ***********/
! 667:
! 668: if ( dict_set_parm_values(dict2) == FALSE )
! 669: return( FALSE );
! 670:
! 671: /***********
! 672: ** Update the table of contents.
! 673: ** PARM HASH STTB STAR
! 674: ***********/
! 675:
! 676: if ( (index=dict_toc_index(dict2,"HASH")) == -1)
! 677: goto err_exit;
! 678: dict2->toc[index].size = dict2->table_size * sizeof(long);
! 679: dict2->toc[index].ptr = dict2->chains;
! 680:
! 681: if ( (index=dict_toc_index(dict2,"STTB")) == -1)
! 682: goto err_exit;
! 683: dict2->toc[index].size = dict2->string_max * sizeof(char);
! 684: dict2->toc[index].ptr = dict2->string_table;
! 685:
! 686: if ( (index=dict_toc_index(dict2,"STAR")) == -1)
! 687: goto err_exit;
! 688: dict2->toc[index].size = dict2->array_size * sizeof(STRING_ENTRY);
! 689: dict2->toc[index].ptr = dict2->string_array;
! 690:
! 691: /***********
! 692: ** Update the signature
! 693: ***********/
! 694:
! 695: dict2->sig->checksum =
! 696: compute_checksum( 4*sizeof(DICT_TOC_ENTRY) , (char*)(dict2->toc) );
! 697:
! 698: /***********
! 699: ** If this is a move, destroy the source dictionary
! 700: ***********/
! 701:
! 702: if ( move == TRUE )
! 703: if ( dict_destroy(dict1) == FALSE )
! 704: goto err_exit;
! 705:
! 706: /***********
! 707: ** Success
! 708: ***********/
! 709:
! 710: return( TRUE );
! 711:
! 712: /***********
! 713: ** Failure
! 714: ***********/
! 715:
! 716: err_exit:
! 717: dict_destroy( dict2 );
! 718: return FALSE;
! 719: }
! 720:
! 721: /*************************************************************************
! 722: * dict_string_by_number: return string pointer for
! 723: * a given string number
! 724: *
! 725: * number - string number
! 726: *
! 727: * Returns: pointer to string entry
! 728: * NULL - entry not found
! 729: * non-NULL - pointer to string entry
! 730: *************************************************************************/
! 731: STRING_ENTRY *dict_string_by_number(const DICTIONARY *dict, const long number)
! 732: {
! 733: if (dict == NULL)
! 734: return NULL;
! 735:
! 736: /* check value has to be OK */
! 737: if (dict->check_value != DICT_VALIDATE)
! 738: return NULL;
! 739:
! 740: /* string number has to be within range */
! 741: if (number < 0 || number >= dict->entry_count)
! 742: return NULL;
! 743:
! 744: return dict->string_table+number;
! 745: }
! 746:
! 747: /*************************************************************************
! 748: * dict_scan_begin: begin a scan of the dictionary
! 749: *
! 750: * dict - pointer to dictionary to scan
! 751: *
! 752: * Returns: status code
! 753: * TRUE - scan initialized
! 754: * FALSE - error
! 755: *
! 756: * Notes: if a scan is already in progress, it is
! 757: * abandoned and the scan is reset to the
! 758: * beginning.
! 759: *************************************************************************/
! 760: BOOLEANC dict_scan_begin(DICTIONARY *dict)
! 761: {
! 762: /* have to point to something */
! 763: if (dict == NULL)
! 764: return FALSE;
! 765:
! 766: /* check value has to be OK */
! 767: if (dict->check_value != DICT_VALIDATE)
! 768: return FALSE;
! 769:
! 770: /* point to first entry in string table */
! 771: dict->scan_string_index = 0;
! 772: return TRUE;
! 773: }
! 774:
! 775: /*************************************************************************
! 776: * dict_scan_next: get the next entry in a scan
! 777: *
! 778: * dict - pointer to dictionary to continue scanning
! 779: *
! 780: * Returns: pointer to string entry
! 781: * NULL - no more entries
! 782: * non-NULL - next string entry
! 783: *************************************************************************/
! 784: STRING_ENTRY *dict_scan_next(DICTIONARY *dict)
! 785: {
! 786: /* have to point to something */
! 787: if (dict == NULL)
! 788: return NULL;
! 789:
! 790: /* check value has to be OK */
! 791: if (dict->check_value != DICT_VALIDATE)
! 792: return NULL;
! 793:
! 794: /* scan index has to be within range */
! 795: if (dict->scan_string_index < 0
! 796: || dict->scan_string_index > dict->entry_count)
! 797: return NULL;
! 798:
! 799: /* for first non-empty table entry */
! 800: while (dict->scan_string_index < dict->entry_count
! 801: && dict->string_table[dict->scan_string_index].count == 0)
! 802: dict->scan_string_index++;
! 803:
! 804: /* past end of table? */
! 805: if (dict->scan_string_index >= dict->entry_count)
! 806: return NULL;
! 807:
! 808: return &dict->string_table[dict->scan_string_index++];
! 809: }
! 810:
! 811:
! 812: /*************************************************************************
! 813: * dict_load - load a compiled dictionary into memory
! 814: * creates a new dictionary
! 815: *
! 816: * fname - fully qualified file name
! 817: *
! 818: * Returns: pointer to created dictionary structure
! 819: * (NULL on failure)
! 820: *************************************************************************/
! 821: DICTIONARY *dict_load(const char *fname)
! 822: {
! 823: DICTIONARY *dict = NULL;
! 824: int code, index;
! 825: FILE *fi;
! 826: int ntoc;
! 827:
! 828: if ( (fi=fopen((char*)fname,"rb")) == NULL ) {
! 829: signal_error( "dict_load: could not open file" , (char*)fname , 0 );
! 830: goto err_exit;
! 831: } /* endif */
! 832:
! 833: if ((dict = (DICTIONARY *)malloc(sizeof(DICTIONARY))) == NULL) {
! 834: /* signal_error( "dict_load: alloc failed" , "" , 0 ); */
! 835: goto err_exit;
! 836: } /* endif */
! 837:
! 838: /* Read the dictionary signature record */
! 839: if ((dict->sig = (DICT_SIG *)malloc(sizeof(DICT_SIG))) == NULL) {
! 840: goto err_exit;
! 841: } /* endif */
! 842: code = block_read( fi , (char*)(dict->sig) , sizeof(DICT_SIG) , 0 );
! 843: if ( code == -1 ) {
! 844: signal_error( "dict_load: could not read signature" , (char*)fname , 0 );
! 845: goto err_exit;
! 846: } /* endif */
! 847:
! 848: if ( dict->sig->check_value != DICT_VALIDATE ) {
! 849: signal_error( "dict_load: could not validate file" , (char*)fname , 0 );
! 850: goto err_exit;
! 851: } /* endif */
! 852: dict->check_value = dict->sig->check_value;
! 853:
! 854: /* Read the dictionary Table of Contents */
! 855: ntoc = dict->sig->toc_size;
! 856: dict->toc = (DICT_TOC_ENTRY *) malloc( ntoc * sizeof(DICT_TOC_ENTRY) );
! 857: if ( dict->toc == NULL ) {
! 858: signal_error( "dict_load: alloc of TOC failed" , "" , 0 );
! 859: goto err_exit;
! 860: } /* endif */
! 861: code = block_read( fi ,
! 862: (char*)(dict->toc) ,
! 863: ntoc * sizeof(DICT_TOC_ENTRY) ,
! 864: sizeof(DICT_SIG) );
! 865: if ( code == -1 ) {
! 866: signal_error( "dict_load: could not read Table of Contents" , (char*)fname , 0 );
! 867: goto err_exit;
! 868: } /* endif */
! 869:
! 870: /* Read the dictionary parameters */
! 871: dict->parm = (DICT_PARM_ENTRY *)
! 872: dict_load_block( dict , "PARM" , fi , NULL );
! 873: if ( dict->parm == NULL ) {
! 874: signal_error( "dict_load: could not load parameter table" , "" , 0 );
! 875: goto err_exit;
! 876: } /* endif */
! 877: index = dict_toc_index( dict , "PARM" );
! 878: dict->sig->nparms = dict->toc[index].size / sizeof(DICT_PARM_ENTRY);
! 879:
! 880: /* Set the parameter values in the dictionary structure */
! 881: if ( dict_set_parm_variables(dict) == FALSE )
! 882: goto err_exit;
! 883:
! 884: /* Load the string array */
! 885: dict->string_array = (char *)
! 886: dict_load_block( dict , "STAR" , fi , NULL );
! 887: if ( dict->string_array == NULL ) {
! 888: signal_error( "dict_load: could not load string array" , (char*)fname , 0 );
! 889: goto err_exit;
! 890: } /* endif */
! 891:
! 892: /* Load the string table */
! 893: dict->string_table = (STRING_ENTRY *)
! 894: dict_load_block( dict , "STTB" , fi , NULL );
! 895: if ( dict->string_table == NULL ) {
! 896: signal_error( "dict_load: could not load string table" , (char*)fname , 0 );
! 897: goto err_exit;
! 898: } /* endif */
! 899:
! 900: /* Load the hash table */
! 901: dict->chains = (long *)
! 902: dict_load_block( dict , "HASH" , fi , NULL );
! 903: if ( dict->chains == NULL ) {
! 904: signal_error( "dict_load: could not load hash table" , (char*)fname , 0 );
! 905: goto err_exit;
! 906: } /* endif */
! 907:
! 908: /* Initialize the hook for dictionary extensions */
! 909: dict->ext = NULL;
! 910:
! 911: /* Success */
! 912: fclose( fi );
! 913: return( dict );
! 914:
! 915: /* Failure */
! 916: err_exit:
! 917: if ( fi != NULL )
! 918: fclose( fi );
! 919: dict_destroy( dict );
! 920: return NULL;
! 921: }
! 922:
! 923:
! 924: /*************************************************************************
! 925: * dict_save - save a dictionary from memory into a file
! 926: *
! 927: * dict - pointer to dictionary to save
! 928: * fname - full qualified file name prefix of dictionary
! 929: *
! 930: * Returns: status code
! 931: * TRUE - dictionary was saved sucessfully
! 932: * FALSE - error during save
! 933: *************************************************************************/
! 934: BOOLEANC dict_save( DICTIONARY *dict, const char *fname )
! 935: {
! 936: int index, ret_code;
! 937: FILE *fo = NULL;
! 938:
! 939: /* Have to be pointing at a valid dictionary */
! 940: if ( dict == NULL || dict->sig->check_value != DICT_VALIDATE )
! 941: goto err_exit;
! 942:
! 943: /* Open the file for output */
! 944: if ( (fo=fopen((char*)fname,"wb")) == NULL )
! 945: goto err_exit;
! 946:
! 947: /* Make the table of contents entries current */
! 948: /* Note: This will not be necessary once the data is stored in EVECTORs */
! 949:
! 950: if ( (index=dict_toc_index(dict,"PARM")) == -1 )
! 951: goto err_exit;
! 952: dict->toc[index].size = dict->sig->nparms * sizeof(DICT_PARM_ENTRY);
! 953: dict->toc[index].ptr = dict->parm;
! 954:
! 955: if ( (index=dict_toc_index(dict,"STAR")) == -1 )
! 956: goto err_exit;
! 957: dict->toc[index].size = dict->array_size * sizeof(char);
! 958: dict->toc[index].ptr = dict->string_array;
! 959:
! 960: if ( (index=dict_toc_index(dict,"STTB")) == -1 )
! 961: goto err_exit;
! 962: dict->toc[index].size = dict->string_max * sizeof(STRING_ENTRY);
! 963: dict->toc[index].ptr = dict->string_table;
! 964:
! 965: if ( (index=dict_toc_index(dict,"HASH")) == -1 )
! 966: goto err_exit;
! 967: dict->toc[index].size = dict->table_size * sizeof(long);
! 968: dict->toc[index].ptr = dict->chains;
! 969:
! 970: /* Reset the TOC offsets and checksums for ALL tables */
! 971: /* (not just type=0 tables) */
! 972: dict_reset_toc_offsets( dict );
! 973:
! 974: /* Set the dictionary parm structure from the parameter values */
! 975: if ( dict_set_parm_values(dict) == FALSE )
! 976: goto err_exit;
! 977:
! 978: /* Save the signature */
! 979: dict->sig->checksum = compute_checksum( sizeof(DICT_SIG) , (char*)(dict->sig) );
! 980: ret_code = block_write( fo ,
! 981: (char*)dict->sig ,
! 982: sizeof(DICT_SIG) );
! 983: if ( ret_code == -1 )
! 984: goto err_exit;
! 985:
! 986: /* Save the table of contents */
! 987: ret_code = block_write( fo,
! 988: (char*)dict->toc,
! 989: dict->sig->toc_size * sizeof(DICT_TOC_ENTRY) );
! 990: if ( ret_code == -1 )
! 991: goto err_exit;
! 992:
! 993: /* Save the tables */
! 994: /* For now, only save type=0 tables */
! 995: for ( index = 0 ; index < dict->sig->toc_size ; index++ ) {
! 996: if ( dict->toc[index].type == 0 ) { /* Ordinary table */
! 997: ret_code = dict_save_block( dict , dict->toc[index].id , fo );
! 998: if ( ret_code == FALSE )
! 999: goto err_exit;
! 1000: } /* endif */
! 1001: } /* endfor */
! 1002:
! 1003: /* Success */
! 1004: fclose( fo );
! 1005: return TRUE;
! 1006:
! 1007: /* Failure */
! 1008: err_exit:
! 1009: if ( fo != NULL )
! 1010: fclose( fo );
! 1011: return FALSE;
! 1012: }
! 1013:
! 1014:
! 1015: /*************************************************************************
! 1016: * dict_import: read in an ASCII dictionary.
! 1017: *
! 1018: * dict_fname - name of dictionary file
! 1019: * parameters to create a DICTIONARY structure (see dict_create)
! 1020: *
! 1021: * Returns: pointer to created DICTIONARY structure
! 1022: * (NULL on failure)
! 1023: *
! 1024: *************************************************************************/
! 1025: DICTIONARY *dict_import( const char *dict_fname ,
! 1026: const long initial_string_count ,
! 1027: const long initial_hash_entries ,
! 1028: const long max_chain_length )
! 1029: {
! 1030: DICTIONARY *dict;
! 1031: char buffer[BUFLEN], ch;
! 1032: int index, c, c0;
! 1033: long number;
! 1034: FILE *fi = NULL;
! 1035:
! 1036: /***********
! 1037: ** Dictionary setup.
! 1038: ***********/
! 1039:
! 1040: dict = dict_create( 4,
! 1041: initial_string_count ,
! 1042: initial_hash_entries ,
! 1043: max_chain_length );
! 1044: if ( dict == NULL )
! 1045: goto err_exit;
! 1046:
! 1047: /***********
! 1048: ** Read the dictionary file
! 1049: ** Each line should have one word or a string delimited by '|'
! 1050: ***********/
! 1051:
! 1052: if ( (fi=fopen(dict_fname,"r")) == NULL )
! 1053: goto err_exit;
! 1054: while( fgets(buffer,BUFLEN,fi) != NULL ) {
! 1055: c0 = 0;
! 1056: /* Skip to non-blank */
! 1057: while ( (c0<BUFLEN-2) && (buffer[c0]==' ') ) ++c0;
! 1058: if ( buffer[c0] == '|' ) {
! 1059: c = ++c0;
! 1060: ch = '|';
! 1061: } else {
! 1062: c = c0;
! 1063: ch = ' ';
! 1064: } /* endif */
! 1065: /* Scan to blank or matching '|' */
! 1066: while ( (c<BUFLEN-1) && (buffer[c]!='\0') &&
! 1067: (buffer[c]!='\n') && (buffer[c]!=ch) )
! 1068: ++c;
! 1069: buffer[c] = '\0';
! 1070: /* Insert the word */
! 1071: if ( dict_insert(dict,buffer+c0,1,0,NULL,&number) == NULL )
! 1072: goto err_exit;
! 1073: } /* endwhile */
! 1074:
! 1075: /***********
! 1076: ** Fill in the dictionary parameter vector.
! 1077: ***********/
! 1078:
! 1079: if ( dict_set_parm_values(dict) == FALSE )
! 1080: goto err_exit;
! 1081:
! 1082: /***********
! 1083: ** Update the table of contents for HASH STTB STAR
! 1084: ***********/
! 1085:
! 1086: if ( (index=dict_toc_index(dict,"HASH")) == -1 )
! 1087: goto err_exit;
! 1088: dict->toc[index].size = dict->table_size * sizeof(long);
! 1089:
! 1090: if ( (index=dict_toc_index(dict,"STTB")) == -1 )
! 1091: goto err_exit;
! 1092: dict->toc[index].size = dict->string_max * sizeof(char);
! 1093:
! 1094: if ( (index=dict_toc_index(dict,"STAR")) == -1 )
! 1095: goto err_exit;
! 1096: dict->toc[index].size = dict->array_size * sizeof(STRING_ENTRY);
! 1097:
! 1098: /* Success. Return a pointer to the new dictionary. */
! 1099: fclose(fi);
! 1100: return( dict );
! 1101:
! 1102: /* Failure. Ignominiously erase our tracks and return NULL. */
! 1103: err_exit:
! 1104: if ( fi != NULL )
! 1105: fclose(fi);
! 1106: dict_destroy( dict );
! 1107: return NULL;
! 1108: }
! 1109:
! 1110: /*************************************************************************
! 1111: * dict_export - save an extended dictionary from memory into
! 1112: * an ASCII file
! 1113: *
! 1114: * dict - pointer to dictionary to save
! 1115: * fname - full qualified file name prefix of dictionary
! 1116: *
! 1117: * Returns: status code
! 1118: * TRUE - dictionary was saved sucessfully
! 1119: * FALSE - error during save
! 1120: *
! 1121: *************************************************************************/
! 1122: BOOLEANC dict_export( DICTIONARY *dict , const char *fname )
! 1123: {
! 1124: FILE *fp = NULL;
! 1125: STRING_ENTRY *se;
! 1126: int i;
! 1127:
! 1128: /* have to point to something */
! 1129: if (dict == NULL)
! 1130: goto err_exit;
! 1131:
! 1132: /* check value has to be OK */
! 1133: if (dict->check_value != DICT_VALIDATE)
! 1134: goto err_exit;
! 1135:
! 1136: /* must have a filename */
! 1137: if (fname == NULL)
! 1138: goto err_exit;
! 1139:
! 1140: fp = fopen( (char*)fname , "w" );
! 1141: if ( fp == NULL )
! 1142: goto err_exit;
! 1143:
! 1144: for ( i = 0 ; i < dict->entry_count ; i++ ) {
! 1145: se = &dict->string_table[i];
! 1146: fprintf( fp , "|%s|\n" , dict->string_array + se->string_offset );
! 1147: } /* endfor */
! 1148: fclose( fp );
! 1149:
! 1150: /* Success. */
! 1151: fclose(fp);
! 1152: return TRUE;
! 1153:
! 1154: /* Failure. */
! 1155: err_exit:
! 1156: if ( fp != NULL )
! 1157: fclose(fp);
! 1158: dict_destroy( dict );
! 1159: return FALSE;
! 1160: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dict.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / urogue