/* * RAM $Id: recycle.c 16 2008-10-22 04:42:21Z ram $ */ /*************************************************************************** * Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer, * * Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe. * * * * Merc Diku Mud improvments copyright (C) 1992, 1993 by Michael * * Chastain, Michael Quan, and Mitchell Tse. * * * * In order to use any part of this Merc Diku Mud, you must comply with * * both the original Diku license in 'license.doc' as well the Merc * * license in 'license.txt'. In particular, you may not remove either of * * these copyright notices. * * * * Much time and thought has gone into this software and you are * * benefitting. We hope that you share your changes too. What goes * * around, comes around. * ***************************************************************************/ /*************************************************************************** * ROM 2.4 is copyright 1993-1998 Russ Taylor * * ROM has been brought to you by the ROM consortium * * Russ Taylor (rtaylor@hypercube.org) * * Gabrielle Taylor (gtaylor@hypercube.org) * * Brian Moore (zump@rom.org) * * By using this code, you have agreed to follow the terms of the * * ROM license, in the file Rom24/doc/rom.license * ***************************************************************************/ #include <sys/types.h> #include <sys/time.h> #include <stdio.h> #include <string.h> #include <stdlib.h> #include "merc.h" #include "db.h" #include "recycle.h" /* stuff for recyling notes */ NOTE_DATA *note_free; NOTE_DATA *new_note( void ) { NOTE_DATA *note; if ( note_free == NULL ) note = ( NOTE_DATA * ) alloc_perm( sizeof( *note ) ); else { note = note_free; note_free = note_free->next; } VALIDATE( note ); return note; } void free_note( NOTE_DATA *note ) { if ( !IS_VALID( note ) ) return; free_string( note->text ); free_string( note->subject ); free_string( note->to_list ); free_string( note->date ); free_string( note->sender ); INVALIDATE( note ); note->next = note_free; note_free = note; } /* stuff for recycling ban structures */ BAN_DATA *ban_free; BAN_DATA *new_ban( void ) { static BAN_DATA ban_zero; BAN_DATA *ban; if ( ban_free == NULL ) ban = ( BAN_DATA * ) alloc_perm( sizeof( *ban ) ); else { ban = ban_free; ban_free = ban_free->next; } *ban = ban_zero; VALIDATE( ban ); ban->name = &str_empty[0]; return ban; } void free_ban( BAN_DATA *ban ) { if ( !IS_VALID( ban ) ) return; free_string( ban->name ); INVALIDATE( ban ); ban->next = ban_free; ban_free = ban; } /* stuff for recycling descriptors */ DESCRIPTOR_DATA *descriptor_free; DESCRIPTOR_DATA *new_descriptor( void ) { static DESCRIPTOR_DATA d_zero; DESCRIPTOR_DATA *d; if ( descriptor_free == NULL ) d = ( DESCRIPTOR_DATA * ) alloc_perm( sizeof( *d ) ); else { d = descriptor_free; descriptor_free = descriptor_free->next; } *d = d_zero; VALIDATE( d ); return d; } void free_descriptor( DESCRIPTOR_DATA *d ) { if ( !IS_VALID( d ) ) return; free_string( d->host ); free_mem( d->outbuf, d->outsize ); INVALIDATE( d ); d->next = descriptor_free; descriptor_free = d; } /* stuff for recycling gen_data */ GEN_DATA *gen_data_free; GEN_DATA *new_gen_data( void ) { static GEN_DATA gen_zero; GEN_DATA *gen; if ( gen_data_free == NULL ) gen = ( GEN_DATA * ) alloc_perm( sizeof( *gen ) ); else { gen = gen_data_free; gen_data_free = gen_data_free->next; } *gen = gen_zero; VALIDATE( gen ); return gen; } void free_gen_data( GEN_DATA *gen ) { if ( !IS_VALID( gen ) ) return; INVALIDATE( gen ); gen->next = gen_data_free; gen_data_free = gen; } /* stuff for recycling extended descs */ EXTRA_DESCR_DATA *extra_descr_free; EXTRA_DESCR_DATA *new_extra_descr( void ) { EXTRA_DESCR_DATA *ed; if ( extra_descr_free == NULL ) ed = ( EXTRA_DESCR_DATA * ) alloc_perm( sizeof( *ed ) ); else { ed = extra_descr_free; extra_descr_free = extra_descr_free->next; } ed->keyword = &str_empty[0]; ed->description = &str_empty[0]; VALIDATE( ed ); return ed; } void free_extra_descr( EXTRA_DESCR_DATA *ed ) { if ( !IS_VALID( ed ) ) return; free_string( ed->keyword ); free_string( ed->description ); INVALIDATE( ed ); ed->next = extra_descr_free; extra_descr_free = ed; } /* stuff for recycling affects */ AFFECT_DATA *affect_free; AFFECT_DATA *new_affect( void ) { static AFFECT_DATA af_zero; AFFECT_DATA *af; if ( affect_free == NULL ) af = ( AFFECT_DATA * ) alloc_perm( sizeof( *af ) ); else { af = affect_free; affect_free = affect_free->next; } *af = af_zero; VALIDATE( af ); return af; } void free_affect( AFFECT_DATA *af ) { if ( !IS_VALID( af ) ) return; INVALIDATE( af ); af->next = affect_free; affect_free = af; } /* stuff for recycling objects */ OBJ_DATA *obj_free; OBJ_DATA *new_obj( void ) { static OBJ_DATA obj_zero; OBJ_DATA *obj; if ( obj_free == NULL ) obj = ( OBJ_DATA * ) alloc_perm( sizeof( *obj ) ); else { obj = obj_free; obj_free = obj_free->next; } *obj = obj_zero; VALIDATE( obj ); return obj; } void free_obj( OBJ_DATA *obj ) { AFFECT_DATA *paf, *paf_next; EXTRA_DESCR_DATA *ed, *ed_next; if ( !IS_VALID( obj ) ) return; for ( paf = obj->affected; paf != NULL; paf = paf_next ) { paf_next = paf->next; free_affect( paf ); } obj->affected = NULL; for ( ed = obj->extra_descr; ed != NULL; ed = ed_next ) { ed_next = ed->next; free_extra_descr( ed ); } obj->extra_descr = NULL; free_string( obj->name ); free_string( obj->description ); free_string( obj->short_descr ); free_string( obj->owner ); INVALIDATE( obj ); obj->next = obj_free; obj_free = obj; } /* stuff for recyling characters */ CHAR_DATA *char_free; CHAR_DATA *new_char( void ) { static CHAR_DATA ch_zero; CHAR_DATA *ch; int i; if ( char_free == NULL ) ch = ( CHAR_DATA * ) alloc_perm( sizeof( *ch ) ); else { ch = char_free; char_free = char_free->next; } *ch = ch_zero; VALIDATE( ch ); ch->name = &str_empty[0]; ch->short_descr = &str_empty[0]; ch->long_descr = &str_empty[0]; ch->description = &str_empty[0]; ch->prompt = &str_empty[0]; ch->prefix = &str_empty[0]; ch->logon = current_time; ch->lines = PAGELEN; for ( i = 0; i < 4; i++ ) ch->armor[i] = 100; ch->position = POS_STANDING; ch->hit = 20; ch->max_hit = 20; ch->mana = 100; ch->max_mana = 100; ch->move = 100; ch->max_move = 100; for ( i = 0; i < MAX_STATS; i++ ) { ch->perm_stat[i] = 13; ch->mod_stat[i] = 0; } return ch; } void free_char( CHAR_DATA *ch ) { OBJ_DATA *obj; OBJ_DATA *obj_next; AFFECT_DATA *paf; AFFECT_DATA *paf_next; if ( !IS_VALID( ch ) ) return; if ( IS_NPC( ch ) ) mobile_count--; for ( obj = ch->carrying; obj != NULL; obj = obj_next ) { obj_next = obj->next_content; extract_obj( obj ); } for ( paf = ch->affected; paf != NULL; paf = paf_next ) { paf_next = paf->next; affect_remove( ch, paf ); } free_string( ch->name ); free_string( ch->short_descr ); free_string( ch->long_descr ); free_string( ch->description ); free_string( ch->prompt ); free_string( ch->prefix ); free_note( ch->pnote ); free_pcdata( ch->pcdata ); ch->next = char_free; char_free = ch; INVALIDATE( ch ); return; } PC_DATA *pcdata_free; PC_DATA *new_pcdata( void ) { int alias; static PC_DATA pcdata_zero; PC_DATA *pcdata; if ( pcdata_free == NULL ) pcdata = ( PC_DATA * ) alloc_perm( sizeof( *pcdata ) ); else { pcdata = pcdata_free; pcdata_free = pcdata_free->next; } *pcdata = pcdata_zero; for ( alias = 0; alias < MAX_ALIAS; alias++ ) { pcdata->alias[alias] = NULL; pcdata->alias_sub[alias] = NULL; } pcdata->buffer = new_buf( ); VALIDATE( pcdata ); return pcdata; } void free_pcdata( PC_DATA *pcdata ) { int alias; if ( !IS_VALID( pcdata ) ) return; free_string( pcdata->pwd ); free_string( pcdata->bamfin ); free_string( pcdata->bamfout ); free_string( pcdata->title ); free_buf( pcdata->buffer ); for ( alias = 0; alias < MAX_ALIAS; alias++ ) { free_string( pcdata->alias[alias] ); free_string( pcdata->alias_sub[alias] ); } INVALIDATE( pcdata ); pcdata->next = pcdata_free; pcdata_free = pcdata; return; } /* stuff for setting ids */ int last_pc_id; int last_mob_id; int get_pc_id( void ) { int val; val = ( current_time <= last_pc_id ) ? last_pc_id + 1 : current_time; last_pc_id = val; return val; } int get_mob_id( void ) { last_mob_id++; return last_mob_id; } /* procedures and constants needed for buffering */ MEM_DATA *mem_data_free; BUFFER *buf_free; MEM_DATA *new_mem_data( void ) { MEM_DATA *memory; if ( mem_data_free == NULL ) memory = ( MEM_DATA * ) alloc_mem( sizeof( *memory ) ); else { memory = mem_data_free; mem_data_free = mem_data_free->next; } memory->next = NULL; memory->id = 0; memory->reaction = 0; memory->when = 0; VALIDATE( memory ); return memory; } void free_mem_data( MEM_DATA *memory ) { if ( !IS_VALID( memory ) ) return; memory->next = mem_data_free; mem_data_free = memory; INVALIDATE( memory ); } /* buffer sizes */ const int buf_size[MAX_BUF_LIST] = { 16, 32, 64, 128, 256, 1024, 2048, 4096, 8192, 16384 }; /* local procedure for finding the next acceptable size */ /* -1 indicates out-of-boundary error */ int get_size( int val ) { int i; for ( i = 0; i < MAX_BUF_LIST; i++ ) if ( buf_size[i] >= val ) { return buf_size[i]; } return -1; } BUFFER *new_buf( void ) { BUFFER *buffer; if ( buf_free == NULL ) buffer = ( BUFFER * ) alloc_perm( sizeof( *buffer ) ); else { buffer = buf_free; buf_free = buf_free->next; } buffer->next = NULL; buffer->state = BUFFER_SAFE; buffer->size = get_size( BASE_BUF ); buffer->string = ( char * ) alloc_mem( buffer->size ); buffer->string[0] = '\0'; VALIDATE( buffer ); return buffer; } BUFFER *new_buf_size( int size ) { BUFFER *buffer; if ( buf_free == NULL ) buffer = ( BUFFER * ) alloc_perm( sizeof( *buffer ) ); else { buffer = buf_free; buf_free = buf_free->next; } buffer->next = NULL; buffer->state = BUFFER_SAFE; buffer->size = get_size( size ); if ( buffer->size == -1 ) { proper_exit( 1, "new_buf: buffer size %d too large.", size ); } buffer->string = ( char * ) alloc_mem( buffer->size ); buffer->string[0] = '\0'; VALIDATE( buffer ); return buffer; } void free_buf( BUFFER *buffer ) { if ( !IS_VALID( buffer ) ) return; free_mem( buffer->string, buffer->size ); buffer->string = NULL; buffer->size = 0; buffer->state = BUFFER_FREED; INVALIDATE( buffer ); buffer->next = buf_free; buf_free = buffer; } bool add_buf( BUFFER *buffer, const char *string ) { int len; char *oldstr; int oldsize; oldstr = buffer->string; oldsize = buffer->size; if ( buffer->state == BUFFER_OVERFLOW ) /* don't waste time on bad * strings! */ return FALSE; len = strlen( buffer->string ) + strlen( string ) + 1; while ( len >= buffer->size ) /* increase the buffer size */ { buffer->size = get_size( buffer->size + 1 ); { if ( buffer->size == -1 ) /* overflow */ { buffer->size = oldsize; buffer->state = BUFFER_OVERFLOW; bug( "buffer overflow past size %d", buffer->size ); return FALSE; } } } if ( buffer->size != oldsize ) { buffer->string = ( char * ) alloc_mem( buffer->size ); strcpy( buffer->string, oldstr ); free_mem( oldstr, oldsize ); } strcat( buffer->string, string ); return TRUE; } void clear_buf( BUFFER *buffer ) { buffer->string[0] = '\0'; buffer->state = BUFFER_SAFE; } char *buf_string( BUFFER *buffer ) { return buffer->string; }