1 /***************************************************************************/
5 /* PSNames module implementation (body). */
7 /* Copyright 1996-2001, 2002, 2003, 2005, 2006, 2007, 2008 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_OBJECTS_H
21 #include FT_SERVICE_POSTSCRIPT_CMAPS_H
30 #ifdef FT_CONFIG_OPTION_POSTSCRIPT_NAMES
33 #ifdef FT_CONFIG_OPTION_ADOBE_GLYPH_LIST
36 #define VARIANT_BIT 0x80000000UL
37 #define BASE_GLYPH( code ) ( (FT_UInt32)( (code) & ~VARIANT_BIT ) )
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. */
46 ps_unicode_value( const char* glyph_name )
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' )
54 /* determine whether the next four characters following are */
57 /* XXX: Add code to deal with ligatures, i.e. glyph names like */
58 /* `uniXXXXYYYYZZZZ'... */
62 const char* p = glyph_name + 3;
65 for ( count = 4; count > 0; count--, p++ )
71 d = (unsigned char)c - '0';
74 d = (unsigned char)c - 'A';
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. */
87 value = ( value << 4 ) + d;
90 /* there must be exactly four hex digits */
96 return (FT_UInt32)( value | VARIANT_BIT );
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' )
106 const char* p = glyph_name + 1;
109 for ( count = 6; count > 0; count--, p++ )
115 d = (unsigned char)c - '0';
118 d = (unsigned char)c - 'A';
128 value = ( value << 4 ) + d;
136 return (FT_UInt32)( value | VARIANT_BIT );
140 /* Look for a non-initial dot in the glyph name in order to */
141 /* find variants like `A.swash', `e.final', etc. */
143 const char* p = glyph_name;
144 const char* dot = NULL;
149 if ( *p == '.' && p > glyph_name )
156 /* now look up the glyph in the Adobe Glyph List */
158 return (FT_UInt32)ft_get_adobe_glyph_index( glyph_name, p );
160 return (FT_UInt32)( ft_get_adobe_glyph_index( glyph_name, dot ) |
166 /* ft_qsort callback to sort the unicode map */
167 FT_CALLBACK_DEF( int )
168 compare_uni_maps( const void* a,
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 );
177 /* sort base glyphs before glyph variants */
178 if ( unicode1 == unicode2 )
180 if ( map1->unicode > map2->unicode )
182 else if ( map1->unicode < map2->unicode )
189 if ( unicode1 > unicode2 )
191 else if ( unicode1 < unicode2 )
199 /* support for extra glyphs not handled (well) in AGL; */
200 /* we add extra mappings for them if necessary */
202 #define EXTRA_GLYPH_LIST_SIZE 10
204 static const FT_UInt32 ft_extra_glyph_unicodes[EXTRA_GLYPH_LIST_SIZE] =
220 static const char ft_extra_glyph_names[] =
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,
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
235 ft_extra_glyph_name_offsets[EXTRA_GLYPH_LIST_SIZE] =
251 ps_check_extra_glyph_name( const char* gname,
253 FT_UInt* extra_glyphs,
259 for ( n = 0; n < EXTRA_GLYPH_LIST_SIZE; n++ )
261 if ( ft_strcmp( ft_extra_glyph_names +
262 ft_extra_glyph_name_offsets[n], gname ) == 0 )
264 if ( states[n] == 0 )
266 /* mark this extra glyph as a candidate for the cmap */
268 extra_glyphs[n] = glyph;
278 ps_check_extra_glyph_unicode( FT_UInt32 uni_char,
284 for ( n = 0; n < EXTRA_GLYPH_LIST_SIZE; n++ )
286 if ( uni_char == ft_extra_glyph_unicodes[n] )
288 /* disable this extra glyph from being added to the cmap */
297 /* Build a table that maps Unicode values to glyph indices. */
299 ps_unicodes_init( FT_Memory memory,
302 PS_GetGlyphNameFunc get_glyph_name,
303 PS_FreeGlyphNameFunc free_glyph_name,
304 FT_Pointer glyph_data )
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];
312 /* we first allocate the table */
316 if ( !FT_NEW_ARRAY( table->maps, num_glyphs + EXTRA_GLYPH_LIST_SIZE ) )
326 for ( n = 0; n < num_glyphs; n++ )
328 const char* gname = get_glyph_name( glyph_data, n );
333 ps_check_extra_glyph_name( gname, n,
334 extra_glyphs, extra_glyph_list_states );
335 uni_char = ps_unicode_value( gname );
337 if ( BASE_GLYPH( uni_char ) != 0 )
339 ps_check_extra_glyph_unicode( uni_char,
340 extra_glyph_list_states );
341 map->unicode = uni_char;
342 map->glyph_index = n;
346 if ( free_glyph_name )
347 free_glyph_name( glyph_data, gname );
351 for ( n = 0; n < EXTRA_GLYPH_LIST_SIZE; n++ )
353 if ( extra_glyph_list_states[n] == 1 )
355 /* This glyph name has an additional representation. */
356 /* Add it to the cmap. */
358 map->unicode = ft_extra_glyph_unicodes[n];
359 map->glyph_index = extra_glyphs[n];
364 /* now compress the table a bit */
365 count = (FT_UInt)( map - table->maps );
369 /* No unicode chars here! */
370 FT_FREE( table->maps );
372 error = PSnames_Err_No_Unicode_Glyph_Name;
376 /* Reallocate if the number of used entries is much smaller. */
377 if ( count < num_glyphs / 2 )
379 (void)FT_RENEW_ARRAY( table->maps, num_glyphs, count );
380 error = PSnames_Err_Ok;
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 ),
389 table->num_maps = count;
397 ps_unicodes_char_index( PS_Unicodes table,
400 PS_UniMap *min, *max, *mid, *result = NULL;
403 /* Perform a binary search on the table. */
406 max = min + table->num_maps - 1;
410 FT_UInt32 base_glyph;
413 mid = min + ( ( max - min ) >> 1 );
415 if ( mid->unicode == unicode )
421 base_glyph = BASE_GLYPH( mid->unicode );
423 if ( base_glyph == unicode )
424 result = mid; /* remember match but continue search for base glyph */
429 if ( base_glyph < unicode )
436 return result->glyph_index;
443 ps_unicodes_char_next( PS_Unicodes table,
447 FT_UInt32 char_code = *unicode + 1;
452 FT_UInt max = table->num_maps;
455 FT_UInt32 base_glyph;
460 mid = min + ( ( max - min ) >> 1 );
461 map = table->maps + mid;
463 if ( map->unicode == char_code )
465 result = map->glyph_index;
469 base_glyph = BASE_GLYPH( map->unicode );
471 if ( base_glyph == char_code )
472 result = map->glyph_index;
474 if ( base_glyph < char_code )
481 goto Exit; /* we have a variant glyph */
483 /* we didn't find it; check whether we have a map just above it */
486 if ( min < table->num_maps )
488 map = table->maps + min;
489 result = map->glyph_index;
490 char_code = BASE_GLYPH( map->unicode );
495 *unicode = char_code;
500 #endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
504 ps_get_macintosh_name( FT_UInt name_index )
506 if ( name_index >= FT_NUM_MAC_NAMES )
509 return ft_standard_glyph_names + ft_mac_names[name_index];
514 ps_get_standard_strings( FT_UInt sid )
516 if ( sid >= FT_NUM_SID_NAMES )
519 return ft_standard_glyph_names + ft_sid_names[sid];
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,
530 (PS_Macintosh_NameFunc) ps_get_macintosh_name,
531 (PS_Adobe_Std_StringsFunc) ps_get_standard_strings,
533 t1_standard_encoding,
539 FT_DEFINE_SERVICE_PSCMAPSREC(pscmaps_interface,
545 (PS_Macintosh_NameFunc) ps_get_macintosh_name,
546 (PS_Adobe_Std_StringsFunc) ps_get_standard_strings,
548 t1_standard_encoding,
552 #endif /* FT_CONFIG_OPTION_ADOBE_GLYPH_LIST */
555 FT_DEFINE_SERVICEDESCREC1(pscmaps_services,
556 FT_SERVICE_ID_POSTSCRIPT_CMAPS, &FT_PSCMAPS_INTERFACE_GET
563 psnames_get_service( FT_Module module,
564 const char* service_id )
566 /* FT_PSCMAPS_SERVICES_GET derefers `library' in PIC mode */
567 #ifdef FT_CONFIG_OPTION_PIC
573 library = module->library;
580 return ft_service_list_lookup( FT_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) 0
589 #define PUT_PS_NAMES_SERVICE(a) a
592 FT_DEFINE_MODULE(psnames_module_class,
594 0, /* this is not a font driver, nor a renderer */
595 sizeof ( FT_ModuleRec ),
597 "psnames", /* driver name */
598 0x10000L, /* driver version */
599 0x20000L, /* driver requires FreeType 2 or above */
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)