freetype/src/sfnt/ttcmap.c

/***************************************************************************/
/*                                                                         */
/*  ttcmap.c                                                               */
/*                                                                         */
/*    TrueType character mapping table (cmap) support (body).              */
/*                                                                         */
/*  Copyright 1996-2001 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 ( READ_UShort( cmap0->language )         ||
           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 ( ALLOC_ARRAY( cmap2->subHeaderKeys, 256, FT_UShort ) ||
           FT_FRAME_ENTER( 2L + 512L )                           )
        goto Fail;

      cmap2->language = GET_UShort();

      for ( i = 0; i < 256; i++ )
      {
        u = (FT_UShort)( 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 ) & 0xFFFF ) / 2 );

      if ( ALLOC_ARRAY( cmap2->subHeaders,
                        num_SH + 1,
                        TT_CMap2SubHeaderRec )    ||
           FT_FRAME_ENTER( ( num_SH + 1 ) * 8L ) )
      {
        FREE( cmap2->subHeaderKeys );
        goto Fail;
      }

      cmap2sub = cmap2->subHeaders;

      for ( i = 0; i <= num_SH; i++ )
      {
        cmap2sub->firstCode     = GET_UShort();
        cmap2sub->entryCount    = GET_UShort();
        cmap2sub->idDelta       = GET_Short();
        /* we apply the location offset immediately */
        cmap2sub->idRangeOffset = (FT_UShort)(
          GET_UShort() - ( num_SH - i ) * 8 - 2 );

        cmap2sub++;
      }

      FT_FRAME_EXIT();

      /* load glyph IDs */

      if ( ALLOC_ARRAY( cmap2->glyphIdArray, l, FT_UShort ) ||
           FT_FRAME_ENTER( l * 2L )                           )
      {
        FREE( cmap2->subHeaders );
        FREE( cmap2->subHeaderKeys );
        goto Fail;
      }

      for ( i = 0; i < l; i++ )
        cmap2->glyphIdArray[i] = 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      = GET_UShort();
      cmap4->segCountX2    = GET_UShort();
      cmap4->searchRange   = GET_UShort();
      cmap4->entrySelector = GET_UShort();
      cmap4->rangeShift    = GET_UShort();

      num_Seg = (FT_UShort)( cmap4->segCountX2 / 2 );

      FT_FRAME_EXIT();

      /* load segments */

      if ( ALLOC_ARRAY( cmap4->segments,
                        num_Seg,
                        TT_CMap4SegmentRec )           ||
           FT_FRAME_ENTER( ( num_Seg * 4 + 1 ) * 2L ) )
        goto Fail;

      segments = cmap4->segments;

      for ( i = 0; i < num_Seg; i++ )
        segments[i].endCount      = GET_UShort();

      (void)GET_UShort();

      for ( i = 0; i < num_Seg; i++ )
        segments[i].startCount    = GET_UShort();

      for ( i = 0; i < num_Seg; i++ )
        segments[i].idDelta       = GET_Short();

      for ( i = 0; i < num_Seg; i++ )
        segments[i].idRangeOffset = GET_UShort();

      FT_FRAME_EXIT();

      cmap4->numGlyphId = l = (FT_UShort)(
        ( ( cmap->length - ( 16L + 8L * num_Seg ) ) & 0xFFFF ) / 2 );

      /* load IDs */

      if ( ALLOC_ARRAY( cmap4->glyphIdArray, l, FT_UShort ) ||
           FT_FRAME_ENTER( l * 2L )                           )
      {
        FREE( cmap4->segments );
        goto Fail;
      }

      for ( i = 0; i < l; i++ )
        cmap4->glyphIdArray[i] = 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   = GET_UShort();
      cmap6->firstCode  = GET_UShort();
      cmap6->entryCount = GET_UShort();

      FT_FRAME_EXIT();

      l = cmap6->entryCount;

      if ( ALLOC_ARRAY( cmap6->glyphIdArray, l, FT_Short ) ||
           FT_FRAME_ENTER( l * 2L )                          )
        goto Fail;

      for ( i = 0; i < l; i++ )
        cmap6->glyphIdArray[i] = 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       = GET_ULong();
      cmap8_12->language = GET_ULong();

      FT_FRAME_EXIT();

      if ( cmap->format == 8 )
        if ( FT_STREAM_SKIP( 8192L ) )
          goto Fail;

      if ( READ_ULong( cmap8_12->nGroups ) )
        goto Fail;

      n = cmap8_12->nGroups;

      if ( ALLOC_ARRAY( cmap8_12->groups, n, TT_CMapGroupRec ) ||
           FT_FRAME_ENTER( n * 3 * 4L )                       )
        goto Fail;

      groups = cmap8_12->groups;

      for ( j = 0; j < n; j++ )
      {
        groups[j].startCharCode = GET_ULong();
        groups[j].endCharCode   = GET_ULong();
        groups[j].startGlyphID  = 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          = GET_ULong();
      cmap10->language      = GET_ULong();
      cmap10->startCharCode = GET_ULong();
      cmap10->numChars      = GET_ULong();

      FT_FRAME_EXIT();

      n = cmap10->numChars;

      if ( ALLOC_ARRAY( cmap10->glyphs, n, FT_Short ) ||
           FT_FRAME_ENTER( n * 2L )                     )
        goto Fail;

      for ( j = 0; j < n; j++ )
        cmap10->glyphs[j] = 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:
      FREE( cmap->c.cmap0.glyphIdArray );
      break;

    case 2:
      FREE( cmap->c.cmap2.subHeaderKeys );
      FREE( cmap->c.cmap2.subHeaders );
      FREE( cmap->c.cmap2.glyphIdArray );
      break;

    case 4:
      FREE( cmap->c.cmap4.segments );
      FREE( cmap->c.cmap4.glyphIdArray );
      cmap->c.cmap4.segCountX2 = 0;
      break;

    case 6:
      FREE( cmap->c.cmap6.glyphIdArray );
      cmap->c.cmap6.entryCount = 0;
      break;

    case 8:
    case 12:
      FREE( cmap->c.cmap8_12.groups );
      cmap->c.cmap8_12.nGroups = 0;
      break;

    case 10:
      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 ) & 0xFFFF;
      }
    }

    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 ) & 0xFFFF;
    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 ) & 0xFFFF;
    }

    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 */