ShuriZma
/
pcsx2
mirror of https://github.com/PCSX2/pcsx2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

CDVD: Purge wxString

This commit is contained in:
Connor McLaughlin 2022-04-12 21:26:39 +10:00 committed by refractionpcsx2
parent a635e84d82
commit 63424b765d
26 changed files with 201 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
pcsx2/CDVD/CDVD.cpp
View File

@ -49,7 +49,7 @@
// (examples: SLUS-2113, etc).
// If the disc is homebrew then it probably won't have a valid serial; in which case
// this string will be empty.
wxString DiscSerial;
std::string DiscSerial;
cdvdStruct cdvd;
@ -375,10 +375,14 @@ s32 cdvdWriteConfig(const u8* config)
static MutexRecursive Mutex_NewDiskCB;
// Sets ElfCRC to the CRC of the game bound to the CDVD source.
static __fi ElfObject* loadElf(const wxString filename, bool isPSXElf)
static __fi ElfObject* loadElf(std::string filename, bool isPSXElf)
{
if (filename.StartsWith(L"host"))
return new ElfObject(filename.After(':'), FileSystem::GetPathFileSize(filename.After(':').ToUTF8()), isPSXElf);
if (StringUtil::StartsWith(filename, "host:"))
{
std::string host_filename(filename.substr(5));
s64 host_size = FileSystem::GetPathFileSize(host_filename.c_str());
return new ElfObject(std::move(host_filename), static_cast<u32>(std::max<s64>(host_size, 0)), isPSXElf);
}
// Mimic PS2 behavior!
// Much trial-and-error with changing the ISOFS and BOOT2 contents of an image have shown that
@ -394,41 +398,35 @@ static __fi ElfObject* loadElf(const wxString filename, bool isPSXElf)
// FIXME: Properly mimicing this behavior is troublesome since we need to add support for "ignoring"
// version information when doing file searches. I'll add this later. For now, assuming a ;1 should
// be sufficient (no known games have their ELF binary as anything but version ;1)
const wxString fixedname(wxStringTokenizer(filename, L';').GetNextToken() + L";1");
if (fixedname != filename)
Console.WriteLn(Color_Blue, "(LoadELF) Non-conforming version suffix detected and replaced.");
const std::string::size_type semi_pos = filename.rfind(';');
if (semi_pos != std::string::npos && std::string_view(filename).substr(semi_pos) != ";1")
{
Console.WriteLn(Color_Blue, "(LoadELF) Non-conforming version suffix (%s) detected and replaced.", filename.c_str());
filename.erase(semi_pos);
filename += ";1";
}
IsoFSCDVD isofs;
IsoFile file(isofs, fixedname);
return new ElfObject(fixedname, file, isPSXElf);
IsoFile file(isofs, filename);
return new ElfObject(std::move(filename), file, isPSXElf);
}
static __fi void _reloadElfInfo(wxString elfpath)
static __fi void _reloadElfInfo(std::string elfpath)
{
// Now's a good time to reload the ELF info...
ScopedLock locker(Mutex_NewDiskCB);
if (elfpath == LastELF)
return;
LastELF = elfpath;
wxString fname = elfpath.AfterLast('\\');
if (!fname)
fname = elfpath.AfterLast('/');
if (!fname)
fname = elfpath.AfterLast(':');
if (fname.Matches(L"????_???.??*"))
DiscSerial = fname(0, 4) + L"-" + fname(5, 3) + fname(9, 2);
std::unique_ptr<ElfObject> elfptr(loadElf(elfpath, false));
elfptr->loadHeaders();
ElfCRC = elfptr->getCRC();
ElfEntry = elfptr->header.e_entry;
ElfTextRange = elfptr->getTextRange();
Console.WriteLn(Color_StrongBlue, L"ELF (%s) Game CRC = 0x%08X, EntryPoint = 0x%08X", WX_STR(elfpath), ElfCRC, ElfEntry);
LastELF = std::move(elfpath);
Console.WriteLn(Color_StrongBlue, "ELF (%s) Game CRC = 0x%08X, EntryPoint = 0x%08X", LastELF.c_str(), ElfCRC, ElfEntry);
// Note: Do not load game database info here. This code is generic and called from
// BIOS key encryption as well as eeloadReplaceOSDSYS. The first is actually still executing
@ -437,27 +435,21 @@ static __fi void _reloadElfInfo(wxString elfpath)
// binary).
}
static __fi void _reloadPSXElfInfo(wxString elfpath)
static __fi void _reloadPSXElfInfo(std::string elfpath)
{
// Now's a good time to reload the ELF info...
ScopedLock locker(Mutex_NewDiskCB);
if (elfpath == LastELF)
return;
LastELF = elfpath;
wxString fname = elfpath.AfterLast('\\');
if (!fname)
fname = elfpath.AfterLast('/');
if (!fname)
fname = elfpath.AfterLast(':');
if (fname.Matches(L"????_???.??*"))
DiscSerial = fname(0, 4) + L"-" + fname(5, 3) + fname(9, 2);
std::unique_ptr<ElfObject> elfptr(loadElf(elfpath, true));
ElfCRC = elfptr->getCRC();
ElfTextRange = elfptr->getTextRange();
Console.WriteLn(Color_StrongBlue, L"PSX ELF (%s) Game CRC = 0x%08X", WX_STR(elfpath), ElfCRC);
LastELF = std::move(elfpath);
Console.WriteLn(Color_StrongBlue, "PSX ELF (%s) Game CRC = 0x%08X", LastELF.c_str(), ElfCRC);
// Note: Do not load game database info here. This code is generic and called from
// BIOS key encryption as well as eeloadReplaceOSDSYS. The first is actually still executing
@ -490,6 +482,11 @@ static std::string ExecutablePathToSerial(const std::string& path)
if (pos != std::string::npos)
serial.erase(pos);
// check that it matches our expected format.
// this maintains the old behavior of PCSX2.
if (!StringUtil::WildcardMatch(serial.c_str(), "????_???.??*"))
serial.clear();
// SCES_123.45 -> SCES-12345
for (std::string::size_type pos = 0; pos < serial.size();)
{
@ -510,31 +507,30 @@ static std::string ExecutablePathToSerial(const std::string& path)
return serial;
}
void cdvdReloadElfInfo(wxString elfoverride)
void cdvdReloadElfInfo(std::string elfoverride)
{
// called from context of executing VM code (recompilers), so we need to trap exceptions
// and route them through the VM's exception handler. (needed for non-SEH platforms, such
// as Linux/GCC)
DevCon.WriteLn(Color_Green, L"Reload ELF");
DevCon.WriteLn(Color_Green, "Reload ELF");
try
{
if (!elfoverride.IsEmpty())
if (!elfoverride.empty())
{
_reloadElfInfo(elfoverride);
_reloadElfInfo(std::move(elfoverride));
return;
}
std::string elfpath;
u32 discType = GetPS2ElfName(elfpath);
DiscSerial = ExecutablePathToSerial(elfpath);
if (discType == 1)
{
// PCSX2 currently only recognizes *.elf executables in proper PS2 format.
// To support different PSX titles in the console title and for savestates, this code bypasses all the detection,
// simply using the exe name, stripped of problematic characters.
const std::string serial(ExecutablePathToSerial(elfpath));
DiscSerial = StringUtil::UTF8StringToWxString(serial);
_reloadPSXElfInfo(StringUtil::UTF8StringToWxString(elfpath));
_reloadPSXElfInfo(std::move(elfpath));
return;
}
@ -543,7 +539,7 @@ void cdvdReloadElfInfo(wxString elfoverride)
return;
// Recognized and PS2 (BOOT2). Good job, user.
_reloadElfInfo(StringUtil::UTF8StringToWxString(elfpath));
_reloadElfInfo(std::move(elfpath));
}
catch (Exception::FileNotFound& e)
{
@ -562,18 +558,6 @@ void cdvdReloadElfInfo(wxString elfoverride)
}
}
static __fi s32 StrToS32(const wxString& str, int base = 10)
{
long l;
if (!str.ToLong(&l, base))
{
Console.Error(L"StrToS32: fail to translate '%s' as long", WX_STR(str));
return 0;
}
return l;
}
void cdvdReadKey(u8, u16, u32 arg2, u8* key)
{
s32 numbers = 0, letters = 0;
@ -585,17 +569,17 @@ void cdvdReadKey(u8, u16, u32 arg2, u8* key)
// clear key values
memset(key, 0, 16);
if (!DiscSerial.IsEmpty())
if (!DiscSerial.empty())
{
// convert the number characters to a real 32 bit number
numbers = StrToS32(DiscSerial(5, 5));
numbers = StringUtil::FromChars<s32>(std::string_view(DiscSerial).substr(5, 5)).value_or(0);
// combine the lower 7 bits of each char
// to make the 4 letters fit into a single u32
letters = (s32)((DiscSerial[3].GetValue() & 0x7F) << 0) |
(s32)((DiscSerial[2].GetValue() & 0x7F) << 7) |
(s32)((DiscSerial[1].GetValue() & 0x7F) << 14) |
(s32)((DiscSerial[0].GetValue() & 0x7F) << 21);
letters = (s32)((DiscSerial[3] & 0x7F) << 0) |
(s32)((DiscSerial[2] & 0x7F) << 7) |
(s32)((DiscSerial[1] & 0x7F) << 14) |
(s32)((DiscSerial[0] & 0x7F) << 21);
}
// calculate magic numbers

9
pcsx2/CDVD/CDVD.h
View File

@ -13,12 +13,13 @@
* If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "CDVDaccess.h"
#include <string>
#include <string_view>
#define btoi(b) ((b) / 16 * 10 + (b) % 16) /* BCD to u_char */
#define itob(i) ((i) / 10 * 16 + (i) % 10) /* u_char to BCD */
@ -175,8 +176,8 @@ extern void cdvdNewDiskCB();
extern u8 cdvdRead(u8 key);
extern void cdvdWrite(u8 key, u8 rt);
extern void cdvdReloadElfInfo(wxString elfoverride = wxEmptyString);
extern void cdvdReloadElfInfo(std::string elfoverride = std::string());
extern s32 cdvdCtrlTrayOpen();
extern s32 cdvdCtrlTrayClose();
extern wxString DiscSerial;
extern std::string DiscSerial;

12
pcsx2/CDVD/CDVDaccess.cpp
View File

@ -84,7 +84,7 @@ static int CheckDiskTypeFS(int baseType)
try
{
IsoFile file(rootdir, L"SYSTEM.CNF;1");
IsoFile file(rootdir, "SYSTEM.CNF;1");
const int size = file.getLength();
const std::unique_ptr<char[]> buffer = std::make_unique<char[]>(size + 1);
@ -109,7 +109,7 @@ static int CheckDiskTypeFS(int baseType)
// PS2 Linux disc 2, doesn't have a System.CNF or a normal ELF
try
{
IsoFile file(rootdir, L"P2L_0100.02;1");
IsoFile file(rootdir, "P2L_0100.02;1");
return CDVD_TYPE_PS2DVD;
}
catch (Exception::FileNotFound&)
@ -118,7 +118,7 @@ static int CheckDiskTypeFS(int baseType)
try
{
IsoFile file(rootdir, L"PSX.EXE;1");
IsoFile file(rootdir, "PSX.EXE;1");
return CDVD_TYPE_PSCD;
}
catch (Exception::FileNotFound&)
@ -127,7 +127,7 @@ static int CheckDiskTypeFS(int baseType)
try
{
IsoFile file(rootdir, L"VIDEO_TS/VIDEO_TS.IFO;1");
IsoFile file(rootdir, "VIDEO_TS/VIDEO_TS.IFO;1");
return CDVD_TYPE_DVDV;
}
catch (Exception::FileNotFound&)
@ -390,8 +390,8 @@ bool DoCDVDopen()
//FWIW Disc serial availability doesn't seem reliable enough, sometimes it's there and sometime it's just null
//Shouldn't the serial be available all time? Potentially need to look into Elfreloadinfo() reliability
//TODO: Add extra fallback case for CRC.
if (somepick.empty() && !DiscSerial.IsEmpty())
somepick = StringUtil::StdStringFromFormat("Untitled-%s", DiscSerial.ToUTF8().data());
if (somepick.empty() && !DiscSerial.empty())
somepick = StringUtil::StdStringFromFormat("Untitled-%s", DiscSerial.c_str());
else if (somepick.empty())
somepick = "Untitled";

20
pcsx2/CDVD/IsoFS/IsoDirectory.h
View File

@ -15,6 +15,10 @@
#pragma once
#include "common/Pcsx2Defs.h"
#include <string_view>
#include <vector>
enum IsoFS_Type
{
FStype_ISO9660 = 1,
@ -33,21 +37,21 @@ public:
IsoDirectory(SectorSource& r, IsoFileDescriptor directoryEntry);
virtual ~IsoDirectory() = default;
wxString FStype_ToString() const;
std::string FStype_ToString() const;
SectorSource& GetReader() const { return internalReader; }
bool Exists(const wxString& filePath) const;
bool IsFile(const wxString& filePath) const;
bool IsDir(const wxString& filePath) const;
bool Exists(const std::string_view& filePath) const;
bool IsFile(const std::string_view& filePath) const;
bool IsDir(const std::string_view& filePath) const;
u32 GetFileSize(const wxString& filePath) const;
u32 GetFileSize(const std::string_view& filePath) const;
IsoFileDescriptor FindFile(const wxString& filePath) const;
IsoFileDescriptor FindFile(const std::string_view& filePath) const;
protected:
const IsoFileDescriptor& GetEntry(const wxString& fileName) const;
const IsoFileDescriptor& GetEntry(const std::string_view& fileName) const;
const IsoFileDescriptor& GetEntry(int index) const;
void Init(const IsoFileDescriptor& directoryEntry);
int GetIndexOf(const wxString& fileName) const;
int GetIndexOf(const std::string_view& fileName) const;
};

71
pcsx2/CDVD/IsoFS/IsoFS.cpp
View File

@ -18,6 +18,10 @@
#include "IsoFS.h"
#include "IsoFile.h"
#include "common/FileSystem.h"
#include "common/StringUtil.h"
#include <memory>
//////////////////////////////////////////////////////////////////////////
@ -28,19 +32,17 @@
//u8 volID[5]; // "CD001"
wxString IsoDirectory::FStype_ToString() const
std::string IsoDirectory::FStype_ToString() const
{
switch (m_fstype)
{
case FStype_ISO9660:
return L"ISO9660";
break;
return "ISO9660";
case FStype_Joliet:
return L"Joliet";
break;
return "Joliet";
}
return wxsFormat(L"Unrecognized Code (0x%x)", m_fstype);
return StringUtil::StdStringFromFormat("Unrecognized Code (0x%x)", m_fstype);
}
// Used to load the Root directory from an image
@ -99,10 +101,10 @@ IsoDirectory::IsoDirectory(SectorSource& r)
}
if (!isValid)
throw Exception::FileNotFound(L"IsoFileSystem") // FIXME: Should report the name of the ISO here...
.SetDiagMsg(L"IsoFS could not find the root directory on the ISO image.");
throw Exception::FileNotFound("IsoFileSystem") // FIXME: Should report the name of the ISO here...
.SetDiagMsg("IsoFS could not find the root directory on the ISO image.");
DevCon.WriteLn(L"(IsoFS) Filesystem is " + FStype_ToString());
DevCon.WriteLn("(IsoFS) Filesystem is %s", FStype_ToString().c_str());
Init(rootDirEntry);
}
@ -149,7 +151,7 @@ const IsoFileDescriptor& IsoDirectory::GetEntry(int index) const
return files[index];
}
int IsoDirectory::GetIndexOf(const wxString& fileName) const
int IsoDirectory::GetIndexOf(const std::string_view& fileName) const
{
for (unsigned int i = 0; i < files.size(); i++)
{
@ -157,21 +159,22 @@ int IsoDirectory::GetIndexOf(const wxString& fileName) const
return i;
}
throw Exception::FileNotFound(fileName);
throw Exception::FileNotFound(StringUtil::UTF8StringToWideString(fileName));
}
const IsoFileDescriptor& IsoDirectory::GetEntry(const wxString& fileName) const
const IsoFileDescriptor& IsoDirectory::GetEntry(const std::string_view& fileName) const
{
return GetEntry(GetIndexOf(fileName));
}
IsoFileDescriptor IsoDirectory::FindFile(const wxString& filePath) const
IsoFileDescriptor IsoDirectory::FindFile(const std::string_view& filePath) const
{
pxAssert(!filePath.IsEmpty());
if (filePath.empty())
throw Exception::FileNotFound();
// wxWidgets DOS-style parser should work fine for ISO 9660 path names. Only practical difference
// is case sensitivity, and that won't matter for path splitting.
wxFileName parts(filePath, wxPATH_DOS);
std::vector<std::string_view> parts(FileSystem::SplitWindowsPath(filePath));
IsoFileDescriptor info;
const IsoDirectory* dir = this;
std::unique_ptr<IsoDirectory> deleteme;
@ -179,37 +182,38 @@ IsoFileDescriptor IsoDirectory::FindFile(const wxString& filePath) const
// walk through path ("." and ".." entries are in the directories themselves, so even if the
// path included . and/or .., it still works)
for (uint i = 0; i < parts.GetDirCount(); ++i)
// ignore the device (cdrom0:\)
const bool has_device = (parts.front().back() == ':');
for (size_t index = has_device ? 1 : 0; index < (parts.size() - 1); index++)
{
info = dir->GetEntry(parts.GetDirs()[i]);
info = dir->GetEntry(parts[index]);
if (info.IsFile())
throw Exception::FileNotFound(filePath);
throw Exception::FileNotFound(StringUtil::UTF8StringToWxString(filePath));
deleteme.reset(new IsoDirectory(internalReader, info));
dir = deleteme.get();
}
if (!parts.GetFullName().IsEmpty())
info = dir->GetEntry(parts.GetFullName());
info = dir->GetEntry(parts.back());
return info;
}
bool IsoDirectory::IsFile(const wxString& filePath) const
bool IsoDirectory::IsFile(const std::string_view& filePath) const
{
if (filePath.IsEmpty())
if (filePath.empty())
return false;
return (FindFile(filePath).flags & 2) != 2;
}
bool IsoDirectory::IsDir(const wxString& filePath) const
bool IsoDirectory::IsDir(const std::string_view& filePath) const
{
if (filePath.IsEmpty())
if (filePath.empty())
return false;
return (FindFile(filePath).flags & 2) == 2;
}
u32 IsoDirectory::GetFileSize(const wxString& filePath) const
u32 IsoDirectory::GetFileSize(const std::string_view& filePath) const
{
return FindFile(filePath).size;
}
@ -251,13 +255,14 @@ void IsoFileDescriptor::Load(const u8* data, int length)
switch (c)
{
case 0:
name = L".";
name = ".";
break;
case 1:
name = L"..";
name = "..";
break;
default:
name = (wxChar)c;
name = static_cast<char>(c);
break;
}
}
else
@ -265,12 +270,6 @@ void IsoFileDescriptor::Load(const u8* data, int length)
// copy string and up-convert from ascii to wxChar
const u8* fnsrc = data + 33;
const u8* fnend = fnsrc + fileNameLength;
while (fnsrc != fnend)
{
name += (wxChar)*fnsrc;
++fnsrc;
}
name.assign(reinterpret_cast<const char*>(fnsrc), fileNameLength);
}
}

4
pcsx2/CDVD/IsoFS/IsoFile.cpp
View File

@ -19,14 +19,14 @@
#include "IsoFS.h"
#include "IsoFile.h"
IsoFile::IsoFile(SectorSource& reader, const wxString& filename)
IsoFile::IsoFile(SectorSource& reader, const std::string_view& filename)
: internalReader(reader)
, fileEntry(IsoDirectory(reader).FindFile(filename))
{
Init();
}
IsoFile::IsoFile(const IsoDirectory& dir, const wxString& filename)
IsoFile::IsoFile(const IsoDirectory& dir, const std::string_view& filename)
: internalReader(dir.GetReader())
, fileEntry(dir.FindFile(filename))
{

7
pcsx2/CDVD/IsoFS/IsoFile.h
View File

@ -18,6 +18,9 @@
#include "IsoFileDescriptor.h"
#include "SectorSource.h"
#include "common/Pcsx2Defs.h"
#include <string_view>
class IsoFile
{
public:
@ -35,8 +38,8 @@ protected:
int sectorOffset;
public:
IsoFile(const IsoDirectory& dir, const wxString& filename);
IsoFile(SectorSource& reader, const wxString& filename);
IsoFile(const IsoDirectory& dir, const std::string_view& filename);
IsoFile(SectorSource& reader, const std::string_view& filename);
IsoFile(SectorSource& reader, const IsoFileDescriptor& fileEntry);
virtual ~IsoFile() = default;

5
pcsx2/CDVD/IsoFS/IsoFileDescriptor.h
View File

@ -15,6 +15,9 @@
#pragma once
#include "common/Pcsx2Defs.h"
#include <string>
struct IsoFileDescriptor
{
struct FileDate // not 1:1 with iso9660 date struct
@ -32,7 +35,7 @@ struct IsoFileDescriptor
u32 lba;
u32 size;
int flags;
wxString name;
std::string name;
IsoFileDescriptor();
IsoFileDescriptor(const u8* data, int length);

17
pcsx2/CDVD/OutputIsoFile.cpp
View File

@ -21,16 +21,6 @@
#include <errno.h>
void pxStream_OpenCheck(std::FILE* stream, const std::string& fname, const wxString& mode)
{
if (stream)
return;
ScopedExcept ex(Exception::FromErrno(StringUtil::UTF8StringToWxString(fname), errno));
ex->SetDiagMsg(pxsFmt(L"Unable to open the file for %s: %s", WX_STR(mode), WX_STR(ex->DiagMsg())));
ex->Rethrow();
}
OutputIsoFile::OutputIsoFile()
{
_init();
@ -62,7 +52,12 @@ void OutputIsoFile::Create(std::string filename, int version)
m_blocksize = 2048;
m_outstream = FileSystem::OpenCFile(m_filename.c_str(), "wb");
pxStream_OpenCheck(m_outstream, m_filename, L"writing");
if (!m_outstream)
{
Console.Error("(OutputIsoFile::Create) Unable to open the file '%s' for writing: %d", m_filename.c_str(), errno);
ScopedExcept ex(Exception::FromErrno(StringUtil::UTF8StringToWxString(filename), errno));
ex->Rethrow();
}
Console.WriteLn("isoFile create ok: %s ", m_filename.c_str());
}

34
pcsx2/Elfheader.cpp
View File

@ -29,28 +29,24 @@
u32 ElfCRC;
u32 ElfEntry;
std::pair<u32,u32> ElfTextRange;
wxString LastELF;
std::string LastELF;
bool isPSXElf;
// All of ElfObjects functions.
ElfObject::ElfObject(const wxString& srcfile, IsoFile& isofile, bool isPSXElf)
: data( wxULongLong(isofile.getLength()).GetLo(), L"ELF headers" )
, proghead( NULL )
, secthead( NULL )
, filename( srcfile )
, header( *(ELF_HEADER*)data.GetPtr() )
ElfObject::ElfObject(std::string srcfile, IsoFile& isofile, bool isPSXElf)
: data(isofile.getLength(), L"ELF headers")
, filename(std::move(srcfile))
, header(*(ELF_HEADER*)data.GetPtr())
{
checkElfSize(data.GetSizeInBytes());
readIso(isofile);
initElfHeaders(isPSXElf);
}
ElfObject::ElfObject( const wxString& srcfile, uint hdrsize, bool isPSXElf )
: data( wxULongLong(hdrsize).GetLo(), L"ELF headers" )
, proghead( NULL )
, secthead( NULL )
, filename( srcfile )
, header( *(ELF_HEADER*)data.GetPtr() )
ElfObject::ElfObject(std::string srcfile, u32 hdrsize, bool isPSXElf)
: data(hdrsize, L"ELF headers")
, filename(std::move(srcfile))
, header(*(ELF_HEADER*)data.GetPtr())
{
checkElfSize(data.GetSizeInBytes());
readFile();
@ -151,20 +147,20 @@ std::pair<u32,u32> ElfObject::getTextRange()
void ElfObject::readIso(IsoFile& file)
{
int rsize = file.read(data.GetPtr(), data.GetSizeInBytes());
if (rsize < data.GetSizeInBytes()) throw Exception::EndOfStream(filename);
if (rsize < data.GetSizeInBytes()) throw Exception::EndOfStream(StringUtil::UTF8StringToWxString(filename));
}
void ElfObject::readFile()
{
int rsize = 0;
FILE *f = FileSystem::OpenCFile( filename.ToUTF8(), "rb" );
if (f == NULL) throw Exception::FileNotFound( filename );
FILE *f = FileSystem::OpenCFile( filename.c_str(), "rb");
if (f == NULL) throw Exception::FileNotFound(StringUtil::UTF8StringToWxString(filename));
fseek(f, 0, SEEK_SET);
rsize = fread(data.GetPtr(), 1, data.GetSizeInBytes(), f);
fclose( f );
if (rsize < data.GetSizeInBytes()) throw Exception::EndOfStream(filename);
if (rsize < data.GetSizeInBytes()) throw Exception::EndOfStream(StringUtil::UTF8StringToWxString(filename));
}
static wxString GetMsg_InvalidELF()
@ -184,7 +180,7 @@ void ElfObject::checkElfSize(s64 elfsize)
else if (elfsize == 0) diagMsg = L"Unexpected end of ELF file.";
if (diagMsg)
throw Exception::BadStream(filename)
throw Exception::BadStream(StringUtil::UTF8StringToWxString(filename))
.SetDiagMsg(diagMsg)
.SetUserMsg(GetMsg_InvalidELF());
}
@ -320,7 +316,7 @@ int GetPS2ElfName( std::string& name )
try {
IsoFSCDVD isofs;
IsoFile file( isofs, L"SYSTEM.CNF;1");
IsoFile file( isofs, "SYSTEM.CNF;1");
int size = file.getLength();
if( size == 0 ) return 0;

14
pcsx2/Elfheader.h
View File

@ -121,9 +121,9 @@ class ElfObject
{
private:
SafeArray<u8> data;
ELF_PHR* proghead;
ELF_SHR* secthead;
wxString filename;
ELF_PHR* proghead = nullptr;
ELF_SHR* secthead = nullptr;
std::string filename;
void initElfHeaders(bool isPSXElf);
void readIso(IsoFile& file);
@ -137,8 +137,8 @@ class ElfObject
// C++ does all the cleanup automagically for us.
virtual ~ElfObject() = default;
ElfObject(const wxString& srcfile, IsoFile& isofile, bool isPSXElf);
ElfObject( const wxString& srcfile, uint hdrsize, bool isPSXElf );
ElfObject(std::string srcfile, IsoFile& isofile, bool isPSXElf);
ElfObject(std::string srcfile, u32 hdrsize, bool isPSXElf);
void loadProgramHeaders();
void loadSectionHeaders();
@ -153,14 +153,14 @@ class ElfObject
};
//-------------------
extern void loadElfFile(const wxString& filename);
extern void loadElfFile(const std::string& filename);
extern int GetPS2ElfName( std::string& dest );
extern u32 ElfCRC;
extern u32 ElfEntry;
extern std::pair<u32,u32> ElfTextRange;
extern wxString LastELF;
extern std::string LastELF;
extern bool isPSXElf;
#endif

6
pcsx2/Frontend/GameList.cpp
View File

@ -149,7 +149,7 @@ bool GameList::GetElfListEntry(const std::string& path, GameList::Entry* entry)
try
{
ElfObject eo(StringUtil::UTF8StringToWxString(path), static_cast<uint>(file_size), false);
ElfObject eo(path, static_cast<uint>(file_size), false);
entry->crc = eo.getCRC();
}
catch (...)
@ -203,10 +203,10 @@ bool GameList::GetGameListEntry(const std::string& path, GameList::Entry* entry)
return false;
}
cdvdReloadElfInfo(wxEmptyString);
cdvdReloadElfInfo();
entry->path = path;
entry->serial = StringUtil::wxStringToUTF8String(DiscSerial);
entry->serial = DiscSerial;
entry->crc = ElfCRC;
entry->total_size = sd.Size;
entry->compatibility_rating = CompatibilityRating::Unknown;

17
pcsx2/R5900.cpp
View File

@ -114,7 +114,7 @@ void cpuReset()
AllowParams2 = !g_SkipBiosHack;
ElfCRC = 0;
DiscSerial = L"";
DiscSerial.clear();
ElfEntry = -1;
// Probably not the right place, but it has to be done when the ram is actually initialized
@ -125,7 +125,7 @@ void cpuReset()
// the same (identical ELF names) but is actually different (devs actually could
// run into this while testing minor binary hacked changes to ISO images, which
// is why I found out about this) --air
LastELF = L"";
LastELF.clear();
g_eeloadMain = 0, g_eeloadExec = 0, g_osdsys_str = 0;
}
@ -620,13 +620,13 @@ int ParseArgumentString(u32 arg_block)
void __fastcall eeloadHook()
{
#ifndef PCSX2_CORE
const wxString &elf_override = GetCoreThread().GetElfOverride();
const std::string elf_override(StringUtil::wxStringToUTF8String(GetCoreThread().GetElfOverride()));
#else
const wxString elf_override(StringUtil::UTF8StringToWxString(VMManager::Internal::GetElfOverride()));
const std::string& elf_override(VMManager::Internal::GetElfOverride());
#endif
if (!elf_override.IsEmpty())
cdvdReloadElfInfo(L"host:" + elf_override);
if (!elf_override.empty())
cdvdReloadElfInfo(StringUtil::StdStringFromFormat("host:%s", elf_override.c_str()));
else
cdvdReloadElfInfo();
@ -702,10 +702,9 @@ void __fastcall eeloadHook()
if (g_SkipBiosHack && elfname.empty())
{
std::string elftoload;
if (!elf_override.IsEmpty())
if (!elf_override.empty())
{
elftoload = "host:";
elftoload += elf_override.ToUTF8();
elftoload = StringUtil::StdStringFromFormat("host:%s", elf_override.c_str());
}
else
{

2
pcsx2/Recording/InputRecording.cpp
View File

@ -454,7 +454,7 @@ void InputRecording::GoToFirstFrame(wxWindow* parent)
wxString InputRecording::resolveGameName()
{
std::string gameName;
const std::string gameKey(StringUtil::wxStringToUTF8String(SysGetDiscID()));
const std::string gameKey(SysGetDiscID());
if (!gameKey.empty())
{
auto game = GameDatabase::findGame(gameKey);

49
pcsx2/SaveState.cpp
View File

@ -83,29 +83,22 @@ static void PostLoadPrep()
// SaveStateBase (implementations)
// --------------------------------------------------------------------------------------
#ifndef PCSX2_CORE
wxString SaveStateBase::GetSavestateFolder( int slot, bool isSavingOrLoading )
std::string SaveStateBase::GetSavestateFolder(int slot, bool isSavingOrLoading)
{
wxString CRCvalue = wxString::Format(wxT("%08X"), ElfCRC);
wxString serialName(DiscSerial);
std::string CRCvalue(StringUtil::StdStringFromFormat("%08X", ElfCRC));
std::string serialName;
if (g_GameStarted || g_GameLoading)
{
if (DiscSerial.IsEmpty())
{
std::string ElfString = LastELF.ToStdString();
std::string ElfString_delimiter = "/";
#ifndef _UNIX_
std::replace(ElfString.begin(), ElfString.end(), '\\', '/');
#endif
size_t pos = 0;
while ((pos = ElfString.find(ElfString_delimiter)) != std::string::npos)
if (DiscSerial.empty())
{
// Running homebrew/standalone ELF, return only the ELF name.
ElfString.erase(0, pos + ElfString_delimiter.length());
}
wxString ElfString_toWxString(ElfString.c_str(), wxConvUTF8);
serialName = ElfString_toWxString;
// can't use FileSystem here because it's DOS paths
const std::string::size_type pos = std::min(DiscSerial.rfind('/'), DiscSerial.rfind('\\'));
if (pos != std::string::npos)
serialName = DiscSerial.substr(pos + 1);
else
serialName = DiscSerial;
}
else
{
@ -117,22 +110,24 @@ wxString SaveStateBase::GetSavestateFolder( int slot, bool isSavingOrLoading )
else
{
// Still inside the BIOS/not running a game (why would anyone want to do this?)
const std::string biosString(StringUtil::StdStringFromFormat("BIOS (%s v%u.%u)", BiosZone.c_str(), (BiosVersion >> 8), BiosVersion & 0xff));
serialName = StringUtil::UTF8StringToWxString(biosString);
CRCvalue = L"None";
serialName = StringUtil::StdStringFromFormat("BIOS (%s v%u.%u)", BiosZone.c_str(), (BiosVersion >> 8), BiosVersion & 0xff);
CRCvalue = "None";
}
wxFileName dirname = wxFileName::DirName(g_Conf->FullpathToSaveState(serialName, CRCvalue));
const std::string dir(StringUtil::StdStringFromFormat("%s" FS_OSPATH_SEPARATOR_STR "%s - (%s)",
g_Conf->Folders.Savestates.ToUTF8().data(), serialName.c_str(), CRCvalue.c_str()));
if (isSavingOrLoading)
{
if (!wxDirExists(g_Conf->FullpathToSaveState(serialName, CRCvalue)))
if (!FileSystem::DirectoryExists(dir.c_str()))
{
wxMkdir(g_Conf->FullpathToSaveState(serialName, CRCvalue));
// sstates should exist, no need to create it
FileSystem::CreateDirectoryPath(dir.c_str(), false);
}
}
return (dirname.GetPath() + "/" +
pxsFmt( L"%s (%s).%02d.p2s", WX_STR(serialName), WX_STR(CRCvalue), slot ));
return Path::CombineStdString(dir, StringUtil::StdStringFromFormat("%s (%s).%02d.p2s",
serialName.c_str(), CRCvalue.c_str(), slot));
}
#endif
@ -234,10 +229,10 @@ SaveStateBase& SaveStateBase::FreezeInternals()
Freeze(ElfCRC);
char localDiscSerial[256];
StringUtil::Strlcpy(localDiscSerial, DiscSerial.ToUTF8(), sizeof(localDiscSerial));
StringUtil::Strlcpy(localDiscSerial, DiscSerial.c_str(), sizeof(localDiscSerial));
Freeze(localDiscSerial);
if (IsLoading())
DiscSerial = wxString::FromUTF8(localDiscSerial);
DiscSerial = localDiscSerial;
// Third Block - Cycle Timers and Events
// -------------------------------------

2
pcsx2/SaveState.h
View File

@ -83,7 +83,7 @@ public:
virtual ~SaveStateBase() { }
#ifndef PCSX2_CORE
static wxString GetSavestateFolder( int slot, bool isSavingOrLoading = false );
static std::string GetSavestateFolder(int slot, bool isSavingOrLoading = false);
#endif
// Gets the version of savestate that this object is acting on.

11
pcsx2/System.cpp
View File

@ -26,6 +26,7 @@
#include "common/MemsetFast.inl"
#include "common/Perf.h"
#include "common/StringUtil.h"
#include "CDVD/CDVD.h"
#ifdef PCSX2_CORE
@ -646,21 +647,21 @@ u8* SysMmapEx(uptr base, u32 size, uptr bounds, const char *caller)
return Mem;
}
wxString SysGetBiosDiscID()
std::string SysGetBiosDiscID()
{
// FIXME: we should return a serial based on
// the BIOS being run (either a checksum of the BIOS roms, and/or a string based on BIOS
// region and revision).
return wxEmptyString;
return {};
}
// This function always returns a valid DiscID -- using the Sony serial when possible, and
// falling back on the CRC checksum of the ELF binary if the PS2 software being run is
// homebrew or some other serial-less item.
wxString SysGetDiscID()
std::string SysGetDiscID()
{
if( !DiscSerial.IsEmpty() ) return DiscSerial;
if( !DiscSerial.empty() ) return DiscSerial;
if( !ElfCRC )
{
@ -668,5 +669,5 @@ wxString SysGetDiscID()
return SysGetBiosDiscID();
}
return pxsFmt( L"%08x", ElfCRC );
return StringUtil::StdStringFromFormat("%08x", ElfCRC);
}

4
pcsx2/System.h
View File

@ -165,8 +165,8 @@ extern u8 *SysMmapEx(uptr base, u32 size, uptr bounds, const char *caller="Unnam
extern void vSyncDebugStuff( uint frame );
extern void NTFS_CompressFile( const wxString& file, bool compressStatus=true );
extern wxString SysGetBiosDiscID();
extern wxString SysGetDiscID();
extern std::string SysGetBiosDiscID();
extern std::string SysGetDiscID();
extern SysMainMemory& GetVmMemory();

2
pcsx2/VMManager.cpp
View File

@ -412,7 +412,7 @@ void VMManager::UpdateRunningGame(bool force)
{
const bool ingame = (ElfCRC && (g_GameLoading || g_GameStarted));
new_crc = ingame ? ElfCRC : 0;
new_serial = ingame ? SysGetDiscID().ToStdString() : SysGetBiosDiscID().ToStdString();
new_serial = ingame ? SysGetDiscID() : SysGetBiosDiscID();
}
else
{

6
pcsx2/gui/AppConfig.cpp
View File

@ -545,12 +545,6 @@ void AppConfig::FolderOptions::Set(FoldersEnum_t folderidx, const wxString& src,
}
}
wxString AppConfig::FullpathToSaveState(wxString serialName, wxString CRCvalue) const
{
wxString Sstate_append = serialName + " - " + "(" + CRCvalue + ")";
return Path::Combine(Folders.Savestates, Sstate_append);
}
bool IsPortable()
{
return InstallationMode == InstallMode_Portable;

2
pcsx2/gui/AppConfig.h
View File

@ -299,7 +299,7 @@ public:
public:
AppConfig();
wxString FullpathToSaveState(wxString serialName, wxString CRCvalue) const;
std::string FullpathToSaveState(const std::string& serialName, const std::string& CRCvalue) const;
void LoadSave(IniInterface& ini, SettingsWrapper& wrap);
void LoadSaveRootItems(IniInterface& ini);

8
pcsx2/gui/AppCoreThread.cpp
View File

@ -368,10 +368,10 @@ static void _ApplySettings(const Pcsx2Config& src, Pcsx2Config& fixup)
else
GameInfo::gameCRC = L""; // Needs to be reset when rebooting otherwise previously loaded patches may load
if (ingame && !DiscSerial.IsEmpty())
GameInfo::gameSerial = DiscSerial;
if (ingame && !DiscSerial.empty())
GameInfo::gameSerial = StringUtil::UTF8StringToWxString(DiscSerial);
const wxString newGameKey(ingame ? SysGetDiscID() : SysGetBiosDiscID());
const wxString newGameKey(StringUtil::UTF8StringToWxString(ingame ? SysGetDiscID() : SysGetBiosDiscID()));
const bool verbose(newGameKey != curGameKey && ingame);
//Console.WriteLn(L"------> patches verbose: %d prev: '%s' new: '%s'", (int)verbose, WX_STR(curGameKey), WX_STR(newGameKey));
SetupPatchesCon(verbose);
@ -405,7 +405,7 @@ static void _ApplySettings(const Pcsx2Config& src, Pcsx2Config& fixup)
else
{
// Set correct title for loading standalone/homebrew ELFs
GameInfo::gameName = LastELF.AfterLast('\\');
GameInfo::gameName = StringUtil::UTF8StringToWxString(LastELF).AfterLast('\\');
}
}

2
pcsx2/gui/Saveslots.cpp
View File

@ -116,7 +116,7 @@ void States_DefrostCurrentSlotBackup()
void States_updateLoadBackupMenuItem()
{
wxString file(SaveStateBase::GetSavestateFolder(StatesC) + ".backup");
wxString file(StringUtil::UTF8StringToWxString(SaveStateBase::GetSavestateFolder(StatesC) + ".backup"));
sMainFrame.EnableMenuItem(MenuId_State_LoadBackup, wxFileExists(file));
sMainFrame.SetMenuItemLabel(MenuId_State_LoadBackup, wxsFormat(L"%s %d", _("Backup"), StatesC));

9
pcsx2/gui/Saveslots.h
View File

@ -19,6 +19,7 @@
#include "System.h"
#include "Elfheader.h"
#include "App.h"
#include "common/StringUtil.h"
#include <array>
// Uncomment to turn on the new saveslot UI.
@ -37,7 +38,7 @@
//#define SAVESLOT_LOGS
#endif
extern wxString DiscSerial;
extern std::string DiscSerial;
static const int StateSlotsCount = 10;
class Saveslot
@ -68,14 +69,14 @@ public:
bool isUsed()
{
return wxFileExists(SaveStateBase::GetSavestateFolder(slot_num, false));
return wxFileExists(StringUtil::UTF8StringToWxString(SaveStateBase::GetSavestateFolder(slot_num, false)));
}
wxDateTime GetTimestamp()
{
if (!isUsed()) return wxInvalidDateTime;
return wxDateTime(wxFileModificationTime(SaveStateBase::GetSavestateFolder(slot_num, false)));
return wxDateTime(wxFileModificationTime(StringUtil::UTF8StringToWxString(SaveStateBase::GetSavestateFolder(slot_num, false))));
}
void UpdateCache()
@ -83,7 +84,7 @@ public:
empty = !isUsed();
updated = GetTimestamp();
crc = ElfCRC;
serialName = DiscSerial;
serialName = StringUtil::UTF8StringToWxString(DiscSerial);
invalid_cache = false;
}

6
pcsx2/gui/SysState.cpp
View File

@ -122,12 +122,12 @@ void StateCopy_LoadFromFile(const wxString& file)
// the one in the memory save. :)
void StateCopy_SaveToSlot(uint num)
{
const wxString file(SaveStateBase::GetSavestateFolder(num, true));
const wxString file(StringUtil::UTF8StringToWxString(SaveStateBase::GetSavestateFolder(num, true)));
// Backup old Savestate if one exists.
if (wxFileExists(file) && EmuConfig.BackupSavestate)
{
const wxString copy(SaveStateBase::GetSavestateFolder(num, true) + pxsFmt(L".backup"));
const wxString copy(StringUtil::UTF8StringToWxString(SaveStateBase::GetSavestateFolder(num, true)) + pxsFmt(L".backup"));
Console.Indent().WriteLn(Color_StrongGreen, L"Backing up existing state in slot %d.", num);
wxRenameFile(file, copy);
@ -144,7 +144,7 @@ void StateCopy_SaveToSlot(uint num)
void StateCopy_LoadFromSlot(uint slot, bool isFromBackup)
{
wxString file(SaveStateBase::GetSavestateFolder(slot, true) + wxString(isFromBackup ? L".backup" : L""));
wxString file(StringUtil::UTF8StringToWxString(SaveStateBase::GetSavestateFolder(slot, true)) + wxString(isFromBackup ? L".backup" : L""));
if (!wxFileExists(file))
{

3
pcsx2/gui/UpdateUI.cpp
View File

@ -51,6 +51,7 @@ static void _SaveLoadStuff(bool enabled)
sMainFrame.EnableMenuItem(MenuId_Sys_SaveStates, enabled);
#ifdef USE_NEW_SAVESLOTS_UI
const wxString wxDiscSerial(StringUtil::UTF8StringToWxString(DiscSerial));
bool crcChanged = false;
// Run though all the slots. Update if they need updating or the crc changed.
for (Saveslot &slot : saveslot_cache)
@ -62,7 +63,7 @@ static void _SaveLoadStuff(bool enabled)
// We need to reload the file information if the crc or serial # changed.
// Invalidate slot cache when using full boot (g_GameLoading) otherwise it won't see the new folder path
if ((g_GameLoading || slot.crc != ElfCRC) || (slot.serialName != DiscSerial))
if ((g_GameLoading || slot.crc != ElfCRC) || (slot.serialName != wxDiscSerial))
{
slot.invalid_cache = true;
crcChanged = true;