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

+	}
 	return NULL;
+}
-int CBaseFile::CheckFile ( CyString filename, float *version )
+int CBaseFile::CheckFile(const Utils::String &filename, float *version )
+{
 	CFileIO File(filename);
 	if ( !File.startRead() ) return 0;
 	Utils::String line = File.readEndOfLine();
 	Utils::String type = line.token(";", 1);
 	        line - Pointed to hold the line number thats read
 			upper - true if it converts to uppercase
 	Return: String - the string it has read
 	Desc:   Reads a string from a file, simlar to readLine() classes, reads to the end of the line in a file
 */
-CyString CBaseFile::GetEndOfLine ( FILE *id, int *line, bool upper )
+Utils::String CBaseFile::GetEndOfLine ( FILE *id, int *line, bool upper )
+{
-	CyString word;
+	Utils::String word;
 	char c = fgetc ( id );
 	if ( c == -1 )
 		return "";
 	if ( line )
 		++(*line);
 	if ( upper )
-		return word.ToUpper();
+		return word.upper();
 	return word;
+}
 size_t CBaseFile::countFiles(FileType filetype) const
 /*
 	Func:   CreateFilesLine
 	Return: String - returns the full string for files list
 	Desc:   Creates a signle line list of all the files
 */
-Utils::String CBaseFile::createFilesLine(bool updateheader, CProgressInfo* progress)
+Utils::String CBaseFile::createFilesLine(SSPKHeader2 *header, CProgressInfo* progress) const
+{
 	Utils::String line;
 	if (progress)
+	{
 		progress->SetDone(0);
 		progress->UpdateStatus(STATUS_COMPRESS);
+	}
-	if (updateheader)
+	if (header)
+	{
+		header->iDataCompression = m_SHeader2.iDataCompression;
+		header->iFileCompression = m_SHeader2.iFileCompression;
+		header->lSize = m_SHeader2.lSize;
-		m_SHeader2.iNumFiles = 0;
+		header->iNumFiles = 0;
-		m_SHeader2.lFullSize = 0;
+		header->lFullSize = 0;
+	}
 	if (m_pIconFile)
+	{
 		// no data, read it from file
 		// compress the file
 		if (!m_pIconFile->CompressData(m_SHeader2.iDataCompression, progress))
 			m_pIconFile->SetDataCompression(SPKCOMPRESS_NONE);
 		line += "Icon:" + Utils::String::Number(m_pIconFile->GetDataSize() + (long)4) + ":" + m_pIconFile->GetUncompressedDataSize() + ":" + (long)m_pIconFile->GetCompressionType() + ":" + _sIconExt + "\n";
-		if (updateheader)
+		if (header)
+		{
-			++m_SHeader2.iNumFiles;
+			++header->iNumFiles;
-			m_SHeader2.lFullSize += (m_pIconFile->GetDataSize() + 4);
+			header->lFullSize += (m_pIconFile->GetDataSize() + 4);
+		}
+	}
 	for (CListNode<C_File>* node = m_lFiles.Front(); node; node = node->next())
+	{
 		if (file->dir().empty())
 			line += command + ":" + (file->GetDataSize() + (long)4) + ":" + file->GetUncompressedDataSize() + ":" + (long)file->GetCompressionType() + ":" + (long)file->GetCreationTime() + ":" + ((file->IsCompressedToFile()) ? "1" : "0") + ":" + file->filename() + ":NULL:" + (long)file->game() + "\n";
 		else
 			line += command + ":" + (file->GetDataSize() + (long)4) + ":" + file->GetUncompressedDataSize() + ":" + (long)file->GetCompressionType() + ":" + (long)file->GetCreationTime() + ":" + ((file->IsCompressedToFile()) ? "1" : "0") + ":" + file->filename() + ":" + file->dir() + ":" + (long)file->game() + "\n";
-		if (updateheader)
+		if (header)
+		{
-			++m_SHeader2.iNumFiles;
+			++header->iNumFiles;
-			m_SHeader2.lFullSize += (file->GetDataSize() + 4);
+			header->lFullSize += (file->GetDataSize() + 4);
+		}
+	}
 	return line;
+}
 	delete File;
+}
 void CBaseFile::_install_adjustFakePatches(CPackages *pPackages)
+{
-	CyStringList lPatches;
+	Utils::CStringList lPatches;
 	int startfake = pPackages->FindNextFakePatch();
 	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
+	{
 		C_File *fit = node->Data();
 		// we should only have cat and dat files, but lets check just incase they have been added incorrectly
 		if ( !fit->CheckFileExt ("cat") && !fit->CheckFileExt("dat") )
 			continue;
 		// search for the name on the list
-		SStringList *opposite = lPatches.FindString(fit->GetBaseName());
-		CyString newname;
+		Utils::String newname;
-		if ( opposite )
+		bool isOpposite = false;
+		if (lPatches.contains(fit->baseName()))
+		{
+			newname = lPatches.findString(fit->baseName());
-			newname = opposite->data;
+			isOpposite = true;
+		}
 		else
+		{
-			newname = CyString::Number((long)startfake).PadNumber(2);
+			newname = Utils::String::PadNumber((long)startfake, 2);
-			lPatches.PushBack(fit->GetBaseName(), newname);
+			lPatches.pushBack(fit->baseName(), newname);
+		}
 		// rename the file
 		fit->FixOriginalName();
-		CLog::logf(CLog::Log_Install, 2, "Adjusting fake patch number, %s => %s", fit->GetNameDirectory(this).c_str(), (newname + "." + fit->GetFileExt()).c_str());
+		CLog::logf(CLog::Log_Install, 2, "Adjusting fake patch number, %s => %s", fit->getNameDirectory(this).c_str(), (newname + "." + fit->fileExt()).c_str());
-		fit->SetName ( newname + ".&quot; + fit->GetFileExt() );
+		fit->setName(newname + ".&quot; + fit->fileExt());
 		// find the next gap
-		if ( !opposite ) {
+		if ( !isOpposite ) {
 			startfake = pPackages->FindNextFakePatch(startfake + 1);
+		}
 	}
 }
 void CBaseFile::_install_renameText(CPackages *pPackages)
+{
 	int starttext = pPackages->findNextTextFile();
 	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() ) {
 		C_File *fit = node->Data();
 		if ( !fit->isAutoTextFile() )
 			continue;
 		Utils::String newname = SPK::FormatTextName(starttext, pPackages->GetLanguage(), (pPackages->GetCurrentGameFlags() & EXEFLAG_TCTEXT));
 		fit->FixOriginalName();
 		CLog::logf(CLog::Log_Install, 2, "Adjusting text file, %s => %s", fit->getNameDirectory(this).c_str(), (newname + "." + fit->fileExt()).c_str());
 		fit->setName(newname + "." + fit->fileExt());
 		++starttext;
+	}
+}
 bool CBaseFile::_install_setEnabled(bool bEnable, C_File *fit)
+{
 	if ( !bEnable )
 	{
 		if ( (fit->GetFileType() == FILETYPE_UNINSTALL) || (fit->GetFileType() == FILETYPE_README) || (fit->GetFileType() == FILETYPE_ADVERT) )
 			bEnable = true;
 		else if ( (fit->GetFileType() == FILETYPE_EXTRA) && (fit->GetDir().Left(7).ToLower() == "Extras/") )
 			bEnable = true;
 		else if ( (IsPatch()) && (fit->GetFileType() == FILETYPE_MOD) && (!fit->IsFakePatch()) )
+	}
 	return bEnable;
+}
-bool CBaseFile::_install_uncompress(C_File *fit, CProgressInfo *progress, CyStringList *errorStr, bool *uncomprToFile)
+bool CBaseFile::_install_uncompress(C_File *fit, CProgressInfo *progress, Utils::CStringList *errorStr, bool *uncomprToFile)
+{
 	*uncomprToFile = false;
 	_sLastError = fit->getNameDirectory(this);
 	_iLastError = SPKERR_UNCOMPRESS;
+		}
 		if ( !uncomprToFile )
+		{
 			if ( errorStr )
-				errorStr->PushBack(CyString(_sLastError), ERRORLOG_OLD(SPKINSTALL_UNCOMPRESS_FAIL));
+				errorStr->pushBack(_sLastError, ERRORLOG(SPKINSTALL_UNCOMPRESS_FAIL));
 			CLog::log(CLog::Log_Install, 1, "Unable to decompress file, skipping");
 			return false;
+		}
+	}
 	ClearError ();
 	// first get the version
 	if ( !m_bOverrideFiles && pFile->ReadScriptVersion() )
+	{
 		CLog::log(CLog::Log_Install, 2, "Checking for existing file version");
 		C_File checkfile;
-		CyString checkfilename = sDestination;
+		Utils::String checkfilename = sDestination;
-		if ( !checkfilename.Empty() ) checkfilename += "/";
+		if ( !checkfilename.empty() ) checkfilename += "/";
-		checkfilename += pFile->GetNameDirectory(this);
+		checkfilename += pFile->getNameDirectory(this);
-		checkfile.SetFilename ( checkfilename );
+		checkfile.setFilename(checkfilename);
 		checkfile.setFileType(pFile->fileType());
 		if ( checkfile.CheckValidFilePointer() ) {
 			if ( checkfile.ReadScriptVersion() > pFile->GetVersion() ) {
 				CLog::log(CLog::Log_Install, 1, "Newer version of the file found in directory, skipping");
 				return false;
+{
 	Utils::String filename = sDestination;
 	if ( !filename.empty() ) filename += "/";
 	if ( (IsPatch()) && (pFile->fileType() == FILETYPE_MOD) )
-		pFile->SetDir ( CyString("Patch") );
+		pFile->setDir("Patch");
 	if ( pFile->isInMod() )
+	{
 		if ( bEnabled )
 			pFile->setFilename(filename + pFile->getInMod() + "::" + pFile->getNameDirectory(this));
 	CLog::logf(CLog::Log_Install, 2, "Adjusting the file pointer to correct install destintation, %s", pFile->filePointer().c_str());
 	return filename;
+}
-C_File *CBaseFile::_install_checkFile(C_File *pFile, CyStringList *errorStr, bool *bDoFile, CLinkList<C_File> *pFileList)
+C_File *CBaseFile::_install_checkFile(C_File *pFile, Utils::CStringList *errorStr, bool *bDoFile, CLinkList<C_File> *pFileList)
+{
 	if ( !pFile->IsFakePatch() && pFile->GetFileType() != FILETYPE_README )
+	{
 		C_File *cFile;
 		for ( cFile = pFileList->First(); cFile; cFile = pFileList->Next() )
+		{
 			if ( !cFile->MatchFile(pFile) ) continue;
 			if ( !m_bOverrideFiles && !cFile->CompareNew(pFile) ) {
-				if ( errorStr ) errorStr->PushBack(pFile->GetNameDirectory(this), ERRORLOG_OLD(SPKINSTALL_SKIPFILE));
+				if ( errorStr ) errorStr->pushBack(pFile->getNameDirectory(this), ERRORLOG(SPKINSTALL_SKIPFILE));
 				CLog::log(CLog::Log_Install, 1, "Newer version of the file already installed, skipping");
 				*bDoFile = false;
+			}
 			break;
+		}
+	}
 	return NULL;
+}
-bool CBaseFile::_install_checkFileEnable(C_File *pCheckFile, C_File *fit, const Utils::String &sDestination, bool bEnabled, CyStringList *errorStr)
+bool CBaseFile::_install_checkFileEnable(C_File *pCheckFile, C_File *fit, const Utils::String &sDestination, bool bEnabled, Utils::CStringList *errorStr)
+{
 	// found a file, check if its in the disabled directory
 	Utils::String dir = CFileIO(pCheckFile->filePointer()).dir();
 	Utils::String lastDir = CDirIO(dir).topDir().lower();
 	if ( ((pCheckFile->IsDisabled()) || (lastDir == "disabled") || (dir.lower().isin("/disabled/"))) && (bEnabled) )
+	{
 		CLog::logf(CLog::Log_Install, 2, "Existing file, %s, is disabled, re-enabling it", pCheckFile->filePointer().c_str());
 		// first check if the directory exists
 		if ( pCheckFile->isInMod() ) {
-			CyString tofile = pCheckFile->filePointer().token("::", 2);
+			Utils::String tofile = pCheckFile->filePointer().token("::", 2);
 			CCatFile tocat;
 			int err = tocat.open(fit->filePointer().token("::", 1), "", CATREAD_CATDECRYPT, true);
 			if ( (err == CATERR_NONE) || (err == CATERR_CREATED) ) {
-				tocat.AppendFile(pCheckFile->filePointer(), tofile.ToString());
+				tocat.AppendFile(pCheckFile->filePointer(), tofile);
 				CLog::logf(CLog::Log_Install, 2, "Adding existing file into new mod File, %s => %s", fit->filePointer().token("::", 1).c_str(), tofile.c_str());
+			}
 			CCatFile fromcat;
 			err = fromcat.open(pCheckFile->filePointer().token("::", 1), "", CATREAD_CATDECRYPT, false);
 			if ( err == CATERR_NONE ) {
-				fromcat.removeFile(tofile.ToString());
+				fromcat.removeFile(tofile);
 				CLog::logf(CLog::Log_Install, 2, "Removing file from existing mod, %s::%s", pCheckFile->filePointer().token("::", 1).c_str(), tofile.c_str());
 			}
 			CLog::logf(CLog::Log_Install, 1, "Adjusting existing file name %s => %s", pCheckFile->filePointer().c_str(), fit->filePointer().c_str());
 			pCheckFile->SetFilename ( fit->GetFilePointer() );
 			CLog::logf(CLog::Log_Install, 2, "Adjusting In Mod setting, %s => %s", pCheckFile->getInMod().c_str(), fit->getInMod().c_str());
 			pCheckFile->setInMod(fit->getInMod());
+		}
 		else {
 			Utils::String to = pCheckFile->getDirectory(this);
 			CDirIO Dir(sDestination);
 			if ( !Dir.exists(to) ) {
 				if ( !Dir.create ( to ) ) {
-					if ( errorStr )	errorStr->PushBack(CyString(to), ERRORLOG_OLD(SPKINSTALL_CREATEDIRECTORY_FAIL));
+					if ( errorStr )	errorStr->pushBack(to, ERRORLOG(SPKINSTALL_CREATEDIRECTORY_FAIL));
 					return false;
+				}
-				if ( errorStr )	errorStr->PushBack(CyString(to), ERRORLOG_OLD(SPKINSTALL_CREATEDIRECTORY));
+				if ( errorStr )	errorStr->pushBack(to, ERRORLOG(SPKINSTALL_CREATEDIRECTORY));
+			}
-			CyString destfile = CyString(sDestination) + "/" + pCheckFile->GetNameDirectory(this);
+			Utils::String destfile = sDestination + "/" + pCheckFile->getNameDirectory(this);
-			if ( CFileIO(destfile).ExistsOld() ) CFileIO::Remove(destfile.ToString());
+			if ( CFileIO(destfile).ExistsOld() ) CFileIO::Remove(destfile);
 			CLog::logf(CLog::Log_Install, 1, "Adjusting existing filename, %s => %s", pCheckFile->GetFilePointer().c_str(), destfile.c_str());
-			rename ( pCheckFile->GetFilePointer().c_str(), destfile.c_str() );
+			rename ( pCheckFile->filePointer().c_str(), destfile.c_str() );
-			pCheckFile->SetFilename ( CyString(sDestination) + "/" + pCheckFile->GetNameDirectory(this) );
+			pCheckFile->setFilename (sDestination + "/" + pCheckFile->getNameDirectory(this) );
+		}
 		pCheckFile->SetDisabled(false);
-		if ( errorStr ) errorStr->PushBack(pCheckFile->GetNameDirectory(this), ERRORLOG_OLD(SPKINSTALL_ENABLEFILE));
+		if ( errorStr ) errorStr->pushBack(pCheckFile->getNameDirectory(this), ERRORLOG(SPKINSTALL_ENABLEFILE));
+	}
 	return true;
+}
-bool CBaseFile::_install_createDirectory(CDirIO &Dir, const Utils::String &sTo, C_File *pFile, CyStringList *errorStr)
+bool CBaseFile::_install_createDirectory(CDirIO &Dir, const Utils::String &sTo, C_File *pFile, Utils::CStringList *errorStr)
+{
 	_sLastError = sTo;
 	if ( !sTo.contains( "::" ) )
+	{
 		if ( !Dir.exists(sTo) )
+		{
 			CLog::logf(CLog::Log_Install, 2, "Creating directory to install file into, %s", sTo.c_str());
 			if ( !Dir.create(sTo) )
+			{
 				if ( errorStr )
-					errorStr->PushBack(CyString(sTo), ERRORLOG_OLD(SPKINSTALL_CREATEDIRECTORY_FAIL));
+					errorStr->pushBack(sTo, ERRORLOG(SPKINSTALL_CREATEDIRECTORY_FAIL));
 				return false;
+			}
 			if ( errorStr )
-				errorStr->PushBack(CyString(sTo), ERRORLOG_OLD(SPKINSTALL_CREATEDIRECTORY));
+				errorStr->pushBack(sTo, ERRORLOG(SPKINSTALL_CREATEDIRECTORY));
+		}
+	}
 	else {
 		CLog::logf(CLog::Log_Install, 2, "Adjusting file extension for file in mod, %s => %s", pFile->filePointer().c_str(), CCatFile::PckChangeExtension(pFile->filePointer()).c_str());
 		pFile->setFilename(CCatFile::PckChangeExtension(pFile->filePointer()));
+	}
 	return true;
+}
-void CBaseFile::_install_writeFile(C_File *pFile, const Utils::String &sDestination, CyStringList *errorStr)
+void CBaseFile::_install_writeFile(C_File *pFile, const Utils::String &sDestination, Utils::CStringList *errorStr)
+{
 	_iLastError = SPKERR_WRITEFILE;
 	_sLastError = pFile->filePointer();
 	Utils::String sInstalledFile = pFile->getNameDirectory(this);
 	if ( pFile->IsDisabled() )
 	if ( !pFile->writeFilePointer() )
+	{
 		CLog::log(CLog::Log_Install, 1, "Failed to write the file");
 		if ( errorStr )
-			errorStr->PushBack(CyString(sInstalledFile), ERRORLOG_OLD(SPKINSTALL_WRITEFILE_FAIL));
+			errorStr->pushBack(sInstalledFile, ERRORLOG(SPKINSTALL_WRITEFILE_FAIL));
+	}
 	else
+	{
 		CLog::log(CLog::Log_Install, 1, "File written successfully");
 		CLog::log(CLog::Log_Install, 2, "Checking signed status of the file");
 		pFile->UpdateSigned();
 		if ( errorStr )
-			errorStr->PushBack(CyString(sInstalledFile), ERRORLOG_OLD(SPKINSTALL_WRITEFILE));
+			errorStr->pushBack(sInstalledFile, ERRORLOG(SPKINSTALL_WRITEFILE));
 		switch(pFile->GetFileType())
+		{
 			case FILETYPE_SCRIPT:
 			case FILETYPE_UNINSTALL:
 				CLog::log(CLog::Log_Install, 2, "Updating file signature");
 				pFile->updateSignature();
 				break;
 		}
 	}
+}
-bool CBaseFile::InstallFiles ( CyString destdir, CProgressInfo *progress, CLinkList<C_File> *filelist, CyStringList *errorStr, bool enabled, CPackages *packages )
+bool CBaseFile::installFiles(const Utils::String &destdir, CProgressInfo *progress, CLinkList<C_File> *filelist, Utils::CStringList *errorStr, bool enabled, CPackages *packages )
+{
 	//TODO: add errorStr and progress as member variables
 	if ( enabled ) {
 		this->_install_adjustFakePatches(packages);
 		if ( packages ) this->_install_renameText(packages);
 	CDirIO Dir(destdir);
 	int fileCount = 0;
 	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
+	{
 		C_File *fit = node->Data();
 		// start the install process, check if we need to the file enabled or disabled
 		CLog::logf(CLog::Log_Install, 1, "Preparing to install file: %s", fit->GetNameDirectory(this).c_str());
 		bool fileEnabled = _install_setEnabled(enabled, fit);
 		// check if the file is for the correct game version
 		if (!fit->isForGame(packages->GetGame()))
+		{
 			CLog::logf(CLog::Log_Install, 1, "File didn't match game version, skipping, %d != %d", fit->game(), packages->GetGame());
 			continue;
 		}
 		// update the progress display to show we are processing this file
 		if ( progress ) {
 			if ( progress->IsSecond() ) progress->SwitchSecond();
 			progress->UpdateFile ( fit );
 			progress->UpdateProgress(fileCount++, m_lFiles.size());
 		if ( !this->_install_uncompress(fit, progress, errorStr, &uncomprToFile) ) {
 			bFailed = true;
 			continue;
+		}
-		bool dofile = _install_checkVersion(fit, destdir.ToString());
+		bool dofile = _install_checkVersion(fit, destdir);
 		// change file pointer
-		Utils::String sInstallDir = _install_adjustFilepointer(fit, fileEnabled, destdir.ToString());
+		Utils::String sInstallDir = _install_adjustFilepointer(fit, fileEnabled, destdir);
 		C_File *adjustPointer = NULL;
 		if ( filelist ) {
 			C_File *cFile = _install_checkFile(fit, errorStr, &dofile, filelist);
 						if ( rFile.exists() )
+						{
 							if ( errorStr )
+							{
 								if ( rFile.remove() )
-									errorStr->PushBack(cFile->GetFilePointer().Remove(destdir), ERRORLOG_OLD(SPKINSTALL_DELETEFILE));
+									errorStr->pushBack(cFile->filePointer().findRemove(destdir), ERRORLOG(SPKINSTALL_DELETEFILE));
 								else
-									errorStr->PushBack(cFile->GetFilePointer().Remove(destdir), ERRORLOG_OLD(SPKINSTALL_DELETEFILE_FAIL));
+									errorStr->pushBack(cFile->filePointer().findRemove(destdir), ERRORLOG(SPKINSTALL_DELETEFILE_FAIL));
+							}
+						}
 						cFile->setFilename(fit->filePointer());
 						cFile->SetDisabled(true);
+					}
 						fit->SetDisabled(false);
+					}
+				}
 				// move it to enabled
 				else {
-					if ( !this->_install_checkFileEnable(cFile, fit, destdir.ToString(), fileEnabled, errorStr) ) {
+					if ( !this->_install_checkFileEnable(cFile, fit, destdir, fileEnabled, errorStr) ) {
 						bFailed = true;
 						continue;
+					}
+				}
 				Utils::String fpointer = fit->filePointer();
 				_iLastError = SPKERR_CREATEDIRECTORY;
 				Utils::String dir = CFileIO(fit->filePointer()).dir();
-				dir = dir.findRemove(destdir.ToString());
+				dir = dir.findRemove(destdir);
 				if (!dir.empty() && (dir[0] == '/' || dir[0] == '\\'))
 					dir.erase(0, 1);
 				if ( !_install_createDirectory(Dir, dir, fit, errorStr) ) {
 					bFailed = true;
 					continue;
+				}
-				_install_writeFile(fit, destdir.ToString(), errorStr);
+				_install_writeFile(fit, destdir, errorStr);
+			}
 			ClearError ();
+		}
 		if ( adjustPointer )
 /*
 	Func:   ParseHeader
 	Input:  Header String - string formated directly from the file
 	Return: Boolean - If string is a valid header
 	Desc:   Splits up the main header string to get all required settings
 */
-bool CBaseFile::ParseHeader ( CyString header )
+bool CBaseFile::_parseHeader(const Utils::String &header)
 {
-	if ( !this->CheckHeader(header.GetToken ( 1, ';&apos; ).ToString()) )
+	if ( !this->_checkHeader(header.token(";&quot;, 1)))
 		return false;
-	m_SHeader.fVersion = header.GetToken ( 2, &apos;;&apos; ).ToFloat();
+	m_SHeader.fVersion = header.token(&quot;;&quot;, 2).toFloat();
 	if ( m_SHeader.fVersion > FILEVERSION )
 		return false;
-	m_SHeader.iValueCompression = header.GetToken ( 3, &apos;;&apos; ).ToInt();
+	m_SHeader.iValueCompression = header.token(&quot;;&quot;, 3).toInt();
-	m_SHeader.lValueCompressSize = header.GetToken ( 4, &apos;;&apos; ).ToLong();
+	m_SHeader.lValueCompressSize = header.token(&quot;;&quot;, 4).toLong();
 	return true;
+}
-bool CBaseFile::CheckHeader(const Utils::String header) const
+bool CBaseFile::_checkHeader(const Utils::String header) const
+{
 	if ( header.Compare("BaseCycrow") )
 		return true;
 	return false;
+}
 	Func:   ParseFileHeader
 	Input:  Header String - string formated directly from the file
 	Return: Boolean - If string is a valid header
 	Desc:   Splits up the file header string to get all required settings
 */
-bool CBaseFile::ParseFileHeader ( CyString header )
+bool CBaseFile::_parseFileHeader(const Utils::String &header)
+{
-	if ( header.GetToken ( 1, ';' ) != ";FileHeader" )
+	if (header.token(";", 1) != ";FileHeader")
 		return false;
-	m_SHeader2.iNumFiles = header.GetToken ( 2, &apos;;&apos; ).ToInt();
+	m_SHeader2.iNumFiles = header.token(&quot;;&quot;, 2).toInt();
-	m_SHeader2.lSize = header.GetToken ( 3, &apos;;&apos; ).ToInt();
+	m_SHeader2.lSize = header.token(&quot;;&quot;, 3).toInt();
-	m_SHeader2.lFullSize = header.GetToken ( 4, &apos;;&apos; ).ToInt();
+	m_SHeader2.lFullSize = header.token(&quot;;&quot;, 4).toInt();
-	m_SHeader2.iFileCompression = header.GetToken ( 5, &apos;;&apos; ).ToInt();
+	m_SHeader2.iFileCompression = header.token(&quot;;&quot;, 5).toInt();
-	m_SHeader2.iDataCompression = header.GetToken ( 6, &apos;;&apos; ).ToInt();
+	m_SHeader2.iDataCompression = header.token(&quot;;&quot;, 6).toInt();
 	return true;
+}
 /*
 	Func:   ReadValues
 	Input:  String - values in one long line
 	Desc:   splits the values data into each line to read the data
 */
-void CBaseFile::ReadValues ( CyString values )
+void CBaseFile::_readValues(const Utils::String &values)
+{
 	int num = 0;
-	CyString *lines = values.SplitToken ( &apos;\n', &num );
+	Utils::String *lines = values.tokenise(&quot;\n", &num);
 	for ( int i = 0; i < num; i++ )
-		ParseValueLine ( lines[i].ToString() );
+		ParseValueLine(lines[i]);
 	CLEANSPLIT(lines, num)
+}
 /*
 	Func:   ParseFilesLine
 	Input:  String - single line from a file to set
 	Return: Boolean - returns true if value exists
 	Desc:   Reads the line and assigns the parameters for the file
 */
-bool CBaseFile::ParseFilesLine ( CyString sLine )
+bool CBaseFile::_parseFilesLine(const Utils::String &line)
+{
-	Utils::String line = sLine.ToString();
 	if ( !line.contains(":") )
 		return false;
 	Utils::String command = line.token(":", 1);
 		_sIconExt = line.token (":", 5);
 		m_pIconFile = new C_File ();
 		m_pIconFile->SetDataSize ( size - 4 );
 		m_pIconFile->SetDataCompression ( compression );
 		m_pIconFile->SetUncompressedDataSize ( usize );
 		return true;
 	}
 	time_t time = line.token(":", 5).toLong();
 	bool compressToFile = (line.token(":", 6).toInt() == 1) ? true : false;
 	Utils::String name  = line.token(":", 7);
 	Utils::String dir = line.token(":", 8);
 		Utils::String game = line.token(":", 9);
 		if (game.contains("_"))
+		{
 			unsigned int iGame = game.token("_", 2).toInt();
 			if (iGame)
 				file->setGame(1 << 31 | 1 << iGame);
 			else
 				file->setGame(0);
 		}
 		else
+		{
 			int iGame = game.toInt();
 			if (iGame & (1 << 31))
 				file->setGame(iGame);
 			else if (!iGame)
 				file->setGame(0);
 			else
 				file->setGame(1 << 31 | 1 << iGame);
+		}
 	}
 	if (dir.Compare("NULL")) {
 		dir = Utils::String::Null();
+	}
 	file->setFileType(type);
 	file->SetCreationTime ( time );
 	file->SetName ( name );
 	file->SetDir ( dir );
 	file->SetDataSize ( size - 4 );
 	file->SetUncompressedDataSize ( usize );
 	file->SetShared ( shared );
 	file->SetCompressedToFile ( compressToFile );
 	_addFile(file, true);
 	return true;
 }
 /*
 	Func:   ParseFiles
 	Input:  String - values in one long line
 	Desc:   splits the files data into each line to read the data
 */
-void CBaseFile::ReadFiles ( CyString values )
+void CBaseFile::_readFiles(const Utils::String &values)
 {
 	int num = 0;
-	CyString *lines = values.SplitToken ( &apos;\n', &num );
+	Utils::String *lines = values.tokenise(&quot;\n", &num);
-	for ( int i = 0; i <; num; i++ )
+	for (int i = 0; i <; num; i++)
-		ParseFilesLine ( lines[i] );
+		_parseFilesLine(lines[i]);
 	CLEANSPLIT(lines, num)
 }
 /*
 	Func:   ReadFile
 	Input:  filename - the name of the file to open and read
 			readdata - If falses, dont read the files to memory, just read the headers and values
 	Return: boolean - return ture if acceptable format
 	Desc:   Opens and reads the spk file and loads all data into class
 */
-bool CBaseFile::ReadFile(CyString filename, int readtype, CProgressInfo *progress)
-{
-	return readFile(filename.ToString(), readtype, progress);
-}
 bool CBaseFile::readFile(const Utils::String &filename, int readtype, CProgressInfo *progress)
+{
 	CFileIO File(filename);
 	if ( !File.startRead() ) return false;
 		try {
 			unsigned char *uncompr = new unsigned char[uncomprLen];
 			int err = uncompress ( uncompr, &uncomprLen, readData, m_SHeader.lValueCompressSize );
 			// update the progress for each section
 			if ( iReadType != SPKREAD_ALL && pProgress ) pProgress->UpdateProgress(2, iMaxProgress);
-			if ( err == Z_OK ) this->ReadValues ( CyString ((char *)uncompr) );
+			if ( err == Z_OK ) this->_readValues((char *)uncompr);
 			doneLen = uncomprLen;
 			delete uncompr;
+		}
 		catch (std::exception &e) {
 			CLog::logf(CLog::Log_IO, 2, "CBaseFile::_read_Header() unable to malloc [uncompr], %d (%s)", uncomprLen, e.what());
 		long len = uncomprLen;
 		unsigned char *compr = LZMADecode_C ( readData, m_SHeader.lValueCompressSize, (size_t*)&len, NULL );
 		// update the progress for each section
 		if ( iReadType != SPKREAD_ALL && pProgress ) pProgress->UpdateProgress(2, iMaxProgress);
-		if ( compr ) ReadValues ( CyString ((char *)compr) );
+		if ( compr ) _readValues((char *)compr);
+	}
 	// no compression
 	else
-		ReadValues ( CyString ((char *)readData) );
+		_readValues((char *)readData);
 	delete []readData;
 	return doneLen;
+}
 	unsigned long uncomprLen = (size[0] << 24) + (size[1] << 16) + (size[2] << 8) + size[3];
 	// check for zlib compression
 	if ( m_SHeader.iValueCompression == SPKCOMPRESS_ZLIB ) {
 		if ( uncomprLen < (unsigned long)iDoneLen ) uncomprLen = iDoneLen;
 		try {
 			unsigned char *uncompr = new unsigned char[uncomprLen];
 			int err = uncompress ( uncompr, &uncomprLen, readData, m_SHeader2.lSize );
 			// update the progress for each section
 			if ( iReadType != SPKREAD_ALL && pProgress ) pProgress->UpdateProgress(5, iMaxProgress);
-			if ( err == Z_OK ) ReadFiles ( CyString ((char *)uncompr) );
+			if ( err == Z_OK ) _readFiles((char *)uncompr);
 			delete uncompr;
+		}
 		catch (std::exception &e) {
 			CLog::logf(CLog::Log_IO, 2, "CBaseFile::_read_FileHeader() unable to malloc [uncompr], %d (%s)", uncomprLen, e.what());
 			delete []readData;
+	{
 		long len = uncomprLen;
 		unsigned char *compr = LZMADecode_C ( readData, m_SHeader2.lSize, (size_t*)&len, NULL );
 		// update the progress for each section
 		if ( iReadType != SPKREAD_ALL && pProgress ) pProgress->UpdateProgress(5, iMaxProgress);
-		if ( compr ) ReadFiles ( CyString ((char *)compr) );
+		if ( compr ) _readFiles((char *)compr);
+	}
 	else
-		ReadFiles ( CyString ((char *)readData) );
+		_readFiles((char *)readData);
 	delete []readData;
 	return true;
+}
 bool CBaseFile::readFile(CFileIO &File, int readtype, CProgressInfo *progress)
+{
 	ClearError ();
 	// first read the header
-	if ( !ParseHeader(File.readEndOfLine()) ) return false;
+	if ( !_parseHeader(File.readEndOfLine()) ) return false;
 	if ( readtype == SPKREAD_HEADER ) return true;
 	// update the progress for each section
 	int maxProgress = (readtype == SPKREAD_VALUES) ? 3 : 6;
 	if ( readtype != SPKREAD_ALL && progress ) progress->UpdateProgress(1, maxProgress);
 	long doneLen = 0;
 	// next read the data values for the spk files
 	// update the progress for each section
 	if ( readtype != SPKREAD_ALL && progress ) progress->UpdateProgress(3, maxProgress);
 	if ( readtype == SPKREAD_VALUES ) return true;
 	// next should be the next header
-	if ( !ParseFileHeader(File.readEndOfLine()) ) return false;
+	if ( !_parseFileHeader(File.readEndOfLine()) ) return false;
 	// clear the current file list
 	m_lFiles.clear(true);
 	if ( _pTextDB ) {
 		delete _pTextDB;
 		_pTextDB = NULL;
 	}
 	// update the progress for each section
 	if ( readtype != SPKREAD_ALL && progress ) progress->UpdateProgress(4, maxProgress);
 	if ( m_SHeader2.lSize ) this->_read_FileHeader(File, readtype, maxProgress, doneLen, progress);
 	// file mismatch
 	long numfiles = m_lFiles.size();
 		_iLastError = SPKERR_FILEMISMATCH;
 		return false;
+	}
 	// update the progress for each section
 	if ( readtype != SPKREAD_ALL && progress )	progress->UpdateProgress(6, maxProgress);
 	if ( readtype == SPKREAD_ALL ) {
 		int fileCount = 2;
 		if ( m_pIconFile ) m_pIconFile->readFromFile(File, m_pIconFile->GetDataSize());
+	}
 	return false;
+}
-Utils::String CBaseFile::CreateValuesLine () const
+Utils::String CBaseFile::createValuesLine () const
+{
 	Utils::String values("Name: ");
 	values += this->name() + "\n";
 	values += "Author: " + this->author() + "\n";
 	values += "Version: " + this->version() + "\n";
 		Utils::String desc = this->description();
 		desc = desc.findReplace("<newline>", "<br>");
 		desc = desc.findReplace("\n", "<br>");
 		desc.remove('\r');
 		values += "Desc: " + desc + "\n";
 	}
 	for ( CListNode<SGameCompat> *gc = m_lGames.Front(); gc; gc = gc->next() ) {
 		if ( !gc->Data()->sVersion.empty() )
 			values += Utils::String("GameCompatExact: ") + (long)gc->Data()->iGame + " " + gc->Data()->sVersion + "\n";
 		else
 			values += Utils::String("GameCompat: ") + (long)gc->Data()->iGame + " " + (long)gc->Data()->iVersion + "\n";
+	}
-	if ( m_bSigned )
+	if (computeSigned(true))
 		values += "Signed\n";
 	for ( int j = 0; j < 2; j++ ) {
 		const CInstallText *text;
 		Utils::String textStart;
 /*
 	Func:   WriteFile
 	Input:  filename - The filename of the spk file to write to
 	Desc:   Writes the data to an spk file
 */
-bool CBaseFile::WriteFile ( CyString filename, CProgressInfo *progress )
+bool CBaseFile::writeFile(const Utils::String &filename, CProgressInfo *progress) const
+{
 	CFileIO File(filename);
-	if ( File.startWrite() ) return WriteData(File, progress);
+	if ( File.startWrite() ) return writeData(File, progress);
 	return false;
+}
-bool CBaseFile::WriteHeader(CFileIO &file, int valueheader, int valueComprLen)
+bool CBaseFile::writeHeader(CFileIO &file, int valueheader, int valueComprLen) const
+{
 	return file.write("BaseCycrow;%.2f;%d;%d\n", FILEVERSION, valueheader, valueComprLen);
+}
-bool CBaseFile::WriteData(CFileIO &file, CProgressInfo *progress )
+bool CBaseFile::writeData(CFileIO &file, CProgressInfo *progress ) const
+{
 	int valueheader = m_SHeader.iValueCompression, fileheader = m_SHeader.iValueCompression;
 	if ( valueheader == SPKCOMPRESS_7ZIP )
 		valueheader = SPKCOMPRESS_ZLIB;
 	if ( fileheader == SPKCOMPRESS_7ZIP )
 		fileheader = SPKCOMPRESS_ZLIB;
 	// get the script values
-	this->UpdateSigned(true);
-	CyString values = this->CreateValuesLine();
+	Utils::String values = this->createValuesLine();
 	// compress the values
-	int valueUncomprLen = (int)values.Length();
+	int valueUncomprLen = (int)values.length();
 	unsigned long valueComprLen = 0;
 	unsigned char *valueCompr = NULL;
 	bool compressed = false;
 	if ( valueheader == SPKCOMPRESS_ZLIB )
+	{
 			valueComprLen = 200;
 		else if ( valueComprLen < 1000 )
 			valueComprLen *= 2;
 		valueCompr = (unsigned char *)calloc((unsigned int)valueComprLen, 1);
-		int err = compress ( (unsigned char *)valueCompr, &valueComprLen, (const unsigned char *)values.c_str(), (unsigned long)values.Length(), 0 );
+		int err = compress ( (unsigned char *)valueCompr, &valueComprLen, (const unsigned char *)values.c_str(), (unsigned long)values.length(), 0 );
 		if ( err == Z_OK )
 			compressed = true;
+	}
 	if ( !compressed )
 		memcpy ( valueCompr, values.c_str(), valueComprLen );
 		valueheader = SPKCOMPRESS_NONE;
+	}
 	// write the main header to the file
-	if ( !this->WriteHeader(file, valueheader, valueComprLen) )	return false;
+	if ( !this->writeHeader(file, valueheader, valueComprLen) )	return false;
 	// write the compressed data to file
 	file.put(static_cast<unsigned char>(valueUncomprLen >> 24));
 	file.put(static_cast<unsigned char>(valueUncomprLen >> 16));
 	file.put(static_cast<unsigned char>(valueUncomprLen >> 8));
 	file.write(valueCompr, valueComprLen);
 	free ( valueCompr );
 	// now compress the files header
 	// create the files values
+	SSPKHeader2 header;
-	Utils::String files = createFilesLine (true, progress);
+	Utils::String files = createFilesLine(&header, progress);
 	// compress the files values
 	long fileUncomprLen = (long)files.length(), fileComprLen = fileUncomprLen;
 	unsigned char *fileCompr = NULL;
 	compressed = false;
 		memcpy ( fileCompr, files.c_str(), fileComprLen );
 		fileheader = SPKCOMPRESS_NONE;
+	}
 	// now write the file header
-	m_SHeader2.lSize = fileComprLen;
+	header.lSize = fileComprLen;
-	file.write("FileHeader;%d;%ld;%ld;%d;%d\n", m_SHeader2.iNumFiles, m_SHeader2.lSize, m_SHeader2.lFullSize, fileheader, m_SHeader2.iDataCompression);
+	file.write("FileHeader;%d;%ld;%ld;%d;%d\n", header.iNumFiles, header.lSize, header.lFullSize, fileheader, header.iDataCompression);
 	file.put(static_cast<unsigned char>(fileUncomprLen >> 24));
 	file.put(static_cast<unsigned char>(fileUncomprLen >> 16));
 	file.put(static_cast<unsigned char>(fileUncomprLen >> 8));
 	file.put(static_cast<unsigned char>(fileUncomprLen));
+			}
 			if ( progress ) progress->IncDone((int)writeSize);
+		}
+	}
-	_changed();
 	return true;
+}
-bool CBaseFile::ExtractFile(C_File *file, CyString dir, bool includedir, CProgressInfo *progress)
-{
-	return extractFile(file, dir.ToString(), includedir, progress);
-}
 bool CBaseFile::extractFile(C_File *file, const Utils::String &dir, bool includedir, CProgressInfo *progress)
+{
 	if (ReadFileToMemory(file))
+	{
 		// now finally, uncompress the file
+		{
 			// attempt a file decompress
 			if (file->GetCompressionType() == SPKCOMPRESS_7ZIP)
+			{
 				if (file->UncompressToFile(dir, this, includedir, progress))
 					return true;
 			}
 			return false;
 		}
 		if (!file->writeToDir(dir, this, includedir, Utils::String::Null(), data, len))
 			return false;
 		return true;
 	}
 	else
 		return false;
+}
 bool CBaseFile::extractFile(C_File *file, const Utils::String &dir, unsigned int game, const Utils::CStringList &gameAddons, bool includedir, CProgressInfo *progress)
+{
 	if (ReadFileToMemory(file))
 		CDirIO Dir(dir);
 		Utils::String addonDir;
 		if (file->isFileInAddon())
+		{
 			int addonGame = file->getForSingleGame();
 			if (!addonGame) addonGame = game;
 			if (addonGame > 0)
 				addonDir = gameAddons.findString(Utils::String::Number(addonGame));
 		}
 		if (!addonDir.empty())
 			Dir.cd(addonDir);
 		// create directory first
 		Dir.create(file->getDirectory(this));
 		// now finally, uncompress the file
 		long len = 0;
 		unsigned char *data = file->UncompressData(&len, progress);
 		if (!data)
+		{
+			}
 			return false;
+		}
 		if (!file->writeToDir(Dir.dir(), this, includedir, Utils::String::Null(), data, len))
 			return false;
 		return true;
+	}
 	else
 		return false;
-}
-bool CBaseFile::ExtractFile(int filenum, CyString dir, bool includedir, CProgressInfo *progress)
-{
-	// invalid valus
-	if (filenum < 0)
-		return false;
-	// out of range
-	if (filenum > m_lFiles.size())
-		return false;
-	// get the file pointer
-	C_File *file = m_lFiles.Get(filenum);
-	return extractFile(file, dir.ToString(), includedir, progress);
+}
 bool CBaseFile::extractFile(int filenum, const Utils::String &dir, unsigned int game, const Utils::CStringList &gameAddons, bool includedir, CProgressInfo *progress)
+{
 	// invalid valus
 	if (filenum > m_lFiles.size())
 		return false;
 	// get the file pointer
 	C_File *file = m_lFiles.Get(filenum);
-	return ExtractFile(file, dir, includedir, progress);
+	return extractFile(file, dir, includedir, progress);
+}
 bool CBaseFile::extractAll(const Utils::String &dir, int game, const Utils::CStringList &gameAddons, bool includedir, CProgressInfo *progress)
+{
 	// no file to read from
 	delete File;
 	return true;
+}
-bool CBaseFile::UpdateSigned (bool updateFiles)
+bool CBaseFile::computeSigned(bool updateFiles) const
+{
-	m_bSigned = true;
-	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
+	for (CListNode<C_File>* node = m_lFiles.Front(); node; node = node->next())
+	{
-		C_File *file = node->Data();
+		C_File* file = node->Data();
-		if ( updateFiles )
+		if (updateFiles)
 			file->UpdateSigned();
 		// extra, text, soundtrack, readmes and screen files do not require a modified game directly
-		if ( (file->GetFileType() == FILETYPE_EXTRA) || (file->GetFileType() == FILETYPE_TEXT) || (file->GetFileType() == FILETYPE_SOUND) || (file->GetFileType() == FILETYPE_SCREEN) || (file->GetFileType() == FILETYPE_README) )
+		if ((file->GetFileType() == FILETYPE_EXTRA) || (file->GetFileType() == FILETYPE_TEXT) || (file->GetFileType() == FILETYPE_SOUND) || (file->GetFileType() == FILETYPE_SCREEN) || (file->GetFileType() == FILETYPE_README))
 			continue;
 		// mods and maps always need modified game
-		else if ( (file->GetFileType() == FILETYPE_MOD) || (file->GetFileType() == FILETYPE_MAP) )
+		else if ((file->GetFileType() == FILETYPE_MOD) || (file->GetFileType() == FILETYPE_MAP))
-		{
-			m_bSigned = false;
+			return false;
-			break;
-		}
 		// else should be a script file, script or uninstall type
 		// all scripts must be signed, if any are not, then no signed status
-		if ( !file->IsSigned () )
+		if (!file->IsSigned())
-		{
-			m_bSigned = false;
+			return false;
-			break;
-		}
+	}
+	return true;
+}
+bool CBaseFile::updateSigned(bool updateFiles)
+{
+	m_bSigned = computeSigned(updateFiles);
 	return m_bSigned;
+}
 bool CBaseFile::IsPackageNeeded(const Utils::String &scriptName, const Utils::String &author)
+{
 	for ( CListNode<SNeededLibrary> *node = m_lNeededLibrarys.Front(); node; node = node->next() )
+	{
 		if ( node->Data()->iGame == 0 )
 			foundAll = true;
 		else if ( node->Data()->iGame == game ) { // now check the version
 			if ( node->Data()->sVersion.empty() ) {
 				if (node->Data()->sVersion.compareVersion(sVersion) == COMPARE_OLDER)
 					return false;
 				return true;
+			}
 			else {
 				if ( node->Data()->iVersion > iVersion )
 					return false;
 				return true;
 Utils::String CBaseFile::fileSizeString() const { return SPK::GetSizeString ( this->fileSize() ); }
 // used for a multiple spk file
 unsigned char *CBaseFile::CreateData(size_t *size, CProgressInfo *progress)
+{
-	if ( this->WriteFile("temp.dat", progress) ) {
+	if ( this->writeFile("temp.dat", progress) ) {
 		CFileIO File("temp.dat");
 		File.setAutoDelete(true);
 		return File.readAll(size);
+	}
 	return NULL;
+	}
 	return Utils::String::Number((long)error);
+}
-bool CBaseFile::SaveToArchive(CyString filename, int game, const CGameExe *exes, CProgressInfo *progress)
-{
-	return saveToArchive(filename.ToString(), game, exes, progress);
-}
 bool CBaseFile::saveToArchive(const Utils::String &filename, int game, const CGameExe *exes, CProgressInfo *progress)
+{
 	CDirIO Dir(CFileIO(filename).dir());
 	if (!Dir.exists())
 		Dir.create();

Subversion Repositories spk

(root)/libspk/src/BaseFile.cpp – Rev 172 → 175