author | Junio C Hamano <junkio@cox.net> | |
Thu, 5 May 2005 23:16:54 +0000 (16:16 -0700) | ||
committer | Junio C Hamano <junkio@cox.net> | |
Thu, 5 May 2005 23:16:54 +0000 (16:16 -0700) |
Update git-apply-patch-script for symbolic links.
Make git-prune-script executable again.
Do not write out new index if nothing has changed.
diff-cache shows differences for unmerged paths without --cache.
Update diff engine for symlinks stored in the cache.
Signed-off-by: Junio C Hamano <junkio@cox.net>
Make git-prune-script executable again.
Do not write out new index if nothing has changed.
diff-cache shows differences for unmerged paths without --cache.
Update diff engine for symlinks stored in the cache.
Signed-off-by: Junio C Hamano <junkio@cox.net>
diff-cache.c | patch | blob | history | |
git-apply-patch-script | patch | blob | history | |
git-prune-script | [changed mode: 0644->0755] | patch | blob | history |
update-cache.c | patch | blob | history |
diff --git a/diff-cache.c b/diff-cache.c
index ef522cd23387aa0f4264f08e346ffdd1616c4f59..7e87d28f3a358710b9f11a4b76e4235926f438ee 100644 (file)
--- a/diff-cache.c
+++ b/diff-cache.c
show_file("+", new, sha1, mode);
}
-static int show_modified(struct cache_entry *old, struct cache_entry *new)
+static int show_modified(struct cache_entry *old,
+ struct cache_entry *new,
+ int report_missing)
{
unsigned int mode, oldmode;
unsigned char *sha1;
unsigned char old_sha1_hex[60];
if (get_stat_data(new, &sha1, &mode) < 0) {
- show_file("-", old, old->sha1, old->ce_mode);
+ if (report_missing)
+ show_file("-", old, old->sha1, old->ce_mode);
return -1;
}
break;
}
/* Show difference between old and new */
- show_modified(ac[1], ce);
+ show_modified(ac[1], ce, 1);
break;
case 1:
/* No stage 3 (merge) entry? That means it's been deleted */
show_file("-", ce, ce->sha1, ce->ce_mode);
break;
}
- /* Otherwise we fall through to the "unmerged" case */
+ /* We come here with ce pointing at stage 1
+ * (original tree) and ac[1] pointing at stage
+ * 3 (unmerged). show-modified with
+ * report-mising set to false does not say the
+ * file is deleted but reports true if work
+ * tree does not have it, in which case we
+ * fall through to report the unmerged state.
+ * Otherwise, we show the differences between
+ * the original tree and the work tree.
+ */
+ if (!cached_only && !show_modified(ce, ac[1], 0))
+ break;
+ /* fallthru */
case 3:
if (generate_patch)
diff_unmerge(ce->name);
diff --git a/git-apply-patch-script b/git-apply-patch-script
index dccad27061ca753a871891afed615c4d4a10c765..13ec1c4490612f524f9b1070a57229cdc2c50aed 100755 (executable)
--- a/git-apply-patch-script
+++ b/git-apply-patch-script
#
case "$#" in
-2) exit 1 ;; # do not feed unmerged diff to me!
+2)
+ echo >&2 "cannot handle unmerged diff on path $1."
+ exit 1 ;;
esac
name="$1" tmp1="$2" hex1="$3" mode1="$4" tmp2="$5" hex2="$6" mode2="$7"
-case "$mode1" in *7??) mode1=+x ;; *6??) mode1=-x ;; esac
-case "$mode2" in *7??) mode2=+x ;; *6??) mode2=-x ;; esac
-if test -f "$name.orig" || test -f "$name.rej"
-then
- echo >&2 "Unresolved patch conflicts in the previous run found."
- exit 1
-fi
+type1=f
+case "$mode1" in
+*120???) type1=l ;;
+*1007??) mode1=+x ;;
+*1006??) mode1=-x ;;
+.) type1=- ;;
+esac
+
+type2=f
+case "$mode2" in
+*120???) type2=l ;;
+*1007??) mode2=+x ;;
+*1006??) mode2=-x ;;
+.) type2=- ;;
+esac
+
+case "$type1,$type2" in
-case "$mode1,$mode2" in
-.,?x)
- # newly created
+-,?)
dir=$(dirname "$name")
- case "$dir" in '' | .) ;; *) mkdir -p "$dir" esac || {
+ case "$dir" in '' | .) ;; *) mkdir -p "$dir" ;; esac || {
echo >&2 "cannot create leading path for $name."
exit 1
}
- if test -f "$name"
+ if test -e "$name"
then
- echo >&2 "file $name to be created already exists."
+ echo >&2 "path $name to be created already exists."
exit 1
fi
- cat "$tmp2" >"$name" || {
- echo >&2 "cannot create $name."
- exit 1
- }
- case "$mode2" in
- +x)
- echo >&2 "created $name with mode +x."
- chmod "$mode2" "$name"
- ;;
- -x)
- echo >&2 "created $name."
+ case "$type2" in
+ f)
+ # creating a regular file
+ cat "$tmp2" >"$name" || {
+ echo >&2 "cannot create a regular file $name."
+ exit 1
+ }
+ case "$mode2" in
+ +x)
+ echo >&2 "created a regular file $name with mode +x."
+ chmod "$mode2" "$name"
+ ;;
+ -x)
+ echo >&2 "created a regular file $name."
+ ;;
+ esac
;;
+ l)
+ # creating a symlink
+ ln -s "$(cat "$tmp2")" "$name" || {
+ echo >&2 "cannot create a symbolic link $name."
+ exit 1
+ }
+ echo >&2 "created a symbolic link $name."
+ ;;
+ *)
+ echo >&2 "do not know how to create $name of type $type2."
+ exit 1
esac
- git-update-cache --add -- "$name"
- ;;
-?x,.)
- # deleted
- echo >&2 "deleted $name."
+ git-update-cache --add -- "$name" ;;
+
+?,-)
rm -f "$name" || {
- echo >&2 "cannot remove $name";
+ echo >&2 "cannot remove $name"
+ exit 1
+ }
+ echo >&2 "deleted $name."
+ git-update-cache --remove -- "$name" ;;
+
+l,f|f,l)
+ echo >&2 "cannot change a regular file $name and a symbolic link $name."
+ exit 1 ;;
+
+l,l)
+ # symlink to symlink
+ current=$(readlink "$name") || {
+ echo >&2 "cannot read the target of the symbolic link $name."
exit 1
}
- git-update-cache --remove -- "$name"
- ;;
-*)
+ original=$(cat "$tmp1")
+ next=$(cat "$tmp2")
+ test "$original" != "$current" || {
+ echo >&2 "cannot apply symbolic link target change ($original->$next) to $name which points to $current."
+ exit 1
+ }
+ if test "$next" != "$current"
+ then
+ rm -f "$name" && ln -s "$next" "$name" || {
+ echo >&2 "cannot create symbolic link $name."
+ exit 1
+ }
+ echo >&2 "changed symbolic target of $name."
+ git-update-cache -- "$name"
+ fi ;;
+
+f,f)
# changed
+ test -e "$name" || {
+ echo >&2 "regular file $name to be patched does not exist."
+ exit 1
+ }
dir=$(dirname "$name")
- case "$dir" in '' | .) ;; *) mkdir -p "$dir" esac || {
+ case "$dir" in '' | .) ;; *) mkdir -p "$dir";; esac || {
echo >&2 "cannot create leading path for $name."
exit 1
}
- # This will say "patching ..." so we do not say anything outselves.
- diff -u -L "a/$name" -L "b/$name" "$tmp1" "$tmp2" | patch -p1 || exit
+ tmp=.git-apply-patch-$$
+ trap "rm -f $tmp-*" 0 1 2 3 15
+ # Be careful, in case "$tmp2" is borrowed path from the work tree
+ # we are looking at...
+ diff -u -L "a/$name" -L "b/$name" "$tmp1" "$tmp2" >$tmp-patch
+
+ # This will say "patching ..." so we do not say anything outselves.
+ patch -p1 <$tmp-patch || exit
+ rm -f $tmp-patch
case "$mode1,$mode2" in
"$mode2,$mode1") ;;
*)
- echo >&2 "changing mode from $mode1 to $mode2."
chmod "$mode2" "$name"
+ echo >&2 "changed mode from $mode1 to $mode2."
;;
esac
git-update-cache -- "$name"
+
esac
diff --git a/git-prune-script b/git-prune-script
old mode 100644 (file)
new mode 100755 (executable)
new mode 100755 (executable)
diff --git a/update-cache.c b/update-cache.c
index 05d584ed48e8c7fbb200c4b9528481c1802c5bae..893ba8679d5764ba84627558d567268ff2500558 100644 (file)
--- a/update-cache.c
+++ b/update-cache.c
*/
static int allow_add = 0, allow_remove = 0, not_new = 0;
+/*
+ * update-cache --refresh may not touch anything at all, in which case
+ * writing 1.6MB of the same thing is a waste.
+ */
+static int cache_changed = 0;
+
/* Three functions to allow overloaded pointer return; see linux/err.h */
static inline void *ERR_PTR(long error)
{
ce->ce_size = htonl(st->st_size);
}
-static int add_file_to_cache(char *path)
+static int add_file_to_cache_1(char *path)
{
int size, namelen;
struct cache_entry *ce;
default:
return -1;
}
+ if (!cache_changed) {
+ /* If we have not smudged the cache, be careful
+ * to keep it clean. Find out if we have a matching
+ * cache entry that add_cache_entry would replace with,
+ * and if it matches then do not bother calling it.
+ */
+ int pos = cache_name_pos(ce->name, namelen);
+ if ((0 <= pos) &&
+ !memcmp(active_cache[pos], ce, sizeof(*ce))) {
+ free(ce);
+ /* magic to tell add_file_to_cache that
+ * we have not updated anything.
+ */
+ return 999;
+ }
+ }
return add_cache_entry(ce, allow_add);
}
+static int add_file_to_cache(char *path)
+{
+ int ret = add_file_to_cache_1(path);
+ if (ret == 0)
+ cache_changed = 1;
+ else if (ret == 999)
+ ret = 0;
+ return ret;
+}
+
static int match_data(int fd, void *buffer, unsigned long size)
{
while (size) {
if (compare_data(ce, st.st_size))
return ERR_PTR(-EINVAL);
+ cache_changed = 1;
size = ce_size(ce);
updated = xmalloc(size);
memcpy(updated, ce, size);
if (!verify_path(arg3))
return -1;
+ cache_changed = 1;
len = strlen(arg3);
size = cache_entry_size(len);
ce = xmalloc(size);
if (add_file_to_cache(path))
die("Unable to add %s to database", path);
}
- if (write_cache(newfd, active_cache, active_nr) || rename(lockfile, indexfile))
+
+ if (!cache_changed)
+ unlink(lockfile);
+ else if (write_cache(newfd, active_cache, active_nr) ||
+ rename(lockfile, indexfile))
die("Unable to write new cachefile");
lockfile_name = NULL;
- return has_errors;
+ return has_errors ? 1 : 0;
}