Annotation of early-roguelike/urogue/dictutil.c, Revision 1.1.1.1
1.1 rubenllo 1: /*
2: dictutil.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: ** Utilities for Dictionary Maintenence Functions
13: *************************************************************************/
14:
15: static char sccsid[] = "%W% %G%";
16:
17: #include <stdio.h>
18: #include <string.h>
19: #include <stdlib.h>
20: #if !defined(OS2) && !defined(_WIN32)
21: #include <unistd.h>
22: #else
23: #include <io.h>
24: #include <fcntl.h>
25: #endif
26:
27: #include "dict.h"
28: #include "dictutil.h"
29: #include "rogue.h"
30:
31: int dict_trace;
32: FILE *ft;
33:
34:
35: /***********
36: ** Read 'count' characters into 'buffer' at 'offset' in a binary file
37: ** Return 0 on success; -1 on failure;
38: ***********/
39:
40: int block_read( FILE *fi , char *buffer , size_t count , long offset )
41: {
42: if ( fseek(fi,offset,SEEK_SET) == -1 )
43: return( -1 );
44:
45: if ( fread(buffer,1,count,fi) != count )
46: return( -1 );
47: return( 0 );
48: }
49:
50: /***********
51: ** Write 'count' characters from 'buffer' to a binary file.
52: ** Return -1 on failure; 0 on success.
53: ***********/
54:
55: int block_write( FILE *fo , char *buffer , size_t count )
56: {
57: if ( fwrite(buffer,1,count,fo) != count )
58: return( -1 );
59: return( 0 );
60: }
61:
62: /***********
63: ** Load a dictionary table entry with id TOC_id into memory pointed to by block.
64: ** Update the dictionary TOC.
65: ** If *block=NULL, allocate the block of memory.
66: ** Return 0 on success; -1 on failure.
67: ** Set dt_entry->ptr to where the block is stored.
68: ***********/
69:
70: void *dict_load_block( DICTIONARY *dict , char *toc_id ,
71: FILE *fi , void *block )
72: { DICT_TOC_ENTRY *dt_entry;
73: static void *ptr;
74: int index, ret_code;
75:
76: index = dict_toc_index( dict , toc_id );
77: if ( index != -1 ) { /* Found the id */
78: dt_entry = &(dict->toc[index]);
79: } else {
80: signal_error( "dict_load_block: could not find TOC_id" , toc_id , 1 );
81: return( NULL );
82: } /* endif */
83:
84: if ( block == NULL ) {
85: ptr = malloc( dt_entry->size );
86: if ( dict_trace > 3 ) {
87: fprintf( ft , "\ndict_load_block allocates %lx bytes at location %p\n" ,
88: dt_entry->size , ptr );
89: } /* endif */
90: } else {
91: ptr = block;
92: if ( dict_trace > 3 ) {
93: fprintf( ft , "\ndict_load_block uses memory at location %p\n" , ptr );
94: } /* endif */
95: } /* endif */
96: if ( ptr == NULL ) {
97: signal_error( "dict_load_block: alloc failed " , toc_id , 1 );
98: return( NULL );
99: } /* endif */
100:
101: ret_code = block_read( fi ,
102: (char*)ptr ,
103: dt_entry->size ,
104: dt_entry->offset );
105: if ( ret_code == -1 )
106: return( NULL );
107:
108: if ( dt_entry->checksum !=
109: compute_checksum( dt_entry->size , (char*)ptr ) ) {
110: signal_error( "dict_load_block: invalid checksum ", toc_id, 1);
111: return( NULL );
112: } /* endif */
113:
114: dt_entry->ptr = ptr;
115:
116: if ( dict_trace > 3 ) {
117: fprintf( ft , "\nLoaded block\nTOC entry: id:%s offset:%lx size:%lx ptr:%p checksum:%lx type:%d\n" ,
118: dict->toc[index].id , dict->toc[index].offset ,
119: dict->toc[index].size , dict->toc[index].ptr ,
120: dict->toc[index].checksum , dict->toc[index].type );
121: } /* endif */
122:
123: return( ptr );
124: }
125:
126: /***********
127: ** Save a dictionary table entry.
128: ** Update the dictionary TOC entry offset and checksum fields.
129: ** Return 0 on success, -1 on failure.
130: ** Note: It is assumed that the size and pointer fields in TOC entry are
131: ** already up to date; i.e., that they are consistent with the current
132: ** location and size of the block being written. This is essential
133: ** because the table of contents must have already been written
134: ** into the file.
135: ***********/
136:
137: BOOLEANC dict_save_block( DICTIONARY *dict , char *toc_id , FILE *fo )
138: { DICT_TOC_ENTRY *dt_entry;
139: int index, ret_code;
140: char *block;
141:
142: index = dict_toc_index( dict , toc_id );
143: if ( index == -1 ) {
144: signal_error( "dict_save_block: id not found " , toc_id , 1 );
145: return( FALSE );
146: } /* endif */
147: dt_entry = &(dict->toc[index]);
148: block = (char*)(dt_entry->ptr);
149:
150: if ( block == NULL ) {
151: signal_error( "dict_save_block: NULL block " , toc_id , 1 );
152: return( FALSE );
153: } /* endif */
154:
155: /* dt_entry->offset = fseek( fo , 0 , SEEK_END ); */
156: dt_entry->checksum = compute_checksum( dt_entry->size , block );
157: ret_code = block_write( fo , dt_entry->ptr , dt_entry->size );
158: if ( ret_code == -1 ) {
159: signal_error( "dict_save_block: block_write failed " , toc_id , 1 );
160: return( FALSE );
161: } /* endif */
162:
163: if ( dict_trace > 3 ) {
164: fprintf( ft , "\nStored block\nTOC entry: id:%s offset:%lx size:%lx ptr:%p checksum:%lx type:%d\n" ,
165: dict->toc[index].id , dict->toc[index].offset ,
166: dict->toc[index].size , dict->toc[index].ptr ,
167: dict->toc[index].checksum , dict->toc[index].type );
168: } /* endif */
169:
170: return( TRUE );
171: }
172:
173: /***********
174: ** Look up and id in the table of contents.
175: ** Return its index (-1 on failure).
176: ***********/
177:
178: int dict_toc_index( DICTIONARY *dict , char *toc_id )
179: { int index;
180:
181: for ( index = 0 ; index < dict->sig->toc_size ; index++ ) {
182: if ( strcmp(dict->toc[index].id,toc_id) == 0 )
183: return( index );
184: } /* endfor */
185:
186: return( -1 );
187: }
188:
189: /***********
190: ** Compute a block checksum.
191: ** (Currently just returns 0.)
192: ***********/
193:
194: unsigned long compute_checksum( size_t size , char *block )
195: {
196: NOOP(size);
197: NOOP(block);
198: return( 0 );
199: }
200:
201: /***********
202: ** Create a dictionary paramter entry.
203: ***********/
204:
205: DICT_PARM_ENTRY *dict_make_parm_entry( char *id , unsigned long value )
206: { static DICT_PARM_ENTRY *entry;
207:
208: entry = (DICT_PARM_ENTRY *) malloc( sizeof(DICT_PARM_ENTRY) );
209: if ( entry == NULL )
210: return(NULL);
211:
212: strncpy( entry->id , id , 13 );
213: entry->value = value;
214:
215: return( entry );
216: }
217:
218: /***********
219: ** Look up and id in the parameter array.
220: ** Return its index (-1 on failure).
221: ***********/
222:
223: int dict_parm_index( DICTIONARY *dict , char *parm_id )
224: { long index;
225:
226: for ( index = 0 ; index < dict->sig->nparms ; index++ ) {
227: if ( strcmp( dict->parm[index].id , parm_id ) == 0 )
228: return( (int) index );
229: } /* endfor */
230:
231: return( -1 );
232: }
233:
234: /***********
235: ** Reset table of contents offsets and checksums
236: ** in preparation for dict_save().
237: ***********/
238:
239: BOOLEANC dict_reset_toc_offsets( DICTIONARY *dict )
240: { int i;
241: long offset;
242:
243: offset = sizeof(DICT_SIG)
244: + dict->sig->toc_size * sizeof(DICT_TOC_ENTRY);
245: for ( i = 0 ; i < dict->sig->toc_size ; i++ ) {
246: dict->toc[i].offset = offset;
247: offset += dict->toc[i].size;
248: dict->toc[i].checksum =
249: compute_checksum( dict->toc[i].size , dict->toc[i].ptr );
250: } /* endfor */
251:
252: return( TRUE );
253: }
254:
255: /***********
256: ** Load the names of the dictionary parameters.
257: ** 14 parms
258: ***********/
259:
260: BOOLEANC dict_set_parm_ids( DICTIONARY *dict )
261: {
262: if ( dict==NULL || dict->sig == NULL ) {
263: signal_error( "dict_set_parm_ids: Allocate dict and signature first." , "" , 0 );
264: return( FALSE );
265: }
266: dict->sig->nparms = 14;
267: strcpy( dict->parm[0].id , "FLAGS_______" );
268: strcpy( dict->parm[1].id , "ENTRY_COUNT_" );
269: strcpy( dict->parm[2].id , "ARRAY_SIZE__" );
270: strcpy( dict->parm[3].id , "ARRAY_USED__" );
271: strcpy( dict->parm[4].id , "ARR_GROW_CT_" );
272: strcpy( dict->parm[5].id , "STRING_MAX__" );
273: strcpy( dict->parm[6].id , "STR_GROW_CT_" );
274: strcpy( dict->parm[7].id , "LONG_CHAIN__" );
275: strcpy( dict->parm[8].id , "ALLOW_CHAIN_" );
276: strcpy( dict->parm[9].id , "HASH_TAB_SIZ" );
277: strcpy( dict->parm[10].id , "HASH_MASK___" );
278: strcpy( dict->parm[11].id , "HASH_GROW_CT" );
279: strcpy( dict->parm[12].id , "CHECK_VALUE_" );
280: strcpy( dict->parm[13].id , "SCAN_STR_IX_" );
281:
282: return( TRUE );
283: }
284:
285: /***********
286: ** Set the dictionary parm structure from the values in the dict structure.
287: ** 14 parms
288: ***********/
289:
290: BOOLEANC dict_set_parm_values( DICTIONARY *dict )
291: { int index;
292:
293: if ( (index=dict_parm_index(dict,"FLAGS_______")) == -1 )
294: return( FALSE );
295: dict->parm[index].value = (unsigned long)dict->flags;
296:
297: if ( (index=dict_parm_index(dict,"ENTRY_COUNT_")) == -1 )
298: return( FALSE );
299: dict->parm[index].value = (unsigned long)dict->entry_count;
300:
301: if ( (index=dict_parm_index(dict,"ARRAY_SIZE__")) == -1 )
302: return( FALSE );
303: dict->parm[index].value = (unsigned long)dict->array_size;
304:
305: if ( (index=dict_parm_index(dict,"ARRAY_USED__")) == -1 )
306: return( FALSE );
307: dict->parm[index].value = (unsigned long)dict->array_used;
308:
309: if ( (index=dict_parm_index(dict,"ARR_GROW_CT_")) == -1 )
310: return( FALSE );
311: dict->parm[index].value = (unsigned long)dict->array_growth_count;
312:
313: if ( (index=dict_parm_index(dict,"STRING_MAX__")) == -1 )
314: return( FALSE );
315: dict->parm[index].value = (unsigned long)dict->string_max;
316:
317: if ( (index=dict_parm_index(dict,"STR_GROW_CT_")) == -1 )
318: return( FALSE );
319: dict->parm[index].value = (unsigned long)dict->string_growth_count;
320:
321: if ( (index=dict_parm_index(dict,"LONG_CHAIN__")) == -1 )
322: return( FALSE );
323: dict->parm[index].value = (unsigned long)dict->longest_chain_length;
324:
325: if ( (index=dict_parm_index(dict,"ALLOW_CHAIN_")) == -1 )
326: return( FALSE );
327: dict->parm[index].value = (unsigned long)dict->allowable_chain_length;
328:
329: if ( (index=dict_parm_index(dict,"HASH_TAB_SIZ")) == -1 )
330: return( FALSE );
331: dict->parm[index].value = (unsigned long)dict->table_size;
332:
333: if ( (index=dict_parm_index(dict,"HASH_MASK___")) == -1 )
334: return( FALSE );
335: dict->parm[index].value = (unsigned long)dict->hash_mask;
336:
337: if ( (index=dict_parm_index(dict,"HASH_GROW_CT")) == -1 )
338: return( FALSE );
339: dict->parm[index].value = (unsigned long)dict->hash_growth_count;
340:
341: if ( (index=dict_parm_index(dict,"CHECK_VALUE_")) == -1 )
342: return( FALSE );
343: dict->parm[index].value = (unsigned long)dict->check_value;
344:
345: if ( (index=dict_parm_index(dict,"SCAN_STR_IX_")) == -1 )
346: return( FALSE );
347: dict->parm[index].value = (unsigned long)dict->scan_string_index;
348:
349: return( TRUE );
350: }
351:
352:
353: /***********
354: ** Set the values in the dict structure from the dictionary parm structure.
355: ** 14 parms
356: ***********/
357:
358: BOOLEANC dict_set_parm_variables( DICTIONARY *dict )
359: { int index;
360:
361: if ( (index=dict_parm_index(dict,"FLAGS_______")) == -1 )
362: return( FALSE );
363: dict->flags = (unsigned long)dict->parm[index].value;
364:
365: if ( (index=dict_parm_index(dict,"ENTRY_COUNT_")) == -1 )
366: return( FALSE );
367: dict->entry_count = (long)dict->parm[index].value;
368:
369: if ( (index=dict_parm_index(dict,"ARRAY_SIZE__")) == -1 )
370: return( FALSE );
371: dict->array_size = (long)dict->parm[index].value;
372:
373: if ( (index=dict_parm_index(dict,"ARRAY_USED__")) == -1 )
374: return( FALSE );
375: dict->array_used = (long)dict->parm[index].value;
376:
377: if ( (index=dict_parm_index(dict,"ARR_GROW_CT_")) == -1 )
378: return( FALSE );
379: dict->array_growth_count = (int)dict->parm[index].value;
380:
381: if ( (index=dict_parm_index(dict,"STRING_MAX__")) == -1 )
382: return( FALSE );
383: dict->string_max = (long)dict->parm[index].value ;
384:
385: if ( (index=dict_parm_index(dict,"STR_GROW_CT_")) == -1 )
386: return( FALSE );
387: dict->string_growth_count = (int)dict->parm[index].value;
388:
389: if ( (index=dict_parm_index(dict,"LONG_CHAIN__")) == -1 )
390: return( FALSE );
391: dict->longest_chain_length = (int)dict->parm[index].value;
392:
393: if ( (index=dict_parm_index(dict,"ALLOW_CHAIN_")) == -1 )
394: return( FALSE );
395: dict->allowable_chain_length = (int)dict->parm[index].value;
396:
397: if ( (index=dict_parm_index(dict,"HASH_TAB_SIZ")) == -1 )
398: return( FALSE );
399: dict->table_size = (long)dict->parm[index].value;
400:
401: if ( (index=dict_parm_index(dict,"HASH_MASK___")) == -1 )
402: return( FALSE );
403: dict->hash_mask = (unsigned long)dict->parm[index].value;
404:
405: if ( (index=dict_parm_index(dict,"HASH_GROW_CT")) == -1 )
406: return( FALSE );
407: dict->hash_growth_count = (int)dict->parm[index].value;
408:
409: if ( (index=dict_parm_index(dict,"CHECK_VALUE_")) == -1 )
410: return( FALSE );
411: dict->check_value = (unsigned long)dict->parm[index].value;
412:
413: if ( (index=dict_parm_index(dict,"SCAN_STR_IX_")) == -1 )
414: return( FALSE );
415: dict->scan_string_index = (long)dict->parm[index].value;
416:
417: return( TRUE );
418: }
419:
420: /***********
421: ** If dict_trace (global) > 0 , signal an error
422: ** If severity > 0 , abort
423: ***********/
424:
425: void signal_error( char *header , char *message , int severity )
426: {
427: FILE *fpe;
428:
429: if ( dict_trace > 0 ) {
430: printf( "%s: %s\n" , header , message );
431: fpe = fopen( "ERROR.FIL" , "a" );
432: fprintf( fpe , "\n%s: %s\n" , header , message );
433: fclose( fpe );
434: } /* endif */
435:
436: if ( severity > 0 )
437: abort();
438: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dictutil.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / early-roguelike / urogue