|
|
/*++
Copyright (c) 1991-2000, Microsoft Corporation All rights reserved.
Module Name:
string.c
Abstract:
This file contains functions that deal with characters and strings.
APIs found in this file: CompareStringW GetStringTypeExW GetStringTypeW
Revision History:
05-31-91 JulieB Created.
--*/
//
// Include Files.
//
#include "nls.h"
#include "nlssafe.h"
#include "jamo.h"
//
// Constant Declarations.
//
//
// State Table.
//
#define STATE_DW 1 // normal diacritic weight state
#define STATE_REVERSE_DW 2 // reverse diacritic weight state
#define STATE_CW 4 // case weight state
#define STATE_JAMO_WEIGHT 8 // jamo weight state
//
// Invalid weight value.
//
#define CMP_INVALID_WEIGHT 0xffffffff
#define CMP_INVALID_FAREAST 0xffff0000
#define CMP_INVALID_UW 0xffff
//
// Forward Declarations.
//
intLongCompareStringW( PLOC_HASH pHashN, DWORD dwCmpFlags, LPCWSTR lpString1, int cchCount1, LPCWSTR lpString2, int cchCount2, BOOL fModify);
intFindJamoDifference( PLOC_HASH pHashN, LPCWSTR* ppString1, int* ctr1, int cchCount1, DWORD* pWeight1, LPCWSTR* ppString2, int* ctr2, int cchCount2, DWORD* pWeight2, LPCWSTR* pLastJamo, WORD* uw1, WORD* uw2, int* pState, int* WhichJamo, BOOL fModify);
//-------------------------------------------------------------------------//
// INTERNAL MACROS //
//-------------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////
//
// NOT_END_STRING
//
// Checks to see if the search has reached the end of the string.
// It returns TRUE if the counter is not at zero (counting backwards) and
// the null termination has not been reached (if -1 was passed in the count
// parameter.
//
// 11-04-92 JulieB Created.
////////////////////////////////////////////////////////////////////////////
#define NOT_END_STRING(ct, ptr, cchIn) \
((ct != 0) && (!((*(ptr) == 0) && (cchIn == -2))))
////////////////////////////////////////////////////////////////////////////
//
// AT_STRING_END
//
// Checks to see if the pointer is at the end of the string.
// It returns TRUE if the counter is zero or if the null termination
// has been reached (if -2 was passed in the count parameter).
//
// 11-04-92 JulieB Created.
////////////////////////////////////////////////////////////////////////////
#define AT_STRING_END(ct, ptr, cchIn) \
((ct == 0) || ((*(ptr) == 0) && (cchIn == -2)))
////////////////////////////////////////////////////////////////////////////
//
// REMOVE_STATE
//
// Removes the current state from the state table. This should only be
// called when the current state should not be entered for the remainder
// of the comparison. It decrements the counter going through the state
// table and decrements the number of states in the table.
//
// 11-04-92 JulieB Created.
////////////////////////////////////////////////////////////////////////////
#define REMOVE_STATE(value) (State &= ~value)
////////////////////////////////////////////////////////////////////////////
//
// POINTER_FIXUP
//
// Fixup the string pointers if expansion characters were found.
// Then, advance the string pointers and decrement the string counters.
//
// 11-04-92 JulieB Created.
////////////////////////////////////////////////////////////////////////////
#define POINTER_FIXUP() \
{ \ /* \
* Fixup the pointers (if necessary). \ */ \ if (pSave1 && (--cExpChar1 == 0)) \ { \ /* \
* Done using expansion temporary buffer. \ */ \ pString1 = pSave1; \ pSave1 = NULL; \ } \ \ if (pSave2 && (--cExpChar2 == 0)) \ { \ /* \
* Done using expansion temporary buffer. \ */ \ pString2 = pSave2; \ pSave2 = NULL; \ } \ \ /* \
* Advance the string pointers. \ */ \ pString1++; \ pString2++; \}
////////////////////////////////////////////////////////////////////////////
//
// SCAN_LONGER_STRING
//
// Scans the longer string for diacritic, case, and special weights.
//
// 11-04-92 JulieB Created.
////////////////////////////////////////////////////////////////////////////
#define SCAN_LONGER_STRING( ct, \
ptr, \ cchIn, \ ret ) \{ \ /* \
* Search through the rest of the longer string to make sure \ * all characters are not to be ignored. If find a character that \ * should not be ignored, return the given return value immediately. \ * \ * The only exception to this is when a nonspace mark is found. If \ * another DW difference has been found earlier, then use that. \ */ \ while (NOT_END_STRING(ct, ptr, cchIn)) \ { \ Weight1 = GET_DWORD_WEIGHT(pHashN, *ptr); \ switch (GET_SCRIPT_MEMBER(&Weight1)) \ { \ case ( UNSORTABLE ): \ { \ break; \ } \ case ( NONSPACE_MARK ): \ { \ if ((!fIgnoreDiacritic) && (!WhichDiacritic)) \ { \ return (ret); \ } \ break; \ } \ case ( PUNCTUATION ) : \ case ( SYMBOL_1 ) : \ case ( SYMBOL_2 ) : \ case ( SYMBOL_3 ) : \ case ( SYMBOL_4 ) : \ case ( SYMBOL_5 ) : \ { \ if (!fIgnoreSymbol) \ { \ return (ret); \ } \ break; \ } \ case ( EXPANSION ) : \ case ( FAREAST_SPECIAL ) : \ case ( JAMO_SPECIAL ) : \ case ( EXTENSION_A ) : \ default : \ { \ return (ret); \ } \ } \ \ /* \
* Advance pointer and decrement counter. \ */ \ ptr++; \ ct--; \ } \ \ /* \
* Need to check diacritic, case, extra, and special weights for \ * final return value. Still could be equal if the longer part of \ * the string contained only characters to be ignored. \ * \ * NOTE: The following checks MUST REMAIN IN THIS ORDER: \ * Diacritic, Case, Extra, Punctuation. \ */ \ if (WhichDiacritic) \ { \ return (WhichDiacritic); \ } \ if (WhichCase) \ { \ return (WhichCase); \ } \ if (WhichExtra) \ { \ if (!fIgnoreDiacritic) \ { \ if (GET_WT_FOUR(&WhichExtra)) \ { \ return (GET_WT_FOUR(&WhichExtra)); \ } \ if (GET_WT_FIVE(&WhichExtra)) \ { \ return (GET_WT_FIVE(&WhichExtra)); \ } \ } \ if (GET_WT_SIX(&WhichExtra)) \ { \ return (GET_WT_SIX(&WhichExtra)); \ } \ if (GET_WT_SEVEN(&WhichExtra)) \ { \ return (GET_WT_SEVEN(&WhichExtra)); \ } \ } \ if (WhichJamo) \ { \ return (WhichJamo); \ } \ if (WhichPunct1) \ { \ return (WhichPunct1); \ } \ if (WhichPunct2) \ { \ return (WhichPunct2); \ } \ \ return (CSTR_EQUAL); \}
////////////////////////////////////////////////////////////////////////////
//
// QUICK_SCAN_LONGER_STRING
//
// Scans the longer string for diacritic, case, and special weights.
// Assumes that both strings are null-terminated.
//
// 11-04-92 JulieB Created.
////////////////////////////////////////////////////////////////////////////
#define QUICK_SCAN_LONGER_STRING( ptr, \
ret ) \{ \ /* \
* Search through the rest of the longer string to make sure \ * all characters are not to be ignored. If find a character that \ * should not be ignored, return the given return value immediately. \ * \ * The only exception to this is when a nonspace mark is found. If \ * another DW difference has been found earlier, then use that. \ */ \ while (*ptr != 0) \ { \ switch (GET_SCRIPT_MEMBER(&(pHashN->pSortkey[*ptr]))) \ { \ case ( UNSORTABLE ): \ { \ break; \ } \ case ( NONSPACE_MARK ): \ { \ if (!WhichDiacritic) \ { \ return (ret); \ } \ break; \ } \ default : \ { \ return (ret); \ } \ } \ \ /* \
* Advance pointer. \ */ \ ptr++; \ } \ \ /* \
* Need to check diacritic, case, extra, and special weights for \ * final return value. Still could be equal if the longer part of \ * the string contained only unsortable characters. \ * \ * NOTE: The following checks MUST REMAIN IN THIS ORDER: \ * Diacritic, Case, Extra, Punctuation. \ */ \ if (WhichDiacritic) \ { \ return (WhichDiacritic); \ } \ if (WhichCase) \ { \ return (WhichCase); \ } \ if (WhichExtra) \ { \ if (GET_WT_FOUR(&WhichExtra)) \ { \ return (GET_WT_FOUR(&WhichExtra)); \ } \ if (GET_WT_FIVE(&WhichExtra)) \ { \ return (GET_WT_FIVE(&WhichExtra)); \ } \ if (GET_WT_SIX(&WhichExtra)) \ { \ return (GET_WT_SIX(&WhichExtra)); \ } \ if (GET_WT_SEVEN(&WhichExtra)) \ { \ return (GET_WT_SEVEN(&WhichExtra)); \ } \ } \ if (WhichJamo) \ { \ return (WhichJamo); \ } \ if (WhichPunct1) \ { \ return (WhichPunct1); \ } \ if (WhichPunct2) \ { \ return (WhichPunct2); \ } \ \ return (CSTR_EQUAL); \}
////////////////////////////////////////////////////////////////////////////
//
// GET_FAREAST_WEIGHT
//
// Returns the weight for the far east special case in "wt". This currently
// includes the Cho-on, the Repeat, and the Kana characters.
//
// 08-19-93 JulieB Created.
////////////////////////////////////////////////////////////////////////////
#define GET_FAREAST_WEIGHT( wt, \
uw, \ mask, \ pBegin, \ pCur, \ ExtraWt, \ fModify ) \{ \ int ct; /* loop counter */ \ BYTE PrevSM; /* previous script member value */ \ BYTE PrevAW; /* previous alphanumeric value */ \ BYTE PrevCW; /* previous case value */ \ BYTE AW; /* alphanumeric value */ \ BYTE CW; /* case value */ \ DWORD PrevWt; /* previous weight */ \ \ \ /* \
* Get the alphanumeric weight and the case weight of the \ * current code point. \ */ \ AW = GET_ALPHA_NUMERIC(&wt); \ CW = GET_CASE(&wt); \ ExtraWt = (DWORD)0; \ \ /* \
* Special case Repeat and Cho-On. \ * AW = 0 => Repeat \ * AW = 1 => Cho-On \ * AW = 2+ => Kana \ */ \ if (AW <= MAX_SPECIAL_AW) \ { \ /* \
* If the script member of the previous character is \ * invalid, then give the special character an \ * invalid weight (highest possible weight) so that it \ * will sort AFTER everything else. \ */ \ ct = 1; \ PrevWt = CMP_INVALID_FAREAST; \ while ((pCur - ct) >= pBegin) \ { \ PrevWt = GET_DWORD_WEIGHT(pHashN, *(pCur - ct)); \ PrevWt &= mask; \ PrevSM = GET_SCRIPT_MEMBER(&PrevWt); \ if (PrevSM < FAREAST_SPECIAL) \ { \ if (PrevSM == EXPANSION) \ { \ PrevWt = CMP_INVALID_FAREAST; \ } \ else \ { \ /* \
* UNSORTABLE or NONSPACE_MARK. \ * \ * Just ignore these, since we only care about the \ * previous UW value. \ */ \ PrevWt = CMP_INVALID_FAREAST; \ ct++; \ continue; \ } \ } \ else if (PrevSM == FAREAST_SPECIAL) \ { \ PrevAW = GET_ALPHA_NUMERIC(&PrevWt); \ if (PrevAW <= MAX_SPECIAL_AW) \ { \ /* \
* Handle case where two special chars follow \ * each other. Keep going back in the string. \ */ \ PrevWt = CMP_INVALID_FAREAST; \ ct++; \ continue; \ } \ \ UNICODE_WT(&PrevWt) = \ MAKE_UNICODE_WT(KANA, PrevAW, fModify); \ \ /* \
* Only build weights 4, 5, 6, and 7 if the \ * previous character is KANA. \ * \ * Always: \ * 4W = previous CW & ISOLATE_SMALL \ * 6W = previous CW & ISOLATE_KANA \ * \ */ \ PrevCW = GET_CASE(&PrevWt); \ GET_WT_FOUR(&ExtraWt) = PrevCW & ISOLATE_SMALL; \ GET_WT_SIX(&ExtraWt) = PrevCW & ISOLATE_KANA; \ \ if (AW == AW_REPEAT) \ { \ /* \
* Repeat: \ * UW = previous UW \ * 5W = WT_FIVE_REPEAT \ * 7W = previous CW & ISOLATE_WIDTH \ */ \ uw = UNICODE_WT(&PrevWt); \ GET_WT_FIVE(&ExtraWt) = WT_FIVE_REPEAT; \ GET_WT_SEVEN(&ExtraWt) = PrevCW & ISOLATE_WIDTH; \ } \ else \ { \ /* \
* Cho-On: \ * UW = previous UW & CHO_ON_UW_MASK \ * 5W = WT_FIVE_CHO_ON \ * 7W = current CW & ISOLATE_WIDTH \ */ \ uw = UNICODE_WT(&PrevWt) & CHO_ON_UW_MASK; \ GET_WT_FIVE(&ExtraWt) = WT_FIVE_CHO_ON; \ GET_WT_SEVEN(&ExtraWt) = CW & ISOLATE_WIDTH; \ } \ } \ else \ { \ uw = GET_UNICODE_MOD(&PrevWt, fModify); \ } \ \ break; \ } \ } \ else \ { \ /* \
* Kana: \ * SM = KANA \ * AW = current AW \ * 4W = current CW & ISOLATE_SMALL \ * 5W = WT_FIVE_KANA \ * 6W = current CW & ISOLATE_KANA \ * 7W = current CW & ISOLATE_WIDTH \ */ \ uw = MAKE_UNICODE_WT(KANA, AW, fModify); \ GET_WT_FOUR(&ExtraWt) = CW & ISOLATE_SMALL; \ GET_WT_FIVE(&ExtraWt) = WT_FIVE_KANA; \ GET_WT_SIX(&ExtraWt) = CW & ISOLATE_KANA; \ GET_WT_SEVEN(&ExtraWt) = CW & ISOLATE_WIDTH; \ } \ \ /* \
* Get the weight for the far east special case and store it in wt. \ */ \ if ((AW > MAX_SPECIAL_AW) || (PrevWt != CMP_INVALID_FAREAST)) \ { \ /* \
* Always: \ * DW = current DW \ * CW = minimum CW \ */ \ UNICODE_WT(&wt) = uw; \ CASE_WT(&wt) = MIN_CW; \ } \ else \ { \ uw = CMP_INVALID_UW; \ wt = CMP_INVALID_FAREAST; \ ExtraWt = 0; \ } \}
//-------------------------------------------------------------------------//
// API ROUTINES //
//-------------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////
//
// CompareStringW
//
// Compares two wide character strings of the same locale according to the
// supplied locale handle.
//
// 05-31-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int WINAPI CompareStringW( LCID Locale, DWORD dwCmpFlags, LPCWSTR lpString1, int cchCount1, LPCWSTR lpString2, int cchCount2){ register LPWSTR pString1; // ptr to go thru string 1
register LPWSTR pString2; // ptr to go thru string 2
PLOC_HASH pHashN; // ptr to LOC hash node
BOOL fIgnorePunct; // flag to ignore punctuation (not symbol)
BOOL fModify; // flag to use modified script member weights
DWORD State; // state table
DWORD Mask; // mask for weights
DWORD Weight1; // full weight of char - string 1
DWORD Weight2; // full weight of char - string 2
int JamoFlag = FALSE; LPCWSTR pLastJamo = lpString1;
int WhichDiacritic; // DW => 1 = str1 smaller, 3 = str2 smaller
int WhichCase; // CW => 1 = str1 smaller, 3 = str2 smaller
int WhichJamo; // XW for Jamo
int WhichPunct1; // SW => 1 = str1 smaller, 3 = str2 smaller
int WhichPunct2; // SW => 1 = str1 smaller, 3 = str2 smaller
LPWSTR pSave1; // ptr to saved pString1
LPWSTR pSave2; // ptr to saved pString2
int cExpChar1, cExpChar2; // ct of expansions in tmp
DWORD ExtraWt1, ExtraWt2; // extra weight values (for far east)
DWORD WhichExtra; // XW => wts 4, 5, 6, 7 (for far east)
//
// Invalid Parameter Check:
// - validate LCID
// - either string is null
//
VALIDATE_LANGUAGE(Locale, pHashN, 0, TRUE); if ((pHashN == NULL) || (lpString1 == NULL) || (lpString2 == NULL)) { SetLastError(ERROR_INVALID_PARAMETER); return (0); }
//
// Make sure the appropriate sorting tables are available. If not,
// return an error.
//
if ((pHashN->pSortkey == NULL) || (pHashN->IfIdeographFailure == TRUE)) { KdPrint(("NLSAPI: Appropriate Sorting Tables Not Loaded.\n")); SetLastError(ERROR_FILE_NOT_FOUND); return (0); }
//
// Call longer compare string if any of the following is true:
// - compression locale
// - either count is not -1
// - dwCmpFlags is not 0 or ignore case (see NOTE below)
// - locale is Korean - script member weight adjustment needed
//
// NOTE: If the value of NORM_IGNORECASE ever changes, this
// code should check for:
// ( (dwCmpFlags != 0) && (dwCmpFlags != NORM_IGNORECASE) )
// Since NORM_IGNORECASE is equal to 1, we can optimize this
// by checking for > 1.
//
dwCmpFlags &= (~LOCALE_USE_CP_ACP); fModify = IS_KOREAN(Locale); if ( (pHashN->IfCompression) || (cchCount1 > -1) || (cchCount2 > -1) || (dwCmpFlags > NORM_IGNORECASE) || (fModify == TRUE) ) { return (LongCompareStringW( pHashN, dwCmpFlags, lpString1, ((cchCount1 <= -1) ? -2 : cchCount1), lpString2, ((cchCount2 <= -1) ? -2 : cchCount2), fModify )); }
//
// Initialize string pointers.
//
pString1 = (LPWSTR)lpString1; pString2 = (LPWSTR)lpString2;
//
// Do a wchar by wchar compare.
//
while (TRUE) { //
// See if characters are equal.
// If characters are equal, increment pointers and continue
// string compare.
//
// NOTE: Loop is unrolled 8 times for performance.
//
if ((*pString1 != *pString2) || (*pString1 == 0)) { break; } pString1++; pString2++;
if ((*pString1 != *pString2) || (*pString1 == 0)) { break; } pString1++; pString2++;
if ((*pString1 != *pString2) || (*pString1 == 0)) { break; } pString1++; pString2++;
if ((*pString1 != *pString2) || (*pString1 == 0)) { break; } pString1++; pString2++;
if ((*pString1 != *pString2) || (*pString1 == 0)) { break; } pString1++; pString2++;
if ((*pString1 != *pString2) || (*pString1 == 0)) { break; } pString1++; pString2++;
if ((*pString1 != *pString2) || (*pString1 == 0)) { break; } pString1++; pString2++;
if ((*pString1 != *pString2) || (*pString1 == 0)) { break; } pString1++; pString2++; }
//
// If strings are both at null terminators, return equal.
//
if (*pString1 == *pString2) { return (CSTR_EQUAL); }
//
// Initialize flags, pointers, and counters.
//
fIgnorePunct = FALSE; WhichDiacritic = 0; WhichCase = 0; WhichJamo = 0; WhichPunct1 = 0; WhichPunct2 = 0; pSave1 = NULL; pSave2 = NULL; ExtraWt1 = (DWORD)0; WhichExtra = (DWORD)0;
//
// Switch on the different flag options. This will speed up
// the comparisons of two strings that are different.
//
// The only two possibilities in this optimized section are
// no flags and the ignore case flag.
//
if (dwCmpFlags == 0) { Mask = CMP_MASKOFF_NONE; } else { Mask = CMP_MASKOFF_CW; } State = (pHashN->IfReverseDW) ? STATE_REVERSE_DW : STATE_DW; State |= (STATE_CW | STATE_JAMO_WEIGHT);
//
// Compare each character's sortkey weight in the two strings.
//
while ((*pString1 != 0) && (*pString2 != 0)) { Weight1 = GET_DWORD_WEIGHT(pHashN, *pString1); Weight2 = GET_DWORD_WEIGHT(pHashN, *pString2); Weight1 &= Mask; Weight2 &= Mask;
if (Weight1 != Weight2) { BYTE sm1 = GET_SCRIPT_MEMBER(&Weight1); // script member 1
BYTE sm2 = GET_SCRIPT_MEMBER(&Weight2); // script member 2
WORD uw1 = GET_UNICODE_SM(&Weight1, sm1); // unicode weight 1
WORD uw2 = GET_UNICODE_SM(&Weight2, sm2); // unicode weight 2
BYTE dw1; // diacritic weight 1
BYTE dw2; // diacritic weight 2
BOOL fContinue; // flag to continue loop
DWORD Wt; // temp weight holder
WCHAR pTmpBuf1[MAX_TBL_EXPANSION]; // temp buffer for exp 1
WCHAR pTmpBuf2[MAX_TBL_EXPANSION]; // temp buffer for exp 2
//
// If Unicode Weights are different and no special cases,
// then we're done. Otherwise, we need to do extra checking.
//
// Must check ENTIRE string for any possibility of Unicode Weight
// differences. As soon as a Unicode Weight difference is found,
// then we're done. If no UW difference is found, then the
// first Diacritic Weight difference is used. If no DW difference
// is found, then use the first Case Difference. If no CW
// difference is found, then use the first Extra Weight
// difference. If no XW difference is found, then use the first
// Special Weight difference.
//
if ((uw1 != uw2) || (sm1 == FAREAST_SPECIAL) || (sm1 == EXTENSION_A)) { //
// Initialize the continue flag.
//
fContinue = FALSE;
//
// Check for Unsortable characters and skip them.
// This needs to be outside the switch statement. If EITHER
// character is unsortable, must skip it and start over.
//
if (sm1 == UNSORTABLE) { pString1++; fContinue = TRUE; } if (sm2 == UNSORTABLE) { pString2++; fContinue = TRUE; } if (fContinue) { continue; }
//
// Switch on the script member of string 1 and take care
// of any special cases.
//
switch (sm1) { case ( NONSPACE_MARK ) : { //
// Nonspace only - look at diacritic weight only.
//
if ((WhichDiacritic == 0) || (State & STATE_REVERSE_DW)) { WhichDiacritic = CSTR_GREATER_THAN;
//
// Remove state from state machine.
//
REMOVE_STATE(STATE_DW); }
//
// Adjust pointer and set flags.
//
pString1++; fContinue = TRUE;
break; } case ( PUNCTUATION ) : { //
// If the ignore punctuation flag is set, then skip
// over the punctuation.
//
if (fIgnorePunct) { pString1++; fContinue = TRUE; } else if (sm2 != PUNCTUATION) { //
// The character in the second string is
// NOT punctuation.
//
if (WhichPunct2) { //
// Set WP 2 to show that string 2 is smaller,
// since a punctuation char had already been
// found at an earlier position in string 2.
//
// Set the Ignore Punctuation flag so we just
// skip over any other punctuation chars in
// the string.
//
WhichPunct2 = CSTR_GREATER_THAN; fIgnorePunct = TRUE; } else { //
// Set WP 1 to show that string 2 is smaller,
// and that string 1 has had a punctuation
// char - since no punctuation chars have
// been found in string 2.
//
WhichPunct1 = CSTR_GREATER_THAN; }
//
// Advance pointer 1, and set flag to true.
//
pString1++; fContinue = TRUE; }
//
// Do NOT want to advance the pointer in string 1 if
// string 2 is also a punctuation char. This will
// be done later.
//
break; } case ( EXPANSION ) : { //
// Save pointer in pString1 so that it can be
// restored.
//
if (pSave1 == NULL) { pSave1 = pString1; } pString1 = pTmpBuf1;
//
// Expand character into temporary buffer.
//
pTmpBuf1[0] = GET_EXPANSION_1(&Weight1); pTmpBuf1[1] = GET_EXPANSION_2(&Weight1);
//
// Set cExpChar1 to the number of expansion characters
// stored.
//
cExpChar1 = MAX_TBL_EXPANSION;
fContinue = TRUE;
break; } case ( FAREAST_SPECIAL ) : { if (sm2 != EXPANSION) { //
// Get the weight for the far east special case
// and store it in Weight1.
//
GET_FAREAST_WEIGHT( Weight1, uw1, Mask, lpString1, pString1, ExtraWt1, FALSE );
if (sm2 != FAREAST_SPECIAL) { //
// The character in the second string is
// NOT a fareast special char.
//
// Set each of weights 4, 5, 6, and 7 to show
// that string 2 is smaller (if not already set).
//
if ((GET_WT_FOUR(&WhichExtra) == 0) && (GET_WT_FOUR(&ExtraWt1) != 0)) { GET_WT_FOUR(&WhichExtra) = CSTR_GREATER_THAN; } if ((GET_WT_FIVE(&WhichExtra) == 0) && (GET_WT_FIVE(&ExtraWt1) != 0)) { GET_WT_FIVE(&WhichExtra) = CSTR_GREATER_THAN; } if ((GET_WT_SIX(&WhichExtra) == 0) && (GET_WT_SIX(&ExtraWt1) != 0)) { GET_WT_SIX(&WhichExtra) = CSTR_GREATER_THAN; } if ((GET_WT_SEVEN(&WhichExtra) == 0) && (GET_WT_SEVEN(&ExtraWt1) != 0)) { GET_WT_SEVEN(&WhichExtra) = CSTR_GREATER_THAN; } } } break; } case ( JAMO_SPECIAL ) : { int ctr1; // dummy variables for FindJamoDifference
LPWSTR pStr1 = pString1; LPWSTR pStr2 = pString2;
//
// Set the JamoFlag so we don't handle it again.
//
JamoFlag = TRUE; fContinue = FindJamoDifference( pHashN, &pStr1, &ctr1, -2, &Weight1, &pStr2, &ctr1, -2, &Weight2, &pLastJamo, &uw1, &uw2, &State, &WhichJamo, fModify ); if (WhichJamo) { return (WhichJamo); }
pString1 = pStr1; pString2 = pStr2;
break; } case ( EXTENSION_A ) : { //
// Compare the weights.
//
if (Weight1 == Weight2) { //
// Adjust pointers and set flag.
//
pString1++; pString2++; fContinue = TRUE; } else { //
// Get the actual UW to compare.
//
if (sm2 == EXTENSION_A) { //
// Set the UW values to be the AW and DW since
// both strings contain an extension A char.
//
uw1 = MAKE_UNICODE_WT( GET_ALPHA_NUMERIC(&Weight1), GET_DIACRITIC(&Weight1), FALSE ); uw2 = MAKE_UNICODE_WT( GET_ALPHA_NUMERIC(&Weight2), GET_DIACRITIC(&Weight2), FALSE ); } else { //
// Only string1 contains an extension A char,
// so set the UW value to be the first UW
// value for extension A (default values):
// SM_EXT_A, AW_EXT_A
//
uw1 = MAKE_UNICODE_WT(SM_EXT_A, AW_EXT_A, fModify); } }
break; } case ( UNSORTABLE ) : { //
// Fill out the case statement so the compiler
// will use a jump table.
//
break; } }
//
// Switch on the script member of string 2 and take care
// of any special cases.
//
switch (sm2) { case ( NONSPACE_MARK ) : { //
// Nonspace only - look at diacritic weight only.
//
if ((WhichDiacritic == 0) || (State & STATE_REVERSE_DW)) { WhichDiacritic = CSTR_LESS_THAN;
//
// Remove state from state machine.
//
REMOVE_STATE(STATE_DW); }
//
// Adjust pointer and set flags.
//
pString2++; fContinue = TRUE;
break; } case ( PUNCTUATION ) : { //
// If the ignore punctuation flag is set, then skip
// over the punctuation.
//
if (fIgnorePunct) { //
// Pointer 2 will be advanced after if-else
// statement.
//
; } else if (sm1 != PUNCTUATION) { //
// The character in the first string is
// NOT punctuation.
//
if (WhichPunct1) { //
// Set WP 1 to show that string 1 is smaller,
// since a punctuation char had already
// been found at an earlier position in
// string 1.
//
// Set the Ignore Punctuation flag so we just
// skip over any other punctuation in the
// string.
//
WhichPunct1 = CSTR_LESS_THAN; fIgnorePunct = TRUE; } else { //
// Set WP 2 to show that string 1 is smaller,
// and that string 2 has had a punctuation
// char - since no punctuation chars have
// been found in string 1.
//
WhichPunct2 = CSTR_LESS_THAN; }
//
// Pointer 2 will be advanced after if-else
// statement.
//
} else { //
// Both code points are punctuation.
//
// See if either of the strings has encountered
// punctuation chars previous to this.
//
if (WhichPunct1) { //
// String 1 has had a punctuation char, so
// it should be the smaller string (since
// both have punctuation chars).
//
WhichPunct1 = CSTR_LESS_THAN; } else if (WhichPunct2) { //
// String 2 has had a punctuation char, so
// it should be the smaller string (since
// both have punctuation chars).
//
WhichPunct2 = CSTR_GREATER_THAN; } else { //
// Position is the same, so compare the
// special weights. Set WhichPunct1 to
// the smaller special weight.
//
WhichPunct1 = (((GET_ALPHA_NUMERIC(&Weight1) < GET_ALPHA_NUMERIC(&Weight2))) ? CSTR_LESS_THAN : CSTR_GREATER_THAN); }
//
// Set the Ignore Punctuation flag so we just
// skip over any other punctuation in the string.
//
fIgnorePunct = TRUE;
//
// Advance pointer 1. Pointer 2 will be
// advanced after if-else statement.
//
pString1++; }
//
// Advance pointer 2 and set flag to true.
//
pString2++; fContinue = TRUE;
break; } case ( EXPANSION ) : { //
// Save pointer in pString1 so that it can be
// restored.
//
if (pSave2 == NULL) { pSave2 = pString2; } pString2 = pTmpBuf2;
//
// Expand character into temporary buffer.
//
pTmpBuf2[0] = GET_EXPANSION_1(&Weight2); pTmpBuf2[1] = GET_EXPANSION_2(&Weight2);
//
// Set cExpChar2 to the number of expansion characters
// stored.
//
cExpChar2 = MAX_TBL_EXPANSION;
fContinue = TRUE;
break; } case ( FAREAST_SPECIAL ) : { if (sm1 != EXPANSION) { //
// Get the weight for the far east special case
// and store it in Weight2.
//
GET_FAREAST_WEIGHT( Weight2, uw2, Mask, lpString2, pString2, ExtraWt2, FALSE );
if (sm1 != FAREAST_SPECIAL) { //
// The character in the first string is
// NOT a fareast special char.
//
// Set each of weights 4, 5, 6, and 7 to show
// that string 1 is smaller (if not already set).
//
if ((GET_WT_FOUR(&WhichExtra) == 0) && (GET_WT_FOUR(&ExtraWt2) != 0)) { GET_WT_FOUR(&WhichExtra) = CSTR_LESS_THAN; } if ((GET_WT_FIVE(&WhichExtra) == 0) && (GET_WT_FIVE(&ExtraWt2) != 0)) { GET_WT_FIVE(&WhichExtra) = CSTR_LESS_THAN; } if ((GET_WT_SIX(&WhichExtra) == 0) && (GET_WT_SIX(&ExtraWt2) != 0)) { GET_WT_SIX(&WhichExtra) = CSTR_LESS_THAN; } if ((GET_WT_SEVEN(&WhichExtra) == 0) && (GET_WT_SEVEN(&ExtraWt2) != 0)) { GET_WT_SEVEN(&WhichExtra) = CSTR_LESS_THAN; } } else { //
// Characters in both strings are fareast
// special chars.
//
// Set each of weights 4, 5, 6, and 7
// appropriately (if not already set).
//
if ( (GET_WT_FOUR(&WhichExtra) == 0) && ( GET_WT_FOUR(&ExtraWt1) != GET_WT_FOUR(&ExtraWt2) ) ) { GET_WT_FOUR(&WhichExtra) = ( GET_WT_FOUR(&ExtraWt1) < GET_WT_FOUR(&ExtraWt2) ) ? CSTR_LESS_THAN : CSTR_GREATER_THAN; } if ( (GET_WT_FIVE(&WhichExtra) == 0) && ( GET_WT_FIVE(&ExtraWt1) != GET_WT_FIVE(&ExtraWt2) ) ) { GET_WT_FIVE(&WhichExtra) = ( GET_WT_FIVE(&ExtraWt1) < GET_WT_FIVE(&ExtraWt2) ) ? CSTR_LESS_THAN : CSTR_GREATER_THAN; } if ( (GET_WT_SIX(&WhichExtra) == 0) && ( GET_WT_SIX(&ExtraWt1) != GET_WT_SIX(&ExtraWt2) ) ) { GET_WT_SIX(&WhichExtra) = ( GET_WT_SIX(&ExtraWt1) < GET_WT_SIX(&ExtraWt2) ) ? CSTR_LESS_THAN : CSTR_GREATER_THAN; } if ( (GET_WT_SEVEN(&WhichExtra) == 0) && ( GET_WT_SEVEN(&ExtraWt1) != GET_WT_SEVEN(&ExtraWt2) ) ) { GET_WT_SEVEN(&WhichExtra) = ( GET_WT_SEVEN(&ExtraWt1) < GET_WT_SEVEN(&ExtraWt2) ) ? CSTR_LESS_THAN : CSTR_GREATER_THAN; } } } break; } case ( JAMO_SPECIAL ) : { if (!JamoFlag) { int ctr1, ctr2; // dummy variables for FindJamoDifference
LPWSTR pStr1 = pString1; LPWSTR pStr2 = pString2;
//
// Set the JamoFlag so we don't handle it again.
//
JamoFlag = TRUE; fContinue = FindJamoDifference( pHashN, &pStr1, &ctr1, -2, &Weight1, &pStr2, &ctr2, -2, &Weight2, &pLastJamo, &uw1, &uw2, &State, &WhichJamo, fModify ); if (WhichJamo) { return (WhichJamo); } pString1 = pStr1; pString2 = pStr2; } else { JamoFlag = FALSE; }
break; } case ( EXTENSION_A ) : { //
// If sm1 is an extension A character, then
// both sm1 and sm2 have been handled. We should
// only get here when either sm1 is not an
// extension A character or the two extension A
// characters are different.
//
if (sm1 != EXTENSION_A) { //
// Get the actual UW to compare.
//
// Only string2 contains an extension A char,
// so set the UW value to be the first UW
// value for extension A (default values):
// SM_EXT_A, AW_EXT_A
//
uw2 = MAKE_UNICODE_WT(SM_EXT_A, AW_EXT_A, fModify); }
//
// We should then fall through to the comparison
// of the Unicode weights.
//
break; } case ( UNSORTABLE ) : { //
// Fill out the case statement so the compiler
// will use a jump table.
//
break; } }
//
// See if the comparison should start again.
//
if (fContinue) { continue; }
//
// We're not supposed to drop down into the state table if
// unicode weights are different, so stop comparison and
// return result of unicode weight comparison.
//
if (uw1 != uw2) { return ((uw1 < uw2) ? CSTR_LESS_THAN : CSTR_GREATER_THAN); } }
//
// For each state in the state table, do the appropriate
// comparisons. (UW1 == UW2)
//
if (State & (STATE_DW | STATE_REVERSE_DW)) { //
// Get the diacritic weights.
//
dw1 = GET_DIACRITIC(&Weight1); dw2 = GET_DIACRITIC(&Weight2);
if (dw1 != dw2) { //
// Look ahead to see if diacritic follows a
// minimum diacritic weight. If so, get the
// diacritic weight of the nonspace mark.
//
while (*(pString1 + 1) != 0) { Wt = GET_DWORD_WEIGHT(pHashN, *(pString1 + 1)); if (GET_SCRIPT_MEMBER(&Wt) == NONSPACE_MARK) { dw1 += GET_DIACRITIC(&Wt); pString1++; } else { break; } }
while (*(pString2 + 1) != 0) { Wt = GET_DWORD_WEIGHT(pHashN, *(pString2 + 1)); if (GET_SCRIPT_MEMBER(&Wt) == NONSPACE_MARK) { dw2 += GET_DIACRITIC(&Wt); pString2++; } else { break; } }
//
// Save which string has the smaller diacritic
// weight if the diacritic weights are still
// different.
//
if (dw1 != dw2) { WhichDiacritic = (dw1 < dw2) ? CSTR_LESS_THAN : CSTR_GREATER_THAN;
//
// Remove state from state machine.
//
REMOVE_STATE(STATE_DW); } } } if (State & STATE_CW) { //
// Get the case weights.
//
if (GET_CASE(&Weight1) != GET_CASE(&Weight2)) { //
// Save which string has the smaller case weight.
//
WhichCase = (GET_CASE(&Weight1) < GET_CASE(&Weight2)) ? CSTR_LESS_THAN : CSTR_GREATER_THAN;
//
// Remove state from state machine.
//
REMOVE_STATE(STATE_CW); } } }
//
// Fixup the pointers.
//
POINTER_FIXUP(); }
//
// If the end of BOTH strings has been reached, then the unicode
// weights match exactly. Check the diacritic, case and special
// weights. If all are zero, then return success. Otherwise,
// return the result of the weight difference.
//
// NOTE: The following checks MUST REMAIN IN THIS ORDER:
// Diacritic, Case, Punctuation.
//
if (*pString1 == 0) { if (*pString2 == 0) { if (WhichDiacritic) { return (WhichDiacritic); } if (WhichCase) { return (WhichCase); } if (WhichExtra) { if (GET_WT_FOUR(&WhichExtra)) { return (GET_WT_FOUR(&WhichExtra)); } if (GET_WT_FIVE(&WhichExtra)) { return (GET_WT_FIVE(&WhichExtra)); } if (GET_WT_SIX(&WhichExtra)) { return (GET_WT_SIX(&WhichExtra)); } if (GET_WT_SEVEN(&WhichExtra)) { return (GET_WT_SEVEN(&WhichExtra)); } } if (WhichPunct1) { return (WhichPunct1); } if (WhichPunct2) { return (WhichPunct2); }
return (CSTR_EQUAL); } else { //
// String 2 is longer.
//
pString1 = pString2; } }
//
// Scan to the end of the longer string.
//
QUICK_SCAN_LONGER_STRING( pString1, ((*pString2 == 0) ? CSTR_GREATER_THAN : CSTR_LESS_THAN) );}
////////////////////////////////////////////////////////////////////////////
//
// GetStringTypeExW
//
// Returns character type information about a particular Unicode string.
//
// 01-18-94 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI GetStringTypeExW( LCID Locale, DWORD dwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType){ PLOC_HASH pHashN; // ptr to LOC hash node
//
// Invalid Parameter Check:
// - Validate LCID
//
VALIDATE_LOCALE(Locale, pHashN, FALSE); if (pHashN == NULL) { SetLastError(ERROR_INVALID_PARAMETER); return (0); }
//
// Return the result of GetStringTypeW.
//
return (GetStringTypeW( dwInfoType, lpSrcStr, cchSrc, lpCharType ));}
////////////////////////////////////////////////////////////////////////////
//
// GetStringTypeW
//
// Returns character type information about a particular Unicode string.
//
// NOTE: The number of parameters is different from GetStringTypeA.
// The 16-bit OLE product shipped GetStringTypeA with the wrong
// parameters (ported from Chicago) and now we must support it.
//
// Use GetStringTypeEx to get the same set of parameters between
// the A and W version.
//
// 05-31-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
BOOL WINAPI GetStringTypeW( DWORD dwInfoType, LPCWSTR lpSrcStr, int cchSrc, LPWORD lpCharType){ int Ctr; // loop counter
//
// Invalid Parameter Check:
// - lpSrcStr NULL
// - cchSrc is 0
// - lpCharType NULL
// - same buffer - src and destination
// - (flags will be checked in switch statement below)
//
if ( (lpSrcStr == NULL) || (cchSrc == 0) || (lpCharType == NULL) || (lpSrcStr == lpCharType) ) { SetLastError(ERROR_INVALID_PARAMETER); return (FALSE); }
//
// If cchSrc is -1, then the source string is null terminated and we
// need to get the length of the source string. Add one to the
// length to include the null termination.
// (This will always be at least 1.)
//
if (cchSrc <= -1) { cchSrc = NlsStrLenW(lpSrcStr) + 1; }
//
// Make sure the ctype table is mapped in.
//
if (GetCTypeFileInfo()) { SetLastError(ERROR_FILE_NOT_FOUND); return (FALSE); }
//
// Return the appropriate information in the lpCharType parameter
// based on the dwInfoType parameter.
//
switch (dwInfoType) { case ( CT_CTYPE1 ) : { //
// Return the ctype 1 information for the string.
//
for (Ctr = 0; Ctr < cchSrc; Ctr++) { lpCharType[Ctr] = GET_CTYPE(lpSrcStr[Ctr], CType1); } break; } case ( CT_CTYPE2 ) : { //
// Return the ctype 2 information.
//
for (Ctr = 0; Ctr < cchSrc; Ctr++) { lpCharType[Ctr] = GET_CTYPE(lpSrcStr[Ctr], CType2); } break; } case ( CT_CTYPE3 ) : { //
// Return the ctype 3 information.
//
for (Ctr = 0; Ctr < cchSrc; Ctr++) { lpCharType[Ctr] = GET_CTYPE(lpSrcStr[Ctr], CType3); } break; } default : { //
// Invalid flag parameter, so return failure.
//
SetLastError(ERROR_INVALID_FLAGS); return (FALSE); } }
//
// Return success.
//
return (TRUE);}
//-------------------------------------------------------------------------//
// INTERNAL ROUTINES //
//-------------------------------------------------------------------------//
////////////////////////////////////////////////////////////////////////////
//
// LongCompareStringW
//
// Compares two wide character strings of the same locale according to the
// supplied locale handle.
//
// 05-31-91 JulieB Created.
////////////////////////////////////////////////////////////////////////////
int LongCompareStringW( PLOC_HASH pHashN, DWORD dwCmpFlags, LPCWSTR lpString1, int cchCount1, LPCWSTR lpString2, int cchCount2, BOOL fModify){ int ctr1 = cchCount1; // loop counter for string 1
int ctr2 = cchCount2; // loop counter for string 2
register LPWSTR pString1; // ptr to go thru string 1
register LPWSTR pString2; // ptr to go thru string 2
BOOL IfCompress; // if compression in locale
BOOL IfDblCompress1; // if double compression in string 1
BOOL IfDblCompress2; // if double compression in string 2
BOOL fEnd1; // if at end of string 1
BOOL fIgnorePunct; // flag to ignore punctuation (not symbol)
BOOL fIgnoreDiacritic; // flag to ignore diacritics
BOOL fIgnoreSymbol; // flag to ignore symbols
BOOL fStringSort; // flag to use string sort
DWORD State; // state table
DWORD Mask; // mask for weights
DWORD Weight1; // full weight of char - string 1
DWORD Weight2; // full weight of char - string 2
int JamoFlag = FALSE; LPCWSTR pLastJamo = lpString1;
int WhichDiacritic; // DW => 1 = str1 smaller, 3 = str2 smaller
int WhichCase; // CW => 1 = str1 smaller, 3 = str2 smaller
int WhichJamo; // XW for Jamo
int WhichPunct1; // SW => 1 = str1 smaller, 3 = str2 smaller
int WhichPunct2; // SW => 1 = str1 smaller, 3 = str2 smaller
LPWSTR pSave1; // ptr to saved pString1
LPWSTR pSave2; // ptr to saved pString2
int cExpChar1, cExpChar2; // ct of expansions in tmp
DWORD ExtraWt1, ExtraWt2; // extra weight values (for far east)
DWORD WhichExtra; // XW => wts 4, 5, 6, 7 (for far east)
//
// Initialize string pointers.
//
pString1 = (LPWSTR)lpString1; pString2 = (LPWSTR)lpString2;
//
// Invalid Flags Check:
// - invalid flags
//
if (dwCmpFlags & CS_INVALID_FLAG) { SetLastError(ERROR_INVALID_FLAGS); return (0); }
//
// See if we should stop on the null terminator regardless of the
// count values. The original count values are stored in ctr1 and ctr2
// above, so it's ok to set these here.
//
if (dwCmpFlags & NORM_STOP_ON_NULL) { cchCount1 = cchCount2 = -2; }
//
// Check if compression in the given locale. If not, then
// try a wchar by wchar compare. If strings are equal, this
// will be quick.
//
if ((IfCompress = pHashN->IfCompression) == FALSE) { //
// Compare each wide character in the two strings.
//
while ( NOT_END_STRING(ctr1, pString1, cchCount1) && NOT_END_STRING(ctr2, pString2, cchCount2) ) { //
// See if characters are equal.
//
if (*pString1 == *pString2) { //
// Characters are equal, so increment pointers,
// decrement counters, and continue string compare.
//
pString1++; pString2++; ctr1--; ctr2--; } else { //
// Difference was found. Fall into the sortkey
// check below.
//
break; } }
//
// If the end of BOTH strings has been reached, then the strings
// match exactly. Return success.
//
if ( AT_STRING_END(ctr1, pString1, cchCount1) && AT_STRING_END(ctr2, pString2, cchCount2) ) { return (CSTR_EQUAL); } }
//
// Initialize flags, pointers, and counters.
//
fIgnorePunct = dwCmpFlags & NORM_IGNORESYMBOLS; fIgnoreDiacritic = dwCmpFlags & NORM_IGNORENONSPACE; fIgnoreSymbol = fIgnorePunct; fStringSort = dwCmpFlags & SORT_STRINGSORT; WhichDiacritic = 0; WhichCase = 0; WhichJamo = 0; WhichPunct1 = 0; WhichPunct2 = 0; pSave1 = NULL; pSave2 = NULL; ExtraWt1 = (DWORD)0; WhichExtra = (DWORD)0;
//
// Set the weights to be invalid. This flags whether or not to
// recompute the weights next time through the loop. It also flags
// whether or not to start over (continue) in the loop.
//
Weight1 = CMP_INVALID_WEIGHT; Weight2 = CMP_INVALID_WEIGHT;
//
// Switch on the different flag options. This will speed up
// the comparisons of two strings that are different.
//
State = STATE_CW | STATE_JAMO_WEIGHT; switch (dwCmpFlags & (NORM_IGNORECASE | NORM_IGNORENONSPACE)) { case ( 0 ) : { Mask = CMP_MASKOFF_NONE; State |= (pHashN->IfReverseDW) ? STATE_REVERSE_DW : STATE_DW;
break; }
case ( NORM_IGNORECASE ) : { Mask = CMP_MASKOFF_CW; State |= (pHashN->IfReverseDW) ? STATE_REVERSE_DW : STATE_DW;
break; }
case ( NORM_IGNORENONSPACE ) : { Mask = CMP_MASKOFF_DW;
break; }
case ( NORM_IGNORECASE | NORM_IGNORENONSPACE ) : { Mask = CMP_MASKOFF_DW_CW;
break; } }
switch (dwCmpFlags & (NORM_IGNOREKANATYPE | NORM_IGNOREWIDTH)) { case ( 0 ) : { break; }
case ( NORM_IGNOREKANATYPE ) : { Mask &= CMP_MASKOFF_KANA;
break; }
case ( NORM_IGNOREWIDTH ) : { Mask &= CMP_MASKOFF_WIDTH;
if (dwCmpFlags & NORM_IGNORECASE) { REMOVE_STATE(STATE_CW); }
break; }
case ( NORM_IGNOREKANATYPE | NORM_IGNOREWIDTH ) : { Mask &= CMP_MASKOFF_KANA_WIDTH;
if (dwCmpFlags & NORM_IGNORECASE) { REMOVE_STATE(STATE_CW); }
break; } }
//
// Compare each character's sortkey weight in the two strings.
//
while ( NOT_END_STRING(ctr1, pString1, cchCount1) && NOT_END_STRING(ctr2, pString2, cchCount2) ) { if (Weight1 == CMP_INVALID_WEIGHT) { Weight1 = GET_DWORD_WEIGHT(pHashN, *pString1); Weight1 &= Mask; } if (Weight2 == CMP_INVALID_WEIGHT) { Weight2 = GET_DWORD_WEIGHT(pHashN, *pString2); Weight2 &= Mask; }
//
// If compression locale, then need to check for compression
// characters even if the weights are equal. If it's not a
// compression locale, then we don't need to check anything
// if the weights are equal.
//
if ( (IfCompress) && (GET_COMPRESSION(&Weight1) || GET_COMPRESSION(&Weight2)) ) { int ctr; // loop counter
PCOMPRESS_3 pComp3; // ptr to compress 3 table
PCOMPRESS_2 pComp2; // ptr to compress 2 table
int If1; // if compression found in string 1
int If2; // if compression found in string 2
int CompVal; // compression value
int IfEnd1; // if exists 1 more char in string 1
int IfEnd2; // if exists 1 more char in string 2
//
// Check for compression in the weights.
//
If1 = GET_COMPRESSION(&Weight1); If2 = GET_COMPRESSION(&Weight2); CompVal = ((If1 > If2) ? If1 : If2);
IfEnd1 = AT_STRING_END(ctr1 - 1, pString1 + 1, cchCount1); IfEnd2 = AT_STRING_END(ctr2 - 1, pString2 + 1, cchCount2);
if (pHashN->IfDblCompression == FALSE) { //
// NO double compression, so don't check for it.
//
switch (CompVal) { //
// Check for 3 characters compressing to 1.
//
case ( COMPRESS_3_MASK ) : { //
// Check character in string 1 and string 2.
//
if ( ((If1) && (!IfEnd1) && !AT_STRING_END(ctr1 - 2, pString1 + 2, cchCount1)) || ((If2) && (!IfEnd2) && !AT_STRING_END(ctr2 - 2, pString2 + 2, cchCount2)) ) { ctr = pHashN->pCompHdr->Num3; pComp3 = pHashN->pCompress3; for (; ctr > 0; ctr--, pComp3++) { //
// Check character in string 1.
//
if ( (If1) && (!IfEnd1) && !AT_STRING_END(ctr1 - 2, pString1 + 2, cchCount1) && (pComp3->UCP1 == *pString1) && (pComp3->UCP2 == *(pString1 + 1)) && (pComp3->UCP3 == *(pString1 + 2)) ) { //
// Found compression for string 1.
// Get new weight and mask it.
// Increment pointer and decrement counter.
//
Weight1 = MAKE_SORTKEY_DWORD(pComp3->Weights); Weight1 &= Mask; pString1 += 2; ctr1 -= 2;
//
// Set boolean for string 1 - search is
// complete.
//
If1 = 0;
//
// Break out of loop if both searches are
// done.
//
if (If2 == 0) { break; } }
//
// Check character in string 2.
//
if ( (If2) && (!IfEnd2) && !AT_STRING_END(ctr2 - 2, pString2 + 2, cchCount2) && (pComp3->UCP1 == *pString2) && (pComp3->UCP2 == *(pString2 + 1)) && (pComp3->UCP3 == *(pString2 + 2)) ) { //
// Found compression for string 2.
// Get new weight and mask it.
// Increment pointer and decrement counter.
//
Weight2 = MAKE_SORTKEY_DWORD(pComp3->Weights); Weight2 &= Mask; pString2 += 2; ctr2 -= 2;
//
// Set boolean for string 2 - search is
// complete.
//
If2 = 0;
//
// Break out of loop if both searches are
// done.
//
if (If1 == 0) { break; } } } if (ctr > 0) { break; } } //
// Fall through if not found.
//
}
//
// Check for 2 characters compressing to 1.
//
case ( COMPRESS_2_MASK ) : { //
// Check character in string 1 and string 2.
//
if ( ((If1) && (!IfEnd1)) || ((If2) && (!IfEnd2)) ) { ctr = pHashN->pCompHdr->Num2; pComp2 = pHashN->pCompress2; for (; ((ctr > 0) && (If1 || If2)); ctr--, pComp2++) { //
// Check character in string 1.
//
if ( (If1) && (!IfEnd1) && (pComp2->UCP1 == *pString1) && (pComp2->UCP2 == *(pString1 + 1)) ) { //
// Found compression for string 1.
// Get new weight and mask it.
// Increment pointer and decrement counter.
//
Weight1 = MAKE_SORTKEY_DWORD(pComp2->Weights); Weight1 &= Mask; pString1++; ctr1--;
//
// Set boolean for string 1 - search is
// complete.
//
If1 = 0;
//
// Break out of loop if both searches are
// done.
//
if (If2 == 0) { break; } }
//
// Check character in string 2.
//
if ( (If2) && (!IfEnd2) && (pComp2->UCP1 == *pString2) && (pComp2->UCP2 == *(pString2 + 1)) ) { //
// Found compression for string 2.
// Get new weight and mask it.
// Increment pointer and decrement counter.
//
Weight2 = MAKE_SORTKEY_DWORD(pComp2->Weights); Weight2 &= Mask; pString2++; ctr2--;
//
// Set boolean for string 2 - search is
// complete.
//
If2 = 0;
//
// Break out of loop if both searches are
// done.
//
if (If1 == 0) { break; } } } if (ctr > 0) { break; } } } } } else if (!IfEnd1 && !IfEnd2) { //
// Double Compression exists, so must check for it.
//
if (IfDblCompress1 = ((GET_DWORD_WEIGHT(pHashN, *pString1) & CMP_MASKOFF_CW) == (GET_DWORD_WEIGHT(pHashN, *(pString1 + 1)) & CMP_MASKOFF_CW))) { //
// Advance past the first code point to get to the
// compression character.
//
pString1++; ctr1--; IfEnd1 = AT_STRING_END(ctr1 - 1, pString1 + 1, cchCount1); }
if (IfDblCompress2 = ((GET_DWORD_WEIGHT(pHashN, *pString2) & CMP_MASKOFF_CW) == (GET_DWORD_WEIGHT(pHashN, *(pString2 + 1)) & CMP_MASKOFF_CW))) { //
// Advance past the first code point to get to the
// compression character.
//
pString2++; ctr2--; IfEnd2 = AT_STRING_END(ctr2 - 1, pString2 + 1, cchCount2); }
switch (CompVal) { //
// Check for 3 characters compressing to 1.
//
case ( COMPRESS_3_MASK ) : { //
// Check character in string 1.
//
if ( (If1) && (!IfEnd1) && !AT_STRING_END(ctr1 - 2, pString1 + 2, cchCount1) ) { ctr = pHashN->pCompHdr->Num3; pComp3 = pHashN->pCompress3; for (; ctr > 0; ctr--, pComp3++) { //
// Check character in string 1.
//
if ( (pComp3->UCP1 == *pString1) && (pComp3->UCP2 == *(pString1 + 1)) && (pComp3->UCP3 == *(pString1 + 2)) ) { //
// Found compression for string 1.
// Get new weight and mask it.
// Increment pointer and decrement counter.
//
Weight1 = MAKE_SORTKEY_DWORD(pComp3->Weights); Weight1 &= Mask; if (!IfDblCompress1) { pString1 += 2; ctr1 -= 2; }
//
// Set boolean for string 1 - search is
// complete.
//
If1 = 0;
break; } } }
//
// Check character in string 2.
//
if ( (If2) && (!IfEnd2) && !AT_STRING_END(ctr2 - 2, pString2 + 2, cchCount2) ) { ctr = pHashN->pCompHdr->Num3; pComp3 = pHashN->pCompress3; for (; ctr > 0; ctr--, pComp3++) { //
// Check character in string 2.
//
if ( (pComp3->UCP1 == *pString2) && (pComp3->UCP2 == *(pString2 + 1)) && (pComp3->UCP3 == *(pString2 + 2)) ) { //
// Found compression for string 2.
// Get new weight and mask it.
// Increment pointer and decrement counter.
//
Weight2 = MAKE_SORTKEY_DWORD(pComp3->Weights); Weight2 &= Mask; if (!IfDblCompress2) { pString2 += 2; ctr2 -= 2; }
//
// Set boolean for string 2 - search is
// complete.
//
If2 = 0;
break; } } }
//
// Fall through if not found.
//
if ((If1 == 0) && (If2 == 0)) { break; } }
//
// Check for 2 characters compressing to 1.
//
case ( COMPRESS_2_MASK ) : { //
// Check character in string 1.
//
if ((If1) && (!IfEnd1)) { ctr = pHashN->pCompHdr->Num2; pComp2 = pHashN->pCompress2; for (; ctr > 0; ctr--, pComp2++) { //
// Check character in string 1.
//
if ((pComp2->UCP1 == *pString1) && (pComp2->UCP2 == *(pString1 + 1))) { //
// Found compression for string 1.
// Get new weight and mask it.
// Increment pointer and decrement counter.
//
Weight1 = MAKE_SORTKEY_DWORD(pComp2->Weights); Weight1 &= Mask; if (!IfDblCompress1) { pString1++; ctr1--; }
//
// Set boolean for string 1 - search is
// complete.
//
If1 = 0;
break; } } }
//
// Check character in string 2.
//
if ((If2) && (!IfEnd2)) { ctr = pHashN->pCompHdr->Num2; pComp2 = pHashN->pCompress2; for (; ctr > 0; ctr--, pComp2++) { //
// Check character in string 2.
//
if ((pComp2->UCP1 == *pString2) && (pComp2->UCP2 == *(pString2 + 1))) { //
// Found compression for string 2.
// Get new weight and mask it.
// Increment pointer and decrement counter.
//
Weight2 = MAKE_SORTKEY_DWORD(pComp2->Weights); Weight2 &= Mask; if (!IfDblCompress2) { pString2++; ctr2--; }
//
// Set boolean for string 2 - search is
// complete.
//
If2 = 0;
break; } } } } }
//
// Reset the pointer back to the beginning of the double
// compression. Pointer fixup at the end will advance
// them correctly.
//
// If double compression, we advanced the pointer at
// the beginning of the switch statement. If double
// compression character was actually found, the pointer
// was NOT advanced. We now want to decrement the pointer
// to put it back to where it was.
//
// The next time through, the pointer will be pointing to
// the regular compression part of the string.
//
if (IfDblCompress1) { pString1--; ctr1++; } if (IfDblCompress2) { pString2--; ctr2++; } } }
//
// Check the weights again.
//
if ((Weight1 != Weight2) || (GET_SCRIPT_MEMBER(&Weight1) == EXTENSION_A)) { //
// Weights are still not equal, even after compression
// check, so compare the different weights.
//
BYTE sm1 = GET_SCRIPT_MEMBER(&Weight1); // script member 1
BYTE sm2 = GET_SCRIPT_MEMBER(&Weight2); // script member 2
WORD uw1 = GET_UNICODE_SM_MOD(&Weight1, sm1, fModify); // unicode weight 1
WORD uw2 = GET_UNICODE_SM_MOD(&Weight2, sm2, fModify); // unicode weight 2
BYTE dw1; // diacritic weight 1
BYTE dw2; // diacritic weight 2
DWORD Wt; // temp weight holder
WCHAR pTmpBuf1[MAX_TBL_EXPANSION]; // temp buffer for exp 1
WCHAR pTmpBuf2[MAX_TBL_EXPANSION]; // temp buffer for exp 2
//
// If Unicode Weights are different and no special cases,
// then we're done. Otherwise, we need to do extra checking.
//
// Must check ENTIRE string for any possibility of Unicode Weight
// differences. As soon as a Unicode Weight difference is found,
// then we're done. If no UW difference is found, then the
// first Diacritic Weight difference is used. If no DW difference
// is found, then use the first Case Difference. If no CW
// difference is found, then use the first Extra Weight
// difference. If no XW difference is found, then use the first
// Special Weight difference.
//
if ((uw1 != uw2) || ((sm1 <= SYMBOL_5) && (sm1 >= FAREAST_SPECIAL))) { //
// Check for Unsortable characters and skip them.
// This needs to be outside the switch statement. If EITHER
// character is unsortable, must skip it and start over.
//
if (sm1 == UNSORTABLE) { pString1++; ctr1--; Weight1 = CMP_INVALID_WEIGHT; } if (sm2 == UNSORTABLE) { pString2++; ctr2--; Weight2 = CMP_INVALID_WEIGHT; }
//
// Check for Ignore Nonspace and Ignore Symbol. If
// Ignore Nonspace is set and either character is a
// nonspace mark only, then we need to advance the
// pointer to skip over the character and continue.
// If Ignore Symbol is set and either character is a
// punctuation char, then we need to advance the
// pointer to skip over the character and continue.
//
// This step is necessary so that a string with a
// nonspace mark and a punctuation char following one
// another are properly ignored when one or both of
// the ignore flags is set.
//
if (fIgnoreDiacritic) { if (sm1 == NONSPACE_MARK) { pString1++; ctr1--; Weight1 = CMP_INVALID_WEIGHT; } if (sm2 == NONSPACE_MARK) { pString2++; ctr2--; Weight2 = CMP_INVALID_WEIGHT; } } if (fIgnoreSymbol) { if (sm1 == PUNCTUATION) { pString1++; ctr1--; Weight1 = CMP_INVALID_WEIGHT; } if (sm2 == PUNCTUATION) { pString2++; ctr2--; Weight2 = CMP_INVALID_WEIGHT; } } if ((Weight1 == CMP_INVALID_WEIGHT) || (Weight2 == CMP_INVALID_WEIGHT)) { continue; }
//
// Switch on the script member of string 1 and take care
// of any special cases.
//
switch (sm1) { case ( NONSPACE_MARK ) : { //
// Nonspace only - look at diacritic weight only.
//
if (!fIgnoreDiacritic) { if ((WhichDiacritic == 0) || (State & STATE_REVERSE_DW)) { WhichDiacritic = CSTR_GREATER_THAN;
//
// Remove state from state machine.
//
REMOVE_STATE(STATE_DW); } }
//
// Adjust pointer and counter and set flags.
//
pString1++; ctr1--; Weight1 = CMP_INVALID_WEIGHT;
break; } case ( SYMBOL_1 ) : case ( SYMBOL_2 ) : case ( SYMBOL_3 ) : case ( SYMBOL_4 ) : case ( SYMBOL_5 ) : { //
// If the ignore symbol flag is set, then skip over
// the symbol.
//
if (fIgnoreSymbol) { pString1++; ctr1--; Weight1 = CMP_INVALID_WEIGHT; }
break; } case ( PUNCTUATION ) : { //
// If the ignore punctuation flag is set, then skip
// over the punctuation char.
//
if (fIgnorePunct) { pString1++; ctr1--; Weight1 = CMP_INVALID_WEIGHT; } else if (!fStringSort) { //
// Use WORD sort method.
//
if (sm2 != PUNCTUATION) { //
// The character in the second string is
// NOT punctuation.
//
if (WhichPunct2) { //
// Set WP 2 to show that string 2 is
// smaller, since a punctuation char had
// already been found at an earlier
// position in string 2.
//
// Set the Ignore Punctuation flag so we
// just skip over any other punctuation
// chars in the string.
//
WhichPunct2 = CSTR_GREATER_THAN; fIgnorePunct = TRUE; } else { //
// Set WP 1 to show that string 2 is
// smaller, and that string 1 has had
// a punctuation char - since no
// punctuation chars have been found
// in string 2.
//
WhichPunct1 = CSTR_GREATER_THAN; }
//
// Advance pointer 1 and decrement counter 1.
//
pString1++; ctr1--; Weight1 = CMP_INVALID_WEIGHT; }
//
// Do NOT want to advance the pointer in string 1
// if string 2 is also a punctuation char. This
// will be done later.
//
}
break; } case ( EXPANSION ) : { //
// Save pointer in pString1 so that it can be
// restored.
//
if (pSave1 == NULL) { pSave1 = pString1; } pString1 = pTmpBuf1;
//
// Add one to counter so that subtraction doesn't end
// comparison prematurely.
//
ctr1++;
//
// Expand character into temporary buffer.
//
pTmpBuf1[0] = GET_EXPANSION_1(&Weight1); pTmpBuf1[1] = GET_EXPANSION_2(&Weight1);
//
// Set cExpChar1 to the number of expansion characters
// stored.
//
cExpChar1 = MAX_TBL_EXPANSION;
Weight1 = CMP_INVALID_WEIGHT;
break; } case ( FAREAST_SPECIAL ) : { if (sm2 != EXPANSION) { //
// Get the weight for the far east special case
// and store it in Weight1.
//
GET_FAREAST_WEIGHT( Weight1, uw1, Mask, lpString1, pString1, ExtraWt1, fModify );
if (sm2 != FAREAST_SPECIAL) { //
// The character in the second string is
// NOT a fareast special char.
//
// Set each of weights 4, 5, 6, and 7 to show
// that string 2 is smaller (if not already set).
//
if ((GET_WT_FOUR(&WhichExtra) == 0) && (GET_WT_FOUR(&ExtraWt1) != 0)) { GET_WT_FOUR(&WhichExtra) = CSTR_GREATER_THAN; } if ((GET_WT_FIVE(&WhichExtra) == 0) && (GET_WT_FIVE(&ExtraWt1) != 0)) { GET_WT_FIVE(&WhichExtra) = CSTR_GREATER_THAN; } if ((GET_WT_SIX(&WhichExtra) == 0) && (GET_WT_SIX(&ExtraWt1) != 0)) { GET_WT_SIX(&WhichExtra) = CSTR_GREATER_THAN; } if ((GET_WT_SEVEN(&WhichExtra) == 0) && (GET_WT_SEVEN(&ExtraWt1) != 0)) { GET_WT_SEVEN(&WhichExtra) = CSTR_GREATER_THAN; } } } break; } case ( JAMO_SPECIAL ) : { LPWSTR pStr1 = pString1; LPWSTR pStr2 = pString2;
//
// Set the JamoFlag so we don't handle it again.
//
JamoFlag = TRUE; FindJamoDifference( pHashN, &pStr1, &ctr1, cchCount1, &Weight1, &pStr2, &ctr2, cchCount2, &Weight2, &pLastJamo, &uw1, &uw2, &State, &WhichJamo, fModify );
if (WhichJamo) { return (WhichJamo); } pString1 = pStr1; pString2 = pStr2;
break; } case ( EXTENSION_A ) : { //
// Get the full weight in case DW got masked.
//
Weight1 = GET_DWORD_WEIGHT(pHashN, *pString1); if (sm2 == EXTENSION_A) { Weight2 = GET_DWORD_WEIGHT(pHashN, *pString2); }
//
// Compare the weights.
//
if (Weight1 == Weight2) { //
// Adjust pointers and counters and set flags.
//
pString1++; pString2++; ctr1--; ctr2--; Weight1 = CMP_INVALID_WEIGHT; Weight2 = CMP_INVALID_WEIGHT; } else { //
// Get the actual UW to compare.
//
if (sm2 == EXTENSION_A) { //
// Set the UW values to be the AW and DW since
// both strings contain an extension A char.
//
uw1 = MAKE_UNICODE_WT( GET_ALPHA_NUMERIC(&Weight1), GET_DIACRITIC(&Weight1), FALSE ); uw2 = MAKE_UNICODE_WT( GET_ALPHA_NUMERIC(&Weight2), GET_DIACRITIC(&Weight2), FALSE ); } else { //
// Only string1 contains an extension A char,
// so set the UW value to be the first UW
// value for extension A (default values):
// SM_EXT_A, AW_EXT_A
//
uw1 = MAKE_UNICODE_WT(SM_EXT_A, AW_EXT_A, fModify); } }
break; } case ( UNSORTABLE ) : { //
// Fill out the case statement so the compiler
// will use a jump table.
//
break; } }
//
// Switch on the script member of string 2 and take care
// of any special cases.
//
switch (sm2) { case ( NONSPACE_MARK ) : { //
// Nonspace only - look at diacritic weight only.
//
if (!fIgnoreDiacritic) { if ((WhichDiacritic == 0) || (State & STATE_REVERSE_DW))
{ WhichDiacritic = CSTR_LESS_THAN;
//
// Remove state from state machine.
//
REMOVE_STATE(STATE_DW); } }
//
// Adjust pointer and counter and set flags.
//
pString2++; ctr2--; Weight2 = CMP_INVALID_WEIGHT;
break; } case ( SYMBOL_1 ) : case ( SYMBOL_2 ) : case ( SYMBOL_3 ) : case ( SYMBOL_4 ) : case ( SYMBOL_5 ) : { //
// If the ignore symbol flag is set, then skip over
// the symbol.
//
if (fIgnoreSymbol) { pString2++; ctr2--; Weight2 = CMP_INVALID_WEIGHT; }
break; } case ( PUNCTUATION ) : { //
// If the ignore punctuation flag is set, then
// skip over the punctuation char.
//
if (fIgnorePunct) { //
// Advance pointer 2 and decrement counter 2.
//
pString2++; ctr2--; Weight2 = CMP_INVALID_WEIGHT; } else if (!fStringSort) { //
// Use WORD sort method.
//
if (sm1 != PUNCTUATION) { //
// The character in the first string is
// NOT punctuation.
//
if (WhichPunct1) { //
// Set WP 1 to show that string 1 is
// smaller, since a punctuation char had
// already been found at an earlier
// position in string 1.
//
// Set the Ignore Punctuation flag so we
// just skip over any other punctuation
// chars in the string.
//
WhichPunct1 = CSTR_LESS_THAN; fIgnorePunct = TRUE; } else { //
// Set WP 2 to show that string 1 is
// smaller, and that string 2 has had
// a punctuation char - since no
// punctuation chars have been found
// in string 1.
//
WhichPunct2 = CSTR_LESS_THAN; }
//
// Pointer 2 and counter 2 will be updated
// after if-else statement.
//
} else { //
// Both code points are punctuation chars.
//
// See if either of the strings has encountered
// punctuation chars previous to this.
//
if (WhichPunct1) { //
// String 1 has had a punctuation char, so
// it should be the smaller string (since
// both have punctuation chars).
//
WhichPunct1 = CSTR_LESS_THAN; } else if (WhichPunct2) { //
// String 2 has had a punctuation char, so
// it should be the smaller string (since
// both have punctuation chars).
//
WhichPunct2 = CSTR_GREATER_THAN; } else { BYTE aw1 = GET_ALPHA_NUMERIC(&Weight1); BYTE aw2 = GET_ALPHA_NUMERIC(&Weight2);
if (aw1 == aw2) { BYTE cw1 = GET_CASE(&Weight1); BYTE cw2 = GET_CASE(&Weight2); if (cw1 < cw2) { WhichPunct1 = CSTR_LESS_THAN; } else if (cw1 > cw2) { WhichPunct1 = CSTR_GREATER_THAN; } } else { //
// Position is the same, so compare the
// special weights. Set WhichPunct1 to
// the smaller special weight.
//
WhichPunct1 = (aw1 < aw2 ? CSTR_LESS_THAN : CSTR_GREATER_THAN); } }
//
// Set the Ignore Punctuation flag.
//
fIgnorePunct = TRUE;
//
// Advance pointer 1 and decrement counter 1.
// Pointer 2 and counter 2 will be updated
// after if-else statement.
//
pString1++; ctr1--; Weight1 = CMP_INVALID_WEIGHT; }
//
// Advance pointer 2 and decrement counter 2.
//
pString2++; ctr2--; Weight2 = CMP_INVALID_WEIGHT; }
break; } case ( EXPANSION ) : { //
// Save pointer in pString1 so that it can be restored.
//
if (pSave2 == NULL) { pSave2 = pString2; } pString2 = pTmpBuf2;
//
// Add one to counter so that subtraction doesn't end
// comparison prematurely.
//
ctr2++;
//
// Expand character into temporary buffer.
//
pTmpBuf2[0] = GET_EXPANSION_1(&Weight2); pTmpBuf2[1] = GET_EXPANSION_2(&Weight2);
//
// Set cExpChar2 to the number of expansion characters
// stored.
//
cExpChar2 = MAX_TBL_EXPANSION;
Weight2 = CMP_INVALID_WEIGHT;
break; } case ( FAREAST_SPECIAL ) : { if (sm1 != EXPANSION) { //
// Get the weight for the far east special case
// and store it in Weight2.
//
GET_FAREAST_WEIGHT( Weight2, uw2, Mask, lpString2, pString2, ExtraWt2, fModify );
if (sm1 != FAREAST_SPECIAL) { //
// The character in the first string is
// NOT a fareast special char.
//
// Set each of weights 4, 5, 6, and 7 to show
// that string 1 is smaller (if not already set).
//
if ((GET_WT_FOUR(&WhichExtra) == 0) && (GET_WT_FOUR(&ExtraWt2) != 0)) { GET_WT_FOUR(&WhichExtra) = CSTR_LESS_THAN; } if ((GET_WT_FIVE(&WhichExtra) == 0) && (GET_WT_FIVE(&ExtraWt2) != 0)) { GET_WT_FIVE(&WhichExtra) = CSTR_LESS_THAN; } if ((GET_WT_SIX(&WhichExtra) == 0) && (GET_WT_SIX(&ExtraWt2) != 0)) { GET_WT_SIX(&WhichExtra) = CSTR_LESS_THAN; } if ((GET_WT_SEVEN(&WhichExtra) == 0) && (GET_WT_SEVEN(&ExtraWt2) != 0)) { GET_WT_SEVEN(&WhichExtra) = CSTR_LESS_THAN; } } else { //
// Characters in both strings are fareast
// special chars.
//
// Set each of weights 4, 5, 6, and 7
// appropriately (if not already set).
//
if ( (GET_WT_FOUR(&WhichExtra) == 0) && ( GET_WT_FOUR(&ExtraWt1) != GET_WT_FOUR(&ExtraWt2) ) ) { GET_WT_FOUR(&WhichExtra) = ( GET_WT_FOUR(&ExtraWt1) < GET_WT_FOUR(&ExtraWt2) ) ? CSTR_LESS_THAN : CSTR_GREATER_THAN; } if ( (GET_WT_FIVE(&WhichExtra) == 0) && ( GET_WT_FIVE(&ExtraWt1) != GET_WT_FIVE(&ExtraWt2) ) ) { GET_WT_FIVE(&WhichExtra) = ( GET_WT_FIVE(&ExtraWt1) < GET_WT_FIVE(&ExtraWt2) ) ? CSTR_LESS_THAN : CSTR_GREATER_THAN; } if ( (GET_WT_SIX(&WhichExtra) == 0) && ( GET_WT_SIX(&ExtraWt1) != GET_WT_SIX(&ExtraWt2) ) ) { GET_WT_SIX(&WhichExtra) = ( GET_WT_SIX(&ExtraWt1) < GET_WT_SIX(&ExtraWt2) ) ? CSTR_LESS_THAN : CSTR_GREATER_THAN; } if ( (GET_WT_SEVEN(&WhichExtra) == 0) && ( GET_WT_SEVEN(&ExtraWt1) != GET_WT_SEVEN(&ExtraWt2) ) ) { GET_WT_SEVEN(&WhichExtra) = ( GET_WT_SEVEN(&ExtraWt1) < GET_WT_SEVEN(&ExtraWt2) ) ? CSTR_LESS_THAN : CSTR_GREATER_THAN; } } } break; } case ( JAMO_SPECIAL ) : { if (!JamoFlag) { LPWSTR pStr1 = pString1; LPWSTR pStr2 = pString2;
FindJamoDifference( pHashN, &pStr1, &ctr1, cchCount1, &Weight1, &pStr2, &ctr2, cchCount2, &Weight2, &pLastJamo, &uw1, &uw2, &State, &WhichJamo, fModify ); if (WhichJamo) { return (WhichJamo); } pString1 = pStr1; pString2 = pStr2; } else { //
// Reset the Jamo flag.
//
JamoFlag = FALSE; }
break; } case ( EXTENSION_A ) : { //
// If sm1 is an extension A character, then
// both sm1 and sm2 have been handled. We should
// only get here when either sm1 is not an
// extension A character or the two extension A
// characters are different.
//
if (sm1 != EXTENSION_A) { //
// Get the full weight in case DW got masked.
// Also, get the actual UW to compare.
//
// Only string2 contains an extension A char,
// so set the UW value to be the first UW
// value for extension A (default values):
// SM_EXT_A, AW_EXT_A
//
Weight2 = GET_DWORD_WEIGHT(pHashN, *pString2); uw2 = MAKE_UNICODE_WT(SM_EXT_A, AW_EXT_A, fModify); }
//
// We should then fall through to the comparison
// of the Unicode weights.
//
break; } case ( UNSORTABLE ) : { //
// Fill out the case statement so the compiler
// will use a jump table.
//
break; } }
//
// See if the comparison should start again.
//
if ((Weight1 == CMP_INVALID_WEIGHT) || (Weight2 == CMP_INVALID_WEIGHT)) { //
// Check to see if we're modifying the script value.
// If so, then we need to reset the fareast weight
// (if applicable) so that it doesn't get modified
// again.
//
if (fModify == TRUE) { if (sm1 == FAREAST_SPECIAL) { Weight1 = CMP_INVALID_WEIGHT; } else if (sm2 == FAREAST_SPECIAL) { Weight2 = CMP_INVALID_WEIGHT; } } continue; }
//
// We're not supposed to drop down into the state table if
// the unicode weights are different, so stop comparison
// and return result of unicode weight comparison.
//
if (uw1 != uw2) { return ((uw1 < uw2) ? CSTR_LESS_THAN : CSTR_GREATER_THAN); } }
//
// For each state in the state table, do the appropriate
// comparisons.
//
if (State & (STATE_DW | STATE_REVERSE_DW)) { //
// Get the diacritic weights.
//
dw1 = GET_DIACRITIC(&Weight1); dw2 = GET_DIACRITIC(&Weight2);
if (dw1 != dw2) { //
// Look ahead to see if diacritic follows a
// minimum diacritic weight. If so, get the
// diacritic weight of the nonspace mark.
//
while (!AT_STRING_END(ctr1 - 1, pString1 + 1, cchCount1)) { Wt = GET_DWORD_WEIGHT(pHashN, *(pString1 + 1)); if (GET_SCRIPT_MEMBER(&Wt) == NONSPACE_MARK) { dw1 += GET_DIACRITIC(&Wt); pString1++; ctr1--; } else { break; } }
while (!AT_STRING_END(ctr2 - 1, pString2 + 1, cchCount2)) { Wt = GET_DWORD_WEIGHT(pHashN, *(pString2 + 1)); if (GET_SCRIPT_MEMBER(&Wt) == NONSPACE_MARK) { dw2 += GET_DIACRITIC(&Wt); pString2++; ctr2--; } else { break; } }
//
// Save which string has the smaller diacritic
// weight if the diacritic weights are still
// different.
//
if (dw1 != dw2) { WhichDiacritic = (dw1 < dw2) ? CSTR_LESS_THAN : CSTR_GREATER_THAN;
//
// Remove state from state machine.
//
REMOVE_STATE(STATE_DW); } } } if (State & STATE_CW) { //
// Get the case weights.
//
if (GET_CASE(&Weight1) != GET_CASE(&Weight2)) { //
// Save which string has the smaller case weight.
//
WhichCase = (GET_CASE(&Weight1) < GET_CASE(&Weight2)) ? CSTR_LESS_THAN : CSTR_GREATER_THAN;
//
// Remove state from state machine.
//
REMOVE_STATE(STATE_CW); } } }
//
// Fixup the pointers and counters.
//
POINTER_FIXUP(); ctr1--; ctr2--;
//
// Reset the weights to be invalid.
//
Weight1 = CMP_INVALID_WEIGHT; Weight2 = CMP_INVALID_WEIGHT; }
//
// If the end of BOTH strings has been reached, then the unicode
// weights match exactly. Check the diacritic, case and special
// weights. If all are zero, then return success. Otherwise,
// return the result of the weight difference.
//
// NOTE: The following checks MUST REMAIN IN THIS ORDER:
// Diacritic, Case, Punctuation.
//
if (AT_STRING_END(ctr1, pString1, cchCount1)) { if (AT_STRING_END(ctr2, pString2, cchCount2)) { if (WhichDiacritic) { return (WhichDiacritic); } if (WhichCase) { return (WhichCase); } if (WhichExtra) { if (!fIgnoreDiacritic) { if (GET_WT_FOUR(&WhichExtra)) { return (GET_WT_FOUR(&WhichExtra)); } if (GET_WT_FIVE(&WhichExtra)) { return (GET_WT_FIVE(&WhichExtra)); } } if (GET_WT_SIX(&WhichExtra)) { return (GET_WT_SIX(&WhichExtra)); } if (GET_WT_SEVEN(&WhichExtra)) { return (GET_WT_SEVEN(&WhichExtra)); } } if (WhichPunct1) { return (WhichPunct1); } if (WhichPunct2) { return (WhichPunct2); }
return (CSTR_EQUAL); } else { //
// String 2 is longer.
//
pString1 = pString2; ctr1 = ctr2; cchCount1 = cchCount2; fEnd1 = CSTR_LESS_THAN; } } else { fEnd1 = CSTR_GREATER_THAN; }
//
// Scan to the end of the longer string.
//
SCAN_LONGER_STRING( ctr1, pString1, cchCount1, fEnd1 );}
////////////////////////////////////////////////////////////////////////////
//
// FindJamoDifference
//
////////////////////////////////////////////////////////////////////////////
int FindJamoDifference( PLOC_HASH pHashN, LPCWSTR* ppString1, int* ctr1, int cchCount1, DWORD* pWeight1, LPCWSTR* ppString2, int* ctr2, int cchCount2, DWORD* pWeight2, LPCWSTR* pLastJamo, WORD* uw1, WORD* uw2, int* pState, int* WhichJamo, BOOL fModify){ int bRestart = 0; // if string compare should restart again
int oldHangulsFound1 = 0; // # of valid old Hangul Jamo compositions found
int oldHangulsFound2 = 0; // # of valid old Hangul Jamo compositions found
WORD UW; BYTE JamoWeight1[3]; // extra weight for first old Hangul composition
BYTE JamoWeight2[3]; // extra weight for second old Hangul composition
//
// Roll back to the first Jamo. We know that these Jamos in both strings
// should be equal, so we can decrement both strings at once.
//
while ((*ppString1 > *pLastJamo) && IsJamo(*(*ppString1 - 1))) { (*ppString1)--; (*ppString2)--; (*ctr1)++; (*ctr2)++; }
//
// Now we are at the beginning of two groups of Jamo characters.
// Compare Jamo unit (either a single Jamo or a valid old Hangul Jamo
// composition) until we run out Jamo units in either strings.
// We also exit when we reach the ends of either string.
//
// while (NOT_END_STRING(*ctr1, *ppString1, cchCount1) &&
// NOT_END_STRING(*ctr2, *ppString2, cchCount2))
//
for (;;) { if (IsJamo(**ppString1)) { if (IsLeadingJamo(**ppString1)) { if ((oldHangulsFound1 = MapOldHangulSortKey( pHashN, *ppString1, *ctr1, &UW, JamoWeight1, fModify )) > 0) { *uw1 = UW;
//
// Mark *pWeight1 so that it is not CMP_INVALID_WEIGHT.
// 0202 is the DW/CW.
//
*pWeight1 = ((DWORD)UW | 0x02020000);
//
// We always increment ppString1/ctr1 at the end of the
// loop, so we need to subtract 1 here.
//
*ppString1 += (oldHangulsFound1 - 1); *ctr1 -= (oldHangulsFound1 - 1); } } if (oldHangulsFound1 == 0) { //
// No valid old Hangul compositions are found. Get the UW
// for the Jamo instead.
//
*pWeight1 = GET_DWORD_WEIGHT(pHashN, **ppString1);
//
// The SMs in PSORTKEY for Jamos are not really SMs. They
// are all 4 (for JAMO_SPECIAL).
// Here we get the real Jamo Unicode weight. The actual SM
// is stored in DW.
//
*uw1 = MAKE_UNICODE_WT( GET_DIACRITIC(pWeight1), GET_ALPHA_NUMERIC(pWeight1), fModify ); ((PSORTKEY)pWeight1)->Diacritic = MIN_DW; } }
if (IsJamo(**ppString2)) { if (IsLeadingJamo(**ppString2)) { if ((oldHangulsFound2 = MapOldHangulSortKey( pHashN, *ppString2, *ctr2, &UW, JamoWeight2, fModify )) > 0) { *uw2 = UW; *pWeight2 = ((DWORD)UW | 0x02020000); *ppString2 += (oldHangulsFound2 - 1); *ctr2 -= (oldHangulsFound2 - 1); } } if (oldHangulsFound2 == 0) { *pWeight2 = GET_DWORD_WEIGHT(pHashN, **ppString2); *uw2 = MAKE_UNICODE_WT( GET_DIACRITIC(pWeight2), GET_ALPHA_NUMERIC(pWeight2), fModify ); ((PSORTKEY)pWeight2)->Diacritic = MIN_DW; } }
//
// See if either weight is invalid.
// A weight can be invalid when the character is not a Jamo.
//
if (*pWeight1 == CMP_INVALID_WEIGHT) { //
// The current character is not a Jamo. Set the Weight to
// be CMP_INVALID_WEIGHT, so that the string comparision can
// restart within the loop of CompareString().
//
*pWeight1 = CMP_INVALID_WEIGHT; bRestart = 1; goto FindJamoDifferenceExit; } if (*pWeight2 == CMP_INVALID_WEIGHT) { //
// The current character is not a Jamo. Set the Weight to
// be CMP_INVALID_WEIGHT, so that the string comparision can
// restart within the loop of CompareString().
//
*pWeight2 = CMP_INVALID_WEIGHT; bRestart = 1; goto FindJamoDifferenceExit; } if (*uw1 != *uw2) { //
// Found differences in Unicode weight. We can stop the
// processing now.
//
goto FindJamoDifferenceExit; }
//
// When we get here, we know that we have the same Unicode Weight.
// Check if we need to record the WhichJamo.
//
if ((*pState & STATE_JAMO_WEIGHT) && ((oldHangulsFound1 > 0) || (oldHangulsFound2 > 0))) { if ((oldHangulsFound1 > 0) && (oldHangulsFound2 > 0)) { *WhichJamo = (int)memcmp( JamoWeight1, JamoWeight2, sizeof(JamoWeight1) ) + 2; } else if (oldHangulsFound1 > 0) { *WhichJamo = CSTR_GREATER_THAN; } else { *WhichJamo = CSTR_LESS_THAN; } *pState &= ~STATE_JAMO_WEIGHT; oldHangulsFound1 = oldHangulsFound2 = 0; } (*ppString1)++; (*ctr1)--; (*ppString2)++; (*ctr2)--;
if (AT_STRING_END(*ctr1, *ppString1, cchCount1) || AT_STRING_END(*ctr2, *ppString2, cchCount2)) { break; } *pWeight1 = *pWeight2 = CMP_INVALID_WEIGHT; }
//
// If we drop out of the while loop because we reach the end of strings,
// decrement the pointers by one because loops in CompareString() will
// increase the pointers at the end of the loop.
//
// If we drop out of the while loop because the goto's in it, we are
// already off by one.
//
if (AT_STRING_END(*ctr1, *ppString1, cchCount1)) { (*ppString1)--; (*ctr1)++; } if (AT_STRING_END(*ctr2, *ppString2, cchCount2)) { (*ppString2)--; (*ctr2)++; }
FindJamoDifferenceExit: *pLastJamo = *ppString1; return (bRestart);}
|
