2315 lines
45 KiB
C++
2315 lines
45 KiB
C++
/*****************************************************************************
|
|
* *
|
|
* BTKEY.C *
|
|
* *
|
|
* Copyright (C) Microsoft Corporation 1989, 1990. *
|
|
* All Rights reserved. *
|
|
* *
|
|
******************************************************************************
|
|
* *
|
|
* Module Intent *
|
|
* *
|
|
* Functions to deal with (i.e. size, compare) keys of all types. *
|
|
* *
|
|
*****************************************************************************/
|
|
#include "stdafx.h"
|
|
|
|
#include "btpriv.h"
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
int STDCALL IsPhoneticOrder(UINT);
|
|
|
|
/***************************************************************************\
|
|
*
|
|
- Function: WCmpKey( key1, key2, qbthr )
|
|
-
|
|
* Purpose: Compare two keys.
|
|
*
|
|
* ASSUMES
|
|
* args IN: key1, key2 - the UNCOMPRESSED keys to compare
|
|
* qbthr->bth.rgchFormat[0] - key type
|
|
* [qbthr->??? - other info ???]
|
|
* state IN: [may someday use state if comparing compressed keys]
|
|
*
|
|
* PROMISES
|
|
* returns: -1 if key1 < key2; 0 if key1 == key2; 1 if key1 > key2
|
|
* args OUT: [if comparing compressed keys, change state in qbthr->???]
|
|
* state OUT:
|
|
*
|
|
* Notes: Might be best to have this routine assume keys are expanded
|
|
* and do something else to compare keys in the scan routines.
|
|
* We're assuming fixed length keys are PSTRs. Alternative
|
|
* would be to use a memcmp() function.
|
|
*
|
|
\***************************************************************************/
|
|
|
|
int STDCALL WCmpKey(KEY key1, KEY key2, KT kt)
|
|
{
|
|
switch (kt) {
|
|
case KT_SZ:
|
|
case KT_SZMIN:
|
|
case '1': case '2': case '3': case '4': case '5': // assume null term
|
|
case '6': case '7': case '8': case '9': case 'a':
|
|
case 'b': case 'c': case 'd': case 'e': case 'f':
|
|
|
|
// DO NOT USE lstrcmp -- it produces a different sort order
|
|
|
|
return strcmp((PSTR) key1, (PSTR) key2);
|
|
break;
|
|
|
|
case KT_SZI:
|
|
return WCmpiSz((PSTR) key1, (PSTR) key2);
|
|
break;
|
|
|
|
case KT_SZISCAND:
|
|
return WCmpiScandSz((PSTR) key1, (PSTR) key2);
|
|
break;
|
|
|
|
case KT_LONG:
|
|
{
|
|
LONG l1 = *(LONG *)key1;
|
|
LONG l2 = *(LONG *)key2;
|
|
if ( l1 < l2 )
|
|
return -1;
|
|
else if ( l2 < l1 )
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
break;
|
|
|
|
case KT_SZIJAPAN:
|
|
return WCmpiJapanSz((PSTR) key1, (PSTR) key2);
|
|
|
|
case KT_SZIKOREA:
|
|
return WCmpiKoreaSz((PSTR) key1, (PSTR) key2);
|
|
|
|
case KT_SZITAIWAN:
|
|
return WCmpiTaiwanSz((PSTR) key1, (PSTR) key2);
|
|
|
|
case KT_NLSI:
|
|
return WNlsCmpiSz((PSTR) key1, (PSTR) key2);
|
|
|
|
case KT_NLS:
|
|
return WNlsCmpSz((PSTR) key1, (PSTR) key2);
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/***************************************************************************\
|
|
*
|
|
- Function: CbSizeKey( key, qbthr, fCompressed )
|
|
-
|
|
* Purpose: Return the key size (compressed or un-) in bytes
|
|
*
|
|
* ASSUMES
|
|
* args IN: key
|
|
* qbthr
|
|
* fCompressed - fTrue to get the compressed size,
|
|
* FALSE to get the uncompressed size.
|
|
*
|
|
* PROMISES
|
|
* returns: size of the key in bytes
|
|
*
|
|
* Note: It's impossible to tell how much suffix was discarded for
|
|
* the KT_*MIN key types.
|
|
*
|
|
\***************************************************************************/
|
|
|
|
#define CbLenSt(PBYTE) ((WORD) *(PBYTE))
|
|
|
|
int STDCALL CbSizeKey(KEY key, QBTHR qbthr, BOOL fCompressed)
|
|
{
|
|
KT kt = (KT)qbthr->bth.rgchFormat[ 0 ];
|
|
|
|
switch (kt) {
|
|
case KT_SZ:
|
|
case KT_SZI:
|
|
case KT_SZISCAND:
|
|
case KT_SZIJAPAN:
|
|
case KT_SZIKOREA:
|
|
case KT_SZITAIWAN:
|
|
case KT_NLSI:
|
|
case KT_NLS:
|
|
return strlen( (PSTR)key ) + 1;
|
|
break;
|
|
|
|
case KT_LONG:
|
|
return sizeof(LONG);
|
|
break;
|
|
|
|
case '1': case '2': case '3': case '4': case '5':
|
|
case '6': case '7': case '8': case '9':
|
|
return kt - '0';
|
|
break;
|
|
|
|
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
|
|
return kt - 'a' + 10;
|
|
break;
|
|
|
|
default:
|
|
ASSERT(FALSE);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*******************************************************************\
|
|
*
|
|
* The following stuff is for international string comparisons.
|
|
* These functions are insensitive to case and accents. For a
|
|
* function that distinguishes between all char values, we use
|
|
* WCmpSz(), which behaves just like strcmp().
|
|
*
|
|
* The tables in maps.h were generated from the ones used in help 2.5
|
|
* which were stolen from Opus international stuff.
|
|
*
|
|
* There are two loops for speed. These should be redone in assembly.
|
|
*
|
|
\*******************************************************************/
|
|
|
|
unsigned char mpchordNorm[] =
|
|
{
|
|
0x00, // 0x00
|
|
0x01, // 0x01
|
|
0x02, // 0x02
|
|
0x03, // 0x03
|
|
0x04, // 0x04
|
|
0x05, // 0x05
|
|
0x06, // 0x06
|
|
0x07, // 0x07
|
|
0x08, // 0x08
|
|
0x09, // 0x09
|
|
0x0A, // 0x0A
|
|
0x0B, // 0x0B
|
|
0x0C, // 0x0C
|
|
0x0D, // 0x0D
|
|
0x0E, // 0x0E
|
|
0x0F, // 0x0F
|
|
0x10, // 0x10
|
|
0x11, // 0x11
|
|
0x12, // 0x12
|
|
0x13, // 0x13
|
|
0x14, // 0x14
|
|
0x15, // 0x15
|
|
0x16, // 0x16
|
|
0x17, // 0x17
|
|
0x18, // 0x18
|
|
0x19, // 0x19
|
|
0x1A, // 0x1A
|
|
0x1B, // 0x1B
|
|
0x1C, // 0x1C
|
|
0x1D, // 0x1D
|
|
0x1E, // 0x1E
|
|
0x1F, // 0x1F
|
|
0x20, // ' '
|
|
0x21, // '!'
|
|
0x22, // '"'
|
|
0x23, // '#'
|
|
0x24, // '$'
|
|
0x25, // '%'
|
|
0x26, // '&'
|
|
0x27, // '''
|
|
0x28, // '('
|
|
0x29, // ')'
|
|
0x2A, // '*'
|
|
0x2B, // '+'
|
|
0x2C, // ','
|
|
0x2D, // '-'
|
|
0x2E, // '.'
|
|
0x2F, // '/'
|
|
0x82, // '0'
|
|
0x83, // '1'
|
|
0x84, // '2'
|
|
0x85, // '3'
|
|
0x86, // '4'
|
|
0x87, // '5'
|
|
0x88, // '6'
|
|
0x89, // '7'
|
|
0x8A, // '8'
|
|
0x8B, // '9'
|
|
0x30, // ':'
|
|
0x31, // ';'
|
|
0x32, // '<'
|
|
0x33, // '='
|
|
0x34, // '>'
|
|
0x35, // '?'
|
|
0x36, // '@'
|
|
0x8D, // 'A'
|
|
0x8F, // 'B'
|
|
0x91, // 'C'
|
|
0x93, // 'D'
|
|
0x95, // 'E'
|
|
0x97, // 'F'
|
|
0x99, // 'G'
|
|
0x9B, // 'H'
|
|
0x9D, // 'I'
|
|
0x9F, // 'J'
|
|
0xA1, // 'K'
|
|
0xA3, // 'L'
|
|
0xA5, // 'M'
|
|
0xA7, // 'N'
|
|
0xAB, // 'O'
|
|
0xAD, // 'P'
|
|
0xAF, // 'Q'
|
|
0xB1, // 'R'
|
|
0xB3, // 'S'
|
|
0xB6, // 'T'
|
|
0xB8, // 'U'
|
|
0xBA, // 'V'
|
|
0xBC, // 'W'
|
|
0xBE, // 'X'
|
|
0xC1, // 'Y'
|
|
0xC5, // 'Z'
|
|
0x37, // '['
|
|
0x38, // '\'
|
|
0x39, // ']'
|
|
0x3A, // '^'
|
|
0x3B, // '_'
|
|
0x3C, // '`'
|
|
0x8D, // 'a'
|
|
0x8F, // 'b'
|
|
0x91, // 'c'
|
|
0x93, // 'd'
|
|
0x95, // 'e'
|
|
0x97, // 'f'
|
|
0x99, // 'g'
|
|
0x9B, // 'h'
|
|
0x9D, // 'i'
|
|
0x9F, // 'j'
|
|
0xA1, // 'k'
|
|
0xA3, // 'l'
|
|
0xA5, // 'm'
|
|
0xA7, // 'n'
|
|
0xAB, // 'o'
|
|
0xAD, // 'p'
|
|
0xAF, // 'q'
|
|
0xB1, // 'r'
|
|
0xB3, // 's'
|
|
0xB6, // 't'
|
|
0xB8, // 'u'
|
|
0xBA, // 'v'
|
|
0xBC, // 'w'
|
|
0xBE, // 'x'
|
|
0xC1, // 'y'
|
|
0xC5, // 'z'
|
|
0x3D, // '{'
|
|
0x3E, // '|'
|
|
0x3F, // '}'
|
|
0x40, // '~'
|
|
0x41, // 0x7F
|
|
0x42, // 0x80
|
|
0x43, // 0x81
|
|
0x44, // 0x82
|
|
0x45, // 0x83
|
|
0x46, // 0x84
|
|
0x47, // 0x85
|
|
0x48, // 0x86
|
|
0x49, // 0x87
|
|
0x4A, // 0x88
|
|
0x4B, // 0x89
|
|
0x4B, // 0x8A
|
|
0x4D, // 0x8B
|
|
0x4E, // 0x8C
|
|
0x4F, // 0x8D
|
|
0x50, // 0x8E
|
|
0x51, // 0x8F
|
|
0x52, // 0x90
|
|
0x53, // 0x91
|
|
0x54, // 0x92
|
|
0x55, // 0x93
|
|
0x56, // 0x94
|
|
0x57, // 0x95
|
|
0x58, // 0x96
|
|
0x59, // 0x97
|
|
0x5A, // 0x98
|
|
0x5B, // 0x99
|
|
0x5C, // 0x9A
|
|
0x5D, // 0x9B
|
|
0x5E, // 0x9C
|
|
0x5F, // 0x9D
|
|
0x60, // 0x9E
|
|
0x61, // 0x9F
|
|
0x62, // 0xA0
|
|
0x63, // 0xA1
|
|
0x64, // 0xA2
|
|
0x65, // 0xA3
|
|
0x66, // 0xA4
|
|
0x67, // 0xA5
|
|
0x68, // 0xA6
|
|
0x69, // 0xA7
|
|
0x6A, // 0xA8
|
|
0x6B, // 0xA9
|
|
0x6C, // 0xAA
|
|
0x6D, // 0xAB
|
|
0x6E, // 0xAC
|
|
0x6F, // 0xAD
|
|
0x70, // 0xAE
|
|
0x71, // 0xAF
|
|
0x72, // 0xB0
|
|
0x73, // 0xB1
|
|
0x74, // 0xB2
|
|
0x75, // 0xB3
|
|
0x76, // 0xB4
|
|
0x77, // 0xB5
|
|
0x78, // 0xB6
|
|
0x79, // 0xB7
|
|
0x7A, // 0xB8
|
|
0x7B, // 0xB9
|
|
0x7C, // 0xBA
|
|
0x7D, // 0xBB
|
|
0x7E, // 0xBC
|
|
0x7F, // 0xBD
|
|
0x80, // 0xBE
|
|
0x81, // 0xBF
|
|
0x8D, // 0xC0
|
|
0x8D, // 0xC1
|
|
0x8D, // 0xC2
|
|
0x8D, // 0xC3
|
|
0x8D, // 0xC4
|
|
0x8D, // 0xC5
|
|
0x8D, // 0xC6
|
|
0x91, // 0xC7
|
|
0x95, // 0xC8
|
|
0x95, // 0xC9
|
|
0x95, // 0xCA
|
|
0x95, // 0xCB
|
|
0x9D, // 0xCC
|
|
0x9D, // 0xCD
|
|
0x9D, // 0xCE
|
|
0x9D, // 0xCF
|
|
0x93, // 0xD0
|
|
0xA9, // 0xD1
|
|
0xAB, // 0xD2
|
|
0xAB, // 0xD3
|
|
0xAB, // 0xD4
|
|
0xAB, // 0xD5
|
|
0xAB, // 0xD6
|
|
0xAA, // 0xD7
|
|
0xAB, // 0xD8
|
|
0xB8, // 0xD9
|
|
0xB8, // 0xDA
|
|
0xB8, // 0xDB
|
|
0xB8, // 0xDC
|
|
0xC2, // 0xDD
|
|
0xC6, // 0xDE
|
|
0xB4, // 0xDF
|
|
0x8D, // 0xE0
|
|
0x8D, // 0xE1
|
|
0x8D, // 0xE2
|
|
0x8D, // 0xE3
|
|
0x8D, // 0xE4
|
|
0x8D, // 0xE5
|
|
0x8D, // 0xE6
|
|
0x91, // 0xE7
|
|
0x95, // 0xE8
|
|
0x95, // 0xE9
|
|
0x95, // 0xEA
|
|
0x95, // 0xEB
|
|
0x9D, // 0xEC
|
|
0x9D, // 0xED
|
|
0x9D, // 0xEE
|
|
0x9D, // 0xEF
|
|
0x93, // 0xF0
|
|
0xA9, // 0xF1
|
|
0xAB, // 0xF2
|
|
0xAB, // 0xF3
|
|
0xAB, // 0xF4
|
|
0xAB, // 0xF5
|
|
0xAB, // 0xF6
|
|
0xAB, // 0xF7
|
|
0xAB, // 0xF8
|
|
0xB8, // 0xF9
|
|
0xB8, // 0xFA
|
|
0xB8, // 0xFB
|
|
0xB8, // 0xFC
|
|
0xC2, // 0xFD
|
|
0xC6, // 0xFE
|
|
0xC3, // 0xFF
|
|
};
|
|
|
|
|
|
unsigned char mpchordScan[] =
|
|
{
|
|
0x00, // 0x00
|
|
0x01, // 0x01
|
|
0x02, // 0x02
|
|
0x03, // 0x03
|
|
0x04, // 0x04
|
|
0x05, // 0x05
|
|
0x06, // 0x06
|
|
0x07, // 0x07
|
|
0x08, // 0x08
|
|
0x09, // 0x09
|
|
0x0A, // 0x0A
|
|
0x0B, // 0x0B
|
|
0x0C, // 0x0C
|
|
0x0D, // 0x0D
|
|
0x0E, // 0x0E
|
|
0x0F, // 0x0F
|
|
0x10, // 0x10
|
|
0x11, // 0x11
|
|
0x12, // 0x12
|
|
0x13, // 0x13
|
|
0x14, // 0x14
|
|
0x15, // 0x15
|
|
0x16, // 0x16
|
|
0x17, // 0x17
|
|
0x18, // 0x18
|
|
0x19, // 0x19
|
|
0x1A, // 0x1A
|
|
0x1B, // 0x1B
|
|
0x1C, // 0x1C
|
|
0x1D, // 0x1D
|
|
0x1E, // 0x1E
|
|
0x1F, // 0x1F
|
|
0x20, // ' '
|
|
0x21, // '!'
|
|
0x22, // '"'
|
|
0x23, // '#'
|
|
0x24, // '$'
|
|
0x25, // '%'
|
|
0x26, // '&'
|
|
0x27, // '''
|
|
0x28, // '('
|
|
0x29, // ')'
|
|
0x2A, // '*'
|
|
0x2B, // '+'
|
|
0x2C, // ','
|
|
0x2D, // '-'
|
|
0x2E, // '.'
|
|
0x2F, // '/'
|
|
0x82, // '0'
|
|
0x83, // '1'
|
|
0x84, // '2'
|
|
0x85, // '3'
|
|
0x86, // '4'
|
|
0x87, // '5'
|
|
0x88, // '6'
|
|
0x89, // '7'
|
|
0x8A, // '8'
|
|
0x8B, // '9'
|
|
0x30, // ':'
|
|
0x31, // ';'
|
|
0x32, // '<'
|
|
0x33, // '='
|
|
0x34, // '>'
|
|
0x35, // '?'
|
|
0x36, // '@'
|
|
0x8D, // 'A'
|
|
0x8F, // 'B'
|
|
0x91, // 'C'
|
|
0x93, // 'D'
|
|
0x95, // 'E'
|
|
0x97, // 'F'
|
|
0x99, // 'G'
|
|
0x9B, // 'H'
|
|
0x9D, // 'I'
|
|
0x9F, // 'J'
|
|
0xA1, // 'K'
|
|
0xA3, // 'L'
|
|
0xA5, // 'M'
|
|
0xA7, // 'N'
|
|
0xAB, // 'O'
|
|
0xAD, // 'P'
|
|
0xAF, // 'Q'
|
|
0xB1, // 'R'
|
|
0xB3, // 'S'
|
|
0xB6, // 'T'
|
|
0xB8, // 'U'
|
|
0xBA, // 'V'
|
|
0xBC, // 'W'
|
|
0xBE, // 'X'
|
|
0xC1, // 'Y'
|
|
0xC5, // 'Z'
|
|
0x37, // '['
|
|
0x38, // '\'
|
|
0x39, // ']'
|
|
0x3A, // '^'
|
|
0x3B, // '_'
|
|
0x3C, // '`'
|
|
0x8D, // 'a'
|
|
0x8F, // 'b'
|
|
0x91, // 'c'
|
|
0x93, // 'd'
|
|
0x95, // 'e'
|
|
0x97, // 'f'
|
|
0x99, // 'g'
|
|
0x9B, // 'h'
|
|
0x9D, // 'i'
|
|
0x9F, // 'j'
|
|
0xA1, // 'k'
|
|
0xA3, // 'l'
|
|
0xA5, // 'm'
|
|
0xA7, // 'n'
|
|
0xAB, // 'o'
|
|
0xAD, // 'p'
|
|
0xAF, // 'q'
|
|
0xB1, // 'r'
|
|
0xB3, // 's'
|
|
0xB6, // 't'
|
|
0xB8, // 'u'
|
|
0xBA, // 'v'
|
|
0xBC, // 'w'
|
|
0xBE, // 'x'
|
|
0xC1, // 'y'
|
|
0xC5, // 'z'
|
|
0x3D, // '{'
|
|
0x3E, // '|'
|
|
0x3F, // '}'
|
|
0x40, // '~'
|
|
0x41, // 0x7F
|
|
0x42, // 0x80
|
|
0x43, // 0x81
|
|
0x44, // 0x82
|
|
0x45, // 0x83
|
|
0x46, // 0x84
|
|
0x47, // 0x85
|
|
0x48, // 0x86
|
|
0x49, // 0x87
|
|
0x4A, // 0x88
|
|
0x4B, // 0x89
|
|
0x4B, // 0x8A
|
|
0x4D, // 0x8B
|
|
0x4E, // 0x8C
|
|
0x4F, // 0x8D
|
|
0x50, // 0x8E
|
|
0x51, // 0x8F
|
|
0x52, // 0x90
|
|
0x53, // 0x91
|
|
0x54, // 0x92
|
|
0x55, // 0x93
|
|
0x56, // 0x94
|
|
0x57, // 0x95
|
|
0x58, // 0x96
|
|
0x59, // 0x97
|
|
0x5A, // 0x98
|
|
0x5B, // 0x99
|
|
0x5C, // 0x9A
|
|
0x5D, // 0x9B
|
|
0x5E, // 0x9C
|
|
0x5F, // 0x9D
|
|
0x60, // 0x9E
|
|
0x61, // 0x9F
|
|
0x62, // 0xA0
|
|
0x63, // 0xA1
|
|
0x64, // 0xA2
|
|
0x65, // 0xA3
|
|
0x66, // 0xA4
|
|
0x67, // 0xA5
|
|
0x68, // 0xA6
|
|
0x69, // 0xA7
|
|
0x6A, // 0xA8
|
|
0x6B, // 0xA9
|
|
0x6C, // 0xAA
|
|
0x6D, // 0xAB
|
|
0x6E, // 0xAC
|
|
0x6F, // 0xAD
|
|
0x70, // 0xAE
|
|
0x71, // 0xAF
|
|
0x72, // 0xB0
|
|
0x73, // 0xB1
|
|
0x74, // 0xB2
|
|
0x75, // 0xB3
|
|
0x76, // 0xB4
|
|
0x77, // 0xB5
|
|
0x78, // 0xB6
|
|
0x79, // 0xB7
|
|
0x7A, // 0xB8
|
|
0x7B, // 0xB9
|
|
0x7C, // 0xBA
|
|
0x7D, // 0xBB
|
|
0x7E, // 0xBC
|
|
0x7F, // 0xBD
|
|
0x80, // 0xBE
|
|
0x81, // 0xBF
|
|
0x8D, // 0xC0
|
|
0x8D, // 0xC1
|
|
0x8D, // 0xC2
|
|
0x8D, // 0xC3
|
|
0xCF, // 0xC4
|
|
0xCD, // 0xC5
|
|
0xC9, // 0xC6
|
|
0x91, // 0xC7
|
|
0x95, // 0xC8
|
|
0x95, // 0xC9
|
|
0x95, // 0xCA
|
|
0x95, // 0xCB
|
|
0x9D, // 0xCC
|
|
0x9D, // 0xCD
|
|
0x9D, // 0xCE
|
|
0x9D, // 0xCF
|
|
0x93, // 0xD0
|
|
0xA9, // 0xD1
|
|
0xAB, // 0xD2
|
|
0xAB, // 0xD3
|
|
0xAB, // 0xD4
|
|
0xAB, // 0xD5
|
|
0xD1, // 0xD6
|
|
0xAA, // 0xD7
|
|
0xCB, // 0xD8
|
|
0xB8, // 0xD9
|
|
0xB8, // 0xDA
|
|
0xB8, // 0xDB
|
|
0xB8, // 0xDC
|
|
0xC2, // 0xDD
|
|
0xC7, // 0xDE
|
|
0xB4, // 0xDF
|
|
0x8D, // 0xE0
|
|
0x8D, // 0xE1
|
|
0x8D, // 0xE2
|
|
0x8D, // 0xE3
|
|
0xCF, // 0xE4
|
|
0xCD, // 0xE5
|
|
0xC9, // 0xE6
|
|
0x91, // 0xE7
|
|
0x95, // 0xE8
|
|
0x95, // 0xE9
|
|
0x95, // 0xEA
|
|
0x95, // 0xEB
|
|
0x9D, // 0xEC
|
|
0x9D, // 0xED
|
|
0x9D, // 0xEE
|
|
0x9D, // 0xEF
|
|
0x93, // 0xF0
|
|
0xA9, // 0xF1
|
|
0xAB, // 0xF2
|
|
0xAB, // 0xF3
|
|
0xAB, // 0xF4
|
|
0xAB, // 0xF5
|
|
0xD1, // 0xF6
|
|
0xAB, // 0xF7
|
|
0xCB, // 0xF8
|
|
0xB8, // 0xF9
|
|
0xB8, // 0xFA
|
|
0xB8, // 0xFB
|
|
0xB8, // 0xFC
|
|
0xC2, // 0xFD
|
|
0xC7, // 0xFE
|
|
0xC3, // 0xFF
|
|
};
|
|
|
|
unsigned char cdecl mpchordJapan[] = {
|
|
0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,
|
|
0x8,0x9,0xA,0xB,0xC,0xD,0xE,0xF,
|
|
0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
|
|
0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
|
|
0x20,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,
|
|
0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
|
|
0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,
|
|
0xBF,0xC0,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,
|
|
0xD6,0x9D,0x9E,0x9F,0xA0,0xA1,0xA2,0xA3,
|
|
0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,
|
|
0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,
|
|
0xB4,0xB5,0xB6,0xD8,0xD9,0xDA,0xDB,0xDC,
|
|
0xD7,0x9D,0x9E,0x9F,0xA0,0xA1,0xA2,0xA3,
|
|
0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,
|
|
0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,
|
|
0xB4,0xB5,0xB6,0xDD,0xDE,0xDF,0xE0,0xE1,
|
|
0xE2,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
|
|
0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
|
|
0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
|
|
0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
|
|
0x5D,0x5E,0x5F,0x60,0x61,0x62,0x63,0x64,
|
|
0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,
|
|
0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,
|
|
0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,
|
|
0x7D,0x7E,0x7F,0x80,0x81,0x82,0x83,0x84,
|
|
0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,
|
|
0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,
|
|
0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,
|
|
0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
|
|
0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
|
|
0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,
|
|
0x58,0x59,0x5A,0x5B,0xE3,0xE4,0xE5,0xE6,
|
|
};
|
|
unsigned char cdecl mpchordKorea[] = {
|
|
0x0,0x1,0x2,0x3,0x4,0x5,0x6,0x7,
|
|
0x8,0x9,0xA,0xB,0xC,0xD,0xE,0xF,
|
|
0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,
|
|
0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,
|
|
0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
|
|
0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,
|
|
0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
|
|
0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,
|
|
0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
|
|
0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
|
|
0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,
|
|
0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
|
|
0x60,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
|
|
0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,
|
|
0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,
|
|
0x58,0x59,0x5A,0x7B,0x7C,0x7D,0x7E,0x7F,
|
|
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,
|
|
0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,
|
|
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,
|
|
0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,
|
|
0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,
|
|
0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,
|
|
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,
|
|
0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,
|
|
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,
|
|
0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,
|
|
0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,
|
|
0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,
|
|
0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,
|
|
0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,
|
|
0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,
|
|
0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,
|
|
};
|
|
|
|
// (YST) for EE & Russia
|
|
#define NonLetter 0
|
|
#define Letter 154
|
|
|
|
// EE table
|
|
unsigned char cdecl mpchordNormEE[] =
|
|
{
|
|
NonLetter + 0,
|
|
NonLetter + 1,
|
|
NonLetter + 2,
|
|
NonLetter + 3,
|
|
NonLetter + 4,
|
|
NonLetter + 5,
|
|
NonLetter + 6,
|
|
NonLetter + 7,
|
|
NonLetter + 8,
|
|
NonLetter + 9,
|
|
NonLetter + 10,
|
|
NonLetter + 11,
|
|
NonLetter + 12,
|
|
NonLetter + 13,
|
|
NonLetter + 14,
|
|
NonLetter + 15,
|
|
NonLetter + 16,
|
|
NonLetter + 17,
|
|
NonLetter + 18,
|
|
NonLetter + 19,
|
|
NonLetter + 20,
|
|
NonLetter + 21,
|
|
NonLetter + 22,
|
|
NonLetter + 23,
|
|
NonLetter + 24,
|
|
NonLetter + 25,
|
|
NonLetter + 26,
|
|
NonLetter + 27,
|
|
NonLetter + 28,
|
|
NonLetter + 29,
|
|
NonLetter + 30,
|
|
NonLetter + 31,
|
|
NonLetter + 67,
|
|
NonLetter + 68,
|
|
NonLetter + 69,
|
|
NonLetter + 70,
|
|
NonLetter + 71,
|
|
NonLetter + 72,
|
|
NonLetter + 73,
|
|
NonLetter + 74,
|
|
NonLetter + 75,
|
|
NonLetter + 76,
|
|
NonLetter + 77,
|
|
NonLetter + 78,
|
|
NonLetter + 79,
|
|
NonLetter + 80,
|
|
NonLetter + 81,
|
|
NonLetter + 82,
|
|
Letter - 10,
|
|
Letter - 9,
|
|
Letter - 8,
|
|
Letter - 7,
|
|
Letter - 6,
|
|
Letter - 5,
|
|
Letter - 4,
|
|
Letter - 3,
|
|
Letter - 2,
|
|
Letter - 1,
|
|
NonLetter + 83,
|
|
NonLetter + 84,
|
|
NonLetter + 85,
|
|
NonLetter + 86,
|
|
NonLetter + 87,
|
|
NonLetter + 88,
|
|
NonLetter + 89,
|
|
Letter + 0,
|
|
Letter + 6,
|
|
Letter + 7,
|
|
Letter + 13,
|
|
Letter + 19,
|
|
Letter + 24,
|
|
Letter + 25,
|
|
Letter + 26,
|
|
Letter + 27,
|
|
Letter + 30,
|
|
Letter + 31,
|
|
Letter + 32,
|
|
Letter + 36,
|
|
Letter + 37,
|
|
Letter + 40,
|
|
Letter + 45,
|
|
Letter + 46,
|
|
Letter + 47,
|
|
Letter + 51,
|
|
Letter + 57,
|
|
Letter + 60,
|
|
Letter + 65,
|
|
Letter + 66,
|
|
Letter + 67,
|
|
Letter + 68,
|
|
Letter + 70,
|
|
NonLetter + 90,
|
|
NonLetter + 91,
|
|
NonLetter + 92,
|
|
NonLetter + 93,
|
|
NonLetter + 94,
|
|
NonLetter + 95,
|
|
Letter + 0,
|
|
Letter + 6,
|
|
Letter + 7,
|
|
Letter + 13,
|
|
Letter + 19,
|
|
Letter + 24,
|
|
Letter + 25,
|
|
Letter + 26,
|
|
Letter + 27,
|
|
Letter + 30,
|
|
Letter + 31,
|
|
Letter + 32,
|
|
Letter + 36,
|
|
Letter + 37,
|
|
Letter + 40,
|
|
Letter + 45,
|
|
Letter + 46,
|
|
Letter + 47,
|
|
Letter + 51,
|
|
Letter + 57,
|
|
Letter + 60,
|
|
Letter + 65,
|
|
Letter + 66,
|
|
Letter + 67,
|
|
Letter + 68,
|
|
Letter + 70,
|
|
NonLetter + 96,
|
|
NonLetter + 97,
|
|
NonLetter + 98,
|
|
NonLetter + 99,
|
|
NonLetter + 32,
|
|
NonLetter + 33,
|
|
NonLetter + 34,
|
|
NonLetter + 35,
|
|
NonLetter + 36,
|
|
NonLetter + 37,
|
|
NonLetter + 38,
|
|
NonLetter + 39,
|
|
NonLetter + 40,
|
|
NonLetter + 41,
|
|
NonLetter + 42,
|
|
Letter + 54,
|
|
NonLetter + 44,
|
|
Letter + 53,
|
|
Letter + 58,
|
|
Letter + 73,
|
|
Letter + 71,
|
|
NonLetter + 49,
|
|
NonLetter + 50,
|
|
NonLetter + 51,
|
|
NonLetter + 52,
|
|
NonLetter + 53,
|
|
NonLetter + 54,
|
|
NonLetter + 55,
|
|
NonLetter + 56,
|
|
NonLetter + 57,
|
|
NonLetter + 58,
|
|
Letter + 54,
|
|
NonLetter + 60,
|
|
Letter + 53,
|
|
Letter + 58,
|
|
Letter + 73,
|
|
Letter + 71,
|
|
NonLetter + 100,
|
|
NonLetter + 101,
|
|
NonLetter + 102,
|
|
Letter + 33,
|
|
NonLetter + 104,
|
|
Letter + 1,
|
|
NonLetter + 106,
|
|
NonLetter + 107,
|
|
NonLetter + 108,
|
|
NonLetter + 109,
|
|
Letter + 55,
|
|
NonLetter + 111,
|
|
NonLetter + 112,
|
|
NonLetter + 113,
|
|
NonLetter + 114,
|
|
Letter + 72,
|
|
NonLetter + 116,
|
|
NonLetter + 117,
|
|
NonLetter + 118,
|
|
Letter + 33,
|
|
NonLetter + 120,
|
|
NonLetter + 121,
|
|
NonLetter + 122,
|
|
NonLetter + 123,
|
|
NonLetter + 124,
|
|
Letter + 1,
|
|
Letter + 55,
|
|
NonLetter + 127,
|
|
Letter + 34,
|
|
NonLetter + 129,
|
|
Letter + 34,
|
|
Letter + 72,
|
|
Letter + 49,
|
|
Letter + 2,
|
|
Letter + 3,
|
|
Letter + 4,
|
|
Letter + 5,
|
|
Letter + 34,
|
|
Letter + 10,
|
|
Letter + 12,
|
|
Letter + 11,
|
|
Letter + 21,
|
|
Letter + 20,
|
|
Letter + 23,
|
|
Letter + 22,
|
|
Letter + 28,
|
|
Letter + 29,
|
|
Letter + 17,
|
|
Letter + 18,
|
|
Letter + 38,
|
|
Letter + 39,
|
|
Letter + 41,
|
|
Letter + 42,
|
|
Letter + 43,
|
|
Letter + 44,
|
|
NonLetter + 65,
|
|
Letter + 50,
|
|
Letter + 61,
|
|
Letter + 62,
|
|
Letter + 63,
|
|
Letter + 64,
|
|
Letter + 69,
|
|
Letter + 59,
|
|
Letter + 56,
|
|
Letter + 49,
|
|
Letter + 2,
|
|
Letter + 3,
|
|
Letter + 4,
|
|
Letter + 5,
|
|
Letter + 34,
|
|
Letter + 10,
|
|
Letter + 12,
|
|
Letter + 11,
|
|
Letter + 21,
|
|
Letter + 20,
|
|
Letter + 23,
|
|
Letter + 22,
|
|
Letter + 28,
|
|
Letter + 29,
|
|
Letter + 17,
|
|
Letter + 18,
|
|
Letter + 38,
|
|
Letter + 39,
|
|
Letter + 41,
|
|
Letter + 42,
|
|
Letter + 43,
|
|
Letter + 44,
|
|
NonLetter + 66,
|
|
Letter + 50,
|
|
Letter + 61,
|
|
Letter + 62,
|
|
Letter + 63,
|
|
Letter + 64,
|
|
Letter + 69,
|
|
Letter + 59,
|
|
NonLetter + 130,
|
|
};
|
|
|
|
|
|
// Cyrillic table
|
|
|
|
unsigned char cdecl mpchordCyr[] =
|
|
{
|
|
NonLetter + 0,
|
|
NonLetter + 1,
|
|
NonLetter + 2,
|
|
NonLetter + 3,
|
|
NonLetter + 4,
|
|
NonLetter + 5,
|
|
NonLetter + 6,
|
|
NonLetter + 7,
|
|
NonLetter + 8,
|
|
NonLetter + 9,
|
|
NonLetter + 10,
|
|
NonLetter + 11,
|
|
NonLetter + 12,
|
|
NonLetter + 13,
|
|
NonLetter + 14,
|
|
NonLetter + 15,
|
|
NonLetter + 16,
|
|
NonLetter + 17,
|
|
NonLetter + 18,
|
|
NonLetter + 19,
|
|
NonLetter + 20,
|
|
NonLetter + 21,
|
|
NonLetter + 22,
|
|
NonLetter + 23,
|
|
NonLetter + 24,
|
|
NonLetter + 25,
|
|
NonLetter + 26,
|
|
NonLetter + 27,
|
|
NonLetter + 28,
|
|
NonLetter + 29,
|
|
NonLetter + 30,
|
|
NonLetter + 31,
|
|
NonLetter + 67,
|
|
NonLetter + 68,
|
|
NonLetter + 69,
|
|
NonLetter + 70,
|
|
NonLetter + 71,
|
|
NonLetter + 72,
|
|
NonLetter + 73,
|
|
NonLetter + 74,
|
|
NonLetter + 75,
|
|
NonLetter + 76,
|
|
NonLetter + 77,
|
|
NonLetter + 78,
|
|
NonLetter + 79,
|
|
NonLetter + 80,
|
|
NonLetter + 81,
|
|
NonLetter + 82,
|
|
Letter - 10,
|
|
Letter - 9,
|
|
Letter - 8,
|
|
Letter - 7,
|
|
Letter - 6,
|
|
Letter - 5,
|
|
Letter - 4,
|
|
Letter - 3,
|
|
Letter - 2,
|
|
Letter - 1,
|
|
NonLetter + 83,
|
|
NonLetter + 84,
|
|
NonLetter + 85,
|
|
NonLetter + 86,
|
|
NonLetter + 87,
|
|
NonLetter + 88,
|
|
NonLetter + 89,
|
|
Letter + 0,
|
|
Letter + 1,
|
|
Letter + 2,
|
|
Letter + 3,
|
|
Letter + 4,
|
|
Letter + 5,
|
|
Letter + 6,
|
|
Letter + 7,
|
|
Letter + 8,
|
|
Letter + 9,
|
|
Letter + 10,
|
|
Letter + 11,
|
|
Letter + 12,
|
|
Letter + 13,
|
|
Letter + 14,
|
|
Letter + 15,
|
|
Letter + 16,
|
|
Letter + 17,
|
|
Letter + 18,
|
|
Letter + 19,
|
|
Letter + 20,
|
|
Letter + 21,
|
|
Letter + 22,
|
|
Letter + 23,
|
|
Letter + 24,
|
|
Letter + 25,
|
|
NonLetter + 90,
|
|
NonLetter + 91,
|
|
NonLetter + 92,
|
|
NonLetter + 93,
|
|
NonLetter + 94,
|
|
NonLetter + 95,
|
|
Letter + 0,
|
|
Letter + 1,
|
|
Letter + 2,
|
|
Letter + 3,
|
|
Letter + 4,
|
|
Letter + 5,
|
|
Letter + 6,
|
|
Letter + 7,
|
|
Letter + 8,
|
|
Letter + 9,
|
|
Letter + 10,
|
|
Letter + 11,
|
|
Letter + 12,
|
|
Letter + 13,
|
|
Letter + 14,
|
|
Letter + 15,
|
|
Letter + 16,
|
|
Letter + 17,
|
|
Letter + 18,
|
|
Letter + 19,
|
|
Letter + 20,
|
|
Letter + 21,
|
|
Letter + 22,
|
|
Letter + 23,
|
|
Letter + 24,
|
|
Letter + 25,
|
|
NonLetter + 96,
|
|
NonLetter + 97,
|
|
NonLetter + 98,
|
|
NonLetter + 99,
|
|
NonLetter + 32,
|
|
Letter + 33,
|
|
Letter + 31,
|
|
NonLetter + 35,
|
|
Letter + 31,
|
|
NonLetter + 37,
|
|
NonLetter + 38,
|
|
NonLetter + 39,
|
|
NonLetter + 40,
|
|
NonLetter + 41,
|
|
NonLetter + 42,
|
|
Letter + 47,
|
|
NonLetter + 44,
|
|
Letter + 50,
|
|
Letter + 45,
|
|
Letter + 57,
|
|
Letter + 64,
|
|
Letter + 33,
|
|
NonLetter + 50,
|
|
NonLetter + 51,
|
|
NonLetter + 52,
|
|
NonLetter + 53,
|
|
NonLetter + 54,
|
|
NonLetter + 55,
|
|
NonLetter + 56,
|
|
NonLetter + 57,
|
|
NonLetter + 58,
|
|
Letter + 47,
|
|
NonLetter + 60,
|
|
Letter + 50,
|
|
Letter + 45,
|
|
Letter + 57,
|
|
Letter + 64,
|
|
NonLetter + 100,
|
|
Letter + 59,
|
|
Letter + 59,
|
|
Letter + 43,
|
|
NonLetter + 104,
|
|
Letter + 30,
|
|
NonLetter + 106,
|
|
NonLetter + 107,
|
|
Letter + 35,
|
|
NonLetter + 109,
|
|
Letter + 36,
|
|
NonLetter + 111,
|
|
NonLetter + 112,
|
|
NonLetter + 113,
|
|
NonLetter + 114,
|
|
Letter + 42,
|
|
NonLetter + 116,
|
|
NonLetter + 117,
|
|
Letter + 41,
|
|
Letter + 41,
|
|
Letter + 30,
|
|
NonLetter + 121,
|
|
NonLetter + 122,
|
|
NonLetter + 123,
|
|
Letter + 35,
|
|
NonLetter + 125,
|
|
Letter + 36,
|
|
NonLetter + 127,
|
|
Letter + 43,
|
|
Letter + 55,
|
|
Letter + 55,
|
|
Letter + 42,
|
|
Letter + 26,
|
|
Letter + 27,
|
|
Letter + 28,
|
|
Letter + 29,
|
|
Letter + 32,
|
|
Letter + 34,
|
|
Letter + 37,
|
|
Letter + 38,
|
|
Letter + 39,
|
|
Letter + 40,
|
|
Letter + 44,
|
|
Letter + 46,
|
|
Letter + 48,
|
|
Letter + 49,
|
|
Letter + 51,
|
|
Letter + 52,
|
|
Letter + 53,
|
|
Letter + 54,
|
|
Letter + 56,
|
|
Letter + 58,
|
|
Letter + 60,
|
|
Letter + 61,
|
|
Letter + 62,
|
|
Letter + 63,
|
|
Letter + 65,
|
|
Letter + 66,
|
|
Letter + 67,
|
|
Letter + 68,
|
|
Letter + 69,
|
|
Letter + 70,
|
|
Letter + 71,
|
|
Letter + 72,
|
|
Letter + 26,
|
|
Letter + 27,
|
|
Letter + 28,
|
|
Letter + 29,
|
|
Letter + 32,
|
|
Letter + 34,
|
|
Letter + 37,
|
|
Letter + 38,
|
|
Letter + 39,
|
|
Letter + 40,
|
|
Letter + 44,
|
|
Letter + 46,
|
|
Letter + 48,
|
|
Letter + 49,
|
|
Letter + 51,
|
|
Letter + 52,
|
|
Letter + 53,
|
|
Letter + 54,
|
|
Letter + 56,
|
|
Letter + 58,
|
|
Letter + 60,
|
|
Letter + 61,
|
|
Letter + 62,
|
|
Letter + 63,
|
|
Letter + 65,
|
|
Letter + 66,
|
|
Letter + 67,
|
|
Letter + 68,
|
|
Letter + 69,
|
|
Letter + 70,
|
|
Letter + 71,
|
|
Letter + 72,
|
|
};
|
|
|
|
/***************************************************************************\
|
|
*
|
|
- Function: WCmpiSz( sz1, sz2 )
|
|
-
|
|
* Purpose: Compare two PSTRs, case insensitive. Non-Scandinavian
|
|
* international characters are OK.
|
|
*
|
|
* ASSUMES
|
|
*
|
|
* args IN: sz1, sz2 - the PSTRs to compare
|
|
*
|
|
* globals IN: mpchordNorm[] - the pch -> ordinal mapping table
|
|
*
|
|
* PROMISES
|
|
*
|
|
* returns: <0 for sz1 < sz2; =0 for sz1 == sz2; >0 for sz1 > sz2
|
|
*
|
|
* Bugs: Doesn't deal with composed ae, oe.
|
|
*
|
|
\***************************************************************************/
|
|
|
|
int STDCALL WCmpiSz(PCSTR sz1, PCSTR sz2)
|
|
{
|
|
while (0 == (int) ((unsigned char) *sz1 - (unsigned char) *sz2)) {
|
|
if ('\0' == *sz1) return 0;
|
|
sz1++; sz2++;
|
|
}
|
|
|
|
while (0 == (mpchordNorm[(unsigned char) *sz1] - mpchordNorm[(unsigned char) *sz2]))
|
|
{
|
|
if ('\0' == *sz1) return 0;
|
|
sz1++; sz2++;
|
|
}
|
|
|
|
return mpchordNorm[(unsigned char)*sz1] - mpchordNorm[(unsigned char)*sz2];
|
|
}
|
|
|
|
/* JAPANESE FUNCTION
|
|
|
|
convert Phonetic character (Hiragana/Katakana) to phonetic order.
|
|
Hiragana first.
|
|
|
|
Shift-JIS code dependent
|
|
*/
|
|
|
|
int STDCALL IsPhoneticOrder(UINT w)
|
|
{
|
|
switch(w & 0xFF00) {
|
|
case 0x8200:
|
|
w &= 0xFF;
|
|
if (w >= 0x9F && w <= 0xF1) // Hiragana range
|
|
return (w - 0x9F) * 2;
|
|
break;
|
|
case 0x8300:
|
|
w &= 0xFF;
|
|
if (w >= 0x40 && w <= 0x93)
|
|
return (w - ((w > 0x7f) ? 0x41 : 0x40)) * 2 + 1;
|
|
break;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int STDCALL WCmpiJapanSz(PCSTR psz1, PCSTR psz2)
|
|
{
|
|
int f = 0;
|
|
unsigned int w1, w2;
|
|
int r1, r2;
|
|
|
|
while (0 == (int) ((unsigned char) *psz1 - (unsigned char) *psz2)) {
|
|
if (!*psz1) {
|
|
return 0;
|
|
}
|
|
if (!f && IsFirstByte(*psz1))
|
|
f = *psz1;
|
|
else
|
|
f = 0;
|
|
psz1++;
|
|
psz2++;
|
|
}
|
|
if (f) { // same first byte, but not second byte
|
|
PhoneticCheck:
|
|
w1 = (f << 8) | (unsigned char) *psz1;
|
|
w2 = (f << 8) | (unsigned char) *psz2;
|
|
if (((r1 = IsPhoneticOrder(w1)) != -1) &&
|
|
((r2 = IsPhoneticOrder(w2)) != -1))
|
|
return r1 - r2;
|
|
return *psz1 - *psz2;
|
|
}
|
|
|
|
while (0 == (mpchordJapan[(unsigned char) *psz1] - mpchordJapan[(unsigned char) *psz2])) {
|
|
if ('\0' == *psz1) {
|
|
return 0;
|
|
}
|
|
if (!f && IsFirstByte(*psz1))
|
|
f = *psz1;
|
|
else
|
|
f = 0;
|
|
psz1++;
|
|
psz2++;
|
|
}
|
|
if (f)
|
|
goto PhoneticCheck;
|
|
if (IsFirstByte(*psz1) && IsFirstByte(*psz2)) {
|
|
// diff on first byte of double byte char.
|
|
if ( ((r1 = IsPhoneticOrder( (*psz1 << 8) | ((unsigned char)*(psz1+1)))) != -1) &&
|
|
((r2 = IsPhoneticOrder( (*psz2 << 8) | ((unsigned char)*(psz2+1)))) != -1) )
|
|
return r1 - r2;
|
|
}
|
|
return mpchordJapan[(unsigned char)*psz1] - mpchordJapan[(unsigned char)*psz2];
|
|
}
|
|
|
|
int STDCALL WCmpiKoreaSz(PCSTR sz1, PCSTR sz2)
|
|
{
|
|
int f = 0;
|
|
|
|
while (0 == (int) ((unsigned char) *sz1 - (unsigned char) *sz2)) {
|
|
if ('\0' == *sz1) {
|
|
return 0;
|
|
}
|
|
if (!f && IsFirstByte(*sz1))
|
|
f = *sz1;
|
|
else
|
|
f = 0;
|
|
sz1++;
|
|
sz2++;
|
|
}
|
|
if (f) {
|
|
return *sz1 - *sz2;
|
|
}
|
|
|
|
while (0 == (mpchordKorea[(unsigned char) *sz1] -
|
|
mpchordKorea[(unsigned char) *sz2])) {
|
|
if ('\0' == *sz1) {
|
|
return 0;
|
|
}
|
|
if (!f && IsFirstByte(*sz1))
|
|
f = *sz1;
|
|
else
|
|
f = 0;
|
|
sz1++; sz2++;
|
|
}
|
|
if (f) {
|
|
return *sz1 - *sz2;
|
|
}
|
|
return mpchordKorea[(unsigned char)*sz1] - mpchordKorea[(unsigned char)*sz2];
|
|
}
|
|
|
|
// Starting TAIWAN's portions
|
|
//===========================
|
|
BOOL STDCALL FIsDbcs1B(PBYTE);
|
|
WORD STDCALL GetWchTC(PBYTE, int *);
|
|
int STDCALL GetStrokeTC(WORD);
|
|
int STDCALL CompStrokeTC(WORD, WORD);
|
|
BOOL fMoreCmp;
|
|
|
|
#define MakeWord(bLo,bHi) ((WORD)(((BYTE)(bLo))|((WORD)((BYTE)(bHi)))<<8))
|
|
|
|
BOOL STDCALL FIsDbcs1B(PCSTR firch)
|
|
{
|
|
return (((unsigned char) *firch >= 0X81) &&
|
|
((unsigned char) *firch <= 0XFE));
|
|
}
|
|
|
|
WORD STDCALL GetWchTC(PCSTR psz, int* pipsz)
|
|
{
|
|
WORD w;
|
|
unsigned char bLo, bHi;
|
|
|
|
if (((unsigned char)*(psz + *pipsz)) == '\0') // end of string
|
|
return (WORD) 0;
|
|
|
|
if (FIsDbcs1B(psz + *pipsz)) {
|
|
bLo = (unsigned char)*(psz + *pipsz + 1);
|
|
bHi = (unsigned char)*(psz + *pipsz);
|
|
w = MakeWord(bLo, bHi);
|
|
*pipsz += 2;
|
|
} else {
|
|
w = MakeWord((unsigned char)*(psz + *pipsz), 0x00);
|
|
*pipsz += 1;
|
|
}
|
|
|
|
return w;
|
|
}
|
|
|
|
WORD STDCALL toDbcsUpperTC(WORD wch)
|
|
{
|
|
#define wchUppA 0xa2cf
|
|
#define wchUppZ 0xa2e8
|
|
#define wchUppV 0xa2e4
|
|
#define wchUppW 0xa2e5
|
|
#define wchLowA 0xa2e9
|
|
#define wchLowV 0xa2fe
|
|
#define wchLowW 0xa340
|
|
#define wchLowZ 0xa343
|
|
if ((WORD)(wch - 'a') <= ('z' - 'a')) //SBCS a ~ z
|
|
return (wch -'a' + wchUppA);
|
|
if ((WORD)(wch - 'A') <= ('Z' - 'A')) //SBCS A ~ Z
|
|
return (wch -'A' + wchUppA);
|
|
if ((WORD)(wch - '0') <= 9) //SBCS 0 ~ 9
|
|
return (wch - '0' + 0xa2af);
|
|
if ((WORD)(wch - wchUppA) <= (wchUppZ- wchUppA)) //DBCS A ~ Z
|
|
return wch;
|
|
if ((WORD)(wch - wchLowA) <= (wchLowV - wchLowA)) //DBCS a ~ v
|
|
return ( wch - wchLowA + wchUppA);
|
|
if ((WORD)(wch - wchLowW) <= (wchLowZ - wchLowW)) //DBCS w ~ z
|
|
return (wch - wchLowW + wchUppW);
|
|
if ((WORD)(wch- 0xa2af) <= 9) //DBCS 0 ~ 9
|
|
return (wch);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* test whether psz1 is prefix of psz2
|
|
return TRUE if yes, FALSE if no
|
|
Dbcs alpha is not converted !! */
|
|
|
|
/* Big-5 strokes sorting table Consultant : TAKASO/MSKK
|
|
this table must be sorted to the "wchst" value. */
|
|
|
|
struct STROKESMAP
|
|
{
|
|
WORD wchst; // start character code range
|
|
WORD wchen; // end character code range
|
|
int strokes; // strokes
|
|
};
|
|
|
|
/* Don't change oder of the each entry of this */
|
|
/* this table is sorted by first elements */
|
|
|
|
struct STROKESMAP StrokesMap[] = {
|
|
0xA259, 0, 9,
|
|
0xA25A, 0, 10,
|
|
0xA25B, 0, 11,
|
|
0xA25C, 0, 11,
|
|
0xA25D, 0, 13,
|
|
0xA25E, 0, 16,
|
|
0xA25F, 0, 13,
|
|
0xA260, 0, 8,
|
|
0xA261, 0, 15,
|
|
0xA440, 0, 1,
|
|
0xA441, 0, 1,
|
|
0xA442, 0xA453, 2,
|
|
0xA454, 0xA47E, 3,
|
|
0xA4A1, 0xA4FD, 4,
|
|
0xA4FE, 0xA5DF, 5,
|
|
0xA5E0, 0xA6E9, 6,
|
|
0xA6EA, 0xA8C2, 7,
|
|
0xA8C3, 0xAB44, 8,
|
|
0xAB45, 0xADBB, 9,
|
|
0xADBC, 0xB0AD, 10,
|
|
0xB0AE, 0xB3C2, 11,
|
|
0xB3C3, 0xB6C2, 12,
|
|
0xB6C3, 0xB9AB, 13,
|
|
0xB9AC, 0xBBF4, 14,
|
|
0xBBF5, 0xBEA6, 15,
|
|
0xBEA7, 0xC074, 16,
|
|
0xC075, 0xC24E, 17,
|
|
0xC24F, 0xC35E, 18,
|
|
0xC35F, 0xC454, 19,
|
|
0xC455, 0xC4D6, 20,
|
|
0xC4D7, 0xC56A, 21,
|
|
0xC56B, 0xC5C7, 22,
|
|
0xC5C8, 0xC5F0, 23,
|
|
0xC5F1, 0xC654, 24,
|
|
0xC655, 0xC664, 25,
|
|
0xC665, 0xC66B, 26,
|
|
0xC66C, 0xC675, 27,
|
|
0xC676, 0xC678, 28,
|
|
0xC679, 0xC67C, 29,
|
|
0xC67D, 0, 30,
|
|
0xC67E, 0, 32,
|
|
0xC940, 0xC944, 2,
|
|
0xC945, 0xC94C, 3,
|
|
0xC94D, 0xC962, 4,
|
|
0xC963, 0xC9AA, 5,
|
|
0xC9AB, 0xCA59, 6,
|
|
0xCA5A, 0xCBB0, 7,
|
|
0xCBB1, 0xCDDC, 8,
|
|
0xCDDD, 0xD0C7, 9,
|
|
0xD0C8, 0xD44A, 10,
|
|
0xD44B, 0xD850, 11,
|
|
0xD851, 0xDCB0, 12,
|
|
0xDCB1, 0xE0EF, 13,
|
|
0xE0F0, 0xE4E5, 14,
|
|
0xE4E6, 0xE8F3, 15,
|
|
0xE8F4, 0xECB8, 16,
|
|
0xECB9, 0xEFB6, 17,
|
|
0xEFB7, 0xF1EA, 18,
|
|
0xF1EB, 0xF3FC, 19,
|
|
0xF3FD, 0xF5BF, 20,
|
|
0xF5C0, 0xF6D5, 21,
|
|
0xF6D6, 0xF7CF, 22,
|
|
0xF7D0, 0xF8A4, 23,
|
|
0xF8A5, 0xF8ED, 24,
|
|
0xF8EE, 0xF96A, 25,
|
|
0xF96B, 0xF9A1, 26,
|
|
0xF9A2, 0xF9B9, 27,
|
|
0xF9BA, 0xF9C5, 28,
|
|
0xF9C6, 0, 33,
|
|
0xF9C7, 0xF9CB, 29,
|
|
0xF9CC, 0xF9CF, 30,
|
|
0xF9D0, 0, 31,
|
|
0xF9D1, 0, 32,
|
|
0xF9D2, 0, 33,
|
|
0xF9D3, 0, 35,
|
|
0xF9D4, 0, 36,
|
|
0xF9D5, 0, 48
|
|
};
|
|
#define MAXSTROKESMAP (sizeof(StrokesMap) / sizeof(struct STROKESMAP))
|
|
|
|
int STDCALL GetStrokeTC(WORD wch)
|
|
{
|
|
int i = 0;
|
|
int iLeft, iRight, iCmp;
|
|
|
|
for (iLeft = 0, iRight = MAXSTROKESMAP-1;;) {
|
|
i = (iRight + iLeft) / 2;
|
|
iCmp = wch - StrokesMap[i].wchst;
|
|
if (iLeft == iRight)
|
|
break;
|
|
if (iCmp > 0)
|
|
iLeft = i + 1;
|
|
else if (iCmp < 0)
|
|
iRight = i;
|
|
else
|
|
break;
|
|
}
|
|
|
|
if (iCmp < 0)
|
|
i--;
|
|
|
|
if (StrokesMap[i].wchst == wch || StrokesMap[i].wchst < wch &&
|
|
wch <= StrokesMap[i].wchen)
|
|
return StrokesMap[i].strokes;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
/* Function: CompStrokeTC(): stroke comparison
|
|
input : wch1, wch2: WORD
|
|
return :
|
|
1 : when wch1 precedes wch2
|
|
-1 : when wch2 precedes wch1
|
|
0 : only when "both are with non-zero and same stroke"
|
|
*/
|
|
|
|
int STDCALL CompStrokeTC(WORD wch1, WORD wch2)
|
|
{
|
|
int nStroke1, nStroke2;
|
|
WORD wchT1, wchT2;
|
|
|
|
nStroke1 = wch1 & 0x8000 ? GetStrokeTC(wch1) : 0;
|
|
nStroke2 = wch2 & 0x8000 ? GetStrokeTC(wch2) : 0;
|
|
|
|
if (nStroke1 > nStroke2) return 1;
|
|
if (nStroke1 < nStroke2) return -1;
|
|
|
|
if (nStroke1 || nStroke2)
|
|
goto LCmpCode; //return 0; // both with stroke and "same stroke"
|
|
|
|
// checking A/N
|
|
wchT1 = toDbcsUpperTC(wch1);
|
|
wchT2 = toDbcsUpperTC(wch2);
|
|
|
|
if (fMoreCmp)
|
|
if (wch1 == 0 && wch2 != 0) return -1; //prefix
|
|
|
|
if (wchT1 > wchT2) return 1;
|
|
if (wchT1 < wchT2) return -1;
|
|
|
|
if (wchT1 && wchT2) {
|
|
fMoreCmp = TRUE;
|
|
return 0;
|
|
}
|
|
|
|
LCmpCode:
|
|
// seem equal !!
|
|
if (wch1 > wch2) return 1;
|
|
if (wch1 < wch2) return -1;
|
|
|
|
// actually equal !!
|
|
return 0;
|
|
}
|
|
|
|
int STDCALL WCmpiTaiwanSz(PCSTR sz1, PCSTR sz2)
|
|
{
|
|
WORD wch1, wch2;
|
|
int ipsz1, ipsz2, nRet;
|
|
|
|
nRet = ipsz1 = ipsz2 = 0;
|
|
fMoreCmp = FALSE;
|
|
|
|
for(;;) {
|
|
wch1 = GetWchTC(sz1, &ipsz1);
|
|
wch2 = GetWchTC(sz2, &ipsz2);
|
|
nRet = CompStrokeTC(wch1, wch2);
|
|
if (nRet)
|
|
return nRet;
|
|
if (wch1 == 0 || wch2 == 0)
|
|
break;
|
|
}
|
|
|
|
//more cmp
|
|
if (!fMoreCmp)
|
|
return 0;
|
|
|
|
ipsz1 = ipsz2 = 0;
|
|
for(;;) {
|
|
wch1= GetWchTC(sz1, &ipsz1);
|
|
wch2= GetWchTC(sz2, &ipsz2);
|
|
if (wch1 > wch2)
|
|
return 1;
|
|
if (wch1 < wch2)
|
|
return -1;
|
|
if (wch1== 0 || wch2 == 0)
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// End of TAIWAN's portions
|
|
//=========================
|
|
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: IsFirstByte
|
|
|
|
PURPOSE: Find out if the first byte is a lead byte for a DBCS character
|
|
|
|
PARAMETERS:
|
|
x -- character to check
|
|
|
|
RETURNS:
|
|
|
|
COMMENTS:
|
|
|
|
MODIFICATION DATES:
|
|
09-May-1994 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
BOOL STDCALL IsFirstByte(unsigned char x)
|
|
{
|
|
if (!options.fDBCS)
|
|
return FALSE;
|
|
|
|
// REVIEW: [ralph] This is similar to what was done in previous
|
|
// versions. But why don't all of these call IsDBCSLeadByte()?
|
|
|
|
switch (PRIMARYLANGID(kwlcid.langid)) {
|
|
case LANG_KOREAN:
|
|
return (x >= 0xA1 && x <= 0xFE);
|
|
|
|
case LANG_CHINESE:
|
|
// To ensure korean, check for sub-lang of SUBLANG_CHINESE_TRADITIONAL
|
|
|
|
return (x >= 0x81 && x <= 0xFE);
|
|
|
|
case LANG_JAPANESE:
|
|
default:
|
|
return IsDBCSLeadByte(x);
|
|
}
|
|
}
|
|
|
|
/***************************************************************************
|
|
;* *
|
|
;* Common definition for EE languages. *
|
|
;* Created from EE language DLLs for Win 3.1 *
|
|
;***************************************************************************
|
|
;* Created 21/10/92 by YST *
|
|
;***************************************************************************/
|
|
|
|
// Structure Definitions used in include file
|
|
|
|
#define fUpper 0x01
|
|
#define fLower 0x02
|
|
#define fAlpha fUpper + fLower
|
|
#define fNum 0x04
|
|
#define fWeight2 0x78
|
|
|
|
// Secondary weight, normally 0-7 Upper case, 8-15 Lower case
|
|
|
|
#define Weight2_0 0x00
|
|
#define Weight2_1 0x08
|
|
#define Weight2_2 0x10
|
|
#define Weight2_3 0x18
|
|
#define Weight2_4 0x20
|
|
#define Weight2_5 0x28
|
|
#define Weight2_6 0x30
|
|
#define Weight2_7 0x38
|
|
#define Weight2_8 0x40
|
|
#define Weight2_9 0x48
|
|
#define Weight2_10 0x50
|
|
#define Weight2_11 0x58
|
|
#define Weight2_12 0x60
|
|
#define Weight2_13 0x68
|
|
#define Weight2_14 0x70
|
|
#define Weight2_15 0x78
|
|
|
|
#define fSpecial 0x80 // Look into SpecialTab also
|
|
|
|
// Compress/expand functions
|
|
|
|
#define CompressA 1
|
|
#define CompressB 2
|
|
#define CompressC 3
|
|
#define CompressD 4
|
|
#define ExpandA 5
|
|
#define ExpandB 6
|
|
#define ExpandC 7
|
|
|
|
// Special struct for EE languages (see "EE language supports" by YST)
|
|
|
|
struct _tagSpecialStruct {
|
|
TBYTE tcEntry;
|
|
TBYTE tcSpecialChr1;
|
|
TBYTE tcSpecialChr2;
|
|
TBYTE tcSpecialChr3;
|
|
TBYTE tcSpecialChr4;
|
|
TBYTE tcSpecialChr5;
|
|
TBYTE tcSpecialChr6;
|
|
TBYTE tcReplacement1;
|
|
TBYTE tcReplacement2;
|
|
short tcFunctionDef;
|
|
};
|
|
|
|
// Language table
|
|
struct _tagLangTab {
|
|
short sSortOrder; // Common sorting order
|
|
short sSecWeight; // Secondary weight and flags
|
|
};
|
|
|
|
#include "eelang.h"
|
|
|
|
///Prototypes
|
|
|
|
unsigned char WgtCompressB(PCSTR, struct _tagSpecialStruct);
|
|
unsigned char WgtCompressD(PCSTR, struct _tagSpecialStruct);
|
|
unsigned char WgtExpandB(PCSTR, struct _tagSpecialStruct);
|
|
unsigned char WgtExpandC(PCSTR, struct _tagSpecialStruct);
|
|
int STDCALL WCmpiEESz(PCSTR, PCSTR,
|
|
struct _tagSpecialStruct[], struct _tagLangTab[]);
|
|
|
|
|
|
// CompressB function: compress two letters to one
|
|
|
|
unsigned char WgtCompressB(PCSTR sz1,
|
|
struct _tagSpecialStruct SpecialStructEE)
|
|
{
|
|
PSTR szp;
|
|
|
|
szp = (PSTR) sz1;
|
|
szp++;
|
|
|
|
if (((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr1))
|
|
return(SpecialStructEE.tcReplacement1);
|
|
else if (((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr2))
|
|
return(SpecialStructEE.tcReplacement1);
|
|
else {
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
// CompressC function: compress three letters to one
|
|
|
|
unsigned char WgtCompressD(PCSTR sz1,
|
|
struct _tagSpecialStruct SpecialStructEE)
|
|
{
|
|
PSTR szp;
|
|
|
|
szp = (PSTR) sz1;
|
|
szp++;
|
|
|
|
if ((((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr1)) ||
|
|
(((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr2))) {
|
|
szp++;
|
|
if ((((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr3)) ||
|
|
(((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr4)))
|
|
return(SpecialStructEE.tcReplacement1);
|
|
else
|
|
return (0);
|
|
}
|
|
else {
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
// ExpandB function: expands three letters to two
|
|
|
|
unsigned char WgtExpandB(PCSTR sz1,
|
|
struct _tagSpecialStruct SpecialStructEE)
|
|
{
|
|
PSTR szp;
|
|
|
|
szp = (PSTR) sz1;
|
|
szp++;
|
|
|
|
if ((((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr1)) ||
|
|
(((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr2))) {
|
|
szp++;
|
|
if ((((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr3)) ||
|
|
(((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr4)))
|
|
return(SpecialStructEE.tcReplacement1);
|
|
else
|
|
return (0);
|
|
}
|
|
else {
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
// ExpandC function: expands/compress for Hungarian
|
|
|
|
unsigned char WgtExpandC(PCSTR sz1,
|
|
struct _tagSpecialStruct SpecialStructEE)
|
|
{
|
|
PSTR szp;
|
|
|
|
szp = (PSTR) sz1;
|
|
szp++;
|
|
|
|
if ((((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr1)) ||
|
|
(((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr2))) {
|
|
szp++;
|
|
if ((((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr3)) ||
|
|
(((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr4))) {
|
|
|
|
if ((((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr5)) ||
|
|
(((unsigned char) *szp) ==
|
|
((unsigned char) SpecialStructEE.tcSpecialChr6)))
|
|
return(SpecialStructEE.tcReplacement1);
|
|
else
|
|
return (0);
|
|
}
|
|
else
|
|
return (0);
|
|
}
|
|
else {
|
|
return (0);
|
|
}
|
|
}
|
|
|
|
/* Common function for comparing two EE strings
|
|
Use two tables:
|
|
SpecialStructEE - special cases (as compress, expend)
|
|
LangTabEE - sorting order with secondary weights.
|
|
*/
|
|
|
|
int STDCALL WCmpiEESz(PCSTR sz1, PCSTR sz2,
|
|
struct _tagSpecialStruct SpecialStructEE[],
|
|
struct _tagLangTab LangTabEE[])
|
|
{
|
|
int iK;
|
|
int i = 0;
|
|
int j = 0;
|
|
unsigned char Weig1 = 0;
|
|
unsigned char Weig2 = 0;
|
|
|
|
M1:
|
|
while(*sz1 && *sz2) {
|
|
|
|
// Checking for Special flag
|
|
|
|
if ((LangTabEE[((int) ((unsigned char) *sz1)) ].sSecWeight & fSpecial) ||
|
|
(LangTabEE[((int) ((unsigned char) *sz2)) ].sSecWeight & fSpecial))
|
|
goto M2;
|
|
|
|
// No special, use only LangTab
|
|
|
|
if (((unsigned char) *sz1) - ((unsigned char) *sz2)) {
|
|
iK = LangTabEE[(unsigned char) *sz1].sSortOrder -
|
|
LangTabEE[(unsigned char) *sz2].sSortOrder;
|
|
if (!iK)
|
|
return((LangTabEE[(unsigned char) *sz1].sSecWeight & (~fSpecial)) -
|
|
(LangTabEE[(unsigned char) *sz2].sSecWeight & (~fSpecial)));
|
|
else
|
|
return(iK);
|
|
}
|
|
else {
|
|
sz1++; sz2++;
|
|
}
|
|
}
|
|
|
|
iK = LangTabEE[(unsigned char) *sz1].sSortOrder -
|
|
LangTabEE[(unsigned char) *sz2].sSortOrder;
|
|
if(!iK)
|
|
return((LangTabEE[(unsigned char)*sz1].sSecWeight & (~fSpecial)) -
|
|
(LangTabEE[(unsigned char)*sz2].sSecWeight & (~fSpecial)));
|
|
else
|
|
return(iK);
|
|
|
|
M2:
|
|
// Special cases
|
|
Weig1 = 0;
|
|
Weig2 = 0;
|
|
M3:
|
|
while((SpecialStructEE[i].tcEntry != *sz1) &&
|
|
(SpecialStructEE[i].tcEntry != 0))
|
|
i++;
|
|
|
|
if(SpecialStructEE[i].tcEntry != 0)
|
|
goto M5;
|
|
|
|
M4:
|
|
while((SpecialStructEE[j].tcEntry != *sz2) &&
|
|
(SpecialStructEE[j].tcEntry != 0))
|
|
j++;
|
|
|
|
if(SpecialStructEE[j].tcEntry != 0)
|
|
goto M6;
|
|
|
|
M7:
|
|
if(Weig1) {
|
|
if(Weig2) {
|
|
if(Weig1 == Weig2) {
|
|
sz1++; sz2++;
|
|
goto M1;
|
|
}
|
|
else {
|
|
iK = LangTabEE[Weig1].sSortOrder -
|
|
LangTabEE[Weig2].sSortOrder;
|
|
if(!iK)
|
|
return((LangTabEE[Weig1].sSecWeight & (~fSpecial)) -
|
|
(LangTabEE[Weig2].sSecWeight & (~fSpecial)));
|
|
else return(iK);
|
|
}
|
|
}
|
|
else if(Weig1 == ((unsigned char)*sz2)) {
|
|
sz1++; sz2++;
|
|
goto M1;
|
|
}
|
|
else {
|
|
iK = LangTabEE[Weig1].sSortOrder -
|
|
LangTabEE[(unsigned char)*sz2].sSortOrder;
|
|
if(!iK)
|
|
return((LangTabEE[Weig1].sSecWeight & (~fSpecial)) -
|
|
(LangTabEE[(unsigned char)*sz2].sSecWeight & (~fSpecial)));
|
|
else return(iK);
|
|
}
|
|
}
|
|
else {
|
|
if(Weig2) {
|
|
if(((unsigned char)*sz1) == Weig2) {
|
|
sz1++; sz2++;
|
|
goto M1;
|
|
}
|
|
else {
|
|
iK = LangTabEE[(unsigned char) *sz1].sSortOrder -
|
|
LangTabEE[Weig2].sSortOrder;
|
|
if(!iK)
|
|
return((LangTabEE[(unsigned char) *sz1].sSecWeight & (~fSpecial)) -
|
|
(LangTabEE[Weig2].sSecWeight & (~fSpecial)));
|
|
else return(iK);
|
|
}
|
|
}
|
|
else if(((unsigned char)*sz1) == ((unsigned char)*sz2)) {
|
|
sz1++; sz2++;
|
|
goto M1;
|
|
}
|
|
else {
|
|
iK = LangTabEE[(unsigned char) *sz1].sSortOrder -
|
|
LangTabEE[(unsigned char)*sz2].sSortOrder;
|
|
if(!iK)
|
|
return((LangTabEE[(unsigned char)*sz1].sSecWeight & (~fSpecial)) -
|
|
(LangTabEE[(unsigned char)*sz2].sSecWeight & (~fSpecial)));
|
|
else return(iK);
|
|
}
|
|
}
|
|
M5:
|
|
switch(SpecialStructEE[i].tcFunctionDef) {
|
|
case CompressB:
|
|
case CompressC:
|
|
Weig1 = WgtCompressB(sz1, SpecialStructEE[i]);
|
|
if(Weig1) {
|
|
sz1++;
|
|
goto M4;
|
|
}
|
|
else {
|
|
i++;
|
|
goto M3;
|
|
}
|
|
break;
|
|
|
|
case CompressD:
|
|
Weig1 = WgtCompressD(sz1, SpecialStructEE[i]);
|
|
if(Weig1) {
|
|
sz1++;
|
|
sz1++;
|
|
goto M4;
|
|
}
|
|
else {
|
|
i++;
|
|
goto M3;
|
|
}
|
|
break;
|
|
|
|
case ExpandB:
|
|
Weig1 = WgtExpandB(sz1, SpecialStructEE[i]);
|
|
if(Weig1) {
|
|
goto M4;
|
|
}
|
|
else {
|
|
i++;
|
|
goto M3;
|
|
}
|
|
break;
|
|
|
|
case ExpandC:
|
|
Weig1 = WgtExpandB(sz1, SpecialStructEE[i]);
|
|
if(Weig1) {
|
|
goto M4;
|
|
}
|
|
else {
|
|
i++;
|
|
goto M3;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
i++;
|
|
goto M3;
|
|
|
|
}
|
|
i++;
|
|
goto M3;
|
|
|
|
M6:
|
|
switch(SpecialStructEE[j].tcFunctionDef) {
|
|
// CompressB and CompressC are the same functions for HC & WinHelp
|
|
case CompressB:
|
|
case CompressC:
|
|
Weig2 = WgtCompressB(sz2, SpecialStructEE[j]);
|
|
if(Weig2) {
|
|
sz2++;
|
|
goto M7;
|
|
}
|
|
else {
|
|
j++;
|
|
goto M4;
|
|
}
|
|
break;
|
|
|
|
case CompressD:
|
|
Weig2 = WgtCompressB(sz2, SpecialStructEE[j]);
|
|
if(Weig2) {
|
|
sz2++;
|
|
sz2++;
|
|
goto M7;
|
|
}
|
|
else {
|
|
j++;
|
|
goto M4;
|
|
}
|
|
break;
|
|
|
|
case ExpandB:
|
|
Weig2 = WgtExpandB(sz2, SpecialStructEE[j]);
|
|
if(Weig2) {
|
|
goto M7;
|
|
}
|
|
else {
|
|
j++;
|
|
goto M4;
|
|
}
|
|
break;
|
|
|
|
case ExpandC:
|
|
Weig2 = WgtExpandB(sz2, SpecialStructEE[j]);
|
|
if(Weig2) {
|
|
goto M7;
|
|
}
|
|
else {
|
|
j++;
|
|
goto M4;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
j++;
|
|
goto M7;
|
|
|
|
}
|
|
j++;
|
|
goto M7;
|
|
|
|
}
|
|
|
|
// Comparing string for Czech language
|
|
// Use special tables for Czech (see langee.H)
|
|
|
|
int STDCALL WCmpiCZSz(PCSTR sz1, PCSTR sz2)
|
|
{
|
|
return WCmpiEESz(sz1, sz2, SpecialStructCZ, LangTabCZ);
|
|
}
|
|
|
|
// Comparing string for Hungarian language
|
|
// Use special tables for Hungarian (see langee.H)
|
|
|
|
int STDCALL WCmpiHUSz(PCSTR sz1, PCSTR sz2)
|
|
{
|
|
return WCmpiEESz(sz1, sz2, SpecialStructHU, LangTabHU);
|
|
}
|
|
|
|
// Comparing string for Polish language
|
|
|
|
int STDCALL WCmpiPLSz(PCSTR sz1, PCSTR sz2)
|
|
{
|
|
while (0 == (int) ((unsigned char) *sz1 - (unsigned char) *sz2)) {
|
|
if ('\0' == *sz1) return 0;
|
|
sz1++; sz2++;
|
|
}
|
|
|
|
while (0 == (mpchordNormEE[(unsigned char) *sz1] -
|
|
mpchordNormEE[(unsigned char) *sz2]))
|
|
{
|
|
if ('\0' == *sz1) return 0;
|
|
sz1++; sz2++;
|
|
}
|
|
|
|
return mpchordNormEE[(unsigned char) *sz1] -
|
|
mpchordNormEE[(unsigned char) *sz2];
|
|
}
|
|
|
|
// Comparing string for Russian language
|
|
|
|
int STDCALL WCmpiRUSz(PCSTR sz1, PCSTR sz2)
|
|
{
|
|
while (0 == (int) ((unsigned char) *sz1 - (unsigned char) *sz2)) {
|
|
if ('\0' == *sz1) return 0;
|
|
sz1++; sz2++;
|
|
}
|
|
|
|
while (0 == (mpchordCyr[(unsigned char) *sz1] - mpchordCyr[(unsigned char) *sz2]))
|
|
{
|
|
if ('\0' == *sz1) return 0;
|
|
sz1++; sz2++;
|
|
}
|
|
|
|
return mpchordCyr[(unsigned char) *sz1] - mpchordCyr[(unsigned char) *sz2];
|
|
}
|
|
|
|
/***************************************************************************
|
|
|
|
FUNCTION: WNlsCmpiSz
|
|
|
|
PURPOSE: NLS comparison of two strings
|
|
|
|
PARAMETERS:
|
|
psz1
|
|
psz2
|
|
|
|
RETURNS: -2 on error, else -1, 0 or 1
|
|
|
|
COMMENTS:
|
|
|
|
MODIFICATION DATES:
|
|
03-Jun-1994 [ralphw]
|
|
|
|
***************************************************************************/
|
|
|
|
int STDCALL WNlsCmpiSz(PCSTR psz1, PCSTR psz2)
|
|
{
|
|
// We do this for speed and because JChicago build 122 gives incorrect
|
|
// results for CompareStringA
|
|
|
|
if (!lcid || LANGIDFROMLCID(lcid) == 0x0409)
|
|
return _stricmp(psz1, psz2);
|
|
|
|
return CompareStringA(lcid, NORM_IGNORECASE | fsCompareI, psz1, -1, psz2,
|
|
-1) - 2;
|
|
}
|
|
|
|
int STDCALL WNlsCmpSz(PCSTR psz1, PCSTR psz2)
|
|
{
|
|
// We do this for speed and because JChicago build 122 gives incorrect
|
|
// results for CompareStringA
|
|
|
|
if (!lcid || LANGIDFROMLCID(lcid) == 0x0409)
|
|
return strcmp(psz1, psz2);
|
|
|
|
return CompareStringA(lcid, fsCompare, psz1, -1, psz2,
|
|
-1) - 2;
|
|
}
|
|
|
|
int STDCALL WCmpiScandSz(LPCSTR sz1, LPCSTR sz2)
|
|
{
|
|
while (0 == (INT16) ((unsigned char) *sz1 - (unsigned char) *sz2)) {
|
|
if ('\0' == *sz1)
|
|
return 0;
|
|
sz1++;
|
|
sz2++;
|
|
}
|
|
|
|
while (0 == (mpchordScan[(unsigned char) *sz1] - mpchordScan[(unsigned char) *sz2]))
|
|
{
|
|
if ('\0' == *sz1)
|
|
return 0;
|
|
sz1++;
|
|
sz2++;
|
|
}
|
|
|
|
return mpchordScan[(unsigned char)*sz1] - mpchordScan[(unsigned char)*sz2];
|
|
}
|