自学教程：C++ FT_STREAM_SKIP函数代码示例

  static FT_Error  pcf_seek_to_table_type( FT_Stream  stream,                          PCF_Table  tables,                          FT_Int     ntables,                          FT_ULong   type,                          FT_ULong  *aformat,                          FT_ULong  *asize )  {    FT_Error  error = 0;    FT_Int    i;    for ( i = 0; i < ntables; i++ )      if ( tables[i].type == type )      {        if ( stream->pos > tables[i].offset )          return PCF_Err_Invalid_Stream_Skip;        if ( FT_STREAM_SKIP( tables[i].offset - stream->pos ) )          return PCF_Err_Invalid_Stream_Skip;        *asize   = tables[i].size;  /* unused - to be removed */        *aformat = tables[i].format;        return PCF_Err_Ok;      }    return PCF_Err_Invalid_File_Format;  }

  static FT_Error  load_post_names( TT_Face  face )  {    FT_Stream  stream;    FT_Error   error;    FT_Fixed   format;    /* get a stream for the face's resource */    stream = face->root.stream;    /* seek to the beginning of the PS names table */    error = face->goto_table( face, TTAG_post, stream, 0 );    if ( error )      goto Exit;    format = face->postscript.FormatType;    /* go to beginning of subtable */    if ( FT_STREAM_SKIP( 32 ) )      goto Exit;    /* now read postscript table */    if ( format == 0x00020000L )      error = load_format_20( face, stream );    else if ( format == 0x00028000L )      error = load_format_25( face, stream );    else      error = SFNT_Err_Invalid_File_Format;    face->postscript_names.loaded = 1;  Exit:    return error;  }

  static FT_Error  pcf_seek_to_table_type( FT_Stream  stream,                          PCF_Table  tables,                          FT_Int     ntables,                          FT_ULong   type,                          FT_ULong  *aformat,                          FT_ULong  *asize )  {    FT_Error  error = PCF_Err_Invalid_File_Format;    FT_Int    i;    for ( i = 0; i < ntables; i++ )      if ( tables[i].type == type )      {        if ( stream->pos > tables[i].offset )        {          error = PCF_Err_Invalid_Stream_Skip;          goto Fail;        }        if ( FT_STREAM_SKIP( tables[i].offset - stream->pos ) )        {          error = PCF_Err_Invalid_Stream_Skip;          goto Fail;        }        *asize   = tables[i].size;        *aformat = tables[i].format;        return PCF_Err_Ok;      }  Fail:    *asize = 0;    return error;  }

  static FT_Error  pcf_seek_to_table_type( FT_Stream  stream,                          PCF_Table  tables,                          FT_ULong   ntables, /* same as PCF_Toc->count */                          FT_ULong   type,                          FT_ULong  *aformat,                          FT_ULong  *asize )  {    FT_Error  error = FT_ERR( Invalid_File_Format );    FT_ULong  i;    for ( i = 0; i < ntables; i++ )      if ( tables[i].type == type )      {        if ( stream->pos > tables[i].offset )        {          error = FT_THROW( Invalid_Stream_Skip );          goto Fail;        }        if ( FT_STREAM_SKIP( tables[i].offset - stream->pos ) )        {          error = FT_THROW( Invalid_Stream_Skip );          goto Fail;        }        *asize   = tables[i].size;        *aformat = tables[i].format;        return FT_Err_Ok;      }  Fail:    *asize = 0;    return error;  }

  pfr_log_font_load( PFR_LogFont  log_font,                     FT_Stream    stream,                     FT_UInt      idx,                     FT_UInt32    section_offset,                     FT_Bool      size_increment )  {    FT_UInt    num_log_fonts;    FT_UInt    flags;    FT_UInt32  offset;    FT_UInt32  size;    FT_Error   error;    if ( FT_STREAM_SEEK( section_offset ) ||         FT_READ_USHORT( num_log_fonts )  )      goto Exit;    if ( idx >= num_log_fonts )      return FT_THROW( Invalid_Argument );    if ( FT_STREAM_SKIP( idx * 5 ) ||         FT_READ_USHORT( size )    ||         FT_READ_UOFF3 ( offset )  )      goto Exit;    /* save logical font size and offset */    log_font->size   = size;    log_font->offset = offset;    /* now, check the rest of the table before loading it */    {      FT_Byte*  p;      FT_Byte*  limit;      FT_UInt   local;      if ( FT_STREAM_SEEK( offset ) ||           FT_FRAME_ENTER( size )   )        goto Exit;      p     = stream->cursor;      limit = p + size;      PFR_CHECK( 13 );      log_font->matrix[0] = PFR_NEXT_LONG( p );      log_font->matrix[1] = PFR_NEXT_LONG( p );      log_font->matrix[2] = PFR_NEXT_LONG( p );      log_font->matrix[3] = PFR_NEXT_LONG( p );      flags = PFR_NEXT_BYTE( p );      local = 0;      if ( flags & PFR_LOG_STROKE )      {        local++;        if ( flags & PFR_LOG_2BYTE_STROKE )          local++;        if ( ( flags & PFR_LINE_JOIN_MASK ) == PFR_LINE_JOIN_MITER )          local += 3;      }      if ( flags & PFR_LOG_BOLD )      {        local++;        if ( flags & PFR_LOG_2BYTE_BOLD )          local++;      }      PFR_CHECK( local );      if ( flags & PFR_LOG_STROKE )      {        log_font->stroke_thickness = ( flags & PFR_LOG_2BYTE_STROKE )                                     ? PFR_NEXT_SHORT( p )                                     : PFR_NEXT_BYTE( p );        if ( ( flags & PFR_LINE_JOIN_MASK ) == PFR_LINE_JOIN_MITER )          log_font->miter_limit = PFR_NEXT_LONG( p );      }      if ( flags & PFR_LOG_BOLD )      {        log_font->bold_thickness = ( flags & PFR_LOG_2BYTE_BOLD )                                   ? PFR_NEXT_SHORT( p )                                   : PFR_NEXT_BYTE( p );      }      if ( flags & PFR_LOG_EXTRA_ITEMS )      {        error = pfr_extra_items_skip( &p, limit );        if ( error )          goto Fail;      }      PFR_CHECK( 5 );      log_font->phys_size   = PFR_NEXT_USHORT( p );      log_font->phys_offset = PFR_NEXT_ULONG( p );      if ( size_increment )      {//.........这里部分代码省略.........

  static FT_Error  cff_index_init( CFF_Index  idx,                  FT_Stream  stream,                  FT_Bool    load )  {    FT_Error   error;    FT_Memory  memory = stream->memory;    FT_UShort  count;    FT_MEM_ZERO( idx, sizeof ( *idx ) );    idx->stream = stream;    idx->start  = FT_STREAM_POS();    if ( !FT_READ_USHORT( count ) &&         count > 0                )    {      FT_Byte   offsize;      FT_ULong  size;      /* there is at least one element; read the offset size,           */      /* then access the offset table to compute the index's total size */      if ( FT_READ_BYTE( offsize ) )        goto Exit;      if ( offsize < 1 || offsize > 4 )      {        error = FT_Err_Invalid_Table;        goto Exit;      }      idx->count    = count;      idx->off_size = offsize;      size          = (FT_ULong)( count + 1 ) * offsize;      idx->data_offset = idx->start + 3 + size;      if ( FT_STREAM_SKIP( size - offsize ) )        goto Exit;      size = cff_index_read_offset( idx, &error );      if ( error )        goto Exit;      if ( size == 0 )      {        error = CFF_Err_Invalid_Table;        goto Exit;      }      idx->data_size = --size;      if ( load )      {        /* load the data */        if ( FT_FRAME_EXTRACT( size, idx->bytes ) )          goto Exit;      }      else      {        /* skip the data */        if ( FT_STREAM_SKIP( size ) )          goto Exit;      }    }  Exit:    if ( error )      FT_FREE( idx->offsets );    return error;  }

  cff_font_load( FT_Stream  stream,                 FT_Int     face_index,                 CFF_Font   font,                 FT_Bool    pure_cff )  {    static const FT_Frame_Field  cff_header_fields[] =    {#undef  FT_STRUCTURE#define FT_STRUCTURE  CFF_FontRec      FT_FRAME_START( 4 ),        FT_FRAME_BYTE( version_major ),        FT_FRAME_BYTE( version_minor ),        FT_FRAME_BYTE( header_size ),        FT_FRAME_BYTE( absolute_offsize ),      FT_FRAME_END    };    FT_Error         error;    FT_Memory        memory = stream->memory;    FT_ULong         base_offset;    CFF_FontRecDict  dict;    FT_ZERO( font );    font->stream = stream;    font->memory = memory;    dict         = &font->top_font.font_dict;    base_offset  = FT_STREAM_POS();    /* read CFF font header */    if ( FT_STREAM_READ_FIELDS( cff_header_fields, font ) )      goto Exit;    /* check format */    if ( font->version_major   != 1 ||         font->header_size      < 4 ||         font->absolute_offsize > 4 )    {      FT_TRACE2(( "[not a CFF font header!]/n" ));      error = CFF_Err_Unknown_File_Format;      goto Exit;    }    /* skip the rest of the header */    if ( FT_STREAM_SKIP( font->header_size - 4 ) )      goto Exit;    /* read the name, top dict, string and global subrs index */    if ( FT_SET_ERROR( cff_index_init( &font->name_index,                                       stream, 0 ) )              ||         FT_SET_ERROR( cff_index_init( &font->font_dict_index,                                       stream, 0 ) )              ||         FT_SET_ERROR( cff_index_init( &font->string_index,                                       stream, 0 ) )              ||         FT_SET_ERROR( cff_index_init( &font->global_subrs_index,                                       stream, 1 ) )              )      goto Exit;    /* well, we don't really forget the `disabled' fonts... */    font->num_faces = font->name_index.count;    if ( face_index >= (FT_Int)font->num_faces )    {      FT_ERROR(( "cff_font_load: incorrect face index = %d/n",                 face_index ));      error = CFF_Err_Invalid_Argument;    }    /* in case of a font format check, simply exit now */    if ( face_index < 0 )      goto Exit;    /* now, parse the top-level font dictionary */    error = cff_subfont_load( &font->top_font,                              &font->font_dict_index,                              face_index,                              stream,                              base_offset );    if ( error )      goto Exit;    if ( FT_STREAM_SEEK( base_offset + dict->charstrings_offset ) )      goto Exit;    error = cff_index_init( &font->charstrings_index, stream, 0 );    if ( error )      goto Exit;    /* now, check for a CID font */    if ( dict->cid_registry != 0xFFFFU )    {      CFF_IndexRec  fd_index;      CFF_SubFont   sub;      FT_UInt       idx;      /* this is a CID-keyed font, we must now allocate a table of */      /* sub-fonts, then load each of them separately              */      if ( FT_STREAM_SEEK( base_offset + dict->cid_fd_array_offset ) )//.........这里部分代码省略.........

  T1_Get_Private_Dict( T1_Parser      parser,                       PSAux_Service  psaux )  {    FT_Stream  stream = parser->stream;    FT_Memory  memory = parser->root.memory;    FT_Error   error  = FT_Err_Ok;    FT_ULong   size;    if ( parser->in_pfb )    {      /* in the case of the PFB format, the private dictionary can be  */      /* made of several segments.  We thus first read the number of   */      /* segments to compute the total size of the private dictionary  */      /* then re-read them into memory.                                */      FT_Long    start_pos = FT_STREAM_POS();      FT_UShort  tag;      parser->private_len = 0;      for (;;)      {        error = read_pfb_tag( stream, &tag, &size );        if ( error )          goto Fail;        if ( tag != 0x8002U )          break;        parser->private_len += size;        if ( FT_STREAM_SKIP( size ) )          goto Fail;      }      /* Check that we have a private dictionary there */      /* and allocate private dictionary buffer        */      if ( parser->private_len == 0 )      {        FT_ERROR(( "T1_Get_Private_Dict:"                   " invalid private dictionary section/n" ));        error = FT_THROW( Invalid_File_Format );        goto Fail;      }      if ( FT_STREAM_SEEK( start_pos )                           ||           FT_ALLOC( parser->private_dict, parser->private_len ) )        goto Fail;      parser->private_len = 0;      for (;;)      {        error = read_pfb_tag( stream, &tag, &size );        if ( error || tag != 0x8002U )        {          error = FT_Err_Ok;          break;        }        if ( FT_STREAM_READ( parser->private_dict + parser->private_len,                             size ) )          goto Fail;        parser->private_len += size;      }    }    else    {      /* We have already `loaded' the whole PFA font file into memory; */      /* if this is a memory resource, allocate a new block to hold    */      /* the private dict.  Otherwise, simply overwrite into the base  */      /* dictionary block in the heap.                                 */      /* first of all, look at the `eexec' keyword */      FT_Byte*  cur   = parser->base_dict;      FT_Byte*  limit = cur + parser->base_len;      FT_Byte   c;    Again:      for (;;)      {        c = cur[0];        if ( c == 'e' && cur + 9 < limit )  /* 9 = 5 letters for `eexec' + */                                            /* whitespace + 4 chars        */        {          if ( cur[1] == 'e' &&               cur[2] == 'x' &&               cur[3] == 'e' &&               cur[4] == 'c' )            break;        }        cur++;        if ( cur >= limit )        {          FT_ERROR(( "T1_Get_Private_Dict:"                     " could not find `eexec' keyword/n" ));          error = FT_THROW( Invalid_File_Format );          goto Exit;        }//.........这里部分代码省略.........

  T1_New_Parser( T1_Parser      parser,                 FT_Stream      stream,                 FT_Memory      memory,                 PSAux_Service  psaux )  {    FT_Error   error;    FT_UShort  tag;    FT_ULong   size;    psaux->ps_parser_funcs->init( &parser->root, 0, 0, memory );    parser->stream       = stream;    parser->base_len     = 0;    parser->base_dict    = 0;    parser->private_len  = 0;    parser->private_dict = 0;    parser->in_pfb       = 0;    parser->in_memory    = 0;    parser->single_block = 0;    /* check the header format */    error = check_type1_format( stream, "%!PS-AdobeFont", 14 );    if ( error )    {      if ( FT_ERR_NEQ( error, Unknown_File_Format ) )        goto Exit;      error = check_type1_format( stream, "%!FontType", 10 );      if ( error )      {        FT_TRACE2(( "  not a Type 1 font/n" ));        goto Exit;      }    }    /******************************************************************/    /*                                                                */    /* Here a short summary of what is going on:                      */    /*                                                                */    /*   When creating a new Type 1 parser, we try to locate and load */    /*   the base dictionary if this is possible (i.e., for PFB       */    /*   files).  Otherwise, we load the whole font into memory.      */    /*                                                                */    /*   When `loading' the base dictionary, we only setup pointers   */    /*   in the case of a memory-based stream.  Otherwise, we         */    /*   allocate and load the base dictionary in it.                 */    /*                                                                */    /*   parser->in_pfb is set if we are in a binary (`.pfb') font.   */    /*   parser->in_memory is set if we have a memory stream.         */    /*                                                                */    /* try to compute the size of the base dictionary;     */    /* look for a Postscript binary file tag, i.e., 0x8001 */    if ( FT_STREAM_SEEK( 0L ) )      goto Exit;    error = read_pfb_tag( stream, &tag, &size );    if ( error )      goto Exit;    if ( tag != 0x8001U )    {      /* assume that this is a PFA file for now; an error will */      /* be produced later when more things are checked        */      if ( FT_STREAM_SEEK( 0L ) )        goto Exit;      size = stream->size;    }    else      parser->in_pfb = 1;    /* now, try to load `size' bytes of the `base' dictionary we */    /* found previously                                          */    /* if it is a memory-based resource, set up pointers */    if ( !stream->read )    {      parser->base_dict = (FT_Byte*)stream->base + stream->pos;      parser->base_len  = size;      parser->in_memory = 1;      /* check that the `size' field is valid */      if ( FT_STREAM_SKIP( size ) )        goto Exit;    }    else    {      /* read segment in memory -- this is clumsy, but so does the format */      if ( FT_ALLOC( parser->base_dict, size )       ||           FT_STREAM_READ( parser->base_dict, size ) )        goto Exit;      parser->base_len = size;    }    parser->root.base   = parser->base_dict;    parser->root.cursor = parser->base_dict;    parser->root.limit  = parser->root.cursor + parser->base_len;  Exit://.........这里部分代码省略.........

/* check and skip .gz header - we don't support `transparent' compression */static FT_Errorft_gzip_check_header( FT_Stream  stream ){    FT_Error  error;    FT_Byte   head[4];    if ( FT_STREAM_SEEK( 0 )       ||            FT_STREAM_READ( head, 4 ) )        goto Exit;    /* head[0] && head[1] are the magic numbers;    */    /* head[2] is the method, and head[3] the flags */    if ( head[0] != 0x1f              ||            head[1] != 0x8b              ||            head[2] != Z_DEFLATED        ||            (head[3] & FT_GZIP_RESERVED)  )    {        error = Gzip_Err_Invalid_File_Format;        goto Exit;    }    /* skip time, xflags and os code */    (void)FT_STREAM_SKIP( 6 );    /* skip the extra field */    if ( head[3] & FT_GZIP_EXTRA_FIELD )    {        FT_UInt  len;        if ( FT_READ_USHORT_LE( len ) ||                FT_STREAM_SKIP( len )    )            goto Exit;    }    /* skip original file name */    if ( head[3] & FT_GZIP_ORIG_NAME )        for (;;)        {            FT_UInt  c;            if ( FT_READ_BYTE( c ) )                goto Exit;            if ( c == 0 )                break;        }    /* skip .gz comment */    if ( head[3] & FT_GZIP_COMMENT )        for (;;)        {            FT_UInt  c;            if ( FT_READ_BYTE( c ) )                goto Exit;            if ( c == 0 )                break;        }    /* skip CRC */    if ( head[3] & FT_GZIP_HEAD_CRC )        if ( FT_STREAM_SKIP( 2 ) )            goto Exit;Exit:    return error;}

  t42_parser_init( T42_Parser     parser,                   FT_Stream      stream,                   FT_Memory      memory,                   PSAux_Service  psaux )  {    FT_Error  error = FT_Err_Ok;    FT_Long   size;    psaux->ps_parser_funcs->init( &parser->root, 0, 0, memory );    parser->stream    = stream;    parser->base_len  = 0;    parser->base_dict = 0;    parser->in_memory = 0;    /*******************************************************************/    /*                                                                 */    /* Here a short summary of what is going on:                       */    /*                                                                 */    /*   When creating a new Type 42 parser, we try to locate and load */    /*   the base dictionary, loading the whole font into memory.      */    /*                                                                 */    /*   When `loading' the base dictionary, we only set up pointers   */    /*   in the case of a memory-based stream.  Otherwise, we allocate */    /*   and load the base dictionary in it.                           */    /*                                                                 */    /*   parser->in_memory is set if we have a memory stream.          */    /*                                                                 */    if ( FT_STREAM_SEEK( 0L ) ||         FT_FRAME_ENTER( 17 ) )      goto Exit;    if ( ft_memcmp( stream->cursor, "%!PS-TrueTypeFont", 17 ) != 0 )    {      FT_TRACE2(( "  not a Type42 font/n" ));      error = FT_THROW( Unknown_File_Format );    }    FT_FRAME_EXIT();    if ( error || FT_STREAM_SEEK( 0 ) )      goto Exit;    size = stream->size;    /* now, try to load `size' bytes of the `base' dictionary we */    /* found previously                                          */    /* if it is a memory-based resource, set up pointers */    if ( !stream->read )    {      parser->base_dict = (FT_Byte*)stream->base + stream->pos;      parser->base_len  = size;      parser->in_memory = 1;      /* check that the `size' field is valid */      if ( FT_STREAM_SKIP( size ) )        goto Exit;    }    else    {      /* read segment in memory */      if ( FT_ALLOC( parser->base_dict, size )       ||           FT_STREAM_READ( parser->base_dict, size ) )        goto Exit;      parser->base_len = size;    }    parser->root.base   = parser->base_dict;    parser->root.cursor = parser->base_dict;    parser->root.limit  = parser->root.cursor + parser->base_len;  Exit:    if ( error && !parser->in_memory )      FT_FREE( parser->base_dict );    return error;  }

  static FT_Error  cff_new_index( CFF_Index  idx,                 FT_Stream  stream,                 FT_Bool    load )  {    FT_Error   error;    FT_Memory  memory = stream->memory;    FT_UShort  count;    FT_MEM_ZERO( idx, sizeof ( *idx ) );    idx->stream = stream;    if ( !FT_READ_USHORT( count ) &&         count > 0                )    {      FT_Byte*   p;      FT_Byte    offsize;      FT_ULong   data_size;      FT_ULong*  poff;      /* there is at least one element; read the offset size,           */      /* then access the offset table to compute the index's total size */      if ( FT_READ_BYTE( offsize ) )        goto Exit;      idx->stream   = stream;      idx->count    = count;      idx->off_size = offsize;      data_size     = (FT_ULong)( count + 1 ) * offsize;      if ( FT_NEW_ARRAY( idx->offsets, count + 1 ) ||           FT_FRAME_ENTER( data_size )             )        goto Exit;      poff = idx->offsets;      p    = (FT_Byte*)stream->cursor;      for ( ; (FT_Short)count >= 0; count-- )      {        poff[0] = cff_get_offset( p, offsize );        poff++;        p += offsize;      }      FT_FRAME_EXIT();      idx->data_offset = FT_STREAM_POS();      data_size        = poff[-1] - 1;      if ( load )      {        /* load the data */        if ( FT_FRAME_EXTRACT( data_size, idx->bytes ) )          goto Exit;      }      else      {        /* skip the data */        if ( FT_STREAM_SKIP( data_size ) )          goto Exit;      }    }  Exit:    if ( error )      FT_FREE( idx->offsets );    return error;  }

  static FT_Error  pcf_get_properties( FT_Stream  stream,                      PCF_Face   face )  {    PCF_ParseProperty  props      = 0;    PCF_Property       properties;    FT_UInt            nprops, i;    FT_ULong           format, size;    FT_Error           error;    FT_Memory          memory     = FT_FACE(face)->memory;    FT_ULong           string_size;    FT_String*         strings    = 0;    error = pcf_seek_to_table_type( stream,                                    face->toc.tables,                                    face->toc.count,                                    PCF_PROPERTIES,                                    &format,                                    &size );    if ( error )      goto Bail;    if ( FT_READ_ULONG_LE( format ) )      goto Bail;    FT_TRACE4(( "pcf_get_properties:/n" ));    FT_TRACE4(( "  format = %ld/n", format ));    if ( !PCF_FORMAT_MATCH( format, PCF_DEFAULT_FORMAT ) )      goto Bail;    if ( PCF_BYTE_ORDER( format ) == MSBFirst )      (void)FT_READ_ULONG( nprops );    else      (void)FT_READ_ULONG_LE( nprops );    if ( error )      goto Bail;    FT_TRACE4(( "  nprop = %d/n", nprops ));    /* rough estimate */    if ( nprops > size / PCF_PROPERTY_SIZE )    {      error = PCF_Err_Invalid_Table;      goto Bail;    }    face->nprops = nprops;    if ( FT_NEW_ARRAY( props, nprops ) )      goto Bail;    for ( i = 0; i < nprops; i++ )    {      if ( PCF_BYTE_ORDER( format ) == MSBFirst )      {        if ( FT_STREAM_READ_FIELDS( pcf_property_msb_header, props + i ) )          goto Bail;      }      else      {        if ( FT_STREAM_READ_FIELDS( pcf_property_header, props + i ) )          goto Bail;      }    }    /* pad the property array                                            */    /*                                                                   */    /* clever here - nprops is the same as the number of odd-units read, */    /* as only isStringProp are odd length   (Keith Packard)             */    /*                                                                   */    if ( nprops & 3 )    {      i = 4 - ( nprops & 3 );      if ( FT_STREAM_SKIP( i ) )      {        error = PCF_Err_Invalid_Stream_Skip;        goto Bail;      }    }    if ( PCF_BYTE_ORDER( format ) == MSBFirst )      (void)FT_READ_ULONG( string_size );    else      (void)FT_READ_ULONG_LE( string_size );    if ( error )      goto Bail;    FT_TRACE4(( "  string_size = %ld/n", string_size ));    /* rough estimate */    if ( string_size > size - nprops * PCF_PROPERTY_SIZE )    {      error = PCF_Err_Invalid_Table;      goto Bail;    }    if ( FT_NEW_ARRAY( strings, string_size ) )//.........这里部分代码省略.........

  static FT_Bool  _tt_face_check_patents( FT_Face  face )  {    FT_Stream  stream = face->stream;    FT_UInt    gindex;    FT_Error   error;    FT_Bool    result;    FT_Service_TTGlyf  service;    result = _tt_check_patents_in_table( face, TTAG_fpgm );    if ( result )      goto Exit;    result = _tt_check_patents_in_table( face, TTAG_prep );    if ( result )      goto Exit;    FT_FACE_FIND_SERVICE( face, service, TT_GLYF );    if ( service == NULL )      goto Exit;    for ( gindex = 0; gindex < (FT_UInt)face->num_glyphs; gindex++ )    {      FT_ULong  offset, num_ins, size;      FT_Int    num_contours;      offset = service->get_location( face, gindex, &size );      if ( size == 0 )        continue;      if ( FT_STREAM_SEEK( offset )      ||           FT_READ_SHORT( num_contours ) )        continue;      if ( num_contours >= 0 )  /* simple glyph */      {        if ( FT_STREAM_SKIP( 8 + num_contours * 2 ) )          continue;      }      else  /* compound glyph */      {        FT_Bool  has_instr = 0;        if ( FT_STREAM_SKIP( 8 ) )          continue;        /* now read each component */        for (;;)        {          FT_UInt  flags, toskip;          if( FT_READ_USHORT( flags ) )            break;          toskip = 2 + 1 + 1;          if ( ( flags & ( 1 << 0 ) ) != 0 )       /* ARGS_ARE_WORDS */            toskip += 2;          if ( ( flags & ( 1 << 3 ) ) != 0 )       /* WE_HAVE_A_SCALE */            toskip += 2;          else if ( ( flags & ( 1 << 6 ) ) != 0 )  /* WE_HAVE_X_Y_SCALE */            toskip += 4;          else if ( ( flags & ( 1 << 7 ) ) != 0 )  /* WE_HAVE_A_2x2 */            toskip += 8;          if ( ( flags & ( 1 << 8 ) ) != 0 )       /* WE_HAVE_INSTRUCTIONS */            has_instr = 1;          if ( FT_STREAM_SKIP( toskip ) )            goto NextGlyph;          if ( ( flags & ( 1 << 5 ) ) == 0 )       /* MORE_COMPONENTS */            break;        }        if ( !has_instr )          goto NextGlyph;      }      if ( FT_READ_USHORT( num_ins ) )        continue;      result = _tt_check_patents_in_range( stream, num_ins );      if ( result )        goto Exit;    NextGlyph:      ;    }  Exit:    return result;  }

  T1_Get_Private_Dict( T1_Parser      parser,                       PSAux_Service  psaux )  {    FT_Stream  stream = parser->stream;    FT_Memory  memory = parser->root.memory;    FT_Error   error  = 0;    FT_Long    size;    if ( parser->in_pfb )    {      /* in the case of the PFB format, the private dictionary can be  */      /* made of several segments.  We thus first read the number of   */      /* segments to compute the total size of the private dictionary  */      /* then re-read them into memory.                                */      FT_Long    start_pos = FT_STREAM_POS();      FT_UShort  tag;      parser->private_len = 0;      for (;;)      {        error = read_pfb_tag( stream, &tag, &size );        if ( error )          goto Fail;        if ( tag != 0x8002U )          break;        parser->private_len += size;        if ( FT_STREAM_SKIP( size ) )          goto Fail;      }      /* Check that we have a private dictionary there */      /* and allocate private dictionary buffer        */      if ( parser->private_len == 0 )      {        FT_ERROR(( "T1_Get_Private_Dict:" ));        FT_ERROR(( " invalid private dictionary section/n" ));        error = T1_Err_Invalid_File_Format;        goto Fail;      }      if ( FT_STREAM_SEEK( start_pos )                             ||           FT_ALLOC( parser->private_dict, parser->private_len ) )        goto Fail;      parser->private_len = 0;      for (;;)      {        error = read_pfb_tag( stream, &tag, &size );        if ( error || tag != 0x8002U )        {          error = T1_Err_Ok;          break;        }        if ( FT_STREAM_READ( parser->private_dict + parser->private_len, size ) )          goto Fail;        parser->private_len += size;      }    }    else    {      /* we have already `loaded' the whole PFA font file into memory; */      /* if this is a memory resource, allocate a new block to hold    */      /* the private dict. Otherwise, simply overwrite into the base   */      /* dictionary block in the heap.                                 */      /* first of all, look at the `eexec' keyword */      FT_Byte*  cur   = parser->base_dict;      FT_Byte*  limit = cur + parser->base_len;      FT_Byte   c;      for (;;)      {        c = cur[0];        if ( c == 'e' && cur + 9 < limit )  /* 9 = 5 letters for `eexec' + */                                            /* newline + 4 chars           */        {          if ( cur[1] == 'e' && cur[2] == 'x' &&               cur[3] == 'e' && cur[4] == 'c' )          {            cur += 6; /* we skip the newling after the `eexec' */            /* XXX: Some fonts use DOS-linefeeds, i.e. /r/n; we need to */            /*      skip the extra /n if we find it                     */            if ( cur[0] == '/n' )              cur++;            break;          }        }        cur++;        if ( cur >= limit )        {//.........这里部分代码省略.........

//.........这里部分代码省略.........      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 ) )