various: tighten constness of some local variables

Signed-off-by: Shahzad Lone <shahzadlone@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/diff.c b/builtin/diff.c
index f0393bba23a7d95c67470508a6b63e4e41e8d46b..84a362ff5625bc6ef776bcd067fa2dcb2d55038a 100644 (file)
--- a/builtin/diff.c
+++ b/builtin/diff.c
@@ -102,7 +102,7 @@ static int builtin_diff_blobs(struct rev_info *revs,
                              int argc, const char **argv,
                              struct object_array_entry **blob)
 {
                              int argc, const char **argv,
                              struct object_array_entry **blob)
 {

-       unsigned mode = canon_mode(S_IFREG | 0644);
+       const unsigned mode = canon_mode(S_IFREG | 0644);

 
        if (argc > 1)
                usage(builtin_diff_usage);
 
        if (argc > 1)
                usage(builtin_diff_usage);

diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
index 0a70d046043ec9b7ae2e604a7ad098d22d36ed59..5c406ab4945f5995b898823078d4e1d803bd8fa9 100644 (file)
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@ -1901,10 +1901,10 @@ static int type_size_sort(const void *_a, const void *_b)
 {
        const struct object_entry *a = *(struct object_entry **)_a;
        const struct object_entry *b = *(struct object_entry **)_b;
 {
        const struct object_entry *a = *(struct object_entry **)_a;
        const struct object_entry *b = *(struct object_entry **)_b;

-       enum object_type a_type = oe_type(a);
-       enum object_type b_type = oe_type(b);
-       unsigned long a_size = SIZE(a);
-       unsigned long b_size = SIZE(b);
+       const enum object_type a_type = oe_type(a);
+       const enum object_type b_type = oe_type(b);
+       const unsigned long a_size = SIZE(a);
+       const unsigned long b_size = SIZE(b);

 
        if (a_type > b_type)
                return -1;
 
        if (a_type > b_type)
                return -1;


@@ -1919,7 +1919,7 @@ static int type_size_sort(const void *_a, const void *_b)
        if (a->preferred_base < b->preferred_base)
                return 1;
        if (use_delta_islands) {
        if (a->preferred_base < b->preferred_base)
                return 1;
        if (use_delta_islands) {

-               int island_cmp = island_delta_cmp(&a->idx.oid, &b->idx.oid);
+               const int island_cmp = island_delta_cmp(&a->idx.oid, &b->idx.oid);

                if (island_cmp)
                        return island_cmp;
        }
                if (island_cmp)
                        return island_cmp;
        }


@@ -2171,7 +2171,7 @@ static unsigned int check_delta_limit(struct object_entry *me, unsigned int n)
        struct object_entry *child = DELTA_CHILD(me);
        unsigned int m = n;
        while (child) {
        struct object_entry *child = DELTA_CHILD(me);
        unsigned int m = n;
        while (child) {

-               unsigned int c = check_delta_limit(child, n + 1);
+               const unsigned int c = check_delta_limit(child, n + 1);

                if (m < c)
                        m = c;
                child = DELTA_SIBLING(child);
                if (m < c)
                        m = c;
                child = DELTA_SIBLING(child);


@@ -2226,7 +2226,7 @@ static void find_deltas(struct object_entry **list, unsigned *list_size,
                while (window_memory_limit &&
                       mem_usage > window_memory_limit &&
                       count > 1) {
                while (window_memory_limit &&
                       mem_usage > window_memory_limit &&
                       count > 1) {

-                       uint32_t tail = (idx + window - count) % window;
+                       const uint32_t tail = (idx + window - count) % window;

                        mem_usage -= free_unpacked(array + tail);
                        count--;
                }
                        mem_usage -= free_unpacked(array + tail);
                        count--;
                }

diff --git a/builtin/pack-redundant.c b/builtin/pack-redundant.c
index cf9a9aabd4eb2e834c08f85240bcb3d0154c3320..11bc51456631e65a35f11d7b5118dc33c0f324e9 100644 (file)
--- a/builtin/pack-redundant.c
+++ b/builtin/pack-redundant.c
@@ -166,7 +166,7 @@ static inline struct llist_item * llist_sorted_remove(struct llist *list, const
        l = (hint == NULL) ? list->front : hint;
        prev = NULL;
        while (l) {
        l = (hint == NULL) ? list->front : hint;
        prev = NULL;
        while (l) {

-               int cmp = oidcmp(l->oid, oid);
+               const int cmp = oidcmp(l->oid, oid);

                if (cmp > 0) /* not in list, since sorted */
                        return prev;
                if (!cmp) { /* found */
                if (cmp > 0) /* not in list, since sorted */
                        return prev;
                if (!cmp) { /* found */


@@ -264,7 +264,7 @@ static void cmp_two_packs(struct pack_list *p1, struct pack_list *p2)
        while (p1_off < p1->pack->num_objects * p1_step &&
               p2_off < p2->pack->num_objects * p2_step)
        {
        while (p1_off < p1->pack->num_objects * p1_step &&
               p2_off < p2->pack->num_objects * p2_step)
        {

-               int cmp = hashcmp(p1_base + p1_off, p2_base + p2_off);
+               const int cmp = hashcmp(p1_base + p1_off, p2_base + p2_off);

                /* cmp ~ p1 - p2 */
                if (cmp == 0) {
                        p1_hint = llist_sorted_remove(p1->unique_objects,
                /* cmp ~ p1 - p2 */
                if (cmp == 0) {
                        p1_hint = llist_sorted_remove(p1->unique_objects,

diff --git a/pack-revindex.c b/pack-revindex.c
index 3c58784a5f4dedd0738ecc564f1945a10320c772..50891f77a26d6ea65b2c038f4f21ada49255a513 100644 (file)
--- a/pack-revindex.c
+++ b/pack-revindex.c
@@ -119,7 +119,7 @@ static void sort_revindex(struct revindex_entry *entries, unsigned n, off_t max)
  */
 static void create_pack_revindex(struct packed_git *p)
 {
  */
 static void create_pack_revindex(struct packed_git *p)
 {

-       unsigned num_ent = p->num_objects;
+       const unsigned num_ent = p->num_objects;

        unsigned i;
        const char *index = p->index_data;
        const unsigned hashsz = the_hash_algo->rawsz;
        unsigned i;
        const char *index = p->index_data;
        const unsigned hashsz = the_hash_algo->rawsz;


@@ -132,7 +132,7 @@ static void create_pack_revindex(struct packed_git *p)
                        (uint32_t *)(index + 8 + p->num_objects * (hashsz + 4));
                const uint32_t *off_64 = off_32 + p->num_objects;
                for (i = 0; i < num_ent; i++) {
                        (uint32_t *)(index + 8 + p->num_objects * (hashsz + 4));
                const uint32_t *off_64 = off_32 + p->num_objects;
                for (i = 0; i < num_ent; i++) {

-                       uint32_t off = ntohl(*off_32++);
+                       const uint32_t off = ntohl(*off_32++);

                        if (!(off & 0x80000000)) {
                                p->revindex[i].offset = off;
                        } else {
                        if (!(off & 0x80000000)) {
                                p->revindex[i].offset = off;
                        } else {


@@ -143,7 +143,7 @@ static void create_pack_revindex(struct packed_git *p)
                }
        } else {
                for (i = 0; i < num_ent; i++) {
                }
        } else {
                for (i = 0; i < num_ent; i++) {

-                       uint32_t hl = *((uint32_t *)(index + (hashsz + 4) * i));
+                       const uint32_t hl = *((uint32_t *)(index + (hashsz + 4) * i));

                        p->revindex[i].offset = ntohl(hl);
                        p->revindex[i].nr = i;
                }
                        p->revindex[i].offset = ntohl(hl);
                        p->revindex[i].nr = i;
                }


@@ -168,10 +168,10 @@ int find_revindex_position(struct packed_git *p, off_t ofs)
 {
        int lo = 0;
        int hi = p->num_objects + 1;
 {
        int lo = 0;
        int hi = p->num_objects + 1;

-       struct revindex_entry *revindex = p->revindex;
+       const struct revindex_entry *revindex = p->revindex;

 
        do {
 
        do {

-               unsigned mi = lo + (hi - lo) / 2;
+               const unsigned mi = lo + (hi - lo) / 2;

                if (revindex[mi].offset == ofs) {
                        return mi;
                } else if (ofs < revindex[mi].offset)
                if (revindex[mi].offset == ofs) {
                        return mi;
                } else if (ofs < revindex[mi].offset)