if (memcmp(bufptr, "tree ", 5))
return error("bogus commit object %s", sha1_to_hex(item->object.sha1));
if (get_sha1_hex(bufptr + 5, parent) < 0)
- -- return error("bad tree pointer in commit %s\n", sha1_to_hex(item->object.sha1));
+ ++ return error("bad tree pointer in commit %s",
+ ++ sha1_to_hex(item->object.sha1));
item->tree = lookup_tree(parent);
if (item->tree)
n_refs++;
/*
* Performs an in-place topological sort on the list supplied.
*/
---void sort_in_topological_order(struct commit_list ** list)
+++void sort_in_topological_order(struct commit_list ** list, int lifo)
{
struct commit_list * next = *list;
struct commit_list * work = NULL, **insert;
}
next=next->next;
}
+++
/* process the list in topological order */
+++ if (!lifo)
+++ sort_by_date(&work);
while (work) {
struct commit * work_item = pop_commit(&work);
struct sort_node * work_node = (struct sort_node *)work_item->object.util;
* guaranteeing topological order.
*/
pn->indegree--;
--- if (!pn->indegree)
--- commit_list_insert(parent, &work);
+++ if (!pn->indegree) {
+++ if (!lifo)
+++ insert_by_date(parent, &work);
+++ else
+++ commit_list_insert(parent, &work);
+++ }
}
parents=parents->next;
}
fi &&
rm -f "$GIT_DIR/objects/sample" &&
cd "$repo" &&
--- find objects -depth -print | cpio -puamd$l "$GIT_DIR/" || exit 1
+++ find objects -depth -print | cpio -pumd$l "$GIT_DIR/" || exit 1
;;
yes)
mkdir -p "$GIT_DIR/objects/info"
case "$no_checkout" in
'')
-- - git checkout
++ + git-read-tree -m -u -v HEAD HEAD
esac
fi
all_strategies='recursive octopus resolve stupid ours'
default_strategies='recursive'
use_strategies=
+++if test "@@NO_PYTHON@@"; then
+++ all_strategies='resolve octopus stupid ours'
+++ default_strategies='resolve'
+++fi
dropsave() {
rm -f -- "$GIT_DIR/MERGE_HEAD" "$GIT_DIR/MERGE_MSG" \
echo "Updating from $head to $1."
git-update-index --refresh 2>/dev/null
new_head=$(git-rev-parse --verify "$1^0") &&
-- - git-read-tree -u -m $head "$new_head" &&
++ + git-read-tree -u -v -m $head "$new_head" &&
finish "$new_head" "Fast forward"
dropsave
exit 0
echo "Trying really trivial in-index merge..."
git-update-index --refresh 2>/dev/null
-- - if git-read-tree --trivial -m -u $common $head "$1" &&
++ + if git-read-tree --trivial -m -u -v $common $head "$1" &&
result_tree=$(git-write-tree)
then
echo "Wonderful."
#include "object.h"
#include "tree.h"
++ +#include <sys/time.h>
++ +#include <signal.h>
static int merge = 0;
static int update = 0;
static int nontrivial_merge = 0;
static int trivial_merges_only = 0;
static int aggressive = 0;
++ +static int verbose_update = 0;
++ +static volatile int progress_update = 0;
static int head_idx = -1;
static int merge_size = 0;
}
}
++ +static void progress_interval(int signum)
++ +{
++ + signal(SIGALRM, progress_interval);
++ + progress_update = 1;
++ +}
++ +
static void check_updates(struct cache_entry **src, int nr)
{
static struct checkout state = {
.refresh_cache = 1,
};
unsigned short mask = htons(CE_UPDATE);
++ + unsigned last_percent = 200, cnt = 0, total = 0;
++ +
++ + if (update && verbose_update) {
++ + struct itimerval v;
++ +
++ + for (total = cnt = 0; cnt < nr; cnt++) {
++ + struct cache_entry *ce = src[cnt];
++ + if (!ce->ce_mode || ce->ce_flags & mask)
++ + total++;
++ + }
++ +
++ + /* Don't bother doing this for very small updates */
++ + if (total < 250)
++ + total = 0;
++ +
++ + if (total) {
++ + v.it_interval.tv_sec = 1;
++ + v.it_interval.tv_usec = 0;
++ + v.it_value = v.it_interval;
++ + signal(SIGALRM, progress_interval);
++ + setitimer(ITIMER_REAL, &v, NULL);
++ + fprintf(stderr, "Checking files out...\n");
++ + progress_update = 1;
++ + }
++ + cnt = 0;
++ + }
++ +
while (nr--) {
struct cache_entry *ce = *src++;
++ +
++ + if (total) {
++ + if (!ce->ce_mode || ce->ce_flags & mask) {
++ + unsigned percent;
++ + cnt++;
++ + percent = (cnt * 100) / total;
++ + if (percent != last_percent ||
++ + progress_update) {
++ + fprintf(stderr, "%4u%% (%u/%u) done\r",
++ + percent, cnt, total);
++ + last_percent = percent;
++ + }
++ + }
++ + }
if (!ce->ce_mode) {
if (update)
unlink_entry(ce->name);
checkout_entry(ce, &state);
}
}
++ + if (total) {
++ + fputc('\n', stderr);
++ + signal(SIGALRM, SIG_IGN);
++ + }
}
static int unpack_trees(merge_fn_t fn)
return;
if (!lstat(ce->name, &st)) {
--- unsigned changed = ce_match_stat(ce, &st);
+++ unsigned changed = ce_match_stat(ce, &st, 1);
if (!changed)
return;
errno = 0;
struct cache_entry *oldtree = src[1], *newtree = src[2];
if (merge_size != 2)
- -- return error("Cannot do a twoway merge of %d trees\n",
+ ++ return error("Cannot do a twoway merge of %d trees",
merge_size);
if (current) {
struct cache_entry *a = src[1];
if (merge_size != 1)
- -- return error("Cannot do a oneway merge of %d trees\n",
+ ++ return error("Cannot do a oneway merge of %d trees",
merge_size);
if (!a)
continue;
}
++ + if (!strcmp(arg, "-v")) {
++ + verbose_update = 1;
++ + continue;
++ + }
++ +
/* "-i" means "index only", meaning that a merge will
* not even look at the working tree.
*/
dir = opendir(path);
if (!dir) {
if (errno != ENOENT)
- -- error("unable to open object pack directory: %s: %s\n",
+ ++ error("unable to open object pack directory: %s: %s",
path, strerror(errno));
return;
}
char *type,
unsigned long *size,
unsigned long *store_size,
--- int *delta_chain_length,
+++ unsigned int *delta_chain_length,
unsigned char *base_sha1)
{
struct packed_git *p = e->p;
if (kind != OBJ_DELTA)
*delta_chain_length = 0;
else {
--- int chain_length = 0;
+++ unsigned int chain_length = 0;
memcpy(base_sha1, pack, 20);
do {
struct pack_entry base_ent;
local = mkstemp(tmpfile);
if (local < 0)
- -- return error("Couldn't open %s for %s\n", tmpfile, sha1_to_hex(sha1));
+ ++ return error("Couldn't open %s for %s",
+ ++ tmpfile, sha1_to_hex(sha1));
memset(&stream, 0, sizeof(stream));
}
if (memcmp(sha1, real_sha1, 20)) {
unlink(tmpfile);
- -- return error("File %s has bad hash\n", sha1_to_hex(sha1));
+ ++ return error("File %s has bad hash", sha1_to_hex(sha1));
}
return move_temp_to_file(tmpfile, sha1_file_name(sha1));