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

static int getaddr(char *node, char *service, void **addr,                   size_t *len){    struct addrinfo *ai;    int ret;    if (!node) {        *addr = NULL;        *len = 0;        return 0;    }    ret = getaddrinfo(node, service, NULL, &ai);    if (ret) {        FT_ERR("getaddrinfo error %s/n", gai_strerror(ret));        return ret;    }    if ((*addr = malloc(ai->ai_addrlen))) {        memcpy(*addr, ai->ai_addr, ai->ai_addrlen);        *len = (size_t)ai->ai_addrlen;    } else {        FT_ERR("addr allocation failed/n");        ret = EAI_MEMORY;    }    freeaddrinfo(ai);    return ret;}

static int check_address(struct fid *fid, const char *message){	char buf1[BUFSIZ], buf2[BUFSIZ];	union sockaddr_any tmp;	size_t tmplen;	const char *ep_addr, *addr_expected;	int ret;	memset(&tmp, 0, sizeof tmp);	tmplen = sizeof tmp;	ret = fi_getname(fid, &tmp, &tmplen);	if (ret) {		FT_PRINTERR("fi_getname", ret);	}	if (sockaddrcmp(&tmp, tmplen, &bound_addr, bound_addr_len)) {		ep_addr = sockaddrstr(&tmp, tmplen, buf1, BUFSIZ);		if (!ep_addr) {			FT_ERR("Unable to get ep_addr as string!/n");			return -FI_EINVAL;		}		addr_expected = sockaddrstr(&bound_addr, bound_addr_len, buf2, BUFSIZ);		if (!addr_expected) {			FT_ERR("Unable to get addr_expected as string!/n");			return -FI_EINVAL;		}		FT_ERR("address changed after %s: got %s expected %s/n",			message, ep_addr, addr_expected);		return -FI_EINVAL;	}	return 0;}

static int server_listen(size_t paramlen){	size_t expected;	uint32_t event;	int ret;	expected = paramlen + sizeof(*entry);	memset(entry, 0, expected);	ret = fi_eq_sread(eq, &event, entry, expected, -1, 0);	if (ret != expected) {		FT_PROCESS_EQ_ERR(ret, eq, "fi_eq_sread", "listen");		return ret;	}	if (event != FI_CONNREQ) {		FT_ERR("Unexpected CM event %d", event);		return -FI_EOTHER;	}	ret = ft_check_buf(entry->data, paramlen);	if (ret)		return ret;	fi = entry->info;	return 0;}

  pfr_get_advance( FT_Face   pfrface,       /* PFR_Face */                   FT_UInt   gindex,                   FT_Pos   *anadvance )  {    PFR_Face  face  = (PFR_Face)pfrface;    FT_Error  error = FT_ERR( Invalid_Argument );    *anadvance = 0;    if ( !gindex )      goto Exit;    gindex--;    if ( face )    {      PFR_PhyFont  phys = &face->phy_font;      if ( gindex < phys->num_chars )      {        *anadvance = phys->chars[gindex].advance;        error      = FT_Err_Ok;      }    }  Exit:    return error;  }

  FT_Set_Var_Blend_Coordinates( FT_Face    face,                                FT_UInt    num_coords,                                FT_Fixed*  coords )  {    FT_Error                 error;    FT_Service_MultiMasters  service;    /* check of `face' delayed to `ft_face_get_mm_service' */    if ( !coords )      return FT_THROW( Invalid_Argument );    error = ft_face_get_mm_service( face, &service );    if ( !error )    {      error = FT_ERR( Invalid_Argument );      if ( service->set_mm_blend )        error = service->set_mm_blend( face, num_coords, coords );    }    /* enforce recomputation of auto-hinting data */    if ( !error && face->autohint.finalizer )    {      face->autohint.finalizer( face->autohint.data );      face->autohint.data = NULL;    }    return error;  }

  FT_Get_BDF_Charset_ID( FT_Face       face,                         const char*  *acharset_encoding,                         const char*  *acharset_registry )  {    FT_Error     error;    const char*  encoding = NULL;    const char*  registry = NULL;    error = FT_ERR( Invalid_Argument );    if ( face )    {      FT_Service_BDF  service;      FT_FACE_FIND_SERVICE( face, service, BDF );      if ( service && service->get_charset_id )        error = service->get_charset_id( face, &encoding, &registry );    }    if ( acharset_encoding )      *acharset_encoding = encoding;    if ( acharset_registry )      *acharset_registry = registry;    return error;  }

  FT_Get_CID_Registry_Ordering_Supplement( FT_Face       face,                                           const char*  *registry,                                           const char*  *ordering,                                           FT_Int       *supplement)  {    FT_Error     error;    const char*  r = NULL;    const char*  o = NULL;    FT_Int       s = 0;    error = FT_ERR( Invalid_Argument );    if ( face )    {      FT_Service_CID  service;      FT_FACE_FIND_SERVICE( face, service, CID );      if ( service && service->get_ros )        error = service->get_ros( face, &r, &o, &s );    }    if ( registry )      *registry = r;    if ( ordering )      *ordering = o;    if ( supplement )      *supplement = s;    return error;  }

  static FT_Error  ft_face_get_mm_service( FT_Face                   face,                          FT_Service_MultiMasters  *aservice )  {    FT_Error  error;    *aservice = NULL;    if ( !face )      return FT_THROW( Invalid_Face_Handle );    error = FT_ERR( Invalid_Argument );    if ( FT_HAS_MULTIPLE_MASTERS( face ) )    {      FT_FACE_LOOKUP_SERVICE( face,                              *aservice,                              MULTI_MASTERS );      if ( *aservice )        error = FT_Err_Ok;    }    return error;  }

ssize_t ft_post_rma(enum ft_rma_opcodes op, struct fid_ep *ep, size_t size,		struct fi_rma_iov *remote, void *context){	switch (op) {	case FT_RMA_WRITE:		FT_POST(fi_write, ft_get_tx_comp, tx_seq, "fi_write", ep, tx_buf,				opts.transfer_size, fi_mr_desc(mr), remote_fi_addr,				remote->addr, remote->key, context);		break;	case FT_RMA_WRITEDATA:		FT_POST(fi_writedata, ft_get_tx_comp, tx_seq, "fi_writedata", ep,				tx_buf, opts.transfer_size, fi_mr_desc(mr),				remote_cq_data,	remote_fi_addr,	remote->addr,				remote->key, context);		break;	case FT_RMA_READ:		FT_POST(fi_read, ft_get_tx_comp, tx_seq, "fi_read", ep, rx_buf,				opts.transfer_size, fi_mr_desc(mr), remote_fi_addr,				remote->addr, remote->key, context);		break;	default:		FT_ERR("Unknown RMA op type/n");		return EXIT_FAILURE;	}	return 0;}

  /*   *  PROPERTY SERVICE   *   */  static FT_Error  tt_property_set( FT_Module    module,         /* TT_Driver */                   const char*  property_name,                   const void*  value )  {    FT_Error   error  = FT_Err_Ok;    TT_Driver  driver = (TT_Driver)module;    if ( !ft_strcmp( property_name, "interpreter-version" ) )    {      FT_UInt*  interpreter_version = (FT_UInt*)value;#ifndef TT_CONFIG_OPTION_SUBPIXEL_HINTING      if ( *interpreter_version != TT_INTERPRETER_VERSION_35 )        error = FT_ERR( Unimplemented_Feature );      else#endif        driver->interpreter_version = *interpreter_version;      return error;    }    FT_TRACE0(( "tt_property_set: missing property `%s'/n",                property_name ));    return FT_THROW( Missing_Property );  }

static int client_expect_accept(size_t paramlen){	size_t expected;	uint32_t event;	int ret;	expected = paramlen + sizeof(*entry);	ret = client_connect(paramlen);	if (ret) {		FT_PRINTERR("fi_connect", ret);		return ret;	}	ret = fi_eq_sread(eq, &event, entry, expected, -1, 0);	if (ret != expected) {		FT_PROCESS_EQ_ERR(ret, eq, "fi_eq_sread", "connect");		return ret;	}	if (event != FI_CONNECTED || entry->fid != &ep->fid) {		FT_ERR("Unexpected CM event %d fid %p (ep %p)", event,				entry->fid, ep);		return -FI_EOTHER;	}	/* Check data on FI_CONNECTED event. */	ret = ft_check_buf(entry->data, paramlen);	if (ret)		return ret;	fi_shutdown(ep, 0);	return read_shutdown_event();}

/* *  PROPERTY SERVICE * */static FT_Errortt_property_set( FT_Module    module,         /* TT_Driver */                 const char*  property_name,                 const void*  value,                 FT_Bool      value_is_string ){    FT_Error   error  = FT_Err_Ok;    TT_Driver  driver = (TT_Driver)module;#ifndef FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES    FT_UNUSED( value_is_string );#endif    if ( !ft_strcmp( property_name, "interpreter-version" ) )    {        FT_UInt  interpreter_version;#ifdef FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES        if ( value_is_string )        {            const char*  s = (const char*)value;            interpreter_version = (FT_UInt)ft_strtol( s, NULL, 10 );        }        else#endif        {            FT_UInt*  iv = (FT_UInt*)value;            interpreter_version = *iv;        }        if ( interpreter_version == TT_INTERPRETER_VERSION_35#ifdef TT_SUPPORT_SUBPIXEL_HINTING_INFINALITY                || interpreter_version == TT_INTERPRETER_VERSION_38#endif#ifdef TT_SUPPORT_SUBPIXEL_HINTING_MINIMAL                || interpreter_version == TT_INTERPRETER_VERSION_40#endif           )            driver->interpreter_version = interpreter_version;        else            error = FT_ERR( Unimplemented_Feature );        return error;    }    FT_TRACE0(( "tt_property_set: missing property `%s'/n",                property_name ));    return FT_THROW( Missing_Property );}

static int dupaddr(void **dst_addr, size_t *dst_addrlen,		void *src_addr, size_t src_addrlen){	*dst_addr = malloc(src_addrlen);	if (!*dst_addr) {		FT_ERR("address allocation failed");		return EAI_MEMORY;	}	*dst_addrlen = src_addrlen;	memcpy(*dst_addr, src_addr, src_addrlen);	return 0;}

  FT_New_Face_From_FSSpec( FT_Library     library,                           const FSSpec*  spec,                           FT_Long        face_index,                           FT_Face*       aface )  {#if HAVE_FSREF    FSRef  ref;    if ( !spec || FSpMakeFSRef( spec, &ref ) != noErr )      return FT_THROW( Invalid_Argument );    else      return FT_New_Face_From_FSRef( library, &ref, face_index, aface );#elif HAVE_FSSPEC    FT_Error      error;    FT_Open_Args  args;    OSErr         err;    UInt8         pathname[PATH_MAX];    if ( !spec )      return FT_THROW( Invalid_Argument );    err = FT_FSpMakePath( spec, pathname, sizeof ( pathname ) );    if ( err )      error = FT_ERR( Cannot_Open_Resource );    error = FT_New_Face_From_Resource( library, pathname, face_index, aface );    if ( error || *aface )      return error;    /* fallback to datafork font */    args.flags    = FT_OPEN_PATHNAME;    args.pathname = (char*)pathname;    return FT_Open_Face( library, &args, face_index, aface );#else    FT_UNUSED( library );    FT_UNUSED( spec );    FT_UNUSED( face_index );    FT_UNUSED( aface );    return FT_THROW( Unimplemented_Feature );#endif /* HAVE_FSREF, HAVE_FSSPEC */  }

static int ft_comp_x(struct fid_cq *cq, struct ft_xcontrol *ft_x,		const char *x_str, int timeout){	uint8_t buf[FT_COMP_BUF_SIZE];	struct timespec s, e;	int poll_time = 0;	int ret;	switch(test_info.cq_wait_obj) {	case FI_WAIT_NONE:		do {			if (!poll_time)				clock_gettime(CLOCK_MONOTONIC, &s);			ft_cq_read(fi_cq_read, cq, buf, comp_entry_cnt[ft_x->cq_format],					ft_x->credits, x_str, ret);			clock_gettime(CLOCK_MONOTONIC, &e);			poll_time = get_elapsed(&s, &e, MILLI);		} while (ret == -FI_EAGAIN && poll_time < timeout);		break;	case FI_WAIT_UNSPEC:	case FI_WAIT_FD:	case FI_WAIT_MUTEX_COND:		ft_cq_read(fi_cq_sread, cq, buf, comp_entry_cnt[ft_x->cq_format],			ft_x->credits, x_str, ret, NULL, timeout);		break;	case FI_WAIT_SET:		FT_ERR("fi_ubertest: Unsupported cq wait object");		return -1;	default:		FT_ERR("Unknown cq wait object");		return -1;	}	return (ret == -FI_EAGAIN && timeout) ? ret : 0;}

  FTC_Manager_RegisterCache( FTC_Manager      manager,                             FTC_CacheClass   clazz,                             FTC_Cache       *acache )  {    FT_Error   error = FT_ERR( Invalid_Argument );    FTC_Cache  cache = NULL;    if ( manager && clazz && acache )    {      FT_Memory  memory = manager->memory;      if ( manager->num_caches >= FTC_MAX_CACHES )      {        error = FT_THROW( Too_Many_Caches );        FT_ERROR(( "FTC_Manager_RegisterCache:"                   " too many registered caches/n" ));        goto Exit;      }      if ( !FT_ALLOC( cache, clazz->cache_size ) )      {        cache->manager   = manager;        cache->memory    = memory;        cache->clazz     = clazz[0];        cache->org_class = clazz;        /* THIS IS VERY IMPORTANT!  IT WILL WRETCH THE MANAGER */        /* IF IT IS NOT SET CORRECTLY                          */        cache->index = manager->num_caches;        error = clazz->cache_init( cache );        if ( error )        {          clazz->cache_done( cache );          FT_FREE( cache );          goto Exit;        }        manager->caches[manager->num_caches++] = cache;      }    }  Exit:    if ( acache )      *acache = cache;    return error;  }

int ft_get_tx_comp(uint64_t total){	int ret;	if (txcq) {		ret = ft_get_cq_comp(txcq, &tx_cq_cntr, total, -1);	} else if (txcntr) {		ret = fi_cntr_wait(txcntr, total, -1);		if (ret)			FT_PRINTERR("fi_cntr_wait", ret);	} else {		FT_ERR("Trying to get a TX completion when no TX CQ or counter were opened");		ret = -FI_EOTHER;	}	return ret;}

  int main( int    argc,            char** argv )  {    FT_Library       library;    FT_StreamRec     stream;    FT_Error         error = FT_Err_Ok;    AFM_FontInfoRec  fi;    if ( argc < 2 )      return FT_ERR( Invalid_Argument );    error = FT_Init_FreeType( &library );    if ( error )      return error;    FT_ZERO( &stream );    error = FT_Stream_Open( &stream, argv[1] );    if ( error )      goto Exit;    stream.memory = library->memory;    FT_ZERO( &fi );    error = parse_afm( library, &stream, &fi );    if ( !error )    {      FT_Memory  memory = library->memory;      dump_fontinfo( &fi );      if ( fi.KernPairs )        FT_FREE( fi.KernPairs );      if ( fi.TrackKerns )        FT_FREE( fi.TrackKerns );    }    else      printf( "parse error/n" );    FT_Stream_Close( &stream );  Exit:    FT_Done_FreeType( library );    return error;  }

  FT_Get_Sfnt_Name( FT_Face       face,                    FT_UInt       idx,                    FT_SfntName  *aname )  {    FT_Error  error = FT_ERR( Invalid_Argument );    if ( aname && face && FT_IS_SFNT( face ) )    {      TT_Face  ttface = (TT_Face)face;      if ( idx < (FT_UInt)ttface->num_names )      {        TT_NameEntryRec*  entry = ttface->name_table.names + idx;        /* load name on demand */        if ( entry->stringLength > 0 && entry->string == NULL )        {          FT_Memory  memory = face->memory;          FT_Stream  stream = face->stream;          if ( FT_NEW_ARRAY  ( entry->string, entry->stringLength ) ||               FT_STREAM_SEEK( entry->stringOffset )                ||               FT_STREAM_READ( entry->string, entry->stringLength ) )          {            FT_FREE( entry->string );            entry->stringLength = 0;          }        }        aname->platform_id = entry->platformID;        aname->encoding_id = entry->encodingID;        aname->language_id = entry->languageID;        aname->name_id     = entry->nameID;        aname->string      = (FT_Byte*)entry->string;        aname->string_len  = entry->stringLength;        error = FT_Err_Ok;      }    }    return error;  }

  FT_Get_MM_Var( FT_Face      face,                 FT_MM_Var*  *amaster )  {    FT_Error                 error;    FT_Service_MultiMasters  service;    error = ft_face_get_mm_service( face, &service );    if ( !error )    {      error = FT_ERR( Invalid_Argument );      if ( service->get_mm_var )        error = service->get_mm_var( face, amaster );    }    return error;  }

int ft_av_insert(struct fid_av *av, void *addr, size_t count, fi_addr_t *fi_addr,		uint64_t flags, void *context){	int ret;	ret = fi_av_insert(av, addr, count, fi_addr, flags, context);	if (ret < 0) {		FT_PRINTERR("fi_av_insert", ret);		return ret;	} else if (ret != count) {		FT_ERR("fi_av_insert: number of addresses inserted = %d;"			       " number of addresses given = %zd/n", ret, count);		return -EXIT_FAILURE;	}	return 0;}

  FT_Set_MM_Design_Coordinates( FT_Face   face,                                FT_UInt   num_coords,                                FT_Long*  coords )  {    FT_Error                 error;    FT_Service_MultiMasters  service;    error = ft_face_get_mm_service( face, &service );    if ( !error )    {      error = FT_ERR( Invalid_Argument );      if ( service->set_mm_design )        error = service->set_mm_design( face, num_coords, coords );    }    return error;  }

  FT_Set_Var_Blend_Coordinates( FT_Face    face,                                FT_UInt    num_coords,                                FT_Fixed*  coords )  {    FT_Error                 error;    FT_Service_MultiMasters  service;    error = ft_face_get_mm_service( face, &service );    if ( !error )    {      error = FT_ERR( Invalid_Argument );      if ( service->set_mm_blend )         error = service->set_mm_blend( face, num_coords, coords );    }    return error;  }

  FT_New_Face_From_FSRef( FT_Library    library,                          const FSRef*  ref,                          FT_Long       face_index,                          FT_Face*      aface )  {#if !HAVE_FSREF    FT_UNUSED( library );    FT_UNUSED( ref );    FT_UNUSED( face_index );    FT_UNUSED( aface );    return FT_THROW( Unimplemented_Feature );#else    FT_Error      error;    FT_Open_Args  args;    OSErr   err;    UInt8   pathname[PATH_MAX];    /* test for valid `library' and `aface' delayed to `FT_Open_Face' */    if ( !ref )      return FT_THROW( Invalid_Argument );    err = FSRefMakePath( ref, pathname, sizeof ( pathname ) );    if ( err )      error = FT_ERR( Cannot_Open_Resource );    error = FT_New_Face_From_Resource( library, pathname, face_index, aface );    if ( error || *aface )      return error;    /* fallback to datafork font */    args.flags    = FT_OPEN_PATHNAME;    args.pathname = (char*)pathname;    return FT_Open_Face( library, &args, face_index, aface );#endif /* HAVE_FSREF */  }

  /* Create a new FT_Face from a file spec to a suitcase file. */  static FT_Error  FT_New_Face_From_Suitcase( FT_Library    library,                             const UInt8*  pathname,                             FT_Long       face_index,                             FT_Face*      aface )  {    FT_Error       error = FT_ERR( Cannot_Open_Resource );    ResFileRefNum  res_ref;    ResourceIndex  res_index;    Handle         fond;    short          num_faces_in_res;    if ( noErr != FT_FSPathMakeRes( pathname, &res_ref ) )      return FT_THROW( Cannot_Open_Resource );    UseResFile( res_ref );    if ( ResError() )      return FT_THROW( Cannot_Open_Resource );    num_faces_in_res = 0;    for ( res_index = 1; ; ++res_index )    {      short  num_faces_in_fond;      fond = Get1IndResource( TTAG_FOND, res_index );      if ( ResError() )        break;      num_faces_in_fond  = count_faces( fond, pathname );      num_faces_in_res  += num_faces_in_fond;      if ( 0 <= face_index && face_index < num_faces_in_fond && error )        error = FT_New_Face_From_FOND( library, fond, face_index, aface );      face_index -= num_faces_in_fond;    }    CloseResFile( res_ref );    if ( !error && aface )      (*aface)->num_faces = num_faces_in_res;    return error;  }

  FT_Get_PS_Font_Private( FT_Face         face,                          PS_PrivateRec*  afont_private )  {    FT_Error  error = FT_ERR( Invalid_Argument );    if ( face )    {      FT_Service_PsInfo  service = NULL;      FT_FACE_FIND_SERVICE( face, service, POSTSCRIPT_INFO );      if ( service && service->ps_get_font_private )        error = service->ps_get_font_private( face, afont_private );    }    return error;  }

static int read_shutdown_event(){	int ret;	uint32_t event;	memset(entry, 0, sizeof(*entry));	ret = fi_eq_sread(eq, &event, entry, sizeof(*entry), -1, 0);	if (ret < 0) {		FT_PROCESS_EQ_ERR(ret, eq, "fi_eq_sread", "shutdown");		return ret;	}	if (event != FI_SHUTDOWN || entry->fid != &ep->fid) {		FT_ERR("Unexpected CM event %d fid %p (ep %p)", event,			entry->fid, ep);		ret = -FI_EOTHER;		return ret;	}	return 0;}

  FT_Outline_Render( FT_Library         library,                     FT_Outline*        outline,                     FT_Raster_Params*  params )  {    FT_Error     error;    FT_Renderer  renderer;    FT_ListNode  node;    if ( !library )      return FT_THROW( Invalid_Library_Handle );    if ( !outline )      return FT_THROW( Invalid_Outline );    if ( !params )      return FT_THROW( Invalid_Argument );    renderer = library->cur_renderer;    node     = library->renderers.head;    params->source = (void*)outline;    error = FT_ERR( Cannot_Render_Glyph );    while ( renderer )    {      error = renderer->raster_render( renderer->raster, params );      if ( !error || FT_ERR_NEQ( error, Cannot_Render_Glyph ) )        break;      /* FT_Err_Cannot_Render_Glyph is returned if the render mode   */      /* is unsupported by the current renderer for this glyph image */      /* format                                                      */      /* now, look for another renderer that supports the same */      /* format                                                */      renderer = FT_Lookup_Renderer( library, FT_GLYPH_FORMAT_OUTLINE,                                     &node );    }    return error;  }

int ft_set_rma_caps(struct fi_info *fi, enum ft_rma_opcodes rma_op){	switch (rma_op) {	case FT_RMA_READ:		fi->caps |= FI_REMOTE_READ;		if (fi->mode & FI_LOCAL_MR)			fi->caps |= FI_READ;		break;	case FT_RMA_WRITE:	case FT_RMA_WRITEDATA:		fi->caps |= FI_REMOTE_WRITE;		if (fi->mode & FI_LOCAL_MR)			fi->caps |= FI_WRITE;		break;	default:		FT_ERR("Invalid rma op type/n");		return -FI_EINVAL;	}	return 0;}

int ft_get_rx_comp(uint64_t total){	int ret = FI_SUCCESS;	if (rxcq) {		ret = ft_get_cq_comp(rxcq, &rx_cq_cntr, total, timeout);	} else if (rxcntr) {		while (fi_cntr_read(rxcntr) < total) {			ret = fi_cntr_wait(rxcntr, total, timeout);			if (ret)				FT_PRINTERR("fi_cntr_wait", ret);			else				break;		}	} else {		FT_ERR("Trying to get a RX completion when no RX CQ or counter were opened");		ret = -FI_EOTHER;	}	return ret;}