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

  cf2_getStdHW( CFF_Decoder*  decoder )  {    FT_ASSERT( decoder && decoder->current_subfont );    return cf2_intToFixed(             decoder->current_subfont->private_dict.standard_width );  }

  /* get scaling and hint flag from GlyphSlot */  static void  cf2_getScaleAndHintFlag( CFF_Decoder*  decoder,                           CF2_Fixed*    x_scale,                           CF2_Fixed*    y_scale,                           FT_Bool*      hinted,                           FT_Bool*      scaled )  {    FT_ASSERT( decoder && decoder->builder.glyph );    /* note: FreeType scale includes a factor of 64 */    *hinted = decoder->builder.glyph->hint;    *scaled = decoder->builder.glyph->scaled;    if ( *hinted )    {      *x_scale = FT_DivFix( decoder->builder.glyph->x_scale,                            cf2_intToFixed( 64 ) );      *y_scale = FT_DivFix( decoder->builder.glyph->y_scale,                            cf2_intToFixed( 64 ) );    }    else    {      /* for unhinted outlines, `cff_slot_load' does the scaling, */      /* thus render at `unity' scale                             */      *x_scale = 0x0400;   /* 1/64 as 16.16 */      *y_scale = 0x0400;    }  }

static int32_t _ft_keydetector_safa_init(struct ft_electrode_data *electrode){  FT_ASSERT(electrode->rom->keydetector_interface == &ft_keydetector_safa_interface);  const struct ft_keydetector_safa *rom = electrode->rom->keydetector_params.safa;  if(_ft_keydetector_safa_rom_check(rom) != FT_SUCCESS)  {    return FT_FAILURE;  }  electrode->keydetector_data.safa = (struct ft_keydetector_safa_data *) _ft_mem_alloc(sizeof(struct ft_keydetector_safa_data));  if(electrode->keydetector_data.safa == NULL)  {      return FT_OUT_OF_MEMORY;  }  electrode->keydetector_data.safa->recovery_cnt = 0;    electrode->keydetector_data.safa->base_avrg_init = rom->base_avrg;  electrode->keydetector_data.safa->noise_avrg_init = rom->base_avrg;  electrode->keydetector_data.safa->noise_avrg_init.n2_order += 2;  electrode->keydetector_data.safa->predicted_signal_avrg_init = rom->base_avrg;  if(electrode->keydetector_data.safa->predicted_signal_avrg_init.n2_order > 2)    electrode->keydetector_data.safa->predicted_signal_avrg_init.n2_order -= 2;    _ft_electrode_set_status(electrode, FT_ELECTRODE_STATE_INIT);    return FT_SUCCESS;}

  T1_Face_Done( T1_Face  face )  {    FT_Memory  memory;    T1_Font    type1;    if ( !face )      return;    memory = face->root.memory;    type1  = &face->type1;#ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT    /* release multiple masters information */    FT_ASSERT( ( face->len_buildchar == 0 ) == ( face->buildchar == NULL ) );    if ( face->buildchar )    {      FT_FREE( face->buildchar );      face->buildchar     = NULL;      face->len_buildchar = 0;    }    T1_Done_Blend( face );    face->blend = 0;#endif    /* release font info strings */    {      PS_FontInfo  info = &type1->font_info;      FT_FREE( info->version );      FT_FREE( info->notice );      FT_FREE( info->full_name );      FT_FREE( info->family_name );      FT_FREE( info->weight );    }    /* release top dictionary */    FT_FREE( type1->charstrings_len );    FT_FREE( type1->charstrings );    FT_FREE( type1->glyph_names );    FT_FREE( type1->subrs );    FT_FREE( type1->subrs_len );    FT_FREE( type1->subrs_block );    FT_FREE( type1->charstrings_block );    FT_FREE( type1->glyph_names_block );    FT_FREE( type1->encoding.char_index );    FT_FREE( type1->encoding.char_name );    FT_FREE( type1->font_name );#ifndef T1_CONFIG_OPTION_NO_AFM    /* release afm data if present */    if ( face->afm_data )

  t1_cmap_custom_init( T1_CMapCustom  cmap,                       FT_Pointer init_data )   {    T1_Face      face     = (T1_Face)FT_CMAP_FACE( cmap );    T1_Encoding  encoding = &face->type1.encoding;    FT_UNUSED( init_data );    cmap->first   = encoding->code_first;    cmap->count   = (FT_UInt)( encoding->code_last - cmap->first );    cmap->indices = encoding->char_index;    FT_ASSERT( cmap->indices != NULL );    FT_ASSERT( encoding->code_first <= encoding->code_last );    return 0;  }

  FT_Stream_EnterFrame( FT_Stream  stream,                        FT_ULong   count )  {    FT_Error  error = FT_Err_Ok;    FT_ULong  read_bytes;    /* check for nested frame access */    FT_ASSERT( stream && stream->cursor == 0 );    if ( stream->read )    {      /* allocate the frame in memory */      FT_Memory  memory = stream->memory;      if ( FT_QALLOC( stream->base, count ) )        goto Exit;      /* read it */      read_bytes = stream->read( stream, stream->pos,                                 stream->base, count );      if ( read_bytes < count )      {        FT_ERROR(( "FT_Stream_EnterFrame:" ));        FT_ERROR(( " invalid read; expected %lu bytes, got %lu/n",                   count, read_bytes ));        FT_FREE( stream->base );        error = FT_Err_Invalid_Stream_Operation;      }      stream->cursor = stream->base;      stream->limit  = stream->cursor + count;      stream->pos   += read_bytes;    }    else    {      /* check current and new position */      if ( stream->pos >= stream->size        ||           stream->pos + count > stream->size )      {        FT_ERROR(( "FT_Stream_EnterFrame:" ));        FT_ERROR(( " invalid i/o; pos = 0x%lx, count = %lu, size = 0x%lx/n",                   stream->pos, count, stream->size ));        error = FT_Err_Invalid_Stream_Operation;        goto Exit;      }      /* set cursor */      stream->cursor = stream->base + stream->pos;      stream->limit  = stream->cursor + count;      stream->pos   += count;    }  Exit:    return error;  }

  cf2_freeSeacComponent( CFF_Decoder*  decoder,                         CF2_Buffer    buf )  {    FT_ASSERT( decoder );    cff_free_glyph_data( decoder->builder.face,                         (FT_Byte**)&buf->start,                         (FT_ULong)( buf->end - buf->start ) );  }

  T1_Compute_Max_Advance( T1_Face  face,                          FT_Pos*  max_advance )  {    FT_Error       error;    T1_DecoderRec  decoder;    FT_Int         glyph_index;    T1_Font        type1 = &face->type1;    PSAux_Service  psaux = (PSAux_Service)face->psaux;    FT_ASSERT( ( face->len_buildchar == 0 ) == ( face->buildchar == NULL ) );    *max_advance = 0;    /* initialize load decoder */    error = psaux->t1_decoder_funcs->init( &decoder,                                           (FT_Face)face,                                           0, /* size       */                                           0, /* glyph slot */                                           (FT_Byte**)type1->glyph_names,                                           face->blend,                                           0,                                           FT_RENDER_MODE_NORMAL,                                           T1_Parse_Glyph );    if ( error )      return error;    decoder.builder.metrics_only = 1;    decoder.builder.load_points  = 0;    decoder.num_subrs     = type1->num_subrs;    decoder.subrs         = type1->subrs;    decoder.subrs_len     = type1->subrs_len;    decoder.subrs_hash    = type1->subrs_hash;    decoder.buildchar     = face->buildchar;    decoder.len_buildchar = face->len_buildchar;    *max_advance = 0;    /* for each glyph, parse the glyph charstring and extract */    /* the advance width                                      */    for ( glyph_index = 0; glyph_index < type1->num_glyphs; glyph_index++ )    {      /* now get load the unscaled outline */      (void)T1_Parse_Glyph( &decoder, (FT_UInt)glyph_index );      if ( glyph_index == 0 || decoder.builder.advance.x > *max_advance )        *max_advance = decoder.builder.advance.x;      /* ignore the error if one occurred - skip to next glyph */    }    psaux->t1_decoder_funcs->done( &decoder );    return FT_Err_Ok;  }

static int32_t _ft_control_slider_init(struct ft_control_data *control){  FT_ASSERT(control != NULL);  FT_ASSERT(control->rom->interface == &ft_control_slider_interface);  control->data.slider = _ft_mem_alloc(sizeof(struct ft_control_slider_data));  if(control->data.slider == NULL)  {    return FT_OUT_OF_MEMORY;  }  if (_ft_control_check_data(control) != FT_SUCCESS)  {    return FT_FAILURE;  }  return FT_SUCCESS;}

  cf2_getBlueValues( CFF_Decoder*  decoder,                     size_t*       count,                     FT_Pos*      *data )  {    FT_ASSERT( decoder && decoder->current_subfont );    *count = decoder->current_subfont->private_dict.num_blue_values;    *data  = (FT_Pos*)               &decoder->current_subfont->private_dict.blue_values;  }

  cf2_getFamilyOtherBlues( CFF_Decoder*  decoder,                           size_t*       count,                           FT_Pos*      *data )  {    FT_ASSERT( decoder && decoder->current_subfont );    *count = decoder->current_subfont->private_dict.num_family_other_blues;    *data  = (FT_Pos*)               &decoder->current_subfont->private_dict.family_other_blues;  }

  /* return false on memory error */  static FT_Bool  cf2_arrstack_setNumElements( CF2_ArrStack  arrstack,                               size_t        numElements )  {    FT_ASSERT( arrstack != NULL );    {      FT_Error   error  = FT_Err_Ok;        /* for FT_REALLOC */      FT_Memory  memory = arrstack->memory; /* for FT_REALLOC */      FT_Long  newSize = numElements * arrstack->sizeItem;      if ( numElements > LONG_MAX / arrstack->sizeItem )        goto exit;      FT_ASSERT( newSize > 0 );   /* avoid realloc with zero size */      if ( !FT_REALLOC( arrstack->ptr, arrstack->totalSize, newSize ) )      {        arrstack->allocated = numElements;        arrstack->totalSize = newSize;        if ( arrstack->count > numElements )        {          /* we truncated the list! */          CF2_SET_ERROR( arrstack->error, Stack_Overflow );          arrstack->count = numElements;          return FALSE;        }        return TRUE;     /* success */      }    }  exit:    /* if there's not already an error, store this one */    CF2_SET_ERROR( arrstack->error, Out_Of_Memory );    return FALSE;  }

  static void  cf2_setGlyphWidth( CF2_Outline  outline,                     CF2_Fixed    width )  {    CFF_Decoder*  decoder = outline->decoder;    FT_ASSERT( decoder );    decoder->glyph_width = cf2_fixedToInt( width );  }

  cf2_initLocalRegionBuffer( CFF_Decoder*  decoder,                             CF2_UInt      idx,                             CF2_Buffer    buf )  {    FT_ASSERT( decoder );    FT_ZERO( buf );    idx += decoder->locals_bias;    if ( idx >= decoder->num_locals )      return TRUE;     /* error */    FT_ASSERT( decoder->locals );    buf->start =    buf->ptr   = decoder->locals[idx];    buf->end   = decoder->locals[idx + 1];    return FALSE;      /* success */  }

  cf2_outline_close( CF2_Outline  outline )  {    CFF_Decoder*  decoder = outline->decoder;    FT_ASSERT( decoder );    cff_builder_close_contour( &decoder->builder );    FT_GlyphLoader_Add( decoder->builder.loader );  }

  static void  cf2_builder_moveTo( CF2_OutlineCallbacks      callbacks,                      const CF2_CallbackParams  params )  {    /* downcast the object pointer */    CF2_Outline   outline = (CF2_Outline)callbacks;    CFF_Builder*  builder;    (void)params;        /* only used in debug mode */    FT_ASSERT( outline && outline->decoder );    FT_ASSERT( params->op == CF2_PathOpMoveTo );    builder = &outline->decoder->builder;    /* note: two successive moves simply close the contour twice */    cff_builder_close_contour( builder );    builder->path_begun = 0;  }

  cf2_outline_reset( CF2_Outline  outline )  {    CFF_Decoder*  decoder = outline->decoder;    FT_ASSERT( decoder );    outline->root.windingMomentum = 0;    FT_GlyphLoader_Rewind( decoder->builder.loader );  }

  ft_mem_qrealloc( FT_Memory  memory,                   FT_Long    item_size,                   FT_Long    cur_count,                   FT_Long    new_count,                   void*      block,                   FT_Error  *p_error )  {    FT_Error  error = FT_Err_Ok;    /* Note that we now accept `item_size == 0' as a valid parameter, in     * order to cover very weird cases where an ALLOC_MULT macro would be     * called.     */    if ( cur_count < 0 || new_count < 0 || item_size < 0 )    {      /* may help catch/prevent nasty security issues */      error = FT_THROW( Invalid_Argument );    }    else if ( new_count == 0 || item_size == 0 )    {      ft_mem_free( memory, block );      block = NULL;    }    else if ( new_count > FT_INT_MAX / item_size )    {      error = FT_THROW( Array_Too_Large );    }    else if ( cur_count == 0 )    {      FT_ASSERT( !block );      block = memory->alloc( memory, new_count * item_size );      if ( block == NULL )        error = FT_THROW( Out_Of_Memory );    }    else    {      FT_Pointer  block2;      FT_Long     cur_size = cur_count * item_size;      FT_Long     new_size = new_count * item_size;      block2 = memory->realloc( memory, cur_size, new_size, block );      if ( !block2 )        error = FT_THROW( Out_Of_Memory );      else        block = block2;    }    *p_error = error;    return block;  }

static void _ft_control_slider_invoke_callback(const struct ft_control_data *control,                                      enum ft_control_slider_event event,                                       uint32_t position){  struct ft_control_slider_data *ram = control->data.slider;  FT_ASSERT(ram != NULL);  if (ram->callback != NULL)   {    ram->callback(control->rom, event, position);  }}

  /* pointer                                                           */  static void  cf2_hintmask_read( CF2_HintMask  hintmask,                     CF2_Buffer    charstring,                     size_t        bitCount )  {    size_t  i;#ifndef CF2_NDEBUG    /* these are the bits in the final mask byte that should be zero  */    /* Note: this variable is only used in an assert expression below */    /* and then only if CF2_NDEBUG is not defined                     */    CF2_UInt  mask = ( 1 << ( -(CF2_Int)bitCount & 7 ) ) - 1;#endif    /* initialize counts and isValid */    if ( cf2_hintmask_setCounts( hintmask, bitCount ) == 0 )      return;    FT_ASSERT( hintmask->byteCount > 0 );    FT_TRACE4(( " (maskbytes:" ));    /* set mask and advance interpreter's charstring pointer */    for ( i = 0; i < hintmask->byteCount; i++ )    {      hintmask->mask[i] = (FT_Byte)cf2_buf_readByte( charstring );      FT_TRACE4(( " 0x%02X", hintmask->mask[i] ));    }    FT_TRACE4(( ")/n" ));    /* assert any unused bits in last byte are zero unless there's a prior */    /* error                                                               */    /* bitCount -> mask, 0 -> 0, 1 -> 7f, 2 -> 3f, ... 6 -> 3, 7 -> 1      */#ifndef CF2_NDEBUG    FT_ASSERT( ( hintmask->mask[hintmask->byteCount - 1] & mask ) == 0 ||               *hintmask->error                                        );#endif  }

static int32_t _ft_control_slider_process(struct ft_control_data *control){    FT_ASSERT(control != NULL);    FT_ASSERT(control->rom->interface == &ft_control_slider_interface);    if (!_ft_control_get_flag(control, FT_CONTROL_EN_FLAG) ||        !_ft_control_get_flag(control, FT_CONTROL_NEW_DATA_FLAG)) {        return FT_FAILURE; /* control disabled or data not ready */    }    struct ft_control_slider_data *ram = control->data.slider;    uint32_t elec_state = _ft_control_get_electrodes_state(control);    if (!elec_state) {        /* all released */        if (_ft_control_get_flag(control, FT_SLIDER_TOUCH_FLAG)) {            /* if none is touched & touch was reported, allreleased event */            _ft_control_clear_flag(control, FT_SLIDER_TOUCH_FLAG);            _ft_control_clear_flag(control, FT_SLIDER_MOVEMENT_FLAG);            _ft_control_slider_invoke_callback(control, FT_SLIDER_ALL_RELEASE,                                      (uint32_t)ram->position);        }        _ft_control_clear_flag(control, FT_CONTROL_NEW_DATA_FLAG); /* data processed */        return FT_SUCCESS; /* no touch on the control's electrodes */    }    uint32_t last_elec = _ft_control_get_last_elec_touched(elec_state);    uint32_t first_elec = _ft_control_get_first_elec_touched(elec_state);    uint32_t touch_count = _ft_control_get_touch_count(elec_state);    _ft_control_slider_calc_position(control, first_elec, last_elec, touch_count);    if (!_ft_control_get_flag(control, FT_SLIDER_TOUCH_FLAG)) {        _ft_control_slider_invoke_callback(control, FT_SLIDER_INITIAL_TOUCH,                                   (uint32_t)ram->position);    }    _ft_control_set_flag(control, FT_SLIDER_TOUCH_FLAG);    _ft_control_clear_flag(control, FT_CONTROL_NEW_DATA_FLAG); /* data processed */    return FT_SUCCESS;}

  FT_Stream_GetChar( FT_Stream  stream )  {    FT_Char  result;    FT_ASSERT( stream && stream->cursor );    result = 0;    if ( stream->cursor < stream->limit )      result = *stream->cursor++;    return result;  }

uint32_t ft_mem_get_free_size(void){  struct ft_kernel * system = _ft_system_get();  struct ft_mem * mem = &system->memory;    int32_t size = mem->pool_size;    size -= mem->free_pointer - mem->pool;    FT_ASSERT(size >= 0);    return size;}

static void _ft_keydetector_afid_process(struct ft_electrode_data *electrode){  FT_ASSERT(electrode->rom->keydetector_interface == &ft_keydetector_afid_interface);  struct ft_keydetector_afid_data *ram = electrode->keydetector_data.afid;  const struct ft_keydetector_afid *rom = electrode->rom->keydetector_params.afid;  struct ft_kernel *system = _ft_system_get();  switch (_ft_electrode_get_last_status(electrode)) {    case FT_ELECTRODE_STATE_INIT:      /* manage switch from init to run phase */      if (_ft_electrode_get_time_offset(electrode) >= system->rom->init_time)      {        _ft_keydetector_afid_asc_track(rom, ram);        _ft_keydetector_afid_asc_process(rom, ram);                if(_ft_electrode_get_flag(electrode, FT_ELECTRODE_AFTER_INIT_TOUCH_FLAG))            _ft_electrode_set_status(electrode, FT_ELECTRODE_STATE_TOUCH);        else            _ft_electrode_set_status(electrode, FT_ELECTRODE_STATE_RELEASE);                _ft_electrode_clear_flag(electrode, FT_ELECTRODE_AFTER_INIT_TOUCH_FLAG);      }    break;    case FT_ELECTRODE_STATE_TOUCH:      if (ram->release_reset_counter > 0U)      {        _ft_electrode_set_status(electrode, FT_ELECTRODE_STATE_RELEASE);      } else {        _ft_keydetector_afid_asc_track(rom, ram);                if (ram->touch_reset_counter < rom->asc.resets_for_touch / 2)        {          ram->touch_reset_counter = 0;        }      }    break;    case FT_ELECTRODE_STATE_RELEASE:      if (ram->touch_reset_counter > rom->asc.resets_for_touch)      {        _ft_electrode_set_status(electrode, FT_ELECTRODE_STATE_TOUCH);              } else {        _ft_keydetector_afid_asc_process(rom, ram);      }    break;    default:    break;  }}

  cf2_arrstack_setCount( CF2_ArrStack  arrstack,                         size_t        numElements )  {    FT_ASSERT( arrstack != NULL );    if ( numElements > arrstack->allocated )    {      /* expand the allocation first */      if ( !cf2_arrstack_setNumElements( arrstack, numElements ) )        return;    }    arrstack->count = numElements;  }

  cf2_arrstack_finalize( CF2_ArrStack  arrstack )  {    FT_Memory  memory = arrstack->memory;     /* for FT_FREE */    FT_ASSERT( arrstack != NULL );    arrstack->allocated = 0;    arrstack->count     = 0;    arrstack->totalSize = 0;    /* free the data buffer */    FT_FREE( arrstack->ptr );  }

  cf2_hintmask_setAll( CF2_HintMask  hintmask,                       size_t        bitCount )  {    size_t    i;    CF2_UInt  mask = ( 1 << ( -(CF2_Int)bitCount & 7 ) ) - 1;    /* initialize counts and isValid */    if ( cf2_hintmask_setCounts( hintmask, bitCount ) == 0 )      return;    FT_ASSERT( hintmask->byteCount > 0 );    FT_ASSERT( hintmask->byteCount <=                 sizeof ( hintmask->mask ) / sizeof ( hintmask->mask[0] ) );    /* set mask to all ones */    for ( i = 0; i < hintmask->byteCount; i++ )      hintmask->mask[i] = 0xFF;    /* clear unused bits                                              */    /* bitCount -> mask, 0 -> 0, 1 -> 7f, 2 -> 3f, ... 6 -> 3, 7 -> 1 */    hintmask->mask[hintmask->byteCount - 1] &= ~mask;  }

  /*   * This check should avoid most internal overflow cases.  Clients should   * generally respond to `Glyph_Too_Big' by getting a glyph outline   * at EM size, scaling it and filling it as a graphics operation.   *   */  static FT_Error  cf2_checkTransform( const CF2_Matrix*  transform,                      CF2_Int            unitsPerEm )  {    CF2_Fixed  maxScale;    FT_ASSERT( unitsPerEm > 0 );    FT_ASSERT( transform->a > 0 && transform->d > 0 );    FT_ASSERT( transform->b == 0 && transform->c == 0 );    FT_ASSERT( transform->tx == 0 && transform->ty == 0 );    if ( unitsPerEm > 0x7FFF )      return FT_THROW( Glyph_Too_Big );    maxScale = FT_DivFix( CF2_MAX_SIZE, cf2_intToFixed( unitsPerEm ) );    if ( transform->a > maxScale || transform->d > maxScale )      return FT_THROW( Glyph_Too_Big );    return FT_Err_Ok;  }

  static void  cf2_builder_cubeTo( CF2_OutlineCallbacks      callbacks,                      const CF2_CallbackParams  params )  {    /* downcast the object pointer */    CF2_Outline   outline = (CF2_Outline)callbacks;    CFF_Builder*  builder;    FT_ASSERT( outline && outline->decoder );    FT_ASSERT( params->op == CF2_PathOpCubeTo );    builder = &outline->decoder->builder;    if ( !builder->path_begun )    {      /* record the move before the line; also check points and set */      /* `path_begun'                                               */      cff_builder_start_point( builder,                               params->pt0.x,                               params->pt0.y );    }    /* prepare room for 3 points: 2 off-curve, 1 on-curve */    cff_check_points( builder, 3 );    cff_builder_add_point( builder,                           params->pt1.x,                           params->pt1.y, 0 );    cff_builder_add_point( builder,                           params->pt2.x,                           params->pt2.y, 0 );    cff_builder_add_point( builder,                           params->pt3.x,                           params->pt3.y, 1 );  }

  cf2_getBlueMetrics( CFF_Decoder*  decoder,                      CF2_Fixed*    blueScale,                      CF2_Fixed*    blueShift,                      CF2_Fixed*    blueFuzz )  {    FT_ASSERT( decoder && decoder->current_subfont );    *blueScale = FT_DivFix(                   decoder->current_subfont->private_dict.blue_scale,                   cf2_intToFixed( 1000 ) );    *blueShift = cf2_intToFixed(                   decoder->current_subfont->private_dict.blue_shift );    *blueFuzz  = cf2_intToFixed(                   decoder->current_subfont->private_dict.blue_fuzz );  }