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);
	}
}