#ifndef _INCLUDED_L3_MEM_H
#define _INCLUDED_L3_MEM_H

// *Quick Memory Management and Data Types* Copyright (C) Krzysztof Bosak, 1999-05-27
// All rights reserved.
// kbosak@box43.pl
// http://www.kbosak.prv.pl

#include <malloc.h>
#include <string.h>

typedef unsigned char byte;
typedef short word;
typedef int dword;

#ifndef NDEBUG
	int MEMS=0;
	inline void * qalloc(int dwords)
	{
		MEMS++;
		assert(dwords>0);
		return new dword[dwords];
	}
	inline void qfree(dword * ptr)
	{
		MEMS--;
		delete[] ptr;
	}
#else
	inline void *qalloc(int dwords)
	{
		return new dword[dwords];
	}
	inline void qfree(dword * ptr)
	{
		delete[] ptr;
	}
#endif

class dwordblock
{
	dword * _pointer;
	dword _single;	// Single cell, when we need to allocate single one
	int _capacity;	// Number of dwords allocated
	int _usedsize;	// Number of dwords used
	inline int allocsize(int desiredsize) const
	{
		return desiredsize<<1;
	}
public:
	inline dwordblock()
	{	// Raw build (uninitialized)
		_single=0;// For NuMega DevPartner.
		_usedsize=1;
		_capacity=1;
		_pointer=&_single;
	}
	inline explicit dwordblock(int requested_size)
	{	// Raw build (uninitialized) with desired number of dwords
		assert(requested_size>0);
		_single=0;// For NuMega DevPartner.
		if(requested_size>1)
		{
			_usedsize=requested_size;
			_capacity=allocsize(requested_size);
			_pointer=reinterpret_cast<dword*>(qalloc(_capacity));
			assert(_pointer!=NULL);
		}
		else
		{
			_capacity=1;
			_usedsize=1;
			_pointer=&_single;
		}
	}
	inline explicit dwordblock(const dwordblock& src)
	{
		assert(&src!=this);
		_single=0;// For NuMega DevPartner.
		if(src._usedsize>1)
		{
			_usedsize=src._usedsize;
			_capacity=allocsize(_usedsize);
			_pointer=reinterpret_cast<dword*>(qalloc(_capacity));
			assert(_pointer!=NULL);
			assert(src._pointer!=NULL);
			memcpy(_pointer, src._pointer, _usedsize*sizeof(dword));
		}
		else
		{
			_usedsize=1;
			_capacity=1;
			_pointer=&_single;
			_single=src._pointer[0];
		}
	}
	inline dwordblock& operator=(const dwordblock& w)// EXCEPTION NETURAL
	{
		assert(&w!=this);// assume no self assignment, guarded dynamically by Number class
		if(w._usedsize>1)
		{
			if(w._usedsize>_capacity)
			{
				const int new_capacity=allocsize(w._usedsize);
				dword * const new_pointer=reinterpret_cast<dword*>(qalloc(new_capacity));
				assert(new_pointer!=NULL);
				_capacity=new_capacity;
				if(_pointer!=&_single)
				{
					qfree(_pointer);
				}
				_pointer=new_pointer;
			}
			assert(_pointer!=NULL);
			assert(w._pointer!=NULL);
			memcpy(_pointer, w._pointer, w._usedsize*sizeof(dword));
			_usedsize=w._usedsize;
		}
		else
		{
			if(_pointer!=&_single)
			{
				qfree(_pointer);
			}
			_usedsize=1;
			_capacity=1;
			_pointer=&_single;
			_single=w._pointer[0];
		}
		return *this;
	}
	inline void resize(int requested_size)
	{	// Resize to desired number of dwords
		if(requested_size>_capacity)
		{
			_capacity=allocsize(requested_size);
			if(_pointer!=&_single)
			{
				dword * const newblock=reinterpret_cast<dword*>(qalloc(_capacity));
				assert(newblock!=NULL);
				assert(_pointer!=NULL);
				memcpy(newblock, _pointer, _usedsize*sizeof(dword));
				qfree(_pointer);
				_pointer=newblock;
			}
			else
			{
				_pointer=reinterpret_cast<dword*>(qalloc(_capacity));
				assert(_pointer!=NULL);
				*_pointer=_single;
			}
		}
		_usedsize=requested_size;
	}
	inline dword& operator[](int i)
	{
		assert(i>=0);
		assert(i<_usedsize);
		return _pointer[i];
	}
	inline const dword& operator[](int i) const
	{
		assert(i>=0);
		assert(i<_usedsize);
		return _pointer[i];
	}
	inline int size() const
	{
		return _usedsize;
	}
	#ifndef NDEBUG
	void test() const
	{
		//cout<<"Pointer:"<<_pointer<<;
		cout<<" size:"<<_capacity<<" used:"<<_usedsize;
		cout<<endl;
		cout.flush();
		assert(_pointer!=NULL);
		assert(_usedsize<=_capacity);
		//assert(_msize(_pointer)==_capacity);// Noy portable to gcc compiler / POSIX
	}
	#endif // NDEBUG
	inline ~dwordblock()
	{
		if(_pointer != &_single)
		{
			qfree(_pointer);
		}
	}
};

#endif //_INCLUDED_L3_MEM_H