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

+{
 	m_bDontDeleteData = false;
 	m_bUsedMalloc = false;
 	m_sData = NULL;
 	Reset ();
-	SetFilename(filename);
+	setFilename(filename);
+}
 C_File::~C_File()
+{
 	DeleteData ();
 	Return: Directory String
 	Desc:	Returns the directory the file goes into, based on m_sDir and Filetype
 */
 CyString C_File::GetDirectory ( CBaseFile *file )
+{
-	if ( IsFakePatch() )
-		return "";
-	if ( (m_iFileType == FILETYPE_MOD) && (m_sDir == "Patch") )
-		return "PluginManager/Patch";
-	if ( (!m_sDir.Empty()) && (m_iFileType != FILETYPE_README) && m_sDir != "." )
-	{
-		CyString dir = m_sDir.FindReplace ( "\\", "/" );
-		if ( file )
-		{
-			dir = dir.FindReplace ( "$scriptname", file->GetNameValidFile() );
-			dir = dir.FindReplace ( "$scriptauthor", CyString(file->author()) );
-		}
-		return dir;
-	}
-	switch ( m_iFileType )
-	{
-		case FILETYPE_SCRIPT:
-			return "Scripts";
-		case FILETYPE_TEXT:
-			return "T";
-		case FILETYPE_README:
-		{
-			if ( file )
-				return CyString("PluginManager/Readme/") + file->GetNameValidFile();
-			return "PluginManager/Readme";
-		}
-		case FILETYPE_MAP:
-			return "Maps";
-		case FILETYPE_MOD:
-//			if ( (file) && (file->IsPatch()) )
-//				return "Mods/Patch";
-			return "Mods";
-		case FILETYPE_UNINSTALL:
-			return "PluginManager/Uninstall";
-		case FILETYPE_SOUND:
-			if ( CFileIO(m_sName).CheckFileExtension("wav") )
-				return "s";
-			return "Soundtrack";
-		case FILETYPE_EXTRA:
-			return "PluginManager/Extras";
-		case FILETYPE_SCREEN:
-			return "loadscr";
-		case FILETYPE_ADVERT:
-			return "PluginManager/Graphics";
-		case FILETYPE_MISSION:
-			return "Director";
+	return getDirectory(file);
-	}
-	return NullString;
+}
 Utils::String C_File::getDirectory(CBaseFile *file) const
+{
 	if (IsFakePatch())
 			dir = dir.findReplace("$scriptauthor", file->author());
+		}
 		return dir;
+	}
-	return GetDirectory(m_iFileType, m_sName.ToString(), file);
+	return C_File::GetDirectory(m_iFileType, _sName, file);
+}
 CyString C_File::GetNameDirectory(CBaseFile *file)
+{
-	CyString dir = GetDirectory(file);
+	return getNameDirectory(file);
-	if (!dir.Empty())
-		dir += "/";
-	return CyString(dir + m_sName).FindReplace("\\", "/").FindReplace("//", "/");
+}
 Utils::String C_File::getNameDirectory(CBaseFile *file) const
+{
 	Utils::String dir = getDirectory(file);
 	if (!dir.empty())
 		dir += "/";
-	return (dir + m_sName.ToString()).findReplace("\\", "/").findReplace("//", "/");
+	return (dir + _sName).findReplace("\\", "/").findReplace("//", "/");
+}
 /*
 	Func:	Reset()
 	Desc:	Resets the file data, clears all data inside
 		case FILETYPE_SCREEN:
 		case FILETYPE_ADVERT:
 		case FILETYPE_SOUND:
 		case FILETYPE_BACKUP:
 			m_bSigned = true;
 			break;
 		// mods, maps are always not signed
 		case FILETYPE_MOD:
 		case FILETYPE_MAP:
 		case FILETYPE_SHIPOTHER:
 		case FILETYPE_SHIPMODEL:
 		case FILETYPE_SHIPSCENE:
 		case FILETYPE_COCKPITSCENE:
 			m_bSigned = false;
 			break;
 		// extra files are a special case
 		case FILETYPE_EXTRA:
 			if ( this->GetDir().Left(6).Compare("extras") )
 				m_bSigned = true;
 			else
 		// 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;
+	}
+{
 	if ( m_iFileType != FILETYPE_TEXT )
 		return -1;
 	if ( filename.Empty() )
-		filename = m_sName;
+		filename = _sName;
 	CyString textid;
 	if ( filename.IsIn("-L") || filename.IsIn("-l") )
 		textid = filename.GetToken("-", 1, 1);
 	else
 		textid = filename.GetToken(".", -1).Right(4);
 	if ( textid.IsNumber() ) return textid.ToInt();
 	return -1;
+}
-bool C_File::IsAutoTextFile ()
+bool C_File::isAutoTextFile ()
+{
 	int textid = GetTextFileID();
 	if ( textid == -1 ) return false;
 	if ( textid <= 3 )
 		return true;
 	// check for original name
 	if ( !_sOriginalName.empty() )
 bool C_File::IsFakePatch() const
+{
 	if (m_iFileType != FILETYPE_MOD)
 		return false;
-	Utils::String name = m_sName.ToString();
+	Utils::String name = _sName;
 	if (name.token(".", 1).toLong())
 		return true;
 	if (name.left(10) == "FakePatch_")
 		return true;
 	return false;
 }
 /*
 ########################################################################################################################
 ####################################             File Pointer Functions             ####################################
 ########################################################################################################################
 */
 /*
 	Func:	SetFilename
 	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
 void C_File::setFilename(const Utils::String &filename)
+{
 	Utils::String file = filename.findReplace ( "\\", "/" ).findReplace ( "//", "/" );
 	_sFullDir = file.tokens("/", 1, -2);
-	m_sName = file.token("/", -1);
+	_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(filePointer());
 }
 bool C_File::ReadFromFile(CyString filename)
+{
 	return readFromFile(filename.ToString());
+}
 bool C_File::readFromFile(const Utils::String filename)
 		m_iLastError = SPKERR_FILEOPEN;
 		return false;
+	}
 	m_iDataCompression = SPKCOMPRESS_NONE;
 	m_lDataSize = m_lUncomprDataSize = m_lSize;
 	DeleteData ();
 	m_sData = File.readAll((size_t *)&m_lSize);
 	if ( !m_sData ) {
 		m_iLastError = SPKERR_MALLOC;
+{
 	Utils::String fullfile = _sFullDir;
 	if ( !fullfile.empty() )
 		fullfile += "/";
-	if ( !m_sName.Empty() )
+	if ( !_sName.empty() )
-		fullfile += m_sName.ToString();
+		fullfile += _sName;
 	return fullfile;
+}
 bool C_File::isExternalFile() const
+	{
 		sData = sData.Right(sData.Length() - pos);
 		pos = sData.FindPos("<signature>", 0);
 		int endpos = sData.FindPos("</signature>", 0);
 		if ( pos != -1 && endpos != -1 )
 		{
 			m_sSignature = sData.Mid(pos + 12, endpos - (pos + 12) + 1);
 			m_sSignature = m_sSignature.Remove('\n').Remove('\r');
+		}
+	}
 	if ( deleteData )
 		DeleteData();
 }
 /*
 	Func:	ReadFileSize()
 	Return:	Returns the file size read
 	Desc:	Opens the file and seeks to the end
 	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
 	return false;
+}
 int C_File::ReadScriptVersion ()
 {
 	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(filePointer());
 		if ( File.startRead() ) {
+{
 	if ( file->GetFileType() != m_iFileType )
 		return false;
 	if ( file->GetDir() != m_sDir )
 		return false;
-	if ( file->GetName() != m_sName )
+	if ( file->name() != _sName )
+	{
 		// check if the base name matches, but only for certain file extensions
 		if (file->shouldCheckBaseName())
+		{
 			Utils::String baseName = CFileIO(file->GetName()).dir() + "/" + CFileIO(file->GetName()).baseName();
-			Utils::String compareBaseName = CFileIO(m_sName).dir() + "/" + CFileIO(m_sName).baseName();
+			Utils::String compareBaseName = CFileIO(_sName).dir() + "/" + CFileIO(_sName).baseName();
 			if (baseName.Compare(compareBaseName))
 				return true;
+		}
 		return false;
+	}
 	return true;
+}
 /*
 ########################################################################################################################
 ####################################              Compression Functions             ####################################
 ########################################################################################################################
 */
 bool C_File::CompressFile ( CProgressInfo *progress )
+{
 	Utils::String file = this->filePointer();
 	if ( !CFileIO(this->filePointer()).exists() )
 	{
 		if ( !this->writeToFile("tempuncompr.dat", m_sData, m_lDataSize) )
 			return false;
 		file = "tempuncompr.dat";
+	}
 	return ret;
+}
 bool C_File::ChangeCompression ( int compressionType, CProgressInfo *progress )
 {
 	// no data to try to compress
 	if ( (!m_sData) || (!m_lDataSize) )
 		return false;
 	// laready compressed to correct type
 	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 )
 	{
 		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 )
 		{
 			DeleteData ();
 			m_iDataCompression = SPKCOMPRESS_NONE;
 			m_lDataSize = uncomprLen;
 			m_sData = uncompr;
 			return true;
+		}
 			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;
 			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 )
+		{
+		}
 		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;
 bool C_File::writeFilePointer(unsigned char *cData, long len)
+{
 	return writeToFile(filePointer(), cData, 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;
+	}
 	Utils::String fulldir = fullfile.tokens("/", 1, -2);
 	if (!fulldir.empty())
+	{
 		if (!CDirIO(fulldir).Create())
 			return false;
 	}
 	return writeToFile(fullfile, data, len);
+}
 CyString C_File::GetDataSizeString ()
 	return FILETYPE_UNKNOWN;
+}
-CyString FormatErrorString(int error, CyString rest)
+Utils::String FormatErrorString(int error, const Utils::String &rest)
+{
 	int max = 0;
-	CyString *args = 0;
+	Utils::String *args = 0;
-	if ( !rest.Empty() )
+	if ( !rest.empty() )
-		args = rest.SplitToken(&apos;~&apos;, &max);
+		args = rest.tokenise(&quot;~&quot;, &max);
-	CyString errorStr;
+	Utils::String errorStr;
 	switch ( error )
+	{
 		case SPKINSTALL_CREATEDIRECTORY:
 			errorStr = "Creating Directory: %1";
 			break;
 		case SPKINSTALL_ORPHANED_FAIL:
 			errorStr = "Unable to remove Orphaned File: %1";
 			break;
+	}
-	CyString ret = errorStr.Args(args, max);
+	Utils::String ret = errorStr.args(args, max);
 	CLEANSPLIT(args, max)
 	return ret;
+}
 	// create data buffer
 	size_t *uncomprLenSize = (size_t*)(newData + (datasize - 4));
 	unsigned long uncomprLen = (unsigned long)*uncomprLenSize;
 	if ( uncomprLen > (datasize * 100) )
 	{
 		if ( tempData ) delete []tempData;
 		*len = 0;
 		return NULL;
 	}
 	unsigned char *uncompr = new unsigned char[uncomprLen + 1];
 	if ( !uncompr ) {
 		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];
 	if ( flag & GZ_FLAG_EXTRA )
+	{
 		size_t xlen = *((short int*)(buf));
 		buf += xlen;
 	}
 	if ( flag & GZ_FLAG_FILENAME )
+	{
 		char *origname = (char*)(buf);
 		buf += strlen (origname) + 1;
+	}
 		while ( data[pos2] != '<' && pos2 > max ) pos2--;
 		if ( data[pos2] != '<' ) break;
 		memcpy(tag, data + pos2, pos - pos2);
 		tag[pos - pos2] = '\0';
 		Utils::String sTag(tag);
 		if ( sTag.Compare("</signature") || sTag.Compare("<signature") ) return true;
 		if ( sTag.Compare("</codearray") || sTag.Compare("<codearray") ) return false;
 		pos = pos2 - 1;
+	}
+}
 CyString C_File::GetBaseName ()
+{
 	// remove any directory
-	CyString file = m_sName.GetToken ( "/&quot;, m_sName.NumToken ( '/&apos; ) );
+	Utils::String file = _sName.token(&quot;/&quot;, -1);
 	// remove file extension
-	file = file.GetToken ( ".", 1, file.NumToken ( '.' ) - 1 );
-	return file;
+	return file.token(".", -1);
+}
 void C_File::CopyData(C_File *oldFile, bool includeData)
+{
 	SetFilename(oldFile->GetFullFilename());
 float GetLibraryVersion() { return (float)LIBRARYVERSION; }
 float GetFileFormatVersion() { return (float)FILEVERSION; }
 CyString C_File::ChangeFileExt(CyString ext)
+{
+	_sName = CFileIO(_sName).changeFileExtension(ext.ToString());
+	return _sName;
+}
+Utils::String C_File::fileExt() const
+{
+	return _sName.token(".", -1);
+}
+const Utils::String &C_File::changeFileExt(const Utils::String &ext)
+{
-	m_sName = CFileIO(m_sName).ChangeFileExtension(ext);
+	_sName = CFileIO(_sName).changeFileExtension(ext);
-	return m_sName;
+	return _sName;
+}
 bool C_File::CheckPackedExtension()
+{
 	CyString ext = this->GetFileExt();
 	return false;
+}
 bool C_File::shouldCheckBaseName() const
+{
-	Utils::String ext = CFileIO(m_sName).extension();
+	Utils::String ext = CFileIO(_sName).extension();
 	if (ext == "xml" || ext == "txt" || ext == "pck")
 		return true;
 	if (ext == "bod" || ext == "bob" || ext == "pbb" || ext == "pbd")
 		return true;
 	return false;
 			if (!fullfile.empty())
 				fullfile += "/";
 			fullfile += d;
+		}
+	}
-	if (!m_sName.Empty())
+	if (!_sName.empty())
+	{
 		if (!fullfile.empty())
 			fullfile += "/";
-		fullfile += m_sName.ToString();
+		fullfile += _sName;
+	}
 	fullfile = fullfile.findReplace("\\", "/");
 	return fullfile;
+}

Subversion Repositories spk

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