src/freetype/sfnt/ttcmap.c

/***************************************************************************/
/*                                                                         */
/*  ttcmap.c                                                               */
/*                                                                         */
/*    TrueType character mapping table (cmap) support (body).              */
/*                                                                         */
/*  Copyright 1996-2000 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 <freetype/internal/ftdebug.h>
#include <freetype/internal/tterrors.h>


#ifdef FT_FLAT_COMPILE

#include "ttload.h"
#include "ttcmap.h"

#else

#include <sfnt/ttload.h>
#include <sfnt/ttcmap.h>

#endif


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


  static FT_UInt  code_to_index0( TT_CMapTable*  charmap,
                                  FT_ULong       char_code );
  static FT_UInt  code_to_index2( TT_CMapTable*  charmap,
                                  FT_ULong       char_code );
  static FT_UInt  code_to_index4( TT_CMapTable*  charmap,
                                  FT_ULong       char_code );
  static FT_UInt  code_to_index6( 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.                                                          */
  /*                                                                       */
  LOCAL_FUNC
  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_UShort  u, l;

    TT_CMap0*  cmap0;
    TT_CMap2*  cmap2;
    TT_CMap4*  cmap4;
    TT_CMap6*  cmap6;

    TT_CMap2SubHeader*  cmap2sub;
    TT_CMap4Segment*    segments;


    if ( cmap->loaded )
      return TT_Err_Ok;

    memory = stream->memory;

    if ( FILE_Seek( cmap->offset ) )
      return error;

    switch ( cmap->format )
    {
    case 0:
      cmap0 = &cmap->c.cmap0;

      if ( ALLOC( cmap0->glyphIdArray, 256L )            ||
           FILE_Read( cmap0->glyphIdArray, 256L ) )
         goto Fail;

      cmap->get_index = code_to_index0;
      break;

    case 2:
      num_SH = 0;
      cmap2  = &cmap->c.cmap2;

      /* allocate subheader keys */

      if ( ALLOC_ARRAY( cmap2->subHeaderKeys, 256, FT_UShort ) ||
           ACCESS_Frame( 512L )                                )
        goto Fail;

      for ( i = 0; i < 256; i++ )
      {
        u = GET_UShort() / 8;
        cmap2->subHeaderKeys[i] = u;

        if ( num_SH < u )
          num_SH = u;
      }

      FORGET_Frame();

      /* load subheaders */

      cmap2->numGlyphId = l =
        ( ( cmap->length - 2L * ( 256 + 3 ) - num_SH * 8L ) & 0xFFFF ) / 2;

      if ( ALLOC_ARRAY( cmap2->subHeaders,
                        num_SH + 1,
                        TT_CMap2SubHeader )    ||
           ACCESS_Frame( ( num_SH + 1 ) * 8L ) )
        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 = GET_UShort() - ( num_SH - i ) * 8 - 2;

        cmap2sub++;
      }

      FORGET_Frame();

      /* load glyph IDs */

      if ( ALLOC_ARRAY( cmap2->glyphIdArray, l, FT_UShort ) ||
           ACCESS_Frame( l * 2L )                           )
        goto Fail;

      for ( i = 0; i < l; i++ )
        cmap2->glyphIdArray[i] = GET_UShort();

      FORGET_Frame();

      cmap->get_index = code_to_index2;
      break;

    case 4:
      cmap4 = &cmap->c.cmap4;

      /* load header */

      if ( ACCESS_Frame( 8L ) )
        goto Fail;

      cmap4->segCountX2    = GET_UShort();
      cmap4->searchRange   = GET_UShort();
      cmap4->entrySelector = GET_UShort();
      cmap4->rangeShift    = GET_UShort();

      num_Seg = cmap4->segCountX2 / 2;

      FORGET_Frame();

      /* load segments */

      if ( ALLOC_ARRAY( cmap4->segments,
                        num_Seg,
                        TT_CMap4Segment )           ||
           ACCESS_Frame( ( 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();

      FORGET_Frame();

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

      /* load IDs */

      if ( ALLOC_ARRAY( cmap4->glyphIdArray, l, FT_UShort ) ||
           ACCESS_Frame( l * 2L )                           )
        goto Fail;

      for ( i = 0; i < l; i++ )
        cmap4->glyphIdArray[i] = GET_UShort();

      FORGET_Frame();

      cmap->get_index = code_to_index4;

      cmap4->last_segment = cmap4->segments;
      break;

    case 6:
      cmap6 = &cmap->c.cmap6;

      if ( ACCESS_Frame( 4L ) )
        goto Fail;

      cmap6->firstCode  = GET_UShort();
      cmap6->entryCount = GET_UShort();

      FORGET_Frame();

      l = cmap6->entryCount;

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

      for ( i = 0; i < l; i++ )
        cmap6->glyphIdArray[i] = GET_UShort();

      FORGET_Frame();
      cmap->get_index = code_to_index6;
      break;

    default:   /* corrupt character mapping table */
      return TT_Err_Invalid_CharMap_Format;

    }

    return TT_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.                             */
  /*                                                                       */
  LOCAL_FUNC
  FT_Error  TT_CharMap_Free( TT_Face        face,
                             TT_CMapTable*  cmap )
  {
    FT_Memory  memory;


    if ( !cmap )
      return TT_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;

    default:
      /* invalid table format, do nothing */
      ;
    }

    cmap->loaded = FALSE;
    return TT_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. */
  /*                                                                       */
  static
  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_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. */
  /*                                                                       */
  static
  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           */
      if ( cmap2->subHeaderKeys[char_lo] == 0 )
        result = cmap2->glyphIdArray[char_lo];
    }
    else
    {
      /* a 16-bit character code */
      index1 = cmap2->subHeaderKeys[char_hi & 0xFF];
      if ( index1 )
      {
        sh2      = cmap2->subHeaders + index1;
        char_lo -= sh2->firstCode;

        if ( char_lo < sh2->entryCount )
        {
          offset = sh2->idRangeOffset / 2 + char_lo;
          if ( offset < cmap2->numGlyphId )
          {
            result = cmap2->glyphIdArray[offset];
            if ( result )
              result = ( result + sh2->idDelta ) & 0xFFFF;
          }
        }
      }
    }

    return result;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <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. */
  /*                                                                       */
  static
  FT_UInt  code_to_index4( TT_CMapTable*  cmap,
                           FT_ULong       charCode )
  {
    FT_UInt          result, index1, segCount;
    TT_CMap4*        cmap4;
    TT_CMap4Segment  *seg4, *limit;


    cmap4    = &cmap->c.cmap4;
    result   = 0;
    segCount = cmap4->segCountX2 / 2;
    seg4     = cmap4->segments;
    limit    = seg4 + segCount;

    /* check against the last segment */
    seg4 = cmap4->last_segment;

    /* the following is equivalent to performing two tests, as in         */
    /*                                                                    */
    /*  if ( charCode >= seg4->startCount && charCode <= seg4->endCount ) */
    /*                                                                    */
    /* Yes, that's a bit strange, but it's 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 Found;

    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 > seg4->endCount )
        continue;

      if ( charCode >= seg4->startCount )
        goto Found;
    }
    return 0;

 Found:
    cmap4->last_segment = seg4;

    /* 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 = seg4->idRangeOffset / 2
               + ( charCode - seg4->startCount )
               + ( seg4 - cmap4->segments )
               - segCount;

      if ( index1 < cmap4->numGlyphId       &&
           cmap4->glyphIdArray[index1] != 0 )
        result = ( cmap4->glyphIdArray[index1] + seg4->idDelta ) & 0xFFFF;
    }

    return result;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <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. */
  /*                                                                       */
  static
  FT_UInt  code_to_index6( TT_CMapTable*  cmap,
                           FT_ULong       charCode )
  {
    TT_CMap6*  cmap6;
    FT_UInt    result = 0;


    cmap6     = &cmap->c.cmap6;
    result    = 0;
    charCode -= cmap6->firstCode;

    if ( charCode < cmap6->entryCount )
      result =  cmap6->glyphIdArray[charCode];

    return result;
  }


/* END */
Commit	Line	Data
	1	/***************************************************************************/
	2	/* */
	3	/* ttcmap.c */
	4	/* */
	5	/* TrueType character mapping table (cmap) support (body). */
	6	/* */
	7	/* Copyright 1996-2000 by */
	8	/* David Turner, Robert Wilhelm, and Werner Lemberg. */
	9	/* */
	10	/* This file is part of the FreeType project, and may only be used, */
	11	/* modified, and distributed under the terms of the FreeType project */
	12	/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
	13	/* this file you indicate that you have read the license and */
	14	/* understand and accept it fully. */
	15	/* */
	16	/***************************************************************************/
	17
	18
	19	#include <freetype/internal/ftdebug.h>
	20	#include <freetype/internal/tterrors.h>
	21
	22
	23	#ifdef FT_FLAT_COMPILE
	24
	25	#include "ttload.h"
	26	#include "ttcmap.h"
	27
	28	#else
	29
	30	#include <sfnt/ttload.h>
	31	#include <sfnt/ttcmap.h>
	32
	33	#endif
	34
	35
	36	/*************************************************************************/
	37	/* */
	38	/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
	39	/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
	40	/* messages during execution. */
	41	/* */
	42	#undef FT_COMPONENT
	43	#define FT_COMPONENT trace_ttcmap
	44
	45
	46	static FT_UInt code_to_index0( TT_CMapTable* charmap,
	47	FT_ULong char_code );
	48	static FT_UInt code_to_index2( TT_CMapTable* charmap,
	49	FT_ULong char_code );
	50	static FT_UInt code_to_index4( TT_CMapTable* charmap,
	51	FT_ULong char_code );
	52	static FT_UInt code_to_index6( TT_CMapTable* charmap,
	53	FT_ULong char_code );
	54
	55
	56	/*************************************************************************/
	57	/* */
	58	/* <Function> */
	59	/* TT_CharMap_Load */
	60	/* */
	61	/* <Description> */
	62	/* Loads a given TrueType character map into memory. */
	63	/* */
	64	/* <Input> */
	65	/* face :: A handle to the parent face object. */
	66	/* stream :: A handle to the current stream object. */
	67	/* */
	68	/* <InOut> */
	69	/* table :: A pointer to a cmap object. */
	70	/* */
	71	/* <Return> */
	72	/* FreeType error code. 0 means success. */
	73	/* */
	74	/* <Note> */
	75	/* The function assumes that the stream is already in use (i.e., */
	76	/* opened). In case of error, all partially allocated tables are */
	77	/* released. */
	78	/* */
	79	LOCAL_FUNC
	80	FT_Error TT_CharMap_Load( TT_Face face,
	81	TT_CMapTable* cmap,
	82	FT_Stream stream )
	83	{
	84	FT_Error error;
	85	FT_Memory memory;
	86	FT_UShort num_SH, num_Seg, i;
	87
	88	FT_UShort u, l;
	89
	90	TT_CMap0* cmap0;
	91	TT_CMap2* cmap2;
	92	TT_CMap4* cmap4;
	93	TT_CMap6* cmap6;
	94
	95	TT_CMap2SubHeader* cmap2sub;
	96	TT_CMap4Segment* segments;
	97
	98
	99	if ( cmap->loaded )
	100	return TT_Err_Ok;
	101
	102	memory = stream->memory;
	103
	104	if ( FILE_Seek( cmap->offset ) )
	105	return error;
	106
	107	switch ( cmap->format )
	108	{
	109	case 0:
	110	cmap0 = &cmap->c.cmap0;
	111
	112	if ( ALLOC( cmap0->glyphIdArray, 256L ) \|\|
	113	FILE_Read( cmap0->glyphIdArray, 256L ) )
	114	goto Fail;
	115
	116	cmap->get_index = code_to_index0;
	117	break;
	118
	119	case 2:
	120	num_SH = 0;
	121	cmap2 = &cmap->c.cmap2;
	122
	123	/* allocate subheader keys */
	124
	125	if ( ALLOC_ARRAY( cmap2->subHeaderKeys, 256, FT_UShort ) \|\|
	126	ACCESS_Frame( 512L ) )
	127	goto Fail;
	128
	129	for ( i = 0; i < 256; i++ )
	130	{
	131	u = GET_UShort() / 8;
	132	cmap2->subHeaderKeys[i] = u;
	133
	134	if ( num_SH < u )
	135	num_SH = u;
	136	}
	137
	138	FORGET_Frame();
	139
	140	/* load subheaders */
	141
	142	cmap2->numGlyphId = l =
	143	( ( cmap->length - 2L * ( 256 + 3 ) - num_SH * 8L ) & 0xFFFF ) / 2;
	144
	145	if ( ALLOC_ARRAY( cmap2->subHeaders,
	146	num_SH + 1,
	147	TT_CMap2SubHeader ) \|\|
	148	ACCESS_Frame( ( num_SH + 1 ) * 8L ) )
	149	goto Fail;
	150
	151	cmap2sub = cmap2->subHeaders;
	152
	153	for ( i = 0; i <= num_SH; i++ )
	154	{
	155	cmap2sub->firstCode = GET_UShort();
	156	cmap2sub->entryCount = GET_UShort();
	157	cmap2sub->idDelta = GET_Short();
	158	/* we apply the location offset immediately */
	159	cmap2sub->idRangeOffset = GET_UShort() - ( num_SH - i ) * 8 - 2;
	160
	161	cmap2sub++;
	162	}
	163
	164	FORGET_Frame();
	165
	166	/* load glyph IDs */
	167
	168	if ( ALLOC_ARRAY( cmap2->glyphIdArray, l, FT_UShort ) \|\|
	169	ACCESS_Frame( l * 2L ) )
	170	goto Fail;
	171
	172	for ( i = 0; i < l; i++ )
	173	cmap2->glyphIdArray[i] = GET_UShort();
	174
	175	FORGET_Frame();
	176
	177	cmap->get_index = code_to_index2;
	178	break;
	179
	180	case 4:
	181	cmap4 = &cmap->c.cmap4;
	182
	183	/* load header */
	184
	185	if ( ACCESS_Frame( 8L ) )
	186	goto Fail;
	187
	188	cmap4->segCountX2 = GET_UShort();
	189	cmap4->searchRange = GET_UShort();
	190	cmap4->entrySelector = GET_UShort();
	191	cmap4->rangeShift = GET_UShort();
	192
	193	num_Seg = cmap4->segCountX2 / 2;
	194
	195	FORGET_Frame();
	196
	197	/* load segments */
	198
	199	if ( ALLOC_ARRAY( cmap4->segments,
	200	num_Seg,
	201	TT_CMap4Segment ) \|\|
	202	ACCESS_Frame( ( num_Seg * 4 + 1 ) * 2L ) )
	203	goto Fail;
	204
	205	segments = cmap4->segments;
	206
	207	for ( i = 0; i < num_Seg; i++ )
	208	segments[i].endCount = GET_UShort();
	209
	210	(void)GET_UShort();
	211
	212	for ( i = 0; i < num_Seg; i++ )
	213	segments[i].startCount = GET_UShort();
	214
	215	for ( i = 0; i < num_Seg; i++ )
	216	segments[i].idDelta = GET_Short();
	217
	218	for ( i = 0; i < num_Seg; i++ )
	219	segments[i].idRangeOffset = GET_UShort();
	220
	221	FORGET_Frame();
	222
	223	cmap4->numGlyphId = l =
	224	( ( cmap->length - ( 16L + 8L * num_Seg ) ) & 0xFFFF ) / 2;
	225
	226	/* load IDs */
	227
	228	if ( ALLOC_ARRAY( cmap4->glyphIdArray, l, FT_UShort ) \|\|
	229	ACCESS_Frame( l * 2L ) )
	230	goto Fail;
	231
	232	for ( i = 0; i < l; i++ )
	233	cmap4->glyphIdArray[i] = GET_UShort();
	234
	235	FORGET_Frame();
	236
	237	cmap->get_index = code_to_index4;
	238
	239	cmap4->last_segment = cmap4->segments;
	240	break;
	241
	242	case 6:
	243	cmap6 = &cmap->c.cmap6;
	244
	245	if ( ACCESS_Frame( 4L ) )
	246	goto Fail;
	247
	248	cmap6->firstCode = GET_UShort();
	249	cmap6->entryCount = GET_UShort();
	250
	251	FORGET_Frame();
	252
	253	l = cmap6->entryCount;
	254
	255	if ( ALLOC_ARRAY( cmap6->glyphIdArray,
	256	cmap6->entryCount,
	257	FT_Short ) \|\|
	258	ACCESS_Frame( l * 2L ) )
	259	goto Fail;
	260
	261	for ( i = 0; i < l; i++ )
	262	cmap6->glyphIdArray[i] = GET_UShort();
	263
	264	FORGET_Frame();
	265	cmap->get_index = code_to_index6;
	266	break;
	267
	268	default: /* corrupt character mapping table */
	269	return TT_Err_Invalid_CharMap_Format;
	270
	271	}
	272
	273	return TT_Err_Ok;
	274
	275	Fail:
	276	TT_CharMap_Free( face, cmap );
	277	return error;
	278	}
	279
	280
	281	/*************************************************************************/
	282	/* */
	283	/* <Function> */
	284	/* TT_CharMap_Free */
	285	/* */
	286	/* <Description> */
	287	/* Destroys a character mapping table. */
	288	/* */
	289	/* <Input> */
	290	/* face :: A handle to the parent face object. */
	291	/* cmap :: A handle to a cmap object. */
	292	/* */
	293	/* <Return> */
	294	/* FreeType error code. 0 means success. */
	295	/* */
	296	LOCAL_FUNC
	297	FT_Error TT_CharMap_Free( TT_Face face,
	298	TT_CMapTable* cmap )
	299	{
	300	FT_Memory memory;
	301
	302
	303	if ( !cmap )
	304	return TT_Err_Ok;
	305
	306	memory = face->root.driver->root.memory;
	307
	308	switch ( cmap->format )
	309	{
	310	case 0:
	311	FREE( cmap->c.cmap0.glyphIdArray );
	312	break;
	313
	314	case 2:
	315	FREE( cmap->c.cmap2.subHeaderKeys );
	316	FREE( cmap->c.cmap2.subHeaders );
	317	FREE( cmap->c.cmap2.glyphIdArray );
	318	break;
	319
	320	case 4:
	321	FREE( cmap->c.cmap4.segments );
	322	FREE( cmap->c.cmap4.glyphIdArray );
	323	cmap->c.cmap4.segCountX2 = 0;
	324	break;
	325
	326	case 6:
	327	FREE( cmap->c.cmap6.glyphIdArray );
	328	cmap->c.cmap6.entryCount = 0;
	329	break;
	330
	331	default:
	332	/* invalid table format, do nothing */
	333	;
	334	}
	335
	336	cmap->loaded = FALSE;
	337	return TT_Err_Ok;
	338	}
	339
	340
	341	/*************************************************************************/
	342	/* */
	343	/* <Function> */
	344	/* code_to_index0 */
	345	/* */
	346	/* <Description> */
	347	/* Converts the character code into a glyph index. Uses format 0. */
	348	/* `charCode' must be in the range 0x00-0xFF (otherwise 0 is */
	349	/* returned). */
	350	/* */
	351	/* <Input> */
	352	/* charCode :: The wanted character code. */
	353	/* cmap0 :: A pointer to a cmap table in format 0. */
	354	/* */
	355	/* <Return> */
	356	/* Glyph index into the glyphs array. 0 if the glyph does not exist. */
	357	/* */
	358	static
	359	FT_UInt code_to_index0( TT_CMapTable* cmap,
	360	FT_ULong charCode )
	361	{
	362	TT_CMap0* cmap0 = &cmap->c.cmap0;
	363
	364
	365	return ( charCode <= 0xFF ? cmap0->glyphIdArray[charCode] : 0 );
	366	}
	367
	368
	369	/*************************************************************************/
	370	/* */
	371	/* <Function> */
	372	/* code_to_index2 */
	373	/* */
	374	/* <Description> */
	375	/* Converts the character code into a glyph index. Uses format 2. */
	376	/* */
	377	/* <Input> */
	378	/* charCode :: The wanted character code. */
	379	/* cmap2 :: A pointer to a cmap table in format 2. */
	380	/* */
	381	/* <Return> */
	382	/* Glyph index into the glyphs array. 0 if the glyph does not exist. */
	383	/* */
	384	static
	385	FT_UInt code_to_index2( TT_CMapTable* cmap,
	386	FT_ULong charCode )
	387	{
	388	FT_UInt result, index1, offset;
	389	FT_UInt char_lo;
	390	FT_ULong char_hi;
	391	TT_CMap2SubHeader* sh2;
	392	TT_CMap2* cmap2;
	393
	394
	395	cmap2 = &cmap->c.cmap2;
	396	result = 0;
	397	char_lo = (FT_UInt)( charCode & 0xFF );
	398	char_hi = charCode >> 8;
	399
	400	if ( char_hi == 0 )
	401	{
	402	/* an 8-bit character code -- we use the subHeader 0 in this case */
	403	/* to test whether the character code is in the charmap */
	404	if ( cmap2->subHeaderKeys[char_lo] == 0 )
	405	result = cmap2->glyphIdArray[char_lo];
	406	}
	407	else
	408	{
	409	/* a 16-bit character code */
	410	index1 = cmap2->subHeaderKeys[char_hi & 0xFF];
	411	if ( index1 )
	412	{
	413	sh2 = cmap2->subHeaders + index1;
	414	char_lo -= sh2->firstCode;
	415
	416	if ( char_lo < sh2->entryCount )
	417	{
	418	offset = sh2->idRangeOffset / 2 + char_lo;
	419	if ( offset < cmap2->numGlyphId )
	420	{
	421	result = cmap2->glyphIdArray[offset];
	422	if ( result )
	423	result = ( result + sh2->idDelta ) & 0xFFFF;
	424	}
	425	}
	426	}
	427	}
	428
	429	return result;
	430	}
	431
	432
	433	/*************************************************************************/
	434	/* */
	435	/* <Function> */
	436	/* code_to_index4 */
	437	/* */
	438	/* <Description> */
	439	/* Converts the character code into a glyph index. Uses format 4. */
	440	/* */
	441	/* <Input> */
	442	/* charCode :: The wanted character code. */
	443	/* cmap4 :: A pointer to a cmap table in format 4. */
	444	/* */
	445	/* <Return> */
	446	/* Glyph index into the glyphs array. 0 if the glyph does not exist. */
	447	/* */
	448	static
	449	FT_UInt code_to_index4( TT_CMapTable* cmap,
	450	FT_ULong charCode )
	451	{
	452	FT_UInt result, index1, segCount;
	453	TT_CMap4* cmap4;
	454	TT_CMap4Segment seg4, limit;
	455
	456
	457	cmap4 = &cmap->c.cmap4;
	458	result = 0;
	459	segCount = cmap4->segCountX2 / 2;
	460	seg4 = cmap4->segments;
	461	limit = seg4 + segCount;
	462
	463	/* check against the last segment */
	464	seg4 = cmap4->last_segment;
	465
	466	/* the following is equivalent to performing two tests, as in */
	467	/* */
	468	/* if ( charCode >= seg4->startCount && charCode <= seg4->endCount ) */
	469	/* */
	470	/* Yes, that's a bit strange, but it's faster, and the idea behind */
	471	/* the cache is to significantly speed up charcode to glyph index */
	472	/* conversion. */
	473
	474	if ( (FT_ULong)(charCode - seg4->startCount) <
	475	(FT_ULong)(seg4->endCount - seg4->startCount) )
	476	goto Found;
	477
	478	for ( seg4 = cmap4->segments; seg4 < limit; seg4++ )
	479	{
	480	/* the ranges are sorted in increasing order. If we are out of */
	481	/* the range here, the char code isn't in the charmap, so exit. */
	482
	483	if ( charCode > seg4->endCount )
	484	continue;
	485
	486	if ( charCode >= seg4->startCount )
	487	goto Found;
	488	}
	489	return 0;
	490
	491	Found:
	492	cmap4->last_segment = seg4;
	493
	494	/* if the idRangeOffset is 0, we can compute the glyph index */
	495	/* directly */
	496
	497	if ( seg4->idRangeOffset == 0 )
	498	result = ( charCode + seg4->idDelta ) & 0xFFFF;
	499	else
	500	{
	501	/* otherwise, we must use the glyphIdArray to do it */
	502	index1 = seg4->idRangeOffset / 2
	503	+ ( charCode - seg4->startCount )
	504	+ ( seg4 - cmap4->segments )
	505	- segCount;
	506
	507	if ( index1 < cmap4->numGlyphId &&
	508	cmap4->glyphIdArray[index1] != 0 )
	509	result = ( cmap4->glyphIdArray[index1] + seg4->idDelta ) & 0xFFFF;
	510	}
	511
	512	return result;
	513	}
	514
	515
	516	/*************************************************************************/
	517	/* */
	518	/* <Function> */
	519	/* code_to_index6 */
	520	/* */
	521	/* <Description> */
	522	/* Converts the character code into a glyph index. Uses format 6. */
	523	/* */
	524	/* <Input> */
	525	/* charCode :: The wanted character code. */
	526	/* cmap6 :: A pointer to a cmap table in format 6. */
	527	/* */
	528	/* <Return> */
	529	/* Glyph index into the glyphs array. 0 if the glyph does not exist. */
	530	/* */
	531	static
	532	FT_UInt code_to_index6( TT_CMapTable* cmap,
	533	FT_ULong charCode )
	534	{
	535	TT_CMap6* cmap6;
	536	FT_UInt result = 0;
	537
	538
	539	cmap6 = &cmap->c.cmap6;
	540	result = 0;
	541	charCode -= cmap6->firstCode;
	542
	543	if ( charCode < cmap6->entryCount )
	544	result = cmap6->glyphIdArray[charCode];
	545
	546	return result;
	547	}
	548
	549
	550	/* END */