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

Everything: Remove a **lot** of wx, and px nonsense 

- common has no wx left except for Path.
 - pcsx2core only has it in a few places (memory cards and path related
   stuff).
This commit is contained in:
Connor McLaughlin 2022-05-18 23:27:23 +10:00 committed by refractionpcsx2
parent c07c942659
commit 893b3c629d
234 changed files with 1952 additions and 2190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
common/AlignedMalloc.h
View File

@ -33,25 +33,6 @@
#define pxUSE_SECURE_MALLOC 0
#endif
//////////////////////////////////////////////////////////////////////////////////////////
// Safe deallocation macros -- checks pointer validity (non-null) when needed, and sets
// pointer to null after deallocation.
#define safe_delete(ptr) \
((void)(delete (ptr)), (ptr) = NULL)
#define safe_delete_array(ptr) \
((void)(delete[](ptr)), (ptr) = NULL)
// No checks for NULL -- wxWidgets says it's safe to skip NULL checks and it runs on
// just about every compiler and libc implementation of any recentness.
#define safe_free(ptr) \
((void)(free(ptr), !!0), (ptr) = NULL)
//((void) (( ( (ptr) != NULL ) && (free( ptr ), !!0) ), (ptr) = NULL))
#define safe_fclose(ptr) \
((void)((((ptr) != NULL) && (fclose(ptr), !!0)), (ptr) = NULL))
// Implementation note: all known implementations of _aligned_free check the pointer for
// NULL status (our implementation under GCC, and microsoft's under MSVC), so no need to
// do it here.
@ -68,27 +49,6 @@ extern void _aligned_free(void* pmem);
_aligned_realloc(handle, new_size, align)
#endif
// --------------------------------------------------------------------------------------
// pxDoOutOfMemory
// --------------------------------------------------------------------------------------
typedef void FnType_OutOfMemory(uptr blocksize);
typedef FnType_OutOfMemory* Fnptr_OutOfMemory;
// This method is meant to be assigned by applications that link against pxWex. It is called
// (invoked) prior to most pxWex built-in memory/array classes throwing exceptions, and can be
// used by an application to remove unneeded memory allocations and/or reduce internal cache
// reserves.
//
// Example: PCSX2 uses several bloated recompiler code caches. Larger caches improve performance,
// however a rouge cache growth could cause memory constraints in the operating system. If an out-
// of-memory error occurs, PCSX2's implementation of this function attempts to reset all internal
// recompiler caches. This can typically free up 100-150 megs of memory, and will allow the app
// to continue running without crashing or hanging the operating system, etc.
//
extern Fnptr_OutOfMemory pxDoOutOfMemory;
// --------------------------------------------------------------------------------------
// AlignedBuffer
// --------------------------------------------------------------------------------------

49
common/Assertions.h
View File

@ -15,9 +15,10 @@
#pragma once
#include <wx/string.h>
#include "common/Pcsx2Defs.h"
#include <string>
#ifndef __pxFUNCTION__
#if defined(__GNUG__)
#define __pxFUNCTION__ __PRETTY_FUNCTION__
@ -26,25 +27,17 @@
#endif
#endif
#ifndef wxNullChar
#define wxNullChar ((wxChar*)NULL)
#endif
// FnChar_t - function name char type; typedef'd in case it ever changes between compilers
// (ie, a compiler decides to wchar_t it instead of char/UTF8).
typedef char FnChar_t;
// --------------------------------------------------------------------------------------
// DiagnosticOrigin
// --------------------------------------------------------------------------------------
struct DiagnosticOrigin
{
const wxChar* srcfile;
const FnChar_t* function;
const wxChar* condition;
const char* srcfile;
const char* function;
const char* condition;
int line;
DiagnosticOrigin(const wxChar* _file, int _line, const FnChar_t* _func, const wxChar* _cond = NULL)
DiagnosticOrigin(const char* _file, int _line, const char* _func, const char* _cond = nullptr)
: srcfile(_file)
, function(_func)
, condition(_cond)
@ -52,12 +45,12 @@ struct DiagnosticOrigin
{
}
wxString ToString(const wxChar* msg = NULL) const;
std::string ToString(const char* msg = nullptr) const;
};
// Returns ture if the assertion is to trap into the debugger, or false if execution
// of the program should continue unimpeded.
typedef bool pxDoAssertFnType(const DiagnosticOrigin& origin, const wxChar* msg);
typedef bool pxDoAssertFnType(const DiagnosticOrigin& origin, const char* msg);
extern pxDoAssertFnType pxAssertImpl_LogIt;
@ -100,8 +93,8 @@ extern pxDoAssertFnType* pxDoAssert;
// it can lead to the compiler optimizing out code and leading to crashes in dev/release
// builds. To have code optimized, explicitly use pxAssume(false) or pxAssumeDev(false,msg);
#define pxDiagSpot DiagnosticOrigin(__TFILE__, __LINE__, __pxFUNCTION__)
#define pxAssertSpot(cond) DiagnosticOrigin(__TFILE__, __LINE__, __pxFUNCTION__, _T(#cond))
#define pxDiagSpot DiagnosticOrigin(__FILE__, __LINE__, __pxFUNCTION__)
#define pxAssertSpot(cond) DiagnosticOrigin(__FILE__, __LINE__, __pxFUNCTION__, #cond)
// pxAssertRel ->
// Special release-mode assertion. Limited use since stack traces in release mode builds
@ -170,28 +163,12 @@ extern pxDoAssertFnType* pxDoAssert;
#endif
#define pxAssert(cond) pxAssertMsg(cond, wxNullChar)
#define pxAssume(cond) pxAssumeMsg(cond, wxNullChar)
#define pxAssert(cond) pxAssertMsg(cond, nullptr)
#define pxAssume(cond) pxAssumeMsg(cond, nullptr)
#define pxAssertRelease(cond, msg)
// Performs an unsigned index bounds check, and generates a debug assertion if the check fails.
// For stricter checking in Devel builds as well as debug builds (but possibly slower), use
// IndexBoundsCheckDev.
#define IndexBoundsCheck(objname, idx, sze) pxAssertMsg((uint)(idx) < (uint)(sze), \
pxsFmt(L"Array index out of bounds accessing object '%s' (index=%d, size=%d)", objname, (idx), (sze)))
#define IndexBoundsCheckDev(objname, idx, sze) pxAssertDev((uint)(idx) < (uint)(sze), \
pxsFmt(L"Array index out of bounds accessing object '%s' (index=%d, size=%d)", objname, (idx), (sze)))
#define IndexBoundsAssume(objname, idx, sze) pxAssumeMsg((uint)(idx) < (uint)(sze), \
pxsFmt(L"Array index out of bounds accessing object '%s' (index=%d, size=%d)", objname, (idx), (sze)))
#define IndexBoundsAssumeDev(objname, idx, sze) pxAssumeDev((uint)(idx) < (uint)(sze), \
pxsFmt(L"Array index out of bounds accessing object '%s' (index=%d, size=%d)", objname, (idx), (sze)))
extern void pxOnAssert(const DiagnosticOrigin& origin, const wxString& msg);
extern void pxOnAssert(const DiagnosticOrigin& origin, const char* msg);
// --------------------------------------------------------------------------------------
// jNO_DEFAULT -- disables the default case in a switch, which improves switch optimization

16
common/CMakeLists.txt
View File

@ -17,7 +17,6 @@ target_sources(common PRIVATE
CrashHandler.cpp
EventSource.cpp
Exceptions.cpp
FastFormatString.cpp
FastJmp.cpp
FileSystem.cpp
Misc.cpp
@ -26,10 +25,8 @@ target_sources(common PRIVATE
PrecompiledHeader.cpp
Perf.cpp
ProgressCallback.cpp
pxTranslate.cpp
Semaphore.cpp
SettingsWrapper.cpp
StringHelpers.cpp
StringUtil.cpp
Timer.cpp
WindowInfo.cpp
@ -64,7 +61,6 @@ target_sources(common PRIVATE
boost_spsc_queue.hpp
Console.h
CrashHandler.h
Dependencies.h
EnumOps.h
EventSource.h
Exceptions.h
@ -80,13 +76,11 @@ target_sources(common PRIVATE
PageFaultSource.h
PrecompiledHeader.h
ProgressCallback.h
pxForwardDefs.h
RedtapeWindows.h
SafeArray.h
ScopedGuard.h
SettingsInterface.h
SettingsWrapper.h
StringHelpers.h
StringUtil.h
Timer.h
Threading.h
@ -262,7 +256,15 @@ if (USE_GCC AND CMAKE_INTERPROCEDURAL_OPTIMIZATION)
set_source_files_properties(FastJmp.cpp PROPERTIES COMPILE_FLAGS -fno-lto)
endif()
target_link_libraries(common PRIVATE ${LIBC_LIBRARIES} PUBLIC wxWidgets::all)
target_link_libraries(common PRIVATE
${LIBC_LIBRARIES}
)
target_link_libraries(common PUBLIC
wxWidgets::all
fmt::fmt
)
target_compile_features(common PUBLIC cxx_std_17)
target_include_directories(common PUBLIC ../3rdparty/include ../)
target_compile_definitions(common PUBLIC "${PCSX2_DEFS}")

212
common/Console.cpp
View File

@ -15,6 +15,7 @@
#include "common/Threading.h"
#include "common/TraceLog.h"
#include "common/Assertions.h"
#include "common/RedtapeWindows.h" // OutputDebugString
using namespace Threading;
@ -73,14 +74,14 @@ void Console_SetActiveHandler(const IConsoleWriter& writer, FILE* flushfp)
// Writes text to the Visual Studio Output window (Microsoft Windows only).
// On all other platforms this pipes to Stdout instead.
void MSW_OutputDebugString(const wxString& text)
static void MSW_OutputDebugString(const char* text)
{
#if defined(__WXMSW__) && !defined(__WXMICROWIN__)
static bool hasDebugger = wxIsDebuggerRunning();
#ifdef _WIN32
static bool hasDebugger = IsDebuggerPresent();
if (hasDebugger)
OutputDebugString(text);
OutputDebugStringA(text);
#else
fputs(text.utf8_str(), stdout_fp);
fputs(text, stdout_fp);
fflush(stdout_fp);
#endif
}
@ -90,11 +91,11 @@ void MSW_OutputDebugString(const wxString& text)
// ConsoleNull
// --------------------------------------------------------------------------------------
static void ConsoleNull_SetTitle(const wxString& title) {}
static void ConsoleNull_SetTitle(const char* title) {}
static void ConsoleNull_DoSetColor(ConsoleColors color) {}
static void ConsoleNull_Newline() {}
static void ConsoleNull_DoWrite(const wxString& fmt) {}
static void ConsoleNull_DoWriteLn(const wxString& fmt) {}
static void ConsoleNull_DoWrite(const char* fmt) {}
static void ConsoleNull_DoWriteLn(const char* fmt) {}
const IConsoleWriter ConsoleWriter_Null =
{
@ -172,20 +173,21 @@ static __fi const char* GetLinuxConsoleColor(ConsoleColors color)
#endif
// One possible default write action at startup and shutdown is to use the stdout.
static void ConsoleStdout_DoWrite(const wxString& fmt)
static void ConsoleStdout_DoWrite(const char* fmt)
{
MSW_OutputDebugString(fmt);
}
// Default write action at startup and shutdown is to use the stdout.
static void ConsoleStdout_DoWriteLn(const wxString& fmt)
static void ConsoleStdout_DoWriteLn(const char* fmt)
{
MSW_OutputDebugString(fmt + L"\n");
MSW_OutputDebugString(fmt);
MSW_OutputDebugString("\n");
}
static void ConsoleStdout_Newline()
{
MSW_OutputDebugString(L"\n");
MSW_OutputDebugString("\n");
}
static void ConsoleStdout_DoSetColor(ConsoleColors color)
@ -198,12 +200,12 @@ static void ConsoleStdout_DoSetColor(ConsoleColors color)
#endif
}
static void ConsoleStdout_SetTitle(const wxString& title)
static void ConsoleStdout_SetTitle(const char* title)
{
#if defined(__POSIX__)
if (supports_color)
fputs("\033]0;", stdout_fp);
fputs(title.utf8_str(), stdout_fp);
fputs(title, stdout_fp);
if (supports_color)
fputs("\007", stdout_fp);
#endif
@ -225,14 +227,14 @@ const IConsoleWriter ConsoleWriter_Stdout =
// ConsoleAssert
// --------------------------------------------------------------------------------------
static void ConsoleAssert_DoWrite(const wxString& fmt)
static void ConsoleAssert_DoWrite(const char* fmt)
{
pxFail(L"Console class has not been initialized; Message written:\n\t" + fmt);
pxFailRel("Console class has not been initialized");
}
static void ConsoleAssert_DoWriteLn(const wxString& fmt)
static void ConsoleAssert_DoWriteLn(const char* fmt)
{
pxFail(L"Console class has not been initialized; Message written:\n\t" + fmt);
pxFailRel("Console class has not been initialized");
}
const IConsoleWriter ConsoleWriter_Assert =
@ -258,16 +260,27 @@ const IConsoleWriter ConsoleWriter_Assert =
// glob_indent - this parameter is used to specify a global indentation setting. It is used by
// WriteLn function, but defaults to 0 for Warning and Error calls. Local indentation always
// applies to all writes.
wxString IConsoleWriter::_addIndentation(const wxString& src, int glob_indent = 0) const
std::string IConsoleWriter::_addIndentation(const std::string& src, int glob_indent = 0) const
{
const int indent = glob_indent + _imm_indentation;
if (indent == 0)
return src;
wxString result(src);
const wxString indentStr(L'\t', indent);
result.Replace(L"\n", L"\n" + indentStr);
return indentStr + result;
std::string indentStr;
for (int i = 0; i < indent; i++)
indentStr += '\t';
std::string result;
result.reserve(src.length() + 16 * indent);
result.append(indentStr);
result.append(src);
std::string::size_type pos = result.find('\n');
while (pos != std::string::npos)
{
result.insert(pos + 1, indentStr);
pos = result.find('\n', pos + 1);
}
return result;
}
// Sets the indentation to be applied to all WriteLn's. The indentation is added to the
@ -324,7 +337,16 @@ const IConsoleWriter& IConsoleWriter::ClearColor() const
bool IConsoleWriter::FormatV(const char* fmt, va_list args) const
{
DoWriteLn(_addIndentation(pxsFmtV(fmt, args), conlog_Indent));
// TODO: Make this less rubbish
if ((_imm_indentation + conlog_Indent) > 0)
{
DoWriteLn(_addIndentation(StringUtil::StdStringFromFormatV(fmt, args), conlog_Indent).c_str());
}
else
{
DoWriteLn(StringUtil::StdStringFromFormatV(fmt, args).c_str());
}
return false;
}
@ -371,105 +393,6 @@ bool IConsoleWriter::Warning(const char* fmt, ...) const
return false;
}
// --------------------------------------------------------------------------------------
// Write Variants - Unicode/UTF16 style
// --------------------------------------------------------------------------------------
bool IConsoleWriter::FormatV(const wxChar* fmt, va_list args) const
{
DoWriteLn(_addIndentation(pxsFmtV(fmt, args), conlog_Indent));
return false;
}
bool IConsoleWriter::WriteLn(const wxChar* fmt, ...) const
{
va_list args;
va_start(args, fmt);
FormatV(fmt, args);
va_end(args);
return false;
}
bool IConsoleWriter::WriteLn(ConsoleColors color, const wxChar* fmt, ...) const
{
va_list args;
va_start(args, fmt);
ConsoleColorScope cs(color);
FormatV(fmt, args);
va_end(args);
return false;
}
bool IConsoleWriter::Error(const wxChar* fmt, ...) const
{
va_list args;
va_start(args, fmt);
ConsoleColorScope cs(Color_StrongRed);
FormatV(fmt, args);
va_end(args);
return false;
}
bool IConsoleWriter::Warning(const wxChar* fmt, ...) const
{
va_list args;
va_start(args, fmt);
ConsoleColorScope cs(Color_StrongOrange);
FormatV(fmt, args);
va_end(args);
return false;
}
// --------------------------------------------------------------------------------------
// Write Variants - Unknown style
// --------------------------------------------------------------------------------------
bool IConsoleWriter::WriteLn(const wxString fmt, ...) const
{
va_list args;
va_start(args, fmt);
FormatV(fmt.wx_str(), args);
va_end(args);
return false;
}
bool IConsoleWriter::WriteLn(ConsoleColors color, const wxString fmt, ...) const
{
va_list args;
va_start(args, fmt);
ConsoleColorScope cs(color);
FormatV(fmt.wx_str(), args);
va_end(args);
return false;
}
bool IConsoleWriter::Error(const wxString fmt, ...) const
{
va_list args;
va_start(args, fmt);
ConsoleColorScope cs(Color_StrongRed);
FormatV(fmt.wx_str(), args);
va_end(args);
return false;
}
bool IConsoleWriter::Warning(const wxString fmt, ...) const
{
va_list args;
va_start(args, fmt);
ConsoleColorScope cs(Color_StrongOrange);
FormatV(fmt.wx_str(), args);
va_end(args);
return false;
}
bool IConsoleWriter::WriteLn(ConsoleColors color, const std::string& str) const
{
ConsoleColorScope cs(color);
@ -478,7 +401,15 @@ bool IConsoleWriter::WriteLn(ConsoleColors color, const std::string& str) const
bool IConsoleWriter::WriteLn(const std::string& str) const
{
DoWriteLn(_addIndentation(fromUTF8(str), conlog_Indent));
// TODO: Make this less rubbish
if ((_imm_indentation + conlog_Indent) > 0)
{
DoWriteLn(_addIndentation(str, conlog_Indent).c_str());
}
else
{
DoWriteLn(str.c_str());
}
return false;
}
@ -533,11 +464,7 @@ ConsoleIndentScope::ConsoleIndentScope(int tabs)
ConsoleIndentScope::~ConsoleIndentScope()
{
try
{
LeaveScope();
}
DESTRUCTOR_CATCHALL
LeaveScope();
}
void ConsoleIndentScope::EnterScope()
@ -560,12 +487,8 @@ ConsoleAttrScope::ConsoleAttrScope(ConsoleColors newcolor, int indent)
ConsoleAttrScope::~ConsoleAttrScope()
{
try
{
Console.SetColor(m_old_color);
Console.SetIndent(-m_tabsize);
}
DESTRUCTOR_CATCHALL
Console.SetColor(m_old_color);
Console.SetIndent(-m_tabsize);
}
@ -599,14 +522,7 @@ NullConsoleWriter NullCon = {};
bool ConsoleLogSource::WriteV(ConsoleColors color, const char* fmt, va_list list) const
{
ConsoleColorScope cs(color);
DoWrite(pxsFmtV(fmt, list).c_str());
return false;
}
bool ConsoleLogSource::WriteV(ConsoleColors color, const wxChar* fmt, va_list list) const
{
ConsoleColorScope cs(color);
DoWrite(pxsFmtV(fmt, list).c_str());
Console.WriteLn(StringUtil::StdStringFromFormatV(fmt, list));
return false;
}
@ -618,9 +534,3 @@ bool ConsoleLogSource::WriteV(const char* fmt, va_list list) const
WriteV(DefaultColor, fmt, list);
return false;
}
bool ConsoleLogSource::WriteV(const wxChar* fmt, va_list list) const
{
WriteV(DefaultColor, fmt, list);
return false;
}

44
common/Console.h
View File

@ -15,7 +15,9 @@
#pragma once
#include "common/StringHelpers.h"
#include "Pcsx2Defs.h"
#include <string>
enum ConsoleColors
{
@ -70,11 +72,11 @@ struct IConsoleWriter
{
// A direct console write, without tabbing or newlines. Useful to devs who want to do quick
// logging of various junk; but should *not* be used in production code due.
void(* WriteRaw)(const wxString& fmt);
void(* WriteRaw)(const char* fmt);
// WriteLn implementation for internal use only. Bypasses tabbing, prefixing, and other
// formatting.
void(* DoWriteLn)(const wxString& fmt);
void(* DoWriteLn)(const char* fmt);
// SetColor implementation for internal use only.
void(* DoSetColor)(ConsoleColors color);
@ -82,16 +84,16 @@ struct IConsoleWriter
// Special implementation of DoWrite that's pretty much for MSVC use only.
// All implementations should map to DoWrite, except Stdio which should map to Null.
// (This avoids circular/recursive stdio output)
void(* DoWriteFromStdout)(const wxString& fmt);
void(* DoWriteFromStdout)(const char* fmt);
void(* Newline)();
void(* SetTitle)(const wxString& title);
void(* SetTitle)(const char* title);
// internal value for indentation of individual lines. Use the Indent() member to invoke.
int _imm_indentation;
// For internal use only.
wxString _addIndentation(const wxString& src, int glob_indent) const;
std::string _addIndentation(const std::string& src, int glob_indent) const;
// ----------------------------------------------------------------------------
// Public members; call these to print stuff to console!
@ -112,17 +114,6 @@ struct IConsoleWriter
bool Error(const char* fmt, ...) const;
bool Warning(const char* fmt, ...) const;
bool FormatV(const wxChar* fmt, va_list args) const;
bool WriteLn(ConsoleColors color, const wxChar* fmt, ...) const;
bool WriteLn(const wxChar* fmt, ...) const;
bool Error(const wxChar* fmt, ...) const;
bool Warning(const wxChar* fmt, ...) const;
bool WriteLn(ConsoleColors color, const wxString fmt, ...) const;
bool WriteLn(const wxString fmt, ...) const;
bool Error(const wxString fmt, ...) const;
bool Warning(const wxString fmt, ...) const;
bool WriteLn(ConsoleColors color, const std::string& str) const;
bool WriteLn(const std::string& str) const;
bool Error(const std::string& str) const;
@ -136,12 +127,12 @@ struct IConsoleWriter
//
struct NullConsoleWriter
{
void WriteRaw(const wxString& fmt) {}
void DoWriteLn(const wxString& fmt) {}
void WriteRaw(const char* fmt) {}
void DoWriteLn(const char* fmt) {}
void DoSetColor(ConsoleColors color) {}
void DoWriteFromStdout(const wxString& fmt) {}
void DoWriteFromStdout(const char* fmt) {}
void Newline() {}
void SetTitle(const wxString& title) {}
void SetTitle(const char* title) {}
ConsoleColors GetColor() const { return Color_Current; }
@ -156,17 +147,6 @@ struct NullConsoleWriter
bool WriteLn(const char* fmt, ...) const { return false; }
bool Error(const char* fmt, ...) const { return false; }
bool Warning(const char* fmt, ...) const { return false; }
bool FormatV(const wxChar* fmt, va_list args) const { return false; }
bool WriteLn(ConsoleColors color, const wxChar* fmt, ...) const { return false; }
bool WriteLn(const wxChar* fmt, ...) const { return false; }
bool Error(const wxChar* fmt, ...) const { return false; }
bool Warning(const wxChar* fmt, ...) const { return false; }
bool WriteLn(ConsoleColors color, const wxString fmt, ...) const { return false; }
bool WriteLn(const wxString fmt, ...) const { return false; }
bool Error(const wxString fmt, ...) const { return false; }
bool Warning(const wxString fmt, ...) const { return false; }
};
// --------------------------------------------------------------------------------------

3
common/Darwin/DarwinMisc.cpp
View File

@ -23,6 +23,7 @@
#include <wx/string.h>
#include "common/Pcsx2Types.h"
#include "common/General.h"
// Darwin (OSX) is a bit different from Linux when requesting properties of
// the OS because of its BSD/Mach heritage. Helpfully, most of this code
@ -85,7 +86,7 @@ static std::string sysctl_str(int category, int name)
return std::string(buf, len > 0 ? len - 1 : 0);
}
wxString GetOSVersionString()
std::string GetOSVersionString()
{
std::string type = sysctl_str(CTL_KERN, KERN_OSTYPE);
std::string release = sysctl_str(CTL_KERN, KERN_OSRELEASE);

240
common/Dependencies.h
View File

@ -1,240 +0,0 @@
/* PCSX2 - PS2 Emulator for PCs
* Copyright (C) 2002-2010 PCSX2 Dev Team
*
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
* of the GNU Lesser General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with PCSX2.
* If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
// Dependencies.h : Contains classes required by all Utilities headers.
// This file is included by most .h files provided by the Utilities class.
#include "pxForwardDefs.h"
// This should prove useful....
#define wxsFormat wxString::Format
// --------------------------------------------------------------------------------------
// ImplementEnumOperators (macro)
// --------------------------------------------------------------------------------------
// This macro implements ++/-- operators for any conforming enumeration. In order for an
// enum to conform, it must have _FIRST and _COUNT members defined, and must have a full
// compliment of sequential members (no custom assignments) --- looking like so:
//
// enum Dummy {
// Dummy_FIRST,
// Dummy_Item = Dummy_FIRST,
// Dummy_Crap,
// Dummy_COUNT
// };
//
// The macro also defines utility functions for bounds checking enumerations:
// EnumIsValid(value); // returns TRUE if the enum value is between FIRST and COUNT.
// EnumAssert(value);
//
// It also defines a *prototype* for converting the enumeration to a string. Note that this
// method is not implemented! You must implement it yourself if you want to use it:
// EnumToString(value);
//
#define ImplementEnumOperators(enumName) \
static __fi enumName& operator++(enumName& src) \
{ \
src = (enumName)((int)src + 1); \
return src; \
} \
\
static __fi enumName& operator--(enumName& src) \
{ \
src = (enumName)((int)src - 1); \
return src; \
} \
\
static __fi enumName operator++(enumName& src, int) \
{ \
enumName orig = src; \
src = (enumName)((int)src + 1); \
return orig; \
} \
\
static __fi enumName operator--(enumName& src, int) \
{ \
enumName orig = src; \
src = (enumName)((int)src - 1); \
return orig; \
} \
\
static __fi bool operator<(const enumName& left, const pxEnumEnd_t&) { return (int)left < enumName##_COUNT; } \
static __fi bool operator!=(const enumName& left, const pxEnumEnd_t&) { return (int)left != enumName##_COUNT; } \
static __fi bool operator==(const enumName& left, const pxEnumEnd_t&) { return (int)left == enumName##_COUNT; } \
\
static __fi bool EnumIsValid(enumName id) \
{ \
return ((int)id >= enumName##_FIRST) && ((int)id < enumName##_COUNT); \
} \
\
static __fi void EnumAssert(enumName id) \
{ \
pxAssert(EnumIsValid(id)); \
} \
\
extern const char* EnumToString(enumName id)
class pxEnumEnd_t
{
};
static const pxEnumEnd_t pxEnumEnd = {};
// --------------------------------------------------------------------------------------
// DeclareNoncopyableObject
// --------------------------------------------------------------------------------------
// This macro provides an easy and clean method for ensuring objects are not copyable.
// Simply add the macro to the head or tail of your class declaration, and attempts to
// copy the class will give you a moderately obtuse compiler error that will have you
// scratching your head for 20 minutes.
//
// (... but that's probably better than having a weird invalid object copy having you
// scratch your head for a day).
//
// Programmer's notes:
// * We intentionally do NOT provide implementations for these methods, which should
// never be referenced anyway.
// * I've opted for macro form over multi-inherited class form (Boost style), because
// the errors generated by the macro are considerably less voodoo. The Boost-style
// The macro reports the exact class that causes the copy failure, while Boost's class
// approach just reports an error in whatever "NoncopyableObject" is inherited.
//
// * This macro is the same as wxWidgets' DECLARE_NO_COPY_CLASS macro. This one is free
// of wx dependencies though, and has a nicer typeset. :)
//
#ifndef DeclareNoncopyableObject
#define DeclareNoncopyableObject(classname) \
public: \
classname(const classname&) = delete; \
classname& operator=(const classname&) = delete
#endif
// --------------------------------------------------------------------------------------
// _(x) / _t(x) / _d(x) / pxL(x) / pxLt(x) [macros]
// --------------------------------------------------------------------------------------
// Define pxWex's own i18n helpers. These override the wxWidgets helpers and provide
// additional functionality. Define them FIRST THING, to make sure that wx's own gettext
// macros aren't in place.
//
// _ is for standard translations
// _t is for tertiary low priority translations
// _d is for debug/devel build translations
#define WXINTL_NO_GETTEXT_MACRO
#ifndef _
#define _(s) pxGetTranslation(_T(s))
#endif
#ifndef _t
#define _t(s) pxGetTranslation(_T(s))
#endif
#ifndef _d
#define _d(s) pxGetTranslation(_T(s))
#endif
// pxL / pxLt / pxDt -- macros provided for tagging translation strings, without actually running
// them through the translator (which the _() does automatically, and sometimes we don't
// want that). This is a shorthand replacement for wxTRANSLATE. pxL is a standard translation
// moniker. pxLt is for tertiary strings that have a very low translation priority. pxDt is for
// debug/devel specific translations.
//
#ifndef pxL
#define pxL(a) wxT(a)
#endif
#ifndef pxLt
#define pxLt(a) wxT(a)
#endif
#ifndef pxDt
#define pxDt(a) wxT(a)
#endif
#include <wx/string.h>
#include <wx/intl.h>
#include <wx/log.h>
#include <wx/crt.h>
#if defined(_WIN32)
// This deals with a mode_t redefinition conflict. The mode_t doesn't seem to be
// used anywhere in w32pthreads, so I've chosen to use the wxWidgets mode_t
// (I think it's unsigned int vs signed int)
#include <wx/filefn.h>
#define HAVE_MODE_T
#endif
#include <stdexcept>
#include <cstring> // string.h under c++
#include <cstdio> // stdio.h under c++
#include <cstdlib>
#include <vector>
#include <list>
#include <algorithm>
#include <memory>
#include <atomic>
#include <thread>
#include "Pcsx2Defs.h"
// --------------------------------------------------------------------------------------
// Handy Human-readable constants for common immediate values (_16kb -> _4gb)
static const sptr _1kb = 1024 * 1;
static const sptr _4kb = _1kb * 4;
static const sptr _16kb = _1kb * 16;
static const sptr _32kb = _1kb * 32;
static const sptr _64kb = _1kb * 64;
static const sptr _128kb = _1kb * 128;
static const sptr _256kb = _1kb * 256;
static const s64 _1mb = 1024 * 1024;
static const s64 _8mb = _1mb * 8;
static const s64 _16mb = _1mb * 16;
static const s64 _32mb = _1mb * 32;
static const s64 _64mb = _1mb * 64;
static const s64 _256mb = _1mb * 256;
static const s64 _1gb = _1mb * 1024;
static const s64 _4gb = _1gb * 4;
// --------------------------------------------------------------------------------------
// pxE(msg) and pxEt(msg) [macros] => now same as _/_t/_d
// --------------------------------------------------------------------------------------
#define pxE(english) pxExpandMsg((english))
// For use with tertiary translations (low priority).
#define pxEt(english) pxExpandMsg((english))
// For use with Dev/debug build translations (low priority).
#define pxE_dev(english) pxExpandMsg((english))
extern const wxChar* pxExpandMsg(const wxChar* message);
extern const wxChar* pxGetTranslation(const wxChar* message);
extern bool pxIsEnglish(int id);
extern wxString fromUTF8(const std::string& str);
extern wxString fromUTF8(const char* src);
extern wxString fromAscii(const char* src);
#include "common/Assertions.h"
#include "common/Exceptions.h"
#include "common/AlignedMalloc.h"

3
common/EventSource.cpp
View File

@ -17,7 +17,4 @@
#include "EventSource.h"
#include "EventSource.inl"
#include <wx/event.h>
//template class EventSource< wxCommandEvent >;
//template class EventSource< int >;

8
common/EventSource.inl
View File

@ -75,21 +75,21 @@ __fi void EventSource<ListenerType>::_DispatchRaw(ListenerIterator iter, const L
{
if (IsDevBuild)
{
pxFailDev(L"Ignoring runtime error thrown from event listener (event listeners should not throw exceptions!): " + ex.FormatDiagnosticMessage());
pxFailDev(("Ignoring runtime error thrown from event listener (event listeners should not throw exceptions!): " + ex.FormatDiagnosticMessage()).c_str());
}
else
{
Console.Error(L"Ignoring runtime error thrown from event listener: " + ex.FormatDiagnosticMessage());
Console.Error("Ignoring runtime error thrown from event listener: %s", ex.FormatDiagnosticMessage().c_str());
}
}
catch (BaseException& ex)
{
if (IsDevBuild)
{
ex.DiagMsg() = L"Non-runtime BaseException thrown from event listener .. " + ex.DiagMsg();
ex.DiagMsg() = "Non-runtime BaseException thrown from event listener .. " + ex.DiagMsg();
throw;
}
Console.Error(L"Ignoring non-runtime BaseException thrown from event listener: " + ex.FormatDiagnosticMessage());
Console.Error("Ignoring non-runtime BaseException thrown from event listener: %s", ex.FormatDiagnosticMessage().c_str());
}
++iter;
}

279
common/Exceptions.cpp
View File

@ -13,20 +13,19 @@
* If not, see <http://www.gnu.org/licenses/>.
*/
#define WXINTL_NO_GETTEXT_MACRO
#include "Threading.h"
#include "General.h"
#include "Exceptions.h"
#include <wx/app.h>
#if defined(__UNIX__)
#include <signal.h>
#include "fmt/core.h"
#ifdef _WIN32
#include "RedtapeWindows.h"
#endif
#include "common/Dependencies.h" // _ macro
#include "common/Threading.h"
#include "common/General.h"
#include "common/StringHelpers.h"
// for lack of a better place...
Fnptr_OutOfMemory pxDoOutOfMemory = NULL;
#ifdef __UNIX__
#include <signal.h>
#endif
// ------------------------------------------------------------------------
// Force DevAssert to *not* inline for devel builds (allows using breakpoints to trap assertions,
@ -43,20 +42,20 @@ pxDoAssertFnType* pxDoAssert = pxAssertImpl_LogIt;
// make life easier for people using VC++ IDE by using this format, which allows double-click
// response times from the Output window...
wxString DiagnosticOrigin::ToString(const wxChar* msg) const
std::string DiagnosticOrigin::ToString(const char* msg) const
{
FastFormatUnicode message;
std::string message;
message.Write(L"%ls(%d) : assertion failed:\n", srcfile, line);
fmt::format_to(std::back_inserter(message), "{}({}) : assertion failed:\n", srcfile, line);
if (function != NULL)
message.Write(" Function: %s\n", function);
if (function)
fmt::format_to(std::back_inserter(message), " Function: {}\n", function);
if (condition != NULL)
message.Write(L" Condition: %ls\n", condition);
if (condition)
fmt::format_to(std::back_inserter(message), " Condition: {}\n", condition);
if (msg != NULL)
message.Write(L" Message: %ls\n", msg);
if (msg)
fmt::format_to(std::back_inserter(message), " Message: {}\n", msg);
return message;
}
@ -65,34 +64,33 @@ wxString DiagnosticOrigin::ToString(const wxChar* msg) const
// Because wxTrap isn't available on Linux builds of wxWidgets (non-Debug, typically)
void pxTrap()
{
#if defined(__WXMSW__) && !defined(__WXMICROWIN__)
#if defined(_WIN32)
__debugbreak();
#elif defined(__WXMAC__) && !defined(__DARWIN__)
#if __powerc
Debugger();
#else
SysBreak();
#endif
#elif defined(_MSL_USING_MW_C_HEADERS) && _MSL_USING_MW_C_HEADERS
Debugger();
#elif defined(__UNIX__)
raise(SIGTRAP);
#else
// TODO
#endif // Win/Unix
abort();
#endif
}
bool pxAssertImpl_LogIt(const DiagnosticOrigin& origin, const wxChar* msg)
bool pxAssertImpl_LogIt(const DiagnosticOrigin& origin, const char* msg)
{
//wxLogError( L"%s", origin.ToString( msg ).c_str() );
wxMessageOutputDebug().Printf(L"%s", origin.ToString(msg).c_str());
std::string full_msg(origin.ToString(msg));
#ifdef _WIN32
OutputDebugStringA(full_msg.c_str());
OutputDebugStringA("\n");
#endif
std::fprintf(stderr, "%s\n", full_msg.c_str());
pxTrap();
return false;
}
DEVASSERT_INLINE void pxOnAssert(const DiagnosticOrigin& origin, const wxString& msg)
DEVASSERT_INLINE void pxOnAssert(const DiagnosticOrigin& origin, const char* msg)
{
// wxWidgets doesn't come with debug builds on some Linux distros, and other distros make
// it difficult to use the debug build (compilation failures). To handle these I've had to
@ -104,11 +102,11 @@ DEVASSERT_INLINE void pxOnAssert(const DiagnosticOrigin& origin, const wxString&
if (pxDoAssert == NULL)
{
// Note: Format uses MSVC's syntax for output window hotlinking.
trapit = pxAssertImpl_LogIt(origin, msg.wc_str());
trapit = pxAssertImpl_LogIt(origin, msg);
}
else
{
trapit = pxDoAssert(origin, msg.wc_str());
trapit = pxDoAssert(origin, msg);
}
if (trapit)
@ -121,83 +119,87 @@ DEVASSERT_INLINE void pxOnAssert(const DiagnosticOrigin& origin, const wxString&
// BaseException (implementations)
// --------------------------------------------------------------------------------------
BaseException& BaseException::SetBothMsgs(const wxChar* msg_diag)
BaseException& BaseException::SetBothMsgs(const char* msg_diag)
{
m_message_user = msg_diag ? wxString(wxGetTranslation(msg_diag)) : wxString("");
m_message_user = msg_diag ? std::string(msg_diag) : std::string();
return SetDiagMsg(msg_diag);
}
BaseException& BaseException::SetDiagMsg(const wxString& msg_diag)
BaseException& BaseException::SetDiagMsg(std::string msg_diag)
{
m_message_diag = msg_diag;
m_message_diag = std::move(msg_diag);
return *this;
}
BaseException& BaseException::SetUserMsg(const wxString& msg_user)
BaseException& BaseException::SetUserMsg(std::string msg_user)
{
m_message_user = msg_user;
m_message_user = std::move(msg_user);
return *this;
}
wxString BaseException::FormatDiagnosticMessage() const
std::string BaseException::FormatDiagnosticMessage() const
{
return m_message_diag;
}
wxString BaseException::FormatDisplayMessage() const
std::string BaseException::FormatDisplayMessage() const
{
return m_message_user.IsEmpty() ? m_message_diag : m_message_user;
return m_message_user.empty() ? m_message_diag : m_message_user;
}
// --------------------------------------------------------------------------------------
// Exception::RuntimeError (implementations)
// --------------------------------------------------------------------------------------
Exception::RuntimeError::RuntimeError(const std::runtime_error& ex, const wxString& prefix)
Exception::RuntimeError::RuntimeError(const std::runtime_error& ex, const char* prefix /* = nullptr */)
{
IsSilent = false;
SetDiagMsg(pxsFmt(L"STL Runtime Error%s: %s",
(prefix.IsEmpty() ? L"" : pxsFmt(L" (%s)", WX_STR(prefix)).c_str()),
WX_STR(fromUTF8(ex.what()))));
const bool has_prefix = prefix && prefix[0] != 0;
SetDiagMsg(fmt::format("STL Runtime Error{}{}{}: {}",
has_prefix ? " (" : "", prefix ? prefix : "", has_prefix ? ")" : "",
ex.what()));
}
Exception::RuntimeError::RuntimeError(const std::exception& ex, const wxString& prefix)
Exception::RuntimeError::RuntimeError(const std::exception& ex, const char* prefix /* = nullptr */)
{
IsSilent = false;
SetDiagMsg(pxsFmt(L"STL Exception%s: %s",
(prefix.IsEmpty() ? L"" : pxsFmt(L" (%s)", WX_STR(prefix)).c_str()),
WX_STR(fromUTF8(ex.what()))));
const bool has_prefix = prefix && prefix[0] != 0;
SetDiagMsg(fmt::format("STL Exception{}{}{}: {}",
has_prefix ? " (" : "", prefix ? prefix : "", has_prefix ? ")" : "",
ex.what()));
}
// --------------------------------------------------------------------------------------
// Exception::OutOfMemory (implementations)
// --------------------------------------------------------------------------------------
Exception::OutOfMemory::OutOfMemory(const wxString& allocdesc)
Exception::OutOfMemory::OutOfMemory(std::string allocdesc)
: AllocDescription(std::move(allocdesc))
{
AllocDescription = allocdesc;
}
wxString Exception::OutOfMemory::FormatDiagnosticMessage() const
std::string Exception::OutOfMemory::FormatDiagnosticMessage() const
{
FastFormatUnicode retmsg;
retmsg.Write(L"Out of memory");
if (!AllocDescription.IsEmpty())
retmsg.Write(L" while allocating '%s'", WX_STR(AllocDescription));
std::string retmsg;
retmsg = "Out of memory";
if (!AllocDescription.empty())
fmt::format_to(std::back_inserter(retmsg), " while allocating '{}'", AllocDescription);
if (!m_message_diag.IsEmpty())
retmsg.Write(L":\n%s", WX_STR(m_message_diag));
if (!m_message_diag.empty())
fmt::format_to(std::back_inserter(retmsg), ":\n{}", m_message_diag);
return retmsg;
}
wxString Exception::OutOfMemory::FormatDisplayMessage() const
std::string Exception::OutOfMemory::FormatDisplayMessage() const
{
FastFormatUnicode retmsg;
retmsg.Write(L"%s", _("Oh noes! Out of memory!"));
std::string retmsg;
retmsg = "Oh noes! Out of memory!";
if (!m_message_user.IsEmpty())
retmsg.Write(L"\n\n%s", WX_STR(m_message_user));
if (!m_message_user.empty())
fmt::format_to(std::back_inserter(retmsg), "\n\n{}", m_message_user);
return retmsg;
}
@ -206,106 +208,104 @@ wxString Exception::OutOfMemory::FormatDisplayMessage() const
// --------------------------------------------------------------------------------------
// Exception::VirtualMemoryMapConflict (implementations)
// --------------------------------------------------------------------------------------
Exception::VirtualMemoryMapConflict::VirtualMemoryMapConflict(const wxString& allocdesc)
Exception::VirtualMemoryMapConflict::VirtualMemoryMapConflict(std::string allocdesc)
{
AllocDescription = allocdesc;
m_message_user = _("Virtual memory mapping failure! Your system may have conflicting device drivers, services, or may simply have insufficient memory or resources to meet PCSX2's lofty needs.");
AllocDescription = std::move(allocdesc);
m_message_user = "Virtual memory mapping failure! Your system may have conflicting device drivers, services, or may simply have insufficient memory or resources to meet PCSX2's lofty needs.";
}
wxString Exception::VirtualMemoryMapConflict::FormatDiagnosticMessage() const
std::string Exception::VirtualMemoryMapConflict::FormatDiagnosticMessage() const
{
FastFormatUnicode retmsg;
retmsg.Write(L"Virtual memory map failed");
if (!AllocDescription.IsEmpty())
retmsg.Write(L" while reserving '%s'", WX_STR(AllocDescription));
std::string retmsg;
retmsg = "Virtual memory map failed";
if (!AllocDescription.empty())
fmt::format_to(std::back_inserter(retmsg), " while reserving '{}'", AllocDescription);
if (!m_message_diag.IsEmpty())
retmsg.Write(L":\n%s", WX_STR(m_message_diag));
if (!m_message_diag.empty())
fmt::format_to(std::back_inserter(retmsg), ":\n{}", m_message_diag);
return retmsg;
}
wxString Exception::VirtualMemoryMapConflict::FormatDisplayMessage() const
std::string Exception::VirtualMemoryMapConflict::FormatDisplayMessage() const
{
FastFormatUnicode retmsg;
retmsg.Write(L"%s",
pxE(L"There is not enough virtual memory available, or necessary virtual memory mappings have already been reserved by other processes, services, or DLLs."));
std::string retmsg;
retmsg = "There is not enough virtual memory available, or necessary virtual memory mappings have already been reserved by other processes, services, or DLLs.";
if (!m_message_diag.IsEmpty())
retmsg.Write(L"\n\n%s", WX_STR(m_message_diag));
if (!m_message_diag.empty())
fmt::format_to(std::back_inserter(retmsg), "\n\n{}", m_message_diag);
return retmsg;
}
// ------------------------------------------------------------------------
wxString Exception::CancelEvent::FormatDiagnosticMessage() const
std::string Exception::CancelEvent::FormatDiagnosticMessage() const
{
return L"Action canceled: " + m_message_diag;
return "Action canceled: " + m_message_diag;
}
wxString Exception::CancelEvent::FormatDisplayMessage() const
std::string Exception::CancelEvent::FormatDisplayMessage() const
{
return L"Action canceled: " + m_message_diag;
return "Action canceled: " + m_message_diag;
}
// --------------------------------------------------------------------------------------
// Exception::BadStream (implementations)
// --------------------------------------------------------------------------------------
wxString Exception::BadStream::FormatDiagnosticMessage() const
std::string Exception::BadStream::FormatDiagnosticMessage() const
{
FastFormatUnicode retval;
std::string retval;
_formatDiagMsg(retval);
return retval;
}
wxString Exception::BadStream::FormatDisplayMessage() const
std::string Exception::BadStream::FormatDisplayMessage() const
{
FastFormatUnicode retval;
std::string retval;
_formatUserMsg(retval);
return retval;
}
void Exception::BadStream::_formatDiagMsg(FastFormatUnicode& dest) const
void Exception::BadStream::_formatDiagMsg(std::string& dest) const
{
dest.Write(L"Path: ");
if (!StreamName.IsEmpty())
dest.Write(L"%s", WX_STR(StreamName));
fmt::format_to(std::back_inserter(dest), "Path: ");
if (!StreamName.empty())
fmt::format_to(std::back_inserter(dest), "{}", StreamName);
else
dest.Write(L"[Unnamed or unknown]");
dest += "[Unnamed or unknown]";
if (!m_message_diag.IsEmpty())
dest.Write(L"\n%s", WX_STR(m_message_diag));
if (!m_message_diag.empty())
fmt::format_to(std::back_inserter(dest), "\n{}", m_message_diag);
}
void Exception::BadStream::_formatUserMsg(FastFormatUnicode& dest) const
void Exception::BadStream::_formatUserMsg(std::string& dest) const
{
dest.Write(_("Path: "));
if (!StreamName.IsEmpty())
dest.Write(L"%s", WX_STR(StreamName));
fmt::format_to(std::back_inserter(dest), "Path: ");
if (!StreamName.empty())
fmt::format_to(std::back_inserter(dest), "{}", StreamName);
else
dest.Write(_("[Unnamed or unknown]"));
dest += "[Unnamed or unknown]";
if (!m_message_user.IsEmpty())
dest.Write(L"\n%s", WX_STR(m_message_user));
if (!m_message_user.empty())
fmt::format_to(std::back_inserter(dest), "\n{}", m_message_user);
}
// --------------------------------------------------------------------------------------
// Exception::CannotCreateStream (implementations)
// --------------------------------------------------------------------------------------
wxString Exception::CannotCreateStream::FormatDiagnosticMessage() const
std::string Exception::CannotCreateStream::FormatDiagnosticMessage() const
{
FastFormatUnicode retval;
retval.Write("File could not be created.");
std::string retval;
retval = "File could not be created.";
_formatDiagMsg(retval);
return retval;
}
wxString Exception::CannotCreateStream::FormatDisplayMessage() const
std::string Exception::CannotCreateStream::FormatDisplayMessage() const
{
FastFormatUnicode retval;
retval.Write(_("A file could not be created."));
retval.Write("\n");
std::string retval;
retval = "A file could not be created.\n";
_formatUserMsg(retval);
return retval;
}
@ -313,19 +313,18 @@ wxString Exception::CannotCreateStream::FormatDisplayMessage() const
// --------------------------------------------------------------------------------------
// Exception::FileNotFound (implementations)
// --------------------------------------------------------------------------------------
wxString Exception::FileNotFound::FormatDiagnosticMessage() const
std::string Exception::FileNotFound::FormatDiagnosticMessage() const
{
FastFormatUnicode retval;
retval.Write("File not found.\n");
std::string retval;
retval = "File not found.\n";
_formatDiagMsg(retval);
return retval;
}
wxString Exception::FileNotFound::FormatDisplayMessage() const
std::string Exception::FileNotFound::FormatDisplayMessage() const
{
FastFormatUnicode retval;
retval.Write(_("File not found."));
retval.Write("\n");
std::string retval;
retval = "File not found.\n";
_formatUserMsg(retval);
return retval;
}
@ -333,19 +332,18 @@ wxString Exception::FileNotFound::FormatDisplayMessage() const
// --------------------------------------------------------------------------------------
// Exception::AccessDenied (implementations)
// --------------------------------------------------------------------------------------
wxString Exception::AccessDenied::FormatDiagnosticMessage() const
std::string Exception::AccessDenied::FormatDiagnosticMessage() const
{
FastFormatUnicode retval;
retval.Write("Permission denied to file.\n");
std::string retval;
retval = "Permission denied to file.\n";
_formatDiagMsg(retval);
return retval;
}
wxString Exception::AccessDenied::FormatDisplayMessage() const
std::string Exception::AccessDenied::FormatDisplayMessage() const
{
FastFormatUnicode retval;
retval.Write(_("Permission denied while trying to open file, likely due to insufficient user account rights."));
retval.Write("\n");
std::string retval;
retval = "Permission denied while trying to open file, likely due to insufficient user account rights.\n";
_formatUserMsg(retval);
return retval;
}
@ -353,19 +351,18 @@ wxString Exception::AccessDenied::FormatDisplayMessage() const
// --------------------------------------------------------------------------------------
// Exception::EndOfStream (implementations)
// --------------------------------------------------------------------------------------
wxString Exception::EndOfStream::FormatDiagnosticMessage() const
std::string Exception::EndOfStream::FormatDiagnosticMessage() const
{
FastFormatUnicode retval;
retval.Write("Unexpected end of file or stream.\n");
std::string retval;
retval = "Unexpected end of file or stream.\n";
_formatDiagMsg(retval);
return retval;
}
wxString Exception::EndOfStream::FormatDisplayMessage() const
std::string Exception::EndOfStream::FormatDisplayMessage() const
{
FastFormatUnicode retval;
retval.Write(_("Unexpected end of file or stream encountered. File is probably truncated or corrupted."));
retval.Write("\n");
std::string retval;
retval = "Unexpected end of file or stream encountered. File is probably truncated or corrupted.\n";
_formatUserMsg(retval);
return retval;
}
@ -376,35 +373,35 @@ wxString Exception::EndOfStream::FormatDisplayMessage() const
// Translates an Errno code into an exception.
// Throws an exception based on the given error code (usually taken from ANSI C's errno)
BaseException* Exception::FromErrno(const wxString& streamname, int errcode)
BaseException* Exception::FromErrno(std::string streamname, int errcode)
{
pxAssumeDev(errcode != 0, "Invalid NULL error code? (errno)");
switch (errcode)
{
case EINVAL:
pxFailDev(L"Invalid argument");
return &(new Exception::BadStream(streamname))->SetDiagMsg(L"Invalid argument? (likely caused by an unforgivable programmer error!)");
pxFailDev("Invalid argument");
return &(new Exception::BadStream(streamname))->SetDiagMsg("Invalid argument? (likely caused by an unforgivable programmer error!)");
case EACCES: // Access denied!
return new Exception::AccessDenied(streamname);
case EMFILE: // Too many open files!
return &(new Exception::CannotCreateStream(streamname))->SetDiagMsg(L"Too many open files"); // File handle allocation failure
return &(new Exception::CannotCreateStream(streamname))->SetDiagMsg("Too many open files"); // File handle allocation failure
case EEXIST:
return &(new Exception::CannotCreateStream(streamname))->SetDiagMsg(L"File already exists");
return &(new Exception::CannotCreateStream(streamname))->SetDiagMsg("File already exists");
case ENOENT: // File not found!
return new Exception::FileNotFound(streamname);
case EPIPE:
return &(new Exception::BadStream(streamname))->SetDiagMsg(L"Broken pipe");
return &(new Exception::BadStream(streamname))->SetDiagMsg("Broken pipe");
case EBADF:
return &(new Exception::BadStream(streamname))->SetDiagMsg(L"Bad file number");
return &(new Exception::BadStream(streamname))->SetDiagMsg("Bad file number");
default:
return &(new Exception::BadStream(streamname))->SetDiagMsg(pxsFmt(L"General file/stream error [errno: %d]", errcode));
return &(new Exception::BadStream(streamname))->SetDiagMsg(fmt::format("General file/stream error [errno: {}]", errcode));
}
}

120
common/Exceptions.h
View File

@ -16,9 +16,9 @@
#pragma once
#include <memory>
#include <wx/string.h>
#include <stdexcept>
#include "common/Assertions.h"
#include "common/Dependencies.h"
#include "common/Pcsx2Defs.h"
// Because wxTrap isn't available on Linux builds of wxWidgets (non-Debug, typically)
void pxTrap();
@ -69,7 +69,7 @@ namespace Exception
class BaseException;
int MakeNewType();
BaseException* FromErrno(const wxString& streamname, int errcode);
BaseException* FromErrno(std::string streamname, int errcode);
// --------------------------------------------------------------------------------------
// BaseException
@ -91,29 +91,29 @@ namespace Exception
class BaseException
{
protected:
wxString m_message_diag; // (untranslated) a "detailed" message of what disastrous thing has occurred!
wxString m_message_user; // (translated) a "detailed" message of what disastrous thing has occurred!
std::string m_message_diag; // (untranslated) a "detailed" message of what disastrous thing has occurred!
std::string m_message_user; // (translated) a "detailed" message of what disastrous thing has occurred!
public:
virtual ~BaseException() = default;
const wxString& DiagMsg() const { return m_message_diag; }
const wxString& UserMsg() const { return m_message_user; }
const std::string& DiagMsg() const { return m_message_diag; }
const std::string& UserMsg() const { return m_message_user; }
wxString& DiagMsg() { return m_message_diag; }
wxString& UserMsg() { return m_message_user; }
std::string& DiagMsg() { return m_message_diag; }
std::string& UserMsg() { return m_message_user; }
BaseException& SetBothMsgs(const wxChar* msg_diag);
BaseException& SetDiagMsg(const wxString& msg_diag);
BaseException& SetUserMsg(const wxString& msg_user);
BaseException& SetBothMsgs(const char* msg_diag);
BaseException& SetDiagMsg(std::string msg_diag);
BaseException& SetUserMsg(std::string msg_user);
// Returns a message suitable for diagnostic / logging purposes.
// This message is always in English, and includes a full stack trace.
virtual wxString FormatDiagnosticMessage() const;
virtual std::string FormatDiagnosticMessage() const;
// Returns a message suitable for end-user display.
// This message is usually meant for display in a user popup or such.
virtual wxString FormatDisplayMessage() const;
virtual std::string FormatDisplayMessage() const;
virtual void Rethrow() const = 0;
virtual BaseException* Clone() const = 0;
@ -135,14 +135,14 @@ namespace Exception
class Ps2Generic
{
protected:
wxString m_message; // a "detailed" message of what disastrous thing has occurred!
std::string m_message; // a "detailed" message of what disastrous thing has occurred!
public:
virtual ~Ps2Generic() = default;
virtual u32 GetPc() const = 0;
virtual bool IsDelaySlot() const = 0;
virtual wxString& Message() { return m_message; }
virtual std::string& Message() { return m_message; }
virtual void Rethrow() const = 0;
virtual Ps2Generic* Clone() const = 0;
@ -181,21 +181,21 @@ public: \
#define DEFINE_EXCEPTION_MESSAGES(classname) \
public: \
classname& SetBothMsgs(const wxChar* msg_diag) \
classname& SetBothMsgs(const char* msg_diag) \
{ \
BaseException::SetBothMsgs(msg_diag); \
return *this; \
} \
\
classname& SetDiagMsg(const wxString& msg_diag) \
classname& SetDiagMsg(std::string msg_diag) \
{ \
m_message_diag = msg_diag; \
return *this; \
} \
\
classname& SetUserMsg(const wxString& msg_user) \
classname& SetUserMsg(std::string msg_user) \
{ \
m_message_user = msg_user; \
m_message_user = std::move(msg_user); \
return *this; \
}
@ -221,8 +221,8 @@ public: \
bool IsSilent;
RuntimeError() { IsSilent = false; }
RuntimeError(const std::runtime_error& ex, const wxString& prefix = wxEmptyString);
RuntimeError(const std::exception& ex, const wxString& prefix = wxEmptyString);
RuntimeError(const std::runtime_error& ex, const char* prefix = nullptr);
RuntimeError(const std::exception& ex, const char* prefix = nullptr);
};
// --------------------------------------------------------------------------------------
@ -236,17 +236,17 @@ public: \
// an App message loop we'll still want it to be handled in a reasonably graceful manner.
class CancelEvent : public RuntimeError
{
DEFINE_RUNTIME_EXCEPTION(CancelEvent, RuntimeError, pxLt("No reason given."))
DEFINE_RUNTIME_EXCEPTION(CancelEvent, RuntimeError, "No reason given.")
public:
explicit CancelEvent(const wxString& logmsg)
explicit CancelEvent(std::string logmsg)
{
m_message_diag = logmsg;
m_message_diag = std::move(logmsg);
// overridden message formatters only use the diagnostic version...
}
virtual wxString FormatDisplayMessage() const;
virtual wxString FormatDiagnosticMessage() const;
virtual std::string FormatDisplayMessage() const;
virtual std::string FormatDiagnosticMessage() const;
};
// ---------------------------------------------------------------------------------------
@ -261,21 +261,21 @@ public: \
//
class OutOfMemory : public RuntimeError
{
DEFINE_RUNTIME_EXCEPTION(OutOfMemory, RuntimeError, wxEmptyString)
DEFINE_RUNTIME_EXCEPTION(OutOfMemory, RuntimeError, "")
public:
wxString AllocDescription;
std::string AllocDescription;
public:
OutOfMemory(const wxString& allocdesc);
OutOfMemory(std::string allocdesc);
virtual wxString FormatDisplayMessage() const;
virtual wxString FormatDiagnosticMessage() const;
virtual std::string FormatDisplayMessage() const;
virtual std::string FormatDiagnosticMessage() const;
};
class ParseError : public RuntimeError
{
DEFINE_RUNTIME_EXCEPTION(ParseError, RuntimeError, pxL("Parse error"));
DEFINE_RUNTIME_EXCEPTION(ParseError, RuntimeError, "Parse error");
};
// ---------------------------------------------------------------------------------------
@ -288,18 +288,18 @@ public: \
// we'd really like to have access to.
class VirtualMemoryMapConflict : public OutOfMemory
{
DEFINE_RUNTIME_EXCEPTION(VirtualMemoryMapConflict, OutOfMemory, wxEmptyString)
DEFINE_RUNTIME_EXCEPTION(VirtualMemoryMapConflict, OutOfMemory, "")
VirtualMemoryMapConflict(const wxString& allocdesc);
VirtualMemoryMapConflict(std::string allocdesc);
virtual wxString FormatDisplayMessage() const;
virtual wxString FormatDiagnosticMessage() const;
virtual std::string FormatDisplayMessage() const;
virtual std::string FormatDiagnosticMessage() const;
};
class HardwareDeficiency : public RuntimeError
{
public:
DEFINE_RUNTIME_EXCEPTION(HardwareDeficiency, RuntimeError, pxL("Your machine's hardware is incapable of running PCSX2. Sorry dood."));
DEFINE_RUNTIME_EXCEPTION(HardwareDeficiency, RuntimeError, "Your machine's hardware is incapable of running PCSX2. Sorry dood.");
};
// ---------------------------------------------------------------------------------------
@ -308,21 +308,21 @@ public: \
// ---------------------------------------------------------------------------------------
#define DEFINE_STREAM_EXCEPTION_ACCESSORS(classname) \
virtual classname& SetStreamName(const wxString& name) \
virtual classname& SetStreamName(std::string name) \
{ \
StreamName = name; \
StreamName = std::move(name); \
return *this; \
} \
\
virtual classname& SetStreamName(const char* name) \
{ \
StreamName = fromUTF8(name); \
StreamName = name; \
return *this; \
}
#define DEFINE_STREAM_EXCEPTION(classname, parent) \
DEFINE_RUNTIME_EXCEPTION(classname, parent, wxEmptyString) \
classname(const wxString& filename) \
DEFINE_RUNTIME_EXCEPTION(classname, parent, "") \
classname(std::string filename) \
{ \
StreamName = filename; \
} \
@ -337,14 +337,14 @@ public: \
DEFINE_STREAM_EXCEPTION(BadStream, RuntimeError)
public:
wxString StreamName; // name of the stream (if applicable)
std::string StreamName; // name of the stream (if applicable)
virtual wxString FormatDiagnosticMessage() const;
virtual wxString FormatDisplayMessage() const;
virtual std::string FormatDiagnosticMessage() const;
virtual std::string FormatDisplayMessage() const;
protected:
void _formatDiagMsg(FastFormatUnicode& dest) const;
void _formatUserMsg(FastFormatUnicode& dest) const;
void _formatDiagMsg(std::string& dest) const;
void _formatUserMsg(std::string& dest) const;
};
// A generic exception for odd-ball stream creation errors.
@ -353,8 +353,8 @@ public: \
{
DEFINE_STREAM_EXCEPTION(CannotCreateStream, BadStream)
virtual wxString FormatDiagnosticMessage() const;
virtual wxString FormatDisplayMessage() const;
virtual std::string FormatDiagnosticMessage() const;
virtual std::string FormatDisplayMessage() const;
};
// Exception thrown when an attempt to open a non-existent file is made.
@ -365,8 +365,8 @@ public: \
public:
DEFINE_STREAM_EXCEPTION(FileNotFound, CannotCreateStream)
virtual wxString FormatDiagnosticMessage() const;
virtual wxString FormatDisplayMessage() const;
virtual std::string FormatDiagnosticMessage() const;
virtual std::string FormatDisplayMessage() const;
};
class AccessDenied : public CannotCreateStream
@ -374,8 +374,8 @@ public: \
public:
DEFINE_STREAM_EXCEPTION(AccessDenied, CannotCreateStream)
virtual wxString FormatDiagnosticMessage() const;
virtual wxString FormatDisplayMessage() const;
virtual std::string FormatDiagnosticMessage() const;
virtual std::string FormatDisplayMessage() const;
};
// EndOfStream can be used either as an error, or used just as a shortcut for manual
@ -386,11 +386,11 @@ public: \
public:
DEFINE_STREAM_EXCEPTION(EndOfStream, BadStream)
virtual wxString FormatDiagnosticMessage() const;
virtual wxString FormatDisplayMessage() const;
virtual std::string FormatDiagnosticMessage() const;
virtual std::string FormatDisplayMessage() const;
};
#ifdef __WXMSW__
#ifdef _WIN32
// --------------------------------------------------------------------------------------
// Exception::WinApiError
// --------------------------------------------------------------------------------------
@ -405,9 +405,9 @@ public: \
public:
WinApiError();
wxString GetMsgFromWindows() const;
virtual wxString FormatDisplayMessage() const;
virtual wxString FormatDiagnosticMessage() const;
std::string GetMsgFromWindows() const;
virtual std::string FormatDisplayMessage() const;
virtual std::string FormatDiagnosticMessage() const;
};
#endif
} // namespace Exception

1
common/GL/Context.cpp
View File

@ -21,6 +21,7 @@
#include <cstdio>
#include <cstdlib>
#include <cstring>
#ifdef __APPLE__
#include <stdlib.h>
#else

2
common/GL/ContextEGL.cpp
View File

@ -17,6 +17,8 @@
#include "common/Console.h"
#include "ContextEGL.h"
#include <algorithm>
#include <cstring>
#include <optional>
#include <vector>

6
common/General.h
View File

@ -16,7 +16,7 @@
#pragma once
#include <atomic>
#include <wx/string.h>
#include <string>
#include "common/Pcsx2Defs.h"
// This macro is actually useful for about any and every possible application of C++
@ -81,7 +81,7 @@ public:
bool CanExecute() const { return m_exec && m_read; }
bool IsNone() const { return !m_read && !m_write; }
wxString ToString() const;
std::string ToString() const;
};
static __fi PageProtectionMode PageAccess_None()
@ -161,6 +161,6 @@ extern u32 ShortSpin();
/// Number of ns to spin for before sleeping a thread
extern const u32 SPIN_TIME_NS;
extern wxString GetOSVersionString();
extern std::string GetOSVersionString();
void ScreensaverAllow(bool allow);

55
common/Linux/LnxHostSys.cpp
View File

@ -14,15 +14,18 @@
*/
#if !defined(_WIN32)
#include <cstdio>
#include <sys/mman.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
#include "fmt/core.h"
#include "common/PageFaultSource.h"
#include "common/Assertions.h"
#include "common/Console.h"
#include "common/Exceptions.h"
#include "common/StringHelpers.h"
// Apple uses the MAP_ANON define instead of MAP_ANONYMOUS, but they mean
// the same thing.
@ -66,10 +69,8 @@ static void SysPageFaultSignalFilter(int signal, siginfo_t* siginfo, void*)
if (Source_PageFault->WasHandled())
return;
if (!wxThread::IsMain())
{
pxFailRel(pxsFmt("Unhandled page fault @ 0x%08x", siginfo->si_addr));
}
std::fprintf(stderr, "Unhandled page fault @ 0x%08x", siginfo->si_addr);
pxFailRel("Unhandled page fault");
// Bad mojo! Completely invalid address.
// Instigate a trap if we're in a debugger, and if not then do a SIGKILL.
@ -95,25 +96,12 @@ void _platform_InstallSignalHandler()
#endif
}
static __ri void PageSizeAssertionTest(size_t size)
{
pxAssertMsg((__pagesize == getpagesize()), pxsFmt(
"Internal system error: Operating system pagesize does not match compiled pagesize.\n\t"
L"\tOS Page Size: 0x%x (%d), Compiled Page Size: 0x%x (%u)",
getpagesize(), getpagesize(), __pagesize, __pagesize));
pxAssertDev((size & (__pagesize - 1)) == 0, pxsFmt(
L"Memory block size must be a multiple of the target platform's page size.\n"
L"\tPage Size: 0x%x (%u), Block Size: 0x%x (%u)",
__pagesize, __pagesize, size, size));
}
// returns FALSE if the mprotect call fails with an ENOMEM.
// Raises assertions on other types of POSIX errors (since those typically reflect invalid object
// or memory states).
static bool _memprotect(void* baseaddr, size_t size, const PageProtectionMode& mode)
{
PageSizeAssertionTest(size);
pxAssertDev((size & (__pagesize - 1)) == 0, "Size is page aligned");
uint lnxmode = 0;
@ -132,13 +120,13 @@ static bool _memprotect(void* baseaddr, size_t size, const PageProtectionMode& m
switch (errno)
{
case EINVAL:
pxFailDev(pxsFmt(L"mprotect returned EINVAL @ 0x%08X -> 0x%08X (mode=%s)",
baseaddr, (uptr)baseaddr + size, WX_STR(mode.ToString())));
pxFailDev(fmt::format("mprotect returned EINVAL @ 0x{:X} -> 0x{:X} (mode={})",
baseaddr, (uptr)baseaddr + size, mode.ToString()).c_str());
break;
case EACCES:
pxFailDev(pxsFmt(L"mprotect returned EACCES @ 0x%08X -> 0x%08X (mode=%s)",
baseaddr, (uptr)baseaddr + size, WX_STR(mode.ToString())));
pxFailDev(fmt::format("mprotect returned EACCES @ 0x{:X} -> 0x{:X} (mode={})",
baseaddr, (uptr)baseaddr + size, mode.ToString()).c_str());
break;
case ENOMEM:
@ -150,7 +138,7 @@ static bool _memprotect(void* baseaddr, size_t size, const PageProtectionMode& m
void* HostSys::MmapReservePtr(void* base, size_t size)
{
PageSizeAssertionTest(size);
pxAssertDev((size & (__pagesize - 1)) == 0, "Size is page aligned");
// On linux a reserve-without-commit is performed by using mmap on a read-only
// or anonymous source, with PROT_NONE (no-access) permission. Since the mapping
@ -172,21 +160,16 @@ bool HostSys::MmapCommitPtr(void* base, size_t size, const PageProtectionMode& m
if (_memprotect(base, size, mode))
return true;
if (!pxDoOutOfMemory)
return false;
pxDoOutOfMemory(size);
return _memprotect(base, size, mode);
return false;
}
void HostSys::MmapResetPtr(void* base, size_t size)
{
PageSizeAssertionTest(size);
pxAssertDev((size & (__pagesize - 1)) == 0, "Size is page aligned");
void* result = mmap(base, size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
pxAssertRel((uptr)result == (uptr)base, pxsFmt(
"Virtual memory decommit failed: memory at 0x%08X -> 0x%08X could not be remapped.",
base, (uptr)base + size));
pxAssertRel((uptr)result == (uptr)base, "Virtual memory decommit failed");
}
void* HostSys::MmapReserve(uptr base, size_t size)
@ -206,7 +189,7 @@ void HostSys::MmapReset(uptr base, size_t size)
void* HostSys::Mmap(uptr base, size_t size)
{
PageSizeAssertionTest(size);
pxAssertDev((size & (__pagesize - 1)) == 0, "Size is page aligned");
// MAP_ANONYMOUS - means we have no associated file handle (or device).
@ -224,9 +207,9 @@ void HostSys::MemProtect(void* baseaddr, size_t size, const PageProtectionMode&
{
if (!_memprotect(baseaddr, size, mode))
{
throw Exception::OutOfMemory(L"MemProtect")
.SetDiagMsg(pxsFmt(L"mprotect failed @ 0x%08X -> 0x%08X (mode=%s)",
baseaddr, (uptr)baseaddr + size, WX_STR(mode.ToString())));
throw Exception::OutOfMemory("MemProtect")
.SetDiagMsg(fmt::format("mprotect failed @ 0x{:X} -> 0x{:X} (mode={})",
baseaddr, (uptr)baseaddr + size, mode.ToString()));
}
}
#endif

8
common/Linux/LnxMisc.cpp
View File

@ -18,9 +18,9 @@
#include <time.h>
#include <unistd.h>
#include <sys/time.h>
#include <wx/utils.h>
#include "common/Pcsx2Types.h"
#include "common/General.h"
// Returns 0 on failure (not supported by the operating system).
u64 GetPhysicalMemory()
@ -51,12 +51,12 @@ u64 GetCPUTicks()
return (static_cast<u64>(ts.tv_sec) * 1000000000ULL) + ts.tv_nsec;
}
wxString GetOSVersionString()
std::string GetOSVersionString()
{
#if defined(__linux__)
return wxGetLinuxDistributionInfo().Description;
return "Linux";
#else // freebsd
return wxGetOsDescription();
return "Other Unix";
#endif
}

13
common/PageFaultSource.h
View File

@ -27,9 +27,10 @@
#include "EventSource.h"
#include "General.h"
#include "Assertions.h"
#include "Dependencies.h"
#include <atomic>
#include <memory>
#include <mutex>
#include <string>
struct PageFaultInfo
{
@ -135,7 +136,7 @@ class VirtualMemoryManager
{
DeclareNoncopyableObject(VirtualMemoryManager);
wxString m_name;
std::string m_name;
uptr m_baseptr;
@ -149,7 +150,7 @@ public:
// If upper_bounds is nonzero and the OS fails to allocate memory that is below it,
// calls to IsOk() will return false and Alloc() will always return null pointers
// strict indicates that the allocation should quietly fail if the memory can't be mapped at `base`
VirtualMemoryManager(const wxString& name, uptr base, size_t size, uptr upper_bounds = 0, bool strict = false);
VirtualMemoryManager(std::string name, uptr base, size_t size, uptr upper_bounds = 0, bool strict = false);
~VirtualMemoryManager();
void* GetBase() const { return (void*)m_baseptr; }
@ -195,7 +196,7 @@ class VirtualMemoryReserve
DeclareNoncopyableObject(VirtualMemoryReserve);
protected:
wxString m_name;
std::string m_name;
// Where the memory came from (so we can return it)
VirtualMemoryManagerPtr m_allocator;
@ -228,7 +229,7 @@ protected:
virtual size_t GetSize(size_t requestedSize);
public:
VirtualMemoryReserve(const wxString& name, size_t size = 0);
VirtualMemoryReserve(std::string name, size_t size = 0);
virtual ~VirtualMemoryReserve()
{
Release();
@ -260,7 +261,7 @@ public:
virtual void AllowModification();
bool IsOk() const { return m_baseptr != NULL; }
const wxString& GetName() const { return m_name; }
const std::string& GetName() const { return m_name; }
uptr GetReserveSizeInBytes() const { return m_pages_reserved * __pagesize; }
uptr GetReserveSizeInPages() const { return m_pages_reserved; }

9
common/Path.h
View File

@ -15,8 +15,9 @@
#pragma once
#include "common/Pcsx2Defs.h"
#include <wx/filename.h>
#include "common/StringHelpers.h"
#include "ghc/filesystem.h"
@ -43,7 +44,7 @@ public:
: wxFileName(src)
{
}
explicit wxDirName(const char* src) { Assign(fromUTF8(src)); }
explicit wxDirName(const char* src) { Assign(wxString(src, wxMBConvUTF8())); }
explicit wxDirName(const wxString& src) { Assign(src); }
// ------------------------------------------------------------------------
@ -187,14 +188,14 @@ public:
}
wxDirName& operator=(const char* dirname)
{
Assign(fromUTF8(dirname));
Assign(wxString(dirname, wxMBConvUTF8()));
return *this;
}
wxFileName operator+(const wxFileName& right) const { return Combine(right); }
wxDirName operator+(const wxDirName& right) const { return Combine(right); }
wxFileName operator+(const wxString& right) const { return Combine(wxFileName(right)); }
wxFileName operator+(const char* right) const { return Combine(wxFileName(fromUTF8(right))); }
wxFileName operator+(const char* right) const { return Combine(wxFileName(wxString(right, wxMBConvUTF8()))); }
bool operator==(const wxDirName& filename) const { return SameAs(filename); }
bool operator!=(const wxDirName& filename) const { return !SameAs(filename); }

18
common/PathUtils.cpp
View File

@ -14,6 +14,8 @@
*/
#include "common/Path.h"
#include "common/Assertions.h"
#include "common/Exceptions.h"
#include <wx/file.h>
#include <wx/utils.h>
@ -24,7 +26,7 @@
wxFileName wxDirName::Combine(const wxFileName& right) const
{
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wxDirName concatenation.");
pxAssertMsg(IsDir(), "Warning: Malformed directory name detected during wxDirName concatenation.");
if (right.IsAbsolute())
return right;
@ -39,7 +41,7 @@ wxFileName wxDirName::Combine(const wxFileName& right) const
wxDirName wxDirName::Combine(const wxDirName& right) const
{
pxAssertMsg(IsDir() && right.IsDir(), L"Warning: Malformed directory name detected during wDirName concatenation.");
pxAssertMsg(IsDir() && right.IsDir(), "Warning: Malformed directory name detected during wDirName concatenation.");
wxDirName result(right);
result.Normalize(wxPATH_NORM_ENV_VARS | wxPATH_NORM_DOTS | wxPATH_NORM_ABSOLUTE, GetPath());
@ -48,25 +50,25 @@ wxDirName wxDirName::Combine(const wxDirName& right) const
wxDirName& wxDirName::Normalize(int flags, const wxString& cwd)
{
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wDirName normalization.");
pxAssertMsg(IsDir(), "Warning: Malformed directory name detected during wDirName normalization.");
if (!wxFileName::Normalize(flags, cwd))
throw Exception::ParseError().SetDiagMsg(L"wxDirName::Normalize operation failed.");
throw Exception::ParseError().SetDiagMsg("wxDirName::Normalize operation failed.");
return *this;
}
wxDirName& wxDirName::MakeRelativeTo(const wxString& pathBase)
{
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wDirName normalization.");
pxAssertMsg(IsDir(), "Warning: Malformed directory name detected during wDirName normalization.");
if (!wxFileName::MakeRelativeTo(pathBase))
throw Exception::ParseError().SetDiagMsg(L"wxDirName::MakeRelativeTo operation failed.");
throw Exception::ParseError().SetDiagMsg("wxDirName::MakeRelativeTo operation failed.");
return *this;
}
wxDirName& wxDirName::MakeAbsolute(const wxString& cwd)
{
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wDirName normalization.");
pxAssertMsg(IsDir(), "Warning: Malformed directory name detected during wDirName normalization.");
if (!wxFileName::MakeAbsolute(cwd))
throw Exception::ParseError().SetDiagMsg(L"wxDirName::MakeAbsolute operation failed.");
throw Exception::ParseError().SetDiagMsg("wxDirName::MakeAbsolute operation failed.");
return *this;
}

141
common/Pcsx2Defs.h
View File

@ -188,3 +188,144 @@ static const int __pagesize = PCSX2_PAGESIZE;
#endif
#define ASSERT assert
//////////////////////////////////////////////////////////////////////////////////////////
// Safe deallocation macros -- checks pointer validity (non-null) when needed, and sets
// pointer to null after deallocation.
#define safe_delete(ptr) \
((void)(delete (ptr)), (ptr) = NULL)
#define safe_delete_array(ptr) \
((void)(delete[](ptr)), (ptr) = NULL)
// No checks for NULL -- wxWidgets says it's safe to skip NULL checks and it runs on
// just about every compiler and libc implementation of any recentness.
#define safe_free(ptr) \
((void)(free(ptr), !!0), (ptr) = NULL)
//((void) (( ( (ptr) != NULL ) && (free( ptr ), !!0) ), (ptr) = NULL))
#define safe_fclose(ptr) \
((void)((((ptr) != NULL) && (fclose(ptr), !!0)), (ptr) = NULL))
// --------------------------------------------------------------------------------------
// ImplementEnumOperators (macro)
// --------------------------------------------------------------------------------------
// This macro implements ++/-- operators for any conforming enumeration. In order for an
// enum to conform, it must have _FIRST and _COUNT members defined, and must have a full
// compliment of sequential members (no custom assignments) --- looking like so:
//
// enum Dummy {
// Dummy_FIRST,
// Dummy_Item = Dummy_FIRST,
// Dummy_Crap,
// Dummy_COUNT
// };
//
// The macro also defines utility functions for bounds checking enumerations:
// EnumIsValid(value); // returns TRUE if the enum value is between FIRST and COUNT.
// EnumAssert(value);
//
// It also defines a *prototype* for converting the enumeration to a string. Note that this
// method is not implemented! You must implement it yourself if you want to use it:
// EnumToString(value);
//
#define ImplementEnumOperators(enumName) \
static __fi enumName& operator++(enumName& src) \
{ \
src = (enumName)((int)src + 1); \
return src; \
} \
\
static __fi enumName& operator--(enumName& src) \
{ \
src = (enumName)((int)src - 1); \
return src; \
} \
\
static __fi enumName operator++(enumName& src, int) \
{ \
enumName orig = src; \
src = (enumName)((int)src + 1); \
return orig; \
} \
\
static __fi enumName operator--(enumName& src, int) \
{ \
enumName orig = src; \
src = (enumName)((int)src - 1); \
return orig; \
} \
\
static __fi bool operator<(const enumName& left, const pxEnumEnd_t&) { return (int)left < enumName##_COUNT; } \
static __fi bool operator!=(const enumName& left, const pxEnumEnd_t&) { return (int)left != enumName##_COUNT; } \
static __fi bool operator==(const enumName& left, const pxEnumEnd_t&) { return (int)left == enumName##_COUNT; } \
\
static __fi bool EnumIsValid(enumName id) \
{ \
return ((int)id >= enumName##_FIRST) && ((int)id < enumName##_COUNT); \
} \
\
extern const char* EnumToString(enumName id)
class pxEnumEnd_t
{
};
static const pxEnumEnd_t pxEnumEnd = {};
// --------------------------------------------------------------------------------------
// DeclareNoncopyableObject
// --------------------------------------------------------------------------------------
// This macro provides an easy and clean method for ensuring objects are not copyable.
// Simply add the macro to the head or tail of your class declaration, and attempts to
// copy the class will give you a moderately obtuse compiler error that will have you
// scratching your head for 20 minutes.
//
// (... but that's probably better than having a weird invalid object copy having you
// scratch your head for a day).
//
// Programmer's notes:
// * We intentionally do NOT provide implementations for these methods, which should
// never be referenced anyway.
// * I've opted for macro form over multi-inherited class form (Boost style), because
// the errors generated by the macro are considerably less voodoo. The Boost-style
// The macro reports the exact class that causes the copy failure, while Boost's class
// approach just reports an error in whatever "NoncopyableObject" is inherited.
//
// * This macro is the same as wxWidgets' DECLARE_NO_COPY_CLASS macro. This one is free
// of wx dependencies though, and has a nicer typeset. :)
//
#ifndef DeclareNoncopyableObject
#define DeclareNoncopyableObject(classname) \
public: \
classname(const classname&) = delete; \
classname& operator=(const classname&) = delete
#endif
// --------------------------------------------------------------------------------------
// Handy Human-readable constants for common immediate values (_16kb -> _4gb)
static constexpr sptr _1kb = 1024 * 1;
static constexpr sptr _4kb = _1kb * 4;
static constexpr sptr _16kb = _1kb * 16;
static constexpr sptr _32kb = _1kb * 32;
static constexpr sptr _64kb = _1kb * 64;
static constexpr sptr _128kb = _1kb * 128;
static constexpr sptr _256kb = _1kb * 256;
static constexpr s64 _1mb = 1024 * 1024;
static constexpr s64 _8mb = _1mb * 8;
static constexpr s64 _16mb = _1mb * 16;
static constexpr s64 _32mb = _1mb * 32;
static constexpr s64 _64mb = _1mb * 64;
static constexpr s64 _256mb = _1mb * 256;
static constexpr s64 _1gb = _1mb * 1024;
static constexpr s64 _4gb = _1gb * 4;
// Disable some spammy warnings which wx appeared to disable.
// We probably should fix these at some point.
#ifdef _MSC_VER
#pragma warning(disable: 4244) // warning C4244: 'initializing': conversion from 'uptr' to 'uint', possible loss of data
#pragma warning(disable: 4267) // warning C4267: 'initializing': conversion from 'size_t' to 'uint', possible loss of data
#endif

21
common/Pcsx2Types.h
View File

@ -17,16 +17,6 @@
#include <cstdint>
// --------------------------------------------------------------------------------------
// Forward declarations
// --------------------------------------------------------------------------------------
// Forward declarations for wxWidgets-supporting features.
// If you aren't linking against wxWidgets libraries, then functions that
// depend on these types will not be usable (they will yield linker errors).
class wxString;
class FastFormatAscii;
class FastFormatUnicode;
// --------------------------------------------------------------------------------------
// Basic Atomic Types
// --------------------------------------------------------------------------------------
@ -99,17 +89,6 @@ union u128
{
return (lo != right.lo) || (hi != right.hi);
}
// In order for the following ToString() and WriteTo methods to be available, you must
// be linking to both wxWidgets and the pxWidgets extension library. If you are not
// using them, then you will need to provide your own implementations of these methods.
wxString ToString() const;
wxString ToString64() const;
wxString ToString8() const;
void WriteTo(FastFormatAscii& dest) const;
void WriteTo8(FastFormatAscii& dest) const;
void WriteTo64(FastFormatAscii& dest) const;
};
struct s128

3
common/Perf.cpp
View File

@ -14,8 +14,7 @@
*/
#include "common/Perf.h"
#include "common/Pcsx2Types.h"
#include "common/Dependencies.h"
#include "common/Pcsx2Defs.h"
#ifdef __unix__
#include <unistd.h>
#endif

3
common/PrecompiledHeader.h
View File

@ -18,6 +18,3 @@
#include <csignal>
#include <cerrno>
#include <cstdio>
#include <wx/string.h>
#include <wx/gdicmn.h>

4
common/RedtapeWindows.h
View File

@ -24,10 +24,12 @@
#define NOMINMAX
#endif
// Win8.1 is our minimum at the moment.
#define _WIN32_WINNT 0x0603 // Windows 8.1
#include <windows.h>
#include <VersionHelpers.h>
#include <ShTypes.h>
#include <timeapi.h>
#include <wx/msw/wrapwin.h>
#endif

20
common/SafeArray.h
View File

@ -15,7 +15,7 @@
#pragma once
#include "common/Dependencies.h"
#include "common/Pcsx2Defs.h"
// pxUSE_SECURE_MALLOC - enables bounds checking on scoped malloc allocations.
@ -43,7 +43,7 @@ public:
static const int DefaultChunkSize = 0x1000 * sizeof(T);
public:
wxString Name; // user-assigned block name
std::string Name; // user-assigned block name
int ChunkSize;
protected:
@ -51,7 +51,7 @@ protected:
int m_size; // size of the allocation of memory
protected:
SafeArray(const wxChar* name, T* allocated_mem, int initSize);
SafeArray(std::string name, T* allocated_mem, int initSize);
virtual T* _virtual_realloc(int newsize);
// A safe array index fetcher. Asserts if the index is out of bounds (dev and debug
@ -61,8 +61,8 @@ protected:
public:
virtual ~SafeArray();
explicit SafeArray(const wxChar* name = L"Unnamed");
explicit SafeArray(int initialSize, const wxChar* name = L"Unnamed");
explicit SafeArray(std::string name = "Unnamed");
explicit SafeArray(int initialSize, std::string name = "Unnamed");
void Dispose();
void ExactAlloc(int newsize);
@ -124,7 +124,7 @@ public:
static const int DefaultChunkSize = 0x80 * sizeof(T);
public:
wxString Name; // user-assigned block name
std::string Name; // user-assigned block name
int ChunkSize; // assigned DefaultChunkSize on init, reconfigurable at any time.
protected:
@ -140,8 +140,8 @@ protected:
public:
virtual ~SafeList();
explicit SafeList(const wxChar* name = L"Unnamed");
explicit SafeList(int initialSize, const wxChar* name = L"Unnamed");
explicit SafeList(const char* name = "Unnamed");
explicit SafeList(int initialSize, const char* name = "Unnamed");
virtual SafeList<T>* Clone() const;
void Remove(int index);
@ -207,11 +207,11 @@ public:
virtual ~SafeAlignedArray();
explicit SafeAlignedArray(const wxChar* name = L"Unnamed")
explicit SafeAlignedArray(std::string name = "Unnamed")
: SafeArray<T>::SafeArray(name)
{
}
explicit SafeAlignedArray(int initialSize, const wxChar* name = L"Unnamed");
explicit SafeAlignedArray(int initialSize, std::string name = "Unnamed");
virtual SafeAlignedArray<T, Alignment>* Clone() const;
};

42
common/SafeArray.inl
View File

@ -15,16 +15,20 @@
#pragma once
#include "common/AlignedMalloc.h"
#include "common/Assertions.h"
#include "common/Exceptions.h"
#include "common/SafeArray.h"
#include "common/StringHelpers.h"
#include "fmt/core.h"
// Internal constructor for use by derived classes. This allows a derived class to
// use its own memory allocation (with an aligned memory, for example).
// Throws:
// Exception::OutOfMemory if the allocated_mem pointer is NULL.
template <typename T>
SafeArray<T>::SafeArray(const wxChar* name, T* allocated_mem, int initSize)
: Name(name)
SafeArray<T>::SafeArray(std::string name, T* allocated_mem, int initSize)
: Name(std::move(name))
{
ChunkSize = DefaultChunkSize;
m_ptr = allocated_mem;
@ -32,7 +36,7 @@ SafeArray<T>::SafeArray(const wxChar* name, T* allocated_mem, int initSize)
if (m_ptr == NULL)
throw Exception::OutOfMemory(name)
.SetDiagMsg(wxsFormat(L"Called from 'SafeArray::ctor' [size=%d]", initSize));
.SetDiagMsg(fmt::format("Called from 'SafeArray::ctor' [size={}]", initSize));
}
template <typename T>
@ -63,8 +67,8 @@ SafeArray<T>::~SafeArray()
}
template <typename T>
SafeArray<T>::SafeArray(const wxChar* name)
: Name(name)
SafeArray<T>::SafeArray(std::string name)
: Name(std::move(name))
{
ChunkSize = DefaultChunkSize;
m_ptr = NULL;
@ -72,8 +76,8 @@ SafeArray<T>::SafeArray(const wxChar* name)
}
template <typename T>
SafeArray<T>::SafeArray(int initialSize, const wxChar* name)
: Name(name)
SafeArray<T>::SafeArray(int initialSize, std::string name)
: Name(std::move(name))
{
ChunkSize = DefaultChunkSize;
m_ptr = (initialSize == 0) ? NULL : (T*)malloc(initialSize * sizeof(T));
@ -81,7 +85,7 @@ SafeArray<T>::SafeArray(int initialSize, const wxChar* name)
if ((initialSize != 0) && (m_ptr == NULL))
throw Exception::OutOfMemory(name)
.SetDiagMsg(wxsFormat(L"Called from 'SafeArray::ctor' [size=%d]", initialSize));
.SetDiagMsg(fmt::format("Called from 'SafeArray::ctor' [size={}]", initialSize));
}
// Clears the contents of the array to zero, and frees all memory allocations.
@ -95,7 +99,7 @@ void SafeArray<T>::Dispose()
template <typename T>
T* SafeArray<T>::_getPtr(uint i) const
{
IndexBoundsAssumeDev(WX_STR(Name), i, m_size);
pxAssumeDev(i < static_cast<uint>(m_size), "Array index in bounds");
return &m_ptr[i];
}
@ -110,7 +114,7 @@ void SafeArray<T>::ExactAlloc(int newsize)
m_ptr = _virtual_realloc(newsize);
if (m_ptr == NULL)
throw Exception::OutOfMemory(Name)
.SetDiagMsg(wxsFormat(L"Called from 'SafeArray::ExactAlloc' [oldsize=%d] [newsize=%d]", m_size, newsize));
.SetDiagMsg(fmt::format("Called from 'SafeArray::ExactAlloc' [oldsize={}] [newsize={}]", m_size, newsize));
m_size = newsize;
}
@ -147,9 +151,9 @@ SafeAlignedArray<T, Alignment>::~SafeAlignedArray()
}
template <typename T, uint Alignment>
SafeAlignedArray<T, Alignment>::SafeAlignedArray(int initialSize, const wxChar* name)
SafeAlignedArray<T, Alignment>::SafeAlignedArray(int initialSize, std::string name)
: SafeArray<T>::SafeArray(
name,
std::move(name),
(T*)_aligned_malloc(initialSize * sizeof(T), Alignment),
initialSize)
{
@ -180,7 +184,7 @@ SafeList<T>::~SafeList()
}
template <typename T>
SafeList<T>::SafeList(const wxChar* name)
SafeList<T>::SafeList(const char* name)
: Name(name)
{
ChunkSize = DefaultChunkSize;
@ -190,7 +194,7 @@ SafeList<T>::SafeList(const wxChar* name)
}
template <typename T>
SafeList<T>::SafeList(int initialSize, const wxChar* name)
SafeList<T>::SafeList(int initialSize, const char* name)
: Name(name)
{
ChunkSize = DefaultChunkSize;
@ -200,7 +204,7 @@ SafeList<T>::SafeList(int initialSize, const wxChar* name)
if (m_ptr == NULL)
throw Exception::OutOfMemory(Name)
.SetDiagMsg(wxsFormat(L"called from 'SafeList::ctor' [length=%d]", m_length));
.SetDiagMsg(fmt::format("called from 'SafeList::ctor' [length={}]", m_length));
for (int i = 0; i < m_allocsize; ++i)
{
@ -211,7 +215,7 @@ SafeList<T>::SafeList(int initialSize, const wxChar* name)
template <typename T>
T* SafeList<T>::_getPtr(uint i) const
{
IndexBoundsAssumeDev(WX_STR(Name), i, m_length);
pxAssumeDev(i < m_length, "Index in bounds");
return &m_ptr[i];
}
@ -226,7 +230,7 @@ void SafeList<T>::MakeRoomFor(int blockSize)
m_ptr = _virtual_realloc(newalloc);
if (m_ptr == NULL)
throw Exception::OutOfMemory(Name)
.SetDiagMsg(wxsFormat(L"Called from 'SafeList::MakeRoomFor' [oldlen=%d] [newlen=%d]", m_length, blockSize));
.SetDiagMsg(fmt::format("Called from 'SafeList::MakeRoomFor' [oldlen={}] [newlen={}]", m_length, blockSize));
for (; m_allocsize < newalloc; ++m_allocsize)
{
@ -266,7 +270,7 @@ T& SafeList<T>::AddNew(const T& src)
template <typename T>
void SafeList<T>::Remove(int index)
{
IndexBoundsAssumeDev(Name.c_str(), index, m_length);
pxAssert(index < m_length);
int copylen = m_length - index;
if (copylen > 0)

5
common/SettingsWrapper.h
View File

@ -17,11 +17,6 @@
#include "SettingsInterface.h"
// TODO(Stenzek): Remove when wx goes bye bye.
#include <wx/gdicmn.h>
#include "Path.h"
// Helper class which loads or saves depending on the derived class.
class SettingsWrapper
{

32
common/StringUtil.cpp
View File

@ -21,6 +21,8 @@
#include <sstream>
#include <algorithm>
#include "fmt/core.h"
#ifdef _WIN32
#include "RedtapeWindows.h"
#endif
@ -321,6 +323,25 @@ namespace StringUtil
return true;
}
void AppendUTF16CharacterToUTF8(std::string& s, u16 ch)
{
if (ch & 0xf800)
{
s.push_back(static_cast<char>(static_cast<u8>(0xe0 | static_cast<u8>(ch >> 12))));
s.push_back(static_cast<char>(static_cast<u8>(0x80 | static_cast<u8>(((ch >> 6) & 0x3f)))));
s.push_back(static_cast<char>(static_cast<u8>(0x80 | static_cast<u8>((ch & 0x3f)))));
}
else if (ch & 0xff80)
{
s.push_back(static_cast<char>(static_cast<u8>(0xc0 | static_cast<u8>((ch >> 6)))));
s.push_back(static_cast<char>(static_cast<u8>(0x80 | static_cast<u8>((ch & 0x3f)))));
}
else
{
s.push_back(static_cast<char>(static_cast<u8>(ch)));
}
}
std::wstring UTF8StringToWideString(const std::string_view& str)
{
std::wstring ret;
@ -402,4 +423,15 @@ namespace StringUtil
return true;
#endif
}
std::string U128ToString(const u128& u)
{
return fmt::format("0x{:08X}.{:08X}.{:08X}.{:08X}", u._u32[0], u._u32[1], u._u32[2], u._u32[3]);
}
std::string& AppendU128ToString(const u128& u, std::string& s)
{
fmt::format_to(std::back_inserter(s), "0x{:08X}.{:08X}.{:08X}.{:08X}", u._u32[0], u._u32[1], u._u32[2], u._u32[3]);
return s;
}
} // namespace StringUtil

7
common/StringUtil.h
View File

@ -174,6 +174,9 @@ namespace StringUtil
/// Parses an assignment string (Key = Value) into its two components.
bool ParseAssignmentString(const std::string_view& str, std::string_view* key, std::string_view* value);
/// Appends a UTF-16/UTF-32 codepoint to a UTF-8 string.
void AppendUTF16CharacterToUTF8(std::string& s, u16 ch);
/// Strided memcpy/memcmp.
static inline void StrideMemCpy(void* dst, std::size_t dst_stride, const void* src, std::size_t src_stride,
std::size_t copy_size, std::size_t count)
@ -244,4 +247,8 @@ namespace StringUtil
/// Converts the specified wide string to a UTF-8 string.
std::string WideStringToUTF8String(const std::wstring_view& str);
bool WideStringToUTF8String(std::string& dest, const std::wstring_view& str);
/// Converts unsigned 128-bit data to string.
std::string U128ToString(const u128& u);
std::string& AppendU128ToString(const u128& u, std::string& s);
} // namespace StringUtil

109
common/TraceLog.h
View File

@ -16,6 +16,8 @@
#pragma once
#include "Console.h"
#include "common/Assertions.h"
#include "common/StringUtil.h"
// --------------------------------------------------------------------------------------
// TraceLogDescriptor
@ -26,15 +28,15 @@
struct TraceLogDescriptor
{
// short name, alphanumerics only: used for saving/loading options.
const wxChar* ShortName;
const char* ShortName;
// Standard UI name for this log source. Used in menus, options dialogs.
const wxChar* Name;
const char* Name;
// Length description for use as a tooltip or menu item description.
const wxChar* Description;
const char* Description;
wxString GetShortName() const
const char* GetShortName() const
{
pxAssumeDev(Name, "Tracelog descriptors require a valid name!");
return ShortName ? ShortName : Name;
@ -90,18 +92,18 @@ public:
// Provides a categorical identifier, typically in "group.subgroup.subgroup" form.
// (use periods in favor of colons, since they do not require escape characters when
// written to ini/config files).
virtual wxString GetCategory() const { return wxEmptyString; }
virtual std::string GetCategory() const { return std::string(); }
// This method should be used to determine if a log should be generated or not.
// See the class overview comments for details on how and why this method should
// be used.
virtual bool IsActive() const { return Enabled; }
virtual wxString GetShortName() const { return m_Descriptor->GetShortName(); }
virtual const wxChar* GetName() const { return m_Descriptor->Name; }
virtual const wxChar* GetDescription() const
virtual const char* GetShortName() const { return m_Descriptor->GetShortName(); }
virtual const char* GetName() const { return m_Descriptor->Name; }
virtual const char* GetDescription() const
{
return (m_Descriptor->Description != NULL) ? pxGetTranslation(m_Descriptor->Description) : wxEmptyString;
return (m_Descriptor->Description != NULL) ? m_Descriptor->Description : "";
}
virtual bool HasDescription() const { return m_Descriptor->Description != NULL; }
@ -133,14 +135,14 @@ public:
bool WriteV(const char* fmt, va_list list) const
{
FastFormatAscii ascii;
std::string ascii;
ApplyPrefix(ascii);
ascii.WriteV(fmt, list);
DoWrite(ascii);
ascii += StringUtil::StdStringFromFormatV(fmt, list);
DoWrite(ascii.c_str());
return false;
}
virtual void ApplyPrefix(FastFormatAscii& ascii) const {}
virtual void ApplyPrefix(std::string& ascii) const {}
virtual void DoWrite(const char* fmt) const = 0;
};
@ -181,26 +183,6 @@ public:
return false;
}
bool Write(const wxChar* fmt, ...) const
{
va_list list;
va_start(list, fmt);
WriteV(fmt, list);
va_end(list);
return false;
}
bool Write(const wxString fmt, ...) const
{
va_list list;
va_start(list, fmt);
WriteV(fmt.wx_str(), list);
va_end(list);
return false;
}
// Writes to the console using the specified color. This overrides the default color setting
// for this log.
bool Write(ConsoleColors color, const char* fmt, ...) const
@ -213,68 +195,7 @@ public:
return false;
}
bool Write(ConsoleColors color, const wxChar* fmt, ...) const
{
va_list list;
va_start(list, fmt);
WriteV(color, fmt, list);
va_end(list);
return false;
}
// Writes to the console using bold yellow text -- overrides the log source's default
// color settings.
bool Warn(const wxChar* fmt, ...) const
{
va_list list;
va_start(list, fmt);
WriteV(Color_StrongYellow, fmt, list);
va_end(list);
return false;
}
bool Warn(const wxString fmt, ...) const
{
va_list list;
va_start(list, fmt);
WriteV(Color_StrongYellow, fmt.wx_str(), list);
va_end(list);
return false;
}
// Writes to the console using bold red text -- overrides the log source's default
// color settings.
bool Error(const wxChar* fmt, ...) const
{
va_list list;
va_start(list, fmt);
WriteV(Color_StrongRed, fmt, list);
va_end(list);
return false;
}
bool Error(const wxString fmt, ...) const
{
va_list list;
va_start(list, fmt);
WriteV(Color_StrongRed, fmt.wx_str(), list);
va_end(list);
return false;
}
bool WriteV(const char* fmt, va_list list) const;
bool WriteV(const wxChar* fmt, va_list list) const;
bool WriteV(ConsoleColors color, const char* fmt, va_list list) const;
bool WriteV(ConsoleColors color, const wxChar* fmt, va_list list) const;
virtual void DoWrite(const wxChar* msg) const
{
Console.DoWriteLn(msg);
}
};

64
common/VirtualMemory.cpp
View File

@ -18,6 +18,10 @@
#include "common/MemsetFast.inl"
#include "common/Console.h"
#include "fmt/core.h"
#include <cinttypes>
template class EventSource<IEventListener_PageFault>;
SrcType_PageFault* Source_PageFault = NULL;
@ -73,8 +77,8 @@ static size_t pageAlign(size_t size)
// VirtualMemoryManager (implementations)
// --------------------------------------------------------------------------------------
VirtualMemoryManager::VirtualMemoryManager(const wxString& name, uptr base, size_t size, uptr upper_bounds, bool strict)
: m_name(name)
VirtualMemoryManager::VirtualMemoryManager(std::string name, uptr base, size_t size, uptr upper_bounds, bool strict)
: m_name(std::move(name))
, m_baseptr(0)
, m_pageuse(nullptr)
, m_pages_reserved(0)
@ -89,8 +93,8 @@ VirtualMemoryManager::VirtualMemoryManager(const wxString& name, uptr base, size
if (!m_baseptr || (upper_bounds != 0 && (((uptr)m_baseptr + reserved_bytes) > upper_bounds)))
{
DevCon.Warning(L"%s: host memory @ %ls -> %ls is unavailable; attempting to map elsewhere...",
WX_STR(m_name), pxsPtr(base), pxsPtr(base + size));
DevCon.Warning("%s: host memory @ 0x%016" PRIXPTR " -> 0x%016" PRIXPTR " is unavailable; attempting to map elsewhere...",
m_name.c_str(), base, base + size);
SafeSysMunmap(m_baseptr, reserved_bytes);
@ -117,15 +121,15 @@ VirtualMemoryManager::VirtualMemoryManager(const wxString& name, uptr base, size
m_pageuse = new std::atomic<bool>[m_pages_reserved]();
FastFormatUnicode mbkb;
std::string mbkb;
uint mbytes = reserved_bytes / _1mb;
if (mbytes)
mbkb.Write("[%umb]", mbytes);
mbkb = fmt::format("[{}mb]", mbytes);
else
mbkb.Write("[%ukb]", reserved_bytes / 1024);
mbkb = fmt::format("[{}kb]", reserved_bytes / 1024);
DevCon.WriteLn(Color_Gray, L"%-32s @ %ls -> %ls %ls", WX_STR(m_name),
pxsPtr(m_baseptr), pxsPtr((uptr)m_baseptr + reserved_bytes), mbkb.c_str());
DevCon.WriteLn(Color_Gray, "%-32s @ 0x%016" PRIXPTR " -> 0x%016" PRIXPTR " %s", m_name.c_str(),
m_baseptr, (uptr)m_baseptr + reserved_bytes, mbkb.c_str());
}
VirtualMemoryManager::~VirtualMemoryManager()
@ -231,8 +235,8 @@ void* VirtualMemoryBumpAllocator::Alloc(size_t size)
// --------------------------------------------------------------------------------------
// VirtualMemoryReserve (implementations)
// --------------------------------------------------------------------------------------
VirtualMemoryReserve::VirtualMemoryReserve(const wxString& name, size_t size)
: m_name(name)
VirtualMemoryReserve::VirtualMemoryReserve(std::string name, size_t size)
: m_name(std::move(name))
{
m_defsize = size;
@ -283,15 +287,15 @@ void* VirtualMemoryReserve::Assign(VirtualMemoryManagerPtr allocator, void* base
if (!m_baseptr)
return nullptr;
FastFormatUnicode mbkb;
std::string mbkb;
uint mbytes = reserved_bytes / _1mb;
if (mbytes)
mbkb.Write("[%umb]", mbytes);
mbkb = fmt::format("[{}mb]", mbytes);
else
mbkb.Write("[%ukb]", reserved_bytes / 1024);
mbkb = fmt::format("[{}kb]", reserved_bytes / 1024);
DevCon.WriteLn(Color_Gray, L"%-32s @ %ls -> %ls %ls", WX_STR(m_name),
pxsPtr(m_baseptr), pxsPtr((uptr)m_baseptr + reserved_bytes), mbkb.c_str());
DevCon.WriteLn(Color_Gray, "%-32s @ 0x%016" PRIXPTR " -> 0x%016" PRIXPTR " %s", m_name.c_str(),
m_baseptr, (uptr)m_baseptr + reserved_bytes, mbkb.c_str());
return m_baseptr;
}
@ -365,16 +369,16 @@ bool VirtualMemoryReserve::TryResize(uint newsize)
uint toReservePages = newPages - m_pages_reserved;
uint toReserveBytes = toReservePages * __pagesize;
DevCon.WriteLn(L"%-32s is being expanded by %u pages.", WX_STR(m_name), toReservePages);
DevCon.WriteLn("%-32s is being expanded by %u pages.", m_name.c_str(), toReservePages);
if (!m_allocator->AllocAtAddress(GetPtrEnd(), toReserveBytes))
{
Console.Warning("%-32s could not be passively resized due to virtual memory conflict!", WX_STR(m_name));
Console.Warning("%-32s could not be passively resized due to virtual memory conflict!", m_name.c_str());
Console.Indent().Warning("(attempted to map memory @ %08p -> %08p)", m_baseptr, (uptr)m_baseptr + toReserveBytes);
return false;
}
DevCon.WriteLn(Color_Gray, L"%-32s @ %08p -> %08p [%umb]", WX_STR(m_name),
DevCon.WriteLn(Color_Gray, "%-32s @ %08p -> %08p [%umb]", m_name.c_str(),
m_baseptr, (uptr)m_baseptr + toReserveBytes, toReserveBytes / _1mb);
}
else if (newPages < m_pages_reserved)
@ -385,11 +389,11 @@ bool VirtualMemoryReserve::TryResize(uint newsize)
uint toRemovePages = m_pages_reserved - newPages;
uint toRemoveBytes = toRemovePages * __pagesize;
DevCon.WriteLn(L"%-32s is being shrunk by %u pages.", WX_STR(m_name), toRemovePages);
DevCon.WriteLn("%-32s is being shrunk by %u pages.", m_name.c_str(), toRemovePages);
m_allocator->Free(GetPtrEnd() - toRemoveBytes, toRemoveBytes);
DevCon.WriteLn(Color_Gray, L"%-32s @ %08p -> %08p [%umb]", WX_STR(m_name),
DevCon.WriteLn(Color_Gray, "%-32s @ %08p -> %08p [%umb]", m_name.c_str(),
m_baseptr, GetPtrEnd(), GetReserveSizeInBytes() / _1mb);
}
@ -400,21 +404,21 @@ bool VirtualMemoryReserve::TryResize(uint newsize)
// --------------------------------------------------------------------------------------
// PageProtectionMode (implementations)
// --------------------------------------------------------------------------------------
wxString PageProtectionMode::ToString() const
std::string PageProtectionMode::ToString() const
{
wxString modeStr;
std::string modeStr;
if (m_read)
modeStr += L"Read";
modeStr += "Read";
if (m_write)
modeStr += L"Write";
modeStr += "Write";
if (m_exec)
modeStr += L"Exec";
modeStr += "Exec";
if (modeStr.IsEmpty())
return L"NoAccess";
if (modeStr.Length() <= 5)
modeStr += L"Only";
if (modeStr.empty())
return "NoAccess";
if (modeStr.length() <= 5)
modeStr += "Only";
return modeStr;
}

19
common/Windows/WinHostSys.cpp
View File

@ -18,6 +18,9 @@
#include "common/RedtapeWindows.h"
#include "common/PageFaultSource.h"
#include "common/Console.h"
#include "common/Exceptions.h"
#include "common/StringUtil.h"
#include "common/AlignedMalloc.h"
static long DoSysPageFaultExceptionFilter(EXCEPTION_POINTERS* eps)
{
@ -97,14 +100,11 @@ bool HostSys::MmapCommitPtr(void* base, size_t size, const PageProtectionMode& m
}
else if (errcode != ERROR_NOT_ENOUGH_MEMORY && errcode != ERROR_OUTOFMEMORY)
{
pxFailDev(L"VirtualAlloc COMMIT failed: " + Exception::WinApiError().GetMsgFromWindows());
pxFailDev(("VirtualAlloc COMMIT failed: " + Exception::WinApiError().GetMsgFromWindows()).c_str());
return false;
}
if (!pxDoOutOfMemory)
return false;
pxDoOutOfMemory(size);
return VirtualAlloc(base, size, MEM_COMMIT, ConvertToWinApi(mode)) != NULL;
return false;
}
void HostSys::MmapResetPtr(void* base, size_t size)
@ -144,10 +144,7 @@ void HostSys::Munmap(uptr base, size_t size)
void HostSys::MemProtect(void* baseaddr, size_t size, const PageProtectionMode& mode)
{
pxAssertDev(((size & (__pagesize - 1)) == 0), pxsFmt(
L"Memory block size must be a multiple of the target platform's page size.\n"
L"\tPage Size: 0x%04x (%d), Block Size: 0x%04x (%d)",
__pagesize, __pagesize, size, size));
pxAssert((size & (__pagesize - 1)) == 0);
DWORD OldProtect; // enjoy my uselessness, yo!
if (!VirtualProtect(baseaddr, size, ConvertToWinApi(mode), &OldProtect))
@ -155,10 +152,10 @@ void HostSys::MemProtect(void* baseaddr, size_t size, const PageProtectionMode&
Exception::WinApiError apiError;
apiError.SetDiagMsg(
pxsFmt(L"VirtualProtect failed @ 0x%08X -> 0x%08X (mode=%s)",
StringUtil::StdStringFromFormat("VirtualProtect failed @ 0x%08X -> 0x%08X (mode=%s)",
baseaddr, (uptr)baseaddr + size, mode.ToString().c_str()));
pxFailDev(apiError.FormatDiagnosticMessage());
pxFailDev(apiError.FormatDiagnosticMessage().c_str());
}
}
#endif

54
common/Windows/WinMisc.cpp
View File

@ -15,11 +15,12 @@
#if defined(_WIN32)
#include <wx/string.h>
#include "common/Pcsx2Defs.h"
#include "common/RedtapeWindows.h"
#include "common/Exceptions.h"
#include "common/Dependencies.h"
#include "common/StringUtil.h"
#include "fmt/core.h"
#pragma comment(lib, "User32.lib")
@ -52,27 +53,26 @@ u64 GetPhysicalMemory()
// Calculates the Windows OS Version and processor architecture, and returns it as a
// human-readable string. :)
wxString GetOSVersionString()
std::string GetOSVersionString()
{
wxString retval;
std::string retval;
SYSTEM_INFO si;
GetNativeSystemInfo(&si);
if (!IsWindows8Point1OrGreater())
return L"Unsupported Operating System!";
{
retval = "Unsupported Operating System!";
}
else
{
retval = "Microsoft ";
retval += L"Microsoft ";
if (IsWindows10OrGreater())
retval += IsWindowsServer() ? L"Windows Server 2016" : L"Windows 10";
else // IsWindows8Point1OrGreater()
retval += IsWindowsServer() ? L"Windows Server 2012 R2" : L"Windows 8.1";
if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
retval += L", 64-bit";
else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL)
retval += L", 32-bit";
if (IsWindows10OrGreater())
retval += IsWindowsServer() ? "Windows Server 2016" : "Windows 10";
else // IsWindows8Point1OrGreater()
retval += IsWindowsServer() ? "Windows Server 2012 R2" : "Windows 8.1";
}
return retval;
}
@ -83,30 +83,30 @@ wxString GetOSVersionString()
Exception::WinApiError::WinApiError()
{
ErrorId = GetLastError();
m_message_diag = L"Unspecified Windows API error.";
m_message_diag = "Unspecified Windows API error.";
}
wxString Exception::WinApiError::GetMsgFromWindows() const
std::string Exception::WinApiError::GetMsgFromWindows() const
{
if (!ErrorId)
return L"No valid error number was assigned to this exception!";
return "No valid error number was assigned to this exception!";
const DWORD BUF_LEN = 2048;
TCHAR t_Msg[BUF_LEN];
if (FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, 0, ErrorId, 0, t_Msg, BUF_LEN, 0))
return wxsFormat(L"Win32 Error #%d: %s", ErrorId, t_Msg);
wchar_t t_Msg[BUF_LEN];
if (FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, 0, ErrorId, 0, t_Msg, BUF_LEN, 0))
return fmt::format("Win32 Error #{}: {}", ErrorId, StringUtil::WideStringToUTF8String(t_Msg));
return wxsFormat(L"Win32 Error #%d (no text msg available)", ErrorId);
return fmt::format("Win32 Error #{} (no text msg available)", ErrorId);
}
wxString Exception::WinApiError::FormatDisplayMessage() const
std::string Exception::WinApiError::FormatDisplayMessage() const
{
return m_message_user + L"\n\n" + GetMsgFromWindows();
return m_message_user + "\n\n" + GetMsgFromWindows();
}
wxString Exception::WinApiError::FormatDiagnosticMessage() const
std::string Exception::WinApiError::FormatDiagnosticMessage() const
{
return m_message_diag + L"\n\t" + GetMsgFromWindows();
return m_message_diag + "\n\t" + GetMsgFromWindows();
}
void ScreensaverAllow(bool allow)

1
common/boost_spsc_queue.hpp
View File

@ -45,6 +45,7 @@
// DEALINGS IN THE SOFTWARE.
#include <atomic>
#include "AlignedMalloc.h"
template <typename T, size_t max_size>
class ringbuffer_base

6
common/common.vcxproj
View File

@ -55,7 +55,6 @@
<ClCompile Include="D3D12\Texture.cpp" />
<ClCompile Include="D3D12\Util.cpp" />
<ClCompile Include="Exceptions.cpp" />
<ClCompile Include="FastFormatString.cpp" />
<ClCompile Include="FastJmp.cpp">
<ExcludedFromBuild>true</ExcludedFromBuild>
</ClCompile>
@ -67,7 +66,6 @@
<ClCompile Include="FileSystem.cpp" />
<ClCompile Include="MD5Digest.cpp" />
<ClCompile Include="ProgressCallback.cpp" />
<ClCompile Include="pxTranslate.cpp" />
<ClCompile Include="StackWalker.cpp" />
<ClCompile Include="StringUtil.cpp" />
<ClCompile Include="SettingsWrapper.cpp" />
@ -89,7 +87,6 @@
<ClCompile Include="PrecompiledHeader.cpp">
<PrecompiledHeader>Create</PrecompiledHeader>
</ClCompile>
<ClCompile Include="StringHelpers.cpp" />
<ClCompile Include="Linux\LnxHostSys.cpp" />
<ClCompile Include="Linux\LnxMisc.cpp" />
<ClCompile Include="Linux\LnxThreads.cpp" />
@ -130,7 +127,6 @@
<ClInclude Include="D3D12\StreamBuffer.h" />
<ClInclude Include="D3D12\Texture.h" />
<ClInclude Include="D3D12\Util.h" />
<ClInclude Include="EmbeddedImage.h" />
<ClInclude Include="boost_spsc_queue.hpp" />
<ClInclude Include="FastJmp.h" />
<ClInclude Include="GL\Context.h" />
@ -149,7 +145,6 @@
<ClInclude Include="SettingsWrapper.h" />
<ClInclude Include="Assertions.h" />
<ClInclude Include="Console.h" />
<ClInclude Include="Dependencies.h" />
<ClInclude Include="EventSource.h" />
<ClInclude Include="Exceptions.h" />
<ClInclude Include="General.h" />
@ -159,7 +154,6 @@
<ClInclude Include="PrecompiledHeader.h" />
<ClInclude Include="RedtapeWindows.h" />
<ClInclude Include="SafeArray.h" />
<ClInclude Include="StringHelpers.h" />
<ClInclude Include="Timer.h" />
<ClInclude Include="Vulkan\Builders.h" />
<ClInclude Include="Vulkan\Context.h" />

18
common/common.vcxproj.filters
View File

@ -16,9 +16,6 @@
<ClCompile Include="Exceptions.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="FastFormatString.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="emitter\fpu.cpp">
<Filter>Source Files</Filter>
</ClCompile>
@ -61,18 +58,12 @@
<ClCompile Include="PrecompiledHeader.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="pxTranslate.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="Semaphore.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="emitter\simd.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="StringHelpers.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="VirtualMemory.cpp">
<Filter>Source Files</Filter>
</ClCompile>
@ -216,15 +207,9 @@
<ClInclude Include="emitter\cpudetect_internal.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="Dependencies.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="emitter\implement\dwshift.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="EmbeddedImage.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="EventSource.h">
<Filter>Header Files</Filter>
</ClInclude>
@ -321,9 +306,6 @@
<ClInclude Include="emitter\implement\xchg.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="StringHelpers.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="FastJmp.h">
<Filter>Header Files</Filter>
</ClInclude>

12
common/emitter/cpudetect.cpp
View File

@ -141,20 +141,20 @@ s64 x86capabilities::_CPUSpeedHz(u64 time) const
return (s64)newCycleCount;
}
wxString x86capabilities::GetTypeName() const
const char* x86capabilities::GetTypeName() const
{
switch (TypeID)
{
case 0:
return L"Standard OEM";
return "Standard OEM";
case 1:
return L"Overdrive";
return "Overdrive";
case 2:
return L"Dual";
return "Dual";
case 3:
return L"Reserved";
return "Reserved";
default:
return L"Unknown";
return "Unknown";
}
}

1
common/emitter/legacy.cpp
View File

@ -27,6 +27,7 @@
#include "common/emitter/legacy_internal.h"
#include "common/Console.h"
#include <cassert>
emitterT void ModRM(uint mod, uint reg, uint rm)
{

4
common/emitter/tools.h
View File

@ -15,7 +15,7 @@
#pragma once
#include "common/Dependencies.h"
#include "common/Pcsx2Defs.h"
enum x86VendorType
{
@ -114,7 +114,7 @@ public:
void Identify();
void CountCores();
wxString GetTypeName() const;
const char* GetTypeName() const;
static u32 CachedMHz();
u32 CalculateMHz() const;

5
common/emitter/x86emitter.cpp
View File

@ -30,6 +30,7 @@
#include "common/emitter/internal.h"
#include "common/emitter/tools.h"
#include <functional>
// ------------------------------------------------------------------------
// Notes on Thread Local Storage:
@ -707,7 +708,7 @@ const xRegister32
else if (Index.IsEmpty())
Index = src;
else
pxAssumeDev(false, L"x86Emitter: address modifiers cannot have more than two index registers."); // oops, only 2 regs allowed per ModRm!
pxAssumeDev(false, "x86Emitter: address modifiers cannot have more than two index registers."); // oops, only 2 regs allowed per ModRm!
return *this;
}
@ -732,7 +733,7 @@ const xRegister32
Factor += src.Factor;
}
else
pxAssumeDev(false, L"x86Emitter: address modifiers cannot have more than two index registers."); // oops, only 2 regs allowed per ModRm!
pxAssumeDev(false, "x86Emitter: address modifiers cannot have more than two index registers."); // oops, only 2 regs allowed per ModRm!
return *this;
}

51
common/pxForwardDefs.h
View File

@ -1,51 +0,0 @@
/* PCSX2 - PS2 Emulator for PCs
* Copyright (C) 2002-2010 PCSX2 Dev Team
*
* PCSX2 is free software: you can redistribute it and/or modify it under the terms
* of the GNU Lesser General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along with PCSX2.
* If not, see <http://www.gnu.org/licenses/>.
*/
#pragma once
// --------------------------------------------------------------------------------------
// Forward Declarations Section
// --------------------------------------------------------------------------------------
class wxOutputStream;
class wxFileOutputStream;
class wxFFileOutputStream;
class wxStreamBase;
class wxInputStream;
class wxFileInputStream;
class wxFFileInputStream;
class wxPoint;
class wxRect;
class wxSize;
class pxInputStream;
class pxOutputStream;
extern const wxSize wxDefaultSize;
extern const wxPoint wxDefaultPosition;
namespace Threading
{
class Mutex;
class Semaphore;
class pxThread;
} // namespace Threading
namespace Exception
{
class BaseException;
}

2
pcsx2-qt/DisplayWidget.cpp
View File

@ -15,6 +15,8 @@
#include "PrecompiledHeader.h"
#include "common/Assertions.h"
#include "DisplayWidget.h"
#include "EmuThread.h"
#include "MainWindow.h"

1
pcsx2-qt/GameList/GameListWidget.cpp
View File

@ -15,6 +15,7 @@
#include "PrecompiledHeader.h"
#include "common/Assertions.h"
#include "common/StringUtil.h"
#include "pcsx2/Frontend/GameList.h"

1
pcsx2-qt/MainWindow.cpp
View File

@ -23,6 +23,7 @@
#include <QtWidgets/QStyle>
#include <QtWidgets/QStyleFactory>
#include "common/Assertions.h"
#include "common/FileSystem.h"
#include "pcsx2/CDVD/CDVDaccess.h"

22
pcsx2-qt/QtHost.cpp
View File

@ -542,9 +542,9 @@ static HANDLE s_old_console_stdin = NULL;
static HANDLE s_old_console_stdout = NULL;
static HANDLE s_old_console_stderr = NULL;
static void ConsoleWinQt_SetTitle(const wxString& title)
static void ConsoleWinQt_SetTitle(const char* title)
{
SetConsoleTitleW(title.wc_str());
SetConsoleTitleW(StringUtil::UTF8StringToWideString(title).c_str());
}
static void ConsoleWinQt_DoSetColor(ConsoleColors color)
@ -593,31 +593,37 @@ static void ConsoleWinQt_Newline()
WriteConsoleW(s_console_handle, L"\n", 1, &written, nullptr);
}
static void ConsoleWinQt_DoWrite(const wxString& fmt)
static void ConsoleWinQt_DoWrite(const char* fmt)
{
if (!s_console_handle)
return;
// TODO: Put this on the stack.
std::wstring wfmt(StringUtil::UTF8StringToWideString(fmt));
if (s_debugger_attached)
OutputDebugStringW(fmt.wc_str());
OutputDebugStringW(wfmt.c_str());
DWORD written;
WriteConsoleW(s_console_handle, fmt.wc_str(), static_cast<DWORD>(fmt.size()), &written, nullptr);
WriteConsoleW(s_console_handle, wfmt.c_str(), static_cast<DWORD>(wfmt.length()), &written, nullptr);
}
static void ConsoleWinQt_DoWriteLn(const wxString& fmt)
static void ConsoleWinQt_DoWriteLn(const char* fmt)
{
if (!s_console_handle)
return;
// TODO: Put this on the stack.
std::wstring wfmt(StringUtil::UTF8StringToWideString(fmt));
if (s_debugger_attached)
{
OutputDebugStringW(fmt.wc_str());
OutputDebugStringW(wfmt.c_str());
OutputDebugStringW(L"\n");
}
DWORD written;
WriteConsoleW(s_console_handle, fmt.wc_str(), static_cast<DWORD>(fmt.size()), &written, nullptr);
WriteConsoleW(s_console_handle, wfmt.c_str(), static_cast<DWORD>(wfmt.length()), &written, nullptr);
WriteConsoleW(s_console_handle, L"\n", 1, &written, nullptr);
}

1
pcsx2-qt/Settings/SettingsDialog.h
View File

@ -22,6 +22,7 @@
#include <memory>
class INISettingsInterface;
class SettingsInterface;
namespace GameList
{

1
pcsx2/CDVD/BlockdumpFileReader.cpp
View File

@ -16,6 +16,7 @@
#include "PrecompiledHeader.h"
#include "AsyncFileReader.h"
#include "IsoFileFormats.h"
#include "common/Assertions.h"
#include "common/FileSystem.h"
#include <errno.h>

28
pcsx2/CDVD/CDVD.cpp
View File

@ -230,8 +230,8 @@ static void cdvdNVM(u8* buffer, int offset, size_t bytes, bool read)
ret = std::fwrite(buffer, 1, bytes, fp.get());
if (ret != bytes)
Console.Error(L"Failed to %s %s. Did only %zu/%zu bytes",
read ? L"read from" : L"write to", nvmfile.c_str(), ret, bytes);
Console.Error("Failed to %s %s. Did only %zu/%zu bytes",
read ? "read from" : "write to", nvmfile.c_str(), ret, bytes);
}
static void cdvdReadNVM(u8* dst, int offset, int bytes)
@ -639,7 +639,7 @@ static void cdvdUpdateReady(u8 NewReadyStatus)
s32 cdvdCtrlTrayOpen()
{
DevCon.WriteLn(Color_Green, L"Open virtual disk tray");
DevCon.WriteLn(Color_Green, "Open virtual disk tray");
// If we switch using a source change we need to pretend it's a new disc
if (CDVDsys_GetSourceType() == CDVD_SourceType::Disc)
@ -660,7 +660,7 @@ s32 cdvdCtrlTrayOpen()
{
cdvd.Tray.cdvdActionSeconds = 3;
cdvd.Tray.trayState = CDVD_DISC_EJECT;
DevCon.WriteLn(Color_Green, L"Simulating ejected media");
DevCon.WriteLn(Color_Green, "Simulating ejected media");
}
return 0; // needs to be 0 for success according to homebrew test "CDVD"
@ -668,11 +668,11 @@ s32 cdvdCtrlTrayOpen()
s32 cdvdCtrlTrayClose()
{
DevCon.WriteLn(Color_Green, L"Close virtual disk tray");
DevCon.WriteLn(Color_Green, "Close virtual disk tray");
if (!g_GameStarted && g_SkipBiosHack)
{
DevCon.WriteLn(Color_Green, L"Media already loaded (fast boot)");
DevCon.WriteLn(Color_Green, "Media already loaded (fast boot)");
cdvdUpdateReady(CDVD_DRIVE_READY);
cdvdUpdateStatus(CDVD_STATUS_PAUSE);
cdvd.Tray.trayState = CDVD_DISC_ENGAGED;
@ -680,7 +680,7 @@ s32 cdvdCtrlTrayClose()
}
else
{
DevCon.WriteLn(Color_Green, L"Detecting media");
DevCon.WriteLn(Color_Green, "Detecting media");
cdvdUpdateReady(CDVD_DRIVE_BUSY);
cdvdUpdateStatus(CDVD_STATUS_SEEK);
cdvd.Tray.trayState = CDVD_DISC_DETECTING;
@ -914,7 +914,7 @@ void cdvdNewDiskCB()
// If not ejected but we've swapped source pretend it got ejected
if ((g_GameStarted || !g_SkipBiosHack) && cdvd.Tray.trayState != CDVD_DISC_EJECT)
{
DevCon.WriteLn(Color_Green, L"Ejecting media");
DevCon.WriteLn(Color_Green, "Ejecting media");
cdvdUpdateStatus(CDVD_STATUS_TRAY_OPEN);
cdvdUpdateReady(CDVD_DRIVE_BUSY);
cdvd.Tray.trayState = CDVD_DISC_EJECT;
@ -926,7 +926,7 @@ void cdvdNewDiskCB()
}
else if (cdvd.Type > 0)
{
DevCon.WriteLn(Color_Green, L"Seeking new media");
DevCon.WriteLn(Color_Green, "Seeking new media");
cdvdUpdateReady(CDVD_DRIVE_BUSY);
cdvdUpdateStatus(CDVD_STATUS_SEEK);
cdvd.Spinning = true;
@ -1390,7 +1390,7 @@ void cdvdUpdateTrayState()
cdvdCtrlTrayClose();
break;
case CDVD_DISC_DETECTING:
DevCon.WriteLn(Color_Green, L"Seeking new disc");
DevCon.WriteLn(Color_Green, "Seeking new disc");
cdvd.Tray.trayState = CDVD_DISC_SEEKING;
cdvd.Tray.cdvdActionSeconds = 2;
cdvd.Spinning = true;
@ -1401,7 +1401,7 @@ void cdvdUpdateTrayState()
cdvdUpdateReady(CDVD_DRIVE_READY);
if (CDVDsys_GetSourceType() != CDVD_SourceType::NoDisc)
{
DevCon.WriteLn(Color_Green, L"Media ready to read");
DevCon.WriteLn(Color_Green, "Media ready to read");
cdvdUpdateStatus(CDVD_STATUS_PAUSE);
}
else
@ -1871,7 +1871,7 @@ static void cdvdWrite04(u8 rt)
cdvd.Sector, cdvd.SeekToSector, cdvd.nSectors, cdvd.RetryCnt, cdvd.Speed, (cdvd.SpindlCtrl & CDVD_SPINDLE_CAV) ? L"CAV" : L"CLV", cdvd.ReadMode, cdvd.NCMDParam[10], cdvd.SpindlCtrl);
if (EmuConfig.CdvdVerboseReads)
Console.WriteLn(Color_Gray, L"CDRead: Reading Sector %07d (%03d Blocks of Size %d) at Speed=%dx(%s) Spindle=%x",
Console.WriteLn(Color_Gray, "CDRead: Reading Sector %07d (%03d Blocks of Size %d) at Speed=%dx(%s) Spindle=%x",
cdvd.SeekToSector, cdvd.nSectors, cdvd.BlockSize, cdvd.Speed, (cdvd.SpindlCtrl & CDVD_SPINDLE_CAV) ? L"CAV" : L"CLV", cdvd.SpindlCtrl);
cdvd.ReadTime = cdvdBlockReadTime((CDVD_MODE_TYPE)cdvdIsDVD());
@ -1970,7 +1970,7 @@ static void cdvdWrite04(u8 rt)
cdvd.Sector, cdvd.SeekToSector, cdvd.nSectors, cdvd.RetryCnt, cdvd.Speed, (cdvd.SpindlCtrl & CDVD_SPINDLE_CAV) ? L"CAV" : L"CLV", cdvd.ReadMode, cdvd.NCMDParam[10], cdvd.SpindlCtrl);
if (EmuConfig.CdvdVerboseReads)
Console.WriteLn(Color_Gray, L"CdAudioRead: Reading Sector %07d (%03d Blocks of Size %d) at Speed=%dx(%s) Spindle=%x",
Console.WriteLn(Color_Gray, "CdAudioRead: Reading Sector %07d (%03d Blocks of Size %d) at Speed=%dx(%s) Spindle=%x",
cdvd.Sector, cdvd.nSectors, cdvd.BlockSize, cdvd.Speed, (cdvd.SpindlCtrl & CDVD_SPINDLE_CAV) ? L"CAV" : L"CLV", cdvd.SpindlCtrl);
cdvd.ReadTime = cdvdBlockReadTime(MODE_CDROM);
@ -2066,7 +2066,7 @@ static void cdvdWrite04(u8 rt)
cdvd.Sector, cdvd.SeekToSector, cdvd.nSectors, cdvd.RetryCnt, cdvd.Speed, (cdvd.SpindlCtrl & CDVD_SPINDLE_CAV) ? L"CAV" : L"CLV", cdvd.ReadMode, cdvd.NCMDParam[10], cdvd.SpindlCtrl);
if (EmuConfig.CdvdVerboseReads)
Console.WriteLn(Color_Gray, L"DvdRead: Reading Sector %07d (%03d Blocks of Size %d) at Speed=%dx(%s) SpindleCtrl=%x",
Console.WriteLn(Color_Gray, "DvdRead: Reading Sector %07d (%03d Blocks of Size %d) at Speed=%dx(%s) SpindleCtrl=%x",
cdvd.SeekToSector, cdvd.nSectors, cdvd.BlockSize, cdvd.Speed, (cdvd.SpindlCtrl & CDVD_SPINDLE_CAV) ? L"CAV" : L"CLV", cdvd.SpindlCtrl);
cdvd.ReadTime = cdvdBlockReadTime(MODE_DVDROM);

9
pcsx2/CDVD/CDVDaccess.cpp
View File

@ -32,6 +32,8 @@
#include "IsoFS/IsoFSCDVD.h"
#include "IsoFileFormats.h"
#include "common/Assertions.h"
#include "common/Exceptions.h"
#include "common/FileSystem.h"
#include "common/StringUtil.h"
#include "DebugTools/SymbolMap.h"
@ -39,13 +41,6 @@
CDVD_API* CDVD = NULL;
const wxChar* CDVD_SourceLabels[] =
{
L"ISO",
L"Disc",
L"NoDisc",
NULL};
// ----------------------------------------------------------------------------
// diskTypeCached
// Internal disc type cache, to reduce the overhead of disc type checks, which are

2
pcsx2/CDVD/CDVDaccess.h
View File

@ -154,8 +154,6 @@ extern CDVD_API CDVDapi_Iso;
extern CDVD_API CDVDapi_Disc;
extern CDVD_API CDVDapi_NoDisc;
extern const wxChar* CDVD_SourceLabels[];
extern void CDVDsys_ChangeSource(CDVD_SourceType type);
extern void CDVDsys_SetFile(CDVD_SourceType srctype, std::string newfile);
extern const std::string& CDVDsys_GetFile(CDVD_SourceType srctype);

2
pcsx2/CDVD/CDVDdiscReader.cpp
View File

@ -18,6 +18,8 @@
#include "CDVD/CDVD.h"
#include <condition_variable>
#include <mutex>
#include <thread>
void (*newDiscCB)();

1
pcsx2/CDVD/CDVDisoReader.cpp
View File

@ -24,6 +24,7 @@
#include "IsoFileFormats.h"
#include "AsyncFileReader.h"
#include "CDVD/CDVD.h"
#include "common/Exceptions.h"
#include <cstring>
#include <array>

7
pcsx2/CDVD/ChdFileReader.cpp
View File

@ -16,6 +16,7 @@
#include "PrecompiledHeader.h"
#include "ChdFileReader.h"
#include "common/Assertions.h"
#include "common/FileSystem.h"
#include "common/StringUtil.h"
@ -114,7 +115,7 @@ bool ChdFileReader::Open2(std::string fileName)
if (error != CHDERR_NONE)
{
Console.Error(L"CDVD: chd_open return error: %s", chd_error_string(error));
Console.Error("CDVD: chd_open return error: %s", chd_error_string(error));
return false;
}
@ -131,7 +132,7 @@ bool ChdFileReader::Open2(std::string fileName)
error = chd_open_wrapper(chds[d].c_str(), &fp, CHD_OPEN_READ, parent, &child);
if (error != CHDERR_NONE)
{
Console.Error(L"CDVD: chd_open return error: %s", chd_error_string(error));
Console.Error("CDVD: chd_open return error: %s", chd_error_string(error));
if (parent)
chd_close(parent);
return false;
@ -175,7 +176,7 @@ int ChdFileReader::ReadChunk(void* dst, s64 chunkID)
chd_error error = chd_read(ChdFile, chunkID, dst);
if (error != CHDERR_NONE)
{
Console.Error(L"CDVD: chd_read returned error: %s", chd_error_string(error));
Console.Error("CDVD: chd_read returned error: %s", chd_error_string(error));
return 0;
}

1
pcsx2/CDVD/CompressedFileReader.cpp
View File

@ -20,6 +20,7 @@
#include "CsoFileReader.h"
#include "GzippedFileReader.h"
#include "common/FileSystem.h"
#include <algorithm>
#include <cctype>
// CompressedFileReader factory.

16
pcsx2/CDVD/GzippedFileReader.cpp
View File

@ -114,7 +114,7 @@ static wxString INDEX_TEMPLATE_KEY(L"$(f)");
// then it's relative to base (not to cwd)
// No checks are performed if the result file name can be created.
// If this proves useful, we can move it into Path:: . Right now there's no need.
static wxString ApplyTemplate(const wxString& name, const wxDirName& base,
static wxString ApplyTemplate(const std::string& name, const wxDirName& base,
const std::string& fileTemplate, const std::string& filename,
bool canEndWithKey)
{
@ -127,9 +127,9 @@ static wxString ApplyTemplate(const wxString& name, const wxDirName& base,
|| first != tem.rfind(key) // more than one instance
|| !canEndWithKey && first == tem.length() - key.length())
{
Console.Error(L"Invalid %s template '%s'.\n"
L"Template must contain exactly one '%s' and must not end with it. Abotring.",
WX_STR(name), WX_STR(tem), WX_STR(key));
Console.Error("Invalid %s template '%s'.\n"
"Template must contain exactly one '%s' and must not end with it. Abotring.",
name.c_str(), tem.ToUTF8().data(), key.ToUTF8().data());
return L"";
}
@ -181,7 +181,7 @@ static std::string iso2indexname(const std::string& isoname)
const wxDirName& appRoot = EmuFolders::DataRoot;
#endif
//TestTemplate(appRoot, isoname, false);
return StringUtil::wxStringToUTF8String(ApplyTemplate(L"gzip index", appRoot, EmuConfig.GzipIsoIndexTemplate, isoname, false));
return StringUtil::wxStringToUTF8String(ApplyTemplate("gzip index", appRoot, EmuConfig.GzipIsoIndexTemplate, isoname, false));
}
GzippedFileReader::GzippedFileReader(void)
@ -258,7 +258,7 @@ void GzippedFileReader::AsyncPrefetchChunk(s64 start)
{
if (hOverlappedFile == INVALID_HANDLE_VALUE || asyncInProgress)
{
Console.Warning(L"Unexpected file handle or progress state. Aborting prefetch.");
Console.Warning("Unexpected file handle or progress state. Aborting prefetch.");
return;
}
@ -384,7 +384,7 @@ int GzippedFileReader::ReadSync(void* pBuffer, uint sector, uint count)
int bytesToRead = count * m_blocksize;
int res = _ReadSync(pBuffer, offset, bytesToRead);
if (res < 0)
Console.Error(L"Error: iso-gzip read unsuccessful.");
Console.Error("Error: iso-gzip read unsuccessful.");
return res;
}
@ -486,7 +486,7 @@ int GzippedFileReader::_ReadSync(void* pBuffer, s64 offset, uint bytesToRead)
int duration = NOW() - s;
if (duration > 10)
Console.WriteLn(Color_Gray, L"gunzip: chunk #%5d-%2d : %1.2f MB - %d ms",
Console.WriteLn(Color_Gray, "gunzip: chunk #%5d-%2d : %1.2f MB - %d ms",
(int)(offset / 4 / 1024 / 1024),
(int)(offset % (4 * 1024 * 1024) / GZFILE_READ_CHUNK_SIZE),
(float)size / 1024 / 1024,

15
pcsx2/CDVD/InputIsoFile.cpp
View File

@ -16,6 +16,11 @@
#include "PrecompiledHeader.h"
#include "IsoFileFormats.h"
#include "common/Assertions.h"
#include "common/Exceptions.h"
#include "Config.h"
#include "fmt/core.h"
#include <errno.h>
@ -42,10 +47,8 @@ int InputIsoFile::ReadSync(u8* dst, uint lsn)
{
if (lsn >= m_blocks)
{
FastFormatUnicode msg;
msg.Write("isoFile error: Block index is past the end of file! (%u >= %u).", lsn, m_blocks);
pxAssertDev(false, msg);
std::string msg(fmt::format("isoFile error: Block index is past the end of file! ({} >= {}).", lsn, m_blocks));
pxAssertDev(false, msg.c_str());
Console.Error(msg.c_str());
return -1;
}
@ -248,8 +251,8 @@ bool InputIsoFile::Open(std::string srcfile, bool testOnly)
if (!detected)
throw Exception::BadStream()
.SetUserMsg(_("Unrecognized ISO image file format"))
.SetDiagMsg(L"ISO mounting failed: PCSX2 is unable to identify the ISO image type.");
.SetUserMsg("Unrecognized ISO image file format")
.SetDiagMsg("ISO mounting failed: PCSX2 is unable to identify the ISO image type.");
if (!isBlockdump && !isCompressed)
{

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

@ -19,6 +19,8 @@
#include "IsoFS.h"
#include "IsoFile.h"
#include "common/Assertions.h"
#include "common/Exceptions.h"
#include "common/FileSystem.h"
#include "common/StringUtil.h"
@ -159,7 +161,7 @@ int IsoDirectory::GetIndexOf(const std::string_view& fileName) const
return i;
}
throw Exception::FileNotFound(StringUtil::UTF8StringToWideString(fileName));
throw Exception::FileNotFound(std::string(fileName));
}
const IsoFileDescriptor& IsoDirectory::GetEntry(const std::string_view& fileName) const
@ -189,7 +191,7 @@ IsoFileDescriptor IsoDirectory::FindFile(const std::string_view& filePath) const
{
info = dir->GetEntry(parts[index]);
if (info.IsFile())
throw Exception::FileNotFound(StringUtil::UTF8StringToWxString(filePath));
throw Exception::FileNotFound(std::string(filePath));
deleteme.reset(new IsoDirectory(internalReader, info));
dir = deleteme.get();

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

@ -15,10 +15,14 @@
#include "PrecompiledHeader.h"
#include "common/Assertions.h"
#include "common/Exceptions.h"
#include "IsoFS.h"
#include "IsoFile.h"
#include <cstdio>
IsoFile::IsoFile(SectorSource& reader, const std::string_view& filename)
: internalReader(reader)
, fileEntry(IsoDirectory(reader).FindFile(filename))
@ -74,19 +78,19 @@ u32 IsoFile::seek(u32 absoffset)
// Returns the new offset in the file. Out-of-bounds seeks are automatically truncated at 0
// and fileLength.
u32 IsoFile::seek(s64 offset, wxSeekMode ref_position)
u32 IsoFile::seek(s64 offset, int mode)
{
switch (ref_position)
switch (mode)
{
case wxFromStart:
case SEEK_SET:
pxAssertDev(offset >= 0 && offset <= (s64)ULONG_MAX, "Invalid seek position from start.");
return seek(offset);
case wxFromCurrent:
case SEEK_CUR:
// truncate negative values to zero, and positive values to 4gb
return seek(std::min(std::max<s64>(0, (s64)currentOffset + offset), (s64)ULONG_MAX));
case wxFromEnd:
case SEEK_END:
// truncate negative values to zero, and positive values to 4gb
return seek(std::min(std::max<s64>(0, (s64)fileEntry.size + offset), (s64)ULONG_MAX));

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

@ -44,7 +44,7 @@ public:
virtual ~IsoFile() = default;
u32 seek(u32 absoffset);
u32 seek(s64 offset, wxSeekMode ref_position);
u32 seek(s64 offset, int mode);
void reset();
s32 skip(s32 n);

13
pcsx2/CDVD/OutputIsoFile.cpp
View File

@ -16,9 +16,12 @@
#include "PrecompiledHeader.h"
#include "IsoFileFormats.h"
#include "common/Exceptions.h"
#include "common/FileSystem.h"
#include "common/StringUtil.h"
#include "fmt/core.h"
#include <errno.h>
OutputIsoFile::OutputIsoFile()
@ -55,7 +58,7 @@ void OutputIsoFile::Create(std::string filename, int version)
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));
ScopedExcept ex(Exception::FromErrno(filename, errno));
ex->Rethrow();
}
@ -123,12 +126,12 @@ void OutputIsoFile::WriteBuffer(const void* src, size_t size)
int err = errno;
if (!err)
{
throw Exception::BadStream(StringUtil::UTF8StringToWxString(m_filename))
.SetDiagMsg(pxsFmt(L"An error occurred while writing %u bytes to file", size));
throw Exception::BadStream(m_filename)
.SetDiagMsg(fmt::format("An error occurred while writing {} bytes to file", size));
}
ScopedExcept ex(Exception::FromErrno(StringUtil::UTF8StringToWxString(m_filename), err));
ex->SetDiagMsg(pxsFmt(L"An error occurred while writing %u bytes to file: %s", size, WX_STR(ex->DiagMsg())));
ScopedExcept ex(Exception::FromErrno(m_filename, err));
ex->SetDiagMsg(fmt::format("An error occurred while writing {} bytes to file: {}", size, ex->DiagMsg()));
ex->Rethrow();
}
}

11
pcsx2/CMakeLists.txt
View File

@ -1116,6 +1116,7 @@ set(pcsx2GuiSources
gui/Debugger/DebugEvents.cpp
gui/DriveList.cpp
gui/ExecutorThread.cpp
gui/FastFormatString.cpp
gui/FrameForGS.cpp
gui/GlobalCommands.cpp
gui/IniInterface.cpp
@ -1143,9 +1144,11 @@ set(pcsx2GuiSources
gui/pxCheckBox.cpp
gui/pxRadioPanel.cpp
gui/pxStaticText.cpp
gui/pxTranslate.cpp
gui/pxWindowTextWriter.cpp
gui/RecentIsoList.cpp
gui/Saveslots.cpp
gui/StringHelpers.cpp
gui/SysCoreThread.cpp
gui/SysState.cpp
gui/SysThreadBase.cpp
@ -1201,6 +1204,7 @@ set(pcsx2GuiHeaders
gui/pxStaticText.h
gui/RecentIsoList.h
gui/Saveslots.h
gui/StringHelpers.h
gui/SysThreads.h
gui/ThreadingDialogs.h
gui/ThreadingDialogs.cpp
@ -1387,11 +1391,6 @@ set(pcsx2SystemHeaders
set(pcsx2UtilitiesSources
Utilities/FileUtils.cpp)
# Utilities headers
set(pcsx2UtilitiesHeaders
Utilities/AsciiFile.h)
# Windows sources
set(pcsx2WindowsSources
CDVD/Windows/DriveUtility.cpp
@ -1520,7 +1519,7 @@ target_sources(PCSX2 PRIVATE
${pcsx2ps2Headers}
${pcsx2SystemHeaders}
${pcsx2UtilitiesSources}
${pcsx2UtilitiesHeaders})
)
# gui sources when not doing a qt build
if (NOT PCSX2_CORE)

6
pcsx2/Common.h
View File

@ -31,5 +31,7 @@ extern s64 PSXCLK; /* 36.864 Mhz */
#include "SaveState.h"
#include "DebugTools/Debug.h"
extern wxString ShiftJIS_ConvertString( const char* src );
extern wxString ShiftJIS_ConvertString( const char* src, int maxlen );
#include <string>
extern std::string ShiftJIS_ConvertString( const char* src );
extern std::string ShiftJIS_ConvertString( const char* src, int maxlen );

3
pcsx2/Config.h
View File

@ -802,9 +802,6 @@ struct Pcsx2Config
void LoadSave(SettingsWrapper& wrap);
GamefixOptions& DisableAll();
void Set(const wxString& list, bool enabled = true);
void Clear(const wxString& list) { Set(list, false); }
bool Get(GamefixId id) const;
void Set(GamefixId id, bool enabled = true);
void Clear(GamefixId id) { Set(id, false); }

1
pcsx2/DEV9/ATA/ATA.h
View File

@ -22,6 +22,7 @@
#include <condition_variable>
#include <fstream>
#include "common/Path.h"
#include "DEV9/SimpleQueue.h"
class ATA

2
pcsx2/DEV9/ATA/ATA_State.cpp
View File

@ -15,6 +15,8 @@
#include "PrecompiledHeader.h"
#include "common/Assertions.h"
#include "ATA.h"
#include "DEV9/DEV9.h"
#ifndef PCSX2_CORE

2
pcsx2/DEV9/ATA/ATA_Transfer.cpp
View File

@ -15,6 +15,8 @@
#include "PrecompiledHeader.h"
#include "common/Assertions.h"
#include "ATA.h"
#include "DEV9/DEV9.h"

2
pcsx2/DEV9/ATA/HddCreate.h
View File

@ -18,6 +18,8 @@
#include <atomic>
#include <chrono>
#include "common/Path.h"
class HddCreate
{
public:

1
pcsx2/DEV9/ATA/HddCreateWx.cpp
View File

@ -16,6 +16,7 @@
#include "PrecompiledHeader.h"
#include "HddCreateWx.h"
#include "gui/App.h"
void HddCreateWx::Init()
{

2
pcsx2/DEV9/DEV9.cpp
View File

@ -15,6 +15,8 @@
#include "PrecompiledHeader.h"
#include "common/Assertions.h"
#ifdef _WIN32
#include "common/RedtapeWindows.h"
#include <Winioctl.h>

2
pcsx2/DEV9/PacketReader/Payload.h
View File

@ -15,6 +15,8 @@
#pragma once
#include <memory>
namespace PacketReader
{
class Payload

4
pcsx2/DEV9/Sessions/ICMP_Session/ICMP_Session.cpp
View File

@ -16,6 +16,7 @@
#include "PrecompiledHeader.h"
#ifdef _WIN32
#include "common/RedtapeWindows.h"
#include <iphlpapi.h>
#include <icmpapi.h>
#elif defined(__POSIX__)
@ -36,6 +37,7 @@
#ifdef __linux__
#include <linux/errqueue.h>
#endif
#include <unistd.h>
#endif
#include "ICMP_Session.h"
@ -898,4 +900,4 @@ namespace Sessions
for (size_t i = 0; i < pings.size(); i++)
delete pings[i];
}
} // namespace Sessions
} // namespace Sessions

7
pcsx2/DEV9/Sessions/TCP_Session/TCP_Session.cpp
View File

@ -17,6 +17,13 @@
#include "TCP_Session.h"
#ifdef _WIN32
#include "common/RedtapeWindows.h"
#include <winsock2.h>
#else
#include <unistd.h>
#endif
using namespace PacketReader;
using namespace PacketReader::IP;
using namespace PacketReader::IP::TCP;

9
pcsx2/DEV9/Sessions/UDP_Session/UDP_FixedPort.cpp
View File

@ -15,6 +15,8 @@
#include "PrecompiledHeader.h"
#include "common/Assertions.h"
#ifdef __POSIX__
#define SOCKET_ERROR -1
#include <errno.h>
@ -22,6 +24,13 @@
#include <netinet/in.h>
#endif
#ifdef _WIN32
#include "common/RedtapeWindows.h"
#include <winsock2.h>
#else
#include <unistd.h>
#endif
#include "UDP_FixedPort.h"
#include "DEV9/PacketReader/IP/UDP/UDP_Packet.h"

9
pcsx2/DEV9/Sessions/UDP_Session/UDP_Session.cpp
View File

@ -15,6 +15,8 @@
#include "PrecompiledHeader.h"
#include "common/Assertions.h"
#ifdef __POSIX__
#define SOCKET_ERROR -1
#include <errno.h>
@ -22,6 +24,13 @@
#include <netinet/in.h>
#endif
#ifdef _WIN32
#include "common/RedtapeWindows.h"
#include <winsock2.h>
#else
#include <unistd.h>
#endif
#include "UDP_Session.h"
#include "DEV9/PacketReader/IP/UDP/UDP_Packet.h"

4
pcsx2/DEV9/SimpleQueue.h
View File

@ -15,6 +15,10 @@
#pragma once
#include <atomic>
#include "common/Assertions.h"
//Designed to allow one thread to queue data to another thread
template <class T>
class SimpleQueue

10
pcsx2/DEV9/Win32/tap-win32.cpp
View File

@ -18,6 +18,8 @@
#include "common/RedtapeWindows.h"
#include "common/StringUtil.h"
#include "fmt/core.h"
#include <stdio.h>
#include <windows.h>
#include <winsock2.h>
@ -355,7 +357,7 @@ bool TAPGetWin32Adapter(const std::string& name, PIP_ADAPTER_ADDRESSES adapter,
//We must be bridged
Console.WriteLn("DEV9: Current adapter is probably bridged");
Console.WriteLn(L"DEV9: Adapter Display name: %s", pAdapterInfo->FriendlyName);
Console.WriteLn(fmt::format("DEV9: Adapter Display name: {}", StringUtil::WideStringToUTF8String(pAdapterInfo->FriendlyName)));
//We will need to find the bridge adapter that out adapter is
//as the IP information of the tap adapter is null
@ -407,7 +409,7 @@ bool TAPGetWin32Adapter(const std::string& name, PIP_ADAPTER_ADDRESSES adapter,
PIP_ADAPTER_ADDRESSES potentialAdapter = FindAdapterViaIndex(AdapterInfoReduced.get(), row.HigherLayerInterfaceIndex);
if (potentialAdapter != nullptr)
{
Console.WriteLn(L"DEV9: %s is possible bridge (Check 1 passed)", potentialAdapter->Description);
Console.WriteLn(fmt::format("DEV9: {} is possible bridge (Check 1 passed)", StringUtil::WideStringToUTF8String(potentialAdapter->Description)));
potentialBridges.push_back(row.HigherLayerInterfaceIndex);
}
else
@ -491,7 +493,7 @@ bool TAPGetWin32Adapter(const std::string& name, PIP_ADAPTER_ADDRESSES adapter,
wil::unique_cotaskmem_string dispName;
hr = component->GetDisplayName(dispName.put());
if (SUCCEEDED(hr))
Console.WriteLn(L"DEV9: %s is possible bridge (Check 2 passed)", dispName);
Console.WriteLn(fmt::format("DEV9: {} is possible bridge (Check 2 passed)", StringUtil::WideStringToUTF8String(dispName.get())));
//Check if adapter has the ms_bridge component bound to it.
auto bindings = bridge.try_query<INetCfgComponentBindings>();
@ -504,7 +506,7 @@ bool TAPGetWin32Adapter(const std::string& name, PIP_ADAPTER_ADDRESSES adapter,
hr = component->GetDisplayName(dispName.put());
if (SUCCEEDED(hr))
Console.WriteLn(L"DEV9: %s is bridge (Check 3 passed)", dispName);
Console.WriteLn(fmt::format("DEV9: {} is bridge (Check 3 passed)", StringUtil::WideStringToUTF8String(dispName.get())));
bridgeAdapter = cAdapterInfo;
break;

2
pcsx2/DEV9/net.h
View File

@ -31,6 +31,8 @@
#include <ifaddrs.h>
#endif
#include "Config.h"
#include "PacketReader/IP/IP_Address.h"
#include "InternalServers/DHCP_Server.h"
#include "InternalServers/DNS_Logger.h"

2
pcsx2/DEV9/pcap_io.cpp
View File

@ -14,6 +14,8 @@
*/
#include "PrecompiledHeader.h"
#include "common/Assertions.h"
#include <memory>
#ifdef _WIN32

1
pcsx2/DEV9/sockets.cpp
View File

@ -14,6 +14,7 @@
*/
#include "PrecompiledHeader.h"
#include "common/Assertions.h"
#include "common/StringUtil.h"
#ifdef __POSIX__

2
pcsx2/Darwin/DarwinFlatFileReader.cpp
View File

@ -129,5 +129,5 @@ void FlatFileReader::Close(void)
uint FlatFileReader::GetBlockCount(void) const
{
return (int)(Path::GetFileSize(m_filename) / m_blocksize);
return (int)(FileSystem::GetPathFileSize(m_filename.c_str()) / m_blocksize);
}

35
pcsx2/DebugTools/Debug.h
View File

@ -86,13 +86,13 @@ class SysTraceLog_EE : public SysTraceLog
public:
SysTraceLog_EE( const SysTraceLogDescriptor* desc ) : _parent( desc ) {}
void ApplyPrefix( FastFormatAscii& ascii ) const override;
void ApplyPrefix( std::string& ascii ) const override;
bool IsActive() const override
{
return SysTraceLog::IsActive() && EmuConfig.Trace.EE.m_EnableAll;
}
wxString GetCategory() const override { return L"EE"; }
std::string GetCategory() const override { return "EE"; }
};
class SysTraceLog_VIFcode : public SysTraceLog_EE
@ -102,7 +102,7 @@ class SysTraceLog_VIFcode : public SysTraceLog_EE
public:
SysTraceLog_VIFcode( const SysTraceLogDescriptor* desc ) : _parent( desc ) {}
void ApplyPrefix( FastFormatAscii& ascii ) const override;
void ApplyPrefix(std::string& ascii ) const override;
};
class SysTraceLog_EE_Disasm : public SysTraceLog_EE
@ -117,7 +117,7 @@ public:
return _parent::IsActive() && EmuConfig.Trace.EE.m_EnableDisasm;
}
wxString GetCategory() const override { return _parent::GetCategory() + L".Disasm"; }
std::string GetCategory() const override { return _parent::GetCategory() + ".Disasm"; }
};
class SysTraceLog_EE_Registers : public SysTraceLog_EE
@ -132,7 +132,7 @@ public:
return _parent::IsActive() && EmuConfig.Trace.EE.m_EnableRegisters;
}
wxString GetCategory() const override { return _parent::GetCategory() + L".Registers"; }
std::string GetCategory() const override { return _parent::GetCategory() + ".Registers"; }
};
class SysTraceLog_EE_Events : public SysTraceLog_EE
@ -147,7 +147,7 @@ public:
return _parent::IsActive() && EmuConfig.Trace.EE.m_EnableEvents;
}
wxString GetCategory() const override { return _parent::GetCategory() + L".Events"; }
std::string GetCategory() const override { return _parent::GetCategory() + ".Events"; }
};
@ -158,13 +158,13 @@ class SysTraceLog_IOP : public SysTraceLog
public:
SysTraceLog_IOP( const SysTraceLogDescriptor* desc ) : _parent( desc ) {}
void ApplyPrefix( FastFormatAscii& ascii ) const override;
void ApplyPrefix( std::string& ascii ) const override;
bool IsActive() const override
{
return SysTraceLog::IsActive() && EmuConfig.Trace.IOP.m_EnableAll;
}
wxString GetCategory() const override { return L"IOP"; }
std::string GetCategory() const override { return "IOP"; }
};
class SysTraceLog_IOP_Disasm : public SysTraceLog_IOP
@ -178,7 +178,7 @@ public:
return _parent::IsActive() && EmuConfig.Trace.IOP.m_EnableDisasm;
}
wxString GetCategory() const override { return _parent::GetCategory() + L".Disasm"; }
std::string GetCategory() const override { return _parent::GetCategory() + ".Disasm"; }
};
class SysTraceLog_IOP_Registers : public SysTraceLog_IOP
@ -192,7 +192,7 @@ public:
return _parent::IsActive() && EmuConfig.Trace.IOP.m_EnableRegisters;
}
wxString GetCategory() const override { return _parent::GetCategory() + L".Registers"; }
std::string GetCategory() const override { return _parent::GetCategory() + ".Registers"; }
};
class SysTraceLog_IOP_Events : public SysTraceLog_IOP
@ -206,7 +206,7 @@ public:
return _parent::IsActive() && EmuConfig.Trace.IOP.m_EnableEvents;
}
wxString GetCategory() const override { return _parent::GetCategory() + L".Events"; }
std::string GetCategory() const override { return _parent::GetCategory() + ".Events"; }
};
// --------------------------------------------------------------------------------------
@ -226,10 +226,10 @@ class ConsoleLogFromVM : public BaseTraceLogSource
public:
ConsoleLogFromVM( const TraceLogDescriptor* desc ) : _parent( desc ) {}
bool Write( const wxString &msg ) const
bool Write( const char* msg ) const
{
ConsoleColorScope cs(conColor);
Console.WriteRaw( msg );
Console.WriteRaw(msg);
// Buffered output isn't compatible with the testsuite. The end of test
// doesn't always get flushed. Let's just flush all the output if EE/IOP
@ -241,7 +241,7 @@ public:
bool Write(const std::string& msg) const
{
return Write(fromUTF8(msg));
return Write(msg.c_str());
}
};
@ -347,13 +347,6 @@ extern void __Log( const char* fmt, ... );
# define SysTraceActive(trace) (false)
#endif
#ifdef __WXMAC__
// Not available on OSX, apparently always double buffered window.
# define SetDoubleBuffered(x)
// TODO OSX OsxKeyCodes.cpp pending
#endif
#define macTrace(trace) SysTraceActive(trace) && SysTrace.trace.Write
#define SIF_LOG macTrace(SIF)

20
pcsx2/DebugTools/DebugInterface.cpp
View File

@ -27,6 +27,8 @@
#include "IopMem.h"
#include "SymbolMap.h"
#include "common/StringUtil.h"
#ifndef PCSX2_CORE
#include "gui/SysThreads.h"
#endif
@ -506,7 +508,7 @@ u128 R5900DebugInterface::getRegister(int cat, int num)
return result;
}
wxString R5900DebugInterface::getRegisterString(int cat, int num)
std::string R5900DebugInterface::getRegisterString(int cat, int num)
{
switch (cat)
{
@ -514,15 +516,11 @@ wxString R5900DebugInterface::getRegisterString(int cat, int num)
case EECAT_CP0:
case EECAT_FCR:
case EECAT_VU0F:
return getRegister(cat, num).ToString();
return StringUtil::U128ToString(getRegister(cat, num));
case EECAT_FPR:
{
char str[64];
sprintf(str, "%f", fpuRegs.fpr[num].f);
return wxString(str, wxConvUTF8);
}
return StringUtil::StdStringFromFormat("%f", fpuRegs.fpr[num].f);
default:
return L"";
return {};
}
}
@ -829,14 +827,14 @@ u128 R3000DebugInterface::getRegister(int cat, int num)
return u128::From32(value);
}
wxString R3000DebugInterface::getRegisterString(int cat, int num)
std::string R3000DebugInterface::getRegisterString(int cat, int num)
{
switch (cat)
{
case IOPCAT_GPR:
return getRegister(cat, num).ToString();
return StringUtil::U128ToString(getRegister(cat, num));
default:
return L"Invalid";
return "Invalid";
}
}

8
pcsx2/DebugTools/DebugInterface.h
View File

@ -18,6 +18,8 @@
#include "ExpressionParser.h"
#include "SymbolMap.h"
#include <string>
enum
{
EECAT_GPR,
@ -66,7 +68,7 @@ public:
virtual RegisterType getRegisterType(int cat) = 0;
virtual const char* getRegisterName(int cat, int num) = 0;
virtual u128 getRegister(int cat, int num) = 0;
virtual wxString getRegisterString(int cat, int num) = 0;
virtual std::string getRegisterString(int cat, int num) = 0;
virtual u128 getHI() = 0;
virtual u128 getLO() = 0;
virtual u32 getPC() = 0;
@ -107,7 +109,7 @@ public:
RegisterType getRegisterType(int cat) override;
const char* getRegisterName(int cat, int num) override;
u128 getRegister(int cat, int num) override;
wxString getRegisterString(int cat, int num) override;
std::string getRegisterString(int cat, int num) override;
u128 getHI() override;
u128 getLO() override;
u32 getPC() override;
@ -141,7 +143,7 @@ public:
RegisterType getRegisterType(int cat) override;
const char* getRegisterName(int cat, int num) override;
u128 getRegister(int cat, int num) override;
wxString getRegisterString(int cat, int num) override;
std::string getRegisterString(int cat, int num) override;
u128 getHI() override;
u128 getLO() override;
u32 getPC() override;

3
pcsx2/DebugTools/SymbolMap.cpp
View File

@ -14,6 +14,7 @@
*/
#include "PrecompiledHeader.h"
#include "common/FileSystem.h"
#include "SymbolMap.h"
#include <algorithm>
@ -47,7 +48,7 @@ void SymbolMap::Clear() {
bool SymbolMap::LoadNocashSym(const char *filename) {
std::lock_guard<std::recursive_mutex> guard(m_lock);
FILE *f = wxFopen(filename, "r");
FILE *f = FileSystem::OpenCFile(filename, "r");
if (!f)
return false;

2
pcsx2/Dmac.cpp
View File

@ -273,7 +273,7 @@ static __ri void DmaExec( void (*func)(), u32 mem, u32 value )
static bool warned; //Check if the warning has already been output to console, to prevent constant spam.
if (!warned)
{
DevCon.Warning(L"%s CHCR.MOD set to 3, assuming 1 (chain)", ChcrName(mem));
DevCon.Warning("%s CHCR.MOD set to 3, assuming 1 (chain)", ChcrName(mem));
warned = true;
}
reg.chcr.MOD = 0x1;

66
pcsx2/Dump.cpp
View File

@ -23,7 +23,9 @@
#include "DebugTools/SymbolMap.h"
#include "Config.h"
#include "Utilities/AsciiFile.h"
#include "common/FileSystem.h"
#include "fmt/core.h"
using namespace R5900;
@ -209,22 +211,24 @@ void iDumpBlock(u32 ee_pc, u32 ee_size, uptr x86_pc, u32 x86_size)
DbgCon.WriteLn( Color_Gray, "dump block %x:%x (x86:0x%x)", ee_pc, ee_end, x86_pc );
EmuFolders::Logs.Mkdir();
wxString dump_filename = Path::Combine(EmuFolders::Logs, wxsFormat(L"R5900dump_%.8X:%.8X.txt", ee_pc, ee_end) );
AsciiFile eff( dump_filename, L"w" );
std::string dump_filename(Path::CombineStdString(EmuFolders::Logs, fmt::format("R5900dump_{:.8X}:{:.8X}.txt", ee_pc, ee_end) ));
std::FILE* eff = FileSystem::OpenCFile(dump_filename.c_str(), "w");
if (!eff)
return;
// Print register content to detect the memory access type. Warning value are taken
// during the call of this function. There aren't the real value of the block.
eff.Printf("Dump register data: 0x%x\n", (uptr)&cpuRegs.GPR.r[0].UL[0]);
std::fprintf(eff, "Dump register data: 0x%p\n", &cpuRegs.GPR.r[0].UL[0]);
for (int reg = 0; reg < 32; reg++) {
// Only lower 32 bits (enough for address)
eff.Printf("\t%2s <= 0x%08x_%08x\n", R5900::GPR_REG[reg], cpuRegs.GPR.r[reg].UL[1],cpuRegs.GPR.r[reg].UL[0]);
std::fprintf(eff, "\t%2s <= 0x%08x_%08x\n", R5900::GPR_REG[reg], cpuRegs.GPR.r[reg].UL[1],cpuRegs.GPR.r[reg].UL[0]);
}
eff.Printf("\n");
std::fprintf(eff, "\n");
if (!R5900SymbolMap.GetLabelString(ee_pc).empty())
{
eff.Printf( "%s\n", R5900SymbolMap.GetLabelString(ee_pc).c_str() );
std::fprintf(eff, "%s\n", R5900SymbolMap.GetLabelString(ee_pc).c_str() );
}
for ( u32 i = ee_pc; i < ee_end; i += 4 )
@ -232,29 +236,31 @@ void iDumpBlock(u32 ee_pc, u32 ee_size, uptr x86_pc, u32 x86_size)
std::string output;
//TLB Issue disR5900Fasm( output, memRead32( i ), i, false );
disR5900Fasm( output, psMu32(i), i, false );
eff.Printf( "0x%.X : %s\n", i, output.c_str() );
std::fprintf(eff, "0x%.X : %s\n", i, output.c_str() );
}
// Didn't find (search) a better solution
eff.Printf( "\nRaw x86 dump (https://www.onlinedisassembler.com/odaweb/):\n");
std::fprintf(eff, "\nRaw x86 dump (https://www.onlinedisassembler.com/odaweb/):\n");
u8* x86 = (u8*)x86_pc;
for (u32 i = 0; i < x86_size; i++) {
eff.Printf("%.2X", x86[i]);
std::fprintf(eff, "%.2X", x86[i]);
}
eff.Printf("\n\n");
std::fprintf(eff, "\n\n");
eff.Close(); // Close the file so it can be appended by objdump
std::fclose(eff); // Close the file so it can be appended by objdump
// handy but slow solution (system call)
#ifdef __linux__
wxString obj_filename = Path::Combine(EmuFolders::Logs, wxString(L"objdump_tmp.o"));
wxFFile objdump(obj_filename , L"wb");
objdump.Write(x86, x86_size);
objdump.Close();
std::string obj_filename(Path::CombineStdString(EmuFolders::Logs, "objdump_tmp.o"));
std::FILE* objdump = FileSystem::OpenCFile(obj_filename.c_str(), "wb");
if (!objdump)
return;
std::fwrite(x86, x86_size, 1, objdump);
std::fclose(objdump);
int status = std::system(
wxsFormat( L"objdump -D -b binary -mi386 --disassembler-options=intel --no-show-raw-insn --adjust-vma=%d %s >> %s",
(u32) x86_pc, WX_STR(obj_filename), WX_STR(dump_filename)).mb_str()
fmt::format( "objdump -D -b binary -mi386 --disassembler-options=intel --no-show-raw-insn --adjust-vma=%d %s >> %s",
(u32) x86_pc, obj_filename, dump_filename).c_str()
);
if (!WIFEXITED(status))
@ -273,25 +279,25 @@ void iDumpBlock( int startpc, u8 * ptr )
DbgCon.WriteLn( Color_Gray, "dump1 %x:%x, %x", startpc, pc, cpuRegs.cycle );
EmuFolders::Logs.Mkdir();
AsciiFile eff(
Path::Combine( EmuFolders::Logs, wxsFormat(L"R5900dump%.8X.txt", startpc) ), L"w"
);
std::FILE* eff = FileSystem::OpenCFile(Path::CombineStdString(EmuFolders::Logs, fmt::format("R5900dump{:.8X}.txt", startpc)).c_str(), "w");
if (!eff)
return;
if (!R5900SymbolMap.GetLabelString(startpc).empty())
{
eff.Printf( "%s\n", R5900SymbolMap.GetLabelString(startpc).c_str() );
std::fprintf(eff, "%s\n", R5900SymbolMap.GetLabelString(startpc).c_str() );
}
for ( uint i = startpc; i < s_nEndBlock; i += 4 )
{
std::string output;
disR5900Fasm( output, memRead32( i ), i, false );
eff.Printf( "%s\n", output.c_str() );
std::fprintf(eff, "%s\n", output.c_str() );
}
// write the instruction info
eff.Printf( "\n\nlive0 - %x, live2 - %x, lastuse - %x\nxmm - %x, used - %x\n",
std::fprintf(eff, "\n\nlive0 - %x, live2 - %x, lastuse - %x\nxmm - %x, used - %x\n",
EEINST_LIVE0, EEINST_LIVE2, EEINST_LASTUSE, EEINST_XMM, EEINST_USED
);
@ -313,17 +319,17 @@ void iDumpBlock( int startpc, u8 * ptr )
}
}
eff.Printf( " " );
std::fprintf(eff, " " );
for(uint i = 0; i < std::size(s_pInstCache->regs); ++i) {
if( used[i] ) eff.Printf( "%2d ", i );
if( used[i] ) std::fprintf(eff, "%2d ", i );
}
eff.Printf( "\n" );
std::fprintf(eff, "\n" );
for(uint i = 0; i < std::size(s_pInstCache->fpuregs); ++i) {
if( fpuused[i] ) eff.Printf( "%2d ", i );
if( fpuused[i] ) std::fprintf(eff, "%2d ", i );
}
eff.Printf( "\n" );
eff.Printf( " " );
std::fprintf(eff, "\n" );
std::fprintf(eff, " " );
// TODO : Finish converting this over to wxWidgets wxFile stuff...
/*

30
pcsx2/Elfheader.cpp
View File

@ -34,7 +34,7 @@ bool isPSXElf;
// All of ElfObjects functions.
ElfObject::ElfObject(std::string srcfile, IsoFile& isofile, bool isPSXElf)
: data(isofile.getLength(), L"ELF headers")
: data(isofile.getLength(), "ELF headers")
, filename(std::move(srcfile))
, header(*(ELF_HEADER*)data.GetPtr())
{
@ -44,7 +44,7 @@ ElfObject::ElfObject(std::string srcfile, IsoFile& isofile, bool isPSXElf)
}
ElfObject::ElfObject(std::string srcfile, u32 hdrsize, bool isPSXElf)
: data(hdrsize, L"ELF headers")
: data(hdrsize, "ELF headers")
, filename(std::move(srcfile))
, header(*(ELF_HEADER*)data.GetPtr())
{
@ -60,7 +60,7 @@ void ElfObject::initElfHeaders(bool isPSXElf)
return;
}
DevCon.WriteLn( L"Initializing Elf: %d bytes", data.GetSizeInBytes());
DevCon.WriteLn("Initializing Elf: %d bytes", data.GetSizeInBytes());
if (header.e_phnum > 0)
{
@ -157,40 +157,40 @@ 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(StringUtil::UTF8StringToWxString(filename));
if (rsize < data.GetSizeInBytes()) throw Exception::EndOfStream(filename);
}
void ElfObject::readFile()
{
int rsize = 0;
FILE *f = FileSystem::OpenCFile( filename.c_str(), "rb");
if (f == NULL) throw Exception::FileNotFound(StringUtil::UTF8StringToWxString(filename));
if (f == NULL) throw Exception::FileNotFound(filename);
fseek(f, 0, SEEK_SET);
rsize = fread(data.GetPtr(), 1, data.GetSizeInBytes(), f);
fclose( f );
if (rsize < data.GetSizeInBytes()) throw Exception::EndOfStream(StringUtil::UTF8StringToWxString(filename));
if (rsize < data.GetSizeInBytes()) throw Exception::EndOfStream(filename);
}
static wxString GetMsg_InvalidELF()
static std::string GetMsg_InvalidELF()
{
return
_("Cannot load ELF binary image. The file may be corrupt or incomplete.") +
wxString(L"\n\n") +
_("If loading from an ISO image, this error may be caused by an unsupported ISO image type or a bug in PCSX2 ISO image support.");
"Cannot load ELF binary image. The file may be corrupt or incomplete."
"\n\n"
"If loading from an ISO image, this error may be caused by an unsupported ISO image type or a bug in PCSX2 ISO image support.";
}
void ElfObject::checkElfSize(s64 elfsize)
{
const wxChar* diagMsg = NULL;
if (elfsize > 0xfffffff) diagMsg = L"Illegal ELF file size over 2GB!";
else if (elfsize == -1) diagMsg = L"ELF file does not exist!";
else if (elfsize == 0) diagMsg = L"Unexpected end of ELF file.";
const char* diagMsg = NULL;
if (elfsize > 0xfffffff) diagMsg = "Illegal ELF file size over 2GB!";
else if (elfsize == -1) diagMsg = "ELF file does not exist!";
else if (elfsize == 0) diagMsg = "Unexpected end of ELF file.";
if (diagMsg)
throw Exception::BadStream(StringUtil::UTF8StringToWxString(filename))
throw Exception::BadStream(filename)
.SetDiagMsg(diagMsg)
.SetUserMsg(GetMsg_InvalidELF());
}

2
pcsx2/Elfheader.h
View File

@ -16,6 +16,8 @@
#ifndef __ELF_H__
#define __ELF_H__
#include "common/SafeArray.h"
#include "common/SafeArray.inl"
#include "CDVD/IsoFS/IsoFSCDVD.h"
#include "CDVD/IsoFS/IsoFS.h"

6
pcsx2/FiFo.cpp
View File

@ -60,7 +60,7 @@ void ReadFIFO_VIF1(mem128_t* out)
}
}
VIF_LOG("ReadFIFO/VIF1 -> %ls", WX_STR(out->ToString()));
VIF_LOG("ReadFIFO/VIF1 -> 0x%08X.%08X.%08X.%08X", out->_u32[0], out->_u32[1], out->_u32[2], out->_u32[3]);
}
//////////////////////////////////////////////////////////////////////////
@ -68,7 +68,7 @@ void ReadFIFO_VIF1(mem128_t* out)
//
void WriteFIFO_VIF0(const mem128_t* value)
{
VIF_LOG("WriteFIFO/VIF0 <- %ls", WX_STR(value->ToString()));
VIF_LOG("WriteFIFO/VIF0 <- 0x%08X.%08X.%08X.%08X", value->_u32[0], value->_u32[1], value->_u32[2], value->_u32[3]);
vif0ch.qwc += 1;
if (vif0.irqoffset.value != 0 && vif0.vifstalled.enabled)
@ -90,7 +90,7 @@ void WriteFIFO_VIF0(const mem128_t* value)
void WriteFIFO_VIF1(const mem128_t* value)
{
VIF_LOG("WriteFIFO/VIF1 <- %ls", WX_STR(value->ToString()));
VIF_LOG("WriteFIFO/VIF1 <- 0x%08X.%08X.%08X.%08X", value->_u32[0], value->_u32[1], value->_u32[2], value->_u32[3]);
if (vif1Regs.stat.FDR)
{

55
pcsx2/Frontend/ImGuiManager.cpp
View File

@ -16,10 +16,12 @@
#include "PrecompiledHeader.h"
#include <chrono>
#include <cmath>
#include <deque>
#include <mutex>
#include "common/StringHelpers.h"
#include "fmt/core.h"
#include "common/StringUtil.h"
#include "imgui.h"
@ -469,15 +471,15 @@ static void DrawOSDMessages()
}
}
static void FormatProcessorStat(FastFormatAscii& text, double usage, double time)
static void FormatProcessorStat(std::string& text, double usage, double time)
{
// Some values, such as GPU (and even CPU to some extent) can be out of phase with the wall clock,
// which the processor time is divided by to get a utilization percentage. Let's clamp it at 100%,
// so that people don't get confused, and remove the decimal places when it's there while we're at it.
if (usage >= 99.95)
text.Write("100%% (%.2fms)", time);
fmt::format_to(std::back_inserter(text), "100% ({:.2f}ms)", time);
else
text.Write("%.1f%% (%.2fms)", usage, time);
fmt::format_to(std::back_inserter(text), "{:.1f}% ({:.2f}ms)", usage, time);
}
static void DrawPerformanceOverlay()
@ -489,10 +491,12 @@ static void DrawPerformanceOverlay()
float position_y = margin;
ImDrawList* dl = ImGui::GetBackgroundDrawList();
FastFormatAscii text;
std::string text;
ImVec2 text_size;
bool first = true;
text.reserve(128);
#define DRAW_LINE(font, text, color) \
do \
{ \
@ -521,33 +525,33 @@ static void DrawPerformanceOverlay()
switch (PerformanceMetrics::GetInternalFPSMethod())
{
case PerformanceMetrics::InternalFPSMethod::GSPrivilegedRegister:
text.Write("G: %.2f [P] | V: %.2f", PerformanceMetrics::GetInternalFPS(), PerformanceMetrics::GetFPS());
fmt::format_to(std::back_inserter(text), "G: {:.2f} [P] | V: {:.2f}", PerformanceMetrics::GetInternalFPS(), PerformanceMetrics::GetFPS());
break;
case PerformanceMetrics::InternalFPSMethod::DISPFBBlit:
text.Write("G: %.2f [B] | V: %.2f", PerformanceMetrics::GetInternalFPS(), PerformanceMetrics::GetFPS());
fmt::format_to(std::back_inserter(text), "G: {:.2f} [B] | V: {:.2f}", PerformanceMetrics::GetInternalFPS(), PerformanceMetrics::GetFPS());
break;
case PerformanceMetrics::InternalFPSMethod::None:
default:
text.Write("V: %.2f", PerformanceMetrics::GetFPS());
fmt::format_to(std::back_inserter(text), "V: {:.2f}", PerformanceMetrics::GetFPS());
break;
}
first = false;
}
if (GSConfig.OsdShowSpeed)
{
text.Write("%s%u%%", first ? "" : " | ", static_cast<u32>(std::round(speed)));
fmt::format_to(std::back_inserter(text), "{}{}%", first ? "" : " | ", static_cast<u32>(std::round(speed)));
// We read the main config here, since MTGS doesn't get updated with speed toggles.
if (EmuConfig.GS.LimitScalar == 0.0)
text.Write(" (Max)");
text += " (Max)";
else
text.Write(" (%.0f%%)", EmuConfig.GS.LimitScalar * 100.0);
fmt::format_to(std::back_inserter(text), " ({:.0f}%)", EmuConfig.GS.LimitScalar * 100.0);
first = false;
}
if (!text.IsEmpty())
if (!text.empty())
{
ImU32 color;
if (speed < 95.0f)
@ -572,44 +576,42 @@ static void DrawPerformanceOverlay()
int width, height;
GSgetInternalResolution(&width, &height);
text.Clear();
text.Write("%dx%d %s %s", width, height, ReportVideoMode(), ReportInterlaceMode());
text.clear();
fmt::format_to(std::back_inserter(text), "{}x{} {} {}", width, height, ReportVideoMode(), ReportInterlaceMode());
DRAW_LINE(s_fixed_font, text.c_str(), IM_COL32(255, 255, 255, 255));
}
if (GSConfig.OsdShowCPU)
{
text.Clear();
text.Write("%.2fms (%.2fms worst)", PerformanceMetrics::GetAverageFrameTime(),
text.clear();
fmt::format_to(std::back_inserter(text), "{:.2f}ms ({:.2f}ms worst)", PerformanceMetrics::GetAverageFrameTime(),
PerformanceMetrics::GetWorstFrameTime());
DRAW_LINE(s_fixed_font, text.c_str(), IM_COL32(255, 255, 255, 255));
text.Clear();
text.clear();
if (EmuConfig.Speedhacks.EECycleRate != 0 || EmuConfig.Speedhacks.EECycleSkip != 0)
text.Write("EE[%d/%d]: ", EmuConfig.Speedhacks.EECycleRate, EmuConfig.Speedhacks.EECycleSkip);
fmt::format_to(std::back_inserter(text), "EE[{}/{}]: ", EmuConfig.Speedhacks.EECycleRate, EmuConfig.Speedhacks.EECycleSkip);
else
text.Write("EE: ");
text = "EE: ";
FormatProcessorStat(text, PerformanceMetrics::GetCPUThreadUsage(), PerformanceMetrics::GetCPUThreadAverageTime());
DRAW_LINE(s_fixed_font, text.c_str(), IM_COL32(255, 255, 255, 255));
text.Clear();
text.Write("GS: ");
text = "GS: ";
FormatProcessorStat(text, PerformanceMetrics::GetGSThreadUsage(), PerformanceMetrics::GetGSThreadAverageTime());
DRAW_LINE(s_fixed_font, text.c_str(), IM_COL32(255, 255, 255, 255));
const u32 gs_sw_threads = PerformanceMetrics::GetGSSWThreadCount();
for (u32 i = 0; i < gs_sw_threads; i++)
{
text.Clear();
text.Write("SW-%u: ", i);
text.clear();
fmt::format_to(std::back_inserter(text), "SW-{}: ", i);
FormatProcessorStat(text, PerformanceMetrics::GetGSSWThreadUsage(i), PerformanceMetrics::GetGSSWThreadAverageTime(i));
DRAW_LINE(s_fixed_font, text.c_str(), IM_COL32(255, 255, 255, 255));
}
if (THREAD_VU1)
{
text.Clear();
text.Write("VU: ");
text = "VU: ";
FormatProcessorStat(text, PerformanceMetrics::GetVUThreadUsage(), PerformanceMetrics::GetVUThreadAverageTime());
DRAW_LINE(s_fixed_font, text.c_str(), IM_COL32(255, 255, 255, 255));
}
@ -617,8 +619,7 @@ static void DrawPerformanceOverlay()
if (GSConfig.OsdShowGPU)
{
text.Clear();
text.Write("GPU: ");
text = "GPU: ";
FormatProcessorStat(text, PerformanceMetrics::GetGPUUsage(), PerformanceMetrics::GetGPUAverageTime());
DRAW_LINE(s_fixed_font, text.c_str(), IM_COL32(255, 255, 255, 255));
}

1
pcsx2/Frontend/XInputSource.h
View File

@ -15,6 +15,7 @@
#pragma once
#include "Frontend/InputSource.h"
#include "common/RedtapeWindows.h"
#include <Xinput.h>
#include <array>
#include <functional>

1
pcsx2/GS/GS.h
View File

@ -19,6 +19,7 @@
#include "Window/GSSetting.h"
#include "SaveState.h"
#include "pcsx2/Config.h"
#include "pcsx2/GS/config.h"
#include <map>

2
pcsx2/GS/GSAlignedClass.h
View File

@ -15,6 +15,8 @@
#pragma once
#include "common/AlignedMalloc.h"
template <int i>
class GSAlignedClass
{

1
pcsx2/GS/GSExtra.h
View File

@ -16,6 +16,7 @@
#pragma once
#include "GSVector.h"
#include "pcsx2/Config.h"
#ifdef _WIN32
#include "common/RedtapeWindows.h"

1
pcsx2/GS/GSLzma.cpp
View File

@ -15,6 +15,7 @@
#include "PrecompiledHeader.h"
#include "common/AlignedMalloc.h"
#include "common/FileSystem.h"
#include "common/StringUtil.h"

2
pcsx2/GS/GSVector.h
View File

@ -114,7 +114,7 @@ class GSVector8i;
#include "GSVector8i.h"
#include "GSVector8.h"
#include "common/Dependencies.h"
#include "common/Pcsx2Defs.h"
// conversion

16
pcsx2/GS/GSVector4i.h
View File

@ -13,6 +13,8 @@
* If not, see <http://www.gnu.org/licenses/>.
*/
#include "common/Assertions.h"
class alignas(16) GSVector4i
{
static const GSVector4i m_xff[17];
@ -259,20 +261,6 @@ public:
GSVector4i fit(int preset) const;
#ifdef _WIN32
__forceinline operator LPCRECT() const
{
return (LPCRECT)this;
}
__forceinline operator LPRECT()
{
return (LPRECT)this;
}
#endif
//
__forceinline u32 rgba32() const

2
pcsx2/GS/GSVector8.h
View File

@ -13,6 +13,8 @@
* If not, see <http://www.gnu.org/licenses/>.
*/
#include <cassert>
#if _M_SSE >= 0x500
class alignas(32) GSVector8

2
pcsx2/GS/GSVector8i.h
View File

@ -13,6 +13,8 @@
* If not, see <http://www.gnu.org/licenses/>.
*/
#include <cassert>
#if _M_SSE >= 0x501
class alignas(32) GSVector8i

2
pcsx2/GS/Renderers/Common/GSFastList.h
View File

@ -15,6 +15,8 @@
#pragma once
#include "common/AlignedMalloc.h"
template <class T>
struct Element
{

Some files were not shown because too many files have changed in this diff Show More