Home | History | Annotate | Download | only in psnames
      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         /* No unicode chars here! */
    370         FT_FREE( table->maps );
    371         if ( !error )
    372           error = PSnames_Err_No_Unicode_Glyph_Name;
    373       }
    374       else
    375       {
    376         /* Reallocate if the number of used entries is much smaller. */
    377         if ( count < num_glyphs / 2 )
    378         {
    379           (void)FT_RENEW_ARRAY( table->maps, num_glyphs, count );
    380           error = PSnames_Err_Ok;
    381         }
    382 
    383         /* Sort the table in increasing order of unicode values, */
    384         /* taking care of glyph variants.                        */
    385         ft_qsort( table->maps, count, sizeof ( PS_UniMap ),
    386                   compare_uni_maps );
    387       }
    388 
    389       table->num_maps = count;
    390     }
    391 
    392     return error;
    393   }
    394 
    395 
    396   static FT_UInt
    397   ps_unicodes_char_index( PS_Unicodes  table,
    398                           FT_UInt32    unicode )
    399   {
    400     PS_UniMap  *min, *max, *mid, *result = NULL;
    401 
    402 
    403     /* Perform a binary search on the table. */
    404 
    405     min = table->maps;
    406     max = min + table->num_maps - 1;
    407 
    408     while ( min <= max )
    409     {
    410       FT_UInt32  base_glyph;
    411 
    412 
    413       mid = min + ( ( max - min ) >> 1 );
    414 
    415       if ( mid->unicode == unicode )
    416       {
    417         result = mid;
    418         break;
    419       }
    420 
    421       base_glyph = BASE_GLYPH( mid->unicode );
    422 
    423       if ( base_glyph == unicode )
    424         result = mid; /* remember match but continue search for base glyph */
    425 
    426       if ( min == max )
    427         break;
    428 
    429       if ( base_glyph < unicode )
    430         min = mid + 1;
    431       else
    432         max = mid - 1;
    433     }
    434 
    435     if ( result )
    436       return result->glyph_index;
    437     else
    438       return 0;
    439   }
    440 
    441 
    442   static FT_UInt32
    443   ps_unicodes_char_next( PS_Unicodes  table,
    444                          FT_UInt32   *unicode )
    445   {
    446     FT_UInt    result    = 0;
    447     FT_UInt32  char_code = *unicode + 1;
    448 
    449 
    450     {
    451       FT_UInt     min = 0;
    452       FT_UInt     max = table->num_maps;
    453       FT_UInt     mid;
    454       PS_UniMap*  map;
    455       FT_UInt32   base_glyph;
    456 
    457 
    458       while ( min < max )
    459       {
    460         mid = min + ( ( max - min ) >> 1 );
    461         map = table->maps + mid;
    462 
    463         if ( map->unicode == char_code )
    464         {
    465           result = map->glyph_index;
    466           goto Exit;
    467         }
    468 
    469         base_glyph = BASE_GLYPH( map->unicode );
    470 
    471         if ( base_glyph == char_code )
    472           result = map->glyph_index;
    473 
    474         if ( base_glyph < char_code )
    475           min = mid + 1;
    476         else
    477           max = mid;
    478       }
    479 
    480       if ( result )
    481         goto Exit;               /* we have a variant glyph */
    482 
    483       /* we didn't find it; check whether we have a map just above it */
    484       char_code = 0;
    485 
    486       if ( min < table->num_maps )
    487       {
    488         map       = table->maps + min;
    489         result    = map->glyph_index;
    490         char_code = BASE_GLYPH( map->unicode );
    491       }
    492     }
    493 
    494   Exit:
    495     *unicode = char_code;
    496     return result;
    497   }
    498 
    499 
    500 #endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
    501 
    502 
    503   static const char*
    504   ps_get_macintosh_name( FT_UInt  name_index )
    505   {
    506     if ( name_index >= FT_NUM_MAC_NAMES )
    507       name_index = 0;
    508 
    509     return ft_standard_glyph_names + ft_mac_names[name_index];
    510   }
    511 
    512 
    513   static const char*
    514   ps_get_standard_strings( FT_UInt  sid )
    515   {
    516     if ( sid >= FT_NUM_SID_NAMES )
    517       return 0;
    518 
    519     return ft_standard_glyph_names + ft_sid_names[sid];
    520   }
    521 
    522 
    523 #ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
    524   FT_DEFINE_SERVICE_PSCMAPSREC(pscmaps_interface,
    525     (PS_Unicode_ValueFunc)     ps_unicode_value,
    526     (PS_Unicodes_InitFunc)     ps_unicodes_init,
    527     (PS_Unicodes_CharIndexFunc)ps_unicodes_char_index,
    528     (PS_Unicodes_CharNextFunc) ps_unicodes_char_next,
    529 
    530     (PS_Macintosh_NameFunc)    ps_get_macintosh_name,
    531     (PS_Adobe_Std_StringsFunc) ps_get_standard_strings,
    532 
    533     t1_standard_encoding,
    534     t1_expert_encoding
    535   )
    536 
    537 #else
    538 
    539   FT_DEFINE_SERVICE_PSCMAPSREC(pscmaps_interface,
    540     0,
    541     0,
    542     0,
    543     0,
    544 
    545     (PS_Macintosh_NameFunc)    ps_get_macintosh_name,
    546     (PS_Adobe_Std_StringsFunc) ps_get_standard_strings,
    547 
    548     t1_standard_encoding,
    549     t1_expert_encoding
    550   )
    551 
    552 #endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
    553 
    554 
    555   FT_DEFINE_SERVICEDESCREC1(pscmaps_services,
    556     FT_SERVICE_ID_POSTSCRIPT_CMAPS, &FT_PSCMAPS_INTERFACE_GET
    557   )
    558 
    559 
    560 
    561 
    562   static FT_Pointer
    563   psnames_get_service( FT_Module    module,
    564                        const char*  service_id )
    565   {
    566     /* FT_PSCMAPS_SERVICES_GET derefers `library' in PIC mode */
    567 #ifdef FT_CONFIG_OPTION_PIC
    568     FT_Library  library;
    569 
    570 
    571     if ( !module )
    572       return NULL;
    573     library = module->library;
    574     if ( !library )
    575       return NULL;
    576 #else
    577     FT_UNUSED( module );
    578 #endif
    579 
    580     return ft_service_list_lookup( FT_PSCMAPS_SERVICES_GET, service_id );
    581   }
    582 
    583 #endif /* FT_CONFIG_OPTION_POSTSCRIPT_NAMES */
    584 
    585 
    586 #ifndef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
    587 #define PUT_PS_NAMES_SERVICE(a) 0
    588 #else
    589 #define PUT_PS_NAMES_SERVICE(a) a
    590 #endif
    591 
    592   FT_DEFINE_MODULE(psnames_module_class,
    593 
    594     0,  /* this is not a font driver, nor a renderer */
    595     sizeof ( FT_ModuleRec ),
    596 
    597     "psnames",  /* driver name                         */
    598     0x10000L,   /* driver version                      */
    599     0x20000L,   /* driver requires FreeType 2 or above */
    600 
    601     PUT_PS_NAMES_SERVICE((void*)&FT_PSCMAPS_INTERFACE_GET),   /* module specific interface */
    602     (FT_Module_Constructor)0,
    603     (FT_Module_Destructor) 0,
    604     (FT_Module_Requester)  PUT_PS_NAMES_SERVICE(psnames_get_service)
    605   )
    606 
    607 
    608 
    609 /* END */
    610