Home | History | Annotate | Download | only in src
      1 /*
      2  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
      3  *
      4  * This is part of HarfBuzz, an OpenType Layout engine library.
      5  *
      6  * Permission is hereby granted, without written agreement and without
      7  * license or royalty fees, to use, copy, modify, and distribute this
      8  * software and its documentation for any purpose, provided that the
      9  * above copyright notice and the following two paragraphs appear in
     10  * all copies of this software.
     11  *
     12  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
     13  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
     14  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
     15  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
     16  * DAMAGE.
     17  *
     18  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
     19  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
     20  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
     21  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
     22  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
     23  */
     24 
     25 #include "harfbuzz-shaper.h"
     26 #include "harfbuzz-shaper-private.h"
     27 
     28 #include <assert.h>
     29 
     30 static const HB_UChar16 ReplacementCharacter = 0xfffd;
     31 
     32 typedef struct {
     33     unsigned char shape;
     34     unsigned char justification;
     35 } HB_ArabicProperties;
     36 
     37 typedef enum {
     38     XIsolated,
     39     XFinal,
     40     XInitial,
     41     XMedial,
     42     /* intermediate state */
     43     XCausing
     44 } ArabicShape;
     45 
     46 /*
     47 // these groups correspond to the groups defined in the Unicode standard.
     48 // Some of these groups are equal with regards to both joining and line breaking behaviour,
     49 // and thus have the same enum value
     50 //
     51 // I'm not sure the mapping of syriac to arabic enums is correct with regards to justification, but as
     52 // I couldn't find any better document I'll hope for the best.
     53 */
     54 typedef enum {
     55     /* NonJoining */
     56     ArabicNone,
     57     ArabicSpace,
     58     /* Transparent */
     59     Transparent,
     60     /* Causing */
     61     Center,
     62     Kashida,
     63 
     64     /* Arabic */
     65     /* Dual */
     66     Beh,
     67     Noon,
     68     Meem = Noon,
     69     Heh = Noon,
     70     KnottedHeh = Noon,
     71     HehGoal = Noon,
     72     SwashKaf = Noon,
     73     Yeh,
     74     Hah,
     75     Seen,
     76     Sad = Seen,
     77     Tah,
     78     Kaf = Tah,
     79     Gaf = Tah,
     80     Lam = Tah,
     81     Ain,
     82     Feh = Ain,
     83     Qaf = Ain,
     84     /* Right */
     85     Alef,
     86     Waw,
     87     Dal,
     88     TehMarbuta = Dal,
     89     Reh,
     90     HamzaOnHehGoal,
     91     YehWithTail = HamzaOnHehGoal,
     92     YehBarre = HamzaOnHehGoal,
     93 
     94     /* Syriac */
     95     /* Dual */
     96     Beth = Beh,
     97     Gamal = Ain,
     98     Heth = Noon,
     99     Teth = Hah,
    100     Yudh = Noon,
    101     Kaph = Noon,
    102     Lamadh = Lam,
    103     Mim = Noon,
    104     Nun = Noon,
    105     Semakh = Noon,
    106     FinalSemakh = Noon,
    107     SyriacE = Ain,
    108     Pe = Ain,
    109     ReversedPe = Hah,
    110     Qaph = Noon,
    111     Shin = Noon,
    112     Fe = Ain,
    113 
    114     /* Right */
    115     Alaph = Alef,
    116     Dalath = Dal,
    117     He = Dal,
    118     SyriacWaw = Waw,
    119     Zain = Alef,
    120     YudhHe = Waw,
    121     Sadhe = HamzaOnHehGoal,
    122     Taw = Dal,
    123 
    124     /* Compiler bug? Otherwise ArabicGroupsEnd would be equal to Dal + 1. */
    125     Dummy = HamzaOnHehGoal,
    126     ArabicGroupsEnd
    127 } ArabicGroup;
    128 
    129 static const unsigned char arabic_group[0x150] = {
    130     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    131     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    132     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    133     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    134 
    135     Transparent, Transparent, Transparent, Transparent,
    136     Transparent, Transparent, ArabicNone, ArabicNone,
    137     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    138     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    139 
    140     ArabicNone, ArabicNone, Alef, Alef,
    141     Waw, Alef, Yeh, Alef,
    142     Beh, TehMarbuta, Beh, Beh,
    143     Hah, Hah, Hah, Dal,
    144 
    145     Dal, Reh, Reh, Seen,
    146     Seen, Sad, Sad, Tah,
    147     Tah, Ain, Ain, ArabicNone,
    148     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    149 
    150     /* 0x640 */
    151     Kashida, Feh, Qaf, Kaf,
    152     Lam, Meem, Noon, Heh,
    153     Waw, Yeh, Yeh, Transparent,
    154     Transparent, Transparent, Transparent, Transparent,
    155 
    156     Transparent, Transparent, Transparent, Transparent,
    157     Transparent, Transparent, Transparent, Transparent,
    158     Transparent, ArabicNone, ArabicNone, ArabicNone,
    159     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    160 
    161     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    162     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    163     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    164     ArabicNone, ArabicNone, Beh, Qaf,
    165 
    166     Transparent, Alef, Alef, Alef,
    167     ArabicNone, Alef, Waw, Waw,
    168     Yeh, Beh, Beh, Beh,
    169     Beh, Beh, Beh, Beh,
    170 
    171     /* 0x680 */
    172     Beh, Hah, Hah, Hah,
    173     Hah, Hah, Hah, Hah,
    174     Dal, Dal, Dal, Dal,
    175     Dal, Dal, Dal, Dal,
    176 
    177     Dal, Reh, Reh, Reh,
    178     Reh, Reh, Reh, Reh,
    179     Reh, Reh, Seen, Seen,
    180     Seen, Sad, Sad, Tah,
    181 
    182     Ain, Feh, Feh, Feh,
    183     Feh, Feh, Feh, Qaf,
    184     Qaf, Gaf, SwashKaf, Gaf,
    185     Kaf, Kaf, Kaf, Gaf,
    186 
    187     Gaf, Gaf, Gaf, Gaf,
    188     Gaf, Lam, Lam, Lam,
    189     Lam, Noon, Noon, Noon,
    190     Noon, Noon, KnottedHeh, Hah,
    191 
    192     /* 0x6c0 */
    193     TehMarbuta, HehGoal, HamzaOnHehGoal, HamzaOnHehGoal,
    194     Waw, Waw, Waw, Waw,
    195     Waw, Waw, Waw, Waw,
    196     Yeh, YehWithTail, Yeh, Waw,
    197 
    198     Yeh, Yeh, YehBarre, YehBarre,
    199     ArabicNone, TehMarbuta, Transparent, Transparent,
    200     Transparent, Transparent, Transparent, Transparent,
    201     Transparent, ArabicNone, ArabicNone, Transparent,
    202 
    203     Transparent, Transparent, Transparent, Transparent,
    204     Transparent, ArabicNone, ArabicNone, Transparent,
    205     Transparent, ArabicNone, Transparent, Transparent,
    206     Transparent, Transparent, Dal, Reh,
    207 
    208     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    209     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    210     ArabicNone, ArabicNone, Seen, Sad,
    211     Ain, ArabicNone, ArabicNone, KnottedHeh,
    212 
    213     /* 0x700 */
    214     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    215     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    216     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    217     ArabicNone, ArabicNone, ArabicNone, ArabicNone,
    218 
    219     Alaph, Transparent, Beth, Gamal,
    220     Gamal, Dalath, Dalath, He,
    221     SyriacWaw, Zain, Heth, Teth,
    222     Teth, Yudh, YudhHe, Kaph,
    223 
    224     Lamadh, Mim, Nun, Semakh,
    225     FinalSemakh, SyriacE, Pe, ReversedPe,
    226     Sadhe, Qaph, Dalath, Shin,
    227     Taw, Beth, Gamal, Dalath,
    228 
    229     Transparent, Transparent, Transparent, Transparent,
    230     Transparent, Transparent, Transparent, Transparent,
    231     Transparent, Transparent, Transparent, Transparent,
    232     Transparent, Transparent, Transparent, Transparent,
    233 
    234     Transparent, Transparent, Transparent, Transparent,
    235     Transparent, Transparent, Transparent, Transparent,
    236     Transparent, Transparent, Transparent, ArabicNone,
    237     ArabicNone, Zain, Kaph, Fe,
    238 };
    239 
    240 static ArabicGroup arabicGroup(unsigned short uc)
    241 {
    242     if (uc >= 0x0600 && uc < 0x750)
    243         return (ArabicGroup) arabic_group[uc-0x600];
    244     else if (uc == 0x200d)
    245         return Center;
    246     else if (HB_GetUnicodeCharCategory(uc) == HB_Separator_Space)
    247         return ArabicSpace;
    248     else
    249         return ArabicNone;
    250 }
    251 
    252 
    253 /*
    254    Arabic shaping obeys a number of rules according to the joining classes (see Unicode book, section on
    255    arabic).
    256 
    257    Each unicode char has a joining class (right, dual (left&right), center (joincausing) or transparent).
    258    transparent joining is not encoded in HB_UChar16::joining(), but applies to all combining marks and format marks.
    259 
    260    Right join-causing: dual + center
    261    Left join-causing: dual + right + center
    262 
    263    Rules are as follows (for a string already in visual order, as we have it here):
    264 
    265    R1 Transparent characters do not affect joining behaviour.
    266    R2 A right joining character, that has a right join-causing char on the right will get form XRight
    267    (R3 A left joining character, that has a left join-causing char on the left will get form XLeft)
    268    Note: the above rule is meaningless, as there are no pure left joining characters defined in Unicode
    269    R4 A dual joining character, that has a left join-causing char on the left and a right join-causing char on
    270              the right will get form XMedial
    271    R5  A dual joining character, that has a right join causing char on the right, and no left join causing char on the left
    272          will get form XRight
    273    R6 A dual joining character, that has a  left join causing char on the left, and no right join causing char on the right
    274          will get form XLeft
    275    R7 Otherwise the character will get form XIsolated
    276 
    277    Additionally we have to do the minimal ligature support for lam-alef ligatures:
    278 
    279    L1 Transparent characters do not affect ligature behaviour.
    280    L2 Any sequence of Alef(XRight) + Lam(XMedial) will form the ligature Alef.Lam(XLeft)
    281    L3 Any sequence of Alef(XRight) + Lam(XLeft) will form the ligature Alef.Lam(XIsolated)
    282 
    283    The state table below handles rules R1-R7.
    284 */
    285 
    286 typedef enum {
    287     JNone,
    288     JCausing,
    289     JDual,
    290     JRight,
    291     JTransparent
    292 } Joining;
    293 
    294 static const Joining joining_for_group[ArabicGroupsEnd] = {
    295     /* NonJoining */
    296     JNone, /* ArabicNone */
    297     JNone, /* ArabicSpace */
    298     /* Transparent */
    299     JTransparent, /* Transparent */
    300     /* Causing */
    301     JCausing, /* Center */
    302     JCausing, /* Kashida */
    303     /* Dual */
    304     JDual, /* Beh */
    305     JDual, /* Noon */
    306     JDual, /* Yeh */
    307     JDual, /* Hah */
    308     JDual, /* Seen */
    309     JDual, /* Tah */
    310     JDual, /* Ain */
    311     /* Right */
    312     JRight, /* Alef */
    313     JRight, /* Waw */
    314     JRight, /* Dal */
    315     JRight, /* Reh */
    316     JRight  /* HamzaOnHehGoal */
    317 };
    318 
    319 
    320 typedef struct {
    321     ArabicShape form1;
    322     ArabicShape form2;
    323 } JoiningPair;
    324 
    325 static const JoiningPair joining_table[5][4] =
    326 /* None, Causing, Dual, Right */
    327 {
    328     { { XIsolated, XIsolated }, { XIsolated, XCausing }, { XIsolated, XInitial }, { XIsolated, XIsolated } }, /* XIsolated */
    329     { { XFinal, XIsolated }, { XFinal, XCausing }, { XFinal, XInitial }, { XFinal, XIsolated } }, /* XFinal */
    330     { { XIsolated, XIsolated }, { XInitial, XCausing }, { XInitial, XMedial }, { XInitial, XFinal } }, /* XInitial */
    331     { { XFinal, XIsolated }, { XMedial, XCausing }, { XMedial, XMedial }, { XMedial, XFinal } }, /* XMedial */
    332     { { XIsolated, XIsolated }, { XIsolated, XCausing }, { XIsolated, XMedial }, { XIsolated, XFinal } }, /* XCausing */
    333 };
    334 
    335 
    336 /*
    337 According to http://www.microsoft.com/middleeast/Arabicdev/IE6/KBase.asp
    338 
    339 1. Find the priority of the connecting opportunities in each word
    340 2. Add expansion at the highest priority connection opportunity
    341 3. If more than one connection opportunity have the same highest value,
    342    use the opportunity closest to the end of the word.
    343 
    344 Following is a chart that provides the priority for connection
    345 opportunities and where expansion occurs. The character group names
    346 are those in table 6.6 of the UNICODE 2.0 book.
    347 
    348 
    349 PrioritY        Glyph                   Condition                                       Kashida Location
    350 
    351 Arabic_Kashida        User inserted Kashida   The user entered a Kashida in a position.       After the user
    352                 (Shift+j or Shift+[E with hat])    Thus, it is the highest priority to insert an   inserted kashida
    353                                         automatic kashida.
    354 
    355 Arabic_Seen        Seen, Sad               Connecting to the next character.               After the character.
    356                                         (Initial or medial form).
    357 
    358 Arabic_HaaDal        Teh Marbutah, Haa, Dal  Connecting to previous character.               Before the final form
    359                                                                                         of these characters.
    360 
    361 Arabic_Alef     Alef, Tah, Lam,         Connecting to previous character.               Before the final form
    362                 Kaf and Gaf                                                             of these characters.
    363 
    364 Arabic_BaRa     Reh, Yeh                Connected to medial Beh                         Before preceding medial Baa
    365 
    366 Arabic_Waw        Waw, Ain, Qaf, Feh      Connecting to previous character.               Before the final form of
    367                                                                                         these characters.
    368 
    369 Arabic_Normal   Other connecting        Connecting to previous character.               Before the final form
    370                 characters                                                              of these characters.
    371 
    372 
    373 
    374 This seems to imply that we have at most one kashida point per arabic word.
    375 
    376 */
    377 
    378 static void getArabicProperties(const unsigned short *chars, int len, HB_ArabicProperties *properties)
    379 {
    380 /*     qDebug("arabicSyriacOpenTypeShape: properties:"); */
    381     int lastPos = 0;
    382     int lastGroup = ArabicNone;
    383     int i = 0;
    384 
    385     ArabicGroup group = arabicGroup(chars[0]);
    386     Joining j = joining_for_group[group];
    387     ArabicShape shape = joining_table[XIsolated][j].form2;
    388     properties[0].justification = HB_NoJustification;
    389 
    390     for (i = 1; i < len; ++i) {
    391         /* #### fix handling for spaces and punktuation */
    392         properties[i].justification = HB_NoJustification;
    393 
    394         group = arabicGroup(chars[i]);
    395         j = joining_for_group[group];
    396 
    397         if (j == JTransparent) {
    398             properties[i].shape = XIsolated;
    399             continue;
    400         }
    401 
    402         properties[lastPos].shape = joining_table[shape][j].form1;
    403         shape = joining_table[shape][j].form2;
    404 
    405         switch(lastGroup) {
    406         case Seen:
    407             if (properties[lastPos].shape == XInitial || properties[lastPos].shape == XMedial)
    408                 properties[i-1].justification = HB_Arabic_Seen;
    409             break;
    410         case Hah:
    411             if (properties[lastPos].shape == XFinal)
    412                 properties[lastPos-1].justification = HB_Arabic_HaaDal;
    413             break;
    414         case Alef:
    415             if (properties[lastPos].shape == XFinal)
    416                 properties[lastPos-1].justification = HB_Arabic_Alef;
    417             break;
    418         case Ain:
    419             if (properties[lastPos].shape == XFinal)
    420                 properties[lastPos-1].justification = HB_Arabic_Waw;
    421             break;
    422         case Noon:
    423             if (properties[lastPos].shape == XFinal)
    424                 properties[lastPos-1].justification = HB_Arabic_Normal;
    425             break;
    426         case ArabicNone:
    427             break;
    428 
    429         default:
    430             assert(FALSE);
    431         }
    432 
    433         lastGroup = ArabicNone;
    434 
    435         switch(group) {
    436         case ArabicNone:
    437         case Transparent:
    438         /* ### Center should probably be treated as transparent when it comes to justification. */
    439         case Center:
    440             break;
    441         case ArabicSpace:
    442             properties[i].justification = HB_Arabic_Space;
    443             break;
    444         case Kashida:
    445             properties[i].justification = HB_Arabic_Kashida;
    446             break;
    447         case Seen:
    448             lastGroup = Seen;
    449             break;
    450 
    451         case Hah:
    452         case Dal:
    453             lastGroup = Hah;
    454             break;
    455 
    456         case Alef:
    457         case Tah:
    458             lastGroup = Alef;
    459             break;
    460 
    461         case Yeh:
    462         case Reh:
    463             if (properties[lastPos].shape == XMedial && arabicGroup(chars[lastPos]) == Beh)
    464                 properties[lastPos-1].justification = HB_Arabic_BaRa;
    465             break;
    466 
    467         case Ain:
    468         case Waw:
    469             lastGroup = Ain;
    470             break;
    471 
    472         case Noon:
    473         case Beh:
    474         case HamzaOnHehGoal:
    475             lastGroup = Noon;
    476             break;
    477         case ArabicGroupsEnd:
    478             assert(FALSE);
    479         }
    480 
    481         lastPos = i;
    482     }
    483     properties[lastPos].shape = joining_table[shape][JNone].form1;
    484 
    485 
    486     /*
    487      for (int i = 0; i < len; ++i)
    488          qDebug("arabic properties(%d): uc=%x shape=%d, justification=%d", i, chars[i], properties[i].shape, properties[i].justification);
    489     */
    490 }
    491 
    492 static Joining getNkoJoining(unsigned short uc)
    493 {
    494     if (uc < 0x7ca)
    495         return JNone;
    496     if (uc <= 0x7ea)
    497         return JDual;
    498     if (uc <= 0x7f3)
    499         return JTransparent;
    500     if (uc <= 0x7f9)
    501         return JNone;
    502     if (uc == 0x7fa)
    503         return JCausing;
    504     return JNone;
    505 }
    506 
    507 static void getNkoProperties(const unsigned short *chars, int len, HB_ArabicProperties *properties)
    508 {
    509     int lastPos = 0;
    510     int i = 0;
    511 
    512     Joining j = getNkoJoining(chars[0]);
    513     ArabicShape shape = joining_table[XIsolated][j].form2;
    514     properties[0].justification = HB_NoJustification;
    515 
    516     for (i = 1; i < len; ++i) {
    517         properties[i].justification = (HB_GetUnicodeCharCategory(chars[i]) == HB_Separator_Space) ?
    518                                       ArabicSpace : ArabicNone;
    519 
    520         j = getNkoJoining(chars[i]);
    521 
    522         if (j == JTransparent) {
    523             properties[i].shape = XIsolated;
    524             continue;
    525         }
    526 
    527         properties[lastPos].shape = joining_table[shape][j].form1;
    528         shape = joining_table[shape][j].form2;
    529 
    530 
    531         lastPos = i;
    532     }
    533     properties[lastPos].shape = joining_table[shape][JNone].form1;
    534 
    535 
    536     /*
    537      for (int i = 0; i < len; ++i)
    538          qDebug("nko properties(%d): uc=%x shape=%d, justification=%d", i, chars[i], properties[i].shape, properties[i].justification);
    539     */
    540 }
    541 
    542 /*
    543 // The unicode to unicode shaping codec.
    544 // does only presentation forms B at the moment, but that should be enough for
    545 // simple display
    546 */
    547 static const hb_uint16 arabicUnicodeMapping[256][2] = {
    548     /* base of shaped forms, and number-1 of them (0 for non shaping,
    549        1 for right binding and 3 for dual binding */
    550 
    551     /* These are just the glyphs available in Unicode,
    552        some characters are in R class, but have no glyphs in Unicode. */
    553 
    554     { 0x0600, 0 }, /* 0x0600 */
    555     { 0x0601, 0 }, /* 0x0601 */
    556     { 0x0602, 0 }, /* 0x0602 */
    557     { 0x0603, 0 }, /* 0x0603 */
    558     { 0x0604, 0 }, /* 0x0604 */
    559     { 0x0605, 0 }, /* 0x0605 */
    560     { 0x0606, 0 }, /* 0x0606 */
    561     { 0x0607, 0 }, /* 0x0607 */
    562     { 0x0608, 0 }, /* 0x0608 */
    563     { 0x0609, 0 }, /* 0x0609 */
    564     { 0x060A, 0 }, /* 0x060A */
    565     { 0x060B, 0 }, /* 0x060B */
    566     { 0x060C, 0 }, /* 0x060C */
    567     { 0x060D, 0 }, /* 0x060D */
    568     { 0x060E, 0 }, /* 0x060E */
    569     { 0x060F, 0 }, /* 0x060F */
    570 
    571     { 0x0610, 0 }, /* 0x0610 */
    572     { 0x0611, 0 }, /* 0x0611 */
    573     { 0x0612, 0 }, /* 0x0612 */
    574     { 0x0613, 0 }, /* 0x0613 */
    575     { 0x0614, 0 }, /* 0x0614 */
    576     { 0x0615, 0 }, /* 0x0615 */
    577     { 0x0616, 0 }, /* 0x0616 */
    578     { 0x0617, 0 }, /* 0x0617 */
    579     { 0x0618, 0 }, /* 0x0618 */
    580     { 0x0619, 0 }, /* 0x0619 */
    581     { 0x061A, 0 }, /* 0x061A */
    582     { 0x061B, 0 }, /* 0x061B */
    583     { 0x061C, 0 }, /* 0x061C */
    584     { 0x061D, 0 }, /* 0x061D */
    585     { 0x061E, 0 }, /* 0x061E */
    586     { 0x061F, 0 }, /* 0x061F */
    587 
    588     { 0x0620, 0 }, /* 0x0620 */
    589     { 0xFE80, 0 }, /* 0x0621            HAMZA */
    590     { 0xFE81, 1 }, /* 0x0622    R       ALEF WITH MADDA ABOVE */
    591     { 0xFE83, 1 }, /* 0x0623    R       ALEF WITH HAMZA ABOVE */
    592     { 0xFE85, 1 }, /* 0x0624    R       WAW WITH HAMZA ABOVE */
    593     { 0xFE87, 1 }, /* 0x0625    R       ALEF WITH HAMZA BELOW */
    594     { 0xFE89, 3 }, /* 0x0626    D       YEH WITH HAMZA ABOVE */
    595     { 0xFE8D, 1 }, /* 0x0627    R       ALEF */
    596     { 0xFE8F, 3 }, /* 0x0628    D       BEH */
    597     { 0xFE93, 1 }, /* 0x0629    R       TEH MARBUTA */
    598     { 0xFE95, 3 }, /* 0x062A    D       TEH */
    599     { 0xFE99, 3 }, /* 0x062B    D       THEH */
    600     { 0xFE9D, 3 }, /* 0x062C    D       JEEM */
    601     { 0xFEA1, 3 }, /* 0x062D    D       HAH */
    602     { 0xFEA5, 3 }, /* 0x062E    D       KHAH */
    603     { 0xFEA9, 1 }, /* 0x062F    R       DAL */
    604 
    605     { 0xFEAB, 1 }, /* 0x0630    R       THAL */
    606     { 0xFEAD, 1 }, /* 0x0631    R       REH */
    607     { 0xFEAF, 1 }, /* 0x0632    R       ZAIN */
    608     { 0xFEB1, 3 }, /* 0x0633    D       SEEN */
    609     { 0xFEB5, 3 }, /* 0x0634    D       SHEEN */
    610     { 0xFEB9, 3 }, /* 0x0635    D       SAD */
    611     { 0xFEBD, 3 }, /* 0x0636    D       DAD */
    612     { 0xFEC1, 3 }, /* 0x0637    D       TAH */
    613     { 0xFEC5, 3 }, /* 0x0638    D       ZAH */
    614     { 0xFEC9, 3 }, /* 0x0639    D       AIN */
    615     { 0xFECD, 3 }, /* 0x063A    D       GHAIN */
    616     { 0x063B, 0 }, /* 0x063B */
    617     { 0x063C, 0 }, /* 0x063C */
    618     { 0x063D, 0 }, /* 0x063D */
    619     { 0x063E, 0 }, /* 0x063E */
    620     { 0x063F, 0 }, /* 0x063F */
    621 
    622     { 0x0640, 0 }, /* 0x0640    C       TATWEEL // ### Join Causing, only one glyph */
    623     { 0xFED1, 3 }, /* 0x0641    D       FEH */
    624     { 0xFED5, 3 }, /* 0x0642    D       QAF */
    625     { 0xFED9, 3 }, /* 0x0643    D       KAF */
    626     { 0xFEDD, 3 }, /* 0x0644    D       LAM */
    627     { 0xFEE1, 3 }, /* 0x0645    D       MEEM */
    628     { 0xFEE5, 3 }, /* 0x0646    D       NOON */
    629     { 0xFEE9, 3 }, /* 0x0647    D       HEH */
    630     { 0xFEED, 1 }, /* 0x0648    R       WAW */
    631     { 0x0649, 3 }, /* 0x0649            ALEF MAKSURA // ### Dual, glyphs not consecutive, handle in code. */
    632     { 0xFEF1, 3 }, /* 0x064A    D       YEH */
    633     { 0x064B, 0 }, /* 0x064B */
    634     { 0x064C, 0 }, /* 0x064C */
    635     { 0x064D, 0 }, /* 0x064D */
    636     { 0x064E, 0 }, /* 0x064E */
    637     { 0x064F, 0 }, /* 0x064F */
    638 
    639     { 0x0650, 0 }, /* 0x0650 */
    640     { 0x0651, 0 }, /* 0x0651 */
    641     { 0x0652, 0 }, /* 0x0652 */
    642     { 0x0653, 0 }, /* 0x0653 */
    643     { 0x0654, 0 }, /* 0x0654 */
    644     { 0x0655, 0 }, /* 0x0655 */
    645     { 0x0656, 0 }, /* 0x0656 */
    646     { 0x0657, 0 }, /* 0x0657 */
    647     { 0x0658, 0 }, /* 0x0658 */
    648     { 0x0659, 0 }, /* 0x0659 */
    649     { 0x065A, 0 }, /* 0x065A */
    650     { 0x065B, 0 }, /* 0x065B */
    651     { 0x065C, 0 }, /* 0x065C */
    652     { 0x065D, 0 }, /* 0x065D */
    653     { 0x065E, 0 }, /* 0x065E */
    654     { 0x065F, 0 }, /* 0x065F */
    655 
    656     { 0x0660, 0 }, /* 0x0660 */
    657     { 0x0661, 0 }, /* 0x0661 */
    658     { 0x0662, 0 }, /* 0x0662 */
    659     { 0x0663, 0 }, /* 0x0663 */
    660     { 0x0664, 0 }, /* 0x0664 */
    661     { 0x0665, 0 }, /* 0x0665 */
    662     { 0x0666, 0 }, /* 0x0666 */
    663     { 0x0667, 0 }, /* 0x0667 */
    664     { 0x0668, 0 }, /* 0x0668 */
    665     { 0x0669, 0 }, /* 0x0669 */
    666     { 0x066A, 0 }, /* 0x066A */
    667     { 0x066B, 0 }, /* 0x066B */
    668     { 0x066C, 0 }, /* 0x066C */
    669     { 0x066D, 0 }, /* 0x066D */
    670     { 0x066E, 0 }, /* 0x066E */
    671     { 0x066F, 0 }, /* 0x066F */
    672 
    673     { 0x0670, 0 }, /* 0x0670 */
    674     { 0xFB50, 1 }, /* 0x0671    R       ALEF WASLA */
    675     { 0x0672, 0 }, /* 0x0672 */
    676     { 0x0673, 0 }, /* 0x0673 */
    677     { 0x0674, 0 }, /* 0x0674 */
    678     { 0x0675, 0 }, /* 0x0675 */
    679     { 0x0676, 0 }, /* 0x0676 */
    680     { 0x0677, 0 }, /* 0x0677 */
    681     { 0x0678, 0 }, /* 0x0678 */
    682     { 0xFB66, 3 }, /* 0x0679    D       TTEH */
    683     { 0xFB5E, 3 }, /* 0x067A    D       TTEHEH */
    684     { 0xFB52, 3 }, /* 0x067B    D       BEEH */
    685     { 0x067C, 0 }, /* 0x067C */
    686     { 0x067D, 0 }, /* 0x067D */
    687     { 0xFB56, 3 }, /* 0x067E    D       PEH */
    688     { 0xFB62, 3 }, /* 0x067F    D       TEHEH */
    689 
    690     { 0xFB5A, 3 }, /* 0x0680    D       BEHEH */
    691     { 0x0681, 0 }, /* 0x0681 */
    692     { 0x0682, 0 }, /* 0x0682 */
    693     { 0xFB76, 3 }, /* 0x0683    D       NYEH */
    694     { 0xFB72, 3 }, /* 0x0684    D       DYEH */
    695     { 0x0685, 0 }, /* 0x0685 */
    696     { 0xFB7A, 3 }, /* 0x0686    D       TCHEH */
    697     { 0xFB7E, 3 }, /* 0x0687    D       TCHEHEH */
    698     { 0xFB88, 1 }, /* 0x0688    R       DDAL */
    699     { 0x0689, 0 }, /* 0x0689 */
    700     { 0x068A, 0 }, /* 0x068A */
    701     { 0x068B, 0 }, /* 0x068B */
    702     { 0xFB84, 1 }, /* 0x068C    R       DAHAL */
    703     { 0xFB82, 1 }, /* 0x068D    R       DDAHAL */
    704     { 0xFB86, 1 }, /* 0x068E    R       DUL */
    705     { 0x068F, 0 }, /* 0x068F */
    706 
    707     { 0x0690, 0 }, /* 0x0690 */
    708     { 0xFB8C, 1 }, /* 0x0691    R       RREH */
    709     { 0x0692, 0 }, /* 0x0692 */
    710     { 0x0693, 0 }, /* 0x0693 */
    711     { 0x0694, 0 }, /* 0x0694 */
    712     { 0x0695, 0 }, /* 0x0695 */
    713     { 0x0696, 0 }, /* 0x0696 */
    714     { 0x0697, 0 }, /* 0x0697 */
    715     { 0xFB8A, 1 }, /* 0x0698    R       JEH */
    716     { 0x0699, 0 }, /* 0x0699 */
    717     { 0x069A, 0 }, /* 0x069A */
    718     { 0x069B, 0 }, /* 0x069B */
    719     { 0x069C, 0 }, /* 0x069C */
    720     { 0x069D, 0 }, /* 0x069D */
    721     { 0x069E, 0 }, /* 0x069E */
    722     { 0x069F, 0 }, /* 0x069F */
    723 
    724     { 0x06A0, 0 }, /* 0x06A0 */
    725     { 0x06A1, 0 }, /* 0x06A1 */
    726     { 0x06A2, 0 }, /* 0x06A2 */
    727     { 0x06A3, 0 }, /* 0x06A3 */
    728     { 0xFB6A, 3 }, /* 0x06A4    D       VEH */
    729     { 0x06A5, 0 }, /* 0x06A5 */
    730     { 0xFB6E, 3 }, /* 0x06A6    D       PEHEH */
    731     { 0x06A7, 0 }, /* 0x06A7 */
    732     { 0x06A8, 0 }, /* 0x06A8 */
    733     { 0xFB8E, 3 }, /* 0x06A9    D       KEHEH */
    734     { 0x06AA, 0 }, /* 0x06AA */
    735     { 0x06AB, 0 }, /* 0x06AB */
    736     { 0x06AC, 0 }, /* 0x06AC */
    737     { 0xFBD3, 3 }, /* 0x06AD    D       NG */
    738     { 0x06AE, 0 }, /* 0x06AE */
    739     { 0xFB92, 3 }, /* 0x06AF    D       GAF */
    740 
    741     { 0x06B0, 0 }, /* 0x06B0 */
    742     { 0xFB9A, 3 }, /* 0x06B1    D       NGOEH */
    743     { 0x06B2, 0 }, /* 0x06B2 */
    744     { 0xFB96, 3 }, /* 0x06B3    D       GUEH */
    745     { 0x06B4, 0 }, /* 0x06B4 */
    746     { 0x06B5, 0 }, /* 0x06B5 */
    747     { 0x06B6, 0 }, /* 0x06B6 */
    748     { 0x06B7, 0 }, /* 0x06B7 */
    749     { 0x06B8, 0 }, /* 0x06B8 */
    750     { 0x06B9, 0 }, /* 0x06B9 */
    751     { 0xFB9E, 1 }, /* 0x06BA    R       NOON GHUNNA */
    752     { 0xFBA0, 3 }, /* 0x06BB    D       RNOON */
    753     { 0x06BC, 0 }, /* 0x06BC */
    754     { 0x06BD, 0 }, /* 0x06BD */
    755     { 0xFBAA, 3 }, /* 0x06BE    D       HEH DOACHASHMEE */
    756     { 0x06BF, 0 }, /* 0x06BF */
    757 
    758     { 0xFBA4, 1 }, /* 0x06C0    R       HEH WITH YEH ABOVE */
    759     { 0xFBA6, 3 }, /* 0x06C1    D       HEH GOAL */
    760     { 0x06C2, 0 }, /* 0x06C2 */
    761     { 0x06C3, 0 }, /* 0x06C3 */
    762     { 0x06C4, 0 }, /* 0x06C4 */
    763     { 0xFBE0, 1 }, /* 0x06C5    R       KIRGHIZ OE */
    764     { 0xFBD9, 1 }, /* 0x06C6    R       OE */
    765     { 0xFBD7, 1 }, /* 0x06C7    R       U */
    766     { 0xFBDB, 1 }, /* 0x06C8    R       YU */
    767     { 0xFBE2, 1 }, /* 0x06C9    R       KIRGHIZ YU */
    768     { 0x06CA, 0 }, /* 0x06CA */
    769     { 0xFBDE, 1 }, /* 0x06CB    R       VE */
    770     { 0xFBFC, 3 }, /* 0x06CC    D       FARSI YEH */
    771     { 0x06CD, 0 }, /* 0x06CD */
    772     { 0x06CE, 0 }, /* 0x06CE */
    773     { 0x06CF, 0 }, /* 0x06CF */
    774 
    775     { 0xFBE4, 3 }, /* 0x06D0    D       E */
    776     { 0x06D1, 0 }, /* 0x06D1 */
    777     { 0xFBAE, 1 }, /* 0x06D2    R       YEH BARREE */
    778     { 0xFBB0, 1 }, /* 0x06D3    R       YEH BARREE WITH HAMZA ABOVE */
    779     { 0x06D4, 0 }, /* 0x06D4 */
    780     { 0x06D5, 0 }, /* 0x06D5 */
    781     { 0x06D6, 0 }, /* 0x06D6 */
    782     { 0x06D7, 0 }, /* 0x06D7 */
    783     { 0x06D8, 0 }, /* 0x06D8 */
    784     { 0x06D9, 0 }, /* 0x06D9 */
    785     { 0x06DA, 0 }, /* 0x06DA */
    786     { 0x06DB, 0 }, /* 0x06DB */
    787     { 0x06DC, 0 }, /* 0x06DC */
    788     { 0x06DD, 0 }, /* 0x06DD */
    789     { 0x06DE, 0 }, /* 0x06DE */
    790     { 0x06DF, 0 }, /* 0x06DF */
    791 
    792     { 0x06E0, 0 }, /* 0x06E0 */
    793     { 0x06E1, 0 }, /* 0x06E1 */
    794     { 0x06E2, 0 }, /* 0x06E2 */
    795     { 0x06E3, 0 }, /* 0x06E3 */
    796     { 0x06E4, 0 }, /* 0x06E4 */
    797     { 0x06E5, 0 }, /* 0x06E5 */
    798     { 0x06E6, 0 }, /* 0x06E6 */
    799     { 0x06E7, 0 }, /* 0x06E7 */
    800     { 0x06E8, 0 }, /* 0x06E8 */
    801     { 0x06E9, 0 }, /* 0x06E9 */
    802     { 0x06EA, 0 }, /* 0x06EA */
    803     { 0x06EB, 0 }, /* 0x06EB */
    804     { 0x06EC, 0 }, /* 0x06EC */
    805     { 0x06ED, 0 }, /* 0x06ED */
    806     { 0x06EE, 0 }, /* 0x06EE */
    807     { 0x06EF, 0 }, /* 0x06EF */
    808 
    809     { 0x06F0, 0 }, /* 0x06F0 */
    810     { 0x06F1, 0 }, /* 0x06F1 */
    811     { 0x06F2, 0 }, /* 0x06F2 */
    812     { 0x06F3, 0 }, /* 0x06F3 */
    813     { 0x06F4, 0 }, /* 0x06F4 */
    814     { 0x06F5, 0 }, /* 0x06F5 */
    815     { 0x06F6, 0 }, /* 0x06F6 */
    816     { 0x06F7, 0 }, /* 0x06F7 */
    817     { 0x06F8, 0 }, /* 0x06F8 */
    818     { 0x06F9, 0 }, /* 0x06F9 */
    819     { 0x06FA, 0 }, /* 0x06FA */
    820     { 0x06FB, 0 }, /* 0x06FB */
    821     { 0x06FC, 0 }, /* 0x06FC */
    822     { 0x06FD, 0 }, /* 0x06FD */
    823     { 0x06FE, 0 }, /* 0x06FE */
    824     { 0x06FF, 0 }  /* 0x06FF */
    825 };
    826 
    827 /* the arabicUnicodeMapping does not work for U+0649 ALEF MAKSURA, this table does */
    828 static const hb_uint16 alefMaksura[4] = {0xFEEF, 0xFEF0, 0xFBE8, 0xFBE9};
    829 
    830 /*
    831 // this is a bit tricky. Alef always binds to the right, so the second parameter descibing the shape
    832 // of the lam can be either initial of medial. So initial maps to the isolated form of the ligature,
    833 // medial to the final form
    834 */
    835 static const hb_uint16 arabicUnicodeLamAlefMapping[6][4] = {
    836     { 0xfffd, 0xfffd, 0xfef5, 0xfef6 }, /* 0x622        R       Alef with Madda above */
    837     { 0xfffd, 0xfffd, 0xfef7, 0xfef8 }, /* 0x623        R       Alef with Hamza above */
    838     { 0xfffd, 0xfffd, 0xfffd, 0xfffd }, /* 0x624        // Just to fill the table ;-) */
    839     { 0xfffd, 0xfffd, 0xfef9, 0xfefa }, /* 0x625        R       Alef with Hamza below */
    840     { 0xfffd, 0xfffd, 0xfffd, 0xfffd }, /* 0x626        // Just to fill the table ;-) */
    841     { 0xfffd, 0xfffd, 0xfefb, 0xfefc }  /* 0x627        R       Alef */
    842 };
    843 
    844 static int getShape(hb_uint8 cell, int shape)
    845 {
    846     /* the arabicUnicodeMapping does not work for U+0649 ALEF MAKSURA, handle this here */
    847     int ch = (cell != 0x49)
    848               ? (shape ? arabicUnicodeMapping[cell][0] + shape : 0x600+cell)
    849               : alefMaksura[shape] ;
    850     return ch;
    851 }
    852 
    853 
    854 /*
    855   Two small helper functions for arabic shaping.
    856 */
    857 static HB_UChar16 prevChar(const HB_UChar16 *str, int pos)
    858 {
    859     /*qDebug("leftChar: pos=%d", pos); */
    860     const HB_UChar16 *ch = str + pos - 1;
    861     pos--;
    862     while(pos > -1) {
    863         if(HB_GetUnicodeCharCategory(*ch) != HB_Mark_NonSpacing)
    864             return *ch;
    865         pos--;
    866         ch--;
    867     }
    868     return ReplacementCharacter;
    869 }
    870 
    871 static HB_UChar16 nextChar(const HB_UChar16 *str, hb_uint32 len, hb_uint32 pos)
    872 {
    873     const HB_UChar16 *ch = str + pos + 1;
    874     pos++;
    875     while(pos < len) {
    876         /*qDebug("rightChar: %d isLetter=%d, joining=%d", pos, ch.isLetter(), ch.joining()); */
    877         if(HB_GetUnicodeCharCategory(*ch) != HB_Mark_NonSpacing)
    878             return *ch;
    879         /* assume it's a transparent char, this might not be 100% correct */
    880         pos++;
    881         ch++;
    882     }
    883     return ReplacementCharacter;
    884 }
    885 
    886 static void shapedString(const HB_UChar16 *uc, hb_uint32 stringLength, hb_uint32 from, hb_uint32 len, HB_UChar16 *shapeBuffer, int *shapedLength,
    887                          HB_Bool reverse, HB_GlyphAttributes *attributes, unsigned short *logClusters)
    888 {
    889     HB_ArabicProperties *properties;
    890     hb_int32 f = from;
    891     hb_uint32 l = len;
    892     const HB_UChar16 *ch;
    893     HB_UChar16 *data;
    894     int clusterStart;
    895     hb_uint32 i;
    896     HB_STACKARRAY(HB_ArabicProperties, props, len + 2);
    897     properties = props;
    898 
    899     assert(stringLength >= from + len);
    900 
    901     if(len == 0) {
    902         *shapedLength = 0;
    903         return;
    904     }
    905 
    906     if (from > 0) {
    907         --f;
    908         ++l;
    909         ++properties;
    910     }
    911     if (f + l < stringLength)
    912         ++l;
    913     getArabicProperties(uc+f, l, props);
    914 
    915     ch = uc + from;
    916     data = shapeBuffer;
    917     clusterStart = 0;
    918 
    919     for (i = 0; i < len; i++) {
    920         hb_uint8 r = *ch >> 8;
    921         int gpos = data - shapeBuffer;
    922 
    923         if (r != 0x06) {
    924             if (r == 0x20) {
    925                 if (*ch == 0x200c || *ch == 0x200d)
    926                     /* remove ZWJ and ZWNJ */
    927                     goto skip;
    928             }
    929             if (reverse)
    930                 *data = HB_GetMirroredChar(*ch);
    931             else
    932                 *data = *ch;
    933         } else {
    934             hb_uint8 c = *ch & 0xff;
    935             int pos = i + from;
    936             int shape = properties[i].shape;
    937 /*            qDebug("mapping U+%x to shape %d glyph=0x%x", ch->unicode(), shape, getShape(c, shape)); */
    938             /* take care of lam-alef ligatures (lam right of alef) */
    939             hb_uint16 map;
    940             switch (c) {
    941                 case 0x44: { /* lam */
    942                     const HB_UChar16 pch = nextChar(uc, stringLength, pos);
    943                     if ((pch >> 8) == 0x06) {
    944                         switch (pch & 0xff) {
    945                             case 0x22:
    946                             case 0x23:
    947                             case 0x25:
    948                             case 0x27:
    949 /*                                 qDebug(" lam of lam-alef ligature"); */
    950                                 map = arabicUnicodeLamAlefMapping[(pch & 0xff) - 0x22][shape];
    951                                 goto next;
    952                             default:
    953                                 break;
    954                         }
    955                     }
    956                     break;
    957                 }
    958                 case 0x22: /* alef with madda */
    959                 case 0x23: /* alef with hamza above */
    960                 case 0x25: /* alef with hamza below */
    961                 case 0x27: /* alef */
    962                     if (prevChar(uc, pos) == 0x0644) {
    963                         /* have a lam alef ligature */
    964                         /*qDebug(" alef of lam-alef ligature"); */
    965                         goto skip;
    966                     }
    967                 default:
    968                     break;
    969             }
    970             map = getShape(c, shape);
    971         next:
    972             *data = map;
    973         }
    974         /* ##### Fixme */
    975         /*glyphs[gpos].attributes.zeroWidth = zeroWidth; */
    976         if (HB_GetUnicodeCharCategory(*ch) == HB_Mark_NonSpacing) {
    977             attributes[gpos].mark = TRUE;
    978 /*             qDebug("glyph %d (char %d) is mark!", gpos, i); */
    979         } else {
    980             attributes[gpos].mark = FALSE;
    981             clusterStart = data - shapeBuffer;
    982         }
    983         attributes[gpos].clusterStart = !attributes[gpos].mark;
    984         attributes[gpos].combiningClass = HB_GetUnicodeCharCombiningClass(*ch);
    985         attributes[gpos].justification = properties[i].justification;
    986 /*         qDebug("data[%d] = %x (from %x)", gpos, (uint)data->unicode(), ch->unicode());*/
    987         data++;
    988     skip:
    989         ch++;
    990         logClusters[i] = clusterStart;
    991     }
    992     *shapedLength = data - shapeBuffer;
    993 
    994     HB_FREE_STACKARRAY(props);
    995 }
    996 
    997 #ifndef NO_OPENTYPE
    998 
    999 static const HB_OpenTypeFeature arabic_features[] = {
   1000     { HB_MAKE_TAG('c', 'c', 'm', 'p'), CcmpProperty },
   1001     { HB_MAKE_TAG('i', 's', 'o', 'l'), IsolProperty },
   1002     { HB_MAKE_TAG('f', 'i', 'n', 'a'), FinaProperty },
   1003     { HB_MAKE_TAG('m', 'e', 'd', 'i'), MediProperty },
   1004     { HB_MAKE_TAG('i', 'n', 'i', 't'), InitProperty },
   1005     { HB_MAKE_TAG('r', 'l', 'i', 'g'), RligProperty },
   1006     { HB_MAKE_TAG('c', 'a', 'l', 't'), CaltProperty },
   1007     { HB_MAKE_TAG('l', 'i', 'g', 'a'), LigaProperty },
   1008     { HB_MAKE_TAG('d', 'l', 'i', 'g'), DligProperty },
   1009     { HB_MAKE_TAG('c', 's', 'w', 'h'), CswhProperty },
   1010     /* mset is used in old Win95 fonts that don't have a 'mark' positioning table. */
   1011     { HB_MAKE_TAG('m', 's', 'e', 't'), MsetProperty },
   1012     {0, 0}
   1013 };
   1014 
   1015 static const HB_OpenTypeFeature syriac_features[] = {
   1016     { HB_MAKE_TAG('c', 'c', 'm', 'p'), CcmpProperty },
   1017     { HB_MAKE_TAG('i', 's', 'o', 'l'), IsolProperty },
   1018     { HB_MAKE_TAG('f', 'i', 'n', 'a'), FinaProperty },
   1019     { HB_MAKE_TAG('f', 'i', 'n', '2'), FinaProperty },
   1020     { HB_MAKE_TAG('f', 'i', 'n', '3'), FinaProperty },
   1021     { HB_MAKE_TAG('m', 'e', 'd', 'i'), MediProperty },
   1022     { HB_MAKE_TAG('m', 'e', 'd', '2'), MediProperty },
   1023     { HB_MAKE_TAG('i', 'n', 'i', 't'), InitProperty },
   1024     { HB_MAKE_TAG('r', 'l', 'i', 'g'), RligProperty },
   1025     { HB_MAKE_TAG('c', 'a', 'l', 't'), CaltProperty },
   1026     { HB_MAKE_TAG('l', 'i', 'g', 'a'), LigaProperty },
   1027     { HB_MAKE_TAG('d', 'l', 'i', 'g'), DligProperty },
   1028     {0, 0}
   1029 };
   1030 
   1031 static HB_Bool arabicSyriacOpenTypeShape(HB_ShaperItem *item, HB_Bool *ot_ok)
   1032 {
   1033     const HB_UChar16 *uc;
   1034     const int nglyphs = item->num_glyphs;
   1035     hb_int32 f;
   1036     hb_uint32 l;
   1037     HB_ArabicProperties *properties;
   1038     HB_DECLARE_STACKARRAY(HB_ArabicProperties, props)
   1039     HB_DECLARE_STACKARRAY(hb_uint32, apply)
   1040     HB_Bool shaped;
   1041     int i = 0;
   1042 
   1043     *ot_ok = TRUE;
   1044 
   1045     if (!HB_ConvertStringToGlyphIndices(item))
   1046         return FALSE;
   1047     HB_HeuristicSetGlyphAttributes(item);
   1048 
   1049     HB_INIT_STACKARRAY(HB_ArabicProperties, props, item->item.length + 2);
   1050     HB_INIT_STACKARRAY(hb_uint32, apply, item->num_glyphs);
   1051 
   1052     uc = item->string + item->item.pos;
   1053 
   1054     properties = props;
   1055     f = 0;
   1056     l = item->item.length;
   1057     if (item->item.pos > 0) {
   1058         --f;
   1059         ++l;
   1060         ++properties;
   1061     }
   1062     if (f + l + item->item.pos < item->stringLength) {
   1063         ++l;
   1064     }
   1065     if (item->item.script == HB_Script_Nko)
   1066         getNkoProperties(uc+f, l, props);
   1067     else
   1068         getArabicProperties(uc+f, l, props);
   1069 
   1070     for (i = 0; i < (int)item->num_glyphs; i++) {
   1071         apply[i] = 0;
   1072 
   1073         if (properties[i].shape == XIsolated)
   1074             apply[i] |= MediProperty|FinaProperty|InitProperty;
   1075         else if (properties[i].shape == XMedial)
   1076             apply[i] |= IsolProperty|FinaProperty|InitProperty;
   1077         else if (properties[i].shape == XFinal)
   1078             apply[i] |= IsolProperty|MediProperty|InitProperty;
   1079         else if (properties[i].shape == XInitial)
   1080             apply[i] |= IsolProperty|MediProperty|FinaProperty;
   1081 
   1082         item->attributes[i].justification = properties[i].justification;
   1083     }
   1084 
   1085     HB_FREE_STACKARRAY(props);
   1086 
   1087     shaped = HB_OpenTypeShape(item, apply);
   1088 
   1089     HB_FREE_STACKARRAY(apply);
   1090 
   1091     if (!shaped) {
   1092         *ot_ok = FALSE;
   1093         return FALSE;
   1094     }
   1095     return HB_OpenTypePosition(item, nglyphs, /*doLogClusters*/TRUE);
   1096 }
   1097 
   1098 #endif
   1099 
   1100 /* #### stil missing: identify invalid character combinations */
   1101 HB_Bool HB_ArabicShape(HB_ShaperItem *item)
   1102 {
   1103     int slen;
   1104     HB_Bool haveGlyphs;
   1105     HB_STACKARRAY(HB_UChar16, shapedChars, item->item.length);
   1106 
   1107     assert(item->item.script == HB_Script_Arabic || item->item.script == HB_Script_Syriac
   1108            || item->item.script == HB_Script_Nko);
   1109 
   1110 #ifndef NO_OPENTYPE
   1111 
   1112     if (HB_SelectScript(item, item->item.script == HB_Script_Arabic ? arabic_features : syriac_features)) {
   1113         HB_Bool ot_ok;
   1114         if (arabicSyriacOpenTypeShape(item, &ot_ok))
   1115             return TRUE;
   1116         if (ot_ok)
   1117             return FALSE;
   1118             /* fall through to the non OT code*/
   1119     }
   1120 #endif
   1121 
   1122     if (item->item.script != HB_Script_Arabic)
   1123         return HB_BasicShape(item);
   1124 
   1125     shapedString(item->string, item->stringLength, item->item.pos, item->item.length, shapedChars, &slen,
   1126                   item->item.bidiLevel % 2,
   1127                   item->attributes, item->log_clusters);
   1128 
   1129     haveGlyphs = item->font->klass
   1130         ->convertStringToGlyphIndices(item->font,
   1131                                       shapedChars, slen,
   1132                                       item->glyphs, &item->num_glyphs,
   1133                                       item->item.bidiLevel % 2);
   1134 
   1135     HB_FREE_STACKARRAY(shapedChars);
   1136 
   1137     if (!haveGlyphs)
   1138         return FALSE;
   1139 
   1140     HB_HeuristicPosition(item);
   1141     return TRUE;
   1142 }
   1143 
   1144 
   1145