ref: d0ab3a0dd8f6355b3603d0fb04043a9ae867639b
dir: /libfreetype/ttcmap.c/
/***************************************************************************/ /* */ /* ttcmap.c */ /* */ /* TrueType character mapping table (cmap) support (body). */ /* */ /* Copyright 1996-2001, 2002 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* */ /* This file is part of the FreeType project, and may only be used, */ /* modified, and distributed under the terms of the FreeType project */ /* license, LICENSE.TXT. By continuing to use, modify, or distribute */ /* this file you indicate that you have read the license and */ /* understand and accept it fully. */ /* */ /***************************************************************************/ #include <ft2build.h> #include FT_INTERNAL_DEBUG_H #include "ttload.h" #include "ttcmap.h" #include "sferrors.h" /*************************************************************************/ /* */ /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ /* messages during execution. */ /* */ #undef FT_COMPONENT #define FT_COMPONENT trace_ttcmap FT_CALLBACK_DEF( FT_UInt ) code_to_index0( TT_CMapTable charmap, FT_ULong char_code ); FT_CALLBACK_DEF( FT_ULong ) code_to_next0( TT_CMapTable charmap, FT_ULong char_code ); FT_CALLBACK_DEF( FT_UInt ) code_to_index2( TT_CMapTable charmap, FT_ULong char_code ); FT_CALLBACK_DEF( FT_ULong ) code_to_next2( TT_CMapTable charmap, FT_ULong char_code ); FT_CALLBACK_DEF( FT_UInt ) code_to_index4( TT_CMapTable charmap, FT_ULong char_code ); FT_CALLBACK_DEF( FT_ULong ) code_to_next4( TT_CMapTable charmap, FT_ULong char_code ); FT_CALLBACK_DEF( FT_UInt ) code_to_index6( TT_CMapTable charmap, FT_ULong char_code ); FT_CALLBACK_DEF( FT_ULong ) code_to_next6( TT_CMapTable charmap, FT_ULong char_code ); FT_CALLBACK_DEF( FT_UInt ) code_to_index8_12( TT_CMapTable charmap, FT_ULong char_code ); FT_CALLBACK_DEF( FT_ULong ) code_to_next8_12( TT_CMapTable charmap, FT_ULong char_code ); FT_CALLBACK_DEF( FT_UInt ) code_to_index10( TT_CMapTable charmap, FT_ULong char_code ); FT_CALLBACK_DEF( FT_ULong ) code_to_next10( TT_CMapTable charmap, FT_ULong char_code ); /*************************************************************************/ /* */ /* <Function> */ /* tt_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 */