/*++ Copyright (c) 1991-2000, Microsoft Corporation All rights reserved. Module Name: jamo.c Abstract: This file contains functions that deal with the sorting of old Hangul. Korean characters (Hangul) can be composed by Jamos (U+1100 - U+11ff). However, some valid compositions of Jamo are not found in mordern Hangul (U+AC00 - U+D7AF). These valid compositions are called old Hangul. MapOldHangulSortKey() is called by CompareString() and MapSortKey() to handle the sorting of old Hangul. Note: The Jamo composition means that several Jamo (Korean alpahbetic) composed a valid Hangul character or old Hangul character. Eg. U+1100 U+1103 U+1161 U+11a8 composes a valid old Hangul character. The following are data members of the global structure pTblPtrs used by old Hangul sorting: * pTblPtrs->pJamoIndex Given a Jamo, this is the index into the pJamoComposition state machine for this Jamo. The value for U+1100 is stored in pJamoIndex[0], U+1101 is in pJamoIndex[1], etc. The value for U+1100 is 1. This means the state machine for U+1100 is stored in pJamoComposition[1]. Note that not every Jamo can start a valid composition. For those Jamos that can not start a valid composition, the table entry for that Jamo is 0. E.g. the index for U+1101 is 0. * pTblPtrs->NumJamoIndex The number of entries in pJamoIndex. Every index is a WORD. * pTblPtrs->pJamoComposition This is the Jamo composition state machine. It is used for two purposes: 1. Used to verify a valid Jamo combination that composes an old Hangul character. 2. If a valid old Hangul composition is found, get the SortInfo for the current combination. * pTblPtrs->NumJamoComposition The number of entires in pJamoComposition Revision History: 05-30-2000 JohnMcCo Create old Hangul sorting algorithm and sample. 06-23-2000 YSLin Created. --*/ // // Include Files. // #include "nls.h" #include "jamo.h" //-------------------------------------------------------------------------// // 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 -2 was passed in the count // parameter. // // 11-04-92 JulieB Created. //////////////////////////////////////////////////////////////////////////// #define NOT_END_STRING(ct, ptr, cchIn) \ ((ct != 0) && (!((*(ptr) == 0) && (cchIn == -2)))) //////////////////////////////////////////////////////////////////////////// // // GET_JAMO_INDEX // // Update the global sort sequence info based on the new state. // //////////////////////////////////////////////////////////////////////////// #define GET_JAMO_INDEX(wch) ((wch) - NLS_CHAR_FIRST_JAMO) //-------------------------------------------------------------------------// // INTERNAL ROUTINES // //-------------------------------------------------------------------------// //////////////////////////////////////////////////////////////////////////// // // UpdateJamoState // // Update the sort result info based on the new state. // // JamoClass The current Jamo class (LeadingJamo/VowelJamo/TrailingJamo) // pSort The sort information derived from the current state. // pSortResult The sort information for the final result. Used to // collect info from pSort. // // 06-22-2000 YSLin Created. //////////////////////////////////////////////////////////////////////////// void UpdateJamoState( int JamoClass, PJAMO_SORT_INFO pSort, PJAMO_SORT_INFOEX pSortResult) // new sort sequence information { // // Record if this is a jamo unique to old Hangul. // pSortResult->m_bOld |= pSort->m_bOld; // // Update the indices iff the new ones are higher than the current ones. // if (pSort->m_chLeadingIndex > pSortResult->m_chLeadingIndex) { pSortResult->m_chLeadingIndex = pSort->m_chLeadingIndex; } if (pSort->m_chVowelIndex > pSortResult->m_chVowelIndex) { pSortResult->m_chVowelIndex = pSort->m_chVowelIndex; } if (pSort->m_chTrailingIndex > pSortResult->m_chTrailingIndex) { pSortResult->m_chTrailingIndex = pSort->m_chTrailingIndex; } // // Update the extra weights according to the current Jamo class. // switch (JamoClass) { case ( NLS_CLASS_LEADING_JAMO ) : { if (pSort->m_ExtraWeight > pSortResult->m_LeadingWeight) { pSortResult->m_LeadingWeight = pSort->m_ExtraWeight; } break; } case ( NLS_CLASS_VOWEL_JAMO ) : { if (pSort->m_ExtraWeight > pSortResult->m_VowelWeight) { pSortResult->m_VowelWeight = pSort->m_ExtraWeight; } break; } case ( NLS_CLASS_TRAILING_JAMO ) : { if (pSort->m_ExtraWeight > pSortResult->m_TrailingWeight) { pSortResult->m_TrailingWeight = pSort->m_ExtraWeight; } break; } } } //////////////////////////////////////////////////////////////////////////// // // GetJamoComposition // // ppString pointer to the current Jamo character // pCount pointer to the current character count (couting backwards) // cchSrc The total character count (if the value is -2, then the string is null-terminated) // currentJamoClass the current Jamo class. // lpJamoTable The entry in jamo table. // JamoSortInfo the sort information for the final result. // // NOTENOTE This function assumes that the character at *ppString is a leading Jamo. // // 06-12-2000 YSLin Created. //////////////////////////////////////////////////////////////////////////// int GetJamoComposition( LPCWSTR* ppString, // The pointer to the current character int* pCount, // The current character count int cchSrc, // The total character length int currentJamoClass, // The current Jamo class. JAMO_SORT_INFOEX* JamoSortInfo // The result Jamo sorting information. ) { WCHAR wch; int JamoClass; int Index; PJAMO_TABLE pJamo; PJAMO_COMPOSE_STATE lpNext = NULL; PJAMO_COMPOSE_STATE pSearchEnd; wch = **ppString; // // Get the Jamo information for the current character. // pJamo = pTblPtrs->pJamoIndex + GET_JAMO_INDEX(wch); UpdateJamoState(currentJamoClass, &(pJamo->SortInfo), JamoSortInfo); // // Move on to next character. // (*ppString)++; while (NOT_END_STRING(*pCount, *ppString, cchSrc)) { wch = **ppString; if (!IsJamo(wch)) { // The current character is not a Jamo. We are done with checking the Jamo composition. return (-1); } if (wch == 0x1160) { JamoSortInfo->m_bFiller = TRUE; } // Get the Jamo class of it. if (IsLeadingJamo(wch)) { JamoClass = NLS_CLASS_LEADING_JAMO; } else if (IsTrailingJamo(wch)) { JamoClass = NLS_CLASS_TRAILING_JAMO; } else { JamoClass = NLS_CLASS_VOWEL_JAMO; } if (JamoClass != currentJamoClass) { return (JamoClass); } if (lpNext == NULL) { // // Get the index into the Jamo composition information. // Index = pJamo->Index; if (Index == 0) { return (JamoClass); } lpNext = pTblPtrs->pJamoComposition + Index; pSearchEnd = lpNext + pJamo->TransitionCount; } // // Push the current Jamo (pointed by pString) into a state machine, // to check if we have a valid old Hangul composition. // During the check, we will also update the sortkey result in JamoSortInfo. // while (lpNext < pSearchEnd) { // Found a match--update the combination pointer and sort info. if (lpNext->m_wcCodePoint == wch) { UpdateJamoState(currentJamoClass, &(lpNext->m_SortInfo), JamoSortInfo); lpNext++; goto NextChar; } // No match -- skip all transitions beginning with this code point lpNext += lpNext->m_bTransitionCount + 1; } // // We didn't find a valid old Hangul composition for the current character. // So return the current Jamo class. // return (JamoClass); NextChar: // We are still in a valid old Hangul composition. Go check the next character. (*ppString)++; (*pCount)--; } return (-1); } //-------------------------------------------------------------------------// // EXTERNAL ROUTINES // //-------------------------------------------------------------------------// //////////////////////////////////////////////////////////////////////////// // // MapOldHangulSortKey // // Check if the given string has a valid old Hangul composition, // If yes, store the sortkey weights for the given string in the destination // buffer and return the number of CHARs consumed by the composition. // If not, return zero. // // NOTENOTE: This function assumes that string starting from pSrc is a // leading Jamo. // // 06-12-2000 YSLin Created. //////////////////////////////////////////////////////////////////////////// int MapOldHangulSortKey( PLOC_HASH pHashN, LPCWSTR pSrc, // source string int cchSrc, // the length of the string WORD* pUW, // generated Unicode weight LPBYTE pXW, // generated extra weight (3 bytes) BOOL fModify) { LPCWSTR pString = pSrc; LPCWSTR pScan; JAMO_SORT_INFOEX JamoSortInfo; // The result Jamo infomation. int Count = cchSrc; PSORTKEY pWeight; int JamoClass; // The current Jamo class. RtlZeroMemory(&JamoSortInfo, sizeof(JamoSortInfo)); JamoClass = GetJamoComposition(&pString, &Count, cchSrc, NLS_CLASS_LEADING_JAMO, &JamoSortInfo); if (JamoClass == NLS_CLASS_VOWEL_JAMO) { JamoClass = GetJamoComposition(&pString, &Count, cchSrc, NLS_CLASS_VOWEL_JAMO, &JamoSortInfo); } if (JamoClass == NLS_CLASS_TRAILING_JAMO) { GetJamoComposition(&pString, &Count, cchSrc, NLS_CLASS_TRAILING_JAMO, &JamoSortInfo); } // // If we have a valid leading and vowel sequences and this is an old // Hangul,... // if (JamoSortInfo.m_bOld) { // // Compute the modern Hangul syllable prior to this composition. // Uses formula from Unicode 3.0 Section 3.11 p54 // "Hangul Syllable Composition". // WCHAR wchModernHangul = (JamoSortInfo.m_chLeadingIndex * NLS_JAMO_VOWEL_COUNT + JamoSortInfo.m_chVowelIndex) * NLS_JAMO_TRAILING_COUNT + JamoSortInfo.m_chTrailingIndex + NLS_HANGUL_FIRST_SYLLABLE; if (JamoSortInfo.m_bFiller) { // Sort before the modern Hangul, instead of after. wchModernHangul--; // If we fall off the modern Hangul syllable block,... if (wchModernHangul < NLS_HANGUL_FIRST_SYLLABLE) { // Sort after the previous character (Circled Hangul Kiyeok A) wchModernHangul = 0x326e; } // Shift the leading weight past any old Hangul that sorts after this modern Hangul JamoSortInfo.m_LeadingWeight += 0x80; } pWeight = &((pHashN->pSortkey)[wchModernHangul]); *pUW = GET_UNICODE_MOD(pWeight, fModify); pXW[0] = JamoSortInfo.m_LeadingWeight; pXW[1] = JamoSortInfo.m_VowelWeight; pXW[2] = JamoSortInfo.m_TrailingWeight; return (int)(pString - pSrc); } // // Otherwise it isn't a valid old Hangul composition and we don't do // anything with it. // return (0); }