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

+}
 CBaseFile *CPackages::openPackage(const Utils::WString &file, int *error, CProgressInfo *progress, int readtype, int flags)
+{
 	int check = checkOpenPackage(file, error);
-	if ( *error == -1 )
+	if (*error == -1)
 		return NULL;
 	CBaseFile *installFile = 0;
 	if ( progress )
+				{
 					delete installFile;
 					return NULL;
+				}
 				break;
+			}
+			// try and open as archive
+			else if(CFileIO(file).isFileExtension(L"spk"))
+			{
+				if (_check_archive_fromZip(file))
+				{
+					installFile = createFromArchive(file, true);
+					if (installFile)
+						return installFile;
+				}
+			}
 			*error = INSTALLERR_INVALID;
 			return NULL;
 		case SPKFILE_BASE:
 			installFile = new CBaseFile();
  * Any directories left empty when disabling files are then removed
+ *
  * param: package	- Package file to be disabled
  * param: errors	- A string list used to add the status as it progresses, used in debugging output
  * param: progress	- The progress class, updates the progress of the current disabling.  Needs a divered class to report the progress somewhere
  *
  * return: boolean, true if there was no errors, otherwise false
  */
 bool CPackages::disablePackage(CBaseFile *package, Utils::WStringList *errors, CProgressInfo *progress )
+{
 	// if already disabled, just skip
 	if ( !package->IsEnabled() )
 		return true;
 	m_lDisableList.clear();
 	if ( this->PrepareDisablePackage(package) )
 		return this->disablePreparedPackages(errors, progress);
 	return false;
 }
 /**
  * Find a Package
+ *
  * Finds a matching package so we can find if one is already installed
+ *
+{
 	return findNextPackageWithFile(NULL, f);
+}
 CBaseFile *CPackages::findNextPackageWithFile(CBaseFile *p, C_File *f) const
 {
 	bool startCheck = (p) ? false : true;
 	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
+	{
 		if ( startCheck )
+		{
 			if ( node->Data()->IsFileAdded(f) )
 				return node->Data();
+		}
 		else if ( p == node->Data() )
 			startCheck = true;
 	}
 	return NULL;
 }
 /**
  * Find a File
+ *
  * Searches for a file matching the filetype and filename
  * Optional dir is used for extras files
 		C_File *f = node->Data();
 		if ( f->GetFileType() != filetype )
 			continue;
 		if ( !f->filename().Compare(filename) )
 			continue;
 		if ( !dir.empty() && f->dir().Compare(dir) )
 			continue;
 		return f;
+	}
 	return NULL;
+}
 CArchiveFile *CPackages::findArchivePackage(const Utils::WString &name) const
 {
 	// interate through all packages
 	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
 	{
 		CBaseFile *file = node->Data();
 		// only look for archive packages
 		if ( file->GetType() != TYPE_ARCHIVE )
 			continue;
 		if ( file->GetType() != TYPE_SPK )
 			continue;
 		// now compare the name and author, "Compare" is a non case senseative check, opposed to ==.
 		if ( file->name().Compare(name) && file->author().Compare(author) )
 			return file;
+	}
 	// nothing found
 	return 0;
+}
+		{
 			SNeededLibrary* nl = node->Data();
 			if (!checkInstalledDependacy((nl->sName.Compare(L"<package>")) ? p->name() : nl->sName, (nl->sAuthor.Compare(L"<author>")) ? p->author() : nl->sAuthor, nl->sMinVersion, (nl->sName.Compare(L"<package>")) ? false : onlyEnabled, (nl->sName.Compare(L"<package>")) ? false : includePrepared))
+			{
 				const SAvailablePackage *available = findAvailablePackage((nl->sName.Compare(L"<package>")) ? p->name() : nl->sName, (nl->sAuthor.Compare(L"<author>")) ? p->author() : nl->sAuthor);
 				if (available)
 					list.push_back(available);
 				++count;
 			}
 		}
+	}
 	if (p->GetType() == TYPE_SPK)
+	{
 		CSpkFile* spk = (CSpkFile*)p;
 			if (!found)
+			{
 				const SAvailablePackage* available = findAvailablePackage(spk->otherName(), spk->otherAuthor());
 				if (available)
 					list.push_back(available);
 				++count;
+			}
+		}
+	}
 	return count;
+						}
+					}
+				}
 				else
 					found = false;
 			}
 			if ( !found )
+			{
 				if ( list )
 					list->pushBack(spk->otherName(), spk->otherAuthor());
+	}
 	m_lInstallList.RemoveEmpty();
 	return count;
 }
 /**
  * Remove uninstall file
+ *
  * Removes a single uninstall file
  */
 bool CPackages::removeUninstallFile(C_File *file, Utils::WStringList *errors)
 	CFileIO fio(file->filePointer());
 	if ( fio.exists() )
+	{
 		if ( fio.remove() ) {
 			this->addLogEntry(SPKINSTALL_UNINSTALL_REMOVE, file->getNameDirectory(NULL), errors);
 			return true;
 		}
 		else if ( errors )
 			this->addLogEntry(SPKINSTALL_UNINSTALL_REMOVE_FAIL, file->getNameDirectory(NULL), errors);
+	}
 	return false;
  * Remove unused shared file
+ *
  * Removes a single file
  */
 bool CPackages::removeSharedFile(C_File *file, Utils::WStringList *errors)
 {
 	CFileIO fio(file->filePointer());
 	if ( fio.exists() )
+	{
 		if ( fio.remove() ) {
 			this->addLogEntry(SPKINSTALL_SHARED, file->getNameDirectory(NULL), errors);
 			continue;
 		if (removeSharedFile(file, errors) )
 			++done;
 		node->ChangeData(NULL);
 	}
 	m_lFiles.RemoveEmpty();
 	return done;
+}
 /**
  * Any Unused Shared
 		// only do ones that are no longer needed
 		if ( file->getUsed() )
 			continue;
 		return true;
 	}
 	return false;
 }
 void CPackages::shuffleTextFiles(Utils::WStringList *errors)
+{
 	for ( CListNode<C_File> *node = m_lFiles.Front(); node; node = node->next() )
+	{
 		C_File *f = node->Data();
 		// only do files that are enabled
 		if ( f->IsDisabled() )
 			continue;
 		if ( f->GetFileType() != FILETYPE_TEXT )
 			continue;
 		// check if the file is an auto text file
 		if ( !f->isAutoTextFile() )
 			continue;
 		// we need to rename it
 		int current = findNextTextFile();
 		if ( current < f->textFileID() )
+		{
 			CFileIO moveFile(f->filePointer());
 		if (!p->AnyFileType(FILETYPE_MOD)) continue;
 		if (p->AnyDependacies())
+		{
 			for (SNeededLibrary* nl = p->GetNeededLibraries()->First(); nl; nl = p->GetNeededLibraries()->Next())
 			{
 				auto package = findPackage(nl->sName, nl->sAuthor);
 				if (package)
+				{
 					packagesBefore.insert(package);
 					packagesAfter[p].insert(package);
 			for (auto itr = list.begin(); itr != list.end(); itr++)
+			{
 				auto package = findPackage((*itr)->str, (*itr)->data);
 				if (package)
 					packagesAfter[package].insert(p);
 			}
+		}
 		if (!p->getFakePatchAfterOrder().empty())
+		{
 			auto& list = p->getFakePatchAfterOrder();
 			for (auto itr = list.begin(); itr != list.end(); itr++)
 				if (findItr != addList.end())
+				{
 					auto checkItr = std::find(addTo.begin(), addTo.end(), p);
 					if(checkItr == addTo.end())
 						addTo.push_back(p);
 				}
 			}
 		}
 		// now add all the others
 		for (auto itr = addList.begin(); itr != addList.end(); itr++)
+		{
 			auto checkItr = std::find(addTo.begin(), addTo.end(), *itr);
 						lowestFile = file;
 					else
+					{
 						if ( file->baseName().toInt() < lowestFile->baseName().toInt() )
 							lowestFile = file;
 					}
 				}
 				if ( !lowestFile ) // no more files ?
 					break;
 				// check its filename, it might already be in the correct place
 					shufflePatchTo(lowestFile, lowest, errors);
+				}
 				doneList.push_back(lowestFile); // we've done this file now
 				lowest++; // move up the lowest ready for the next patch
 			}
 		}
 	}
 	// now lets shuffle the rest
 	// now find any packages with greater fake patchs and fill the gaps
+	std::vector<C_File*> fakepatches;
-	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 *f = node->Data();
+		C_File* f = node->Data();
 		// already done?
-		if ( doneList.FindData(f) )
+		if (doneList.FindData(f))
 			continue;
 		// only do files that are enabled
-		if ( f->IsDisabled() )
+		if (f->IsDisabled())
 			continue;
 		// check if the file is a fake patch
-		if ( !f->IsFakePatch() )
+		if (!f->IsFakePatch())
 			continue;
 		// we only want cat and dat files, all fake patchs should be, but incase theres an error in the package somewhere we can check
 		if (!f->checkFileExt(L"cat"))
 			continue;
+		bool added = false;
+		int num = f->baseName().toInt();
+		for (auto itr = fakepatches.begin(); itr != fakepatches.end(); itr++)
+		{
+			int checkNum = (*itr)->baseName().toInt();
+			if (num < checkNum)
+			{
+				fakepatches.insert(itr, f);
+				added = true;
+				break;
+			}
+		}
+		if (!added)
+			fakepatches.push_back(f);
+	}
+	for(auto itr = fakepatches.begin(); itr != fakepatches.end(); itr++)
+	{
 		// now lets check if its greater than our gap
 		int check = findNextFakePatch();
-		int patchNum = f->filename().token(L".", 1).toInt();
+		int patchNum = (*itr)->filename().token(L".", 1).toInt();
 		if ( patchNum <= check )
 			continue;
-		shufflePatchTo(f, check, errors);
+		shufflePatchTo(*itr, check, errors);
+	}
+}
 void CPackages::shufflePatchTo(C_File *file, int to, Utils::WStringList *errors)
+{
 	return lowest;
+}
 int CPackages::findLastFakePatch(int start, const Utils::WString &dir) const
 {
 	CDirIO Dir((dir.empty()) ? m_sCurrentDir : dir);
 	int check = start;
 	while ( check > 0 )
+	{
 		Utils::WString checkStr = Utils::WString::PadNumber(check, 2);
 		// check if a cat file exists
 		if ( !Dir.exists(checkStr + L".cat") )
+		{
 			// it doen't, check if theres a dat file (incase of package error)
 			if ( !Dir.exists(checkStr + L".dat") )
 				break;
+		}
 		--check;
 	}
 	return check;
 }
 /**
  * Find next fake patch
+ *
  * Searching for the next gap in patches, starting with 01.cat to 99.cat
 	int check = start;
 	while ( check < 99 )
+	{
 		++check;
 		Utils::WString checkStr = Utils::WString::PadNumber(check, 2);
 		// check if a cat file exists
 		if ( !Dir.exists(checkStr + L".cat") )
+		{
 			// it doen't, check if theres a dat file (incase of package error)
 			if ( !Dir.exists(checkStr + L".dat") )
 	// check for lang.dat file
 	if ( Dir.exists(L"lang.dat") )
+	{
 		CFileIO File(Dir.file(L"lang.dat"));
 		size_t size;
 		char *data = File.ReadToData(&size);
 		if ( data )
+		{
 /**
  * Create Language Text File
+ *
  * Creates text files for all packages into the correct language
  */
 void CPackages::CreateLanguageTextFiles(Utils::WStringList *errors)
+{
 	// no need to create them if theres no language to use
 	if ( !m_iLanguage )
 		return;
 	return Utils::WString::Null();
+}
 Utils::WString CPackages::getGameVersionFromType(int game, int version, const Utils::WString &sVersion) const
 {
 	return m_gameExe.gameVersionFromType(game - 1, version - 1, sVersion);
+}
 int CPackages::CountBuiltInPackages(bool onlyEnabled)
+{
 	int count = 0;
 	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
+	{
 			continue;
 		if ( onlyEnabled && !node->Data()->IsEnabled() )
 			continue;
 		if ( node->Data()->author().Compare(L"PluginManager") )
 			++count;
 	}
 	return count;
+}
 int CPackages::countPackages(int type, bool onlyEnabled) const
+{
 	int count = 0;
 			if (!file->checkFileExt(L"cat"))
 				continue;
 			CCatFile catFile;
 			if (catFile.open(file->filePointer(), addonDir, CATREAD_CATDECRYPT, false) == CATERR_NONE)
 			{
 				if (catFile.extractFile(aFilename, aTo))
 					return 1;
 				if (catFile.error() == CATERR_INVALIDDEST || catFile.error() == CATERR_CANTCREATEDIR)
 				{
 					if (catFile.extractFile(aFilename))
 						return -1;
 				}
+			}
+		}
+	}
 	else if (!m_sSetMod.empty())
 	// get the last one, not the next free one
 	--catNumber;
 	// work backwards until we find the file
 	for (; catNumber; catNumber--)
 	{
 		CCatFile catFile;
 		if (catFile.open((dir + L"/" + Utils::WString::PadNumber(catNumber, 2) + L".cat"), addonDir, CATREAD_CATDECRYPT, false) == CATERR_NONE)
+		{
 			// check for the file
 			if (catFile.extractFile(aFilename, aTo))
 		// lets extract the ware file
 		wchar_t wareType = CPackages::ConvertWareTypeBack(i);
 		Utils::WString wareFile = L"TWare";
 		wareFile += (wchar_t)std::toupper(wareType);
 		Utils::WString openFile;
 		int e;
 		if ( i == WARES_TECH && CFileIO::Exists(m_sTempDir + L"/TWareT.txt") )
 			openFile = m_sTempDir + L"/TWareT.txt";
 					Utils::WString line = *itr;
 					line.removeFirstSpace();
 					line.removeChar(9);
 					line.removeChar('\r');
 					if ( line.empty() )
 						continue;
 					if ( line[0] == '/' )
 						continue;
 					if ( oldSize == -1 )
+					{
+	}
 	else if (m_iGame == GAME_X3FL)
+	{
 		if (maxsize) (*maxsize) = EMP_X3FL;
 		return GetX3TCEmp();
 	}
 	else if ( m_iGame == GAME_X3 )
+	{
 		if ( maxsize ) (*maxsize) = EMP_X3;
 		return GetX3Emp();
+	}
 			CFileIO WriteFile(m_sTempDir + L"/TShips.txt");
 			if ( WriteFile.writeFile(tshipsList) )
+			{
 				this->packFile(&WriteFile, L"types/TShips.pck");
 				WriteFile.remove();
 			}
 		}
 	}
+}
 bool CPackages::packFile(const Utils::WString &filename) const
+{
 	// compress the file
 	return list.size();
+}
 CBaseFile *CPackages::findScriptByAuthor(const Utils::WString &author, CBaseFile *prev)
 {
 	for ( CListNode<CBaseFile> *node = m_lPackages.Front(); node; node = node->next() )
+	{
 		CBaseFile *p = node->Data();
 		if ( prev )
+		{
 			continue;
+		}
 		if ( p->author().Compare(author) )
 			return p;
+	}
 	return NULL;
 }
 bool CPackages::extractAll(CBaseFile *baseFile, const Utils::WString &dir, int game, bool includedir, CProgressInfo *progress) const
+{
 	if (!baseFile)
 		return false;
 		if (!exe->sAddon.empty())
 			gameAddons.pushBack(Utils::WString::Number(i + 1), exe->sAddon);
+	}
 	return baseFile->extractAll(dir, game, gameAddons, includedir, progress);
 }
 bool CPackages::generatePackagerScript(CBaseFile *baseFile, bool wildcard, Utils::WStringList *list, int game, bool datafile) const
+{
 	if (!baseFile)
 		return false;
 		if (!exe->sAddon.empty())
 			gameAddons.pushBack(Utils::WString::Number(i + 1), exe->sAddon);
+	}
 	return baseFile->GeneratePackagerScript(wildcard, list, game, gameAddons, datafile);
 }
 CBaseFile *CPackages::loadPackagerScript(const Utils::WString &filename, int compression, Utils::WString (*askFunc)(const Utils::WString &), Utils::WStringList *malformedLines, Utils::WStringList *unknownCommands, Utils::WStringList *variables, CProgressInfo *progress)
+{
 	// check the file exists
 	if ( !CFileIO::Exists(filename) )
 		return NULL;
 		// check for any comments (so we can ignore them)
 		if ( line.left(2).Compare(L"//") || line[0] == L'#' ) continue;
 		++iLine;
 		// all commands start with a keyword followed by a colon, if one doesn't exist, it cant be a valid line
 		if ( !line.contains(L':') )
+		{
 			// there are some exeptions, and these are one word entrys only
 			line.removeEndSpace();
 	for (unsigned int i = 0; i < m_gameExe.gameCount(); ++i)
+	{
 		SGameExe *exe = m_gameExe.game(i);
 		if (!exe->sAddon.empty())
 			gameAddons.pushBack(Utils::WString::Number(i + 1), exe->sAddon);
 	}
 	// now lets read the rest of the day
 	Utils::WStringList listVaribles;
 	for (Utils::WStringNode *line = fileData.first(); line; line = fileData.next())
+	{
 		Utils::WString cmd = line->str.token(L":", 1);
 	return false;
+}
 size_t CPackages::loadShipData(const Utils::WString &file, Utils::WStringList &list) const
 {
 	CFileIO File;
 	bool deleteFile = false;
 	// load from cat file
 	if (CFileIO(file).isFileExtension(L"cat"))
+	{
 		return FILETYPE_SOUND;
 	return filetype;
+}
 void CPackages::RemoveFailedFiles()
 {
 	Utils::WStringList removed;
 	for (auto itr = _lNonRemovedFiles.begin(); itr != _lNonRemovedFiles.end(); itr++)
+	{
 		if (CFileIO::Remove((*itr)->str))
 			removed.pushBack((*itr)->str);
 //	Utils::WStringList *text = this->MergeTextFiles(conflicts, mod1, mod2);
 //	delete text;
 	// write the cat file when we're done
 	if ( !newCat.WriteCatFile() )
 		return false;
 	return true;
+}
 /**
  * Gets the file list from a mod that might have compatability problems
 			// check for any comments
 			if ( linenospace.left(2) == L"//" )
 				continue;
 			if ( linenospace[0] == L'#' )
 				continue;
 			// all commands start with a keyword followed by a colon, if one doesn't exist, it cant be a valid line
 			if ( !line.contains(':'))
 				continue;
 			Utils::WString first = line.token(L":", 1);
 #endif
 	return archive;
+}
+bool CPackages::_check_archive_fromZip(const Utils::WString& filename) const
+{
+	HZIP hz = OpenZip(filename.c_str(), 0);
+	if (!hz)
+		return false;
+	bool found = false;
+	int index;
+	// move the files from the zip to the package
+	ZIPENTRY ze;
+	if (FindZipItem(hz, L"pluginmanager.txt", true, &index, &ze) == Z_OK)
+		found = true;
+	CloseZip(hz);
+	return found;
+}
-CBaseFile *CPackages::_archive_fromZip(const Utils::WString &filename, bool toInstall) const
+CBaseFile* CPackages::_archive_fromZip(const Utils::WString& filename, bool toInstall) const
+{
 	CBaseFile *archive = NULL;
 	HZIP hz = OpenZip(filename.c_str(), 0);
 	if ( !hz )
 				f = archive->addFile(filename, dir, FILETYPE_SCRIPT);
 				if ( f ) {
 					f->copyData((const unsigned char *)iBuf, ze.unc_size);
+				}
 				type = FILETYPE_UNINSTALL;
 			}
 			int game = 0;
 			// check for addons
 			if (dir.contains('/', true))
+			{
 					game = g + 1;
+			}
 			if ( type == -1 )
 				f = archive->addFile(filename, dir, FILETYPE_EXTRA, game);
 			else
 				f = archive->addFile(filename, extradir, static_cast<FileType>(type), game);
 			if ( f )
 				f->SetData((const unsigned char *)iBuf, ze.unc_size);
 			else
 	CBaseFile *archive = NULL;
 	if ( CFileIO(filename).isFileExtension(L"rar") )
 		archive = this->_archive_fromRar(filename, toInstall);
 	else if ( CFileIO(filename).isFileExtension(L"zip") )
 		archive = this->_archive_fromZip(filename, toInstall);
+	else
+		archive = this->_archive_fromZip(filename, false);
 	if ( archive ) {
 		archive->setFilename(CFileIO(filename).changeFileExtension(L"spk"));
 		if ( toInstall )
 			archive->setName(CFileIO(filename).filename());

Subversion Repositories spk

(root)/libspk/src/Packages.cpp – Rev 266 → 271