2023-01-17 10:09:00 +00:00
|
|
|
|
#pragma once
|
|
|
|
|
|
2023-01-18 07:16:59 +00:00
|
|
|
|
#include "lang/app_language.h"
|
2023-01-20 05:38:16 +00:00
|
|
|
|
#include "base_pak.h"
|
2023-01-17 10:09:00 +00:00
|
|
|
|
|
|
|
|
|
#if defined(_WIN32) || defined(_WIN64)
|
|
|
|
|
#define PATH_SEPERATOR "\\"
|
|
|
|
|
#define THIS_MODULE_NAME "lang.dll"
|
|
|
|
|
#else
|
2023-01-20 05:38:16 +00:00
|
|
|
|
#include <string.h> // for strcasecmp
|
2023-01-17 10:09:00 +00:00
|
|
|
|
#define PATH_SEPERATOR "/"
|
|
|
|
|
#define THIS_MODULE_NAME "lang.so"
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#include <string>
|
|
|
|
|
#include <vector>
|
|
|
|
|
#include <map>
|
|
|
|
|
#include <algorithm>
|
|
|
|
|
#include <locale.h>
|
2023-01-19 07:44:47 +00:00
|
|
|
|
#include <thread>
|
2023-01-17 10:09:00 +00:00
|
|
|
|
|
2023-01-18 10:04:16 +00:00
|
|
|
|
namespace util
|
|
|
|
|
{
|
|
|
|
|
const uint32_t crc_table[256] = {
|
|
|
|
|
0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
|
|
|
|
|
0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
|
|
|
|
|
0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
|
|
|
|
|
0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
|
|
|
|
|
0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
|
|
|
|
|
0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
|
|
|
|
|
0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
|
|
|
|
|
0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
|
|
|
|
|
0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
|
|
|
|
|
0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
|
|
|
|
|
0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
|
|
|
|
|
0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
|
|
|
|
|
0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
|
|
|
|
|
0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
|
|
|
|
|
0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
|
|
|
|
|
0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
|
|
|
|
|
0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
|
|
|
|
|
0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
|
|
|
|
|
0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
|
|
|
|
|
0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
|
|
|
|
|
0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
|
|
|
|
|
0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
|
|
|
|
|
0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
|
|
|
|
|
0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
|
|
|
|
|
0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
|
|
|
|
|
0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
|
|
|
|
|
0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
|
|
|
|
|
0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
|
|
|
|
|
0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
|
|
|
|
|
0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
|
|
|
|
|
0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
|
|
|
|
|
0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
|
|
|
|
|
0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
|
|
|
|
|
0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
|
|
|
|
|
0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
|
|
|
|
|
0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
|
|
|
|
|
0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
|
|
|
|
|
0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
|
|
|
|
|
0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
|
|
|
|
|
0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
|
|
|
|
|
0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
|
|
|
|
|
0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
|
|
|
|
|
0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
|
|
|
|
|
0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
|
|
|
|
|
0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
|
|
|
|
|
0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
|
|
|
|
|
0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
|
|
|
|
|
0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
|
|
|
|
|
0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
|
|
|
|
|
0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
|
|
|
|
|
0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
|
|
|
|
|
0x2d02ef8dL
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define CRC32(c, b) (crc_table[((int)(c) ^ (b)) & 0xff] ^ ((c) >> 8))
|
|
|
|
|
#define DO1(buf) crc = CRC32(crc, *buf++)
|
|
|
|
|
#define DO2(buf) DO1(buf); DO1(buf)
|
|
|
|
|
#define DO4(buf) DO2(buf); DO2(buf)
|
|
|
|
|
#define DO8(buf) DO4(buf); DO4(buf)
|
|
|
|
|
|
|
|
|
|
uint32_t crc32(uint32_t crc, const uint8_t* buf, uint32_t len)
|
|
|
|
|
{
|
|
|
|
|
if (buf == NULL) return 0L;
|
|
|
|
|
crc = crc ^ 0xffffffffL;
|
|
|
|
|
while (len >= 8) { DO8(buf); len -= 8; }
|
|
|
|
|
if (len) do { DO1(buf); } while (--len);
|
|
|
|
|
|
|
|
|
|
return crc ^ 0xffffffffL; // (instead of ~c for 64-bit machines)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
};
|
|
|
|
|
|
2023-01-17 10:09:00 +00:00
|
|
|
|
// *.pak ...
|
|
|
|
|
//typedef struct _lang_pak
|
|
|
|
|
//{
|
|
|
|
|
// uint32_t len;
|
|
|
|
|
// uint32_t crc; // crc check ...
|
|
|
|
|
// uint32_t ver;
|
|
|
|
|
// uint32_t* cps[]; // supported code-pages table offset, until '-1'
|
|
|
|
|
// struct
|
|
|
|
|
// {
|
|
|
|
|
// uint32_t name_id;
|
|
|
|
|
// char name[0];
|
|
|
|
|
// }*name[]; // my name on my code-page
|
|
|
|
|
// ENDING address align 16 before
|
|
|
|
|
//
|
|
|
|
|
// struct
|
|
|
|
|
// {
|
|
|
|
|
// uint32_t id;
|
|
|
|
|
// uint32_t offset; // offset to the first structure
|
|
|
|
|
// }str_map[]; // Offset of corresponding ID string, until id == -1
|
|
|
|
|
//};
|
|
|
|
|
struct _cp_locale
|
|
|
|
|
{
|
|
|
|
|
int cp;
|
|
|
|
|
const char* locale;
|
|
|
|
|
}g_known_locale[] =
|
2023-01-20 05:38:16 +00:00
|
|
|
|
{ {DEFAULT_CODE_PAGE, "zh_CN"}
|
2023-01-17 10:09:00 +00:00
|
|
|
|
, {950, "zh_HK"}
|
|
|
|
|
, {950, "zh_TW"}
|
|
|
|
|
, {950, "zh_SG"}
|
|
|
|
|
, {20127, "en_"}
|
|
|
|
|
, {932, "ja_JP"}
|
|
|
|
|
, {863, "fr_"}
|
|
|
|
|
, {1144, "it_CH"}
|
|
|
|
|
, {1141, "de_"}
|
|
|
|
|
, {855, "ru_RU"}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
class lang_mgr
|
|
|
|
|
{
|
|
|
|
|
typedef struct _map_str
|
|
|
|
|
{
|
|
|
|
|
uint32_t name_id; // global unique
|
|
|
|
|
std::vector<int> code_pages;
|
|
|
|
|
std::string name;
|
|
|
|
|
std::string file;
|
|
|
|
|
|
|
|
|
|
bool operator==(int cp)
|
|
|
|
|
{
|
|
|
|
|
return std::find(code_pages.begin(), code_pages.end(), cp) != code_pages.end();
|
|
|
|
|
}
|
|
|
|
|
}MAPSTR;
|
2023-01-19 07:44:47 +00:00
|
|
|
|
typedef struct _chg_notify
|
|
|
|
|
{
|
|
|
|
|
void(*notify)(int code_page, void* param);
|
|
|
|
|
void* param;
|
|
|
|
|
bool operator==(void(*ntfy)(int code_page, void* param))
|
|
|
|
|
{
|
|
|
|
|
return notify == ntfy;
|
|
|
|
|
}
|
|
|
|
|
}CHGNOTIFY;
|
|
|
|
|
std::vector<CHGNOTIFY> notify_;
|
2023-01-17 10:09:00 +00:00
|
|
|
|
|
2023-01-19 07:44:47 +00:00
|
|
|
|
volatile bool in_changing_;
|
2023-01-17 10:09:00 +00:00
|
|
|
|
std::vector<MAPSTR> code_pages_;
|
2023-01-20 05:38:16 +00:00
|
|
|
|
LANATTR** all_;
|
2023-01-17 10:09:00 +00:00
|
|
|
|
uint32_t os_cp_;
|
|
|
|
|
uint32_t cur_cp_;
|
|
|
|
|
std::string cur_lang_;
|
|
|
|
|
std::map<uint32_t, std::string> map_off_;
|
|
|
|
|
|
|
|
|
|
static lang_mgr* inst_;
|
2023-01-20 05:38:16 +00:00
|
|
|
|
MAPSTR cp_default_;
|
|
|
|
|
std::map<uint32_t, std::string> map_default_;
|
|
|
|
|
std::map<uint32_t, std::string>* pak_now_;
|
|
|
|
|
|
2023-01-17 10:09:00 +00:00
|
|
|
|
|
|
|
|
|
void clear(void)
|
|
|
|
|
{
|
|
|
|
|
map_off_.clear();
|
|
|
|
|
cur_lang_.clear();
|
|
|
|
|
cur_cp_ = -1;
|
|
|
|
|
}
|
|
|
|
|
uint32_t calculate_crc32(uint8_t* data, uint32_t len, uint32_t prev = 0)
|
|
|
|
|
{
|
2023-01-18 10:04:16 +00:00
|
|
|
|
return util::crc32(prev, data, len);
|
2023-01-17 10:09:00 +00:00
|
|
|
|
}
|
|
|
|
|
uint32_t get_cur_code_page_id(void)
|
|
|
|
|
{
|
|
|
|
|
return os_cp_;
|
|
|
|
|
}
|
2023-01-18 10:04:16 +00:00
|
|
|
|
bool parse_pak_digest(uint8_t* data, MAPSTR& ms, int* id)
|
2023-01-17 10:09:00 +00:00
|
|
|
|
{
|
|
|
|
|
uint32_t ver = *(uint32_t*)data,
|
2023-01-20 05:38:16 +00:00
|
|
|
|
val = 0,
|
|
|
|
|
* cps = (uint32_t*)(data + sizeof(uint32_t) * 3);
|
2023-01-17 10:09:00 +00:00
|
|
|
|
|
2023-01-18 10:04:16 +00:00
|
|
|
|
if (id)
|
|
|
|
|
*id = *cps;
|
2023-01-17 10:09:00 +00:00
|
|
|
|
while (*cps != -1)
|
|
|
|
|
{
|
|
|
|
|
ms.code_pages.push_back(*cps++);
|
|
|
|
|
}
|
|
|
|
|
if (ms.code_pages.empty())
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
cps++;
|
|
|
|
|
ms.name_id = *cps++;
|
|
|
|
|
val = (uint8_t*)cps - data;
|
|
|
|
|
ms.name = (char*)data + val;
|
|
|
|
|
|
|
|
|
|
return ms.name.length() ? true : false;
|
|
|
|
|
}
|
|
|
|
|
bool parse_pak(uint8_t* data, uint32_t* bgn, uint32_t* id, std::map<uint32_t, std::string>& off)
|
|
|
|
|
{
|
|
|
|
|
uint32_t ver = *(uint32_t*)data,
|
2023-01-20 05:38:16 +00:00
|
|
|
|
val = 0,
|
|
|
|
|
* cps = (uint32_t*)(data + sizeof(uint32_t) * 3);
|
2023-01-17 10:09:00 +00:00
|
|
|
|
|
|
|
|
|
if (id)
|
|
|
|
|
*id = cps[0];
|
|
|
|
|
while (*cps++ != -1);
|
|
|
|
|
cps++;
|
|
|
|
|
val = (uint8_t*)cps - data;
|
|
|
|
|
val += strlen((char*)data + val) + 1;
|
|
|
|
|
val += 15;
|
|
|
|
|
val /= 16;
|
|
|
|
|
val *= 16;
|
|
|
|
|
if (bgn)
|
|
|
|
|
*bgn = val;
|
|
|
|
|
|
|
|
|
|
struct
|
|
|
|
|
{
|
|
|
|
|
uint32_t id;
|
|
|
|
|
uint32_t off;
|
|
|
|
|
}*go = nullptr;
|
|
|
|
|
*((void**)&go) = (void*)(data + val);
|
|
|
|
|
while (go->id != -1)
|
|
|
|
|
{
|
|
|
|
|
off[go->id] = (char*)data + go->off + val;
|
|
|
|
|
go++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
bool load_language_pak(const char* file, bool at_init)
|
|
|
|
|
{
|
|
|
|
|
std::string cont(""), name("");
|
|
|
|
|
uint32_t bgn = 0, id = 0, cur_id = -1;
|
|
|
|
|
bool ret = false;
|
2023-01-20 05:38:16 +00:00
|
|
|
|
FILE* src = fopen(file, "rb");
|
2023-01-17 10:09:00 +00:00
|
|
|
|
std::map<uint32_t, std::string> off;
|
2023-01-20 05:38:16 +00:00
|
|
|
|
|
2023-01-17 10:09:00 +00:00
|
|
|
|
if (src)
|
|
|
|
|
{
|
|
|
|
|
int len = 0;
|
|
|
|
|
uint8_t* buf = nullptr;
|
|
|
|
|
|
|
|
|
|
fseek(src, 0, SEEK_END);
|
|
|
|
|
len = ftell(src);
|
|
|
|
|
fseek(src, 0, SEEK_SET);
|
|
|
|
|
if (len)
|
|
|
|
|
{
|
|
|
|
|
buf = new uint8_t[len + 4];
|
|
|
|
|
if (buf)
|
|
|
|
|
{
|
|
|
|
|
memset(buf, 0, len + 4);
|
|
|
|
|
len = fread(buf, 1, len, src);
|
2023-01-20 05:38:16 +00:00
|
|
|
|
if (len == *(uint32_t*)buf
|
|
|
|
|
&& calculate_crc32(buf + sizeof(uint32_t) * 2, len - sizeof(uint32_t) * 2) == ((uint32_t*)buf)[1])
|
2023-01-17 10:09:00 +00:00
|
|
|
|
{
|
|
|
|
|
cont = std::string((char*)buf, len);
|
|
|
|
|
}
|
|
|
|
|
delete[] buf;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
fclose(src);
|
|
|
|
|
}
|
|
|
|
|
if (cont.length())
|
|
|
|
|
{
|
|
|
|
|
if (at_init)
|
|
|
|
|
{
|
|
|
|
|
MAPSTR ms;
|
2023-01-20 05:38:16 +00:00
|
|
|
|
|
2023-01-17 10:09:00 +00:00
|
|
|
|
ms.file = file;
|
|
|
|
|
cur_id = get_cur_code_page_id();
|
2023-01-20 05:38:16 +00:00
|
|
|
|
if (parse_pak_digest((uint8_t*)&cont[0], ms, (int*)&id))
|
2023-01-17 10:09:00 +00:00
|
|
|
|
{
|
2023-01-20 05:38:16 +00:00
|
|
|
|
if (id == DEFAULT_CODE_PAGE)
|
|
|
|
|
cp_default_ = ms;
|
|
|
|
|
else
|
|
|
|
|
code_pages_.push_back(std::move(ms));
|
2023-01-17 10:09:00 +00:00
|
|
|
|
if (cur_id == id && map_off_.size() == 0)
|
|
|
|
|
{
|
|
|
|
|
ret = parse_pak((uint8_t*)&cont[0], &bgn, &id, off);
|
|
|
|
|
if (ret)
|
|
|
|
|
name = ms.name;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
ret = parse_pak((uint8_t*)&cont[0], &bgn, &id, off);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ret && ((at_init && cur_id == id) || !at_init))
|
|
|
|
|
{
|
|
|
|
|
clear();
|
|
|
|
|
cur_cp_ = id;
|
|
|
|
|
cur_lang_ = std::move(name);
|
2023-01-20 05:38:16 +00:00
|
|
|
|
if (cur_cp_ == DEFAULT_CODE_PAGE)
|
|
|
|
|
{
|
|
|
|
|
map_default_ = std::move(off);
|
|
|
|
|
pak_now_ = &map_default_;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
map_off_ = std::move(off);
|
|
|
|
|
pak_now_ = &map_off_;
|
|
|
|
|
}
|
2023-01-17 10:09:00 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2023-01-19 07:44:47 +00:00
|
|
|
|
void notify_changed(void)
|
|
|
|
|
{
|
|
|
|
|
for (auto& v : notify_)
|
|
|
|
|
v.notify(cur_cp_, v.param);
|
|
|
|
|
}
|
2023-01-17 10:09:00 +00:00
|
|
|
|
|
|
|
|
|
#if defined(_WIN32) || defined(_WIN64)
|
|
|
|
|
static std::string u2a(const wchar_t* u, UINT cp = CP_ACP)
|
|
|
|
|
{
|
|
|
|
|
std::string a("");
|
|
|
|
|
|
|
|
|
|
if (u)
|
|
|
|
|
{
|
|
|
|
|
char stack[256] = { 0 }, * ansi = NULL;
|
|
|
|
|
int len = 0;
|
|
|
|
|
|
|
|
|
|
len = WideCharToMultiByte(cp, 0, u, lstrlenW(u), NULL, 0, NULL, NULL);
|
|
|
|
|
ansi = new char[len + 2];
|
|
|
|
|
len = WideCharToMultiByte(cp, 0, u, lstrlenW(u), ansi, len, NULL, NULL);
|
|
|
|
|
ansi[len--] = 0;
|
|
|
|
|
a = ansi;
|
|
|
|
|
delete[] ansi;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return a;
|
|
|
|
|
}
|
|
|
|
|
static std::wstring a2u(const char* a, UINT cp = CP_ACP)
|
|
|
|
|
{
|
|
|
|
|
std::wstring u(L"");
|
|
|
|
|
|
|
|
|
|
if (a)
|
|
|
|
|
{
|
2023-01-20 05:38:16 +00:00
|
|
|
|
wchar_t* unic = NULL;
|
2023-01-17 10:09:00 +00:00
|
|
|
|
int len = 0;
|
|
|
|
|
|
|
|
|
|
len = MultiByteToWideChar(cp, 0, a, lstrlenA(a), NULL, 0);
|
|
|
|
|
unic = new wchar_t[len + 2];
|
|
|
|
|
len = MultiByteToWideChar(cp, 0, a, lstrlenA(a), unic, len + 1);
|
|
|
|
|
unic[len--] = 0;
|
|
|
|
|
u = unic;
|
|
|
|
|
delete[] unic;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return u;
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
static std::string link_file(const char* lnk)
|
|
|
|
|
{
|
|
|
|
|
char path[512] = { 0 };
|
|
|
|
|
int len = readlink(lnk, path, sizeof(path) - 1);
|
|
|
|
|
|
|
|
|
|
return path;
|
|
|
|
|
}
|
|
|
|
|
static bool found_module(const char* file, void* param)
|
|
|
|
|
{
|
|
|
|
|
std::string* str = (std::string*)param;
|
|
|
|
|
const char* n = strrchr(file, PATH_SEPERATOR[0]);
|
|
|
|
|
|
|
|
|
|
if (n++ == nullptr)
|
|
|
|
|
n = file;
|
|
|
|
|
if (strcasecmp(str->c_str(), n) == 0)
|
|
|
|
|
{
|
|
|
|
|
*str = file;
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
int enum_files(const char* dir, bool(*on_found)(const char*, void*), void* param, bool recursive = true)
|
|
|
|
|
{
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
#if defined(_WIN32) || defined(_WIN64)
|
|
|
|
|
std::wstring root(a2u(dir, CP_UTF8) + L"\\");
|
|
|
|
|
WIN32_FIND_DATAW fd = { 0 };
|
2023-01-20 05:38:16 +00:00
|
|
|
|
HANDLE h = FindFirstFileW((a2u(dir, CP_UTF8) + L"\\*.pak").c_str(), &fd);
|
2023-01-17 10:09:00 +00:00
|
|
|
|
if (h == INVALID_HANDLE_VALUE)
|
|
|
|
|
return GetLastError();
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
|
|
|
{
|
|
|
|
|
if (recursive && wcscmp(fd.cFileName, L".") && wcscmp(fd.cFileName, L".."))
|
|
|
|
|
{
|
|
|
|
|
ret = enum_files(u2a((root + fd.cFileName).c_str(), CP_UTF8).c_str(), on_found, param, recursive);
|
|
|
|
|
if (ret == ERROR_CANCELLED)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (!on_found(u2a((root + fd.cFileName).c_str(), CP_UTF8).c_str(), param))
|
|
|
|
|
{
|
|
|
|
|
ret = ERROR_CANCELLED;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
} while (FindNextFileW(h, &fd));
|
|
|
|
|
FindClose(h);
|
|
|
|
|
#else
|
|
|
|
|
DIR* pdir = nullptr;
|
|
|
|
|
struct dirent* ent = nullptr;
|
|
|
|
|
|
|
|
|
|
pdir = opendir(dir);
|
|
|
|
|
if (!pdir)
|
|
|
|
|
return errno;
|
|
|
|
|
|
|
|
|
|
while ((ent = readdir(pdir)))
|
|
|
|
|
{
|
|
|
|
|
if (ent->d_type & DT_DIR)
|
|
|
|
|
{
|
|
|
|
|
if (recursive)
|
|
|
|
|
{
|
|
|
|
|
if (strcmp(ent->d_name, ".") && strcmp(ent->d_name, ".."))
|
|
|
|
|
{
|
|
|
|
|
std::string sub(dir);
|
|
|
|
|
sub += "/";
|
|
|
|
|
sub += ent->d_name;
|
2023-01-29 07:27:20 +00:00
|
|
|
|
ret = enum_files(sub.c_str(), on_found, param, recursive);
|
2023-01-17 10:09:00 +00:00
|
|
|
|
if (ret == 0x5e17)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2023-01-20 05:38:16 +00:00
|
|
|
|
char* ext = strrchr(ent->d_name, '.');
|
|
|
|
|
if (ext && strcasecmp(ext, ".pak") == 0)
|
2023-01-17 10:09:00 +00:00
|
|
|
|
{
|
2023-01-20 05:38:16 +00:00
|
|
|
|
std::string file(dir);
|
|
|
|
|
|
|
|
|
|
file += "/";
|
|
|
|
|
file += ent->d_name;
|
2023-01-29 07:27:20 +00:00
|
|
|
|
if (!on_found(link_file(file.c_str()).c_str(), param))
|
2023-01-20 05:38:16 +00:00
|
|
|
|
{
|
|
|
|
|
ret = 0x5e17;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2023-01-17 10:09:00 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
static bool found_language_pak(const char* file, void* obj)
|
|
|
|
|
{
|
|
|
|
|
((lang_mgr*)obj)->load_language_pak(file, true);
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
std::string get_module_path(void)
|
|
|
|
|
{
|
|
|
|
|
#if defined(_WIN32) || defined(_WIN64)
|
|
|
|
|
wchar_t path[MAX_PATH] = { 0 };
|
|
|
|
|
|
|
|
|
|
GetModuleFileNameW(GetModuleHandleA(THIS_MODULE_NAME), path, _countof(path) - 1);
|
|
|
|
|
|
|
|
|
|
return u2a(path, CP_UTF8);
|
|
|
|
|
#else
|
|
|
|
|
char path[256] = { 0 };
|
|
|
|
|
std::string ret(THIS_MODULE_NAME);
|
|
|
|
|
|
|
|
|
|
sprintf(path, "/proc/%u/map_files", getpid());
|
|
|
|
|
enum_files(path, &lang_mgr::found_module, &ret);
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-20 05:38:16 +00:00
|
|
|
|
lang_mgr() : os_cp_(lang_mgr::get_os_code_page()), cur_cp_(-1), cur_lang_(""), all_(nullptr), in_changing_(true), pak_now_(&map_off_)
|
2023-01-17 10:09:00 +00:00
|
|
|
|
{
|
|
|
|
|
std::string path(get_module_path());
|
|
|
|
|
size_t pos = path.rfind(PATH_SEPERATOR[0]);
|
|
|
|
|
char *str = nullptr;
|
|
|
|
|
LANATTR *st = nullptr;
|
|
|
|
|
int ind = 0;
|
|
|
|
|
|
|
|
|
|
if (pos++ == std::string::npos)
|
|
|
|
|
pos = 0;
|
|
|
|
|
path.erase(pos);
|
|
|
|
|
path += "lang";
|
2023-01-20 05:38:16 +00:00
|
|
|
|
parse_pak_digest(g_chinese, cp_default_, nullptr);
|
|
|
|
|
parse_pak(g_chinese, nullptr, nullptr, map_default_);
|
2023-01-17 10:09:00 +00:00
|
|
|
|
enum_files(path.c_str(), &lang_mgr::found_language_pak, this, false);
|
|
|
|
|
|
|
|
|
|
size_t len = sizeof(LANATTR*) * (code_pages_.size() + 1) + sizeof(LANATTR) * code_pages_.size();
|
|
|
|
|
|
|
|
|
|
pos = len;
|
|
|
|
|
for (const auto& v: code_pages_)
|
|
|
|
|
{
|
|
|
|
|
len += v.name.length() + 4;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
all_ = (LANATTR**)new char[len];
|
|
|
|
|
memset(all_, 0, len);
|
|
|
|
|
str = (char*)all_ + pos;
|
|
|
|
|
st = (LANATTR*)((char*)all_ + sizeof(LANATTR*) * (code_pages_.size() + 1));
|
|
|
|
|
for (const auto& v : code_pages_)
|
|
|
|
|
{
|
|
|
|
|
all_[ind++] = st;
|
|
|
|
|
st->cp = v.code_pages[0];
|
|
|
|
|
st->name = str;
|
2023-01-20 05:38:16 +00:00
|
|
|
|
st->id = v.name_id;
|
2023-01-17 10:09:00 +00:00
|
|
|
|
strcpy(str, v.name.c_str());
|
|
|
|
|
str += v.name.length() + 2;
|
|
|
|
|
st++;
|
|
|
|
|
}
|
2023-01-20 05:38:16 +00:00
|
|
|
|
|
|
|
|
|
if (map_off_.empty())
|
|
|
|
|
{
|
|
|
|
|
// system language pak not found, reset to DEFAULT_CODE_PAGE or first ...
|
|
|
|
|
cur_cp_ = DEFAULT_CODE_PAGE;
|
|
|
|
|
pak_now_ = &map_default_;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-19 07:44:47 +00:00
|
|
|
|
in_changing_ = false;
|
2023-01-17 10:09:00 +00:00
|
|
|
|
}
|
|
|
|
|
~lang_mgr()
|
|
|
|
|
{
|
|
|
|
|
delete[](char*)all_;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
static int get_os_code_page(void)
|
|
|
|
|
{
|
|
|
|
|
char* locale = setlocale(LC_ALL, "");
|
2023-01-20 05:38:16 +00:00
|
|
|
|
int cp = DEFAULT_CODE_PAGE;
|
2023-01-17 10:09:00 +00:00
|
|
|
|
|
|
|
|
|
if (locale)
|
|
|
|
|
{
|
|
|
|
|
char* end = nullptr;
|
|
|
|
|
bool found = false;
|
|
|
|
|
|
|
|
|
|
if (strstr(locale, "LC_CTYPE="))
|
|
|
|
|
locale = strstr(locale, "LC_CTYPE=") + strlen("LC_CTYPE");
|
|
|
|
|
end = strstr(locale, ";");
|
|
|
|
|
if (end)
|
|
|
|
|
*end = 0;
|
|
|
|
|
for (int i = 0; i < sizeof(g_known_locale) / sizeof(g_known_locale[0]); ++i)
|
|
|
|
|
{
|
|
|
|
|
if (strstr(locale, g_known_locale[i].locale))
|
|
|
|
|
{
|
|
|
|
|
cp = g_known_locale[i].cp;
|
|
|
|
|
found = true;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (!found && strrchr(locale, '.'))
|
|
|
|
|
{
|
2023-01-20 05:38:16 +00:00
|
|
|
|
// windows: Chinese (Simplified)_China.DEFAULT_CODE_PAGE
|
2023-01-17 10:09:00 +00:00
|
|
|
|
locale = strrchr(locale, '.') + 1;
|
|
|
|
|
if (*locale >= '0' && *locale <= '9')
|
|
|
|
|
cp = atoi(locale);
|
|
|
|
|
}
|
2023-01-20 05:38:16 +00:00
|
|
|
|
if(end)
|
|
|
|
|
*end = ';';
|
2023-01-17 10:09:00 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return cp;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
static lang_mgr* instance(void)
|
|
|
|
|
{
|
|
|
|
|
if (!lang_mgr::inst_)
|
|
|
|
|
lang_mgr::inst_ = new lang_mgr();
|
|
|
|
|
|
|
|
|
|
return lang_mgr::inst_;
|
|
|
|
|
}
|
|
|
|
|
int get_cur_cp(void)
|
|
|
|
|
{
|
|
|
|
|
return cur_cp_;
|
|
|
|
|
}
|
|
|
|
|
std::string get_cur_name(void)
|
|
|
|
|
{
|
|
|
|
|
return cur_lang_;
|
|
|
|
|
}
|
|
|
|
|
LANATTR** get_all(void)
|
|
|
|
|
{
|
|
|
|
|
return all_;
|
|
|
|
|
}
|
|
|
|
|
int set_code_page(int cp)
|
|
|
|
|
{
|
|
|
|
|
if (cp == 0)
|
|
|
|
|
cp = lang_mgr::get_os_code_page();
|
|
|
|
|
if (cp == cur_cp_)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2023-01-20 05:38:16 +00:00
|
|
|
|
bool changed = true;
|
|
|
|
|
if (cp == DEFAULT_CODE_PAGE)
|
|
|
|
|
{
|
|
|
|
|
pak_now_ = &map_default_;
|
|
|
|
|
cur_cp_ = cp;
|
|
|
|
|
cur_lang_ = cp_default_.name;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
std::vector<MAPSTR>::iterator it = std::find(code_pages_.begin(), code_pages_.end(), cp);
|
|
|
|
|
if (it == code_pages_.end())
|
|
|
|
|
return ENOENT;
|
2023-01-17 10:09:00 +00:00
|
|
|
|
|
2023-01-20 05:38:16 +00:00
|
|
|
|
std::string f(it->file);
|
2023-01-19 07:44:47 +00:00
|
|
|
|
|
2023-01-20 05:38:16 +00:00
|
|
|
|
in_changing_ = true;
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(50));
|
2023-01-19 07:44:47 +00:00
|
|
|
|
|
2023-01-20 05:38:16 +00:00
|
|
|
|
cp = cur_cp_;
|
|
|
|
|
load_language_pak(f.c_str(), false);
|
|
|
|
|
in_changing_ = false;
|
|
|
|
|
changed = cp != cur_cp_;
|
|
|
|
|
}
|
2023-01-19 07:44:47 +00:00
|
|
|
|
|
2023-01-20 05:38:16 +00:00
|
|
|
|
if (changed)
|
2023-01-19 07:44:47 +00:00
|
|
|
|
notify_changed();
|
2023-01-17 10:09:00 +00:00
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2023-01-20 05:38:16 +00:00
|
|
|
|
const char* get_string(uint32_t id, int* err, bool def)
|
2023-01-17 10:09:00 +00:00
|
|
|
|
{
|
2023-01-19 07:44:47 +00:00
|
|
|
|
int cnt = 0;
|
|
|
|
|
while (in_changing_)
|
|
|
|
|
{
|
|
|
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
|
|
|
|
if (cnt++ > 100)
|
|
|
|
|
return "";
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-20 05:38:16 +00:00
|
|
|
|
std::map<uint32_t, std::string>* pak = def ? &map_default_ : pak_now_;
|
|
|
|
|
if ((*pak)[id].size())
|
2023-01-17 10:09:00 +00:00
|
|
|
|
{
|
|
|
|
|
if (err)
|
|
|
|
|
*err = 0;
|
|
|
|
|
|
2023-01-20 05:38:16 +00:00
|
|
|
|
return (*pak)[id].c_str();
|
2023-01-17 10:09:00 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (err)
|
|
|
|
|
*err = ENOENT;
|
|
|
|
|
|
|
|
|
|
return "";
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
int supported_cps(void)
|
|
|
|
|
{
|
2023-01-20 05:38:16 +00:00
|
|
|
|
return code_pages_.size() + 1;
|
2023-01-17 10:09:00 +00:00
|
|
|
|
}
|
2023-01-19 07:44:47 +00:00
|
|
|
|
void register_language_changed_notify(void(*lan_changed)(int code_page, void* param), bool reg, void* param = nullptr)
|
|
|
|
|
{
|
|
|
|
|
std::vector<CHGNOTIFY>::iterator it = std::find(notify_.begin(), notify_.end(), lan_changed);
|
|
|
|
|
|
|
|
|
|
if (it == notify_.end())
|
|
|
|
|
{
|
|
|
|
|
if (reg)
|
|
|
|
|
{
|
|
|
|
|
CHGNOTIFY c;
|
|
|
|
|
c.notify = lan_changed;
|
|
|
|
|
c.param = param;
|
|
|
|
|
notify_.push_back(c);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (reg)
|
|
|
|
|
it->param = param;
|
|
|
|
|
else
|
|
|
|
|
notify_.erase(it);
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-01-28 01:28:46 +00:00
|
|
|
|
int get_string_id(const char* str, bool def)
|
2023-01-20 05:38:16 +00:00
|
|
|
|
{
|
2023-01-28 01:28:46 +00:00
|
|
|
|
std::map<uint32_t, std::string>* lang = def ? &map_default_ : pak_now_;
|
|
|
|
|
|
2023-01-28 07:19:51 +00:00
|
|
|
|
while (*str == ' ')
|
|
|
|
|
str++;
|
|
|
|
|
|
2023-01-28 01:28:46 +00:00
|
|
|
|
for (auto& v : *lang)
|
2023-01-20 05:38:16 +00:00
|
|
|
|
{
|
|
|
|
|
if (v.second == str)
|
|
|
|
|
return v.first;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
2023-01-28 01:28:46 +00:00
|
|
|
|
const char* transform_language(const char* in, bool to_def, bool* found)
|
|
|
|
|
{
|
|
|
|
|
if (cur_cp_ == DEFAULT_CODE_PAGE)
|
|
|
|
|
{
|
|
|
|
|
if (found)
|
|
|
|
|
*found = true;
|
|
|
|
|
|
|
|
|
|
return in;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-29 07:02:52 +00:00
|
|
|
|
int id = get_string_id(in, !to_def);
|
2023-01-28 01:28:46 +00:00
|
|
|
|
std::map<uint32_t, std::string>* t = to_def ? &map_default_ : pak_now_;
|
|
|
|
|
|
|
|
|
|
if (id == -1)
|
|
|
|
|
{
|
|
|
|
|
if (found)
|
|
|
|
|
*found = false;
|
|
|
|
|
|
|
|
|
|
return in;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (t->count(id))
|
|
|
|
|
{
|
|
|
|
|
if (found)
|
|
|
|
|
*found = true;
|
|
|
|
|
|
|
|
|
|
return (*t)[id].c_str();
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (found)
|
|
|
|
|
*found = false;
|
|
|
|
|
|
|
|
|
|
return in;
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-01-17 10:09:00 +00:00
|
|
|
|
};
|
|
|
|
|
lang_mgr* lang_mgr::inst_ = nullptr;
|
|
|
|
|
|
|
|
|
|
extern "C"
|
|
|
|
|
{
|
|
|
|
|
int lang_initialize(void* param)
|
|
|
|
|
{
|
|
|
|
|
if (lang_mgr::instance()->supported_cps() > 0)
|
|
|
|
|
return lang_mgr::instance()->get_cur_cp();
|
|
|
|
|
else
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
LANATTR** lang_get_supported_languages(void)
|
|
|
|
|
{
|
|
|
|
|
return lang_mgr::instance()->get_all();
|
|
|
|
|
}
|
|
|
|
|
int lang_get_cur_code_page(void)
|
|
|
|
|
{
|
|
|
|
|
return lang_mgr::instance()->get_cur_cp();
|
|
|
|
|
}
|
|
|
|
|
int lang_set_code_page(int cp)
|
|
|
|
|
{
|
|
|
|
|
return lang_mgr::instance()->set_code_page(cp);
|
|
|
|
|
}
|
2023-01-20 05:38:16 +00:00
|
|
|
|
const char* lang_load_string(uint32_t id, int* err, bool def)
|
2023-01-17 10:09:00 +00:00
|
|
|
|
{
|
2023-01-20 05:38:16 +00:00
|
|
|
|
return lang_mgr::instance()->get_string(id, err, def);
|
2023-01-17 10:09:00 +00:00
|
|
|
|
}
|
2023-01-19 07:44:47 +00:00
|
|
|
|
void register_language_changed_notify(void(*lan_changed)(int code_page, void* param), bool reg, void* param)
|
|
|
|
|
{
|
|
|
|
|
lang_mgr::instance()->register_language_changed_notify(lan_changed, reg, param);
|
|
|
|
|
}
|
2023-01-20 05:38:16 +00:00
|
|
|
|
|
2023-01-28 01:28:46 +00:00
|
|
|
|
int lang_get_string_id(const char* str, bool def_lang)
|
|
|
|
|
{
|
|
|
|
|
return lang_mgr::instance()->get_string_id(str, def_lang);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char* to_default_language(const char* str, bool* ok)
|
|
|
|
|
{
|
|
|
|
|
return lang_mgr::instance()->transform_language(str, true, ok);
|
|
|
|
|
}
|
|
|
|
|
const char* from_default_language(const char* str, bool* ok)
|
2023-01-20 05:38:16 +00:00
|
|
|
|
{
|
2023-01-28 01:28:46 +00:00
|
|
|
|
return lang_mgr::instance()->transform_language(str, false, ok);
|
2023-01-20 05:38:16 +00:00
|
|
|
|
}
|
2023-01-17 10:09:00 +00:00
|
|
|
|
}
|