/*
....[@@@..[@@@..............[@.................. MUD++ is a written from
....[@..[@..[@..[@..[@..[@@@@@....[@......[@.... scratch multi-user swords and
....[@..[@..[@..[@..[@..[@..[@..[@@@@@..[@@@@@.. sorcery game written in C++.
....[@......[@..[@..[@..[@..[@....[@......[@.... This server is an ongoing
....[@......[@..[@@@@@..[@@@@@.................. development project.  All 
................................................ contributions are welcome. 
....Copyright(C).1995.Melvin.Smith.............. Enjoy. 
------------------------------------------------------------------------------
Melvin Smith (aka Fusion)         msmith@hom.net
MUD++ development mailing list    mudpp@van.ml.org
------------------------------------------------------------------------------
memoryblock.h
*/


#ifndef _MEMORYBLOCK_H
#define _MEMORYBLOCK_H

typedef union
{
	s32 vmint;
	float vmfloat;
	struct {
		u8 opcode;
		u8 conds;
		union {
			s16 reloc;
			u16 number;
	   	}u;
	}s;
} memorycell;

class MemoryCellBlock
{
	protected:
		memorycell * mem;
		memorycell * pmem;
		int size;

	public:
		MemoryCellBlock() :
			mem(0), pmem(0), size(0)
		{}

		virtual ~MemoryCellBlock()
		{
			if (mem) delete [] mem;
		}

		memorycell * getMem() { return mem; }
		const memorycell * getConstMem() const { return mem; }
		void setMem( memorycell * block , int nsize) 
			{ mem = block; pmem = block; size = nsize; }

		memorycell * getPtr() { return pmem; }
		void setPtr( memorycell * where ) { pmem = where; }
		void movePtr( signed int offs ) { pmem += offs; }
		void setOffset( int where ) { pmem = &mem[where]; }
		int getOffset() {return (int) (pmem-mem);}

		void clrMemBlock() { memset( mem, 0, size * sizeof(memorycell)); }
		void allocMemBlock(int s) 
			{ if (mem) delete [] mem; size = s; mem = new memorycell[size]; pmem = mem;}

		void enlargeMemBlock(int s )
		{
			memorycell * nmem = new memorycell[s+size];
			if ( mem ) memcpy( nmem, mem, size * sizeof(memorycell));
			pmem = (pmem - mem ) + nmem;
			if ( mem ) delete [] mem;
			mem = nmem;
			size += s;
		}

		void canCarryMore( int s )
		{
			if ( ((pmem - mem) + s) < size )
				return;
			enlargeMemBlock(s);
		}

		int getUsedSize() const { return (int) (pmem - mem); }
		int getUsedBytesize() const { return (int) (pmem - mem) * sizeof(memorycell);}
		int getSize() const { return size; }
 		int getFree() const { return size - (pmem - mem); }

		void putCell( memorycell mc ) {*pmem =mc; pmem++;}
		memorycell getCell() { return *pmem++; }
		memorycell getCell(int where) {return mem[where]; }
		void setCell( int where, memorycell mc ) {mem[where] = mc;}
		void relocCell( int where, int offset ) { mem[where].s.u.number += offset; }
		memorycell & operator[] ( int offset ) { return mem[offset]; }

		void putInt( int val ) { pmem->vmint = val; pmem++;}
		void putFloat( float val ) { pmem->vmfloat = val; pmem++;}
};

#define ALIGNSIZE	sizeof( void *)
#define ALIGNMASK	ALIGNSIZE - 1

class ConstantsBlock
{
	protected:
		char * mem;
		char * pmem;
		int size;

	public:
		ConstantsBlock() :
			mem(0), pmem(0), size(0)
		{}

		~ConstantsBlock()
		{
			if (mem) delete [] mem;
		}

		char * getMem() { return mem; }
		const char * getConstMem() const { return mem; }
		void setMem( char * block , int nsize) 
			{ mem = block; pmem = block; size = nsize; }

		char * getPtr() { return pmem; }
		void setPtr( char * where ) { pmem = where; }
		void movePtr( signed int offs ) { pmem += offs; }
		void setOffset( int where ) { pmem = &mem[where]; }
		int getOffset() { return (int) (pmem - mem);}

		void clrMemBlock() { memset( mem, 0, size * sizeof(char)); }
		void allocMemBlock(int s) 
			{ if (mem) delete [] mem; size = s; mem = new char[size]; pmem = mem;}
		void enlargeMemBlock(int s )
		{
			char * nmem = new char[s+size];
			if ( mem ) memcpy( nmem, mem, size * sizeof(char));
			pmem = (pmem - mem ) + nmem;
			if ( mem ) delete [] mem;
			mem = nmem;
			size += s;
		}

		int getUsedSize() const { return (int) (pmem - mem); }
		int getUsedBytesize() const { return (int) (pmem - mem) * sizeof(char);}
		int getSize() const { return size; }
 		int getFree() const { return size - (pmem - mem); }

		char & operator[] ( int offset ) { return mem[offset]; }

		void assureFit( int len )
		{
			if ( getFree() < len )
				enlargeMemBlock(1000);
		}

		void align()
		{
			int align;
			if ( (align = ((int)(pmem-mem)) & ALIGNMASK) )
				pmem += (ALIGNSIZE-align);
		}

		void putString( const char * txt ) 
		{ 
			int len = strlen(txt) +1;
			assureFit(len);
			memcpy( pmem, txt, len);
			pmem += len;
			align();
		}
		
		void putString( const char * txt, int len )
		{
			len++;
			assureFit(len);
			memcpy( pmem, txt, len);
			pmem += len;
			align();
		}

		const void * getStruct( int where ) {return &mem[where]; }
		void setStruct( int where, const void * str, int len )
		{
			memcpy( &mem[where], str, len );
		}
		
		void putStruct( const void * str, int len )
		{
			assureFit(len);
			memcpy( pmem, str, len );
			pmem += len;
			align();
		}
};

#endif