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