kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

use CALLOC_ARRAY 

Add and apply a semantic patch for converting code that open-codes
CALLOC_ARRAY to use it instead.  It shortens the code and infers the
element size automatically.

Signed-off-by: René Scharfe <l.s.r@web.de>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
René Scharfe 2021-03-13 17:17:22 +01:00 committed by Junio C Hamano
parent f1121499e6
commit ca56dadb4b
88 changed files with 190 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
add-interactive.c
View File

@ -476,7 +476,7 @@ static void collect_changes_cb(struct diff_queue_struct *q,


add_file_item(s->files, name); add_file_item(s->files, name);


entry = xcalloc(sizeof(*entry), 1); CALLOC_ARRAY(entry, 1);
hashmap_entry_init(&entry->ent, hash); hashmap_entry_init(&entry->ent, hash);
entry->name = s->files->items[s->files->nr - 1].string; entry->name = s->files->items[s->files->nr - 1].string;
entry->item = s->files->items[s->files->nr - 1].util; entry->item = s->files->items[s->files->nr - 1].util;

6
apply.c
View File

@ -1781,7 +1781,7 @@ static int parse_single_patch(struct apply_state *state,
struct fragment *fragment; struct fragment *fragment;
int len; int len;


fragment = xcalloc(1, sizeof(*fragment)); CALLOC_ARRAY(fragment, 1);
fragment->linenr = state->linenr; fragment->linenr = state->linenr;
len = parse_fragment(state, line, size, patch, fragment); len = parse_fragment(state, line, size, patch, fragment);
if (len <= 0) { if (len <= 0) {
@ -1959,7 +1959,7 @@ static struct fragment *parse_binary_hunk(struct apply_state *state,
size -= llen; size -= llen;
} }


frag = xcalloc(1, sizeof(*frag)); CALLOC_ARRAY(frag, 1);
frag->patch = inflate_it(data, hunk_size, origlen); frag->patch = inflate_it(data, hunk_size, origlen);
frag->free_patch = 1; frag->free_patch = 1;
if (!frag->patch) if (!frag->patch)
@ -4681,7 +4681,7 @@ static int apply_patch(struct apply_state *state,
struct patch *patch; struct patch *patch;
int nr; int nr;


patch = xcalloc(1, sizeof(*patch)); CALLOC_ARRAY(patch, 1);
patch->inaccurate_eof = !!(options & APPLY_OPT_INACCURATE_EOF); patch->inaccurate_eof = !!(options & APPLY_OPT_INACCURATE_EOF);
patch->recount = !!(options & APPLY_OPT_RECOUNT); patch->recount = !!(options & APPLY_OPT_RECOUNT);
nr = parse_chunk(state, buf.buf + offset, buf.len - offset, patch); nr = parse_chunk(state, buf.buf + offset, buf.len - offset, patch);

2
archive-tar.c
View File

@ -371,7 +371,7 @@ static int tar_filter_config(const char *var, const char *value, void *data)


ar = find_tar_filter(name, namelen); ar = find_tar_filter(name, namelen);
if (!ar) { if (!ar) {
ar = xcalloc(1, sizeof(*ar)); CALLOC_ARRAY(ar, 1);
ar->name = xmemdupz(name, namelen); ar->name = xmemdupz(name, namelen);
ar->write_archive = write_tar_filter_archive; ar->write_archive = write_tar_filter_archive;
ar->flags = ARCHIVER_WANT_COMPRESSION_LEVELS | ar->flags = ARCHIVER_WANT_COMPRESSION_LEVELS |

12
attr.c
View File

@ -569,7 +569,7 @@ struct attr_check *attr_check_initl(const char *one, ...)
check = attr_check_alloc(); check = attr_check_alloc();
check->nr = cnt; check->nr = cnt;
check->alloc = cnt; check->alloc = cnt;
check->items = xcalloc(cnt, sizeof(struct attr_check_item)); CALLOC_ARRAY(check->items, cnt);


check->items[0].attr = git_attr(one); check->items[0].attr = git_attr(one);
va_start(params, one); va_start(params, one);
@ -670,7 +670,7 @@ static struct attr_stack *read_attr_from_array(const char **list)
const char *line; const char *line;
int lineno = 0; int lineno = 0;


res = xcalloc(1, sizeof(*res)); CALLOC_ARRAY(res, 1);
while ((line = *(list++)) != NULL) while ((line = *(list++)) != NULL)
handle_attr_line(res, line, "[builtin]", ++lineno, 1); handle_attr_line(res, line, "[builtin]", ++lineno, 1);
return res; return res;
@ -707,7 +707,7 @@ static struct attr_stack *read_attr_from_file(const char *path, int macro_ok)


if (!fp) if (!fp)
return NULL; return NULL;
res = xcalloc(1, sizeof(*res)); CALLOC_ARRAY(res, 1);
while (fgets(buf, sizeof(buf), fp)) { while (fgets(buf, sizeof(buf), fp)) {
char *bufp = buf; char *bufp = buf;
if (!lineno) if (!lineno)
@ -733,7 +733,7 @@ static struct attr_stack *read_attr_from_index(const struct index_state *istate,
if (!buf) if (!buf)
return NULL; return NULL;


res = xcalloc(1, sizeof(*res)); CALLOC_ARRAY(res, 1);
for (sp = buf; *sp; ) { for (sp = buf; *sp; ) {
char *ep; char *ep;
int more; int more;
@ -774,7 +774,7 @@ static struct attr_stack *read_attr(const struct index_state *istate,
} }


if (!res) if (!res)
res = xcalloc(1, sizeof(*res)); CALLOC_ARRAY(res, 1);
return res; return res;
} }


@ -874,7 +874,7 @@ static void bootstrap_attr_stack(const struct index_state *istate,
else else
e = NULL; e = NULL;
if (!e) if (!e)
e = xcalloc(1, sizeof(struct attr_stack)); CALLOC_ARRAY(e, 1);
push_stack(stack, e, NULL, 0); push_stack(stack, e, NULL, 0);
} }



2
bisect.c
View File

@ -423,7 +423,7 @@ void find_bisection(struct commit_list **commit_list, int *reaches,
show_list("bisection 2 sorted", 0, nr, list); show_list("bisection 2 sorted", 0, nr, list);


*all = nr; *all = nr;
weights = xcalloc(on_list, sizeof(*weights)); CALLOC_ARRAY(weights, on_list);


/* Do the real work of finding bisection commit. */ /* Do the real work of finding bisection commit. */
best = do_find_bisection(list, nr, weights, bisect_flags); best = do_find_bisection(list, nr, weights, bisect_flags);

17
blame.c
View File

@ -951,13 +951,13 @@ static int *fuzzy_find_matching_lines(struct blame_origin *parent,
max_search_distance_b = ((2 * max_search_distance_a + 1) * length_b max_search_distance_b = ((2 * max_search_distance_a + 1) * length_b
- 1) / length_a; - 1) / length_a;


result = xcalloc(sizeof(int), length_b); CALLOC_ARRAY(result, length_b);
second_best_result = xcalloc(sizeof(int), length_b); CALLOC_ARRAY(second_best_result, length_b);
certainties = xcalloc(sizeof(int), length_b); CALLOC_ARRAY(certainties, length_b);


/* See get_similarity() for details of similarities. */ /* See get_similarity() for details of similarities. */
similarity_count = length_b * (max_search_distance_a * 2 + 1); similarity_count = length_b * (max_search_distance_a * 2 + 1);
similarities = xcalloc(sizeof(int), similarity_count); CALLOC_ARRAY(similarities, similarity_count);


for (i = 0; i < length_b; ++i) { for (i = 0; i < length_b; ++i) {
result[i] = -1; result[i] = -1;
@ -995,7 +995,7 @@ static void fill_origin_fingerprints(struct blame_origin *o)
return; return;
o->num_lines = find_line_starts(&line_starts, o->file.ptr, o->num_lines = find_line_starts(&line_starts, o->file.ptr,
o->file.size); o->file.size);
o->fingerprints = xcalloc(sizeof(struct fingerprint), o->num_lines); CALLOC_ARRAY(o->fingerprints, o->num_lines);
get_line_fingerprints(o->fingerprints, o->file.ptr, line_starts, get_line_fingerprints(o->fingerprints, o->file.ptr, line_starts,
0, o->num_lines); 0, o->num_lines);
free(line_starts); free(line_starts);
@ -1853,8 +1853,7 @@ static void blame_chunk(struct blame_entry ***dstq, struct blame_entry ***srcq,
diffp = NULL; diffp = NULL;


if (ignore_diffs && same - tlno > 0) { if (ignore_diffs && same - tlno > 0) {
line_blames = xcalloc(sizeof(struct blame_line_tracker), CALLOC_ARRAY(line_blames, same - tlno);
same - tlno);
guess_line_blames(parent, target, tlno, offset, same, guess_line_blames(parent, target, tlno, offset, same,
parent_len, line_blames); parent_len, line_blames);
} }
@ -2216,7 +2215,7 @@ static struct blame_list *setup_blame_list(struct blame_entry *unblamed,
for (e = unblamed, num_ents = 0; e; e = e->next) for (e = unblamed, num_ents = 0; e; e = e->next)
num_ents++; num_ents++;
if (num_ents) { if (num_ents) {
blame_list = xcalloc(num_ents, sizeof(struct blame_list)); CALLOC_ARRAY(blame_list, num_ents);
for (e = unblamed, i = 0; e; e = e->next) for (e = unblamed, i = 0; e; e = e->next)
blame_list[i++].ent = e; blame_list[i++].ent = e;
} }
@ -2428,7 +2427,7 @@ static void pass_blame(struct blame_scoreboard *sb, struct blame_origin *origin,
else if (num_sg < ARRAY_SIZE(sg_buf)) else if (num_sg < ARRAY_SIZE(sg_buf))
memset(sg_buf, 0, sizeof(sg_buf)); memset(sg_buf, 0, sizeof(sg_buf));
else else
sg_origin = xcalloc(num_sg, sizeof(*sg_origin)); CALLOC_ARRAY(sg_origin, num_sg);


/* /*
* The first pass looks for unrenamed path to optimize for * The first pass looks for unrenamed path to optimize for

2
bloom.c
View File

@ -277,7 +277,7 @@ struct bloom_filter *get_or_compute_bloom_filter(struct repository *r,
*computed |= BLOOM_TRUNC_EMPTY; *computed |= BLOOM_TRUNC_EMPTY;
filter->len = 1; filter->len = 1;
} }
filter->data = xcalloc(filter->len, sizeof(unsigned char)); CALLOC_ARRAY(filter->data, filter->len);


hashmap_for_each_entry(&pathmap, &iter, e, entry) { hashmap_for_each_entry(&pathmap, &iter, e, entry) {
struct bloom_key key; struct bloom_key key;

2
builtin/clean.c
View File

@ -623,7 +623,7 @@ static int *list_and_choose(struct menu_opts *opts, struct menu_stuff *stuff)
nr += chosen[i]; nr += chosen[i];
} }


result = xcalloc(st_add(nr, 1), sizeof(int)); CALLOC_ARRAY(result, st_add(nr, 1));
for (i = 0; i < stuff->nr && j < nr; i++) { for (i = 0; i < stuff->nr && j < nr; i++) {
if (chosen[i]) if (chosen[i])
result[j++] = i; result[j++] = i;

8
builtin/fast-import.c
View File

@ -3322,7 +3322,7 @@ static void option_rewrite_submodules(const char *arg, struct string_list *list)
die(_("Expected format name:filename for submodule rewrite option")); die(_("Expected format name:filename for submodule rewrite option"));
*f = '\0'; *f = '\0';
f++; f++;
ms = xcalloc(1, sizeof(*ms)); CALLOC_ARRAY(ms, 1);


fp = fopen(f, "r"); fp = fopen(f, "r");
if (!fp) if (!fp)
@ -3519,9 +3519,9 @@ int cmd_fast_import(int argc, const char **argv, const char *prefix)


alloc_objects(object_entry_alloc); alloc_objects(object_entry_alloc);
strbuf_init(&command_buf, 0); strbuf_init(&command_buf, 0);
atom_table = xcalloc(atom_table_sz, sizeof(struct atom_str*)); CALLOC_ARRAY(atom_table, atom_table_sz);
branch_table = xcalloc(branch_table_sz, sizeof(struct branch*)); CALLOC_ARRAY(branch_table, branch_table_sz);
avail_tree_table = xcalloc(avail_tree_table_sz, sizeof(struct avail_tree_content*)); CALLOC_ARRAY(avail_tree_table, avail_tree_table_sz);
marks = mem_pool_calloc(&fi_mem_pool, 1, sizeof(struct mark_set)); marks = mem_pool_calloc(&fi_mem_pool, 1, sizeof(struct mark_set));


hashmap_init(&object_table, object_entry_hashcmp, NULL, 0); hashmap_init(&object_table, object_entry_hashcmp, NULL, 0);

2
builtin/grep.c
View File

@ -211,7 +211,7 @@ static void start_threads(struct grep_opt *opt)
strbuf_init(&todo[i].out, 0); strbuf_init(&todo[i].out, 0);
} }


threads = xcalloc(num_threads, sizeof(*threads)); CALLOC_ARRAY(threads, num_threads);
for (i = 0; i < num_threads; i++) { for (i = 0; i < num_threads; i++) {
int err; int err;
struct grep_opt *o = grep_opt_dup(opt); struct grep_opt *o = grep_opt_dup(opt);

10
builtin/index-pack.c
View File

@ -185,7 +185,7 @@ static void init_thread(void)
if (show_stat) if (show_stat)
pthread_mutex_init(&deepest_delta_mutex, NULL); pthread_mutex_init(&deepest_delta_mutex, NULL);
pthread_key_create(&key, NULL); pthread_key_create(&key, NULL);
thread_data = xcalloc(nr_threads, sizeof(*thread_data)); CALLOC_ARRAY(thread_data, nr_threads);
for (i = 0; i < nr_threads; i++) { for (i = 0; i < nr_threads; i++) {
thread_data[i].pack_fd = open(curr_pack, O_RDONLY); thread_data[i].pack_fd = open(curr_pack, O_RDONLY);
if (thread_data[i].pack_fd == -1) if (thread_data[i].pack_fd == -1)
@ -1674,7 +1674,7 @@ static void show_pack_info(int stat_only)
unsigned long *chain_histogram = NULL; unsigned long *chain_histogram = NULL;


if (deepest_delta) if (deepest_delta)
chain_histogram = xcalloc(deepest_delta, sizeof(unsigned long)); CALLOC_ARRAY(chain_histogram, deepest_delta);


for (i = 0; i < nr_objects; i++) { for (i = 0; i < nr_objects; i++) {
struct object_entry *obj = &objects[i]; struct object_entry *obj = &objects[i];
@ -1912,10 +1912,10 @@ int cmd_index_pack(int argc, const char **argv, const char *prefix)


curr_pack = open_pack_file(pack_name); curr_pack = open_pack_file(pack_name);
parse_pack_header(); parse_pack_header();
objects = xcalloc(st_add(nr_objects, 1), sizeof(struct object_entry)); CALLOC_ARRAY(objects, st_add(nr_objects, 1));
if (show_stat) if (show_stat)
obj_stat = xcalloc(st_add(nr_objects, 1), sizeof(struct object_stat)); CALLOC_ARRAY(obj_stat, st_add(nr_objects, 1));
ofs_deltas = xcalloc(nr_objects, sizeof(struct ofs_delta_entry)); CALLOC_ARRAY(ofs_deltas, nr_objects);
parse_pack_objects(pack_hash); parse_pack_objects(pack_hash);
if (report_end_of_input) if (report_end_of_input)
write_in_full(2, "\0", 1); write_in_full(2, "\0", 1);

2
builtin/ls-remote.c
View File

@ -88,7 +88,7 @@ int cmd_ls_remote(int argc, const char **argv, const char *prefix)


if (argc > 1) { if (argc > 1) {
int i; int i;
pattern = xcalloc(argc, sizeof(const char *)); CALLOC_ARRAY(pattern, argc);
for (i = 1; i < argc; i++) { for (i = 1; i < argc; i++) {
pattern[i - 1] = xstrfmt("*/%s", argv[i]); pattern[i - 1] = xstrfmt("*/%s", argv[i]);
} }

2
builtin/merge.c
View File

@ -210,7 +210,7 @@ static struct strategy *get_strategy(const char *name)
exit(1); exit(1);
} }


ret = xcalloc(1, sizeof(struct strategy)); CALLOC_ARRAY(ret, 1);
ret->name = xstrdup(name); ret->name = xstrdup(name);
ret->attr = NO_TRIVIAL; ret->attr = NO_TRIVIAL;
return ret; return ret;

2
builtin/notes.c
View File

@ -730,7 +730,7 @@ static int merge_commit(struct notes_merge_options *o)
else else
oidclr(&parent_oid); oidclr(&parent_oid);


t = xcalloc(1, sizeof(struct notes_tree)); CALLOC_ARRAY(t, 1);
init_notes(t, "NOTES_MERGE_PARTIAL", combine_notes_overwrite, 0); init_notes(t, "NOTES_MERGE_PARTIAL", combine_notes_overwrite, 0);


o->local_ref = local_ref_to_free = o->local_ref = local_ref_to_free =

8
builtin/pack-objects.c
View File

@ -1635,7 +1635,7 @@ static void add_preferred_base(struct object_id *oid)
} }
} }


it = xcalloc(1, sizeof(*it)); CALLOC_ARRAY(it, 1);
it->next = pbase_tree; it->next = pbase_tree;
pbase_tree = it; pbase_tree = it;


@ -2096,7 +2096,7 @@ static void get_object_details(void)
progress_state = start_progress(_("Counting objects"), progress_state = start_progress(_("Counting objects"),
to_pack.nr_objects); to_pack.nr_objects);


sorted_by_offset = xcalloc(to_pack.nr_objects, sizeof(struct object_entry *)); CALLOC_ARRAY(sorted_by_offset, to_pack.nr_objects);
for (i = 0; i < to_pack.nr_objects; i++) for (i = 0; i < to_pack.nr_objects; i++)
sorted_by_offset[i] = to_pack.objects + i; sorted_by_offset[i] = to_pack.objects + i;
QSORT(sorted_by_offset, to_pack.nr_objects, pack_offset_sort); QSORT(sorted_by_offset, to_pack.nr_objects, pack_offset_sort);
@ -2428,7 +2428,7 @@ static void find_deltas(struct object_entry **list, unsigned *list_size,
struct unpacked *array; struct unpacked *array;
unsigned long mem_usage = 0; unsigned long mem_usage = 0;


array = xcalloc(window, sizeof(struct unpacked)); CALLOC_ARRAY(array, window);


for (;;) { for (;;) {
struct object_entry *entry; struct object_entry *entry;
@ -2665,7 +2665,7 @@ static void ll_find_deltas(struct object_entry **list, unsigned list_size,
if (progress > pack_to_stdout) if (progress > pack_to_stdout)
fprintf_ln(stderr, _("Delta compression using up to %d threads"), fprintf_ln(stderr, _("Delta compression using up to %d threads"),
delta_search_threads); delta_search_threads);
p = xcalloc(delta_search_threads, sizeof(*p)); CALLOC_ARRAY(p, delta_search_threads);


/* Partition the work amongst work threads. */ /* Partition the work amongst work threads. */
for (i = 0; i < delta_search_threads; i++) { for (i = 0; i < delta_search_threads; i++) {

2
builtin/pack-redundant.c
View File

@ -373,7 +373,7 @@ static void sort_pack_list(struct pack_list **pl)
return; return;


/* prepare an array of packed_list for easier sorting */ /* prepare an array of packed_list for easier sorting */
ary = xcalloc(n, sizeof(struct pack_list *)); CALLOC_ARRAY(ary, n);
for (n = 0, p = *pl; p; p = p->next) for (n = 0, p = *pl; p; p = p->next)
ary[n++] = p; ary[n++] = p;



4
builtin/receive-pack.c
View File

@ -358,7 +358,7 @@ static void proc_receive_ref_append(const char *prefix)
char *p; char *p;
int len; int len;


ref_pattern = xcalloc(1, sizeof(struct proc_receive_ref)); CALLOC_ARRAY(ref_pattern, 1);
p = strchr(prefix, ':'); p = strchr(prefix, ':');
if (p) { if (p) {
while (prefix < p) { while (prefix < p) {
@ -1024,7 +1024,7 @@ static int read_proc_receive_report(struct packet_reader *reader,
} }
if (new_report) { if (new_report) {
if (!hint->report) { if (!hint->report) {
hint->report = xcalloc(1, sizeof(struct ref_push_report)); CALLOC_ARRAY(hint->report, 1);
report = hint->report; report = hint->report;
} else { } else {
report = hint->report; report = hint->report;

4
builtin/unpack-objects.c
View File

@ -46,7 +46,7 @@ static struct obj_buffer *lookup_object_buffer(struct object *base)
static void add_object_buffer(struct object *object, char *buffer, unsigned long size) static void add_object_buffer(struct object *object, char *buffer, unsigned long size)
{ {
struct obj_buffer *obj; struct obj_buffer *obj;
obj = xcalloc(1, sizeof(struct obj_buffer)); CALLOC_ARRAY(obj, 1);
obj->buffer = buffer; obj->buffer = buffer;
obj->size = size; obj->size = size;
if (add_decoration(&obj_decorate, object, obj)) if (add_decoration(&obj_decorate, object, obj))
@ -500,7 +500,7 @@ static void unpack_all(void)


if (!quiet) if (!quiet)
progress = start_progress(_("Unpacking objects"), nr_objects); progress = start_progress(_("Unpacking objects"), nr_objects);
obj_list = xcalloc(nr_objects, sizeof(*obj_list)); CALLOC_ARRAY(obj_list, nr_objects);
for (i = 0; i < nr_objects; i++) { for (i = 0; i < nr_objects; i++) {
unpack_one(i); unpack_one(i);
display_progress(progress, i + 1); display_progress(progress, i + 1);

2
bulk-checkin.c
View File

@ -211,7 +211,7 @@ static int deflate_to_pack(struct bulk_checkin_state *state,


/* Note: idx is non-NULL when we are writing */ /* Note: idx is non-NULL when we are writing */
if ((flags & HASH_WRITE_OBJECT) != 0) if ((flags & HASH_WRITE_OBJECT) != 0)
idx = xcalloc(1, sizeof(*idx)); CALLOC_ARRAY(idx, 1);


already_hashed_to = 0; already_hashed_to = 0;



2
cache-tree.c
View File

@ -564,7 +564,7 @@ static struct cache_tree *read_one(const char **buffer, unsigned long *size_p)
* hence +2. * hence +2.
*/ */
it->subtree_alloc = subtree_nr + 2; it->subtree_alloc = subtree_nr + 2;
it->down = xcalloc(it->subtree_alloc, sizeof(struct cache_tree_sub *)); CALLOC_ARRAY(it->down, it->subtree_alloc);
for (i = 0; i < subtree_nr; i++) { for (i = 0; i < subtree_nr; i++) {
/* read each subtree */ /* read each subtree */
struct cache_tree *sub; struct cache_tree *sub;

20
combine-diff.c
View File

@ -214,11 +214,11 @@ static struct lline *coalesce_lines(struct lline *base, int *lenbase,
* - Else if we have NEW, insert newend lline into base and * - Else if we have NEW, insert newend lline into base and
* consume newend * consume newend
*/ */
lcs = xcalloc(st_add(origbaselen, 1), sizeof(int*)); CALLOC_ARRAY(lcs, st_add(origbaselen, 1));
directions = xcalloc(st_add(origbaselen, 1), sizeof(enum coalesce_direction*)); CALLOC_ARRAY(directions, st_add(origbaselen, 1));
for (i = 0; i < origbaselen + 1; i++) { for (i = 0; i < origbaselen + 1; i++) {
lcs[i] = xcalloc(st_add(lennew, 1), sizeof(int)); CALLOC_ARRAY(lcs[i], st_add(lennew, 1));
directions[i] = xcalloc(st_add(lennew, 1), sizeof(enum coalesce_direction)); CALLOC_ARRAY(directions[i], st_add(lennew, 1));
directions[i][0] = BASE; directions[i][0] = BASE;
} }
for (j = 1; j < lennew + 1; j++) for (j = 1; j < lennew + 1; j++)
@ -398,8 +398,8 @@ static void consume_hunk(void *state_,
state->lost_bucket = &state->sline[state->nb-1]; state->lost_bucket = &state->sline[state->nb-1];
} }
if (!state->sline[state->nb-1].p_lno) if (!state->sline[state->nb-1].p_lno)
state->sline[state->nb-1].p_lno = CALLOC_ARRAY(state->sline[state->nb - 1].p_lno,
xcalloc(state->num_parent, sizeof(unsigned long)); state->num_parent);
state->sline[state->nb-1].p_lno[state->n] = state->ob; state->sline[state->nb-1].p_lno[state->n] = state->ob;
} }


@ -1159,7 +1159,7 @@ static void show_patch_diff(struct combine_diff_path *elem, int num_parent,
if (result_size && result[result_size-1] != '\n') if (result_size && result[result_size-1] != '\n')
cnt++; /* incomplete line */ cnt++; /* incomplete line */


sline = xcalloc(st_add(cnt, 2), sizeof(*sline)); CALLOC_ARRAY(sline, st_add(cnt, 2));
sline[0].bol = result; sline[0].bol = result;
for (lno = 0, cp = result; cp < result + result_size; cp++) { for (lno = 0, cp = result; cp < result + result_size; cp++) {
if (*cp == '\n') { if (*cp == '\n') {
@ -1178,7 +1178,7 @@ static void show_patch_diff(struct combine_diff_path *elem, int num_parent,
/* Even p_lno[cnt+1] is valid -- that is for the end line number /* Even p_lno[cnt+1] is valid -- that is for the end line number
* for deletion hunk at the end. * for deletion hunk at the end.
*/ */
sline[0].p_lno = xcalloc(st_mult(st_add(cnt, 2), num_parent), sizeof(unsigned long)); CALLOC_ARRAY(sline[0].p_lno, st_mult(st_add(cnt, 2), num_parent));
for (lno = 0; lno <= cnt; lno++) for (lno = 0; lno <= cnt; lno++)
sline[lno+1].p_lno = sline[lno].p_lno + num_parent; sline[lno+1].p_lno = sline[lno].p_lno + num_parent;


@ -1319,7 +1319,7 @@ static struct diff_filepair *combined_pair(struct combine_diff_path *p,
struct diff_filespec *pool; struct diff_filespec *pool;


pair = xmalloc(sizeof(*pair)); pair = xmalloc(sizeof(*pair));
pool = xcalloc(st_add(num_parent, 1), sizeof(struct diff_filespec)); CALLOC_ARRAY(pool, st_add(num_parent, 1));
pair->one = pool + 1; pair->one = pool + 1;
pair->two = pool; pair->two = pool;


@ -1348,7 +1348,7 @@ static void handle_combined_callback(struct diff_options *opt,
struct diff_queue_struct q; struct diff_queue_struct q;
int i; int i;


q.queue = xcalloc(num_paths, sizeof(struct diff_filepair *)); CALLOC_ARRAY(q.queue, num_paths);
q.alloc = num_paths; q.alloc = num_paths;
q.nr = num_paths; q.nr = num_paths;
for (i = 0, p = paths; p; p = p->next) for (i = 0, p = paths; p; p = p->next)

4
commit-graph.c
View File

@ -516,7 +516,7 @@ static struct commit_graph *load_commit_graph_chain(struct repository *r,
return NULL; return NULL;


count = st.st_size / (the_hash_algo->hexsz + 1); count = st.st_size / (the_hash_algo->hexsz + 1);
oids = xcalloc(count, sizeof(struct object_id)); CALLOC_ARRAY(oids, count);


prepare_alt_odb(r); prepare_alt_odb(r);


@ -2238,7 +2238,7 @@ int write_commit_graph(struct object_directory *odb,
if (!commit_graph_compatible(the_repository)) if (!commit_graph_compatible(the_repository))
return 0; return 0;


ctx = xcalloc(1, sizeof(struct write_commit_graph_context)); CALLOC_ARRAY(ctx, 1);
ctx->r = the_repository; ctx->r = the_repository;
ctx->odb = odb; ctx->odb = odb;
ctx->append = flags & COMMIT_GRAPH_WRITE_APPEND ? 1 : 0; ctx->append = flags & COMMIT_GRAPH_WRITE_APPEND ? 1 : 0;

6
commit-reach.c
View File

@ -183,7 +183,7 @@ static int remove_redundant_no_gen(struct repository *r,
int *filled_index; int *filled_index;
int i, j, filled; int i, j, filled;


work = xcalloc(cnt, sizeof(*work)); CALLOC_ARRAY(work, cnt);
redundant = xcalloc(cnt, 1); redundant = xcalloc(cnt, 1);
ALLOC_ARRAY(filled_index, cnt - 1); ALLOC_ARRAY(filled_index, cnt - 1);


@ -399,7 +399,7 @@ static struct commit_list *get_merge_bases_many_0(struct repository *r,


/* There are more than one */ /* There are more than one */
cnt = commit_list_count(result); cnt = commit_list_count(result);
rslt = xcalloc(cnt, sizeof(*rslt)); CALLOC_ARRAY(rslt, cnt);
for (list = result, i = 0; list; list = list->next) for (list = result, i = 0; list; list = list->next)
rslt[i++] = list->item; rslt[i++] = list->item;
free_commit_list(result); free_commit_list(result);
@ -541,7 +541,7 @@ struct commit_list *reduce_heads(struct commit_list *heads)
p->item->object.flags |= STALE; p->item->object.flags |= STALE;
num_head++; num_head++;
} }
array = xcalloc(num_head, sizeof(*array)); CALLOC_ARRAY(array, num_head);
for (p = heads, i = 0; p; p = p->next) { for (p = heads, i = 0; p; p = p->next) {
if (p->item->object.flags & STALE) { if (p->item->object.flags & STALE) {
array[i++] = p->item; array[i++] = p->item;

4
commit.c
View File

@ -1171,7 +1171,7 @@ static void handle_signed_tag(struct commit *parent, struct commit_extra_header
* if (verify_signed_buffer(buf, len, buf + len, size - len, ...)) * if (verify_signed_buffer(buf, len, buf + len, size - len, ...))
* warn("warning: signed tag unverified."); * warn("warning: signed tag unverified.");
*/ */
mergetag = xcalloc(1, sizeof(*mergetag)); CALLOC_ARRAY(mergetag, 1);
mergetag->key = xstrdup("mergetag"); mergetag->key = xstrdup("mergetag");
mergetag->value = buf; mergetag->value = buf;
mergetag->len = size; mergetag->len = size;
@ -1336,7 +1336,7 @@ static struct commit_extra_header *read_commit_extra_header_lines(
excluded_header_field(line, eof - line, exclude)) excluded_header_field(line, eof - line, exclude))
continue; continue;


it = xcalloc(1, sizeof(*it)); CALLOC_ARRAY(it, 1);
it->key = xmemdupz(line, eof-line); it->key = xmemdupz(line, eof-line);
*tail = it; *tail = it;
tail = &it->next; tail = &it->next;

2
config.c
View File

@ -2269,7 +2269,7 @@ static void repo_read_config(struct repository *repo)
opts.git_dir = repo->gitdir; opts.git_dir = repo->gitdir;


if (!repo->config) if (!repo->config)
repo->config = xcalloc(1, sizeof(struct config_set)); CALLOC_ARRAY(repo->config, 1);
else else
git_configset_clear(repo->config); git_configset_clear(repo->config);



8
contrib/coccinelle/array.cocci
View File

@ -88,3 +88,11 @@ expression n;
@@ @@
- ptr = xmalloc((n) * sizeof(T)); - ptr = xmalloc((n) * sizeof(T));
+ ALLOC_ARRAY(ptr, n); + ALLOC_ARRAY(ptr, n);

@@
type T;
T *ptr;
expression n;
@@
- ptr = xcalloc(n, \( sizeof(*ptr) \| sizeof(T) \) )
+ CALLOC_ARRAY(ptr, n)

2
convert.c
View File

@ -1028,7 +1028,7 @@ static int read_convert_config(const char *var, const char *value, void *cb)
if (!strncmp(drv->name, name, namelen) && !drv->name[namelen]) if (!strncmp(drv->name, name, namelen) && !drv->name[namelen])
break; break;
if (!drv) { if (!drv) {
drv = xcalloc(1, sizeof(struct convert_driver)); CALLOC_ARRAY(drv, 1);
drv->name = xmemdupz(name, namelen); drv->name = xmemdupz(name, namelen);
*user_convert_tail = drv; *user_convert_tail = drv;
user_convert_tail = &(drv->next); user_convert_tail = &(drv->next);

4
daemon.c
View File

@ -840,7 +840,7 @@ static void add_child(struct child_process *cld, struct sockaddr *addr, socklen_
{ {
struct child *newborn, **cradle; struct child *newborn, **cradle;


newborn = xcalloc(1, sizeof(*newborn)); CALLOC_ARRAY(newborn, 1);
live_children++; live_children++;
memcpy(&newborn->cld, cld, sizeof(*cld)); memcpy(&newborn->cld, cld, sizeof(*cld));
memcpy(&newborn->address, addr, addrlen); memcpy(&newborn->address, addr, addrlen);
@ -1148,7 +1148,7 @@ static int service_loop(struct socketlist *socklist)
struct pollfd *pfd; struct pollfd *pfd;
int i; int i;


pfd = xcalloc(socklist->nr, sizeof(struct pollfd)); CALLOC_ARRAY(pfd, socklist->nr);


for (i = 0; i < socklist->nr; i++) { for (i = 0; i < socklist->nr; i++) {
pfd[i].fd = socklist->list[i]; pfd[i].fd = socklist->list[i];

2
decorate.c
View File

@ -39,7 +39,7 @@ static void grow_decoration(struct decoration *n)
struct decoration_entry *old_entries = n->entries; struct decoration_entry *old_entries = n->entries;


n->size = (old_size + 1000) * 3 / 2; n->size = (old_size + 1000) * 3 / 2;
n->entries = xcalloc(n->size, sizeof(struct decoration_entry)); CALLOC_ARRAY(n->entries, n->size);
n->nr = 0; n->nr = 0;


for (i = 0; i < old_size; i++) { for (i = 0; i < old_size; i++) {

10
diff.c
View File

@ -2233,14 +2233,12 @@ static void init_diff_words_data(struct emit_callback *ecbdata,
struct diff_options *o = xmalloc(sizeof(struct diff_options)); struct diff_options *o = xmalloc(sizeof(struct diff_options));
memcpy(o, orig_opts, sizeof(struct diff_options)); memcpy(o, orig_opts, sizeof(struct diff_options));


ecbdata->diff_words = CALLOC_ARRAY(ecbdata->diff_words, 1);
xcalloc(1, sizeof(struct diff_words_data));
ecbdata->diff_words->type = o->word_diff; ecbdata->diff_words->type = o->word_diff;
ecbdata->diff_words->opt = o; ecbdata->diff_words->opt = o;


if (orig_opts->emitted_symbols) if (orig_opts->emitted_symbols)
o->emitted_symbols = CALLOC_ARRAY(o->emitted_symbols, 1);
xcalloc(1, sizeof(struct emitted_diff_symbols));


if (!o->word_regex) if (!o->word_regex)
o->word_regex = userdiff_word_regex(one, o->repo->index); o->word_regex = userdiff_word_regex(one, o->repo->index);
@ -2509,7 +2507,7 @@ static struct diffstat_file *diffstat_add(struct diffstat_t *diffstat,
const char *name_b) const char *name_b)
{ {
struct diffstat_file *x; struct diffstat_file *x;
x = xcalloc(1, sizeof(*x)); CALLOC_ARRAY(x, 1);
ALLOC_GROW(diffstat->files, diffstat->nr + 1, diffstat->alloc); ALLOC_GROW(diffstat->files, diffstat->nr + 1, diffstat->alloc);
diffstat->files[diffstat->nr++] = x; diffstat->files[diffstat->nr++] = x;
if (name_b) { if (name_b) {
@ -4918,7 +4916,7 @@ static int diff_opt_find_object(const struct option *option,
return error(_("unable to resolve '%s'"), arg); return error(_("unable to resolve '%s'"), arg);


if (!opt->objfind) if (!opt->objfind)
opt->objfind = xcalloc(1, sizeof(*opt->objfind)); CALLOC_ARRAY(opt->objfind, 1);


opt->pickaxe_opts |= DIFF_PICKAXE_KIND_OBJFIND; opt->pickaxe_opts |= DIFF_PICKAXE_KIND_OBJFIND;
opt->flags.recursive = 1; opt->flags.recursive = 1;

3
diffcore-rename.c
View File

@ -787,8 +787,7 @@ void diffcore_rename(struct diff_options *options)
(uint64_t)num_destinations * (uint64_t)num_sources); (uint64_t)num_destinations * (uint64_t)num_sources);
} }


mx = xcalloc(st_mult(NUM_CANDIDATE_PER_DST, num_destinations), CALLOC_ARRAY(mx, st_mult(NUM_CANDIDATE_PER_DST, num_destinations));
sizeof(*mx));
for (dst_cnt = i = 0; i < rename_dst_nr; i++) { for (dst_cnt = i = 0; i < rename_dst_nr; i++) {
struct diff_filespec *two = rename_dst[i].p->two; struct diff_filespec *two = rename_dst[i].p->two;
struct diff_score *m; struct diff_score *m;

6
dir.c
View File

@ -1488,7 +1488,7 @@ static void prep_exclude(struct dir_struct *dir,
const char *cp; const char *cp;
struct oid_stat oid_stat; struct oid_stat oid_stat;


stk = xcalloc(1, sizeof(*stk)); CALLOC_ARRAY(stk, 1);
if (current < 0) { if (current < 0) {
cp = base; cp = base;
current = 0; current = 0;
@ -3162,7 +3162,7 @@ void write_untracked_extension(struct strbuf *out, struct untracked_cache *untra
int varint_len; int varint_len;
const unsigned hashsz = the_hash_algo->rawsz; const unsigned hashsz = the_hash_algo->rawsz;


ouc = xcalloc(1, sizeof(*ouc)); CALLOC_ARRAY(ouc, 1);
stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat); stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);
stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat); stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);
ouc->dir_flags = htonl(untracked->dir_flags); ouc->dir_flags = htonl(untracked->dir_flags);
@ -3373,7 +3373,7 @@ struct untracked_cache *read_untracked_extension(const void *data, unsigned long
if (next + exclude_per_dir_offset + 1 > end) if (next + exclude_per_dir_offset + 1 > end)
return NULL; return NULL;


uc = xcalloc(1, sizeof(*uc)); CALLOC_ARRAY(uc, 1);
strbuf_init(&uc->ident, ident_len); strbuf_init(&uc->ident, ident_len);
strbuf_add(&uc->ident, ident, ident_len); strbuf_add(&uc->ident, ident, ident_len);
load_oid_stat(&uc->ss_info_exclude, load_oid_stat(&uc->ss_info_exclude,

2
ewah/bitmap.c
View File

@ -25,7 +25,7 @@
struct bitmap *bitmap_word_alloc(size_t word_alloc) struct bitmap *bitmap_word_alloc(size_t word_alloc)
{ {
struct bitmap *bitmap = xmalloc(sizeof(struct bitmap)); struct bitmap *bitmap = xmalloc(sizeof(struct bitmap));
bitmap->words = xcalloc(word_alloc, sizeof(eword_t)); CALLOC_ARRAY(bitmap->words, word_alloc);
bitmap->word_alloc = word_alloc; bitmap->word_alloc = word_alloc;
return bitmap; return bitmap;
} }

2
fetch-pack.c
View File

@ -1916,7 +1916,7 @@ static void update_shallow(struct fetch_pack_args *args,
* remote is also shallow, check what ref is safe to update * remote is also shallow, check what ref is safe to update
* without updating .git/shallow * without updating .git/shallow
*/ */
status = xcalloc(nr_sought, sizeof(*status)); CALLOC_ARRAY(status, nr_sought);
assign_shallow_commits_to_refs(si, NULL, status); assign_shallow_commits_to_refs(si, NULL, status);
if (si->nr_ours || si->nr_theirs) { if (si->nr_ours || si->nr_theirs) {
for (i = 0; i < nr_sought; i++) for (i = 0; i < nr_sought; i++)

2
fmt-merge-msg.c
View File

@ -130,7 +130,7 @@ static int handle_line(char *line, struct merge_parents *merge_parents)
if (!find_merge_parent(merge_parents, &oid, NULL)) if (!find_merge_parent(merge_parents, &oid, NULL))
return 0; /* subsumed by other parents */ return 0; /* subsumed by other parents */


origin_data = xcalloc(1, sizeof(struct origin_data)); CALLOC_ARRAY(origin_data, 1);
oidcpy(&origin_data->oid, &oid); oidcpy(&origin_data->oid, &oid);


if (line[len - 1] == '\n') if (line[len - 1] == '\n')

8
grep.c
View File

@ -621,7 +621,7 @@ static struct grep_expr *compile_pattern_atom(struct grep_pat **list)
case GREP_PATTERN: /* atom */ case GREP_PATTERN: /* atom */
case GREP_PATTERN_HEAD: case GREP_PATTERN_HEAD:
case GREP_PATTERN_BODY: case GREP_PATTERN_BODY:
x = xcalloc(1, sizeof (struct grep_expr)); CALLOC_ARRAY(x, 1);
x->node = GREP_NODE_ATOM; x->node = GREP_NODE_ATOM;
x->u.atom = p; x->u.atom = p;
*list = p->next; *list = p->next;
@ -651,7 +651,7 @@ static struct grep_expr *compile_pattern_not(struct grep_pat **list)
if (!p->next) if (!p->next)
die("--not not followed by pattern expression"); die("--not not followed by pattern expression");
*list = p->next; *list = p->next;
x = xcalloc(1, sizeof (struct grep_expr)); CALLOC_ARRAY(x, 1);
x->node = GREP_NODE_NOT; x->node = GREP_NODE_NOT;
x->u.unary = compile_pattern_not(list); x->u.unary = compile_pattern_not(list);
if (!x->u.unary) if (!x->u.unary)
@ -676,7 +676,7 @@ static struct grep_expr *compile_pattern_and(struct grep_pat **list)
y = compile_pattern_and(list); y = compile_pattern_and(list);
if (!y) if (!y)
die("--and not followed by pattern expression"); die("--and not followed by pattern expression");
z = xcalloc(1, sizeof (struct grep_expr)); CALLOC_ARRAY(z, 1);
z->node = GREP_NODE_AND; z->node = GREP_NODE_AND;
z->u.binary.left = x; z->u.binary.left = x;
z->u.binary.right = y; z->u.binary.right = y;
@ -696,7 +696,7 @@ static struct grep_expr *compile_pattern_or(struct grep_pat **list)
y = compile_pattern_or(list); y = compile_pattern_or(list);
if (!y) if (!y)
die("not a pattern expression %s", p->pattern); die("not a pattern expression %s", p->pattern);
z = xcalloc(1, sizeof (struct grep_expr)); CALLOC_ARRAY(z, 1);
z->node = GREP_NODE_OR; z->node = GREP_NODE_OR;
z->u.binary.left = x; z->u.binary.left = x;
z->u.binary.right = y; z->u.binary.right = y;

2
hashmap.c
View File

@ -76,7 +76,7 @@ unsigned int memihash_cont(unsigned int hash_seed, const void *buf, size_t len)
static void alloc_table(struct hashmap *map, unsigned int size) static void alloc_table(struct hashmap *map, unsigned int size)
{ {
map->tablesize = size; map->tablesize = size;
map->table = xcalloc(size, sizeof(struct hashmap_entry *)); CALLOC_ARRAY(map->table, size);


/* calculate resize thresholds for new size */ /* calculate resize thresholds for new size */
map->grow_at = (unsigned int) ((uint64_t) size * HASHMAP_LOAD_FACTOR / 100); map->grow_at = (unsigned int) ((uint64_t) size * HASHMAP_LOAD_FACTOR / 100);

2
http-backend.c
View File

@ -39,7 +39,7 @@ static struct string_list *get_parameters(void)
if (!query_params) { if (!query_params) {
const char *query = getenv("QUERY_STRING"); const char *query = getenv("QUERY_STRING");


query_params = xcalloc(1, sizeof(*query_params)); CALLOC_ARRAY(query_params, 1);
while (query && *query) { while (query && *query) {
char *name = url_decode_parameter_name(&query); char *name = url_decode_parameter_name(&query);
char *value = url_decode_parameter_value(&query); char *value = url_decode_parameter_value(&query);

4
http-push.c
View File

@ -896,7 +896,7 @@ static struct remote_lock *lock_remote(const char *path, long timeout)
curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers); curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, dav_headers);
curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer); curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);


lock = xcalloc(1, sizeof(*lock)); CALLOC_ARRAY(lock, 1);
lock->timeout = -1; lock->timeout = -1;


if (start_active_slot(slot)) { if (start_active_slot(slot)) {
@ -1713,7 +1713,7 @@ int cmd_main(int argc, const char **argv)
int new_refs; int new_refs;
struct ref *ref, *local_refs; struct ref *ref, *local_refs;


repo = xcalloc(1, sizeof(*repo)); CALLOC_ARRAY(repo, 1);


argv++; argv++;
for (i = 1; i < argc; i++, argv++) { for (i = 1; i < argc; i++, argv++) {

4
http.c
View File

@ -2324,7 +2324,7 @@ struct http_pack_request *new_direct_http_pack_request(
off_t prev_posn = 0; off_t prev_posn = 0;
struct http_pack_request *preq; struct http_pack_request *preq;


preq = xcalloc(1, sizeof(*preq)); CALLOC_ARRAY(preq, 1);
strbuf_init(&preq->tmpfile, 0); strbuf_init(&preq->tmpfile, 0);


preq->url = url; preq->url = url;
@ -2419,7 +2419,7 @@ struct http_object_request *new_http_object_request(const char *base_url,
off_t prev_posn = 0; off_t prev_posn = 0;
struct http_object_request *freq; struct http_object_request *freq;


freq = xcalloc(1, sizeof(*freq)); CALLOC_ARRAY(freq, 1);
strbuf_init(&freq->tmpfile, 0); strbuf_init(&freq->tmpfile, 0);
oidcpy(&freq->oid, oid); oidcpy(&freq->oid, oid);
freq->localfile = -1; freq->localfile = -1;

4
imap-send.c
View File

@ -963,9 +963,9 @@ static struct imap_store *imap_open_store(struct imap_server_conf *srvc, const c
char *arg, *rsp; char *arg, *rsp;
int s = -1, preauth; int s = -1, preauth;


ctx = xcalloc(1, sizeof(*ctx)); CALLOC_ARRAY(ctx, 1);


ctx->imap = imap = xcalloc(1, sizeof(*imap)); ctx->imap = CALLOC_ARRAY(imap, 1);
imap->buf.sock.fd[0] = imap->buf.sock.fd[1] = -1; imap->buf.sock.fd[0] = imap->buf.sock.fd[1] = -1;
imap->in_progress_append = &imap->in_progress; imap->in_progress_append = &imap->in_progress;



2
line-log.c
View File

@ -296,7 +296,7 @@ static void line_log_data_insert(struct line_log_data **list,
return; return;
} }


p = xcalloc(1, sizeof(struct line_log_data)); CALLOC_ARRAY(p, 1);
p->path = path; p->path = path;
range_set_append(&p->ranges, begin, end); range_set_append(&p->ranges, begin, end);
if (ip) { if (ip) {

2
line-range.c
View File

@ -202,7 +202,7 @@ static const char *parse_range_funcname(
drv = userdiff_find_by_path(istate, path); drv = userdiff_find_by_path(istate, path);
if (drv && drv->funcname.pattern) { if (drv && drv->funcname.pattern) {
const struct userdiff_funcname *pe = &drv->funcname; const struct userdiff_funcname *pe = &drv->funcname;
xecfg = xcalloc(1, sizeof(*xecfg)); CALLOC_ARRAY(xecfg, 1);
xdiff_set_find_func(xecfg, pe->pattern, pe->cflags); xdiff_set_find_func(xecfg, pe->pattern, pe->cflags);
} }



6
list-objects-filter.c
View File

@ -186,7 +186,7 @@ static enum list_objects_filter_result filter_trees_depth(
seen_info = oidmap_get( seen_info = oidmap_get(
&filter_data->seen_at_depth, &obj->oid); &filter_data->seen_at_depth, &obj->oid);
if (!seen_info) { if (!seen_info) {
seen_info = xcalloc(1, sizeof(*seen_info)); CALLOC_ARRAY(seen_info, 1);
oidcpy(&seen_info->base.oid, &obj->oid); oidcpy(&seen_info->base.oid, &obj->oid);
seen_info->depth = filter_data->current_depth; seen_info->depth = filter_data->current_depth;
oidmap_put(&filter_data->seen_at_depth, seen_info); oidmap_put(&filter_data->seen_at_depth, seen_info);
@ -626,7 +626,7 @@ static void filter_combine__init(
size_t sub; size_t sub;


d->nr = filter_options->sub_nr; d->nr = filter_options->sub_nr;
d->sub = xcalloc(d->nr, sizeof(*d->sub)); CALLOC_ARRAY(d->sub, d->nr);
for (sub = 0; sub < d->nr; sub++) for (sub = 0; sub < d->nr; sub++)
d->sub[sub].filter = list_objects_filter__init( d->sub[sub].filter = list_objects_filter__init(
filter->omits ? &d->sub[sub].omits : NULL, filter->omits ? &d->sub[sub].omits : NULL,
@ -674,7 +674,7 @@ struct filter *list_objects_filter__init(
if (!init_fn) if (!init_fn)
return NULL; return NULL;


filter = xcalloc(1, sizeof(*filter)); CALLOC_ARRAY(filter, 1);
filter->omits = omitted; filter->omits = omitted;
init_fn(filter_options, filter); init_fn(filter_options, filter);
return filter; return filter;

2
ll-merge.c
View File

@ -268,7 +268,7 @@ static int read_merge_config(const char *var, const char *value, void *cb)
if (!strncmp(fn->name, name, namelen) && !fn->name[namelen]) if (!strncmp(fn->name, name, namelen) && !fn->name[namelen])
break; break;
if (!fn) { if (!fn) {
fn = xcalloc(1, sizeof(struct ll_merge_driver)); CALLOC_ARRAY(fn, 1);
fn->name = xmemdupz(name, namelen); fn->name = xmemdupz(name, namelen);
fn->fn = ll_ext_merge; fn->fn = ll_ext_merge;
*ll_user_merge_tail = fn; *ll_user_merge_tail = fn;

2
mailmap.c
View File

@ -83,7 +83,7 @@ static void add_mapping(struct string_list *map,
if (item->util) { if (item->util) {
me = (struct mailmap_entry *)item->util; me = (struct mailmap_entry *)item->util;
} else { } else {
me = xcalloc(1, sizeof(struct mailmap_entry)); CALLOC_ARRAY(me, 1);
me->namemap.strdup_strings = 1; me->namemap.strdup_strings = 1;
me->namemap.cmp = namemap_cmp; me->namemap.cmp = namemap_cmp;
item->util = me; item->util = me;

9
merge-ort.c
View File

@ -1576,8 +1576,7 @@ static void compute_collisions(struct strmap *collisions,
if (collision_info) { if (collision_info) {
free(new_path); free(new_path);
} else { } else {
collision_info = xcalloc(1, CALLOC_ARRAY(collision_info, 1);
sizeof(struct collision_info));
string_list_init(&collision_info->source_files, 0); string_list_init(&collision_info->source_files, 0);
strmap_put(collisions, new_path, collision_info); strmap_put(collisions, new_path, collision_info);
} }
@ -1718,7 +1717,7 @@ static void apply_directory_rename_modifications(struct merge_options *opt,
struct conflict_info *dir_ci; struct conflict_info *dir_ci;
char *cur_dir = dirs_to_insert.items[i].string; char *cur_dir = dirs_to_insert.items[i].string;


dir_ci = xcalloc(1, sizeof(*dir_ci)); CALLOC_ARRAY(dir_ci, 1);


dir_ci->merged.directory_name = parent_name; dir_ci->merged.directory_name = parent_name;
len = strlen(parent_name); len = strlen(parent_name);
@ -2703,7 +2702,7 @@ static void process_entry(struct merge_options *opt,
* the directory to remain here, so we need to move this * the directory to remain here, so we need to move this
* path to some new location. * path to some new location.
*/ */
new_ci = xcalloc(1, sizeof(*new_ci)); CALLOC_ARRAY(new_ci, 1);
/* We don't really want new_ci->merged.result copied, but it'll /* 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 * be overwritten below so it doesn't matter. We also don't
* want any directory mode/oid values copied, but we'll zero * want any directory mode/oid values copied, but we'll zero
@ -3083,7 +3082,7 @@ static int checkout(struct merge_options *opt,
unpack_opts.verbose_update = (opt->verbosity > 2); unpack_opts.verbose_update = (opt->verbosity > 2);
unpack_opts.fn = twoway_merge; unpack_opts.fn = twoway_merge;
if (1/* FIXME: opts->overwrite_ignore*/) { if (1/* FIXME: opts->overwrite_ignore*/) {
unpack_opts.dir = xcalloc(1, sizeof(*unpack_opts.dir)); CALLOC_ARRAY(unpack_opts.dir, 1);
unpack_opts.dir->flags |= DIR_SHOW_IGNORED; unpack_opts.dir->flags |= DIR_SHOW_IGNORED;
setup_standard_excludes(unpack_opts.dir); setup_standard_excludes(unpack_opts.dir);
} }

9
merge-recursive.c
View File

@ -303,7 +303,7 @@ static inline void setup_rename_conflict_info(enum rename_type rename_type,
return; return;
} }


ci = xcalloc(1, sizeof(struct rename_conflict_info)); CALLOC_ARRAY(ci, 1);
ci->rename_type = rename_type; ci->rename_type = rename_type;
ci->ren1 = ren1; ci->ren1 = ren1;
ci->ren2 = ren2; ci->ren2 = ren2;
@ -2389,8 +2389,7 @@ static void compute_collisions(struct hashmap *collisions,
continue; continue;
collision_ent = collision_find_entry(collisions, new_path); collision_ent = collision_find_entry(collisions, new_path);
if (!collision_ent) { if (!collision_ent) {
collision_ent = xcalloc(1, CALLOC_ARRAY(collision_ent, 1);
sizeof(struct collision_entry));
hashmap_entry_init(&collision_ent->ent, hashmap_entry_init(&collision_ent->ent,
strhash(new_path)); strhash(new_path));
hashmap_put(collisions, &collision_ent->ent); hashmap_put(collisions, &collision_ent->ent);
@ -2594,7 +2593,7 @@ static struct string_list *get_renames(struct merge_options *opt,
struct string_list *renames; struct string_list *renames;


compute_collisions(&collisions, dir_renames, pairs); compute_collisions(&collisions, dir_renames, pairs);
renames = xcalloc(1, sizeof(struct string_list)); CALLOC_ARRAY(renames, 1);


for (i = 0; i < pairs->nr; ++i) { for (i = 0; i < pairs->nr; ++i) {
struct string_list_item *item; struct string_list_item *item;
@ -3664,7 +3663,7 @@ static int merge_start(struct merge_options *opt, struct tree *head)
return -1; return -1;
} }


opt->priv = xcalloc(1, sizeof(*opt->priv)); CALLOC_ARRAY(opt->priv, 1);
string_list_init(&opt->priv->df_conflict_file_set, 1); string_list_init(&opt->priv->df_conflict_file_set, 1);
return 0; return 0;
} }

8
midx.c
View File

@ -145,8 +145,8 @@ struct multi_pack_index *load_multi_pack_index(const char *object_dir, int local


m->num_objects = ntohl(m->chunk_oid_fanout[255]); m->num_objects = ntohl(m->chunk_oid_fanout[255]);


m->pack_names = xcalloc(m->num_packs, sizeof(*m->pack_names)); CALLOC_ARRAY(m->pack_names, m->num_packs);
m->packs = xcalloc(m->num_packs, sizeof(*m->packs)); CALLOC_ARRAY(m->packs, m->num_packs);


cur_pack_name = (const char *)m->chunk_pack_names; cur_pack_name = (const char *)m->chunk_pack_names;
for (i = 0; i < m->num_packs; i++) { for (i = 0; i < m->num_packs; i++) {
@ -1144,7 +1144,7 @@ int expire_midx_packs(struct repository *r, const char *object_dir, unsigned fla
if (!m) if (!m)
return 0; return 0;


count = xcalloc(m->num_packs, sizeof(uint32_t)); CALLOC_ARRAY(count, m->num_packs);


if (flags & MIDX_PROGRESS) if (flags & MIDX_PROGRESS)
progress = start_delayed_progress(_("Counting referenced objects"), progress = start_delayed_progress(_("Counting referenced objects"),
@ -1315,7 +1315,7 @@ int midx_repack(struct repository *r, const char *object_dir, size_t batch_size,
if (!m) if (!m)
return 0; return 0;


include_pack = xcalloc(m->num_packs, sizeof(unsigned char)); CALLOC_ARRAY(include_pack, m->num_packs);


if (batch_size) { if (batch_size) {
if (fill_included_packs_batch(r, m, include_pack, batch_size)) if (fill_included_packs_batch(r, m, include_pack, batch_size))

8
name-hash.c
View File

@ -225,7 +225,7 @@ static void init_dir_mutex(void)
{ {
int j; int j;


lazy_dir_mutex_array = xcalloc(LAZY_MAX_MUTEX, sizeof(pthread_mutex_t)); CALLOC_ARRAY(lazy_dir_mutex_array, LAZY_MAX_MUTEX);


for (j = 0; j < LAZY_MAX_MUTEX; j++) for (j = 0; j < LAZY_MAX_MUTEX; j++)
init_recursive_mutex(&lazy_dir_mutex_array[j]); init_recursive_mutex(&lazy_dir_mutex_array[j]);
@ -514,9 +514,9 @@ static void threaded_lazy_init_name_hash(
k_start = 0; k_start = 0;
nr_each = DIV_ROUND_UP(istate->cache_nr, lazy_nr_dir_threads); nr_each = DIV_ROUND_UP(istate->cache_nr, lazy_nr_dir_threads);


lazy_entries = xcalloc(istate->cache_nr, sizeof(struct lazy_entry)); CALLOC_ARRAY(lazy_entries, istate->cache_nr);
td_dir = xcalloc(lazy_nr_dir_threads, sizeof(struct lazy_dir_thread_data)); CALLOC_ARRAY(td_dir, lazy_nr_dir_threads);
td_name = xcalloc(1, sizeof(struct lazy_name_thread_data)); CALLOC_ARRAY(td_name, 1);


init_dir_mutex(); init_dir_mutex();



2
negotiator/default.c
View File

@ -167,7 +167,7 @@ void default_negotiator_init(struct fetch_negotiator *negotiator)
negotiator->next = next; negotiator->next = next;
negotiator->ack = ack; negotiator->ack = ack;
negotiator->release = release; negotiator->release = release;
negotiator->data = ns = xcalloc(1, sizeof(*ns)); negotiator->data = CALLOC_ARRAY(ns, 1);
ns->rev_list.compare = compare_commits_by_commit_date; ns->rev_list.compare = compare_commits_by_commit_date;


if (marked) if (marked)

4
negotiator/skipping.c
View File

@ -62,7 +62,7 @@ static struct entry *rev_list_push(struct data *data, struct commit *commit, int
struct entry *entry; struct entry *entry;
commit->object.flags |= mark | SEEN; commit->object.flags |= mark | SEEN;


entry = xcalloc(1, sizeof(*entry)); CALLOC_ARRAY(entry, 1);
entry->commit = commit; entry->commit = commit;
prio_queue_put(&data->rev_list, entry); prio_queue_put(&data->rev_list, entry);


@ -241,7 +241,7 @@ void skipping_negotiator_init(struct fetch_negotiator *negotiator)
negotiator->next = next; negotiator->next = next;
negotiator->ack = ack; negotiator->ack = ack;
negotiator->release = release; negotiator->release = release;
negotiator->data = data = xcalloc(1, sizeof(*data)); negotiator->data = CALLOC_ARRAY(data, 1);
data->rev_list.compare = compare; data->rev_list.compare = compare;


if (marked) if (marked)

2
notes-merge.c
View File

@ -136,7 +136,7 @@ static struct notes_merge_pair *diff_tree_remote(struct notes_merge_options *o,
diff_tree_oid(base, remote, "", &opt); diff_tree_oid(base, remote, "", &opt);
diffcore_std(&opt); diffcore_std(&opt);


changes = xcalloc(diff_queued_diff.nr, sizeof(struct notes_merge_pair)); CALLOC_ARRAY(changes, diff_queued_diff.nr);


for (i = 0; i < diff_queued_diff.nr; i++) { for (i = 0; i < diff_queued_diff.nr; i++) {
struct diff_filepair *p = diff_queued_diff.queue[i]; struct diff_filepair *p = diff_queued_diff.queue[i];

2
notes-utils.c
View File

@ -129,7 +129,7 @@ struct notes_rewrite_cfg *init_copy_notes_for_rewrite(const char *cmd)
c->cmd = cmd; c->cmd = cmd;
c->enabled = 1; c->enabled = 1;
c->combine = combine_notes_concatenate; c->combine = combine_notes_concatenate;
c->refs = xcalloc(1, sizeof(struct string_list)); CALLOC_ARRAY(c->refs, 1);
c->refs->strdup_strings = 1; c->refs->strdup_strings = 1;
c->refs_from_env = 0; c->refs_from_env = 0;
c->mode_from_env = 0; c->mode_from_env = 0;

2
notes.c
View File

@ -452,7 +452,7 @@ static void load_subtree(struct notes_tree *t, struct leaf_node *subtree,
goto handle_non_note; goto handle_non_note;
} }


l = xcalloc(1, sizeof(*l)); CALLOC_ARRAY(l, 1);
oidcpy(&l->key_oid, &object_oid); oidcpy(&l->key_oid, &object_oid);
oidcpy(&l->val_oid, &entry.oid); oidcpy(&l->val_oid, &entry.oid);
if (note_tree_insert(t, node, n, l, type, if (note_tree_insert(t, node, n, l, type,

2
object-file.c
View File

@ -546,7 +546,7 @@ static int link_alt_odb_entry(struct repository *r, const char *entry,
return -1; return -1;
} }


ent = xcalloc(1, sizeof(*ent)); CALLOC_ARRAY(ent, 1);
ent->path = xstrdup(pathbuf.buf); ent->path = xstrdup(pathbuf.buf);


/* add the alternate entry */ /* add the alternate entry */

4
object.c
View File

@ -127,7 +127,7 @@ static void grow_object_hash(struct repository *r)
int new_hash_size = r->parsed_objects->obj_hash_size < 32 ? 32 : 2 * r->parsed_objects->obj_hash_size; int new_hash_size = r->parsed_objects->obj_hash_size < 32 ? 32 : 2 * r->parsed_objects->obj_hash_size;
struct object **new_hash; struct object **new_hash;


new_hash = xcalloc(new_hash_size, sizeof(struct object *)); CALLOC_ARRAY(new_hash, new_hash_size);
for (i = 0; i < r->parsed_objects->obj_hash_size; i++) { for (i = 0; i < r->parsed_objects->obj_hash_size; i++) {
struct object *obj = r->parsed_objects->obj_hash[i]; struct object *obj = r->parsed_objects->obj_hash[i];


@ -478,7 +478,7 @@ struct parsed_object_pool *parsed_object_pool_new(void)
o->object_state = allocate_alloc_state(); o->object_state = allocate_alloc_state();


o->is_shallow = -1; o->is_shallow = -1;
o->shallow_stat = xcalloc(1, sizeof(*o->shallow_stat)); CALLOC_ARRAY(o->shallow_stat, 1);


o->buffer_slab = allocate_commit_buffer_slab(); o->buffer_slab = allocate_commit_buffer_slab();



4
pack-bitmap.c
View File

@ -978,7 +978,7 @@ struct bitmap_index *prepare_bitmap_walk(struct rev_info *revs,


/* try to open a bitmapped pack, but don't parse it yet /* try to open a bitmapped pack, but don't parse it yet
* because we may not need to use it */ * because we may not need to use it */
bitmap_git = xcalloc(1, sizeof(*bitmap_git)); CALLOC_ARRAY(bitmap_git, 1);
if (open_pack_bitmap(revs->repo, bitmap_git) < 0) if (open_pack_bitmap(revs->repo, bitmap_git) < 0)
goto cleanup; goto cleanup;


@ -1388,7 +1388,7 @@ uint32_t *create_bitmap_mapping(struct bitmap_index *bitmap_git,
uint32_t *reposition; uint32_t *reposition;


num_objects = bitmap_git->pack->num_objects; num_objects = bitmap_git->pack->num_objects;
reposition = xcalloc(num_objects, sizeof(uint32_t)); CALLOC_ARRAY(reposition, num_objects);


for (i = 0; i < num_objects; ++i) { for (i = 0; i < num_objects; ++i) {
struct object_id oid; struct object_id oid;

2
pack-objects.c
View File

@ -49,7 +49,7 @@ static void rehash_objects(struct packing_data *pdata)
pdata->index_size = 1024; pdata->index_size = 1024;


free(pdata->index); free(pdata->index);
pdata->index = xcalloc(pdata->index_size, sizeof(*pdata->index)); CALLOC_ARRAY(pdata->index, pdata->index_size);


entry = pdata->objects; entry = pdata->objects;



2
packfile.c
View File

@ -638,7 +638,7 @@ unsigned char *use_pack(struct packed_git *p,
if (p->pack_fd == -1 && open_packed_git(p)) if (p->pack_fd == -1 && open_packed_git(p))
die("packfile %s cannot be accessed", p->pack_name); die("packfile %s cannot be accessed", p->pack_name);


win = xcalloc(1, sizeof(*win)); CALLOC_ARRAY(win, 1);
win->offset = (offset / window_align) * window_align; win->offset = (offset / window_align) * window_align;
len = p->pack_size - win->offset; len = p->pack_size - win->offset;
if (len > packed_git_window_size) if (len > packed_git_window_size)

2
patch-ids.c
View File

@ -124,7 +124,7 @@ struct patch_id *add_commit_patch_id(struct commit *commit,
if (!patch_id_defined(commit)) if (!patch_id_defined(commit))
return NULL; return NULL;


key = xcalloc(1, sizeof(*key)); CALLOC_ARRAY(key, 1);
if (init_patch_id_entry(key, commit, ids)) { if (init_patch_id_entry(key, commit, ids)) {
free(key); free(key);
return NULL; return NULL;

4
pathspec.c
View File

@ -154,7 +154,7 @@ static void parse_pathspec_attr_match(struct pathspec_item *item, const char *va
string_list_remove_empty_items(&list, 0); string_list_remove_empty_items(&list, 0);


item->attr_check = attr_check_alloc(); item->attr_check = attr_check_alloc();
item->attr_match = xcalloc(list.nr, sizeof(struct attr_match)); CALLOC_ARRAY(item->attr_match, list.nr);


for_each_string_list_item(si, &list) { for_each_string_list_item(si, &list) {
size_t attr_len; size_t attr_len;
@ -561,7 +561,7 @@ void parse_pathspec(struct pathspec *pathspec,
if (!(flags & PATHSPEC_PREFER_CWD)) if (!(flags & PATHSPEC_PREFER_CWD))
BUG("PATHSPEC_PREFER_CWD requires arguments"); BUG("PATHSPEC_PREFER_CWD requires arguments");


pathspec->items = item = xcalloc(1, sizeof(*item)); pathspec->items = CALLOC_ARRAY(item, 1);
item->match = xstrdup(prefix); item->match = xstrdup(prefix);
item->original = xstrdup(prefix); item->original = xstrdup(prefix);
item->nowildcard_len = item->len = strlen(prefix); item->nowildcard_len = item->len = strlen(prefix);

2
pretty.c
View File

@ -678,7 +678,7 @@ static int mailmap_name(const char **email, size_t *email_len,
{ {
static struct string_list *mail_map; static struct string_list *mail_map;
if (!mail_map) { if (!mail_map) {
mail_map = xcalloc(1, sizeof(*mail_map)); CALLOC_ARRAY(mail_map, 1);
read_mailmap(mail_map); read_mailmap(mail_map);
} }
return mail_map->nr && map_user(mail_map, email, email_len, name, name_len); return mail_map->nr && map_user(mail_map, email, email_len, name, name_len);

2
progress.c
View File

@ -196,7 +196,7 @@ void display_throughput(struct progress *progress, uint64_t total)
now_ns = progress_getnanotime(progress); now_ns = progress_getnanotime(progress);


if (!tp) { if (!tp) {
progress->throughput = tp = xcalloc(1, sizeof(*tp)); progress->throughput = CALLOC_ARRAY(tp, 1);
tp->prev_total = tp->curr_total = total; tp->prev_total = tp->curr_total = total;
tp->prev_ns = now_ns; tp->prev_ns = now_ns;
strbuf_init(&tp->display, 0); strbuf_init(&tp->display, 0);

2
promisor-remote.c
View File

@ -208,7 +208,7 @@ static int remove_fetched_oids(struct repository *repo,


if (remaining_nr) { if (remaining_nr) {
int j = 0; int j = 0;
new_oids = xcalloc(remaining_nr, sizeof(*new_oids)); CALLOC_ARRAY(new_oids, remaining_nr);
for (i = 0; i < oid_nr; i++) for (i = 0; i < oid_nr; i++)
if (remaining[i]) if (remaining[i])
oidcpy(&new_oids[j++], &old_oids[i]); oidcpy(&new_oids[j++], &old_oids[i]);

2
range-diff.c
View File

@ -96,7 +96,7 @@ static int read_patches(const char *range, struct string_list *list,
string_list_append(list, buf.buf)->util = util; string_list_append(list, buf.buf)->util = util;
strbuf_reset(&buf); strbuf_reset(&buf);
} }
util = xcalloc(sizeof(*util), 1); CALLOC_ARRAY(util, 1);
if (get_oid(p, &util->oid)) { if (get_oid(p, &util->oid)) {
error(_("could not parse commit '%s'"), p); error(_("could not parse commit '%s'"), p);
free(util); free(util);

8
read-cache.c
View File

@ -2097,7 +2097,7 @@ static unsigned long load_cache_entries_threaded(struct index_state *istate, con
/* ensure we have no more threads than we have blocks to process */ /* ensure we have no more threads than we have blocks to process */
if (nr_threads > ieot->nr) if (nr_threads > ieot->nr)
nr_threads = ieot->nr; nr_threads = ieot->nr;
data = xcalloc(nr_threads, sizeof(*data)); CALLOC_ARRAY(data, nr_threads);


offset = ieot_start = 0; offset = ieot_start = 0;
ieot_blocks = DIV_ROUND_UP(ieot->nr, nr_threads); ieot_blocks = DIV_ROUND_UP(ieot->nr, nr_threads);
@ -2199,7 +2199,7 @@ int do_read_index(struct index_state *istate, const char *path, int must_exist)
istate->version = ntohl(hdr->hdr_version); istate->version = ntohl(hdr->hdr_version);
istate->cache_nr = ntohl(hdr->hdr_entries); istate->cache_nr = ntohl(hdr->hdr_entries);
istate->cache_alloc = alloc_nr(istate->cache_nr); istate->cache_alloc = alloc_nr(istate->cache_nr);
istate->cache = xcalloc(istate->cache_alloc, sizeof(*istate->cache)); CALLOC_ARRAY(istate->cache, istate->cache_alloc);
istate->initialized = 1; istate->initialized = 1;


p.istate = istate; p.istate = istate;
@ -2326,7 +2326,7 @@ int read_index_from(struct index_state *istate, const char *path,
if (split_index->base) if (split_index->base)
discard_index(split_index->base); discard_index(split_index->base);
else else
split_index->base = xcalloc(1, sizeof(*split_index->base)); CALLOC_ARRAY(split_index->base, 1);


base_oid_hex = oid_to_hex(&split_index->base_oid); base_oid_hex = oid_to_hex(&split_index->base_oid);
base_path = xstrfmt("%s/sharedindex.%s", gitdir, base_oid_hex); base_path = xstrfmt("%s/sharedindex.%s", gitdir, base_oid_hex);
@ -3427,7 +3427,7 @@ void stat_validity_update(struct stat_validity *sv, int fd)
stat_validity_clear(sv); stat_validity_clear(sv);
else { else {
if (!sv->sd) if (!sv->sd)
sv->sd = xcalloc(1, sizeof(struct stat_data)); CALLOC_ARRAY(sv->sd, 1);
fill_stat_data(sv->sd, &st); fill_stat_data(sv->sd, &st);
} }
} }

6
ref-filter.c
View File

@ -1676,7 +1676,7 @@ static int populate_value(struct ref_array_item *ref, struct strbuf *err)
int i; int i;
struct object_info empty = OBJECT_INFO_INIT; struct object_info empty = OBJECT_INFO_INIT;


ref->value = xcalloc(used_atom_cnt, sizeof(struct atom_value)); CALLOC_ARRAY(ref->value, used_atom_cnt);


if (need_symref && (ref->flag & REF_ISSYMREF) && !ref->symref) { if (need_symref && (ref->flag & REF_ISSYMREF) && !ref->symref) {
ref->symref = resolve_refdup(ref->refname, RESOLVE_REF_READING, ref->symref = resolve_refdup(ref->refname, RESOLVE_REF_READING,
@ -2185,7 +2185,7 @@ static void reach_filter(struct ref_array *array,
if (!check_reachable) if (!check_reachable)
return; return;


to_clear = xcalloc(sizeof(struct commit *), array->nr); CALLOC_ARRAY(to_clear, array->nr);


repo_init_revisions(the_repository, &revs, NULL); repo_init_revisions(the_repository, &revs, NULL);


@ -2490,7 +2490,7 @@ void parse_ref_sorting(struct ref_sorting **sorting_tail, const char *arg)
{ {
struct ref_sorting *s; struct ref_sorting *s;


s = xcalloc(1, sizeof(*s)); CALLOC_ARRAY(s, 1);
s->next = *sorting_tail; s->next = *sorting_tail;
*sorting_tail = s; *sorting_tail = s;



4
reflog-walk.c
View File

@ -112,7 +112,7 @@ struct reflog_walk_info {


void init_reflog_walk(struct reflog_walk_info **info) void init_reflog_walk(struct reflog_walk_info **info)
{ {
*info = xcalloc(1, sizeof(struct reflog_walk_info)); CALLOC_ARRAY(*info, 1);
(*info)->complete_reflogs.strdup_strings = 1; (*info)->complete_reflogs.strdup_strings = 1;
} }


@ -181,7 +181,7 @@ int add_reflog_for_walk(struct reflog_walk_info *info,
} }
free(branch); free(branch);


commit_reflog = xcalloc(1, sizeof(struct commit_reflog)); CALLOC_ARRAY(commit_reflog, 1);
if (recno < 0) { if (recno < 0) {
commit_reflog->recno = get_reflog_recno_by_time(reflogs, timestamp); commit_reflog->recno = get_reflog_recno_by_time(reflogs, timestamp);
if (commit_reflog->recno < 0) { if (commit_reflog->recno < 0) {

4
refs.c
View File

@ -1007,7 +1007,7 @@ struct ref_transaction *ref_store_transaction_begin(struct ref_store *refs,
struct ref_transaction *tr; struct ref_transaction *tr;
assert(err); assert(err);


tr = xcalloc(1, sizeof(struct ref_transaction)); CALLOC_ARRAY(tr, 1);
tr->ref_store = refs; tr->ref_store = refs;
return tr; return tr;
} }
@ -1306,7 +1306,7 @@ int parse_hide_refs_config(const char *var, const char *value, const char *secti
while (len && ref[len - 1] == '/') while (len && ref[len - 1] == '/')
ref[--len] = '\0'; ref[--len] = '\0';
if (!hide_refs) { if (!hide_refs) {
hide_refs = xcalloc(1, sizeof(*hide_refs)); CALLOC_ARRAY(hide_refs, 1);
hide_refs->strdup_strings = 1; hide_refs->strdup_strings = 1;
} }
string_list_append(hide_refs, ref); string_list_append(hide_refs, ref);

10
refs/files-backend.c
View File

@ -549,7 +549,7 @@ static int lock_raw_ref(struct files_ref_store *refs,


/* First lock the file so it can't change out from under us. */ /* First lock the file so it can't change out from under us. */


*lock_p = lock = xcalloc(1, sizeof(*lock)); *lock_p = CALLOC_ARRAY(lock, 1);


lock->ref_name = xstrdup(refname); lock->ref_name = xstrdup(refname);
files_ref_path(refs, &ref_file, refname); files_ref_path(refs, &ref_file, refname);
@ -843,7 +843,7 @@ static struct ref_iterator *files_ref_iterator_begin(


overlay_iter = overlay_ref_iterator_begin(loose_iter, packed_iter); overlay_iter = overlay_ref_iterator_begin(loose_iter, packed_iter);


iter = xcalloc(1, sizeof(*iter)); CALLOC_ARRAY(iter, 1);
ref_iterator = &iter->base; ref_iterator = &iter->base;
base_ref_iterator_init(ref_iterator, &files_ref_iterator_vtable, base_ref_iterator_init(ref_iterator, &files_ref_iterator_vtable,
overlay_iter->ordered); overlay_iter->ordered);
@ -930,7 +930,7 @@ static struct ref_lock *lock_ref_oid_basic(struct files_ref_store *refs,
files_assert_main_repository(refs, "lock_ref_oid_basic"); files_assert_main_repository(refs, "lock_ref_oid_basic");
assert(err); assert(err);


lock = xcalloc(1, sizeof(struct ref_lock)); CALLOC_ARRAY(lock, 1);


if (mustexist) if (mustexist)
resolve_flags |= RESOLVE_REF_READING; resolve_flags |= RESOLVE_REF_READING;
@ -2152,7 +2152,7 @@ static struct ref_iterator *reflog_iterator_begin(struct ref_store *ref_store,
return empty_ref_iterator_begin(); return empty_ref_iterator_begin();
} }


iter = xcalloc(1, sizeof(*iter)); CALLOC_ARRAY(iter, 1);
ref_iterator = &iter->base; ref_iterator = &iter->base;


base_ref_iterator_init(ref_iterator, &files_reflog_iterator_vtable, 0); base_ref_iterator_init(ref_iterator, &files_reflog_iterator_vtable, 0);
@ -2597,7 +2597,7 @@ static int files_transaction_prepare(struct ref_store *ref_store,
if (!transaction->nr) if (!transaction->nr)
goto cleanup; goto cleanup;


backend_data = xcalloc(1, sizeof(*backend_data)); CALLOC_ARRAY(backend_data, 1);
transaction->backend_data = backend_data; transaction->backend_data = backend_data;


/* /*

2
refs/iterator.c
View File

@ -393,7 +393,7 @@ struct ref_iterator *prefix_ref_iterator_begin(struct ref_iterator *iter0,
if (!*prefix && !trim) if (!*prefix && !trim)
return iter0; /* optimization: no need to wrap iterator */ return iter0; /* optimization: no need to wrap iterator */


iter = xcalloc(1, sizeof(*iter)); CALLOC_ARRAY(iter, 1);
ref_iterator = &iter->base; ref_iterator = &iter->base;


base_ref_iterator_init(ref_iterator, &prefix_ref_iterator_vtable, iter0->ordered); base_ref_iterator_init(ref_iterator, &prefix_ref_iterator_vtable, iter0->ordered);

4
refs/packed-backend.c
View File

@ -941,7 +941,7 @@ static struct ref_iterator *packed_ref_iterator_begin(
if (start == snapshot->eof) if (start == snapshot->eof)
return empty_ref_iterator_begin(); return empty_ref_iterator_begin();


iter = xcalloc(1, sizeof(*iter)); CALLOC_ARRAY(iter, 1);
ref_iterator = &iter->base; ref_iterator = &iter->base;
base_ref_iterator_init(ref_iterator, &packed_ref_iterator_vtable, 1); base_ref_iterator_init(ref_iterator, &packed_ref_iterator_vtable, 1);


@ -1424,7 +1424,7 @@ static int packed_transaction_prepare(struct ref_store *ref_store,
* do so itself. * do so itself.
*/ */


data = xcalloc(1, sizeof(*data)); CALLOC_ARRAY(data, 1);
string_list_init(&data->updates, 0); string_list_init(&data->updates, 0);


transaction->backend_data = data; transaction->backend_data = data;

2
refs/ref-cache.c
View File

@ -530,7 +530,7 @@ struct ref_iterator *cache_ref_iterator_begin(struct ref_cache *cache,
if (prime_dir) if (prime_dir)
prime_ref_dir(dir, prefix); prime_ref_dir(dir, prefix);


iter = xcalloc(1, sizeof(*iter)); CALLOC_ARRAY(iter, 1);
ref_iterator = &iter->base; ref_iterator = &iter->base;
base_ref_iterator_init(ref_iterator, &cache_ref_iterator_vtable, 1); base_ref_iterator_init(ref_iterator, &cache_ref_iterator_vtable, 1);
ALLOC_GROW(iter->levels, 10, iter->levels_alloc); ALLOC_GROW(iter->levels, 10, iter->levels_alloc);

8
remote.c
View File

@ -151,7 +151,7 @@ static struct remote *make_remote(const char *name, int len)
if (e) if (e)
return container_of(e, struct remote, ent); return container_of(e, struct remote, ent);


ret = xcalloc(1, sizeof(struct remote)); CALLOC_ARRAY(ret, 1);
ret->prune = -1; /* unspecified */ ret->prune = -1; /* unspecified */
ret->prune_tags = -1; /* unspecified */ ret->prune_tags = -1; /* unspecified */
ret->name = xstrndup(name, len); ret->name = xstrndup(name, len);
@ -186,7 +186,7 @@ static struct branch *make_branch(const char *name, size_t len)
} }


ALLOC_GROW(branches, branches_nr + 1, branches_alloc); ALLOC_GROW(branches, branches_nr + 1, branches_alloc);
ret = xcalloc(1, sizeof(struct branch)); CALLOC_ARRAY(ret, 1);
branches[branches_nr++] = ret; branches[branches_nr++] = ret;
ret->name = xstrndup(name, len); ret->name = xstrndup(name, len);
ret->refname = xstrfmt("refs/heads/%s", ret->name); ret->refname = xstrfmt("refs/heads/%s", ret->name);
@ -207,7 +207,7 @@ static struct rewrite *make_rewrite(struct rewrites *r,
} }


ALLOC_GROW(r->rewrite, r->rewrite_nr + 1, r->rewrite_alloc); ALLOC_GROW(r->rewrite, r->rewrite_nr + 1, r->rewrite_alloc);
ret = xcalloc(1, sizeof(struct rewrite)); CALLOC_ARRAY(ret, 1);
r->rewrite[r->rewrite_nr++] = ret; r->rewrite[r->rewrite_nr++] = ret;
ret->base = xstrndup(base, len); ret->base = xstrndup(base, len);
ret->baselen = len; ret->baselen = len;
@ -1664,7 +1664,7 @@ static void set_merge(struct branch *ret)


remote = remote_get(ret->remote_name); remote = remote_get(ret->remote_name);


ret->merge = xcalloc(ret->merge_nr, sizeof(*ret->merge)); CALLOC_ARRAY(ret->merge, ret->merge_nr);
for (i = 0; i < ret->merge_nr; i++) { for (i = 0; i < ret->merge_nr; i++) {
ret->merge[i] = xcalloc(1, sizeof(**ret->merge)); ret->merge[i] = xcalloc(1, sizeof(**ret->merge));
ret->merge[i]->src = xstrdup(ret->merge_name[i]); ret->merge[i]->src = xstrdup(ret->merge_name[i]);

4
repository.c
View File

@ -72,7 +72,7 @@ void repo_set_gitdir(struct repository *repo,
repo_set_commondir(repo, o->commondir); repo_set_commondir(repo, o->commondir);


if (!repo->objects->odb) { if (!repo->objects->odb) {
repo->objects->odb = xcalloc(1, sizeof(*repo->objects->odb)); CALLOC_ARRAY(repo->objects->odb, 1);
repo->objects->odb_tail = &repo->objects->odb->next; repo->objects->odb_tail = &repo->objects->odb->next;
} }
expand_base_dir(&repo->objects->odb->path, o->object_dir, expand_base_dir(&repo->objects->odb->path, o->object_dir,
@ -262,7 +262,7 @@ void repo_clear(struct repository *repo)
int repo_read_index(struct repository *repo) int repo_read_index(struct repository *repo)
{ {
if (!repo->index) if (!repo->index)
repo->index = xcalloc(1, sizeof(*repo->index)); CALLOC_ARRAY(repo->index, 1);


/* Complete the double-reference */ /* Complete the double-reference */
if (!repo->index->repo) if (!repo->index->repo)

4
resolve-undo.c
View File

@ -15,7 +15,7 @@ void record_resolve_undo(struct index_state *istate, struct cache_entry *ce)
return; return;


if (!istate->resolve_undo) { if (!istate->resolve_undo) {
resolve_undo = xcalloc(1, sizeof(*resolve_undo)); CALLOC_ARRAY(resolve_undo, 1);
resolve_undo->strdup_strings = 1; resolve_undo->strdup_strings = 1;
istate->resolve_undo = resolve_undo; istate->resolve_undo = resolve_undo;
} }
@ -57,7 +57,7 @@ struct string_list *resolve_undo_read(const char *data, unsigned long size)
int i; int i;
const unsigned rawsz = the_hash_algo->rawsz; const unsigned rawsz = the_hash_algo->rawsz;


resolve_undo = xcalloc(1, sizeof(*resolve_undo)); CALLOC_ARRAY(resolve_undo, 1);
resolve_undo->strdup_strings = 1; resolve_undo->strdup_strings = 1;


while (size) { while (size) {

6
revision.c
View File

@ -154,7 +154,7 @@ static void paths_and_oids_insert(struct hashmap *map,


entry = hashmap_get_entry(map, &key, ent, NULL); entry = hashmap_get_entry(map, &key, ent, NULL);
if (!entry) { if (!entry) {
entry = xcalloc(1, sizeof(struct path_and_oids_entry)); CALLOC_ARRAY(entry, 1);
hashmap_entry_init(&entry->ent, hash); hashmap_entry_init(&entry->ent, hash);
entry->path = xstrdup(key.path); entry->path = xstrdup(key.path);
oidset_init(&entry->trees, 16); oidset_init(&entry->trees, 16);
@ -1555,7 +1555,7 @@ void clear_ref_exclusion(struct string_list **ref_excludes_p)
void add_ref_exclusion(struct string_list **ref_excludes_p, const char *exclude) void add_ref_exclusion(struct string_list **ref_excludes_p, const char *exclude)
{ {
if (!*ref_excludes_p) { if (!*ref_excludes_p) {
*ref_excludes_p = xcalloc(1, sizeof(**ref_excludes_p)); CALLOC_ARRAY(*ref_excludes_p, 1);
(*ref_excludes_p)->strdup_strings = 1; (*ref_excludes_p)->strdup_strings = 1;
} }
string_list_append(*ref_excludes_p, exclude); string_list_append(*ref_excludes_p, exclude);
@ -2929,7 +2929,7 @@ static struct merge_simplify_state *locate_simplify_state(struct rev_info *revs,


st = lookup_decoration(&revs->merge_simplification, &commit->object); st = lookup_decoration(&revs->merge_simplification, &commit->object);
if (!st) { if (!st) {
st = xcalloc(1, sizeof(*st)); CALLOC_ARRAY(st, 1);
add_decoration(&revs->merge_simplification, &commit->object, st); add_decoration(&revs->merge_simplification, &commit->object, st);
} }
return st; return st;

4
run-command.c
View File

@ -1638,8 +1638,8 @@ static void pp_init(struct parallel_processes *pp,
pp->nr_processes = 0; pp->nr_processes = 0;
pp->output_owner = 0; pp->output_owner = 0;
pp->shutdown = 0; pp->shutdown = 0;
pp->children = xcalloc(n, sizeof(*pp->children)); CALLOC_ARRAY(pp->children, n);
pp->pfd = xcalloc(n, sizeof(*pp->pfd)); CALLOC_ARRAY(pp->pfd, n);
strbuf_init(&pp->buffered_output, 0); strbuf_init(&pp->buffered_output, 0);


for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {

4
send-pack.c
View File

@ -188,13 +188,13 @@ static int receive_status(struct packet_reader *reader, struct ref *refs)
} }
if (new_report) { if (new_report) {
if (!hint->report) { if (!hint->report) {
hint->report = xcalloc(1, sizeof(struct ref_push_report)); CALLOC_ARRAY(hint->report, 1);
report = hint->report; report = hint->report;
} else { } else {
report = hint->report; report = hint->report;
while (report->next) while (report->next)
report = report->next; report = report->next;
report->next = xcalloc(1, sizeof(struct ref_push_report)); CALLOC_ARRAY(report->next, 1);
report = report->next; report = report->next;
} }
new_report = 0; new_report = 0;

2
sequencer.c
View File

@ -5171,7 +5171,7 @@ void todo_list_add_exec_commands(struct todo_list *todo_list,
int i, insert, nr = 0, alloc = 0; int i, insert, nr = 0, alloc = 0;
struct todo_item *items = NULL, *base_items = NULL; struct todo_item *items = NULL, *base_items = NULL;


base_items = xcalloc(commands->nr, sizeof(struct todo_item)); CALLOC_ARRAY(base_items, commands->nr);
for (i = 0; i < commands->nr; i++) { for (i = 0; i < commands->nr; i++) {
size_t command_len = strlen(commands->items[i].string); size_t command_len = strlen(commands->items[i].string);



2
server-info.c
View File

@ -296,7 +296,7 @@ static void init_pack_info(const char *infofile, int force)


i = num_pack++; i = num_pack++;
ALLOC_GROW(info, num_pack, alloc); ALLOC_GROW(info, num_pack, alloc);
info[i] = xcalloc(1, sizeof(struct pack_info)); CALLOC_ARRAY(info[i], 1);
info[i]->p = p; info[i]->p = p;
info[i]->old_num = -1; info[i]->old_num = -1;
} }

4
split-index.c
View File

@ -5,7 +5,7 @@
struct split_index *init_split_index(struct index_state *istate) struct split_index *init_split_index(struct index_state *istate)
{ {
if (!istate->split_index) { if (!istate->split_index) {
istate->split_index = xcalloc(1, sizeof(*istate->split_index)); CALLOC_ARRAY(istate->split_index, 1);
istate->split_index->refcount = 1; istate->split_index->refcount = 1;
} }
return istate->split_index; return istate->split_index;
@ -87,7 +87,7 @@ void move_cache_to_base_index(struct index_state *istate)
mem_pool_combine(istate->ce_mem_pool, istate->split_index->base->ce_mem_pool); mem_pool_combine(istate->ce_mem_pool, istate->split_index->base->ce_mem_pool);
} }


si->base = xcalloc(1, sizeof(*si->base)); CALLOC_ARRAY(si->base, 1);
si->base->version = istate->version; si->base->version = istate->version;
/* zero timestamp disables racy test in ce_write_index() */ /* zero timestamp disables racy test in ce_write_index() */
si->base->timestamp = istate->timestamp; si->base->timestamp = istate->timestamp;

2
trailer.c
View File

@ -445,7 +445,7 @@ static struct arg_item *get_conf_item(const char *name)
} }


/* Item does not already exists, create it */ /* Item does not already exists, create it */
item = xcalloc(sizeof(*item), 1); CALLOC_ARRAY(item, 1);
duplicate_conf(&item->conf, &default_conf_info); duplicate_conf(&item->conf, &default_conf_info);
item->conf.name = xstrdup(name); item->conf.name = xstrdup(name);



4
transport-helper.c
View File

@ -745,13 +745,13 @@ static int push_update_ref_status(struct strbuf *buf,
die(_("'option' without a matching 'ok/error' directive")); die(_("'option' without a matching 'ok/error' directive"));
if (state->new_report) { if (state->new_report) {
if (!state->hint->report) { if (!state->hint->report) {
state->hint->report = xcalloc(1, sizeof(struct ref_push_report)); CALLOC_ARRAY(state->hint->report, 1);
state->report = state->hint->report; state->report = state->hint->report;
} else { } else {
state->report = state->hint->report; state->report = state->hint->report;
while (state->report->next) while (state->report->next)
state->report = state->report->next; state->report = state->report->next;
state->report->next = xcalloc(1, sizeof(struct ref_push_report)); CALLOC_ARRAY(state->report->next, 1);
state->report = state->report->next; state->report = state->report->next;
} }
state->new_report = 0; state->new_report = 0;

2
transport.c
View File

@ -871,7 +871,7 @@ void transport_take_over(struct transport *transport,
BUG("taking over transport requires non-NULL " BUG("taking over transport requires non-NULL "
"smart_options field."); "smart_options field.");


data = xcalloc(1, sizeof(*data)); CALLOC_ARRAY(data, 1);
data->options = *transport->smart_options; data->options = *transport->smart_options;
data->conn = child; data->conn = child;
data->fd[0] = data->conn->out; data->fd[0] = data->conn->out;

4
worktree.c
View File

@ -53,7 +53,7 @@ static struct worktree *get_main_worktree(void)
strbuf_add_real_path(&worktree_path, get_git_common_dir()); strbuf_add_real_path(&worktree_path, get_git_common_dir());
strbuf_strip_suffix(&worktree_path, "/.git"); strbuf_strip_suffix(&worktree_path, "/.git");


worktree = xcalloc(1, sizeof(*worktree)); CALLOC_ARRAY(worktree, 1);
worktree->path = strbuf_detach(&worktree_path, NULL); worktree->path = strbuf_detach(&worktree_path, NULL);
/* /*
* NEEDSWORK: If this function is called from a secondary worktree and * NEEDSWORK: If this function is called from a secondary worktree and
@ -84,7 +84,7 @@ static struct worktree *get_linked_worktree(const char *id)
strbuf_rtrim(&worktree_path); strbuf_rtrim(&worktree_path);
strbuf_strip_suffix(&worktree_path, "/.git"); strbuf_strip_suffix(&worktree_path, "/.git");


worktree = xcalloc(1, sizeof(*worktree)); CALLOC_ARRAY(worktree, 1);
worktree->path = strbuf_detach(&worktree_path, NULL); worktree->path = strbuf_detach(&worktree_path, NULL);
worktree->id = xstrdup(id); worktree->id = xstrdup(id);
add_head_info(worktree); add_head_info(worktree);

6
wt-status.c
View File

@ -456,7 +456,7 @@ static void wt_status_collect_changed_cb(struct diff_queue_struct *q,
it = string_list_insert(&s->change, p->two->path); it = string_list_insert(&s->change, p->two->path);
d = it->util; d = it->util;
if (!d) { if (!d) {
d = xcalloc(1, sizeof(*d)); CALLOC_ARRAY(d, 1);
it->util = d; it->util = d;
} }
if (!d->worktree_status) if (!d->worktree_status)
@ -540,7 +540,7 @@ static void wt_status_collect_updated_cb(struct diff_queue_struct *q,
it = string_list_insert(&s->change, p->two->path); it = string_list_insert(&s->change, p->two->path);
d = it->util; d = it->util;
if (!d) { if (!d) {
d = xcalloc(1, sizeof(*d)); CALLOC_ARRAY(d, 1);
it->util = d; it->util = d;
} }
if (!d->index_status) if (!d->index_status)
@ -671,7 +671,7 @@ static void wt_status_collect_changes_initial(struct wt_status *s)
it = string_list_insert(&s->change, ce->name); it = string_list_insert(&s->change, ce->name);
d = it->util; d = it->util;
if (!d) { if (!d) {
d = xcalloc(1, sizeof(*d)); CALLOC_ARRAY(d, 1);
it->util = d; it->util = d;
} }
if (ce_stage(ce)) { if (ce_stage(ce)) {