undef/git-commit-vandalism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'dg/local-mod-error-messages'

Browse Source 
* dg/local-mod-error-messages:
  t7609: test merge and checkout error messages
  unpack_trees: group error messages by type
  merge-recursive: distinguish "removed" and "overwritten" messages
  merge-recursive: porcelain messages for checkout
  Turn unpack_trees_options.msgs into an array + enum

Conflicts:
	t/t3400-rebase.sh
This commit is contained in:
Junio C Hamano 2010-08-21 23:26:46 -07:00
commit 2eb54692d1
13 changed files with 340 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Documentation/technical/api-tree-walking.txt
View File

@ -42,6 +42,8 @@ information.
* `data` can be anything the `fn` callback would want to use.
* `show_all_errors` tells whether to stop at the first error or not.
Initializing
------------

3
builtin/checkout.c
View File

@ -376,7 +376,7 @@ static int merge_working_tree(struct checkout_opts *opts,
topts.src_index = &the_index;
topts.dst_index = &the_index;
topts.msgs.not_uptodate_file = "You have local changes to '%s'; cannot switch branches.";
set_porcelain_error_msgs(topts.msgs, "checkout");
refresh_cache(REFRESH_QUIET);
@ -395,6 +395,7 @@ static int merge_working_tree(struct checkout_opts *opts,
topts.dir = xcalloc(1, sizeof(*topts.dir));
topts.dir->flags |= DIR_SHOW_IGNORED;
topts.dir->exclude_per_dir = ".gitignore";
topts.show_all_errors = 1;
tree = parse_tree_indirect(old->commit ?
old->commit->object.sha1 :
(unsigned char *)EMPTY_TREE_SHA1_BIN);

3
builtin/merge.c
View File

@ -704,7 +704,8 @@ int checkout_fast_forward(const unsigned char *head, const unsigned char *remote
opts.verbose_update = 1;
opts.merge = 1;
opts.fn = twoway_merge;
opts.msgs = get_porcelain_error_msgs();
opts.show_all_errors = 1;
set_porcelain_error_msgs(opts.msgs, "merge");
trees[nr_trees] = parse_tree_indirect(head);
if (!trees[nr_trees++])

62
merge-recursive.c
View File

@ -179,7 +179,7 @@ static int git_merge_trees(int index_only,
opts.fn = threeway_merge;
opts.src_index = &the_index;
opts.dst_index = &the_index;
opts.msgs = get_porcelain_error_msgs();
set_porcelain_error_msgs(opts.msgs, "merge");
init_tree_desc_from_tree(t+0, common);
init_tree_desc_from_tree(t+1, head);
@ -1173,26 +1173,48 @@ static int process_entry(struct merge_options *o,
return clean_merge;
}
struct unpack_trees_error_msgs get_porcelain_error_msgs(void)
void set_porcelain_error_msgs(const char **msgs, const char *cmd)
{
struct unpack_trees_error_msgs msgs = {
/* would_overwrite */
"Your local changes to '%s' would be overwritten by merge. Aborting.",
/* not_uptodate_file */
"Your local changes to '%s' would be overwritten by merge. Aborting.",
/* not_uptodate_dir */
"Updating '%s' would lose untracked files in it. Aborting.",
/* would_lose_untracked */
"Untracked working tree file '%s' would be %s by merge. Aborting",
/* bind_overlap -- will not happen here */
NULL,
};
if (advice_commit_before_merge) {
msgs.would_overwrite = msgs.not_uptodate_file =
"Your local changes to '%s' would be overwritten by merge. Aborting.\n"
"Please, commit your changes or stash them before you can merge.";
}
return msgs;
const char *msg;
char *tmp;
const char *cmd2 = strcmp(cmd, "checkout") ? cmd : "switch branches";
if (advice_commit_before_merge)
msg = "Your local changes to the following files would be overwritten by %s:\n%%s"
"Please, commit your changes or stash them before you can %s.";
else
msg = "Your local changes to the following files would be overwritten by %s:\n%%s";
tmp = xmalloc(strlen(msg) + strlen(cmd) + strlen(cmd2) - 2);
sprintf(tmp, msg, cmd, cmd2);
msgs[ERROR_WOULD_OVERWRITE] = tmp;
msgs[ERROR_NOT_UPTODATE_FILE] = tmp;
msgs[ERROR_NOT_UPTODATE_DIR] =
"Updating the following directories would lose untracked files in it:\n%s";
if (advice_commit_before_merge)
msg = "The following untracked working tree files would be %s by %s:\n%%s"
"Please move or remove them before you can %s.";
else
msg = "The following untracked working tree files would be %s by %s:\n%%s";
tmp = xmalloc(strlen(msg) + strlen(cmd) + strlen("removed") + strlen(cmd2) - 4);
sprintf(tmp, msg, "removed", cmd, cmd2);
msgs[ERROR_WOULD_LOSE_UNTRACKED_REMOVED] = tmp;
tmp = xmalloc(strlen(msg) + strlen(cmd) + strlen("overwritten") + strlen(cmd2) - 4);
sprintf(tmp, msg, "overwritten", cmd, cmd2);
msgs[ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN] = tmp;
/*
* Special case: ERROR_BIND_OVERLAP refers to a pair of paths, we
* cannot easily display it as a list.
*/
msgs[ERROR_BIND_OVERLAP] = "Entry '%s' overlaps with '%s'. Cannot bind.";
msgs[ERROR_SPARSE_NOT_UPTODATE_FILE] =
"Cannot update sparse checkout: the following entries are not up-to-date:\n%s";
msgs[ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN] =
"The following Working tree files would be overwritten by sparse checkout update:\n%s";
msgs[ERROR_WOULD_LOSE_ORPHANED_REMOVED] =
"The following Working tree files would be removed by sparse checkout update:\n%s";
}
int merge_trees(struct merge_options *o,

7
merge-recursive.h
View File

@ -23,8 +23,11 @@ struct merge_options {
struct string_list current_directory_set;
};
/* Return a list of user-friendly error messages to be used by merge */
struct unpack_trees_error_msgs get_porcelain_error_msgs(void);
/*
* Sets the list of user-friendly error messages to be used by the
* command "cmd" (either merge or checkout)
*/
void set_porcelain_error_msgs(const char **msgs, const char *cmd);
/* merge_trees() but with recursive ancestor consolidation */
int merge_recursive(struct merge_options *o,

2
t/t3030-merge-recursive.sh
View File

@ -294,7 +294,7 @@ test_expect_success 'fail if the index has unresolved entries' '
grep "You have not concluded your merge" out &&
rm -f .git/MERGE_HEAD &&
test_must_fail git merge "$c5" 2> out &&
grep "Your local changes to .* would be overwritten by merge." out
grep "Your local changes to the following files would be overwritten by merge:" out
'
test_expect_success 'merge-recursive remove conflict' '

3
t/t3400-rebase.sh
View File

@ -153,7 +153,8 @@ test_expect_success 'setup: recover' '
test_expect_success 'Show verbose error when HEAD could not be detached' '
>B &&
test_must_fail git rebase topic 2>output.err >output.out &&
grep "Untracked working tree file .B. would be overwritten" output.err
grep "The following untracked working tree files would be overwritten by checkout:" output.err &&
grep B output.err
'
rm -f B

3
t/t3404-rebase-interactive.sh
View File

@ -150,8 +150,9 @@ test_expect_success 'abort with error when new base cannot be checked out' '
git rm --cached file1 &&
git commit -m "remove file in base" &&
test_must_fail git rebase -i master > output 2>&1 &&
grep "Untracked working tree file .file1. would be overwritten" \
grep "The following untracked working tree files would be overwritten by checkout:" \
output &&
grep "file1" output &&
! test -d .git/rebase-merge &&
git reset --hard HEAD^
'

125
t/t7609-merge-co-error-msgs.sh Executable file
View File

@ -0,0 +1,125 @@
#!/bin/sh
test_description='unpack-trees error messages'
. ./test-lib.sh
test_expect_success 'setup' '
echo one >one &&
git add one &&
git commit -a -m First &&
git checkout -b branch &&
echo two >two &&
echo three >three &&
echo four >four &&
echo five >five &&
git add two three four five &&
git commit -m Second &&
git checkout master &&
echo other >two &&
echo other >three &&
echo other >four &&
echo other >five
'
cat >expect <<\EOF
error: The following untracked working tree files would be overwritten by merge:
two
three
four
five
Please move or remove them before you can merge.
EOF
test_expect_success 'untracked files overwritten by merge' '
test_must_fail git merge branch 2>out &&
test_cmp out expect
'
cat >expect <<\EOF
error: Your local changes to the following files would be overwritten by merge:
two
three
four
Please, commit your changes or stash them before you can merge.
error: The following untracked working tree files would be overwritten by merge:
five
Please move or remove them before you can merge.
EOF
test_expect_success 'untracked files or local changes ovewritten by merge' '
git add two &&
git add three &&
git add four &&
test_must_fail git merge branch 2>out &&
test_cmp out expect
'
cat >expect <<\EOF
error: Your local changes to the following files would be overwritten by checkout:
rep/two
rep/one
Please, commit your changes or stash them before you can switch branches.
EOF
test_expect_success 'cannot switch branches because of local changes' '
git add five &&
mkdir rep &&
echo one >rep/one &&
echo two >rep/two &&
git add rep/one rep/two &&
git commit -m Fourth &&
git checkout master &&
echo uno >rep/one &&
echo dos >rep/two &&
test_must_fail git checkout branch 2>out &&
test_cmp out expect
'
cat >expect <<\EOF
error: Your local changes to the following files would be overwritten by checkout:
rep/two
rep/one
Please, commit your changes or stash them before you can switch branches.
EOF
test_expect_success 'not uptodate file porcelain checkout error' '
git add rep/one rep/two &&
test_must_fail git checkout branch 2>out &&
test_cmp out expect
'
cat >expect <<\EOF
error: Updating the following directories would lose untracked files in it:
rep2
rep
EOF
test_expect_success 'not_uptodate_dir porcelain checkout error' '
git init uptodate &&
cd uptodate &&
mkdir rep &&
mkdir rep2 &&
touch rep/foo &&
touch rep2/foo &&
git add rep/foo rep2/foo &&
git commit -m init &&
git checkout -b branch &&
git rm rep -r &&
git rm rep2 -r &&
>rep &&
>rep2 &&
git add rep rep2&&
git commit -m "added test as a file" &&
git checkout master &&
>rep/untracked-file &&
>rep2/untracked-file &&
test_must_fail git checkout branch 2>out &&
test_cmp out ../expect
'
test_done

11
tree-walk.c
View File

@ -1,5 +1,6 @@
#include "cache.h"
#include "tree-walk.h"
#include "unpack-trees.h"
#include "tree.h"
static const char *get_mode(const char *str, unsigned int *modep)
@ -310,6 +311,7 @@ static void free_extended_entry(struct tree_desc_x *t)
int traverse_trees(int n, struct tree_desc *t, struct traverse_info *info)
{
int ret = 0;
int error = 0;
struct name_entry *entry = xmalloc(n*sizeof(*entry));
int i;
struct tree_desc_x *tx = xcalloc(n, sizeof(*tx));
@ -377,8 +379,11 @@ int traverse_trees(int n, struct tree_desc *t, struct traverse_info *info)
if (!mask)
break;
ret = info->fn(n, mask, dirmask, entry, info);
if (ret < 0)
break;
if (ret < 0) {
error = ret;
if (!info->show_all_errors)
break;
}
mask &= ret;
ret = 0;
for (i = 0; i < n; i++)
@ -389,7 +394,7 @@ int traverse_trees(int n, struct tree_desc *t, struct traverse_info *info)
for (i = 0; i < n; i++)
free_extended_entry(tx + i);
free(tx);
return ret;
return error;
}
static int find_tree_entry(struct tree_desc *t, const char *name, unsigned char *result, unsigned *mode)

1
tree-walk.h
View File

@ -45,6 +45,7 @@ struct traverse_info {
unsigned long conflicts;
traverse_callback_t fn;
void *data;
int show_all_errors;
};
int get_tree_entry(const unsigned char *, const char *, unsigned char *, unsigned *);

165
unpack-trees.c
View File

@ -13,37 +13,42 @@
* Error messages expected by scripts out of plumbing commands such as
* read-tree. Non-scripted Porcelain is not required to use these messages
* and in fact are encouraged to reword them to better suit their particular
* situation better. See how "git checkout" replaces not_uptodate_file to
* explain why it does not allow switching between branches when you have
* local changes, for example.
* situation better. See how "git checkout" and "git merge" replaces
* them using set_porcelain_error_msgs(), for example.
*/
static struct unpack_trees_error_msgs unpack_plumbing_errors = {
/* would_overwrite */
const char *unpack_plumbing_errors[NB_UNPACK_TREES_ERROR_TYPES] = {
/* ERROR_WOULD_OVERWRITE */
"Entry '%s' would be overwritten by merge. Cannot merge.",
/* not_uptodate_file */
/* ERROR_NOT_UPTODATE_FILE */
"Entry '%s' not uptodate. Cannot merge.",
/* not_uptodate_dir */
/* ERROR_NOT_UPTODATE_DIR */
"Updating '%s' would lose untracked files in it",
/* would_lose_untracked */
"Untracked working tree file '%s' would be %s by merge.",
/* ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN */
"Untracked working tree file '%s' would be overwritten by merge.",
/* bind_overlap */
/* ERROR_WOULD_LOSE_UNTRACKED_REMOVED */
"Untracked working tree file '%s' would be removed by merge.",
/* ERROR_BIND_OVERLAP */
"Entry '%s' overlaps with '%s'. Cannot bind.",
/* sparse_not_uptodate_file */
/* ERROR_SPARSE_NOT_UPTODATE_FILE */
"Entry '%s' not uptodate. Cannot update sparse checkout.",
/* would_lose_orphaned */
"Working tree file '%s' would be %s by sparse checkout update.",
/* ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN */
"Working tree file '%s' would be overwritten by sparse checkout update.",
/* ERROR_WOULD_LOSE_ORPHANED_REMOVED */
"Working tree file '%s' would be removed by sparse checkout update.",
};
#define ERRORMSG(o,fld) \
( ((o) && (o)->msgs.fld) \
? ((o)->msgs.fld) \
: (unpack_plumbing_errors.fld) )
#define ERRORMSG(o,type) \
( ((o) && (o)->msgs[(type)]) \
? ((o)->msgs[(type)]) \
: (unpack_plumbing_errors[(type)]) )
static void add_entry(struct unpack_trees_options *o, struct cache_entry *ce,
unsigned int set, unsigned int clear)
@ -59,6 +64,73 @@ static void add_entry(struct unpack_trees_options *o, struct cache_entry *ce,
add_index_entry(&o->result, new, ADD_CACHE_OK_TO_ADD|ADD_CACHE_OK_TO_REPLACE);
}
/*
* add error messages on path <path>
* corresponding to the type <e> with the message <msg>
* indicating if it should be display in porcelain or not
*/
static int add_rejected_path(struct unpack_trees_options *o,
enum unpack_trees_error_types e,
const char *path)
{
struct rejected_paths_list *newentry;
int porcelain = o && (o)->msgs[e];
/*
* simply display the given error message if in plumbing mode
*/
if (!porcelain)
o->show_all_errors = 0;
if (!o->show_all_errors)
return error(ERRORMSG(o, e), path);
/*
* Otherwise, insert in a list for future display by
* display_error_msgs()
*/
newentry = xmalloc(sizeof(struct rejected_paths_list));
newentry->path = (char *)path;
newentry->next = o->unpack_rejects[e];
o->unpack_rejects[e] = newentry;
return -1;
}
/*
* free all the structures allocated for the error <e>
*/
static void free_rejected_paths(struct unpack_trees_options *o,
enum unpack_trees_error_types e)
{
while (o->unpack_rejects[e]) {
struct rejected_paths_list *del = o->unpack_rejects[e];
o->unpack_rejects[e] = o->unpack_rejects[e]->next;
free(del);
}
free(o->unpack_rejects[e]);
}
/*
* display all the error messages stored in a nice way
*/
static void display_error_msgs(struct unpack_trees_options *o)
{
int e;
int something_displayed = 0;
for (e = 0; e < NB_UNPACK_TREES_ERROR_TYPES; e++) {
if (o->unpack_rejects[e]) {
struct rejected_paths_list *rp;
struct strbuf path = STRBUF_INIT;
something_displayed = 1;
for (rp = o->unpack_rejects[e]; rp; rp = rp->next)
strbuf_addf(&path, "\t%s\n", rp->path);
error(ERRORMSG(o, e), path.buf);
strbuf_release(&path);
free_rejected_paths(o, e);
}
}
if (something_displayed)
printf("Aborting\n");
}
/*
* Unlink the last component and schedule the leading directories for
* removal, such that empty directories get removed.
@ -132,7 +204,7 @@ static int check_updates(struct unpack_trees_options *o)
}
static int verify_uptodate_sparse(struct cache_entry *ce, struct unpack_trees_options *o);
static int verify_absent_sparse(struct cache_entry *ce, const char *action, struct unpack_trees_options *o);
static int verify_absent_sparse(struct cache_entry *ce, enum unpack_trees_error_types, struct unpack_trees_options *o);
static int will_have_skip_worktree(const struct cache_entry *ce, struct unpack_trees_options *o)
{
@ -175,7 +247,7 @@ static int apply_sparse_checkout(struct cache_entry *ce, struct unpack_trees_opt
ce->ce_flags |= CE_WT_REMOVE;
}
if (was_skip_worktree && !ce_skip_worktree(ce)) {
if (verify_absent_sparse(ce, "overwritten", o))
if (verify_absent_sparse(ce, ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o))
return -1;
ce->ce_flags |= CE_UPDATE;
}
@ -755,6 +827,7 @@ int unpack_trees(unsigned len, struct tree_desc *t, struct unpack_trees_options
setup_traverse_info(&info, prefix);
info.fn = unpack_callback;
info.data = o;
info.show_all_errors = o->show_all_errors;
if (o->prefix) {
/*
@ -834,6 +907,8 @@ done:
return ret;
return_failed:
if (o->show_all_errors)
display_error_msgs(o);
mark_all_ce_unused(o->src_index);
ret = unpack_failed(o, NULL);
goto done;
@ -843,7 +918,7 @@ return_failed:
static int reject_merge(struct cache_entry *ce, struct unpack_trees_options *o)
{
return error(ERRORMSG(o, would_overwrite), ce->name);
return add_rejected_path(o, ERROR_WOULD_OVERWRITE, ce->name);
}
static int same(struct cache_entry *a, struct cache_entry *b)
@ -865,7 +940,7 @@ static int same(struct cache_entry *a, struct cache_entry *b)
*/
static int verify_uptodate_1(struct cache_entry *ce,
struct unpack_trees_options *o,
const char *error_msg)
enum unpack_trees_error_types error_type)
{
struct stat st;
@ -890,7 +965,7 @@ static int verify_uptodate_1(struct cache_entry *ce,
if (errno == ENOENT)
return 0;
return o->gently ? -1 :
error(error_msg, ce->name);
add_rejected_path(o, error_type, ce->name);
}
static int verify_uptodate(struct cache_entry *ce,
@ -898,13 +973,13 @@ static int verify_uptodate(struct cache_entry *ce,
{
if (!o->skip_sparse_checkout && will_have_skip_worktree(ce, o))
return 0;
return verify_uptodate_1(ce, o, ERRORMSG(o, not_uptodate_file));
return verify_uptodate_1(ce, o, ERROR_NOT_UPTODATE_FILE);
}
static int verify_uptodate_sparse(struct cache_entry *ce,
struct unpack_trees_options *o)
{
return verify_uptodate_1(ce, o, ERRORMSG(o, sparse_not_uptodate_file));
return verify_uptodate_1(ce, o, ERROR_SPARSE_NOT_UPTODATE_FILE);
}
static void invalidate_ce_path(struct cache_entry *ce, struct unpack_trees_options *o)
@ -920,13 +995,15 @@ static void invalidate_ce_path(struct cache_entry *ce, struct unpack_trees_optio
* Currently, git does not checkout subprojects during a superproject
* checkout, so it is not going to overwrite anything.
*/
static int verify_clean_submodule(struct cache_entry *ce, const char *action,
static int verify_clean_submodule(struct cache_entry *ce,
enum unpack_trees_error_types error_type,
struct unpack_trees_options *o)
{
return 0;
}
static int verify_clean_subdirectory(struct cache_entry *ce, const char *action,
static int verify_clean_subdirectory(struct cache_entry *ce,
enum unpack_trees_error_types error_type,
struct unpack_trees_options *o)
{
/*
@ -947,7 +1024,7 @@ static int verify_clean_subdirectory(struct cache_entry *ce, const char *action,
*/
if (!hashcmp(sha1, ce->sha1))
return 0;
return verify_clean_submodule(ce, action, o);
return verify_clean_submodule(ce, error_type, o);
}
/*
@ -991,7 +1068,7 @@ static int verify_clean_subdirectory(struct cache_entry *ce, const char *action,
i = read_directory(&d, pathbuf, namelen+1, NULL);
if (i)
return o->gently ? -1 :
error(ERRORMSG(o, not_uptodate_dir), ce->name);
add_rejected_path(o, ERROR_NOT_UPTODATE_DIR, ce->name);
free(pathbuf);
return cnt;
}
@ -1016,9 +1093,9 @@ static int icase_exists(struct unpack_trees_options *o, struct cache_entry *dst,
* We do not want to remove or overwrite a working tree file that
* is not tracked, unless it is ignored.
*/
static int verify_absent_1(struct cache_entry *ce, const char *action,
struct unpack_trees_options *o,
const char *error_msg)
static int verify_absent_1(struct cache_entry *ce,
enum unpack_trees_error_types error_type,
struct unpack_trees_options *o)
{
struct stat st;
@ -1056,7 +1133,7 @@ static int verify_absent_1(struct cache_entry *ce, const char *action,
* files that are in "foo/" we would lose
* them.
*/
if (verify_clean_subdirectory(ce, action, o) < 0)
if (verify_clean_subdirectory(ce, error_type, o) < 0)
return -1;
return 0;
}
@ -1073,22 +1150,28 @@ static int verify_absent_1(struct cache_entry *ce, const char *action,
}
return o->gently ? -1 :
error(ERRORMSG(o, would_lose_untracked), ce->name, action);
add_rejected_path(o, error_type, ce->name);
}
return 0;
}
static int verify_absent(struct cache_entry *ce, const char *action,
static int verify_absent(struct cache_entry *ce,
enum unpack_trees_error_types error_type,
struct unpack_trees_options *o)
{
if (!o->skip_sparse_checkout && will_have_skip_worktree(ce, o))
return 0;
return verify_absent_1(ce, action, o, ERRORMSG(o, would_lose_untracked));
return verify_absent_1(ce, error_type, o);
}
static int verify_absent_sparse(struct cache_entry *ce, const char *action,
static int verify_absent_sparse(struct cache_entry *ce,
enum unpack_trees_error_types error_type,
struct unpack_trees_options *o)
{
return verify_absent_1(ce, action, o, ERRORMSG(o, would_lose_orphaned));
enum unpack_trees_error_types orphaned_error = error_type;
if (orphaned_error == ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN)
orphaned_error = ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN;
return verify_absent_1(ce, orphaned_error, o);
}
static int merged_entry(struct cache_entry *merge, struct cache_entry *old,
@ -1097,7 +1180,7 @@ static int merged_entry(struct cache_entry *merge, struct cache_entry *old,
int update = CE_UPDATE;
if (!old) {
if (verify_absent(merge, "overwritten", o))
if (verify_absent(merge, ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN, o))
return -1;
invalidate_ce_path(merge, o);
} else if (!(old->ce_flags & CE_CONFLICTED)) {
@ -1135,7 +1218,7 @@ static int deleted_entry(struct cache_entry *ce, struct cache_entry *old,
{
/* Did it exist in the index? */
if (!old) {
if (verify_absent(ce, "removed", o))
if (verify_absent(ce, ERROR_WOULD_LOSE_UNTRACKED_REMOVED, o))
return -1;
return 0;
}
@ -1284,7 +1367,7 @@ int threeway_merge(struct cache_entry **stages, struct unpack_trees_options *o)
if (index)
return deleted_entry(index, index, o);
if (ce && !head_deleted) {
if (verify_absent(ce, "removed", o))
if (verify_absent(ce, ERROR_WOULD_LOSE_UNTRACKED_REMOVED, o))
return -1;
}
return 0;
@ -1417,7 +1500,7 @@ int bind_merge(struct cache_entry **src,
o->merge_size);
if (a && old)
return o->gently ? -1 :
error(ERRORMSG(o, bind_overlap), a->name, old->name);
error(ERRORMSG(o, ERROR_BIND_OVERLAP), a->name, old->name);
if (!a)
return keep_entry(old, o);
else

34
unpack-trees.h
View File

@ -9,14 +9,22 @@ struct exclude_list;
typedef int (*merge_fn_t)(struct cache_entry **src,
struct unpack_trees_options *options);
struct unpack_trees_error_msgs {
const char *would_overwrite;
const char *not_uptodate_file;
const char *not_uptodate_dir;
const char *would_lose_untracked;
const char *bind_overlap;
const char *sparse_not_uptodate_file;
const char *would_lose_orphaned;
enum unpack_trees_error_types {
ERROR_WOULD_OVERWRITE = 0,
ERROR_NOT_UPTODATE_FILE,
ERROR_NOT_UPTODATE_DIR,
ERROR_WOULD_LOSE_UNTRACKED_OVERWRITTEN,
ERROR_WOULD_LOSE_UNTRACKED_REMOVED,
ERROR_BIND_OVERLAP,
ERROR_SPARSE_NOT_UPTODATE_FILE,
ERROR_WOULD_LOSE_ORPHANED_OVERWRITTEN,
ERROR_WOULD_LOSE_ORPHANED_REMOVED,
NB_UNPACK_TREES_ERROR_TYPES
};
struct rejected_paths_list {
char *path;
struct rejected_paths_list *next;
};
struct unpack_trees_options {
@ -33,12 +41,18 @@ struct unpack_trees_options {
diff_index_cached,
debug_unpack,
skip_sparse_checkout,
gently;
gently,
show_all_errors;
const char *prefix;
int cache_bottom;
struct dir_struct *dir;
merge_fn_t fn;
struct unpack_trees_error_msgs msgs;
const char *msgs[NB_UNPACK_TREES_ERROR_TYPES];
/*
* Store error messages in an array, each case
* corresponding to a error message type
*/
struct rejected_paths_list *unpack_rejects[NB_UNPACK_TREES_ERROR_TYPES];
int head_idx;
int merge_size;