dlls/usp10/indic.c

   1 /*
   2  * Implementation of Indic Syllables for the Uniscribe Script Processor
   3  *
   4  * Copyright 2011 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 "config.h"
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winuser.h"
  29 #include "wingdi.h"
  30 #include "winnls.h"
  31 #include "usp10.h"
  32 #include "winternl.h"
  33
  34 #include "wine/debug.h"
  35 #include "usp10_internal.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(uniscribe);
  38
  39 static void debug_output_string(LPCWSTR str, int cChar, lexical_function f)
  40 {
  41     int i;
  42     if (TRACE_ON(uniscribe))
  43     {
  44         for (i = 0; i < cChar; i++)
  45         {
  46             switch (f(str[i]))
  47             {
  48                 case lex_Consonant: TRACE("C"); break;
  49                 case lex_Ra: TRACE("Ra"); break;
  50                 case lex_Vowel: TRACE("V"); break;
  51                 case lex_Nukta: TRACE("N"); break;
  52                 case lex_Halant: TRACE("H"); break;
  53                 case lex_ZWNJ: TRACE("Zwnj"); break;
  54                 case lex_ZWJ: TRACE("Zwj"); break;
  55                 case lex_Matra_post: TRACE("Mp");break;
  56                 case lex_Matra_above: TRACE("Ma");break;
  57                 case lex_Matra_below: TRACE("Mb");break;
  58                 case lex_Matra_pre: TRACE("Mm");break;
  59                 case lex_Modifier: TRACE("Sm"); break;
  60                 case lex_Vedic: TRACE("Vd"); break;
  61                 case lex_Anudatta: TRACE("A"); break;
  62                 case lex_Composed_Vowel: TRACE("t"); break;
  63                 default:
  64                     TRACE("X"); break;
  65             }
  66         }
  67         TRACE("\n");
  68     }
  69 }
  70
  71 static inline BOOL is_matra( int type )
  72 {
  73     return (type == lex_Matra_above || type == lex_Matra_below ||
  74             type == lex_Matra_pre || type == lex_Matra_post ||
  75             type == lex_Composed_Vowel);
  76 }
  77
  78 static inline BOOL is_joiner( int type )
  79 {
  80     return (type == lex_ZWJ || type == lex_ZWNJ);
  81 }
  82
  83 static INT consonant_header(LPCWSTR input, INT cChar, INT start, INT next,
  84                             lexical_function lex)
  85 {
  86     if (!is_consonant( lex(input[next]) )) return -1;
  87     next++;
  88     if ((next < cChar) && lex(input[next]) == lex_Nukta)
  89             next++;
  90     if ((next < cChar) && lex(input[next])==lex_Halant)
  91     {
  92         next++;
  93         if((next < cChar) && is_joiner( lex(input[next]) ))
  94             next++;
  95         if ((next < cChar) && is_consonant( lex(input[next]) ))
  96             return next;
  97     }
  98     else if ((next < cChar) && is_joiner( lex(input[next]) ) && lex(input[next+1])==lex_Halant)
  99     {
 100         next+=2;
 101         if ((next < cChar) && is_consonant( lex(input[next]) ))
 102             return next;
 103     }
 104     return -1;
 105 }
 106
 107 static INT parse_consonant_syllable(LPCWSTR input, INT cChar, INT start,
 108                                     INT *main, INT next, lexical_function lex)
 109 {
 110     int check;
 111     int headers = 0;
 112     do
 113     {
 114         check = consonant_header(input,cChar,start,next,lex);
 115         if (check != -1)
 116         {
 117             next = check;
 118             headers++;
 119         }
 120     } while (check != -1);
 121     if (headers || is_consonant( lex(input[next]) ))
 122     {
 123         *main = next;
 124         next++;
 125     }
 126     else
 127         return -1;
 128     if ((next < cChar) && lex(input[next]) == lex_Nukta)
 129             next++;
 130     if ((next < cChar) && lex(input[next]) == lex_Anudatta)
 131             next++;
 132
 133     if ((next < cChar) && lex(input[next]) == lex_Halant)
 134     {
 135         next++;
 136         if((next < cChar) && is_joiner( lex(input[next]) ))
 137             next++;
 138     }
 139     else if (next < cChar)
 140     {
 141         while((next < cChar) && is_matra( lex(input[next]) ))
 142             next++;
 143         if ((next < cChar) && lex(input[next]) == lex_Nukta)
 144             next++;
 145         if ((next < cChar) && lex(input[next]) == lex_Halant)
 146             next++;
 147     }
 148     if ((next < cChar) && lex(input[next]) == lex_Modifier)
 149             next++;
 150     if ((next < cChar) && lex(input[next]) == lex_Vedic)
 151             next++;
 152     return next;
 153 }
 154
 155 static INT parse_vowel_syllable(LPCWSTR input, INT cChar, INT start,
 156                                     INT next, lexical_function lex)
 157 {
 158     if ((next < cChar) && lex(input[next]) == lex_Nukta)
 159         next++;
 160     if ((next < cChar) && is_joiner( lex(input[next]) ) && lex(input[next+1])==lex_Halant && is_consonant( lex(input[next+2]) ))
 161         next+=3;
 162     else if ((next < cChar) && lex(input[next])==lex_Halant && is_consonant( lex(input[next+1]) ))
 163         next+=2;
 164     else if ((next < cChar) && lex(input[next])==lex_ZWJ && is_consonant( lex(input[next+1]) ))
 165         next+=2;
 166
 167     if ((next < cChar) && is_matra( lex(input[next]) ))
 168     {
 169         while((next < cChar) && is_matra( lex(input[next]) ))
 170             next++;
 171         if ((next < cChar) && lex(input[next]) == lex_Nukta)
 172             next++;
 173         if ((next < cChar) && lex(input[next]) == lex_Halant)
 174             next++;
 175     }
 176
 177     if ((next < cChar) && lex(input[next]) == lex_Modifier)
 178         next++;
 179     if ((next < cChar) && lex(input[next]) == lex_Vedic)
 180         next++;
 181     return next;
 182 }
 183
 184 static INT Indic_process_next_syllable( LPCWSTR input, INT cChar, INT start, INT* main, INT next, lexical_function lex )
 185 {
 186     if (lex(input[next])==lex_Vowel)
 187     {
 188         *main = next;
 189         return parse_vowel_syllable(input, cChar, start, next+1, lex);
 190     }
 191     else if ((cChar > next+3) && lex(input[next]) == lex_Ra && lex(input[next+1]) == lex_Halant && lex(input[next+2]) == lex_Vowel)
 192     {
 193         *main = next+2;
 194         return parse_vowel_syllable(input, cChar, start, next+3, lex);
 195     }
 196
 197     else if (start == next && lex(input[next])==lex_NBSP)
 198     {
 199         *main = next;
 200         return parse_vowel_syllable(input, cChar, start, next+1, lex);
 201     }
 202     else if (start == next && (cChar > next+3) && lex(input[next]) == lex_Ra && lex(input[next+1]) == lex_Halant && lex(input[next+2]) == lex_NBSP)
 203     {
 204         *main = next+2;
 205         return parse_vowel_syllable(input, cChar, start, next+3, lex);
 206     }
 207
 208     return parse_consonant_syllable(input, cChar, start, main, next, lex);
 209 }
 210
 211 static BOOL Consonent_is_post_base_form(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache* psc, LPCWSTR pwChar, IndicSyllable *s, lexical_function lexical, BOOL modern)
 212 {
 213     if (is_consonant(lexical(pwChar[s->base])) && s->base > s->start && lexical(pwChar[s->base-1]) == lex_Halant)
 214     {
 215         if (modern)
 216             return (SHAPE_does_GSUB_feature_apply_to_chars(hdc, psa, psc, &pwChar[s->base-1], 1, 2, "pstf") > 0);
 217         else
 218         {
 219             WCHAR cc[2];
 220             cc[0] = pwChar[s->base];
 221             cc[1] = pwChar[s->base-1];
 222             return (SHAPE_does_GSUB_feature_apply_to_chars(hdc, psa, psc, cc, 1, 2, "pstf") > 0);
 223         }
 224     }
 225     return FALSE;
 226 }
 227
 228 static BOOL Consonent_is_below_base_form(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache* psc, LPCWSTR pwChar, IndicSyllable *s, lexical_function lexical, BOOL modern)
 229 {
 230     if (is_consonant(lexical(pwChar[s->base])) && s->base > s->start && lexical(pwChar[s->base-1]) == lex_Halant)
 231     {
 232         if (modern)
 233             return (SHAPE_does_GSUB_feature_apply_to_chars(hdc, psa, psc, &pwChar[s->base-1], 1, 2, "blwf") > 0);
 234         else
 235         {
 236             WCHAR cc[2];
 237             cc[0] = pwChar[s->base];
 238             cc[1] = pwChar[s->base-1];
 239             return (SHAPE_does_GSUB_feature_apply_to_chars(hdc, psa, psc, cc, 1, 2, "blwf") > 0);
 240         }
 241     }
 242     return FALSE;
 243 }
 244
 245 static BOOL Consonent_is_pre_base_form(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache* psc, LPCWSTR pwChar, IndicSyllable *s, lexical_function lexical, BOOL modern)
 246 {
 247     if (is_consonant(lexical(pwChar[s->base])) && s->base > s->start && lexical(pwChar[s->base-1]) == lex_Halant)
 248     {
 249         if (modern)
 250             return (SHAPE_does_GSUB_feature_apply_to_chars(hdc, psa, psc, &pwChar[s->base-1], 1, 2, "pref") > 0);
 251         else
 252         {
 253             WCHAR cc[2];
 254             cc[0] = pwChar[s->base];
 255             cc[1] = pwChar[s->base-1];
 256             return (SHAPE_does_GSUB_feature_apply_to_chars(hdc, psa, psc, cc, 1, 2, "pref") > 0);
 257         }
 258     }
 259     return FALSE;
 260 }
 261
 262 static BOOL Consonent_is_ralf(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache* psc, LPCWSTR pwChar, IndicSyllable *s, lexical_function lexical)
 263 {
 264     if ((lexical(pwChar[s->start])==lex_Ra) && s->end > s->start && lexical(pwChar[s->start+1]) == lex_Halant)
 265         return (SHAPE_does_GSUB_feature_apply_to_chars(hdc, psa, psc, &pwChar[s->start], 1, 2, "rphf") > 0);
 266     return FALSE;
 267 }
 268
 269 static int FindBaseConsonant(HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache* psc, LPCWSTR input, IndicSyllable *s, lexical_function lex, BOOL modern)
 270 {
 271     int i;
 272     BOOL blwf = FALSE;
 273     BOOL pref = FALSE;
 274
 275     /* remove ralf from consideration */
 276     if (Consonent_is_ralf(hdc, psa, psc, input, s, lex))
 277     {
 278         s->ralf = s->start;
 279         s->start+=2;
 280     }
 281
 282     /* try to find a base consonant */
 283     if (!is_consonant( lex(input[s->base]) ))
 284     {
 285         for (i = s->end; i >= s->start; i--)
 286             if (is_consonant( lex(input[i]) ))
 287             {
 288                 s->base = i;
 289                 break;
 290             }
 291     }
 292
 293     while ((blwf = Consonent_is_below_base_form(hdc, psa, psc, input, s, lex, modern)) || Consonent_is_post_base_form(hdc, psa, psc, input, s, lex, modern) || (pref = Consonent_is_pre_base_form(hdc, psa, psc, input, s, lex, modern)))
 294     {
 295         if (blwf && s->blwf == -1)
 296             s->blwf = s->base - 1;
 297         if (pref && s->pref == -1)
 298             s->pref = s->base - 1;
 299
 300         for (i = s->base-1; i >= s->start; i--)
 301             if (is_consonant( lex(input[i]) ))
 302             {
 303                 s->base = i;
 304                 break;
 305             }
 306     }
 307
 308     if (s->ralf >= 0)
 309         s->start = s->ralf;
 310
 311     if (s->ralf == s->base)
 312         s->ralf = -1;
 313
 314     return s->base;
 315 }
 316
 317 void Indic_ParseSyllables( HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache* psc, LPCWSTR input, const int cChar, IndicSyllable **syllables, int *syllable_count, lexical_function lex, BOOL modern)
 318 {
 319     int index = 0;
 320     int next = 0;
 321     int center = 0;
 322
 323     *syllable_count = 0;
 324
 325     if (!lex)
 326     {
 327         ERR("Failure to have required functions\n");
 328         return;
 329     }
 330
 331     debug_output_string(input, cChar, lex);
 332     while (next != -1)
 333     {
 334         while((next < cChar) && lex(input[next]) == lex_Generic)
 335             next++;
 336         index = next;
 337         if (next >= cChar)
 338             break;
 339         next = Indic_process_next_syllable(input, cChar, 0, &center, index, lex);
 340         if (next != -1)
 341         {
 342             if (*syllable_count)
 343                 *syllables = HeapReAlloc(GetProcessHeap(),0,*syllables, sizeof(IndicSyllable)*(*syllable_count+1));
 344             else
 345                 *syllables = HeapAlloc(GetProcessHeap(),0,sizeof(IndicSyllable));
 346             (*syllables)[*syllable_count].start = index;
 347             (*syllables)[*syllable_count].base = center;
 348             (*syllables)[*syllable_count].ralf = -1;
 349             (*syllables)[*syllable_count].blwf = -1;
 350             (*syllables)[*syllable_count].pref = -1;
 351             (*syllables)[*syllable_count].end = next-1;
 352             FindBaseConsonant(hdc, psa, psc, input, &(*syllables)[*syllable_count], lex, modern);
 353             index = next;
 354             *syllable_count = (*syllable_count)+1;
 355         }
 356         else if (index < cChar)
 357         {
 358             TRACE("Processing failed at %i\n",index);
 359             next = ++index;
 360         }
 361     }
 362     TRACE("Processed %i of %i characters into %i syllables\n",index,cChar,*syllable_count);
 363 }
 364
 365 void Indic_ReorderCharacters( HDC hdc, SCRIPT_ANALYSIS *psa, ScriptCache* psc, LPWSTR input, int cChar, IndicSyllable **syllables, int *syllable_count, lexical_function lex, reorder_function reorder_f, BOOL modern)
 366 {
 367     int i;
 368
 369     if (!reorder_f)
 370     {
 371         ERR("Failure to have required functions\n");
 372         return;
 373     }
 374
 375     Indic_ParseSyllables(hdc, psa, psc, input, cChar, syllables, syllable_count, lex, modern);
 376     for (i = 0; i < *syllable_count; i++)
 377         reorder_f(input, &(*syllables)[i], lex);
 378 }