📄 utility.c
字号:
//
//
// Copyright (C) 1995-1998 TechnoCraft. All Rights Reserved.
//
// MODULE: UTILITY.C
//
#include <windows.h>
#include "utility.h"
extern char szRoboNlsPath[255];
extern HANDLE g_hInstNls;
#pragma warning(disable:4033)
#pragma warning(disable:4704)
WORD WINAPI Decode_CHS(WORD code)
{
__asm mov ax,code
__asm cmp ah,0A1h
__asm jb __error
__asm cmp al,0A1h
__asm jb __error
__asm sub ax,0A1A1h
__asm mov dl,ah
__asm xor dh,dh
__asm mov ah,94
__asm mul ah
__asm add ax,dx
return;
__error:
return 0xFFFF;
}
#pragma warning(disable:4033)
#pragma warning(disable:4704)
WORD WINAPI Decode_CHT(WORD code)
{
short wTemp;
__asm mov ax,code
__asm shr ax,8
__asm and ax,0FFh
__asm and ax,0FFh
__asm cmp ax,40h
__asm jge short loc_0287
__asm jmp loc_0289
loc_0287:
__asm mov ax,code
__asm shr ax,8
__asm and ax,0FFh
__asm and ax,0FFh
__asm cmp ax,7Eh
__asm jle short loc_0288
__asm jmp loc_0289
loc_0288:
__asm mov ax,code
__asm shr ax,8
__asm and ax,0FFh
__asm and ax,0FFh
__asm mov wTemp,ax
__asm mov ax,word ptr [ebp+6]
__asm mov ax, code
__asm and ax,0FFh
__asm add ax,0FF5Fh
__asm imul ax,ax,9Dh
__asm mov cx,wTemp
__asm add ax,cx
__asm add ax,0FFC0h
__asm jmp loc_0290
loc_0289:
__asm mov ax,code
__asm shr ax,8
__asm and ax,0FFh
__asm and ax,0FFh
__asm mov wTemp,ax
__asm mov ax,code
__asm and ax,0FFh
__asm add ax,0FF5Fh
__asm imul ax,ax,9Dh
__asm mov cx,wTemp
__asm add ax,cx
__asm add ax,0FF9Eh
loc_0290:
__asm mov wTemp, ax
return wTemp;
}
static WORD nKanaToSJIS[] = {
0x8142,0x8175,0x8176,0x8141,0x8145,0x8392,
0x8340,0x8342,0x8344,0x8346,0x8348,0x8383,
0x8385,0x8387,0x8362,0x815b,0x8341,0x8343,
0x8345,0x8347,0x8349,0x834a,0x834c,0x834e,
0x8350,0x8352,0x8354,0x8356,0x8358,0x835a,
0x835c,0x835e,0x8360,0x8363,0x8365,0x8367,
0x8369,0x836a,0x836b,0x836c,0x836d,0x836e,
0x8371,0x8374,0x8377,0x837a,0x837d,0x837e,
0x8380,0x8381,0x8382,0x8384,0x8386,0x8388,
0x8389,0x838a,0x838b,0x838c,0x838d,0x838f,
0x8393,0x814a,0x814b
};
#pragma warning(disable:4033)
#pragma warning(disable:4704)
#pragma warning(disable: 4035) // shut off warning about return value
WORD WINAPI Decode_JPN(WORD wCode)
{
WORD w1, w2, w3;
__asm push cx
__asm mov ax, wCode
__asm or ah, ah
__asm jz __kana
__asm xchg ah, al
__Again:
__asm mov w1,ax
__asm cmp ax,8140h
__asm jb __l2
__asm cmp ax,9FFDh
__asm jb __l1
__asm cmp ax,0E040h
__asm jb __l2
__l1:
__asm cmp w1,0FCFDh
__asm jb __l3
__l2:
__asm mov ax,0FFFFh
__asm pop cx
return;
__kana:
__asm cmp ax, 0A1h
__asm jb __l2
__asm cmp ax, 0DFh
__asm ja __l2
__asm sub ax, 0A1h
__asm mov si, ax
__asm add si, ax
__asm and esi, 0xFF
__asm mov ax, word ptr nKanaToSJIS[esi]
__asm jmp __Again;
__l3:
__asm cmp w1,0E040h
__asm jb __l4
__asm sub w1,4000h
__l4:
__asm sub w1,8100h
__asm mov al,byte ptr w1
__asm sub ah,ah
__asm mov w2,ax
__asm mov ax,w1
__asm mov cl,8
__asm shr ax,cl
__asm mov w3,ax
__asm cmp w2,40h
__asm jb __l2
__asm cmp w2,7Fh
__asm je __l2
__asm cmp w2,0FDh
__asm jae __l2
__asm cmp w2,7Fh
__asm jbe __l5
__asm dec w2
__l5:
__asm sub w2,40h
__asm mov ax,w3
__asm mov w1,ax
__asm mov ax,0BCh
__asm mul w1
__asm mov w1,ax
__asm mov ax,w2
__asm add w1,ax
__asm mov ax, w1
__asm pop cx
return;
}
#pragma warning(disable:4033)
#pragma warning(disable:4704)
WORD WINAPI Decode_KOR(WORD code)
{
__asm mov ax,code
__asm cmp ah,0A1h
__asm jb __error
__asm cmp al,0A1h
__asm jb __error
// __asm xchg al, ah ; only difference from GB
__asm sub ax,0A1A1h
__asm mov dl,ah
__asm xor dh,dh
__asm mov ah,94
__asm mul ah
__asm add ax,dx
return;
__error:
return 0xFFFF;
}
BOOL WINAPI IsMiddleByte_CHS(BYTE aByte)
{
return FALSE;
}
BOOL WINAPI IsLeadByte_CHS(BYTE aByte)
{
if (aByte >= 0xA1 && aByte <= 0xFE)
return TRUE;
else
return FALSE;
}
BOOL WINAPI IsLeadByteFollow_CHS(BYTE aByte)
{
if (aByte >= 0xA1 && aByte <= 0xFE)
return TRUE;
else
return FALSE;
}
BOOL WINAPI IsMiddleByte_CHT(BYTE aByte)
{
return FALSE;
}
BOOL WINAPI IsLeadByte_CHT(BYTE aByte)
{
return (aByte < 0xA1U || aByte > 0xFEU)? FALSE : TRUE;
}
BOOL WINAPI IsLeadByteFollow_CHT(BYTE aByte)
{
return ((aByte >= 0x40U && aByte <= 0x7eU) ||
(aByte >= 0xa1U && aByte <= 0xfeU)) ? TRUE : FALSE;
}
BOOL WINAPI IsMiddleByte_JPN(BYTE aByte)
{
// Modified by LQH, 97-9-13 from (9e, e1)
return (aByte <= 0xdf && aByte >= 0xa1);
}
BOOL WINAPI IsLeadByte_JPN(BYTE aByte)
{
return ((aByte >= 0x81 && aByte <= 0x9f) ||
(aByte >= 0xe0 && aByte <= 0xf9));
}
BOOL WINAPI IsLeadByteFollow_JPN(BYTE aByte)
{
return (aByte > 0xFF || aByte < 0x40)? FALSE : TRUE;
}
BOOL WINAPI IsMiddleByte_KOR(BYTE aByte)
{
return FALSE;
}
BOOL WINAPI IsLeadByte_KOR(BYTE aByte)
{
if (aByte >= 0xA1 && aByte <= 0xFE)
return TRUE;
else
return FALSE;
}
BOOL WINAPI IsLeadByteFollow_KOR(BYTE aByte)
{
if (aByte >= 0xA1 && aByte <= 0xFE)
return TRUE;
else
return FALSE;
}
BOOL WINAPI IsMiddleByte_ENU(BYTE aByte)
{
return FALSE;
}
BOOL WINAPI IsLeadByte_ENU(BYTE aByte)
{
return FALSE;
}
BOOL WINAPI IsLeadByteFollow_ENU(BYTE aByte)
{
return FALSE;
}
BOOL WINAPI TCIsDBCSMiddleByte(WORD wCharSet, BYTE aByte)
{
if(wCharSet == 0) return IsMiddleByte_ENU(aByte);
else if(wCharSet == 128) return IsMiddleByte_JPN(aByte);
else if(wCharSet == 129) return IsMiddleByte_KOR(aByte);
else if(wCharSet == 134) return IsMiddleByte_CHS(aByte);
else if(wCharSet == 136) return IsMiddleByte_CHT(aByte);
else return IsMiddleByte_ENU(aByte);
}
BOOL WINAPI TCIsDBCSLeadByte(WORD wCharSet, BYTE aByte)
{
if(wCharSet == 0) return IsLeadByte_ENU(aByte);
else if(wCharSet == 128) return IsLeadByte_JPN(aByte);
else if(wCharSet == 129) return IsLeadByte_KOR(aByte);
else if(wCharSet == 134) return IsLeadByte_CHS(aByte);
else if(wCharSet == 136) return IsLeadByte_CHT(aByte);
else return IsLeadByte_ENU(aByte);
}
BOOL WINAPI TCIsDBCSLeadByteFollow(WORD wCharSet, BYTE aByte)
{
if(wCharSet == 0) return IsLeadByteFollow_ENU(aByte);
else if(wCharSet == 128) return IsLeadByteFollow_JPN(aByte);
else if(wCharSet == 129) return IsLeadByteFollow_KOR(aByte);
else if(wCharSet == 134) return IsLeadByteFollow_CHS(aByte);
else if(wCharSet == 136) return IsLeadByteFollow_CHT(aByte);
else return IsLeadByteFollow_ENU(aByte);
}
WORD WINAPI TCCharSetToCodePage(WORD wCharSet)
{
if(wCharSet == 0) return 1252; // ANSI_CHARSET
else if(wCharSet == 2) return 1252; // SYMBOL_CHARSET
else if(wCharSet == 128) return 932; // SHIFTJIS_CHARSET
else if(wCharSet == 129) return 949; // HANGEUL_CHARSET
else if(wCharSet == 134) return 936; // GB2312_CHARSET
else if(wCharSet == 136) return 950; // CHINESEBIG5_CHARSET
else if(wCharSet == 130) return 1361; // JOHAB_CHARSET
else if(wCharSet == 177) return 1255; // HEBREW_CHARSET
else if(wCharSet == 178) return 1256; // ARABIC_CHARSET
else if(wCharSet == 161) return 1253; // GREEK_CHARSET
else if(wCharSet == 162) return 1254; // TURKEY_CHARSET
else if(wCharSet == 163) return 1258; // VIETNAMESE_CHARSET
else if(wCharSet == 222) return 874; // THAI_CHARSET
else if(wCharSet == 238) return 1250; // EASTEUROPE_CHARSET
else if(wCharSet == 204) return 866; // RUSSIAN_CHARSET
else if(wCharSet == 186) return 1257; // BALTIC_CHARSET
else return 1252; // ANSI_CHARSET
}
WORD BinarySearch(LPWORD lpW, WORD wCode)
{
}
WORD WINAPI IndexFromCode(WORD wCharSet, WORD wCode)
{
if(wCharSet == 128) {
return Decode_JPN(wCode);
}
else if(wCharSet == 134) {
return Decode_CHS(wCode);
}
else if(wCharSet == 136) {
return Decode_CHT(wCode);
}
else if(wCharSet == 129) {
return Decode_KOR(wCode);
}
return wCode;
}
int WINAPI TCMB2WC(
WORD wCharSet,
LPCSTR lpMultiByteStr,
int cchMultiByte,
LPWSTR lpWideCharStr,
int cchWideChar )
{
HRSRC hFound;
HGLOBAL hRes;
LPWORD lpBuff;
int nLen, i, j = 0;
WORD wTemp, wMax;
int nChar;
nChar = MultiByteToWideChar(TCCharSetToCodePage(wCharSet),
0, lpMultiByteStr, cchMultiByte, NULL, 0);
if(nChar) {
if(cchWideChar == 0) return nChar;
return MultiByteToWideChar(TCCharSetToCodePage(wCharSet),
0, lpMultiByteStr, cchMultiByte, lpWideCharStr, cchWideChar);
}
else {
if(cchWideChar == 0 || lpWideCharStr == NULL) {
nLen = cchMultiByte;
if(nLen < 0) nLen = lstrlen(lpMultiByteStr);
j = 0;
for (i=0;i< nLen;i++) {
if ((i < nLen-1) && TCIsDBCSLeadByte((WORD)wCharSet, lpMultiByteStr[i]) &&
TCIsDBCSLeadByteFollow((WORD)wCharSet, lpMultiByteStr[i+1])) {
j++;
i++;
}
else if(TCIsDBCSMiddleByte((WORD) wCharSet, lpMultiByteStr[i])) {
j++;
}
// Added by LQH, 1997-9-26
else j++;
// End of Add
}
j++;
}
else {
hFound = FindResource(g_hInstNls, MAKEINTRESOURCE(wCharSet+0xFF), RT_RCDATA);
if(g_hInstNls && hFound) {
nLen = cchMultiByte;
if(nLen < 0) nLen = lstrlen(lpMultiByteStr);
hRes = LoadResource(g_hInstNls, hFound);
lpBuff = (LPWORD) LockResource(hRes);
wMax = (WORD) *lpBuff;
wMax -= 1;
j = 0;
for (i=0;i< nLen;i++) {
if ((i < nLen-1) && TCIsDBCSLeadByte((WORD)wCharSet, lpMultiByteStr[i]) &&
TCIsDBCSLeadByteFollow((WORD)wCharSet, lpMultiByteStr[i+1])) {
wTemp = MAKEWORD(lpMultiByteStr[i], lpMultiByteStr[i+1]);
wTemp = IndexFromCode(wCharSet, wTemp);
if(wTemp < wMax) lpWideCharStr[j] = (WORD) lpBuff[wTemp+1];
else lpWideCharStr[j] = 0x0;
j++;
i++;
}
else if(TCIsDBCSMiddleByte((WORD) wCharSet, lpMultiByteStr[i])) {
wTemp = MAKEWORD(lpMultiByteStr[i], 0);
wTemp = IndexFromCode(wCharSet, wTemp);
if(wTemp < wMax) lpWideCharStr[j] = (WORD) lpBuff[wTemp+1];
else lpWideCharStr[j] = lpMultiByteStr[i] & 0x00FF;
j++;
}
// Added by LQH, 1997-9-26
else {
lpWideCharStr[j] = lpMultiByteStr[i] & 0x00FF;
j++;
}
// End of Add
}
lpWideCharStr[j] = 0x0;
UnlockResource(hRes);
FreeResource(hRes);
// Deleted by Lijun, 1997-12-12
//j++;
// End of Delete
}
}
}
return j;
}
int WINAPI GetIndex(LPWORD lpIn, WCHAR WideChar)
{
WORD l = 1, r = *lpIn - 2, x;
while(r >= l) {
x = (l + r) /2;
if(WideChar < lpIn[x]) r = x - 1; else l = x + 1;
if(WideChar == lpIn[x]) return x;
}
return -1;
}
int WINAPI TCWC2MB(
WORD wCharSet,
LPCWSTR lpWideCharStr,
int cchWideChar,
LPSTR lpMultiByteStr,
int cchMultiByte
)
{
HRSRC hFound;
HGLOBAL hRes;
LPWORD lpBuffWC, lpBuffMB, lpW;
int nLen, i, j = 0;
int nMax;
int nTemp;
int nChar;
char defchar = '\0';
nChar = WideCharToMultiByte(TCCharSetToCodePage(wCharSet), 0, lpWideCharStr,
cchWideChar, NULL, 0, &defchar, NULL);
if(nChar) {
if(cchMultiByte == 0) return nChar;
else return WideCharToMultiByte(TCCharSetToCodePage(wCharSet), 0, lpWideCharStr,
cchWideChar, lpMultiByteStr, cchMultiByte, &defchar, NULL);
}
else {
if(cchMultiByte == 0 || lpMultiByteStr == NULL) {
nLen = cchWideChar;
if(nLen < 0) nLen = wcslen(lpWideCharStr);
j = 2 * nLen;
}
else {
hFound = FindResource(g_hInstNls, MAKEINTRESOURCE(wCharSet), RT_RCDATA);
if(g_hInstNls && hFound) {
lpW = (LPWORD) lpMultiByteStr;
nLen = cchWideChar;
if(nLen < 0) nLen = wcslen(lpWideCharStr);
hRes = LoadResource(g_hInstNls, hFound);
lpBuffWC = (LPWORD) LockResource(hRes);
nMax = (int) *lpBuffWC;
lpBuffMB = (LPWORD) lpBuffWC + nMax;
j = 0;
for(i = 0; i < nLen; i++) {
nTemp = GetIndex(lpBuffWC, lpWideCharStr[i]);
nTemp -= 1;
if((nTemp < nMax) && (nTemp >= 0)) {
// lpW[i] = (WORD) lpBuffMB[nTemp];
*lpW++ = (WORD) lpBuffMB[nTemp];
j += 2;
}
else {
// lpW[i] = (WORD) lpWideCharStr[i] & 0x00FF;
*(LPBYTE) lpW = (BYTE) lpWideCharStr[i] & 0x00FF;
(LPBYTE) lpW += 1;
j++;
}
}
// j = 2 * nLen;
j++;
UnlockResource(hRes);
FreeResource(hRes);
}
}
}
return j;
}
BOOL WINAPI TCGetTextExtentPoint32(HDC hdc, LPCTSTR lpString, int cbString,
LPSIZE lpSize, WORD wSrcCharSet)
{
BOOL bRet;
if (cbString <= 0) {
lpSize->cx = lpSize->cy = 0;
return TRUE;
}
if (wSrcCharSet == ANSI_CHARSET || wSrcCharSet == SYMBOL_CHARSET || (GetACP() == (UINT) wSrcCharSet)) {
bRet = GetTextExtentPoint32A(hdc, lpString, cbString, lpSize);
}
else {
int nLen;
nLen = TCMB2WC(wSrcCharSet, lpString, cbString, (LPWSTR) NULL, 0);
if (nLen > 0) {
HGLOBAL hMem = GlobalAlloc(GHND, (nLen + 1) * sizeof(WCHAR));
LPWSTR lpwStr = (LPWSTR)GlobalLock(hMem);
TCMB2WC(wSrcCharSet, lpString, cbString, lpwStr, nLen);
bRet = GetTextExtentPoint32W(hdc, lpwStr, nLen, lpSize);
GlobalUnlock(hMem);
GlobalFree(hMem);
}
}
return bRet;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -