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

StringUtil cleanup. Nothing seems broken. 

git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@6367 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
Jordan Woyak 2010-11-10 04:12:31 +00:00
parent 7b34def0fc
commit 26f84c1e74
20 changed files with 190 additions and 411 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Source/Core/Common/Src/FileUtil.cpp
View File

@ -180,7 +180,6 @@ bool CreateFullPath(const char *fullPath)
// safety check to ensure we have good dir seperators // safety check to ensure we have good dir seperators
std::string strFullPath(fullPath); std::string strFullPath(fullPath);
NormalizeDirSep(&strFullPath);
const char *position = strFullPath.c_str(); const char *position = strFullPath.c_str();
while (true) { while (true) {

10
Source/Core/Common/Src/IniFile.cpp
View File

@ -181,7 +181,7 @@ bool IniFile::Section::Get(const char* key, int* value, int defaultValue)
{ {
std::string temp; std::string temp;
bool retval = Get(key, &temp, 0); bool retval = Get(key, &temp, 0);
if (retval && TryParseInt(temp.c_str(), value)) if (retval && TryParse(temp.c_str(), value))
return true; return true;
*value = defaultValue; *value = defaultValue;
return false; return false;
@ -191,7 +191,7 @@ bool IniFile::Section::Get(const char* key, u32* value, u32 defaultValue)
{ {
std::string temp; std::string temp;
bool retval = Get(key, &temp, 0); bool retval = Get(key, &temp, 0);
if (retval && TryParseUInt(temp.c_str(), value)) if (retval && TryParse(temp, value))
return true; return true;
*value = defaultValue; *value = defaultValue;
return false; return false;
@ -201,7 +201,7 @@ bool IniFile::Section::Get(const char* key, bool* value, bool defaultValue)
{ {
std::string temp; std::string temp;
bool retval = Get(key, &temp, 0); bool retval = Get(key, &temp, 0);
if (retval && TryParseBool(temp.c_str(), value)) if (retval && TryParse(temp.c_str(), value))
return true; return true;
*value = defaultValue; *value = defaultValue;
return false; return false;
@ -211,7 +211,7 @@ bool IniFile::Section::Get(const char* key, float* value, float defaultValue)
{ {
std::string temp; std::string temp;
bool retval = Get(key, &temp, 0); bool retval = Get(key, &temp, 0);
if (retval && TryParseFloat(temp.c_str(), value)) if (retval && TryParse(temp.c_str(), value))
return true; return true;
*value = defaultValue; *value = defaultValue;
return false; return false;
@ -221,7 +221,7 @@ bool IniFile::Section::Get(const char* key, double* value, double defaultValue)
{ {
std::string temp; std::string temp;
bool retval = Get(key, &temp, 0); bool retval = Get(key, &temp, 0);
if (retval && TryParseDouble(temp.c_str(), value)) if (retval && TryParse(temp.c_str(), value))
return true; return true;
*value = defaultValue; *value = defaultValue;
return false; return false;

2
Source/Core/Common/Src/MemoryUtil.cpp
View File

@ -140,7 +140,7 @@ std::string MemUsage()
if (NULL == hProcess) return "MemUsage Error"; if (NULL == hProcess) return "MemUsage Error";
if (GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc))) if (GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc)))
Ret = StringFromFormat("%s K", ThS((int)(pmc.WorkingSetSize / 1024), true, 7).c_str()); Ret = StringFromFormat("%s K", ThousandSeparate(pmc.WorkingSetSize / 1024, 7).c_str());
CloseHandle(hProcess); CloseHandle(hProcess);
return Ret; return Ret;

421
Source/Core/Common/Src/StringUtil.cpp
View File

@ -26,45 +26,15 @@
bool AsciiToHex(const char* _szValue, u32& result) bool AsciiToHex(const char* _szValue, u32& result)
{ {
char *endptr = NULL; char *endptr = NULL;
u32 value = strtoul(_szValue,&endptr,16); const u32 value = strtoul(_szValue, &endptr, 16);
if (!endptr || *endptr != '\0')
if (!endptr || *endptr)
return false; return false;
result = value; result = value;
return true; return true;
} }
// Convert AB to it's ascii table entry numbers 0x4142
u32 Ascii2Hex(std::string _Text)
{
// Reset the return value zero
u32 Result = 0;
// Max 32-bit values are supported
size_t Length = _Text.length();
if (Length > 4)
Length = 4;
for (int i = 0; i < (int)Length; i++)
{
// Add up the values, for example RSPE becomes, 0x52000000, then 0x52530000 and so on
Result += _Text.c_str()[i] << ((Length - 1 - i) * 8);
}
// Return the value
return Result;
}
// Convert it back again
std::string Hex2Ascii(u32 _Text)
{
// Create temporary storate
char Result[5]; // need space for the final \0
// Go through the four characters
sprintf(Result, "%c%c%c%c", _Text >> 24, _Text >> 16, _Text >> 8, _Text);
// Return the string
std::string StrResult = Result;
return StrResult;
}
bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list args) bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list args)
{ {
int writtenCount = vsnprintf(out, outsize, format, args); int writtenCount = vsnprintf(out, outsize, format, args);
@ -81,84 +51,24 @@ bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list ar
} }
} }
// Expensive!
void ToStringFromFormat(std::string* out, const char* format, ...)
{
int writtenCount = -1;
int newSize = (int)strlen(format) + 4;
char *buf = 0;
va_list args;
while (writtenCount < 0)
{
delete [] buf;
buf = new char[newSize + 1];
va_start(args, format);
writtenCount = vsnprintf(buf, newSize, format, args);
va_end(args);
if (writtenCount >= (int)newSize) {
writtenCount = -1;
}
// ARGH! vsnprintf does no longer return -1 on truncation in newer libc!
// WORKAROUND! let's fake the old behaviour (even though it's less efficient).
// TODO: figure out why the fix causes an invalid read in strlen called from vsnprintf :(
// if (writtenCount >= (int)newSize)
// writtenCount = -1;
newSize *= 2;
}
buf[writtenCount] = '\0';
*out = buf;
delete[] buf;
}
std::wstring StringFromFormat(const wchar_t* format, ...)
{
int writtenCount = -1;
int newSize = (int)wcslen(format) + 4;
wchar_t *buf = 0;
va_list args;
while (writtenCount < 0)
{
delete [] buf;
buf = new wchar_t[newSize + 1];
va_start(args, format);
writtenCount = vswprintf(buf, newSize, format, args);
va_end(args);
if (writtenCount >= (int)newSize) {
writtenCount = -1;
}
// ARGH! vsnprintf does no longer return -1 on truncation in newer libc!
// WORKAROUND! let's fake the old behaviour (even though it's less efficient).
// TODO: figure out why the fix causes an invalid read in strlen called from vsnprintf :(
// if (writtenCount >= (int)newSize)
// writtenCount = -1;
newSize *= 2;
}
buf[writtenCount] = '\0';
std::wstring temp = buf;
delete[] buf;
return temp;
}
std::string StringFromFormat(const char* format, ...) std::string StringFromFormat(const char* format, ...)
{ {
int writtenCount = -1; int writtenCount = -1;
int newSize = (int)strlen(format) + 4; size_t newSize = strlen(format) + 4;
char *buf = 0; char *buf = NULL;
va_list args; va_list args;
while (writtenCount < 0) while (writtenCount < 0)
{ {
delete [] buf; delete[] buf;
buf = new char[newSize + 1]; buf = new char[newSize + 1];
va_start(args, format); va_start(args, format);
writtenCount = vsnprintf(buf, newSize, format, args); writtenCount = vsnprintf(buf, newSize, format, args);
va_end(args); va_end(args);
if (writtenCount >= (int)newSize) {
if (writtenCount >= (int)newSize)
writtenCount = -1; writtenCount = -1;
}
// ARGH! vsnprintf does no longer return -1 on truncation in newer libc! // ARGH! vsnprintf does no longer return -1 on truncation in newer libc!
// WORKAROUND! let's fake the old behaviour (even though it's less efficient). // WORKAROUND! let's fake the old behaviour (even though it's less efficient).
// TODO: figure out why the fix causes an invalid read in strlen called from vsnprintf :( // TODO: figure out why the fix causes an invalid read in strlen called from vsnprintf :(
@ -174,42 +84,36 @@ std::string StringFromFormat(const char* format, ...)
} }
// For Debugging. Read out an u8 array. // For Debugging. Read out an u8 array.
std::string ArrayToString(const u8 *data, u32 size, u32 offset, int line_len, bool Spaces) std::string ArrayToString(const u8 *data, u32 size, int line_len, bool spaces)
{ {
std::string Tmp, Spc; std::ostringstream oss;
if (Spaces) Spc = " "; else Spc = ""; oss << std::setfill('0') << std::hex;
for (u32 i = 0; i < size; i++)
for (int line = 0; size; ++data, --size)
{ {
Tmp += StringFromFormat("%02x%s", data[i + offset], Spc.c_str()); oss << std::setw(2) << (int)*data;
if(i > 1 && (i + 1) % line_len == 0) Tmp.append("\n"); // break long lines
} if (line_len == ++line)
return Tmp; {
oss << '\n';
line = 0;
}
else if (spaces)
oss << ' ';
}
return oss.str();
} }
// Turns " hej " into "hej". Also handles tabs. // Turns " hej " into "hej". Also handles tabs.
std::string StripSpaces(const std::string &str) std::string StripSpaces(const std::string &str)
{ {
std::string s = str; const size_t s = str.find_first_not_of(" \t\r\n");
int i;
for (i = 0; i < (int)s.size(); i++)
{
if ((s[i] != ' ') && (s[i] != 9))
{
break;
}
}
s = s.substr(i); if (str.npos != s)
return str.substr(s, str.find_last_not_of(" \t\r\n") - s + 1);
for (i = (int)s.size() - 1; i > 0; i--) else
{ return "";
if ((s[i] != ' ') && (s[i] != 9))
{
break;
}
}
return s.substr(0, i + 1);
} }
// "\"hello\"" is turned to "hello" // "\"hello\"" is turned to "hello"
@ -217,7 +121,7 @@ std::string StripSpaces(const std::string &str)
// ends, as done by StripSpaces above, for example. // ends, as done by StripSpaces above, for example.
std::string StripQuotes(const std::string& s) std::string StripQuotes(const std::string& s)
{ {
if ((s[0] == '\"') && (s[s.size() - 1] == '\"')) if (s.size() && '\"' == s[0] && '\"' == *s.rbegin())
return s.substr(1, s.size() - 2); return s.substr(1, s.size() - 2);
else else
return s; return s;
@ -228,63 +132,41 @@ std::string StripQuotes(const std::string& s)
// ends, as done by StripSpaces above, for example. // ends, as done by StripSpaces above, for example.
std::string StripNewline(const std::string& s) std::string StripNewline(const std::string& s)
{ {
if (!s.size()) if (s.size() && '\n' == *s.rbegin())
return s;
else if (s[s.size() - 1] == '\n')
return s.substr(0, s.size() - 1); return s.substr(0, s.size() - 1);
else else
return s; return s;
} }
bool TryParseInt(const char* str, int* outVal) bool TryParse(const std::string &str, u32 *const output)
{ {
char *endptr = NULL; char *endptr = NULL;
int value = strtol(str,&endptr,10); u32 value = strtoul(str.c_str(), &endptr, 0);
if (!endptr || *endptr != '\0')
if (!endptr || *endptr)
return false; return false;
*outVal = value;
*output = value;
return true; return true;
} }
bool TryParseBool(const char* str, bool* output) bool TryParse(const std::string &str, bool *const output)
{ {
if ((str[0] == '1') || !strcasecmp(str, "true")) if ('1' == str[0] || !stricmp("true", str.c_str()))
{
*output = true; *output = true;
return true; else if ('0' == str[0] || !stricmp("false", str.c_str()))
}
else if (str[0] == '0' || !strcasecmp(str, "false"))
{
*output = false; *output = false;
return true;
}
return false;
}
bool TryParseFloat(const char* str, float *output)
{
float d_val;
if (sscanf(str, "%f", &d_val) == 1)
{
*output = (float)d_val;
return true;
}
else else
{
return false; return false;
}
}
bool TryParseDouble(const char* str, double *output) return true;
{
return sscanf(str, "%lf", output) == 1;
} }
std::string StringFromInt(int value) std::string StringFromInt(int value)
{ {
char temp[16]; char temp[16];
sprintf(temp, "%i", value); sprintf(temp, "%i", value);
return std::string(temp); return temp;
} }
std::string StringFromBool(bool value) std::string StringFromBool(bool value)
@ -292,207 +174,76 @@ std::string StringFromBool(bool value)
return value ? "True" : "False"; return value ? "True" : "False";
} }
bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename, std::string* _pExtension)
{
if (full_path.empty())
return false;
size_t dir_end = full_path.find_last_of("/"
// windows needs the : included for something like just "C:" to be considered a directory
#ifdef _WIN32 #ifdef _WIN32
bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename, std::string* _pExtension) ":"
{ #endif
char drive[_MAX_DRIVE]; );
char dir[_MAX_DIR]; if (std::string::npos == dir_end)
char fname[_MAX_FNAME]; dir_end = 0;
char ext[_MAX_EXT]; else
dir_end += 1;
if (_splitpath_s(full_path.c_str(), drive, _MAX_DRIVE, dir, _MAX_DIR, fname, _MAX_FNAME, ext, _MAX_EXT) == 0) size_t fname_end = full_path.rfind('.');
{ if (fname_end < dir_end || std::string::npos == fname_end)
if (_pPath) fname_end = full_path.size();
{
*_pPath = std::string(drive) + std::string(dir);
}
if (_pFilename != 0)
{
*_pFilename = fname;
}
if (_pExtension != 0)
{
*_pExtension = ext;
}
return true;
}
return false;
}
#else
bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename, std::string* _pExtension)
{
size_t last_slash = full_path.rfind('/');
if (last_slash == std::string::npos)
{
return false; // FIXME return the filename
}
size_t last_dot = full_path.rfind('.');
if ((last_dot == std::string::npos) || (last_dot < last_slash))
{
return false; // FIXME why missing . is critical?
}
if (_pPath) if (_pPath)
{ *_pPath = full_path.substr(0, dir_end);
*_pPath = full_path.substr(0, last_slash + 1);
}
if (_pFilename) if (_pFilename)
{ *_pFilename = full_path.substr(dir_end, fname_end - dir_end);
*_pFilename = full_path.substr(last_slash + 1, last_dot - (last_slash + 1));
}
if (_pExtension) if (_pExtension)
{ *_pExtension = full_path.substr(fname_end);
*_pExtension = full_path.substr(last_dot + 1);
_pExtension->insert(0, ".");
}
else if (_pFilename)
{
*_pFilename += full_path.substr(last_dot);
}
return true; return true;
} }
#endif
std::string PathToFilename(const std::string &Path)
{
std::string Name, Ending;
SplitPath(Path, 0, &Name, &Ending);
return Name + Ending;
}
void BuildCompleteFilename(std::string& _CompleteFilename, const std::string& _Path, const std::string& _Filename) void BuildCompleteFilename(std::string& _CompleteFilename, const std::string& _Path, const std::string& _Filename)
{ {
_CompleteFilename = _Path; _CompleteFilename = _Path;
// check for seperator // check for seperator
if (_CompleteFilename[_CompleteFilename.size() - 1] != DIR_SEP_CHR) if (DIR_SEP_CHR != *_CompleteFilename.rbegin())
{ _CompleteFilename += DIR_SEP_CHR;
#ifdef _WIN32
if (_CompleteFilename[_CompleteFilename.size() - 1] != '\\')
#endif
_CompleteFilename += DIR_SEP_CHR;
}
// add the filename // add the filename
_CompleteFilename += _Filename; _CompleteFilename += _Filename;
} }
void SplitString(const std::string& str, const char delim, std::vector<std::string>& output)
void SplitString(const std::string& str, const std::string& delim, std::vector<std::string>& output)
{ {
output.clear(); std::istringstream iss(str);
output.resize(1);
size_t offset = 0; while (std::getline(iss, *output.rbegin(), delim))
size_t delimIndex = 0; output.push_back("");
delimIndex = str.find(delim, offset); output.pop_back();
while (delimIndex != std::string::npos)
{
output.push_back(str.substr(offset, delimIndex - offset));
offset += delimIndex - offset + delim.length();
delimIndex = str.find(delim, offset);
}
output.push_back(str.substr(offset));
}
bool TryParseUInt(const std::string& str, u32* output)
{
char *endptr = NULL;
u32 value = strtoul(str.c_str(),&endptr,0);
if (!endptr || *endptr != '\0')
return false;
*output = value;
return true;
}
int ChooseStringFrom(const char* str, const char* * items)
{
int i = 0;
while (items[i] != 0)
{
if (!strcmp(str, items[i]))
return i;
i++;
}
return -1;
}
// Thousand separator. Turns 12345678 into 12,345,678
std::string ThS(int Integer, bool Unsigned, int Spaces)
{
// Create storage space
char cbuf[20];
// Determine treatment of signed or unsigned
if(Unsigned) sprintf(cbuf, "%u", Integer); else sprintf(cbuf, "%i", Integer);
std::string Sbuf = cbuf;
for (u32 i = 0; i < Sbuf.length(); ++i)
{
if((i & 3) == 3)
{
Sbuf.insert(Sbuf.length() - i, ",");
}
}
// Spaces
std::string Spc = "";
for (int i = 0; i < (int)(Spaces - Sbuf.length()); i++) Spc += " ";
return Spc + Sbuf;
}
void NormalizeDirSep(std::string* str)
{
#ifdef _WIN32
int i;
while ((i = (int)str->find_first_of('\\')) >= 0)
{
str->replace(i, 1, DIR_SEP);
}
#endif
} }
std::string TabsToSpaces(int tab_size, const std::string &in) std::string TabsToSpaces(int tab_size, const std::string &in)
{ {
std::string out; const std::string spaces(tab_size, ' ');
int len = 0; std::string out(in);
// First, compute the size of the new string.
for (unsigned i = 0; i < in.size(); i++) size_t i = 0;
{ while (out.npos != (i = out.find('\t')))
if (in[i] == '\t') out.replace(i, 1, spaces);
len += tab_size;
else
len += 1;
}
out.resize(len);
int out_ctr = 0;
for (unsigned i = 0; i < in.size(); i++)
{
if (in[i] == '\t')
{
for (int j = 0; j < tab_size; j++)
out[out_ctr++] = ' ';
}
else
{
out[out_ctr++] = in[i];
}
}
return out; return out;
} }
std::string PathToFilename(std::string Path)
{
std::string Name, Ending;
SplitPath(Path, 0, &Name, &Ending);
return Name + Ending;
}

71
Source/Core/Common/Src/StringUtil.h
View File

@ -22,22 +22,15 @@
#include <vector> #include <vector>
#include <string> #include <string>
#include <sstream>
#include <iomanip>
#include "Common.h" #include "Common.h"
std::wstring StringFromFormat(const wchar_t* format, ...);
std::string StringFromFormat(const char* format, ...); std::string StringFromFormat(const char* format, ...);
void ToStringFromFormat(std::string* out, const char* format, ...);
// WARNING - only call once with a set of args!
void StringFromFormatV(std::string* out, const char* format, va_list args);
// Cheap! // Cheap!
bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list args); bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list args);
// Good
std::string ArrayToString(const u8 *data, u32 size, u32 offset = 0, int line_len = 20, bool Spaces = true);
template<size_t Count> template<size_t Count>
inline void CharArrayFromFormat(char (& out)[Count], const char* format, ...) inline void CharArrayFromFormat(char (& out)[Count], const char* format, ...)
{ {
@ -47,49 +40,57 @@ inline void CharArrayFromFormat(char (& out)[Count], const char* format, ...)
va_end(args); va_end(args);
} }
std::wstring StripSpaces(const std::wstring &s); // Good
std::wstring StripQuotes(const std::wstring &s); std::string ArrayToString(const u8 *data, u32 size, int line_len = 20, bool spaces = true);
//std::wstring StripNewline(const std::string &s);
// Thousand separator. Turns 12345678 into 12,345,678
//std::wstring ThS(int a, bool b = true, int Spaces = 0);
std::string StripSpaces(const std::string &s); std::string StripSpaces(const std::string &s);
std::string StripQuotes(const std::string &s); std::string StripQuotes(const std::string &s);
std::string StripNewline(const std::string &s); std::string StripNewline(const std::string &s);
// Thousand separator. Turns 12345678 into 12,345,678
std::string ThS(int a, bool b = true, int Spaces = 0);
std::wstring StringFromIntW(int value); // Thousand separator. Turns 12345678 into 12,345,678
std::wstring StringFromBoolW(bool value); template <typename I>
std::string ThousandSeparate(I value, int spaces = 0)
{
std::ostringstream oss;
oss.imbue(std::locale(""));
oss << std::setw(spaces) << value;
return oss.str();
}
std::string StringFromInt(int value); std::string StringFromInt(int value);
std::string StringFromBool(bool value); std::string StringFromBool(bool value);
bool TryParseInt(const wchar_t* str, int* outVal); bool TryParse(const std::string &str, bool *output);
bool TryParseBool(const wchar_t* str, bool* output); bool TryParse(const std::string &str, u32 *output);
bool TryParseUInt(const std::wstring& str, u32* output);
bool TryParseInt(const char* str, int* outVal);
bool TryParseBool(const char* str, bool* output);
bool TryParseUInt(const std::string& str, u32* output);
bool TryParseFloat(const char* str, float *output);
bool TryParseDouble(const char* str, double *output);
template <typename N>
bool TryParse(const std::string &str, N *const output)
{
std::istringstream iss(str);
N tmp = 0;
if (iss >> tmp)
{
*output = tmp;
return true;
}
else
return false;
}
// TODO: kill this // TODO: kill this
bool AsciiToHex(const char* _szValue, u32& result); bool AsciiToHex(const char* _szValue, u32& result);
u32 Ascii2Hex(std::string _Text);
std::string Hex2Ascii(u32 _Text);
std::string TabsToSpaces(int tab_size, const std::string &in); std::string TabsToSpaces(int tab_size, const std::string &in);
void SplitString(const std::string& str, const std::string& delim, std::vector<std::string>& output); void SplitString(const std::string& str, char delim, std::vector<std::string>& output);
int ChooseStringFrom(const char* str, const char* * items);
// "C:/Windows/winhelp.exe" to "C:/Windows/", "winhelp", ".exe"
// "C:\Windows\winhelp.exe" to "C:\Windows\", "winhelp", "exe"
bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename, std::string* _pExtension); bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _pFilename, std::string* _pExtension);
// "C:\Windows\winhelp.exe" to "winhelp.exe" // "C:/Windows/winhelp.exe" to "winhelp.exe"
std::string PathToFilename(std::string Path); std::string PathToFilename(const std::string &Path);
void BuildCompleteFilename(std::string& _CompleteFilename, const std::string& _Path, const std::string& _Filename); void BuildCompleteFilename(std::string& _CompleteFilename, const std::string& _Path, const std::string& _Filename);
void NormalizeDirSep(std::string* str);
#endif // _STRINGUTIL_H_ #endif // _STRINGUTIL_H_

8
Source/Core/Core/Src/ActionReplay.cpp
View File

@ -184,14 +184,14 @@ void LoadCodes(IniFile &ini, bool forceLoad)
continue; continue;
} }
SplitString(line, " ", pieces); SplitString(line, ' ', pieces);
// Check if the AR code is decrypted // Check if the AR code is decrypted
if (pieces.size() == 2 && pieces[0].size() == 8 && pieces[1].size() == 8) if (pieces.size() == 2 && pieces[0].size() == 8 && pieces[1].size() == 8)
{ {
AREntry op; AREntry op;
bool success_addr = TryParseUInt(std::string("0x") + pieces[0], &op.cmd_addr); bool success_addr = TryParse(std::string("0x") + pieces[0], &op.cmd_addr);
bool success_val = TryParseUInt(std::string("0x") + pieces[1], &op.value); bool success_val = TryParse(std::string("0x") + pieces[1], &op.value);
if (!(success_addr | success_val)) { if (!(success_addr | success_val)) {
PanicAlert("Action Replay Error: invalid AR code line: %s", line.c_str()); PanicAlert("Action Replay Error: invalid AR code line: %s", line.c_str());
if (!success_addr) PanicAlert("The address is invalid"); if (!success_addr) PanicAlert("The address is invalid");
@ -202,7 +202,7 @@ void LoadCodes(IniFile &ini, bool forceLoad)
} }
else else
{ {
SplitString(line, "-", pieces); SplitString(line, '-', pieces);
if (pieces.size() == 3 && pieces[0].size() == 4 && pieces[1].size() == 4 && pieces[2].size() == 5) if (pieces.size() == 3 && pieces[0].size() == 4 && pieces[1].size() == 4 && pieces[2].size() == 5)
{ {
// Encrypted AR code // Encrypted AR code

2
Source/Core/Core/Src/CoreRerecording.cpp
View File

@ -213,7 +213,7 @@ void FrameStepOnOff()
void WriteStatus() void WriteStatus()
{ {
std::string TmpStr = "Time: " + ReRecTimer.GetTimeElapsedFormatted(); std::string TmpStr = "Time: " + ReRecTimer.GetTimeElapsedFormatted();
TmpStr += StringFromFormat(" Frame: %s", ThS(g_FrameCounter).c_str()); TmpStr += StringFromFormat(" Frame: %s", ThousandSeparate(g_FrameCounter).c_str());
// The FPS is the total average since the game was booted // The FPS is the total average since the game was booted
TmpStr += StringFromFormat(" FPS: %i", (g_FrameCounter * 1000) / ReRecTimer.GetTimeElapsed()); TmpStr += StringFromFormat(" FPS: %i", (g_FrameCounter * 1000) / ReRecTimer.GetTimeElapsed());
TmpStr += StringFromFormat(" FrameStep: %s", g_FrameStep ? "On" : "Off"); TmpStr += StringFromFormat(" FrameStep: %s", g_FrameStep ? "On" : "Off");

2
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_Device_DI.cpp
View File

@ -197,7 +197,7 @@ u32 CWII_IPC_HLE_Device_di::ExecuteCommand(u32 _BufferIn, u32 _BufferInSize, u32
VolumeHandler::RAWReadToPtr(Memory::GetPointer(_BufferOut), 0, _BufferOutSize); VolumeHandler::RAWReadToPtr(Memory::GetPointer(_BufferOut), 0, _BufferOutSize);
INFO_LOG(WII_IPC_DVD, "DVDLowReadDiskID %s", INFO_LOG(WII_IPC_DVD, "DVDLowReadDiskID %s",
ArrayToString(Memory::GetPointer(_BufferOut), _BufferOutSize, 0, _BufferOutSize).c_str()); ArrayToString(Memory::GetPointer(_BufferOut), _BufferOutSize, _BufferOutSize).c_str());
} }
break; break;

2
Source/Core/Core/Src/IPC_HLE/WII_IPC_HLE_WiiMote.cpp
View File

@ -895,7 +895,7 @@ namespace Core
INFO_LOG(WIIMOTE, "===================="); INFO_LOG(WIIMOTE, "====================");
INFO_LOG(WIIMOTE, "Callback_WiimoteInterruptChannel: (Wiimote: #%i)", _number); INFO_LOG(WIIMOTE, "Callback_WiimoteInterruptChannel: (Wiimote: #%i)", _number);
DEBUG_LOG(WIIMOTE, " Data: %s", ArrayToString(pData, _Size, 0, 50).c_str()); DEBUG_LOG(WIIMOTE, " Data: %s", ArrayToString(pData, _Size, 50).c_str());
DEBUG_LOG(WIIMOTE, " Channel: %x", _channelID); DEBUG_LOG(WIIMOTE, " Channel: %x", _channelID);
s_Usb->m_WiiMotes[_number].ReceiveL2capData(_channelID, _pData, _Size); s_Usb->m_WiiMotes[_number].ReceiveL2capData(_channelID, _pData, _Size);

18
Source/Core/Core/Src/PatchEngine.cpp
View File

@ -30,6 +30,8 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include <map> #include <map>
#include <algorithm>
#include "StringUtil.h" #include "StringUtil.h"
#include "PatchEngine.h" #include "PatchEngine.h"
#include "HW/Memmap.h" #include "HW/Memmap.h"
@ -48,7 +50,6 @@ const char *PatchTypeStrings[] =
"byte", "byte",
"word", "word",
"dword", "dword",
0
}; };
std::vector<Patch> onFrame; std::vector<Patch> onFrame;
@ -88,14 +89,15 @@ void LoadPatchSection(const char *section, std::vector<Patch> &patches, IniFile
line.at(loc) = ':'; line.at(loc) = ':';
std::vector<std::string> items; std::vector<std::string> items;
SplitString(line, ":", items); SplitString(line, ':', items);
if (items.size() >= 3) { if (items.size() >= 3) {
PatchEntry pE; PatchEntry pE;
bool success = true; bool success = true;
success = success && TryParseUInt(items[0], &pE.address); success &= TryParse(items[0], &pE.address);
success = success && TryParseUInt(items[2], &pE.value); success &= TryParse(items[2], &pE.value);
pE.type = (PatchType)ChooseStringFrom(items[1].c_str(), PatchTypeStrings);
success = success && (pE.type != (PatchType)-1); pE.type = PatchType(std::find(PatchTypeStrings, PatchTypeStrings + 3, items[1]) - PatchTypeStrings);
success &= (pE.type != (PatchType)3);
if (success) if (success)
currentPatch.entries.push_back(pE); currentPatch.entries.push_back(pE);
} }
@ -131,8 +133,8 @@ static void LoadSpeedhacks(const char *section, std::map<u32, int> &hacks, IniFi
u32 address; u32 address;
u32 cycles; u32 cycles;
bool success = true; bool success = true;
success = success && TryParseUInt(std::string(key.c_str()), &address); success &= TryParse(key, &address);
success = success && TryParseUInt(value, &cycles); success &= TryParse(value, &cycles);
if (success) { if (success) {
speedHacks[address] = (int)cycles; speedHacks[address] = (int)cycles;
} }

2
Source/Core/DebuggerWX/Src/BreakpointWindow.cpp
View File

@ -195,7 +195,7 @@ void CBreakPointWindow::OnAddMemoryCheckMany()
{ {
std::string line = StripSpaces(*iter); std::string line = StripSpaces(*iter);
std::vector<std::string> pieces; std::vector<std::string> pieces;
SplitString(line, " ", pieces); // split string SplitString(line, ' ', pieces); // split string
TMemCheck MemCheck; TMemCheck MemCheck;
u32 sAddress = 0; u32 sAddress = 0;

4
Source/Core/DebuggerWX/Src/MemoryWindow.cpp
View File

@ -157,13 +157,13 @@ void CMemoryWindow::SetMemoryValue(wxCommandEvent& event)
u32 addr; u32 addr;
u32 val; u32 val;
if (!TryParseUInt(std::string("0x") + str_addr, &addr)) if (!TryParse(std::string("0x") + str_addr, &addr))
{ {
PanicAlert("Invalid Address: %s", str_addr.c_str()); PanicAlert("Invalid Address: %s", str_addr.c_str());
return; return;
} }
if (!TryParseUInt(std::string("0x") + str_val, &val)) if (!TryParse(std::string("0x") + str_val, &val))
{ {
PanicAlert("Invalid Value: %s", str_val.c_str()); PanicAlert("Invalid Value: %s", str_val.c_str());
return; return;

2
Source/Core/DebuggerWX/Src/RegisterView.cpp
View File

@ -90,7 +90,7 @@ static void SetSpecialRegValue(int reg, u32 value) {
void CRegTable::SetValue(int row, int col, const wxString& strNewVal) void CRegTable::SetValue(int row, int col, const wxString& strNewVal)
{ {
u32 newVal = 0; u32 newVal = 0;
if (TryParseUInt(std::string(strNewVal.mb_str()), &newVal)) if (TryParse(std::string(strNewVal.mb_str()), &newVal))
{ {
if (row < 32) { if (row < 32) {
if (col == 1) if (col == 1)

2
Source/Core/DiscIO/Src/FileMonitor.cpp
View File

@ -103,7 +103,7 @@ void CheckFile(std::string File, u64 Size)
if (CurrentFile == File) return; if (CurrentFile == File) return;
if (Size > 0) Size = (Size / 1000); if (Size > 0) Size = (Size / 1000);
std::string Str = StringFromFormat("%s kB %s", ThS(Size, true, 7).c_str(), File.c_str()); std::string Str = StringFromFormat("%s kB %s", ThousandSeparate(Size, 7).c_str(), File.c_str());
if (ShowSound(File)) if (ShowSound(File))
{ {
NOTICE_LOG(FILEMON, Str.c_str()); NOTICE_LOG(FILEMON, Str.c_str());

4
Source/Core/DolphinWX/Src/ARCodeAddEdit.cpp
View File

@ -112,7 +112,7 @@ void CARCodeAddEdit::SaveCheatData(wxCommandEvent& WXUNUSED (event))
std::vector<std::string> pieces; std::vector<std::string> pieces;
std::string line_str = cheatValues.substr(line, cheatValues.find('\n', line) - line); std::string line_str = cheatValues.substr(line, cheatValues.find('\n', line) - line);
SplitString(line_str, " ", pieces); SplitString(line_str, ' ', pieces);
if (pieces.size() == 2 && pieces[0].size() == 8 && pieces[1].size() == 8) if (pieces.size() == 2 && pieces[0].size() == 8 && pieces[1].size() == 8)
{ {
@ -123,7 +123,7 @@ void CARCodeAddEdit::SaveCheatData(wxCommandEvent& WXUNUSED (event))
} }
else else
{ {
SplitString(line_str, "-", pieces); SplitString(line_str, '-', pieces);
if (pieces.size() == 3 && pieces[0].size() == 4 && pieces[1].size() == 4 && pieces[2].size() == 5) if (pieces.size() == 3 && pieces[0].size() == 4 && pieces[1].size() == 4 && pieces[2].size() == 5)
{ {

10
Source/Core/DolphinWX/Src/FrameAui.cpp
View File

@ -811,7 +811,7 @@ void CFrame::LoadIniPerspectives()
ini.Load(File::GetUserPath(F_DEBUGGERCONFIG_IDX)); ini.Load(File::GetUserPath(F_DEBUGGERCONFIG_IDX));
ini.Get("Perspectives", "Perspectives", &_Perspectives, "Perspective 1"); ini.Get("Perspectives", "Perspectives", &_Perspectives, "Perspective 1");
ini.Get("Perspectives", "Active", &ActivePerspective, 0); ini.Get("Perspectives", "Active", &ActivePerspective, 0);
SplitString(_Perspectives, ",", VPerspectives); SplitString(_Perspectives, ',', VPerspectives);
for (u32 i = 0; i < VPerspectives.size(); i++) for (u32 i = 0; i < VPerspectives.size(); i++)
{ {
@ -833,17 +833,17 @@ void CFrame::LoadIniPerspectives()
Tmp.Perspective = wxString::FromAscii(_Perspective.c_str()); Tmp.Perspective = wxString::FromAscii(_Perspective.c_str());
SplitString(_Width, ",", _SWidth); SplitString(_Width, ',', _SWidth);
SplitString(_Height, ",", _SHeight); SplitString(_Height, ',', _SHeight);
for (u32 j = 0; j < _SWidth.size(); j++) for (u32 j = 0; j < _SWidth.size(); j++)
{ {
int _Tmp; int _Tmp;
if (TryParseInt(_SWidth[j].c_str(), &_Tmp)) Tmp.Width.push_back(_Tmp); if (TryParse(_SWidth[j].c_str(), &_Tmp)) Tmp.Width.push_back(_Tmp);
} }
for (u32 j = 0; j < _SHeight.size(); j++) for (u32 j = 0; j < _SHeight.size(); j++)
{ {
int _Tmp; int _Tmp;
if (TryParseInt(_SHeight[j].c_str(), &_Tmp)) Tmp.Height.push_back(_Tmp); if (TryParse(_SHeight[j].c_str(), &_Tmp)) Tmp.Height.push_back(_Tmp);
} }
Perspectives.push_back(Tmp); Perspectives.push_back(Tmp);
} }

2
Source/Core/DolphinWX/Src/GameListCtrl.cpp
View File

@ -542,10 +542,8 @@ void CGameListCtrl::ScanForISOs()
if (FST_Temp.children.at(j).isDirectory) if (FST_Temp.children.at(j).isDirectory)
{ {
bool duplicate = false; bool duplicate = false;
NormalizeDirSep(&(FST_Temp.children.at(j).physicalName));
for (u32 k = 0; k < Directories.size(); k++) for (u32 k = 0; k < Directories.size(); k++)
{ {
NormalizeDirSep(&Directories.at(k));
if (strcmp(Directories.at(k).c_str(), if (strcmp(Directories.at(k).c_str(),
FST_Temp.children.at(j).physicalName.c_str()) == 0) FST_Temp.children.at(j).physicalName.c_str()) == 0)
{ {

4
Source/Core/DolphinWX/Src/ISOProperties.cpp
View File

@ -1138,9 +1138,7 @@ void CISOProperties::PatchList_Save()
for (std::vector<PatchEngine::PatchEntry>::const_iterator iter2 = onFrame_it->entries.begin(); iter2 != onFrame_it->entries.end(); ++iter2) for (std::vector<PatchEngine::PatchEntry>::const_iterator iter2 = onFrame_it->entries.begin(); iter2 != onFrame_it->entries.end(); ++iter2)
{ {
std::string temp; std::string temp = StringFromFormat("0x%08X:%s:0x%08X", iter2->address, PatchEngine::PatchTypeStrings[iter2->type], iter2->value);
ToStringFromFormat(&temp, "0x%08X:%s:0x%08X", iter2->address, PatchEngine::PatchTypeStrings[iter2->type], iter2->value);
lines.push_back(temp); lines.push_back(temp);
} }
++index; ++index;

2
Source/Core/VideoCommon/Src/HiresTextures.cpp
View File

@ -49,10 +49,8 @@ void Init(const char *gameCode)
if (FST_Temp.children.at(j).isDirectory) if (FST_Temp.children.at(j).isDirectory)
{ {
bool duplicate = false; bool duplicate = false;
NormalizeDirSep(&(FST_Temp.children.at(j).physicalName));
for (u32 k = 0; k < Directories.size(); k++) for (u32 k = 0; k < Directories.size(); k++)
{ {
NormalizeDirSep(&Directories.at(k));
if (strcmp(Directories.at(k).c_str(), FST_Temp.children.at(j).physicalName.c_str()) == 0) if (strcmp(Directories.at(k).c_str(), FST_Temp.children.at(j).physicalName.c_str()) == 0)
{ {
duplicate = true; duplicate = true;

32
Source/UnitTests/UnitTests.cpp
View File

@ -93,11 +93,43 @@ void MathTests()
void StringTests() void StringTests()
{ {
EXPECT_EQ(StripSpaces(" abc "), "abc"); EXPECT_EQ(StripSpaces(" abc "), "abc");
EXPECT_EQ(StripNewline(" abc \n"), " abc "); EXPECT_EQ(StripNewline(" abc \n"), " abc ");
EXPECT_EQ(StripNewline(" abc \n "), " abc \n "); EXPECT_EQ(StripNewline(" abc \n "), " abc \n ");
EXPECT_EQ(StripQuotes("\"abc\""), "abc"); EXPECT_EQ(StripQuotes("\"abc\""), "abc");
EXPECT_EQ(StripQuotes("\"abc\" "), "\"abc\" "); EXPECT_EQ(StripQuotes("\"abc\" "), "\"abc\" ");
EXPECT_EQ(TabsToSpaces(4, "a\tb"), "a b"); EXPECT_EQ(TabsToSpaces(4, "a\tb"), "a b");
EXPECT_EQ(ThousandSeparate(1234567, 15), " 1,234,567");
int i = 7;
EXPECT_EQ(false, TryParse("FF", &i));
EXPECT_EQ(7, i);
EXPECT_EQ(true, TryParse("22", &i));
EXPECT_EQ(22, i);
std::vector<std::string> strs;
SplitString("blah,foo,bar", ',', strs);
EXPECT_EQ(3, strs.size());
EXPECT_EQ("bar", strs[2]);
std::string path, fname, ext;
SplitPath("C:/some/path/test.jpg", &path, &fname, &ext);
EXPECT_EQ("C:/some/path/", path);
EXPECT_EQ("test", fname);
EXPECT_EQ(".jpg", ext);
SplitPath("C:/so.me/path/", &path, &fname, &ext);
EXPECT_EQ("C:/so.me/path/", path);
EXPECT_EQ("", fname);
EXPECT_EQ("", ext);
SplitPath("test.file.jpg", &path, &fname, &ext);
EXPECT_EQ("", path);
EXPECT_EQ("test.file", fname);
EXPECT_EQ(".jpg", ext);
} }