membuffer.cpp

x-wrt is the GUI config tool for openwrt,which is a open project about wireless Router

#include "XWRT.h"
#include "MemBuffer.h"
#include <stdlib.h> 
#include <memory.h>
#include "Common.h"

unsigned int CMemoryBuffer::memsize=0;

CMemoryBuffer::CMemoryBuffer(std::string mname) 
{ 
	name=mname;
	Clear(); 
	AllocTgtBuf(); 
};

CMemoryBuffer::~CMemoryBuffer() 
{ 
	if (TargetBuf)
		free(TargetBuf-3);
	
	if (SourceBuf)
		free(SourceBuf);
};

inline void CMemoryBuffer::Clear()
{
	TargetBuf=NULL; SourceBuf=NULL; SrcPtr=0; TgtPtr=0; SrcLen=0; TgtLen=0;
}

inline int CMemoryBuffer::Size() 
{
	return TgtPtr;
}

inline int CMemoryBuffer::Allocated() 
{
	return TgtLen;
}

void CMemoryBuffer::OutTgtByte( unsigned char c ) 
{ 
	memsize++;

	*(TargetBuf+(TgtPtr++))=c; 
	if (TgtPtr>TgtLen-1)
	{
		if (TgtLen > (1<<19))  // 512 KB
			ReallocTgtBuf(TgtLen+(1<<19));
		else
			ReallocTgtBuf(TgtLen*2);
	}
}

int CMemoryBuffer::InpSrcByte( void ) 
{
	memsize++;

	if (SrcPtr>=SrcLen)
		return EOF;

	return *(SourceBuf+(SrcPtr++)); 
}

void CMemoryBuffer::UndoSrcByte( void ) 
{
	memsize--;
	SrcPtr--;
}

inline void CMemoryBuffer::SetSrcBuf( unsigned char* SrcBuf, unsigned int len )
{
	SrcLen = len;
	SourceBuf = SrcBuf;
}

inline void CMemoryBuffer::AllocSrcBuf( unsigned int len )
{
	SrcLen = len;
	SourceBuf = (unsigned char*) malloc(SrcLen);
	if (SourceBuf==NULL)
		OUT_OF_MEMORY();
}
	
inline void CMemoryBuffer::AllocTgtBuf( unsigned int len )
{
	TgtLen = len;
	TargetBuf = (unsigned char*) malloc(len+6);
	if (TargetBuf==NULL)
		OUT_OF_MEMORY();
	TargetBuf += 3;
}

inline void CMemoryBuffer::ReallocTgtBuf(unsigned int len)
{
	unsigned char* NewTargetBuf = (unsigned char*) malloc(len+6);

	if (NewTargetBuf==NULL)
		OUT_OF_MEMORY();

	NewTargetBuf += 3;
	memcpy(NewTargetBuf,TargetBuf,min(TgtPtr,len));
	TgtLen = len;
	delete(TargetBuf-3);
	TargetBuf=NewTargetBuf;
}

#define CHECK_ERR(err, msg) { \
    if (err != Z_OK) { \
        fprintf(stdout, "%s error: %d\n", msg, err); \
        exit(1); \
    } \
}


CContainers::CContainers() : bigBuffer(NULL) {};

void CContainers::prepareMemBuffers()
{
	memout=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p("!data",memout);
	memmap.insert(p);

	memout_words=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p2("!!!words",memout_words);
	memmap.insert(p2);

	memout_letters=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p3("!!letters",memout_letters);
	memmap.insert(p3);

	memout_num=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p4("!num",memout_num);
	memmap.insert(p4);

	memout_year=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p5("!year",memout_year);
	memmap.insert(p5);

	memout_date=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p6("!date",memout_date);
	memmap.insert(p6);

	memout_words2=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p7("!!!words2",memout_words2);
	memmap.insert(p7);

	memout_words3=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p8("!!!words3",memout_words3);
	memmap.insert(p8);

	memout_words4=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p9("!!!words4",memout_words4);
	memmap.insert(p9);

	memout_pages=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p10("!pages",memout_pages);
	memmap.insert(p10);

	memout_num2=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p11("!num2",memout_num2);
	memmap.insert(p11);

	memout_num3=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p12("!num3",memout_num3);
	memmap.insert(p12);

	memout_num4=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p13("!num4",memout_num4);
	memmap.insert(p13);

	memout_remain=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p14("!remain",memout_remain);
	memmap.insert(p14);

	memout_date2=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p15("!date2",memout_date2);
	memmap.insert(p15);

	memout_date3=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p16("!date3",memout_date3);
	memmap.insert(p16);

	memout_num2b=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p17("!num2b",memout_num2b);
	memmap.insert(p17);

	memout_num3b=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p18("!num3b",memout_num3b);
	memmap.insert(p18);

	memout_num4b=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p19("!num4b",memout_num4b);
	memmap.insert(p19);

	memout_numb=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p20("!numb",memout_numb);
	memmap.insert(p20);

	memout_num2c=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p21("!num2c",memout_num2c);
	memmap.insert(p21);

	memout_num3c=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p22("!num3c",memout_num3c);
	memmap.insert(p22);

	memout_num4c=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p23("!num4c",memout_num4c);
	memmap.insert(p23);

	memout_numc=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p24("!numc",memout_numc);
	memmap.insert(p24);

	memout_time=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p25("!time",memout_time);
	memmap.insert(p25);

	memout_remain2=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p26("!remain2",memout_remain2);
	memmap.insert(p26);

	memout_ip=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p27("!ip",memout_ip);
	memmap.insert(p27);

	memout_hm=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p28("!hm",memout_hm);
	memmap.insert(p28);

	memout_hms=new CMemoryBuffer();
	std::pair<std::string,CMemoryBuffer*> p29("!hms",memout_hms);
	memmap.insert(p29);
}

void CContainers::writeMemBuffers(int preprocFlag, int PPMVClib_order, int comprLevel, Encoder* PAQ_encoder, unsigned char* zlibBuffer,COutFileStream* outStream)
{
	std::map<std::string,CMemoryBuffer*>::iterator it;

	int fileLen=0;
	int len=0;
	int lenCompr=0;
	int allocated=0;

#ifdef USE_LZMA_LIBRARY
	if (IF_OPTION(OPTION_LZMA))
	{
		Byte **Data;
		unsigned int* Size;
		int count;
		
		count=(int)memmap.size();
		Size=new unsigned int[count];
		Data=(unsigned char**) malloc(sizeof(unsigned char*)*count);
		if (Data==NULL)
			OUT_OF_MEMORY();
	
		int i=0;
		for (it=memmap.begin(); it!=memmap.end(); it++)
		{
			CMemoryBuffer* b=it->second;
			fileLen=b->Size();
			
			if (fileLen>0)
			{
				Size[i]=fileLen;
				Data[i]=b->TargetBuf;
				i++;
				
				PUTC((int)it->first.size());
				for (int i=0; i<(int)it->first.size(); i++)
					PUTC(it->first[i]);
				
				PUTC(fileLen>>24);
				PUTC(fileLen>>16);
				PUTC(fileLen>>8);
				PUTC(fileLen);	
			}
		}
		
		PUTC(0);
		
		count=i;
		int last=LZMAlib_GetOutputFilePos(outStream);
		LZMAlib_EncodeSolidMemToFile(Data,Size,count,outStream);
		printStatus(0,LZMAlib_GetOutputFilePos(outStream)-last,true);
	}
	else
#endif
	{
		for (it=memmap.begin(); it!=memmap.end(); it++)
		{
			CMemoryBuffer* b=it->second;
			fileLen=b->Size();
			
			PRINT_CONTAINERS(("cont=%s fileLen=%d\n",it->first.c_str(),fileLen));

			if (fileLen>0)
			{
				allocated+=b->Allocated();
				len+=fileLen;
					
				if (!IF_OPTION(OPTION_PAQ))
				{	
					PUTC((int)it->first.size());
					for (int i=0; i<(int)it->first.size(); i++)
						PUTC(it->first[i]);
				}

#ifdef USE_PAQ_LIBRARY
				if (IF_OPTION(OPTION_PAQ))
				{
					int i;
					PAQ_encoder->compress((int)it->first.size());
					for (i=0; i<(int)it->first.size(); i++)
						PAQ_encoder->compress(it->first[i]);

					PAQ_encoder->compress(fileLen>>24);
					PAQ_encoder->compress(fileLen>>16);
					PAQ_encoder->compress(fileLen>>8);
					PAQ_encoder->compress(fileLen);

					int last=ftell(XWRT_fileout);
					for (i=0; i<fileLen; )
					{
						PAQ_encoder->compress(b->TargetBuf[i++]);
						if (i%102400==0)
						{
							printStatus(0,ftell(XWRT_fileout)-last,true);
							last=ftell(XWRT_fileout);
						}
					}
					printStatus(0,ftell(XWRT_fileout)-last,true);
				}
				else
#endif
#ifdef USE_PPMVC_LIBRARY
				if (IF_OPTION(OPTION_PPMVC))
				{
					int last=ftell(XWRT_fileout);
					PPMVClib_EncodeMemToFile(PPMVClib_order,b->TargetBuf,fileLen,XWRT_fileout);
					printStatus(0,ftell(XWRT_fileout)-last,true);
				}
				else
#endif
#ifdef USE_ZLIB_LIBRARY
				if (IF_OPTION(OPTION_ZLIB))
				{

					int l=Zlib_compress(XWRT_fileout,b->TargetBuf,fileLen,zlibBuffer,ZLIB_BUFFER_SIZE,comprLevel);
					lenCompr+=l;
				}
				else
#endif
				{
					PUTC(fileLen>>24);
					PUTC(fileLen>>16);
					PUTC(fileLen>>8);
					PUTC(fileLen);

					fwrite_fast(it->second->TargetBuf,it->second->TgtPtr,XWRT_fileout);

					lenCompr+=fileLen;

					printStatus(0,fileLen,true);
				}
				
			}
		}
		
		if (!IF_OPTION(OPTION_PAQ))
			PUTC(0)
#ifdef USE_PAQ_LIBRARY
		else
			PAQ_encoder->compress(0);
#endif
	}

	PRINT_DICT(("dataSize=%d compr=%d allocated=%d\n",len,lenCompr,allocated));

	freeMemBuffers(true);
	prepareMemBuffers();
}

void CContainers::readMemBuffers(int preprocFlag, int maxMemSize, int PPMVClib_order, Encoder* PAQ_encoder, unsigned char* zlibBuffer,CInFileStream* inStream)
{
	unsigned char* buf=NULL;
	unsigned int bufLen=0;
	unsigned int fileLen;
	unsigned int ui;
	int len=0;
	int lenCompr=0;
	int i,c;
	unsigned char s[STRING_MAX_SIZE];

	if (IF_OPTION(OPTION_ZLIB) || IF_OPTION(OPTION_LZMA) || IF_OPTION(OPTION_PPMVC) || IF_OPTION(OPTION_PAQ))
	{
		bufLen=maxMemSize+10240;
		if (bigBuffer==NULL)
		{
			bigBuffer=(unsigned char*)malloc(bufLen);
			if (bigBuffer==NULL)
				OUT_OF_MEMORY();
		}
		buf=bigBuffer+3;