From 34692ab826abc8f8faa61bdb2280b742424528f1 Mon Sep 17 00:00:00 2001
From: "Jasper St. Pierre" <jstpierre@mecheye.net>
Date: Sat, 7 Dec 2013 15:14:29 -0500
Subject: Remove unnecessary Src/ folders

---
 Source/Core/Common/StringUtil.cpp | 534 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 534 insertions(+)
 create mode 100644 Source/Core/Common/StringUtil.cpp

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
new file mode 100644
index 0000000000..7ad4ac6ca5
--- /dev/null
+++ b/Source/Core/Common/StringUtil.cpp
@@ -0,0 +1,534 @@
+// Copyright 2013 Dolphin Emulator Project
+// Licensed under GPLv2
+// Refer to the license.txt file included.
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <algorithm>
+
+#include "CommonPaths.h"
+#include "StringUtil.h"
+
+#ifdef _WIN32
+	#include <Windows.h>
+#else
+	#include <iconv.h>
+	#include <errno.h>
+#endif
+
+// faster than sscanf
+bool AsciiToHex(const char* _szValue, u32& result)
+{
+	char *endptr = NULL;
+	const u32 value = strtoul(_szValue, &endptr, 16);
+
+	if (!endptr || *endptr)
+		return false;
+
+	result = value;
+	return true;
+}
+
+bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list args)
+{
+	int writtenCount;
+
+#ifdef _WIN32
+	// You would think *printf are simple, right? Iterate on each character,
+	// if it's a format specifier handle it properly, etc.
+	//
+	// Nooooo. Not according to the C standard.
+	//
+	// According to the C99 standard (7.19.6.1 "The fprintf function")
+	//     The format shall be a multibyte character sequence
+	//
+	// Because some character encodings might have '%' signs in the middle of
+	// a multibyte sequence (SJIS for example only specifies that the first
+	// byte of a 2 byte sequence is "high", the second byte can be anything),
+	// printf functions have to decode the multibyte sequences and try their
+	// best to not screw up.
+	//
+	// Unfortunately, on Windows, the locale for most languages is not UTF-8
+	// as we would need. Notably, for zh_TW, Windows chooses EUC-CN as the
+	// locale, and completely fails when trying to decode UTF-8 as EUC-CN.
+	//
+	// On the other hand, the fix is simple: because we use UTF-8, no such
+	// multibyte handling is required as we can simply assume that no '%' char
+	// will be present in the middle of a multibyte sequence.
+	//
+	// This is why we lookup an ANSI (cp1252) locale here and use _vsnprintf_l.
+	static locale_t c_locale = NULL;
+	if (!c_locale)
+		c_locale = _create_locale(LC_ALL, ".1252");
+	writtenCount = _vsnprintf_l(out, outsize, format, c_locale, args);
+#else
+	writtenCount = vsnprintf(out, outsize, format, args);
+#endif
+
+	if (writtenCount > 0 && writtenCount < outsize)
+	{
+		out[writtenCount] = '\0';
+		return true;
+	}
+	else
+	{
+		out[outsize - 1] = '\0';
+		return false;
+	}
+}
+
+std::string StringFromFormat(const char* format, ...)
+{
+	va_list args;
+	char *buf = NULL;
+#ifdef _WIN32
+	int required = 0;
+
+	va_start(args, format);
+	required = _vscprintf(format, args);
+	buf = new char[required + 1];
+	CharArrayFromFormatV(buf, required + 1, format, args);
+	va_end(args);
+
+	std::string temp = buf;
+	delete[] buf;
+#else
+	va_start(args, format);
+	if (vasprintf(&buf, format, args) < 0)
+		ERROR_LOG(COMMON, "Unable to allocate memory for string");
+	va_end(args);
+
+	std::string temp = buf;
+	free(buf);
+#endif
+	return temp;
+}
+
+// For Debugging. Read out an u8 array.
+std::string ArrayToString(const u8 *data, u32 size, int line_len, bool spaces)
+{
+	std::ostringstream oss;
+	oss << std::setfill('0') << std::hex;
+
+	for (int line = 0; size; ++data, --size)
+	{
+		oss << std::setw(2) << (int)*data;
+
+		if (line_len == ++line)
+		{
+			oss << '\n';
+			line = 0;
+		}
+		else if (spaces)
+			oss << ' ';
+	}
+
+	return oss.str();
+}
+
+// Turns "  hej " into "hej". Also handles tabs.
+std::string StripSpaces(const std::string &str)
+{
+	const size_t s = str.find_first_not_of(" \t\r\n");
+
+	if (str.npos != s)
+		return str.substr(s, str.find_last_not_of(" \t\r\n") - s + 1);
+	else
+		return "";
+}
+
+// "\"hello\"" is turned to "hello"
+// This one assumes that the string has already been space stripped in both
+// ends, as done by StripSpaces above, for example.
+std::string StripQuotes(const std::string& s)
+{
+	if (s.size() && '\"' == s[0] && '\"' == *s.rbegin())
+		return s.substr(1, s.size() - 2);
+	else
+		return s;
+}
+
+bool TryParse(const std::string &str, u32 *const output)
+{
+	char *endptr = NULL;
+
+	// Reset errno to a value other than ERANGE
+	errno = 0;
+
+	unsigned long value = strtoul(str.c_str(), &endptr, 0);
+
+	if (!endptr || *endptr)
+		return false;
+
+	if (errno == ERANGE)
+		return false;
+
+#if ULONG_MAX > UINT_MAX
+	if (value >= 0x100000000ull
+	    && value <= 0xFFFFFFFF00000000ull)
+		return false;
+#endif
+
+	*output = static_cast<u32>(value);
+	return true;
+}
+
+bool TryParse(const std::string &str, bool *const output)
+{
+	if ("1" == str || !strcasecmp("true", str.c_str()))
+		*output = true;
+	else if ("0" == str || !strcasecmp("false", str.c_str()))
+		*output = false;
+	else
+		return false;
+
+	return true;
+}
+
+std::string StringFromInt(int value)
+{
+	char temp[16];
+	sprintf(temp, "%i", value);
+	return temp;
+}
+
+std::string StringFromBool(bool value)
+{
+	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
+		":"
+#endif
+	);
+	if (std::string::npos == dir_end)
+		dir_end = 0;
+	else
+		dir_end += 1;
+
+	size_t fname_end = full_path.rfind('.');
+	if (fname_end < dir_end || std::string::npos == fname_end)
+		fname_end = full_path.size();
+
+	if (_pPath)
+		*_pPath = full_path.substr(0, dir_end);
+
+	if (_pFilename)
+		*_pFilename = full_path.substr(dir_end, fname_end - dir_end);
+
+	if (_pExtension)
+		*_pExtension = full_path.substr(fname_end);
+
+	return true;
+}
+
+void BuildCompleteFilename(std::string& _CompleteFilename, const std::string& _Path, const std::string& _Filename)
+{
+	_CompleteFilename = _Path;
+
+	// check for seperator
+	if (DIR_SEP_CHR != *_CompleteFilename.rbegin())
+		_CompleteFilename += DIR_SEP_CHR;
+
+	// add the filename
+	_CompleteFilename += _Filename;
+}
+
+void SplitString(const std::string& str, const char delim, std::vector<std::string>& output)
+{
+	std::istringstream iss(str);
+	output.resize(1);
+
+	while (std::getline(iss, *output.rbegin(), delim))
+		output.push_back("");
+
+	output.pop_back();
+}
+
+std::string TabsToSpaces(int tab_size, const std::string &in)
+{
+	const std::string spaces(tab_size, ' ');
+	std::string out(in);
+
+	size_t i = 0;
+	while (out.npos != (i = out.find('\t')))
+		out.replace(i, 1, spaces);
+
+	return out;
+}
+
+std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest)
+{
+	while(1)
+	{
+		size_t pos = result.find(src);
+		if (pos == std::string::npos) break;
+		result.replace(pos, src.size(), dest);
+	}
+	return result;
+}
+
+// UriDecode and UriEncode are from http://www.codeguru.com/cpp/cpp/string/conversions/print.php/c12759
+// by jinq0123 (November 2, 2006)
+
+// Uri encode and decode.
+// RFC1630, RFC1738, RFC2396
+
+//#include <string>
+//#include <assert.h>
+
+const char HEX2DEC[256] =
+{
+	/*       0  1  2  3   4  5  6  7   8  9  A  B   C  D  E  F */
+	/* 0 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
+	/* 1 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
+	/* 2 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
+	/* 3 */  0, 1, 2, 3,  4, 5, 6, 7,  8, 9,16,16, 16,16,16,16,
+
+	/* 4 */ 16,10,11,12, 13,14,15,16, 16,16,16,16, 16,16,16,16,
+	/* 5 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
+	/* 6 */ 16,10,11,12, 13,14,15,16, 16,16,16,16, 16,16,16,16,
+	/* 7 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
+
+	/* 8 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
+	/* 9 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
+	/* A */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
+	/* B */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
+
+	/* C */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
+	/* D */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
+	/* E */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
+	/* F */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16
+};
+
+std::string UriDecode(const std::string & sSrc)
+{
+	// Note from RFC1630:  "Sequences which start with a percent sign
+	// but are not followed by two hexadecimal characters (0-9, A-F) are reserved
+	// for future extension"
+
+	const unsigned char * pSrc = (const unsigned char *)sSrc.c_str();
+	const size_t SRC_LEN = sSrc.length();
+	const unsigned char * const SRC_END = pSrc + SRC_LEN;
+	const unsigned char * const SRC_LAST_DEC = SRC_END - 2;   // last decodable '%'
+
+	char * const pStart = new char[SRC_LEN];
+	char * pEnd = pStart;
+
+	while (pSrc < SRC_LAST_DEC)
+	{
+		if (*pSrc == '%')
+		{
+			char dec1, dec2;
+			if (16 != (dec1 = HEX2DEC[*(pSrc + 1)])
+				&& 16 != (dec2 = HEX2DEC[*(pSrc + 2)]))
+			{
+				*pEnd++ = (dec1 << 4) + dec2;
+				pSrc += 3;
+				continue;
+			}
+		}
+
+		*pEnd++ = *pSrc++;
+	}
+
+	// the last 2- chars
+	while (pSrc < SRC_END)
+		*pEnd++ = *pSrc++;
+
+	std::string sResult(pStart, pEnd);
+	delete [] pStart;
+	return sResult;
+}
+
+// Only alphanum is safe.
+const char SAFE[256] =
+{
+	/*      0 1 2 3  4 5 6 7  8 9 A B  C D E F */
+	/* 0 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+	/* 1 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+	/* 2 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+	/* 3 */ 1,1,1,1, 1,1,1,1, 1,1,0,0, 0,0,0,0,
+
+	/* 4 */ 0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1,
+	/* 5 */ 1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,0,
+	/* 6 */ 0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1,
+	/* 7 */ 1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,0,
+
+	/* 8 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+	/* 9 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+	/* A */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+	/* B */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+
+	/* C */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+	/* D */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+	/* E */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
+	/* F */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
+};
+
+std::string UriEncode(const std::string & sSrc)
+{
+	const char DEC2HEX[16 + 1] = "0123456789ABCDEF";
+	const unsigned char * pSrc = (const unsigned char *)sSrc.c_str();
+	const size_t SRC_LEN = sSrc.length();
+	unsigned char * const pStart = new unsigned char[SRC_LEN * 3];
+	unsigned char * pEnd = pStart;
+	const unsigned char * const SRC_END = pSrc + SRC_LEN;
+
+	for (; pSrc < SRC_END; ++pSrc)
+	{
+		if (SAFE[*pSrc])
+			*pEnd++ = *pSrc;
+		else
+		{
+			// escape this char
+			*pEnd++ = '%';
+			*pEnd++ = DEC2HEX[*pSrc >> 4];
+			*pEnd++ = DEC2HEX[*pSrc & 0x0F];
+		}
+	}
+
+	std::string sResult((char *)pStart, (char *)pEnd);
+	delete [] pStart;
+	return sResult;
+}
+
+#ifdef _WIN32
+
+std::string UTF16ToUTF8(const std::wstring& input)
+{
+	auto const size = WideCharToMultiByte(CP_UTF8, 0, input.data(), (int)input.size(), nullptr, 0, nullptr, nullptr);
+
+	std::string output;
+	output.resize(size);
+
+	if (size == 0 || size != WideCharToMultiByte(CP_UTF8, 0, input.data(), (int)input.size(), &output[0], (int)output.size(), nullptr, nullptr))
+	{
+		output.clear();
+	}
+
+	return output;
+}
+
+std::wstring CPToUTF16(u32 code_page, const std::string& input)
+{
+	auto const size = MultiByteToWideChar(code_page, 0, input.data(), (int)input.size(), nullptr, 0);
+
+	std::wstring output;
+	output.resize(size);
+
+	if (size == 0 || size != MultiByteToWideChar(code_page, 0, input.data(), (int)input.size(), &output[0], (int)output.size()))
+	{
+		output.clear();
+	}
+
+	return output;
+}
+
+std::wstring UTF8ToUTF16(const std::string& input)
+{
+	return CPToUTF16(CP_UTF8, input);
+}
+
+std::string SHIFTJISToUTF8(const std::string& input)
+{
+	return UTF16ToUTF8(CPToUTF16(932, input));
+}
+
+std::string CP1252ToUTF8(const std::string& input)
+{
+	return UTF16ToUTF8(CPToUTF16(1252, input));
+}
+
+#else
+
+template <typename T>
+std::string CodeToUTF8(const char* fromcode, const std::basic_string<T>& input)
+{
+	std::string result;
+
+	iconv_t const conv_desc = iconv_open("UTF-8", fromcode);
+	if ((iconv_t)-1 == conv_desc)
+	{
+		ERROR_LOG(COMMON, "Iconv initialization failure [%s]: %s", fromcode, strerror(errno));
+	}
+	else
+	{
+		size_t const in_bytes = sizeof(T) * input.size();
+		size_t const out_buffer_size = 4 * in_bytes;
+
+		std::string out_buffer;
+		out_buffer.resize(out_buffer_size);
+
+		auto src_buffer = &input[0];
+		size_t src_bytes = in_bytes;
+		auto dst_buffer = &out_buffer[0];
+		size_t dst_bytes = out_buffer.size();
+
+		while (src_bytes != 0)
+		{
+			size_t const iconv_result = iconv(conv_desc, (char**)(&src_buffer), &src_bytes,
+				&dst_buffer, &dst_bytes);
+
+			if ((size_t)-1 == iconv_result)
+			{
+				if (EILSEQ == errno || EINVAL == errno)
+				{
+					// Try to skip the bad character
+					if (src_bytes != 0)
+					{
+						--src_bytes;
+						++src_buffer;
+					}
+				}
+				else
+				{
+					ERROR_LOG(COMMON, "iconv failure [%s]: %s", fromcode, strerror(errno));
+					break;
+				}
+			}
+		}
+
+		out_buffer.resize(out_buffer_size - dst_bytes);
+		out_buffer.swap(result);
+
+		iconv_close(conv_desc);
+	}
+
+	return result;
+}
+
+std::string CP1252ToUTF8(const std::string& input)
+{
+	//return CodeToUTF8("CP1252//TRANSLIT", input);
+	//return CodeToUTF8("CP1252//IGNORE", input);
+	return CodeToUTF8("CP1252", input);
+}
+
+std::string SHIFTJISToUTF8(const std::string& input)
+{
+	//return CodeToUTF8("CP932", input);
+	return CodeToUTF8("SJIS", input);
+}
+
+std::string UTF16ToUTF8(const std::wstring& input)
+{
+	std::string result =
+	//	CodeToUTF8("UCS-2", input);
+	//	CodeToUTF8("UCS-2LE", input);
+	//	CodeToUTF8("UTF-16", input);
+		CodeToUTF8("UTF-16LE", input);
+
+	// TODO: why is this needed?
+	result.erase(std::remove(result.begin(), result.end(), 0x00), result.end());
+	return result;
+}
+
+#endif
-- 
cgit v1.2.3


From 05742ffd488703f71462518957260f12cb657088 Mon Sep 17 00:00:00 2001
From: Lioncash <mathew1800@gmail.com>
Date: Thu, 6 Feb 2014 18:08:31 -0500
Subject: Remove function StringFromInt from StringUtil.cpp/.h. C++11 has
 std::to_string for this now.

---
 Source/Core/Common/StringUtil.cpp | 7 -------
 1 file changed, 7 deletions(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index 7ad4ac6ca5..a0a8c739ca 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -185,13 +185,6 @@ bool TryParse(const std::string &str, bool *const output)
 	return true;
 }
 
-std::string StringFromInt(int value)
-{
-	char temp[16];
-	sprintf(temp, "%i", value);
-	return temp;
-}
-
 std::string StringFromBool(bool value)
 {
 	return value ? "True" : "False";
-- 
cgit v1.2.3


From 70e2ed320de81a33b146469c87e9a1203c13c171 Mon Sep 17 00:00:00 2001
From: Pierre Bourdon <delroth@gmail.com>
Date: Fri, 7 Feb 2014 00:26:33 +0100
Subject: Revert "Merge pull request #47 from lioncash/remove-stringfromint"

Breaks Android build.

This reverts commit 12d026c544748521332ad5edfaf123547fa18233, reversing
changes made to 6d678490f51cc0154a0bdedf9dce23c77fdfb991.
---
 Source/Core/Common/StringUtil.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index a0a8c739ca..7ad4ac6ca5 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -185,6 +185,13 @@ bool TryParse(const std::string &str, bool *const output)
 	return true;
 }
 
+std::string StringFromInt(int value)
+{
+	char temp[16];
+	sprintf(temp, "%i", value);
+	return temp;
+}
+
 std::string StringFromBool(bool value)
 {
 	return value ? "True" : "False";
-- 
cgit v1.2.3


From 3fd87a7636ff434118a5d7f7334550be8db55c0b Mon Sep 17 00:00:00 2001
From: Lioncash <mathew1800@gmail.com>
Date: Sun, 16 Feb 2014 23:51:41 -0500
Subject: Second and final pass of clearing out tabs.

---
 Source/Core/Common/StringUtil.cpp | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index 7ad4ac6ca5..7d8825231e 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -520,11 +520,7 @@ std::string SHIFTJISToUTF8(const std::string& input)
 
 std::string UTF16ToUTF8(const std::wstring& input)
 {
-	std::string result =
-	//	CodeToUTF8("UCS-2", input);
-	//	CodeToUTF8("UCS-2LE", input);
-	//	CodeToUTF8("UTF-16", input);
-		CodeToUTF8("UTF-16LE", input);
+	std::string result = CodeToUTF8("UTF-16LE", input);
 
 	// TODO: why is this needed?
 	result.erase(std::remove(result.begin(), result.end(), 0x00), result.end());
-- 
cgit v1.2.3


From 2afe2152712981e21d6bda6f029292ed2b1cf91e Mon Sep 17 00:00:00 2001
From: Lioncash <mathew1800@gmail.com>
Date: Mon, 17 Feb 2014 05:18:15 -0500
Subject: Convert all includes to relative paths.

---
 Source/Core/Common/StringUtil.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index 7d8825231e..233bc8717b 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -2,12 +2,12 @@
 // Licensed under GPLv2
 // Refer to the license.txt file included.
 
-#include <stdlib.h>
-#include <stdio.h>
 #include <algorithm>
+#include <cstdlib>
+#include <cstdio>
 
-#include "CommonPaths.h"
-#include "StringUtil.h"
+#include "Common/CommonPaths.h"
+#include "Common/StringUtil.h"
 
 #ifdef _WIN32
 	#include <Windows.h>
-- 
cgit v1.2.3


From 3f9c38d2314a259a9c34dd89bcdfab3af00a02f5 Mon Sep 17 00:00:00 2001
From: Pierre Bourdon <delroth@gmail.com>
Date: Wed, 19 Feb 2014 01:54:11 +0100
Subject: Fix more header sorting issues in Common/ (now check-includes clean).

---
 Source/Core/Common/StringUtil.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index 233bc8717b..3031669323 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -3,8 +3,8 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
-#include <cstdlib>
 #include <cstdio>
+#include <cstdlib>
 
 #include "Common/CommonPaths.h"
 #include "Common/StringUtil.h"
-- 
cgit v1.2.3


From 83b7bb64aa5e1ee6b18eaa5d08c17bb5b6c57048 Mon Sep 17 00:00:00 2001
From: Pierre Bourdon <delroth@gmail.com>
Date: Thu, 20 Feb 2014 04:11:52 +0100
Subject: Make Common/ mostly IWYU clean (and fix errors in rest of the project
 detected by this change).

---
 Source/Core/Common/StringUtil.cpp | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index 3031669323..7f7ce5d794 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -3,9 +3,18 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
+#include <cstdarg>
+#include <cstddef>
 #include <cstdio>
 #include <cstdlib>
-
+#include <cstring>
+#include <iomanip>
+#include <istream>
+#include <limits.h>
+#include <string>
+#include <vector>
+
+#include "Common/Common.h"
 #include "Common/CommonPaths.h"
 #include "Common/StringUtil.h"
 
-- 
cgit v1.2.3


From d802d392811be44d34ae9cd23f616db93e54c50f Mon Sep 17 00:00:00 2001
From: Tillmann Karras <tilkax@gmail.com>
Date: Sun, 9 Mar 2014 21:14:26 +0100
Subject: clang-modernize -use-nullptr

and s/\bNULL\b/nullptr/g for *.cpp/h/mm files not compiled on my machine
---
 Source/Core/Common/StringUtil.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index 7f7ce5d794..1919083162 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -28,7 +28,7 @@
 // faster than sscanf
 bool AsciiToHex(const char* _szValue, u32& result)
 {
-	char *endptr = NULL;
+	char *endptr = nullptr;
 	const u32 value = strtoul(_szValue, &endptr, 16);
 
 	if (!endptr || *endptr)
@@ -66,7 +66,7 @@ bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list ar
 	// will be present in the middle of a multibyte sequence.
 	//
 	// This is why we lookup an ANSI (cp1252) locale here and use _vsnprintf_l.
-	static locale_t c_locale = NULL;
+	static locale_t c_locale = nullptr;
 	if (!c_locale)
 		c_locale = _create_locale(LC_ALL, ".1252");
 	writtenCount = _vsnprintf_l(out, outsize, format, c_locale, args);
@@ -89,7 +89,7 @@ bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list ar
 std::string StringFromFormat(const char* format, ...)
 {
 	va_list args;
-	char *buf = NULL;
+	char *buf = nullptr;
 #ifdef _WIN32
 	int required = 0;
 
@@ -159,7 +159,7 @@ std::string StripQuotes(const std::string& s)
 
 bool TryParse(const std::string &str, u32 *const output)
 {
-	char *endptr = NULL;
+	char *endptr = nullptr;
 
 	// Reset errno to a value other than ERANGE
 	errno = 0;
-- 
cgit v1.2.3


From 31cfc73a09a8685cbab20502b4bc132e98e2feb5 Mon Sep 17 00:00:00 2001
From: Matthew Parlane <parlane@gmail.com>
Date: Tue, 11 Mar 2014 00:30:55 +1300
Subject: Fixes spacing for "for", "while", "switch" and "if" Also moved && and
 || to ends of lines instead of start. Fixed misc vertical alignments and some
 { needed newlining.

---
 Source/Core/Common/StringUtil.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index 1919083162..9a42d35fd6 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -173,8 +173,8 @@ bool TryParse(const std::string &str, u32 *const output)
 		return false;
 
 #if ULONG_MAX > UINT_MAX
-	if (value >= 0x100000000ull
-	    && value <= 0xFFFFFFFF00000000ull)
+	if (value >= 0x100000000ull &&
+	    value <= 0xFFFFFFFF00000000ull)
 		return false;
 #endif
 
@@ -275,7 +275,7 @@ std::string TabsToSpaces(int tab_size, const std::string &in)
 
 std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest)
 {
-	while(1)
+	while (1)
 	{
 		size_t pos = result.find(src);
 		if (pos == std::string::npos) break;
@@ -336,8 +336,8 @@ std::string UriDecode(const std::string & sSrc)
 		if (*pSrc == '%')
 		{
 			char dec1, dec2;
-			if (16 != (dec1 = HEX2DEC[*(pSrc + 1)])
-				&& 16 != (dec2 = HEX2DEC[*(pSrc + 2)]))
+			if (16 != (dec1 = HEX2DEC[*(pSrc + 1)]) &&
+			    16 != (dec2 = HEX2DEC[*(pSrc + 2)]))
 			{
 				*pEnd++ = (dec1 << 4) + dec2;
 				pSrc += 3;
-- 
cgit v1.2.3


From a82675b7d581421fa80d5d5c53253cf1d5c1a26d Mon Sep 17 00:00:00 2001
From: Lioncash <mathew1800@gmail.com>
Date: Wed, 12 Mar 2014 15:33:41 -0400
Subject: Kill off some usages of c_str.

Also changes some function params, but this is ok.
Some simplifications were also able to be made (ie. killing off strcmps with ==, etc).
---
 Source/Core/Common/StringUtil.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index 9a42d35fd6..16281ac91f 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -26,10 +26,10 @@
 #endif
 
 // faster than sscanf
-bool AsciiToHex(const char* _szValue, u32& result)
+bool AsciiToHex(const std::string& _szValue, u32& result)
 {
 	char *endptr = nullptr;
-	const u32 value = strtoul(_szValue, &endptr, 16);
+	const u32 value = strtoul(_szValue.c_str(), &endptr, 16);
 
 	if (!endptr || *endptr)
 		return false;
-- 
cgit v1.2.3


From 5afb9cc5c44ea143141689e26f84fc7036accb7e Mon Sep 17 00:00:00 2001
From: Lioncash <mathew1800@gmail.com>
Date: Tue, 12 Aug 2014 02:48:52 -0400
Subject: Common: Fix AsciiToHex returning true on overflow values

We should be checking errno against ERANGE.
---
 Source/Core/Common/StringUtil.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index 16281ac91f..59fcb4131d 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -28,12 +28,18 @@
 // faster than sscanf
 bool AsciiToHex(const std::string& _szValue, u32& result)
 {
+	// Set errno to a good state.
+	errno = 0;
+
 	char *endptr = nullptr;
 	const u32 value = strtoul(_szValue.c_str(), &endptr, 16);
 
 	if (!endptr || *endptr)
 		return false;
 
+	if (errno == ERANGE)
+		return false;
+
 	result = value;
 	return true;
 }
-- 
cgit v1.2.3


From 636917398139d7f7a0612bff4bdc2c3145b8140e Mon Sep 17 00:00:00 2001
From: Lioncash <mathew1800@gmail.com>
Date: Thu, 4 Sep 2014 21:30:33 -0400
Subject: DolphinWX: Simplify wiki link construction

---
 Source/Core/Common/StringUtil.cpp | 125 --------------------------------------
 1 file changed, 125 deletions(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index 59fcb4131d..3239628b62 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -290,131 +290,6 @@ std::string ReplaceAll(std::string result, const std::string& src, const std::st
 	return result;
 }
 
-// UriDecode and UriEncode are from http://www.codeguru.com/cpp/cpp/string/conversions/print.php/c12759
-// by jinq0123 (November 2, 2006)
-
-// Uri encode and decode.
-// RFC1630, RFC1738, RFC2396
-
-//#include <string>
-//#include <assert.h>
-
-const char HEX2DEC[256] =
-{
-	/*       0  1  2  3   4  5  6  7   8  9  A  B   C  D  E  F */
-	/* 0 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
-	/* 1 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
-	/* 2 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
-	/* 3 */  0, 1, 2, 3,  4, 5, 6, 7,  8, 9,16,16, 16,16,16,16,
-
-	/* 4 */ 16,10,11,12, 13,14,15,16, 16,16,16,16, 16,16,16,16,
-	/* 5 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
-	/* 6 */ 16,10,11,12, 13,14,15,16, 16,16,16,16, 16,16,16,16,
-	/* 7 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
-
-	/* 8 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
-	/* 9 */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
-	/* A */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
-	/* B */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
-
-	/* C */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
-	/* D */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
-	/* E */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16,
-	/* F */ 16,16,16,16, 16,16,16,16, 16,16,16,16, 16,16,16,16
-};
-
-std::string UriDecode(const std::string & sSrc)
-{
-	// Note from RFC1630:  "Sequences which start with a percent sign
-	// but are not followed by two hexadecimal characters (0-9, A-F) are reserved
-	// for future extension"
-
-	const unsigned char * pSrc = (const unsigned char *)sSrc.c_str();
-	const size_t SRC_LEN = sSrc.length();
-	const unsigned char * const SRC_END = pSrc + SRC_LEN;
-	const unsigned char * const SRC_LAST_DEC = SRC_END - 2;   // last decodable '%'
-
-	char * const pStart = new char[SRC_LEN];
-	char * pEnd = pStart;
-
-	while (pSrc < SRC_LAST_DEC)
-	{
-		if (*pSrc == '%')
-		{
-			char dec1, dec2;
-			if (16 != (dec1 = HEX2DEC[*(pSrc + 1)]) &&
-			    16 != (dec2 = HEX2DEC[*(pSrc + 2)]))
-			{
-				*pEnd++ = (dec1 << 4) + dec2;
-				pSrc += 3;
-				continue;
-			}
-		}
-
-		*pEnd++ = *pSrc++;
-	}
-
-	// the last 2- chars
-	while (pSrc < SRC_END)
-		*pEnd++ = *pSrc++;
-
-	std::string sResult(pStart, pEnd);
-	delete [] pStart;
-	return sResult;
-}
-
-// Only alphanum is safe.
-const char SAFE[256] =
-{
-	/*      0 1 2 3  4 5 6 7  8 9 A B  C D E F */
-	/* 0 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
-	/* 1 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
-	/* 2 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
-	/* 3 */ 1,1,1,1, 1,1,1,1, 1,1,0,0, 0,0,0,0,
-
-	/* 4 */ 0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1,
-	/* 5 */ 1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,0,
-	/* 6 */ 0,1,1,1, 1,1,1,1, 1,1,1,1, 1,1,1,1,
-	/* 7 */ 1,1,1,1, 1,1,1,1, 1,1,1,0, 0,0,0,0,
-
-	/* 8 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
-	/* 9 */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
-	/* A */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
-	/* B */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
-
-	/* C */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
-	/* D */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
-	/* E */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0,
-	/* F */ 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0
-};
-
-std::string UriEncode(const std::string & sSrc)
-{
-	const char DEC2HEX[16 + 1] = "0123456789ABCDEF";
-	const unsigned char * pSrc = (const unsigned char *)sSrc.c_str();
-	const size_t SRC_LEN = sSrc.length();
-	unsigned char * const pStart = new unsigned char[SRC_LEN * 3];
-	unsigned char * pEnd = pStart;
-	const unsigned char * const SRC_END = pSrc + SRC_LEN;
-
-	for (; pSrc < SRC_END; ++pSrc)
-	{
-		if (SAFE[*pSrc])
-			*pEnd++ = *pSrc;
-		else
-		{
-			// escape this char
-			*pEnd++ = '%';
-			*pEnd++ = DEC2HEX[*pSrc >> 4];
-			*pEnd++ = DEC2HEX[*pSrc & 0x0F];
-		}
-	}
-
-	std::string sResult((char *)pStart, (char *)pEnd);
-	delete [] pStart;
-	return sResult;
-}
-
 #ifdef _WIN32
 
 std::string UTF16ToUTF8(const std::wstring& input)
-- 
cgit v1.2.3


From 3e0c04a83e99847e5e846ce8c198bb8a5d26343f Mon Sep 17 00:00:00 2001
From: lioncash <mathew1800@gmail.com>
Date: Fri, 5 Sep 2014 14:34:46 -0400
Subject: Common: Fix a potential infinite loop in ReplaceAll

Prior to this change, it was possible to cause an infinite loop by making the string to be replaced and the replacing string the same thing.

e.g.

std::string some_str = "test";
ReplaceAll(some_str, "test", "test");

This also changes the replacing in a way that doesn't require starting from the beginning of the string on each replacement iteration.
---
 Source/Core/Common/StringUtil.cpp | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index 3239628b62..91d451a03f 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -281,12 +281,17 @@ std::string TabsToSpaces(int tab_size, const std::string &in)
 
 std::string ReplaceAll(std::string result, const std::string& src, const std::string& dest)
 {
-	while (1)
+	size_t pos = 0;
+
+	if (src == dest)
+		return result;
+
+	while ((pos = result.find(src, pos)) != std::string::npos)
 	{
-		size_t pos = result.find(src);
-		if (pos == std::string::npos) break;
 		result.replace(pos, src.size(), dest);
+		pos += dest.length();
 	}
+
 	return result;
 }
 
-- 
cgit v1.2.3


From fbc64984ca7de7db10b1a8a4f49002f260c93569 Mon Sep 17 00:00:00 2001
From: Rohit Nirmal <rohitnirmal9@gmail.com>
Date: Sun, 7 Sep 2014 20:06:58 -0500
Subject: Include CommonTypes.h instead of Common.h.

---
 Source/Core/Common/StringUtil.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index 91d451a03f..d1af64f30e 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -14,8 +14,8 @@
 #include <string>
 #include <vector>
 
-#include "Common/Common.h"
 #include "Common/CommonPaths.h"
+#include "Common/CommonTypes.h"
 #include "Common/StringUtil.h"
 
 #ifdef _WIN32
-- 
cgit v1.2.3


From 9bcadc8029b615d3d447a2a875fd720a73255d11 Mon Sep 17 00:00:00 2001
From: Lioncash <mathew1800@gmail.com>
Date: Fri, 5 Dec 2014 20:54:41 -0500
Subject: Common: Remove locale based functions from CommonFuncs.

Since %f isn't used anymore in the shader generators, these can go.
---
 Source/Core/Common/StringUtil.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index d1af64f30e..edc1ca9046 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -72,7 +72,7 @@ bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list ar
 	// will be present in the middle of a multibyte sequence.
 	//
 	// This is why we lookup an ANSI (cp1252) locale here and use _vsnprintf_l.
-	static locale_t c_locale = nullptr;
+	static _locale_t c_locale = nullptr;
 	if (!c_locale)
 		c_locale = _create_locale(LC_ALL, ".1252");
 	writtenCount = _vsnprintf_l(out, outsize, format, c_locale, args);
-- 
cgit v1.2.3


From cb86db7b68481edf129a4bfcf6cd44a9a0f32ac8 Mon Sep 17 00:00:00 2001
From: Stevoisiak <S.Vascellaro@gmail.com>
Date: Sun, 11 Jan 2015 00:17:29 -0500
Subject: Minor consistency changes

Mostly small changes, like capitalization and spelling
---
 Source/Core/Common/StringUtil.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index edc1ca9046..cfd7b03577 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -218,7 +218,7 @@ bool SplitPath(const std::string& full_path, std::string* _pPath, std::string* _
 		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
+	// Windows needs the : included for something like just "C:" to be considered a directory
 #ifdef _WIN32
 		":"
 #endif
-- 
cgit v1.2.3


From a957f93532bfd2025fe20dd8929866c97b5e4df1 Mon Sep 17 00:00:00 2001
From: Gabriel Corona <gabriel.corona@enst-bretagne.fr>
Date: Mon, 29 Dec 2014 01:09:07 +0100
Subject: Use printf-like format in JitRegister::Register

The API is cleaner (no more magic default parameter) and more
extensible like this.
---
 Source/Core/Common/StringUtil.cpp | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index cfd7b03577..b922704032 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -95,28 +95,30 @@ bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list ar
 std::string StringFromFormat(const char* format, ...)
 {
 	va_list args;
+	va_start(args, format);
+	std::string res = StringFromFormatV(format, args);
+	va_end(args);
+	return std::move(res);
+}
+
+std::string StringFromFormatV(const char* format, va_list args)
+{
 	char *buf = nullptr;
 #ifdef _WIN32
-	int required = 0;
-
-	va_start(args, format);
-	required = _vscprintf(format, args);
+	int required = _vscprintf(format, args);
 	buf = new char[required + 1];
 	CharArrayFromFormatV(buf, required + 1, format, args);
-	va_end(args);
 
 	std::string temp = buf;
 	delete[] buf;
 #else
-	va_start(args, format);
 	if (vasprintf(&buf, format, args) < 0)
 		ERROR_LOG(COMMON, "Unable to allocate memory for string");
-	va_end(args);
 
 	std::string temp = buf;
 	free(buf);
 #endif
-	return temp;
+	return std::move(temp);
 }
 
 // For Debugging. Read out an u8 array.
-- 
cgit v1.2.3


From 266d50c8112dabc7a24bd290670e93bfef5b12f8 Mon Sep 17 00:00:00 2001
From: Gabriel Corona <gabriel.corona@enst-bretagne.fr>
Date: Mon, 2 Feb 2015 00:45:37 +0100
Subject: Use the C locale for non-Windows CharArrayFromFormatV() and
 StringFromFormat()

The Windows implementations of CharArrayFromFormatV() and
StringFromFormat() use the "C"/".1252" locale instead of the user
locale (using _vsnprintf_l). On non-Windows, the user locale was used.

This leads to bugs on non-Windows: the Overclock parameter was
serialised with the user locale ("0,279322" in some locale) and was
interpreted back as "0" (because the C locale is used for parsing the
string).

Make non-Windows CharArrayFromFormatV() and StringFromFormat()
consistent with their Windows counterpart.

The locale code is not enables for Android:: uselocale is only
available since API 21 and API 21 only supports C and C.UTF-8.
---
 Source/Core/Common/StringUtil.cpp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index b922704032..7f233e430d 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -22,9 +22,18 @@
 	#include <Windows.h>
 #else
 	#include <iconv.h>
+	#include <locale.h>
 	#include <errno.h>
 #endif
 
+#if !defined(_WIN32) && !defined(ANDROID)
+static locale_t GetCLocale()
+{
+	static locale_t c_locale = newlocale(LC_ALL_MASK, "C", NULL);
+	return c_locale;
+}
+#endif
+
 // faster than sscanf
 bool AsciiToHex(const std::string& _szValue, u32& result)
 {
@@ -77,7 +86,13 @@ bool CharArrayFromFormatV(char* out, int outsize, const char* format, va_list ar
 		c_locale = _create_locale(LC_ALL, ".1252");
 	writtenCount = _vsnprintf_l(out, outsize, format, c_locale, args);
 #else
+	#if !defined(ANDROID)
+	locale_t previousLocale = uselocale(GetCLocale());
+	#endif
 	writtenCount = vsnprintf(out, outsize, format, args);
+	#if !defined(ANDROID)
+	uselocale(previousLocale);
+	#endif
 #endif
 
 	if (writtenCount > 0 && writtenCount < outsize)
@@ -112,8 +127,14 @@ std::string StringFromFormatV(const char* format, va_list args)
 	std::string temp = buf;
 	delete[] buf;
 #else
+	#if !defined(ANDROID)
+	locale_t previousLocale = uselocale(GetCLocale());
+	#endif
 	if (vasprintf(&buf, format, args) < 0)
 		ERROR_LOG(COMMON, "Unable to allocate memory for string");
+	#if !defined(ANDROID)
+	uselocale(previousLocale);
+	#endif
 
 	std::string temp = buf;
 	free(buf);
-- 
cgit v1.2.3


From 48ec42d4a01b9dd3db4316a3de1230e3f3fffe07 Mon Sep 17 00:00:00 2001
From: Rohit Nirmal <rohitnirmal9@gmail.com>
Date: Sat, 14 Mar 2015 20:20:41 -0500
Subject: Core: Change NULLs to nullptrs.

---
 Source/Core/Common/StringUtil.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index 7f233e430d..3f201f321f 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -29,7 +29,7 @@
 #if !defined(_WIN32) && !defined(ANDROID)
 static locale_t GetCLocale()
 {
-	static locale_t c_locale = newlocale(LC_ALL_MASK, "C", NULL);
+	static locale_t c_locale = newlocale(LC_ALL_MASK, "C", nullptr);
 	return c_locale;
 }
 #endif
-- 
cgit v1.2.3


From cefcb0ace9d363b3679b4e93bcc9ec05f1e5f4f8 Mon Sep 17 00:00:00 2001
From: Tillmann Karras <tilkax@gmail.com>
Date: Mon, 18 May 2015 01:08:10 +0200
Subject: Update license headers to GPLv2+

---
 Source/Core/Common/StringUtil.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index 3f201f321f..a7bdbe03b1 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -1,5 +1,5 @@
 // Copyright 2013 Dolphin Emulator Project
-// Licensed under GPLv2
+// Licensed under GPLv2+
 // Refer to the license.txt file included.
 
 #include <algorithm>
-- 
cgit v1.2.3


From 30ebb2459eb97ba544547183854775df8460b475 Mon Sep 17 00:00:00 2001
From: Tillmann Karras <tilkax@gmail.com>
Date: Sun, 24 May 2015 06:55:12 +0200
Subject: Set copyright year to when a file was created

---
 Source/Core/Common/StringUtil.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Source/Core/Common/StringUtil.cpp')

diff --git a/Source/Core/Common/StringUtil.cpp b/Source/Core/Common/StringUtil.cpp
index a7bdbe03b1..903131a5d3 100644
--- a/Source/Core/Common/StringUtil.cpp
+++ b/Source/Core/Common/StringUtil.cpp
@@ -1,4 +1,4 @@
-// Copyright 2013 Dolphin Emulator Project
+// Copyright 2008 Dolphin Emulator Project
 // Licensed under GPLv2+
 // Refer to the license.txt file included.
 
-- 
cgit v1.2.3