2005-04-08 06:16:10 +08:00
|
|
|
/*
|
|
|
|
* GIT - The information manager from hell
|
|
|
|
*
|
|
|
|
* Copyright (C) Linus Torvalds, 2005
|
|
|
|
*/
|
2005-09-07 03:53:56 +08:00
|
|
|
|
2005-04-08 06:13:13 +08:00
|
|
|
#include "cache.h"
|
2005-09-05 14:04:48 +08:00
|
|
|
#include "object.h"
|
|
|
|
#include "tree.h"
|
2006-05-30 03:18:00 +08:00
|
|
|
#include "tree-walk.h"
|
2006-04-25 12:18:58 +08:00
|
|
|
#include "cache-tree.h"
|
2006-07-31 02:25:18 +08:00
|
|
|
#include "unpack-trees.h"
|
2006-12-05 08:00:46 +08:00
|
|
|
#include "dir.h"
|
2006-05-23 20:15:32 +08:00
|
|
|
#include "builtin.h"
|
2005-09-05 14:04:48 +08:00
|
|
|
|
2007-08-10 13:21:29 +08:00
|
|
|
static int nr_trees;
|
2008-03-14 13:07:18 +08:00
|
|
|
static struct tree *trees[MAX_UNPACK_TREES];
|
2005-09-05 14:04:48 +08:00
|
|
|
|
|
|
|
static int list_tree(unsigned char *sha1)
|
|
|
|
{
|
2007-08-10 13:21:29 +08:00
|
|
|
struct tree *tree;
|
|
|
|
|
2008-03-14 13:07:18 +08:00
|
|
|
if (nr_trees >= MAX_UNPACK_TREES)
|
|
|
|
die("I cannot read more than %d trees", MAX_UNPACK_TREES);
|
2007-08-10 13:21:29 +08:00
|
|
|
tree = parse_tree_indirect(sha1);
|
2005-09-05 14:04:48 +08:00
|
|
|
if (!tree)
|
|
|
|
return -1;
|
2007-08-10 13:21:29 +08:00
|
|
|
trees[nr_trees++] = tree;
|
2005-09-05 14:04:48 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-04-27 16:33:07 +08:00
|
|
|
static void prime_cache_tree_rec(struct cache_tree *it, struct tree *tree)
|
|
|
|
{
|
2006-05-30 03:18:00 +08:00
|
|
|
struct tree_desc desc;
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-31 00:45:45 +08:00
|
|
|
struct name_entry entry;
|
2006-04-27 16:33:07 +08:00
|
|
|
int cnt;
|
2006-05-20 15:56:11 +08:00
|
|
|
|
2006-08-23 14:49:00 +08:00
|
|
|
hashcpy(it->sha1, tree->object.sha1);
|
2007-03-22 01:08:25 +08:00
|
|
|
init_tree_desc(&desc, tree->buffer, tree->size);
|
2006-05-30 03:18:00 +08:00
|
|
|
cnt = 0;
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-31 00:45:45 +08:00
|
|
|
while (tree_entry(&desc, &entry)) {
|
|
|
|
if (!S_ISDIR(entry.mode))
|
2006-04-27 16:33:07 +08:00
|
|
|
cnt++;
|
|
|
|
else {
|
|
|
|
struct cache_tree_sub *sub;
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-31 00:45:45 +08:00
|
|
|
struct tree *subtree = lookup_tree(entry.sha1);
|
2006-04-27 16:33:07 +08:00
|
|
|
if (!subtree->object.parsed)
|
|
|
|
parse_tree(subtree);
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-31 00:45:45 +08:00
|
|
|
sub = cache_tree_sub(it, entry.path);
|
2006-04-27 16:33:07 +08:00
|
|
|
sub->cache_tree = cache_tree();
|
|
|
|
prime_cache_tree_rec(sub->cache_tree, subtree);
|
|
|
|
cnt += sub->cache_tree->entry_count;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
it->entry_count = cnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void prime_cache_tree(void)
|
|
|
|
{
|
2007-08-10 13:21:29 +08:00
|
|
|
if (!nr_trees)
|
2006-04-27 16:33:07 +08:00
|
|
|
return;
|
|
|
|
active_cache_tree = cache_tree();
|
2007-08-10 13:21:29 +08:00
|
|
|
prime_cache_tree_rec(active_cache_tree, trees[0]);
|
2006-04-27 16:33:07 +08:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2008-09-14 01:18:36 +08:00
|
|
|
static const char read_tree_usage[] = "git read-tree (<sha> | [[-m [--trivial] [--aggressive] | --reset | --prefix=<prefix>] [-u | -i]] [--exclude-per-directory=<gitignore>] [--index-output=<file>] <sha1> [<sha2> [<sha3>]])";
|
2005-04-21 10:49:16 +08:00
|
|
|
|
2006-06-07 03:51:49 +08:00
|
|
|
static struct lock_file lock_file;
|
2005-06-07 03:20:55 +08:00
|
|
|
|
2006-08-04 04:44:09 +08:00
|
|
|
int cmd_read_tree(int argc, const char **argv, const char *unused_prefix)
|
2005-04-08 06:13:13 +08:00
|
|
|
{
|
2006-05-15 23:09:31 +08:00
|
|
|
int i, newfd, stage = 0;
|
2005-04-08 06:13:13 +08:00
|
|
|
unsigned char sha1[20];
|
2008-03-14 13:07:18 +08:00
|
|
|
struct tree_desc t[MAX_UNPACK_TREES];
|
2006-07-31 02:25:18 +08:00
|
|
|
struct unpack_trees_options opts;
|
2005-04-22 01:55:18 +08:00
|
|
|
|
2006-07-31 02:25:18 +08:00
|
|
|
memset(&opts, 0, sizeof(opts));
|
|
|
|
opts.head_idx = -1;
|
2008-03-07 10:12:28 +08:00
|
|
|
opts.src_index = &the_index;
|
|
|
|
opts.dst_index = &the_index;
|
2006-07-09 02:34:02 +08:00
|
|
|
|
2008-05-15 01:46:53 +08:00
|
|
|
git_config(git_default_config, NULL);
|
2005-11-26 16:50:02 +08:00
|
|
|
|
_GIT_INDEX_OUTPUT: allow plumbing to output to an alternative index file.
When defined, this allows plumbing commands that update the
index (add, apply, checkout-index, merge-recursive, mv,
read-tree, rm, update-index, and write-tree) to write their
resulting index to an alternative index file while holding a
lock to the original index file. With this, git-commit that
jumps the index does not have to make an extra copy of the index
file, and more importantly, it can do the update while holding
the lock on the index.
However, I think the interface to let an environment variable
specify the output is a mistake, as shown in the documentation.
If a curious user has the environment variable set to something
other than the file GIT_INDEX_FILE points at, almost everything
will break. This should instead be a command line parameter to
tell these plumbing commands to write the result in the named
file, to prevent stupid mistakes.
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-04-01 14:09:02 +08:00
|
|
|
newfd = hold_locked_index(&lock_file, 1);
|
2005-04-10 03:11:25 +08:00
|
|
|
|
|
|
|
for (i = 1; i < argc; i++) {
|
|
|
|
const char *arg = argv[i];
|
|
|
|
|
2005-09-11 08:46:27 +08:00
|
|
|
/* "-u" means "update", meaning that a merge will update
|
|
|
|
* the working tree.
|
|
|
|
*/
|
2005-06-06 13:07:31 +08:00
|
|
|
if (!strcmp(arg, "-u")) {
|
2006-07-31 02:25:18 +08:00
|
|
|
opts.update = 1;
|
2005-06-06 13:07:31 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2006-02-23 11:02:39 +08:00
|
|
|
if (!strcmp(arg, "-v")) {
|
2006-07-31 02:25:18 +08:00
|
|
|
opts.verbose_update = 1;
|
2006-02-23 11:02:39 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-09-11 08:46:27 +08:00
|
|
|
/* "-i" means "index only", meaning that a merge will
|
|
|
|
* not even look at the working tree.
|
|
|
|
*/
|
|
|
|
if (!strcmp(arg, "-i")) {
|
2006-07-31 02:25:18 +08:00
|
|
|
opts.index_only = 1;
|
2005-09-11 08:46:27 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2007-04-01 14:27:41 +08:00
|
|
|
if (!prefixcmp(arg, "--index-output=")) {
|
|
|
|
set_alternate_index_output(arg + 15);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2006-01-15 13:46:58 +08:00
|
|
|
/* "--prefix=<subdirectory>/" means keep the current index
|
|
|
|
* entries and put the entries from the tree under the
|
|
|
|
* given subdirectory.
|
|
|
|
*/
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 17:53:29 +08:00
|
|
|
if (!prefixcmp(arg, "--prefix=")) {
|
2006-07-31 02:25:18 +08:00
|
|
|
if (stage || opts.merge || opts.prefix)
|
2006-01-15 13:46:58 +08:00
|
|
|
usage(read_tree_usage);
|
2006-07-31 02:25:18 +08:00
|
|
|
opts.prefix = arg + 9;
|
|
|
|
opts.merge = 1;
|
2006-01-15 13:46:58 +08:00
|
|
|
stage = 1;
|
|
|
|
if (read_cache_unmerged())
|
|
|
|
die("you need to resolve your current index first");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2006-06-03 16:49:31 +08:00
|
|
|
/* This differs from "-m" in that we'll silently ignore
|
|
|
|
* unmerged entries and overwrite working tree files that
|
|
|
|
* correspond to them.
|
|
|
|
*/
|
2005-06-10 03:51:01 +08:00
|
|
|
if (!strcmp(arg, "--reset")) {
|
2006-07-31 02:25:18 +08:00
|
|
|
if (stage || opts.merge || opts.prefix)
|
2005-06-10 03:51:01 +08:00
|
|
|
usage(read_tree_usage);
|
2006-07-31 02:25:18 +08:00
|
|
|
opts.reset = 1;
|
|
|
|
opts.merge = 1;
|
2005-06-10 03:51:01 +08:00
|
|
|
stage = 1;
|
|
|
|
read_cache_unmerged();
|
2005-06-16 01:25:46 +08:00
|
|
|
continue;
|
2005-06-10 03:51:01 +08:00
|
|
|
}
|
|
|
|
|
2005-09-29 23:16:12 +08:00
|
|
|
if (!strcmp(arg, "--trivial")) {
|
2006-07-31 02:25:18 +08:00
|
|
|
opts.trivial_merges_only = 1;
|
2005-09-29 23:16:12 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2006-02-04 14:04:14 +08:00
|
|
|
if (!strcmp(arg, "--aggressive")) {
|
2006-07-31 02:25:18 +08:00
|
|
|
opts.aggressive = 1;
|
2006-02-04 14:04:14 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-04-16 13:53:45 +08:00
|
|
|
/* "-m" stands for "merge", meaning we start in stage 1 */
|
2005-04-10 03:11:25 +08:00
|
|
|
if (!strcmp(arg, "-m")) {
|
2006-07-31 02:25:18 +08:00
|
|
|
if (stage || opts.merge || opts.prefix)
|
2005-06-10 03:51:01 +08:00
|
|
|
usage(read_tree_usage);
|
|
|
|
if (read_cache_unmerged())
|
|
|
|
die("you need to resolve your current index first");
|
2005-04-16 13:53:45 +08:00
|
|
|
stage = 1;
|
2006-07-31 02:25:18 +08:00
|
|
|
opts.merge = 1;
|
2005-04-10 03:11:25 +08:00
|
|
|
continue;
|
|
|
|
}
|
2005-06-11 09:36:08 +08:00
|
|
|
|
Mechanical conversion to use prefixcmp()
This mechanically converts strncmp() to use prefixcmp(), but only when
the parameters match specific patterns, so that they can be verified
easily. Leftover from this will be fixed in a separate step, including
idiotic conversions like
if (!strncmp("foo", arg, 3))
=>
if (!(-prefixcmp(arg, "foo")))
This was done by using this script in px.perl
#!/usr/bin/perl -i.bak -p
if (/strncmp\(([^,]+), "([^\\"]*)", (\d+)\)/ && (length($2) == $3)) {
s|strncmp\(([^,]+), "([^\\"]*)", (\d+)\)|prefixcmp($1, "$2")|;
}
if (/strncmp\("([^\\"]*)", ([^,]+), (\d+)\)/ && (length($1) == $3)) {
s|strncmp\("([^\\"]*)", ([^,]+), (\d+)\)|(-prefixcmp($2, "$1"))|;
}
and running:
$ git grep -l strncmp -- '*.c' | xargs perl px.perl
Signed-off-by: Junio C Hamano <junkio@cox.net>
2007-02-20 17:53:29 +08:00
|
|
|
if (!prefixcmp(arg, "--exclude-per-directory=")) {
|
2006-12-05 08:00:46 +08:00
|
|
|
struct dir_struct *dir;
|
|
|
|
|
|
|
|
if (opts.dir)
|
|
|
|
die("more than one --exclude-per-directory are given.");
|
|
|
|
|
2007-03-28 06:30:19 +08:00
|
|
|
dir = xcalloc(1, sizeof(*opts.dir));
|
2006-12-05 08:00:46 +08:00
|
|
|
dir->show_ignored = 1;
|
|
|
|
dir->exclude_per_dir = arg + 24;
|
|
|
|
opts.dir = dir;
|
|
|
|
/* We do not need to nor want to do read-directory
|
|
|
|
* here; we are merely interested in reusing the
|
|
|
|
* per directory ignore stack mechanism.
|
|
|
|
*/
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-09-11 08:46:27 +08:00
|
|
|
/* using -u and -i at the same time makes no sense */
|
2006-07-31 02:25:18 +08:00
|
|
|
if (1 < opts.index_only + opts.update)
|
2005-09-11 08:46:27 +08:00
|
|
|
usage(read_tree_usage);
|
|
|
|
|
2006-05-09 05:43:38 +08:00
|
|
|
if (get_sha1(arg, sha1))
|
|
|
|
die("Not a valid object name %s", arg);
|
2005-09-05 14:04:48 +08:00
|
|
|
if (list_tree(sha1) < 0)
|
2005-04-13 17:28:48 +08:00
|
|
|
die("failed to unpack tree object %s", arg);
|
2005-04-16 13:53:45 +08:00
|
|
|
stage++;
|
2005-04-10 03:11:25 +08:00
|
|
|
}
|
2006-07-31 02:25:18 +08:00
|
|
|
if ((opts.update||opts.index_only) && !opts.merge)
|
2005-06-08 06:20:39 +08:00
|
|
|
usage(read_tree_usage);
|
2006-12-05 08:00:46 +08:00
|
|
|
if ((opts.dir && !opts.update))
|
|
|
|
die("--exclude-per-directory is meaningless unless -u");
|
2008-08-28 21:03:22 +08:00
|
|
|
if (opts.merge && !opts.index_only)
|
|
|
|
setup_work_tree();
|
2005-10-02 15:50:16 +08:00
|
|
|
|
2006-07-31 02:25:18 +08:00
|
|
|
if (opts.merge) {
|
2005-09-05 14:04:48 +08:00
|
|
|
if (stage < 2)
|
2005-04-20 02:41:18 +08:00
|
|
|
die("just how do you expect me to merge %d trees?", stage-1);
|
2005-09-05 14:04:48 +08:00
|
|
|
switch (stage - 1) {
|
|
|
|
case 1:
|
2006-07-31 02:25:18 +08:00
|
|
|
opts.fn = opts.prefix ? bind_merge : oneway_merge;
|
2005-09-05 14:04:48 +08:00
|
|
|
break;
|
|
|
|
case 2:
|
2006-07-31 02:25:18 +08:00
|
|
|
opts.fn = twoway_merge;
|
checkout: Fix "initial checkout" detection
Earlier commit 5521883 (checkout: do not lose staged removal, 2008-09-07)
tightened the rule to prevent switching branches from losing local
changes, so that staged removal of paths can be protected, while
attempting to keep a loophole to still allow a special case of switching
out of an un-checked-out state.
However, the loophole was made a bit too tight, and did not allow
switching from one branch (in an un-checked-out state) to check out
another branch.
The change to builtin-checkout.c in this commit loosens it to allow this,
by not insisting the original commit and the new commit to be the same.
It also introduces a new function, is_index_unborn (and an associated
macro, is_cache_unborn), to check if the repository is truly in an
un-checked-out state more reliably, by making sure that $GIT_INDEX_FILE
did not exist when populating the in-core index structure. A few places
the earlier commit 5521883 added the check for the initial checkout
condition are updated to use this function.
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2008-11-13 03:52:35 +08:00
|
|
|
opts.initial_checkout = is_cache_unborn();
|
2005-09-05 14:04:48 +08:00
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
default:
|
2006-07-31 02:25:18 +08:00
|
|
|
opts.fn = threeway_merge;
|
2006-04-27 15:13:34 +08:00
|
|
|
cache_tree_free(&active_cache_tree);
|
2005-09-05 14:04:48 +08:00
|
|
|
break;
|
2005-06-11 09:36:08 +08:00
|
|
|
}
|
2005-09-05 14:04:48 +08:00
|
|
|
|
|
|
|
if (stage - 1 >= 3)
|
2006-07-31 02:25:18 +08:00
|
|
|
opts.head_idx = stage - 2;
|
2005-09-05 14:04:48 +08:00
|
|
|
else
|
2006-07-31 02:25:18 +08:00
|
|
|
opts.head_idx = 1;
|
2005-09-05 14:04:48 +08:00
|
|
|
}
|
|
|
|
|
2007-08-10 13:21:29 +08:00
|
|
|
for (i = 0; i < nr_trees; i++) {
|
|
|
|
struct tree *tree = trees[i];
|
|
|
|
parse_tree(tree);
|
|
|
|
init_tree_desc(t+i, tree->buffer, tree->size);
|
|
|
|
}
|
2008-02-08 00:39:48 +08:00
|
|
|
if (unpack_trees(nr_trees, t, &opts))
|
|
|
|
return 128;
|
2006-04-27 16:33:07 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* When reading only one tree (either the most basic form,
|
|
|
|
* "-m ent" or "--reset ent" form), we can obtain a fully
|
|
|
|
* valid cache-tree because the index must match exactly
|
|
|
|
* what came from the tree.
|
|
|
|
*/
|
2007-08-10 13:21:29 +08:00
|
|
|
if (nr_trees && !opts.prefix && (!opts.merge || (stage == 2))) {
|
2006-05-07 23:42:37 +08:00
|
|
|
cache_tree_free(&active_cache_tree);
|
2006-04-27 16:33:07 +08:00
|
|
|
prime_cache_tree();
|
|
|
|
}
|
|
|
|
|
2005-06-07 03:20:55 +08:00
|
|
|
if (write_cache(newfd, active_cache, active_nr) ||
|
2008-01-17 03:12:46 +08:00
|
|
|
commit_locked_index(&lock_file))
|
2005-04-13 17:28:48 +08:00
|
|
|
die("unable to write new index file");
|
2005-04-12 06:39:26 +08:00
|
|
|
return 0;
|
2005-04-08 06:13:13 +08:00
|
|
|
}
|