Common: reformat (#4720)

* common: format AlignedMalloc.cpp

* common: format AppTrait.h

* common: format Assertions.h

* common: format CheckedStaticBox

* common: format Console

* common: format Dependencies.h

* common: format EmbeddedImage

* common: format EventSource

* common: format Exceptions

* common: format FastFormatString.cpp

* common: format General.h

* common: format InitInterface

* common: format MathUtils.h

* common: format MemsetFast/MemcpyFast

* common: format Mutex.cpp

* common: format PageFaultSource.h

* common: format Path.h

* common: format PathUtils.cpp

* common: format Pcsx2Types.h

* common: format Perf

* common: format PersistentThread.h

* common: format RwMutex

* common: format SafeArray

* common: format ScopedAlloc.h

* common: format ScopedPtrMT.h

* common: format Semaphore.cpp

* common: format StringHelpers

* common: format ThreadTools.cpp

* common: format Threading.h

* common: format ThreadingDialogs

* common: format ThreadingInternal.h

* common: format TraceLog.h

* common: format VirtualMemory.cpp

* common: format pxCheckBox

* common: format pxEvents.h

* common: format pxForwardDefs.h

* common: format pxRadioPanel

* common: format pxStaticText

* common: format pxStreams

* common: format pxTranslate.cpp

* common: format pxWindowTextWriter.cpp

* common: format wxAppWithHelpers

* common: format wxBaseTools.h

* common: format wxGuiTools

* common: format wxHelpers.cpp

* common: format Darwin directory

* common: format Linux directory

* common: format Windows directory

* common: format LnxCpuDetect.cpp

* common: format WinCpuDetect.cpp

* common: format bmi.cpp

* common: format cpudetect.cpp

* common: format cpu_detect_internal.h

* common: format fpu.cpp

* common: format groups.cpp

* common: format instructions.h

* common: format internal.h

* common: format jmp.cpp

* common: format legacy.cpp

* common: format legacy_instructions.h

* common: format legacy_internal.h

* common: format movs.cpp

* common: format simd.cpp

* common: format tools.h

* common: format x86emitter.cpp

* common: format x86types.h

* common: format bmi.h

* common: format dwshift.h

* common: format group1.h group2.h group3.h

* common: format incdec.h

* common: format jmpcall.h

* common: format movs.h

* common: format simd_arithmetic.h

* common: format simd_comparisons.h

* common: format simd_helpers.h

* common: format simd_moremovs.h

* common: format simd_shufflepack.h

* common: format simd_templated_helpers.h

* common: format test.h
This commit is contained in:
Kojin authored and GitHub committed 2021-09-06 14:28:26 -04:00
1 parent f9bf87f50d
commit 13dfceff48
102 files changed
+13189 -12692

No files matched your search

+87 -87
View File
@@ -22,60 +22,60 @@
// wxDirName (implementations)
// ---------------------------------------------------------------------------------
wxFileName wxDirName::Combine(const wxFileName &right) const
wxFileName wxDirName::Combine(const wxFileName& right) const
{
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wxDirName concatenation.");
if (right.IsAbsolute())
return right;
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wxDirName concatenation.");
if (right.IsAbsolute())
return right;
// Append any directory parts from right, and then set the filename.
// Except we can't do that because our m_members are private (argh!) and there is no API
// for getting each component of the path. So instead let's use Normalize:
// Append any directory parts from right, and then set the filename.
// Except we can't do that because our m_members are private (argh!) and there is no API
// for getting each component of the path. So instead let's use Normalize:
wxFileName result(right);
result.Normalize(wxPATH_NORM_ENV_VARS | wxPATH_NORM_DOTS | wxPATH_NORM_ABSOLUTE, GetPath());
return result;
wxFileName result(right);
result.Normalize(wxPATH_NORM_ENV_VARS | wxPATH_NORM_DOTS | wxPATH_NORM_ABSOLUTE, GetPath());
return result;
}
wxDirName wxDirName::Combine(const wxDirName &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(), L"Warning: Malformed directory name detected during wDirName concatenation.");
wxDirName result(right);
result.Normalize(wxPATH_NORM_ENV_VARS | wxPATH_NORM_DOTS | wxPATH_NORM_ABSOLUTE, GetPath());
return result;
wxDirName result(right);
result.Normalize(wxPATH_NORM_ENV_VARS | wxPATH_NORM_DOTS | wxPATH_NORM_ABSOLUTE, GetPath());
return result;
}
wxDirName &wxDirName::Normalize(int flags, const wxString &cwd)
wxDirName& wxDirName::Normalize(int flags, const wxString& cwd)
{
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wDirName normalization.");
if (!wxFileName::Normalize(flags, cwd))
throw Exception::ParseError().SetDiagMsg(L"wxDirName::Normalize operation failed.");
return *this;
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wDirName normalization.");
if (!wxFileName::Normalize(flags, cwd))
throw Exception::ParseError().SetDiagMsg(L"wxDirName::Normalize operation failed.");
return *this;
}
wxDirName &wxDirName::MakeRelativeTo(const wxString &pathBase)
wxDirName& wxDirName::MakeRelativeTo(const wxString& pathBase)
{
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wDirName normalization.");
if (!wxFileName::MakeRelativeTo(pathBase))
throw Exception::ParseError().SetDiagMsg(L"wxDirName::MakeRelativeTo operation failed.");
return *this;
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wDirName normalization.");
if (!wxFileName::MakeRelativeTo(pathBase))
throw Exception::ParseError().SetDiagMsg(L"wxDirName::MakeRelativeTo operation failed.");
return *this;
}
wxDirName &wxDirName::MakeAbsolute(const wxString &cwd)
wxDirName& wxDirName::MakeAbsolute(const wxString& cwd)
{
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wDirName normalization.");
if (!wxFileName::MakeAbsolute(cwd))
throw Exception::ParseError().SetDiagMsg(L"wxDirName::MakeAbsolute operation failed.");
return *this;
pxAssertMsg(IsDir(), L"Warning: Malformed directory name detected during wDirName normalization.");
if (!wxFileName::MakeAbsolute(cwd))
throw Exception::ParseError().SetDiagMsg(L"wxDirName::MakeAbsolute operation failed.");
return *this;
}
void wxDirName::Rmdir()
{
if (!Exists())
return;
wxFileName::Rmdir();
// TODO : Throw exception if operation failed? Do we care?
if (!Exists())
return;
wxFileName::Rmdir();
// TODO : Throw exception if operation failed? Do we care?
}
bool wxDirName::Mkdir()
@@ -87,9 +87,9 @@ bool wxDirName::Mkdir()
#define wxS_DIR_DEFAULT 0777
#endif
if (Exists())
return true;
return wxFileName::Mkdir(wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
if (Exists())
return true;
return wxFileName::Mkdir(wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL);
}
@@ -98,111 +98,111 @@ bool wxDirName::Mkdir()
// ---------------------------------------------------------------------------------
bool Path::IsRelative(const wxString &path)
bool Path::IsRelative(const wxString& path)
{
return wxDirName(path).IsRelative();
return wxDirName(path).IsRelative();
}
// Returns -1 if the file does not exist.
s64 Path::GetFileSize(const wxString &path)
s64 Path::GetFileSize(const wxString& path)
{
if (!wxFile::Exists(path.c_str()))
return -1;
return (s64)wxFileName::GetSize(path).GetValue();
if (!wxFile::Exists(path.c_str()))
return -1;
return (s64)wxFileName::GetSize(path).GetValue();
}
wxString Path::Normalize(const wxString &src)
wxString Path::Normalize(const wxString& src)
{
wxFileName normalize(src);
normalize.Normalize();
return normalize.GetFullPath();
wxFileName normalize(src);
normalize.Normalize();
return normalize.GetFullPath();
}
wxString Path::Normalize(const wxDirName &src)
wxString Path::Normalize(const wxDirName& src)
{
return wxDirName(src).Normalize().ToString();
return wxDirName(src).Normalize().ToString();
}
wxString Path::MakeAbsolute(const wxString &src)
wxString Path::MakeAbsolute(const wxString& src)
{
wxFileName absolute(src);
absolute.MakeAbsolute();
return absolute.GetFullPath();
wxFileName absolute(src);
absolute.MakeAbsolute();
return absolute.GetFullPath();
}
// Concatenates two pathnames together, inserting delimiters (backslash on win32)
// as needed! Assumes the 'dest' is allocated to at least g_MaxPath length.
//
wxString Path::Combine(const wxString &srcPath, const wxString &srcFile)
wxString Path::Combine(const wxString& srcPath, const wxString& srcFile)
{
return (wxDirName(srcPath) + srcFile).GetFullPath();
return (wxDirName(srcPath) + srcFile).GetFullPath();
}
wxString Path::Combine(const wxDirName &srcPath, const wxFileName &srcFile)
wxString Path::Combine(const wxDirName& srcPath, const wxFileName& srcFile)
{
return (srcPath + srcFile).GetFullPath();
return (srcPath + srcFile).GetFullPath();
}
wxString Path::Combine(const wxString &srcPath, const wxDirName &srcFile)
wxString Path::Combine(const wxString& srcPath, const wxDirName& srcFile)
{
return (wxDirName(srcPath) + srcFile).ToString();
return (wxDirName(srcPath) + srcFile).ToString();
}
// Replaces the extension of the file with the one given.
// This function works for path names as well as file names.
wxString Path::ReplaceExtension(const wxString &src, const wxString &ext)
wxString Path::ReplaceExtension(const wxString& src, const wxString& ext)
{
wxFileName jojo(src);
jojo.SetExt(ext);
return jojo.GetFullPath();
wxFileName jojo(src);
jojo.SetExt(ext);
return jojo.GetFullPath();
}
wxString Path::ReplaceFilename(const wxString &src, const wxString &newfilename)
wxString Path::ReplaceFilename(const wxString& src, const wxString& newfilename)
{
wxFileName jojo(src);
jojo.SetFullName(newfilename);
return jojo.GetFullPath();
wxFileName jojo(src);
jojo.SetFullName(newfilename);
return jojo.GetFullPath();
}
wxString Path::GetFilename(const wxString &src)
wxString Path::GetFilename(const wxString& src)
{
return wxFileName(src).GetFullName();
return wxFileName(src).GetFullName();
}
wxString Path::GetFilenameWithoutExt(const wxString &src)
wxString Path::GetFilenameWithoutExt(const wxString& src)
{
return wxFileName(src).GetName();
return wxFileName(src).GetName();
}
wxString Path::GetDirectory(const wxString &src)
wxString Path::GetDirectory(const wxString& src)
{
return wxFileName(src).GetPath();
return wxFileName(src).GetPath();
}
// returns the base/root directory of the given path.
// Example /this/that/something.txt -> dest == "/"
wxString Path::GetRootDirectory(const wxString &src)
wxString Path::GetRootDirectory(const wxString& src)
{
size_t pos = src.find_first_of(wxFileName::GetPathSeparators());
if (pos == wxString::npos)
return wxString();
else
return wxString(src.begin(), src.begin() + pos);
size_t pos = src.find_first_of(wxFileName::GetPathSeparators());
if (pos == wxString::npos)
return wxString();
else
return wxString(src.begin(), src.begin() + pos);
}
// ------------------------------------------------------------------------
// Launches the specified file according to its mime type
//
void pxLaunch(const wxString &filename)
void pxLaunch(const wxString& filename)
{
wxLaunchDefaultBrowser(filename);
wxLaunchDefaultBrowser(filename);
}
void pxLaunch(const char *filename)
void pxLaunch(const char* filename)
{
pxLaunch(fromUTF8(filename));
pxLaunch(fromUTF8(filename));
}
// ------------------------------------------------------------------------
@@ -211,12 +211,12 @@ void pxLaunch(const char *filename)
// bypasses wxWidgets internal filename checking, which can end up launching things
// through browser more often than desired.
//
void pxExplore(const wxString &path)
void pxExplore(const wxString& path)
{
wxLaunchDefaultBrowser(!path.Contains(L"://") ? L"file://" + path : path);
wxLaunchDefaultBrowser(!path.Contains(L"://") ? L"file://" + path : path);
}
void pxExplore(const char *path)
void pxExplore(const char* path)
{
pxExplore(fromUTF8(path));
pxExplore(fromUTF8(path));
}