kc3-lang/freetype/src/sfnt/ttcmap.c

• Show log

  Commit

• Hash : b7b163cb
  Author :
  Date : 2002-03-31T18:48:24
  

  * src/sfnt/ttcmap.c: 16bit fixes (0xFFFF -> 0xFFFFU). * src/sfnt/ttcmap0.c: 16bit fixes. (TT_Build_CMaps): Simplify debug messages. (tt_cmap12_char_next): Fix offset. * src/sfnt/ttload.c (TT_Load_Names, TT_Load_CMap): Fix debug messages. (TT_Load_OS2): 16bit fix.

Download

• src/sfnt/ttcmap.c

• /***************************************************************************/
  /*                                                                         */
  /*  ttcmap.c                                                               */
  /*                                                                         */
  /*    TrueType character mapping table (cmap) support (body).              */
  /*                                                                         */
  /*  Copyright 1996-2001, 2002 by                                           */
  /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  /*                                                                         */
  /*  This file is part of the FreeType project, and may only be used,       */
  /*  modified, and distributed under the terms of the FreeType project      */
  /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  /*  this file you indicate that you have read the license and              */
  /*  understand and accept it fully.                                        */
  /*                                                                         */
  /***************************************************************************/
  
  
  #include <ft2build.h>
  #include FT_INTERNAL_DEBUG_H
  #include "ttload.h"
  #include "ttcmap.h"
  
  #include "sferrors.h"
  
  
    /*************************************************************************/
    /*                                                                       */
    /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
    /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
    /* messages during execution.                                            */
    /*                                                                       */
  #undef  FT_COMPONENT
  #define FT_COMPONENT  trace_ttcmap
  
  
    FT_CALLBACK_DEF( FT_UInt )
    code_to_index0( TT_CMapTable  charmap,
                    FT_ULong      char_code );
  
    FT_CALLBACK_DEF( FT_ULong )
    code_to_next0( TT_CMapTable  charmap,
                   FT_ULong      char_code );
  
    FT_CALLBACK_DEF( FT_UInt )
    code_to_index2( TT_CMapTable  charmap,
                    FT_ULong      char_code );
  
    FT_CALLBACK_DEF( FT_ULong )
    code_to_next2( TT_CMapTable  charmap,
                   FT_ULong      char_code );
  
    FT_CALLBACK_DEF( FT_UInt )
    code_to_index4( TT_CMapTable  charmap,
                    FT_ULong      char_code );
  
    FT_CALLBACK_DEF( FT_ULong )
    code_to_next4( TT_CMapTable  charmap,
                   FT_ULong      char_code );
  
    FT_CALLBACK_DEF( FT_UInt )
    code_to_index6( TT_CMapTable  charmap,
                    FT_ULong      char_code );
  
    FT_CALLBACK_DEF( FT_ULong )
    code_to_next6( TT_CMapTable  charmap,
                   FT_ULong      char_code );
  
    FT_CALLBACK_DEF( FT_UInt )
    code_to_index8_12( TT_CMapTable  charmap,
                       FT_ULong      char_code );
  
    FT_CALLBACK_DEF( FT_ULong )
    code_to_next8_12( TT_CMapTable  charmap,
                      FT_ULong      char_code );
  
    FT_CALLBACK_DEF( FT_UInt )
    code_to_index10( TT_CMapTable  charmap,
                     FT_ULong      char_code );
  
    FT_CALLBACK_DEF( FT_ULong )
    code_to_next10( TT_CMapTable  charmap,
                    FT_ULong      char_code );
  
  
    /*************************************************************************/
    /*                                                                       */
    /* <Function>                                                            */
    /*    TT_CharMap_Load                                                    */
    /*                                                                       */
    /* <Description>                                                         */
    /*    Loads a given TrueType character map into memory.                  */
    /*                                                                       */
    /* <Input>                                                               */
    /*    face   :: A handle to the parent face object.                      */
    /*                                                                       */
    /*    stream :: A handle to the current stream object.                   */
    /*                                                                       */
    /* <InOut>                                                               */
    /*    table  :: A pointer to a cmap object.                              */
    /*                                                                       */
    /* <Return>                                                              */
    /*    FreeType error code.  0 means success.                             */
    /*                                                                       */
    /* <Note>                                                                */
    /*    The function assumes that the stream is already in use (i.e.,      */
    /*    opened).  In case of error, all partially allocated tables are     */
    /*    released.                                                          */
    /*                                                                       */
    FT_LOCAL_DEF( FT_Error )
    TT_CharMap_Load( TT_Face       face,
                     TT_CMapTable  cmap,
                     FT_Stream     stream )
    {
      FT_Error     error;
      FT_Memory    memory;
      FT_UShort    num_SH, num_Seg, i;
      FT_ULong     j, n;
  
      FT_UShort    u, l;
  
      TT_CMap0     cmap0;
      TT_CMap2     cmap2;
      TT_CMap4     cmap4;
      TT_CMap6     cmap6;
      TT_CMap8_12  cmap8_12;
      TT_CMap10    cmap10;
  
      TT_CMap2SubHeader  cmap2sub;
      TT_CMap4Segment    segments;
      TT_CMapGroup       groups;
  
  
      if ( cmap->loaded )
        return SFNT_Err_Ok;
  
      memory = stream->memory;
  
      if ( FT_STREAM_SEEK( cmap->offset ) )
        return error;
  
      switch ( cmap->format )
      {
      case 0:
        cmap0 = &cmap->c.cmap0;
  
        if ( FT_READ_USHORT( cmap0->language )           ||
             FT_ALLOC( cmap0->glyphIdArray, 256L )       ||
             FT_STREAM_READ( cmap0->glyphIdArray, 256L ) )
          goto Fail;
  
        cmap->get_index     = code_to_index0;
        cmap->get_next_char = code_to_next0;
        break;
  
      case 2:
        num_SH = 0;
        cmap2  = &cmap->c.cmap2;
  
        /* allocate subheader keys */
  
        if ( FT_NEW_ARRAY( cmap2->subHeaderKeys, 256 ) ||
             FT_FRAME_ENTER( 2L + 512L )               )
          goto Fail;
  
        cmap2->language = FT_GET_USHORT();
  
        for ( i = 0; i < 256; i++ )
        {
          u = (FT_UShort)( FT_GET_USHORT() / 8 );
          cmap2->subHeaderKeys[i] = u;
  
          if ( num_SH < u )
            num_SH = u;
        }
  
        FT_FRAME_EXIT();
  
        /* load subheaders */
  
        cmap2->numGlyphId = l = (FT_UShort)(
          ( ( cmap->length - 2L * ( 256 + 3 ) - num_SH * 8L ) & 0xFFFFU ) / 2 );
  
        if ( FT_NEW_ARRAY( cmap2->subHeaders, num_SH + 1 ) ||
             FT_FRAME_ENTER( ( num_SH + 1 ) * 8L )         )
        {
          FT_FREE( cmap2->subHeaderKeys );
          goto Fail;
        }
  
        cmap2sub = cmap2->subHeaders;
  
        for ( i = 0; i <= num_SH; i++ )
        {
          cmap2sub->firstCode     = FT_GET_USHORT();
          cmap2sub->entryCount    = FT_GET_USHORT();
          cmap2sub->idDelta       = FT_GET_SHORT();
          /* we apply the location offset immediately */
          cmap2sub->idRangeOffset = (FT_UShort)(
            FT_GET_USHORT() - ( num_SH - i ) * 8 - 2 );
  
          cmap2sub++;
        }
  
        FT_FRAME_EXIT();
  
        /* load glyph IDs */
  
        if ( FT_NEW_ARRAY( cmap2->glyphIdArray, l ) ||
             FT_FRAME_ENTER( l * 2L )               )
        {
          FT_FREE( cmap2->subHeaders );
          FT_FREE( cmap2->subHeaderKeys );
          goto Fail;
        }
  
        for ( i = 0; i < l; i++ )
          cmap2->glyphIdArray[i] = FT_GET_USHORT();
  
        FT_FRAME_EXIT();
  
        cmap->get_index = code_to_index2;
        cmap->get_next_char = code_to_next2;
        break;
  
      case 4:
        cmap4 = &cmap->c.cmap4;
  
        /* load header */
  
        if ( FT_FRAME_ENTER( 10L ) )
          goto Fail;
  
        cmap4->language      = FT_GET_USHORT();
        cmap4->segCountX2    = FT_GET_USHORT();
        cmap4->searchRange   = FT_GET_USHORT();
        cmap4->entrySelector = FT_GET_USHORT();
        cmap4->rangeShift    = FT_GET_USHORT();
  
        num_Seg = (FT_UShort)( cmap4->segCountX2 / 2 );
  
        FT_FRAME_EXIT();
  
        /* load segments */
  
        if ( FT_NEW_ARRAY( cmap4->segments, num_Seg )   ||
             FT_FRAME_ENTER( ( num_Seg * 4 + 1 ) * 2L ) )
          goto Fail;
  
        segments = cmap4->segments;
  
        for ( i = 0; i < num_Seg; i++ )
          segments[i].endCount = FT_GET_USHORT();
  
        (void)FT_GET_USHORT();
  
        for ( i = 0; i < num_Seg; i++ )
          segments[i].startCount = FT_GET_USHORT();
  
        for ( i = 0; i < num_Seg; i++ )
          segments[i].idDelta = FT_GET_SHORT();
  
        for ( i = 0; i < num_Seg; i++ )
          segments[i].idRangeOffset = FT_GET_USHORT();
  
        FT_FRAME_EXIT();
  
        cmap4->numGlyphId = l = (FT_UShort)(
          ( ( cmap->length - ( 16L + 8L * num_Seg ) ) & 0xFFFFU ) / 2 );
  
        /* load IDs */
  
        if ( FT_NEW_ARRAY( cmap4->glyphIdArray, l ) ||
             FT_FRAME_ENTER( l * 2L )               )
        {
          FT_FREE( cmap4->segments );
          goto Fail;
        }
  
        for ( i = 0; i < l; i++ )
          cmap4->glyphIdArray[i] = FT_GET_USHORT();
  
        FT_FRAME_EXIT();
  
        cmap4->last_segment = cmap4->segments;
  
        cmap->get_index     = code_to_index4;
        cmap->get_next_char = code_to_next4;
        break;
  
      case 6:
        cmap6 = &cmap->c.cmap6;
  
        if ( FT_FRAME_ENTER( 6L ) )
          goto Fail;
  
        cmap6->language   = FT_GET_USHORT();
        cmap6->firstCode  = FT_GET_USHORT();
        cmap6->entryCount = FT_GET_USHORT();
  
        FT_FRAME_EXIT();
  
        l = cmap6->entryCount;
  
        if ( FT_NEW_ARRAY( cmap6->glyphIdArray, l ) ||
             FT_FRAME_ENTER( l * 2L )               )
          goto Fail;
  
        for ( i = 0; i < l; i++ )
          cmap6->glyphIdArray[i] = FT_GET_USHORT();
  
        FT_FRAME_EXIT();
        cmap->get_index     = code_to_index6;
        cmap->get_next_char = code_to_next6;
        break;
  
      case 8:
      case 12:
        cmap8_12 = &cmap->c.cmap8_12;
  
        if ( FT_FRAME_ENTER( 8L ) )
          goto Fail;
  
        cmap->length       = FT_GET_ULONG();
        cmap8_12->language = FT_GET_ULONG();
  
        FT_FRAME_EXIT();
  
        if ( cmap->format == 8 )
          if ( FT_STREAM_SKIP( 8192L ) )
            goto Fail;
  
        if ( FT_READ_ULONG( cmap8_12->nGroups ) )
          goto Fail;
  
        n = cmap8_12->nGroups;
  
        if ( FT_NEW_ARRAY( cmap8_12->groups, n ) ||
             FT_FRAME_ENTER( n * 3 * 4L )        )
          goto Fail;
  
        groups = cmap8_12->groups;
  
        for ( j = 0; j < n; j++ )
        {
          groups[j].startCharCode = FT_GET_ULONG();
          groups[j].endCharCode   = FT_GET_ULONG();
          groups[j].startGlyphID  = FT_GET_ULONG();
        }
  
        FT_FRAME_EXIT();
  
        cmap8_12->last_group = cmap8_12->groups;
  
        cmap->get_index     = code_to_index8_12;
        cmap->get_next_char = code_to_next8_12;
        break;
  
      case 10:
        cmap10 = &cmap->c.cmap10;
  
        if ( FT_FRAME_ENTER( 16L ) )
          goto Fail;
  
        cmap->length          = FT_GET_ULONG();
        cmap10->language      = FT_GET_ULONG();
        cmap10->startCharCode = FT_GET_ULONG();
        cmap10->numChars      = FT_GET_ULONG();
  
        FT_FRAME_EXIT();
  
        n = cmap10->numChars;
  
        if ( FT_NEW_ARRAY( cmap10->glyphs, n ) ||
             FT_FRAME_ENTER( n * 2L )          )
          goto Fail;
  
        for ( j = 0; j < n; j++ )
          cmap10->glyphs[j] = FT_GET_USHORT();
  
        FT_FRAME_EXIT();
        cmap->get_index     = code_to_index10;
        cmap->get_next_char = code_to_next10;
        break;
  
      default:   /* corrupt character mapping table */
        return SFNT_Err_Invalid_CharMap_Format;
  
      }
  
      return SFNT_Err_Ok;
  
    Fail:
      TT_CharMap_Free( face, cmap );
      return error;
    }
  
  
    /*************************************************************************/
    /*                                                                       */
    /* <Function>                                                            */
    /*    TT_CharMap_Free                                                    */
    /*                                                                       */
    /* <Description>                                                         */
    /*    Destroys a character mapping table.                                */
    /*                                                                       */
    /* <Input>                                                               */
    /*    face :: A handle to the parent face object.                        */
    /*                                                                       */
    /*    cmap :: A handle to a cmap object.                                 */
    /*                                                                       */
    /* <Return>                                                              */
    /*    FreeType error code.  0 means success.                             */
    /*                                                                       */
    FT_LOCAL_DEF( FT_Error )
    TT_CharMap_Free( TT_Face       face,
                     TT_CMapTable  cmap )
    {
      FT_Memory  memory;
  
  
      if ( !cmap )
        return SFNT_Err_Ok;
  
      memory = face->root.driver->root.memory;
  
      switch ( cmap->format )
      {
      case 0:
        FT_FREE( cmap->c.cmap0.glyphIdArray );
        break;
  
      case 2:
        FT_FREE( cmap->c.cmap2.subHeaderKeys );
        FT_FREE( cmap->c.cmap2.subHeaders );
        FT_FREE( cmap->c.cmap2.glyphIdArray );
        break;
  
      case 4:
        FT_FREE( cmap->c.cmap4.segments );
        FT_FREE( cmap->c.cmap4.glyphIdArray );
        cmap->c.cmap4.segCountX2 = 0;
        break;
  
      case 6:
        FT_FREE( cmap->c.cmap6.glyphIdArray );
        cmap->c.cmap6.entryCount = 0;
        break;
  
      case 8:
      case 12:
        FT_FREE( cmap->c.cmap8_12.groups );
        cmap->c.cmap8_12.nGroups = 0;
        break;
  
      case 10:
        FT_FREE( cmap->c.cmap10.glyphs );
        cmap->c.cmap10.numChars = 0;
        break;
  
      default:
        /* invalid table format, do nothing */
        ;
      }
  
      cmap->loaded = FALSE;
      return SFNT_Err_Ok;
    }
  
  
    /*************************************************************************/
    /*                                                                       */
    /* <Function>                                                            */
    /*    code_to_index0                                                     */
    /*                                                                       */
    /* <Description>                                                         */
    /*    Converts the character code into a glyph index.  Uses format 0.    */
    /*    `charCode' must be in the range 0x00-0xFF (otherwise 0 is          */
    /*    returned).                                                         */
    /*                                                                       */
    /* <Input>                                                               */
    /*    charCode :: The wanted character code.                             */
    /*                                                                       */
    /*    cmap0    :: A pointer to a cmap table in format 0.                 */
    /*                                                                       */
    /* <Return>                                                              */
    /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
    /*                                                                       */
    FT_CALLBACK_DEF( FT_UInt )
    code_to_index0( TT_CMapTable  cmap,
                    FT_ULong      charCode )
    {
      TT_CMap0  cmap0 = &cmap->c.cmap0;
  
  
      return ( charCode <= 0xFF ? cmap0->glyphIdArray[charCode] : 0 );
    }
  
  
    /*************************************************************************/
    /*                                                                       */
    /* <Function>                                                            */
    /*    code_to_next0                                                      */
    /*                                                                       */
    /* <Description>                                                         */
    /*    Finds the next encoded character after the given one.  Uses        */
    /*    format 0. `charCode' must be in the range 0x00-0xFF (otherwise 0   */
    /*    is returned).                                                      */
    /*                                                                       */
    /* <Input>                                                               */
    /*    charCode :: The wanted character code.                             */
    /*                                                                       */
    /*    cmap0    :: A pointer to a cmap table in format 0.                 */
    /*                                                                       */
    /* <Return>                                                              */
    /*    Next char code.  0 if no higher one is encoded.                    */
    /*                                                                       */
    FT_CALLBACK_DEF( FT_ULong )
    code_to_next0( TT_CMapTable  cmap,
                   FT_ULong      charCode )
    {
      TT_CMap0  cmap0 = &cmap->c.cmap0;
  
  
      while ( ++charCode <= 0xFF )
        if ( cmap0->glyphIdArray[charCode] )
          return ( charCode );
      return ( 0 );
    }
  
  
    /*************************************************************************/
    /*                                                                       */
    /* <Function>                                                            */
    /*    code_to_index2                                                     */
    /*                                                                       */
    /* <Description>                                                         */
    /*    Converts the character code into a glyph index.  Uses format 2.    */
    /*                                                                       */
    /* <Input>                                                               */
    /*    charCode :: The wanted character code.                             */
    /*                                                                       */
    /*    cmap2    :: A pointer to a cmap table in format 2.                 */
    /*                                                                       */
    /* <Return>                                                              */
    /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
    /*                                                                       */
    FT_CALLBACK_DEF( FT_UInt )
    code_to_index2( TT_CMapTable  cmap,
                    FT_ULong      charCode )
    {
      FT_UInt            result, index1, offset;
      FT_UInt            char_lo;
      FT_ULong           char_hi;
      TT_CMap2SubHeader  sh2;
      TT_CMap2           cmap2;
  
  
      cmap2   = &cmap->c.cmap2;
      result  = 0;
      char_lo = (FT_UInt)( charCode & 0xFF );
      char_hi = charCode >> 8;
  
      if ( char_hi == 0 )
      {
        /* an 8-bit character code -- we use the subHeader 0 in this case */
        /* to test whether the character code is in the charmap           */
        index1 = cmap2->subHeaderKeys[char_lo];
        if ( index1 != 0 )
          return 0;
      }
      else
      {
        /* a 16-bit character code */
        index1 = cmap2->subHeaderKeys[char_hi & 0xFF];
        if ( index1 == 0 )
          return 0;
      }
  
      sh2      = cmap2->subHeaders + index1;
      char_lo -= sh2->firstCode;
  
      if ( char_lo < (FT_UInt)sh2->entryCount )
      {
        offset = sh2->idRangeOffset / 2 + char_lo;
        if ( offset < (FT_UInt)cmap2->numGlyphId )
        {
          result = cmap2->glyphIdArray[offset];
          if ( result )
            result = ( result + sh2->idDelta ) & 0xFFFFU;
        }
      }
  
      return result;
    }
  
  
    /*************************************************************************/
    /*                                                                       */
    /* <Function>                                                            */
    /*    code_to_next2                                                      */
    /*                                                                       */
    /* <Description>                                                         */
    /*    Find the next encoded character.  Uses format 2.                   */
    /*                                                                       */
    /* <Input>                                                               */
    /*    charCode :: The wanted character code.                             */
    /*                                                                       */
    /*    cmap2    :: A pointer to a cmap table in format 2.                 */
    /*                                                                       */
    /* <Return>                                                              */
    /*    Next encoded character.  0 if none exists.                         */
    /*                                                                       */
    FT_CALLBACK_DEF( FT_ULong )
    code_to_next2( TT_CMapTable  cmap,
                   FT_ULong      charCode )
    {
      FT_UInt            index1, offset;
      FT_UInt            char_lo;
      FT_ULong           char_hi;
      TT_CMap2SubHeader  sh2;
      TT_CMap2           cmap2;
  
  
      cmap2 = &cmap->c.cmap2;
      charCode++;
  
      /*
       * This is relatively simplistic -- look for a subHeader containing
       * glyphs and then walk to the first glyph in that subHeader.
       */
      while ( charCode < 0x10000 )
      {
        char_lo = (FT_UInt)( charCode & 0xFF );
        char_hi = charCode >> 8;
    
        if ( char_hi == 0 )
        {
          /* an 8-bit character code -- we use the subHeader 0 in this case */
          /* to test whether the character code is in the charmap           */
          index1 = cmap2->subHeaderKeys[char_lo];
          if ( index1 != 0 )
          {
            charCode++;
            continue;
          }
        }
        else
        {
          /* a 16-bit character code */
          index1 = cmap2->subHeaderKeys[char_hi & 0xFF];
          if ( index1 == 0 )
          {
            charCode = ( char_hi + 1 ) << 8;
            continue;
          }
        }
    
        sh2      = cmap2->subHeaders + index1;
        char_lo -= sh2->firstCode;
    
        if ( char_lo > (FT_UInt)sh2->entryCount )
        {
          charCode = ( char_hi + 1 ) << 8;
          continue;
        }
        
        offset = sh2->idRangeOffset / 2 + char_lo;
        if ( offset >= (FT_UInt)cmap2->numGlyphId ||
             cmap2->glyphIdArray[offset] == 0     )
        {
          charCode++;
          continue;
        }
        
        return charCode;
      }
      return 0;
    }
  
  
    /*************************************************************************/
    /*                                                                       */
    /* <Function>                                                            */
    /*    code_to_index4                                                     */
    /*                                                                       */
    /* <Description>                                                         */
    /*    Converts the character code into a glyph index.  Uses format 4.    */
    /*                                                                       */
    /* <Input>                                                               */
    /*    charCode :: The wanted character code.                             */
    /*                                                                       */
    /*    cmap4    :: A pointer to a cmap table in format 4.                 */
    /*                                                                       */
    /* <Return>                                                              */
    /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
    /*                                                                       */
    FT_CALLBACK_DEF( FT_UInt )
    code_to_index4( TT_CMapTable  cmap,
                    FT_ULong      charCode )
    {
      FT_UInt             result, index1, segCount;
      TT_CMap4            cmap4;
      TT_CMap4SegmentRec  *seg4, *limit;
  
  
      cmap4    = &cmap->c.cmap4;
      result   = 0;
      segCount = cmap4->segCountX2 / 2;
      limit    = cmap4->segments + segCount;
  
      /* first, check against the last used segment */
  
      seg4 = cmap4->last_segment;
  
      /* the following is equivalent to performing two tests, as in         */
      /*                                                                    */
      /*  if ( charCode >= seg4->startCount && charCode <= seg4->endCount ) */
      /*                                                                    */
      /* This is a bit strange, but it is faster, and the idea behind the   */
      /* cache is to significantly speed up charcode to glyph index         */
      /* conversion.                                                        */
  
      if ( (FT_ULong)( charCode       - seg4->startCount ) <
           (FT_ULong)( seg4->endCount - seg4->startCount ) )
        goto Found1;
  
      for ( seg4 = cmap4->segments; seg4 < limit; seg4++ )
      {
        /* the ranges are sorted in increasing order.  If we are out of */
        /* the range here, the char code isn't in the charmap, so exit. */
  
        if ( charCode > (FT_UInt)seg4->endCount )
          continue;
  
        if ( charCode >= (FT_UInt)seg4->startCount )
          goto Found;
      }
      return 0;
  
    Found:
      cmap4->last_segment = seg4;
  
    Found1:
      /* if the idRangeOffset is 0, we can compute the glyph index */
      /* directly                                                  */
  
      if ( seg4->idRangeOffset == 0 )
        result = ( charCode + seg4->idDelta ) & 0xFFFFU;
      else
      {
        /* otherwise, we must use the glyphIdArray to do it */
        index1 = (FT_UInt)( seg4->idRangeOffset / 2
                            + ( charCode - seg4->startCount )
                            + ( seg4 - cmap4->segments )
                            - segCount );
  
        if ( index1 < (FT_UInt)cmap4->numGlyphId &&
             cmap4->glyphIdArray[index1] != 0    )
          result = ( cmap4->glyphIdArray[index1] + seg4->idDelta ) & 0xFFFFU;
      }
  
      return result;
    }
  
  
    /*************************************************************************/
    /*                                                                       */
    /* <Function>                                                            */
    /*    code_to_next4                                                      */
    /*                                                                       */
    /* <Description>                                                         */
    /*    Find the next encoded character.  Uses format 4.                   */
    /*                                                                       */
    /* <Input>                                                               */
    /*    charCode :: The wanted character code.                             */
    /*                                                                       */
    /*    cmap     :: A pointer to a cmap table in format 4.                 */
    /*                                                                       */
    /* <Return>                                                              */
    /*    Next encoded character.  0 if none exists.                         */
    /*                                                                       */
    FT_CALLBACK_DEF( FT_ULong )
    code_to_next4( TT_CMapTable  cmap,
                   FT_ULong      charCode )
    {
      FT_UInt             index1, segCount;
      TT_CMap4            cmap4;
      TT_CMap4SegmentRec  *seg4, *limit;
  
  
      cmap4    = &cmap->c.cmap4;
      segCount = cmap4->segCountX2 / 2;
      limit    = cmap4->segments + segCount;
  
      charCode++;
  
      for ( seg4 = cmap4->segments; seg4 < limit; seg4++ )
      {
        /* The ranges are sorted in increasing order.  If we are out of */
        /* the range here, the char code isn't in the charmap, so exit. */
  
        if ( charCode <= (FT_UInt)seg4->endCount )
          goto Found;
      }
      return 0;
  
    Found:
      if ( charCode < (FT_ULong) seg4->startCount )
        charCode = seg4->startCount;
  
      /* if the idRangeOffset is 0, all chars in the map exist */
  
      if ( seg4->idRangeOffset == 0 )
        return ( charCode );
      
      while ( charCode <= (FT_UInt) seg4->endCount )
      {
        /* otherwise, we must use the glyphIdArray to do it */
        index1 = (FT_UInt)( seg4->idRangeOffset / 2
                            + ( charCode - seg4->startCount )
                            + ( seg4 - cmap4->segments )
                            - segCount );
  
        if ( index1 < (FT_UInt)cmap4->numGlyphId &&
             cmap4->glyphIdArray[index1] != 0    )
          return ( charCode );
        charCode++;
      }
  
      return 0;
    }
  
  
    /*************************************************************************/
    /*                                                                       */
    /* <Function>                                                            */
    /*    code_to_index6                                                     */
    /*                                                                       */
    /* <Description>                                                         */
    /*    Converts the character code into a glyph index.  Uses format 6.    */
    /*                                                                       */
    /* <Input>                                                               */
    /*    charCode :: The wanted character code.                             */
    /*                                                                       */
    /*    cmap6    :: A pointer to a cmap table in format 6.                 */
    /*                                                                       */
    /* <Return>                                                              */
    /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
    /*                                                                       */
    FT_CALLBACK_DEF( FT_UInt )
    code_to_index6( TT_CMapTable  cmap,
                    FT_ULong      charCode )
    {
      TT_CMap6  cmap6;
      FT_UInt   result = 0;
  
  
      cmap6     = &cmap->c.cmap6;
      charCode -= cmap6->firstCode;
  
      if ( charCode < (FT_UInt)cmap6->entryCount )
        result = cmap6->glyphIdArray[charCode];
  
      return result;
    }
  
  
    /*************************************************************************/
    /*                                                                       */
    /* <Function>                                                            */
    /*    code_to_next6                                                      */
    /*                                                                       */
    /* <Description>                                                         */
    /*    Find the next encoded character.  Uses format 6.                   */
    /*                                                                       */
    /* <Input>                                                               */
    /*    charCode :: The wanted character code.                             */
    /*                                                                       */
    /*    cmap     :: A pointer to a cmap table in format 6.                 */
    /*                                                                       */
    /* <Return>                                                              */
    /*    Next encoded character.  0 if none exists.                         */
    /*                                                                       */
    FT_CALLBACK_DEF( FT_ULong )
    code_to_next6( TT_CMapTable  cmap,
                   FT_ULong      charCode )
    {
      TT_CMap6  cmap6;
  
  
      charCode++;
      
      cmap6 = &cmap->c.cmap6;
      
      if ( charCode < (FT_ULong) cmap6->firstCode )
        charCode = cmap6->firstCode;
      
      charCode -= cmap6->firstCode;
  
      while ( charCode < (FT_UInt)cmap6->entryCount )
      {
        if ( cmap6->glyphIdArray[charCode] != 0 )
          return charCode + cmap6->firstCode;
        charCode++;
      }
  
      return 0;
    }
  
  
    /*************************************************************************/
    /*                                                                       */
    /* <Function>                                                            */
    /*    code_to_index8_12                                                  */
    /*                                                                       */
    /* <Description>                                                         */
    /*    Converts the (possibly 32bit) character code into a glyph index.   */
    /*    Uses format 8 or 12.                                               */
    /*                                                                       */
    /* <Input>                                                               */
    /*    charCode :: The wanted character code.                             */
    /*                                                                       */
    /*    cmap8_12 :: A pointer to a cmap table in format 8 or 12.           */
    /*                                                                       */
    /* <Return>                                                              */
    /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
    /*                                                                       */
    FT_CALLBACK_DEF( FT_UInt )
    code_to_index8_12( TT_CMapTable  cmap,
                       FT_ULong      charCode )
    {
      TT_CMap8_12      cmap8_12;
      TT_CMapGroupRec  *group, *limit;
  
  
      cmap8_12 = &cmap->c.cmap8_12;
      limit    = cmap8_12->groups + cmap8_12->nGroups;
  
      /* first, check against the last used group */
  
      group = cmap8_12->last_group;
  
      /* the following is equivalent to performing two tests, as in       */
      /*                                                                  */
      /*  if ( charCode >= group->startCharCode &&                        */
      /*       charCode <= group->endCharCode   )                         */
      /*                                                                  */
      /* This is a bit strange, but it is faster, and the idea behind the */
      /* cache is to significantly speed up charcode to glyph index       */
      /* conversion.                                                      */
  
      if ( (FT_ULong)( charCode           - group->startCharCode ) <
           (FT_ULong)( group->endCharCode - group->startCharCode ) )
        goto Found1;
  
      for ( group = cmap8_12->groups; group < limit; group++ )
      {
        /* the ranges are sorted in increasing order.  If we are out of */
        /* the range here, the char code isn't in the charmap, so exit. */
  
        if ( charCode > group->endCharCode )
          continue;
  
        if ( charCode >= group->startCharCode )
          goto Found;
      }
      return 0;
  
    Found:
      cmap8_12->last_group = group;
  
    Found1:
      return group->startGlyphID + (FT_UInt)( charCode - group->startCharCode );
    }
  
  
    /*************************************************************************/
    /*                                                                       */
    /* <Function>                                                            */
    /*    code_to_next8_12                                                   */
    /*                                                                       */
    /* <Description>                                                         */
    /*    Find the next encoded character.  Uses format 8 or 12.             */
    /*                                                                       */
    /* <Input>                                                               */
    /*    charCode :: The wanted character code.                             */
    /*                                                                       */
    /*    cmap     :: A pointer to a cmap table in format 8 or 12.           */
    /*                                                                       */
    /* <Return>                                                              */
    /*    Next encoded character.  0 if none exists.                         */
    /*                                                                       */
    FT_CALLBACK_DEF( FT_ULong )
    code_to_next8_12( TT_CMapTable  cmap,
                      FT_ULong      charCode )
    {
      TT_CMap8_12      cmap8_12;
      TT_CMapGroupRec  *group, *limit;
  
  
      charCode++;
      cmap8_12 = &cmap->c.cmap8_12;
      limit    = cmap8_12->groups + cmap8_12->nGroups;
  
      for ( group = cmap8_12->groups; group < limit; group++ )
      {
        /* the ranges are sorted in increasing order.  If we are out of */
        /* the range here, the char code isn't in the charmap, so exit. */
  
        if ( charCode <= group->endCharCode )
          goto Found;
      }
      return 0;
  
    Found:
      if ( charCode < group->startCharCode )
        charCode = group->startCharCode;
      
      return charCode;
    }
  
  
    /*************************************************************************/
    /*                                                                       */
    /* <Function>                                                            */
    /*    code_to_index10                                                    */
    /*                                                                       */
    /* <Description>                                                         */
    /*    Converts the (possibly 32bit) character code into a glyph index.   */
    /*    Uses format 10.                                                    */
    /*                                                                       */
    /* <Input>                                                               */
    /*    charCode :: The wanted character code.                             */
    /*                                                                       */
    /*    cmap10   :: A pointer to a cmap table in format 10.                */
    /*                                                                       */
    /* <Return>                                                              */
    /*    Glyph index into the glyphs array.  0 if the glyph does not exist. */
    /*                                                                       */
    FT_CALLBACK_DEF( FT_UInt )
    code_to_index10( TT_CMapTable  cmap,
                     FT_ULong      charCode )
    {
      TT_CMap10  cmap10;
      FT_UInt    result = 0;
  
  
      cmap10    = &cmap->c.cmap10;
      charCode -= cmap10->startCharCode;
  
      /* the overflow trick for comparison works here also since the number */
      /* of glyphs (even if numChars is specified as ULong in the specs) in */
      /* an OpenType font is limited to 64k                                 */
  
      if ( charCode < cmap10->numChars )
        result = cmap10->glyphs[charCode];
  
      return result;
    }
  
  
    /*************************************************************************/
    /*                                                                       */
    /* <Function>                                                            */
    /*    code_to_next10                                                     */
    /*                                                                       */
    /* <Description>                                                         */
    /*    Find the next encoded character.  Uses format 10.                  */
    /*                                                                       */
    /* <Input>                                                               */
    /*    charCode :: The wanted character code.                             */
    /*                                                                       */
    /*    cmap     :: A pointer to a cmap table in format 10.                */
    /*                                                                       */
    /* <Return>                                                              */
    /*    Next encoded character.  0 if none exists.                         */
    /*                                                                       */
    FT_CALLBACK_DEF( FT_ULong )
    code_to_next10( TT_CMapTable  cmap,
                    FT_ULong      charCode )
    {
      TT_CMap10  cmap10;
  
  
      charCode++;
      cmap10 = &cmap->c.cmap10;
      
      if ( charCode < cmap10->startCharCode )
        charCode = cmap10->startCharCode;
      
      charCode -= cmap10->startCharCode;
  
      /* the overflow trick for comparison works here also since the number */
      /* of glyphs (even if numChars is specified as ULong in the specs) in */
      /* an OpenType font is limited to 64k                                 */
  
      while ( charCode < cmap10->numChars )
      {
        if ( cmap10->glyphs[charCode] )
          return ( charCode + cmap10->startCharCode );
        charCode++;
      }
  
      return 0;
    }
  
  
  /* END */
  

Download