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

 	Accept:	filename - String for the filename of disk
 	Desc:	Sets the file pointer
 			Reads the file size and last modifed time to store in the class
 			Splits up the filename and dir path
 */
-void C_File::SetFilename ( CyString filename )
+void C_File::SetFilename(CyString filename)
+{
-	CyString file = filename.FindReplace ( "\\", "/" ).FindReplace ( "//", "/" );
-	int tok = file.NumToken ( '/' );
+	setFilename(filename.ToString());
+}
-	m_sFullDir = file.GetToken ( "/&quot;, 1, -1 );
+void C_File::setFilename(const Utils::String &amp;filename)
+{
-	m_sName = file.GetToken ( &quot;/", -1 );
+	Utils::String file = filename.findReplace ( "\\", "/" ).findReplace ( &quot;//", "/" );
-	if ( m_sFullDir.Right(2) == "/." )
-		m_sFullDir = m_sFullDir.Left(-2);
+	_sFullDir = file.tokens("/", 1, -2);
+	m_sName = file.token("/", -1);
+	if ( _sFullDir.right(2) == "/." )
+		_sFullDir = _sFullDir.left(-2);
 	ReadFileSize ();
 	ReadLastModified ();
 }
 /*
 	Func:	ReadFromFile
 	Return:	Boolean - Returns true if read was successfull
 	Desc:	Reads data from file pointer into data stream
 			As its read from a file, there will be no compression, so its set to None
 */
 bool C_File::ReadFromFile ()
 {
-	return this->ReadFromFile(GetFilePointer().c_str());
+	return this->readFromFile(filePointer());
 }
-bool C_File::ReadFromFile (CyString filename)
+bool C_File::ReadFromFile(CyString filename)
+{
+	return readFromFile(filename.ToString());
+}
+bool C_File::readFromFile(const Utils::String filename)
+{
 	CFileIO File(filename);
 	if ( !File.startRead() ) {
 		m_iLastError = SPKERR_FILEOPEN;
 		return false;
 	}
 	m_iDataCompression = SPKCOMPRESS_NONE;
 	m_lDataSize = m_lUncomprDataSize = m_lSize;
 	DeleteData ();
 	catch(std::exception &e) {
 		CLog::logf(CLog::Log_IO, 2, "C_File::readFromFile() unable to read from file, %d (%s)", m_lDataSize, e.what());
 		DeleteData ();
 		m_lDataSize = 0;
 		return false;
 	}
 	return true;
+}
 void C_File::copyData(const unsigned char *data, size_t size)
+{
 	m_lDataSize = (long)size;
 	delete m_sData;
 	m_sData = new unsigned char[size];
 	memcpy(m_sData, data, size);
 }
 Utils::String C_File::filePointer() const
+{
-	Utils::String fullfile = m_sFullDir.ToString();
+	Utils::String fullfile = _sFullDir;
 	if ( !fullfile.empty() )
 		fullfile += "/";
 	if ( !m_sName.Empty() )
 		fullfile += m_sName.ToString();
 	return fullfile;
+}
 bool C_File::isExternalFile() const
 {
 	if (!m_sData && !m_lDataSize)
+	{
 		Utils::String file = this->filePointer();
 		if (!file.empty() && CFileIO::Exists(file))
 			return true;
 void C_File::UpdateSignature()
+{
 	m_sSignature = "";
 	bool deleteData = false;
 	if ( !m_sData )
+	{
 		if ( !ReadFromFile() )
 			return;
 	Return:	Returns the file size read
 	Desc:	Opens the file and seeks to the end
 */
 long C_File::ReadFileSize ()
+{
-	CFileIO File(GetFilePointer());
+	CFileIO File(filePointer());
 	if ( File.exists() ) m_lSize = File.fileSize();
 	m_lUncomprDataSize = m_lSize;
 	return m_lSize;
+}
 /*
 	Func:	ReadLastModifed()
 	Desc:	Reads the last modified time of the file and returns
 			Uses seperate rountines for Windows and Linux
 */
 time_t C_File::ReadLastModified ()
+{
-	CyString file = GetFilePointer();
+	Utils::String file = filePointer();
-	if ( file.Empty() )
+	if ( file.empty() )
 		return m_tTime;
 	#ifndef _WIN32
 	struct stat attrib;			// create a file attribute structure
     stat ( file.c_str(), &attrib);
 	return m_tTime;
+}
 bool C_File::CheckValidFilePointer ()
+{
-	return CFileIO::Exists(GetFilePointer().ToString());
+	return CFileIO::Exists(filePointer());
+}
 bool C_File::ReadSignedFile()
+{
 	if ( (m_iFileType != FILETYPE_SCRIPT) && (m_iFileType != FILETYPE_UNINSTALL) )
 		return false;
 	// check file pointer
-	CyString file = GetFilePointer();
+	Utils::String file = filePointer();
-	CyString ext = CFileIO(file).GetFileExtension();
+	Utils::String ext = CFileIO(file).extension();
 	if ( !ext.Compare("xml") && !ext.Compare("pck") )
 		return false;
 	if ( m_iDataCompression != SPKCOMPRESS_NONE )
 		return m_bSigned;
 	if ( (m_iFileType != FILETYPE_SCRIPT) && (m_iFileType != FILETYPE_UNINSTALL) ) return 0;
 	if ( (m_sData) && (m_iDataCompression == SPKCOMPRESS_NONE) )
 		m_iVersion = ::ReadScriptVersionFromData ( m_sData, m_lDataSize );
 	else {
-		CFileIO File(GetFilePointer());
+		CFileIO File(filePointer());
 		if ( File.startRead() ) {
 			int iRead = (File.fileSize() > 5000) ? 5000 : File.fileSize();
 			unsigned char *data = File.read(iRead);
 			if ( data ) {
 				m_iVersion = ::ReadScriptVersionFromData(data, iRead);
 ########################################################################################################################
 */
 bool C_File::CompressFile ( CProgressInfo *progress )
+{
-	CyString file = this->GetFilePointer();
+	Utils::String file = this->filePointer();
-	if ( !CFileIO(this->GetFilePointer()).exists() )
+	if ( !CFileIO(this->filePointer()).exists() )
+	{
-		if ( !this->WriteToFile("tempuncompr.dat", m_sData, m_lDataSize) )
+		if ( !this->writeToFile("tempuncompr.dat", m_sData, m_lDataSize) )
 			return false;
 		file = "tempuncompr.dat";
+	}
 	bool ret = false;
 		if ( res == SZ_OK )
+		{
 			DeleteData ();
 			m_iDataCompression = SPKCOMPRESS_NONE;
 			m_lDataSize = (long)uncomprLen;
 			m_sData = new unsigned char[m_lDataSize];
 			memcpy(m_sData, uncompr, m_lDataSize);
 			delete uncompr;
 			return true;
 		}
 		if ( uncompr )
 			delete [] uncompr;
 	}
 	else if ( m_iDataCompression == SPKCOMPRESS_7ZIP )
+	{
 		long len = m_lUncomprDataSize;
 		unsigned char *compr = LZMADecode_C ( (unsigned char *)m_sData, m_lDataSize, (size_t*)&len, NULL );
 		if ( compr )
 			DeleteData ();
 			m_sData = compr;
 			m_lDataSize = len;
 			m_iDataCompression = SPKCOMPRESS_NONE;
 			return true;
 		}
 	}
 	return false;
+}
 unsigned char *C_File::UncompressData ( long *size, CProgressInfo *progress )
+{
 	// no data to try to uncompress
 	if ( (!m_sData) || (!m_lDataSize) )
 		return NULL;
 	//if ( m_bCompressedToFile )
 	//	return NULL;
 	// if comopression is set to none, dont bother
 	if ( m_iDataCompression == SPKCOMPRESS_NONE )
 	{
 		*size = m_lDataSize;
 		return m_sData;
+	}
 	if ( m_iDataCompression == SPKCOMPRESS_ZLIB )
+	{
 		unsigned long uncomprLen = m_lUncomprDataSize;
 		unsigned char *uncompr = new unsigned char[m_lUncomprDataSize];
 		int err = uncompress ( uncompr, &uncomprLen, (const unsigned char *)m_sData, m_lDataSize );
 		if ( err == Z_OK )
+		{
 			*size = uncomprLen;
 			return uncompr;
+		}
 		if ( uncompr )
 			delete [] uncompr;
+	}
 	if ( m_iDataCompression == SPKCOMPRESS_7ZIP )
 	{
 		long len = m_lUncomprDataSize;
 		unsigned char *compr = LZMADecode_C ( m_sData, m_lDataSize, (size_t *)&len, NULL );
 		if ( compr )
+		{
 			*size = len;
 			return compr;
+		}
 		if ( compr )
 			delete [] compr;
+	}
 	else if ( m_iDataCompression == SPKCOMPRESS_LZMA )
 	{
 		size_t uncomprLen = m_lUncomprDataSize;
 		unsigned char *uncompr = new unsigned char[m_lUncomprDataSize];
 		SRes res = Lzma86_Decode(uncompr, &uncomprLen, m_sData, (size_t*)&m_lDataSize);
 		if ( res == SZ_OK )
+		{
+	{
 		m_iTempNum++;
 		file = CyString("uncompr") + (long)m_iTempNum + ".tmp";
+	}
 	else
-		file = GetFullFileToDir ( file, includedir, spkfile );
+		file = _getFullFileToDir(file.ToString(), includedir, spkfile);
 	CFileIO File("compr.tmp");
 	if ( !File.startWrite() ) return false;
 	if ( !File.write(m_sData, m_lDataSize) ) return false;
 	File.close();
 	return false;
 #endif
+}
-bool C_File::WriteFilePointer ( unsigned char *cData, long len )
+bool C_File::writeFilePointer(unsigned char *cData, long len)
+{
-	return WriteToFile ( GetFilePointer(), cData, len );
+	return writeToFile(filePointer(), cData, len);
+}
-bool C_File::WriteToFile ( CyString filename, unsigned char *cData, long len )
+bool C_File::writeToFile(const Utils::String &filename, unsigned char *cData, long len)
+{
 	unsigned char *data = cData;
 	if ( (!len) || (!data) ) {
 		len = m_lDataSize;
 		data = m_sData;
 	}
 	if ( (!len) || (!data) ) {
 		if ( m_lSize ) return false;
 	}
 	bool ret = false;
 	// check for cat file
-	if ( filename.IsIn ( "::" ) ) {
+	if ( filename.contains("::")) {
-		Utils::String catfile = filename.GetToken ( "::", 1, 1 ).ToString();
+		Utils::String catfile = filename.token("::", 1);
-		Utils::String file = filename.GetToken ( "::", 2, 2 ).ToString();
+		Utils::String file = filename.token( "::", 2);
 		CCatFile newcat;
 		return newcat.AddData ( catfile, data, len, file, true, true );
+	}
 	else {
-		Utils::String filen = filename.FindReplace ( "/", "\\" ).ToString();
+		Utils::String filen = filename.findReplace ( "/", "\\" );
 		filen = filen.findReplace ( "\\\\", "\\" );
 		if ( len && data ) {
 			CFileIO File(filen);
 			if ( File.startWrite() ) ret = File.write(data, len);
+		}
+	}
 	return ret;
 }
-CyString C_File::GetFullFileToDir ( CyString dir, bool includedir, CBaseFile *file )
-{
-	CyString fullfile = dir;
-	if ( includedir )
-	{
-		CyString d = GetDirectory ( file );
-		if ( !d.Empty() )
-		{
-			if ( !fullfile.Empty() )
-				fullfile += "/";
-			fullfile += d;
-		}
-	}
-	if ( !m_sName.Empty() )
-	{
-		if ( !fullfile.Empty() )
-			fullfile += "/";
-		fullfile += m_sName;
-	}
-	fullfile = fullfile.FindReplace ( "\\", "/" );
-	return fullfile;
-}
-bool C_File::WriteToDir ( CyString &dir, CBaseFile *spkfile, bool includedir, CyString appendDir, unsigned char *data, long len )
+bool C_File::writeToDir(const Utils::String &dir, CBaseFile *spkfile, bool includedir, const Utils::String &appendDir, unsigned char *data, long len)
 {
-	CyString fullfile = GetFullFileToDir ( dir, includedir, spkfile );
+	Utils::String fullfile = _getFullFileToDir(dir, includedir, spkfile);
-	if ( !appendDir.Empty() )
+	if (!appendDir.empty())
 	{
-		if ( !fullfile.Empty() )
+		if (!fullfile.empty())
 			fullfile += "/";
 		fullfile += appendDir;
 	}
-	CyString fulldir = fullfile.GetToken ( 1, fullfile.NumToken('/') - 2, '/&apos; );
+	Utils::String fulldir = fullfile.tokens("/&quot;, 1, -2);
-	if ( !fulldir.Empty() )
+	if (!fulldir.empty())
+	{
-		if ( !CDirIO(fulldir).Create() )
+		if (!CDirIO(fulldir).Create())
 			return false;
+	}
-	return WriteToFile ( fullfile, data, len );
+	return writeToFile(fullfile, data, len);
 }
 CyString C_File::GetDataSizeString ()
+{
 	return SPK::GetSizeString ( m_lDataSize );
 }
 CyString C_File::GetUncompressedSizeString ()
+{
 	return SPK::GetSizeString ( GetUncompressedDataSize() );
+}
 CyString C_File::GetCreationTimeString ()
+{
 	if ( !m_tTime )
 		return NullString;
 	struct tm   *currDate;
 	char    dateString[100];
 	time_t n = m_tTime;
 	currDate = localtime(&n);
 	strftime(dateString, sizeof dateString, "(%d/%m/%Y) %H:%M", currDate);
 	return CyString(dateString);
+}
 bool C_File::CompareNew ( C_File *file )
+{
 	if ( !m_iVersion )
 		ReadScriptVersion ();
 	// if version, check if its later version
 	if ( (m_iVersion) && (file->GetVersion()) )
+	{
 		if ( m_iVersion > file->GetVersion() )
 			return false;
 	}
 	// now check for last modified time
 	if ( (m_tTime) && (file->GetLastModified()) )
+	{
 		if ( m_tTime > file->GetLastModified() )
 		case FILETYPE_SHIPSCENE:
 			return "ShipScene";
 		case FILETYPE_COCKPITSCENE:
 			return "CockpitScene";
+	}
 	return Utils::String::Null();
+}
 FileType GetFileTypeFromString ( CyString type )
+{
 		case SPKINSTALL_UNINSTALL_MOVE_FAIL:
 			errorStr = "Unable to Move uninstall file: %1";
 			break;
 		case SPKINSTALL_UNINSTALL_COPY:
 			errorStr = "Coping uninstall file: %1";
 			break;
 		case SPKINSTALL_UNINSTALL_COPY_FAIL:
 			errorStr = "Unable to Copy uninstall file: %1";
 			break;
 		case SPKINSTALL_UNINSTALL_REMOVE:
 			errorStr = "Removing Uninstall file: %1";
 			break;
 		case SPKINSTALL_UNINSTALL_REMOVE_FAIL:
 			errorStr = "Unable to remove Uninstall file: %1";
 			break;
 		case SPKINSTALL_SHARED:
 			errorStr = "Removing Unused Shared file: %1";
 			break;
 		case SPKINSTALL_SHARED_FAIL:
 			errorStr = "Unable to remove Unused Shared file: %1";
 			break;
 		case SPKINSTALL_ORIGINAL_BACKUP:
 			errorStr = "Backing up original file: %1";
 			break;
 		case SPKINSTALL_ORIGINAL_BACKUP_FAIL:
 			errorStr = "Unable to back up original file: %1";
 			break;
 		case SPKINSTALL_ORIGINAL_RESTORE:
 			errorStr = "Restoring original file: %1";
 			break;
 		case SPKINSTALL_ORIGINAL_RESTORE_FAIL:
 			errorStr = "Unable to restore original file: %1";
 			break;
 		case SPKINSTALL_FAKEPATCH:
 			errorStr = "Shifted fake patch: %1 to %2";
 			errorStr = "Orphaned File removed: %1";
 			break;
 		case SPKINSTALL_ORPHANED_FAIL:
 			errorStr = "Unable to remove Orphaned File: %1";
 			break;
 	}
 	CyString ret = errorStr.Args(args, max);
 	CLEANSPLIT(args, max)
 	return ret;
+}
 bool C_File::CheckPCK ()
+{
 	if ( (m_sData) && (m_lDataSize) && (m_iDataCompression == SPKCOMPRESS_NONE) )
 		return IsDataPCK ( m_sData, m_lDataSize );
-	Utils::String filename = GetFilePointer().ToString();
+	Utils::String filename = filePointer();
 	if ( !filename.empty() ) {
 		CFileIO File(filename);
 		if ( File.startRead() ) {
 			unsigned char data[4];
 			if ( File.read(data, 3) ) return IsDataPCK ( data, 3 );
 			m_bUsedMalloc = false;
 			m_lDataSize = (long)size;
 			m_sData = new unsigned char[size];
 			memcpy(m_sData, data, size);
 			delete [] data;
 		}
 		return true;
+	}
 	return false;
 	unsigned char *data = NULL;
 	size_t datasize = 0;
 	if ( CheckValidFilePointer() )
+	{
-		CFileIO File(GetFilePointer().ToString());
+		CFileIO File(filePointer());
 		if ( File.startRead() ) data = File.readAll(&datasize);
+	}
 	if ( !data )
+	{
 unsigned char *UnPCKFile ( const char *file, size_t *len, bool nocrypt )
+{
 	CFileIO File(file);
 	if ( !File.startRead() ) return NULL;
 	size_t size;
 	unsigned char *data = File.readAll(&size);
 	if ( data ) {
 		unsigned char *unData = UnPCKData ( data, size, len, nocrypt );
 		if ( tempData ) delete []tempData;
 		return NULL;
+	}
 	memset ( uncompr, 0, sizeof(uncompr) );
 	// find header size
 	unsigned char *buf = newData + PCKHEADERSIZE;
 //	buf = data + (6 + sizeof(time_t));
 	char flag = newData[3];
+}
 int ReadScriptVersionFromData ( unsigned char *data, long size )
+{
 	int iVersion = 0;
 	if ( IsDataPCK ( data, size ) )
+	{
 		size_t unpckSize = 0;
 		unsigned char *unpckData = UnPCKData ( data, size, &unpckSize );
 		if ( (unpckData) && (unpckSize) ) {
 		tag[pos - iStartPos] = '\0';
 		return atoi(tag);
+	}
 	return iVersion;
 }
 CyString C_File::GetBaseName ()
+{
 	// remove any directory
 	CyString file = m_sName.GetToken ( "/", m_sName.NumToken ( '/' ) );
 	m_sName = CFileIO(m_sName).ChangeFileExtension(ext);
 	return m_sName;
+}
 bool C_File::CheckPackedExtension()
 {
 	CyString ext = this->GetFileExt();
 	if ( ext == "pck" )
 		return true;
 	else if ( ext == "pbb" )
 		return true;
 	else if ( ext == "pbd" )
 		return true;
 	return false;
 }
 bool C_File::shouldCheckBaseName() const
+{
 	Utils::String ext = CFileIO(m_sName).extension();
 	if (ext == "xml" || ext == "txt" || ext == "pck")
 		return true;
 	if (ext == "bod" || ext == "bob" || ext == "pbb" || ext == "pbd")
 		return true;
 	return false;
+}
 unsigned int C_File::game() const
+{
 	return _iGame;
 }
+bool C_File::isForGame(int game) const
+{
+	if (game > 0)
+	{
+		if (!_iGame || _iGame == GAME_ALLNEW)
+			return true;
+		return (_iGame & 1 << game) != 0;
+	}
+	return true;
+}
+int C_File::getForSingleGame() const
+{
+	int checkGame = _iGame & ~GAME_ALLNEW;
+	for (int i = 0; i < 31; ++i)
+	{
+		if (checkGame == (1 << i))
+			return i;
+	}
+	return 0;
+}
 void C_File::setGame(unsigned int i)
+{
 	if (i == 0 || i == 1 << 31)
 		_iGame = 0;
 unsigned char *C_File::BobDecompile(size_t *size)
+{
 	(*size) = 0;
-	Utils::String fromFile = this->GetFilePointer().ToString();
+	Utils::String fromFile = this->filePointer();
 	if ( !CFileIO::Exists(fromFile) ) {
-		if ( this->WriteToFile(CPackages::tempDirectory() + "bob.tmp") ) {
+		if ( this->writeToFile(CPackages::tempDirectory() + "bob.tmp") ) {
 			fromFile = CPackages::tempDirectory() + "bob.tmp";
+		}
+	}
 	fromFile = fromFile.findReplace("/", "\\");
 	bob_dom_document doc(&settings);
 	ibinaryrealfile is;
 	otextrealfile os;
 	os.open(CPackages::tempDirectory() + "tmp.tmp", filestream::create);
-	is.open(this->GetFilePointer().c_str(), filestream::rdonly);
+	is.open(this->filePointer().c_str(), filestream::rdonly);
 	if(is.fail() || os.fail()) return NULL;
 	bool bRes=doc.convert(is, os);
 	// uncompress the file
 	if ( !this->UncompressData() )
 		return false;
 	// un pck the file
 	if ( this->CheckFileExt("pck") )
+	{
 		if ( !this->UnPCKFile() )
 			return false;
+	}
 	// now we should have the raw data
 	CyString data((const char *)m_sData);
 	data.Truncate(m_lDataSize);
 	this->DeleteData();
 	m_sData = new unsigned char[data.Length()];
 	memcpy(m_sData, data.c_str(), data.Length());
 	m_lDataSize = (long)data.Length();
 	// repck the file
 	if ( this->CheckFileExt("pck") )
 	{
 		if ( !this->PCKFile() )
 			return false;
+	}
 	return true;
+}
+Utils::String C_File::_getFullFileToDir(const Utils::String &dir, bool includedir, CBaseFile *file) const
+{
+	Utils::String fullfile = dir;
+	if (includedir)
+	{
+		Utils::String d = getDirectory(file);
+		if (!d.empty())
+		{
+			if (!fullfile.empty())
+				fullfile += "/";
+			fullfile += d;
+		}
+	}
+	if (!m_sName.Empty())
+	{
+		if (!fullfile.empty())
+			fullfile += "/";
+		fullfile += m_sName.ToString();
+	}
+	fullfile = fullfile.findReplace("\\", "/");
+	return fullfile;
+}

Subversion Repositories spk

(root)//libspk/src/File.cpp – Rev 128 → 129