1 /***************************************************************************/
5 /* PSNames module implementation (body). */
7 /* Copyright 1996-2003, 2005-2008, 2012-2014 by */
8 /* David Turner, Robert Wilhelm, and Werner Lemberg. */
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. */
16 /***************************************************************************/
20 #include FT_INTERNAL_DEBUG_H
21 #include FT_INTERNAL_OBJECTS_H
22 #include FT_SERVICE_POSTSCRIPT_CMAPS_H
31 #ifdef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
34 #ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
37 #define VARIANT_BIT 0x80000000UL
38 #define BASE_GLYPH( code ) ( (FT_UInt32)( (code) & ~VARIANT_BIT ) )
41 /* Return the Unicode value corresponding to a given glyph. Note that */
42 /* we do deal with glyph variants by detecting a non-initial dot in */
43 /* the name, as in `A.swash' or `e.final'; in this case, the */
44 /* VARIANT_BIT is set in the return value. */
47 ps_unicode_value( const char* glyph_name )
49 /* If the name begins with `uni', then the glyph name may be a */
50 /* hard-coded unicode character code. */
51 if ( glyph_name[0] == 'u' &&
52 glyph_name[1] == 'n' &&
53 glyph_name[2] == 'i' )
55 /* determine whether the next four characters following are */
58 /* XXX: Add code to deal with ligatures, i.e. glyph names like */
59 /* `uniXXXXYYYYZZZZ'... */
63 const char* p = glyph_name + 3;
66 for ( count = 4; count > 0; count--, p++ )
72 d = (unsigned char)c - '0';
75 d = (unsigned char)c - 'A';
82 /* Exit if a non-uppercase hexadecimal character was found */
83 /* -- this also catches character codes below `0' since such */
84 /* negative numbers cast to `unsigned int' are far too big. */
88 value = ( value << 4 ) + d;
91 /* there must be exactly four hex digits */
97 return (FT_UInt32)( value | VARIANT_BIT );
101 /* If the name begins with `u', followed by four to six uppercase */
102 /* hexadecimal digits, it is a hard-coded unicode character code. */
103 if ( glyph_name[0] == 'u' )
107 const char* p = glyph_name + 1;
110 for ( count = 6; count > 0; count--, p++ )
116 d = (unsigned char)c - '0';
119 d = (unsigned char)c - 'A';
129 value = ( value << 4 ) + d;
137 return (FT_UInt32)( value | VARIANT_BIT );
141 /* Look for a non-initial dot in the glyph name in order to */
142 /* find variants like `A.swash', `e.final', etc. */
144 const char* p = glyph_name;
145 const char* dot = NULL;
150 if ( *p == '.' && p > glyph_name )
157 /* now look up the glyph in the Adobe Glyph List */
159 return (FT_UInt32)ft_get_adobe_glyph_index( glyph_name, p );
161 return (FT_UInt32)( ft_get_adobe_glyph_index( glyph_name, dot ) |
167 /* ft_qsort callback to sort the unicode map */
168 FT_CALLBACK_DEF( int )
169 compare_uni_maps( const void* a,
172 PS_UniMap* map1 = (PS_UniMap*)a;
173 PS_UniMap* map2 = (PS_UniMap*)b;
174 FT_UInt32 unicode1 = BASE_GLYPH( map1->unicode );
175 FT_UInt32 unicode2 = BASE_GLYPH( map2->unicode );
178 /* sort base glyphs before glyph variants */
179 if ( unicode1 == unicode2 )
181 if ( map1->unicode > map2->unicode )
183 else if ( map1->unicode < map2->unicode )
190 if ( unicode1 > unicode2 )
192 else if ( unicode1 < unicode2 )
200 /* support for extra glyphs not handled (well) in AGL; */
201 /* we add extra mappings for them if necessary */
203 #define EXTRA_GLYPH_LIST_SIZE 10
205 static const FT_UInt32 ft_extra_glyph_unicodes[EXTRA_GLYPH_LIST_SIZE] =
221 static const char ft_extra_glyph_names[] =
223 'D','e','l','t','a',0,
224 'O','m','e','g','a',0,
225 'f','r','a','c','t','i','o','n',0,
226 'h','y','p','h','e','n',0,
227 'm','a','c','r','o','n',0,
229 'p','e','r','i','o','d','c','e','n','t','e','r','e','d',0,
230 's','p','a','c','e',0,
231 'T','c','o','m','m','a','a','c','c','e','n','t',0,
232 't','c','o','m','m','a','a','c','c','e','n','t',0
236 ft_extra_glyph_name_offsets[EXTRA_GLYPH_LIST_SIZE] =
252 ps_check_extra_glyph_name( const char* gname,
254 FT_UInt* extra_glyphs,
260 for ( n = 0; n < EXTRA_GLYPH_LIST_SIZE; n++ )
262 if ( ft_strcmp( ft_extra_glyph_names +
263 ft_extra_glyph_name_offsets[n], gname ) == 0 )
265 if ( states[n] == 0 )
267 /* mark this extra glyph as a candidate for the cmap */
269 extra_glyphs[n] = glyph;
279 ps_check_extra_glyph_unicode( FT_UInt32 uni_char,
285 for ( n = 0; n < EXTRA_GLYPH_LIST_SIZE; n++ )
287 if ( uni_char == ft_extra_glyph_unicodes[n] )
289 /* disable this extra glyph from being added to the cmap */
298 /* Build a table that maps Unicode values to glyph indices. */
300 ps_unicodes_init( FT_Memory memory,
303 PS_GetGlyphNameFunc get_glyph_name,
304 PS_FreeGlyphNameFunc free_glyph_name,
305 FT_Pointer glyph_data )
309 FT_UInt extra_glyph_list_states[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
310 FT_UInt extra_glyphs[EXTRA_GLYPH_LIST_SIZE];
313 /* we first allocate the table */
317 if ( !FT_NEW_ARRAY( table->maps, num_glyphs + EXTRA_GLYPH_LIST_SIZE ) )
327 for ( n = 0; n < num_glyphs; n++ )
329 const char* gname = get_glyph_name( glyph_data, n );
334 ps_check_extra_glyph_name( gname, n,
335 extra_glyphs, extra_glyph_list_states );
336 uni_char = ps_unicode_value( gname );
338 if ( BASE_GLYPH( uni_char ) != 0 )
340 ps_check_extra_glyph_unicode( uni_char,
341 extra_glyph_list_states );
342 map->unicode = uni_char;
343 map->glyph_index = n;
347 if ( free_glyph_name )
348 free_glyph_name( glyph_data, gname );
352 for ( n = 0; n < EXTRA_GLYPH_LIST_SIZE; n++ )
354 if ( extra_glyph_list_states[n] == 1 )
356 /* This glyph name has an additional representation. */
357 /* Add it to the cmap. */
359 map->unicode = ft_extra_glyph_unicodes[n];
360 map->glyph_index = extra_glyphs[n];
365 /* now compress the table a bit */
366 count = (FT_UInt)( map - table->maps );
370 /* No unicode chars here! */
371 FT_FREE( table->maps );
373 error = FT_THROW( No_Unicode_Glyph_Name );
377 /* Reallocate if the number of used entries is much smaller. */
378 if ( count < num_glyphs / 2 )
380 (void)FT_RENEW_ARRAY( table->maps, num_glyphs, count );
384 /* Sort the table in increasing order of unicode values, */
385 /* taking care of glyph variants. */
386 ft_qsort( table->maps, count, sizeof ( PS_UniMap ),
390 table->num_maps = count;
398 ps_unicodes_char_index( PS_Unicodes table,
401 PS_UniMap *min, *max, *mid, *result = NULL;
404 /* Perform a binary search on the table. */
407 max = min + table->num_maps - 1;
411 FT_UInt32 base_glyph;
414 mid = min + ( ( max - min ) >> 1 );
416 if ( mid->unicode == unicode )
422 base_glyph = BASE_GLYPH( mid->unicode );
424 if ( base_glyph == unicode )
425 result = mid; /* remember match but continue search for base glyph */
430 if ( base_glyph < unicode )
437 return result->glyph_index;
444 ps_unicodes_char_next( PS_Unicodes table,
448 FT_UInt32 char_code = *unicode + 1;
453 FT_UInt max = table->num_maps;
456 FT_UInt32 base_glyph;
461 mid = min + ( ( max - min ) >> 1 );
462 map = table->maps + mid;
464 if ( map->unicode == char_code )
466 result = map->glyph_index;
470 base_glyph = BASE_GLYPH( map->unicode );
472 if ( base_glyph == char_code )
473 result = map->glyph_index;
475 if ( base_glyph < char_code )
482 goto Exit; /* we have a variant glyph */
484 /* we didn't find it; check whether we have a map just above it */
487 if ( min < table->num_maps )
489 map = table->maps + min;
490 result = map->glyph_index;
491 char_code = BASE_GLYPH( map->unicode );
496 *unicode = char_code;
501 #endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
505 ps_get_macintosh_name( FT_UInt name_index )
507 if ( name_index >= FT_NUM_MAC_NAMES )
510 return ft_standard_glyph_names + ft_mac_names[name_index];
515 ps_get_standard_strings( FT_UInt sid )
517 if ( sid >= FT_NUM_SID_NAMES )
520 return ft_standard_glyph_names + ft_sid_names[sid];
524 #ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
526 FT_DEFINE_SERVICE_PSCMAPSREC(
528 (PS_Unicode_ValueFunc) ps_unicode_value,
529 (PS_Unicodes_InitFunc) ps_unicodes_init,
530 (PS_Unicodes_CharIndexFunc)ps_unicodes_char_index,
531 (PS_Unicodes_CharNextFunc) ps_unicodes_char_next,
533 (PS_Macintosh_NameFunc) ps_get_macintosh_name,
534 (PS_Adobe_Std_StringsFunc) ps_get_standard_strings,
536 t1_standard_encoding,
541 FT_DEFINE_SERVICE_PSCMAPSREC(
548 (PS_Macintosh_NameFunc) ps_get_macintosh_name,
549 (PS_Adobe_Std_StringsFunc) ps_get_standard_strings,
551 t1_standard_encoding,
554 #endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
557 FT_DEFINE_SERVICEDESCREC1(
559 FT_SERVICE_ID_POSTSCRIPT_CMAPS, &PSCMAPS_INTERFACE_GET )
563 psnames_get_service( FT_Module module,
564 const char* service_id )
566 /* PSCMAPS_SERVICES_GET dereferences `library' in PIC mode */
567 #ifdef FT_CONFIG_OPTION_PIC
573 library = module->library;
580 return ft_service_list_lookup( PSCMAPS_SERVICES_GET, service_id );
583 #endif /* FT_CONFIG_OPTION_POSTSCRIPT_NAMES */
586 #ifndef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
587 #define PUT_PS_NAMES_SERVICE( a ) NULL
589 #define PUT_PS_NAMES_SERVICE( a ) a
593 psnames_module_class,
595 0, /* this is not a font driver, nor a renderer */
596 sizeof ( FT_ModuleRec ),
598 "psnames", /* driver name */
599 0x10000L, /* driver version */
600 0x20000L, /* driver requires FreeType 2 or above */
602 PUT_PS_NAMES_SERVICE(
603 (void*)&PSCMAPS_INTERFACE_GET ), /* module specific interface */
604 (FT_Module_Constructor)NULL,
605 (FT_Module_Destructor) NULL,
606 (FT_Module_Requester) PUT_PS_NAMES_SERVICE( psnames_get_service ) )