PageRenderTime 41ms CodeModel.GetById 17ms app.highlight 20ms RepoModel.GetById 1ms app.codeStats 0ms

/src/freetype/src/psnames/psmodule.c

https://bitbucket.org/cabalistic/ogredeps/
C | 609 lines | 415 code | 137 blank | 57 comment | 80 complexity | 83a9a1c44978a3e4ba1d11996806cabb MD5 | raw file
  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 */