20060303a

1 files changed, 1110 insertions, 0 deletions

diff --git a/libfreetype/ttcmap.c b/libfreetype/ttcmap.c
new file mode 100644
index 00000000..f6aabfee
--- /dev/null
+++ b/libfreetype/ttcmap.c
@@ -0,0 +1,1110 @@
+/***************************************************************************/
+/*                                                                         */
+/*  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_face_load_charmap                                               */
+  /*                                                                       */
+  /* <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_face_load_charmap( 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_face_free_charmap( face, cmap );
+    return error;
+  }
+
+
+  /*************************************************************************/
+  /*                                                                       */
+  /* <Function>                                                            */
+  /*    tt_face_free_charmap                                               */
+  /*                                                                       */
+  /* <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_face_free_charmap( 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 < 0x10000L )
+    {
+      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 = (FT_UInt)( 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 (FT_UInt)( group->startGlyphID +
+                      ( 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 */