Subversion Repositories spk

#include "bob_dom_cut.h"

#include "../common/indian.h"

static int g_i;

#define BOB_WRITE(fd, i) (g_i=be2le((unsigned int)i), write(fd, &g_i, sizeof(i)))

#define max(a, b) (a > b ? a : b)

//---------------------------------------------------------------------------------

bool bob_dom_name::toFile(bob_dom_otextfilestream& os)

{

	if(m_text && *m_text!=0) {

		int oldf=os.flags();

		os << noSemicolons << "N " << autoSemicolons << m_text;

		os.flags(oldf);

	}

	return os.good();

}

//---------------------------------------------------------------------------------

// STAT

#ifdef X2BC_USE_INI_FORMATS

bool bob_dom_stat::load(bob_dom_ibinaryfilestream& is, const Settings *settings)

{

	is >> frameId;

	m_format=settings->findStatFormat(frameId);

	if(m_format==NULL){

		error(s_error, e_format_noStatFormat, "Cannot find STAT format 0x%X", frameId);

		setstate(bob_dom_stat::noFormat);

	}

	else{

		int v;

		for(Settings::StatFormat::const_iterator &it=m_format->tokens.begin(); it!=m_format->tokens.end(); ++it){

			for(int i=0; i < it->count; i++){

				is >> v;

				push_back(v);

			}

			if(is.fail()){

				error(s_error, e_format_notEnoughData, "Not enough data to match format 0x%X", frameId);

				setstate(cannotMatchFormat);

				break;

			}

		}

	}

	return rdstate()==formatted;

}

//---------------------------------------------------------------------------------

bool bob_dom_stat::toFile(bob_dom_obinaryfilestream& os)

{

	os << frameId;

	for(iterator &it=begin(); it!=end(); ++it){

		os << *it;

	}

	return os.good();

}

//---------------------------------------------------------------------------------

bool bob_dom_stat::toFile(bob_dom_otextfilestream& os, const Settings *settings)

{

	os << noSemicolons;

	if(rdstate()!=formatted && settings->outputWarnings()){

		os << "// Error: STAT frame id=" << hex << "0x" << frameId << dec;

		if(rdstate()==noFormat)	

			os << ": cannot find frame format";

		else

			os << ": unable to match frame format";

	}

	else{

		if(settings->statFormatWarnings() && settings->outputWarnings() && m_format->issueWarning)

			os << "// Warning: Format 0x" << hex << m_format->id << " was used and it's marked with warning sign" << endl;

		double val;

		os << "{ ";

		os << hex << "0x" << frameId << "; " << dec;

		iterator &valit=begin();

		for(Settings::StatFormat::const_iterator &it=m_format->tokens.begin(); it!=m_format->tokens.end(); ++it){

			for(int i=0; i < it->count; i++){

				val=*valit;

				if(settings->convert())

					val*=it->numFormat->multiplier;

				if(settings->convert() && it->numFormat->outformat==Settings::NumberFormat::Float)

					os << (float)val;

				else

					os << (int)val;

				os << ';';

				++valit;

			}

			if(it->data)

				os << it->data;

		}

		os << noSemicolons << " }";

	}

	return os.good();

}

//---------------------------------------------------------------------------------

#endif // defined(X2BC_USE_INI_FORMATS)

// PATH

bool bob_dom_path::load(bob_dom_ibinaryfilestream& is, int version)

{

	int hdr;

	is >> hdr;

	if(hdr!=hdr_begin){

		error(e_badHeader);

		return false;

	}

	is >> partIdx;

	if(version < 6) {

		int bid;

		is >> bid;

		m_bodyId=new char[20];

		_itoa(bid, m_bodyId, 10);

	}

	else 

		is >> m_bodyId;

	is >> cockpitIdx >> parentIdx >> bodyFlags;

	if(peek(is)==bob_dom_name::hdr_begin){

		if(name.load(is)==false){

			for(ErrorIterator &it=name.errors.begin(); it!=name.errors.end(); ++it){

				error(it->code, "name: %s", it->text);

			}

			return false;

		}

	}

	if(peek(is)==bob_dom_constants::hdr_begin){

		if(constants.load(is)==false){

			for(ErrorIterator &it=name.errors.begin(); it!=name.errors.end(); ++it){

				error(it->code, "constants: %s", it->text);

			}

			return false;

		}

	}

	if(peek(is)==bob_dom_bob::hdr_begin){

		bob=new bob_dom_bob(m_settings);

		if(bob->load(is)==false){

			for(ErrorIterator &it=bob->errors.begin(); it!=bob->errors.end(); ++it){

				error(it->code, "bob->%s", it->text);

			}

			return false;

		}

	}

	int noteLineCount;

	is >> noteLineCount;

	if(noteLineCount > 0){

		if(m_notes.load(is, noteLineCount)==false){

			for(ErrorIterator &it=m_notes.errors.begin(); it!=m_notes.errors.end(); ++it){

				error(it->code, "notes->%s", it->text);

			}

			return false;

		}

	}

	int statCount;

	is >> statCount;

	if(loadStatValues(is, statCount)==false) return false;

	is >> hdr;

	if(is.fail())

		error(e_notEnoughData);

	else if(hdr!=hdr_end)

		error(e_badEndHeader);

	/////////////////

	//if(hdr==hdr_end) formatStats();

	////////////////

	return hdr==hdr_end && !is.fail();

}

//---------------------------------------------------------------------------------

bool bob_dom_path::loadStatValues(bob_dom_ibinaryfilestream& is, int count)

{

	int hdr;

	is >> hdr;

	if(hdr!=hdr_stat_begin){

		error(e_badHeader, "Expected STAT header.");

		return false;

	}

	child_type *ch;

	bool bRes;

	for(int i=0; i < count; i++){

		ch=createChild();

#ifdef X2BC_USE_INI_FORMATS

		bRes=ch->load(is, m_settings);

#else

		bRes=ch->load(is);

#endif

		for(ErrorIterator &it=ch->errors.begin(); it!=ch->errors.end(); ++it){

			error(it->severity, it->code, "stat->frame[%d]: %s", i, it->text);

		}

		if(bRes==false) break;

	}

	is >> hdr;

	if(hdr!=hdr_stat_end){

		error(s_error, e_moreData, "More data in STAT section than expected - skipping");

		do{

			is >> hdr;

		}

		while(hdr!=hdr_stat_end && is.good());

	}

	if(hdr!=hdr_stat_end)

		error(e_notEnoughData);

	return hdr==hdr_stat_end;

}

//---------------------------------------------------------------------------------

bool bob_dom_path::toFile(bob_dom_obinaryfilestream& os, int cutVersion)

{

	os << hdr_begin;

	os << partIdx;

	if(cutVersion >= 6)

		os << bodyId();

	else

		os << atoi(bodyId());

	os << cockpitIdx;

	os << parentIdx;

	os << bodyFlags;

	os << name;

	constants.toFile(os);

	if(bob) bob->toFile(os);

	os << (int)m_notes.size();

	m_notes.toFile(os);

	os << (int)size();

	os << hdr_stat_begin;

	for(iterator &it=begin(); it!=end(); ++it){

		it->toFile(os);

	}

	os << hdr_stat_end << hdr_end;

	return true;

}

//---------------------------------------------------------------------------------

bool bob_dom_path::toFile(bob_dom_otextfilestream& os, int idx)

{

	os << noSemicolons << "P " << partIdx << "; B " << bodyId() << "; ";

	if(parentIdx!=-1)

		os << "F " << parentIdx << "; ";

	if(cockpitIdx > 0)

		os << "C " << cockpitIdx << "; ";

	os << name;

	constants.toFile(os);

	/*

		we've got old x2 flags and new x3 flags

		these 2 can be mixed together

		for example body || light

		only the body (64) and scene (128) can be mixed with anything else imho

	*/

	if(bodyFlags!=0) {

		if(bodyFlags & BodyFlags::fBody)

			os << "b ";

		if(bodyFlags & BodyFlags::fScene)

			os << "j ";

		int i=bodyFlags & 0x3F;

		if(i) 

			os << (char) ('b' + i) << ' ';

	}

	os << "// idx " << idx << ", flags: " << bodyFlags << endl;

	if(m_notes.size())

		m_notes.toFile(os);

	if(bob){

		os << noSemicolons << "L { // beginning of embedded BOB" << endl;

		os << *bob << "} // end of embedded BOB" << endl << endl;

	}

	int i=0;

	for(iterator &it=begin(); it!=end(); ++it, ++i){

#ifdef X2BC_USE_INI_FORMATS

		it->toFile(os, m_settings);

#else

		it->toFile(os);

#endif

		os << " // " << i << endl;

	}

	os << endl;

	return os.good();

}

//---------------------------------------------------------------------------------

// CUT file

bool bob_dom_cut::load(bob_dom_ibinaryfilestream& is)

{

	int hdr;

	is >> hdr;

	if(hdr!=hdr_begin){

		error(e_badHeader);

		return false;

	}

	if(peek(is)==bob_dom_info::hdr_begin){

		if(!info.load(is)){

			for(ErrorIterator &it=info.errors.begin(); it!=info.errors.end(); ++it){

				error(it->code, "info: %s", it->text);

			}

			return false;

		}

	}

	is >> version;

	if(version!=supported_version)

		error(s_warning, e_badVersion, "Unsupported CUT1 version, loading might fail");

	is >> m_storedPathCount;

	child_type *ch;

	for(int i=0; i < m_storedPathCount; i++){

		ch=createChild();

		bool bRes=ch->load(is, version);

		for(ErrorIterator &it=ch->errors.begin(); it!=ch->errors.end(); ++it){

			error(it->code, "path[%d]->%s", i, it->text);

		}

		if(bRes==false) return false;

	}

	is >> hdr;

	if(hdr!=hdr_end)

		error(e_badEndHeader);

	return hdr==hdr_end;

}

//---------------------------------------------------------------------------------

bool bob_dom_cut::convert(bob_dom_ibinaryfilestream& is, bob_dom_otextfilestream& os)

{

	int hdr;

	is >> hdr;

	if(hdr!=hdr_begin){

		error(e_badHeader);

		return false;

	}

	if(peek(is)==bob_dom_info::hdr_begin){

		if(!info.load(is)){

			for(ErrorIterator &it=info.errors.begin(); it!=info.errors.end(); ++it){

				error(it->code, "info: %s", it->text);

			}

			return false;

		}

	}

	is >> version;

	os << info << endl << "VER: " << autoSemicolons << version << endl << endl;

	is >> m_storedPathCount;

	child_type *ch;

	for(int i=0; i < m_storedPathCount; i++){

		ch=new bob_dom_path(m_settings);

		bool bRes=ch->load(is, version);

		for(ErrorIterator &it=ch->errors.begin(); it!=ch->errors.end(); ++it){

			error(it->code, "path[%d]->%s", i, it->text);

		}

		if(bRes)

			ch->toFile(os, i);

		delete ch;

		if(bRes==false) return false;

	}

	is >> hdr;

	if(hdr!=hdr_end)

		error(e_badEndHeader);

	return hdr==hdr_end;

}

//---------------------------------------------------------------------------------

bool bob_dom_cut::toFile(bob_dom_obinaryfilestream& os)

{

	os << hdr_begin << info << version << (int)size();

	for(iterator &it=begin(); it!=end(); ++it){

		it->toFile(os, version);

	}

	os << hdr_end;

	return os.good();

}

//---------------------------------------------------------------------------------

bool bob_dom_cut::toFile(bob_dom_otextfilestream& os)

{

	os << noSemicolons << info << endl;

	os << "VER: " << autoSemicolons << version << endl << endl;

	int idx=0;

	for(iterator &it=begin(); it!=end(); ++it){

		it->toFile(os, idx++);

		os << endl;

	}

	return os.good();

}

//---------------------------------------------------------------------------------

// NOTES - section NOTE

bool bob_dom_notes::load(bob_dom_ibinaryfilestream& is, int lineCount)

{

	int hdr;

	is >> hdr;

	if(hdr!=hdr_begin){

		error(e_badHeader);

		return false;

	}

	child_type *ch;

	for(int i=0; i < lineCount; i++){

		ch=createChild();

		if(ch->load(is)==false){

			error(ch->errorCode, "line[%d]: %s", i, bob_traslate_error(ch->errorCode));

			return false;

		}

	}

	is >> hdr;

	if(hdr!=hdr_end)

		error(e_badEndHeader);

	return hdr==hdr_end && !is.fail();

}

//---------------------------------------------------------------------------------

bool bob_dom_notes::toFile(bob_dom_obinaryfilestream& os)

{

	if(size()==0) return true;

	os << hdr_begin;

	for(iterator &it=begin(); it!=end(); ++it){

		it->toFile(os);

	}

	os << hdr_end;

	return os.good();

}

//---------------------------------------------------------------------------------

bool bob_dom_notes::toFile(bob_dom_otextfilestream& os)

{

 os << noSemicolons << "T // Notes" << endl;

	for(iterator &it=begin(); it!=end(); ++it){

		it->toFile(os);

		os << endl;

	}

	os << -1 << " // end of Notes" << endl;

	return os.good();

}

//---------------------------------------------------------------------------------

// NOTE - object

bool bob_note::load(bob_dom_ibinaryfilestream& is)

{

	is >> value;

	is >> text;

	if(is.fail())

		errorCode=e_notEnoughData;

	return !is.fail();

}

//---------------------------------------------------------------------------------

bool bob_note::toFile(bob_dom_obinaryfilestream& os)

{

	os << value << text;

	return os.good();

}

//---------------------------------------------------------------------------------

bool bob_note::toFile(bob_dom_otextfilestream& os)

{

	os << autoSemicolons << value << text;

	return os.good();

}

//---------------------------------------------------------------------------------

bool bob_dom_constants::load(bob_dom_ibinaryfilestream& is)

{

	int hdr, count;

	is >> hdr;

	if(hdr!=hdr_begin){

		error(e_badHeader);

		return false;

	}

	is >> count;

	constant c;

	for(int i=0; i < count; i++){

		c.load(is);

		values.push_back(c);

	}

	is >> hdr;

	if(hdr!=hdr_end){

		error(e_badEndHeader);

		return false;

	}

	return is.good();

}

//---------------------------------------------------------------------------------

bool bob_dom_constants::toFile(bob_dom_obinaryfilestream& os)

{

	if(values.size()==0) return true;

	os << hdr_begin << (int)values.size();

	for(iterator &it=values.begin(); it!=values.end(); ++it){

		(*it).toFile(os);

	}

	os << hdr_end;

	return os.good();

}

//---------------------------------------------------------------------------------

bool bob_dom_constants::toFile(bob_dom_otextfilestream& os)

{

	if(values.size()==0) return true;

	os << noSemicolons << "K " << autoSemicolons << (int)values.size();

	for(iterator &it=values.begin(); it!=values.end(); ++it){

		(*it).toFile(os);

	}

	os << noSemicolons;

	return os.good();

}

//---------------------------------------------------------------------------------

bool bob_dom_constants::constant::load(bob_dom_ibinaryfilestream& is)

{

	is >> a >> b;

	return is.good();

}

//---------------------------------------------------------------------------------

bool bob_dom_constants::constant::toFile(bob_dom_obinaryfilestream& os)

{

	os << a << b;

	return os.good();

}

//---------------------------------------------------------------------------------

bool bob_dom_constants::constant::toFile(bob_dom_otextfilestream& os)

{

	os << a << b;

	return os.good();

}

//---------------------------------------------------------------------------------