WebSVN – spk – Diff – //libspk/src/File.cpp

 // LZMA compression
 #include "lzma/Lzma86Enc.h"
 #include "lzma/Lzma86Dec.h"
 // X2BOD
+#ifdef _XBODLIBRARY__
+#include "../Windows/libx2bc.h"
-/*
+#else
 #include "x2bc/x2bc_common/settings.h"
 #include "x2bc/x2bc_common/bob_dom.h"
 #include "x2bc/x2bc_common/bod_parser.h"
 #include "x2bc/x2bc_common/realfile_stream.h"
-*/
+#endif
-#include "../Windows/libx2bc.h"
 //////////////////////////////////////////////////////////////////////
 // STATIC FUNCTIONS
 //////////////////////////////////////////////////////////////////////
 	Reset ();
 	setFilename(filename);
+}
 C_File::~C_File()
 {
 	DeleteData ();
 	if (!_sTmpFile.empty())
 		CFileIO::Remove(_sTmpFile);
 }
 long C_File::uncompressedDataSize() const
+{
 	if (m_lUncomprDataSize)
 		return m_lUncomprDataSize;
 	Utils::WString sDir = _sDir;
 	if ((m_iFileType == FILETYPE_MOD) && (sDir == L"Patch"))
 		return L"PluginManager/Patch";
 	if ((!sDir.empty()) && (m_iFileType != FILETYPE_README) && sDir != L".")
+	{
 		Utils::WString dir = sDir.findReplace(L"\\", L"/");
 		if (file)
+		{
 		// script files need to check
 		case FILETYPE_SCRIPT:
 		case FILETYPE_UNINSTALL:
 			m_bSigned = this->ReadSignedFile();
 			break;
 		// mission files
 		case FILETYPE_MISSION:
 			m_bSigned = false;
 			break;
+	}
 			break;
 		case SPKCOMPRESS_LZMA:
+			{
 				unsigned char *compr = (unsigned char *)malloc(comprLen);
+				if (!compr) {
+					return NULL;
+				}
 				SRes res = Lzma86_Encode((Byte *)compr, (size_t *)&comprLen, (const Byte *)m_sData, (size_t)m_lDataSize, level, LZMA_DICT, SZ_FILTER_NO, (progress) ? progress->GetDonePointer() : NULL);
 				if ( res == SZ_OK )
+				{
 					unsigned char *retData = new unsigned char[comprLen];
 					(*outSize) = comprLen;
 					memcpy(retData, compr, comprLen);
 				free(compr);
 				return NULL;
+			}
 			break;
 	}
 	return NULL;
+}
 bool C_File::CompressData ( int compressionType, CProgressInfo *progress, int level )
+{
 	// no data to try to compress
 	if ( (!m_sData) || (!m_lDataSize) )
 		return false;
 	// if comopression is set to noe, dont bother
-	if ( compressionType == SPKCOMPRESS_NONE )
+	if (compressionType == SPKCOMPRESS_NONE)
 		return true;
 	if ( compressionType == SPKCOMPRESS_7ZIP )
 		compressionType = SPKCOMPRESS_LZMA;
 	// if its zlib, and we are trying to compress pcked files (ie already zlib compression) then switch to lzma instead
 	if ( compressionType == SPKCOMPRESS_ZLIB && (this->checkFileExt(L"pck") || this->checkFileExt(L"cat") || this->checkFileExt(L"dat") || this->checkFileExt(L"pbb") || this->checkFileExt(L"pbd")) )
 		compressionType = SPKCOMPRESS_LZMA;
+	// dont compress cat/dat files
+	if (this->checkFileExt(L"cat") || this->checkFileExt(L"dat"))
+		compressionType = SPKCOMPRESS_NONE;
 	// if its already compressed, no need to compress again
 	if ( compressionType == m_iDataCompression )
 		return true;
 			m_bUsedMalloc = false;
 			m_lDataSize = comprLen;
 			m_iDataCompression = compressionType;
+		}
 		// we shall always return true, files can be added in non compressed mode
+		//TODO: file compression?
 		return true;
+	}
 	return false;
+}
 	if ( (!m_sData) || (!m_lDataSize) ) {
 		return (m_lSize) ? false : true;
+	}
 	if ( m_bCompressedToFile )
 		return false;
 	// if comopression is set to none, dont bother
 	if ( m_iDataCompression == SPKCOMPRESS_NONE )
 		return true;
 	if ( m_iDataCompression == SPKCOMPRESS_ZLIB )
 	return ret;
+}
 bool C_File::CheckPCK ()
 {
 	if ( (m_sData) && (m_lDataSize) && (m_iDataCompression == SPKCOMPRESS_NONE) )
 		return IsDataPCK ( m_sData, m_lDataSize );
 	Utils::WString filename = filePointer();
 	if ( !filename.empty() ) {
 		CFileIO File(filename);
 		if ( File.startRead() ) {
 			unsigned char data[4];
 			if ( File.read(data, 3) ) return IsDataPCK ( data, 3 );
+		}
 	}
 	if (checkFileExt(L"pck") || checkFileExt(L"pbb") || checkFileExt(L"pbd")) return true;
 	return false;
+}
 bool C_File::PCKFile()
 {
 	if ( !m_lDataSize || !m_sData )
 	{
 		if ( !this->ReadFromFile() )
 			return false;
 	}
 	if ( m_lDataSize && m_sData )
 	{
 		if ( !this->UncompressData() )
 			return false;
 		size_t size;
 		unsigned char *data = PCKData(m_sData, m_lDataSize, &size, false);
 		if ( data && size )
+		{
+}
 bool C_File::UnPCKFile()
+{
 	if ( !m_lDataSize || !m_sData )
 	{
 		if ( !this->ReadFromFile() )
 			return false;
+	}
 	if ( m_lDataSize && m_sData )
+	{
+	{
 		tempData = new unsigned char[datasize];
 		newData = tempData;
 		memcpy(newData, data, datasize);
 		unsigned char magic = newData[0] ^ 0xC8;
 		for ( size_t i = 1; i < datasize; i++ )
 			newData[i] ^= magic;
 		++newData;
 		--datasize;
+	}
+	{
 		if ( tempData ) delete []tempData;
 		delete uncompr;
 		*len = 0;
 		return NULL;
 	}
 	*len = uncomprLen;
 	uncompr[uncomprLen] = '\0';
 	if ( tempData ) delete []tempData;
 	return uncompr;
 }
 bool IsDataPCK ( const unsigned char *data, size_t size )
+{
 	if ( size >=3 )
+	{
 		unsigned char magic=data[0] ^ 0xC8;
 	if ( IsDataPCK ( data, size ) ) {
 		size_t unpckSize = 0;
 		unsigned char *unpckData = UnPCKData ( data, size, &unpckSize, false );
 		if ( (unpckData) && (unpckSize) ) {
 			ret = ReadSignedFromData ( unpckData, (long)unpckSize );
 			delete unpckData;
 		}
 		return ret;
 	}
 	char tag[10000];
 	// work backwards
 	int pos = size - 1;
 	int max = size - 5000;
 	if ( max < 0 ) max = 0;
 	// find the first tage
 		// now find the front
 		int pos2 = pos - 1;
 		while ( data[pos2] != '<' && pos2 > max ) pos2--;
 		if ( data[pos2] != '<' ) break;
 		memcpy(tag, data + pos2, pos - pos2);
 		tag[pos - pos2] = '\0';
 		Utils::WString sTag(tag);
 		if ( sTag.Compare(L"</signature") || sTag.Compare(L"<signature") ) return true;
 		if ( sTag.Compare(L"</codearray") || sTag.Compare(L"<codearray") ) return false;
 		pos = pos2 - 1;
 	}
 	return false;
+}
 int ReadScriptVersionFromData ( unsigned char *data, long size )
+{
 	int iVersion = 0;
 	return iVersion;
+}
 Utils::WString C_File::baseName() const
 {
 	// remove any directory
 	Utils::WString file = _sName.token(L"/", -1);
 	// remove file extension
 	return file.remToken(L".", -1);
 		if ( oldFile->GetData() && m_lDataSize )
+		{
 			m_sData = new unsigned char[m_lDataSize];
 			m_bUsedMalloc = false;
 			memcpy((char *)m_sData, (char *)oldFile->GetData(), m_lDataSize);
 		}
 		m_lUncomprDataSize = oldFile->uncompressedDataSize();
+	}
 	m_iDataCompression = oldFile->GetCompressionType();
 }
 float GetLibraryVersion() { return (float)LIBRARYVERSION; }
 float GetFileFormatVersion() { return (float)FILEVERSION; }
 Utils::WString C_File::fileExt() const
+{
 	return _sName.token(L".", -1);
+}
 bool C_File::checkFileExt(const Utils::WString& ext)
 {
 	if (fileExt().Compare(ext)) return true; return false;
+}
 const Utils::WString &C_File::changeFileExt(const Utils::WString &ext)
+{
 bool C_File::CheckPackedExtension()
+{
 	Utils::WString ext = this->fileExt();
 	if ( ext == L"pck" )
 		return true;
 	else if ( ext == L"pbb" )
 		return true;
 	else if ( ext == L"pbd" )
 		return true;
+}
 unsigned char *C_File::BobDecompile(size_t *size)
+{
+	(*size) = 0;
+	Utils::WString fromFile = this->filePointer();
+	if (!CFileIO::Exists(fromFile))
+	{
+		if (this->writeToFile(CPackages::tempDirectory() + L"bob.tmp"))
+			fromFile = CPackages::tempDirectory() + L"bob.tmp";
+	}
+	fromFile = fromFile.findReplace(L"/", L"\\");
+	Utils::WString toFile = CPackages::tempDirectory() + L"bod.tmp";
+	toFile = toFile.findReplace(L"/", L"\\");
+	if (CFileIO::Exists(fromFile))
+	{
+#ifdef _XBODLIBRARY__
+		if (X2BC_BOB2BOD(fromFile.toString().c_str(), toFile.toString().c_str())) {
+			CFileIO F(toFile);
+			if (F.exists() && F.startRead()) {
+				unsigned char* data = F.readAll(size);
+				F.close();
+				F.remove();
+				return data;
+			}
+		}
+#else
+		// Use x2bc library to convert the file
+		Settings settings;
+		bob_dom_document doc(&settings);
+		ibinaryrealfile is;
+		otextrealfile os;
+		is.open(fromFile.toString().c_str(), filestream::rdonly);
+		os.open(toFile.toString().c_str(), filestream::create);
+		if (!is.fail() && !os.fail())
+		{
+			if (doc.convert(is, os))
+			{
+				CFileIO F(toFile);
+				if (F.exists() && F.startRead())
+				{
+					unsigned char* data = F.readAll(size);
+					F.close();
+					F.remove();
+					return data;
+				}
+			}
+		}
+#endif
+	}
+	if (CFileIO::Exists(CPackages::tempDirectory() + L"bob.tmp"))
+		CFileIO::Remove(CPackages::tempDirectory() + L"bob.tmp");
+	return NULL;
+	/*
 	(*size) = 0;
 	Utils::WString fromFile = this->filePointer();
 	if ( !CFileIO::Exists(fromFile) ) {
 		if ( this->writeToFile(CPackages::tempDirectory() + L"bob.tmp")) {
 			fromFile = CPackages::tempDirectory() + L"bob.tmp";
 		}
+	}
 	fromFile = fromFile.findReplace(L"/", L"\\");
 	Utils::WString toFile = CPackages::tempDirectory() + L"bod.tmp";
 	toFile = toFile.findReplace(L"/", L"\\");
 			CFileIO F(toFile);
 			if ( F.exists() && F.startRead() ) {
 				unsigned char *data = F.readAll(size);
 				F.close();
 				F.remove();
 				return data;
+			}
+		}
+	}
 	if ( CFileIO::Exists(CPackages::tempDirectory() + L"bob.tmp") )
 		CFileIO::Remove(CPackages::tempDirectory() + L"bob.tmp");
+		*/
 	/*
 	Settings settings;
 	bob_dom_document doc(&settings);
 	ibinaryrealfile is;

Subversion Repositories spk

(root)//libspk/src/File.cpp – Rev 277 → 283