[apple/icu.git] / icuSources / layout / KhmerReordering.cpp

/*
 *
 * (C) Copyright IBM Corp. 1998-2007 - All Rights Reserved 
 *
 * This file is a modification of the ICU file IndicReordering.cpp
 * by Jens Herden and Javier Sola for Khmer language 
 *
 */

#include "LETypes.h"
#include "OpenTypeTables.h"
#include "KhmerReordering.h"
#include "LEGlyphStorage.h"


U_NAMESPACE_BEGIN

// Characters that get refered to by name...
enum
{
    C_SIGN_ZWNJ     = 0x200C,
    C_SIGN_ZWJ      = 0x200D,
    C_DOTTED_CIRCLE = 0x25CC,
    C_RO            = 0x179A,
    C_VOWEL_AA      = 0x17B6,
    C_SIGN_NIKAHIT  = 0x17C6,
    C_VOWEL_E       = 0x17C1,
    C_COENG         = 0x17D2
};


enum
{
    // simple classes, they are used in the statetable (in this file) to control the length of a syllable
    // they are also used to know where a character should be placed (location in reference to the base character)
    // and also to know if a character, when independtly displayed, should be displayed with a dotted-circle to
    // indicate error in syllable construction 
    _xx = KhmerClassTable::CC_RESERVED,
    _sa = KhmerClassTable::CC_SIGN_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_POS_ABOVE,
    _sp = KhmerClassTable::CC_SIGN_AFTER | KhmerClassTable::CF_DOTTED_CIRCLE| KhmerClassTable::CF_POS_AFTER,
    _c1 = KhmerClassTable::CC_CONSONANT | KhmerClassTable::CF_CONSONANT,
    _c2 = KhmerClassTable::CC_CONSONANT2 | KhmerClassTable::CF_CONSONANT,
    _c3 = KhmerClassTable::CC_CONSONANT3 | KhmerClassTable::CF_CONSONANT,
    _rb = KhmerClassTable::CC_ROBAT | KhmerClassTable::CF_POS_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE,
    _cs = KhmerClassTable::CC_CONSONANT_SHIFTER | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_SHIFTER,
    _dl = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_BEFORE | KhmerClassTable::CF_DOTTED_CIRCLE, 
    _db = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_BELOW | KhmerClassTable::CF_DOTTED_CIRCLE,
    _da = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_ABOVE | KhmerClassTable::CF_DOTTED_CIRCLE | KhmerClassTable::CF_ABOVE_VOWEL,
    _dr = KhmerClassTable::CC_DEPENDENT_VOWEL | KhmerClassTable::CF_POS_AFTER | KhmerClassTable::CF_DOTTED_CIRCLE,
    _co = KhmerClassTable::CC_COENG | KhmerClassTable::CF_COENG | KhmerClassTable::CF_DOTTED_CIRCLE,
    
    // split vowel
    _va = _da | KhmerClassTable::CF_SPLIT_VOWEL,
    _vr = _dr | KhmerClassTable::CF_SPLIT_VOWEL
};


// Character class tables 
// _xx character does not combine into syllable, such as numbers, puntuation marks, non-Khmer signs... 
// _sa Sign placed above the base
// _sp Sign placed after the base
// _c1 Consonant of type 1 or independent vowel (independent vowels behave as type 1 consonants)
// _c2 Consonant of type 2 (only RO)
// _c3 Consonant of type 3 
// _rb Khmer sign robat u17CC. combining mark for subscript consonants
// _cd Consonant-shifter
// _dl Dependent vowel placed before the base (left of the base)
// _db Dependent vowel placed below the base 
// _da Dependent vowel placed above the base
// _dr Dependent vowel placed behind the base (right of the base)    
// _co Khmer combining mark COENG u17D2, combines with the consonant or independent vowel following 
//     it to create a subscript consonant or independent vowel   
// _va Khmer split vowel in wich the first part is before the base and the second one above the base
// _vr Khmer split vowel in wich the first part is before the base and the second one behind (right of) the base

static const KhmerClassTable::CharClass khmerCharClasses[] =
{
    _c1, _c1, _c1, _c3, _c1, _c1, _c1, _c1, _c3, _c1, _c1, _c1, _c1, _c3, _c1, _c1, // 1780 - 178F
    _c1, _c1, _c1, _c1, _c3, _c1, _c1, _c1, _c1, _c3, _c2, _c1, _c1, _c1, _c3, _c3, // 1790 - 179F
    _c1, _c3, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, // 17A0 - 17AF
    _c1, _c1, _c1, _c1, _dr, _dr, _dr, _da, _da, _da, _da, _db, _db, _db, _va, _vr, // 17B0 - 17BF
    _vr, _dl, _dl, _dl, _vr, _vr, _sa, _sp, _sp, _cs, _cs, _sa, _rb, _sa, _sa, _sa, // 17C0 - 17CF
    _sa, _sa, _co, _sa, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _sa, _xx, _xx, // 17D0 - 17DF
};                                                                                  


//
// Khmer Class Tables
//                   

//
// The range of characters defined in the above table is defined here. FOr Khmer 1780 to 17DF
// Even if the Khmer range is bigger, all other characters are not combinable, and therefore treated
// as _xx
static const KhmerClassTable khmerClassTable = {0x1780, 0x17df, khmerCharClasses};


// Below we define how a character in the input string is either in the khmerCharClasses table
// (in which case we get its type back), a ZWJ or ZWNJ (two characters that may appear 
// within the syllable, but are not in the table) we also get their type back, or an unknown object
// in which case we get _xx (CC_RESERVED) back
KhmerClassTable::CharClass KhmerClassTable::getCharClass(LEUnicode ch) const
{

    if (ch == C_SIGN_ZWJ) {
        return CC_ZERO_WIDTH_J_MARK;
    }

    if (ch == C_SIGN_ZWNJ) {
        return CC_ZERO_WIDTH_NJ_MARK;
    }

    if (ch < firstChar || ch > lastChar) {
        return CC_RESERVED;
    }
    
    return classTable[ch - firstChar];
}

const KhmerClassTable *KhmerClassTable::getKhmerClassTable()
{
    return &khmerClassTable;
}


class KhmerReorderingOutput : public UMemory {
private:
    le_int32 fSyllableCount;
    le_int32 fOutIndex;
    LEUnicode *fOutChars;

    LEGlyphStorage &fGlyphStorage;


public:
    KhmerReorderingOutput(LEUnicode *outChars, LEGlyphStorage &glyphStorage)
        : fSyllableCount(0), fOutIndex(0), fOutChars(outChars), fGlyphStorage(glyphStorage)
    {
        // nothing else to do...
    }

    ~KhmerReorderingOutput()
    {
        // nothing to do here...
    }

    void reset()
    {
        fSyllableCount += 1;
    }

    void writeChar(LEUnicode ch, le_uint32 charIndex, FeatureMask charFeatures)
    {
        LEErrorCode success = LE_NO_ERROR;

        fOutChars[fOutIndex] = ch;

        fGlyphStorage.setCharIndex(fOutIndex, charIndex, success);
        fGlyphStorage.setAuxData(fOutIndex, charFeatures | (fSyllableCount & LE_GLYPH_GROUP_MASK), success);

        fOutIndex += 1;
    }

    le_int32 getOutputIndex()
    {
        return fOutIndex;
    }
};


#define blwfFeatureTag LE_BLWF_FEATURE_TAG
#define pstfFeatureTag LE_PSTF_FEATURE_TAG
#define presFeatureTag LE_PRES_FEATURE_TAG
#define blwsFeatureTag LE_BLWS_FEATURE_TAG
#define abvsFeatureTag LE_ABVS_FEATURE_TAG
#define pstsFeatureTag LE_PSTS_FEATURE_TAG

#define blwmFeatureTag LE_BLWM_FEATURE_TAG
#define abvmFeatureTag LE_ABVM_FEATURE_TAG
#define distFeatureTag LE_DIST_FEATURE_TAG

#define prefFeatureTag LE_PREF_FEATURE_TAG
#define abvfFeatureTag LE_ABVF_FEATURE_TAG
#define cligFeatureTag LE_CLIG_FEATURE_TAG
#define mkmkFeatureTag LE_MKMK_FEATURE_TAG

#define prefFeatureMask 0x80000000UL
#define blwfFeatureMask 0x40000000UL
#define abvfFeatureMask 0x20000000UL
#define pstfFeatureMask 0x10000000UL 
#define presFeatureMask 0x08000000UL
#define blwsFeatureMask 0x04000000UL
#define abvsFeatureMask 0x02000000UL
#define pstsFeatureMask 0x01000000UL
#define cligFeatureMask 0x00800000UL
#define distFeatureMask 0x00400000UL
#define blwmFeatureMask 0x00200000UL
#define abvmFeatureMask 0x00100000UL
#define mkmkFeatureMask 0x00080000UL

#define tagPref    (prefFeatureMask | presFeatureMask | cligFeatureMask | distFeatureMask)
#define tagAbvf    (abvfFeatureMask | abvsFeatureMask | cligFeatureMask | distFeatureMask | abvmFeatureMask | mkmkFeatureMask)
#define tagPstf    (blwfFeatureMask | blwsFeatureMask | prefFeatureMask | presFeatureMask | pstfFeatureMask | pstsFeatureMask | cligFeatureMask | distFeatureMask | blwmFeatureMask)
#define tagBlwf    (blwfFeatureMask | blwsFeatureMask | cligFeatureMask | distFeatureMask | blwmFeatureMask | mkmkFeatureMask)
#define tagDefault (prefFeatureMask | blwfFeatureMask | presFeatureMask | blwsFeatureMask | cligFeatureMask | distFeatureMask | abvmFeatureMask | blwmFeatureMask | mkmkFeatureMask)


// These are in the order in which the features need to be applied
// for correct processing
static const FeatureMap featureMap[] =
{
    // Shaping features
    {prefFeatureTag, prefFeatureMask},
    {blwfFeatureTag, blwfFeatureMask},
    {abvfFeatureTag, abvfFeatureMask},
    {pstfFeatureTag, pstfFeatureMask}, 
    {presFeatureTag, presFeatureMask},
    {blwsFeatureTag, blwsFeatureMask},
    {abvsFeatureTag, abvsFeatureMask},
    {pstsFeatureTag, pstsFeatureMask},
    {cligFeatureTag, cligFeatureMask},
    
    // Positioning features
    {distFeatureTag, distFeatureMask},
    {blwmFeatureTag, blwmFeatureMask},
    {abvmFeatureTag, abvmFeatureMask},
    {mkmkFeatureTag, mkmkFeatureMask},
};

static const le_int32 featureMapCount = LE_ARRAY_SIZE(featureMap);

// The stateTable is used to calculate the end (the length) of a well
// formed Khmer Syllable. 
//
// Each horizontal line is ordered exactly the same way as the values in KhmerClassTable
// CharClassValues in KhmerReordering.h This coincidence of values allows the
// follow up of the table.
//
// Each line corresponds to a state, which does not necessarily need to be a type
// of component... for example, state 2 is a base, with is always a first character
// in the syllable, but the state could be produced a consonant of any type when
// it is the first character that is analysed (in ground state).
//
// Differentiating 3 types of consonants is necessary in order to 
// forbid the use of certain combinations, such as having a second
// coeng after a coeng RO, 
// The inexistent possibility of having a type 3 after another type 3 is permitted,
// eliminating it would very much complicate the table, and it does not create typing
// problems, as the case above.
//
// The table is quite complex, in order to limit the number of coeng consonants
// to 2 (by means of the table).
//
// There a peculiarity, as far as Unicode is concerned:
// - The consonant-shifter is considered in two possible different 
//   locations, the one considered in Unicode 3.0 and the one considered in
//   Unicode 4.0. (there is a backwards compatibility problem in this standard).


// xx    independent character, such as a number, punctuation sign or non-khmer char
//
// c1    Khmer consonant of type 1 or an independent vowel
//       that is, a letter in which the subscript for is only under the
//       base, not taking any space to the right or to the left
//
// c2    Khmer consonant of type 2, the coeng form takes space under
//       and to the left of the base (only RO is of this type)
//
// c3    Khmer consonant of type 3. Its subscript form takes space under
//       and to the right of the base. 
//
// cs    Khmer consonant shifter         
//
// rb    Khmer robat
//
// co    coeng character (u17D2)
//
// dv    dependent vowel (including split vowels, they are treated in the same way).
//       even if dv is not defined above, the component that is really tested for is
//       KhmerClassTable::CC_DEPENDENT_VOWEL, which is common to all dependent vowels
//
// zwj   Zero Width joiner
//
// zwnj  Zero width non joiner  
//
// sa    above sign
//
// sp    post sign    
// 
// there are lines with equal content but for an easier understanding 
// (and maybe change in the future) we did not join them
//
static const le_int8 khmerStateTable[][KhmerClassTable::CC_COUNT] =
{

//   xx  c1  c2  c3 zwnj cs  rb  co  dv  sa  sp zwj  
    { 1,  2,  2,  2,  1,  1,  1,  6,  1,  1,  1,  2}, //  0 - ground state
    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, //  1 - exit state (or sign to the right of the syllable)
    {-1, -1, -1, -1,  3,  4,  5,  6, 16, 17,  1, -1}, //  2 - Base consonant    
    {-1, -1, -1, -1, -1,  4, -1, -1, 16, -1, -1, -1}, //  3 - First ZWNJ before a register shifter
                                                      //      It can only be followed by a shifter or a vowel
    {-1, -1, -1, -1, 15, -1, -1,  6, 16, 17,  1, 14}, //  4 - First register shifter             
    {-1, -1, -1, -1, -1, -1, -1, -1, 20, -1,  1, -1}, //  5 - Robat
    {-1,  7,  8,  9, -1, -1, -1, -1, -1, -1, -1, -1}, //  6 - First Coeng
    {-1, -1, -1, -1, 12, 13, -1, 10, 16, 17,  1, 14}, //  7 - First consonant of type 1 after coeng 
    {-1, -1, -1, -1, 12, 13, -1, -1, 16, 17,  1, 14}, //  8 - First consonant of type 2 after coeng
    {-1, -1, -1, -1, 12, 13, -1, 10, 16, 17,  1, 14}, //  9 - First consonant or type 3 after ceong
    {-1, 11, 11, 11, -1, -1, -1, -1, -1, -1, -1, -1}, // 10 - Second Coeng (no register shifter before)
    {-1, -1, -1, -1, 15, -1, -1, -1, 16, 17,  1, 14}, // 11 - Second coeng consonant (or ind. vowel) no register shifter before 
    {-1, -1, -1, -1, -1, 13, -1, -1, 16, -1, -1, -1}, // 12 - Second ZWNJ before a register shifter
    {-1, -1, -1, -1, 15, -1, -1, -1, 16, 17,  1, 14}, // 13 - Second register shifter 
    {-1, -1, -1, -1, -1, -1, -1, -1, 16, -1, -1, -1}, // 14 - ZWJ before vowel    
    {-1, -1, -1, -1, -1, -1, -1, -1, 16, -1, -1, -1}, // 15 - ZWNJ before vowel
    {-1, -1, -1, -1, -1, -1, -1, -1, -1, 17,  1, 18}, // 16 - dependent vowel 
    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  1, 18}, // 17 - sign above
    {-1, -1, -1, -1, -1, -1, -1, 19, -1, -1, -1, -1}, // 18 - ZWJ after vowel    
    {-1,  1, -1,  1, -1, -1, -1, -1, -1, -1, -1, -1}, // 19 - Third coeng 
    {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  1, -1}, // 20 - dependent vowel after a Robat

};         


const FeatureMap *KhmerReordering::getFeatureMap(le_int32 &count)
{
    count = featureMapCount;

    return featureMap;
}


// Given an input string of characters and a location in which to start looking
// calculate, using the state table, which one is the last character of the syllable
// that starts in the starting position.
le_int32 KhmerReordering::findSyllable(const KhmerClassTable *classTable, const LEUnicode *chars, le_int32 prev, le_int32 charCount)
{
    le_int32 cursor = prev;
    le_int8 state = 0;

    while (cursor < charCount) {
        KhmerClassTable::CharClass charClass = (classTable->getCharClass(chars[cursor]) & KhmerClassTable::CF_CLASS_MASK);

        state = khmerStateTable[state][charClass];

        if (state < 0) {
            break;
        }

        cursor += 1;
    }

    return cursor;
}


// This is the real reordering function as applied to the Khmer language

le_int32 KhmerReordering::reorder(const LEUnicode *chars, le_int32 charCount, le_int32 /*scriptCode*/,
                                  LEUnicode *outChars, LEGlyphStorage &glyphStorage)
{
    const KhmerClassTable *classTable = KhmerClassTable::getKhmerClassTable();

    KhmerReorderingOutput output(outChars, glyphStorage);
    KhmerClassTable::CharClass charClass;
    le_int32 i, prev = 0, coengRo;

    
    // This loop only exits when we reach the end of a run, which may contain 
    // several syllables.
    while (prev < charCount) {
        le_int32 syllable = findSyllable(classTable, chars, prev, charCount);

        output.reset();
   
        // write a pre vowel or the pre part of a split vowel first
        // and look out for coeng + ro. RO is the only vowel of type 2, and
        // therefore the only one that requires saving space before the base.
        coengRo = -1;  // There is no Coeng Ro, if found this value will change
        for (i = prev; i < syllable; i += 1) {
            charClass = classTable->getCharClass(chars[i]);
            
            // if a split vowel, write the pre part. In Khmer the pre part
            // is the same for all split vowels, same glyph as pre vowel C_VOWEL_E
            if (charClass & KhmerClassTable::CF_SPLIT_VOWEL) {
                output.writeChar(C_VOWEL_E, i, tagPref);
                break; // there can be only one vowel
            }
            
            // if a vowel with pos before write it out
            if (charClass & KhmerClassTable::CF_POS_BEFORE) {
                output.writeChar(chars[i], i, tagPref);
                break; // there can be only one vowel 
            }
            
            // look for coeng + ro and remember position
            // works because coeng + ro is always in front of a vowel (if there is a vowel) 
            // and because CC_CONSONANT2 is enough to identify it, as it is the only consonant
            // with this flag
            if ( (charClass & KhmerClassTable::CF_COENG) && (i + 1 < syllable) &&
                 ( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK) == KhmerClassTable::CC_CONSONANT2) )
            {
                    coengRo = i;
            }
        }
        
        // write coeng + ro if found
        if (coengRo > -1) {
            output.writeChar(C_COENG, coengRo, tagPref);
            output.writeChar(C_RO, coengRo + 1, tagPref);
        }
        
        // shall we add a dotted circle?
        // If in the position in which the base should be (first char in the string) there is
        // a character that has the Dotted circle flag (a character that cannot be a base)
        // then write a dotted circle
        if (classTable->getCharClass(chars[prev]) & KhmerClassTable::CF_DOTTED_CIRCLE) {
            output.writeChar(C_DOTTED_CIRCLE, prev, tagDefault);        
        }        

        // copy what is left to the output, skipping before vowels and coeng Ro if they are present
        for (i = prev; i < syllable; i += 1) {
            charClass = classTable->getCharClass(chars[i]);
            
            // skip a before vowel, it was already processed
            if (charClass & KhmerClassTable::CF_POS_BEFORE) {
                continue;
            }
            
            // skip coeng + ro, it was already processed
            if (i == coengRo) {
                i += 1;
                continue;
            }
            
            switch (charClass & KhmerClassTable::CF_POS_MASK) {
                case KhmerClassTable::CF_POS_ABOVE :
                    output.writeChar(chars[i], i, tagAbvf);
                    break;
                
                case KhmerClassTable::CF_POS_AFTER :
                    output.writeChar(chars[i], i, tagPstf);
                    break;
                
                case KhmerClassTable::CF_POS_BELOW :
                    output.writeChar(chars[i], i, tagBlwf);
                    break;
                
                default:
                    // assign the correct flags to a coeng consonant
                    // Consonants of type 3 are taged as Post forms and those type 1 as below forms
                    if ( (charClass & KhmerClassTable::CF_COENG) && i + 1 < syllable ) {
                        if ( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK) 
                              == KhmerClassTable::CC_CONSONANT3) {
                            output.writeChar(chars[i], i, tagPstf);
                            i += 1;
                            output.writeChar(chars[i], i, tagPstf);
                        }
                        else {
                            output.writeChar(chars[i], i, tagBlwf);
                            i += 1;
                            output.writeChar(chars[i], i, tagBlwf);
                        }
                        break;
                    }
                    // if a shifter is followed by an above vowel change the shifter to below form,
                    // an above vowel can have two possible positions i + 1 or i + 3 
                    // (position i+1 corresponds to unicode 3, position i+3 to Unicode 4)
                    // and there is an extra rule for C_VOWEL_AA + C_SIGN_NIKAHIT also for two
                    // different positions, right after the shifter or after a vowel (Unicode 4)
                    if ( (charClass & KhmerClassTable::CF_SHIFTER) && (i + 1 < syllable) ) {
                        if ((classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_ABOVE_VOWEL)
                            || (i + 2 < syllable
                                && ( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK) == C_VOWEL_AA)
                                && ( (classTable->getCharClass(chars[i + 2]) & KhmerClassTable::CF_CLASS_MASK) == C_SIGN_NIKAHIT))
                            || (i + 3 < syllable && (classTable->getCharClass(chars[i + 3]) & KhmerClassTable::CF_ABOVE_VOWEL))
                            || (i + 4 < syllable
                                && ( (classTable->getCharClass(chars[i + 3]) & KhmerClassTable::CF_CLASS_MASK) == C_VOWEL_AA)
                                && ( (classTable->getCharClass(chars[i + 4]) & KhmerClassTable::CF_CLASS_MASK) == C_SIGN_NIKAHIT) ) ) 
                        {
                            output.writeChar(chars[i], i, tagBlwf);
                            break;
                        }
                        
                    }
                    // default - any other characters
                    output.writeChar(chars[i], i, tagDefault);
                    break;
            } // switch
        } // for

        prev = syllable; // move the pointer to the start of next syllable
    }

    return output.getOutputIndex();
}


U_NAMESPACE_END
Commit	Line	Data
73c04bcf A	1	/*
73c04bcf A	2	*
46f4442e	3	* (C) Copyright IBM Corp. 1998-2007 - All Rights Reserved
73c04bcf A	4	*
	5	* This file is a modification of the ICU file IndicReordering.cpp
	6	* by Jens Herden and Javier Sola for Khmer language
	7	*
	8	*/
	9
	10	#include "LETypes.h"
	11	#include "OpenTypeTables.h"
	12	#include "KhmerReordering.h"
	13	#include "LEGlyphStorage.h"
	14
	15
	16	U_NAMESPACE_BEGIN
	17
	18	// Characters that get refered to by name...
	19	enum
	20	{
	21	C_SIGN_ZWNJ = 0x200C,
	22	C_SIGN_ZWJ = 0x200D,
	23	C_DOTTED_CIRCLE = 0x25CC,
	24	C_RO = 0x179A,
	25	C_VOWEL_AA = 0x17B6,
	26	C_SIGN_NIKAHIT = 0x17C6,
	27	C_VOWEL_E = 0x17C1,
	28	C_COENG = 0x17D2
	29	};
	30
	31
	32	enum
	33	{
	34	// simple classes, they are used in the statetable (in this file) to control the length of a syllable
	35	// they are also used to know where a character should be placed (location in reference to the base character)
	36	// and also to know if a character, when independtly displayed, should be displayed with a dotted-circle to
	37	// indicate error in syllable construction
	38	_xx = KhmerClassTable::CC_RESERVED,
	39	_sa = KhmerClassTable::CC_SIGN_ABOVE \| KhmerClassTable::CF_DOTTED_CIRCLE \| KhmerClassTable::CF_POS_ABOVE,
	40	_sp = KhmerClassTable::CC_SIGN_AFTER \| KhmerClassTable::CF_DOTTED_CIRCLE\| KhmerClassTable::CF_POS_AFTER,
	41	_c1 = KhmerClassTable::CC_CONSONANT \| KhmerClassTable::CF_CONSONANT,
	42	_c2 = KhmerClassTable::CC_CONSONANT2 \| KhmerClassTable::CF_CONSONANT,
	43	_c3 = KhmerClassTable::CC_CONSONANT3 \| KhmerClassTable::CF_CONSONANT,
	44	_rb = KhmerClassTable::CC_ROBAT \| KhmerClassTable::CF_POS_ABOVE \| KhmerClassTable::CF_DOTTED_CIRCLE,
	45	_cs = KhmerClassTable::CC_CONSONANT_SHIFTER \| KhmerClassTable::CF_DOTTED_CIRCLE \| KhmerClassTable::CF_SHIFTER,
	46	_dl = KhmerClassTable::CC_DEPENDENT_VOWEL \| KhmerClassTable::CF_POS_BEFORE \| KhmerClassTable::CF_DOTTED_CIRCLE,
	47	_db = KhmerClassTable::CC_DEPENDENT_VOWEL \| KhmerClassTable::CF_POS_BELOW \| KhmerClassTable::CF_DOTTED_CIRCLE,
	48	_da = KhmerClassTable::CC_DEPENDENT_VOWEL \| KhmerClassTable::CF_POS_ABOVE \| KhmerClassTable::CF_DOTTED_CIRCLE \| KhmerClassTable::CF_ABOVE_VOWEL,
	49	_dr = KhmerClassTable::CC_DEPENDENT_VOWEL \| KhmerClassTable::CF_POS_AFTER \| KhmerClassTable::CF_DOTTED_CIRCLE,
	50	_co = KhmerClassTable::CC_COENG \| KhmerClassTable::CF_COENG \| KhmerClassTable::CF_DOTTED_CIRCLE,
	51
	52	// split vowel
	53	_va = _da \| KhmerClassTable::CF_SPLIT_VOWEL,
	54	_vr = _dr \| KhmerClassTable::CF_SPLIT_VOWEL
	55	};
	56
	57
	58	// Character class tables
	59	// _xx character does not combine into syllable, such as numbers, puntuation marks, non-Khmer signs...
	60	// _sa Sign placed above the base
	61	// _sp Sign placed after the base
	62	// _c1 Consonant of type 1 or independent vowel (independent vowels behave as type 1 consonants)
	63	// _c2 Consonant of type 2 (only RO)
	64	// _c3 Consonant of type 3
	65	// _rb Khmer sign robat u17CC. combining mark for subscript consonants
	66	// _cd Consonant-shifter
	67	// _dl Dependent vowel placed before the base (left of the base)
68	// _db Dependent vowel placed below the base
69	// _da Dependent vowel placed above the base
70	// _dr Dependent vowel placed behind the base (right of the base)
71	// _co Khmer combining mark COENG u17D2, combines with the consonant or independent vowel following
72	// it to create a subscript consonant or independent vowel
73	// _va Khmer split vowel in wich the first part is before the base and the second one above the base
74	// _vr Khmer split vowel in wich the first part is before the base and the second one behind (right of) the base
75
76	static const KhmerClassTable::CharClass khmerCharClasses[] =
77	{
78	_c1, _c1, _c1, _c3, _c1, _c1, _c1, _c1, _c3, _c1, _c1, _c1, _c1, _c3, _c1, _c1, // 1780 - 178F
79	_c1, _c1, _c1, _c1, _c3, _c1, _c1, _c1, _c1, _c3, _c2, _c1, _c1, _c1, _c3, _c3, // 1790 - 179F
80	_c1, _c3, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, _c1, // 17A0 - 17AF
81	_c1, _c1, _c1, _c1, _dr, _dr, _dr, _da, _da, _da, _da, _db, _db, _db, _va, _vr, // 17B0 - 17BF
82	_vr, _dl, _dl, _dl, _vr, _vr, _sa, _sp, _sp, _cs, _cs, _sa, _rb, _sa, _sa, _sa, // 17C0 - 17CF
83	_sa, _sa, _co, _sa, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _xx, _sa, _xx, _xx, // 17D0 - 17DF
84	};
85
86
87	//
88	// Khmer Class Tables
89	//
90
91	//
92	// The range of characters defined in the above table is defined here. FOr Khmer 1780 to 17DF
93	// Even if the Khmer range is bigger, all other characters are not combinable, and therefore treated
94	// as _xx
95	static const KhmerClassTable khmerClassTable = {0x1780, 0x17df, khmerCharClasses};
96
97
98	// Below we define how a character in the input string is either in the khmerCharClasses table
99	// (in which case we get its type back), a ZWJ or ZWNJ (two characters that may appear
100	// within the syllable, but are not in the table) we also get their type back, or an unknown object
101	// in which case we get _xx (CC_RESERVED) back
102	KhmerClassTable::CharClass KhmerClassTable::getCharClass(LEUnicode ch) const
103	{
104
105	if (ch == C_SIGN_ZWJ) {
106	return CC_ZERO_WIDTH_J_MARK;
107	}
108
109	if (ch == C_SIGN_ZWNJ) {
110	return CC_ZERO_WIDTH_NJ_MARK;
111	}
112
113	if (ch < firstChar \|\| ch > lastChar) {
114	return CC_RESERVED;
115	}
116
117	return classTable[ch - firstChar];
118	}
119
120	const KhmerClassTable *KhmerClassTable::getKhmerClassTable()
121	{
122	return &khmerClassTable;
123	}
124
125
126
127	class KhmerReorderingOutput : public UMemory {
128	private:
46f4442e	129	le_int32 fSyllableCount;
73c04bcf A	130	le_int32 fOutIndex;
	131	LEUnicode *fOutChars;
	132
	133	LEGlyphStorage &fGlyphStorage;
	134
	135
	136	public:
	137	KhmerReorderingOutput(LEUnicode *outChars, LEGlyphStorage &glyphStorage)
46f4442e	138	: fSyllableCount(0), fOutIndex(0), fOutChars(outChars), fGlyphStorage(glyphStorage)
73c04bcf A	139	{
	140	// nothing else to do...
	141	}
	142
	143	~KhmerReorderingOutput()
	144	{
	145	// nothing to do here...
	146	}
	147
46f4442e A	148	void reset()
	149	{
	150	fSyllableCount += 1;
	151	}
	152
73c04bcf A	153	void writeChar(LEUnicode ch, le_uint32 charIndex, FeatureMask charFeatures)
	154	{
	155	LEErrorCode success = LE_NO_ERROR;
	156
	157	fOutChars[fOutIndex] = ch;
	158
	159	fGlyphStorage.setCharIndex(fOutIndex, charIndex, success);
46f4442e	160	fGlyphStorage.setAuxData(fOutIndex, charFeatures \| (fSyllableCount & LE_GLYPH_GROUP_MASK), success);
73c04bcf A	161
	162	fOutIndex += 1;
	163	}
	164
	165	le_int32 getOutputIndex()
	166	{
	167	return fOutIndex;
	168	}
	169	};
	170
	171
	172	#define blwfFeatureTag LE_BLWF_FEATURE_TAG
	173	#define pstfFeatureTag LE_PSTF_FEATURE_TAG
	174	#define presFeatureTag LE_PRES_FEATURE_TAG
	175	#define blwsFeatureTag LE_BLWS_FEATURE_TAG
	176	#define abvsFeatureTag LE_ABVS_FEATURE_TAG
	177	#define pstsFeatureTag LE_PSTS_FEATURE_TAG
	178
	179	#define blwmFeatureTag LE_BLWM_FEATURE_TAG
	180	#define abvmFeatureTag LE_ABVM_FEATURE_TAG
	181	#define distFeatureTag LE_DIST_FEATURE_TAG
	182
	183	#define prefFeatureTag LE_PREF_FEATURE_TAG
	184	#define abvfFeatureTag LE_ABVF_FEATURE_TAG
	185	#define cligFeatureTag LE_CLIG_FEATURE_TAG
	186	#define mkmkFeatureTag LE_MKMK_FEATURE_TAG
	187
	188	#define prefFeatureMask 0x80000000UL
	189	#define blwfFeatureMask 0x40000000UL
	190	#define abvfFeatureMask 0x20000000UL
	191	#define pstfFeatureMask 0x10000000UL
	192	#define presFeatureMask 0x08000000UL
	193	#define blwsFeatureMask 0x04000000UL
	194	#define abvsFeatureMask 0x02000000UL
	195	#define pstsFeatureMask 0x01000000UL
	196	#define cligFeatureMask 0x00800000UL
	197	#define distFeatureMask 0x00400000UL
	198	#define blwmFeatureMask 0x00200000UL
	199	#define abvmFeatureMask 0x00100000UL
	200	#define mkmkFeatureMask 0x00080000UL
	201
	202	#define tagPref (prefFeatureMask \| presFeatureMask \| cligFeatureMask \| distFeatureMask)
	203	#define tagAbvf (abvfFeatureMask \| abvsFeatureMask \| cligFeatureMask \| distFeatureMask \| abvmFeatureMask \| mkmkFeatureMask)
	204	#define tagPstf (blwfFeatureMask \| blwsFeatureMask \| prefFeatureMask \| presFeatureMask \| pstfFeatureMask \| pstsFeatureMask \| cligFeatureMask \| distFeatureMask \| blwmFeatureMask)
	205	#define tagBlwf (blwfFeatureMask \| blwsFeatureMask \| cligFeatureMask \| distFeatureMask \| blwmFeatureMask \| mkmkFeatureMask)
	206	#define tagDefault (prefFeatureMask \| blwfFeatureMask \| presFeatureMask \| blwsFeatureMask \| cligFeatureMask \| distFeatureMask \| abvmFeatureMask \| blwmFeatureMask \| mkmkFeatureMask)
	207
	208
	209
	210	// These are in the order in which the features need to be applied
	211	// for correct processing
	212	static const FeatureMap featureMap[] =
	213	{
	214	// Shaping features
	215	{prefFeatureTag, prefFeatureMask},
	216	{blwfFeatureTag, blwfFeatureMask},
	217	{abvfFeatureTag, abvfFeatureMask},
	218	{pstfFeatureTag, pstfFeatureMask},
	219	{presFeatureTag, presFeatureMask},
	220	{blwsFeatureTag, blwsFeatureMask},
	221	{abvsFeatureTag, abvsFeatureMask},
	222	{pstsFeatureTag, pstsFeatureMask},
	223	{cligFeatureTag, cligFeatureMask},
	224
225	// Positioning features
226	{distFeatureTag, distFeatureMask},
227	{blwmFeatureTag, blwmFeatureMask},
228	{abvmFeatureTag, abvmFeatureMask},
229	{mkmkFeatureTag, mkmkFeatureMask},
230	};
231
232	static const le_int32 featureMapCount = LE_ARRAY_SIZE(featureMap);
233
234	// The stateTable is used to calculate the end (the length) of a well
235	// formed Khmer Syllable.
236	//
237	// Each horizontal line is ordered exactly the same way as the values in KhmerClassTable
238	// CharClassValues in KhmerReordering.h This coincidence of values allows the
239	// follow up of the table.
240	//
241	// Each line corresponds to a state, which does not necessarily need to be a type
242	// of component... for example, state 2 is a base, with is always a first character
243	// in the syllable, but the state could be produced a consonant of any type when
244	// it is the first character that is analysed (in ground state).
245	//
246	// Differentiating 3 types of consonants is necessary in order to
247	// forbid the use of certain combinations, such as having a second
248	// coeng after a coeng RO,
249	// The inexistent possibility of having a type 3 after another type 3 is permitted,
250	// eliminating it would very much complicate the table, and it does not create typing
251	// problems, as the case above.
252	//
253	// The table is quite complex, in order to limit the number of coeng consonants
254	// to 2 (by means of the table).
255	//
256	// There a peculiarity, as far as Unicode is concerned:
257	// - The consonant-shifter is considered in two possible different
258	// locations, the one considered in Unicode 3.0 and the one considered in
259	// Unicode 4.0. (there is a backwards compatibility problem in this standard).
260
261
262	// xx independent character, such as a number, punctuation sign or non-khmer char
263	//
264	// c1 Khmer consonant of type 1 or an independent vowel
265	// that is, a letter in which the subscript for is only under the
266	// base, not taking any space to the right or to the left
267	//
268	// c2 Khmer consonant of type 2, the coeng form takes space under
269	// and to the left of the base (only RO is of this type)
270	//
271	// c3 Khmer consonant of type 3. Its subscript form takes space under
272	// and to the right of the base.
273	//
274	// cs Khmer consonant shifter
275	//
276	// rb Khmer robat
277	//
278	// co coeng character (u17D2)
279	//
280	// dv dependent vowel (including split vowels, they are treated in the same way).
281	// even if dv is not defined above, the component that is really tested for is
282	// KhmerClassTable::CC_DEPENDENT_VOWEL, which is common to all dependent vowels
283	//
284	// zwj Zero Width joiner
285	//
286	// zwnj Zero width non joiner
287	//
288	// sa above sign
289	//
290	// sp post sign
291	//
292	// there are lines with equal content but for an easier understanding
293	// (and maybe change in the future) we did not join them
294	//
295	static const le_int8 khmerStateTable[][KhmerClassTable::CC_COUNT] =
296	{
297
298	// xx c1 c2 c3 zwnj cs rb co dv sa sp zwj
299	{ 1, 2, 2, 2, 1, 1, 1, 6, 1, 1, 1, 2}, // 0 - ground state
300	{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, // 1 - exit state (or sign to the right of the syllable)
301	{-1, -1, -1, -1, 3, 4, 5, 6, 16, 17, 1, -1}, // 2 - Base consonant
302	{-1, -1, -1, -1, -1, 4, -1, -1, 16, -1, -1, -1}, // 3 - First ZWNJ before a register shifter
303	// It can only be followed by a shifter or a vowel
304	{-1, -1, -1, -1, 15, -1, -1, 6, 16, 17, 1, 14}, // 4 - First register shifter
305	{-1, -1, -1, -1, -1, -1, -1, -1, 20, -1, 1, -1}, // 5 - Robat
306	{-1, 7, 8, 9, -1, -1, -1, -1, -1, -1, -1, -1}, // 6 - First Coeng
307	{-1, -1, -1, -1, 12, 13, -1, 10, 16, 17, 1, 14}, // 7 - First consonant of type 1 after coeng
308	{-1, -1, -1, -1, 12, 13, -1, -1, 16, 17, 1, 14}, // 8 - First consonant of type 2 after coeng
309	{-1, -1, -1, -1, 12, 13, -1, 10, 16, 17, 1, 14}, // 9 - First consonant or type 3 after ceong
310	{-1, 11, 11, 11, -1, -1, -1, -1, -1, -1, -1, -1}, // 10 - Second Coeng (no register shifter before)
311	{-1, -1, -1, -1, 15, -1, -1, -1, 16, 17, 1, 14}, // 11 - Second coeng consonant (or ind. vowel) no register shifter before
312	{-1, -1, -1, -1, -1, 13, -1, -1, 16, -1, -1, -1}, // 12 - Second ZWNJ before a register shifter
313	{-1, -1, -1, -1, 15, -1, -1, -1, 16, 17, 1, 14}, // 13 - Second register shifter
314	{-1, -1, -1, -1, -1, -1, -1, -1, 16, -1, -1, -1}, // 14 - ZWJ before vowel
315	{-1, -1, -1, -1, -1, -1, -1, -1, 16, -1, -1, -1}, // 15 - ZWNJ before vowel
316	{-1, -1, -1, -1, -1, -1, -1, -1, -1, 17, 1, 18}, // 16 - dependent vowel
317	{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 18}, // 17 - sign above
318	{-1, -1, -1, -1, -1, -1, -1, 19, -1, -1, -1, -1}, // 18 - ZWJ after vowel
319	{-1, 1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1}, // 19 - Third coeng
320	{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1}, // 20 - dependent vowel after a Robat
321
322	};
323
324
325	const FeatureMap *KhmerReordering::getFeatureMap(le_int32 &count)
326	{
327	count = featureMapCount;
328
329	return featureMap;
330	}
331
332
333	// Given an input string of characters and a location in which to start looking
334	// calculate, using the state table, which one is the last character of the syllable
335	// that starts in the starting position.
336	le_int32 KhmerReordering::findSyllable(const KhmerClassTable classTable, const LEUnicode chars, le_int32 prev, le_int32 charCount)
337	{
338	le_int32 cursor = prev;
339	le_int8 state = 0;
340
341	while (cursor < charCount) {
342	KhmerClassTable::CharClass charClass = (classTable->getCharClass(chars[cursor]) & KhmerClassTable::CF_CLASS_MASK);
343
344	state = khmerStateTable[state][charClass];
345
346	if (state < 0) {
347	break;
348	}
349
350	cursor += 1;
351	}
352
353	return cursor;
354	}
355
356
357	// This is the real reordering function as applied to the Khmer language
358
359	le_int32 KhmerReordering::reorder(const LEUnicode chars, le_int32 charCount, le_int32 /scriptCode*/,
360	LEUnicode *outChars, LEGlyphStorage &glyphStorage)
361	{
362	const KhmerClassTable *classTable = KhmerClassTable::getKhmerClassTable();
363
364	KhmerReorderingOutput output(outChars, glyphStorage);
365	KhmerClassTable::CharClass charClass;
366	le_int32 i, prev = 0, coengRo;
367
368
369	// This loop only exits when we reach the end of a run, which may contain
370	// several syllables.
371	while (prev < charCount) {
372	le_int32 syllable = findSyllable(classTable, chars, prev, charCount);
46f4442e A	373
46f4442e A	374	output.reset();
73c04bcf A	375
	376	// write a pre vowel or the pre part of a split vowel first
	377	// and look out for coeng + ro. RO is the only vowel of type 2, and
	378	// therefore the only one that requires saving space before the base.
	379	coengRo = -1; // There is no Coeng Ro, if found this value will change
	380	for (i = prev; i < syllable; i += 1) {
	381	charClass = classTable->getCharClass(chars[i]);
	382
	383	// if a split vowel, write the pre part. In Khmer the pre part
	384	// is the same for all split vowels, same glyph as pre vowel C_VOWEL_E
	385	if (charClass & KhmerClassTable::CF_SPLIT_VOWEL) {
	386	output.writeChar(C_VOWEL_E, i, tagPref);
	387	break; // there can be only one vowel
	388	}
	389
	390	// if a vowel with pos before write it out
	391	if (charClass & KhmerClassTable::CF_POS_BEFORE) {
	392	output.writeChar(chars[i], i, tagPref);
	393	break; // there can be only one vowel
	394	}
	395
	396	// look for coeng + ro and remember position
	397	// works because coeng + ro is always in front of a vowel (if there is a vowel)
	398	// and because CC_CONSONANT2 is enough to identify it, as it is the only consonant
	399	// with this flag
	400	if ( (charClass & KhmerClassTable::CF_COENG) && (i + 1 < syllable) &&
	401	( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK) == KhmerClassTable::CC_CONSONANT2) )
	402	{
	403	coengRo = i;
	404	}
	405	}
	406
	407	// write coeng + ro if found
	408	if (coengRo > -1) {
	409	output.writeChar(C_COENG, coengRo, tagPref);
	410	output.writeChar(C_RO, coengRo + 1, tagPref);
	411	}
	412
	413	// shall we add a dotted circle?
	414	// If in the position in which the base should be (first char in the string) there is
	415	// a character that has the Dotted circle flag (a character that cannot be a base)
	416	// then write a dotted circle
	417	if (classTable->getCharClass(chars[prev]) & KhmerClassTable::CF_DOTTED_CIRCLE) {
	418	output.writeChar(C_DOTTED_CIRCLE, prev, tagDefault);
	419	}
	420
	421	// copy what is left to the output, skipping before vowels and coeng Ro if they are present
	422	for (i = prev; i < syllable; i += 1) {
	423	charClass = classTable->getCharClass(chars[i]);
	424
	425	// skip a before vowel, it was already processed
	426	if (charClass & KhmerClassTable::CF_POS_BEFORE) {
	427	continue;
	428	}
	429
	430	// skip coeng + ro, it was already processed
	431	if (i == coengRo) {
	432	i += 1;
	433	continue;
	434	}
	435
	436	switch (charClass & KhmerClassTable::CF_POS_MASK) {
	437	case KhmerClassTable::CF_POS_ABOVE :
	438	output.writeChar(chars[i], i, tagAbvf);
439	break;
440
441	case KhmerClassTable::CF_POS_AFTER :
442	output.writeChar(chars[i], i, tagPstf);
443	break;
444
445	case KhmerClassTable::CF_POS_BELOW :
446	output.writeChar(chars[i], i, tagBlwf);
447	break;
448
449	default:
450	// assign the correct flags to a coeng consonant
451	// Consonants of type 3 are taged as Post forms and those type 1 as below forms
452	if ( (charClass & KhmerClassTable::CF_COENG) && i + 1 < syllable ) {
453	if ( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK)
454	== KhmerClassTable::CC_CONSONANT3) {
455	output.writeChar(chars[i], i, tagPstf);
456	i += 1;
457	output.writeChar(chars[i], i, tagPstf);
458	}
459	else {
460	output.writeChar(chars[i], i, tagBlwf);
461	i += 1;
462	output.writeChar(chars[i], i, tagBlwf);
463	}
464	break;
465	}
466	// if a shifter is followed by an above vowel change the shifter to below form,
467	// an above vowel can have two possible positions i + 1 or i + 3
468	// (position i+1 corresponds to unicode 3, position i+3 to Unicode 4)
469	// and there is an extra rule for C_VOWEL_AA + C_SIGN_NIKAHIT also for two
470	// different positions, right after the shifter or after a vowel (Unicode 4)
471	if ( (charClass & KhmerClassTable::CF_SHIFTER) && (i + 1 < syllable) ) {
472	if ((classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_ABOVE_VOWEL)
473	\|\| (i + 2 < syllable
474	&& ( (classTable->getCharClass(chars[i + 1]) & KhmerClassTable::CF_CLASS_MASK) == C_VOWEL_AA)
475	&& ( (classTable->getCharClass(chars[i + 2]) & KhmerClassTable::CF_CLASS_MASK) == C_SIGN_NIKAHIT))
476	\|\| (i + 3 < syllable && (classTable->getCharClass(chars[i + 3]) & KhmerClassTable::CF_ABOVE_VOWEL))
477	\|\| (i + 4 < syllable
478	&& ( (classTable->getCharClass(chars[i + 3]) & KhmerClassTable::CF_CLASS_MASK) == C_VOWEL_AA)
479	&& ( (classTable->getCharClass(chars[i + 4]) & KhmerClassTable::CF_CLASS_MASK) == C_SIGN_NIKAHIT) ) )
480	{
481	output.writeChar(chars[i], i, tagBlwf);
482	break;
483	}
484
485	}
486	// default - any other characters
487	output.writeChar(chars[i], i, tagDefault);
488	break;
489	} // switch
490	} // for
491
492	prev = syllable; // move the pointer to the start of next syllable
493	}
494
495	return output.getOutputIndex();
496	}
497
498
499	U_NAMESPACE_END