/* *	HT Editor *	store.cc * *	Copyright (C) 1999-2003 Sebastian Biallas (sb@biallas.net) * *	This program is free software; you can redistribute it and/or modify *	it under the terms of the GNU General Public License version 2 as *	published by the Free Software Foundation. * *	This program is distributed in the hope that it will be useful, *	but WITHOUT ANY WARRANTY; without even the implied warranty of *	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the *	GNU General Public License for more details. * *	You should have received a copy of the GNU General Public License *	along with this program; if not, write to the Free Software *	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */#include <cerrno>#include <cstring>#include "atom.h"#include "htdebug.h"#include "endianess.h"#include "language.h"#include "snprintf.h"#include "store.h"#include "strtools.h"#include "tools.h"static char hexchars[] = "0123456789abcdef";char oidchar(ObjectID oID, int byte){	unsigned char c = (oID >> (byte*8)) & 0xff;	if ((c<32) || (c>0x7f)) c = '?';	return c;}void putIDComment(ObjectStream &o, uint32 id){	char buf[64];	char id_str[4];	id_str[3] = id&0xff;	id_str[2] = (id>>8)&0xff;	id_str[1] = (id>>16)&0xff;	id_str[0] = (id>>24)&0xff;	escape_special(buf, sizeof buf, id_str, 4);	o.putComment(buf);}ObjectNotRegisteredException::ObjectNotRegisteredException(ObjectID aID)	: MsgfException("Object %x/%c%c%c-%x not registered.", aID,	  oidchar(aID, 3), oidchar(aID, 2), oidchar(aID, 1), aID & 0xff){}/* *	ObjectStreamInter */ ObjectStreamInter::ObjectStreamInter(Stream *s, bool own_s) : ObjectStream(s, own_s){}Object *ObjectStreamInter::getObjectInternal(const char *name, ObjectID id){	if (id == OBJID_INVALID) {		GET_INT32X(*this, id);		if (!id) {			return NULL;		}	}	object_builder build = (object_builder)getAtomValue(id);	if (!build) throw ObjectNotRegisteredException(id);	Object *o = build();	o->load(*this);	return o;}void	ObjectStreamInter::putObject(const Object *object, const char *name, ObjectID id){	if (!object) {		if (id == OBJID_INVALID) {			PUTX_INT32X(*this, 0, "id");			return;		} else {			throw IllegalArgumentException(HERE);		}	}	if (id == OBJID_INVALID) {		id = object->getObjectID();		putIDComment(*this, id);		PUTX_INT32X(*this, id, "id");	}	if (!getAtomValue(id)) {		throw ObjectNotRegisteredException(id);	}	object->store(*this);}/* *	ObjectStreamBin */ ObjectStreamBin::ObjectStreamBin(Stream *s, bool own_s) : ObjectStreamInter(s, own_s){} void ObjectStreamBin::getBinary(void *buf, uint size, const char *desc){	mStream->readx(buf, size);}bool ObjectStreamBin::getBool(const char *desc){	bool b;	mStream->readx(&b, 1);	return b;}uint64 ObjectStreamBin::getInt(uint size, const char *desc){	assert(size <= 8);	byte neta[8];	mStream->readx(&neta, size);	return createHostInt64(neta, size, big_endian);}char *ObjectStreamBin::getString(const char *desc){	return mStream->readstrz();}byte *ObjectStreamBin::getLenString(int &length, const char *desc){	byte b;	mStream->readx(&b, 1);	switch (b) {    	case 0xfe: {		byte neta[2];		mStream->readx(&neta, 2);		length = createHostInt(neta, 2, big_endian);		break;	}	case 0xff: {		byte neta[4];		mStream->readx(&neta, 4);		length = createHostInt(neta, 4, big_endian);		break;	}	default:		length = b;		break;	}	if (length==0) return NULL;	byte *p = ht_malloc(length);	mStream->readx(p, length);	return p;}void ObjectStreamBin::putBinary(const void *mem, uint size, const char *desc){	mStream->writex(mem, size);}void ObjectStreamBin::putBool(bool b, const char *desc){	b = (b) ? 1 : 0;	mStream->writex(&b, 1);}void ObjectStreamBin::putCommentf(const char *comment_format, ...){	// NOP}void ObjectStreamBin::putComment(const char *comment){	// NOP}void ObjectStreamBin::putInt(uint64 i, uint size, const char *desc, uint int_fmt_hint){	assert(size <= 8);	byte neta[8];	createForeignInt64(neta, i, size, big_endian);	mStream->writex(neta, size);}void ObjectStreamBin::putSeparator(){	// NOP}void ObjectStreamBin::putString(const char *string, const char *desc){	mStream->writestrz(string);}void ObjectStreamBin::putLenString(const byte *string, int len, const char *desc){	byte bLen;	if (len < 0xfe) {		bLen = len;		mStream->writex(&bLen, 1);	} else if (len <= 0xffff) {		byte neta[2];		createForeignInt(neta, len, 2, big_endian);		bLen = 0xfe;		mStream->writex(&bLen, 1);		mStream->writex(neta, 2);	} else {		byte neta[4];		createForeignInt(neta, len, 4, big_endian);		bLen = 0xff;		mStream->writex(&bLen, 1);		mStream->writex(neta, 4);	}	mStream->writex(string, len);}void	ObjectStreamBin::corrupt(){	throw MsgfException("corrupt file");}/* *	ObjectStreamText */ ObjectStreamText::ObjectStreamText(Stream *s, bool own_s) : ObjectStreamInter(s, own_s){	indent = 0;	cur = ' ';	// must be initialized to a whitespace char	line = 1;	errorline = 0;}void	ObjectStreamText::getBinary(void *buf, uint size, const char *desc){	readDesc(desc);	expect('=');	expect('[');	byte *pp=(byte *)buf;	for (uint i=0; i<size; i++) {		skipWhite();		int bb;		if ((bb = hexdigit(cur))==-1) setSyntaxError();		int b = bb*16;		readChar();		if ((bb = hexdigit(cur))==-1) setSyntaxError();		b += bb;		*pp++=b;		readChar();	}	expect(']');}bool ObjectStreamText::getBool(const char *desc){	readDesc(desc);	expect('=');	skipWhite();	if (cur=='f') {		readDesc("false");		return false;	} else {		readDesc("true");		return true;	}}uint64 ObjectStreamText::getInt(uint size, const char *desc){	readDesc(desc);	expect('=');	skipWhite();	if (mapchar[(byte)cur]!='0') setSyntaxError();	char str[40];	char *s=str;	do {		*s++ = cur;		if (s-str >= 39) setSyntaxError();		readChar();	} while (mapchar[(byte)cur]=='0' || mapchar[(byte)cur]=='A');	*s=0;	uint64 a;	if (!str2int(str, a)) setSyntaxError();	return a;}Object *ObjectStreamText::getObjectInternal(const char *name, ObjectID id){	readDesc(name);	expect('=');	expect('{');	Object *o = ObjectStreamInter::getObjectInternal(name, id);	expect('}');	return o;}char *ObjectStreamText::getString(const char *desc){	readDesc(desc);	expect('=');	skipWhite();	if (cur == '"') {		String s;		readChar();		while (cur != '"') {			s += cur;			if (cur == '\\') {				readChar();				s += cur;				cur = 0; // hackish			}			readChar();		}		readChar();		s.unescape();		return s.grabContentChar();	} else {		readDesc("NULL");		return NULL;	}}byte *ObjectStreamText::getLenString(int &len, const char *desc){	readDesc(desc);	expect('=');	skipWhite();	if (cur == '"') {		String s;		readChar();		while (cur != '"') {			s += cur;			if (cur == '\\') {				readChar();				s += cur;				cur = 0; // hackish			}			readChar();		}		readChar();		s.unescape();		len = s.length();		return s.grabContent();	} else {		readDesc("NULL");		return NULL;	}}void ObjectStreamText::putBinary(const void *mem, uint size, const char *desc){	putDesc(desc);	putChar('[');	for (uint i=0; i < size; i++) {		byte a = *((byte *)mem+i);		putChar(hexchars[(a & 0xf0) >> 4]);		putChar(hexchars[(a & 0x0f)]);		if (i+1 < size) putChar(' ');	}	putS("]\n");}void ObjectStreamText::putBool(bool b, const char *desc){	putDesc(desc);	if (b) putS("true"); else putS("false");	putChar('\n');}void ObjectStreamText::putComment(const char *comment){	putIndent();	putS("# ");	putS(comment);	putChar('\n');}void ObjectStreamText::putInt(uint64 i, uint size, const char *desc, uint int_fmt_hint){	putDesc(desc);	char number[40];	switch (int_fmt_hint) {		case OS_FMT_DEC:			ht_snprintf(number, sizeof number, "%qd\n", i);			break;		case OS_FMT_HEX:		default:			ht_snprintf(number, sizeof number, "0x%qx\n", i);			break;	}	putS(number);}void ObjectStreamText::putObject(const Object *object, const char *name, ObjectID id){	putDesc(name);	putS("{\n");	indent++;	ObjectStreamInter::putObject(object, name, id);	indent--;	putIndent();	putS("}\n");}void ObjectStreamText::putSeparator(){	putIndent();	putS("# ------------------------ \n");}void ObjectStreamText::putString(const char *string, const char *desc){	putDesc(desc);	if (string) {		String s(string);		putChar('"');		s.escape("\"", true);		putS(s.contentChar());		putChar('"');	} else {		putS("NULL");	}	putChar('\n');}void ObjectStreamText::putLenString(const byte *string, int len, const char *desc){	putDesc(desc);	if (string) {		int strl=len*4+1;		char *str = ht_malloc(strl);		putChar('"');		escape_special(str, strl, string, len, "\"");		putS(str);		putChar('"');		free(str);	} else {		putS("NULL");	}	putChar('\n');}class TextSyntaxError: public MsgfException {public:	TextSyntaxError(uint line)		: MsgfException("syntax error in line %d", line)	{	}};void	ObjectStreamText::setSyntaxError(){	// FIXME: errorline still usable ?	if (!errorline) {		errorline = line;		throw TextSyntaxError(line);	}}int	ObjectStreamText::getErrorLine(){	return errorline;}void	ObjectStreamText::expect(char c){	skipWhite();	if (cur != c) setSyntaxError();	readChar();}void	ObjectStreamText::skipWhite(){	while (1) {		switch (mapchar[(byte)cur]) {		case '\n':			line++;  // fallthrough		case ' ':			readChar();			break;		case '#':			do {				readChar();			} while (cur != '\n');			break;		default: return;		}	}}char ObjectStreamText::readChar(){	mStream->readx(&cur, 1);	return cur;}void ObjectStreamText::readDesc(const char *desc){	skipWhite();	if (!desc) desc = "data";	while (*desc) {		if (*desc != cur) setSyntaxError();		readChar();		desc++;	}}void ObjectStreamText::putDesc(const char *desc){	putIndent();	putS(desc ? desc : "data");	putChar('=');}void ObjectStreamText::putIndent(){	for(int i=0; i < indent; i++) putChar(' ');}void ObjectStreamText::putChar(char c){	mStream->writex(&c, 1);}void ObjectStreamText::putS(const char *s){	uint len=strlen(s);	if (mStream->write(s, len) != len) setSyntaxError();}void	ObjectStreamText::corrupt(){	errorline = line;	throw MsgfException("corrupt format near line %d", line);}/* *	ObjectStreamNative View:set/getData() methods *	(endian-dependend) */ObjectStreamNative::ObjectStreamNative(Stream *s, bool own_s, bool d): ObjectStream(s, own_s), duplicate(d), allocd(true){}void *ObjectStreamNative::duppa(const void *p, int size){	if (duplicate) {		MemArea *m = new MemArea(p, size, true);		allocd += m;		return m->ptr;	} else {		// FIXME: un-const'ing p		return const_cast<void*>(p);	}}void ObjectStreamNative::getBinary(void *buf, uint size, const char *desc){	void *pp;	mStream->readx(&pp, sizeof pp);	memcpy(buf, pp, size);}bool ObjectStreamNative::getBool(const char *desc){	bool b;	mStream->readx(&b, sizeof b);	return b;}uint64 ObjectStreamNative::getInt(uint size, const char *desc){	switch (size) {	case 1: {		uint8 i;		mStream->readx(&i, size);		return i;	}	case 2: {		uint16 i;		mStream->readx(&i, size);		return i;	}	case 4: {		uint32 i;		mStream->readx(&i, size);		return i;	}	case 8: {		uint64 i;		mStream->readx(&i, size);		return i;	}	}	throw IllegalArgumentException(HERE);}Object *ObjectStreamNative::getObjectInternal(const char *name, ObjectID id){	Object *pp;	mStream->readx(&pp, sizeof pp);	return pp;}char	*ObjectStreamNative::getString(const char *desc){	char *pp;	mStream->readx(&pp, sizeof pp);	return pp;}byte	*ObjectStreamNative::getLenString(int &len, const char *desc){	byte *pp;	mStream->readx(&pp, sizeof pp);	// FIXME?	if (pp) len = strlen((char*)pp); else len = 0;	return pp;}void	ObjectStreamNative::putBinary(const void *mem, uint size, const char *desc){	void *pp = mem ? duppa(mem, size) : NULL;	mStream->writex(&pp, sizeof pp);}void	ObjectStreamNative::putBool(bool b, const char *desc){	mStream->writex(&b, sizeof b);}void	ObjectStreamNative::putComment(const char *comment){	// NOP}void	ObjectStreamNative::putInt(uint64 i, uint size, const char *desc, uint int_fmt_hint){	switch (size) {	case 1: {		uint8 x = i;		mStream->writex(&x, size);		return;	}	case 2: {		uint16 x = i;		mStream->writex(&x, size);		return;	}	case 4: {		uint32 x = i;		mStream->writex(&x, size);		return;	}	case 8:		mStream->writex(&i, size);		return;	}	throw IllegalArgumentException(HERE);}void ObjectStreamNative::putObject(const Object *object, const char *name, ObjectID id){	Object *d = duplicate ? d->clone() : d;	mStream->write(&d, sizeof d);}void	ObjectStreamNative::putSeparator(){	// NOP}void	ObjectStreamNative::putString(const char *string, const char *desc){	const char *pp = string ? (const char*)duppa(string, strlen(string)+1) : NULL;	mStream->write(&pp, sizeof pp);}void	ObjectStreamNative::putLenString(const byte *string, int len, const char *desc){	const char *pp = string ? (const char*)duppa(string, len+1) : NULL;	mStream->write(&pp, sizeof pp);}void	ObjectStreamNative::corrupt(){}