/***************************************************************************
* 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. *
***************************************************************************/
/***************************************************************************
* *
* MOBprograms for ROM 2.4 v0.98g (C) M.Nylander 1996 *
* Based on MERC 2.2 MOBprograms concept by N'Atas-ha. *
* Written and adapted to ROM 2.4 by *
* Markku Nylander (markku.nylander@uta.fi) *
* This code may be copied and distributed as per the ROM license. *
* *
***************************************************************************/
/***************************************************************************
* _/ _/ *
* _/_/_/ _/_/ _/_/_/ _/ _/_/ _/ _/ _/_/_/ *
* _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ *
* _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ _/ *
* _/ _/ _/ _/_/_/ _/ _/_/ _/_/_/ _/_/_/ *
***************************************************************************
* Mindcloud Copyright 2001-2003 by Jeff Boschee (Zarius), *
* Additional credits are in the help file CODECREDITS *
* All Rights Reserved. *
***************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/types.h>
#include <ctype.h>
#include "merc.h"
#include "recycle.h"
//BUFFER STUFF
BUFFER *buf_free;
BUFFER * new_buf()
{
BUFFER *buffer;
if (buf_free == NULL)
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 = 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 = 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)
{
bug("new_buf: buffer size %d too large.",size);
exit(1);
}
buffer->string = alloc_mem(buffer->size);
buffer->string[0] = '\0';
VALIDATE(buffer);
return buffer;
}
/* stuff for recycling wizlist structures */
WIZ_DATA *wiz_free;
WIZ_DATA *new_wiz(void)
{
static WIZ_DATA wiz_zero;
WIZ_DATA *wiz;
if (wiz_free == NULL)
wiz = alloc_perm(sizeof(*wiz));
else
{
wiz = wiz_free;
wiz_free = wiz_free->next;
}
*wiz = wiz_zero;
VALIDATE(wiz);
wiz->name = &str_empty[0];
return wiz;
}
void free_wiz(WIZ_DATA *wiz)
{
if (!IS_VALID(wiz))
return;
free_string(wiz->name);
INVALIDATE(wiz);
wiz->next = wiz_free;
wiz_free = wiz;
}
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;
}
/* buffer sizes */
const int buf_size[MAX_BUF_LIST] =
{
16,32,64,128,256,1024,2048,4096,8192,16384
};
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;
}
char * buf_string(BUFFER *buffer)
{
return buffer->string;
}
void clear_buf(BUFFER *buffer)
{
buffer->string[0] = '\0';
buffer->state = BUFFER_SAFE;
}
bool add_buf(BUFFER *buffer, 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 = alloc_mem(buffer->size);
strcpy(buffer->string,oldstr);
free_mem(oldstr,oldsize);
}
strcat(buffer->string,string);
return TRUE;
}
/* stuff for recycling mobprograms */
PROG_LIST *mprog_free;
PROG_LIST *oprog_free;
PROG_LIST *rprog_free;
PROG_LIST *new_mprog(void)
{
static PROG_LIST mp_zero;
PROG_LIST *mp;
if (mprog_free == NULL)
mp = alloc_perm(sizeof(*mp));
else
{
mp = mprog_free;
mprog_free=mprog_free->next;
}
*mp = mp_zero;
mp->vnum = 0;
mp->trig_type = 0;
mp->code = str_dup("");
VALIDATE(mp);
return mp;
}
void free_mprog(PROG_LIST *mp)
{
if (!IS_VALID(mp))
return;
INVALIDATE(mp);
mp->next = mprog_free;
mprog_free = mp;
}
PROG_LIST *new_oprog(void)
{
static PROG_LIST op_zero;
PROG_LIST *op;
if (oprog_free == NULL)
op = alloc_perm(sizeof(*op));
else
{
op = oprog_free;
oprog_free=oprog_free->next;
}
*op = op_zero;
op->vnum = 0;
op->trig_type = 0;
op->code = str_dup("");
VALIDATE(op);
return op;
}
void free_oprog(PROG_LIST *op)
{
if (!IS_VALID(op))
return;
INVALIDATE(op);
op->next = oprog_free;
oprog_free = op;
}
PROG_LIST *new_rprog(void)
{
static PROG_LIST rp_zero;
PROG_LIST *rp;
if (rprog_free == NULL)
rp = alloc_perm(sizeof(*rp));
else
{
rp = rprog_free;
rprog_free=rprog_free->next;
}
*rp = rp_zero;
rp->vnum = 0;
rp->trig_type = 0;
rp->code = str_dup("");
VALIDATE(rp);
return rp;
}
void free_rprog(PROG_LIST *rp)
{
if (!IS_VALID(rp))
return;
INVALIDATE(rp);
rp->next = rprog_free;
rprog_free = rp;
}
SLEEP_DATA *sd_free;
SLEEP_DATA *new_sleep_data(void)
{
SLEEP_DATA *sd;
if (sd_free == NULL)
sd = alloc_perm(sizeof(*sd));
else
{
sd = sd_free;
sd_free=sd_free->next;
}
sd->vnum = 0;
sd->timer = 0;
sd->line = 0;
sd->prog = NULL;
sd->mob = NULL;
sd->ch = NULL;
sd->next = NULL;
sd->prev = NULL;
VALIDATE(sd);
return sd;
}
void free_sleep_data(SLEEP_DATA *sd)
{
if (!IS_VALID(sd))
return;
INVALIDATE(sd);
sd->next = sd_free;
sd_free = sd;
}