void (*strset_clear_func)(struct strset *) =
reinitialize ? strset_partial_clear : strset_clear;
- /*
- * We marked opti->paths with strdup_strings = 0, so that we
- * wouldn't have to make another copy of the fullpath created by
- * make_traverse_path from setup_path_info(). But, now that we've
- * used it and have no other references to these strings, it is time
- * to deallocate them.
- */
- free_strmap_strings(&opti->paths);
- strmap_clear_func(&opti->paths, 1);
+ if (opti->pool)
+ strmap_clear_func(&opti->paths, 0);
+ else {
+ /*
+ * We marked opti->paths with strdup_strings = 0, so that
+ * we wouldn't have to make another copy of the fullpath
+ * created by make_traverse_path from setup_path_info().
+ * But, now that we've used it and have no other references
+ * to these strings, it is time to deallocate them.
+ */
+ free_strmap_strings(&opti->paths);
+ strmap_clear_func(&opti->paths, 1);
+ }
/*
* All keys and values in opti->conflicted are a subset of those in
*/
strmap_clear_func(&opti->conflicted, 0);
- /*
- * opti->paths_to_free is similar to opti->paths; we created it with
- * strdup_strings = 0 to avoid making _another_ copy of the fullpath
- * but now that we've used it and have no other references to these
- * strings, it is time to deallocate them. We do so by temporarily
- * setting strdup_strings to 1.
- */
- opti->paths_to_free.strdup_strings = 1;
- string_list_clear(&opti->paths_to_free, 0);
- opti->paths_to_free.strdup_strings = 0;
+ if (!opti->pool) {
+ /*
+ * opti->paths_to_free is similar to opti->paths; we
+ * created it with strdup_strings = 0 to avoid making
+ * _another_ copy of the fullpath but now that we've used
+ * it and have no other references to these strings, it is
+ * time to deallocate them. We do so by temporarily
+ * setting strdup_strings to 1.
+ */
+ opti->paths_to_free.strdup_strings = 1;
+ string_list_clear(&opti->paths_to_free, 0);
+ opti->paths_to_free.strdup_strings = 0;
+ }
if (opti->attr_index.cache_nr) /* true iff opt->renormalize */
discard_index(&opti->attr_index);
strbuf_addch(sb, '\n');
}
-MAYBE_UNUSED
static void *pool_calloc(struct mem_pool *pool, size_t count, size_t size)
{
if (!pool)
return mem_pool_calloc(pool, count, size);
}
-MAYBE_UNUSED
static void *pool_alloc(struct mem_pool *pool, size_t size)
{
if (!pool)
return mem_pool_alloc(pool, size);
}
-MAYBE_UNUSED
static void *pool_strndup(struct mem_pool *pool, const char *str, size_t len)
{
if (!pool)
assert(!df_conflict || !resolved); /* df_conflict implies !resolved */
assert(resolved == (merged_version != NULL));
- mi = xcalloc(1, resolved ? sizeof(struct merged_info) :
- sizeof(struct conflict_info));
+ mi = pool_calloc(opt->priv->pool, 1,
+ resolved ? sizeof(struct merged_info) :
+ sizeof(struct conflict_info));
mi->directory_name = current_dir_name;
mi->basename_offset = current_dir_name_len;
mi->clean = !!resolved;
len = traverse_path_len(info, p->pathlen);
/* +1 in both of the following lines to include the NUL byte */
- fullpath = xmalloc(len + 1);
+ fullpath = pool_alloc(opt->priv->pool, len + 1);
make_traverse_path(fullpath, len + 1, info, p->path, p->pathlen);
/*
copy = renames->deferred[side].possible_trivial_merges;
strintmap_init_with_options(&renames->deferred[side].possible_trivial_merges,
0,
- NULL,
+ opt->priv->pool,
0);
strintmap_for_each_entry(©, &iter, entry) {
const char *path = entry->key;
VERIFY_CI(ci);
/* Find parent directories missing from opt->priv->paths */
- cur_path = new_path;
+ if (opt->priv->pool) {
+ cur_path = mem_pool_strdup(opt->priv->pool, new_path);
+ free((char*)new_path);
+ new_path = (char *)cur_path;
+ } else {
+ cur_path = new_path;
+ }
+
while (1) {
/* Find the parent directory of cur_path */
char *last_slash = strrchr(cur_path, '/');
if (last_slash) {
- parent_name = xstrndup(cur_path, last_slash - cur_path);
+ parent_name = pool_strndup(opt->priv->pool,
+ cur_path,
+ last_slash - cur_path);
} else {
parent_name = opt->priv->toplevel_dir;
break;
/* Look it up in opt->priv->paths */
entry = strmap_get_entry(&opt->priv->paths, parent_name);
if (entry) {
- free((char*)parent_name);
+ if (!opt->priv->pool)
+ free((char*)parent_name);
parent_name = entry->key; /* reuse known pointer */
break;
}
parent_name = cur_dir;
}
- /*
- * We are removing old_path from opt->priv->paths. old_path also will
- * eventually need to be freed, but it may still be used by e.g.
- * ci->pathnames. So, store it in another string-list for now.
- */
- string_list_append(&opt->priv->paths_to_free, old_path);
+ if (!opt->priv->pool) {
+ /*
+ * We are removing old_path from opt->priv->paths.
+ * old_path also will eventually need to be freed, but it
+ * may still be used by e.g. ci->pathnames. So, store it
+ * in another string-list for now.
+ */
+ string_list_append(&opt->priv->paths_to_free, old_path);
+ }
assert(ci->filemask == 2 || ci->filemask == 4);
assert(ci->dirmask == 0);
new_ci->stages[index].mode = ci->stages[index].mode;
oidcpy(&new_ci->stages[index].oid, &ci->stages[index].oid);
- free(ci);
+ if (!opt->priv->pool)
+ free(ci);
ci = new_ci;
}
* the directory to remain here, so we need to move this
* path to some new location.
*/
- CALLOC_ARRAY(new_ci, 1);
+ new_ci = pool_calloc(opt->priv->pool, 1, sizeof(*new_ci));
+
/* We don't really want new_ci->merged.result copied, but it'll
* be overwritten below so it doesn't matter. We also don't
* want any directory mode/oid values copied, but we'll zero
const char *a_path = NULL, *b_path = NULL;
int rename_a = 0, rename_b = 0;
- new_ci = xmalloc(sizeof(*new_ci));
+ new_ci = pool_alloc(opt->priv->pool, sizeof(*new_ci));
if (S_ISREG(a_mode))
rename_a = 1;
strmap_remove(&opt->priv->paths, path, 0);
/*
* We removed path from opt->priv->paths. path
- * will also eventually need to be freed, but
- * it may still be used by e.g. ci->pathnames.
- * So, store it in another string-list for now.
+ * will also eventually need to be freed if not
+ * part of a memory pool...but it may still be
+ * used by e.g. ci->pathnames. So, store it in
+ * another string-list for now in that case.
*/
- string_list_append(&opt->priv->paths_to_free,
- path);
+ if (!opt->priv->pool)
+ string_list_append(&opt->priv->paths_to_free,
+ path);
}
/*
{
struct rename_info *renames;
int i;
+ struct mem_pool *pool = NULL;
/* Sanity checks on opt */
trace2_region_enter("merge", "sanity checks", opt->repo);
#else
opt->priv->pool = NULL;
#endif
+ pool = opt->priv->pool;
for (i = MERGE_SIDE1; i <= MERGE_SIDE2; i++) {
strintmap_init_with_options(&renames->dirs_removed[i],
- NOT_RELEVANT, NULL, 0);
+ NOT_RELEVANT, pool, 0);
strmap_init_with_options(&renames->dir_rename_count[i],
NULL, 1);
strmap_init_with_options(&renames->dir_renames[i],
*/
strintmap_init_with_options(&renames->relevant_sources[i],
-1 /* explicitly invalid */,
- NULL, 0);
+ pool, 0);
strmap_init_with_options(&renames->cached_pairs[i],
NULL, 1);
strset_init_with_options(&renames->cached_irrelevant[i],
}
for (i = MERGE_SIDE1; i <= MERGE_SIDE2; i++) {
strintmap_init_with_options(&renames->deferred[i].possible_trivial_merges,
- 0, NULL, 0);
+ 0, pool, 0);
strset_init_with_options(&renames->deferred[i].target_dirs,
- NULL, 1);
+ pool, 1);
renames->deferred[i].trivial_merges_okay = 1; /* 1 == maybe */
}
* In contrast, conflicted just has a subset of keys from paths, so
* we don't want to free those (it'd be a duplicate free).
*/
- strmap_init_with_options(&opt->priv->paths, NULL, 0);
- strmap_init_with_options(&opt->priv->conflicted, NULL, 0);
- string_list_init_nodup(&opt->priv->paths_to_free);
+ strmap_init_with_options(&opt->priv->paths, pool, 0);
+ strmap_init_with_options(&opt->priv->conflicted, pool, 0);
+ if (!opt->priv->pool)
+ string_list_init_nodup(&opt->priv->paths_to_free);
/*
* keys & strbufs in output will sometimes need to outlive "paths",
projects / thirdparty / git.git / commitdiff
