thirdparty/freetype-2.3.12/src/psnames/psmodule.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  psmodule.c                                                             */
   4 /*                                                                         */
   5 /*    PSNames module implementation (body).                                */
   6 /*                                                                         */
   7 /*  Copyright 1996-2001, 2002, 2003, 2005, 2006, 2007, 2008 by             */
   8 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
   9 /*                                                                         */
  10 /*  This file is part of the FreeType project, and may only be used,       */
  11 /*  modified, and distributed under the terms of the FreeType project      */
  12 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  13 /*  this file you indicate that you have read the license and              */
  14 /*  understand and accept it fully.                                        */
  15 /*                                                                         */
  16 /***************************************************************************/
  17
  18
  19 #include <ft2build.h>
  20 #include FT_INTERNAL_OBJECTS_H
  21 #include FT_SERVICE_POSTSCRIPT_CMAPS_H
  22
  23 #include "psmodule.h"
  24 #include "pstables.h"
  25
  26 #include "psnamerr.h"
  27 #include "pspic.h"
  28
  29
  30 #ifdef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
  31
  32
  33 #ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
  34
  35
  36 #define VARIANT_BIT         0x80000000UL
  37 #define BASE_GLYPH( code )  ( (FT_UInt32)( (code) & ~VARIANT_BIT ) )
  38
  39
  40   /* Return the Unicode value corresponding to a given glyph.  Note that */
  41   /* we do deal with glyph variants by detecting a non-initial dot in    */
  42   /* the name, as in `A.swash' or `e.final'; in this case, the           */
  43   /* VARIANT_BIT is set in the return value.                             */
  44   /*                                                                     */
  45   static FT_UInt32
  46   ps_unicode_value( const char*  glyph_name )
  47   {
  48     /* If the name begins with `uni', then the glyph name may be a */
  49     /* hard-coded unicode character code.                          */
  50     if ( glyph_name[0] == 'u' &&
  51          glyph_name[1] == 'n' &&
  52          glyph_name[2] == 'i' )
  53     {
  54       /* determine whether the next four characters following are */
  55       /* hexadecimal.                                             */
  56
  57       /* XXX: Add code to deal with ligatures, i.e. glyph names like */
  58       /*      `uniXXXXYYYYZZZZ'...                                   */
  59
  60       FT_Int       count;
  61       FT_UInt32    value = 0;
  62       const char*  p     = glyph_name + 3;
  63
  64
  65       for ( count = 4; count > 0; count--, p++ )
  66       {
  67         char          c = *p;
  68         unsigned int  d;
  69
  70
  71         d = (unsigned char)c - '0';
  72         if ( d >= 10 )
  73         {
  74           d = (unsigned char)c - 'A';
  75           if ( d >= 6 )
  76             d = 16;
  77           else
  78             d += 10;
  79         }
  80
  81         /* Exit if a non-uppercase hexadecimal character was found   */
  82         /* -- this also catches character codes below `0' since such */
  83         /* negative numbers cast to `unsigned int' are far too big.  */
  84         if ( d >= 16 )
  85           break;
  86
  87         value = ( value << 4 ) + d;
  88       }
  89
  90       /* there must be exactly four hex digits */
  91       if ( count == 0 )
  92       {
  93         if ( *p == '\0' )
  94           return value;
  95         if ( *p == '.' )
  96           return (FT_UInt32)( value | VARIANT_BIT );
  97       }
  98     }
  99
 100     /* If the name begins with `u', followed by four to six uppercase */
 101     /* hexadecimal digits, it is a hard-coded unicode character code. */
 102     if ( glyph_name[0] == 'u' )
 103     {
 104       FT_Int       count;
 105       FT_UInt32    value = 0;
 106       const char*  p     = glyph_name + 1;
 107
 108
 109       for ( count = 6; count > 0; count--, p++ )
 110       {
 111         char          c = *p;
 112         unsigned int  d;
 113
 114
 115         d = (unsigned char)c - '0';
 116         if ( d >= 10 )
 117         {
 118           d = (unsigned char)c - 'A';
 119           if ( d >= 6 )
 120             d = 16;
 121           else
 122             d += 10;
 123         }
 124
 125         if ( d >= 16 )
 126           break;
 127
 128         value = ( value << 4 ) + d;
 129       }
 130
 131       if ( count <= 2 )
 132       {
 133         if ( *p == '\0' )
 134           return value;
 135         if ( *p == '.' )
 136           return (FT_UInt32)( value | VARIANT_BIT );
 137       }
 138     }
 139
 140     /* Look for a non-initial dot in the glyph name in order to */
 141     /* find variants like `A.swash', `e.final', etc.            */
 142     {
 143       const char*  p   = glyph_name;
 144       const char*  dot = NULL;
 145
 146
 147       for ( ; *p; p++ )
 148       {
 149         if ( *p == '.' && p > glyph_name )
 150         {
 151           dot = p;
 152           break;
 153         }
 154       }
 155
 156       /* now look up the glyph in the Adobe Glyph List */
 157       if ( !dot )
 158         return (FT_UInt32)ft_get_adobe_glyph_index( glyph_name, p );
 159       else
 160         return (FT_UInt32)( ft_get_adobe_glyph_index( glyph_name, dot ) |
 161                             VARIANT_BIT );
 162     }
 163   }
 164
 165
 166   /* ft_qsort callback to sort the unicode map */
 167   FT_CALLBACK_DEF( int )
 168   compare_uni_maps( const void*  a,
 169                     const void*  b )
 170   {
 171     PS_UniMap*  map1 = (PS_UniMap*)a;
 172     PS_UniMap*  map2 = (PS_UniMap*)b;
 173     FT_UInt32   unicode1 = BASE_GLYPH( map1->unicode );
 174     FT_UInt32   unicode2 = BASE_GLYPH( map2->unicode );
 175
 176
 177     /* sort base glyphs before glyph variants */
 178     if ( unicode1 == unicode2 )
 179     {
 180       if ( map1->unicode > map2->unicode )
 181         return 1;
 182       else if ( map1->unicode < map2->unicode )
 183         return -1;
 184       else
 185         return 0;
 186     }
 187     else
 188     {
 189       if ( unicode1 > unicode2 )
 190         return 1;
 191       else if ( unicode1 < unicode2 )
 192         return -1;
 193       else
 194         return 0;
 195     }
 196   }
 197
 198
 199   /* support for extra glyphs not handled (well) in AGL; */
 200   /* we add extra mappings for them if necessary         */
 201
 202 #define EXTRA_GLYPH_LIST_SIZE  10
 203
 204   static const FT_UInt32  ft_extra_glyph_unicodes[EXTRA_GLYPH_LIST_SIZE] =
 205   {
 206     /* WGL 4 */
 207     0x0394,
 208     0x03A9,
 209     0x2215,
 210     0x00AD,
 211     0x02C9,
 212     0x03BC,
 213     0x2219,
 214     0x00A0,
 215     /* Romanian */
 216     0x021A,
 217     0x021B
 218   };
 219
 220   static const char  ft_extra_glyph_names[] =
 221   {
 222     'D','e','l','t','a',0,
 223     'O','m','e','g','a',0,
 224     'f','r','a','c','t','i','o','n',0,
 225     'h','y','p','h','e','n',0,
 226     'm','a','c','r','o','n',0,
 227     'm','u',0,
 228     'p','e','r','i','o','d','c','e','n','t','e','r','e','d',0,
 229     's','p','a','c','e',0,
 230     'T','c','o','m','m','a','a','c','c','e','n','t',0,
 231     't','c','o','m','m','a','a','c','c','e','n','t',0
 232   };
 233
 234   static const FT_Int
 235   ft_extra_glyph_name_offsets[EXTRA_GLYPH_LIST_SIZE] =
 236   {
 237      0,
 238      6,
 239     12,
 240     21,
 241     28,
 242     35,
 243     38,
 244     53,
 245     59,
 246     72
 247   };
 248
 249
 250   static void
 251   ps_check_extra_glyph_name( const char*  gname,
 252                              FT_UInt      glyph,
 253                              FT_UInt*     extra_glyphs,
 254                              FT_UInt     *states )
 255   {
 256     FT_UInt  n;
 257
 258
 259     for ( n = 0; n < EXTRA_GLYPH_LIST_SIZE; n++ )
 260     {
 261       if ( ft_strcmp( ft_extra_glyph_names +
 262                         ft_extra_glyph_name_offsets[n], gname ) == 0 )
 263       {
 264         if ( states[n] == 0 )
 265         {
 266           /* mark this extra glyph as a candidate for the cmap */
 267           states[n]     = 1;
 268           extra_glyphs[n] = glyph;
 269         }
 270
 271         return;
 272       }
 273     }
 274   }
 275
 276
 277   static void
 278   ps_check_extra_glyph_unicode( FT_UInt32  uni_char,
 279                                 FT_UInt   *states )
 280   {
 281     FT_UInt  n;
 282
 283
 284     for ( n = 0; n < EXTRA_GLYPH_LIST_SIZE; n++ )
 285     {
 286       if ( uni_char == ft_extra_glyph_unicodes[n] )
 287       {
 288         /* disable this extra glyph from being added to the cmap */
 289         states[n] = 2;
 290
 291         return;
 292       }
 293     }
 294   }
 295
 296
 297   /* Build a table that maps Unicode values to glyph indices. */
 298   static FT_Error
 299   ps_unicodes_init( FT_Memory             memory,
 300                     PS_Unicodes           table,
 301                     FT_UInt               num_glyphs,
 302                     PS_GetGlyphNameFunc   get_glyph_name,
 303                     PS_FreeGlyphNameFunc  free_glyph_name,
 304                     FT_Pointer            glyph_data )
 305   {
 306     FT_Error  error;
 307
 308     FT_UInt  extra_glyph_list_states[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 309     FT_UInt  extra_glyphs[EXTRA_GLYPH_LIST_SIZE];
 310
 311
 312     /* we first allocate the table */
 313     table->num_maps = 0;
 314     table->maps     = 0;
 315
 316     if ( !FT_NEW_ARRAY( table->maps, num_glyphs + EXTRA_GLYPH_LIST_SIZE ) )
 317     {
 318       FT_UInt     n;
 319       FT_UInt     count;
 320       PS_UniMap*  map;
 321       FT_UInt32   uni_char;
 322
 323
 324       map = table->maps;
 325
 326       for ( n = 0; n < num_glyphs; n++ )
 327       {
 328         const char*  gname = get_glyph_name( glyph_data, n );
 329
 330
 331         if ( gname )
 332         {
 333           ps_check_extra_glyph_name( gname, n,
 334                                      extra_glyphs, extra_glyph_list_states );
 335           uni_char = ps_unicode_value( gname );
 336
 337           if ( BASE_GLYPH( uni_char ) != 0 )
 338           {
 339             ps_check_extra_glyph_unicode( uni_char,
 340                                           extra_glyph_list_states );
 341             map->unicode     = uni_char;
 342             map->glyph_index = n;
 343             map++;
 344           }
 345
 346           if ( free_glyph_name )
 347             free_glyph_name( glyph_data, gname );
 348         }
 349       }
 350
 351       for ( n = 0; n < EXTRA_GLYPH_LIST_SIZE; n++ )
 352       {
 353         if ( extra_glyph_list_states[n] == 1 )
 354         {
 355           /* This glyph name has an additional representation. */
 356           /* Add it to the cmap.                               */
 357
 358           map->unicode     = ft_extra_glyph_unicodes[n];
 359           map->glyph_index = extra_glyphs[n];
 360           map++;
 361         }
 362       }
 363
 364       /* now compress the table a bit */
 365       count = (FT_UInt)( map - table->maps );
 366
 367       if ( count == 0 )
 368       {
 369         FT_FREE( table->maps );
 370         if ( !error )
 371           error = PSnames_Err_Invalid_Argument;  /* No unicode chars here! */
 372       }
 373       else {
 374         /* Reallocate if the number of used entries is much smaller. */
 375         if ( count < num_glyphs / 2 )
 376         {
 377           (void)FT_RENEW_ARRAY( table->maps, num_glyphs, count );
 378           error = PSnames_Err_Ok;
 379         }
 380
 381         /* Sort the table in increasing order of unicode values, */
 382         /* taking care of glyph variants.                        */
 383         ft_qsort( table->maps, count, sizeof ( PS_UniMap ),
 384                   compare_uni_maps );
 385       }
 386
 387       table->num_maps = count;
 388     }
 389
 390     return error;
 391   }
 392
 393
 394   static FT_UInt
 395   ps_unicodes_char_index( PS_Unicodes  table,
 396                           FT_UInt32    unicode )
 397   {
 398     PS_UniMap  *min, *max, *mid, *result = NULL;
 399
 400
 401     /* Perform a binary search on the table. */
 402
 403     min = table->maps;
 404     max = min + table->num_maps - 1;
 405
 406     while ( min <= max )
 407     {
 408       FT_UInt32  base_glyph;
 409
 410
 411       mid = min + ( ( max - min ) >> 1 );
 412
 413       if ( mid->unicode == unicode )
 414       {
 415         result = mid;
 416         break;
 417       }
 418
 419       base_glyph = BASE_GLYPH( mid->unicode );
 420
 421       if ( base_glyph == unicode )
 422         result = mid; /* remember match but continue search for base glyph */
 423
 424       if ( min == max )
 425         break;
 426
 427       if ( base_glyph < unicode )
 428         min = mid + 1;
 429       else
 430         max = mid - 1;
 431     }
 432
 433     if ( result )
 434       return result->glyph_index;
 435     else
 436       return 0;
 437   }
 438
 439
 440   static FT_UInt32
 441   ps_unicodes_char_next( PS_Unicodes  table,
 442                          FT_UInt32   *unicode )
 443   {
 444     FT_UInt    result    = 0;
 445     FT_UInt32  char_code = *unicode + 1;
 446
 447
 448     {
 449       FT_UInt     min = 0;
 450       FT_UInt     max = table->num_maps;
 451       FT_UInt     mid;
 452       PS_UniMap*  map;
 453       FT_UInt32   base_glyph;
 454
 455
 456       while ( min < max )
 457       {
 458         mid = min + ( ( max - min ) >> 1 );
 459         map = table->maps + mid;
 460
 461         if ( map->unicode == char_code )
 462         {
 463           result = map->glyph_index;
 464           goto Exit;
 465         }
 466
 467         base_glyph = BASE_GLYPH( map->unicode );
 468
 469         if ( base_glyph == char_code )
 470           result = map->glyph_index;
 471
 472         if ( base_glyph < char_code )
 473           min = mid + 1;
 474         else
 475           max = mid;
 476       }
 477
 478       if ( result )
 479         goto Exit;               /* we have a variant glyph */
 480
 481       /* we didn't find it; check whether we have a map just above it */
 482       char_code = 0;
 483
 484       if ( min < table->num_maps )
 485       {
 486         map       = table->maps + min;
 487         result    = map->glyph_index;
 488         char_code = BASE_GLYPH( map->unicode );
 489       }
 490     }
 491
 492   Exit:
 493     *unicode = char_code;
 494     return result;
 495   }
 496
 497
 498 #endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
 499
 500
 501   static const char*
 502   ps_get_macintosh_name( FT_UInt  name_index )
 503   {
 504     if ( name_index >= FT_NUM_MAC_NAMES )
 505       name_index = 0;
 506
 507     return ft_standard_glyph_names + ft_mac_names[name_index];
 508   }
 509
 510
 511   static const char*
 512   ps_get_standard_strings( FT_UInt  sid )
 513   {
 514     if ( sid >= FT_NUM_SID_NAMES )
 515       return 0;
 516
 517     return ft_standard_glyph_names + ft_sid_names[sid];
 518   }
 519
 520
 521 #ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
 522   FT_DEFINE_SERVICE_PSCMAPSREC(pscmaps_interface,
 523     (PS_Unicode_ValueFunc)     ps_unicode_value,
 524     (PS_Unicodes_InitFunc)     ps_unicodes_init,
 525     (PS_Unicodes_CharIndexFunc)ps_unicodes_char_index,
 526     (PS_Unicodes_CharNextFunc) ps_unicodes_char_next,
 527
 528     (PS_Macintosh_NameFunc)    ps_get_macintosh_name,
 529     (PS_Adobe_Std_StringsFunc) ps_get_standard_strings,
 530
 531     t1_standard_encoding,
 532     t1_expert_encoding
 533   )
 534
 535 #else
 536
 537   FT_DEFINE_SERVICE_PSCMAPSREC(pscmaps_interface,
 538     0,
 539     0,
 540     0,
 541     0,
 542
 543     (PS_Macintosh_NameFunc)    ps_get_macintosh_name,
 544     (PS_Adobe_Std_StringsFunc) ps_get_standard_strings,
 545
 546     t1_standard_encoding,
 547     t1_expert_encoding
 548   )
 549
 550 #endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
 551
 552
 553   FT_DEFINE_SERVICEDESCREC1(pscmaps_services,
 554     FT_SERVICE_ID_POSTSCRIPT_CMAPS, &FT_PSCMAPS_INTERFACE_GET
 555   )
 556
 557
 558
 559
 560   static FT_Pointer
 561   psnames_get_service( FT_Module    module,
 562                        const char*  service_id )
 563   {
 564     FT_UNUSED( module );
 565
 566     return ft_service_list_lookup( FT_PSCMAPS_SERVICES_GET, service_id );
 567   }
 568
 569 #endif /* FT_CONFIG_OPTION_POSTSCRIPT_NAMES */
 570
 571
 572 #ifndef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
 573 #define PUT_PS_NAMES_SERVICE(a) 0
 574 #else
 575 #define PUT_PS_NAMES_SERVICE(a) a
 576 #endif
 577
 578   FT_DEFINE_MODULE(psnames_module_class,
 579
 580     0,  /* this is not a font driver, nor a renderer */
 581     sizeof ( FT_ModuleRec ),
 582
 583     "psnames",  /* driver name                         */
 584     0x10000L,   /* driver version                      */
 585     0x20000L,   /* driver requires FreeType 2 or above */
 586
 587     PUT_PS_NAMES_SERVICE((void*)&FT_PSCMAPS_INTERFACE_GET),   /* module specific interface */
 588     (FT_Module_Constructor)0,
 589     (FT_Module_Destructor) 0,
 590     (FT_Module_Requester)  PUT_PS_NAMES_SERVICE(psnames_get_service)
 591   )
 592
 593
 594
 595 /* END */