PageRenderTime 44ms CodeModel.GetById 16ms app.highlight 18ms RepoModel.GetById 1ms app.codeStats 0ms

/src/compiler/android-ndk/jni/freetype/src/psnames/psmodule.c

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