/*******************************************************************************
;*******************************************************************************
;**                                                                           **
;**                  COPYRIGHT 1998-2012 NUANCE COMMUNICATIONS                **
;**                                                                           **
;**               NUANCE COMMUNICATIONS PROPRIETARY INFORMATION               **
;**                                                                           **
;**     This software is supplied under the terms of a license agreement      **
;**     or non-disclosure agreement with Nuance Communications and may not    **
;**     be copied or disclosed except in accordance with the terms of that    **
;**     agreement.                                                            **
;**                                                                           **
;*******************************************************************************
;**                                                                           **
;**     FileName: et9asym.c                                                   **
;**                                                                           **
;**  Description: Case, Class, Key assignment routines source file.           **
;**                                                                           **
;*******************************************************************************
;******* 10 ****** 20 ****** 30 ****** 40 ****** 50 ****** 60 ****** 70 *******/

/*! -IDR-                                                       
*                                    
*   
*/

#include "et9api.h"
#ifdef ET9_ALPHABETIC_MODULE
#include "et9sym.h"
#include "et9asym.h"
#include "et9amisc.h"


#define NUM_STANDARD_TERM_PUNCT_CHARS   10      /* < -IDR-                                             */
#define NUM_SPANISH_TERM_PUNCT_CHARS    12      /* < -IDR-                                            */
#define NUM_GREEK_TERM_PUNCT_CHARS      10      /* < -IDR-                                          */
#define NUM_ARABIC_TERM_PUNCT_CHARS     9       /* < -IDR-                                           */
#define NUM_FARSI_TERM_PUNCT_CHARS      10      /* < -IDR-                                          */
#define NUM_PASHTO_TERM_PUNCT_CHARS     6       /* < -IDR-                                           */
#define NUM_THAI_TERM_PUNCT_CHARS       11      /* < -IDR-                                         */
#define NUM_CATALAN_TERM_PUNCT_CHARS    13      /* < -IDR-                                            */
#define NUM_KHMER_TERM_PUNCT_CHARS      7       /* < -IDR-                                          */
#define NUM_HEBREW_TERM_PUNCT_CHARS     10      /* < -IDR-                                           */
#define NUM_AMHARIC_TERM_PUNCT_CHARS    8       /* < -IDR-                                            */
#define NUM_ARMENIAN_TERM_PUNCT_CHARS   9       /* < -IDR-                                             */


/*  -IDR-                                                             /      */
static const ET9SYMB StandardTermPunct[] = {0x002e, 0x003f, 0x0021, 0x002c, 0x002d, 0x0027, 0x0022, 0x0040, 0x003a, 0x002f};

/*  -IDR-                                       / ¿ ¡     */
static const ET9SYMB  SpanishTermPunct[] = {0x002e, 0x003f, 0x0021, 0x002c, 0x002d, 0x0027, 0x0022, 0x0040, 0x003a, 0x002f, 0x00bf, 0x00a1};

/*  -IDR-                                     /      */
static const ET9SYMB GreekTermPunct[] = {0x002e, 0x003b, 0x0021, 0x002c, 0x002d, 0x0027, 0x0022, 0x0040, 0x003a, 0x002f};

/*  -IDR-                                                                                   /          */
static const ET9SYMB ArabicTermPunct[] = {0x002e, 0x061f, 0x0021, 0x060c, 0x061b, 0x0022, 0x0040, 0x003a, 0x002f};

/*  -IDR-               */
static const ET9SYMB FarsiTermPunct[] = {0x002e, 0x061f, 0x0021, 0x060c, 0x061b, 0x0022, 0x002d, 0x003a, 0x002f, 0x0040};

/*  -IDR-                                                           */
static const ET9SYMB PashtoTermPunct[] = {0x002e, 0x061f, 0x003a, 0x060c, 0x0021, 0x061B};

/*  -IDR-                                       /           */
static const ET9SYMB ThaiTermPunct[] = {0x0020, 0x002e, 0x003f, 0x0021, 0x002c, 0x002d, 0x0027, 0x0022, 0x0040, 0x003a, 0x002f};

/*  -IDR-                                      ·            ·         ¿ ¡ / ·      */
static const ET9SYMB CatalanTermPunct[] = {0x002e, 0x003f, 0x0021, 0x002c, 0x002d, 0x0027, 0x0022, 0x0040, 0x003a, 0x002f, 0x00bf, 0x00a1, 0x00b7};

/*  -IDR-                                                                                       */
static const ET9SYMB KhmerTermPunct[] = {0x0020, 0x17D4, 0x17D5, 0x17D6, 0x17D7, 0x002E, 0x17DB};

/*  -IDR-                                                    /                  */
static const ET9SYMB HebrewTermPunct[] = {0x002e, 0x003f, 0x0021, 0x002c, 0x002d, 0x0027, 0x0022, 0x0040, 0x003a, 0x002f};

/*  -IDR-                    */
static const ET9SYMB AmharicTermPunct[] = {0x1362, 0x1363, 0x003f, 0x0021, 0x002f, 0x1364, 0x1365, 0x1366};

/*  -IDR-                     */
static const ET9SYMB ArmenianTermPunct[] = {0x0589, 0x055E, 0x055D, 0x055B, 0x055C, 0x002e, 0x003f, 0x0021, 0x002c};


static const ET9SYMB sPeriodEmbPunct = 0x002e;
static const ET9SYMB sHyphenEmbPunct = 0x002d;
static const ET9SYMB sDandaEmbPunct  = 0x0964;
static const ET9SYMB sSpaceEmbPunct  = 0x0020;
static const ET9SYMB sArmQuestionEmbPunct  = 0x055E;

#define NUM_STANDARD_SINGLE_CHAR_WORDS      0       /* < -IDR-                                              */
#define NUM_ALBANIAN_SINGLE_CHAR_WORDS      5       /* < -IDR-                                              */
#define NUM_ARABIC_SINGLE_CHAR_WORDS        1       /* < -IDR-                                            */
#define NUM_ARMENIAN_SINGLE_CHAR_WORDS      2       /* < -IDR-                                              */
#define NUM_AZERBAIJANI_SINGLE_CHAR_WORDS   2       /* < -IDR-                                                 */
#define NUM_BASQUE_SINGLE_CHAR_WORDS        2       /* < -IDR-                                            */
#define NUM_BULGARIAN_SINGLE_CHAR_WORDS     9       /* < -IDR-                                               */
#define NUM_CATALAN_SINGLE_CHAR_WORDS       4       /* < -IDR-                                             */
#define NUM_CROATIAN_SINGLE_CHAR_WORDS      6       /* < -IDR-                                              */
#define NUM_CZECH_SINGLE_CHAR_WORDS         8       /* < -IDR-                                           */
#define NUM_DANISH_SINGLE_CHAR_WORDS        4       /* < -IDR-                                            */
#define NUM_DUTCH_SINGLE_CHAR_WORDS         1       /* < -IDR-                                           */
#define NUM_ENGLISH_SINGLE_CHAR_WORDS       2       /* < -IDR-                                             */
#define NUM_FARSI_SINGLE_CHAR_WORDS         2       /* < -IDR-                                           */
#define NUM_FRENCH_SINGLE_CHAR_WORDS        3       /* < -IDR-                                            */
#define NUM_GALICIAN_SINGLE_CHAR_WORDS      5       /* < -IDR-                                              */
#define NUM_GREEK_SINGLE_CHAR_WORDS         3       /* < -IDR-                                           */
#define NUM_HINDI_SINGLE_CHAR_WORDS         3       /* < -IDR-                                           */
#define NUM_HUNGARIAN_SINGLE_CHAR_WORDS     5       /* < -IDR-                                               */
#define NUM_ICELANDIC_SINGLE_CHAR_WORDS     2       /* < -IDR-                                               */
#define NUM_ITALIAN_SINGLE_CHAR_WORDS       5       /* < -IDR-                                             */
#define NUM_LATVIAN_SINGLE_CHAR_WORDS       1       /* < -IDR-                                             */
#define NUM_LITHUANIAN_SINGLE_CHAR_WORDS    5       /* < -IDR-                                                */
#define NUM_MALAY_SINGLE_CHAR_WORDS         1       /* < -IDR-                                           */
#define NUM_MARATHI_SINGLE_CHAR_WORDS       4       /* < -IDR-                                             */
#define NUM_NORWEGIAN_SINGLE_CHAR_WORDS     2       /* < -IDR-                                               */
#define NUM_POLISH_SINGLE_CHAR_WORDS        6       /* < -IDR-                                            */
#define NUM_PORTUGUESE_SINGLE_CHAR_WORDS    6       /* < -IDR-                                                */
#define NUM_ROMANIAN_SINGLE_CHAR_WORDS      4       /* < -IDR-                                              */
#define NUM_RUSSIAN_SINGLE_CHAR_WORDS       8       /* < -IDR-                                             */
#define NUM_SERBIAN_SINGLE_CHAR_WORDS       5       /* < -IDR-                                             */
#define NUM_SERBIANCYRILLIC_SINGLE_CHAR_WORDS 4       /* < -IDR-                                                     */
#define NUM_SLOVAK_SINGLE_CHAR_WORDS        7       /* < -IDR-                                            */
#define NUM_SLOVENIAN_SINGLE_CHAR_WORDS     7       /* < -IDR-                                               */
#define NUM_SPANISH_SINGLE_CHAR_WORDS       5       /* < -IDR-                                             */
#define NUM_SWEDISH_SINGLE_CHAR_WORDS       3       /* < -IDR-                                             */
#define NUM_TAGALOG_SINGLE_CHAR_WORDS       1       /* < -IDR-                                             */
#define NUM_TAMIL_SINGLE_CHAR_WORDS         1       /* < -IDR-                                           */
#define NUM_THAI_SINGLE_CHAR_WORDS          4       /* < -IDR-                                          */
#define NUM_TURKISH_SINGLE_CHAR_WORDS       3       /* < -IDR-                                             */
#define NUM_UKRAINIAN_SINGLE_CHAR_WORDS     8       /* < -IDR-                                               */
#define NUM_URDU_SINGLE_CHAR_WORDS          1       /* < -IDR-                                          */
#define NUM_VIETNAMESE_SINGLE_CHAR_WORDS    1       /* < -IDR-                                                */

/*  -IDR-                         */
static const ET9SYMB AlbanianSingleCharWord[] = {0x0069, 0x0065, 0x0075, 0x0061, 0x006F};

/*  -IDR-                    */
static const ET9SYMB ArabicSingleCharWord[] = {0x0648};

/*  -IDR-                             */
static const ET9SYMB ArmenianSingleCharWord[] = {0x0567, 0x0587};

/*  -IDR-                           */
static const ET9SYMB AzerbaijaniSingleCharWord[] = {0x006F, 0x0259};

/*  -IDR-                 */
static const ET9SYMB BasqueSingleCharWord[] = {0x0061, 0x0065};

/*  -IDR-                                                                                       */
static const ET9SYMB BulgarianSingleCharWord[] = {0x0435, 0x0430, 0x0438, 0x045D, 0x0432, 0x043E, 0x0441, 0x0443, 0x044F};

/*  -IDR-                      */
static const ET9SYMB CatalanSingleCharWord[] = {0x0061, 0x0069, 0x006F, 0x0075};

/*  -IDR-                           */
static const ET9SYMB CroatianSingleCharWord[] = {0x0075, 0x0069, 0x006F, 0x0061, 0x0073, 0x006B};

/*  -IDR-                            */
static const ET9SYMB CzechSingleCharWord[] = {0x0061, 0x006B, 0x006F, 0x007A, 0x0073, 0x0069, 0x0076, 0x0075};

/*  -IDR-               å ø   */
static const ET9SYMB DanishSingleCharWord[] = {0x0069, 0x00E5, 0x00F8, 0x0049};

/*  -IDR-              */
static const ET9SYMB DutchSingleCharWord[] = {0x0075};

/*  -IDR-                  */
static const ET9SYMB EnglishSingleCharWord[] = {0x0061, 0x0049};

/*  -IDR-                          */
static const ET9SYMB FarsiSingleCharWord[] = {0x0648, 0x0632};

/*  -IDR-             à     */
static const ET9SYMB FrenchSingleCharWord[] = {0x00E0, 0x0061, 0x0079};

/*  -IDR-                 á     é */
static const ET9SYMB GalicianSingleCharWord[] = {0x0061, 0x00E1, 0x0065, 0x006F, 0x00E9};

/*  -IDR-                            */
static const ET9SYMB GreekSingleCharWord[] = {0x006F, 0x03B7, 0x03AE};

/*  -IDR-                                   */
static const ET9SYMB HindiSingleCharWord[] = {0x0906, 0x0928, 0x0913};

/*  -IDR-                               */
static const ET9SYMB HungarianSingleCharWord[] = {0x0061, 0x0065, 0x006F, 0x0151, 0x0073};

/*  -IDR-                á í */
static const ET9SYMB IcelandicSingleCharWord[] = {0x00E1, 0x00ED};

/*  -IDR-                  è     */
static const ET9SYMB ItalianSingleCharWord[] = {0x0065, 0x0061, 0x00E8, 0x0069, 0x006F};

/*  -IDR-                */
static const ET9SYMB LatvianSingleCharWord[] = {0x006F};

/*  -IDR-                                     */
static const ET9SYMB LithuanianSingleCharWord[] = {0x012F, 0x006F, 0x0061, 0x0065, 0x0117};

/*  -IDR-              */
static const ET9SYMB MalaySingleCharWord[] = {0x0078};

/*  -IDR-                                             */
static const ET9SYMB MarathiSingleCharWord[] = {0x0935, 0x0928, 0x0908, 0x0912};

/*  -IDR-                  å */
static const ET9SYMB NorwegianSingleCharWord[] = {0x0069, 0x00E5};

/*  -IDR-                         */
static const ET9SYMB PolishSingleCharWord[] = {0x0061, 0x006F, 0x0069, 0x0075, 0x0077, 0x007A};

/*  -IDR-                 é       à á */
static const ET9SYMB PortugueseSingleCharWord[] = {0x00E9, 0x0065, 0x0061, 0x00E0, 0x00E1};

/*  -IDR-                       */
static const ET9SYMB RomanianSingleCharWord[] = {0x0061, 0x0065, 0x0069, 0x006F};

/*  -IDR-                                                                             */
static const ET9SYMB RussianSingleCharWord[] = {0x044F, 0x0432, 0x0438, 0x0430, 0x043E, 0x043A, 0x0441, 0x0443};

/*  -IDR-                        */
static const ET9SYMB SerbianSingleCharWord[] = {0x0075, 0x0069, 0x006F, 0x0061, 0x0073};

/*  -IDR-                                                     */
static const ET9SYMB SerbianCyrillicSingleCharWord[] = {0x0443, 0x0438, 0x043E, 0x0430};

/*  -IDR-                           */
static const ET9SYMB SlovakSingleCharWord[] = {0x0061, 0x0076, 0x007A, 0x006F, 0x0073, 0x006B, 0x0069};

/*  -IDR-                              */
static const ET9SYMB SlovenianSingleCharWord[] = {0x007A, 0x0076, 0x0073, 0x006F, 0x0061, 0x006B, 0x0068};

/*  -IDR-                        */
static const ET9SYMB SpanishSingleCharWord[] = {0x0061, 0x006F, 0x0079, 0x0075, 0x0065};

/*  -IDR-                å ö */
static const ET9SYMB SwedishSingleCharWord[] = {0x0069, 0x00E5, 0x00F6};

/*  -IDR-                */
static const ET9SYMB TagalogSingleCharWord[] = {0x006F};

/*  -IDR-                   */
static const ET9SYMB TamilSingleCharWord[] = {0x0B88};

/*  -IDR-                                          */
static const ET9SYMB ThaiSingleCharWord[] = {0x0E2F, 0x0E13, 0x0E18, 0x0E46};

/*  -IDR-                    */
static const ET9SYMB TurkishSingleCharWord[] = {0x006F, 0x0065, 0x0068};

/*  -IDR-                                                                               */
static const ET9SYMB UkrainianSingleCharWord[] = {0x0439, 0x0437, 0x0456, 0x0432, 0x0430, 0x0454, 0x044F, 0x043E};

/*  -IDR-                  */
static const ET9SYMB UrduSingleCharWord[] = {0x0648};

/*  -IDR-                   */
static const ET9SYMB VietnameseSingleCharWord[] = {0x0075};

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                         
 *
 *                                      
 *
 *                                            
 */

#define IS_EMBEDDED_HYPHEN(n) ( \
n == ET9PLIDBasque || \
n == ET9PLIDBelarusian || \
n == ET9PLIDCatalan || \
n == ET9PLIDFrench || \
n == ET9PLIDGalician || \
n == ET9PLIDGreek || \
n == ET9PLIDIndonesian || \
n == ET9PLIDIrish || \
n == ET9PLIDJavanese || \
n == ET9PLIDKirghiz || \
n == ET9PLIDLithuanian || \
n == ET9PLIDMalay || \
n == ET9PLIDPolish || \
n == ET9PLIDMongolian || \
n == ET9PLIDTurkmen || \
n == ET9PLIDPortuguese || \
n == ET9PLIDRomanian || \
n == ET9PLIDSundanese || \
n == ET9PLIDTagalog || \
n == ET9PLIDTajik || \
n == ET9PLIDXhosa || \
n == ET9PLIDZulu)

#define IS_EMBEDDED_DANDA(n) (n == ET9PLIDBengali)

#define IS_EMBEDDED_SPACE(n) (n == ET9PLIDThai || n == ET9PLIDKhmer || n == ET9PLIDLao || n == ET9PLIDAmharic)

#define IS_EMBEDDED_ARMQUESTION(n) (n == ET9PLIDArmenian)

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                     
 *
 *                                                                              
 *                                             
 *
 *                                        
 */

ET9SYMB ET9FARCALL _ET9_GetEmbPunctChar(ET9AWLingInfo   * const pLingInfo,
                                        const ET9U32            dwLdbNum)
{
    ET9AWLingCmnInfo * const pLingCmnInfo = pLingInfo->pLingCmnInfo;
    ET9SYMB sHolder;
    ET9U32 dwLang = dwLdbNum & ET9PLIDMASK;

    ET9Assert(pLingInfo);

    if (pLingCmnInfo->Private.sExpEmbeddedPunct) {
        sHolder = pLingCmnInfo->Private.sExpEmbeddedPunct;
    }
    else if (IS_EMBEDDED_HYPHEN(dwLang)) {
        sHolder = sHyphenEmbPunct;
    }
    else if (IS_EMBEDDED_DANDA(dwLang)) {
        sHolder = sDandaEmbPunct;
    }
    else if (IS_EMBEDDED_SPACE(dwLang)) {
        sHolder = sSpaceEmbPunct;
    }
    else if (IS_EMBEDDED_ARMQUESTION(dwLang)) {
        sHolder = sArmQuestionEmbPunct;
    }
    else {
        sHolder = sPeriodEmbPunct;
    }
    return sHolder;
}


/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                      
 *
 *                                                                              
 *                                             
 *                                               
 *
 *                                       
 */

ET9SYMB ET9FARCALL _ET9_GetTermPunctChar(ET9AWLingInfo  * const pLingInfo,
                                         const ET9U32           dwLdbNum,
                                         const ET9UINT          nSymbIndex)
{
    ET9AWLingCmnInfo * const pLingCmnInfo = pLingInfo->pLingCmnInfo;

    const ET9SYMB *pTable;
    ET9UINT nVal;

    ET9Assert(pLingInfo);

    if (pLingCmnInfo->Private.bTotalExpTermPuncts) {
        pTable = pLingCmnInfo->Private.sExpTermPuncts;
        nVal = pLingCmnInfo->Private.bTotalExpTermPuncts;
    }
    else {
        switch (dwLdbNum & ET9PLIDMASK)
        {
            case ET9PLIDSpanish:
            case ET9PLIDGalician:
                pTable = SpanishTermPunct;
                nVal = NUM_SPANISH_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDGreek:
                pTable = GreekTermPunct;
                nVal = NUM_GREEK_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDArabic:
            case ET9PLIDUrdu:
                pTable = ArabicTermPunct;
                nVal = NUM_ARABIC_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDFarsi:
                pTable = FarsiTermPunct;
                nVal = NUM_FARSI_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDPashto:
                pTable = PashtoTermPunct;
                nVal = NUM_PASHTO_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDThai:
            case ET9PLIDLao:
                pTable = ThaiTermPunct;
                nVal = NUM_THAI_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDCatalan:
                pTable = CatalanTermPunct;
                nVal = NUM_CATALAN_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDKhmer:
                pTable = KhmerTermPunct;
                nVal = NUM_KHMER_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDHebrew:
                pTable = HebrewTermPunct;
                nVal = NUM_HEBREW_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDAmharic:
                pTable = AmharicTermPunct;
                nVal = NUM_AMHARIC_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDArmenian:
                pTable = ArmenianTermPunct;
                nVal = NUM_ARMENIAN_TERM_PUNCT_CHARS;
                break;
           default:
                pTable = StandardTermPunct;
                nVal = NUM_STANDARD_TERM_PUNCT_CHARS;
                break;
        }
    }

    ET9Assert(nVal);
    ET9Assert(pTable[nSymbIndex >= nVal ? 0 : nSymbIndex]);

    return pTable[nSymbIndex >= nVal ? 0 : nSymbIndex];
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                                
 *
 *                                                                              
 *                                             
 *
 *                                             
 */

ET9UINT ET9FARCALL _ET9_GetNumTermPunct(ET9AWLingInfo   * const pLingInfo,
                                        const ET9U32            dwLdbNum)
{
    ET9AWLingCmnInfo * const pLingCmnInfo = pLingInfo->pLingCmnInfo;
    ET9UINT nVal;

    ET9Assert(pLingInfo != NULL);
    ET9Assert(pLingCmnInfo);

    if (pLingCmnInfo->Private.bTotalExpTermPuncts) {
        nVal = pLingCmnInfo->Private.bTotalExpTermPuncts;
    }
    else {
        switch (dwLdbNum & ET9PLIDMASK)
        {
            case ET9PLIDSpanish:
            case ET9PLIDGalician:
                nVal = NUM_SPANISH_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDGreek:
                nVal = NUM_GREEK_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDArabic:
            case ET9PLIDUrdu:
                nVal = NUM_ARABIC_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDFarsi:
                nVal = NUM_FARSI_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDPashto:
                nVal = NUM_PASHTO_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDThai:
                nVal = NUM_THAI_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDCatalan:
                nVal = NUM_CATALAN_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDKhmer:
                nVal = NUM_KHMER_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDHebrew:
                nVal = NUM_HEBREW_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDAmharic:
                nVal = NUM_AMHARIC_TERM_PUNCT_CHARS;
                break;
            case ET9PLIDArmenian:
                nVal = NUM_ARMENIAN_TERM_PUNCT_CHARS;
                break;
            default:
                nVal = NUM_STANDARD_TERM_PUNCT_CHARS;
                break;
        }
    }

    return nVal;
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                    
 *
 *                                                                              
 *                                             
 *                                               
 *
 *             /     
 */

ET9BOOL ET9FARCALL _ET9_IsTermPunct(ET9AWLingInfo   * const pLingInfo,
                                    const ET9U32            dwLdbNum,
                                    const ET9SYMB           sSymb)
{
    const ET9UINT nTotalPuncts = _ET9_GetNumTermPunct(pLingInfo, dwLdbNum);

    ET9UINT i;

    ET9Assert(pLingInfo);

    for (i = 0; i < nTotalPuncts; ++i) {
        if (_ET9_GetTermPunctChar(pLingInfo, dwLdbNum, i) == sSymb) {
            return 1;
        }
    }

    return 0;
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                                
 *
 *                                                                              
 *                                                                                        
 *
 *                                                                           
 */

ET9STATUS ET9FARCALL _ET9_ConvertBuildBuf(ET9AWLingInfo * const pLingInfo,
                                          ET9AWWordInfo * const pWord)
{
    ET9U16      wCount;
    ET9SYMB    *psSymb;
    ET9STATUS   wStatus = ET9STATUS_NONE;

    ET9Assert(pWord != NULL);
    ET9Assert(pLingInfo != NULL);

    /* if the host provides a character conversion (onthefly mapping)*/

    if (!pLingInfo->Private.pConvertSymb) {
        return wStatus;
    }

    wCount = pWord->wWordLen;
    psSymb = pWord->sWord;
    for (; wCount; --wCount, ++psSymb) {

        wStatus = pLingInfo->Private.pConvertSymb(pLingInfo->Private.pConvertSymbInfo, psSymb);

        if (wStatus) {
            break;
        }
    }

    if (!wStatus) {

        wCount = pWord->wSubstitutionLen;
        psSymb = pWord->sSubstitution;
        for (; wCount; --wCount, ++psSymb) {

            wStatus = pLingInfo->Private.pConvertSymb(pLingInfo->Private.pConvertSymbInfo, psSymb);

            if (wStatus) {
                break;
            }
        }
    }

    return wStatus;
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                                    
 *
 *                                                                              
 *
 *                                                             
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_ApplySpcLenTwo(ET9AWLingInfo * const pLingInfo)
{
    /* Intentionally just checking the first language */

    const ET9U32 dwLdbNum  = ET9PLIDMASK & pLingInfo->pLingCmnInfo->dwFirstLdbNum;

    switch (dwLdbNum)
    {
        case ET9PLIDNone:
        case ET9PLIDFrench:
        case ET9PLIDEnglish:
            return 1;
        default:
            return 0;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                           
 *
 *                                                                              
 *                                                                    
 *
 *                         
 */

ET9U8 ET9FARCALL _ET9_LanguageSpecific_ApplyDynamicRegionality(ET9AWLingInfo * const pLingInfo,
                                                               const ET9U16          wLength)
{
    /* Intentionally just checking the first language */

    const ET9U32 dwLdbNum  = ET9PLIDMASK & pLingInfo->pLingCmnInfo->dwFirstLdbNum;

    /* currently no limitations for trace */

    if (pLingInfo->pLingCmnInfo->Private.bTraceBuild) {
        return 0xFF;
    }

    /* language specific limitations */

    switch (dwLdbNum)
    {
        case ET9PLIDKorean:
            if (wLength >= 2 && wLength <= 5) {
                return 2;
            }
            break;
    }

    /* no limitations */

    return 0xFF;
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                                 
 *
 *                                                                              
 *                                                                        
 *
 *                                                             
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_ApplyCapsRules(ET9AWLingInfo               * const pLingInfo,
                                                        ET9AWPrivWordInfo     const * const pWord)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & (!pWord ? (pLingInfo->pLingCmnInfo->Private.dwCurrActiveLanguage) : ((pWord->Body.bLangIndexScoring == ET9AWSECOND_LANGUAGE) ? pLingInfo->pLingCmnInfo->dwSecondLdbNum : pLingInfo->pLingCmnInfo->dwFirstLdbNum));

    switch (dwLdbNum)
    {
        case ET9PLIDGerman:
        case ET9PLIDKorean:
        case ET9PLIDJapanese:
            return 0;
        default:
            if (dwLdbNum >= ET9PLIDChineseReservePoint) {
                return 0;
            }
            return 1;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                          
 *
 *                                                                              
 *                                                                        
 *
 *                                                             
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_ApplyAcronymRules(ET9AWLingInfo               * const pLingInfo,
                                                           ET9AWPrivWordInfo     const * const pWord)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & (!pWord ? (pLingInfo->pLingCmnInfo->Private.dwCurrActiveLanguage) : ((pWord->Body.bLangIndexScoring == ET9AWSECOND_LANGUAGE) ? pLingInfo->pLingCmnInfo->dwSecondLdbNum : pLingInfo->pLingCmnInfo->dwFirstLdbNum));

    switch (dwLdbNum)
    {
        case ET9PLIDKorean:
        case ET9PLIDJapanese:
            return 0;
        default:
            if (dwLdbNum >= ET9PLIDChineseReservePoint) {
                return 0;
            }
            return 1;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                             
 *
 *                                                                              
 *                                                                        
 *
 *                                                             
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_ApplyCompletionRules(ET9AWLingInfo               * const pLingInfo,
                                                             ET9AWPrivWordInfo     const * const pWord)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & (!pWord ? (pLingInfo->pLingCmnInfo->Private.dwCurrActiveLanguage) : ((pWord->Body.bLangIndexScoring == ET9AWSECOND_LANGUAGE) ? pLingInfo->pLingCmnInfo->dwSecondLdbNum : pLingInfo->pLingCmnInfo->dwFirstLdbNum));

    switch (dwLdbNum)
    {
        case ET9PLIDKorean:
        case ET9PLIDJapanese:
            return 0;
        default:
            if (dwLdbNum >= ET9PLIDChineseReservePoint) {
                return 0;
            }
            return 1;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                     
 *
 *                                                                              
 *                                                                        
 *
 *                                                                
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_ApplyShifting(ET9AWLingInfo               * const pLingInfo,
                                                       ET9AWPrivWordInfo     const * const pWord)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & (!pWord ? (pLingInfo->pLingCmnInfo->Private.dwCurrActiveLanguage) : ((pWord->Body.bLangIndexScoring == ET9AWSECOND_LANGUAGE) ? pLingInfo->pLingCmnInfo->dwSecondLdbNum : pLingInfo->pLingCmnInfo->dwFirstLdbNum));

    switch (dwLdbNum)
    {
        case ET9PLIDKorean:
        case ET9PLIDJapanese:
            return 0;
        default:
            if (dwLdbNum >= ET9PLIDChineseReservePoint) {
                return 0;
            }
            return 1;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                        
 *
 *                                                                              
 *                                                                        
 *
 *                                                                   
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_ApplyTermDemote(ET9AWLingInfo               * const pLingInfo,
                                                         ET9AWPrivWordInfo     const * const pWord)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & (!pWord ? (pLingInfo->pLingCmnInfo->Private.dwCurrActiveLanguage) : ((pWord->Body.bLangIndexScoring == ET9AWSECOND_LANGUAGE) ? pLingInfo->pLingCmnInfo->dwSecondLdbNum : pLingInfo->pLingCmnInfo->dwFirstLdbNum));

    switch (dwLdbNum)
    {
        case ET9PLIDKorean:
        case ET9PLIDJapanese:
            return 0;
        default:
            if (dwLdbNum >= ET9PLIDChineseReservePoint) {
                return 0;
            }
            return 1;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                                
 *
 *                                                                              
 *
 *                                                             
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_ApplyConfusablesRules(ET9AWLingInfo * const pLingInfo)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & pLingInfo->pLingCmnInfo->Private.dwCurrActiveLanguage;

    switch (dwLdbNum)
    {
        case ET9PLIDKorean:
        case ET9PLIDJapanese:
            return 0;
        default:
            if (dwLdbNum >= ET9PLIDChineseReservePoint) {
                return 0;
            }
            return 1;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                      
 *
 *                                                                              
 *
 *                                                                
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_ApplyCaseSensitiveRule(ET9AWLingInfo * const pLingInfo)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & pLingInfo->pLingCmnInfo->Private.dwCurrActiveLanguage;

    switch (dwLdbNum)
    {
        case ET9PLIDKorean:
        case ET9PLIDJapanese:
            return 1;
        default:
            if (dwLdbNum >= ET9PLIDChineseReservePoint) {
                return 1;
            }
            return 0;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                         
 *
 *                                                                              
 *
 *                                                          
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_ApplyShapedWords(ET9AWLingInfo * const pLingInfo)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & pLingInfo->pLingCmnInfo->dwFirstLdbNum;

    switch (dwLdbNum)
    {
        case ET9PLIDKorean:
        case ET9PLIDJapanese:
            return 0;
        default:
            if (dwLdbNum >= ET9PLIDChineseReservePoint) {
                return 0;
            }
            return 1;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                
 *
 *                                                                              
 *
 *                                                          
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_ApplyCdbWords(ET9AWLingInfo * const pLingInfo)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & pLingInfo->pLingCmnInfo->dwFirstLdbNum;

    switch (dwLdbNum)
    {
        case ET9PLIDJapanese:
            return 0;
        default:
            return 1;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                                 
 *                                                         
 *
 *                                                                              
 *
 *                                                                 
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_ApplyListShrinking(ET9AWLingInfo * const pLingInfo)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & pLingInfo->pLingCmnInfo->dwFirstLdbNum;

    switch (dwLdbNum)
    {
        case ET9PLIDKorean:
            return 1;
        case ET9PLIDJapanese:
            return 1;
        default:
            if (dwLdbNum >= ET9PLIDChineseReservePoint) {
                return 0;
            }
            return 1;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                                 
 *
 *                                                                              
 *
 *                                                         
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_ApplyBuildarounds(ET9AWLingInfo * const pLingInfo)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & pLingInfo->pLingCmnInfo->dwFirstLdbNum;

    switch (dwLdbNum)
    {
        case ET9PLIDKorean:
            return 1;
        case ET9PLIDJapanese:
            return 0;
        default:
            if (dwLdbNum >= ET9PLIDChineseReservePoint) {
                return 1;
            }
            return 1;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                                     
 *
 *                                                                                     
 *
 *                                                            
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_ApplyImplicitLocking(ET9AWLingCmnInfo * const pLingCmnInfo)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & pLingCmnInfo->dwFirstLdbNum;

    switch (dwLdbNum)
    {
        case ET9PLIDKorean:
            return 1;
        case ET9PLIDJapanese:
            return 0;
        default:
            if (dwLdbNum >= ET9PLIDChineseReservePoint) {
                return 1;
            }
            return 1;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                                      
 *                                                   
 *
 *                                                                                     
 *
 *                                                            
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_ApplyTraceTapLocking(ET9AWLingCmnInfo * const pLingCmnInfo)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & pLingCmnInfo->dwFirstLdbNum;

    switch (dwLdbNum)
    {
        case ET9PLIDKorean:
            return 1;
        case ET9PLIDJapanese:
            return 1;
        default:
            if (dwLdbNum >= ET9PLIDChineseReservePoint) {
                return 0;
            }
            return 1;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                             
 *
 *                                                                                     
 *
 *                                                        
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_IsNonSpaceLanguage(ET9AWLingCmnInfo * const pLingCmnInfo)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & pLingCmnInfo->Private.dwCurrActiveLanguage;

    switch (dwLdbNum)
    {
        case ET9PLIDThai:
        case ET9PLIDKorean:
        case ET9PLIDJapanese:
            return 1;
        default:
            if (dwLdbNum >= ET9PLIDChineseReservePoint) {
                return 1;
            }
            return 0;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                               
 *
 *                                                                                     
 *
 *                                                        
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_IsNonGestureLanguage(ET9AWLingCmnInfo * const pLingCmnInfo)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & pLingCmnInfo->Private.dwCurrActiveLanguage;

    if (dwLdbNum >= ET9PLIDChineseReservePoint) {
        return 1;
    }

    return 0;
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                      
 *
 *                                                                                     
 *
 *                                                                 
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_IsNonBreakingSpaceLanguage(ET9AWLingCmnInfo * const pLingCmnInfo)
{
    const ET9U32 dwLdbNum  = ET9PLIDMASK & pLingCmnInfo->Private.dwCurrActiveLanguage;

    switch (dwLdbNum)
    {
        case ET9PLIDFrench:
        case ET9PLIDArmenian:
            return 1;
        default:
            return 0;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                                       
 *
 *                                              
 *
 *                                                  
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_IsDLMLanguage(const ET9U32 dwLdbNum)
{
    switch (dwLdbNum & ET9PLIDMASK)
    {
        case ET9PLIDThai:
            return 0;
        case ET9PLIDKorean:
            return 0;
        case ET9PLIDJapanese:
            return 0;
        default:
            if ((dwLdbNum & ET9PLIDMASK) >= ET9PLIDChineseReservePoint) {
                return 0;
            }
            return 1;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                                                         
 *
 *                                              
 *
 *                                                                    
 */

ET9BOOL ET9FARCALL _ET9_LanguageSpecific_IsRequireDoubleLetterGestureLanguage(const ET9U32 dwLdbNum)
{
    switch (dwLdbNum & ET9PLIDMASK)
    {
        case ET9PLIDFinnish:
        case ET9PLIDEstonian:
            return 1;
        default:
            if ((dwLdbNum & ET9PLIDMASK) >= ET9PLIDChineseReservePoint) {
                return 0;
            }
            return 0;
    }
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                     
 *
 *                                                                              
 *                                                      
 *
 *             
 */

void ET9FARCALL _ET9_PrecalculateSettings(ET9AWLingInfo * const pLingInfo,
                                          const ET9U8           bLastInputSymb)
{
    ET9AWLingCmnInfo * const    pLingCmnInfo = pLingInfo->pLingCmnInfo;
    ET9WordSymbInfo * const     pWordSymbInfo = pLingCmnInfo->Base.pWordSymbInfo;
    const ET9U8                 bNumSymbs = pWordSymbInfo->bNumSymbs;

    /* demoting limited regionality? */

    {
        ET9BOOL bDemoteLimitedRegionality = 0;

        if (bLastInputSymb < bNumSymbs) {

            ET9SymbInfo const * const pSymbInfo = &pWordSymbInfo->SymbsInfo[bLastInputSymb];

            if (!pSymbInfo->bTraceIndex) {

                const ET9KEYTYPE eSymbType = (ET9KEYTYPE)pSymbInfo->bSymbType;

                if (eSymbType == ET9KTSMARTPUNCT || eSymbType == ET9KTPUNCTUATION || eSymbType == ET9KTNUMBER) {

                    bDemoteLimitedRegionality = 1;
                }
            }
        }

        pLingCmnInfo->Private.bDemoteLimitedRegionality = bDemoteLimitedRegionality;
    }
}

/*---------------------------------------------------------------------------*/
/**
 * Check if there should be no space in front of this word.
 * This function can be called when inserting a word into the text buffer to check if there should be a space before it or not.
 *
 * @param pLingInfo                 Pointer to alphabetic information structure.
 * @param bWordIndex                Word index of base 0.
 *
 * @return Non zero for no space, otherwise zero.
 */

ET9BOOL ET9FARCALL ET9AWShouldRemoveSpaceBeforeWord(ET9AWLingInfo     * const pLingInfo,
                                                    const ET9U8               bWordIndex)
{
    if (_ET9AWSys_BasicValidityCheck(pLingInfo)) {
        return 0;
    }

    if (pLingInfo->pLingCmnInfo->Base.bSymbsInfoInvalidated) {
        return 0;
    }
    if (bWordIndex >= pLingInfo->pLingCmnInfo->Private.sWordC.pCurrC->nTotalWords) {
        return 0;
    }

    {
        ET9AWLingCmnInfo * const pLingCmnInfo = pLingInfo->pLingCmnInfo;

        ET9AWPrivWordInfo const * const pWord = &pLingCmnInfo->Private.sWordC.pCurrC->pWordList[pLingCmnInfo->Private.sWordC.pCurrC->pnWordList[bWordIndex]];

        const ET9U32 dwLdbNum  = ET9PLIDMASK & pLingCmnInfo->dwFirstLdbNum;

        const ET9BOOL bIsContextNumber = _ET9_IsNumericString(pLingCmnInfo->Private.pContextWords[0].sString, pLingCmnInfo->Private.pContextWords[0].wLen);

        /* string suffixes */

        if (pWord->Base.wWordLen > 1) {

            ET9UINT nCount;
            ET9SYMB const *psSymb;
            ET9U32 dwHashValue;

            dwHashValue = 0;
            psSymb = &pWord->Base.sWord[0];
            for (nCount = pWord->Base.wWordLen; nCount; --nCount, ++psSymb) {

                const ET9SYMB sSymb = _ET9SymToLower(*psSymb, dwLdbNum);

                dwHashValue = sSymb + (65599 * dwHashValue);
            }

            /* language independent */

            switch (dwHashValue)
            {
                case 0x16d4d4ae: /* ...      */
                case 0x8d689cf3: /* .com     */
                case 0x92c9450f: /* .net     */
                case 0x935457b6: /* .org     */
                case 0x8e59b948: /* .edu     */
                case 0x8f60db00: /* .gov     */
                case 0x8ce48c05: /* .biz     */
                    return 1;
            }

            /* language dependent */

            switch (dwLdbNum)
            {
                case ET9PLIDAlbanian:

                    switch (dwHashValue)
                    {
                        case 0x002d0b74: /* -a       */
                        case 0x5de9ae29: /* -ash     */
                        case 0x1689d200: /* -at      */
                        case 0x5decaee3: /* -ave     */
                        case 0x002d0b78: /* -e       */
                        case 0x5fe1ec2d: /* -esh     */
                        case 0x168dd2fc: /* -et      */
                        case 0x168dd2fd: /* -eu      */
                        case 0x5fe4ece3: /* -eva     */
                        case 0x5fe4ece7: /* -eve     */
                        case 0x605ffbae: /* -fsh     */
                        case 0xb34cf033: /* -fsha    */
                        case 0xb34cf03b: /* -fshi    */
                        case 0x102a1ef2: /* -fshim   */
                        case 0x102a1ef3: /* -fshin   */
                        case 0x6060fc70: /* -ftë     */
                        case 0x614e1740: /* -hej     */
                        case 0x614e1743: /* -hem     */
                        case 0x097ab9e6: /* -hemi    */
                        case 0x614e1744: /* -hen     */
                        case 0x097bba25: /* -heni    */
                        case 0x0980bb5f: /* -hesh    */
                        case 0x120d1cc2: /* -hesha   */
                        case 0x120d1cc6: /* -heshe   */
                        case 0x8e041623: /* -heshim  */
                        case 0x8e041624: /* -heshin  */
                        case 0x8e04162a: /* -heshit  */
                        case 0x614e174a: /* -het     */
                        case 0x115cb235: /* -huni    */
                        case 0x002d0b7c: /* -i       */
                        case 0x61cc26c4: /* -iem     */
                        case 0x61cc26c5: /* -ien     */
                        case 0x61cc26c9: /* -ier     */
                        case 0x61cc26cb: /* -iet     */
                        case 0x1691d3f1: /* -im      */
                        case 0x1691d3f2: /* -in      */
                        case 0x1691d3f8: /* -it      */
                        case 0x1692d424: /* -ja      */
                        case 0x1692d428: /* -je      */
                        case 0x624a364d: /* -jeu     */
                        case 0x66915d93: /* -jeva    */
                        case 0x66915d97: /* -jeve    */
                        case 0x625238bb: /* -jmë     */
                        case 0x625338fa: /* -jnë     */
                        case 0x1692d4ae: /* -jë      */
                        case 0x1693d463: /* -ka      */
                        case 0x62c444ca: /* -kam     */
                        case 0x62c444cb: /* -kan     */
                        case 0x1693d467: /* -ke      */
                        case 0x950f2c23: /* -kemi    */
                        case 0x95102c62: /* -keni    */
                        case 0x1694d4a2: /* -la      */
                        case 0xc1a3c057: /* -lash    */
                        case 0x63425452: /* -lat     */
                        case 0xc1a6c111: /* -lave    */
                        case 0x1694d4a6: /* -le      */
                        case 0x63cc7642: /* -lën     */
                        case 0x63cc7647: /* -lës     */
                        case 0x002d0b81: /* -n       */
                        case 0x1696d528: /* -ni      */
                        case 0x64467545: /* -nim     */
                        case 0x64467546: /* -nin     */
                        case 0x6446754c: /* -nit     */
                        case 0x645177f2: /* -nte     */
                        case 0x1696d5aa: /* -në      */
                        case 0x4fae8019: /* -ofsh    */
                        case 0x1c0a8688: /* -ofsha   */
                        case 0x1c0a8690: /* -ofshi   */
                        case 0x6d271ddd: /* -ofshim  */
                        case 0x6d271dde: /* -ofshin  */
                        case 0x4faf80db: /* -oftë    */
                        case 0x1697d567: /* -oi      */
                        case 0x64d187ed: /* -ova     */
                        case 0x64d187f1: /* -ove     */
                        case 0x169ad61c: /* -ra      */
                        case 0xd8cca4d1: /* -rash    */
                        case 0x6636b158: /* -rat     */
                        case 0xd8cfa58b: /* -rave    */
                        case 0x169ad620: /* -re      */
                        case 0x6647b574: /* -rra     */
                        case 0x0d4f5829: /* -rrash   */
                        case 0xe119a800: /* -rrat    */
                        case 0x0d5258e3: /* -rrave   */
                        case 0x6647b578: /* -rre     */
                        case 0xe1a3c9f0: /* -rrën    */
                        case 0xe1a3c9f5: /* -rrës    */
                        case 0x66c0d348: /* -rën     */
                        case 0x66c0d34d: /* -rës     */
                        case 0x002d0b86: /* -s       */
                        case 0x169bd662: /* -sh      */
                        case 0x66bbc27f: /* -sha     */
                        case 0x66bbc287: /* -shi     */
                        case 0x0abbdfa6: /* -shim    */
                        case 0x0abbdfa7: /* -shin    */
                        case 0x66c7c577: /* -ste     */
                        case 0x169bd6e5: /* -së      */
                        case 0x002d0b87: /* -t       */
                        case 0x169cd69e: /* -te      */
                        case 0x169cd724: /* -të      */
                        case 0x002d0b88: /* -u       */
                        case 0x6459150f: /* -uaka    */
                        case 0xc6fb2f1e: /* -uakam   */
                        case 0xc6fb2f1f: /* -uakan   */
                        case 0x64591513: /* -uake    */
                        case 0x28e6d6cf: /* -uakemi  */
                        case 0x28e7d70e: /* -uakeni  */
                        case 0x67b0dfd4: /* -uam     */
                        case 0x67b0dfd5: /* -uan     */
                        case 0x67b0dfd9: /* -uar     */
                        case 0x67b0dfdb: /* -uat     */
                        case 0x169dd6e6: /* -un      */
                        case 0x169dd6ea: /* -ur      */
                        case 0x169dd6ec: /* -ut      */
                        case 0x169ed718: /* -va      */
                        case 0x169ed71c: /* -ve      */
                        case 0x69ad1ed4: /* -yem     */
                        case 0x69ad1ed5: /* -yen     */
                        case 0x69ad1ed9: /* -yer     */
                        case 0x69ad1edb: /* -yet     */
                        case 0x002d0bfe: /* -ë       */
                        case 0x1713f3f0: /* -ën      */
                        case 0x1713f3f5: /* -ës      */
                        case 0xa1de09b3: /* -ësh     */
                        case 0x1713f3f6: /* -ët      */
                        case 0xa1e10a6d: /* -ëve     */
                        case 0x170be27e: /* .eu      */
                        case 0x1707e179: /* .al      */
                        case 0x1713e46c: /* .mk      */
                        case 0x170de2f9: /* .gr      */
                        case 0x1718e5af: /* .rs      */
                        case 0x171ae62c: /* .tr      */
                        case 0x1707e181: /* .at      */
                        case 0x1709e1f3: /* .ch      */
                        case 0x170ae235: /* .dk      */
                        case 0x170ae22f: /* .de      */
                            return 1;
                    }

                    if (bIsContextNumber) {

                        switch (dwHashValue)
                        {
                            case 0x00741cf5: /* ti       */
                            case 0x00741ced: /* ta       */
                                return 1;
                        }
                    }
                    break;

                case ET9PLIDArabic:

                    switch (dwHashValue)
                    {
                        case 0x1707e172: /* .ae      */
                        case 0x170ae244: /* .dz      */
                        case 0x1708e1b4: /* .bh      */
                        case 0x170ae234: /* .dj      */
                        case 0x1711e3f0: /* .km      */
                        case 0x170be270: /* .eg      */
                        case 0x170be27b: /* .er      */
                        case 0x170fe376: /* .iq      */
                        case 0x170fe371: /* .il      */
                        case 0x1710e3b3: /* .jo      */
                        case 0x1711e3fa: /* .kw      */
                        case 0x1712e424: /* .lb      */
                        case 0x1712e43b: /* .ly      */
                        case 0x1713e473: /* .mr      */
                        case 0x1713e462: /* .ma      */
                        case 0x1715e4ec: /* .om      */
                        case 0x1716e531: /* .ps      */
                        case 0x1717e55e: /* .qa      */
                        case 0x1719e5dc: /* .sa      */
                        case 0x1719e5ea: /* .so      */
                        case 0x1719e5df: /* .sd      */
                        case 0x1719e5f4: /* .sy      */
                        case 0x171ae61e: /* .td      */
                        case 0x171ae628: /* .tn      */
                        case 0x171fe75a: /* .ye      */
                            return 1;
                    }
                    break;

                case ET9PLIDAzerbaijani:

                    switch (dwHashValue)
                    {
                        case 0x1707e187: /* .az      */
                        case 0x1709e204: /* .cy      */
                        case 0x170de2ec: /* .ge      */
                        case 0x170fe377: /* .ir      */
                        case 0x1718e5b1: /* .ru      */
                        case 0x171ae62c: /* .tr      */
                            return 1;
                    }
                    break;

                case ET9PLIDBasque:

                    switch (dwHashValue)
                    {
                        case 0x5fe2ec65: /* -eta     */
                        case 0x002d0b7e: /* -k       */
                        case 0x170be27c: /* .es      */
                        case 0x170ce2ba: /* .fr      */
                        case 0x170be27e: /* .eu      */
                            return 1;
                    }

                    if (bIsContextNumber) {

                        switch (dwHashValue)
                        {
                            case 0x00000061: /* a        */
                            case 0x0061184d: /* an       */
                            case 0xd99d191a: /* aren     */
                            case 0x321d3632: /* ean      */
                            case 0x322738a9: /* eko      */
                            case 0x75a48c73: /* ekoak    */
                            case 0x94b07a1c: /* etan     */
                            case 0x118e0e41: /* etara    */
                            case 0x613aa364: /* etatik   */
                            case 0x006b1ac4: /* ko       */
                            case 0x351f969d: /* koa      */
                            case 0x0000006e: /* n        */
                            case 0x00721c6f: /* ra       */
                            case 0x388800bb: /* ren      */
                            case 0x398820b6: /* tik      */
                                return 1;
                        }
                    }
                    break;

                case ET9PLIDBelarusian:

                    switch (dwHashValue)
                    {
                        case 0x1718e5b1: /* .ru      */
                        case 0x1708e1c5: /* .by      */
                        case 0x1711e3fd: /* .kz      */
                        case 0x1711e3ea: /* .kg      */
                        case 0x1713e465: /* .md      */
                            return 1;
                    }

                    if (bIsContextNumber) {

                        switch (dwHashValue)
                        {
                            case 0x002d0f4c: /* -й       */
                            case 0x002d0f5e: /* -ы       */
                                return 1;
                        }
                    }
                    break;

                case ET9PLIDBulgarian:

                    switch (dwHashValue)
                    {
                        case 0x1708e1b3: /* .bg      */
                        case 0x170be27e: /* .eu      */
                        case 0x1718e5b1: /* .ru      */
                        case 0x1713e46c: /* .mk      */
                        case 0x1718e5af: /* .rs      */
                        case 0x1708e1ad: /* .ba      */
                        case 0x1713e470: /* .mo      */
                            return 1;
                    }
                    break;

                case ET9PLIDCatalan:

                    switch (dwHashValue)
                    {
                        case 0x170be27c: /* .es      */
                        case 0x1707e171: /* .ad      */
                        case 0x00270a07: /* 'n       */
                        case 0x00270a0c: /* 's       */
                        case 0x00270a0d: /* 't       */
                        case 0x13a2782c: /* 'ns      */
                        case 0x00270a06: /* 'm       */
                        case 0x00270a05: /* 'l       */
                        case 0x13a077ae: /* 'ls      */
                        case 0x1694d4a2: /* -la      */
                        case 0x6346554d: /* -les     */
                        case 0x169bd65f: /* -se      */
                        case 0x635057c3: /* -los     */
                        case 0x644c76c5: /* -nos     */
                        case 0x1690d3ae: /* -hi      */
                        case 0x1690d3b4: /* -ho      */
                        case 0x169cd69e: /* -te      */
                        case 0x1694d4b0: /* -lo      */
                        case 0x1695d4e5: /* -me      */
                        case 0x1694d4aa: /* -li      */
                        case 0x683cf2cd: /* -vos     */
                        case 0x168dd2f6: /* -en      */
                        case 0x1696d524: /* -ne      */
                        case 0x169dd6eb: /* -us      */
                        case 0x168dd2f4: /* -el      */
                        case 0x5fdaea7f: /* -els     */
                        case 0x168dd2f5: /* -em      */
                        case 0x5fdceafd: /* -ens     */
                        case 0x1691d3b1: /* -i-      */
                            return 1;
                    }
                    break;

                case ET9PLIDCroatian:

                    switch (dwHashValue)
                    {
                        case 0x00270a08: /* 'o       */
                        case 0x170ee338: /* .hr      */
                        case 0x1708e1ad: /* .ba      */
                        case 0x1713e466: /* .me      */
                        case 0x1707e181: /* .at      */
                        case 0x1718e5ab: /* .ro      */
                        case 0x170fe379: /* .it      */
                        case 0x1718e5af: /* .rs      */
                            return 1;
                    }
                    break;

                case ET9PLIDCzech:

                    switch (dwHashValue)
                    {
                        case 0x1709e205: /* .cz      */
                        case 0x170be27e: /* .eu      */
                        case 0x1694d4aa: /* -li      */
                            return 1;
                    }
                    break;

                case ET9PLIDDanish:

                    switch (dwHashValue)
                    {
                        case 0x00270a0c: /* 's       */
                        case 0x139975f4: /* 'er      */
                        case 0x48b8077f: /* 'ers     */
                        case 0x139975f6: /* 'et      */
                        case 0x48ba07fd: /* 'ets     */
                        case 0x139975f0: /* 'en      */
                        case 0x48b40683: /* 'ens     */
                        case 0xecc3d76b: /* 'erne    */
                        case 0x1b9d03c8: /* 'ernes   */
                        case 0xecbad53d: /* 'eren    */
                        case 0x17377a76: /* 'erens   */
                        case 0x13a87998: /* 'te      */
                        case 0x170ae235: /* .dk      */
                        case 0x170be27e: /* .eu      */
                        case 0x8055737c: /* .info    */
                        case 0x170fe379: /* .it      */
                        case 0x1714e4b5: /* .nu      */
                        case 0x171ae630: /* .tv      */
                        case 0x170ce2b7: /* .fo      */
                            return 1;
                    }
                    break;

                case ET9PLIDDutch:

                    switch (dwHashValue)
                    {
                        case 0x00270a0c: /* 's       */
                        case 0x5012ee08: /* 'tje     */
                        case 0x1714e4ac: /* .nl      */
                        case 0x1707e184: /* .aw      */
                        case 0x1719e5ed: /* .sr      */
                        case 0x1708e1b1: /* .be      */
                        case 0x1707e17b: /* .an      */
                        case 0x170be27e: /* .eu      */
                            return 1;
                    }

                    if (bIsContextNumber) {

                        switch (dwHashValue)
                        {
                            case 0x00641901: /* de       */
                            case 0x391513e4: /* ste      */
                                return 1;
                        }
                    }
                    break;

                case ET9PLIDEnglish:

                    switch (dwHashValue)
                    {
                        case 0x00270a0c: /* 's       */
                        case 0x00270a06: /* 'm       */
                        case 0x13a077a7: /* 'll      */
                        case 0x002709fd: /* 'd       */
                        case 0x13aa7a16: /* 've      */
                        case 0x13a6791a: /* 're      */
                        case 0x3651b37b: /* n't      */ /* likely not generated by LDB or LM */
                        case 0x171be664: /* .uk      */
                        case 0x1709e1ec: /* .ca      */
                        case 0x170be27e: /* .eu      */
                        case 0x170de2f9: /* .gr      */
                        case 0x1714e4ba: /* .nz      */
                        case 0x1707e182: /* .au      */
                        case 0x1707e174: /* .ag      */
                        case 0x1708e1ae: /* .bb      */
                        case 0x1708e1c6: /* .bz      */
                        case 0x170ae237: /* .dm      */
                        case 0x170de2eb: /* .gd      */
                        case 0x170de300: /* .gy      */
                        case 0x1710e3b1: /* .jm      */
                        case 0x1711e3f1: /* .kn      */
                        case 0x1712e425: /* .lc      */
                        case 0x171ce69b: /* .vc      */
                        case 0x171ae62e: /* .tt      */
                        case 0x171be66c: /* .us      */
                        case 0x1709e1fa: /* .co      */
                        case 0x54ca0179: /* .html    */
                        case 0x97bde209: /* .xml     */
                        case 0x8d6c9df5: /* .css     */
                        case 0x95d0a6c2: /* .txt     */
                        case 0x8fe3ebb3: /* .htm     */
                        case 0x905af975: /* .img     */
                        case 0x93c463c4: /* .pdf     */
                        case 0x92563802: /* .mp3     */
                        case 0x92563803: /* .mp4     */
                        case 0x97bce1d1: /* .xls     */
                        case 0x8de3abb6: /* .dll     */
                        case 0x8de6ac6a: /* .doc     */
                        case 0x7daa1e23: /* .tiff    */
                        case 0x8f5ad976: /* .gif     */
                        case 0x90dc09b3: /* .jpg     */
                        case 0xafd762f6: /* .jpeg    */
                        case 0x93ce663b: /* .png     */
                            return 1;
                    }

                    if (bIsContextNumber) {

                        switch (dwHashValue)
                        {
                            case 0x00731cc1: /* st       */
                            case 0x391513f2: /* sts      */
                            case 0x006e1b76: /* nd       */
                            case 0x368ec27d: /* nds      */
                            case 0x00721c72: /* rd       */
                            case 0x38870081: /* rds      */
                            case 0x00741cf4: /* th       */
                            case 0x3987207f: /* ths      */
                                return 1;
                        }
                    }
                    break;

                case ET9PLIDEstonian:

                    switch (dwHashValue)
                    {
                        case 0x002709fd: /* 'd       */
                        case 0x139875a8: /* 'de      */
                        case 0x13a87998: /* 'te      */
                        case 0x139d76e2: /* 'id      */
                        case 0x4f93de47: /* 'sid     */
                        case 0x002709fe: /* 'e       */
                        case 0x00270a02: /* 'i       */
                        case 0x00270a0e: /* 'u       */
                        case 0x4f9de0be: /* 'sse     */
                        case 0x00270a0c: /* 's       */
                        case 0x13a77968: /* 'st      */
                        case 0x13a077a0: /* 'le      */
                        case 0x00270a05: /* 'l       */
                        case 0x13a077af: /* 'lt      */
                        case 0x139f776f: /* 'ks      */
                        case 0x13a27822: /* 'ni      */
                        case 0x13a2781a: /* 'na      */
                        case 0x13a87994: /* 'ta      */
                        case 0x139b7661: /* 'ga      */
                        case 0x170be26e: /* .ee      */
                        case 0x170be27e: /* .eu      */
                        case 0x170ce2b1: /* .fi      */
                        case 0x1712e438: /* .lv      */
                        case 0x1712e436: /* .lt      */
                        case 0x1718e5b1: /* .ru      */
                            return 1;
                    }
                    break;

                case ET9PLIDFarsi:

                    switch (dwHashValue)
                    {
                        case 0x170fe377: /* .ir      */
                        case 0x1707e173: /* .af      */
                        case 0x171ae624: /* .tj      */
                            return 1;
                    }
                    break;

                case ET9PLIDFinnish:

                    switch (dwHashValue)
                    {
                        case 0x003a0eb4: /* :n       */
                        case 0x003a0ea7: /* :a       */
                        case 0x1cf09b7a: /* :aa      */
                        case 0x1d73bc3a: /* :ää      */
                        case 0xfbb552b4: /* :ään     */
                        case 0xbcac8274: /* :een     */
                        case 0xbe22affb: /* :han     */
                        case 0xbe26b0f7: /* :hen     */
                        case 0xbe30b36d: /* :hon     */
                        case 0xbe3ab5e3: /* :hyn     */
                        case 0xbea8c174: /* :iin     */
                        case 0x1cf89d7f: /* :in      */
                        case 0x1cf89d85: /* :it      */
                        case 0xbeb3c49f: /* :itä     */
                        case 0x1cf99db1: /* :ja      */
                        case 0xbfaee2e7: /* :ksi     */
                        case 0xc025f0a7: /* :lla     */
                        case 0xc025f0ab: /* :lle     */
                        case 0xc025f12a: /* :llä     */
                        case 0xc02df29f: /* :lta     */
                        case 0xc02df322: /* :ltä     */
                        case 0x1cfd9f30: /* :nä      */
                        case 0x1cfe9ef9: /* :on      */
                        case 0xc3915b82: /* :sen     */
                        case 0xc39f5ee7: /* :ssa     */
                        case 0xc39f5f6a: /* :ssä     */
                        case 0xc3a05f26: /* :sta     */
                        case 0xc3a05fa9: /* :stä     */
                        case 0x003a0eba: /* :t       */
                        case 0x1d03a027: /* :ta      */
                        case 0x1d03a0aa: /* :tä      */
                        case 0x170ce2b1: /* .fi      */
                        case 0x170be27e: /* .eu      */
                        case 0x1714e4af: /* .no      */
                        case 0x1719e5e0: /* .se      */
                        case 0x170ae235: /* .dk      */
                        case 0x170be26e: /* .ee      */
                            return 1;
                    }
                    break;

                case ET9PLIDFrench:

                    switch (dwHashValue)
                    {
                        case 0x1692d428: /* -je      */
                        case 0x25983b6c: /* -nous    */
                        case 0x169cd6ae: /* -tu      */
                        case 0x99cec164: /* -vous    */
                        case 0x1691d3f0: /* -il      */
                        case 0x61d32883: /* -ils     */
                        case 0x8157b3ed: /* -elle    */
                        case 0x888247c6: /* -elles   */
                        case 0x1697d56c: /* -on      */
                        case 0x5fe3ecbb: /* -eux     */
                        case 0x1c351da9: /* -t-il    */
                        case 0x0ebb4d0a: /* -t-ils   */
                        case 0x32ffb126: /* -t-elle  */
                        case 0x3e1298cd: /* -t-elles */
                        case 0x1c3b1f25: /* -t-on    */
                        case 0x193cbfa9: /* -t'en    */
                        case 0x168bd26f: /* -ce      */
                        case 0x1694d521: /* -là      */
                        case 0x168bd273: /* -ci      */
                        case 0x1708f0fa: /* -à-      */
                        case 0x170ce2ba: /* .fr      */
                        case 0xa9ea96c3: /* .gouv.fr */
                        case 0x1709e1ec: /* .ca      */
                        case 0x171be66c: /* .us      */
                        case 0x1708e1b6: /* .bj      */
                        case 0x1708e1b2: /* .bf      */
                        case 0x1709e1f8: /* .cm      */
                        case 0x1708e1b1: /* .be      */
                        case 0x1709e1f4: /* .ci      */
                        case 0x1709e1f2: /* .cg      */
                        case 0x170ee33a: /* .ht      */
                        case 0x1713e468: /* .mg      */
                        case 0x1712e437: /* .lu      */
                        case 0x170be27e: /* .eu      */
                        case 0x1708e1b5: /* .bi      */
                        case 0x1713e46d: /* .ml      */
                        case 0x1711e3f0: /* .km      */
                        case 0x170de2e8: /* .ga      */
                        case 0x170de2f5: /* .gn      */
                        case 0x1713e464: /* .mc      */
                        case 0x1714e4a5: /* .ne      */
                        case 0x1718e5b3: /* .rw      */
                        case 0x1719e5e9: /* .sn      */
                        case 0x1719e5de: /* .sc      */
                        case 0x1709e1f3: /* .ch      */
                        case 0x171ae621: /* .tg      */
                        case 0x171ce6ad: /* .vu      */
                            return 1;
                    }

                    if (bIsContextNumber) {

                        switch (dwHashValue)
                        {
                            case 0x0065194d: /* er       */
                            case 0x72b0295b: /* ère      */
                            case 0x00641901: /* de       */
                            case 0x368ec26f: /* nde      */
                            case 0x72ab2820: /* ème      */
                                return 1;
                        }
                    }
                    break;

                case ET9PLIDGalician:

                    switch (dwHashValue)
                    {
                        case 0x1708e1be: /* .br      */
                        case 0x1707e17c: /* .ao      */
                        case 0x170be27c: /* .es      */
                        case 0x1716e532: /* .pt      */
                            return 1;
                    }
                    break;

                case ET9PLIDGeorgian:

                    switch (dwHashValue)
                    {
                        case 0x170de2ec: /* .ge      */
                        case 0x1718e5b1: /* .ru      */
                        case 0x1707e187: /* .az      */
                        case 0x1707e17a: /* .am      */
                        case 0x171ae62c: /* .tr      */
                        case 0x26fcedb0: /* -ად      */
                        case 0x88c8c679: /* -ამდე    */
                        case 0x86e7ad71: /* -გან     */
                        case 0x002d1be6: /* -დ       */
                        case 0x8765bcf2: /* -დან     */
                        case 0x002d1be7: /* -ე       */
                        case 0x3df46dad: /* -ებად    */
                        case 0x87e4ccae: /* -ები     */
                        case 0x3dfc6fa9: /* -ებით    */
                        case 0x3dfc6fb3: /* -ების    */
                        case 0x3dff705f: /* -ებმა    */
                        case 0x87e4ccb3: /* -ებო     */
                        case 0x87e4ccb7: /* -ებს     */
                        case 0x2700eeac: /* -ედ      */
                        case 0x2700eeae: /* -ევ      */
                        case 0x4262f936: /* -ელად    */
                        case 0xb3011633: /* -ელებად  */
                        case 0x5187a2a8: /* -ელები   */
                        case 0xb309182f: /* -ელებით  */
                        case 0xb3091839: /* -ელების  */
                        case 0xb30c18e5: /* -ელებმა  */
                        case 0x5187a2ad: /* -ელებო   */
                        case 0x5187a2b1: /* -ელებს   */
                        case 0x87edcee5: /* -ელი     */
                        case 0x426afb32: /* -ელით    */
                        case 0x426afb3c: /* -ელის    */
                        case 0x426dfbe8: /* -ელმა    */
                        case 0x87edceea: /* -ელო     */
                        case 0x87edceee: /* -ელს     */
                        case 0x2700eeb4: /* -ემ      */
                        case 0x2700eeba: /* -ეს      */
                        case 0x87f4d09e: /* -ესი     */
                        case 0x002d1be8: /* -ვ       */
                        case 0x8869dde7: /* -ვით     */
                        case 0x2702ef2b: /* -ზე      */
                        case 0x88e3ec65: /* -ზეა     */
                        case 0x88e3ec7f: /* -ზეც     */
                        case 0x895dfaf6: /* -თან     */
                        case 0xc207fb99: /* -თანავე  */
                        case 0xcb891ff4: /* -თვის    */
                        case 0x2703ef6e: /* -თი      */
                        case 0x002d1beb: /* -ი       */
                        case 0x2704efa5: /* -ია      */
                        case 0x89dc0a77: /* -იან     */
                        case 0x93e472fa: /* -იანად   */
                        case 0x49d9edf7: /* -იანებად */
                        case 0xda2899e4: /* -იანები  */
                        case 0x49e1eff3: /* -იანებით */
                        case 0x49e1effd: /* -იანების */
                        case 0x49e4f0a9: /* -იანებმა */
                        case 0xda2899e9: /* -იანებო  */
                        case 0xda2899ed: /* -იანებს  */
                        case 0x49f1f3e4: /* -იანებში */
                        case 0xf79da421: /* -იანი    */
                        case 0x93ec74f6: /* -იანით   */
                        case 0x93ec7500: /* -იანის   */
                        case 0x93ef75ac: /* -იანმა   */
                        case 0xf79da426: /* -იანო    */
                        case 0xf79da42a: /* -იანს    */
                        case 0xf90bcfb4: /* -იდან    */
                        case 0x2704efac: /* -ით      */
                        case 0x2704efb6: /* -ის      */
                        case 0x89ed0e9a: /* -ისა     */
                        case 0x2e1512f6: /* -ისადმი  */
                        case 0xa5ebb4a8: /* -ისგან   */
                        case 0xd4b00da2: /* -ისთანავე */
                        case 0x74bde67d: /* -ისთვის  */
                        case 0xa962222b: /* -ისკენ   */
                        case 0x2704efbf: /* -იც      */
                        case 0x8a5e1af4: /* -კენ     */
                        case 0x2706f02b: /* -ლი      */
                        case 0x002d1bee: /* -მ       */
                        case 0x2707f062: /* -მა      */
                        case 0x8b563908: /* -მაც     */
                        case 0x8b5939af: /* -მდე     */
                        case 0x84a843ee: /* -მდის    */
                        case 0x002d1bf0: /* -ო       */
                        case 0x002d1bf4: /* -ს       */
                        case 0x270df1dc: /* -სა      */
                        case 0xf2d04134: /* -სადმი   */
                        case 0x8e4a960e: /* -საც     */
                        case 0x9dc1646f: /* -სთან    */
                        case 0x270df1e4: /* -სი      */
                        case 0x8f56b8ed: /* -ურთ     */
                        case 0x8f56b8ee: /* -ური     */
                        case 0x2714f39d: /* -ში      */
                        case 0x91c50473: /* -შია     */
                        case 0x91c5048d: /* -შიც     */
                        case 0x002d1bfd: /* -ც       */
                        case 0x17638aa4: /* -მეთქი   */
                        case 0x89730022: /* -თქო     */
                            return 1;
                    }
                    break;

                case ET9PLIDGerman:

                    switch (dwHashValue)
                    {
                        case 0x00270a06: /* 'm       */
                        case 0x00270a07: /* 'n       */
                        case 0x13a2781e: /* 'ne      */
                        case 0x4d198fcf: /* 'nem     */
                        case 0x4d198fd0: /* 'nen     */
                        case 0x4d198fd4: /* 'ner     */
                        case 0x00270a0c: /* 's       */
                        case 0x170ae22f: /* .de      */
                        case 0x1707e182: /* .au      */
                        case 0x1709e1f3: /* .ch      */
                        case 0x1708e1b1: /* .be      */
                        case 0x170fe379: /* .it      */
                        case 0x1712e42b: /* .li      */
                        case 0x1712e437: /* .lu      */
                        case 0x170be27e: /* .eu      */
                            return 1;
                    }
                    break;

                case ET9PLIDGreek:

                    switch (dwHashValue)
                    {
                        case 0x170de2f9: /* .gr      */
                        case 0x1709e204: /* .cy      */
                        case 0x170be27e: /* .eu      */
                            return 1;
                    }

                    if (bIsContextNumber) {

                        switch (dwHashValue)
                        {
                            case 0x03bfefc3: /* ος       */
                                return 1;
                        }
                    }
                    break;

                case ET9PLIDHindi:

                    switch (dwHashValue)
                    {
                        case 0x170fe373: /* .in      */
                            return 1;
                    }
                    break;

                case ET9PLIDHungarian:

                    switch (dwHashValue)
                    {
                        case 0x170ee33b: /* .hu      */
                        case 0x170be27e: /* .eu      */
                        case 0x1709e205: /* .cz      */
                        case 0x170ae22f: /* .de      */
                        case 0x1719e5e6: /* .sk      */
                        case 0x1719e5e4: /* .si      */
                        case 0x1707e181: /* .at      */
                        case 0x1718e5ab: /* .ro      */
                        case 0x1718e5af: /* .rs      */
                        case 0x170ee338: /* .hr      */
                            return 1;
                    }
                    break;

                case ET9PLIDIcelandic:

                    switch (dwHashValue)
                    {
                        case 0x170fe378: /* .is      */
                        case 0x170be27e: /* .eu      */
                            return 1;
                    }
                    break;

                case ET9PLIDIndonesian:

                    switch (dwHashValue)
                    {
                        case 0x83e69cef: /* .co.id   */
                        case 0x3e8f8338: /* .or.id   */
                        case 0xfb30999a: /* .net.id  */
                        case 0x939818f3: /* .go.id   */
                        case 0x807f2e67: /* .mil.id  */
                        case 0xcdbc15f9: /* .ac.id   */
                        case 0xb3e3f8df: /* .sch.id  */
                        case 0x7d455763: /* .web.id  */
                        case 0x170fe369: /* .id      */
                            return 1;
                    }
                    break;

                case ET9PLIDItalian:

                    switch (dwHashValue)
                    {
                        case 0x170fe379: /* .it      */
                        case 0x1709e1f3: /* .ch      */
                        case 0x170ee338: /* .hr      */
                        case 0x1719e5e4: /* .si      */
                        case 0x1713e475: /* .mt      */
                        case 0x170be27e: /* .eu      */
                            return 1;
                    }
                    break;

                case ET9PLIDLatvian:

                    switch (dwHashValue)
                    {
                        case 0x170be27e: /* .eu      */
                        case 0x1712e438: /* .lv      */
                        case 0x1712e436: /* .lt      */
                        case 0x170be26e: /* .ee      */
                        case 0x1718e5b1: /* .ru      */
                        case 0x1708e1c5: /* .by      */
                            return 1;
                    }
                    break;

                case ET9PLIDLithuanian:

                    switch (dwHashValue)
                    {
                        case 0x170be27e: /* .eu      */
                        case 0x1712e436: /* .lt      */
                        case 0x1712e438: /* .lv      */
                        case 0x170be26e: /* .ee      */
                        case 0x1718e5b1: /* .ru      */
                        case 0x1708e1c5: /* .by      */
                        case 0x1716e52a: /* .pl      */
                            return 1;
                    }

                    if (bIsContextNumber) {

                        switch (dwHashValue)
                        {
                            case 0x002d0b74: /* -a       */
                            case 0x1689d1f5: /* -ai      */
                            case 0x5ddfabbe: /* -ais     */
                            case 0xb13bc640: /* -aisiais */
                            case 0x1689d1f9: /* -am      */
                            case 0x5de3acac: /* -ame     */
                            case 0x1689d1ff: /* -as      */
                            case 0xcaabdcc9: /* -asis    */
                            case 0x002d0b7c: /* -i       */
                            case 0x61c825c4: /* -iai     */
                            case 0x61c825c8: /* -iam     */
                            case 0x61c825ce: /* -ias     */
                            case 0x37fe89e8: /* -ieji    */
                            case 0x38018aaf: /* -iems    */
                            case 0x0bddf44c: /* -iesiems */
                            case 0x1691d3f3: /* -io      */
                            case 0x244a4684: /* -iomis   */
                            case 0x3cee25b9: /* -ioms    */
                            case 0x61d62940: /* -ios     */
                            case 0x3cf42725: /* -iose    */
                            case 0x61dc2aba: /* -ius     */
                            case 0x1691d4f7: /* -ių      */
                            case 0x002d0b82: /* -o       */
                            case 0x64c584fd: /* -oje     */
                            case 0x64c58501: /* -oji     */
                            case 0x64c58507: /* -ojo     */
                            case 0xd42f8c02: /* -ojoje   */
                            case 0x5316ea35: /* -omis    */
                            case 0x64c885c8: /* -oms     */
                            case 0x1697d571: /* -os      */
                            case 0x64ce8734: /* -ose     */
                            case 0xbb268640: /* -osiomis */
                            case 0x125a36fd: /* -osioms  */
                            case 0x73fd86fc: /* -osios   */
                            case 0x12603869: /* -osiose  */
                            case 0x002d0b88: /* -u       */
                            case 0x6b3cedf2: /* -uoju    */
                            case 0x6b45f019: /* -uose    */
                            case 0xcbd5f009: /* -uosiuose */
                            case 0x560acedb: /* -uosius  */
                            case 0x169dd6eb: /* -us      */
                            case 0x002d0c18: /* -ą       */
                            case 0xaea29a8f: /* -ąja     */
                            case 0x9493099a: /* -ąjai    */
                            case 0x9493099e: /* -ąjam    */
                            case 0x99cd5e47: /* -ąjame   */
                            case 0xaea29b33: /* -ąją     */
                            case 0xaea29b5d: /* -ąjį     */
                            case 0x406f2e20: /* -ąsias   */
                            case 0x002d0c86: /* -ų       */
                            case 0xe4cd450f: /* -ųjų     */
                            case 0x662a0799: /* -metis   */
                            case 0xb1814bae: /* -mečio   */
                            case 0xfa85a1b5: /* -mečiui  */
                            case 0xf223d020: /* -metį    */
                            case 0xb1814bb4: /* -mečiu   */
                            case 0x33c8d4e5: /* -metyje  */
                            case 0xf223cf5a: /* -meti    */
                            case 0xfa719cc9: /* -mečiai  */
                            case 0xb1814cb2: /* -mečių   */
                            case 0x3ec296e6: /* -mečiams */
                            case 0xfa85a1bf: /* -mečius  */
                            case 0x3ebe95ea: /* -mečiais */
                            case 0xac4d90ed: /* -mečiuose */
                            case 0xe2a37ffa: /* irpan.   */
                            case 0x83a7adbd: /* irt.t.   */
                                return 1;
                        }
                    }
                    break;

                case ET9PLIDMalay:

                    switch (dwHashValue)
                    {
                        case 0x1708e1ba: /* .bn      */
                        case 0x170fe369: /* .id      */
                        case 0x1713e47a: /* .my      */
                        case 0x1719e5e2: /* .sg      */
                        case 0x171ae626: /* .tl      */
                            return 1;
                    }
                    break;

                case ET9PLIDNorwegian:

                    switch (dwHashValue)
                    {
                        case 0x1714e4af: /* .no      */
                        case 0x170be27e: /* .eu      */
                        case 0x00270a07: /* 'n       */
                        case 0xecc3d76b: /* 'erne    */
                        case 0x00270a0d: /* 't       */
                            return 1;
                    }
                    break;

                case ET9PLIDPolish:

                    switch (dwHashValue)
                    {
                        case 0x1716e52a: /* .pl      */
                        case 0x170be27e: /* .eu      */
                            return 1;
                    }

                    if (bIsContextNumber) {

                        switch (dwHashValue)
                        {
                            case 0x169cd69e: /* -te      */
                            case 0x419bb677: /* -tych    */
                                return 1;
                        }
                    }
                    break;

                case ET9PLIDRomanian:

                    switch (dwHashValue)
                    {
                        case 0x002d0b74: /* -a       */
                        case 0x002d0b82: /* -o       */
                        case 0x169dd6e4: /* -ul      */
                        case 0x002d0b7f: /* -l       */
                        case 0x002d0b7c: /* -i       */
                        case 0x69cdc218: /* -ului    */
                        case 0x169bd65f: /* -se      */
                        case 0x1696d524: /* -ne      */
                        case 0x1695d583: /* -mă      */
                        case 0x002d0b81: /* -n       */
                        case 0x1694d4a6: /* -le      */
                        case 0x1695d4e9: /* -mi      */
                        case 0x169cd69e: /* -te      */
                        case 0x002d0b86: /* -s       */
                        case 0x002d0b78: /* -e       */
                        case 0x169dd6e6: /* -un      */
                        case 0x178c1173: /* -ţi      */
                        case 0x169ed7ba: /* -vă      */
                        case 0x1689d1fe: /* -ar      */
                        case 0x5de8ade7: /* -are     */
                        case 0x1718e5ab: /* .ro      */
                        case 0x1713e465: /* .md      */
                        case 0x1718e5af: /* .rs      */
                        case 0x170be27e: /* .eu      */
                            return 1;
                    }
                    break;

                case ET9PLIDRussian:

                    switch (dwHashValue)
                    {
                        case 0x1718e5b1: /* .ru      */
                        case 0x1708e1c5: /* .by      */
                        case 0x1711e3fd: /* .kz      */
                        case 0x1711e3ea: /* .kg      */
                        case 0x1713e465: /* .md      */
                            return 1;
                    }

                    if (bIsContextNumber) {

                        switch (dwHashValue)
                        {
                            case 0x002d0f4c: /* -й       */
                                return 1;
                        }
                    }
                    break;

                case ET9PLIDSerbian:

                    switch (dwHashValue)
                    {
                        case 0x1713e466: /* .me      */
                        case 0x1713e465: /* .md      */
                        case 0x1718e5af: /* .rs      */
                        case 0x1711e3f2: /* .ko      */
                            return 1;
                    }
                    break;

                case ET9PLIDSerbianCyrillic:

                    switch (dwHashValue)
                    {
                        case 0x1713e466: /* .me      */
                        case 0x1713e465: /* .md      */
                        case 0x1718e5af: /* .rs      */
                        case 0x1711e3f2: /* .ko      */
                        case 0x1718e5b1: /* .ru      */
                            return 1;
                    }
                    break;

                case ET9PLIDSlovak:

                    switch (dwHashValue)
                    {
                        case 0x1719e5e6: /* .sk      */
                        case 0x170be27e: /* .eu      */
                        case 0x1718e5af: /* .rs      */
                            return 1;
                    }
                    break;

                case ET9PLIDSlovenian:

                    switch (dwHashValue)
                    {
                        case 0x1719e5e4: /* .si      */
                        case 0x170be27e: /* .eu      */
                            return 1;
                    }
                    break;

                case ET9PLIDSpanish:

                    switch (dwHashValue)
                    {
                        case 0x1716e530: /* .pr      */
                        case 0x1707e17f: /* .ar      */
                        case 0x1709e1fd: /* .cr      */
                        case 0x1709e1fa: /* .co      */
                        case 0x1709e200: /* .cu      */
                        case 0x170ae239: /* .do      */
                        case 0x170be26c: /* .ec      */
                        case 0x170be27c: /* .es      */
                        case 0x170de2fb: /* .gt      */
                        case 0x1713e479: /* .mx      */
                        case 0x1716e51f: /* .pa      */
                        case 0x1719e5f1: /* .sv      */
                        case 0x171be672: /* .uy      */
                        case 0x1716e537: /* .py      */
                        case 0x171ce69d: /* .ve      */
                        case 0x1708e1bb: /* .bo      */
                        case 0x1716e523: /* .pe      */
                        case 0x170ee334: /* .hn      */
                        case 0x1709e1f7: /* .cl      */
                        case 0x1714e4a9: /* .ni      */
                            return 1;
                    }
                    break;

                case ET9PLIDSwedish:

                    switch (dwHashValue)
                    {
                        case 0x003a0eb4: /* :n       */
                        case 0x003a0eb9: /* :s       */
                        case 0x3d33a17e: /* :arna    */
                        case 0xc8930bf0: /* :orna    */
                        case 0x1719e5e0: /* .se      */
                        case 0x1714e4af: /* .no      */
                        case 0x170ce2b1: /* .fi      */
                            return 1;
                    }

                    if (bIsContextNumber) {

                        switch (dwHashValue)
                        {
                            case 0x003a0ea7: /* :a       */
                            case 0x003a0eab: /* :e       */
                                return 1;
                        }
                    }
                    break;

                case ET9PLIDTagalog:

                    switch (dwHashValue)
                    {
                        case 0x1716e526: /* .ph      */
                            return 1;
                    }
                    break;

                case ET9PLIDTamil:

                    switch (dwHashValue)
                    {
                        case 0x170fe373: /* .in      */
                        case 0x1712e42d: /* .lk      */
                            return 1;
                    }
                    break;

                case ET9PLIDTurkish:

                    switch (dwHashValue)
                    {
                        case 0x171ae62c: /* .tr      */
                        case 0x1709e204: /* .cy      */
                        case 0x002709fa: /* 'a       */
                        case 0x002709fe: /* 'e       */
                        case 0x00270aca: /* 'ı       */
                        case 0x00270a02: /* 'i       */
                        case 0x00270a0e: /* 'u       */
                        case 0x00270a95: /* 'ü       */
                        case 0x139875a4: /* 'da      */
                        case 0x139875a8: /* 'de      */
                        case 0x139875ac: /* 'di      */
                        case 0xb5dafe62: /* 'daki    */
                        case 0xb7d33c66: /* 'deki    */
                        case 0x4828f3ca: /* 'dan     */
                        case 0x482cf4c6: /* 'den     */
                        case 0x1465a824: /* 'ın      */
                        case 0x139d76ec: /* 'in      */
                        case 0x13a0779c: /* 'la      */
                        case 0x13a077a0: /* 'le      */
                        case 0x13a077a4: /* 'li      */
                        case 0x13a2781a: /* 'na      */
                        case 0x13a2781e: /* 'ne      */
                        case 0x13a278ea: /* 'nı      */
                        case 0x13a27822: /* 'ni      */
                        case 0x13a2782e: /* 'nu      */
                        case 0x13a278b5: /* 'nü      */
                        case 0x4d188f84: /* 'nda     */
                        case 0x4d188f88: /* 'nde     */
                        case 0xef246646: /* 'ndeki   */
                        case 0x888f51ea: /* 'ndan    */
                        case 0x889352e6: /* 'nden    */
                        case 0x4de5c204: /* 'nın     */
                        case 0x4d1d90cc: /* 'nin     */
                        case 0x4d2993c0: /* 'nun     */
                        case 0x4db0b4f9: /* 'nün     */
                        case 0x13a87998: /* 'te      */
                        case 0x9e480a52: /* 'taki    */
                        case 0x5009ebda: /* 'tan     */
                        case 0x500decd6: /* 'ten     */
                        case 0x00270a06: /* 'm       */
                        case 0x00270a0c: /* 's       */
                        case 0x13a979e0: /* 'un      */
                        case 0x14309b19: /* 'ün      */
                        case 0x13ad7acf: /* 'ya      */
                        case 0x13ad7ad3: /* 'ye      */
                        case 0x13ad7b9f: /* 'yı      */
                        case 0x13ad7ad7: /* 'yi      */
                        case 0x13ad7ae3: /* 'yu      */
                            return 1;
                    }
                    break;

                case ET9PLIDUkrainian:

                    switch (dwHashValue)
                    {
                        case 0x171be65a: /* .ua      */
                        case 0x1713e465: /* .md      */
                        case 0x1718e5b1: /* .ru      */
                        case 0x1719e5f0: /* .su      */
                        case 0x1708e1c5: /* .by      */
                        case 0x170be27e: /* .eu      */
                            return 1;
                    }
                    break;

                case ET9PLIDUrdu:

                    switch (dwHashValue)
                    {
                        case 0x1716e529: /* .pk      */
                        case 0x170fe373: /* .in      */
                        case 0x1707e173: /* .af      */
                        case 0x1708e1b0: /* .bd      */
                            return 1;
                    }
                    break;

                case ET9PLIDVietnamese:

                    switch (dwHashValue)
                    {
                        case 0x171ce6a6: /* .vn      */
                        case 0x1712e423: /* .la      */
                        case 0x1709e1f9: /* .cn      */
                            return 1;
                    }
                    break;
           }
        }

        /* single chars */

        if (pWord->Base.wWordLen == 1) {

            const ET9SYMB sSymb = pWord->Base.sWord[0];

            switch (dwLdbNum)
            {
                case ET9PLIDFrench:

                    switch (sSymb)
                    {
                        case '!':
                        case '?':
                        case ':':
                        case ';':
                            return 0;
                    }
            }

            /* default and language independent */

            switch (sSymb)
            {
                case '.':
                case ',':
                case '!':
                case '?':
                case '-':
                case ':':
                case ';':
                case ')':
                case 0x27:      /* apostrophe */
                case 0x201D:    /* right double quotation mark */
                    return 1;
            }
        }
    }

    return 0;
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                                 
 *
 *                                                                              
 *                                             
 *
 *                                      
 */

ET9UINT ET9FARCALL _ET9_GetNumSingleCharWords(ET9AWLingInfo  const * const pLingInfo,
                                              const ET9U32                 dwLdbNum)
{
    ET9UINT val;

    ET9_UNUSED(pLingInfo);

    switch (dwLdbNum & ET9PLIDMASK)
    {
        case ET9PLIDAlbanian:
            val = NUM_ALBANIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDArabic:
            val = NUM_ARABIC_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDArmenian:
            val = NUM_ARMENIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDAzerbaijani:
            val = NUM_AZERBAIJANI_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDBasque:
            val = NUM_BASQUE_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDBulgarian:
            val = NUM_BULGARIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDCatalan:
            val = NUM_CATALAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDCzech:
            val = NUM_CZECH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDCroatian:
            val = NUM_CROATIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDDanish:
            val = NUM_DANISH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDDutch:
            val = NUM_DUTCH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDEnglish:
            val = NUM_ENGLISH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDFarsi:
            val = NUM_FARSI_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDFrench:
            val = NUM_FRENCH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDGalician:
            val = NUM_GALICIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDGreek:
            val = NUM_GREEK_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDHindi:
            val = NUM_HINDI_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDHungarian:
            val = NUM_HUNGARIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDIcelandic:
            val = NUM_ICELANDIC_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDItalian:
            val = NUM_ITALIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDLatvian:
            val = NUM_LATVIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDLithuanian:
            val = NUM_LITHUANIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDMalay:
            val = NUM_MALAY_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDMarathi:
            val = NUM_MALAY_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDNorwegian:
            val = NUM_NORWEGIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDPolish:
            val = NUM_POLISH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDPortuguese:
            val = NUM_PORTUGUESE_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDRomanian:
            val = NUM_ROMANIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDRussian:
            val = NUM_RUSSIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDSerbian:
            val = NUM_SERBIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDSerbianCyrillic:
            val = NUM_SERBIANCYRILLIC_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDSlovak:
            val = NUM_SLOVAK_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDSlovenian:
            val = NUM_SLOVENIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDSpanish:
            val = NUM_SPANISH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDSwedish:
            val = NUM_SWEDISH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDTagalog:
            val = NUM_TAGALOG_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDTamil:
            val = NUM_TAMIL_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDThai:
            val = NUM_THAI_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDTurkish:
            val = NUM_TURKISH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDUkrainian:
            val = NUM_UKRAINIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDUrdu:
            val = NUM_URDU_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDVietnamese:
            val = NUM_VIETNAMESE_SINGLE_CHAR_WORDS;
            break;

        default:
            val = NUM_STANDARD_SINGLE_CHAR_WORDS;
            break;
    }

    return val;
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                           
 *
 *                                                                              
 *                                             
 *                                               
 *
 *                                    
 */

ET9SYMB ET9FARCALL _ET9_GetSingleCharWord(ET9AWLingInfo  const * const pLingInfo,
                                         const ET9U32                  dwLdbNum,
                                         const ET9UINT                 nSymbIndex)
{
    const ET9SYMB *pTable;

    ET9UINT nVal = 0;

    ET9_UNUSED(pLingInfo);

    switch (dwLdbNum & ET9PLIDMASK)
    {
        case ET9PLIDAlbanian:
            pTable = AlbanianSingleCharWord;
            nVal = NUM_ALBANIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDArabic:
            pTable = ArabicSingleCharWord;
            nVal = NUM_ARABIC_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDArmenian:
            pTable = ArmenianSingleCharWord;
            nVal = NUM_ARMENIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDAzerbaijani:
            pTable = AzerbaijaniSingleCharWord;
            nVal = NUM_AZERBAIJANI_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDBasque:
            pTable = BasqueSingleCharWord;
            nVal = NUM_BASQUE_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDBulgarian:
            pTable = BulgarianSingleCharWord;
            nVal = NUM_BULGARIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDCatalan:
            pTable = CatalanSingleCharWord;
            nVal = NUM_CATALAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDCroatian:
            pTable = CroatianSingleCharWord;
            nVal = NUM_CROATIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDCzech:
            pTable = CzechSingleCharWord;
            nVal = NUM_CZECH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDDanish:
            pTable = DanishSingleCharWord;
            nVal = NUM_DANISH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDDutch:
            pTable = DutchSingleCharWord;
            nVal = NUM_DUTCH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDEnglish:
            pTable = EnglishSingleCharWord;
            nVal = NUM_ENGLISH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDFarsi:
            pTable = FarsiSingleCharWord;
            nVal = NUM_FARSI_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDFrench:
            pTable = FrenchSingleCharWord;
            nVal = NUM_FRENCH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDGalician:
            pTable = GalicianSingleCharWord;
            nVal = NUM_GALICIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDGreek:
            pTable = GreekSingleCharWord;
            nVal = NUM_GREEK_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDHindi:
            pTable = HindiSingleCharWord;
            nVal = NUM_HINDI_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDHungarian:
            pTable = HungarianSingleCharWord;
            nVal = NUM_HUNGARIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDIcelandic:
            pTable = IcelandicSingleCharWord;
            nVal = NUM_ICELANDIC_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDItalian:
            pTable = ItalianSingleCharWord;
            nVal = NUM_ITALIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDLatvian:
            pTable = LatvianSingleCharWord;
            nVal = NUM_LATVIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDLithuanian:
            pTable = LithuanianSingleCharWord;
            nVal = NUM_LITHUANIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDMalay:
            pTable = MalaySingleCharWord;
            nVal = NUM_MALAY_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDMarathi:
            pTable = MarathiSingleCharWord;
            nVal = NUM_MALAY_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDNorwegian:
            pTable = NorwegianSingleCharWord;
            nVal = NUM_NORWEGIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDPolish:
            pTable = PolishSingleCharWord;
            nVal = NUM_POLISH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDPortuguese:
            pTable = PortugueseSingleCharWord;
            nVal = NUM_PORTUGUESE_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDRomanian:
            pTable = RomanianSingleCharWord;
            nVal = NUM_ROMANIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDRussian:
            pTable = RussianSingleCharWord;
            nVal = NUM_RUSSIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDSerbian:
            pTable = SerbianSingleCharWord;
            nVal = NUM_SERBIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDSerbianCyrillic:
            pTable = SerbianCyrillicSingleCharWord;
            nVal = NUM_SERBIANCYRILLIC_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDSlovak:
            pTable = SlovakSingleCharWord;
            nVal = NUM_SLOVAK_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDSlovenian:
            pTable = SlovenianSingleCharWord;
            nVal = NUM_SLOVENIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDSpanish:
            pTable = SpanishSingleCharWord;
            nVal = NUM_SPANISH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDSwedish:
            pTable = SwedishSingleCharWord;
            nVal = NUM_SWEDISH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDTagalog:
            pTable = TagalogSingleCharWord;
            nVal = NUM_TAGALOG_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDTamil:
            pTable = TamilSingleCharWord;
            nVal = NUM_TAMIL_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDThai:
            pTable = ThaiSingleCharWord;
            nVal = NUM_THAI_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDTurkish:
            pTable = TurkishSingleCharWord;
            nVal = NUM_TURKISH_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDUkrainian:
            pTable = UkrainianSingleCharWord;
            nVal = NUM_UKRAINIAN_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDUrdu:
            pTable = UrduSingleCharWord;
            nVal = NUM_URDU_SINGLE_CHAR_WORDS;
            break;

        case ET9PLIDVietnamese:
            pTable = VietnameseSingleCharWord;
            nVal = NUM_VIETNAMESE_SINGLE_CHAR_WORDS;
            break;

        default:
            pTable = EnglishSingleCharWord;
            nVal = NUM_STANDARD_SINGLE_CHAR_WORDS;
            break;
    }

    return nVal > 0 ? pTable[nSymbIndex >= nVal ? 0 : nSymbIndex] : 0;
}

/*---------------------------------------------------------------------------*/
/*  -IDR-    
 *                                
 *
 *                                                                              
 *                                             
 *                                               
 *
 *             /     
 */

ET9BOOL ET9FARCALL _ET9_IsSingleCharWord(ET9AWLingInfo    const * const pLingInfo,
                                         const ET9U32                   dwLdbNum,
                                         const ET9SYMB                  sSymb)
{
    const ET9UINT nTotalSingleCharWords = _ET9_GetNumSingleCharWords(pLingInfo, dwLdbNum);

    ET9UINT i;

    ET9Assert(pLingInfo);

    for (i = 0; i < nTotalSingleCharWords; ++i) {
        if (_ET9_GetSingleCharWord(pLingInfo, dwLdbNum, i) == sSymb) {
            return 1;
        }
    }

    return 0;
}

#endif /* ET9_ALPHABETIC_MODULE */
/*! @} */
/* ----------------------------------< eof >--------------------------------- */
