incentive/psopeeps-newserv
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

eliminate using namespace

Browse Source
This commit is contained in:
Martin Michelsen
2026-05-25 16:38:31 -07:00
parent 4503d09c77
commit e9c2ac34a3
98 changed files with 6022 additions and 6531 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Text.cc
+47 -49
View File
@@ -9,15 +9,13 @@
#include <phosg/Strings.hh>
#include <vector>
using namespace std;
const iconv_t TextTranscoder::INVALID_IC = (iconv_t)(-1);
const size_t TextTranscoder::FAILURE_RESULT = static_cast<size_t>(-1);
TextTranscoder::TextTranscoder(const char* to, const char* from) : ic(iconv_open(to, from)) {
if (ic == this->INVALID_IC) {
string error_str = phosg::string_for_error(errno);
throw runtime_error(std::format("failed to initialize {} -> {} text converter: {}", from, to, error_str));
throw std::runtime_error(std::format("failed to initialize {} -> {} text converter: {}",
from, to, phosg::string_for_error(errno)));
}
}
@@ -45,32 +43,32 @@ TextTranscoder::Result TextTranscoder::operator()(
if (ret == this->FAILURE_RESULT) {
switch (errno) {
case EILSEQ: {
string custom_result = this->on_untranslatable(&src, &src_bytes);
std::string custom_result = this->on_untranslatable(&src, &src_bytes);
if (custom_result.empty()) {
throw runtime_error(std::format("untranslatable character at position 0x{:X}", bytes_read));
throw std::runtime_error(std::format("untranslatable character at position 0x{:X}", bytes_read));
} else if (custom_result.size() <= dest_bytes) {
memcpy(dest, custom_result.data(), custom_result.size());
dest = reinterpret_cast<char*>(dest) + custom_result.size();
dest_bytes -= custom_result.size();
} else if (!truncate_oversize_result) {
throw runtime_error("string does not fit in buffer");
throw std::runtime_error("string does not fit in buffer");
}
break;
}
case EINVAL:
throw runtime_error(std::format("incomplete multibyte sequence at position 0x{:X}", bytes_read));
throw std::runtime_error(std::format("incomplete multibyte sequence at position 0x{:X}", bytes_read));
case E2BIG:
if (!truncate_oversize_result) {
throw runtime_error("string does not fit in buffer");
throw std::runtime_error("string does not fit in buffer");
} else {
src_bytes = 0;
break;
}
default:
throw runtime_error("transcoding failed: " + phosg::string_for_error(errno));
throw std::runtime_error("transcoding failed: " + phosg::string_for_error(errno));
}
} else if (src_bytes_before == src_bytes) {
throw runtime_error("could not transcode any characters");
throw std::runtime_error("could not transcode any characters");
}
}
@@ -79,15 +77,15 @@ TextTranscoder::Result TextTranscoder::operator()(
return Result{.bytes_read = bytes_read, .bytes_written = bytes_written};
}
string TextTranscoder::operator()(const void* src, size_t src_bytes) {
std::string TextTranscoder::operator()(const void* src, size_t src_bytes) {
// Clear any conversion state left over from the previous call
iconv(this->ic, nullptr, nullptr, nullptr, nullptr);
const void* orig_src = src;
deque<string> blocks;
std::deque<std::string> blocks;
while (src_bytes > 0) {
// Assume 2x input size on average, but always allocate at least 8 bytes
string& block = blocks.emplace_back(max<size_t>((src_bytes << 1), 8), '\0');
std::string& block = blocks.emplace_back(std::max<size_t>((src_bytes << 1), 8), '\0');
char* dest = block.data();
size_t dest_size = block.size();
size_t src_bytes_before = src_bytes;
@@ -103,29 +101,29 @@ string TextTranscoder::operator()(const void* src, size_t src_bytes) {
if (ret == this->FAILURE_RESULT) {
switch (errno) {
case EILSEQ: {
string custom_result = this->on_untranslatable(&src, &src_bytes);
std::string custom_result = this->on_untranslatable(&src, &src_bytes);
if (custom_result.empty()) {
throw runtime_error(std::format("untranslatable character at position {}", bytes_read));
throw std::runtime_error(std::format("untranslatable character at position {}", bytes_read));
}
blocks.emplace_back(std::move(custom_result));
break;
}
case EINVAL:
throw runtime_error(std::format("incomplete multibyte sequence at position {}", bytes_read));
throw std::runtime_error(std::format("incomplete multibyte sequence at position {}", bytes_read));
case E2BIG:
break;
default:
throw runtime_error("transcoding failed: " + phosg::string_for_error(errno));
throw std::runtime_error("transcoding failed: " + phosg::string_for_error(errno));
}
} else if (src_bytes_before == src_bytes) {
throw runtime_error("could not transcode any characters");
throw std::runtime_error("could not transcode any characters");
}
}
return phosg::join(blocks, "");
}
string TextTranscoder::operator()(const string& data) {
std::string TextTranscoder::operator()(const std::string& data) {
return this->operator()(data.data(), data.size());
}
@@ -136,7 +134,7 @@ std::string TextTranscoder::on_untranslatable(const void**, size_t*) const {
TextTranscoderCustomSJISToUTF8::TextTranscoderCustomSJISToUTF8() : TextTranscoder("UTF-8", "SHIFT_JIS") {}
std::string encode_utf8_char(uint32_t ch) {
string ret;
std::string ret;
if (ch < 0x80) {
ret.push_back(ch);
} else if (ch < 0x800) {
@@ -152,14 +150,14 @@ std::string encode_utf8_char(uint32_t ch) {
ret.push_back(0x80 | ((ch >> 6) & 0x3F));
ret.push_back(0x80 | (ch & 0x3F));
} else {
throw runtime_error("unencodable Unicode code point");
throw std::runtime_error("unencodable Unicode code point");
}
return ret;
}
uint32_t decode_utf8_char(const void** vdata, size_t* size) {
if (*size == 0) {
throw runtime_error("incomplete UTF-8 character");
throw std::runtime_error("incomplete UTF-8 character");
}
const uint8_t* data = reinterpret_cast<const uint8_t*>(*vdata);
@@ -169,27 +167,27 @@ uint32_t decode_utf8_char(const void** vdata, size_t* size) {
return *data;
} else if ((data[0] & 0xE0) == 0xC0) {
if ((*size < 2) || ((data[1] & 0xC0) != 0x80)) {
throw runtime_error("incomplete UTF-8 character");
throw std::runtime_error("incomplete UTF-8 character");
}
(*size) -= 2;
*vdata = data + 2;
return ((data[0] & 0x1F) << 6) | (data[1] & 0x3F);
} else if ((data[0] & 0xF0) == 0xE0) {
if ((*size < 3) || ((data[1] & 0xC0) != 0x80) || ((data[2] & 0xC0) != 0x80)) {
throw runtime_error("incomplete UTF-8 character");
throw std::runtime_error("incomplete UTF-8 character");
}
(*size) -= 3;
*vdata = data + 3;
return ((data[0] & 0x0F) << 12) | ((data[1] & 0x3F) << 6) | (data[2] & 0x3F);
} else if ((data[0] & 0xF8) == 0xF0) {
if ((*size < 4) || ((data[1] & 0xC0) != 0x80) || ((data[2] & 0xC0) != 0x80) || ((data[3] & 0xC0) != 0x80)) {
throw runtime_error("incomplete UTF-8 character");
throw std::runtime_error("incomplete UTF-8 character");
}
(*size) -= 4;
*vdata = data + 4;
return ((data[0] & 0x07) << 18) | ((data[1] & 0x3F) << 12) | ((data[2] & 0x3F) << 6) | (data[3] & 0x3F);
} else {
throw runtime_error("invalid UTF-8 character");
throw std::runtime_error("invalid UTF-8 character");
}
}
@@ -208,7 +206,7 @@ std::string TextTranscoderCustomSJISToUTF8::on_untranslatable(const void** vsrc,
return "";
}
string ret;
std::string ret;
if (src[1] < 0x40) {
return "";
} else if (src[1] == 0x40) { // F040 -> U+2665
@@ -236,7 +234,7 @@ std::string TextTranscoderUTF8ToCustomSJIS::on_untranslatable(const void** src,
uint32_t ch;
try {
ch = decode_utf8_char(src, size);
} catch (const runtime_error&) {
} catch (const std::runtime_error&) {
return "";
}
@@ -245,11 +243,11 @@ std::string TextTranscoderUTF8ToCustomSJIS::on_untranslatable(const void** src,
} else if (ch == 0x24EA) { // U+24EA -> F041
return "\xF0\x41";
} else if (ch >= 0x2460 && ch <= 0x2468) { // U+2460-U+2468 -> F042-F04A
string ret("\xF0");
std::string ret("\xF0");
ret.push_back(0x42 + (ch - 0x2460));
return ret;
} else if (ch >= 0x1D4D0 && ch <= 0x1D4E9) { // U+1D4D0-U+1D4E9 -> F04B-F064
string ret("\xF0");
std::string ret("\xF0");
ret.push_back(0x4B + (ch - 0x1D4D0));
return ret;
} else {
@@ -270,29 +268,29 @@ TextTranscoder tt_utf8_to_utf16("UTF-16LE", "UTF-8");
TextTranscoder tt_ascii_to_utf8("UTF-8", "ASCII");
TextTranscoder tt_utf8_to_ascii("ASCII", "UTF-8");
string tt_encode_marked_optional(const string& utf8, Language default_language, bool is_utf16) {
std::string tt_encode_marked_optional(const std::string& utf8, Language default_language, bool is_utf16) {
if (is_utf16) {
return tt_utf8_to_utf16(utf8);
} else {
if (default_language == Language::JAPANESE) {
try {
return tt_utf8_to_sega_sjis(utf8);
} catch (const exception& e) {
} catch (const std::exception& e) {
return "\tE" + tt_utf8_to_8859(utf8);
}
} else {
try {
return tt_utf8_to_8859(utf8);
} catch (const exception& e) {
} catch (const std::exception& e) {
return "\tJ" + tt_utf8_to_sega_sjis(utf8);
}
}
}
}
string tt_encode_marked(const string& utf8, Language default_language, bool is_utf16) {
std::string tt_encode_marked(const std::string& utf8, Language default_language, bool is_utf16) {
if (is_utf16) {
string to_encode = "\t";
std::string to_encode = "\t";
to_encode += marker_for_language(default_language);
to_encode += utf8;
return tt_utf8_to_utf16(to_encode);
@@ -300,22 +298,22 @@ string tt_encode_marked(const string& utf8, Language default_language, bool is_u
if (default_language == Language::JAPANESE) {
try {
return "\tJ" + tt_utf8_to_sega_sjis(utf8);
} catch (const exception& e) {
} catch (const std::exception& e) {
return "\tE" + tt_utf8_to_8859(utf8);
}
} else {
try {
return "\tE" + tt_utf8_to_8859(utf8);
} catch (const exception& e) {
} catch (const std::exception& e) {
return "\tJ" + tt_utf8_to_sega_sjis(utf8);
}
}
}
}
string tt_decode_marked(const string& data, Language default_language, bool is_utf16) {
std::string tt_decode_marked(const std::string& data, Language default_language, bool is_utf16) {
if (is_utf16) {
string ret = tt_utf16_to_utf8(data);
std::string ret = tt_utf16_to_utf8(data);
if (ret.size() >= 2 && ret[0] == '\t' && is_language_marker_utf16(ret[1])) {
ret = ret.substr(2);
}
@@ -332,19 +330,19 @@ string tt_decode_marked(const string& data, Language default_language, bool is_u
}
}
string add_language_marker(const string& s, char marker) {
std::string add_language_marker(const std::string& s, char marker) {
if ((s.size() >= 2) && (s[0] == '\t') && (s[1] != 'C')) {
return s;
}
string ret;
std::string ret;
ret.push_back('\t');
ret.push_back(marker);
ret += s;
return ret;
}
string remove_language_marker(const string& s) {
std::string remove_language_marker(const std::string& s) {
if ((s.size() < 2) || (s[0] != '\t') || (s[1] == 'C')) {
return s;
}
@@ -394,7 +392,7 @@ size_t add_color_inplace(char* a, size_t max_chars) {
return d - orig_d;
}
void add_color_inplace(string& s) {
void add_color_inplace(std::string& s) {
s.resize(add_color_inplace(s.data(), s.size()));
}
@@ -425,7 +423,7 @@ void add_color(phosg::StringWriter& w, const char* src, size_t max_input_chars)
}
}
string add_color(const string& s) {
std::string add_color(const std::string& s) {
phosg::StringWriter w;
add_color(w, s.data(), s.size());
return std::move(w.str());
@@ -453,14 +451,14 @@ void remove_color(phosg::StringWriter& w, const char* src, size_t max_input_char
}
}
string remove_color(const string& s) {
std::string remove_color(const std::string& s) {
phosg::StringWriter w;
remove_color(w, s.data(), s.size());
return std::move(w.str());
}
string strip_color(const string& s) {
string ret;
std::string strip_color(const std::string& s) {
std::string ret;
for (size_t r = 0; r < s.size(); r++) {
if ((s[r] == '$' || s[r] == '\t') &&
(s[r + 1] == 'C') && (((s[r + 2] >= '0') && (s[r + 2] <= '9')) || (s[r + 2] == 'G') || (s[r + 2] == 'a'))) {
@@ -472,7 +470,7 @@ string strip_color(const string& s) {
return ret;
}
string escape_player_name(const string& name) {
std::string escape_player_name(const std::string& name) {
if (name.size() > 2 && name[0] == '\t' && name[1] != 'C') {
return remove_color(name.substr(2));
} else {