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

static GHashKey *_ghashutil_keyalloc(const void *msgctxt, const void *msgid){	GHashKey *key = MEM_mallocN(sizeof(GHashKey), "Py i18n GHashKey");	key->msgctxt = BLI_strdup(BLT_is_default_context(msgctxt) ? BLT_I18NCONTEXT_DEFAULT_BPYRNA : msgctxt);	key->msgid = BLI_strdup(msgid);	return key;}

FontBLF *blf_font_new(const char *name, const char *filename){	FontBLF *font;	FT_Error err;	char *mfile;	font = (FontBLF *)MEM_callocN(sizeof(FontBLF), "blf_font_new");	err = FT_New_Face(ft_lib, filename, 0, &font->face);	if (err) {		MEM_freeN(font);		return NULL;	}	err = FT_Select_Charmap(font->face, ft_encoding_unicode);	if (err) {		printf("Can't set the unicode character map!/n");		FT_Done_Face(font->face);		MEM_freeN(font);		return NULL;	}	mfile = blf_dir_metrics_search(filename);	if (mfile) {		err = FT_Attach_File(font->face, mfile);		if (err) {			fprintf(stderr, "FT_Attach_File failed to load '%s' with error %d/n", filename, (int)err);		}		MEM_freeN(mfile);	}	font->name = BLI_strdup(name);	font->filename = BLI_strdup(filename);	blf_font_fill(font);	return font;}

int IMB_metadata_add_field(struct ImBuf* img, const char* key, const char* field){	ImMetaData *info;	ImMetaData *last;	if (!img)		return 0;	if (!img->metadata) {		img->metadata = MEM_callocN(sizeof(ImMetaData), "ImMetaData");		info = img->metadata;	} else {		info = img->metadata;		last = info;		while (info) {			last = info;			info = info->next;		}		info = MEM_callocN(sizeof(ImMetaData), "ImMetaData");		last->next = info;	}	info->key = BLI_strdup(key);	info->value = BLI_strdup(field);	return 1;}

static char *rna_VertexPaint_path(PointerRNA *ptr){	Scene *scene = (Scene *)ptr->id.data;	ToolSettings *ts = scene->toolsettings;	if (ptr->data == ts->vpaint) {		return BLI_strdup("tool_settings.vertex_paint");	}	else {		return BLI_strdup("tool_settings.weight_paint");	}}

static char *strip_last_slash(const char *dir){	char *result = BLI_strdup(dir);	BLI_del_slash(result);	return result;}

/* Some font have additional file with metrics information, * in general, the extension of the file is: .afm or .pfm */char *blf_dir_metrics_search(const char *filename){	char *mfile;	char *s;	mfile = BLI_strdup(filename);	s = strrchr(mfile, '.');	if (s) {		if (BLI_strnlen(s, 4) < 4) {			MEM_freeN(mfile);			return NULL;		}		s++;		s[0] = 'a';		s[1] = 'f';		s[2] = 'm';		/* first check .afm */		if (BLI_exists(mfile))			return mfile;		/* and now check .pfm */		s[0] = 'p';		if (BLI_exists(mfile))			return mfile;	}	MEM_freeN(mfile);	return NULL;}

FontBLF *blf_font_new_from_mem(const char *name, const unsigned char *mem, int mem_size){	FontBLF *font;	FT_Error err;	font = (FontBLF *)MEM_callocN(sizeof(FontBLF), "blf_font_new_from_mem");	err = FT_New_Memory_Face(ft_lib, mem, mem_size, 0, &font->face);	if (err) {		MEM_freeN(font);		return NULL;	}	err = FT_Select_Charmap(font->face, ft_encoding_unicode);	if (err) {		printf("Can't set the unicode character map!/n");		FT_Done_Face(font->face);		MEM_freeN(font);		return NULL;	}	font->name = BLI_strdup(name);	font->filename = NULL;	blf_font_fill(font);	return font;}

void wm_history_file_read(void){	char name[FILE_MAX];	LinkNode *l, *lines;	struct RecentFile *recent;	const char *line;	int num;	const char * const cfgdir = BKE_appdir_folder_id(BLENDER_USER_CONFIG, NULL);	if (!cfgdir) return;	BLI_make_file_string("/", name, cfgdir, BLENDER_HISTORY_FILE);	lines = BLI_file_read_as_lines(name);	BLI_listbase_clear(&G.recent_files);	/* read list of recent opened files from recent-files.txt to memory */	for (l = lines, num = 0; l && (num < U.recent_files); l = l->next) {		line = l->link;		/* don't check if files exist, causes slow startup for remote/external drives */		if (line[0]) {			recent = (RecentFile *)MEM_mallocN(sizeof(RecentFile), "RecentFile");			BLI_addtail(&(G.recent_files), recent);			recent->filepath = BLI_strdup(line);			num++;		}	}		BLI_file_free_lines(lines);}

static char *rna_NlaStrip_path(PointerRNA *ptr){	NlaStrip *strip = (NlaStrip *)ptr->data;	AnimData *adt = BKE_animdata_from_id(ptr->id.data);		/* if we're attached to AnimData, try to resolve path back to AnimData */	if (adt) {		NlaTrack *nlt;		NlaStrip *nls;				for (nlt = adt->nla_tracks.first; nlt; nlt = nlt->next) {			for (nls = nlt->strips.first; nls; nls = nls->next) {				if (nls == strip) {					/* XXX but if we animate like this, the control will never work... */					char name_esc_nlt[sizeof(nlt->name) * 2];					char name_esc_strip[sizeof(strip->name) * 2];					BLI_strescape(name_esc_nlt, nlt->name, sizeof(name_esc_nlt));					BLI_strescape(name_esc_strip, strip->name, sizeof(name_esc_strip));					return BLI_sprintfN("animation_data.nla_tracks[/"%s/"].strips[/"%s/"]",					                    name_esc_nlt, name_esc_strip);				}			}		}	}		/* no path */	return BLI_strdup("");}

/* Get locale's elements (if relevant pointer is not NULL and element actually exists, e.g. if there is no variant, * *variant and *language_variant will always be NULL). * Non-null elements are always MEM_mallocN'ed, it's the caller's responsibility to free them. * NOTE: Keep that one always available, you never know, may become useful even in no-WITH_INTERNATIONAL context... */void BLT_lang_locale_explode(        const char *locale, char **language, char **country, char **variant,        char **language_country, char **language_variant){	char *m1, *m2, *_t = NULL;	m1 = strchr(locale, '_');	m2 = strchr(locale, '@');	if (language || language_variant) {		if (m1 || m2) {			_t = m1 ? BLI_strdupn(locale, m1 - locale) : BLI_strdupn(locale, m2 - locale);			if (language)				*language = _t;		}		else if (language) {			*language = BLI_strdup(locale);		}	}	if (country) {		if (m1)			*country = m2 ? BLI_strdupn(m1 + 1, m2 - (m1 + 1)) : BLI_strdup(m1 + 1);		else			*country = NULL;	}	if (variant) {		if (m2)			*variant = BLI_strdup(m2 + 1);		else			*variant = NULL;	}	if (language_country) {		if (m1)			*language_country = m2 ? BLI_strdupn(locale, m2 - locale) : BLI_strdup(locale);		else			*language_country = NULL;	}	if (language_variant) {		if (m2)			*language_variant = m1 ? BLI_strdupcat(_t, m2) : BLI_strdup(locale);		else			*language_variant = NULL;	}	if (_t && !language) {		MEM_freeN(_t);	}}

static char *rna_ImageUser_path(PointerRNA *ptr){	if (ptr->id.data) {		/* ImageUser *iuser = ptr->data; */				switch (GS(((ID *)ptr->id.data)->name)) {			case ID_TE:			{				return BLI_strdup("image_user");			}			case ID_NT:			{				return rna_Node_ImageUser_path(ptr);			}		}	}		return BLI_strdup("");}

static void node_dynamic_register_type(bNode *node){	nodeRegisterType(&node_all_shaders, node->typeinfo);	/* nodeRegisterType copied it to a new one, so we	 * free the typeinfo itself, but not what it	 * points to: */	MEM_freeN(node->typeinfo);	node->typeinfo = node_dynamic_find_typeinfo(&node_all_shaders, node->id);	MEM_freeN(node->typeinfo->name);	node->typeinfo->name = BLI_strdup(node->name);}

static ConsoleLine *console_lb_add_str__internal(ListBase *lb, char *str, bool own){	ConsoleLine *ci = MEM_callocN(sizeof(ConsoleLine), "ConsoleLine Add");	if (own) ci->line = str;	else ci->line = BLI_strdup(str);		ci->len = ci->len_alloc = strlen(str);		BLI_addtail(lb, ci);	return ci;}

static void rna_ksPath_RnaPath_set(PointerRNA *ptr, const char *value){	KS_Path *ksp = (KS_Path *)ptr->data;	if (ksp->rna_path)		MEM_freeN(ksp->rna_path);		if (value[0])		ksp->rna_path = BLI_strdup(value);	else		ksp->rna_path = NULL;}

void RE_engine_set_error_message(RenderEngine *engine, const char *msg){	Render *re = engine->re;	if (re != NULL) {		RenderResult *rr = RE_AcquireResultRead(re);		if (rr->error != NULL) {			MEM_freeN(rr->error);		}		rr->error = BLI_strdup(msg);		RE_ReleaseResult(re);	}}

static void rna_FCurve_RnaPath_set(PointerRNA *ptr, const char *value){	FCurve *fcu= (FCurve *)ptr->data;	if (fcu->rna_path)		MEM_freeN(fcu->rna_path);		if (strlen(value))		fcu->rna_path= BLI_strdup(value);	else 		fcu->rna_path= NULL;}

static void rna_Text_filename_set(PointerRNA *ptr, const char *value){	Text *text= (Text*)ptr->data;	if(text->name)		MEM_freeN(text->name);	if(value[0])		text->name= BLI_strdup(value);	else		text->name= NULL;}

void BLF_dir_add(const char *path){	DirBLF *dir;		dir = blf_dir_find(path);	if (dir) /* already in the list ? just return. */		return;		dir = (DirBLF *)MEM_callocN(sizeof(DirBLF), "BLF_dir_add");	dir->path = BLI_strdup(path);	BLI_addhead(&global_font_dir, dir);}

static void rna_DriverTarget_RnaPath_set(PointerRNA *ptr, const char *value){	DriverTarget *dtar= (DriverTarget *)ptr->data;		// XXX in this case we need to be very careful, as this will require some new dependencies to be added!	if (dtar->rna_path)		MEM_freeN(dtar->rna_path);		if (strlen(value))		dtar->rna_path= BLI_strdup(value);	else 		dtar->rna_path= NULL;}

char *blf_dir_search(const char *file){	DirBLF *dir;	char full_path[FILE_MAX];	char *s = NULL;	for (dir = global_font_dir.first; dir; dir = dir->next) {		BLI_join_dirfile(full_path, sizeof(full_path), dir->path, file);		if (BLI_exists(full_path)) {			s = BLI_strdup(full_path);			break;		}	}	if (!s) {		/* check the current directory, why not ? */		if (BLI_exists(file))			s = BLI_strdup(file);	}	return s;}

/** * Generate an empty PreviewImage, if not yet existing. */PreviewImage *BKE_previewimg_cached_ensure(const char *name){	PreviewImage *prv = NULL;	void **key_p, **prv_p;	if (!BLI_ghash_ensure_p_ex(gCachedPreviews, name, &key_p, &prv_p)) {		*key_p = BLI_strdup(name);		*prv_p = BKE_previewimg_create();	}	prv = *prv_p;	BLI_assert(prv);	return prv;}

/** * Generate a PreviewImage from given file path, using thumbnails management, if not yet existing. */PreviewImage *BKE_previewimg_cached_thumbnail_read(        const char *name, const char *path, const int source, bool force_update){	PreviewImage *prv = NULL;	void **prv_p;	prv_p = BLI_ghash_lookup_p(gCachedPreviews, name);	if (prv_p) {		prv = *prv_p;		BLI_assert(prv);	}	if (prv && force_update) {		const char *prv_deferred_data = PRV_DEFERRED_DATA(prv);		if (((int)prv_deferred_data[0] == source) && STREQ(&prv_deferred_data[1], path)) {			/* If same path, no need to re-allocate preview, just clear it up. */			BKE_previewimg_clear(prv);		}		else {			BKE_previewimg_free(&prv);		}	}	if (!prv) {		/* We pack needed data for lazy loading (source type, in a single char, and path). */		const size_t deferred_data_size = strlen(path) + 2;		char *deferred_data;		prv = previewimg_create_ex(deferred_data_size);		deferred_data = PRV_DEFERRED_DATA(prv);		deferred_data[0] = source;		memcpy(&deferred_data[1], path, deferred_data_size - 1);		force_update = true;	}	if (force_update) {		if (prv_p) {			*prv_p = prv;		}		else {			BLI_ghash_insert(gCachedPreviews, BLI_strdup(name), prv);		}	}	return prv;}

void BLT_lang_init(void){#ifdef WITH_INTERNATIONAL	const char * const messagepath = BKE_appdir_folder_id(BLENDER_DATAFILES, "locale");#endif	/* Make sure LANG is correct and wouldn't cause std::rumtime_error. */#ifndef _WIN32	/* TODO(sergey): This code only ensures LANG is set properly, so later when	 * Cycles will try to use file system API from boost there'll be no runtime	 * exception generated by std::locale() which _requires_ having proper LANG	 * set in the environment.	 *	 * Ideally we also need to ensure LC_ALL, LC_MESSAGES and others are also	 * set to a proper value, but currently it's not a huge deal and doesn't	 * cause any headache.	 *	 * Would also be good to find nicer way to check if LANG is correct.	 */	const char *lang = getenv("LANG");	if (lang != NULL) {		char *old_locale = setlocale(LC_ALL, NULL);		/* Make a copy so subsequenct setlocale() doesn't interfere. */		old_locale = BLI_strdup(old_locale);		if (setlocale(LC_ALL, lang) == NULL) {			setenv("LANG", "C", 1);			printf("Warning: Falling back to the standard locale (/"C/")/n");		}		setlocale(LC_ALL, old_locale);		MEM_freeN(old_locale);	}#endif#ifdef WITH_INTERNATIONAL	if (messagepath) {		bl_locale_init(messagepath, TEXT_DOMAIN_NAME);		fill_locales();	}	else {		printf("%s: 'locale' data path for translations not found, continuing/n", __func__);	}#else#endif}