convert trivial cases to ALLOC_ARRAY

Each of these cases can be converted to use ALLOC_ARRAY or
REALLOC_ARRAY, which has two advantages:

1. It automatically checks the array-size multiplication
for overflow.

2. It always uses sizeof(*array) for the element-size,
so that it can never go out of sync with the declared
type of the array.

Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/alias.c b/alias.c
index a11229db9e67b7b651356be3fb1d4b3d1014a8bd..3b90397a99d9f7ed4a0c1c5a83f5e69c879e752f 100644 (file)
--- a/alias.c
+++ b/alias.c
@@ -23,7 +23,7 @@ int split_cmdline(char *cmdline, const char ***argv)
        int src, dst, count = 0, size = 16;
        char quoted = 0;
 
        int src, dst, count = 0, size = 16;
        char quoted = 0;
 

-       *argv = xmalloc(sizeof(**argv) * size);
+       ALLOC_ARRAY(*argv, size);

 
        /* split alias_string */
        (*argv)[count++] = cmdline;
 
        /* split alias_string */
        (*argv)[count++] = cmdline;

diff --git a/attr.c b/attr.c
index 086c08dcfab613ef2927ff2769797fa40cd03308..c83ec49f1860f7993ab8390da694dbbcd3dab764 100644 (file)
--- a/attr.c
+++ b/attr.c
@@ -799,7 +799,7 @@ int git_all_attrs(const char *path, int *num, struct git_attr_check **check)
                        ++count;
        }
        *num = count;
                        ++count;
        }
        *num = count;

-       *check = xmalloc(sizeof(**check) * count);
+       ALLOC_ARRAY(*check, count);

        j = 0;
        for (i = 0; i < attr_nr; i++) {
                const char *value = check_all_attr[i].value;
        j = 0;
        for (i = 0; i < attr_nr; i++) {
                const char *value = check_all_attr[i].value;

diff --git a/bisect.c b/bisect.c
index 42aa7aa6aa1e53e66bafd47d76b783514dcfabf1..6d0793b9fc240f4f4e3898644e9506ecec6a1035 100644 (file)
--- a/bisect.c
+++ b/bisect.c
@@ -708,10 +708,10 @@ static struct commit *get_commit_reference(const unsigned char *sha1)
 
 static struct commit **get_bad_and_good_commits(int *rev_nr)
 {
 
 static struct commit **get_bad_and_good_commits(int *rev_nr)
 {

-       int len = 1 + good_revs.nr;
-       struct commit **rev = xmalloc(len * sizeof(*rev));
+       struct commit **rev;

        int i, n = 0;
 
        int i, n = 0;
 

+       ALLOC_ARRAY(rev, 1 + good_revs.nr);

        rev[n++] = get_commit_reference(current_bad_oid->hash);
        for (i = 0; i < good_revs.nr; i++)
                rev[n++] = get_commit_reference(good_revs.sha1[i]);
        rev[n++] = get_commit_reference(current_bad_oid->hash);
        for (i = 0; i < good_revs.nr; i++)
                rev[n++] = get_commit_reference(good_revs.sha1[i]);

diff --git a/builtin/blame.c b/builtin/blame.c
index 1df13cf7f4b501ed82dcbffdf4620706591a245e..4de9e1014803db4b9c9a86f1fd0418ac75d6ee67 100644 (file)
--- a/builtin/blame.c
+++ b/builtin/blame.c
@@ -2042,7 +2042,8 @@ static int prepare_lines(struct scoreboard *sb)
        for (p = buf; p < end; p = get_next_line(p, end))
                num++;
 
        for (p = buf; p < end; p = get_next_line(p, end))
                num++;
 

-       sb->lineno = lineno = xmalloc(sizeof(*sb->lineno) * (num + 1));
+       ALLOC_ARRAY(sb->lineno, num + 1);
+       lineno = sb->lineno;

 
        for (p = buf; p < end; p = get_next_line(p, end))
                *lineno++ = p - buf;
 
        for (p = buf; p < end; p = get_next_line(p, end))
                *lineno++ = p - buf;

diff --git a/builtin/clean.c b/builtin/clean.c
index 919157bc2fa0d72653b64c24f7c5b78039df191a..1f02c8294cb682196691942b569e35fc659d4138 100644 (file)
--- a/builtin/clean.c
+++ b/builtin/clean.c
@@ -543,7 +543,7 @@ static int *list_and_choose(struct menu_opts *opts, struct menu_stuff *stuff)
        int eof = 0;
        int i;
 
        int eof = 0;
        int i;
 

-       chosen = xmalloc(sizeof(int) * stuff->nr);
+       ALLOC_ARRAY(chosen, stuff->nr);

        /* set chosen as uninitialized */
        for (i = 0; i < stuff->nr; i++)
                chosen[i] = -1;
        /* set chosen as uninitialized */
        for (i = 0; i < stuff->nr; i++)
                chosen[i] = -1;

diff --git a/builtin/fast-export.c b/builtin/fast-export.c
index 2471297f7101964c61c055b10e24a7aa4b65326a..8164b581a66f257c5b4a74abbf1b76546946e2cf 100644 (file)
--- a/builtin/fast-export.c
+++ b/builtin/fast-export.c
@@ -1021,7 +1021,7 @@ int cmd_fast_export(int argc, const char **argv, const char *prefix)
                const char **refspecs_str;
                int i;
 
                const char **refspecs_str;
                int i;
 

-               refspecs_str = xmalloc(sizeof(*refspecs_str) * refspecs_list.nr);
+               ALLOC_ARRAY(refspecs_str, refspecs_list.nr);

                for (i = 0; i < refspecs_list.nr; i++)
                        refspecs_str[i] = refspecs_list.items[i].string;
 
                for (i = 0; i < refspecs_list.nr; i++)
                        refspecs_str[i] = refspecs_list.items[i].string;
 

diff --git a/builtin/index-pack.c b/builtin/index-pack.c
index 6a015095877a8d201e68348ecd76ddc5331af357..a60bcfac0646b63f279c8ca88b48e2f9ee958396 100644 (file)
--- a/builtin/index-pack.c
+++ b/builtin/index-pack.c
@@ -1346,7 +1346,7 @@ static void fix_unresolved_deltas(struct sha1file *f)
         * before deltas depending on them, a good heuristic is to start
         * resolving deltas in the same order as their position in the pack.
         */
         * before deltas depending on them, a good heuristic is to start
         * resolving deltas in the same order as their position in the pack.
         */

-       sorted_by_pos = xmalloc(nr_ref_deltas * sizeof(*sorted_by_pos));
+       ALLOC_ARRAY(sorted_by_pos, nr_ref_deltas);

        for (i = 0; i < nr_ref_deltas; i++)
                sorted_by_pos[i] = &ref_deltas[i];
        qsort(sorted_by_pos, nr_ref_deltas, sizeof(*sorted_by_pos), delta_pos_compare);
        for (i = 0; i < nr_ref_deltas; i++)
                sorted_by_pos[i] = &ref_deltas[i];
        qsort(sorted_by_pos, nr_ref_deltas, sizeof(*sorted_by_pos), delta_pos_compare);


@@ -1759,7 +1759,7 @@ int cmd_index_pack(int argc, const char **argv, const char *prefix)
        if (show_stat)
                show_pack_info(stat_only);
 
        if (show_stat)
                show_pack_info(stat_only);
 

-       idx_objects = xmalloc((nr_objects) * sizeof(struct pack_idx_entry *));
+       ALLOC_ARRAY(idx_objects, nr_objects);

        for (i = 0; i < nr_objects; i++)
                idx_objects[i] = &objects[i].idx;
        curr_index = write_idx_file(index_name, idx_objects, nr_objects, &opts, pack_sha1);
        for (i = 0; i < nr_objects; i++)
                idx_objects[i] = &objects[i].idx;
        curr_index = write_idx_file(index_name, idx_objects, nr_objects, &opts, pack_sha1);

diff --git a/builtin/merge-base.c b/builtin/merge-base.c
index a8911626c2ca9e178c8f4373d544c670afdb6aea..c0d1822eb3ad371b9ab0b830aed2cc2741a978bd 100644 (file)
--- a/builtin/merge-base.c
+++ b/builtin/merge-base.c
@@ -252,7 +252,7 @@ int cmd_merge_base(int argc, const char **argv, const char *prefix)
        if (argc < 2)
                usage_with_options(merge_base_usage, options);
 
        if (argc < 2)
                usage_with_options(merge_base_usage, options);
 

-       rev = xmalloc(argc * sizeof(*rev));
+       ALLOC_ARRAY(rev, argc);

        while (argc-- > 0)
                rev[rev_nr++] = get_commit_reference(*argv++);
        return show_merge_base(rev, rev_nr, show_all);
        while (argc-- > 0)
                rev[rev_nr++] = get_commit_reference(*argv++);
        return show_merge_base(rev, rev_nr, show_all);

diff --git a/builtin/mv.c b/builtin/mv.c
index d1d43168ae79d0157f8adf9dc36a4d2683afe91b..9a9813a0eca32850f62a1c3646a6bfd5cad050fb 100644 (file)
--- a/builtin/mv.c
+++ b/builtin/mv.c
@@ -24,7 +24,8 @@ static const char **internal_copy_pathspec(const char *prefix,
                                           int count, unsigned flags)
 {
        int i;
                                           int count, unsigned flags)
 {
        int i;

-       const char **result = xmalloc((count + 1) * sizeof(const char *));
+       const char **result;
+       ALLOC_ARRAY(result, count + 1);

        memcpy(result, pathspec, count * sizeof(const char *));
        result[count] = NULL;
        for (i = 0; i < count; i++) {
        memcpy(result, pathspec, count * sizeof(const char *));
        result[count] = NULL;
        for (i = 0; i < count; i++) {

diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
index 4dae5b11c28deb3c296cbd89753cafe3ca7a1e90..b4f1fa6d3396f7b8845216bc99d1aaa243d3e518 100644 (file)
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@ -624,7 +624,7 @@ static struct object_entry **compute_write_order(void)
 {
        unsigned int i, wo_end, last_untagged;
 
 {
        unsigned int i, wo_end, last_untagged;
 

-       struct object_entry **wo = xmalloc(to_pack.nr_objects * sizeof(*wo));
+       struct object_entry **wo;

        struct object_entry *objects = to_pack.objects;
 
        for (i = 0; i < to_pack.nr_objects; i++) {
        struct object_entry *objects = to_pack.objects;
 
        for (i = 0; i < to_pack.nr_objects; i++) {


@@ -657,6 +657,7 @@ static struct object_entry **compute_write_order(void)
         * Give the objects in the original recency order until
         * we see a tagged tip.
         */
         * Give the objects in the original recency order until
         * we see a tagged tip.
         */

+       ALLOC_ARRAY(wo, to_pack.nr_objects);

        for (i = wo_end = 0; i < to_pack.nr_objects; i++) {
                if (objects[i].tagged)
                        break;
        for (i = wo_end = 0; i < to_pack.nr_objects; i++) {
                if (objects[i].tagged)
                        break;


@@ -769,7 +770,7 @@ static void write_pack_file(void)
 
        if (progress > pack_to_stdout)
                progress_state = start_progress(_("Writing objects"), nr_result);
 
        if (progress > pack_to_stdout)
                progress_state = start_progress(_("Writing objects"), nr_result);

-       written_list = xmalloc(to_pack.nr_objects * sizeof(*written_list));
+       ALLOC_ARRAY(written_list, to_pack.nr_objects);

        write_order = compute_write_order();
 
        do {
        write_order = compute_write_order();
 
        do {


@@ -2129,7 +2130,7 @@ static void prepare_pack(int window, int depth)
        if (!to_pack.nr_objects || !window || !depth)
                return;
 
        if (!to_pack.nr_objects || !window || !depth)
                return;
 

-       delta_list = xmalloc(to_pack.nr_objects * sizeof(*delta_list));
+       ALLOC_ARRAY(delta_list, to_pack.nr_objects);

        nr_deltas = n = 0;
 
        for (i = 0; i < to_pack.nr_objects; i++) {
        nr_deltas = n = 0;
 
        for (i = 0; i < to_pack.nr_objects; i++) {

diff --git a/builtin/pack-redundant.c b/builtin/pack-redundant.c
index d0532f66b1d4a479360263bb031e001f4cb42a46..72c815844dd2abe7f2b4bc5a641eb692d2a45103 100644 (file)
--- a/builtin/pack-redundant.c
+++ b/builtin/pack-redundant.c
@@ -53,7 +53,7 @@ static inline struct llist_item *llist_item_get(void)
                free_nodes = free_nodes->next;
        } else {
                int i = 1;
                free_nodes = free_nodes->next;
        } else {
                int i = 1;

-               new = xmalloc(sizeof(struct llist_item) * BLKSIZE);
+               ALLOC_ARRAY(new, BLKSIZE);

                for (; i < BLKSIZE; i++)
                        llist_item_put(&new[i]);
        }
                for (; i < BLKSIZE; i++)
                        llist_item_put(&new[i]);
        }

diff --git a/builtin/receive-pack.c b/builtin/receive-pack.c
index 932afab9312ecdf12a6edcf8e649835a3006dc93..3dc3868c8694f3a97e69d2f147bef0a0dbd379e3 100644 (file)
--- a/builtin/receive-pack.c
+++ b/builtin/receive-pack.c
@@ -1591,8 +1591,7 @@ static void prepare_shallow_update(struct command *commands,
 {
        int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
 
 {
        int i, j, k, bitmap_size = (si->ref->nr + 31) / 32;
 

-       si->used_shallow = xmalloc(sizeof(*si->used_shallow) *
-                                  si->shallow->nr);
+       ALLOC_ARRAY(si->used_shallow, si->shallow->nr);

        assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
 
        si->need_reachability_test =
        assign_shallow_commits_to_refs(si, si->used_shallow, NULL);
 
        si->need_reachability_test =


@@ -1658,7 +1657,7 @@ static void update_shallow_info(struct command *commands,
                return;
        }
 
                return;
        }
 

-       ref_status = xmalloc(sizeof(*ref_status) * ref->nr);
+       ALLOC_ARRAY(ref_status, ref->nr);

        assign_shallow_commits_to_refs(si, NULL, ref_status);
        for (cmd = commands; cmd; cmd = cmd->next) {
                if (is_null_sha1(cmd->new_sha1))
        assign_shallow_commits_to_refs(si, NULL, ref_status);
        for (cmd = commands; cmd; cmd = cmd->next) {
                if (is_null_sha1(cmd->new_sha1))

diff --git a/column.c b/column.c
index 786abe62b0bb0f27b51218f7698c60476d12c8e8..f9fda681f13d3bffb44a6d198fe64cc03e4f62bb 100644 (file)
--- a/column.c
+++ b/column.c
@@ -164,7 +164,7 @@ static void display_table(const struct string_list *list,
        data.colopts = colopts;
        data.opts = *opts;
 
        data.colopts = colopts;
        data.opts = *opts;
 

-       data.len = xmalloc(sizeof(*data.len) * list->nr);
+       ALLOC_ARRAY(data.len, list->nr);

        for (i = 0; i < list->nr; i++)
                data.len[i] = item_length(colopts, list->items[i].string);
 
        for (i = 0; i < list->nr; i++)
                data.len[i] = item_length(colopts, list->items[i].string);
 

diff --git a/combine-diff.c b/combine-diff.c
index 55713049a4d6764722307e2a2c870996ff9b373b..a698016db7d3eccb77e80219adda60e8b9cccb20 100644 (file)
--- a/combine-diff.c
+++ b/combine-diff.c
@@ -1372,7 +1372,7 @@ static struct combine_diff_path *find_paths_multitree(
        struct combine_diff_path paths_head;
        struct strbuf base;
 
        struct combine_diff_path paths_head;
        struct strbuf base;
 

-       parents_sha1 = xmalloc(nparent * sizeof(parents_sha1[0]));
+       ALLOC_ARRAY(parents_sha1, nparent);

        for (i = 0; i < nparent; i++)
                parents_sha1[i] = parents->sha1[i];
 
        for (i = 0; i < nparent; i++)
                parents_sha1[i] = parents->sha1[i];
 


@@ -1483,7 +1483,7 @@ void diff_tree_combined(const unsigned char *sha1,
        if (opt->orderfile && num_paths) {
                struct obj_order *o;
 
        if (opt->orderfile && num_paths) {
                struct obj_order *o;
 

-               o = xmalloc(sizeof(*o) * num_paths);
+               ALLOC_ARRAY(o, num_paths);

                for (i = 0, p = paths; p; p = p->next, i++)
                        o[i].obj = p;
                order_objects(opt->orderfile, path_path, o, num_paths);
                for (i = 0, p = paths; p; p = p->next, i++)
                        o[i].obj = p;
                order_objects(opt->orderfile, path_path, o, num_paths);

diff --git a/commit.c b/commit.c
index 40388d71e754bb35e3879a73f6e8a0ad8904ca41..31cd91f81ea54c056dba34e0b748fe1fee8ed29a 100644 (file)
--- a/commit.c
+++ b/commit.c
@@ -903,7 +903,7 @@ static int remove_redundant(struct commit **array, int cnt)
 
        work = xcalloc(cnt, sizeof(*work));
        redundant = xcalloc(cnt, 1);
 
        work = xcalloc(cnt, sizeof(*work));
        redundant = xcalloc(cnt, 1);

-       filled_index = xmalloc(sizeof(*filled_index) * (cnt - 1));
+       ALLOC_ARRAY(filled_index, cnt - 1);

 
        for (i = 0; i < cnt; i++)
                parse_commit(array[i]);
 
        for (i = 0; i < cnt; i++)
                parse_commit(array[i]);

diff --git a/compat/mingw.c b/compat/mingw.c
index 9b2a1f552e77835a23b7f9b5ac0134d6a800d01f..d8a5345a3056859476f5f796f17334b34169c623 100644 (file)
--- a/compat/mingw.c
+++ b/compat/mingw.c
@@ -852,7 +852,7 @@ static char **get_path_split(void)
        if (!n)
                return NULL;
 
        if (!n)
                return NULL;
 

-       path = xmalloc((n+1)*sizeof(char *));
+       ALLOC_ARRAY(path, n + 1);

        p = envpath;
        i = 0;
        do {
        p = envpath;
        i = 0;
        do {


@@ -937,7 +937,7 @@ static wchar_t *make_environment_block(char **deltaenv)
                i++;
 
        /* copy the environment, leaving space for changes */
                i++;
 
        /* copy the environment, leaving space for changes */

-       tmpenv = xmalloc((size + i) * sizeof(char*));
+       ALLOC_ARRAY(tmpenv, size + i);

        memcpy(tmpenv, environ, size * sizeof(char*));
 
        /* merge supplied environment changes into the temporary environment */
        memcpy(tmpenv, environ, size * sizeof(char*));
 
        /* merge supplied environment changes into the temporary environment */


@@ -1127,7 +1127,7 @@ static int try_shell_exec(const char *cmd, char *const *argv)
                int argc = 0;
                const char **argv2;
                while (argv[argc]) argc++;
                int argc = 0;
                const char **argv2;
                while (argv[argc]) argc++;

-               argv2 = xmalloc(sizeof(*argv) * (argc+1));
+               ALLOC_ARRAY(argv2, argc + 1);

                argv2[0] = (char *)cmd; /* full path to the script file */
                memcpy(&argv2[1], &argv[1], sizeof(*argv) * argc);
                pid = mingw_spawnv(prog, argv2, 1);
                argv2[0] = (char *)cmd; /* full path to the script file */
                memcpy(&argv2[1], &argv[1], sizeof(*argv) * argc);
                pid = mingw_spawnv(prog, argv2, 1);

diff --git a/diffcore-order.c b/diffcore-order.c
index 97dd3d0095723c194288db0da1b9cfbf400e7e26..69d41f7a5781a10e43cf0e74f20be85a0d1fc5be 100644 (file)
--- a/diffcore-order.c
+++ b/diffcore-order.c
@@ -52,7 +52,7 @@ static void prepare_order(const char *orderfile)
                }
                if (pass == 0) {
                        order_cnt = cnt;
                }
                if (pass == 0) {
                        order_cnt = cnt;

-                       order = xmalloc(sizeof(*order) * cnt);
+                       ALLOC_ARRAY(order, cnt);

                }
        }
 }
                }
        }
 }


@@ -120,7 +120,7 @@ void diffcore_order(const char *orderfile)
        if (!q->nr)
                return;
 
        if (!q->nr)
                return;
 

-       o = xmalloc(sizeof(*o) * q->nr);
+       ALLOC_ARRAY(o, q->nr);

        for (i = 0; i < q->nr; i++)
                o[i].obj = q->queue[i];
        order_objects(orderfile, pair_pathtwo, o, q->nr);
        for (i = 0; i < q->nr; i++)
                o[i].obj = q->queue[i];
        order_objects(orderfile, pair_pathtwo, o, q->nr);

diff --git a/dir.c b/dir.c
index 29aec124871e44972de70cb05f1c6023e514fcc2..363a402887e52a6e551483efa0e1efe3b36f3657 100644 (file)
--- a/dir.c
+++ b/dir.c
@@ -2448,14 +2448,14 @@ static int read_one_dir(struct untracked_cache_dir **untracked_,
        ud.untracked_alloc = value;
        ud.untracked_nr    = value;
        if (ud.untracked_nr)
        ud.untracked_alloc = value;
        ud.untracked_nr    = value;
        if (ud.untracked_nr)

-               ud.untracked = xmalloc(sizeof(*ud.untracked) * ud.untracked_nr);
+               ALLOC_ARRAY(ud.untracked, ud.untracked_nr);

        data = next;
 
        next = data;
        ud.dirs_alloc = ud.dirs_nr = decode_varint(&next);
        if (next > end)
                return -1;
        data = next;
 
        next = data;
        ud.dirs_alloc = ud.dirs_nr = decode_varint(&next);
        if (next > end)
                return -1;

-       ud.dirs = xmalloc(sizeof(*ud.dirs) * ud.dirs_nr);
+       ALLOC_ARRAY(ud.dirs, ud.dirs_nr);

        data = next;
 
        len = strlen((const char *)data);
        data = next;
 
        len = strlen((const char *)data);


@@ -2575,7 +2575,7 @@ struct untracked_cache *read_untracked_extension(const void *data, unsigned long
        rd.data       = next;
        rd.end        = end;
        rd.index      = 0;
        rd.data       = next;
        rd.end        = end;
        rd.index      = 0;

-       rd.ucd        = xmalloc(sizeof(*rd.ucd) * len);
+       ALLOC_ARRAY(rd.ucd, len);

 
        if (read_one_dir(&uc->root, &rd) || rd.index != len)
                goto done;
 
        if (read_one_dir(&uc->root, &rd) || rd.index != len)
                goto done;

diff --git a/fast-import.c b/fast-import.c
index 3c65edb5c44e1fa57beef851d56a9674a5be1b72..36dbaa5b16513434fdf0729777d16e621b289c8f 100644 (file)
--- a/fast-import.c
+++ b/fast-import.c
@@ -814,7 +814,8 @@ static struct tree_entry *new_tree_entry(void)
        if (!avail_tree_entry) {
                unsigned int n = tree_entry_alloc;
                total_allocd += n * sizeof(struct tree_entry);
        if (!avail_tree_entry) {
                unsigned int n = tree_entry_alloc;
                total_allocd += n * sizeof(struct tree_entry);

-               avail_tree_entry = e = xmalloc(n * sizeof(struct tree_entry));
+               ALLOC_ARRAY(e, n);
+               avail_tree_entry = e;

                while (n-- > 1) {
                        *((void**)e) = e + 1;
                        e++;
                while (n-- > 1) {
                        *((void**)e) = e + 1;
                        e++;


@@ -898,7 +899,7 @@ static const char *create_index(void)
        struct object_entry_pool *o;
 
        /* Build the table of object IDs. */
        struct object_entry_pool *o;
 
        /* Build the table of object IDs. */

-       idx = xmalloc(object_count * sizeof(*idx));
+       ALLOC_ARRAY(idx, object_count);

        c = idx;
        for (o = blocks; o; o = o->next_pool)
                for (e = o->next_free; e-- != o->entries;)
        c = idx;
        for (o = blocks; o; o = o->next_pool)
                for (e = o->next_free; e-- != o->entries;)

diff --git a/fsck.c b/fsck.c
index c637f6676b639beb90240e4667ed07ceb83cdbf8..ca4c68537788496dea803b559e2ffd4cf1dbeea7 100644 (file)
--- a/fsck.c
+++ b/fsck.c
@@ -199,7 +199,8 @@ void fsck_set_msg_type(struct fsck_options *options,
 
        if (!options->msg_type) {
                int i;
 
        if (!options->msg_type) {
                int i;

-               int *msg_type = xmalloc(sizeof(int) * FSCK_MSG_MAX);
+               int *msg_type;
+               ALLOC_ARRAY(msg_type, FSCK_MSG_MAX);

                for (i = 0; i < FSCK_MSG_MAX; i++)
                        msg_type[i] = fsck_msg_type(i, options);
                options->msg_type = msg_type;
                for (i = 0; i < FSCK_MSG_MAX; i++)
                        msg_type[i] = fsck_msg_type(i, options);
                options->msg_type = msg_type;

diff --git a/graph.c b/graph.c
index c25a09a8fdaf3e90bf7e029c78127146418ab023..1350bdde3be4346e8bc2038c57e4883d0ab12b25 100644 (file)
--- a/graph.c
+++ b/graph.c
@@ -234,12 +234,10 @@ struct git_graph *graph_init(struct rev_info *opt)
         * We'll automatically grow columns later if we need more room.
         */
        graph->column_capacity = 30;
         * We'll automatically grow columns later if we need more room.
         */
        graph->column_capacity = 30;

-       graph->columns = xmalloc(sizeof(struct column) *
-                                graph->column_capacity);
-       graph->new_columns = xmalloc(sizeof(struct column) *
-                                    graph->column_capacity);
-       graph->mapping = xmalloc(sizeof(int) * 2 * graph->column_capacity);
-       graph->new_mapping = xmalloc(sizeof(int) * 2 * graph->column_capacity);
+       ALLOC_ARRAY(graph->columns, graph->column_capacity);
+       ALLOC_ARRAY(graph->new_columns, graph->column_capacity);
+       ALLOC_ARRAY(graph->mapping, 2 * graph->column_capacity);
+       ALLOC_ARRAY(graph->new_mapping, 2 * graph->column_capacity);

 
        /*
         * The diff output prefix callback, with this we can make
 
        /*
         * The diff output prefix callback, with this we can make

diff --git a/khash.h b/khash.h
index 376475a5eaf80585311ab518d03c229a7a49a7ed..c0da40daa78f703f825208bb7d1b4b5b3cc05ae3 100644 (file)
--- a/khash.h
+++ b/khash.h
@@ -117,7 +117,7 @@ static const double __ac_HASH_UPPER = 0.77;
                        if (new_n_buckets < 4) new_n_buckets = 4;                                       \
                        if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER + 0.5)) j = 0; /* requested size is too small */ \
                        else { /* hash table size to be changed (shrink or expand); rehash */ \
                        if (new_n_buckets < 4) new_n_buckets = 4;                                       \
                        if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER + 0.5)) j = 0; /* requested size is too small */ \
                        else { /* hash table size to be changed (shrink or expand); rehash */ \

-                               new_flags = (khint32_t*)xmalloc(__ac_fsize(new_n_buckets) * sizeof(khint32_t)); \
+                               ALLOC_ARRAY(new_flags, __ac_fsize(new_n_buckets)); \

                                if (!new_flags) return -1;                                                              \
                                memset(new_flags, 0xaa, __ac_fsize(new_n_buckets) * sizeof(khint32_t)); \
                                if (h->n_buckets < new_n_buckets) {     /* expand */            \
                                if (!new_flags) return -1;                                                              \
                                memset(new_flags, 0xaa, __ac_fsize(new_n_buckets) * sizeof(khint32_t)); \
                                if (h->n_buckets < new_n_buckets) {     /* expand */            \

diff --git a/levenshtein.c b/levenshtein.c
index fc281597fd2fd5ad2299eab0848da99355e383fc..d2632690d5107b53ee8a7ac4832cd85eb8c7bfc1 100644 (file)
--- a/levenshtein.c
+++ b/levenshtein.c
@@ -42,11 +42,13 @@ int levenshtein(const char *string1, const char *string2,
                int w, int s, int a, int d)
 {
        int len1 = strlen(string1), len2 = strlen(string2);
                int w, int s, int a, int d)
 {
        int len1 = strlen(string1), len2 = strlen(string2);

-       int *row0 = xmalloc(sizeof(int) * (len2 + 1));
-       int *row1 = xmalloc(sizeof(int) * (len2 + 1));
-       int *row2 = xmalloc(sizeof(int) * (len2 + 1));
+       int *row0, *row1, *row2;

        int i, j;
 
        int i, j;
 

+       ALLOC_ARRAY(row0, len2 + 1);
+       ALLOC_ARRAY(row1, len2 + 1);
+       ALLOC_ARRAY(row2, len2 + 1);
+

        for (j = 0; j <= len2; j++)
                row1[j] = j * a;
        for (i = 0; i < len1; i++) {
        for (j = 0; j <= len2; j++)
                row1[j] = j * a;
        for (i = 0; i < len1; i++) {

diff --git a/line-log.c b/line-log.c
index 5877986c5a683684997e96b35409e0d8c619fa05..bbe31ed6fbb7c103c739f7e9a3c45cde5d36fcec 100644 (file)
--- a/line-log.c
+++ b/line-log.c
@@ -522,7 +522,7 @@ static void fill_line_ends(struct diff_filespec *spec, long *lines,
        if (diff_populate_filespec(spec, 0))
                die("Cannot read blob %s", sha1_to_hex(spec->sha1));
 
        if (diff_populate_filespec(spec, 0))
                die("Cannot read blob %s", sha1_to_hex(spec->sha1));
 

-       ends = xmalloc(size * sizeof(*ends));
+       ALLOC_ARRAY(ends, size);

        ends[cur++] = 0;
        data = spec->data;
        while (num < spec->size) {
        ends[cur++] = 0;
        data = spec->data;
        while (num < spec->size) {


@@ -1142,9 +1142,9 @@ static int process_ranges_merge_commit(struct rev_info *rev, struct commit *comm
        if (nparents > 1 && rev->first_parent_only)
                nparents = 1;
 
        if (nparents > 1 && rev->first_parent_only)
                nparents = 1;
 

-       diffqueues = xmalloc(nparents * sizeof(*diffqueues));
-       cand = xmalloc(nparents * sizeof(*cand));
-       parents = xmalloc(nparents * sizeof(*parents));
+       ALLOC_ARRAY(diffqueues, nparents);
+       ALLOC_ARRAY(cand, nparents);
+       ALLOC_ARRAY(parents, nparents);

 
        p = commit->parents;
        for (i = 0; i < nparents; i++) {
 
        p = commit->parents;
        for (i = 0; i < nparents; i++) {

diff --git a/notes.c b/notes.c
index db77922130b4f7df6ab72122206a76d6c580faac..8b59ccdb1166dfc413035e2699f3eb1dc9bd853e 100644 (file)
--- a/notes.c
+++ b/notes.c
@@ -1032,7 +1032,7 @@ struct notes_tree **load_notes_trees(struct string_list *refs)
        struct string_list_item *item;
        int counter = 0;
        struct notes_tree **trees;
        struct string_list_item *item;
        int counter = 0;
        struct notes_tree **trees;

-       trees = xmalloc((refs->nr+1) * sizeof(struct notes_tree *));
+       ALLOC_ARRAY(trees, refs->nr + 1);

        for_each_string_list_item(item, refs) {
                struct notes_tree *t = xcalloc(1, sizeof(struct notes_tree));
                init_notes(t, item->string, combine_notes_ignore, 0);
        for_each_string_list_item(item, refs) {
                struct notes_tree *t = xcalloc(1, sizeof(struct notes_tree));
                init_notes(t, item->string, combine_notes_ignore, 0);

diff --git a/pack-check.c b/pack-check.c
index 433bd86ccd5c38ff5a4993be4e1463946aead59d..1da89a41cec9e605fc3fdfa8efaaf2489e501c88 100644 (file)
--- a/pack-check.c
+++ b/pack-check.c
@@ -89,7 +89,7 @@ static int verify_packfile(struct packed_git *p,
         * we do not do scan-streaming check on the pack file.
         */
        nr_objects = p->num_objects;
         * we do not do scan-streaming check on the pack file.
         */
        nr_objects = p->num_objects;

-       entries = xmalloc((nr_objects + 1) * sizeof(*entries));
+       ALLOC_ARRAY(entries, nr_objects + 1);

        entries[nr_objects].offset = pack_sig_ofs;
        /* first sort entries by pack offset, since unpacking them is more efficient that way */
        for (i = 0; i < nr_objects; i++) {
        entries[nr_objects].offset = pack_sig_ofs;
        /* first sort entries by pack offset, since unpacking them is more efficient that way */
        for (i = 0; i < nr_objects; i++) {

diff --git a/pack-revindex.c b/pack-revindex.c
index e542ea7703a740916f8d2cac9176674782d37f61..f6a3613bebe4ae8d398ab3b0ada22ba81b1339ee 100644 (file)
--- a/pack-revindex.c
+++ b/pack-revindex.c
@@ -83,10 +83,14 @@ static void sort_revindex(struct revindex_entry *entries, unsigned n, off_t max)
         * keep track of them with alias pointers, always sorting from "from"
         * to "to".
         */
         * keep track of them with alias pointers, always sorting from "from"
         * to "to".
         */

-       struct revindex_entry *tmp = xmalloc(n * sizeof(*tmp));
-       struct revindex_entry *from = entries, *to = tmp;
+       struct revindex_entry *tmp, *from, *to;

        int bits;
        int bits;

-       unsigned *pos = xmalloc(BUCKETS * sizeof(*pos));
+       unsigned *pos;
+
+       ALLOC_ARRAY(pos, BUCKETS);
+       ALLOC_ARRAY(tmp, n);
+       from = entries;
+       to = tmp;

 
        /*
         * If (max >> bits) is zero, then we know that the radix digit we are
 
        /*
         * If (max >> bits) is zero, then we know that the radix digit we are


@@ -161,7 +165,7 @@ static void create_pack_revindex(struct pack_revindex *rix)
        unsigned i;
        const char *index = p->index_data;
 
        unsigned i;
        const char *index = p->index_data;
 

-       rix->revindex = xmalloc(sizeof(*rix->revindex) * (num_ent + 1));
+       ALLOC_ARRAY(rix->revindex, num_ent + 1);

        index += 4 * 256;
 
        if (p->index_version > 1) {
        index += 4 * 256;
 
        if (p->index_version > 1) {

diff --git a/pathspec.c b/pathspec.c
index 9304ee33d75ab9de14e4a7b6dc96f5dd8028c464..c9e9b6c0778c755fcade1430cf674dfd867050f1 100644 (file)
--- a/pathspec.c
+++ b/pathspec.c
@@ -406,7 +406,8 @@ void parse_pathspec(struct pathspec *pathspec,
                n++;
 
        pathspec->nr = n;
                n++;
 
        pathspec->nr = n;

-       pathspec->items = item = xmalloc(sizeof(*item) * n);
+       ALLOC_ARRAY(pathspec->items, n);
+       item = pathspec->items;

        pathspec->_raw = argv;
        prefixlen = prefix ? strlen(prefix) : 0;
 
        pathspec->_raw = argv;
        prefixlen = prefix ? strlen(prefix) : 0;
 


@@ -483,7 +484,7 @@ const char **get_pathspec(const char *prefix, const char **pathspec)
 void copy_pathspec(struct pathspec *dst, const struct pathspec *src)
 {
        *dst = *src;
 void copy_pathspec(struct pathspec *dst, const struct pathspec *src)
 {
        *dst = *src;

-       dst->items = xmalloc(sizeof(struct pathspec_item) * dst->nr);
+       ALLOC_ARRAY(dst->items, dst->nr);

        memcpy(dst->items, src->items,
               sizeof(struct pathspec_item) * dst->nr);
 }
        memcpy(dst->items, src->items,
               sizeof(struct pathspec_item) * dst->nr);
 }

diff --git a/remote-curl.c b/remote-curl.c
index e81b9d560b2508c08b877d18f6cfbfddb504e9a2..e85333a51b0b6a88bfcb212d40d39802eca74a1d 100644 (file)
--- a/remote-curl.c
+++ b/remote-curl.c
@@ -696,9 +696,10 @@ static int rpc_service(struct rpc_state *rpc, struct discovery *heads)
 static int fetch_dumb(int nr_heads, struct ref **to_fetch)
 {
        struct walker *walker;
 static int fetch_dumb(int nr_heads, struct ref **to_fetch)
 {
        struct walker *walker;

-       char **targets = xmalloc(nr_heads * sizeof(char*));
+       char **targets;

        int ret, i;
 
        int ret, i;
 

+       ALLOC_ARRAY(targets, nr_heads);

        if (options.depth)
                die("dumb http transport does not support --depth");
        for (i = 0; i < nr_heads; i++)
        if (options.depth)
                die("dumb http transport does not support --depth");
        for (i = 0; i < nr_heads; i++)

diff --git a/sha1_file.c b/sha1_file.c
index 73ccd49a465b1cf8b668edf8c13ea75d6b8de718..d14abfed9b5697cbe52a007625f190602e537747 100644 (file)
--- a/sha1_file.c
+++ b/sha1_file.c
@@ -1942,7 +1942,7 @@ static enum object_type packed_to_object_type(struct packed_git *p,
                /* Push the object we're going to leave behind */
                if (poi_stack_nr >= poi_stack_alloc && poi_stack == small_poi_stack) {
                        poi_stack_alloc = alloc_nr(poi_stack_nr);
                /* Push the object we're going to leave behind */
                if (poi_stack_nr >= poi_stack_alloc && poi_stack == small_poi_stack) {
                        poi_stack_alloc = alloc_nr(poi_stack_nr);

-                       poi_stack = xmalloc(sizeof(off_t)*poi_stack_alloc);
+                       ALLOC_ARRAY(poi_stack, poi_stack_alloc);

                        memcpy(poi_stack, small_poi_stack, sizeof(off_t)*poi_stack_nr);
                } else {
                        ALLOC_GROW(poi_stack, poi_stack_nr+1, poi_stack_alloc);
                        memcpy(poi_stack, small_poi_stack, sizeof(off_t)*poi_stack_nr);
                } else {
                        ALLOC_GROW(poi_stack, poi_stack_nr+1, poi_stack_alloc);


@@ -2308,7 +2308,7 @@ void *unpack_entry(struct packed_git *p, off_t obj_offset,
                if (delta_stack_nr >= delta_stack_alloc
                    && delta_stack == small_delta_stack) {
                        delta_stack_alloc = alloc_nr(delta_stack_nr);
                if (delta_stack_nr >= delta_stack_alloc
                    && delta_stack == small_delta_stack) {
                        delta_stack_alloc = alloc_nr(delta_stack_nr);

-                       delta_stack = xmalloc(sizeof(*delta_stack)*delta_stack_alloc);
+                       ALLOC_ARRAY(delta_stack, delta_stack_alloc);

                        memcpy(delta_stack, small_delta_stack,
                               sizeof(*delta_stack)*delta_stack_nr);
                } else {
                        memcpy(delta_stack, small_delta_stack,
                               sizeof(*delta_stack)*delta_stack_nr);
                } else {

diff --git a/shallow.c b/shallow.c
index 60f1505d9791bc92a283d02183da35e7542ad2dc..71163bf3d7c8d5cdab02968e2ddacaea02c995f7 100644 (file)
--- a/shallow.c
+++ b/shallow.c
@@ -315,8 +315,8 @@ void prepare_shallow_info(struct shallow_info *info, struct sha1_array *sa)
        info->shallow = sa;
        if (!sa)
                return;
        info->shallow = sa;
        if (!sa)
                return;

-       info->ours = xmalloc(sizeof(*info->ours) * sa->nr);
-       info->theirs = xmalloc(sizeof(*info->theirs) * sa->nr);
+       ALLOC_ARRAY(info->ours, sa->nr);
+       ALLOC_ARRAY(info->theirs, sa->nr);

        for (i = 0; i < sa->nr; i++) {
                if (has_sha1_file(sa->sha1[i])) {
                        struct commit_graft *graft;
        for (i = 0; i < sa->nr; i++) {
                if (has_sha1_file(sa->sha1[i])) {
                        struct commit_graft *graft;


@@ -487,7 +487,7 @@ void assign_shallow_commits_to_refs(struct shallow_info *info,
        struct paint_info pi;
 
        trace_printf_key(&trace_shallow, "shallow: assign_shallow_commits_to_refs\n");
        struct paint_info pi;
 
        trace_printf_key(&trace_shallow, "shallow: assign_shallow_commits_to_refs\n");

-       shallow = xmalloc(sizeof(*shallow) * (info->nr_ours + info->nr_theirs));
+       ALLOC_ARRAY(shallow, info->nr_ours + info->nr_theirs);

        for (i = 0; i < info->nr_ours; i++)
                shallow[nr_shallow++] = info->ours[i];
        for (i = 0; i < info->nr_theirs; i++)
        for (i = 0; i < info->nr_ours; i++)
                shallow[nr_shallow++] = info->ours[i];
        for (i = 0; i < info->nr_theirs; i++)

diff --git a/show-index.c b/show-index.c
index d9e4903fed24f5916962f8d315eb680f9b4013ff..acf8d5445ad96aacf6d2c3ccc2d77a3815291228 100644 (file)
--- a/show-index.c
+++ b/show-index.c
@@ -50,7 +50,8 @@ int main(int argc, char **argv)
                        unsigned char sha1[20];
                        uint32_t crc;
                        uint32_t off;
                        unsigned char sha1[20];
                        uint32_t crc;
                        uint32_t off;

-               } *entries = xmalloc(nr * sizeof(entries[0]));
+               } *entries;
+               ALLOC_ARRAY(entries, nr);

                for (i = 0; i < nr; i++)
                        if (fread(entries[i].sha1, 20, 1, stdin) != 1)
                                die("unable to read sha1 %u/%u", i, nr);
                for (i = 0; i < nr; i++)
                        if (fread(entries[i].sha1, 20, 1, stdin) != 1)
                                die("unable to read sha1 %u/%u", i, nr);

diff --git a/transport.c b/transport.c
index 67f366687c7abf2f6bd9cf31faa6f4ed9e6dc69e..163abedcb0fcbd4b8a769007914b512db3fb8dce 100644 (file)
--- a/transport.c
+++ b/transport.c
@@ -1306,7 +1306,7 @@ int transport_fetch_refs(struct transport *transport, struct ref *refs)
                 * This condition shouldn't be met in a non-deepening fetch
                 * (see builtin/fetch.c:quickfetch()).
                 */
                 * This condition shouldn't be met in a non-deepening fetch
                 * (see builtin/fetch.c:quickfetch()).
                 */

-               heads = xmalloc(nr_refs * sizeof(*heads));
+               ALLOC_ARRAY(heads, nr_refs);

                for (rm = refs; rm; rm = rm->next)
                        heads[nr_heads++] = rm;
        }
                for (rm = refs; rm; rm = rm->next)
                        heads[nr_heads++] = rm;
        }

diff --git a/xdiff-interface.c b/xdiff-interface.c
index cb67c1c42b35e412dccf9a13ad18dde727ab8ce6..54236f24b9786710f91650ac63f6004cdeb012e6 100644 (file)
--- a/xdiff-interface.c
+++ b/xdiff-interface.c
@@ -265,7 +265,7 @@ void xdiff_set_find_func(xdemitconf_t *xecfg, const char *value, int cflags)
        for (i = 0, regs->nr = 1; value[i]; i++)
                if (value[i] == '\n')
                        regs->nr++;
        for (i = 0, regs->nr = 1; value[i]; i++)
                if (value[i] == '\n')
                        regs->nr++;

-       regs->array = xmalloc(regs->nr * sizeof(struct ff_reg));
+       ALLOC_ARRAY(regs->array, regs->nr);

        for (i = 0; i < regs->nr; i++) {
                struct ff_reg *reg = regs->array + i;
                const char *ep = strchr(value, '\n'), *expression;
        for (i = 0; i < regs->nr; i++) {
                struct ff_reg *reg = regs->array + i;
                const char *ep = strchr(value, '\n'), *expression;