Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
NT4/private/windows/win4help/hcrtf/btkey.cpp

2315 lines
45 KiB
C++
Raw Permalink Normal View History

First commit
2001-01-01 00:00:00 +01:00
/*****************************************************************************
* *
* 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];
}
Reference in New Issue Copy Permalink