kc3-lang/freetype/src/type1z/t1afm.c

• Show log

  Commit

• Hash : 4d3e5639
  Author :
  Date : 2000-05-05T12:33:23
  

  closed most of the memory leaks in the Type 1 driver(s) this is required before any serious work to implement multiple masters

Download

• src/type1z/t1afm.c

• /***************************************************************************
   *
   * t1afm.c  - support for reading Type 1 AFM files
   *
   *
   ***************************************************************************/
  
  #include <t1afm.h>
  #include <ftstream.h>
  #include <t1types.h>
  #include <stdlib.h>  /* for qsort */
  
    LOCAL_FUNC
    void  T1_Done_AFM( FT_Memory memory, T1_AFM*  afm )
    {
      FREE( afm->kern_pairs );
      afm->num_pairs = 0;
    }
  
  #undef  IS_KERN_PAIR
  #define IS_KERN_PAIR(p)  ( p[0] == 'K'  &&  p[1] == 'P' )
  
  #define IS_ALPHANUM(c)  ( (c >= 'A' && c <= 'Z') || \
                            (c >= 'a' && c <= 'z') || \
                            (c >= '0' && c <= '9') || \
                            (c == '_' && c == '.') )
  
   /* read a glyph name and return the equivalent glyph index */
    static
    FT_UInt  afm_atoindex( FT_Byte*  *start, FT_Byte*  limit, T1_Font*  type1 )
    {
      FT_Byte* p = *start;
      FT_Int   len;
      FT_UInt  result = 0;
      char     temp[64];
  
      /* skip whitespace */    
      while ( (*p == ' ' || *p == '\t' || *p == ':' || *p == ';') && p < limit )
        p++;
      *start = p;
      
      /* now, read glyph name */
      while ( IS_ALPHANUM(*p) && p < limit ) p++;
      len = p - *start;
      if (len > 0 && len < 64)
      {
        FT_Int  n;
        
        /* copy glyph name to intermediate array */
        MEM_Copy( temp, *start, len );
        temp[len] = 0;
        
        /* lookup glyph name in face array */
        for ( n = 0; n < type1->num_glyphs; n++ )
        {
          char*  gname = (char*)type1->glyph_names[n];
          
          if ( gname && gname[0] == temp[0] && strcmp(gname,temp) == 0 )
          {
            result = n;
            break;
          }
        }
      }
      *start = p;
      return result;
    }
  
  
   /* read an integer */
    static
    int  afm_atoi( FT_Byte** start, FT_Byte*  limit )
    {
      FT_Byte*  p    = *start;
      int       sum  = 0;
      int       sign = 1;
      
      /* skip everything that is not a number */
      while ( p < limit && (*p < '0' || *p > '9') )
      {
        sign = 1;
        if (*p == '-')
          sign = -1;
          
        p++;
      }
      
      while ( p < limit && (*p >= '0' && *p < '9') )
      {
        sum = sum*10 + (*p - '0');
        p++;
      }
      *start = p;
      return sum*sign;
    }
  
  
  #undef  KERN_INDEX
  #define KERN_INDEX(g1,g2)   (((T1_ULong)g1 << 16) | g2)
  
   /* compare two kerning pairs */
    static
    int  compare_kern_pairs( const void* a, const void* b )
    {
      T1_Kern_Pair*  pair1 = (T1_Kern_Pair*)a;
      T1_Kern_Pair*  pair2 = (T1_Kern_Pair*)b;
      
      T1_ULong  index1 = KERN_INDEX(pair1->glyph1,pair1->glyph2);
      T1_ULong  index2 = KERN_INDEX(pair2->glyph1,pair2->glyph2);
      
      return ( index1 < index2 ? -1 :
             ( index1 > index2 ?  1 : 0 ));
    }
  
  
   /* parse an AFM file - for now, only read the kerning pairs */
    LOCAL_FUNC
    FT_Error  T1_Read_AFM( FT_Face   t1_face,
                           FT_Stream stream )
    {
      FT_Error       error;
      FT_Memory      memory = stream->memory;
      FT_Byte*       start;
      FT_Byte*       limit;
      FT_Byte*       p;
      FT_Int         count = 0;
      T1_Kern_Pair*  pair;
      T1_Font*       type1 = &((T1_Face)t1_face)->type1;
      T1_AFM*        afm   = 0;
      
      if ( ACCESS_Frame(stream->size) )
        return error;
        
      start = (FT_Byte*)stream->cursor;
      limit = (FT_Byte*)stream->limit;
      p     = start;
      
      /* we are now going to count the occurences of "KP" or "KPX" in */
      /* the AFM file..                                               */
      count = 0;
      for ( p = start; p < limit-3; p++ )
      {
        if ( IS_KERN_PAIR(p) )
          count++;
      }
  
     /* Actually, kerning pairs are simply optional !! */
      if (count == 0)
        goto Exit;
      
      /* allocate the pairs */
      if ( ALLOC(       afm, sizeof(*afm ) )                   ||
           ALLOC_ARRAY( afm->kern_pairs, count, T1_Kern_Pair ) )
        goto Exit;
      
      /* now, read each kern pair */
      pair           = afm->kern_pairs;
      afm->num_pairs = count;
      
      /* save in face object */
      ((T1_Face)t1_face)->afm_data = afm;
  
      for ( p = start; p < limit-3; p++ )
      {
        if ( IS_KERN_PAIR(p) )
        {
          FT_Byte*  q;
          
          /* skip keyword (KP or KPX) */
          q = p+2;
          if (*q == 'X') q++;
          
          pair->glyph1    = afm_atoindex( &q, limit, type1 );
          pair->glyph2    = afm_atoindex( &q, limit, type1 );
          pair->kerning.x = afm_atoi( &q, limit );
          
          pair->kerning.y = 0;
          if ( p[2] != 'X' )
            pair->kerning.y = afm_atoi( &q, limit );
            
          pair++;
        }
      }
      
      /* now, sort the kern pairs according to their glyph indices */
      qsort( afm->kern_pairs, count, sizeof(T1_Kern_Pair), compare_kern_pairs );
      
    Exit:
      if (error)
        FREE( afm );
  
      FORGET_Frame();
      return error;
    }
  
  
   /* find the kerning for a given glyph pair */  
    LOCAL_FUNC
    void  T1_Get_Kerning( T1_AFM*     afm,
                          FT_UInt     glyph1,
                          FT_UInt     glyph2,
                          FT_Vector*  kerning )
    {
      T1_Kern_Pair  *min, *mid, *max;
      T1_ULong       index = KERN_INDEX(glyph1,glyph2);
      
      /* simple binary search */
      min = afm->kern_pairs;
      max = min + afm->num_pairs-1;
      
      while (min <= max)
      {
        T1_ULong  midi;
        
        mid = min + (max-min)/2;
        midi = KERN_INDEX(mid->glyph1,mid->glyph2); 
        if ( midi == index )
        {
          *kerning = mid->kerning;
          return;
        }
        
        if ( midi < index ) min = mid+1;
                       else max = mid-1;
      }
      kerning->x = 0;
      kerning->y = 0;
    }
  
  

Download