static HRESULT lcid_to_rfc1766(LCID lcid, WCHAR *rfc1766, INT len)
{
WCHAR buffer[6 /* MAX_RFC1766_NAME */];
INT n = GetLocaleInfoW(lcid, LOCALE_SISO639LANGNAME, buffer, ARRAY_SIZE(buffer));
INT i;
if (n)
{
i = PRIMARYLANGID(lcid);
if ((((i == LANG_ENGLISH) || (i == LANG_CHINESE) || (i == LANG_ARABIC)) &&
(SUBLANGID(lcid) == SUBLANG_DEFAULT)) ||
(SUBLANGID(lcid) > SUBLANG_DEFAULT)) {
buffer[n - 1] = '-';
i = GetLocaleInfoW(lcid, LOCALE_SISO3166CTRYNAME, buffer + n, ARRAY_SIZE(buffer) - n);
if (!i)
buffer[n - 1] = '\0';
}
else
i = 0;
LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE, buffer, n + i, rfc1766, len);
return ((n + i) > len) ? E_INVALIDARG : S_OK;
}
return E_FAIL;
}
static const int lcid_to_fl(LCID lcid, FL_Locale *rtn)
{
LANGID langid = LANGIDFROMLCID(lcid);
LANGID primary_lang = PRIMARYLANGID(langid);
LANGID sub_lang = SUBLANGID(langid);
int i;
// try to find an exact primary/sublanguage combo that we know about
for (i = 0; i < num_both_to_code; ++i)
{
if (both_to_code[i].id == langid)
{
accumulate_locstring(both_to_code[i].code, rtn);
return 1;
}
}
// fallback to just checking the primary language id
for (i = 0; i < num_primary_to_code; ++i)
{
if (primary_to_code[i].id == primary_lang)
{
accumulate_locstring(primary_to_code[i].code, rtn);
return 1;
}
}
return 0;
}
LANGID TaLocale_GuessBestLangID (LANGID lang)
{
switch (PRIMARYLANGID(lang))
{
case LANG_KOREAN:
return MAKELANGID(LANG_KOREAN,SUBLANG_KOREAN);
case LANG_JAPANESE:
return MAKELANGID(LANG_JAPANESE,SUBLANG_DEFAULT);
case LANG_ENGLISH:
return MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US);
case LANG_CHINESE:
if (SUBLANGID(lang) != SUBLANG_CHINESE_TRADITIONAL)
return MAKELANGID(LANG_CHINESE,SUBLANG_CHINESE_SIMPLIFIED);
case LANG_GERMAN:
return MAKELANGID(LANG_GERMAN,SUBLANG_GERMAN);
case LANG_SPANISH:
return MAKELANGID(LANG_SPANISH,SUBLANG_SPANISH);
case LANG_PORTUGUESE:
return MAKELANGID(LANG_PORTUGUESE,SUBLANG_PORTUGUESE_BRAZILIAN);
}
return lang;
}
/***
*BOOL match_ctry_lang - match country with language
*
*Purpose:
* ensure language and country match, choose proper values for language
* and country when matching, country ids converted to proper language id
*
*Entry:
* pwCtry - pointer to country id to match and set
* pwLang - pointer to language id to match and set
*
*Exit:
*
*Exceptions:
*
*******************************************************************************/
static BOOL match_ctry_lang(WORD *pwCtry, WORD *pwLang)
{
UINT i;
WORD wCtry = *pwCtry;
WORD wLang = *pwLang;
WORD wLangT;
/* only use base 10 two least significant digits */
wCtry = wCtry % 100;
if (wCtry > MAX_CTRY_NUM)
return FALSE;
/* see if any of the sublanguages for this country match*/
for (i = 0; i < MAX_LANG_PER_CTRY; i++)
{
if (!(wLangT = __rgrgwlang[wCtry][i]))
break;
if (PRIMARYLANGID(wLangT) == PRIMARYLANGID(wLang))
{
/* they match*/
if (!SUBLANGID(wLang))
/* don't override sublanguage*/
*pwLang = wLangT;
*pwCtry = wLangT;
return TRUE;
}
}
/* get the default language for this country*/
if (!(*pwCtry = __rgrgwlang[wCtry][0]))
/* bad country number*/
return FALSE;
return TRUE;
}
void ASLocalizer::setLanguageFromLCID(size_t lcid)
// Windows get the language to use from the user locale.
// NOTE: GetUserDefaultLocaleName() gets nearly the same name as Linux.
// But it needs Windows Vista or higher.
// Same with LCIDToLocaleName().
{
m_lcid = lcid;
m_langID = "en"; // default to english
size_t lang = PRIMARYLANGID(LANGIDFROMLCID(m_lcid));
size_t sublang = SUBLANGID(LANGIDFROMLCID(m_lcid));
// find language in the wlc table
size_t count = sizeof(wlc) / sizeof(wlc[0]);
for (size_t i = 0; i < count; i++)
{
if (wlc[i].winLang == lang)
{
m_langID = wlc[i].canonicalLang;
break;
}
}
if (m_langID == "zh")
{
if (sublang == SUBLANG_CHINESE_SIMPLIFIED || sublang == SUBLANG_CHINESE_SINGAPORE)
m_subLangID = "CHS";
else
m_subLangID = "CHT"; // default
}
setTranslationClass();
}
CMediaInfoDlg::CMediaInfoDlg()
{
LANGID _SysLangId = GetSystemDefaultLangID();
if(PRIMARYLANGID(_SysLangId) == LANG_CHINESE) {
if(SUBLANGID(_SysLangId) == SUBLANG_CHINESE_SIMPLIFIED)
codepage = 936; //Simplified Chinese GBK
else if(SUBLANGID(_SysLangId) == SUBLANG_CHINESE_TRADITIONAL)
codepage = 950; //Traditional Chinese Big5
else if(SUBLANGID(_SysLangId) == SUBLANG_CHINESE_HONGKONG)
codepage = 950; //Traditional Chinese Big5
} else if(PRIMARYLANGID(_SysLangId) == LANG_JAPANESE)
codepage = 932; //Japanese Shift-JIS
else if(PRIMARYLANGID(_SysLangId) == LANG_KOREAN)
codepage = 949; //Korean
m_wndListCtrl.RegisterClass();
}
void GetLanguageID()
{
LANGID _SysLangId = GetSystemDefaultLangID();
if(PRIMARYLANGID(_SysLangId) == LANG_CHINESE)
{
if(SUBLANGID(_SysLangId) == SUBLANG_CHINESE_SIMPLIFIED)
sys_language_id = 936; //Simplified Chinese GBK
else if(SUBLANGID(_SysLangId) == SUBLANG_CHINESE_TRADITIONAL)
sys_language_id = 950; //Traditional Chinese Big5
else if(SUBLANGID(_SysLangId) == SUBLANG_CHINESE_HONGKONG)
sys_language_id = 950; //Traditional Chinese Big5
else
sys_language_id = CP_ACP; //ANSI
}
else if(PRIMARYLANGID(_SysLangId) == LANG_JAPANESE)
sys_language_id = 932; //Japanese Shift-JIS
else if(PRIMARYLANGID(_SysLangId) == LANG_KOREAN)
sys_language_id = 949; //Korean
else
sys_language_id = CP_ACP; //ANSI
}
int MLocale::GetCharsetFromLang(LANGID langid)
{
switch( PRIMARYLANGID(langid) )
{
case LANG_JAPANESE:
return SHIFTJIS_CHARSET;
case LANG_KOREAN:
return HANGEUL_CHARSET;
case LANG_CHINESE:
switch( SUBLANGID(langid) )
{
case SUBLANG_CHINESE_SIMPLIFIED:
return GB2312_CHARSET;
case SUBLANG_CHINESE_TRADITIONAL:
return CHINESEBIG5_CHARSET;
default:
return ANSI_CHARSET;
}
case LANG_GREEK:
return GREEK_CHARSET;
case LANG_TURKISH:
return TURKISH_CHARSET;
case LANG_HEBREW:
return HEBREW_CHARSET;
case LANG_ARABIC:
return ARABIC_CHARSET;
case LANG_ESTONIAN:
case LANG_LATVIAN:
case LANG_LITHUANIAN:
return BALTIC_CHARSET;
case LANG_THAI:
return THAI_CHARSET;
case LANG_CZECH:
case LANG_HUNGARIAN:
case LANG_POLISH:
case LANG_PORTUGUESE:
case LANG_CROATIAN:
case LANG_MACEDONIAN:
case LANG_ROMANIAN:
case LANG_SLOVAK:
case LANG_SLOVENIAN:
return EASTEUROPE_CHARSET;
case LANG_RUSSIAN:
case LANG_BELARUSIAN:
case LANG_BULGARIAN:
case LANG_UKRAINIAN:
return RUSSIAN_CHARSET;
default:
return ANSI_CHARSET;
}
}
int meshml_export::DoExport(TCHAR const * name, ExpInterface* /*exp_interface*/, Interface* max_interface,
BOOL /*suppress_prompts*/, DWORD options)
{
file_name_ = tstr_to_str(name);
max_interface_ = max_interface;
export_nodes_.clear();
if (options & SCENE_EXPORT_SELECTED)
{
int count = max_interface_->GetSelNodeCount();
for (int i = 0; i < count; ++ i)
{
this->enum_node(max_interface_->GetSelNode(i));
}
}
else
{
this->enum_node(this->max_interface_->GetRootNode());
}
DWORD dlg_id;
WORD lang_id = MaxSDK::Util::GetLanguageID();
if ((LANG_CHINESE == PRIMARYLANGID(lang_id)) && (SUBLANG_CHINESE_SIMPLIFIED == SUBLANGID(lang_id)))
{
dlg_id = IDD_MESHML_EXPORT_CHS;
in_chs_ = true;
}
else
{
dlg_id = IDD_MESHML_EXPORT_EN;
in_chs_ = false;
}
HWND max_wnd = max_interface->GetMAXHWnd();
if (::DialogBoxParam(dll_instance, MAKEINTRESOURCE(dlg_id), max_wnd,
export_wnd_proc, reinterpret_cast<LPARAM>(this)))
{
if (in_chs_)
{
::MessageBox(max_wnd, TEXT("导出成功!"), TEXT("MeshML导出插件"), MB_OK);
}
else
{
::MessageBox(max_wnd, TEXT("Export Successful!"), TEXT("MeshML Export"), MB_OK);
}
}
return 1;
}
static std::wstring get_system_language()
{
LCID locale = GetUserDefaultLCID();
wchar_t buffer[9];
int length = ::GetLocaleInfoW(locale, LOCALE_SISO639LANGNAME, &buffer[0], _countof(buffer));
if (length <= 1)
return std::move(std::wstring());
std::wstring res(buffer);
if (SUBLANGID(locale) == SUBLANG_NEUTRAL)
return std::move(language);
length = ::GetLocaleInfoW(locale, LOCALE_SISO3166CTRYNAME, &buffer[0], _countof(buffer));
if (length <= 1)
return std::move(language);
return std::move(res.append(1, '-').append(buffer));
}
//! note: this function can be extended to include other exotic cases as they arise.
// This function was added in response to bug [#25715]
// This is going to be a long list [T42426]
GHOST_TKey GHOST_SystemWin32::processSpecialKey(GHOST_IWindow *window, short vKey, short scanCode) const
{
GHOST_TKey key = GHOST_kKeyUnknown;
switch (PRIMARYLANGID(m_langId)) {
case LANG_FRENCH:
if (vKey == VK_OEM_8) key = GHOST_kKeyF13; // oem key; used purely for shortcuts .
break;
case LANG_ENGLISH:
if (SUBLANGID(m_langId) == SUBLANG_ENGLISH_UK && vKey == VK_OEM_8) // "`¬"
key = GHOST_kKeyAccentGrave;
break;
}
return key;
}
int main()
{
LANGID langID;
WORD primLang;
WORD subLang;
setlocale( LC_ALL, "" );
langID = GetUserDefaultLangID();
printf("langID=0x%x\n",langID);
primLang = (WORD)(PRIMARYLANGID(langID));
subLang = (WORD)(SUBLANGID(langID));
printf("primLang=%d subLang=%d\n",(unsigned)primLang,(unsigned)subLang);
return 0;
}
HINSTANCE CLangDll::Init(LPCTSTR appname, unsigned long langID)
{
TCHAR langpath[MAX_PATH] = {0};
TCHAR langdllpath[MAX_PATH] = {0};
TCHAR sVer[MAX_PATH] = {0};
_tcscpy_s(sVer, MAX_PATH, _T(STRPRODUCTVER));
GetModuleFileName(NULL, langpath, MAX_PATH);
TCHAR * pSlash = _tcsrchr(langpath, '\\');
if (pSlash)
{
*pSlash = 0;
pSlash = _tcsrchr(langpath, '\\');
if (pSlash)
{
*pSlash = 0;
_tcscat_s(langpath, MAX_PATH, _T("\\Languages\\"));
assert(m_hInstance == NULL);
do
{
_stprintf_s(langdllpath, MAX_PATH, _T("%s%s%lu.dll"), langpath, appname, langID);
m_hInstance = LoadLibrary(langdllpath);
if (!DoVersionStringsMatch(sVer, langdllpath))
{
FreeLibrary(m_hInstance);
m_hInstance = NULL;
}
if (m_hInstance == NULL)
{
DWORD lid = SUBLANGID(langID);
lid--;
if (lid > 0)
{
langID = MAKELANGID(PRIMARYLANGID(langID), lid);
}
else
langID = 0;
}
} while ((m_hInstance == NULL) && (langID != 0));
}
}
return m_hInstance;
}
// FindLocaleDirectory: Search the provided path for one of the expected code page subdirectories
// Returns empty string on failure, or the full path to the c:\my\directory\1033\myrcfile.dll
static MyString FindLocaleDirectory(const MyString &path, const MyString &dllName)
{
// We'll be checking for 3 different locales: The user's default locale
// The user's primary language locale, and english (in that order)
const LCID lcidUser = MAKELCID(GetUserDefaultUILanguage(), SORT_DEFAULT);
LCID rglcid[3] = {lcidUser, MAKELCID(MAKELANGID(PRIMARYLANGID(lcidUser), SUBLANG_DEFAULT), SORTIDFROMLCID(lcidUser)), ENGLISH_LCID};
for (int i = 0; i < _countof(rglcid); i++)
{
LCID lcid = rglcid[i];
// Turn the LCID into a string
wchar_t wzNumBuf[12];
_itow_s(lcid, wzNumBuf, _countof(wzNumBuf), 10);
MyString localePath = MakePath(path, wzNumBuf, dllName);
// Check to see if the file exists
if (FileExists(localePath))
{
// make sure the console can support a codepage for this language.
UINT ConsoleCP = GetConsoleOutputCP();
// Dev10 #843375: For a GUI application, GetConsoleOutputCP returns 0
// If that's the case, we don't care about capabilities of the console,
// since we're not outputting to the console, anyway...
if ( ConsoleCP != 0 && lcid != ENGLISH_LCID )
{
LANGID LanguageID = MAKELANGID( lcid, SUBLANGID(lcid) );
// we know the console cannot support arabic or hebrew (right to left scripts?)
if( PRIMARYLANGID(LanguageID) == LANG_ARABIC || PRIMARYLANGID(LanguageID) == LANG_HEBREW )
continue;
UINT LangOEMCodepage = GetCodePage(LanguageID, LOCALE_IDEFAULTCODEPAGE);
UINT LangANSICodepage = GetCodePage(LanguageID, LOCALE_IDEFAULTANSICODEPAGE);
// We can only support it if the console's code page is UTF8, OEM, or ANSI
if( ConsoleCP != CP_UTF8 && ConsoleCP != LangOEMCodepage && ConsoleCP != LangANSICodepage )
continue;
}
return localePath;
}
}
return W("");
}
int CMultiLanguage::PrintThreeLetterLanguageCodeList( void )
{
LANGID id[] =
{
0x0436,0x041c,0x0401,0x0801,0x0c01,0x1001,0x1401,0x1801,0x1c01,0x2001,0x2401,0x2801,
0x2c01,0x3001,0x3401,0x3801,0x3c01,0x4001,0x042b,0x042c,0x082c,0x042d,0x0423,0x0445,
0x141a,0x0402,0x0455,0x0403,0x0404,0x0804,0x0c04,0x1004,0x1404,0x041a,0x101a,0x0405,
0x0406,0x0465,0x0413,0x0813,0x0409,0x0809,0x0c09,0x1009,0x1409,0x1809,0x1c09,0x2009,
0x2409,0x2809,0x2c09,0x3009,0x3409,0x0425,0x0438,0x0429,0x040b,0x040c,0x080c,0x0c0c,
0x100c,0x140c,0x180c,0x0456,0x0437,0x0407,0x0807,0x0c07,0x1007,0x1407,0x0408,0x0447,
0x040d,0x0439,0x040e,0x040f,0x0421,0x0434,0x0435,0x0410,0x0810,0x0411,0x044b,0x0457,
0x0412,0x0812,0x0440,0x0426,0x0427,0x0827,0x042f,0x043e,0x083e,0x044c,0x0481,0x043a,
0x044e,0x0450,0x0414,0x0814,0x0415,0x0416,0x0816,0x0446,0x046b,0x086b,0x0c6b,0x0418,
0x0419,0x044f,0x043b,0x083b,0x0c3b,0x103b,0x143b,0x183b,0x1c3b,0x203b,0x243b,0x0c1a,
0x1c1a,0x081a,0x181a,0x046c,0x0432,0x041b,0x0424,0x040a,0x080a,0x0c0a,0x100a,0x140a,
0x180a,0x1c0a,0x200a,0x240a,0x280a,0x2c0a,0x300a,0x340a,0x380a,0x3c0a,0x400a,0x440a,
0x480a,0x4c0a,0x500a,0x0430,0x0441,0x041d,0x081d,0x045a,0x0449,0x0444,0x044a,0x041e,
0x041f,0x0422,0x0420,0x0820,0x0443,0x0843,0x042a,0x0452
};
LCID lcid, lcidMain;
int nResult;
TCHAR szLangCode[4];
TCHAR szLangCodeMain[4];
TRACE(_T("Identifier\tThree-letter Abbrev. lang. Name\n"));
for ( int i=0; i< sizeof(id)/sizeof(id[0]); i++ )
{
lcid = MAKELCID( id[i], SORT_DEFAULT );
LANGID langid = id[i]; // Without sub language
int nPrimaryLang = PRIMARYLANGID(langid);
int nSubLang = SUBLANGID(langid);
lcidMain = MAKELCID(MAKELANGID(nPrimaryLang, SUBLANG_NEUTRAL), SORT_DEFAULT);
lstrcpy(szLangCode, _T("==="));
lstrcpy(szLangCodeMain, _T("==="));
nResult = ::GetLocaleInfo(lcid, LOCALE_SABBREVLANGNAME, szLangCode, 4);
nResult = ::GetLocaleInfo(lcidMain, LOCALE_SABBREVLANGNAME, szLangCodeMain, 4);
TRACE(_T("0x%04X,\t%s,\t%s\n"), lcid, szLangCode, szLangCodeMain );
}
return 0;
}
void CTortoiseSIProcApp::LoadLanguageDLL()
{
CRegDWORD regLangId = CRegDWORD(_T("Software\\TortoiseSI\\LanguageID"), 1033);
long langId = regLangId;
CString langDll;
do
{
langDll.Format(_T("%sLanguages\\TortoiseProc%ld.dll"), (LPCTSTR)CPathUtils::GetAppParentDirectory(), langId);
CString sVer = _T(STRPRODUCTVER);
CString sFileVer = CPathUtils::GetVersionFromFile(langDll);
if (sFileVer == sVer)
{
// Language DLL version matches TortoiseSIProc version, so load language DLL
HINSTANCE hInst = LoadLibrary(langDll);
if (hInst != NULL)
{
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": Loaded Language DLL %s\n"), langDll);
// Tell the application that this is the default resources for the application
AfxSetResourceHandle(hInst);
break;
}
}
DWORD lid = SUBLANGID(langId) - 1;
if (lid > 0) {
langId = MAKELANGID(PRIMARYLANGID(langId), lid);
} else {
langId = 0;
}
} while (langId != 0);
}
/****************************************************************************
* QueryPathOfRegTypeLib [TYPELIB.14]
*
* Get the registry key of a registered type library.
*
* RETURNS
* Success: S_OK. path is updated with the key name
* Failure: E_FAIL, if guid was not found in the registry
*
* NOTES
* The key takes the form "Classes\Typelib\<guid>\<major>.<minor>\<lcid>\win16\"
*/
HRESULT WINAPI
QueryPathOfRegTypeLib16(
REFGUID guid, /* [in] Guid to get the key name for */
WORD wMaj, /* [in] Major version */
WORD wMin, /* [in] Minor version */
LCID lcid, /* [in] Locale Id */
SEGPTR *path) /* [out] Destination for the registry key name */
{
char xguid[80];
char typelibkey[100],pathname[260];
LONG plen;
char *ret;
TRACE("\n");
if (HIWORD(guid)) {
sprintf( typelibkey, "SOFTWARE\\Classes\\Typelib\\{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\%d.%d\\%x\\win16",
guid->Data1, guid->Data2, guid->Data3,
guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7],
wMaj,wMin,lcid);
} else {
sprintf(xguid,"<guid 0x%08x>",(DWORD)guid);
FIXME("(%s,%d,%d,0x%04x,%p),can't handle non-string guids.\n",xguid,wMaj,wMin,lcid,path);
return E_FAIL;
}
plen = sizeof(pathname);
if (RegQueryValueA(HKEY_LOCAL_MACHINE,typelibkey,pathname,&plen)) {
/* try again without lang specific id */
if (SUBLANGID(lcid))
return QueryPathOfRegTypeLib16(guid,wMaj,wMin,PRIMARYLANGID(lcid),path);
FIXME("key %s not found\n",typelibkey);
return E_FAIL;
}
ret = HeapAlloc( GetProcessHeap(), 0, strlen(pathname) + 1 );
if (!ret) return E_FAIL;
strcpy( ret, pathname );
*path = MapLS(ret);
return S_OK;
}
int main(int argc,char *argv[])
{
extern char* optarg;
extern int optind;
int optc;
int opti = 0;
int stdinc = 1;
int lose = 0;
int nb_files = 0;
int i;
int cmdlen;
int po_mode = 0;
char *po_dir = NULL;
char **files = xmalloc( argc * sizeof(*files) );
signal(SIGSEGV, segvhandler);
signal( SIGTERM, exit_on_signal );
signal( SIGINT, exit_on_signal );
#ifdef SIGHUP
signal( SIGHUP, exit_on_signal );
#endif
now = time(NULL);
/* Set the default defined stuff */
set_version_defines();
wpp_add_cmdline_define("RC_INVOKED=1");
/* Microsoft RC always searches current directory */
wpp_add_include_path(".");
/* First rebuild the commandline to put in destination */
/* Could be done through env[], but not all OS-es support it */
cmdlen = 4; /* for "wrc " */
for(i = 1; i < argc; i++)
cmdlen += strlen(argv[i]) + 1;
cmdline = xmalloc(cmdlen);
strcpy(cmdline, "wrc ");
for(i = 1; i < argc; i++)
{
strcat(cmdline, argv[i]);
if(i < argc-1)
strcat(cmdline, " ");
}
while((optc = getopt_long(argc, argv, short_options, long_options, &opti)) != EOF)
{
switch(optc)
{
case LONG_OPT_NOSTDINC:
stdinc = 0;
break;
case LONG_OPT_TMPFILE:
if (debuglevel) warning("--use-temp-file option not yet supported, ignored.\n");
break;
case LONG_OPT_NOTMPFILE:
if (debuglevel) warning("--no-use-temp-file option not yet supported, ignored.\n");
break;
case LONG_OPT_PO_DIR:
po_dir = xstrdup( optarg );
break;
case LONG_OPT_PREPROCESSOR:
if (strcmp(optarg, "cat") == 0) no_preprocess = 1;
else fprintf(stderr, "-P option not yet supported, ignored.\n");
break;
case LONG_OPT_VERSION:
printf(version_string);
exit(0);
break;
case LONG_OPT_DEBUG:
debuglevel = strtol(optarg, NULL, 0);
break;
case LONG_OPT_ENDIANESS:
switch(optarg[0])
{
case 'n':
case 'N':
byteorder = WRC_BO_NATIVE;
break;
case 'l':
case 'L':
byteorder = WRC_BO_LITTLE;
break;
case 'b':
case 'B':
byteorder = WRC_BO_BIG;
break;
default:
fprintf(stderr, "Byte ordering must be n[ative], l[ittle] or b[ig]\n");
lose++;
}
break;
case LONG_OPT_PEDANTIC:
pedantic = 1;
wpp_set_pedantic(1);
break;
case LONG_OPT_VERIFY_TRANSL:
verify_translations_mode = 1;
break;
case 'D':
wpp_add_cmdline_define(optarg);
break;
case 'E':
preprocess_only = 1;
break;
case 'b':
case 'F':
set_target( optarg );
break;
case 'h':
printf(usage);
exit(0);
case 'i':
files[nb_files++] = optarg;
break;
case 'I':
wpp_add_include_path(optarg);
break;
case 'J':
if (strcmp(optarg, "rc16") == 0) extensions = 0;
else if (strcmp(optarg, "rc")) error("Output format %s not supported.\n", optarg);
break;
case 'l':
{
int lan;
lan = strtol(optarg, NULL, 0);
if (get_language_codepage(PRIMARYLANGID(lan), SUBLANGID(lan)) == -1)
error("Language %04x is not supported\n", lan);
defaultlanguage = new_language(PRIMARYLANGID(lan), SUBLANGID(lan));
}
break;
case 'm':
if (!strcmp( optarg, "16" )) win32 = 0;
else if (!strcmp( optarg, "32" )) { win32 = 1; pointer_size = 4; }
else if (!strcmp( optarg, "64" )) { win32 = 1; pointer_size = 8; }
else error( "Invalid option: -m%s\n", optarg );
break;
case 'f':
if (*optarg != 'o') error("Unknown option: -f%s\n", optarg);
optarg++;
/* fall through */
case 'o':
if (!output_name) output_name = strdup(optarg);
else error("Too many output files.\n");
break;
case 'O':
if (strcmp(optarg, "po") == 0) po_mode = 1;
else if (strcmp(optarg, "pot") == 0) po_mode = 2;
else if (strcmp(optarg, "res16") == 0) win32 = 0;
else if (strcmp(optarg, "res")) warning("Output format %s not supported.\n", optarg);
break;
case 'r':
/* ignored for compatibility with rc */
break;
case 'U':
wpp_del_define(optarg);
break;
case 'v':
debuglevel = DEBUGLEVEL_CHAT;
break;
default:
lose++;
break;
}
}
if(lose)
{
fprintf(stderr, usage);
return 1;
}
if (win32)
{
wpp_add_cmdline_define("_WIN32=1");
if (pointer_size == 8) wpp_add_cmdline_define("_WIN64=1");
}
/* If we do need to search standard includes, add them to the path */
if (stdinc)
{
/* Odyssey doesn't use this feature
wpp_add_include_path(INCLUDEDIR"/msvcrt");
wpp_add_include_path(INCLUDEDIR"/windows");
*/
}
/* Kill io buffering when some kind of debuglevel is enabled */
if(debuglevel)
{
setbuf(stdout, NULL);
setbuf(stderr, NULL);
}
parser_debug = debuglevel & DEBUGLEVEL_TRACE ? 1 : 0;
yy_flex_debug = debuglevel & DEBUGLEVEL_TRACE ? 1 : 0;
wpp_set_debug( (debuglevel & DEBUGLEVEL_PPLEX) != 0,
(debuglevel & DEBUGLEVEL_PPTRACE) != 0,
(debuglevel & DEBUGLEVEL_PPMSG) != 0 );
/* Check if the user set a language, else set default */
if(!defaultlanguage)
defaultlanguage = new_language(0, 0);
atexit(cleanup_files);
while (optind < argc) files[nb_files++] = argv[optind++];
for (i = 0; i < nb_files; i++)
{
input_name = files[i];
if (load_file( input_name, output_name )) exit(1);
}
/* stdin special case. NULL means "stdin" for wpp. */
if (nb_files == 0 && load_file( NULL, output_name )) exit(1);
if(debuglevel & DEBUGLEVEL_DUMP)
dump_resources(resource_top);
if(verify_translations_mode)
{
verify_translations(resource_top);
exit(0);
}
if (po_mode)
{
if (po_mode == 2) /* pot file */
{
if (!output_name)
{
output_name = dup_basename( nb_files ? files[0] : NULL, ".rc" );
strcat( output_name, ".pot" );
}
write_pot_file( output_name );
}
else write_po_files( output_name );
output_name = NULL;
exit(0);
}
if (po_dir) add_translations( po_dir );
/* Convert the internal lists to binary data */
resources2res(resource_top);
chat("Writing .res-file\n");
if (!output_name)
{
output_name = dup_basename( nb_files ? files[0] : NULL, ".rc" );
strcat(output_name, ".res");
}
write_resfile(output_name, resource_top);
output_name = NULL;
return 0;
}
void LoadLangDll()
{
if ((g_langid != g_ShellCache.GetLangID())&&((g_langTimeout == 0)||(g_langTimeout < GetTickCount())))
{
g_langid = g_ShellCache.GetLangID();
DWORD langId = g_langid;
TCHAR langDll[MAX_PATH*4];
HINSTANCE hInst = NULL;
TCHAR langdir[MAX_PATH] = {0};
char langdirA[MAX_PATH] = {0};
if (GetModuleFileName(g_hmodThisDll, langdir, _countof(langdir))==0)
return;
if (GetModuleFileNameA(g_hmodThisDll, langdirA, _countof(langdirA))==0)
return;
TCHAR * dirpoint = _tcsrchr(langdir, '\\');
char * dirpointA = strrchr(langdirA, '\\');
if (dirpoint)
*dirpoint = 0;
if (dirpointA)
*dirpointA = 0;
dirpoint = _tcsrchr(langdir, '\\');
dirpointA = strrchr(langdirA, '\\');
if (dirpoint)
*dirpoint = 0;
if (dirpointA)
*dirpointA = 0;
strcat_s(langdirA, "\\Languages");
// bindtextdomain ("subversion", langdirA);
BOOL bIsWow = FALSE;
IsWow64Process(GetCurrentProcess(), &bIsWow);
do
{
if (bIsWow)
_stprintf_s(langDll, _T("%s\\Languages\\TortoiseProc32%lu.dll"), langdir, langId);
else
_stprintf_s(langDll, _T("%s\\Languages\\TortoiseProc%lu.dll"), langdir, langId);
BOOL versionmatch = TRUE;
struct TRANSARRAY
{
WORD wLanguageID;
WORD wCharacterSet;
};
DWORD dwReserved,dwBufferSize;
dwBufferSize = GetFileVersionInfoSize((LPTSTR)langDll,&dwReserved);
if (dwBufferSize > 0)
{
LPVOID pBuffer = (void*) malloc(dwBufferSize);
if (pBuffer != (void*) NULL)
{
UINT nInfoSize = 0;
UINT nFixedLength = 0;
LPSTR lpVersion = NULL;
VOID* lpFixedPointer;
TRANSARRAY* lpTransArray;
TCHAR strLangProductVersion[MAX_PATH];
if (GetFileVersionInfo((LPTSTR)langDll,
dwReserved,
dwBufferSize,
pBuffer))
{
// Query the current language
if (VerQueryValue( pBuffer,
_T("\\VarFileInfo\\Translation"),
&lpFixedPointer,
&nFixedLength))
{
lpTransArray = (TRANSARRAY*) lpFixedPointer;
_stprintf_s(strLangProductVersion, _T("\\StringFileInfo\\%04x%04x\\ProductVersion"),
lpTransArray[0].wLanguageID, lpTransArray[0].wCharacterSet);
if (VerQueryValue(pBuffer,
(LPTSTR)strLangProductVersion,
(LPVOID *)&lpVersion,
&nInfoSize))
{
versionmatch = (_tcscmp((LPCTSTR)lpVersion, _T(STRPRODUCTVER)) == 0);
}
}
}
free(pBuffer);
} // if (pBuffer != (void*) NULL)
} // if (dwBufferSize > 0)
else
versionmatch = FALSE;
if (versionmatch)
hInst = LoadLibrary(langDll);
if (hInst != NULL)
{
if (g_hResInst != g_hmodThisDll)
FreeLibrary(g_hResInst);
g_hResInst = hInst;
}
else
{
DWORD lid = SUBLANGID(langId);
lid--;
if (lid > 0)
{
langId = MAKELANGID(PRIMARYLANGID(langId), lid);
}
else
langId = 0;
}
} while ((hInst == NULL) && (langId != 0));
if (hInst == NULL)
{
// either the dll for the selected language is not present, or
// it is the wrong version.
// fall back to English and set a timeout so we don't retry
// to load the language dll too often
if (g_hResInst != g_hmodThisDll)
FreeLibrary(g_hResInst);
g_hResInst = g_hmodThisDll;
g_langid = 1033;
// set a timeout of 10 seconds
if (g_ShellCache.GetLangID() != 1033)
g_langTimeout = GetTickCount() + 10000;
}
else
g_langTimeout = 0;
} // if (g_langid != g_ShellCache.GetLangID())
}
/***********************************************************************
* LHashValOfNameSysA (OLEAUT32.166)
*
* Produce a string hash value.
*
* PARAMS
* skind [I] Type of the system.
* lcid [I] Locale id for the hash.
* lpStr [I] String to hash.
*
* RETURNS
* Success: The hash value of the string.
* Failure: 0, if lpStr is NULL.
*
* NOTES
* This function produces a two part hash: The high word is based on
* skind and lcid, while the low word is based on a repeated string
* hash of skind/str.
*/
ULONG WINAPI LHashValOfNameSysA( SYSKIND skind, LCID lcid, LPCSTR lpStr)
{
ULONG nOffset, nMask = skind == SYS_MAC ? 1 : 0;
ULONG nHiWord, nLoWord = 0x0deadbee;
const unsigned char *str = (const unsigned char *)lpStr, *pnLookup = NULL;
TRACE("(%d, 0x%x, %s) %s\n", skind, lcid, debugstr_a(lpStr),
(skind == SYS_WIN16) ? "SYS_WIN16" : (skind == SYS_WIN32) ? "SYS_WIN32" : "");
if (!str)
return 0;
lcid = ConvertDefaultLocale(lcid);
switch (PRIMARYLANGID(LANGIDFROMLCID(lcid)))
{
default:
ERR("Unknown lcid %x, treating as latin-based, please report\n", lcid);
/* .. Fall Through .. */
case LANG_AFRIKAANS: case LANG_ALBANIAN: case LANG_ARMENIAN:
case LANG_ASSAMESE: case LANG_AZERI: case LANG_BASQUE:
case LANG_BELARUSIAN: case LANG_BENGALI: case LANG_BULGARIAN:
case LANG_CATALAN: case LANG_DANISH: case LANG_DIVEHI:
case LANG_DUTCH: case LANG_ENGLISH: case LANG_ESTONIAN:
case LANG_FAEROESE: case LANG_FINNISH: case LANG_FRENCH:
case LANG_GALICIAN: case LANG_GEORGIAN: case LANG_GERMAN:
case LANG_GUJARATI: case LANG_HINDI: case LANG_INDONESIAN:
case LANG_ITALIAN: case LANG_KANNADA: case LANG_KASHMIRI:
case LANG_KAZAK: case LANG_KONKANI: case LANG_KYRGYZ:
case LANG_LATVIAN: case LANG_LITHUANIAN: case LANG_MACEDONIAN:
case LANG_MALAY: case LANG_MALAYALAM: case LANG_MANIPURI:
case LANG_MARATHI: case LANG_MONGOLIAN: case LANG_NEPALI:
case LANG_ORIYA: case LANG_PORTUGUESE: case LANG_PUNJABI:
case LANG_ROMANIAN: case LANG_SANSKRIT: case LANG_SERBIAN:
case LANG_SINDHI: case LANG_SLOVENIAN: case LANG_SWAHILI:
case LANG_SWEDISH: case LANG_SYRIAC: case LANG_TAMIL:
case LANG_TATAR: case LANG_TELUGU: case LANG_THAI:
case LANG_UKRAINIAN: case LANG_URDU: case LANG_UZBEK:
case LANG_VIETNAMESE: case LANG_SCOTTISH_GAELIC: case LANG_MALTESE:
case LANG_MAORI: case LANG_ROMANSH: case LANG_IRISH:
case LANG_SAMI: case LANG_UPPER_SORBIAN: case LANG_SUTU:
case LANG_TSONGA: case LANG_TSWANA: case LANG_VENDA:
case LANG_XHOSA: case LANG_ZULU: case LANG_ESPERANTO:
case LANG_WALON: case LANG_CORNISH: case LANG_WELSH:
case LANG_BRETON: case LANG_MANX_GAELIC:
nOffset = 16;
pnLookup = Lookup_16;
break;
case LANG_CZECH: case LANG_HUNGARIAN: case LANG_POLISH:
case LANG_SLOVAK: case LANG_SPANISH:
nOffset = 32;
pnLookup = Lookup_32;
break;
case LANG_HEBREW:
nOffset = 48;
pnLookup = Lookup_48;
break;
case LANG_JAPANESE:
nOffset = 64;
pnLookup = Lookup_64;
break;
case LANG_KOREAN:
nOffset = 80;
pnLookup = Lookup_80;
break;
case LANG_CHINESE:
nOffset = 112;
pnLookup = Lookup_112;
break;
case LANG_GREEK:
nOffset = 128;
pnLookup = Lookup_128;
break;
case LANG_ICELANDIC:
nOffset = 144;
pnLookup = Lookup_144;
break;
case LANG_TURKISH:
nOffset = 160;
pnLookup = Lookup_160;
break;
case LANG_NORWEGIAN:
if (SUBLANGID(LANGIDFROMLCID(lcid)) == SUBLANG_NORWEGIAN_NYNORSK)
{
nOffset = 176;
pnLookup = Lookup_176;
}
else
{
nOffset = 16;
pnLookup = Lookup_16;
}
break;
case LANG_ARABIC:
case LANG_FARSI:
nOffset = 208;
pnLookup = Lookup_208;
break;
case LANG_RUSSIAN:
nOffset = 224;
pnLookup = Lookup_224;
break;
}
nHiWord = (nOffset | nMask) << 16;
while (*str)
{
nLoWord = 37 * nLoWord + pnLookup[*str > 0x7f && nMask ? *str + 0x80 : *str];
str++;
}
/* Constrain to a prime modulo and sizeof(WORD) */
nLoWord = (nLoWord % 65599) & 0xffff;
return nHiWord | nLoWord;
}
static char *
win32_getlocale (void)
{
LCID lcid;
LANGID langid;
char *ev;
int primary, sub;
char bfr[64];
char iso639[10];
char iso3166[10];
const char *script = NULL;
/* Let the user override the system settings through environment
* variables, as on POSIX systems. Note that in GTK+ applications
* since GTK+ 2.10.7 setting either LC_ALL or LANG also sets the
* Win32 locale and C library locale through code in gtkmain.c.
*/
if (((ev = getenv ("LC_ALL")) != NULL && ev[0] != '\0')
|| ((ev = getenv ("LC_MESSAGES")) != NULL && ev[0] != '\0')
|| ((ev = getenv ("LANG")) != NULL && ev[0] != '\0'))
return safe_strdup (ev);
lcid = GetThreadLocale ();
if (!GetLocaleInfo (lcid, LOCALE_SISO639LANGNAME, iso639, sizeof (iso639)) ||
!GetLocaleInfo (lcid, LOCALE_SISO3166CTRYNAME, iso3166, sizeof (iso3166)))
return safe_strdup ("C");
/* Strip off the sorting rules, keep only the language part. */
langid = LANGIDFROMLCID (lcid);
/* Split into language and territory part. */
primary = PRIMARYLANGID (langid);
sub = SUBLANGID (langid);
/* Handle special cases */
switch (primary)
{
case LANG_AZERI:
switch (sub)
{
case SUBLANG_AZERI_LATIN:
script = "@Latn";
break;
case SUBLANG_AZERI_CYRILLIC:
script = "@Cyrl";
break;
}
break;
case LANG_SERBIAN: /* LANG_CROATIAN == LANG_SERBIAN */
switch (sub)
{
case SUBLANG_SERBIAN_LATIN:
case 0x06: /* Serbian (Latin) - Bosnia and Herzegovina */
script = "@Latn";
break;
}
break;
case LANG_UZBEK:
switch (sub)
{
case SUBLANG_UZBEK_LATIN:
script = "@Latn";
break;
case SUBLANG_UZBEK_CYRILLIC:
script = "@Cyrl";
break;
}
break;
}
strcat (bfr, iso639);
strcat (bfr, "_");
strcat (bfr, iso3166);
if (script)
strcat (bfr, script);
return safe_strdup (bfr);
}
/**********************************************************************
* find_entry
*
* Find a resource entry
*/
static NTSTATUS find_entry( HMODULE hmod, const LDR_RESOURCE_INFO *info,
ULONG level, const void **ret, int want_dir )
{
ULONG size;
const void *root;
const IMAGE_RESOURCE_DIRECTORY *resdirptr;
WORD list[9]; /* list of languages to try */
int i, pos = 0;
root = RtlImageDirectoryEntryToData( hmod, TRUE, IMAGE_DIRECTORY_ENTRY_RESOURCE, &size );
if (!root) return STATUS_RESOURCE_DATA_NOT_FOUND;
if (size < sizeof(*resdirptr)) return STATUS_RESOURCE_DATA_NOT_FOUND;
resdirptr = root;
if (!level--) goto done;
if (!(*ret = find_entry_by_name( resdirptr, (LPCWSTR)info->Type, root, want_dir || level )))
return STATUS_RESOURCE_TYPE_NOT_FOUND;
if (!level--) return STATUS_SUCCESS;
resdirptr = *ret;
if (!(*ret = find_entry_by_name( resdirptr, (LPCWSTR)info->Name, root, want_dir || level )))
return STATUS_RESOURCE_NAME_NOT_FOUND;
if (!level--) return STATUS_SUCCESS;
if (level) return STATUS_INVALID_PARAMETER; /* level > 3 */
/* 1. specified language */
pos = push_language( list, pos, info->Language );
/* 2. specified language with neutral sublanguage */
pos = push_language( list, pos, MAKELANGID( PRIMARYLANGID(info->Language), SUBLANG_NEUTRAL ) );
/* 3. neutral language with neutral sublanguage */
pos = push_language( list, pos, MAKELANGID( LANG_NEUTRAL, SUBLANG_NEUTRAL ) );
/* if no explicitly specified language, try some defaults */
if (PRIMARYLANGID(info->Language) == LANG_NEUTRAL)
{
/* user defaults, unless SYS_DEFAULT sublanguage specified */
if (SUBLANGID(info->Language) != SUBLANG_SYS_DEFAULT)
{
/* 4. current thread locale language */
pos = push_language( list, pos, LANGIDFROMLCID(NtCurrentTeb()->CurrentLocale) );
/* 5. user locale language */
pos = push_language( list, pos, LANGIDFROMLCID(user_lcid) );
/* 6. user locale language with neutral sublanguage */
pos = push_language( list, pos, MAKELANGID( PRIMARYLANGID(user_lcid), SUBLANG_NEUTRAL ) );
}
/* now system defaults */
/* 7. system locale language */
pos = push_language( list, pos, LANGIDFROMLCID( system_lcid ) );
/* 8. system locale language with neutral sublanguage */
pos = push_language( list, pos, MAKELANGID( PRIMARYLANGID(system_lcid), SUBLANG_NEUTRAL ) );
/* 9. English */
pos = push_language( list, pos, MAKELANGID( LANG_ENGLISH, SUBLANG_DEFAULT ) );
}
resdirptr = *ret;
for (i = 0; i < pos; i++)
if ((*ret = find_entry_by_id( resdirptr, list[i], root, want_dir ))) return STATUS_SUCCESS;
/* if no explicitly specified language, return the first entry */
if (PRIMARYLANGID(info->Language) == LANG_NEUTRAL)
{
if ((*ret = find_first_entry( resdirptr, root, want_dir ))) return STATUS_SUCCESS;
}
return STATUS_RESOURCE_LANG_NOT_FOUND;
done:
*ret = resdirptr;
return STATUS_SUCCESS;
}
/*static*/ int wxLocale::GetSystemLanguage()
{
CreateLanguagesDB();
// init i to avoid compiler warning
size_t i = 0,
count = ms_languagesDB->GetCount();
#if defined(__UNIX__)
// first get the string identifying the language from the environment
wxString langFull;
#ifdef __WXMAC__
wxCFRef<CFLocaleRef> userLocaleRef(CFLocaleCopyCurrent());
// because the locale identifier (kCFLocaleIdentifier) is formatted a little bit differently, eg
// az_Cyrl_AZ@calendar=buddhist;currency=JPY we just recreate the base info as expected by wx here
wxCFStringRef str(wxCFRetain((CFStringRef)CFLocaleGetValue(userLocaleRef, kCFLocaleLanguageCode)));
langFull = str.AsString()+"_";
str.reset(wxCFRetain((CFStringRef)CFLocaleGetValue(userLocaleRef, kCFLocaleCountryCode)));
langFull += str.AsString();
#else
if (!wxGetEnv(wxS("LC_ALL"), &langFull) &&
!wxGetEnv(wxS("LC_MESSAGES"), &langFull) &&
!wxGetEnv(wxS("LANG"), &langFull))
{
// no language specified, treat it as English
return wxLANGUAGE_ENGLISH_US;
}
if ( langFull == wxS("C") || langFull == wxS("POSIX") )
{
// default C locale is English too
return wxLANGUAGE_ENGLISH_US;
}
#endif
// the language string has the following form
//
// lang[_LANG][.encoding][@modifier]
//
// (see environ(5) in the Open Unix specification)
//
// where lang is the primary language, LANG is a sublang/territory,
// encoding is the charset to use and modifier "allows the user to select
// a specific instance of localization data within a single category"
//
// for example, the following strings are valid:
// fr
// fr_FR
// de_DE.iso88591
// de_DE@euro
// de_DE.iso88591@euro
// for now we don't use the encoding, although we probably should (doing
// translations of the msg catalogs on the fly as required) (TODO)
//
// we need the modified for languages like Valencian: ca_ES@valencia
// though, remember it
wxString modifier;
size_t posModifier = langFull.find_first_of(wxS("@"));
if ( posModifier != wxString::npos )
modifier = langFull.Mid(posModifier);
size_t posEndLang = langFull.find_first_of(wxS("@."));
if ( posEndLang != wxString::npos )
{
langFull.Truncate(posEndLang);
}
// do we have just the language (or sublang too)?
const bool justLang = langFull.find('_') == wxString::npos;
// 0. Make sure the lang is according to latest ISO 639
// (this is necessary because glibc uses iw and in instead
// of he and id respectively).
// the language itself (second part is the dialect/sublang)
wxString langOrig = ExtractLang(langFull);
wxString lang;
if ( langOrig == wxS("iw"))
lang = wxS("he");
else if (langOrig == wxS("in"))
lang = wxS("id");
else if (langOrig == wxS("ji"))
lang = wxS("yi");
else if (langOrig == wxS("no_NO"))
lang = wxS("nb_NO");
else if (langOrig == wxS("no_NY"))
lang = wxS("nn_NO");
else if (langOrig == wxS("no"))
lang = wxS("nb_NO");
else
lang = langOrig;
// did we change it?
if ( lang != langOrig )
{
langFull = lang + ExtractNotLang(langFull);
}
// 1. Try to find the language either as is:
// a) With modifier if set
if ( !modifier.empty() )
{
wxString langFullWithModifier = langFull + modifier;
for ( i = 0; i < count; i++ )
{
if ( ms_languagesDB->Item(i).CanonicalName == langFullWithModifier )
break;
}
}
// b) Without modifier
if ( modifier.empty() || i == count )
{
for ( i = 0; i < count; i++ )
{
if ( ms_languagesDB->Item(i).CanonicalName == langFull )
break;
}
}
// 2. If langFull is of the form xx_YY, try to find xx:
if ( i == count && !justLang )
{
for ( i = 0; i < count; i++ )
{
if ( ms_languagesDB->Item(i).CanonicalName == lang )
{
break;
}
}
}
// 3. If langFull is of the form xx, try to find any xx_YY record:
if ( i == count && justLang )
{
for ( i = 0; i < count; i++ )
{
if ( ExtractLang(ms_languagesDB->Item(i).CanonicalName)
== langFull )
{
break;
}
}
}
if ( i == count )
{
// In addition to the format above, we also can have full language
// names in LANG env var - for example, SuSE is known to use
// LANG="german" - so check for use of non-standard format and try to
// find the name in verbose description.
for ( i = 0; i < count; i++ )
{
if (ms_languagesDB->Item(i).Description.CmpNoCase(langFull) == 0)
{
break;
}
}
}
#elif defined(__WIN32__)
LCID lcid = GetUserDefaultLCID();
if ( lcid != 0 )
{
wxUint32 lang = PRIMARYLANGID(LANGIDFROMLCID(lcid));
wxUint32 sublang = SUBLANGID(LANGIDFROMLCID(lcid));
for ( i = 0; i < count; i++ )
{
if (ms_languagesDB->Item(i).WinLang == lang &&
ms_languagesDB->Item(i).WinSublang == sublang)
{
break;
}
}
}
//else: leave wxlang == wxLANGUAGE_UNKNOWN
#endif // Unix/Win32
if ( i < count )
{
// we did find a matching entry, use it
return ms_languagesDB->Item(i).Language;
}
// no info about this language in the database
return wxLANGUAGE_UNKNOWN;
}
BOOL CMEditor2App::InitInstance()
{
// 如果一个运行在 Windows XP 上的应用程序清单指定要
// 使用 ComCtl32.dll 版本 6 或更高版本来启用可视化方式，
//则需要 InitCommonControlsEx()。否则，将无法创建窗口。
INITCOMMONCONTROLSEX InitCtrls;
InitCtrls.dwSize = sizeof(InitCtrls);
// 将它设置为包括所有要在应用程序中使用的
// 公共控件类。
InitCtrls.dwICC = ICC_WIN95_CLASSES;
InitCommonControlsEx(&InitCtrls);
CWinApp::InitInstance();
AfxEnableControlContainer();
SetRegistryKey(_T("MEditor2 - MPlayer 首选项"));
CString sCmdLine(this->m_lpCmdLine);
int OpenType = 0;
CString ProgramName;
CString program_dir;
TCHAR szFilePath[MAX_PATH + 1];
GetModuleFileName(NULL, szFilePath, MAX_PATH);
ProgramName.Format(_T("%s"),szFilePath);
ProgramName = ProgramName.Right(15);
ProgramName.MakeLower();
(_tcsrchr(szFilePath, _T('\\')))[1] = 0;
program_dir.Format(_T("%s"),szFilePath);
if(sCmdLine.Find(_T("Open Editor")) >= 0 ||
sCmdLine.Find(_T("--open-ontop")) >= 0)
OpenType = 3;
CString langfile_tc;
CString langfile_en;
if(IsFileExist(program_dir + _T("tools\\meditor2.tc.dll")))
langfile_tc = program_dir + _T("tools\\meditor2.tc.dll");
if(IsFileExist(program_dir + _T("tools\\meditor2.en.dll")))
langfile_en = program_dir + _T("tools\\meditor2.en.dll");
if(IsFileExist(program_dir + _T("codecs\\meditor2.tc.dll")))
langfile_tc = program_dir + _T("codecs\\meditor2.tc.dll");
if(IsFileExist(program_dir + _T("codecs\\meditor2.en.dll")))
langfile_en = program_dir + _T("codecs\\meditor2.en.dll");
if(IsFileExist(program_dir + _T("meditor2.tc.dll")))
langfile_tc = program_dir + _T("meditor2.tc.dll");
if(IsFileExist(program_dir + _T("meditor2.en.dll")))
langfile_en = program_dir + _T("meditor2.en.dll");
if(langfile_tc.GetLength()>1 || langfile_en.GetLength()> 1) {
AppLanguage = GetPrivateProfileInt(_T("Option"),_T("Language"), 0, program_dir + _T("kk.ini"));
if(AppLanguage == 0) {
LANGID _SysLangId = GetSystemDefaultLangID();
if(PRIMARYLANGID(_SysLangId) == LANG_CHINESE) {
if(SUBLANGID(_SysLangId) == SUBLANG_CHINESE_SIMPLIFIED)
AppLanguage = 1; //Simplified Chinese GBK
else if(SUBLANGID(_SysLangId) == SUBLANG_CHINESE_TRADITIONAL)
AppLanguage = 4; //Traditional Chinese Big5
else
AppLanguage = 3; //ANSI
} else
AppLanguage = 2; //ANSI
}
}
CString strSatellite = _T("");
if(AppLanguage == 2 && langfile_en.GetLength() > 1)
strSatellite = langfile_en;
else if((AppLanguage == 3 || AppLanguage == 4) && langfile_tc.GetLength() > 1)
strSatellite = langfile_tc;
hResourceHandleOld = NULL;
hResourceHandleMod = NULL;
if (strSatellite.GetLength() > 2) {
hResourceHandleOld = AfxGetResourceHandle();
hResourceHandleMod = LoadLibrary(strSatellite);
if (hResourceHandleMod)
AfxSetResourceHandle(hResourceHandleMod);
}
CMEditor2Dlg dlg;
m_pMainWnd = &dlg;
dlg.m_OpenType = OpenType;
INT_PTR nResponse = dlg.DoModal();
if (hResourceHandleMod)
FreeLibrary(hResourceHandleMod);
if (nResponse == IDOK)
{
// “确定”来关闭对话框的代码
}
else if (nResponse == IDCANCEL)
{
// “取消”来关闭对话框的代码
}
return FALSE;
}
static wchar_t* winpidgin_lcid_to_posix(LCID lcid) {
wchar_t *posix = NULL;
int lang_id = PRIMARYLANGID(lcid);
int sub_id = SUBLANGID(lcid);
switch (lang_id) {
case LANG_AFRIKAANS: posix = L"af"; break;
case LANG_ARABIC: posix = L"ar"; break;
case LANG_AZERI: posix = L"az"; break;
case LANG_BENGALI: posix = L"bn"; break;
case LANG_BULGARIAN: posix = L"bg"; break;
case LANG_CATALAN: posix = L"ca"; break;
case LANG_CZECH: posix = L"cs"; break;
case LANG_DANISH: posix = L"da"; break;
case LANG_ESTONIAN: posix = L"et"; break;
case LANG_PERSIAN: posix = L"fa"; break;
case LANG_GERMAN: posix = L"de"; break;
case LANG_GREEK: posix = L"el"; break;
case LANG_ENGLISH:
switch (sub_id) {
case SUBLANG_ENGLISH_UK:
posix = L"en_GB"; break;
case SUBLANG_ENGLISH_AUS:
posix = L"en_AU"; break;
case SUBLANG_ENGLISH_CAN:
posix = L"en_CA"; break;
default:
posix = L"en"; break;
}
break;
case LANG_SPANISH: posix = L"es"; break;
case LANG_BASQUE: posix = L"eu"; break;
case LANG_FINNISH: posix = L"fi"; break;
case LANG_FRENCH: posix = L"fr"; break;
case LANG_GALICIAN: posix = L"gl"; break;
case LANG_GUJARATI: posix = L"gu"; break;
case LANG_HEBREW: posix = L"he"; break;
case LANG_HINDI: posix = L"hi"; break;
case LANG_HUNGARIAN: posix = L"hu"; break;
case LANG_ICELANDIC: break;
case LANG_INDONESIAN: posix = L"id"; break;
case LANG_ITALIAN: posix = L"it"; break;
case LANG_JAPANESE: posix = L"ja"; break;
case LANG_GEORGIAN: posix = L"ka"; break;
case LANG_KANNADA: posix = L"kn"; break;
case LANG_KOREAN: posix = L"ko"; break;
case LANG_LITHUANIAN: posix = L"lt"; break;
case LANG_MACEDONIAN: posix = L"mk"; break;
case LANG_DUTCH: posix = L"nl"; break;
case LANG_NEPALI: posix = L"ne"; break;
case LANG_NORWEGIAN:
switch (sub_id) {
case SUBLANG_NORWEGIAN_BOKMAL:
posix = L"nb"; break;
case SUBLANG_NORWEGIAN_NYNORSK:
posix = L"nn"; break;
}
break;
case LANG_PUNJABI: posix = L"pa"; break;
case LANG_POLISH: posix = L"pl"; break;
case LANG_PASHTO: posix = L"ps"; break;
case LANG_PORTUGUESE:
switch (sub_id) {
case SUBLANG_PORTUGUESE_BRAZILIAN:
posix = L"pt_BR"; break;
default:
posix = L"pt"; break;
}
break;
case LANG_ROMANIAN: posix = L"ro"; break;
case LANG_RUSSIAN: posix = L"ru"; break;
case LANG_SLOVAK: posix = L"sk"; break;
case LANG_SLOVENIAN: posix = L"sl"; break;
case LANG_ALBANIAN: posix = L"sq"; break;
/* LANG_CROATIAN == LANG_SERBIAN == LANG_BOSNIAN */
case LANG_SERBIAN:
switch (sub_id) {
case SUBLANG_SERBIAN_LATIN:
posix = L"sr@Latn"; break;
case SUBLANG_SERBIAN_CYRILLIC:
posix = L"sr"; break;
case SUBLANG_BOSNIAN_BOSNIA_HERZEGOVINA_CYRILLIC:
case SUBLANG_BOSNIAN_BOSNIA_HERZEGOVINA_LATIN:
posix = L"bs"; break;
case SUBLANG_CROATIAN_BOSNIA_HERZEGOVINA_LATIN:
posix = L"hr"; break;
}
break;
case LANG_SWEDISH: posix = L"sv"; break;
case LANG_TAMIL: posix = L"ta"; break;
case LANG_TELUGU: posix = L"te"; break;
case LANG_THAI: posix = L"th"; break;
case LANG_TURKISH: posix = L"tr"; break;
case LANG_UKRAINIAN: posix = L"uk"; break;
case LANG_VIETNAMESE: posix = L"vi"; break;
case LANG_XHOSA: posix = L"xh"; break;
case LANG_CHINESE:
switch (sub_id) {
case SUBLANG_CHINESE_SIMPLIFIED:
posix = L"zh_CN"; break;
case SUBLANG_CHINESE_TRADITIONAL:
posix = L"zh_TW"; break;
default:
posix = L"zh"; break;
}
break;
case LANG_URDU: break;
case LANG_BELARUSIAN: break;
case LANG_LATVIAN: break;
case LANG_ARMENIAN: break;
case LANG_FAEROESE: break;
case LANG_MALAY: break;
case LANG_KAZAK: break;
case LANG_KYRGYZ: break;
case LANG_SWAHILI: break;
case LANG_UZBEK: break;
case LANG_TATAR: break;
case LANG_ORIYA: break;
case LANG_MALAYALAM: break;
case LANG_ASSAMESE: break;
case LANG_MARATHI: break;
case LANG_SANSKRIT: break;
case LANG_MONGOLIAN: break;
case LANG_KONKANI: break;
case LANG_MANIPURI: break;
case LANG_SINDHI: break;
case LANG_SYRIAC: break;
case LANG_KASHMIRI: break;
case LANG_DIVEHI: break;
}
/* Deal with exceptions */
if (posix == NULL) {
switch (lcid) {
case 0x0455: posix = L"my_MM"; break; /* Myanmar (Burmese) */
case 9999: posix = L"ku"; break; /* Kurdish (from NSIS) */
}
}
return posix;
}
BOOL CTortoiseGitBlameApp::InitInstance()
{
{
DWORD len = GetCurrentDirectory(0, NULL);
if (len)
{
std::unique_ptr<TCHAR[]> originalCurrentDirectory(new TCHAR[len]);
if (GetCurrentDirectory(len, originalCurrentDirectory.get()))
{
sOrigCWD = originalCurrentDirectory.get();
sOrigCWD = CPathUtils::GetLongPathname(sOrigCWD);
}
}
}
//set the resource dll for the required language
CRegDWORD loc = CRegDWORD(_T("Software\\TortoiseGit\\LanguageID"), 1033);
long langId = loc;
CString langDll;
HINSTANCE hInst = NULL;
do
{
langDll.Format(_T("%sLanguages\\TortoiseGitBlame%ld.dll"), (LPCTSTR)CPathUtils::GetAppParentDirectory(), langId);
hInst = LoadLibrary(langDll);
CString sVer = _T(STRPRODUCTVER);
CString sFileVer = CPathUtils::GetVersionFromFile(langDll);
if (sFileVer.Compare(sVer)!=0)
{
FreeLibrary(hInst);
hInst = NULL;
}
if (hInst != NULL)
AfxSetResourceHandle(hInst);
else
{
DWORD lid = SUBLANGID(langId);
lid--;
if (lid > 0)
{
langId = MAKELANGID(PRIMARYLANGID(langId), lid);
}
else
langId = 0;
}
} while ((hInst == NULL) && (langId != 0));
TCHAR buf[6] = { 0 };
_tcscpy_s(buf, _T("en"));
langId = loc;
CString sHelppath;
sHelppath = this->m_pszHelpFilePath;
sHelppath = sHelppath.MakeLower();
sHelppath.Replace(_T(".chm"), _T("_en.chm"));
free((void*)m_pszHelpFilePath);
m_pszHelpFilePath=_tcsdup(sHelppath);
sHelppath = CPathUtils::GetAppParentDirectory() + _T("Languages\\TortoiseGitBlame_en.chm");
do
{
GetLocaleInfo(MAKELCID(langId, SORT_DEFAULT), LOCALE_SISO639LANGNAME, buf, _countof(buf));
CString sLang = _T("_");
sLang += buf;
sHelppath.Replace(_T("_en"), sLang);
if (PathFileExists(sHelppath))
{
free((void*)m_pszHelpFilePath);
m_pszHelpFilePath=_tcsdup(sHelppath);
break;
}
sHelppath.Replace(sLang, _T("_en"));
GetLocaleInfo(MAKELCID(langId, SORT_DEFAULT), LOCALE_SISO3166CTRYNAME, buf, _countof(buf));
sLang += _T("_");
sLang += buf;
sHelppath.Replace(_T("_en"), sLang);
if (PathFileExists(sHelppath))
{
free((void*)m_pszHelpFilePath);
m_pszHelpFilePath=_tcsdup(sHelppath);
break;
}
sHelppath.Replace(sLang, _T("_en"));
DWORD lid = SUBLANGID(langId);
lid--;
if (lid > 0)
{
langId = MAKELANGID(PRIMARYLANGID(langId), lid);
}
else
langId = 0;
} while (langId);
setlocale(LC_ALL, "");
// We need to explicitly set the thread locale to the system default one to avoid possible problems with saving files in its original codepage
// The problems occures when the language of OS differs from the regional settings
// See the details here: http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=100887
SetThreadLocale(LOCALE_SYSTEM_DEFAULT);
// InitCommonControlsEx() is required on Windows XP if an application
// manifest specifies use of ComCtl32.dll version 6 or later to enable
// visual styles. Otherwise, any window creation will fail.
INITCOMMONCONTROLSEX InitCtrls;
InitCtrls.dwSize = sizeof(InitCtrls);
// Set this to include all the common control classes you want to use
// in your application.
InitCtrls.dwICC = ICC_WIN95_CLASSES;
InitCommonControlsEx(&InitCtrls);
CWinAppEx::InitInstance();
Gdiplus::GdiplusStartupInput gdiplusStartupInput;
Gdiplus::GdiplusStartup(&m_gdiplusToken,&gdiplusStartupInput,NULL);
// Initialize OLE libraries
if (!AfxOleInit())
{
AfxMessageBox(IDP_OLE_INIT_FAILED);
return FALSE;
}
AfxEnableControlContainer();
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need
// Change the registry key under which our settings are stored
SetRegistryKey(_T("TortoiseGit"));
LoadStdProfileSettings(4); // Load standard INI file options (including MRU)
InitContextMenuManager();
InitKeyboardManager();
InitTooltipManager();
CMFCToolTipInfo ttParams;
ttParams.m_bVislManagerTheme = TRUE;
theApp.GetTooltipManager()->SetTooltipParams(AFX_TOOLTIP_TYPE_ALL,
RUNTIME_CLASS(CMFCToolTipCtrl), &ttParams);
// Register the application's document templates. Document templates
// serve as the connection between documents, frame windows and views
CSingleDocTemplate* pDocTemplate;
pDocTemplate = new CSingleDocTemplate(
IDR_TORTOISE_GIT_BLAME_MAINFRAME,
RUNTIME_CLASS(CTortoiseGitBlameDoc),
RUNTIME_CLASS(CMainFrame), // main SDI frame window
RUNTIME_CLASS(CTortoiseGitBlameView));
if (!pDocTemplate)
return FALSE;
AddDocTemplate(pDocTemplate);
CCmdLineParser parser = CCmdLineParser(this->m_lpCmdLine);
g_sGroupingUUID = parser.GetVal(L"groupuuid");
// Parse command line for standard shell commands, DDE, file open
CCommandLineInfo cmdInfo;
ParseCommandLine(cmdInfo);
// Dispatch commands specified on the command line. Will return FALSE if
// app was launched with /RegServer, /Register, /Unregserver or /Unregister.
if (!ProcessShellCommand(cmdInfo))
return FALSE;
// The one and only window has been initialized, so show and update it
m_pMainWnd->ShowWindow(SW_SHOW);
m_pMainWnd->UpdateWindow();
// call DragAcceptFiles only if there's a suffix
// In an SDI app, this should occur after ProcessShellCommand
return TRUE;
}
BOOL ReadIni()
{
TCHAR lpszPath[ MAX_PATH * 2 ];
GetIniPath( lpszPath );
g_bLogging = !! GetPrivateProfileInt( TEXT( "Options" ), TEXT( "Logging" ), FALSE, lpszPath );
EnableLoggingIni( g_bLogging );
g_bSelChange = !! GetPrivateProfileInt( TEXT( "Options" ), TEXT( "SelChange" ), FALSE, lpszPath );
//0x04 LANG_CHINESE
//0x01 SUBLANG_CHINESE_TRADITIONAL Chinese (Traditional)
//0x02 SUBLANG_CHINESE_SIMPLIFIED Chinese (Simplified)
// WORD wDefLanguage = (WORD) PRIMARYLANGID( GetSystemDefaultLangID() );
WORD wDefLanguage = (WORD) PRIMARYLANGID( GetUserDefaultLangID() );
if( wDefLanguage == LANG_CHINESE )
{
WORD wSubLangId = (WORD) SUBLANGID( GetSystemDefaultLangID() );
wDefLanguage = ( wSubLangId == SUBLANG_CHINESE_TRADITIONAL )? LANG_CHINESE_T : LANG_CHINESE_S ;
}
else if( wDefLanguage != LANG_ENGLISH && wDefLanguage != LANG_FINNISH && wDefLanguage != LANG_JAPANESE
&& wDefLanguage != LANG_SPANISH )
{
wDefLanguage = LANG_ENGLISH;
}
WORD wLanguage = (WORD) GetPrivateProfileInt( TEXT( "Options" ), TEXT( "Language" ), (int) wDefLanguage, lpszPath );
if( wLanguage != LANG_ENGLISH && wLanguage != LANG_FINNISH && wLanguage != LANG_JAPANESE && wLanguage != LANG_JAPANESEo
&& wLanguage != LANG_CHINESE_T && wLanguage != LANG_CHINESE_S && wDefLanguage != LANG_SPANISH
&& wLanguage != LANG_FRENCH )
{
wLanguage = wDefLanguage;
}
SetLanguage( wLanguage );
g_Slider[ 0 ] = (BYTE) 33;
g_Slider[ 1 ] = (BYTE) 33;
g_Slider[ 2 ] = (BYTE) 33;
g_Slider[ 3 ] = (BYTE) 0;
int i, j;
TCHAR lpszKey[ 100 ];
g_iEnemyIndex = 0;
for( i = 0; i < MAX_PROCESS_CNT; i++ )
{
wsprintf( lpszKey, TEXT( "Enemy%d" ), i );
GetPrivateProfileString(
TEXT( "Enemy" ),
lpszKey,
TEXT( "" ),
g_lpszEnemy[ g_iEnemyIndex ],
MAX_PATH + 1,
lpszPath
);
if( lstrlen( g_lpszEnemy[ g_iEnemyIndex ] ) == 0 ) break;
else if( IsAbsFoe( g_lpszEnemy[ g_iEnemyIndex ] ) ) continue;
else if( _tcschr( g_lpszEnemy[ g_iEnemyIndex ], TEXT( '\\' ) ) != NULL ) continue;
PathToExeEx( g_lpszEnemy[ g_iEnemyIndex ], MAX_PATH + 1 );
for( j = 0; j < g_iEnemyIndex; j++ )
{
if( lstrcmpi( g_lpszEnemy[ j ], g_lpszEnemy[ g_iEnemyIndex ] ) == 0 ) goto NEXT_FOE;
}
g_iEnemyIndex++;
NEXT_FOE:
{
;
}
}
g_iFriendIndex = 0;
for( i = 0; i < MAX_PROCESS_CNT; i++ )
{
wsprintf( lpszKey, TEXT( "Friend%d" ), i );
GetPrivateProfileString(
TEXT( "Friend" ),
lpszKey,
TEXT( "" ),
g_lpszFriend[ g_iFriendIndex ],
MAX_PATH + 1,
lpszPath
);
if( lstrlen( g_lpszFriend[ g_iFriendIndex ] ) == 0 ) break;
else if( IsAbsFoe( g_lpszEnemy[ g_iFriendIndex ] ) ) continue;
else if( _tcschr( g_lpszEnemy[ g_iFriendIndex ], TEXT( '\\' ) ) != NULL ) continue;
PathToExeEx( g_lpszFriend[ g_iFriendIndex ], MAX_PATH + 1 );
for( j = 0; j < g_iFriendIndex; j++ )
{
if( lstrcmpi( g_lpszFriend[ j ], g_lpszFriend[ g_iFriendIndex ] ) == 0 ) goto NEXT_FRIEND;
}
for( j = 0; j < g_iEnemyIndex; j++ )
{
if( lstrcmpi( g_lpszEnemy[ j ], g_lpszFriend[ g_iFriendIndex ] ) == 0 ) goto NEXT_FRIEND;
}
g_iFriendIndex++;
NEXT_FRIEND:
{
;
}
}
return TRUE;
}
// CTortoiseMergeApp initialization
BOOL CTortoiseMergeApp::InitInstance()
{
SetDllDirectory(L"");
CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows));
CMFCButton::EnableWindowsTheming();
{
DWORD len = GetCurrentDirectory(0, NULL);
if (len)
{
auto_buffer<TCHAR> originalCurrentDirectory(len);
if (GetCurrentDirectory(len, originalCurrentDirectory))
{
sOrigCWD = originalCurrentDirectory;
sOrigCWD = CPathUtils::GetLongPathname(sOrigCWD);
}
}
}
//set the resource dll for the required language
CRegDWORD loc = CRegDWORD(_T("Software\\TortoiseGit\\LanguageID"), 1033);
long langId = loc;
CString langDll;
HINSTANCE hInst = NULL;
do
{
langDll.Format(_T("%sLanguages\\TortoiseMerge%d.dll"), (LPCTSTR)CPathUtils::GetAppParentDirectory(), langId);
hInst = LoadLibrary(langDll);
CString sVer = _T(STRPRODUCTVER);
CString sFileVer = CPathUtils::GetVersionFromFile(langDll);
if (sFileVer.Compare(sVer)!=0)
{
FreeLibrary(hInst);
hInst = NULL;
}
if (hInst != NULL)
AfxSetResourceHandle(hInst);
else
{
DWORD lid = SUBLANGID(langId);
lid--;
if (lid > 0)
{
langId = MAKELANGID(PRIMARYLANGID(langId), lid);
}
else
langId = 0;
}
} while ((hInst == NULL) && (langId != 0));
TCHAR buf[6];
_tcscpy_s(buf, _T("en"));
langId = loc;
CString sHelppath;
sHelppath = this->m_pszHelpFilePath;
sHelppath = sHelppath.MakeLower();
sHelppath.Replace(_T(".chm"), _T("_en.chm"));
free((void*)m_pszHelpFilePath);
m_pszHelpFilePath=_tcsdup(sHelppath);
sHelppath = CPathUtils::GetAppParentDirectory() + _T("Languages\\TortoiseMerge_en.chm");
do
{
GetLocaleInfo(MAKELCID(langId, SORT_DEFAULT), LOCALE_SISO639LANGNAME, buf, _countof(buf));
CString sLang = _T("_");
sLang += buf;
sHelppath.Replace(_T("_en"), sLang);
if (PathFileExists(sHelppath))
{
free((void*)m_pszHelpFilePath);
m_pszHelpFilePath=_tcsdup(sHelppath);
break;
}
sHelppath.Replace(sLang, _T("_en"));
GetLocaleInfo(MAKELCID(langId, SORT_DEFAULT), LOCALE_SISO3166CTRYNAME, buf, _countof(buf));
sLang += _T("_");
sLang += buf;
sHelppath.Replace(_T("_en"), sLang);
if (PathFileExists(sHelppath))
{
free((void*)m_pszHelpFilePath);
m_pszHelpFilePath=_tcsdup(sHelppath);
break;
}
sHelppath.Replace(sLang, _T("_en"));
DWORD lid = SUBLANGID(langId);
lid--;
if (lid > 0)
{
langId = MAKELANGID(PRIMARYLANGID(langId), lid);
}
else
langId = 0;
} while (langId);
setlocale(LC_ALL, "");
// We need to explicitly set the thread locale to the system default one to avoid possible problems with saving files in its original codepage
// The problems occures when the language of OS differs from the regional settings
// See the details here: http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=100887
SetThreadLocale(LOCALE_SYSTEM_DEFAULT);
// InitCommonControls() is required on Windows XP if an application
// manifest specifies use of ComCtl32.dll version 6 or later to enable
// visual styles. Otherwise, any window creation will fail.
InitCommonControls();
// Initialize all Managers for usage. They are automatically constructed
// if not yet present
InitContextMenuManager();
InitKeyboardManager();
CCmdLineParser parser = CCmdLineParser(this->m_lpCmdLine);
if (parser.HasKey(_T("?")) || parser.HasKey(_T("help")))
{
CString sHelpText;
sHelpText.LoadString(IDS_COMMANDLINEHELP);
MessageBox(NULL, sHelpText, _T("TortoiseMerge"), MB_ICONINFORMATION);
return FALSE;
}
// Initialize OLE libraries
if (!AfxOleInit())
{
AfxMessageBox(IDP_OLE_INIT_FAILED);
return FALSE;
}
AfxEnableControlContainer();
// Standard initialization
// If you are not using these features and wish to reduce the size
// of your final executable, you should remove from the following
// the specific initialization routines you do not need
// Change the registry key under which our settings are stored
SetRegistryKey(_T("TortoiseMerge"));
if (CRegDWORD(_T("Software\\TortoiseMerge\\Debug"), FALSE)==TRUE)
AfxMessageBox(AfxGetApp()->m_lpCmdLine, MB_OK | MB_ICONINFORMATION);
// To create the main window, this code creates a new frame window
// object and then sets it as the application's main window object
CMainFrame* pFrame = new CMainFrame;
if (pFrame == NULL)
return FALSE;
m_pMainWnd = pFrame;
// create and load the frame with its resources
pFrame->LoadFrame(IDR_MAINFRAME,
WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE, NULL,
NULL);
// Fill in the command line options
pFrame->m_Data.m_baseFile.SetFileName(parser.GetVal(_T("base")));
pFrame->m_Data.m_baseFile.SetDescriptiveName(parser.GetVal(_T("basename")));
pFrame->m_Data.m_theirFile.SetFileName(parser.GetVal(_T("theirs")));
pFrame->m_Data.m_theirFile.SetDescriptiveName(parser.GetVal(_T("theirsname")));
pFrame->m_Data.m_yourFile.SetFileName(parser.GetVal(_T("mine")));
pFrame->m_Data.m_yourFile.SetDescriptiveName(parser.GetVal(_T("minename")));
pFrame->m_Data.m_mergedFile.SetFileName(parser.GetVal(_T("merged")));
pFrame->m_Data.m_mergedFile.SetDescriptiveName(parser.GetVal(_T("mergedname")));
pFrame->m_Data.m_sPatchPath = parser.HasVal(_T("patchpath")) ? parser.GetVal(_T("patchpath")) : _T("");
pFrame->m_Data.m_sPatchPath.Replace('/', '\\');
if (parser.HasKey(_T("patchoriginal")))
pFrame->m_Data.m_sPatchOriginal = parser.GetVal(_T("patchoriginal"));
if (parser.HasKey(_T("patchpatched")))
pFrame->m_Data.m_sPatchPatched = parser.GetVal(_T("patchpatched"));
pFrame->m_Data.m_sDiffFile = parser.GetVal(_T("diff"));
pFrame->m_Data.m_sDiffFile.Replace('/', '\\');
if (parser.HasKey(_T("oneway")))
pFrame->m_bOneWay = TRUE;
if (parser.HasKey(_T("diff")))
pFrame->m_bOneWay = FALSE;
if (parser.HasKey(_T("reversedpatch")))
pFrame->m_bReversedPatch = TRUE;
if (pFrame->m_Data.IsBaseFileInUse() && !pFrame->m_Data.IsYourFileInUse() && pFrame->m_Data.IsTheirFileInUse())
{
pFrame->m_Data.m_yourFile.TransferDetailsFrom(pFrame->m_Data.m_theirFile);
}
if ((!parser.HasKey(_T("patchpath")))&&(parser.HasVal(_T("diff"))))
{
// a patchfile was given, but not folder path to apply the patch to
// If the patchfile is located inside a working copy, then use the parent directory
// of the patchfile as the target directory, otherwise ask the user for a path.
if (parser.HasKey(_T("wc")))
pFrame->m_Data.m_sPatchPath = pFrame->m_Data.m_sDiffFile.Left(pFrame->m_Data.m_sDiffFile.ReverseFind('\\'));
else
{
CBrowseFolder fbrowser;
fbrowser.m_style = BIF_EDITBOX | BIF_NEWDIALOGSTYLE | BIF_RETURNFSANCESTORS | BIF_RETURNONLYFSDIRS;
if (fbrowser.Show(NULL, pFrame->m_Data.m_sPatchPath)==CBrowseFolder::CANCEL)
return FALSE;
}
}
if ((parser.HasKey(_T("patchpath")))&&(!parser.HasVal(_T("diff"))))
{
// A path was given for applying a patchfile, but
// the patchfile itself was not.
// So ask the user for that patchfile
OPENFILENAME ofn = {0}; // common dialog box structure
TCHAR szFile[MAX_PATH] = {0}; // buffer for file name
// Initialize OPENFILENAME
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = pFrame->m_hWnd;
ofn.lpstrFile = szFile;
ofn.nMaxFile = _countof(szFile);
CString temp;
temp.LoadString(IDS_OPENDIFFFILETITLE);
if (temp.IsEmpty())
ofn.lpstrTitle = NULL;
else
ofn.lpstrTitle = temp;
ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_EXPLORER;
// check if there's a patchfile in the clipboard
UINT cFormat = RegisterClipboardFormat(_T("TSVN_UNIFIEDDIFF"));
if (cFormat)
{
if (OpenClipboard(NULL))
{
UINT enumFormat = 0;
do
{
if (enumFormat == cFormat)
{
// yes, there's a patchfile in the clipboard
ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_ENABLETEMPLATE | OFN_ENABLEHOOK | OFN_EXPLORER;
ofn.hInstance = AfxGetResourceHandle();
ofn.lpTemplateName = MAKEINTRESOURCE(IDD_PATCH_FILE_OPEN_CUSTOM);
ofn.lpfnHook = CreatePatchFileOpenHook;
}
} while((enumFormat = EnumClipboardFormats(enumFormat))!=0);
CloseClipboard();
}
}
CString sFilter;
sFilter.LoadString(IDS_PATCHFILEFILTER);
TCHAR * pszFilters = new TCHAR[sFilter.GetLength()+4];
_tcscpy_s (pszFilters, sFilter.GetLength()+4, sFilter);
// Replace '|' delimiters with '\0's
TCHAR *ptr = pszFilters + _tcslen(pszFilters); //set ptr at the NULL
while (ptr != pszFilters)
{
if (*ptr == '|')
*ptr = '\0';
ptr--;
}
ofn.lpstrFilter = pszFilters;
ofn.nFilterIndex = 1;
// Display the Open dialog box.
CString tempfile;
if (GetOpenFileName(&ofn)==FALSE)
{
delete [] pszFilters;
return FALSE;
}
delete [] pszFilters;
pFrame->m_Data.m_sDiffFile = ofn.lpstrFile;
}
if ( pFrame->m_Data.m_baseFile.GetFilename().IsEmpty() && pFrame->m_Data.m_yourFile.GetFilename().IsEmpty() )
{
LPWSTR *szArglist;
int nArgs;
szArglist = CommandLineToArgvW(GetCommandLineW(), &nArgs);
if( NULL == szArglist )
{
TRACE("CommandLineToArgvW failed\n");
}
else
{
if ( nArgs==3 || nArgs==4 )
{
// Four parameters:
// [0]: Program name
// [1]: BASE file
// [2]: my file
// [3]: THEIR file (optional)
// This is the same format CAppUtils::StartExtDiff
// uses if %base and %mine are not set and most
// other diff tools use it too.
if ( PathFileExists(szArglist[1]) && PathFileExists(szArglist[2]) )
{
pFrame->m_Data.m_baseFile.SetFileName(szArglist[1]);
pFrame->m_Data.m_yourFile.SetFileName(szArglist[2]);
if ( nArgs == 4 && PathFileExists(szArglist[3]) )
{
pFrame->m_Data.m_theirFile.SetFileName(szArglist[3]);
}
}
}
}
// Free memory allocated for CommandLineToArgvW arguments.
LocalFree(szArglist);
}
pFrame->m_bReadOnly = !!parser.HasKey(_T("readonly"));
if (GetFileAttributes(pFrame->m_Data.m_yourFile.GetFilename()) & FILE_ATTRIBUTE_READONLY)
pFrame->m_bReadOnly = true;
pFrame->m_bBlame = !!parser.HasKey(_T("blame"));
// diffing a blame means no editing!
if (pFrame->m_bBlame)
pFrame->m_bReadOnly = true;
// try to find a suitable window title
CString sYour = pFrame->m_Data.m_yourFile.GetDescriptiveName();
if (sYour.Find(_T(" - "))>=0)
sYour = sYour.Left(sYour.Find(_T(" - ")));
if (sYour.Find(_T(" : "))>=0)
sYour = sYour.Left(sYour.Find(_T(" : ")));
CString sTheir = pFrame->m_Data.m_theirFile.GetDescriptiveName();
if (sTheir.Find(_T(" - "))>=0)
sTheir = sTheir.Left(sTheir.Find(_T(" - ")));
if (sTheir.Find(_T(" : "))>=0)
sTheir = sTheir.Left(sTheir.Find(_T(" : ")));
if (!sYour.IsEmpty() && !sTheir.IsEmpty())
{
if (sYour.CompareNoCase(sTheir)==0)
pFrame->SetWindowText(sYour + _T(" - TortoiseMerge"));
else if ((sYour.GetLength() < 10) &&
(sTheir.GetLength() < 10))
pFrame->SetWindowText(sYour + _T(" - ") + sTheir + _T(" - TortoiseMerge"));
else
{
// we have two very long descriptive texts here, which
// means we have to find a way to use them as a window
// title in a shorter way.
// for simplicity, we just use the one from "yourfile"
pFrame->SetWindowText(sYour + _T(" - TortoiseMerge"));
}
}
else if (!sYour.IsEmpty())
pFrame->SetWindowText(sYour + _T(" - TortoiseMerge"));
else if (!sTheir.IsEmpty())
pFrame->SetWindowText(sTheir + _T(" - TortoiseMerge"));
if (parser.HasKey(_T("createunifieddiff")))
{
// user requested to create a unified diff file
CString origFile = parser.GetVal(_T("origfile"));
CString modifiedFile = parser.GetVal(_T("modifiedfile"));
if (!origFile.IsEmpty() && !modifiedFile.IsEmpty())
{
CString outfile = parser.GetVal(_T("outfile"));
if (outfile.IsEmpty())
{
OPENFILENAME ofn = {0}; // common dialog box structure
TCHAR szFile[MAX_PATH] = {0}; // buffer for file name
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.lpstrFile = szFile;
ofn.nMaxFile = _countof(szFile);
CString temp;
temp.LoadString(IDS_SAVEASTITLE);
if (!temp.IsEmpty())
ofn.lpstrTitle = temp;
ofn.Flags = OFN_OVERWRITEPROMPT;
CString sFilter;
sFilter.LoadString(IDS_COMMONFILEFILTER);
TCHAR * pszFilters = new TCHAR[sFilter.GetLength()+4];
_tcscpy_s (pszFilters, sFilter.GetLength()+4, sFilter);
// Replace '|' delimiters with '\0's
TCHAR *ptr = pszFilters + _tcslen(pszFilters); //set ptr at the NULL
while (ptr != pszFilters)
{
if (*ptr == '|')
*ptr = '\0';
ptr--;
}
ofn.lpstrFilter = pszFilters;
ofn.nFilterIndex = 1;
// Display the Save dialog box.
CString sFile;
if (GetSaveFileName(&ofn)==TRUE)
{
outfile = CString(ofn.lpstrFile);
}
delete [] pszFilters;
}
if (!outfile.IsEmpty())
{
CAppUtils::CreateUnifiedDiff(origFile, modifiedFile, outfile, false);
return FALSE;
}
}
}
// The one and only window has been initialized, so show and update it
pFrame->ActivateFrame();
pFrame->ShowWindow(SW_SHOW);
pFrame->UpdateWindow();
pFrame->ShowDiffBar(!pFrame->m_bOneWay);
if (!pFrame->m_Data.IsBaseFileInUse() && pFrame->m_Data.m_sPatchPath.IsEmpty() && pFrame->m_Data.m_sDiffFile.IsEmpty())
{
pFrame->OnFileOpen();
return TRUE;
}
return pFrame->LoadViews();
}
int main(int argc,char *argv[])
{
extern char* optarg;
extern int optind;
int optc;
int opti = 0;
int stdinc = 1;
int lose = 0;
int ret;
int i;
int cmdlen;
signal(SIGSEGV, segvhandler);
signal( SIGTERM, exit_on_signal );
signal( SIGINT, exit_on_signal );
#ifdef SIGHUP
signal( SIGHUP, exit_on_signal );
#endif
now = time(NULL);
/* Set the default defined stuff */
set_version_defines();
wpp_add_cmdline_define("RC_INVOKED=1");
wpp_add_cmdline_define("__WIN32__=1");
wpp_add_cmdline_define("__FLAT__=1");
/* Microsoft RC always searches current directory */
wpp_add_include_path(".");
/* First rebuild the commandline to put in destination */
/* Could be done through env[], but not all OS-es support it */
cmdlen = 4; /* for "wrc " */
for(i = 1; i < argc; i++)
cmdlen += strlen(argv[i]) + 1;
cmdline = (char *)xmalloc(cmdlen);
strcpy(cmdline, "wrc ");
for(i = 1; i < argc; i++)
{
strcat(cmdline, argv[i]);
if(i < argc-1)
strcat(cmdline, " ");
}
while((optc = getopt_long(argc, argv, short_options, long_options, &opti)) != EOF)
{
switch(optc)
{
case 1:
stdinc = 0;
break;
case 2:
if (debuglevel) warning("--use-temp-file option not yet supported, ignored.\n");
break;
case 3:
if (debuglevel) warning("--no-use-temp-file option not yet supported, ignored.\n");
break;
case 4:
if (strcmp(optarg, "cat") == 0) no_preprocess = 1;
else fprintf(stderr, "-P option not yet supported, ignored.\n");
break;
case 5:
printf(version_string);
exit(0);
break;
case 6:
debuglevel = strtol(optarg, NULL, 0);
break;
case 7:
switch(optarg[0])
{
case 'n':
case 'N':
byteorder = WRC_BO_NATIVE;
break;
case 'l':
case 'L':
byteorder = WRC_BO_LITTLE;
break;
case 'b':
case 'B':
byteorder = WRC_BO_BIG;
break;
default:
fprintf(stderr, "Byte ordering must be n[ative], l[ittle] or b[ig]\n");
lose++;
}
break;
case 8:
pedantic = 1;
wpp_set_pedantic(1);
break;
case 9:
verify_translations_mode = 1;
break;
case 'D':
wpp_add_cmdline_define(optarg);
break;
case 'E':
preprocess_only = 1;
break;
case 'F':
/* ignored for compatibility with windres */
break;
case 'h':
printf(usage);
exit(0);
case 'i':
if (!input_name) input_name = strdup(optarg);
else error("Too many input files.\n");
break;
case 'I':
wpp_add_include_path(optarg);
break;
case 'J':
if (strcmp(optarg, "rc16") == 0) extensions = 0;
else if (strcmp(optarg, "rc")) error("Output format %s not supported.\n", optarg);
break;
case 'l':
{
int lan;
lan = strtol(optarg, NULL, 0);
if (get_language_codepage(PRIMARYLANGID(lan), SUBLANGID(lan)) == -1)
error("Language %04x is not supported\n", lan);
currentlanguage = new_language(PRIMARYLANGID(lan), SUBLANGID(lan));
}
break;
case 'f':
if (*optarg != 'o') error("Unknown option: -f%s\n", optarg);
optarg++;
/* fall through */
case 'o':
if (!output_name) output_name = strdup(optarg);
else error("Too many output files.\n");
break;
case 'O':
if (strcmp(optarg, "res16") == 0)
{
win32 = 0;
wpp_del_define("__WIN32__");
wpp_del_define("__FLAT__");
}
else if (strcmp(optarg, "res")) warning("Output format %s not supported.\n", optarg);
break;
case 'r':
/* ignored for compatibility with rc */
break;
case 'U':
wpp_del_define(optarg);
break;
case 'v':
debuglevel = DEBUGLEVEL_CHAT;
break;
default:
lose++;
break;
}
}
if(lose)
{
fprintf(stderr, usage);
return 1;
}
/* If we do need to search standard includes, add them to the path */
if (stdinc)
{
wpp_add_include_path(INCLUDEDIR"/msvcrt");
wpp_add_include_path(INCLUDEDIR"/windows");
}
/* Check for input file on command-line */
if(optind < argc)
{
if (!input_name) input_name = argv[optind++];
else error("Too many input files.\n");
}
/* Check for output file on command-line */
if(optind < argc)
{
if (!output_name) output_name = argv[optind++];
else error("Too many output files.\n");
}
/* Kill io buffering when some kind of debuglevel is enabled */
if(debuglevel)
{
setbuf(stdout,0);
setbuf(stderr,0);
}
yydebug = debuglevel & DEBUGLEVEL_TRACE ? 1 : 0;
yy_flex_debug = debuglevel & DEBUGLEVEL_TRACE ? 1 : 0;
wpp_set_debug( (debuglevel & DEBUGLEVEL_PPLEX) != 0,
(debuglevel & DEBUGLEVEL_PPTRACE) != 0,
(debuglevel & DEBUGLEVEL_PPMSG) != 0 );
/* Check if the user set a language, else set default */
if(!currentlanguage)
currentlanguage = new_language(0, 0);
/* Generate appropriate outfile names */
if(!output_name && !preprocess_only)
{
output_name = dup_basename(input_name, ".rc");
strcat(output_name, ".res");
}
atexit(cleanup_files);
/* Run the preprocessor on the input */
if(!no_preprocess)
{
/*
* Preprocess the input to a temp-file, or stdout if
* no output was given.
*/
chat("Starting preprocess");
if (!preprocess_only)
{
ret = wpp_parse_temp( input_name, output_name, &temp_name );
}
else if (output_name)
{
FILE *output;
if (!(output = fopen( output_name, "w" )))
error( "Could not open %s for writing\n", output_name );
ret = wpp_parse( input_name, output );
fclose( output );
}
else
{
ret = wpp_parse( input_name, stdout );
}
if(ret)
exit(1); /* Error during preprocess */
if(preprocess_only)
{
output_name = NULL;
exit(0);
}
input_name = temp_name;
}
/* Go from .rc to .res */
chat("Starting parse");
if(!(yyin = fopen(input_name, "rb")))
error("Could not open %s for input\n", input_name);
ret = yyparse();
if(input_name) fclose(yyin);
if(ret) exit(1); /* Error during parse */
if(debuglevel & DEBUGLEVEL_DUMP)
dump_resources(resource_top);
if(verify_translations_mode)
{
verify_translations(resource_top);
exit(0);
}
/* Convert the internal lists to binary data */
resources2res(resource_top);
chat("Writing .res-file");
write_resfile(output_name, resource_top);
output_name = NULL;
return 0;
}
BOOLEAN
McWriteBinaryFilesA( void )
{
PNAME_INFO LanguageName, *pp;
PLANGUAGE_INFO LanguageInfo;
PMESSAGE_INFO MessageInfo;
PMESSAGE_BLOCK BlockInfo;
char *FileName;
ULONG cb, cbNeeded;
ULONG MessageOffset;
MESSAGE_RESOURCE_ENTRY MessageEntry;
MESSAGE_RESOURCE_BLOCK MessageBlock;
MESSAGE_RESOURCE_DATA MessageData;
ULONG Zeroes = 0;
ULONG NumberOfMessages;
LPBYTE lpBuf;
ULONG Size = 256;
FileName = BinaryMessageFileName;
FileName += strlen( FileName );
lpBuf = malloc( Size );
if (!lpBuf) {
McInputErrorA( "Out of memory writing to output file - %s", TRUE, BinaryMessageFileName );
return( FALSE );
}
pp = &LanguageNames;
while (LanguageName = *pp) {
pp = &LanguageName->Next;
if (!LanguageName->Used) {
continue;
}
WideCharToMultiByte( CP_OEMCP, 0, LanguageName->Value, -1, FileName,
sizeof( BinaryMessageFileName ) - strlen( FileName ), NULL, NULL );
strcat( FileName, ".bin" );
if (!(BinaryMessageFile = fopen( BinaryMessageFileName, "wb" ))) {
McInputErrorA( "unable to open output file - %s", TRUE, BinaryMessageFileName );
return( FALSE );
}
if (VerboseOutput) {
fprintf( stderr, "Writing %s\n", BinaryMessageFileName );
}
fprintf( RcInclFile, "LANGUAGE 0x%x,0x%x\r\n",
PRIMARYLANGID( LanguageName->Id ),
SUBLANGID( LanguageName->Id )
);
fprintf( RcInclFile, "1 11 %s\r\n", FileName );
NumberOfMessages = 0L;
MessageData.NumberOfBlocks = NumberOfBlocks;
MessageOffset = fwrite( &MessageData,
1,
(size_t)FIELD_OFFSET( MESSAGE_RESOURCE_DATA,
Blocks[ 0 ]
),
BinaryMessageFile
);
MessageOffset += NumberOfBlocks * sizeof( MessageBlock );
BlockInfo = MessageBlocks;
while (BlockInfo) {
MessageBlock.LowId = BlockInfo->LowId;
MessageBlock.HighId = BlockInfo->HighId;
MessageBlock.OffsetToEntries = MessageOffset;
fwrite( &MessageBlock, 1, sizeof( MessageBlock ), BinaryMessageFile );
BlockInfo->InfoLength = 0;
MessageInfo = BlockInfo->LowInfo;
while (MessageInfo != NULL && MessageInfo->Id <= BlockInfo->HighId) {
LanguageInfo = MessageInfo->MessageText;
while (LanguageInfo) {
if (LanguageInfo->Id == LanguageName->Id) {
break;
}
else {
LanguageInfo = LanguageInfo->Next;
}
}
if (LanguageInfo != NULL) {
cb = FIELD_OFFSET( MESSAGE_RESOURCE_ENTRY, Text[ 0 ] ) +
WideCharToMultiByte( LanguageName->CodePage,
0,
LanguageInfo->Text,
LanguageInfo->Length,
NULL, 0, NULL, NULL ) + 1;
cb = (cb + 3) & ~3;
BlockInfo->InfoLength += cb;
}
else {
fprintf( stderr,
"MC: No %ws language text for %ws\n",
LanguageName->Name,
MessageInfo->SymbolicName
);
fclose( BinaryMessageFile );
return( FALSE );
}
MessageInfo = MessageInfo->Next;
}
if (VerboseOutput) {
fprintf( stderr, " [%08lx .. %08lx] - %lu bytes\n",
BlockInfo->LowId,
BlockInfo->HighId,
BlockInfo->InfoLength
);
}
MessageOffset += BlockInfo->InfoLength;
BlockInfo = BlockInfo->Next;
}
BlockInfo = MessageBlocks;
while (BlockInfo) {
MessageInfo = BlockInfo->LowInfo;
while (MessageInfo != NULL && MessageInfo->Id <= BlockInfo->HighId) {
LanguageInfo = MessageInfo->MessageText;
while (LanguageInfo) {
if (LanguageInfo->Id == LanguageName->Id) {
break;
}
else {
LanguageInfo = LanguageInfo->Next;
}
}
if (LanguageInfo != NULL) {
cbNeeded = WideCharToMultiByte( LanguageName->CodePage,
0,
LanguageInfo->Text,
LanguageInfo->Length,
NULL, 0, NULL, NULL );
cb = FIELD_OFFSET( MESSAGE_RESOURCE_ENTRY, Text[ 0 ] ) +
cbNeeded + 1;
cb = (cb + 3) & ~3;
MessageEntry.Length = (USHORT)cb;
MessageEntry.Flags = 0;
cb = fwrite( &MessageEntry,
1,
(size_t)FIELD_OFFSET( MESSAGE_RESOURCE_ENTRY,
Text[ 0 ]
),
BinaryMessageFile
);
if (Size < cbNeeded ) {
lpBuf = realloc( lpBuf, cbNeeded );
if (!lpBuf) {
McInputErrorA( "Out of memory writing to output file - %s",
TRUE, BinaryMessageFileName );
return( FALSE );
}
Size = cbNeeded;
}
WideCharToMultiByte( LanguageName->CodePage,
0,
LanguageInfo->Text,
LanguageInfo->Length,
lpBuf, cbNeeded, NULL, NULL );
cb += fwrite( lpBuf,
1,
(size_t)cbNeeded,
BinaryMessageFile
);
NumberOfMessages++;
cb = MessageEntry.Length - cb;
if (cb) {
fwrite( &Zeroes,
1,
(size_t)cb,
BinaryMessageFile
);
}
}
MessageInfo = MessageInfo->Next;
}
BlockInfo = BlockInfo->Next;
}
if (VerboseOutput) {
fprintf( stderr, " Total of %lu messages, %lu bytes\n",
NumberOfMessages,
ftell( BinaryMessageFile )
);
}
fclose( BinaryMessageFile );
McClearArchiveBit( BinaryMessageFileName );
}
free( lpBuf );
return( TRUE );
}
