freetype1/test/arabic.c

   1 /****************************************************************************/
   2 /*                                                                          */
   3 /*  The FreeType project -- a free and portable quality TrueType renderer.  */
   4 /*                                                                          */
   5 /*  Copyright 1996-1999 by                                                  */
   6 /*  D. Turner, R.Wilhelm, and W. Lemberg                                    */
   7 /*                                                                          */
   8 /*  arabic -- An implementation of the contextual algorithm given in the    */
   9 /*  Unicode 2.0 book to assign the `isolated', `initial', `medial', and     */
  10 /*  `final' properties to an input string of character codes for the Arabic */
  11 /*  script.                                                                 */
  12 /*                                                                          */
  13 /****************************************************************************/
  14
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17
  18 #include "arabic.h"
  19 #include "freetype.h"
  20 #include "ftxopen.h"
  21
  22
  23   /*
  24
  25      Here a table of the joining classes for characters in the range
  26      U+0620 - U+06FF.
  27
  28      The following character also has a joining class:
  29
  30      U+200C  ZERO WIDTH NON-JOINER  -> causing
  31
  32      All other characters are given the joining class `none'.
  33
  34   */
  35
  36   joining_class  arabic[] =
  37   {
  38     /* U+0620 */
  39     none, none, right, right,
  40     right, right, dual, right,
  41     dual, right, dual, dual,
  42     dual, dual, dual, right,
  43
  44     /* U+0630 */
  45     right, right, right, dual,
  46     dual, dual, dual, dual,
  47     dual, dual, dual, none,
  48     none, none, none, none,
  49
  50     /* U+0640 */
  51     causing, dual, dual, dual,
  52     dual, dual, dual, dual,
  53     right, right, dual, transparent,
  54     transparent, transparent, transparent, transparent,
  55
  56     /* U+0650 */
  57     transparent, transparent, transparent, none,
  58     none, none, none, none,
  59     none, none, none, none,
  60     none, none, none, none,
  61
  62     /* U+0660 */
  63     none, none, none, none,
  64     none, none, none, none,
  65     none, none, none, none,
  66     none, none, none, none,
  67
  68     /* U+0670 */
  69     transparent, none, right, right,
  70     none, right, right, right,
  71     dual, dual, dual, dual,
  72     dual, dual, dual, dual,
  73
  74     /* U+0680 */
  75     dual, dual, dual, dual,
  76     dual, dual, dual, dual,
  77     right, right, right, right,
  78     right, right, right, right,
  79
  80     /* U+0690 */
  81     right, right, right, right,
  82     right, right, right, right,
  83     right, right, dual, dual,
  84     dual, dual, dual, dual,
  85
  86     /* U+06A0 */
  87     dual, dual, dual, dual,
  88     dual, dual, dual, dual,
  89     dual, dual, dual, dual,
  90     dual, dual, dual, dual,
  91
  92     /* U+06B0 */
  93     dual, dual, dual, dual,
  94     dual, dual, dual, dual,
  95     dual, dual, dual, dual,
  96     dual, dual, dual, dual,
  97
  98     /* U+06C0 */
  99     right, dual, right, right,
 100     right, right, right, right,
 101     right, right, right, right,
 102     dual, right, dual, right,
 103
 104     /* U+06D0 */
 105     dual, dual, right, right,
 106     none, none, none, transparent,
 107     transparent, transparent, transparent, transparent,
 108     transparent, transparent, transparent, transparent,
 109
 110     /* U+06E0 */
 111     transparent, transparent, transparent, transparent,
 112     transparent, none, none, transparent,
 113     transparent, none, transparent, transparent,
 114     transparent, transparent, none, none,
 115
 116     /* U+06F0 */
 117     none, none, none, none,
 118     none, none, none, none,
 119     none, none, dual, dual,
 120     dual, none, none, none
 121   };
 122
 123
 124   struct cgc_
 125   {
 126     TT_UShort  char_code;
 127     TT_UShort  glyph_index;
 128     TT_UShort  class;
 129   };
 130
 131   typedef struct cgc_  cgc;
 132
 133
 134   int  compare_cgc( const void*  a,
 135                     const void*  b )
 136   {
 137     return ( ((cgc*)a)->glyph_index > ((cgc*)b)->glyph_index ) ?
 138            1 : ( ( ((cgc*)a)->glyph_index == ((cgc*)b)->glyph_index ) ?
 139                0 : -1 );
 140   }
 141
 142
 143   TT_Error  Build_Arabic_Glyph_Properties( TT_CharMap        char_map,
 144                                            TT_UShort         max_glyphs,
 145                                            TTO_GDEFHeader**  gdef )
 146   {
 147     TT_UShort  i, j, num_glyphs;
 148
 149     cgc        Arabic[0x0700 - 0x0620];
 150
 151     TT_UShort  glyph_indices[0x700 - 0x0620];
 152     TT_UShort  classes[0x700 - 0x0620];
 153
 154     if ( !gdef )
 155       return TT_Err_Invalid_Argument;
 156
 157     j = 0;
 158
 159     for ( i = 0x0620; i < 0x0700; i++ )
 160     {
 161       Arabic[j].char_code   = i;
 162       Arabic[j].class       = ( arabic[i - 0x0620] == transparent ) ?
 163                               MARK_GLYPH : SIMPLE_GLYPH;
 164       Arabic[j].glyph_index = TT_Char_Index( char_map, i );
 165       if ( Arabic[j].glyph_index )
 166         j++;
 167     }
 168     num_glyphs = j;
 169
 170     if ( !num_glyphs )
 171     {
 172       /* no Arabic font */
 173       *gdef = NULL;
 174       return TT_Err_Ok;
 175     }
 176
 177     /* sort it */
 178
 179     qsort( Arabic, num_glyphs, sizeof ( cgc ), compare_cgc );
 180
 181     /* write it to the arrays, removing duplicates */
 182
 183     glyph_indices[0] = Arabic[0].glyph_index;
 184     classes[0]       = Arabic[0].class;
 185
 186     j = 1;
 187
 188     for ( i = 1; i < num_glyphs; i++ )
 189     {
 190       glyph_indices[j] = Arabic[i].glyph_index;
 191       classes[j]       = Arabic[i].class;
 192
 193       if ( glyph_indices[j - 1] != glyph_indices[j] )
 194         j++;
 195     }
 196     num_glyphs = j;
 197
 198     TT_GDEF_Build_ClassDefinition( *gdef, max_glyphs, num_glyphs,
 199                                    glyph_indices, classes );
 200
 201     return TT_Err_Ok;
 202   }
 203
 204
 205   /* The joining rules as given in the Unicode 2.0 book (characters are
 206      here specified as appearing in the byte stream, i.e. *not* in
 207      visual order).  Joining classes are given in angle brackets, glyph
 208      forms in square brackets.  Glyphs affected by a specific rule are
 209      enclosed with vertical bars.
 210
 211      Note: The description of the joining algorithm in the book is
 212            severely broken.  You can get a corrected version from
 213            www.unicode.org (as of 29-Jun-1999, this hasn't appeared).
 214
 215        R1: <anything1> <transparent> <anything2>
 216
 217              apply joining rules for
 218                <anything1> <anything2> -> [shape1] [shape2]
 219
 220            -> [shape1] [isolated] [shape2]
 221
 222        R2: <causing|left|dual> |<right>|
 223
 224            -> [final]
 225
 226        R3: |<left>| <causing|right|dual>
 227
 228            -> [initial]
 229
 230        R4: <causing|left|dual> |<dual>| <causing|right|dual>
 231
 232            -> [medial]
 233
 234        R5: <causing|left|dual> |<dual>| <!(causing|right|dual)>
 235
 236            -> [final]
 237
 238        R6: <!(causing|left|dual)> |<dual>| <causing|right|dual>
 239
 240            -> [initial]
 241
 242        R7: If R1-R6 fail:
 243
 244            <anything> -> [isolated]                                      */
 245
 246
 247   /* `direction' can be -1, 0, or 1 to indicate the last non-transparent
 248      glyph, the current glyph, and the next non-transparent glyph,
 249      respectively.                                                       */
 250
 251   static joining_class  Get_Joining_Class( TT_UShort*  string,
 252                                            TT_UShort   pos,
 253                                            TT_UShort   length,
 254                                            int         direction )
 255   {
 256     joining_class  j;
 257
 258
 259     while ( 1 )
 260     {
 261       if ( pos == 0 && direction < 0 )
 262         return none;
 263
 264       pos += direction;
 265
 266       if ( pos >= length )
 267         return none;
 268
 269       if ( string[pos] < 0x0620 ||
 270            string[pos] >= 0x0700 )
 271       {
 272         if ( string[pos] == 0x200C )
 273           return causing;
 274         else
 275           return none;
 276       }
 277       else
 278         j =  arabic[string[pos] - 0x0620];
 279
 280       if ( !direction || j != transparent )
 281         return j;
 282     }
 283   }
 284
 285
 286   TT_Error  Assign_Arabic_Properties( TT_UShort*  string,
 287                                       TT_UShort*  properties,
 288                                       TT_UShort   length )
 289   {
 290     joining_class  previous, current, next;
 291
 292     TT_UShort      i;
 293
 294
 295     if ( !string || !properties || length == 0 )
 296       return TT_Err_Invalid_Argument;
 297
 298     for ( i = 0; i < length; i++ )
 299     {
 300       previous = Get_Joining_Class( string, i, length, -1 );
 301       current  = Get_Joining_Class( string, i, length,  0 );
 302       next     = Get_Joining_Class( string, i, length,  1 );
 303
 304       /* R1 */
 305
 306       if ( current == transparent )
 307       {
 308         properties[i] |= isolated_p;
 309         continue;
 310       }
 311
 312       /* R2 */
 313
 314       if ( previous == causing ||
 315            previous == left    ||
 316            previous == dual    )
 317         if ( current == right )
 318         {
 319           properties[i] |= final_p;
 320           continue;
 321         }
 322
 323       /* R3 */
 324
 325       if ( current == left )
 326         if ( next == causing ||
 327              next == right   ||
 328              next == dual    )
 329         {
 330           properties[i] |= initial_p;
 331           continue;
 332         }
 333
 334       /* R4 */
 335
 336       if ( previous == causing ||
 337            previous == left    ||
 338            previous == dual    )
 339         if ( current == dual )
 340           if ( next == causing ||
 341                next == right   ||
 342                next == dual    )
 343           {
 344             properties[i] |= medial_p;
 345             continue;
 346           }
 347
 348       /* R5 */
 349
 350       if ( previous == causing ||
 351            previous == left    ||
 352            previous == dual    )
 353         if ( current == dual )
 354           if ( !( next == causing ||
 355                   next == right   ||
 356                   next == dual    ) )
 357           {
 358             properties[i] |= final_p;
 359             continue;
 360           }
 361
 362       /* R6 */
 363
 364       if ( !( previous == causing ||
 365               previous == left    ||
 366               previous == dual    ) )
 367         if ( current == dual )
 368           if ( next == causing ||
 369                next == right   ||
 370                next == dual    )
 371           {
 372             properties[i] |= initial_p;
 373             continue;
 374           }
 375
 376       /* R7 */
 377
 378       if ( current != none )
 379         properties[i] |= isolated_p;
 380     }
 381
 382     return TT_Err_Ok;
 383   }
 384
 385
 386 /* End */