merge-recur: Convert variable names to lower_case

Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
Signed-off-by: Junio C Hamano <junkio@cox.net>

diff --git a/merge-recursive.c b/merge-recursive.c
index d78f58d8d2463c49bf14d3639ec60772b232f7f9..5d20f9efce54224d9461f6451a049066b5d75232 100644 (file)
--- a/merge-recursive.c
+++ b/merge-recursive.c
@@ -122,8 +122,8 @@ struct stage_data
        unsigned processed:1;
 };
 
        unsigned processed:1;
 };
 

-static struct path_list currentFileSet = {NULL, 0, 0, 1};
-static struct path_list currentDirectorySet = {NULL, 0, 0, 1};
+static struct path_list current_file_set = {NULL, 0, 0, 1};
+static struct path_list current_directory_set = {NULL, 0, 0, 1};

 
 static int output_indent = 0;
 
 
 static int output_indent = 0;
 


@@ -335,9 +335,9 @@ static int save_files_dirs(const unsigned char *sha1,
        newpath[baselen + len] = '\0';
 
        if (S_ISDIR(mode))
        newpath[baselen + len] = '\0';
 
        if (S_ISDIR(mode))

-               path_list_insert(newpath, &currentDirectorySet);
+               path_list_insert(newpath, &current_directory_set);

        else
        else

-               path_list_insert(newpath, &currentFileSet);
+               path_list_insert(newpath, &current_file_set);

        free(newpath);
 
        return READ_TREE_RECURSIVE;
        free(newpath);
 
        return READ_TREE_RECURSIVE;


@@ -351,7 +351,7 @@ static int get_files_dirs(struct tree *tree)
                debug("  get_files_dirs done (0)\n");
                return 0;
        }
                debug("  get_files_dirs done (0)\n");
                return 0;
        }

-       n = currentFileSet.nr + currentDirectorySet.nr;
+       n = current_file_set.nr + current_directory_set.nr;

        debug("  get_files_dirs done (%d)\n", n);
        return n;
 }
        debug("  get_files_dirs done (%d)\n", n);
        return n;
 }


@@ -378,7 +378,7 @@ static struct stage_data *insert_stage_data(const char *path,
 }
 
 /*
 }
 
 /*

- * Create a dictionary mapping file names to CacheEntry objects. The
+ * Create a dictionary mapping file names to stage_data objects. The

  * dictionary contains one entry for every path with a non-zero stage entry.
  */
 static struct path_list *get_unmerged(void)
  * dictionary contains one entry for every path with a non-zero stage entry.
  */
 static struct path_list *get_unmerged(void)


@@ -420,15 +420,15 @@ struct rename
 };
 
 /*
 };
 
 /*

- * Get information of all renames which occured between 'oTree' and
- * 'tree'. We need the three trees in the merge ('oTree', 'aTree' and
- * 'bTree') to be able to associate the correct cache entries with
- * the rename information. 'tree' is always equal to either aTree or bTree.
+ * Get information of all renames which occured between 'o_tree' and
+ * 'tree'. We need the three trees in the merge ('o_tree', 'a_tree' and
+ * 'b_tree') to be able to associate the correct cache entries with
+ * the rename information. 'tree' is always equal to either a_tree or b_tree.

  */
 static struct path_list *get_renames(struct tree *tree,
  */
 static struct path_list *get_renames(struct tree *tree,

-                                       struct tree *oTree,
-                                       struct tree *aTree,
-                                       struct tree *bTree,
+                                       struct tree *o_tree,
+                                       struct tree *a_tree,
+                                       struct tree *b_tree,

                                        struct path_list *entries)
 {
        int i;
                                        struct path_list *entries)
 {
        int i;


@@ -437,7 +437,7 @@ static struct path_list *get_renames(struct tree *tree,
 #ifdef DEBUG
        time_t t = time(0);
 
 #ifdef DEBUG
        time_t t = time(0);
 

-       debug("getRenames ...\n");
+       debug("get_renames ...\n");

 #endif
 
        renames = xcalloc(1, sizeof(struct path_list));
 #endif
 
        renames = xcalloc(1, sizeof(struct path_list));


@@ -447,7 +447,7 @@ static struct path_list *get_renames(struct tree *tree,
        opts.output_format = DIFF_FORMAT_NO_OUTPUT;
        if (diff_setup_done(&opts) < 0)
                die("diff setup failed");
        opts.output_format = DIFF_FORMAT_NO_OUTPUT;
        if (diff_setup_done(&opts) < 0)
                die("diff setup failed");

-       diff_tree_sha1(oTree->object.sha1, tree->object.sha1, "", &opts);
+       diff_tree_sha1(o_tree->object.sha1, tree->object.sha1, "", &opts);

        diffcore_std(&opts);
        for (i = 0; i < diff_queued_diff.nr; ++i) {
                struct path_list_item *item;
        diffcore_std(&opts);
        for (i = 0; i < diff_queued_diff.nr; ++i) {
                struct path_list_item *item;


@@ -463,14 +463,14 @@ static struct path_list *get_renames(struct tree *tree,
                item = path_list_lookup(re->pair->one->path, entries);
                if (!item)
                        re->src_entry = insert_stage_data(re->pair->one->path,
                item = path_list_lookup(re->pair->one->path, entries);
                if (!item)
                        re->src_entry = insert_stage_data(re->pair->one->path,

-                                       oTree, aTree, bTree, entries);
+                                       o_tree, a_tree, b_tree, entries);

                else
                        re->src_entry = item->util;
 
                item = path_list_lookup(re->pair->two->path, entries);
                if (!item)
                        re->dst_entry = insert_stage_data(re->pair->two->path,
                else
                        re->src_entry = item->util;
 
                item = path_list_lookup(re->pair->two->path, entries);
                if (!item)
                        re->dst_entry = insert_stage_data(re->pair->two->path,

-                                       oTree, aTree, bTree, entries);
+                                       o_tree, a_tree, b_tree, entries);

                else
                        re->dst_entry = item->util;
                item = path_list_insert(pair->one->path, renames);
                else
                        re->dst_entry = item->util;
                item = path_list_insert(pair->one->path, renames);


@@ -480,7 +480,7 @@ static struct path_list *get_renames(struct tree *tree,
        diff_queued_diff.nr = 0;
        diff_flush(&opts);
 #ifdef DEBUG
        diff_queued_diff.nr = 0;
        diff_flush(&opts);
 #ifdef DEBUG

-       debug("  getRenames done in %ld\n", time(0)-t);
+       debug("  get_renames done in %ld\n", time(0)-t);

 #endif
        return renames;
 }
 #endif
        return renames;
 }


@@ -526,25 +526,23 @@ static int remove_path(const char *name)
        return ret;
 }
 
        return ret;
 }
 

-/* General TODO: unC99ify the code: no declaration after code */
-/* General TODO: no javaIfiCation: rename updateCache to update_cache */

 /*
  * TODO: once we no longer call external programs, we'd probably be better off
  * not setting / getting the environment variable GIT_INDEX_FILE all the time.
  */
 int remove_file(int clean, const char *path)
 {
 /*
  * TODO: once we no longer call external programs, we'd probably be better off
  * not setting / getting the environment variable GIT_INDEX_FILE all the time.
  */
 int remove_file(int clean, const char *path)
 {

-       int updateCache = index_only || clean;
-       int updateWd = !index_only;
+       int update_cache = index_only || clean;
+       int update_working_directory = !index_only;

 
 

-       if (updateCache) {
+       if (update_cache) {

                if (!cache_dirty)
                        read_cache_from(getenv("GIT_INDEX_FILE"));
                cache_dirty++;
                if (remove_file_from_cache(path))
                        return -1;
        }
                if (!cache_dirty)
                        read_cache_from(getenv("GIT_INDEX_FILE"));
                cache_dirty++;
                if (remove_file_from_cache(path))
                        return -1;
        }

-       if (updateWd)
+       if (update_working_directory)

        {
                unlink(path);
                if (errno != ENOENT || errno != EISDIR)
        {
                unlink(path);
                if (errno != ENOENT || errno != EISDIR)


@@ -566,12 +564,12 @@ static char *unique_path(const char *path, const char *branch)
        for (; *p; ++p)
                if ('/' == *p)
                        *p = '_';
        for (; *p; ++p)
                if ('/' == *p)
                        *p = '_';

-       while (path_list_has_path(&currentFileSet, newpath) ||
-              path_list_has_path(&currentDirectorySet, newpath) ||
+       while (path_list_has_path(&current_file_set, newpath) ||
+              path_list_has_path(&current_directory_set, newpath) ||

               lstat(newpath, &st) == 0)
                sprintf(p, "_%d", suffix++);
 
               lstat(newpath, &st) == 0)
                sprintf(p, "_%d", suffix++);
 

-       path_list_insert(newpath, &currentFileSet);
+       path_list_insert(newpath, &current_file_set);

        return newpath;
 }
 
        return newpath;
 }
 


@@ -784,22 +782,22 @@ static void conflict_rename_rename(struct rename *ren1,
        int delp = 0;
        const char *ren1_dst = ren1->pair->two->path;
        const char *ren2_dst = ren2->pair->two->path;
        int delp = 0;
        const char *ren1_dst = ren1->pair->two->path;
        const char *ren2_dst = ren2->pair->two->path;

-       const char *dstName1 = ren1_dst;
-       const char *dstName2 = ren2_dst;
-       if (path_list_has_path(&currentDirectorySet, ren1_dst)) {
-               dstName1 = del[delp++] = unique_path(ren1_dst, branch1);
+       const char *dst_name1 = ren1_dst;
+       const char *dst_name2 = ren2_dst;
+       if (path_list_has_path(&current_directory_set, ren1_dst)) {
+               dst_name1 = del[delp++] = unique_path(ren1_dst, branch1);

                output("%s is a directory in %s adding as %s instead",
                output("%s is a directory in %s adding as %s instead",

-                      ren1_dst, branch2, dstName1);
+                      ren1_dst, branch2, dst_name1);

                remove_file(0, ren1_dst);
        }
                remove_file(0, ren1_dst);
        }

-       if (path_list_has_path(&currentDirectorySet, ren2_dst)) {
-               dstName2 = del[delp++] = unique_path(ren2_dst, branch2);
+       if (path_list_has_path(&current_directory_set, ren2_dst)) {
+               dst_name2 = del[delp++] = unique_path(ren2_dst, branch2);

                output("%s is a directory in %s adding as %s instead",
                output("%s is a directory in %s adding as %s instead",

-                      ren2_dst, branch1, dstName2);
+                      ren2_dst, branch1, dst_name2);

                remove_file(0, ren2_dst);
        }
                remove_file(0, ren2_dst);
        }

-       update_stages(dstName1, NULL, ren1->pair->two, NULL, 1);
-       update_stages(dstName2, NULL, NULL, ren2->pair->two, 1);
+       update_stages(dst_name1, NULL, ren1->pair->two, NULL, 1);
+       update_stages(dst_name2, NULL, NULL, ren2->pair->two, 1);

        while (delp--)
                free(del[delp]);
 }
        while (delp--)
                free(del[delp]);
 }


@@ -807,11 +805,11 @@ static void conflict_rename_rename(struct rename *ren1,
 static void conflict_rename_dir(struct rename *ren1,
                                const char *branch1)
 {
 static void conflict_rename_dir(struct rename *ren1,
                                const char *branch1)
 {

-       char *newPath = unique_path(ren1->pair->two->path, branch1);
-       output("Renaming %s to %s instead", ren1->pair->one->path, newPath);
+       char *new_path = unique_path(ren1->pair->two->path, branch1);
+       output("Renaming %s to %s instead", ren1->pair->one->path, new_path);

        remove_file(0, ren1->pair->two->path);
        remove_file(0, ren1->pair->two->path);

-       update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, newPath);
-       free(newPath);
+       update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, new_path);
+       free(new_path);

 }
 
 static void conflict_rename_rename_2(struct rename *ren1,
 }
 
 static void conflict_rename_rename_2(struct rename *ren1,


@@ -819,74 +817,74 @@ static void conflict_rename_rename_2(struct rename *ren1,
                                     struct rename *ren2,
                                     const char *branch2)
 {
                                     struct rename *ren2,
                                     const char *branch2)
 {

-       char *newPath1 = unique_path(ren1->pair->two->path, branch1);
-       char *newPath2 = unique_path(ren2->pair->two->path, branch2);
+       char *new_path1 = unique_path(ren1->pair->two->path, branch1);
+       char *new_path2 = unique_path(ren2->pair->two->path, branch2);

        output("Renaming %s to %s and %s to %s instead",
        output("Renaming %s to %s and %s to %s instead",

-              ren1->pair->one->path, newPath1,
-              ren2->pair->one->path, newPath2);
+              ren1->pair->one->path, new_path1,
+              ren2->pair->one->path, new_path2);

        remove_file(0, ren1->pair->two->path);
        remove_file(0, ren1->pair->two->path);

-       update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, newPath1);
-       update_file(0, ren2->pair->two->sha1, ren2->pair->two->mode, newPath2);
-       free(newPath2);
-       free(newPath1);
+       update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, new_path1);
+       update_file(0, ren2->pair->two->sha1, ren2->pair->two->mode, new_path2);
+       free(new_path2);
+       free(new_path1);

 }
 
 /* General TODO: get rid of all the debug messages */
 }
 
 /* General TODO: get rid of all the debug messages */

-static int process_renames(struct path_list *renamesA,
-                          struct path_list *renamesB,
-                          const char *branchNameA,
-                          const char *branchNameB)
+static int process_renames(struct path_list *a_renames,
+                          struct path_list *b_renames,
+                          const char *a_branch,
+                          const char *b_branch)

 {
 {

-       int cleanMerge = 1, i, j;
-       struct path_list byDstA = {NULL, 0, 0, 0}, byDstB = {NULL, 0, 0, 0};
+       int clean_merge = 1, i, j;
+       struct path_list a_by_dst = {NULL, 0, 0, 0}, b_by_dst = {NULL, 0, 0, 0};

        const struct rename *sre;
 
        const struct rename *sre;
 

-       for (i = 0; i < renamesA->nr; i++) {
-               sre = renamesA->items[i].util;
-               path_list_insert(sre->pair->two->path, &byDstA)->util
+       for (i = 0; i < a_renames->nr; i++) {
+               sre = a_renames->items[i].util;
+               path_list_insert(sre->pair->two->path, &a_by_dst)->util

                        = sre->dst_entry;
        }
                        = sre->dst_entry;
        }

-       for (i = 0; i < renamesB->nr; i++) {
-               sre = renamesB->items[i].util;
-               path_list_insert(sre->pair->two->path, &byDstB)->util
+       for (i = 0; i < b_renames->nr; i++) {
+               sre = b_renames->items[i].util;
+               path_list_insert(sre->pair->two->path, &b_by_dst)->util

                        = sre->dst_entry;
        }
 
                        = sre->dst_entry;
        }
 

-       for (i = 0, j = 0; i < renamesA->nr || j < renamesB->nr;) {
+       for (i = 0, j = 0; i < a_renames->nr || j < b_renames->nr;) {

                int compare;
                char *src;
                struct path_list *renames1, *renames2, *renames2Dst;
                struct rename *ren1 = NULL, *ren2 = NULL;
                int compare;
                char *src;
                struct path_list *renames1, *renames2, *renames2Dst;
                struct rename *ren1 = NULL, *ren2 = NULL;

-               const char *branchName1, *branchName2;
+               const char *branch1, *branch2;

                const char *ren1_src, *ren1_dst;
 
                const char *ren1_src, *ren1_dst;
 

-               if (i >= renamesA->nr) {
+               if (i >= a_renames->nr) {

                        compare = 1;
                        compare = 1;

-                       ren2 = renamesB->items[j++].util;
-               } else if (j >= renamesB->nr) {
+                       ren2 = b_renames->items[j++].util;
+               } else if (j >= b_renames->nr) {

                        compare = -1;
                        compare = -1;

-                       ren1 = renamesA->items[i++].util;
+                       ren1 = a_renames->items[i++].util;

                } else {
                } else {

-                       compare = strcmp(renamesA->items[i].path,
-                                       renamesB->items[j].path);
-                       ren1 = renamesA->items[i++].util;
-                       ren2 = renamesB->items[j++].util;
+                       compare = strcmp(a_renames->items[i].path,
+                                       b_renames->items[j].path);
+                       ren1 = a_renames->items[i++].util;
+                       ren2 = b_renames->items[j++].util;

                }
 
                /* TODO: refactor, so that 1/2 are not needed */
                if (ren1) {
                }
 
                /* TODO: refactor, so that 1/2 are not needed */
                if (ren1) {

-                       renames1 = renamesA;
-                       renames2 = renamesB;
-                       renames2Dst = &byDstB;
-                       branchName1 = branchNameA;
-                       branchName2 = branchNameB;
+                       renames1 = a_renames;
+                       renames2 = b_renames;
+                       renames2Dst = &b_by_dst;
+                       branch1 = a_branch;
+                       branch2 = b_branch;

                } else {
                        struct rename *tmp;
                } else {
                        struct rename *tmp;

-                       renames1 = renamesB;
-                       renames2 = renamesA;
-                       renames2Dst = &byDstA;
-                       branchName1 = branchNameB;
-                       branchName2 = branchNameA;
+                       renames1 = b_renames;
+                       renames2 = a_renames;
+                       renames2Dst = &a_by_dst;
+                       branch1 = b_branch;
+                       branch2 = a_branch;

                        tmp = ren2;
                        ren2 = ren1;
                        ren1 = tmp;
                        tmp = ren2;
                        ren2 = ren1;
                        ren1 = tmp;


@@ -912,21 +910,21 @@ static int process_renames(struct path_list *renamesA,
                        ren2->dst_entry->processed = 1;
                        ren2->processed = 1;
                        if (strcmp(ren1_dst, ren2_dst) != 0) {
                        ren2->dst_entry->processed = 1;
                        ren2->processed = 1;
                        if (strcmp(ren1_dst, ren2_dst) != 0) {

-                               cleanMerge = 0;
+                               clean_merge = 0;

                                output("CONFLICT (rename/rename): "
                                       "Rename %s->%s in branch %s "
                                       "rename %s->%s in %s",
                                output("CONFLICT (rename/rename): "
                                       "Rename %s->%s in branch %s "
                                       "rename %s->%s in %s",

-                                      src, ren1_dst, branchName1,
-                                      src, ren2_dst, branchName2);
-                               conflict_rename_rename(ren1, branchName1, ren2, branchName2);
+                                      src, ren1_dst, branch1,
+                                      src, ren2_dst, branch2);
+                               conflict_rename_rename(ren1, branch1, ren2, branch2);

                        } else {
                        } else {

-                               remove_file(1, ren1_src);

                                struct merge_file_info mfi;
                                struct merge_file_info mfi;

+                               remove_file(1, ren1_src);

                                mfi = merge_file(ren1->pair->one,
                                                 ren1->pair->two,
                                                 ren2->pair->two,
                                mfi = merge_file(ren1->pair->one,
                                                 ren1->pair->two,
                                                 ren2->pair->two,

-                                                branchName1,
-                                                branchName2);
+                                                branch1,
+                                                branch2);

                                if (mfi.merge || !mfi.clean)
                                        output("Renaming %s->%s", src, ren1_dst);
 
                                if (mfi.merge || !mfi.clean)
                                        output("Renaming %s->%s", src, ren1_dst);
 


@@ -936,7 +934,7 @@ static int process_renames(struct path_list *renamesA,
                                if (!mfi.clean) {
                                        output("CONFLICT (content): merge conflict in %s",
                                               ren1_dst);
                                if (!mfi.clean) {
                                        output("CONFLICT (content): merge conflict in %s",
                                               ren1_dst);

-                                       cleanMerge = 0;
+                                       clean_merge = 0;

 
                                        if (!index_only)
                                                update_stages(ren1_dst,
 
                                        if (!index_only)
                                                update_stages(ren1_dst,


@@ -952,7 +950,7 @@ static int process_renames(struct path_list *renamesA,
                        struct path_list_item *item;
                        /* we only use sha1 and mode of these */
                        struct diff_filespec src_other, dst_other;
                        struct path_list_item *item;
                        /* we only use sha1 and mode of these */
                        struct diff_filespec src_other, dst_other;

-                       int tryMerge, stage = renamesA == renames1 ? 3: 2;
+                       int try_merge, stage = a_renames == renames1 ? 3: 2;

 
                        remove_file(1, ren1_src);
 
 
                        remove_file(1, ren1_src);
 


@@ -963,52 +961,52 @@ static int process_renames(struct path_list *renamesA,
                                        ren1->dst_entry->stages[stage].sha, 20);
                        dst_other.mode = ren1->dst_entry->stages[stage].mode;
 
                                        ren1->dst_entry->stages[stage].sha, 20);
                        dst_other.mode = ren1->dst_entry->stages[stage].mode;
 

-                       tryMerge = 0;
+                       try_merge = 0;

 
 

-                       if (path_list_has_path(&currentDirectorySet, ren1_dst)) {
-                               cleanMerge = 0;
+                       if (path_list_has_path(&current_directory_set, ren1_dst)) {
+                               clean_merge = 0;

                                output("CONFLICT (rename/directory): Rename %s->%s in %s "
                                       " directory %s added in %s",
                                output("CONFLICT (rename/directory): Rename %s->%s in %s "
                                       " directory %s added in %s",

-                                      ren1_src, ren1_dst, branchName1,
-                                      ren1_dst, branchName2);
-                               conflict_rename_dir(ren1, branchName1);
+                                      ren1_src, ren1_dst, branch1,
+                                      ren1_dst, branch2);
+                               conflict_rename_dir(ren1, branch1);

                        } else if (sha_eq(src_other.sha1, null_sha1)) {
                        } else if (sha_eq(src_other.sha1, null_sha1)) {

-                               cleanMerge = 0;
+                               clean_merge = 0;

                                output("CONFLICT (rename/delete): Rename %s->%s in %s "
                                       "and deleted in %s",
                                output("CONFLICT (rename/delete): Rename %s->%s in %s "
                                       "and deleted in %s",

-                                      ren1_src, ren1_dst, branchName1,
-                                      branchName2);
+                                      ren1_src, ren1_dst, branch1,
+                                      branch2);

                                update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, ren1_dst);
                        } else if (!sha_eq(dst_other.sha1, null_sha1)) {
                                update_file(0, ren1->pair->two->sha1, ren1->pair->two->mode, ren1_dst);
                        } else if (!sha_eq(dst_other.sha1, null_sha1)) {

-                               const char *newPath;
-                               cleanMerge = 0;
-                               tryMerge = 1;
+                               const char *new_path;
+                               clean_merge = 0;
+                               try_merge = 1;

                                output("CONFLICT (rename/add): Rename %s->%s in %s. "
                                       "%s added in %s",
                                output("CONFLICT (rename/add): Rename %s->%s in %s. "
                                       "%s added in %s",

-                                      ren1_src, ren1_dst, branchName1,
-                                      ren1_dst, branchName2);
-                               newPath = unique_path(ren1_dst, branchName2);
-                               output("Adding as %s instead", newPath);
-                               update_file(0, dst_other.sha1, dst_other.mode, newPath);
+                                      ren1_src, ren1_dst, branch1,
+                                      ren1_dst, branch2);
+                               new_path = unique_path(ren1_dst, branch2);
+                               output("Adding as %s instead", new_path);
+                               update_file(0, dst_other.sha1, dst_other.mode, new_path);

                        } else if ((item = path_list_lookup(ren1_dst, renames2Dst))) {
                                ren2 = item->util;
                        } else if ((item = path_list_lookup(ren1_dst, renames2Dst))) {
                                ren2 = item->util;

-                               cleanMerge = 0;
+                               clean_merge = 0;

                                ren2->processed = 1;
                                output("CONFLICT (rename/rename): Rename %s->%s in %s. "
                                       "Rename %s->%s in %s",
                                ren2->processed = 1;
                                output("CONFLICT (rename/rename): Rename %s->%s in %s. "
                                       "Rename %s->%s in %s",

-                                      ren1_src, ren1_dst, branchName1,
-                                      ren2->pair->one->path, ren2->pair->two->path, branchName2);
-                               conflict_rename_rename_2(ren1, branchName1, ren2, branchName2);
+                                      ren1_src, ren1_dst, branch1,
+                                      ren2->pair->one->path, ren2->pair->two->path, branch2);
+                               conflict_rename_rename_2(ren1, branch1, ren2, branch2);

                        } else
                        } else

-                               tryMerge = 1;
+                               try_merge = 1;

 
 

-                       if (tryMerge) {
+                       if (try_merge) {

                                struct diff_filespec *o, *a, *b;
                                struct merge_file_info mfi;
                                src_other.path = (char *)ren1_src;
 
                                o = ren1->pair->one;
                                struct diff_filespec *o, *a, *b;
                                struct merge_file_info mfi;
                                src_other.path = (char *)ren1_src;
 
                                o = ren1->pair->one;

-                               if (renamesA == renames1) {
+                               if (a_renames == renames1) {

                                        a = ren1->pair->two;
                                        b = &src_other;
                                } else {
                                        a = ren1->pair->two;
                                        b = &src_other;
                                } else {


@@ -1016,7 +1014,7 @@ static int process_renames(struct path_list *renamesA,
                                        a = &src_other;
                                }
                                mfi = merge_file(o, a, b,
                                        a = &src_other;
                                }
                                mfi = merge_file(o, a, b,

-                                               branchNameA, branchNameB);
+                                               a_branch, b_branch);

 
                                if (mfi.merge || !mfi.clean)
                                        output("Renaming %s => %s", ren1_src, ren1_dst);
 
                                if (mfi.merge || !mfi.clean)
                                        output("Renaming %s => %s", ren1_src, ren1_dst);


@@ -1025,7 +1023,7 @@ static int process_renames(struct path_list *renamesA,
                                if (!mfi.clean) {
                                        output("CONFLICT (rename/modify): Merge conflict in %s",
                                               ren1_dst);
                                if (!mfi.clean) {
                                        output("CONFLICT (rename/modify): Merge conflict in %s",
                                               ren1_dst);

-                                       cleanMerge = 0;
+                                       clean_merge = 0;

 
                                        if (!index_only)
                                                update_stages(ren1_dst,
 
                                        if (!index_only)
                                                update_stages(ren1_dst,


@@ -1035,12 +1033,12 @@ static int process_renames(struct path_list *renamesA,
                        }
                }
        }
                        }
                }
        }

-       path_list_clear(&byDstA, 0);
-       path_list_clear(&byDstB, 0);
+       path_list_clear(&a_by_dst, 0);
+       path_list_clear(&b_by_dst, 0);

 
        if (cache_dirty)
                flush_cache();
 
        if (cache_dirty)
                flush_cache();

-       return cleanMerge;
+       return clean_merge;

 }
 
 static unsigned char *has_sha(const unsigned char *sha)
 }
 
 static unsigned char *has_sha(const unsigned char *sha)


@@ -1057,116 +1055,116 @@ static int process_entry(const char *path, struct stage_data *entry,
        printf("processing entry, clean cache: %s\n", index_only ? "yes": "no");
        print_index_entry("\tpath: ", entry);
        */
        printf("processing entry, clean cache: %s\n", index_only ? "yes": "no");
        print_index_entry("\tpath: ", entry);
        */

-       int cleanMerge = 1;
-       unsigned char *oSha = has_sha(entry->stages[1].sha);
-       unsigned char *aSha = has_sha(entry->stages[2].sha);
-       unsigned char *bSha = has_sha(entry->stages[3].sha);
-       unsigned oMode = entry->stages[1].mode;
-       unsigned aMode = entry->stages[2].mode;
-       unsigned bMode = entry->stages[3].mode;
-
-       if (oSha && (!aSha || !bSha)) {
+       int clean_merge = 1;
+       unsigned char *o_sha = has_sha(entry->stages[1].sha);
+       unsigned char *a_sha = has_sha(entry->stages[2].sha);
+       unsigned char *b_sha = has_sha(entry->stages[3].sha);
+       unsigned o_mode = entry->stages[1].mode;
+       unsigned a_mode = entry->stages[2].mode;
+       unsigned b_mode = entry->stages[3].mode;
+
+       if (o_sha && (!a_sha || !b_sha)) {

                /* Case A: Deleted in one */
                /* Case A: Deleted in one */

-               if ((!aSha && !bSha) ||
-                   (sha_eq(aSha, oSha) && !bSha) ||
-                   (!aSha && sha_eq(bSha, oSha))) {
+               if ((!a_sha && !b_sha) ||
+                   (sha_eq(a_sha, o_sha) && !b_sha) ||
+                   (!a_sha && sha_eq(b_sha, o_sha))) {

                        /* Deleted in both or deleted in one and
                         * unchanged in the other */
                        /* Deleted in both or deleted in one and
                         * unchanged in the other */

-                       if (aSha)
+                       if (a_sha)

                                output("Removing %s", path);
                        remove_file(1, path);
                } else {
                        /* Deleted in one and changed in the other */
                                output("Removing %s", path);
                        remove_file(1, path);
                } else {
                        /* Deleted in one and changed in the other */

-                       cleanMerge = 0;
-                       if (!aSha) {
+                       clean_merge = 0;
+                       if (!a_sha) {

                                output("CONFLICT (delete/modify): %s deleted in %s "
                                       "and modified in %s. Version %s of %s left in tree.",
                                       path, branch1Name,
                                       branch2Name, branch2Name, path);
                                output("CONFLICT (delete/modify): %s deleted in %s "
                                       "and modified in %s. Version %s of %s left in tree.",
                                       path, branch1Name,
                                       branch2Name, branch2Name, path);

-                               update_file(0, bSha, bMode, path);
+                               update_file(0, b_sha, b_mode, path);

                        } else {
                                output("CONFLICT (delete/modify): %s deleted in %s "
                                       "and modified in %s. Version %s of %s left in tree.",
                                       path, branch2Name,
                                       branch1Name, branch1Name, path);
                        } else {
                                output("CONFLICT (delete/modify): %s deleted in %s "
                                       "and modified in %s. Version %s of %s left in tree.",
                                       path, branch2Name,
                                       branch1Name, branch1Name, path);

-                               update_file(0, aSha, aMode, path);
+                               update_file(0, a_sha, a_mode, path);

                        }
                }
 
                        }
                }
 

-       } else if ((!oSha && aSha && !bSha) ||
-                  (!oSha && !aSha && bSha)) {
+       } else if ((!o_sha && a_sha && !b_sha) ||
+                  (!o_sha && !a_sha && b_sha)) {

                /* Case B: Added in one. */
                /* Case B: Added in one. */

-               const char *addBranch;
-               const char *otherBranch;
+               const char *add_branch;
+               const char *other_branch;

                unsigned mode;
                const unsigned char *sha;
                const char *conf;
 
                unsigned mode;
                const unsigned char *sha;
                const char *conf;
 

-               if (aSha) {
-                       addBranch = branch1Name;
-                       otherBranch = branch2Name;
-                       mode = aMode;
-                       sha = aSha;
+               if (a_sha) {
+                       add_branch = branch1Name;
+                       other_branch = branch2Name;
+                       mode = a_mode;
+                       sha = a_sha;

                        conf = "file/directory";
                } else {
                        conf = "file/directory";
                } else {

-                       addBranch = branch2Name;
-                       otherBranch = branch1Name;
-                       mode = bMode;
-                       sha = bSha;
+                       add_branch = branch2Name;
+                       other_branch = branch1Name;
+                       mode = b_mode;
+                       sha = b_sha;

                        conf = "directory/file";
                }
                        conf = "directory/file";
                }

-               if (path_list_has_path(&currentDirectorySet, path)) {
-                       const char *newPath = unique_path(path, addBranch);
-                       cleanMerge = 0;
+               if (path_list_has_path(&current_directory_set, path)) {
+                       const char *new_path = unique_path(path, add_branch);
+                       clean_merge = 0;

                        output("CONFLICT (%s): There is a directory with name %s in %s. "
                               "Adding %s as %s",
                        output("CONFLICT (%s): There is a directory with name %s in %s. "
                               "Adding %s as %s",

-                              conf, path, otherBranch, path, newPath);
+                              conf, path, other_branch, path, new_path);

                        remove_file(0, path);
                        remove_file(0, path);

-                       update_file(0, sha, mode, newPath);
+                       update_file(0, sha, mode, new_path);

                } else {
                        output("Adding %s", path);
                        update_file(1, sha, mode, path);
                }
                } else {
                        output("Adding %s", path);
                        update_file(1, sha, mode, path);
                }

-       } else if (!oSha && aSha && bSha) {
+       } else if (!o_sha && a_sha && b_sha) {

                /* Case C: Added in both (check for same permissions). */
                /* Case C: Added in both (check for same permissions). */

-               if (sha_eq(aSha, bSha)) {
-                       if (aMode != bMode) {
-                               cleanMerge = 0;
+               if (sha_eq(a_sha, b_sha)) {
+                       if (a_mode != b_mode) {
+                               clean_merge = 0;

                                output("CONFLICT: File %s added identically in both branches, "
                                       "but permissions conflict %06o->%06o",
                                output("CONFLICT: File %s added identically in both branches, "
                                       "but permissions conflict %06o->%06o",

-                                      path, aMode, bMode);
-                               output("CONFLICT: adding with permission: %06o", aMode);
-                               update_file(0, aSha, aMode, path);
+                                      path, a_mode, b_mode);
+                               output("CONFLICT: adding with permission: %06o", a_mode);
+                               update_file(0, a_sha, a_mode, path);

                        } else {
                                /* This case is handled by git-read-tree */
                                assert(0 && "This case must be handled by git-read-tree");
                        }
                } else {
                        } else {
                                /* This case is handled by git-read-tree */
                                assert(0 && "This case must be handled by git-read-tree");
                        }
                } else {

-                       const char *newPath1, *newPath2;
-                       cleanMerge = 0;
-                       newPath1 = unique_path(path, branch1Name);
-                       newPath2 = unique_path(path, branch2Name);
+                       const char *new_path1, *new_path2;
+                       clean_merge = 0;
+                       new_path1 = unique_path(path, branch1Name);
+                       new_path2 = unique_path(path, branch2Name);

                        output("CONFLICT (add/add): File %s added non-identically "
                               "in both branches. Adding as %s and %s instead.",
                        output("CONFLICT (add/add): File %s added non-identically "
                               "in both branches. Adding as %s and %s instead.",

-                              path, newPath1, newPath2);
+                              path, new_path1, new_path2);

                        remove_file(0, path);
                        remove_file(0, path);

-                       update_file(0, aSha, aMode, newPath1);
-                       update_file(0, bSha, bMode, newPath2);
+                       update_file(0, a_sha, a_mode, new_path1);
+                       update_file(0, b_sha, b_mode, new_path2);

                }
 
                }
 

-       } else if (oSha && aSha && bSha) {
+       } else if (o_sha && a_sha && b_sha) {

                /* case D: Modified in both, but differently. */
                struct merge_file_info mfi;
                struct diff_filespec o, a, b;
 
                output("Auto-merging %s", path);
                o.path = a.path = b.path = (char *)path;
                /* case D: Modified in both, but differently. */
                struct merge_file_info mfi;
                struct diff_filespec o, a, b;
 
                output("Auto-merging %s", path);
                o.path = a.path = b.path = (char *)path;

-               memcpy(o.sha1, oSha, 20);
-               o.mode = oMode;
-               memcpy(a.sha1, aSha, 20);
-               a.mode = aMode;
-               memcpy(b.sha1, bSha, 20);
-               b.mode = bMode;
+               memcpy(o.sha1, o_sha, 20);
+               o.mode = o_mode;
+               memcpy(a.sha1, a_sha, 20);
+               a.mode = a_mode;
+               memcpy(b.sha1, b_sha, 20);
+               b.mode = b_mode;

 
                mfi = merge_file(&o, &a, &b,
                                 branch1Name, branch2Name);
 
                mfi = merge_file(&o, &a, &b,
                                 branch1Name, branch2Name);


@@ -1174,14 +1172,14 @@ static int process_entry(const char *path, struct stage_data *entry,
                if (mfi.clean)
                        update_file(1, mfi.sha, mfi.mode, path);
                else {
                if (mfi.clean)
                        update_file(1, mfi.sha, mfi.mode, path);
                else {

-                       cleanMerge = 0;
+                       clean_merge = 0;

                        output("CONFLICT (content): Merge conflict in %s", path);
 
                        if (index_only)
                                update_file(0, mfi.sha, mfi.mode, path);
                        else
                                update_file_flags(mfi.sha, mfi.mode, path,
                        output("CONFLICT (content): Merge conflict in %s", path);
 
                        if (index_only)
                                update_file(0, mfi.sha, mfi.mode, path);
                        else
                                update_file_flags(mfi.sha, mfi.mode, path,

-                                             0 /* updateCache */, 1 /* updateWd */);
+                                             0 /* update_cache */, 1 /* update_working_directory */);

                }
        } else
                die("Fatal merge failure, shouldn't happen.");
                }
        } else
                die("Fatal merge failure, shouldn't happen.");


@@ -1189,7 +1187,7 @@ static int process_entry(const char *path, struct stage_data *entry,
        if (cache_dirty)
                flush_cache();
 
        if (cache_dirty)
                flush_cache();
 

-       return cleanMerge;
+       return clean_merge;

 }
 
 static int merge_trees(struct tree *head,
 }
 
 static int merge_trees(struct tree *head,


@@ -1218,8 +1216,8 @@ static int merge_trees(struct tree *head,
        if (!*result) {
                struct path_list *entries, *re_head, *re_merge;
                int i;
        if (!*result) {
                struct path_list *entries, *re_head, *re_merge;
                int i;

-               path_list_clear(&currentFileSet, 1);
-               path_list_clear(&currentDirectorySet, 1);
+               path_list_clear(&current_file_set, 1);
+               path_list_clear(&current_directory_set, 1);

                get_files_dirs(head);
                get_files_dirs(merge);
 
                get_files_dirs(head);
                get_files_dirs(merge);
 


@@ -1265,12 +1263,12 @@ int merge(struct commit *h1,
                          struct commit *h2,
                          const char *branch1Name,
                          const char *branch2Name,
                          struct commit *h2,
                          const char *branch1Name,
                          const char *branch2Name,

-                         int callDepth /* =0 */,
+                         int call_depth /* =0 */,

                          struct commit *ancestor /* =None */,
                          struct commit **result)
 {
        struct commit_list *ca = NULL, *iter;
                          struct commit *ancestor /* =None */,
                          struct commit **result)
 {
        struct commit_list *ca = NULL, *iter;

-       struct commit *mergedCA;
+       struct commit *merged_common_ancestors;

        struct tree *mrtree;
        int clean;
 
        struct tree *mrtree;
        int clean;
 


@@ -1287,10 +1285,10 @@ int merge(struct commit *h1,
        for (iter = ca; iter; iter = iter->next)
                output_commit_title(iter->item);
 
        for (iter = ca; iter; iter = iter->next)
                output_commit_title(iter->item);
 

-       mergedCA = pop_commit(&ca);
+       merged_common_ancestors = pop_commit(&ca);

 
        for (iter = ca; iter; iter = iter->next) {
 
        for (iter = ca; iter; iter = iter->next) {

-               output_indent = callDepth + 1;
+               output_indent = call_depth + 1;

                /*
                 * When the merge fails, the result contains files
                 * with conflict markers. The cleanness flag is
                /*
                 * When the merge fails, the result contains files
                 * with conflict markers. The cleanness flag is


@@ -1298,19 +1296,19 @@ int merge(struct commit *h1,
                 * merge_trees has always overwritten it: the commited
                 * "conflicts" were already resolved.
                 */
                 * merge_trees has always overwritten it: the commited
                 * "conflicts" were already resolved.
                 */

-               merge(mergedCA, iter->item,
+               merge(merged_common_ancestors, iter->item,

                      "Temporary merge branch 1",
                      "Temporary merge branch 2",
                      "Temporary merge branch 1",
                      "Temporary merge branch 2",

-                     callDepth + 1,
+                     call_depth + 1,

                      NULL,
                      NULL,

-                     &mergedCA);
-               output_indent = callDepth;
+                     &merged_common_ancestors);
+               output_indent = call_depth;

 
 

-               if (!mergedCA)
+               if (!merged_common_ancestors)

                        die("merge returned no commit");
        }
 
                        die("merge returned no commit");
        }
 

-       if (callDepth == 0) {
+       if (call_depth == 0) {

                setup_index(0 /* $GIT_DIR/index */);
                index_only = 0;
        } else {
                setup_index(0 /* $GIT_DIR/index */);
                index_only = 0;
        } else {


@@ -1319,7 +1317,7 @@ int merge(struct commit *h1,
                index_only = 1;
        }
 
                index_only = 1;
        }
 

-       clean = merge_trees(h1->tree, h2->tree, mergedCA->tree,
+       clean = merge_trees(h1->tree, h2->tree, merged_common_ancestors->tree,

                            branch1Name, branch2Name, &mrtree);
 
        if (!ancestor && (clean || index_only)) {
                            branch1Name, branch2Name, &mrtree);
 
        if (!ancestor && (clean || index_only)) {