merge_ort_nonrecursive_internal() will be used by both
merge_inmemory_nonrecursive() and merge_inmemory_recursive(); let's
focus on it for now. It involves some setup -- merge_start() --
followed by the following chain of functions:
collect_merge_info()
This function will populate merge_options_internal's paths field,
via a call to traverse_trees() and a new callback that will be added
later.
detect_and_process_renames()
This function will detect renames, and then adjust entries in paths
to move conflict stages from old pathnames into those for new
pathnames, so that the next step doesn't have to think about renames
and just can do three-way content merging and such.
process_entries()
This function determines how to take the various stages (versions of
a file from the three different sides) and merge them, and whether
to mark the result as conflicted or cleanly merged. It also writes
out these merged file versions as it goes to create a tree.
Signed-off-by: Elijah Newren <newren@xxxxxxxxx>
---
merge-ort.c | 67 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 66 insertions(+), 1 deletion(-)
diff --git a/merge-ort.c b/merge-ort.c
index 9d5ea0930d..b53cd80104 100644
--- a/merge-ort.c
+++ b/merge-ort.c
@@ -18,6 +18,7 @@
#include "merge-ort.h"
#include "strmap.h"
+#include "tree.h"
struct merge_options_internal {
struct strmap paths; /* maps path -> (merged|conflict)_info */
@@ -57,6 +58,37 @@ struct conflict_info {
unsigned match_mask:3;
};
+static int collect_merge_info(struct merge_options *opt,
+ struct tree *merge_base,
+ struct tree *side1,
+ struct tree *side2)
+{
+ die("Not yet implemented.");
+}
+
+static int detect_and_process_renames(struct merge_options *opt,
+ struct tree *merge_base,
+ struct tree *side1,
+ struct tree *side2)
+{
+ int clean = 1;
+
+ /*
+ * Rename detection works by detecting file similarity. Here we use
+ * a really easy-to-implement scheme: files are similar IFF they have
+ * the same filename. Therefore, by this scheme, there are no renames.
+ *
+ * TODO: Actually implement a real rename detection scheme.
+ */
+ return clean;
+}
+
+static void process_entries(struct merge_options *opt,
+ struct object_id *result_oid)
+{
+ die("Not yet implemented.");
+}
+
void merge_switch_to_result(struct merge_options *opt,
struct tree *head,
struct merge_result *result,
@@ -73,13 +105,46 @@ void merge_finalize(struct merge_options *opt,
die("Not yet implemented");
}
+static void merge_start(struct merge_options *opt, struct merge_result *result)
+{
+ die("Not yet implemented.");
+}
+
+/*
+ * Originally from merge_trees_internal(); heavily adapted, though.
+ */
+static void merge_ort_nonrecursive_internal(struct merge_options *opt,
+ struct tree *merge_base,
+ struct tree *side1,
+ struct tree *side2,
+ struct merge_result *result)
+{
+ struct object_id working_tree_oid;
+
+ collect_merge_info(opt, merge_base, side1, side2);
+ result->clean = detect_and_process_renames(opt, merge_base,
+ side1, side2);
+ process_entries(opt, &working_tree_oid);
+
+ /* Set return values */
+ result->tree = parse_tree_indirect(&working_tree_oid);
+ /* existence of unmerged entries implies unclean */
+ result->clean &= strmap_empty(&opt->priv->unmerged);
+ if (!opt->priv->call_depth) {
+ result->priv = opt->priv;
+ opt->priv = NULL;
+ }
+}
+
void merge_incore_nonrecursive(struct merge_options *opt,
struct tree *merge_base,
struct tree *side1,
struct tree *side2,
struct merge_result *result)
{
- die("Not yet implemented");
+ assert(opt->ancestor != NULL);
+ merge_start(opt, result);
+ merge_ort_nonrecursive_internal(opt, merge_base, side1, side2, result);
}
void merge_incore_recursive(struct merge_options *opt,
--
2.29.0.471.ga4f56089c0
