git.oblomov.eu Git - wine/blob - dlls/usp10/shape.c

   1 /*
   2  * Implementation of Shaping for the Uniscribe Script Processor (usp10.dll)
   3  *
   4  * Copyright 2010 CodeWeavers, Aric Stewart
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21 #include <stdarg.h>
  22 #include <stdlib.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "wingdi.h"
  27 #include "winuser.h"
  28 #include "winnls.h"
  29 #include "usp10.h"
  30 #include "winternl.h"
  31
  32 #include "usp10_internal.h"
  33
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(uniscribe);
  37
  38 #define FIRST_ARABIC_CHAR 0x0600
  39 #define LAST_ARABIC_CHAR  0x06ff
  40
  41 typedef VOID (*ContextualShapingProc)(HDC, ScriptCache*, SCRIPT_ANALYSIS*,
  42                                       WCHAR*, INT, WORD*, INT*, INT, WORD*);
  43
  44 static void ContextualShape_Arabic(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  45 static void ContextualShape_Syriac(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  46 static void ContextualShape_Phags_pa(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  47 static void ContextualShape_Sinhala(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  48 static void ContextualShape_Devanagari(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  49 static void ContextualShape_Bengali(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  50 static void ContextualShape_Gurmukhi(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  51 static void ContextualShape_Gujarati(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  52 static void ContextualShape_Oriya(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  53 static void ContextualShape_Tamil(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  54 static void ContextualShape_Telugu(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  55 static void ContextualShape_Kannada(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  56 static void ContextualShape_Malayalam(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  57 static void ContextualShape_Khmer(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  58 static void ContextualShape_Mongolian(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust);
  59
  60 typedef VOID (*ShapeCharGlyphPropProc)( HDC , ScriptCache*, SCRIPT_ANALYSIS*, const WCHAR*, const INT, const WORD*, const INT, WORD*, SCRIPT_CHARPROP*, SCRIPT_GLYPHPROP*);
  61
  62 static void ShapeCharGlyphProp_Default( HDC hdc, ScriptCache* psc, SCRIPT_ANALYSIS* psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD* pwLogClust, SCRIPT_CHARPROP* pCharProp, SCRIPT_GLYPHPROP* pGlyphProp);
  63 static void ShapeCharGlyphProp_Arabic( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP* pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
  64 static void ShapeCharGlyphProp_Thai( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
  65 static void ShapeCharGlyphProp_None( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
  66 static void ShapeCharGlyphProp_Tibet( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
  67 static void ShapeCharGlyphProp_Sinhala( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
  68 static void ShapeCharGlyphProp_Devanagari( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
  69 static void ShapeCharGlyphProp_Bengali( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
  70 static void ShapeCharGlyphProp_Gurmukhi( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
  71 static void ShapeCharGlyphProp_Gujarati( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
  72 static void ShapeCharGlyphProp_Oriya( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
  73 static void ShapeCharGlyphProp_Tamil( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
  74 static void ShapeCharGlyphProp_Telugu( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
  75 static void ShapeCharGlyphProp_Kannada( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
  76 static void ShapeCharGlyphProp_Malayalam( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
  77 static void ShapeCharGlyphProp_Khmer( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp );
  78
  79 extern const unsigned short indic_syllabic_table[];
  80 extern const unsigned short wine_shaping_table[];
  81 extern const unsigned short wine_shaping_forms[LAST_ARABIC_CHAR - FIRST_ARABIC_CHAR + 1][4];
  82
  83 enum joining_types {
  84     jtU,
  85     jtT,
  86     jtR,
  87     jtL,
  88     jtD,
  89     jtC
  90 };
  91
  92 enum joined_forms {
  93     Xn=0,
  94     Xr,
  95     Xl,
  96     Xm,
  97     /* Syriac Alaph */
  98     Afj,
  99     Afn,
 100     Afx
 101 };
 102
 103 #ifdef WORDS_BIGENDIAN
 104 #define GET_BE_WORD(x) (x)
 105 #define GET_BE_DWORD(x) (x)
 106 #else
 107 #define GET_BE_WORD(x) RtlUshortByteSwap(x)
 108 #define GET_BE_DWORD(x) RtlUlongByteSwap(x)
 109 #endif
 110
 111 /* These are all structures needed for the GSUB table */
 112 #define GSUB_TAG MS_MAKE_TAG('G', 'S', 'U', 'B')
 113 #define GSUB_E_NOFEATURE -2
 114 #define GSUB_E_NOGLYPH -1
 115
 116 typedef struct {
 117     DWORD version;
 118     WORD ScriptList;
 119     WORD FeatureList;
 120     WORD LookupList;
 121 } GSUB_Header;
 122
 123 typedef struct {
 124     CHAR ScriptTag[4];
 125     WORD Script;
 126 } GSUB_ScriptRecord;
 127
 128 typedef struct {
 129     WORD ScriptCount;
 130     GSUB_ScriptRecord ScriptRecord[1];
 131 } GSUB_ScriptList;
 132
 133 typedef struct {
 134     CHAR LangSysTag[4];
 135     WORD LangSys;
 136 } GSUB_LangSysRecord;
 137
 138 typedef struct {
 139     WORD DefaultLangSys;
 140     WORD LangSysCount;
 141     GSUB_LangSysRecord LangSysRecord[1];
 142 } GSUB_Script;
 143
 144 typedef struct {
 145     WORD LookupOrder; /* Reserved */
 146     WORD ReqFeatureIndex;
 147     WORD FeatureCount;
 148     WORD FeatureIndex[1];
 149 } GSUB_LangSys;
 150
 151 typedef struct {
 152     CHAR FeatureTag[4];
 153     WORD Feature;
 154 } GSUB_FeatureRecord;
 155
 156 typedef struct {
 157     WORD FeatureCount;
 158     GSUB_FeatureRecord FeatureRecord[1];
 159 } GSUB_FeatureList;
 160
 161 typedef struct {
 162     WORD FeatureParams; /* Reserved */
 163     WORD LookupCount;
 164     WORD LookupListIndex[1];
 165 } GSUB_Feature;
 166
 167 typedef struct {
 168     WORD LookupCount;
 169     WORD Lookup[1];
 170 } GSUB_LookupList;
 171
 172 typedef struct {
 173     WORD LookupType;
 174     WORD LookupFlag;
 175     WORD SubTableCount;
 176     WORD SubTable[1];
 177 } GSUB_LookupTable;
 178
 179 typedef struct {
 180     WORD CoverageFormat;
 181     WORD GlyphCount;
 182     WORD GlyphArray[1];
 183 } GSUB_CoverageFormat1;
 184
 185 typedef struct {
 186     WORD Start;
 187     WORD End;
 188     WORD StartCoverageIndex;
 189 } GSUB_RangeRecord;
 190
 191 typedef struct {
 192     WORD CoverageFormat;
 193     WORD RangeCount;
 194     GSUB_RangeRecord RangeRecord[1];
 195 } GSUB_CoverageFormat2;
 196
 197 typedef struct {
 198     WORD SubstFormat; /* = 1 */
 199     WORD Coverage;
 200     WORD DeltaGlyphID;
 201 } GSUB_SingleSubstFormat1;
 202
 203 typedef struct {
 204     WORD SubstFormat; /* = 2 */
 205     WORD Coverage;
 206     WORD GlyphCount;
 207     WORD Substitute[1];
 208 }GSUB_SingleSubstFormat2;
 209
 210 typedef struct {
 211     WORD SubstFormat; /* = 1 */
 212     WORD Coverage;
 213     WORD SequenceCount;
 214     WORD Sequence[1];
 215 }GSUB_MultipleSubstFormat1;
 216
 217 typedef struct {
 218     WORD GlyphCount;
 219     WORD Substitute[1];
 220 }GSUB_Sequence;
 221
 222 typedef struct {
 223     WORD SubstFormat; /* = 1 */
 224     WORD Coverage;
 225     WORD LigSetCount;
 226     WORD LigatureSet[1];
 227 }GSUB_LigatureSubstFormat1;
 228
 229 typedef struct {
 230     WORD LigatureCount;
 231     WORD Ligature[1];
 232 }GSUB_LigatureSet;
 233
 234 typedef struct{
 235     WORD LigGlyph;
 236     WORD CompCount;
 237     WORD Component[1];
 238 }GSUB_Ligature;
 239
 240 typedef struct{
 241     WORD SequenceIndex;
 242     WORD LookupListIndex;
 243
 244 }GSUB_SubstLookupRecord;
 245
 246 typedef struct{
 247     WORD SubstFormat; /* = 1 */
 248     WORD Coverage;
 249     WORD ChainSubRuleSetCount;
 250     WORD ChainSubRuleSet[1];
 251 }GSUB_ChainContextSubstFormat1;
 252
 253 typedef struct {
 254     WORD SubstFormat; /* = 3 */
 255     WORD BacktrackGlyphCount;
 256     WORD Coverage[1];
 257 }GSUB_ChainContextSubstFormat3_1;
 258
 259 typedef struct{
 260     WORD InputGlyphCount;
 261     WORD Coverage[1];
 262 }GSUB_ChainContextSubstFormat3_2;
 263
 264 typedef struct{
 265     WORD LookaheadGlyphCount;
 266     WORD Coverage[1];
 267 }GSUB_ChainContextSubstFormat3_3;
 268
 269 typedef struct{
 270     WORD SubstCount;
 271     GSUB_SubstLookupRecord SubstLookupRecord[1];
 272 }GSUB_ChainContextSubstFormat3_4;
 273
 274 typedef struct {
 275     WORD SubstFormat; /* = 1 */
 276     WORD Coverage;
 277     WORD AlternateSetCount;
 278     WORD AlternateSet[1];
 279 } GSUB_AlternateSubstFormat1;
 280
 281 typedef struct{
 282     WORD GlyphCount;
 283     WORD Alternate[1];
 284 } GSUB_AlternateSet;
 285
 286 /* These are all structures needed for the GDEF table */
 287 #define GDEF_TAG MS_MAKE_TAG('G', 'D', 'E', 'F')
 288
 289 enum {BaseGlyph=1, LigatureGlyph, MarkGlyph, ComponentGlyph};
 290
 291 typedef struct {
 292     DWORD Version;
 293     WORD GlyphClassDef;
 294     WORD AttachList;
 295     WORD LigCaretList;
 296     WORD MarkAttachClassDef;
 297 } GDEF_Header;
 298
 299 typedef struct {
 300     WORD ClassFormat;
 301     WORD StartGlyph;
 302     WORD GlyphCount;
 303     WORD ClassValueArray[1];
 304 } GDEF_ClassDefFormat1;
 305
 306 typedef struct {
 307     WORD Start;
 308     WORD End;
 309     WORD Class;
 310 } GDEF_ClassRangeRecord;
 311
 312 typedef struct {
 313     WORD ClassFormat;
 314     WORD ClassRangeCount;
 315     GDEF_ClassRangeRecord ClassRangeRecord[1];
 316 } GDEF_ClassDefFormat2;
 317
 318
 319 /* These are all structures needed for the cmap format 12 table */
 320 #define CMAP_TAG MS_MAKE_TAG('c', 'm', 'a', 'p')
 321
 322 typedef struct {
 323     WORD platformID;
 324     WORD encodingID;
 325     DWORD offset;
 326 } CMAP_EncodingRecord;
 327
 328 typedef struct {
 329     WORD version;
 330     WORD numTables;
 331     CMAP_EncodingRecord tables[1];
 332 } CMAP_Header;
 333
 334 typedef struct {
 335     DWORD startCharCode;
 336     DWORD endCharCode;
 337     DWORD startGlyphID;
 338 } CMAP_SegmentedCoverage_group;
 339
 340 typedef struct {
 341     WORD format;
 342     WORD reserved;
 343     DWORD length;
 344     DWORD language;
 345     DWORD nGroups;
 346     CMAP_SegmentedCoverage_group groups[1];
 347 } CMAP_SegmentedCoverage;
 348
 349 static INT GSUB_apply_lookup(const GSUB_LookupList* lookup, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count);
 350
 351 typedef struct tagVowelComponents
 352 {
 353     WCHAR base;
 354     WCHAR parts[3];
 355 } VowelComponents;
 356
 357 typedef struct tagConsonantComponents
 358 {
 359     WCHAR parts[3];
 360     WCHAR output;
 361 } ConsonantComponents;
 362
 363 typedef void (*second_reorder_function)(LPWSTR pwChar, IndicSyllable *syllable,WORD* pwGlyphs, IndicSyllable* glyph_index, lexical_function lex);
 364
 365 /* the orders of joined_forms and contextual_features need to line up */
 366 static const char* contextual_features[] =
 367 {
 368     "isol",
 369     "fina",
 370     "init",
 371     "medi",
 372     /* Syriac Alaph */
 373     "med2",
 374     "fin2",
 375     "fin3"
 376 };
 377
 378 static OPENTYPE_FEATURE_RECORD standard_features[] =
 379 {
 380     { MS_MAKE_TAG('c','c','m','p'), 1},
 381     { MS_MAKE_TAG('l','o','c','l'), 1},
 382 };
 383
 384 static OPENTYPE_FEATURE_RECORD latin_features[] =
 385 {
 386     { MS_MAKE_TAG('l','i','g','a'), 1},
 387     { MS_MAKE_TAG('c','l','i','g'), 1},
 388 };
 389
 390 static OPENTYPE_FEATURE_RECORD arabic_features[] =
 391 {
 392     { MS_MAKE_TAG('r','l','i','g'), 1},
 393     { MS_MAKE_TAG('c','a','l','t'), 1},
 394     { MS_MAKE_TAG('l','i','g','a'), 1},
 395     { MS_MAKE_TAG('d','l','i','g'), 1},
 396     { MS_MAKE_TAG('c','s','w','h'), 1},
 397     { MS_MAKE_TAG('m','s','e','t'), 1},
 398 };
 399
 400 static const char* required_arabic_features[] =
 401 {
 402     "fina",
 403     "init",
 404     "medi",
 405     "rlig",
 406     NULL
 407 };
 408
 409 static OPENTYPE_FEATURE_RECORD hebrew_features[] =
 410 {
 411     { MS_MAKE_TAG('d','l','i','g'), 0},
 412 };
 413
 414 static OPENTYPE_FEATURE_RECORD syriac_features[] =
 415 {
 416     { MS_MAKE_TAG('r','l','i','g'), 1},
 417     { MS_MAKE_TAG('c','a','l','t'), 1},
 418     { MS_MAKE_TAG('l','i','g','a'), 1},
 419     { MS_MAKE_TAG('d','l','i','g'), 1},
 420 };
 421
 422 static const char* required_syriac_features[] =
 423 {
 424     "fina",
 425     "fin2",
 426     "fin3",
 427     "init",
 428     "medi",
 429     "med2",
 430     "rlig",
 431     NULL
 432 };
 433
 434 static OPENTYPE_FEATURE_RECORD sinhala_features[] =
 435 {
 436     /* Presentation forms */
 437     { MS_MAKE_TAG('b','l','w','s'), 1},
 438     { MS_MAKE_TAG('a','b','v','s'), 1},
 439     { MS_MAKE_TAG('p','s','t','s'), 1},
 440 };
 441
 442 static OPENTYPE_FEATURE_RECORD tibetan_features[] =
 443 {
 444     { MS_MAKE_TAG('a','b','v','s'), 1},
 445     { MS_MAKE_TAG('b','l','w','s'), 1},
 446 };
 447
 448 static OPENTYPE_FEATURE_RECORD phags_features[] =
 449 {
 450     { MS_MAKE_TAG('a','b','v','s'), 1},
 451     { MS_MAKE_TAG('b','l','w','s'), 1},
 452     { MS_MAKE_TAG('c','a','l','t'), 1},
 453 };
 454
 455 static OPENTYPE_FEATURE_RECORD thai_features[] =
 456 {
 457     { MS_MAKE_TAG('c','c','m','p'), 1},
 458 };
 459
 460 static const char* required_lao_features[] =
 461 {
 462     "ccmp",
 463     NULL
 464 };
 465
 466 static const char* required_devanagari_features[] =
 467 {
 468     "nukt",
 469     "akhn",
 470     "rphf",
 471     "blwf",
 472     "half",
 473     "vatu",
 474     "pres",
 475     "abvs",
 476     "blws",
 477     "psts",
 478     "haln",
 479     NULL
 480 };
 481
 482 static OPENTYPE_FEATURE_RECORD devanagari_features[] =
 483 {
 484     { MS_MAKE_TAG('p','r','e','s'), 1},
 485     { MS_MAKE_TAG('a','b','v','s'), 1},
 486     { MS_MAKE_TAG('b','l','w','s'), 1},
 487     { MS_MAKE_TAG('p','s','t','s'), 1},
 488     { MS_MAKE_TAG('h','a','l','n'), 1},
 489     { MS_MAKE_TAG('c','a','l','t'), 1},
 490 };
 491
 492 static OPENTYPE_FEATURE_RECORD myanmar_features[] =
 493 {
 494     { MS_MAKE_TAG('l','i','g','a'), 1},
 495     { MS_MAKE_TAG('c','l','i','g'), 1},
 496 };
 497
 498 static const char* required_bengali_features[] =
 499 {
 500     "nukt",
 501     "akhn",
 502     "rphf",
 503     "blwf",
 504     "half",
 505     "vatu",
 506     "pstf",
 507     "init",
 508     "abvs",
 509     "blws",
 510     "psts",
 511     "haln",
 512     NULL
 513 };
 514
 515 static const char* required_gurmukhi_features[] =
 516 {
 517     "nukt",
 518     "akhn",
 519     "rphf",
 520     "blwf",
 521     "half",
 522     "pstf",
 523     "vatu",
 524     "cjct",
 525     "pres",
 526     "abvs",
 527     "blws",
 528     "psts",
 529     "haln",
 530     "calt",
 531     NULL
 532 };
 533
 534 static const char* required_oriya_features[] =
 535 {
 536     "nukt",
 537     "akhn",
 538     "rphf",
 539     "blwf",
 540     "pstf",
 541     "cjct",
 542     "pres",
 543     "abvs",
 544     "blws",
 545     "psts",
 546     "haln",
 547     "calt",
 548     NULL
 549 };
 550
 551 static const char* required_tamil_features[] =
 552 {
 553     "nukt",
 554     "akhn",
 555     "rphf",
 556     "pref",
 557     "half",
 558     "pres",
 559     "abvs",
 560     "blws",
 561     "psts",
 562     "haln",
 563     "calt",
 564     NULL
 565 };
 566
 567 static const char* required_telugu_features[] =
 568 {
 569     "nukt",
 570     "akhn",
 571     "rphf",
 572     "pref",
 573     "half",
 574     "pstf",
 575     "cjct",
 576     "pres",
 577     "abvs",
 578     "blws",
 579     "psts",
 580     "haln",
 581     "calt",
 582     NULL
 583 };
 584
 585 static OPENTYPE_FEATURE_RECORD khmer_features[] =
 586 {
 587     { MS_MAKE_TAG('p','r','e','s'), 1},
 588     { MS_MAKE_TAG('b','l','w','s'), 1},
 589     { MS_MAKE_TAG('a','b','v','s'), 1},
 590     { MS_MAKE_TAG('p','s','t','s'), 1},
 591     { MS_MAKE_TAG('c','l','i','g'), 1},
 592 };
 593
 594 static const char* required_khmer_features[] =
 595 {
 596     "pref",
 597     "blwf",
 598     "abvf",
 599     "pstf",
 600     "pres",
 601     "blws",
 602     "abvs",
 603     "psts",
 604     "clig",
 605     NULL
 606 };
 607
 608 static OPENTYPE_FEATURE_RECORD no_features[] =
 609 { };
 610
 611 static OPENTYPE_FEATURE_RECORD ethiopic_features[] =
 612 {
 613     { MS_MAKE_TAG('c','c','m','p'), 1},
 614     { MS_MAKE_TAG('l','o','c','l'), 1},
 615     { MS_MAKE_TAG('c','a','l','t'), 1},
 616     { MS_MAKE_TAG('l','i','g','a'), 1},
 617 };
 618
 619 static OPENTYPE_FEATURE_RECORD mongolian_features[] =
 620 {
 621     { MS_MAKE_TAG('c','c','m','p'), 1},
 622     { MS_MAKE_TAG('l','o','c','l'), 1},
 623     { MS_MAKE_TAG('c','a','l','t'), 1},
 624     { MS_MAKE_TAG('r','l','i','g'), 1},
 625 };
 626
 627 typedef struct ScriptShapeDataTag {
 628     TEXTRANGE_PROPERTIES   defaultTextRange;
 629     const char**           requiredFeatures;
 630     CHAR                   otTag[5];
 631     CHAR                   newOtTag[5];
 632     ContextualShapingProc  contextProc;
 633     ShapeCharGlyphPropProc charGlyphPropProc;
 634 } ScriptShapeData;
 635
 636 /* in order of scripts */
 637 static const ScriptShapeData ShapingData[] =
 638 {
 639     {{ standard_features, 2}, NULL, "", "", NULL, NULL},
 640     {{ latin_features, 2}, NULL, "latn", "", NULL, NULL},
 641     {{ latin_features, 2}, NULL, "latn", "", NULL, NULL},
 642     {{ latin_features, 2}, NULL, "latn", "", NULL, NULL},
 643     {{ standard_features, 2}, NULL, "" , "", NULL, NULL},
 644     {{ latin_features, 2}, NULL, "latn", "", NULL, NULL},
 645     {{ arabic_features, 6}, required_arabic_features, "arab", "", ContextualShape_Arabic, ShapeCharGlyphProp_Arabic},
 646     {{ arabic_features, 6}, required_arabic_features, "arab", "", ContextualShape_Arabic, ShapeCharGlyphProp_Arabic},
 647     {{ hebrew_features, 1}, NULL, "hebr", "", NULL, NULL},
 648     {{ syriac_features, 4}, required_syriac_features, "syrc", "", ContextualShape_Syriac, ShapeCharGlyphProp_None},
 649     {{ arabic_features, 6}, required_arabic_features, "arab", "", ContextualShape_Arabic, ShapeCharGlyphProp_Arabic},
 650     {{ NULL, 0}, NULL, "thaa", "", NULL, ShapeCharGlyphProp_None},
 651     {{ standard_features, 2}, NULL, "grek", "", NULL, NULL},
 652     {{ standard_features, 2}, NULL, "cyrl", "", NULL, NULL},
 653     {{ standard_features, 2}, NULL, "armn", "", NULL, NULL},
 654     {{ standard_features, 2}, NULL, "geor", "", NULL, NULL},
 655     {{ sinhala_features, 3}, NULL, "sinh", "", ContextualShape_Sinhala, ShapeCharGlyphProp_Sinhala},
 656     {{ tibetan_features, 2}, NULL, "tibt", "", NULL, ShapeCharGlyphProp_Tibet},
 657     {{ tibetan_features, 2}, NULL, "tibt", "", NULL, ShapeCharGlyphProp_Tibet},
 658     {{ phags_features, 3}, NULL, "phag", "", ContextualShape_Phags_pa, ShapeCharGlyphProp_Thai},
 659     {{ thai_features, 1}, NULL, "thai", "", NULL, ShapeCharGlyphProp_Thai},
 660     {{ thai_features, 1}, NULL, "thai", "", NULL, ShapeCharGlyphProp_Thai},
 661     {{ thai_features, 1}, required_lao_features, "lao", "", NULL, ShapeCharGlyphProp_Thai},
 662     {{ thai_features, 1}, required_lao_features, "lao", "", NULL, ShapeCharGlyphProp_Thai},
 663     {{ devanagari_features, 6}, required_devanagari_features, "deva", "dev2", ContextualShape_Devanagari, ShapeCharGlyphProp_Devanagari},
 664     {{ devanagari_features, 6}, required_devanagari_features, "deva", "dev2", ContextualShape_Devanagari, ShapeCharGlyphProp_Devanagari},
 665     {{ devanagari_features, 6}, required_bengali_features, "beng", "bng2", ContextualShape_Bengali, ShapeCharGlyphProp_Bengali},
 666     {{ devanagari_features, 6}, required_bengali_features, "beng", "bng2", ContextualShape_Bengali, ShapeCharGlyphProp_Bengali},
 667     {{ devanagari_features, 6}, required_bengali_features, "beng", "bng2", ContextualShape_Bengali, ShapeCharGlyphProp_Bengali},
 668     {{ devanagari_features, 6}, required_gurmukhi_features, "guru", "gur2", ContextualShape_Gurmukhi, ShapeCharGlyphProp_Gurmukhi},
 669     {{ devanagari_features, 6}, required_gurmukhi_features, "guru", "gur2", ContextualShape_Gurmukhi, ShapeCharGlyphProp_Gurmukhi},
 670     {{ devanagari_features, 6}, required_devanagari_features, "gujr", "gjr2", ContextualShape_Gujarati, ShapeCharGlyphProp_Gujarati},
 671     {{ devanagari_features, 6}, required_devanagari_features, "gujr", "gjr2", ContextualShape_Gujarati, ShapeCharGlyphProp_Gujarati},
 672     {{ devanagari_features, 6}, required_devanagari_features, "gujr", "gjr2", ContextualShape_Gujarati, ShapeCharGlyphProp_Gujarati},
 673     {{ devanagari_features, 6}, required_oriya_features, "orya", "ory2", ContextualShape_Oriya, ShapeCharGlyphProp_Oriya},
 674     {{ devanagari_features, 6}, required_oriya_features, "orya", "ory2", ContextualShape_Oriya, ShapeCharGlyphProp_Oriya},
 675     {{ devanagari_features, 6}, required_tamil_features, "taml", "tam2", ContextualShape_Tamil, ShapeCharGlyphProp_Tamil},
 676     {{ devanagari_features, 6}, required_tamil_features, "taml", "tam2", ContextualShape_Tamil, ShapeCharGlyphProp_Tamil},
 677     {{ devanagari_features, 6}, required_telugu_features, "telu", "tel2", ContextualShape_Telugu, ShapeCharGlyphProp_Telugu},
 678     {{ devanagari_features, 6}, required_telugu_features, "telu", "tel2", ContextualShape_Telugu, ShapeCharGlyphProp_Telugu},
 679     {{ devanagari_features, 6}, required_telugu_features, "knda", "knd2", ContextualShape_Kannada, ShapeCharGlyphProp_Kannada},
 680     {{ devanagari_features, 6}, required_telugu_features, "knda", "knd2", ContextualShape_Kannada, ShapeCharGlyphProp_Kannada},
 681     {{ devanagari_features, 6}, required_telugu_features, "mlym", "mlm2", ContextualShape_Malayalam, ShapeCharGlyphProp_Malayalam},
 682     {{ devanagari_features, 6}, required_telugu_features, "mlym", "mlm2", ContextualShape_Malayalam, ShapeCharGlyphProp_Malayalam},
 683     {{ standard_features, 2}, NULL, "" , "", NULL, NULL},
 684     {{ latin_features, 2}, NULL, "latn" , "", NULL, NULL},
 685     {{ standard_features, 2}, NULL, "" , "", NULL, NULL},
 686     {{ myanmar_features, 2}, NULL, "mymr", "", NULL, NULL},
 687     {{ myanmar_features, 2}, NULL, "mymr", "", NULL, NULL},
 688     {{ standard_features, 2}, NULL, "tale", "", NULL, NULL},
 689     {{ standard_features, 2}, NULL, "talu", "", NULL, NULL},
 690     {{ standard_features, 2}, NULL, "talu", "", NULL, NULL},
 691     {{ khmer_features, 5}, required_khmer_features, "khmr", "", ContextualShape_Khmer, ShapeCharGlyphProp_Khmer},
 692     {{ khmer_features, 5}, required_khmer_features, "khmr", "", ContextualShape_Khmer, ShapeCharGlyphProp_Khmer},
 693     {{ no_features, 0}, NULL, "hani", "", NULL, NULL},
 694     {{ no_features, 0}, NULL, "hani", "", NULL, NULL},
 695     {{ no_features, 0}, NULL, "bopo", "", NULL, NULL},
 696     {{ no_features, 0}, NULL, "kana", "", NULL, NULL},
 697     {{ no_features, 0}, NULL, "hang", "", NULL, NULL},
 698     {{ no_features, 0}, NULL, "yi  ", "", NULL, NULL},
 699     {{ ethiopic_features, 4}, NULL, "ethi", "", NULL, NULL},
 700     {{ ethiopic_features, 4}, NULL, "ethi", "", NULL, NULL},
 701     {{ mongolian_features, 4}, NULL, "mong", "", ContextualShape_Mongolian, NULL},
 702     {{ mongolian_features, 4}, NULL, "mong", "", ContextualShape_Mongolian, NULL},
 703     {{ no_features, 0}, NULL, "tfng", "", NULL, NULL},
 704     {{ no_features, 0}, NULL, "nko ", "", NULL, NULL},
 705     {{ no_features, 0}, NULL, "vai ", "", NULL, NULL},
 706     {{ no_features, 0}, NULL, "vai ", "", NULL, NULL},
 707     {{ no_features, 0}, NULL, "cher", "", NULL, NULL},
 708     {{ no_features, 0}, NULL, "cans", "", NULL, NULL},
 709     {{ no_features, 0}, NULL, "ogam", "", NULL, NULL},
 710     {{ no_features, 0}, NULL, "runr", "", NULL, NULL},
 711     {{ no_features, 0}, NULL, "brai", "", NULL, NULL},
 712     {{ no_features, 0}, NULL, "", "", NULL, NULL},
 713     {{ no_features, 0}, NULL, "", "", NULL, NULL},
 714     {{ no_features, 0}, NULL, "dsrt", "", NULL, NULL},
 715     {{ no_features, 0}, NULL, "osma", "", NULL, NULL},
 716     {{ no_features, 0}, NULL, "osma", "", NULL, NULL},
 717 };
 718
 719 static INT GSUB_is_glyph_covered(LPCVOID table , UINT glyph)
 720 {
 721     const GSUB_CoverageFormat1* cf1;
 722
 723     cf1 = table;
 724
 725     if (GET_BE_WORD(cf1->CoverageFormat) == 1)
 726     {
 727         int count = GET_BE_WORD(cf1->GlyphCount);
 728         int i;
 729         TRACE("Coverage Format 1, %i glyphs\n",count);
 730         for (i = 0; i < count; i++)
 731             if (glyph == GET_BE_WORD(cf1->GlyphArray[i]))
 732                 return i;
 733         return -1;
 734     }
 735     else if (GET_BE_WORD(cf1->CoverageFormat) == 2)
 736     {
 737         const GSUB_CoverageFormat2* cf2;
 738         int i;
 739         int count;
 740         cf2 = (const GSUB_CoverageFormat2*)cf1;
 741
 742         count = GET_BE_WORD(cf2->RangeCount);
 743         TRACE("Coverage Format 2, %i ranges\n",count);
 744         for (i = 0; i < count; i++)
 745         {
 746             if (glyph < GET_BE_WORD(cf2->RangeRecord[i].Start))
 747                 return -1;
 748             if ((glyph >= GET_BE_WORD(cf2->RangeRecord[i].Start)) &&
 749                 (glyph <= GET_BE_WORD(cf2->RangeRecord[i].End)))
 750             {
 751                 return (GET_BE_WORD(cf2->RangeRecord[i].StartCoverageIndex) +
 752                     glyph - GET_BE_WORD(cf2->RangeRecord[i].Start));
 753             }
 754         }
 755         return -1;
 756     }
 757     else
 758         ERR("Unknown CoverageFormat %i\n",GET_BE_WORD(cf1->CoverageFormat));
 759
 760     return -1;
 761 }
 762
 763 static const GSUB_Script* GSUB_get_script_table( const GSUB_Header* header, const char* tag)
 764 {
 765     const GSUB_ScriptList *script;
 766     const GSUB_Script *deflt = NULL;
 767     int i;
 768     script = (const GSUB_ScriptList*)((const BYTE*)header + GET_BE_WORD(header->ScriptList));
 769
 770     TRACE("%i scripts in this font\n",GET_BE_WORD(script->ScriptCount));
 771     for (i = 0; i < GET_BE_WORD(script->ScriptCount); i++)
 772     {
 773         const GSUB_Script *scr;
 774         int offset;
 775
 776         offset = GET_BE_WORD(script->ScriptRecord[i].Script);
 777         scr = (const GSUB_Script*)((const BYTE*)script + offset);
 778
 779         if (strncmp(script->ScriptRecord[i].ScriptTag, tag,4)==0)
 780             return scr;
 781         if (strncmp(script->ScriptRecord[i].ScriptTag, "dflt",4)==0)
 782             deflt = scr;
 783     }
 784     return deflt;
 785 }
 786
 787 static const GSUB_LangSys* GSUB_get_lang_table( const GSUB_Script* script, const char* tag)
 788 {
 789     int i;
 790     int offset;
 791     const GSUB_LangSys *Lang;
 792
 793     TRACE("Deflang %x, LangCount %i\n",GET_BE_WORD(script->DefaultLangSys), GET_BE_WORD(script->LangSysCount));
 794
 795     for (i = 0; i < GET_BE_WORD(script->LangSysCount) ; i++)
 796     {
 797         offset = GET_BE_WORD(script->LangSysRecord[i].LangSys);
 798         Lang = (const GSUB_LangSys*)((const BYTE*)script + offset);
 799
 800         if ( strncmp(script->LangSysRecord[i].LangSysTag,tag,4)==0)
 801             return Lang;
 802     }
 803     offset = GET_BE_WORD(script->DefaultLangSys);
 804     if (offset)
 805     {
 806         Lang = (const GSUB_LangSys*)((const BYTE*)script + offset);
 807         return Lang;
 808     }
 809     return NULL;
 810 }
 811
 812 static const GSUB_Feature * GSUB_get_feature(const GSUB_Header *header, const GSUB_LangSys *lang, const char* tag)
 813 {
 814     int i;
 815     const GSUB_FeatureList *feature;
 816     feature = (const GSUB_FeatureList*)((const BYTE*)header + GET_BE_WORD(header->FeatureList));
 817
 818     TRACE("%i features\n",GET_BE_WORD(lang->FeatureCount));
 819     for (i = 0; i < GET_BE_WORD(lang->FeatureCount); i++)
 820     {
 821         int index = GET_BE_WORD(lang->FeatureIndex[i]);
 822         if (strncmp(feature->FeatureRecord[index].FeatureTag,tag,4)==0)
 823         {
 824             const GSUB_Feature *feat;
 825             feat = (const GSUB_Feature*)((const BYTE*)feature + GET_BE_WORD(feature->FeatureRecord[index].Feature));
 826             return feat;
 827         }
 828     }
 829     return NULL;
 830 }
 831
 832 static INT GSUB_apply_SingleSubst(const GSUB_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 833 {
 834     int j;
 835     TRACE("Single Substitution Subtable\n");
 836
 837     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
 838     {
 839         int offset;
 840         const GSUB_SingleSubstFormat1 *ssf1;
 841         offset = GET_BE_WORD(look->SubTable[j]);
 842         ssf1 = (const GSUB_SingleSubstFormat1*)((const BYTE*)look+offset);
 843         if (GET_BE_WORD(ssf1->SubstFormat) == 1)
 844         {
 845             int offset = GET_BE_WORD(ssf1->Coverage);
 846             TRACE("  subtype 1, delta %i\n", GET_BE_WORD(ssf1->DeltaGlyphID));
 847             if (GSUB_is_glyph_covered((const BYTE*)ssf1+offset, glyphs[glyph_index]) != -1)
 848             {
 849                 TRACE("  Glyph 0x%x ->",glyphs[glyph_index]);
 850                 glyphs[glyph_index] = glyphs[glyph_index] + GET_BE_WORD(ssf1->DeltaGlyphID);
 851                 TRACE(" 0x%x\n",glyphs[glyph_index]);
 852                 return glyph_index + write_dir;
 853             }
 854         }
 855         else
 856         {
 857             const GSUB_SingleSubstFormat2 *ssf2;
 858             INT index;
 859             INT offset;
 860
 861             ssf2 = (const GSUB_SingleSubstFormat2 *)ssf1;
 862             offset = GET_BE_WORD(ssf1->Coverage);
 863             TRACE("  subtype 2,  glyph count %i\n", GET_BE_WORD(ssf2->GlyphCount));
 864             index = GSUB_is_glyph_covered((const BYTE*)ssf2+offset, glyphs[glyph_index]);
 865             TRACE("  Coverage index %i\n",index);
 866             if (index != -1)
 867             {
 868                 if (glyphs[glyph_index] == GET_BE_WORD(ssf2->Substitute[index]))
 869                     return GSUB_E_NOGLYPH;
 870
 871                 TRACE("    Glyph is 0x%x ->",glyphs[glyph_index]);
 872                 glyphs[glyph_index] = GET_BE_WORD(ssf2->Substitute[index]);
 873                 TRACE("0x%x\n",glyphs[glyph_index]);
 874                 return glyph_index + write_dir;
 875             }
 876         }
 877     }
 878     return GSUB_E_NOGLYPH;
 879 }
 880
 881 static INT GSUB_apply_MultipleSubst(const GSUB_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 882 {
 883     int j;
 884     TRACE("Multiple Substitution Subtable\n");
 885
 886     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
 887     {
 888         int offset, index;
 889         const GSUB_MultipleSubstFormat1 *msf1;
 890         offset = GET_BE_WORD(look->SubTable[j]);
 891         msf1 = (const GSUB_MultipleSubstFormat1*)((const BYTE*)look+offset);
 892
 893         offset = GET_BE_WORD(msf1->Coverage);
 894         index = GSUB_is_glyph_covered((const BYTE*)msf1+offset, glyphs[glyph_index]);
 895         if (index != -1)
 896         {
 897             const GSUB_Sequence *seq;
 898             int sub_count;
 899             int j;
 900             offset = GET_BE_WORD(msf1->Sequence[index]);
 901             seq = (const GSUB_Sequence*)((const BYTE*)msf1+offset);
 902             sub_count = GET_BE_WORD(seq->GlyphCount);
 903             TRACE("  Glyph 0x%x (+%i)->",glyphs[glyph_index],(sub_count-1));
 904
 905             for (j = (*glyph_count)+(sub_count-1); j > glyph_index; j--)
 906                     glyphs[j] =glyphs[j-(sub_count-1)];
 907
 908             for (j = 0; j < sub_count; j++)
 909                     if (write_dir < 0)
 910                         glyphs[glyph_index + (sub_count-1) - j] = GET_BE_WORD(seq->Substitute[j]);
 911                     else
 912                         glyphs[glyph_index + j] = GET_BE_WORD(seq->Substitute[j]);
 913
 914             *glyph_count = *glyph_count + (sub_count - 1);
 915
 916             if (TRACE_ON(uniscribe))
 917             {
 918                 for (j = 0; j < sub_count; j++)
 919                     TRACE(" 0x%x",glyphs[glyph_index+j]);
 920                 TRACE("\n");
 921             }
 922
 923             return glyph_index + (sub_count * write_dir);
 924         }
 925     }
 926     return GSUB_E_NOGLYPH;
 927 }
 928
 929 static INT GSUB_apply_AlternateSubst(const GSUB_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 930 {
 931     int j;
 932     TRACE("Alternate Substitution Subtable\n");
 933
 934     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
 935     {
 936         int offset;
 937         const GSUB_AlternateSubstFormat1 *asf1;
 938         INT index;
 939
 940         offset = GET_BE_WORD(look->SubTable[j]);
 941         asf1 = (const GSUB_AlternateSubstFormat1*)((const BYTE*)look+offset);
 942         offset = GET_BE_WORD(asf1->Coverage);
 943
 944         index = GSUB_is_glyph_covered((const BYTE*)asf1+offset, glyphs[glyph_index]);
 945         if (index != -1)
 946         {
 947             const GSUB_AlternateSet *as;
 948             offset =  GET_BE_WORD(asf1->AlternateSet[index]);
 949             as = (const GSUB_AlternateSet*)((const BYTE*)asf1+offset);
 950             FIXME("%i alternates, picking index 0\n",GET_BE_WORD(as->GlyphCount));
 951             if (glyphs[glyph_index] == GET_BE_WORD(as->Alternate[0]))
 952                 return GSUB_E_NOGLYPH;
 953
 954             TRACE("  Glyph 0x%x ->",glyphs[glyph_index]);
 955             glyphs[glyph_index] = GET_BE_WORD(as->Alternate[0]);
 956             TRACE(" 0x%x\n",glyphs[glyph_index]);
 957             return glyph_index + write_dir;
 958         }
 959     }
 960     return GSUB_E_NOGLYPH;
 961 }
 962
 963 static INT GSUB_apply_LigatureSubst(const GSUB_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
 964 {
 965     int j;
 966
 967     TRACE("Ligature Substitution Subtable\n");
 968     for (j = 0; j < GET_BE_WORD(look->SubTableCount); j++)
 969     {
 970         const GSUB_LigatureSubstFormat1 *lsf1;
 971         int offset,index;
 972
 973         offset = GET_BE_WORD(look->SubTable[j]);
 974         lsf1 = (const GSUB_LigatureSubstFormat1*)((const BYTE*)look+offset);
 975         offset = GET_BE_WORD(lsf1->Coverage);
 976         index = GSUB_is_glyph_covered((const BYTE*)lsf1+offset, glyphs[glyph_index]);
 977         TRACE("  Coverage index %i\n",index);
 978         if (index != -1)
 979         {
 980             const GSUB_LigatureSet *ls;
 981             int k, count;
 982
 983             offset = GET_BE_WORD(lsf1->LigatureSet[index]);
 984             ls = (const GSUB_LigatureSet*)((const BYTE*)lsf1+offset);
 985             count = GET_BE_WORD(ls->LigatureCount);
 986             TRACE("  LigatureSet has %i members\n",count);
 987             for (k = 0; k < count; k++)
 988             {
 989                 const GSUB_Ligature *lig;
 990                 int CompCount,l,CompIndex;
 991
 992                 offset = GET_BE_WORD(ls->Ligature[k]);
 993                 lig = (const GSUB_Ligature*)((const BYTE*)ls+offset);
 994                 CompCount = GET_BE_WORD(lig->CompCount) - 1;
 995                 CompIndex = glyph_index+write_dir;
 996                 for (l = 0; l < CompCount && CompIndex >= 0 && CompIndex < *glyph_count; l++)
 997                 {
 998                     int CompGlyph;
 999                     CompGlyph = GET_BE_WORD(lig->Component[l]);
1000                     if (CompGlyph != glyphs[CompIndex])
1001                         break;
1002                     CompIndex += write_dir;
1003                 }
1004                 if (l == CompCount)
1005                 {
1006                     int replaceIdx = glyph_index;
1007                     if (write_dir < 0)
1008                         replaceIdx = glyph_index - CompCount;
1009
1010                     TRACE("    Glyph is 0x%x (+%i) ->",glyphs[glyph_index],CompCount);
1011                     glyphs[replaceIdx] = GET_BE_WORD(lig->LigGlyph);
1012                     TRACE("0x%x\n",glyphs[replaceIdx]);
1013                     if (CompCount > 0)
1014                     {
1015                         int j;
1016                         for (j = replaceIdx + 1; j < *glyph_count; j++)
1017                             glyphs[j] =glyphs[j+CompCount];
1018                         *glyph_count = *glyph_count - CompCount;
1019                     }
1020                     return replaceIdx + write_dir;
1021                 }
1022             }
1023         }
1024     }
1025     return GSUB_E_NOGLYPH;
1026 }
1027
1028 static INT GSUB_apply_ChainContextSubst(const GSUB_LookupList* lookup, const GSUB_LookupTable *look, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
1029 {
1030     int j;
1031     BOOL done = FALSE;
1032
1033     TRACE("Chaining Contextual Substitution Subtable\n");
1034     for (j = 0; j < GET_BE_WORD(look->SubTableCount) && !done; j++)
1035     {
1036         const GSUB_ChainContextSubstFormat1 *ccsf1;
1037         int offset;
1038         int dirLookahead = write_dir;
1039         int dirBacktrack = -1 * write_dir;
1040
1041         offset = GET_BE_WORD(look->SubTable[j]);
1042         ccsf1 = (const GSUB_ChainContextSubstFormat1*)((const BYTE*)look+offset);
1043         if (GET_BE_WORD(ccsf1->SubstFormat) == 1)
1044         {
1045             FIXME("  TODO: subtype 1 (Simple context glyph substitution)\n");
1046             continue;
1047         }
1048         else if (GET_BE_WORD(ccsf1->SubstFormat) == 2)
1049         {
1050             FIXME("  TODO: subtype 2 (Class-based Chaining Context Glyph Substitution)\n");
1051             continue;
1052         }
1053         else if (GET_BE_WORD(ccsf1->SubstFormat) == 3)
1054         {
1055             int k;
1056             int indexGlyphs;
1057             const GSUB_ChainContextSubstFormat3_1 *ccsf3_1;
1058             const GSUB_ChainContextSubstFormat3_2 *ccsf3_2;
1059             const GSUB_ChainContextSubstFormat3_3 *ccsf3_3;
1060             const GSUB_ChainContextSubstFormat3_4 *ccsf3_4;
1061             int newIndex = glyph_index;
1062
1063             ccsf3_1 = (const GSUB_ChainContextSubstFormat3_1 *)ccsf1;
1064
1065             TRACE("  subtype 3 (Coverage-based Chaining Context Glyph Substitution)\n");
1066
1067             for (k = 0; k < GET_BE_WORD(ccsf3_1->BacktrackGlyphCount); k++)
1068             {
1069                 offset = GET_BE_WORD(ccsf3_1->Coverage[k]);
1070                 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (dirBacktrack * (k+1))]) == -1)
1071                     break;
1072             }
1073             if (k != GET_BE_WORD(ccsf3_1->BacktrackGlyphCount))
1074                 continue;
1075             TRACE("Matched Backtrack\n");
1076
1077             ccsf3_2 = (const GSUB_ChainContextSubstFormat3_2 *)(((LPBYTE)ccsf1)+sizeof(GSUB_ChainContextSubstFormat3_1) + (sizeof(WORD) * (GET_BE_WORD(ccsf3_1->BacktrackGlyphCount)-1)));
1078
1079             indexGlyphs = GET_BE_WORD(ccsf3_2->InputGlyphCount);
1080             for (k = 0; k < indexGlyphs; k++)
1081             {
1082                 offset = GET_BE_WORD(ccsf3_2->Coverage[k]);
1083                 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (write_dir * k)]) == -1)
1084                     break;
1085             }
1086             if (k != indexGlyphs)
1087                 continue;
1088             TRACE("Matched IndexGlyphs\n");
1089
1090             ccsf3_3 = (const GSUB_ChainContextSubstFormat3_3 *)(((LPBYTE)ccsf3_2)+sizeof(GSUB_ChainContextSubstFormat3_2) + (sizeof(WORD) * (GET_BE_WORD(ccsf3_2->InputGlyphCount)-1)));
1091
1092             for (k = 0; k < GET_BE_WORD(ccsf3_3->LookaheadGlyphCount); k++)
1093             {
1094                 offset = GET_BE_WORD(ccsf3_3->Coverage[k]);
1095                 if (GSUB_is_glyph_covered((const BYTE*)ccsf3_1+offset, glyphs[glyph_index + (dirLookahead * (indexGlyphs + k))]) == -1)
1096                     break;
1097             }
1098             if (k != GET_BE_WORD(ccsf3_3->LookaheadGlyphCount))
1099                 continue;
1100             TRACE("Matched LookAhead\n");
1101
1102             ccsf3_4 = (const GSUB_ChainContextSubstFormat3_4 *)(((LPBYTE)ccsf3_3)+sizeof(GSUB_ChainContextSubstFormat3_3) + (sizeof(WORD) * (GET_BE_WORD(ccsf3_3->LookaheadGlyphCount)-1)));
1103
1104             if (GET_BE_WORD(ccsf3_4->SubstCount))
1105             {
1106                 for (k = 0; k < GET_BE_WORD(ccsf3_4->SubstCount); k++)
1107                 {
1108                     int lookupIndex = GET_BE_WORD(ccsf3_4->SubstLookupRecord[k].LookupListIndex);
1109                     int SequenceIndex = GET_BE_WORD(ccsf3_4->SubstLookupRecord[k].SequenceIndex) * write_dir;
1110
1111                     TRACE("SUBST: %i -> %i %i\n",k, SequenceIndex, lookupIndex);
1112                     newIndex = GSUB_apply_lookup(lookup, lookupIndex, glyphs, glyph_index + SequenceIndex, write_dir, glyph_count);
1113                     if (newIndex == -1)
1114                     {
1115                         ERR("Chain failed to generate a glyph\n");
1116                         continue;
1117                     }
1118                 }
1119                 return newIndex;
1120             }
1121             else return GSUB_E_NOGLYPH;
1122         }
1123     }
1124     return -1;
1125 }
1126
1127 static INT GSUB_apply_lookup(const GSUB_LookupList* lookup, INT lookup_index, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
1128 {
1129     int offset;
1130     const GSUB_LookupTable *look;
1131
1132     offset = GET_BE_WORD(lookup->Lookup[lookup_index]);
1133     look = (const GSUB_LookupTable*)((const BYTE*)lookup + offset);
1134     TRACE("type %i, flag %x, subtables %i\n",GET_BE_WORD(look->LookupType),GET_BE_WORD(look->LookupFlag),GET_BE_WORD(look->SubTableCount));
1135     switch(GET_BE_WORD(look->LookupType))
1136     {
1137         case 1:
1138             return GSUB_apply_SingleSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1139         case 2:
1140             return GSUB_apply_MultipleSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1141         case 3:
1142             return GSUB_apply_AlternateSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1143         case 4:
1144             return GSUB_apply_LigatureSubst(look, glyphs, glyph_index, write_dir, glyph_count);
1145         case 6:
1146             return GSUB_apply_ChainContextSubst(lookup, look, glyphs, glyph_index, write_dir, glyph_count);
1147         default:
1148             FIXME("We do not handle SubType %i\n",GET_BE_WORD(look->LookupType));
1149     }
1150     return GSUB_E_NOGLYPH;
1151 }
1152
1153 static INT GSUB_apply_feature_all_lookups(const GSUB_Header * header, const GSUB_Feature* feature, WORD *glyphs, INT glyph_index, INT write_dir, INT *glyph_count)
1154 {
1155     int i;
1156     int out_index = GSUB_E_NOGLYPH;
1157     const GSUB_LookupList *lookup;
1158
1159     lookup = (const GSUB_LookupList*)((const BYTE*)header + GET_BE_WORD(header->LookupList));
1160
1161     TRACE("%i lookups\n", GET_BE_WORD(feature->LookupCount));
1162     for (i = 0; i < GET_BE_WORD(feature->LookupCount); i++)
1163     {
1164         out_index = GSUB_apply_lookup(lookup, GET_BE_WORD(feature->LookupListIndex[i]), glyphs, glyph_index, write_dir, glyph_count);
1165         if (out_index != GSUB_E_NOGLYPH)
1166             break;
1167     }
1168     if (out_index == GSUB_E_NOGLYPH)
1169         TRACE("lookups found no glyphs\n");
1170     else
1171     {
1172         int out2;
1173         out2 = GSUB_apply_feature_all_lookups(header, feature, glyphs, glyph_index, write_dir, glyph_count);
1174         if (out2!=GSUB_E_NOGLYPH)
1175             out_index = out2;
1176     }
1177     return out_index;
1178 }
1179
1180 static const char* get_opentype_script(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache *psc, BOOL tryNew)
1181 {
1182     UINT charset;
1183
1184     if (psc->userScript != 0)
1185     {
1186         if (tryNew && ShapingData[psa->eScript].newOtTag[0] != 0 && strncmp((char*)&psc->userScript,ShapingData[psa->eScript].otTag,4)==0)
1187             return ShapingData[psa->eScript].newOtTag;
1188         else
1189             return (char*)&psc->userScript;
1190     }
1191
1192     if (tryNew && ShapingData[psa->eScript].newOtTag[0] != 0)
1193         return ShapingData[psa->eScript].newOtTag;
1194
1195     if (ShapingData[psa->eScript].otTag[0] != 0)
1196         return ShapingData[psa->eScript].otTag;
1197
1198     /*
1199      * fall back to the font charset
1200      */
1201     charset = GetTextCharsetInfo(hdc, NULL, 0x0);
1202     switch (charset)
1203     {
1204         case ANSI_CHARSET: return "latn";
1205         case BALTIC_CHARSET: return "latn"; /* ?? */
1206         case CHINESEBIG5_CHARSET: return "hani";
1207         case EASTEUROPE_CHARSET: return "latn"; /* ?? */
1208         case GB2312_CHARSET: return "hani";
1209         case GREEK_CHARSET: return "grek";
1210         case HANGUL_CHARSET: return "hang";
1211         case RUSSIAN_CHARSET: return "cyrl";
1212         case SHIFTJIS_CHARSET: return "kana";
1213         case TURKISH_CHARSET: return "latn"; /* ?? */
1214         case VIETNAMESE_CHARSET: return "latn";
1215         case JOHAB_CHARSET: return "latn"; /* ?? */
1216         case ARABIC_CHARSET: return "arab";
1217         case HEBREW_CHARSET: return "hebr";
1218         case THAI_CHARSET: return "thai";
1219         default: return "latn";
1220     }
1221 }
1222
1223 static LPCVOID load_GSUB_feature(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache *psc, const char* feat)
1224 {
1225     const GSUB_Feature *feature;
1226     const char* script;
1227     int i;
1228
1229     script = get_opentype_script(hdc,psa,psc,FALSE);
1230
1231     for (i = 0; i <  psc->feature_count; i++)
1232     {
1233         if (strncmp(psc->features[i].tag,feat,4)==0 && strncmp(psc->features[i].script,script,4)==0)
1234             return psc->features[i].feature;
1235     }
1236
1237     feature = NULL;
1238
1239     if (psc->GSUB_Table)
1240     {
1241         const GSUB_Script *script;
1242         const GSUB_LangSys *language;
1243         int attempt = 2;
1244
1245         do
1246         {
1247             script = GSUB_get_script_table(psc->GSUB_Table, get_opentype_script(hdc,psa,psc,(attempt==2)));
1248             attempt--;
1249             if (script)
1250             {
1251                 if (psc->userLang != 0)
1252                     language = GSUB_get_lang_table(script,(char*)&psc->userLang);
1253                 else
1254                     language = GSUB_get_lang_table(script, "xxxx"); /* Need to get Lang tag */
1255                 if (language)
1256                     feature = GSUB_get_feature(psc->GSUB_Table, language, feat);
1257             }
1258         } while(attempt && !feature);
1259
1260         /* try in the default (latin) table */
1261         if (!feature)
1262         {
1263             script = GSUB_get_script_table(psc->GSUB_Table, "latn");
1264             if (script)
1265             {
1266                 language = GSUB_get_lang_table(script, "xxxx"); /* Need to get Lang tag */
1267                 if (language)
1268                     feature = GSUB_get_feature(psc->GSUB_Table, language, feat);
1269             }
1270         }
1271     }
1272
1273     TRACE("Feature %s located at %p\n",debugstr_an(feat,4),feature);
1274
1275     psc->feature_count++;
1276
1277     if (psc->features)
1278         psc->features = HeapReAlloc(GetProcessHeap(), 0, psc->features, psc->feature_count * sizeof(LoadedFeature));
1279     else
1280         psc->features = HeapAlloc(GetProcessHeap(), 0, psc->feature_count * sizeof(LoadedFeature));
1281
1282     lstrcpynA(psc->features[psc->feature_count - 1].tag, feat, 5);
1283     lstrcpynA(psc->features[psc->feature_count - 1].script, script, 5);
1284     psc->features[psc->feature_count - 1].feature = feature;
1285     return feature;
1286 }
1287
1288 static INT apply_GSUB_feature_to_glyph(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache* psc, WORD *glyphs, INT index, INT write_dir, INT* glyph_count, const char* feat)
1289 {
1290     const GSUB_Feature *feature;
1291
1292     feature = load_GSUB_feature(hdc, psa, psc, feat);
1293     if (!feature)
1294         return GSUB_E_NOFEATURE;
1295
1296     TRACE("applying feature %s\n",feat);
1297     return GSUB_apply_feature_all_lookups(psc->GSUB_Table, feature, glyphs, index, write_dir, glyph_count);
1298 }
1299
1300 static VOID *load_gsub_table(HDC hdc)
1301 {
1302     VOID* GSUB_Table = NULL;
1303     int length = GetFontData(hdc, GSUB_TAG , 0, NULL, 0);
1304     if (length != GDI_ERROR)
1305     {
1306         GSUB_Table = HeapAlloc(GetProcessHeap(),0,length);
1307         GetFontData(hdc, GSUB_TAG , 0, GSUB_Table, length);
1308         TRACE("Loaded GSUB table of %i bytes\n",length);
1309     }
1310     return GSUB_Table;
1311 }
1312
1313 INT SHAPE_does_GSUB_feature_apply_to_chars(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache* psc, const WCHAR *chars, INT write_dir, INT count, const char* feature)
1314 {
1315     WORD *glyphs;
1316     INT glyph_count = count;
1317     INT rc;
1318
1319     glyphs = HeapAlloc(GetProcessHeap(),0,sizeof(WORD)*(count*2));
1320     GetGlyphIndicesW(hdc, chars, count, glyphs, 0);
1321     rc = apply_GSUB_feature_to_glyph(hdc, psa, psc, glyphs, 0, write_dir, &glyph_count, feature);
1322     if (rc > GSUB_E_NOGLYPH)
1323         rc = count - glyph_count;
1324     else
1325         rc = 0;
1326
1327     HeapFree(GetProcessHeap(),0,glyphs);
1328     return rc;
1329 }
1330
1331 static WORD GDEF_get_glyph_class(const GDEF_Header *header, WORD glyph)
1332 {
1333     int offset;
1334     WORD class = 0;
1335     const GDEF_ClassDefFormat1 *cf1;
1336
1337     if (!header)
1338         return 0;
1339
1340     offset = GET_BE_WORD(header->GlyphClassDef);
1341     if (!offset)
1342         return 0;
1343
1344     cf1 = (GDEF_ClassDefFormat1*)(((BYTE*)header)+offset);
1345     if (GET_BE_WORD(cf1->ClassFormat) == 1)
1346     {
1347         if (glyph >= GET_BE_WORD(cf1->StartGlyph))
1348         {
1349             int index = glyph - GET_BE_WORD(cf1->StartGlyph);
1350             if (index < GET_BE_WORD(cf1->GlyphCount))
1351                 class = GET_BE_WORD(cf1->ClassValueArray[index]);
1352         }
1353     }
1354     else if (GET_BE_WORD(cf1->ClassFormat) == 2)
1355     {
1356         const GDEF_ClassDefFormat2 *cf2 = (GDEF_ClassDefFormat2*)cf1;
1357         int i, top;
1358         top = GET_BE_WORD(cf2->ClassRangeCount);
1359         for (i = 0; i < top; i++)
1360         {
1361             if (glyph >= GET_BE_WORD(cf2->ClassRangeRecord[i].Start) &&
1362                 glyph <= GET_BE_WORD(cf2->ClassRangeRecord[i].End))
1363             {
1364                 class = GET_BE_WORD(cf2->ClassRangeRecord[i].Class);
1365                 break;
1366             }
1367         }
1368     }
1369     else
1370         ERR("Unknown Class Format %i\n",GET_BE_WORD(cf1->ClassFormat));
1371
1372     return class;
1373 }
1374
1375 static VOID *load_gdef_table(HDC hdc)
1376 {
1377     VOID* GDEF_Table = NULL;
1378     int length = GetFontData(hdc, GDEF_TAG , 0, NULL, 0);
1379     if (length != GDI_ERROR)
1380     {
1381         GDEF_Table = HeapAlloc(GetProcessHeap(),0,length);
1382         GetFontData(hdc, GDEF_TAG , 0, GDEF_Table, length);
1383         TRACE("Loaded GDEF table of %i bytes\n",length);
1384     }
1385     return GDEF_Table;
1386 }
1387
1388 static void GDEF_UpdateGlyphProps(HDC hdc, ScriptCache *psc, const WORD *pwGlyphs, const WORD cGlyphs, WORD* pwLogClust, const WORD cChars, SCRIPT_GLYPHPROP *pGlyphProp)
1389 {
1390     int i;
1391
1392     if (!psc->GDEF_Table)
1393         psc->GDEF_Table = load_gdef_table(hdc);
1394
1395     for (i = 0; i < cGlyphs; i++)
1396     {
1397         WORD class;
1398         int char_count = 0;
1399         int k;
1400
1401         for (k = 0; k < cChars; k++)
1402             if (pwLogClust[k] == i)
1403                 char_count++;
1404
1405         class = GDEF_get_glyph_class(psc->GDEF_Table, pwGlyphs[i]);
1406
1407         switch (class)
1408         {
1409             case 0:
1410             case BaseGlyph:
1411                 pGlyphProp[i].sva.fClusterStart = 1;
1412                 pGlyphProp[i].sva.fDiacritic = 0;
1413                 pGlyphProp[i].sva.fZeroWidth = 0;
1414                 break;
1415             case LigatureGlyph:
1416                 pGlyphProp[i].sva.fClusterStart = 1;
1417                 pGlyphProp[i].sva.fDiacritic = 0;
1418                 pGlyphProp[i].sva.fZeroWidth = 0;
1419                 break;
1420             case MarkGlyph:
1421                 pGlyphProp[i].sva.fClusterStart = 0;
1422                 pGlyphProp[i].sva.fDiacritic = 1;
1423                 pGlyphProp[i].sva.fZeroWidth = 1;
1424                 break;
1425             case ComponentGlyph:
1426                 pGlyphProp[i].sva.fClusterStart = 0;
1427                 pGlyphProp[i].sva.fDiacritic = 0;
1428                 pGlyphProp[i].sva.fZeroWidth = 0;
1429                 break;
1430             default:
1431                 ERR("Unknown glyph class %i\n",class);
1432                 pGlyphProp[i].sva.fClusterStart = 1;
1433                 pGlyphProp[i].sva.fDiacritic = 0;
1434                 pGlyphProp[i].sva.fZeroWidth = 0;
1435         }
1436
1437         if (char_count == 0)
1438             pGlyphProp[i].sva.fClusterStart = 0;
1439     }
1440 }
1441
1442 static void UpdateClustersFromGlyphProp(const int cGlyphs, const int cChars, WORD* pwLogClust, SCRIPT_GLYPHPROP *pGlyphProp)
1443 {
1444     int i;
1445
1446     for (i = 0; i < cGlyphs; i++)
1447     {
1448         if (!pGlyphProp[i].sva.fClusterStart)
1449         {
1450             int j;
1451             for (j = 0; j < cChars; j++)
1452             {
1453                 if (pwLogClust[j] == i)
1454                 {
1455                     int k = j;
1456                     while (!pGlyphProp[pwLogClust[k]].sva.fClusterStart && k >= 0 && k <cChars)
1457                         k-=1;
1458                     if (pGlyphProp[pwLogClust[k]].sva.fClusterStart)
1459                         pwLogClust[j] = pwLogClust[k];
1460                 }
1461             }
1462         }
1463     }
1464 }
1465
1466 static void UpdateClusters(int nextIndex, int changeCount, int write_dir, int chars, WORD* pwLogClust )
1467 {
1468     if (changeCount == 0)
1469         return;
1470     else
1471     {
1472         int i;
1473         int target_glyph = nextIndex - write_dir;
1474         int seeking_glyph;
1475         int target_index = -1;
1476         int replacing_glyph = -1;
1477         int changed = 0;
1478         int top_logclust = 0;
1479
1480         if (changeCount > 0)
1481         {
1482             if (write_dir > 0)
1483                 target_glyph = nextIndex - changeCount;
1484             else
1485                 target_glyph = nextIndex + (changeCount + 1);
1486         }
1487
1488         seeking_glyph = target_glyph;
1489         for (i = 0; i < chars; i++)
1490             if (pwLogClust[i] > top_logclust)
1491                 top_logclust = pwLogClust[i];
1492
1493         do {
1494             if (write_dir > 0)
1495                 for (i = 0; i < chars; i++)
1496                 {
1497                     if (pwLogClust[i] == seeking_glyph)
1498                     {
1499                         target_index = i;
1500                         break;
1501                     }
1502                 }
1503             else
1504                 for (i = chars - 1; i >= 0; i--)
1505                 {
1506                     if (pwLogClust[i] == seeking_glyph)
1507                     {
1508                         target_index = i;
1509                         break;
1510                     }
1511                 }
1512             if (target_index == -1)
1513                 seeking_glyph ++;
1514         }
1515         while (target_index == -1 && seeking_glyph <= top_logclust);
1516
1517         if (target_index == -1)
1518         {
1519             ERR("Unable to find target glyph\n");
1520             return;
1521         }
1522
1523         if (changeCount < 0)
1524         {
1525             /* merge glyphs */
1526             for(i = target_index; i < chars && i >= 0; i+=write_dir)
1527             {
1528                 if (pwLogClust[i] == target_glyph)
1529                     continue;
1530                 if(pwLogClust[i] == replacing_glyph)
1531                     pwLogClust[i] = target_glyph;
1532                 else
1533                 {
1534                     changed--;
1535                     if (changed >= changeCount)
1536                     {
1537                         replacing_glyph = pwLogClust[i];
1538                         pwLogClust[i] = target_glyph;
1539                     }
1540                     else
1541                         break;
1542                 }
1543             }
1544
1545             /* renumber trailing indexes*/
1546             for(i = target_index; i < chars && i >= 0; i+=write_dir)
1547             {
1548                 if (pwLogClust[i] != target_glyph)
1549                     pwLogClust[i] += changeCount;
1550             }
1551         }
1552         else
1553         {
1554             for(i = target_index; i < chars && i >= 0; i+=write_dir)
1555                     pwLogClust[i] += changeCount;
1556         }
1557     }
1558 }
1559
1560 static int apply_GSUB_feature(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache* psc, WORD *pwOutGlyphs, int write_dir, INT* pcGlyphs, INT cChars, const char* feat, WORD *pwLogClust )
1561 {
1562     if (psc->GSUB_Table)
1563     {
1564         const GSUB_Feature *feature;
1565         const GSUB_LookupList *lookup;
1566         const GSUB_Header *header = psc->GSUB_Table;
1567         int lookup_index, lookup_count;
1568
1569         feature = load_GSUB_feature(hdc, psa, psc, feat);
1570         if (!feature)
1571             return GSUB_E_NOFEATURE;
1572
1573         TRACE("applying feature %s\n",debugstr_an(feat,4));
1574         lookup = (const GSUB_LookupList*)((const BYTE*)header + GET_BE_WORD(header->LookupList));
1575         lookup_count = GET_BE_WORD(feature->LookupCount);
1576         TRACE("%i lookups\n", lookup_count);
1577         for (lookup_index = 0; lookup_index < lookup_count; lookup_index++)
1578         {
1579             int i;
1580
1581             if (write_dir > 0)
1582                 i = 0;
1583             else
1584                 i = *pcGlyphs-1;
1585             TRACE("applying lookup (%i/%i)\n",lookup_index,lookup_count);
1586             while(i < *pcGlyphs && i >= 0)
1587             {
1588                 INT nextIndex;
1589                 INT prevCount = *pcGlyphs;
1590
1591                 nextIndex = GSUB_apply_lookup(lookup, GET_BE_WORD(feature->LookupListIndex[lookup_index]), pwOutGlyphs, i, write_dir, pcGlyphs);
1592                 if (*pcGlyphs != prevCount)
1593                 {
1594                     UpdateClusters(nextIndex, *pcGlyphs - prevCount, write_dir, cChars, pwLogClust);
1595                     i = nextIndex;
1596                 }
1597                 else
1598                     i+=write_dir;
1599             }
1600         }
1601         return *pcGlyphs;
1602     }
1603     return GSUB_E_NOFEATURE;
1604 }
1605
1606 static inline BOOL get_GSUB_Indic2(SCRIPT_ANALYSIS *psa, ScriptCache *psc)
1607 {
1608     return(GSUB_get_script_table(psc->GSUB_Table,ShapingData[psa->eScript].newOtTag)!=NULL);
1609 }
1610
1611 static WCHAR neighbour_char(int i, int delta, const WCHAR* chars, INT cchLen)
1612 {
1613     if (i + delta < 0)
1614         return 0;
1615     if ( i+ delta >= cchLen)
1616         return 0;
1617
1618     i += delta;
1619
1620     return chars[i];
1621 }
1622
1623 static CHAR neighbour_joining_type(int i, int delta, const CHAR* context_type, INT cchLen, SCRIPT_ANALYSIS *psa)
1624 {
1625     if (i + delta < 0)
1626     {
1627         if (psa->fLinkBefore)
1628             return jtR;
1629         else
1630             return jtU;
1631     }
1632     if ( i+ delta >= cchLen)
1633     {
1634         if (psa->fLinkAfter)
1635             return jtL;
1636         else
1637             return jtU;
1638     }
1639
1640     i += delta;
1641
1642     if (context_type[i] == jtT)
1643         return neighbour_joining_type(i,delta,context_type,cchLen,psa);
1644     else
1645         return context_type[i];
1646 }
1647
1648 static inline BOOL right_join_causing(CHAR joining_type)
1649 {
1650     return (joining_type == jtL || joining_type == jtD || joining_type == jtC);
1651 }
1652
1653 static inline BOOL left_join_causing(CHAR joining_type)
1654 {
1655     return (joining_type == jtR || joining_type == jtD || joining_type == jtC);
1656 }
1657
1658 static inline BOOL word_break_causing(WCHAR chr)
1659 {
1660     /* we are working within a string of characters already guareented to
1661        be within one script, Syriac, so we do not worry about any character
1662        other than the space character outside of that range */
1663     return (chr == 0 || chr == 0x20 );
1664 }
1665
1666 /*
1667  * ContextualShape_Arabic
1668  */
1669 static void ContextualShape_Arabic(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
1670 {
1671     CHAR *context_type;
1672     INT *context_shape;
1673     INT dirR, dirL;
1674     int i;
1675
1676     if (*pcGlyphs != cChars)
1677     {
1678         ERR("Number of Glyphs and Chars need to match at the beginning\n");
1679         return;
1680     }
1681
1682     if (!psa->fLogicalOrder && psa->fRTL)
1683     {
1684         dirR = 1;
1685         dirL = -1;
1686     }
1687     else
1688     {
1689         dirR = -1;
1690         dirL = 1;
1691     }
1692
1693     if (!psc->GSUB_Table)
1694         psc->GSUB_Table = load_gsub_table(hdc);
1695
1696     context_type = HeapAlloc(GetProcessHeap(),0,cChars);
1697     context_shape = HeapAlloc(GetProcessHeap(),0,sizeof(INT) * cChars);
1698
1699     for (i = 0; i < cChars; i++)
1700         context_type[i] = get_table_entry( wine_shaping_table, pwcChars[i] );
1701
1702     for (i = 0; i < cChars; i++)
1703     {
1704         if (context_type[i] == jtR && right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1705             context_shape[i] = Xr;
1706         else if (context_type[i] == jtL && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)))
1707             context_shape[i] = Xl;
1708         else if (context_type[i] == jtD && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)) && right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1709             context_shape[i] = Xm;
1710         else if (context_type[i] == jtD && right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1711             context_shape[i] = Xr;
1712         else if (context_type[i] == jtD && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)))
1713             context_shape[i] = Xl;
1714         else
1715             context_shape[i] = Xn;
1716     }
1717
1718     /* Contextual Shaping */
1719     i = 0;
1720     while(i < *pcGlyphs)
1721     {
1722         BOOL shaped = FALSE;
1723
1724         if (psc->GSUB_Table)
1725         {
1726             INT nextIndex;
1727             INT prevCount = *pcGlyphs;
1728             nextIndex = apply_GSUB_feature_to_glyph(hdc, psa, psc, pwOutGlyphs, i, dirL, pcGlyphs, contextual_features[context_shape[i]]);
1729             if (nextIndex > GSUB_E_NOGLYPH)
1730             {
1731                 i = nextIndex;
1732                 UpdateClusters(nextIndex, *pcGlyphs - prevCount, dirL, cChars, pwLogClust);
1733             }
1734             shaped = (nextIndex > GSUB_E_NOGLYPH);
1735         }
1736
1737         if (!shaped)
1738         {
1739             if (context_shape[i] == Xn)
1740             {
1741                 WORD newGlyph = pwOutGlyphs[i];
1742                 if (pwcChars[i] >= FIRST_ARABIC_CHAR && pwcChars[i] <= LAST_ARABIC_CHAR)
1743                 {
1744                     /* fall back to presentation form B */
1745                     WCHAR context_char = wine_shaping_forms[pwcChars[i] - FIRST_ARABIC_CHAR][context_shape[i]];
1746                     if (context_char != pwcChars[i] && GetGlyphIndicesW(hdc, &context_char, 1, &newGlyph, 0) != GDI_ERROR && newGlyph != 0x0000)
1747                         pwOutGlyphs[i] = newGlyph;
1748                 }
1749             }
1750             i++;
1751         }
1752     }
1753
1754     HeapFree(GetProcessHeap(),0,context_shape);
1755     HeapFree(GetProcessHeap(),0,context_type);
1756 }
1757
1758 /*
1759  * ContextualShape_Syriac
1760  */
1761
1762 #define ALAPH 0x710
1763 #define DALATH 0x715
1764 #define RISH 0x72A
1765
1766 static void ContextualShape_Syriac(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
1767 {
1768     CHAR *context_type;
1769     INT *context_shape;
1770     INT dirR, dirL;
1771     int i;
1772
1773     if (*pcGlyphs != cChars)
1774     {
1775         ERR("Number of Glyphs and Chars need to match at the beginning\n");
1776         return;
1777     }
1778
1779     if (!psa->fLogicalOrder && psa->fRTL)
1780     {
1781         dirR = 1;
1782         dirL = -1;
1783     }
1784     else
1785     {
1786         dirR = -1;
1787         dirL = 1;
1788     }
1789
1790     if (!psc->GSUB_Table)
1791         psc->GSUB_Table = load_gsub_table(hdc);
1792
1793     if (!psc->GSUB_Table)
1794         return;
1795
1796     context_type = HeapAlloc(GetProcessHeap(),0,cChars);
1797     context_shape = HeapAlloc(GetProcessHeap(),0,sizeof(INT) * cChars);
1798
1799     for (i = 0; i < cChars; i++)
1800         context_type[i] = get_table_entry( wine_shaping_table, pwcChars[i] );
1801
1802     for (i = 0; i < cChars; i++)
1803     {
1804         if (pwcChars[i] == ALAPH)
1805         {
1806             WCHAR rchar = neighbour_char(i,dirR,pwcChars,cChars);
1807
1808             if (left_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)) && word_break_causing(neighbour_char(i,dirL,pwcChars,cChars)))
1809             context_shape[i] = Afj;
1810             else if ( rchar != DALATH && rchar != RISH &&
1811 !left_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)) &&
1812 word_break_causing(neighbour_char(i,dirL,pwcChars,cChars)))
1813             context_shape[i] = Afn;
1814             else if ( (rchar == DALATH || rchar == RISH) && word_break_causing(neighbour_char(i,dirL,pwcChars,cChars)))
1815             context_shape[i] = Afx;
1816             else
1817             context_shape[i] = Xn;
1818         }
1819         else if (context_type[i] == jtR &&
1820 right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1821             context_shape[i] = Xr;
1822         else if (context_type[i] == jtL && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)))
1823             context_shape[i] = Xl;
1824         else if (context_type[i] == jtD && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)) && right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1825             context_shape[i] = Xm;
1826         else if (context_type[i] == jtD && right_join_causing(neighbour_joining_type(i,dirR,context_type,cChars,psa)))
1827             context_shape[i] = Xr;
1828         else if (context_type[i] == jtD && left_join_causing(neighbour_joining_type(i,dirL,context_type,cChars,psa)))
1829             context_shape[i] = Xl;
1830         else
1831             context_shape[i] = Xn;
1832     }
1833
1834     /* Contextual Shaping */
1835     i = 0;
1836     while(i < *pcGlyphs)
1837     {
1838         INT nextIndex;
1839         INT prevCount = *pcGlyphs;
1840         nextIndex = apply_GSUB_feature_to_glyph(hdc, psa, psc, pwOutGlyphs, i, dirL, pcGlyphs, contextual_features[context_shape[i]]);
1841         if (nextIndex > GSUB_E_NOGLYPH)
1842         {
1843             UpdateClusters(nextIndex, *pcGlyphs - prevCount, dirL, cChars, pwLogClust);
1844             i = nextIndex;
1845         }
1846         else
1847             i++;
1848     }
1849
1850     HeapFree(GetProcessHeap(),0,context_shape);
1851     HeapFree(GetProcessHeap(),0,context_type);
1852 }
1853
1854 /*
1855  * ContextualShape_Phags_pa
1856  */
1857
1858 #define phags_pa_CANDRABINDU  0xA873
1859 #define phags_pa_START 0xA840
1860 #define phags_pa_END  0xA87F
1861
1862 static void ContextualShape_Phags_pa(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
1863 {
1864     INT *context_shape;
1865     INT dirR, dirL;
1866     int i;
1867
1868     if (*pcGlyphs != cChars)
1869     {
1870         ERR("Number of Glyphs and Chars need to match at the beginning\n");
1871         return;
1872     }
1873
1874     if (!psa->fLogicalOrder && psa->fRTL)
1875     {
1876         dirR = 1;
1877         dirL = -1;
1878     }
1879     else
1880     {
1881         dirR = -1;
1882         dirL = 1;
1883     }
1884
1885     if (!psc->GSUB_Table)
1886         psc->GSUB_Table = load_gsub_table(hdc);
1887
1888     if (!psc->GSUB_Table)
1889         return;
1890
1891     context_shape = HeapAlloc(GetProcessHeap(),0,sizeof(INT) * cChars);
1892
1893     for (i = 0; i < cChars; i++)
1894     {
1895         if (pwcChars[i] >= phags_pa_START && pwcChars[i] <=  phags_pa_END)
1896         {
1897             WCHAR rchar = neighbour_char(i,dirR,pwcChars,cChars);
1898             WCHAR lchar = neighbour_char(i,dirL,pwcChars,cChars);
1899             BOOL jrchar = (rchar != phags_pa_CANDRABINDU && rchar >= phags_pa_START && rchar <=  phags_pa_END);
1900             BOOL jlchar = (lchar != phags_pa_CANDRABINDU && lchar >= phags_pa_START && lchar <=  phags_pa_END);
1901
1902             if (jrchar && jlchar)
1903                 context_shape[i] = Xm;
1904             else if (jrchar)
1905                 context_shape[i] = Xr;
1906             else if (jlchar)
1907                 context_shape[i] = Xl;
1908             else
1909                 context_shape[i] = Xn;
1910         }
1911         else
1912             context_shape[i] = -1;
1913     }
1914
1915     /* Contextual Shaping */
1916     i = 0;
1917     while(i < *pcGlyphs)
1918     {
1919         if (context_shape[i] >= 0)
1920         {
1921             INT nextIndex;
1922             INT prevCount = *pcGlyphs;
1923             nextIndex = apply_GSUB_feature_to_glyph(hdc, psa, psc, pwOutGlyphs, i, dirL, pcGlyphs, contextual_features[context_shape[i]]);
1924             if (nextIndex > GSUB_E_NOGLYPH)
1925             {
1926                 UpdateClusters(nextIndex, *pcGlyphs - prevCount, dirL, cChars, pwLogClust);
1927                 i = nextIndex;
1928             }
1929             else
1930                 i++;
1931         }
1932         else
1933             i++;
1934     }
1935
1936     HeapFree(GetProcessHeap(),0,context_shape);
1937 }
1938
1939 static void ReplaceInsertChars(HDC hdc, INT cWalk, INT* pcChars, WCHAR *pwOutChars, const WCHAR *replacements)
1940 {
1941     int i;
1942
1943     /* Replace */
1944     pwOutChars[cWalk] = replacements[0];
1945     cWalk=cWalk+1;
1946
1947     /* Insert */
1948     for (i = 1; replacements[i] != 0x0000 && i < 3; i++)
1949     {
1950         int j;
1951         for (j = *pcChars; j > cWalk; j--)
1952             pwOutChars[j] = pwOutChars[j-1];
1953         *pcChars= *pcChars+1;
1954         pwOutChars[cWalk] = replacements[i];
1955         cWalk = cWalk+1;
1956     }
1957 }
1958
1959 static void DecomposeVowels(HDC hdc, WCHAR *pwOutChars, INT *pcChars, const VowelComponents vowels[], WORD* pwLogClust, INT cChars)
1960 {
1961     int i;
1962     int cWalk;
1963
1964     for (cWalk = 0; cWalk < *pcChars; cWalk++)
1965     {
1966         for (i = 0; vowels[i].base != 0x0; i++)
1967         {
1968             if (pwOutChars[cWalk] == vowels[i].base)
1969             {
1970                 int o = 0;
1971                 ReplaceInsertChars(hdc, cWalk, pcChars, pwOutChars, vowels[i].parts);
1972                 if (vowels[i].parts[1]) { cWalk++; o++; }
1973                 if (vowels[i].parts[2]) { cWalk++; o++; }
1974                 UpdateClusters(cWalk, o, 1,  cChars,  pwLogClust);
1975                 break;
1976             }
1977         }
1978     }
1979 }
1980
1981 static void ComposeConsonants(HDC hdc, WCHAR *pwOutChars, INT *pcChars, const ConsonantComponents consonants[], WORD* pwLogClust)
1982 {
1983     int i;
1984     int offset = 0;
1985     int cWalk;
1986
1987     for (cWalk = 0; cWalk < *pcChars; cWalk++)
1988     {
1989         for (i = 0; consonants[i].output!= 0x0; i++)
1990         {
1991             int j;
1992             for (j = 0; j + cWalk < *pcChars && consonants[i].parts[j]!=0x0; j++)
1993                 if (pwOutChars[cWalk+j] != consonants[i].parts[j])
1994                     break;
1995
1996             if (consonants[i].parts[j]==0x0) /* matched all */
1997             {
1998                 int k;
1999                 j--;
2000                 pwOutChars[cWalk] = consonants[i].output;
2001                 for(k = cWalk+1; k < *pcChars - j; k++)
2002                     pwOutChars[k] = pwOutChars[k+j];
2003                 *pcChars = *pcChars - j;
2004                 for (k = j ; k > 0; k--)
2005                     pwLogClust[cWalk + k + offset] = pwLogClust[cWalk + offset];
2006                 offset += j;
2007                 for (k = cWalk + j + offset; k < *pcChars + offset; k++)
2008                     pwLogClust[k]--;
2009                 break;
2010             }
2011         }
2012         cWalk++;
2013     }
2014 }
2015
2016 static void Reorder_Ra_follows_base(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
2017 {
2018     if (s->ralf >= 0)
2019     {
2020         int j;
2021         WORD Ra = pwChar[s->start];
2022         WORD H = pwChar[s->start+1];
2023
2024         TRACE("Doing reorder of Ra to %i\n",s->base);
2025         for (j = s->start; j < s->base-1; j++)
2026             pwChar[j] = pwChar[j+2];
2027         pwChar[s->base-1] = Ra;
2028         pwChar[s->base] = H;
2029
2030         s->ralf = s->base-1;
2031         s->base -= 2;
2032     }
2033 }
2034
2035 static void Reorder_Ra_follows_matra(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
2036 {
2037     if (s->ralf >= 0)
2038     {
2039         int j,loc;
2040         int stop = (s->blwf >=0)? s->blwf+1 : s->base;
2041         WORD Ra = pwChar[s->start];
2042         WORD H = pwChar[s->start+1];
2043         for (loc = s->end; loc > stop; loc--)
2044             if (lexical(pwChar[loc]) == lex_Matra_post || lexical(pwChar[loc]) == lex_Matra_below)
2045                 break;
2046
2047         TRACE("Doing reorder of Ra to %i\n",loc);
2048         for (j = s->start; j < loc-1; j++)
2049             pwChar[j] = pwChar[j+2];
2050         pwChar[loc-1] = Ra;
2051         pwChar[loc] = H;
2052
2053         s->ralf = loc-1;
2054         s->base -= 2;
2055         if (s->blwf >= 0) s->blwf -= 2;
2056         if (s->pref >= 0) s->pref -= 2;
2057     }
2058 }
2059
2060 static void Reorder_Ra_follows_syllable(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
2061 {
2062     if (s->ralf >= 0)
2063     {
2064         int j;
2065         WORD Ra = pwChar[s->start];
2066         WORD H = pwChar[s->start+1];
2067
2068         TRACE("Doing reorder of Ra to %i\n",s->end-1);
2069         for (j = s->start; j < s->end-1; j++)
2070             pwChar[j] = pwChar[j+2];
2071         pwChar[s->end-1] = Ra;
2072         pwChar[s->end] = H;
2073
2074         s->ralf = s->end-1;
2075         s->base -= 2;
2076         if (s->blwf >= 0) s->blwf -= 2;
2077         if (s->pref >= 0) s->pref -= 2;
2078     }
2079 }
2080
2081 static void Reorder_Matra_precede_base(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
2082 {
2083     int i;
2084
2085     /* reorder Matras */
2086     if (s->end > s->base)
2087     {
2088         for (i = 1; i <= s->end-s->base; i++)
2089         {
2090             if (lexical(pwChar[s->base+i]) == lex_Matra_pre)
2091             {
2092                 int j;
2093                 WCHAR c = pwChar[s->base+i];
2094                 TRACE("Doing reorder of %x %x\n",c,pwChar[s->base]);
2095                 for (j = s->base+i; j > s->base; j--)
2096                     pwChar[j] = pwChar[j-1];
2097                 pwChar[s->base] = c;
2098
2099                 if (s->ralf >= s->base) s->ralf++;
2100                 if (s->blwf >= s->base) s->blwf++;
2101                 if (s->pref >= s->base) s->pref++;
2102                 s->base ++;
2103             }
2104         }
2105     }
2106 }
2107
2108 static void Reorder_Matra_precede_syllable(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
2109 {
2110     int i;
2111
2112     /* reorder Matras */
2113     if (s->end > s->base)
2114     {
2115         for (i = 1; i <= s->end-s->base; i++)
2116         {
2117             if (lexical(pwChar[s->base+i]) == lex_Matra_pre)
2118             {
2119                 int j;
2120                 WCHAR c = pwChar[s->base+i];
2121                 TRACE("Doing reorder of %x to %i\n",c,s->start);
2122                 for (j = s->base+i; j > s->start; j--)
2123                     pwChar[j] = pwChar[j-1];
2124                 pwChar[s->start] = c;
2125
2126                 if (s->ralf >= 0) s->ralf++;
2127                 if (s->blwf >= 0) s->blwf++;
2128                 if (s->pref >= 0) s->pref++;
2129                 s->base ++;
2130             }
2131         }
2132     }
2133 }
2134
2135 static void SecondReorder_Blwf_follows_matra(LPWSTR pwChar, IndicSyllable *s, WORD *glyphs, IndicSyllable *g, lexical_function lexical)
2136 {
2137     if (s->blwf >= 0 && g->blwf > g->base)
2138     {
2139         int j,loc;
2140         int g_offset;
2141         for (loc = s->end; loc > s->blwf; loc--)
2142             if (lexical(pwChar[loc]) == lex_Matra_below || lexical(pwChar[loc]) == lex_Matra_above || lexical(pwChar[loc]) == lex_Matra_post)
2143                 break;
2144
2145         g_offset = (loc - s->blwf) - 1;
2146
2147         if (loc != s->blwf)
2148         {
2149             WORD blwf = glyphs[g->blwf];
2150             TRACE("Doing reorder of Below-base to %i (glyph offset %i)\n",loc,g_offset);
2151             /* do not care about the pwChar array anymore, just the glyphs */
2152             for (j = 0; j < g_offset; j++)
2153                 glyphs[g->blwf + j] = glyphs[g->blwf + j + 1];
2154             glyphs[g->blwf + g_offset] = blwf;
2155         }
2156     }
2157 }
2158
2159 static void SecondReorder_Matra_precede_base(LPWSTR pwChar, IndicSyllable *s, WORD *glyphs, IndicSyllable *g, lexical_function lexical)
2160 {
2161     int i;
2162
2163     /* reorder previously moved Matras to correct position*/
2164     for (i = s->start; i < s->base; i++)
2165     {
2166         if (lexical(pwChar[i]) == lex_Matra_pre)
2167         {
2168             int j;
2169             int g_start = g->start + i - s->start;
2170             if (g_start < g->base -1 )
2171             {
2172                 WCHAR og = glyphs[g_start];
2173                 TRACE("Doing reorder of matra from %i to %i\n",g_start,g->base);
2174                 for (j = g_start; j < g->base-1; j++)
2175                     glyphs[j] = glyphs[j+1];
2176                 glyphs[g->base-1] = og;
2177             }
2178         }
2179     }
2180 }
2181
2182 static void SecondReorder_Pref_precede_base(LPWSTR pwChar, IndicSyllable *s, WORD *glyphs, IndicSyllable *g, lexical_function lexical)
2183 {
2184     if (s->pref >= 0 && g->pref > g->base)
2185     {
2186         int j;
2187         WCHAR og = glyphs[g->pref];
2188         TRACE("Doing reorder of pref from %i to %i\n",g->pref,g->base);
2189         for (j = g->pref; j > g->base; j--)
2190             glyphs[j] = glyphs[j-1];
2191         glyphs[g->base] = og;
2192     }
2193 }
2194
2195 static void Reorder_Like_Sinhala(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
2196 {
2197     TRACE("Syllable (%i..%i..%i)\n",s->start,s->base,s->end);
2198     if (s->start == s->base && s->base == s->end)  return;
2199     if (lexical(pwChar[s->base]) == lex_Vowel) return;
2200
2201     Reorder_Ra_follows_base(pwChar, s, lexical);
2202     Reorder_Matra_precede_base(pwChar, s, lexical);
2203 }
2204
2205 static void Reorder_Like_Devanagari(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
2206 {
2207     TRACE("Syllable (%i..%i..%i)\n",s->start,s->base,s->end);
2208     if (s->start == s->base && s->base == s->end)  return;
2209     if (lexical(pwChar[s->base]) == lex_Vowel) return;
2210
2211     Reorder_Ra_follows_matra(pwChar, s, lexical);
2212     Reorder_Matra_precede_syllable(pwChar, s, lexical);
2213 }
2214
2215 static void Reorder_Like_Bengali(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
2216 {
2217     TRACE("Syllable (%i..%i..%i)\n",s->start,s->base,s->end);
2218     if (s->start == s->base && s->base == s->end)  return;
2219     if (lexical(pwChar[s->base]) == lex_Vowel) return;
2220
2221     Reorder_Ra_follows_base(pwChar, s, lexical);
2222     Reorder_Matra_precede_syllable(pwChar, s, lexical);
2223 }
2224
2225 static void Reorder_Like_Kannada(LPWSTR pwChar, IndicSyllable *s, lexical_function lexical)
2226 {
2227     TRACE("Syllable (%i..%i..%i)\n",s->start,s->base,s->end);
2228     if (s->start == s->base && s->base == s->end)  return;
2229     if (lexical(pwChar[s->base]) == lex_Vowel) return;
2230
2231     Reorder_Ra_follows_syllable(pwChar, s, lexical);
2232     Reorder_Matra_precede_syllable(pwChar, s, lexical);
2233 }
2234
2235 static void SecondReorder_Like_Telugu(LPWSTR pwChar, IndicSyllable *s, WORD* pwGlyphs, IndicSyllable *g, lexical_function lexical)
2236 {
2237     TRACE("Syllable (%i..%i..%i)\n",s->start,s->base,s->end);
2238     TRACE("Glyphs (%i..%i..%i)\n",g->start,g->base,g->end);
2239     if (s->start == s->base && s->base == s->end)  return;
2240     if (lexical(pwChar[s->base]) == lex_Vowel) return;
2241
2242     SecondReorder_Blwf_follows_matra(pwChar, s, pwGlyphs, g, lexical);
2243 }
2244
2245 static void SecondReorder_Like_Tamil(LPWSTR pwChar, IndicSyllable *s, WORD* pwGlyphs, IndicSyllable *g, lexical_function lexical)
2246 {
2247     TRACE("Syllable (%i..%i..%i)\n",s->start,s->base,s->end);
2248     TRACE("Glyphs (%i..%i..%i)\n",g->start,g->base,g->end);
2249     if (s->start == s->base && s->base == s->end)  return;
2250     if (lexical(pwChar[s->base]) == lex_Vowel) return;
2251
2252     SecondReorder_Matra_precede_base(pwChar, s, pwGlyphs, g, lexical);
2253     SecondReorder_Pref_precede_base(pwChar, s, pwGlyphs, g, lexical);
2254 }
2255
2256
2257 static inline void shift_syllable_glyph_indexs(IndicSyllable *glyph_index, INT index, INT shift)
2258 {
2259     if (shift == 0)
2260         return;
2261
2262     if (glyph_index->start > index)
2263         glyph_index->start += shift;
2264     if (glyph_index->base > index)
2265         glyph_index->base+= shift;
2266     if (glyph_index->end > index)
2267         glyph_index->end+= shift;
2268     if (glyph_index->ralf > index)
2269         glyph_index->ralf+= shift;
2270     if (glyph_index->blwf > index)
2271         glyph_index->blwf+= shift;
2272     if (glyph_index->pref > index)
2273         glyph_index->pref+= shift;
2274 }
2275
2276 static void Apply_Indic_BasicForm(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwChars, INT cChars, IndicSyllable *syllable, WORD *pwOutGlyphs, INT* pcGlyphs, WORD *pwLogClust, lexical_function lexical, IndicSyllable *glyph_index, const GSUB_Feature *feature )
2277 {
2278     int index = glyph_index->start;
2279
2280     if (!feature)
2281         return;
2282
2283     while(index <= glyph_index->end)
2284     {
2285             INT nextIndex;
2286             INT prevCount = *pcGlyphs;
2287             nextIndex = GSUB_apply_feature_all_lookups(psc->GSUB_Table, feature, pwOutGlyphs, index, 1, pcGlyphs);
2288             if (nextIndex > GSUB_E_NOGLYPH)
2289             {
2290                 UpdateClusters(nextIndex, *pcGlyphs - prevCount, 1, cChars, pwLogClust);
2291                 shift_syllable_glyph_indexs(glyph_index,index,*pcGlyphs - prevCount);
2292                 index = nextIndex;
2293             }
2294             else
2295                 index++;
2296     }
2297 }
2298
2299 static inline INT find_consonant_halant(WCHAR* pwChars, INT index, INT end, lexical_function lexical)
2300 {
2301     int i = 0;
2302     while (i + index < end - 1 && !(is_consonant(lexical(pwChars[index+i])) && (lexical(pwChars[index+i+1]) == lex_Halant || (index + i < end - 2 && lexical(pwChars[index+i+1]) == lex_Nukta && lexical(pwChars[index+i+2] == lex_Halant)))))
2303         i++;
2304     if (index + i <= end-1)
2305         return index + i;
2306     else
2307         return -1;
2308 }
2309
2310 static void Apply_Indic_PreBase(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwChars, INT cChars, IndicSyllable *syllable, WORD *pwOutGlyphs, INT* pcGlyphs, WORD *pwLogClust, lexical_function lexical, IndicSyllable *glyph_index, const char* feature)
2311 {
2312     INT index, nextIndex;
2313     INT count,g_offset;
2314
2315     count = syllable->base - syllable->start;
2316
2317     g_offset = 0;
2318     index = find_consonant_halant(&pwChars[syllable->start], 0, count, lexical);
2319     while (index >= 0 && index + g_offset < (glyph_index->base - glyph_index->start))
2320     {
2321         INT prevCount = *pcGlyphs;
2322         nextIndex = apply_GSUB_feature_to_glyph(hdc, psa, psc, pwOutGlyphs, index+glyph_index->start+g_offset, 1, pcGlyphs, feature);
2323         if (nextIndex > GSUB_E_NOGLYPH)
2324         {
2325             UpdateClusters(nextIndex, *pcGlyphs - prevCount, 1, cChars, pwLogClust);
2326             shift_syllable_glyph_indexs(glyph_index, index + glyph_index->start + g_offset, (*pcGlyphs - prevCount));
2327             g_offset += (*pcGlyphs - prevCount);
2328         }
2329
2330         index+=2;
2331         index = find_consonant_halant(&pwChars[syllable->start], index, count, lexical);
2332     }
2333 }
2334
2335 static void Apply_Indic_Rphf(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwChars, INT cChars, IndicSyllable *syllable, WORD *pwOutGlyphs, INT* pcGlyphs, WORD *pwLogClust, lexical_function lexical, IndicSyllable *glyph_index)
2336 {
2337     INT nextIndex;
2338     INT prevCount = *pcGlyphs;
2339
2340     if (syllable->ralf >= 0)
2341     {
2342         nextIndex = apply_GSUB_feature_to_glyph(hdc, psa, psc, pwOutGlyphs, glyph_index->ralf, 1, pcGlyphs, "rphf");
2343         if (nextIndex > GSUB_E_NOGLYPH)
2344         {
2345             UpdateClusters(nextIndex, *pcGlyphs - prevCount, 1, cChars, pwLogClust);
2346             shift_syllable_glyph_indexs(glyph_index,glyph_index->ralf,*pcGlyphs - prevCount);
2347         }
2348     }
2349 }
2350
2351 static inline INT find_halant_consonant(WCHAR* pwChars, INT index, INT end, lexical_function lexical)
2352 {
2353     int i = 0;
2354     while (index + i < end-1 && !(lexical(pwChars[index+i]) == lex_Halant &&
2355              ((index + i < end-2 && lexical(pwChars[index+i]) == lex_Nukta && is_consonant(lexical(pwChars[index+i+1]))) ||
2356               is_consonant(lexical(pwChars[index+i+1])))))
2357         i++;
2358     if (index + i <= end-1)
2359         return index+i;
2360     else
2361         return -1;
2362 }
2363
2364 static void Apply_Indic_PostBase(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwChars, INT cChars, IndicSyllable *syllable, WORD *pwOutGlyphs, INT* pcGlyphs, WORD *pwLogClust, lexical_function lexical, IndicSyllable *glyph_index, BOOL modern, const char* feat)
2365 {
2366     INT index, nextIndex;
2367     INT count, g_offset=0;
2368     INT ralf = syllable->ralf;
2369
2370     count = syllable->end - syllable->base;
2371
2372     index = find_halant_consonant(&pwChars[syllable->base], 0, count, lexical);
2373
2374     while (index >= 0)
2375     {
2376         INT prevCount = *pcGlyphs;
2377         if (ralf >=0 && ralf < index)
2378         {
2379             g_offset--;
2380             ralf = -1;
2381         }
2382
2383         if (!modern)
2384         {
2385             WORD g = pwOutGlyphs[index+glyph_index->base+g_offset];
2386             pwOutGlyphs[index+glyph_index->base+g_offset] = pwOutGlyphs[index+glyph_index->base+g_offset+1];
2387             pwOutGlyphs[index+glyph_index->base+g_offset+1] = g;
2388         }
2389
2390         nextIndex = apply_GSUB_feature_to_glyph(hdc, psa, psc, pwOutGlyphs, index+glyph_index->base+g_offset, 1, pcGlyphs, feat);
2391         if (nextIndex > GSUB_E_NOGLYPH)
2392         {
2393             UpdateClusters(nextIndex, *pcGlyphs - prevCount, 1, cChars, pwLogClust);
2394             shift_syllable_glyph_indexs(glyph_index,index+glyph_index->start+g_offset, (*pcGlyphs - prevCount));
2395             g_offset += (*pcGlyphs - prevCount);
2396         }
2397         else if (!modern)
2398         {
2399             WORD g = pwOutGlyphs[index+glyph_index->base+g_offset];
2400             pwOutGlyphs[index+glyph_index->base+g_offset] = pwOutGlyphs[index+glyph_index->base+g_offset+1];
2401             pwOutGlyphs[index+glyph_index->base+g_offset+1] = g;
2402         }
2403
2404         index+=2;
2405         index = find_halant_consonant(&pwChars[syllable->base], index, count, lexical);
2406     }
2407 }
2408
2409 static void ShapeIndicSyllables(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwChars, INT cChars, IndicSyllable *syllables, INT syllable_count, WORD *pwOutGlyphs, INT* pcGlyphs, WORD *pwLogClust, lexical_function lexical, second_reorder_function second_reorder, BOOL modern)
2410 {
2411     int c;
2412     int overall_shift = 0;
2413     const GSUB_Feature *locl = (modern)?load_GSUB_feature(hdc, psa, psc, "locl"):NULL;
2414     const GSUB_Feature *nukt = load_GSUB_feature(hdc, psa, psc, "nukt");
2415     const GSUB_Feature *akhn = load_GSUB_feature(hdc, psa, psc, "akhn");
2416     const GSUB_Feature *rkrf = (modern)?load_GSUB_feature(hdc, psa, psc, "rkrf"):NULL;
2417     const GSUB_Feature *pstf = load_GSUB_feature(hdc, psa, psc, "pstf");
2418     const GSUB_Feature *vatu = (!rkrf)?load_GSUB_feature(hdc, psa, psc, "vatu"):NULL;
2419     const GSUB_Feature *cjct = (modern)?load_GSUB_feature(hdc, psa, psc, "cjct"):NULL;
2420     BOOL rphf = (load_GSUB_feature(hdc, psa, psc, "rphf") != NULL);
2421     BOOL pref = (load_GSUB_feature(hdc, psa, psc, "pref") != NULL);
2422     BOOL blwf = (load_GSUB_feature(hdc, psa, psc, "blwf") != NULL);
2423     BOOL half = (load_GSUB_feature(hdc, psa, psc, "half") != NULL);
2424     IndicSyllable glyph_indexs;
2425
2426     for (c = 0; c < syllable_count; c++)
2427     {
2428         int old_end;
2429         memcpy(&glyph_indexs, &syllables[c], sizeof(IndicSyllable));
2430         shift_syllable_glyph_indexs(&glyph_indexs, -1, overall_shift);
2431         old_end = glyph_indexs.end;
2432
2433         if (locl)
2434         {
2435             TRACE("applying feature locl\n");
2436             Apply_Indic_BasicForm(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, locl);
2437         }
2438         if (nukt)
2439         {
2440             TRACE("applying feature nukt\n");
2441             Apply_Indic_BasicForm(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, nukt);
2442         }
2443         if (akhn)
2444         {
2445             TRACE("applying feature akhn\n");
2446             Apply_Indic_BasicForm(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, akhn);
2447         }
2448
2449         if (rphf)
2450             Apply_Indic_Rphf(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs);
2451         if (rkrf)
2452         {
2453             TRACE("applying feature rkrf\n");
2454             Apply_Indic_BasicForm(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, rkrf);
2455         }
2456         if (pref)
2457             Apply_Indic_PostBase(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, modern, "pref");
2458         if (blwf)
2459         {
2460             if (!modern)
2461                 Apply_Indic_PreBase(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, "blwf");
2462
2463             Apply_Indic_PostBase(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, modern, "blwf");
2464
2465         }
2466         if (half)
2467             Apply_Indic_PreBase(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, "half");
2468         if (pstf)
2469         {
2470             TRACE("applying feature pstf\n");
2471             Apply_Indic_BasicForm(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, pstf);
2472         }
2473         if (vatu)
2474         {
2475             TRACE("applying feature vatu\n");
2476             Apply_Indic_BasicForm(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, vatu);
2477         }
2478         if (cjct)
2479         {
2480             TRACE("applying feature cjct\n");
2481             Apply_Indic_BasicForm(hdc, psc, psa, pwChars, cChars, &syllables[c], pwOutGlyphs, pcGlyphs, pwLogClust, lexical, &glyph_indexs, cjct);
2482         }
2483
2484         if (second_reorder)
2485             second_reorder(pwChars, &syllables[c], pwOutGlyphs, &glyph_indexs, lexical);
2486
2487         overall_shift += glyph_indexs.end - old_end;
2488     }
2489 }
2490
2491 static inline int unicode_lex(WCHAR c)
2492 {
2493     int type;
2494
2495     if (!c) return lex_Generic;
2496     if (c == 0x200D) return lex_ZWJ;
2497     if (c == 0x200C) return lex_ZWNJ;
2498     if (c == 0x00A0) return lex_NBSP;
2499
2500     type = get_table_entry( indic_syllabic_table, c );
2501
2502     if ((type & 0x00ff) != 0x0007)  type = type & 0x00ff;
2503
2504     switch( type )
2505     {
2506         case 0x0d07: /* Unknown */
2507         case 0x0e07: /* Unknwon */
2508         default: return lex_Generic;
2509         case 0x0001:
2510         case 0x0002:
2511         case 0x0011:
2512         case 0x0012:
2513         case 0x0013:
2514         case 0x0014: return lex_Modifier;
2515         case 0x0003:
2516         case 0x0009:
2517         case 0x000a:
2518         case 0x000b:
2519         case 0x000d:
2520         case 0x000e:
2521         case 0x000f:
2522         case 0x0010: return lex_Consonant;
2523         case 0x0004: return lex_Nukta;
2524         case 0x0005: return lex_Halant;
2525         case 0x0006:
2526         case 0x0008: return lex_Vowel;
2527         case 0x0007:
2528         case 0x0107: return lex_Matra_post;
2529         case 0x0207:
2530         case 0x0307: return lex_Matra_pre;
2531         case 0x0807:
2532         case 0x0907:
2533         case 0x0a07:
2534         case 0x0b07:
2535         case 0x0c07:
2536         case 0x0407: return lex_Composed_Vowel;
2537         case 0x0507: return lex_Matra_above;
2538         case 0x0607: return lex_Matra_below;
2539         case 0x000c: return lex_Ra;
2540     };
2541 }
2542
2543 static int sinhala_lex(WCHAR c)
2544 {
2545     switch (c)
2546     {
2547         case 0x0DDA:
2548         case 0x0DDD:
2549         case 0x0DDC:
2550         case 0x0DDE: return lex_Matra_post;
2551         default:
2552             return unicode_lex(c);
2553     }
2554 }
2555
2556 static const VowelComponents Sinhala_vowels[] = {
2557             {0x0DDA, {0x0DD9,0x0DDA,0x0}},
2558             {0x0DDC, {0x0DD9,0x0DDC,0x0}},
2559             {0x0DDD, {0x0DD9,0x0DDD,0x0}},
2560             {0x0DDE, {0x0DD9,0x0DDE,0x0}},
2561             {0x0000, {0x0000,0x0000,0x0}}};
2562
2563 static void ContextualShape_Sinhala(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2564 {
2565     int cCount = cChars;
2566     int i;
2567     WCHAR *input;
2568     IndicSyllable *syllables = NULL;
2569     int syllable_count = 0;
2570
2571     if (*pcGlyphs != cChars)
2572     {
2573         ERR("Number of Glyphs and Chars need to match at the beginning\n");
2574         return;
2575     }
2576
2577     input = HeapAlloc(GetProcessHeap(),0,sizeof(WCHAR) * (cChars * 3));
2578
2579     memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2580
2581     /* Step 1:  Decompose multi part vowels */
2582     DecomposeVowels(hdc, input,  &cCount, Sinhala_vowels, pwLogClust, cChars);
2583
2584     TRACE("New double vowel expanded string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2585
2586     /* Step 2:  Reorder within Syllables */
2587     Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, sinhala_lex, Reorder_Like_Sinhala, TRUE);
2588     TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2589
2590     /* Step 3:  Strip dangling joiners */
2591     for (i = 0; i < cCount; i++)
2592     {
2593         if ((input[i] == 0x200D || input[i] == 0x200C) &&
2594             (i == 0 || input[i-1] == 0x0020 || i == cCount-1 || input[i+1] == 0x0020))
2595             input[i] = 0x0020;
2596     }
2597
2598     /* Step 4: Base Form application to syllables */
2599     GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2600     *pcGlyphs = cCount;
2601     ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, sinhala_lex, NULL, TRUE);
2602
2603     HeapFree(GetProcessHeap(),0,input);
2604     HeapFree(GetProcessHeap(),0,syllables);
2605 }
2606
2607 static int devanagari_lex(WCHAR c)
2608 {
2609     switch (c)
2610     {
2611         case 0x0930: return lex_Ra;
2612         default:
2613             return unicode_lex(c);
2614     }
2615 }
2616
2617 static const ConsonantComponents Devanagari_consonants[] ={
2618     {{0x0928, 0x093C, 0x00000}, 0x0929},
2619     {{0x0930, 0x093C, 0x00000}, 0x0931},
2620     {{0x0933, 0x093C, 0x00000}, 0x0934},
2621     {{0x0915, 0x093C, 0x00000}, 0x0958},
2622     {{0x0916, 0x093C, 0x00000}, 0x0959},
2623     {{0x0917, 0x093C, 0x00000}, 0x095A},
2624     {{0x091C, 0x093C, 0x00000}, 0x095B},
2625     {{0x0921, 0x093C, 0x00000}, 0x095C},
2626     {{0x0922, 0x093C, 0x00000}, 0x095D},
2627     {{0x092B, 0x093C, 0x00000}, 0x095E},
2628     {{0x092F, 0x093C, 0x00000}, 0x095F}};
2629
2630 static void ContextualShape_Devanagari(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2631 {
2632     int cCount = cChars;
2633     WCHAR *input;
2634     IndicSyllable *syllables = NULL;
2635     int syllable_count = 0;
2636     BOOL modern = get_GSUB_Indic2(psa, psc);
2637
2638     if (*pcGlyphs != cChars)
2639     {
2640         ERR("Number of Glyphs and Chars need to match at the beginning\n");
2641         return;
2642     }
2643
2644     input = HeapAlloc(GetProcessHeap(), 0, cChars * sizeof(WCHAR));
2645     memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2646
2647     /* Step 1: Compose Consonant and Nukta */
2648     ComposeConsonants(hdc, input, &cCount, Devanagari_consonants, pwLogClust);
2649     TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2650
2651     /* Step 2: Reorder within Syllables */
2652     Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, devanagari_lex, Reorder_Like_Devanagari, modern);
2653     TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2654     GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2655     *pcGlyphs = cCount;
2656
2657     /* Step 3: Base Form application to syllables */
2658     ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, devanagari_lex, NULL, modern);
2659
2660     HeapFree(GetProcessHeap(),0,input);
2661     HeapFree(GetProcessHeap(),0,syllables);
2662 }
2663
2664 static int bengali_lex(WCHAR c)
2665 {
2666     switch (c)
2667     {
2668         case 0x09B0: return lex_Ra;
2669         default:
2670             return unicode_lex(c);
2671     }
2672 }
2673
2674 static const VowelComponents Bengali_vowels[] = {
2675             {0x09CB, {0x09C7,0x09BE,0x0000}},
2676             {0x09CC, {0x09C7,0x09D7,0x0000}},
2677             {0x0000, {0x0000,0x0000,0x0000}}};
2678
2679 static const ConsonantComponents Bengali_consonants[] = {
2680             {{0x09A4,0x09CD,0x200D}, 0x09CE},
2681             {{0x09A1,0x09BC,0x0000}, 0x09DC},
2682             {{0x09A2,0x09BC,0x0000}, 0x09DD},
2683             {{0x09AF,0x09BC,0x0000}, 0x09DF},
2684             {{0x0000,0x0000,0x0000}, 0x0000}};
2685
2686 static void ContextualShape_Bengali(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2687 {
2688     int cCount = cChars;
2689     WCHAR *input;
2690     IndicSyllable *syllables = NULL;
2691     int syllable_count = 0;
2692     BOOL modern = get_GSUB_Indic2(psa, psc);
2693
2694     if (*pcGlyphs != cChars)
2695     {
2696         ERR("Number of Glyphs and Chars need to match at the beginning\n");
2697         return;
2698     }
2699
2700     input = HeapAlloc(GetProcessHeap(), 0, (cChars * 2) * sizeof(WCHAR));
2701     memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2702
2703     /* Step 1: Decompose Vowels and Compose Consonents */
2704     DecomposeVowels(hdc, input,  &cCount, Bengali_vowels, pwLogClust, cChars);
2705     ComposeConsonants(hdc, input, &cCount, Bengali_consonants, pwLogClust);
2706     TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2707
2708     /* Step 2: Reorder within Syllables */
2709     Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, bengali_lex, Reorder_Like_Bengali, modern);
2710     TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2711     GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2712     *pcGlyphs = cCount;
2713
2714     /* Step 3: Initial form is only applied to the beginning of words */
2715     for (cCount = cCount - 1 ; cCount >= 0; cCount --)
2716     {
2717         if (cCount == 0 || input[cCount] == 0x0020) /* space */
2718         {
2719             int index = cCount;
2720             int gCount = 1;
2721             if (index > 0) index++;
2722
2723             apply_GSUB_feature_to_glyph(hdc, psa, psc, &pwOutGlyphs[index], 0, 1, &gCount, "init");
2724         }
2725     }
2726
2727     /* Step 4: Base Form application to syllables */
2728     ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, bengali_lex, NULL, modern);
2729
2730     HeapFree(GetProcessHeap(),0,input);
2731     HeapFree(GetProcessHeap(),0,syllables);
2732 }
2733
2734 static int gurmukhi_lex(WCHAR c)
2735 {
2736     if (c == 0x0A71)
2737         return lex_Modifier;
2738     else
2739         return unicode_lex(c);
2740 }
2741
2742 static const ConsonantComponents Gurmukhi_consonants[] = {
2743             {{0x0A32,0x0A3C,0x0000}, 0x0A33},
2744             {{0x0A16,0x0A3C,0x0000}, 0x0A59},
2745             {{0x0A17,0x0A3C,0x0000}, 0x0A5A},
2746             {{0x0A1C,0x0A3C,0x0000}, 0x0A5B},
2747             {{0x0A2B,0x0A3C,0x0000}, 0x0A5E},
2748             {{0x0000,0x0000,0x0000}, 0x0000}};
2749
2750 static void ContextualShape_Gurmukhi(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2751 {
2752     int cCount = cChars;
2753     WCHAR *input;
2754     IndicSyllable *syllables = NULL;
2755     int syllable_count = 0;
2756     BOOL modern = get_GSUB_Indic2(psa, psc);
2757
2758     if (*pcGlyphs != cChars)
2759     {
2760         ERR("Number of Glyphs and Chars need to match at the beginning\n");
2761         return;
2762     }
2763
2764     input = HeapAlloc(GetProcessHeap(), 0, cChars * sizeof(WCHAR));
2765     memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2766
2767     /* Step 1: Compose Consonents */
2768     ComposeConsonants(hdc, input, &cCount, Gurmukhi_consonants, pwLogClust);
2769     TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2770
2771     /* Step 2: Reorder within Syllables */
2772     Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, gurmukhi_lex, Reorder_Like_Bengali, modern);
2773     TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2774     GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2775     *pcGlyphs = cCount;
2776
2777     /* Step 3: Base Form application to syllables */
2778     ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, gurmukhi_lex, NULL, modern);
2779
2780     HeapFree(GetProcessHeap(),0,input);
2781     HeapFree(GetProcessHeap(),0,syllables);
2782 }
2783
2784 static int gujarati_lex(WCHAR c)
2785 {
2786     switch (c)
2787     {
2788         case 0x0AB0: return lex_Ra;
2789         default:
2790             return unicode_lex(c);
2791     }
2792 }
2793
2794 static void ContextualShape_Gujarati(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2795 {
2796     int cCount = cChars;
2797     WCHAR *input;
2798     IndicSyllable *syllables = NULL;
2799     int syllable_count = 0;
2800     BOOL modern = get_GSUB_Indic2(psa, psc);
2801
2802     if (*pcGlyphs != cChars)
2803     {
2804         ERR("Number of Glyphs and Chars need to match at the beginning\n");
2805         return;
2806     }
2807
2808     input = HeapAlloc(GetProcessHeap(), 0, cChars * sizeof(WCHAR));
2809     memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2810
2811     /* Step 1: Reorder within Syllables */
2812     Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, gujarati_lex, Reorder_Like_Devanagari, modern);
2813     TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2814     GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2815     *pcGlyphs = cCount;
2816
2817     /* Step 2: Base Form application to syllables */
2818     ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, gujarati_lex, NULL, modern);
2819
2820     HeapFree(GetProcessHeap(),0,input);
2821     HeapFree(GetProcessHeap(),0,syllables);
2822 }
2823
2824 static int oriya_lex(WCHAR c)
2825 {
2826     switch (c)
2827     {
2828         case 0x0B30: return lex_Ra;
2829         default:
2830             return unicode_lex(c);
2831     }
2832 }
2833
2834 static const VowelComponents Oriya_vowels[] = {
2835             {0x0B48, {0x0B47,0x0B56,0x0000}},
2836             {0x0B4B, {0x0B47,0x0B3E,0x0000}},
2837             {0x0B4C, {0x0B47,0x0B57,0x0000}},
2838             {0x0000, {0x0000,0x0000,0x0000}}};
2839
2840 static const ConsonantComponents Oriya_consonants[] = {
2841             {{0x0B21,0x0B3C,0x0000}, 0x0B5C},
2842             {{0x0B22,0x0B3C,0x0000}, 0x0B5D},
2843             {{0x0000,0x0000,0x0000}, 0x0000}};
2844
2845 static void ContextualShape_Oriya(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2846 {
2847     int cCount = cChars;
2848     WCHAR *input;
2849     IndicSyllable *syllables = NULL;
2850     int syllable_count = 0;
2851     BOOL modern = get_GSUB_Indic2(psa, psc);
2852
2853     if (*pcGlyphs != cChars)
2854     {
2855         ERR("Number of Glyphs and Chars need to match at the beginning\n");
2856         return;
2857     }
2858
2859     input = HeapAlloc(GetProcessHeap(), 0, (cChars*2) * sizeof(WCHAR));
2860     memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2861
2862     /* Step 1: Decompose Vowels and Compose Consonents */
2863     DecomposeVowels(hdc, input,  &cCount, Oriya_vowels, pwLogClust, cChars);
2864     ComposeConsonants(hdc, input, &cCount, Oriya_consonants, pwLogClust);
2865     TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2866
2867     /* Step 2: Reorder within Syllables */
2868     Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, oriya_lex, Reorder_Like_Bengali, modern);
2869     TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2870     GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2871     *pcGlyphs = cCount;
2872
2873     /* Step 3: Base Form application to syllables */
2874     ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, oriya_lex, NULL, modern);
2875
2876     HeapFree(GetProcessHeap(),0,input);
2877     HeapFree(GetProcessHeap(),0,syllables);
2878 }
2879
2880 static int tamil_lex(WCHAR c)
2881 {
2882     return unicode_lex(c);
2883 }
2884
2885 static const VowelComponents Tamil_vowels[] = {
2886             {0x0BCA, {0x0BC6,0x0BBE,0x0000}},
2887             {0x0BCB, {0x0BC7,0x0BBE,0x0000}},
2888             {0x0BCB, {0x0BC6,0x0BD7,0x0000}},
2889             {0x0000, {0x0000,0x0000,0x0000}}};
2890
2891 static const ConsonantComponents Tamil_consonants[] = {
2892             {{0x0B92,0x0BD7,0x0000}, 0x0B94},
2893             {{0x0000,0x0000,0x0000}, 0x0000}};
2894
2895 static void ContextualShape_Tamil(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2896 {
2897     int cCount = cChars;
2898     WCHAR *input;
2899     IndicSyllable *syllables = NULL;
2900     int syllable_count = 0;
2901     BOOL modern = get_GSUB_Indic2(psa, psc);
2902
2903     if (*pcGlyphs != cChars)
2904     {
2905         ERR("Number of Glyphs and Chars need to match at the beginning\n");
2906         return;
2907     }
2908
2909     input = HeapAlloc(GetProcessHeap(), 0, (cChars*2) * sizeof(WCHAR));
2910     memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2911
2912     /* Step 1: Decompose Vowels and Compose Consonents */
2913     DecomposeVowels(hdc, input,  &cCount, Tamil_vowels, pwLogClust, cChars);
2914     ComposeConsonants(hdc, input, &cCount, Tamil_consonants, pwLogClust);
2915     TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2916
2917     /* Step 2: Reorder within Syllables */
2918     Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, tamil_lex, Reorder_Like_Bengali, modern);
2919     TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2920     GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2921     *pcGlyphs = cCount;
2922
2923     /* Step 3: Base Form application to syllables */
2924     ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, tamil_lex, SecondReorder_Like_Tamil, modern);
2925
2926     HeapFree(GetProcessHeap(),0,input);
2927     HeapFree(GetProcessHeap(),0,syllables);
2928 }
2929
2930 static int telugu_lex(WCHAR c)
2931 {
2932     switch (c)
2933     {
2934         case 0x0C43:
2935         case 0x0C44: return lex_Modifier;
2936         default:
2937             return unicode_lex(c);
2938     }
2939 }
2940
2941 static const VowelComponents Telugu_vowels[] = {
2942             {0x0C48, {0x0C46,0x0C56,0x0000}},
2943             {0x0000, {0x0000,0x0000,0x0000}}};
2944
2945 static void ContextualShape_Telugu(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2946 {
2947     int cCount = cChars;
2948     WCHAR *input;
2949     IndicSyllable *syllables = NULL;
2950     int syllable_count = 0;
2951     BOOL modern = get_GSUB_Indic2(psa, psc);
2952
2953     if (*pcGlyphs != cChars)
2954     {
2955         ERR("Number of Glyphs and Chars need to match at the beginning\n");
2956         return;
2957     }
2958
2959     input = HeapAlloc(GetProcessHeap(), 0, (cChars*2) * sizeof(WCHAR));
2960     memcpy(input, pwcChars, cChars * sizeof(WCHAR));
2961
2962     /* Step 1: Decompose Vowels */
2963     DecomposeVowels(hdc, input,  &cCount, Telugu_vowels, pwLogClust, cChars);
2964     TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
2965
2966     /* Step 2: Reorder within Syllables */
2967     Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, telugu_lex, Reorder_Like_Bengali, modern);
2968     TRACE("reordered string %s\n",debugstr_wn(input,cCount));
2969     GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
2970     *pcGlyphs = cCount;
2971
2972     /* Step 3: Base Form application to syllables */
2973     ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, telugu_lex, SecondReorder_Like_Telugu, modern);
2974
2975     HeapFree(GetProcessHeap(),0,input);
2976     HeapFree(GetProcessHeap(),0,syllables);
2977 }
2978
2979 static int kannada_lex(WCHAR c)
2980 {
2981     switch (c)
2982     {
2983         case 0x0CB0: return lex_Ra;
2984         default:
2985             return unicode_lex(c);
2986     }
2987 }
2988
2989 static const VowelComponents Kannada_vowels[] = {
2990             {0x0CC0, {0x0CBF,0x0CD5,0x0000}},
2991             {0x0CC7, {0x0CC6,0x0CD5,0x0000}},
2992             {0x0CC8, {0x0CC6,0x0CD6,0x0000}},
2993             {0x0CCA, {0x0CC6,0x0CC2,0x0000}},
2994             {0x0CCB, {0x0CC6,0x0CC2,0x0CD5}},
2995             {0x0000, {0x0000,0x0000,0x0000}}};
2996
2997 static void ContextualShape_Kannada(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
2998 {
2999     int cCount = cChars;
3000     WCHAR *input;
3001     IndicSyllable *syllables = NULL;
3002     int syllable_count = 0;
3003     BOOL modern = get_GSUB_Indic2(psa, psc);
3004
3005     if (*pcGlyphs != cChars)
3006     {
3007         ERR("Number of Glyphs and Chars need to match at the beginning\n");
3008         return;
3009     }
3010
3011     input = HeapAlloc(GetProcessHeap(), 0, (cChars*3) * sizeof(WCHAR));
3012     memcpy(input, pwcChars, cChars * sizeof(WCHAR));
3013
3014     /* Step 1: Decompose Vowels */
3015     DecomposeVowels(hdc, input,  &cCount, Kannada_vowels, pwLogClust, cChars);
3016     TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
3017
3018     /* Step 2: Reorder within Syllables */
3019     Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, kannada_lex, Reorder_Like_Kannada, modern);
3020     TRACE("reordered string %s\n",debugstr_wn(input,cCount));
3021     GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
3022     *pcGlyphs = cCount;
3023
3024     /* Step 3: Base Form application to syllables */
3025     ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, kannada_lex, SecondReorder_Like_Telugu, modern);
3026
3027     HeapFree(GetProcessHeap(),0,input);
3028     HeapFree(GetProcessHeap(),0,syllables);
3029 }
3030
3031 static int malayalam_lex(WCHAR c)
3032 {
3033     return unicode_lex(c);
3034 }
3035
3036 static const VowelComponents Malayalam_vowels[] = {
3037             {0x0D4A, {0x0D46,0x0D3E,0x0000}},
3038             {0x0D4B, {0x0D47,0x0D3E,0x0000}},
3039             {0x0D4C, {0x0D46,0x0D57,0x0000}},
3040             {0x0000, {0x0000,0x0000,0x0000}}};
3041
3042 static void ContextualShape_Malayalam(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
3043 {
3044     int cCount = cChars;
3045     WCHAR *input;
3046     IndicSyllable *syllables = NULL;
3047     int syllable_count = 0;
3048     BOOL modern = get_GSUB_Indic2(psa, psc);
3049
3050     if (*pcGlyphs != cChars)
3051     {
3052         ERR("Number of Glyphs and Chars need to match at the beginning\n");
3053         return;
3054     }
3055
3056     input = HeapAlloc(GetProcessHeap(), 0, (cChars*2) * sizeof(WCHAR));
3057     memcpy(input, pwcChars, cChars * sizeof(WCHAR));
3058
3059     /* Step 1: Decompose Vowels */
3060     DecomposeVowels(hdc, input,  &cCount, Malayalam_vowels, pwLogClust, cChars);
3061     TRACE("New composed string %s (%i)\n",debugstr_wn(input,cCount),cCount);
3062
3063     /* Step 2: Reorder within Syllables */
3064     Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, malayalam_lex, Reorder_Like_Devanagari, modern);
3065     TRACE("reordered string %s\n",debugstr_wn(input,cCount));
3066     GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
3067     *pcGlyphs = cCount;
3068
3069     /* Step 3: Base Form application to syllables */
3070     ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, malayalam_lex, SecondReorder_Like_Tamil, modern);
3071
3072     HeapFree(GetProcessHeap(),0,input);
3073     HeapFree(GetProcessHeap(),0,syllables);
3074 }
3075
3076 static int khmer_lex(WCHAR c)
3077 {
3078     return unicode_lex(c);
3079 }
3080
3081 static void ContextualShape_Khmer(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
3082 {
3083     int cCount = cChars;
3084     WCHAR *input;
3085     IndicSyllable *syllables = NULL;
3086     int syllable_count = 0;
3087
3088     if (*pcGlyphs != cChars)
3089     {
3090         ERR("Number of Glyphs and Chars need to match at the beginning\n");
3091         return;
3092     }
3093
3094     input = HeapAlloc(GetProcessHeap(), 0, cChars * sizeof(WCHAR));
3095     memcpy(input, pwcChars, cChars * sizeof(WCHAR));
3096
3097     /* Step 1: Reorder within Syllables */
3098     Indic_ReorderCharacters( hdc, psa, psc, input, cCount, &syllables, &syllable_count, khmer_lex, Reorder_Like_Devanagari, FALSE);
3099     TRACE("reordered string %s\n",debugstr_wn(input,cCount));
3100     GetGlyphIndicesW(hdc, input, cCount, pwOutGlyphs, 0);
3101     *pcGlyphs = cCount;
3102
3103     /* Step 2: Base Form application to syllables */
3104     ShapeIndicSyllables(hdc, psc, psa, input, cChars, syllables, syllable_count, pwOutGlyphs, pcGlyphs, pwLogClust, khmer_lex, NULL, FALSE);
3105
3106     HeapFree(GetProcessHeap(),0,input);
3107     HeapFree(GetProcessHeap(),0,syllables);
3108 }
3109
3110 static inline BOOL mongolian_wordbreak(WCHAR chr)
3111 {
3112     return ((chr == 0x0020) || (chr == 0x200C) || (chr == 0x202F) || (chr == 0x180E) || (chr == 0x1800) || (chr == 0x1802) || (chr == 0x1803) || (chr == 0x1805) || (chr == 0x1808) || (chr == 0x1809) || (chr == 0x1807));
3113 }
3114
3115 static void ContextualShape_Mongolian(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
3116 {
3117     INT *context_shape;
3118     INT dirL;
3119     int i;
3120
3121     if (*pcGlyphs != cChars)
3122     {
3123         ERR("Number of Glyphs and Chars need to match at the beginning\n");
3124         return;
3125     }
3126
3127     if (!psa->fLogicalOrder && psa->fRTL)
3128         dirL = -1;
3129     else
3130         dirL = 1;
3131
3132     if (!psc->GSUB_Table)
3133         psc->GSUB_Table = load_gsub_table(hdc);
3134
3135     if (!psc->GSUB_Table)
3136         return;
3137
3138     context_shape = HeapAlloc(GetProcessHeap(),0,sizeof(INT) * cChars);
3139
3140     for (i = 0; i < cChars; i++)
3141     {
3142         if (i == 0 || mongolian_wordbreak(pwcChars[i-1]))
3143         {
3144             if ((i == cChars-1) || mongolian_wordbreak(pwcChars[i+1]))
3145                 context_shape[i] = Xn;
3146             else
3147                 context_shape[i] = Xl;
3148         }
3149         else
3150         {
3151             if ((i == cChars-1) || mongolian_wordbreak(pwcChars[i+1]))
3152                 context_shape[i] = Xr;
3153             else
3154                 context_shape[i] = Xm;
3155         }
3156     }
3157
3158     /* Contextual Shaping */
3159     i = 0;
3160     while(i < *pcGlyphs)
3161     {
3162         INT nextIndex;
3163         INT prevCount = *pcGlyphs;
3164         nextIndex = apply_GSUB_feature_to_glyph(hdc, psa, psc, pwOutGlyphs, i, dirL, pcGlyphs, contextual_features[context_shape[i]]);
3165         if (nextIndex > GSUB_E_NOGLYPH)
3166         {
3167             UpdateClusters(nextIndex, *pcGlyphs - prevCount, dirL, cChars, pwLogClust);
3168             i = nextIndex;
3169         }
3170         else
3171             i++;
3172     }
3173
3174     HeapFree(GetProcessHeap(),0,context_shape);
3175 }
3176
3177 static void ShapeCharGlyphProp_Default( HDC hdc, ScriptCache* psc, SCRIPT_ANALYSIS* psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD* pwLogClust, SCRIPT_CHARPROP* pCharProp, SCRIPT_GLYPHPROP* pGlyphProp)
3178 {
3179     int i,k;
3180
3181     for (i = 0; i < cGlyphs; i++)
3182     {
3183         int char_index[20];
3184         int char_count = 0;
3185
3186         for (k = 0; k < cChars; k++)
3187         {
3188             if (pwLogClust[k] == i)
3189             {
3190                 char_index[char_count] = k;
3191                 char_count++;
3192             }
3193         }
3194
3195         if (char_count == 0)
3196             continue;
3197
3198         if (char_count ==1 && pwcChars[char_index[0]] == 0x0020)  /* space */
3199         {
3200             pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_BLANK;
3201             pCharProp[char_index[0]].fCanGlyphAlone = 1;
3202         }
3203         else
3204             pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_CHARACTER;
3205     }
3206
3207     GDEF_UpdateGlyphProps(hdc, psc, pwGlyphs, cGlyphs, pwLogClust, cChars, pGlyphProp);
3208     UpdateClustersFromGlyphProp(cGlyphs, cChars, pwLogClust, pGlyphProp);
3209 }
3210
3211 static void ShapeCharGlyphProp_Arabic( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3212 {
3213     int i,k;
3214     int initGlyph, finaGlyph;
3215     INT dirR, dirL;
3216     BYTE *spaces;
3217
3218     spaces = HeapAlloc(GetProcessHeap(),0,cGlyphs);
3219     memset(spaces,0,cGlyphs);
3220
3221     if (!psa->fLogicalOrder && psa->fRTL)
3222     {
3223         initGlyph = cGlyphs-1;
3224         finaGlyph = 0;
3225         dirR = 1;
3226         dirL = -1;
3227     }
3228     else
3229     {
3230         initGlyph = 0;
3231         finaGlyph = cGlyphs-1;
3232         dirR = -1;
3233         dirL = 1;
3234     }
3235
3236     for (i = 0; i < cGlyphs; i++)
3237     {
3238         for (k = 0; k < cChars; k++)
3239             if (pwLogClust[k] == i)
3240             {
3241                 if (pwcChars[k] == 0x0020)
3242                     spaces[i] = 1;
3243             }
3244     }
3245
3246     for (i = 0; i < cGlyphs; i++)
3247     {
3248         int char_index[20];
3249         int char_count = 0;
3250         BOOL isInit, isFinal;
3251
3252         for (k = 0; k < cChars; k++)
3253         {
3254             if (pwLogClust[k] == i)
3255             {
3256                 char_index[char_count] = k;
3257                 char_count++;
3258             }
3259         }
3260
3261         isInit = (i == initGlyph || (i+dirR > 0 && i+dirR < cGlyphs && spaces[i+dirR]));
3262         isFinal = (i == finaGlyph || (i+dirL > 0 && i+dirL < cGlyphs && spaces[i+dirL]));
3263
3264         if (char_count == 0)
3265             continue;
3266
3267         if (char_count == 1)
3268         {
3269             if (pwcChars[char_index[0]] == 0x0020)  /* space */
3270             {
3271                 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_BLANK;
3272                 pCharProp[char_index[0]].fCanGlyphAlone = 1;
3273             }
3274             else if (pwcChars[char_index[0]] == 0x0640)  /* kashida */
3275                 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_KASHIDA;
3276             else if (pwcChars[char_index[0]] == 0x0633)  /* SEEN */
3277             {
3278                 if (!isInit && !isFinal)
3279                     pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_SEEN_M;
3280                 else if (isInit)
3281                     pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_SEEN;
3282                 else
3283                     pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3284             }
3285             else if (!isInit)
3286             {
3287                 if (pwcChars[char_index[0]] == 0x0628 ) /* BA */
3288                     pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_BA;
3289                 else if (pwcChars[char_index[0]] == 0x0631 ) /* RA */
3290                     pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_RA;
3291                 else if (pwcChars[char_index[0]] == 0x0647 ) /* HA */
3292                     pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_HA;
3293                 else if ((pwcChars[char_index[0]] == 0x0627 || pwcChars[char_index[0]] == 0x0625 || pwcChars[char_index[0]] == 0x0623 || pwcChars[char_index[0]] == 0x0622) ) /* alef-like */
3294                     pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_ALEF;
3295                 else
3296                     pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3297             }
3298             else if (!isInit && !isFinal)
3299                 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_NORMAL;
3300             else
3301                 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3302         }
3303         else if (char_count == 2)
3304         {
3305             if ((pwcChars[char_index[0]] == 0x0628 && pwcChars[char_index[1]]== 0x0631) ||  (pwcChars[char_index[0]] == 0x0631 && pwcChars[char_index[1]]== 0x0628)) /* BA+RA */
3306                 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_BARA;
3307             else if (!isInit)
3308                 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_NORMAL;
3309             else
3310                 pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3311         }
3312         else if (!isInit && !isFinal)
3313             pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_ARABIC_NORMAL;
3314         else
3315             pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3316     }
3317
3318     GDEF_UpdateGlyphProps(hdc, psc, pwGlyphs, cGlyphs, pwLogClust, cChars, pGlyphProp);
3319     UpdateClustersFromGlyphProp(cGlyphs, cChars, pwLogClust, pGlyphProp);
3320     HeapFree(GetProcessHeap(),0,spaces);
3321 }
3322
3323 static void ShapeCharGlyphProp_Thai( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3324 {
3325     int i,k;
3326     int finaGlyph;
3327     INT dirL;
3328     BYTE *spaces;
3329
3330     spaces = HeapAlloc(GetProcessHeap(),0,cGlyphs);
3331     memset(spaces,0,cGlyphs);
3332
3333     if (!psa->fLogicalOrder && psa->fRTL)
3334     {
3335         finaGlyph = 0;
3336         dirL = -1;
3337     }
3338     else
3339     {
3340         finaGlyph = cGlyphs-1;
3341         dirL = 1;
3342     }
3343
3344     for (i = 0; i < cGlyphs; i++)
3345     {
3346         for (k = 0; k < cChars; k++)
3347             if (pwLogClust[k] == i)
3348             {
3349                 if (pwcChars[k] == 0x0020)
3350                     spaces[i] = 1;
3351             }
3352     }
3353
3354     GDEF_UpdateGlyphProps(hdc, psc, pwGlyphs, cGlyphs, pwLogClust, cChars, pGlyphProp);
3355
3356     for (i = 0; i < cGlyphs; i++)
3357     {
3358         int char_index[20];
3359         int char_count = 0;
3360
3361         for (k = 0; k < cChars; k++)
3362         {
3363             if (pwLogClust[k] == i)
3364             {
3365                 char_index[char_count] = k;
3366                 char_count++;
3367             }
3368         }
3369
3370         if (char_count == 0)
3371             continue;
3372
3373         if (char_count ==1 && pwcChars[char_index[0]] == 0x0020)  /* space */
3374         {
3375             pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_CHARACTER;
3376             pCharProp[char_index[0]].fCanGlyphAlone = 1;
3377         }
3378         else if (i == finaGlyph)
3379             pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3380         else
3381             pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_CHARACTER;
3382
3383         /* handle Thai SARA AM (U+0E33) differently than GDEF */
3384         if (char_count == 1 && pwcChars[char_index[0]] == 0x0e33)
3385             pGlyphProp[i].sva.fClusterStart = 0;
3386     }
3387
3388     HeapFree(GetProcessHeap(),0,spaces);
3389     UpdateClustersFromGlyphProp(cGlyphs, cChars, pwLogClust, pGlyphProp);
3390
3391     /* Do not allow justification between marks and their base */
3392     for (i = 0; i < cGlyphs; i++)
3393     {
3394         if (!pGlyphProp[i].sva.fClusterStart)
3395             pGlyphProp[i-dirL].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3396     }
3397 }
3398
3399 static void ShapeCharGlyphProp_None( HDC hdc, ScriptCache* psc, SCRIPT_ANALYSIS* psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD* pwLogClust, SCRIPT_CHARPROP* pCharProp, SCRIPT_GLYPHPROP* pGlyphProp)
3400 {
3401     int i,k;
3402
3403     for (i = 0; i < cGlyphs; i++)
3404     {
3405         int char_index[20];
3406         int char_count = 0;
3407
3408         for (k = 0; k < cChars; k++)
3409         {
3410             if (pwLogClust[k] == i)
3411             {
3412                 char_index[char_count] = k;
3413                 char_count++;
3414             }
3415         }
3416
3417         if (char_count == 0)
3418             continue;
3419
3420         if (char_count ==1 && pwcChars[char_index[0]] == 0x0020)  /* space */
3421         {
3422             pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_CHARACTER;
3423             pCharProp[char_index[0]].fCanGlyphAlone = 1;
3424         }
3425         else
3426             pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3427     }
3428     GDEF_UpdateGlyphProps(hdc, psc, pwGlyphs, cGlyphs, pwLogClust, cChars, pGlyphProp);
3429     UpdateClustersFromGlyphProp(cGlyphs, cChars, pwLogClust, pGlyphProp);
3430 }
3431
3432 static void ShapeCharGlyphProp_Tibet( HDC hdc, ScriptCache* psc, SCRIPT_ANALYSIS* psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD* pwLogClust, SCRIPT_CHARPROP* pCharProp, SCRIPT_GLYPHPROP* pGlyphProp)
3433 {
3434     int i,k;
3435
3436     for (i = 0; i < cGlyphs; i++)
3437     {
3438         int char_index[20];
3439         int char_count = 0;
3440
3441         for (k = 0; k < cChars; k++)
3442         {
3443             if (pwLogClust[k] == i)
3444             {
3445                 char_index[char_count] = k;
3446                 char_count++;
3447             }
3448         }
3449
3450         if (char_count == 0)
3451             continue;
3452
3453         if (char_count ==1 && pwcChars[char_index[0]] == 0x0020)  /* space */
3454         {
3455             pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_BLANK;
3456             pCharProp[char_index[0]].fCanGlyphAlone = 1;
3457         }
3458         else
3459             pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3460     }
3461     GDEF_UpdateGlyphProps(hdc, psc, pwGlyphs, cGlyphs, pwLogClust, cChars, pGlyphProp);
3462     UpdateClustersFromGlyphProp(cGlyphs, cChars, pwLogClust, pGlyphProp);
3463
3464     /* Tibeten script does not set sva.fDiacritic or sva.fZeroWidth */
3465     for (i = 0; i < cGlyphs; i++)
3466     {
3467         if (!pGlyphProp[i].sva.fClusterStart)
3468         {
3469             pGlyphProp[i].sva.fDiacritic = 0;
3470             pGlyphProp[i].sva.fZeroWidth = 0;
3471         }
3472     }
3473 }
3474
3475 static void ShapeCharGlyphProp_BaseIndic( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp, lexical_function lexical, BOOL use_syllables, BOOL override_gsub)
3476 {
3477     int i,k;
3478
3479     GDEF_UpdateGlyphProps(hdc, psc, pwGlyphs, cGlyphs, pwLogClust, cChars, pGlyphProp);
3480     for (i = 0; i < cGlyphs; i++)
3481     {
3482         int char_index[20];
3483         int char_count = 0;
3484
3485         for (k = 0; k < cChars; k++)
3486         {
3487             if (pwLogClust[k] == i)
3488             {
3489                 char_index[char_count] = k;
3490                 char_count++;
3491             }
3492         }
3493
3494         if (override_gsub)
3495         {
3496             /* Most indic scripts do not set fDiacritic or fZeroWidth */
3497             pGlyphProp[i].sva.fDiacritic = FALSE;
3498             pGlyphProp[i].sva.fZeroWidth = FALSE;
3499         }
3500
3501         if (char_count == 0)
3502             continue;
3503
3504         if (char_count ==1 && pwcChars[char_index[0]] == 0x0020)  /* space */
3505         {
3506             pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_BLANK;
3507             pCharProp[char_index[0]].fCanGlyphAlone = 1;
3508         }
3509         else
3510             pGlyphProp[i].sva.uJustification = SCRIPT_JUSTIFY_NONE;
3511
3512         pGlyphProp[i].sva.fClusterStart = 0;
3513         for (k = 0; k < char_count && !pGlyphProp[i].sva.fClusterStart; k++)
3514             switch (lexical(pwcChars[char_index[k]]))
3515             {
3516                 case lex_Matra_pre:
3517                 case lex_Matra_post:
3518                 case lex_Matra_above:
3519                 case lex_Matra_below:
3520                 case lex_Modifier:
3521                 case lex_Halant:
3522                     break;
3523                 case lex_ZWJ:
3524                 case lex_ZWNJ:
3525                     /* check for dangling joiners */
3526                     if (pwcChars[char_index[k]-1] == 0x0020 || pwcChars[char_index[k]+1] == 0x0020)
3527                         pGlyphProp[i].sva.fClusterStart = 1;
3528                     else
3529                         k = char_count;
3530                     break;
3531                 default:
3532                     pGlyphProp[i].sva.fClusterStart = 1;
3533                     break;
3534             }
3535     }
3536
3537     if (use_syllables)
3538     {
3539         IndicSyllable *syllables = NULL;
3540         int syllable_count = 0;
3541         BOOL modern = get_GSUB_Indic2(psa, psc);
3542
3543         Indic_ParseSyllables( hdc, psa, psc, pwcChars, cChars, &syllables, &syllable_count, lexical, modern);
3544
3545         for (i = 0; i < syllable_count; i++)
3546         {
3547             int j;
3548             WORD g = pwLogClust[syllables[i].start];
3549             for (j = syllables[i].start+1; j <= syllables[i].end; j++)
3550             {
3551                 if (pwLogClust[j] != g)
3552                 {
3553                     pGlyphProp[pwLogClust[j]].sva.fClusterStart = 0;
3554                     pwLogClust[j] = g;
3555                 }
3556             }
3557         }
3558
3559         HeapFree(GetProcessHeap(), 0, syllables);
3560     }
3561
3562     UpdateClustersFromGlyphProp(cGlyphs, cChars, pwLogClust, pGlyphProp);
3563 }
3564
3565 static void ShapeCharGlyphProp_Sinhala( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3566 {
3567     ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, sinhala_lex, FALSE, FALSE);
3568 }
3569
3570 static void ShapeCharGlyphProp_Devanagari( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3571 {
3572     ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, devanagari_lex, TRUE, TRUE);
3573 }
3574
3575 static void ShapeCharGlyphProp_Bengali( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3576 {
3577     ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, bengali_lex, TRUE, TRUE);
3578 }
3579
3580 static void ShapeCharGlyphProp_Gurmukhi( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3581 {
3582     ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, gurmukhi_lex, TRUE, TRUE);
3583 }
3584
3585 static void ShapeCharGlyphProp_Gujarati( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3586 {
3587     ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, gujarati_lex, TRUE, TRUE);
3588 }
3589
3590 static void ShapeCharGlyphProp_Oriya( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3591 {
3592     ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, oriya_lex, TRUE, TRUE);
3593 }
3594
3595 static void ShapeCharGlyphProp_Tamil( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3596 {
3597     ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, tamil_lex, TRUE, TRUE);
3598 }
3599
3600 static void ShapeCharGlyphProp_Telugu( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3601 {
3602     ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, telugu_lex, TRUE, TRUE);
3603 }
3604
3605 static void ShapeCharGlyphProp_Kannada( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3606 {
3607     ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, kannada_lex, TRUE, TRUE);
3608 }
3609
3610 static void ShapeCharGlyphProp_Malayalam( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3611 {
3612     ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, malayalam_lex, TRUE, TRUE);
3613 }
3614
3615 static void ShapeCharGlyphProp_Khmer( HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp )
3616 {
3617     ShapeCharGlyphProp_BaseIndic(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp, khmer_lex, TRUE, TRUE);
3618 }
3619
3620 void SHAPE_CharGlyphProp(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, const WCHAR* pwcChars, const INT cChars, const WORD* pwGlyphs, const INT cGlyphs, WORD *pwLogClust, SCRIPT_CHARPROP *pCharProp, SCRIPT_GLYPHPROP *pGlyphProp)
3621 {
3622     if (ShapingData[psa->eScript].charGlyphPropProc)
3623         ShapingData[psa->eScript].charGlyphPropProc(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp);
3624     else
3625         ShapeCharGlyphProp_Default(hdc, psc, psa, pwcChars, cChars, pwGlyphs, cGlyphs, pwLogClust, pCharProp, pGlyphProp);
3626 }
3627
3628 void SHAPE_ContextualShaping(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WCHAR* pwcChars, INT cChars, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, WORD *pwLogClust)
3629 {
3630     if (!psc->GSUB_Table)
3631         psc->GSUB_Table = load_gsub_table(hdc);
3632
3633     if (ShapingData[psa->eScript].contextProc)
3634         ShapingData[psa->eScript].contextProc(hdc, psc, psa, pwcChars, cChars, pwOutGlyphs, pcGlyphs, cMaxGlyphs, pwLogClust);
3635 }
3636
3637 static void SHAPE_ApplyOpenTypeFeatures(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, INT cChars, const TEXTRANGE_PROPERTIES *rpRangeProperties, WORD *pwLogClust)
3638 {
3639     int i;
3640     INT dirL;
3641
3642     if (!rpRangeProperties)
3643         return;
3644
3645     if (!psc->GSUB_Table)
3646         psc->GSUB_Table = load_gsub_table(hdc);
3647
3648     if (!psc->GSUB_Table)
3649         return;
3650
3651     if (!psa->fLogicalOrder && psa->fRTL)
3652         dirL = -1;
3653     else
3654         dirL = 1;
3655
3656     for (i = 0; i < rpRangeProperties->cotfRecords; i++)
3657     {
3658         if (rpRangeProperties->potfRecords[i].lParameter > 0)
3659         apply_GSUB_feature(hdc, psa, psc, pwOutGlyphs, dirL, pcGlyphs, cChars, (const char*)&rpRangeProperties->potfRecords[i].tagFeature, pwLogClust);
3660     }
3661 }
3662
3663 void SHAPE_ApplyDefaultOpentypeFeatures(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa, WORD* pwOutGlyphs, INT* pcGlyphs, INT cMaxGlyphs, INT cChars, WORD *pwLogClust)
3664 {
3665 const TEXTRANGE_PROPERTIES *rpRangeProperties;
3666 rpRangeProperties = &ShapingData[psa->eScript].defaultTextRange;
3667
3668     SHAPE_ApplyOpenTypeFeatures(hdc, psc, psa, pwOutGlyphs, pcGlyphs, cMaxGlyphs, cChars, rpRangeProperties, pwLogClust);
3669 }
3670
3671 HRESULT SHAPE_CheckFontForRequiredFeatures(HDC hdc, ScriptCache *psc, SCRIPT_ANALYSIS *psa)
3672 {
3673     const GSUB_Feature *feature;
3674     int i;
3675
3676     if (!ShapingData[psa->eScript].requiredFeatures)
3677         return S_OK;
3678
3679     if (!psc->GSUB_Table)
3680         psc->GSUB_Table = load_gsub_table(hdc);
3681
3682     /* we need to have at least one of the required features */
3683     i = 0;
3684     while (ShapingData[psa->eScript].requiredFeatures[i])
3685     {
3686         feature = load_GSUB_feature(hdc, psa, psc, ShapingData[psa->eScript].requiredFeatures[i]);
3687         if (feature)
3688             return S_OK;
3689         i++;
3690     }
3691
3692     return USP_E_SCRIPT_NOT_IN_FONT;
3693 }
3694
3695 static VOID *load_CMAP_format12_table(HDC hdc, ScriptCache *psc)
3696 {
3697     CMAP_Header *CMAP_Table = NULL;
3698     int length;
3699     int i;
3700
3701     if (!psc->CMAP_Table)
3702     {
3703         length = GetFontData(hdc, CMAP_TAG , 0, NULL, 0);
3704         if (length != GDI_ERROR)
3705         {
3706             psc->CMAP_Table = HeapAlloc(GetProcessHeap(),0,length);
3707             GetFontData(hdc, CMAP_TAG , 0, psc->CMAP_Table, length);
3708             TRACE("Loaded cmap table of %i bytes\n",length);
3709         }
3710         else
3711             return NULL;
3712     }
3713
3714     CMAP_Table = psc->CMAP_Table;
3715
3716     for (i = 0; i < GET_BE_WORD(CMAP_Table->numTables); i++)
3717     {
3718         if ( (GET_BE_WORD(CMAP_Table->tables[i].platformID) == 3) &&
3719              (GET_BE_WORD(CMAP_Table->tables[i].encodingID) == 10) )
3720         {
3721             CMAP_SegmentedCoverage *format = (CMAP_SegmentedCoverage*)(((BYTE*)CMAP_Table) + GET_BE_DWORD(CMAP_Table->tables[i].offset));
3722             if (GET_BE_WORD(format->format) == 12)
3723                 return format;
3724         }
3725     }
3726     return NULL;
3727 }
3728
3729 static int compare_group(const void *a, const void* b)
3730 {
3731     const DWORD *chr = a;
3732     const CMAP_SegmentedCoverage_group *group = b;
3733
3734     if (*chr < GET_BE_DWORD(group->startCharCode))
3735         return -1;
3736     if (*chr > GET_BE_DWORD(group->endCharCode))
3737         return 1;
3738     return 0;
3739 }
3740
3741 DWORD CMAP_GetGlyphIndex(HDC hdc, ScriptCache *psc, DWORD utf32c, LPWORD pgi, DWORD flags)
3742 {
3743     /* BMP: use gdi32 for ease */
3744     if (utf32c < 0x10000)
3745     {
3746         WCHAR ch = utf32c;
3747         return GetGlyphIndicesW(hdc,&ch, 1, pgi, flags);
3748     }
3749
3750     if (!psc->CMAP_format12_Table)
3751         psc->CMAP_format12_Table = load_CMAP_format12_table(hdc, psc);
3752
3753     if (flags & GGI_MARK_NONEXISTING_GLYPHS)
3754         *pgi = 0xffff;
3755     else
3756         *pgi = 0;
3757
3758     if (psc->CMAP_format12_Table)
3759     {
3760         CMAP_SegmentedCoverage *format = NULL;
3761         CMAP_SegmentedCoverage_group *group = NULL;
3762
3763         format = (CMAP_SegmentedCoverage *)psc->CMAP_format12_Table;
3764
3765         group = bsearch(&utf32c, format->groups, GET_BE_DWORD(format->nGroups),
3766                         sizeof(CMAP_SegmentedCoverage_group), compare_group);
3767
3768         if (group)
3769         {
3770             DWORD offset = utf32c - GET_BE_DWORD(group->startCharCode);
3771             *pgi = GET_BE_DWORD(group->startGlyphID) + offset;
3772             return 0;
3773         }
3774     }
3775     return 0;
3776 }