* [PATCH 3/5] Docs - include README in git.txt
From: David Greaves @ 2005-05-22 17:44 UTC (permalink / raw)
To: Linus Torvalds; +Cc: git
Include the README in the git.txt
Signed-off-by: David Greaves <david@dgreaves.com>
---
commit e6d7c5341942fdd07d966efe36fde653167e84f0
tree 03ae742170ebaef9040fa8234e1d6752bad140ab
parent 6f657e57d7a5b941ed401365e23d78ff77f5ebcf
author David Greaves <david@dgreaves.com> Sat, 21 May 2005 21:27:41 +0100
committer David Greaves <david@dgreaves.com> Sat, 21 May 2005 21:27:41 +0100
Documentation/git.txt | 46 +++++++++++++++++++++-------------------------
1 files changed, 21 insertions(+), 25 deletions(-)
Index: Documentation/git.txt
===================================================================
--- c081754f951815c43bdd973ddc7e23365793e75e/Documentation/git.txt (mode:100644)
+++ 03ae742170ebaef9040fa8234e1d6752bad140ab/Documentation/git.txt (mode:100644)
@@ -1,6 +1,6 @@
git(7)
======
-v0.1, May 2005
+May 2005
NAME
----
@@ -16,9 +16,10 @@
This is reference information for the core git commands.
-The link:README[] contains much useful definition and clarification
-info - read that first. And of the commands, I suggest reading
-'git-update-cache' and 'git-read-tree' first - I wish I had!
+The Discussion section below contains much useful definition and
+clarification info - read that first. And of the commands, I suggest
+reading link:git-update-cache.html[git-update-cache] and
+link:git-read-tree.html[git-read-tree] first - I wish I had!
David Greaves <david@dgreaves.com>
08/05/05
@@ -157,14 +158,10 @@
-Terminology
------------
-see README for description
-
-Identifier terminology
+Identifier Terminology
----------------------
<object>::
- Indicates any object sha1 identifier
+ Indicates the sha1 identifier for any type of object
<blob>::
Indicates a blob object sha1 identifier
@@ -176,11 +173,10 @@
Indicates a commit object sha1 identifier
<tree-ish>::
- Indicates a tree, commit or tag object sha1 identifier.
- A command that takes a <tree-ish> argument ultimately
- wants to operate on a <tree> object but automatically
- dereferences <commit> and <tag> that points at a
- <tree>.
+ Indicates a tree, commit or tag object sha1 identifier. A
+ command that takes a <tree-ish> argument ultimately wants to
+ operate on a <tree> object but automatically dereferences
+ <commit> and <tag> objects that point at a <tree>.
<type>::
Indicates that an object type is required.
@@ -192,10 +188,12 @@
Symbolic Identifiers
--------------------
-Any git comand accepting any <object> can also use the following symbolic notation:
+Any git comand accepting any <object> can also use the following
+symbolic notation:
HEAD::
- indicates the head of the repository (ie the contents of `$GIT_DIR/HEAD`)
+ indicates the head of the repository (ie the contents of
+ `$GIT_DIR/HEAD`)
<tag>::
a valid tag 'name'+
(ie the contents of `$GIT_DIR/refs/tags/<tag>`)
@@ -230,18 +228,12 @@
Terminology
-----------
-Each line contains terms used interchangeably
+Each line contains terms which you may see used interchangeably
object database, .git directory
directory cache, index
id, sha1, sha1-id, sha1 hash
type, tag
- blob, blob object
- tree, tree object
- commit, commit object
- parent
- root object
- changeset
Environment Variables
@@ -295,9 +287,13 @@
link:git-diff-files.html[git-diff-files];
link:git-diff-tree.html[git-diff-tree]
+Discussion
+----------
+include::../README[]
+
Author
------
-Written by Linus Torvalds <torvalds@osdl.org>
+Written by Linus Torvalds <torvalds@osdl.org> and the git-list <git@vger.kernel.org>.
Documentation
--------------
^ permalink raw reply
* [PATCH 1/5] Docs - Makefile update
From: David Greaves @ 2005-05-22 17:44 UTC (permalink / raw)
To: Linus Torvalds; +Cc: git
A Makefile that works just fine when the 6 character patch is applied
to asciidoc
Signed-off-by: David Greaves <david@dgreaves.com>
---
commit 4a137fb4f4d7e04ae0fb72b3f4910dc487f39c8a
tree 72336a9478877b0708833f0e61cfd27574f24417
parent e002a16ba54096666c2d1768daa122e29fba11ee
author David Greaves <david@dgreaves.com> Sat, 21 May 2005 21:15:18 +0100
committer David Greaves <david@dgreaves.com> Sat, 21 May 2005 21:15:18 +0100
Documentation/Makefile | 28 +++++++++++++++++++++-------
1 files changed, 21 insertions(+), 7 deletions(-)
Index: Documentation/Makefile
===================================================================
--- 58741c69570705801db4b785681790d636475695/Documentation/Makefile (mode:100644)
+++ 72336a9478877b0708833f0e61cfd27574f24417/Documentation/Makefile (mode:100644)
@@ -1,12 +1,28 @@
-DOC_SRC=$(wildcard git*.txt)
-DOC_HTML=$(patsubst %.txt,%.html,$(DOC_SRC))
-DOC_MAN=$(patsubst %.txt,%.1,$(wildcard git-*.txt)) git.7
+MAN1_TXT=$(wildcard git-*.txt)
+MAN7_TXT=git.txt
-all: $(DOC_HTML) $(DOC_MAN)
+DOC_HTML=$(patsubst %.txt,%.html,$(MAN1_TXT) $(MAN7_TXT))
+
+DOC_MAN1=$(patsubst %.txt,%.1,$(MAN1_TXT))
+DOC_MAN7=$(patsubst %.txt,%.7,$(MAN7_TXT))
+
+#
+# Please note that there is a minor bug in asciidoc.
+# The version after 6.0.3 _will_ include the patch found here:
+# http://marc.theaimsgroup.com/?l=git&m=111558757202243&w=2
+#
+# Until that version is released you may have to apply the patch
+# yourself - yes, all 6 characters of it!
+#
+
+all: html man
html: $(DOC_HTML)
-man: $(DOC_MAN)
+
+man: man1 man7
+man1: $(DOC_MAN1)
+man7: $(DOC_MAN7)
# 'include' dependencies
git-diff-%.txt: diff-format.txt
@@ -20,8 +36,6 @@
%.1 %.7 : %.xml
xmlto man $<
- # FIXME: this next line works around an output filename bug in asciidoc 6.0.3
- [ "$@" = "git.7" ] || mv git.1 $@
%.xml : %.txt
asciidoc -b docbook -d manpage $<
^ permalink raw reply
* Re: git-diff-files -z output
From: Thomas Glanzmann @ 2005-05-22 17:38 UTC (permalink / raw)
To: GIT
In-Reply-To: <20050522173243.GA18500@cip.informatik.uni-erlangen.de>
Hello,
> $tmp[0] =~ s/^://g;
^ -> This is useless.
Thomas
^ permalink raw reply
* Re: git-diff-files -z output
From: Thomas Glanzmann @ 2005-05-22 17:32 UTC (permalink / raw)
To: GIT
In-Reply-To: <20050522172737.GB17570@cip.informatik.uni-erlangen.de>
Hello,
this is better (it strips the colon from the first mode):
sub
process_git_diff_output
{
my $str = shift || die("Need Input");
my @in = split("\0", $str);
my @out = ();
while (@in) {
my @tmp = split(' ', shift(@in));
$tmp[0] =~ s/^://g;
push(@tmp, shift(@in), shift(@in));
push(@out, [@tmp]);
}
return(@out);
}
Thomas
^ permalink raw reply
* Re: git-diff-files -z output
From: Thomas Glanzmann @ 2005-05-22 17:27 UTC (permalink / raw)
To: GIT
In-Reply-To: <7v3bsffadn.fsf@assigned-by-dhcp.cox.net>
Hello,
> Please see Documentation/diff-format.txt; find the below in the
> archive for the full description of why we wanted this format
> update.
got it thanks. I read that eMail before. But I thought that the
tab -> space was a mistake, but it wasn't. So I am fine. I use the
following code fragment to match it. Gitweb and co have to be adopted as
well:
sub
process_git_diff_output
{
my $str = shift || die("Need Input");
my @in = split("\0", $str);
my @out = ();
while (@in) {
my @tmp = split(' ', shift(@in));
push(@tmp, shift(@in), shift(@in));
push(@out, [@tmp]);
}
return(@out);
}
Thomas
^ permalink raw reply
* Re: git-diff-files -z output
From: Junio C Hamano @ 2005-05-22 17:17 UTC (permalink / raw)
To: GIT
In-Reply-To: <20050522170540.GO15178@cip.informatik.uni-erlangen.de>
>>>>> "TG" == Thomas Glanzmann <sithglan@stud.uni-erlangen.de> writes:
TG> I am adopting to the new format.
TG> Are the fields supposed to be seperated by space or tab?
Please see Documentation/diff-format.txt; find the below in the
archive for the full description of why we wanted this format
update.
From: Junio C Hamano <junkio@cox.net>
Subject: Re: updated design for the diff-raw format.
To: git@vger.kernel.org
Date: Sat, 21 May 2005 16:17:33 -0700
(second of the replayed message, with blessing from Linus)
Date: Sat, 21 May 2005 11:24:31 -0700 (PDT)
From: Linus Torvalds <torvalds@osdl.org>
To: Junio C Hamano <junkio@cox.net>
Subject: Re: [PATCH 3/3] Diff overhaul, adding the other half of copy detection.
Message-ID: <Pine.LNX.4.58.0505211107160.2206@ppc970.osdl.org>
On Sat, 21 May 2005, Junio C Hamano wrote:
>
> Once we start to think of it this way, it becomes quite tempting
> to change the diff-raw format to actually match the above
> concept.
I agree, and I was going to suggest changing the "raw" diff output for all
the same reasons. So I think you should do it, as the old format was based
on not really knowing where this all would take us. I think your proposed
format is visually nicer, and it's obviously more flexible.
^ permalink raw reply
* Re: How stop tracking a file?
From: Junio C Hamano @ 2005-05-22 17:10 UTC (permalink / raw)
To: jeff millar; +Cc: git
In-Reply-To: <4290B7FB.5070708@adelphia.net>
>>>>> "jm" == jeff millar <wa1hco@adelphia.net> writes:
jm> cg-rm does two things
jm> rm -f "$@"
jm> git-update-cache --remove -- "$@"
I do not do Porcelain, but something along the following lines
should work:
for path
do
git-update-cache --force-remove "$path"
done
^ permalink raw reply
* git-diff-files -z output
From: Thomas Glanzmann @ 2005-05-22 17:05 UTC (permalink / raw)
To: GIT
Hello,
is this correct?
(faui00u) [~/work/git/yagf] git-diff-files -z | xxd
0000000: 3a31 3030 3634 3420 3030 3030 3030 2031 :100644 000000 1
0000010: 6663 3834 3639 6366 6332 6631 3436 3332 fc8469cfc2f14632
0000020: 3734 3333 3363 3062 6562 6162 3065 3465 74333c0bebab0e4e
0000030: 3439 3562 6336 6220 3030 3030 3030 3030 495bc6b 00000000
0000040: 3030 3030 3030 3030 3030 3030 3030 3030 0000000000000000
0000050: 3030 3030 3030 3030 3030 3030 3030 3030 0000000000000000
0000060: 0064 6966 662e 6800 6469 6666 2e68 003a .diff.h.diff.h.:
0000070: 3130 3037 3535 2031 3030 3735 3520 6464 100755 100755 dd
0000080: 3633 6533 3535 3463 3137 6431 3861 3039 63e3554c17d18a09
0000090: 3137 3931 3038 3264 3164 3632 3864 3835 1791082d1d628d85
00000a0: 3162 3933 3038 2030 3030 3030 3030 3030 1b9308 000000000
00000b0: 3030 3030 3030 3030 3030 3030 3030 3030 0000000000000000
00000c0: 3030 3030 3030 3030 3030 3030 3030 3000 000000000000000.
00000d0: 6769 7400 6769 7400 git.git.
Eg the fields are seperated by space/tab and only the filenames by \0?
I am adopting to the new format.
Are the fields supposed to be seperated by space or tab?
static void diff_flush_raw(struct diff_filepair *p)
{
/*
* We used to reject rename/copy but new diff-raw can express them.
*/
printf(":%06o %06o %s ",
p->one->mode, p->two->mode, sha1_to_hex(p->one->sha1));
printf("%s%c%s%c%s%c",
sha1_to_hex(p->two->sha1), inter_name_termination,
p->one->path, inter_name_termination,
p->two->path, line_termination);
}
Gruesse,
Thomas
^ permalink raw reply
* [PATCH] Diffcore updates.
From: Junio C Hamano @ 2005-05-22 17:04 UTC (permalink / raw)
To: Linus Torvalds; +Cc: git
In-Reply-To: <7vbr73ha2c.fsf@assigned-by-dhcp.cox.net>
This applies on top of the "math thinko" fix; would not conflict
if you are missing it, but you would see offsets. I added the
file missing from the previous patch. Sorry about the screwup.
------------
This patch moves the path selection logic from individual
programs to a new diffcore transformer (diff-tree still needs
to have its own for performance reasons). Also the header
printing code in diff-tree was tweaked not to produce anything
when pickaxe is in effect and there is nothing interesting to
report. An interesting example is the following in the GIT
archive itself:
$ git-whatchanged -p -C -S'or something in a real script'
Signed-off-by: Junio C Hamano <junkio@cox.net>
---
Makefile | 9 +-
diff-cache.c | 27 +++++---
diff-files.c | 38 +++--------
diff-helper.c | 17 +++--
diff-tree.c | 44 +++++++------
diff.c | 172 +++++++++++++++++++++++++++-------------------------
diff.h | 22 ++++--
diffcore-pathspec.c | 63 +++++++++++++++++++
diffcore-pickaxe.c | 15 ++--
diffcore-rename.c | 23 ++++++
diffcore.h | 4 +
11 files changed, 267 insertions(+), 167 deletions(-)
new file (100644): diffcore-pathspec.c
diff --git a/Makefile b/Makefile
--- a/Makefile
+++ b/Makefile
@@ -45,7 +45,7 @@ LIB_H += strbuf.h
LIB_OBJS += strbuf.o
LIB_H += diff.h
-LIB_OBJS += diff.o diffcore-rename.o diffcore-pickaxe.o
+LIB_OBJS += diff.o diffcore-rename.o diffcore-pickaxe.o diffcore-pathspec.o
LIB_OBJS += gitenv.o
@@ -123,9 +123,10 @@ sha1_file.o: $(LIB_H)
usage.o: $(LIB_H)
strbuf.o: $(LIB_H)
gitenv.o: $(LIB_H)
-diff.o: $(LIB_H)
-diffcore-rename.o : $(LIB_H)
-diffcore-pickaxe.o : $(LIB_H)
+diff.o: $(LIB_H) diffcore.h
+diffcore-rename.o : $(LIB_H) diffcore.h
+diffcore-pathspec.o : $(LIB_H) diffcore.h
+diffcore-pickaxe.o : $(LIB_H) diffcore.h
test: all
make -C t/ all
diff --git a/diff-cache.c b/diff-cache.c
--- a/diff-cache.c
+++ b/diff-cache.c
@@ -71,7 +71,7 @@ static int show_modified(struct cache_en
oldmode = old->ce_mode;
if (mode == oldmode && !memcmp(sha1, old->sha1, 20) &&
- detect_rename < 2)
+ detect_rename < DIFF_DETECT_COPY)
return 0;
mode = ntohl(mode);
@@ -156,7 +156,7 @@ static void mark_merge_entries(void)
static char *diff_cache_usage =
"git-diff-cache [-p] [-r] [-z] [-m] [-M] [-C] [-R] [-S<string>] [--cached] <tree-ish>";
-int main(int argc, char **argv)
+int main(int argc, const char **argv)
{
unsigned char tree_sha1[20];
void *tree;
@@ -165,7 +165,7 @@ int main(int argc, char **argv)
read_cache();
while (argc > 2) {
- char *arg = argv[1];
+ const char *arg = argv[1];
argv++;
argc--;
if (!strcmp(arg, "-r")) {
@@ -177,12 +177,12 @@ int main(int argc, char **argv)
continue;
}
if (!strncmp(arg, "-M", 2)) {
- detect_rename = 1;
+ detect_rename = DIFF_DETECT_RENAME;
diff_score_opt = diff_scoreopt_parse(arg);
continue;
}
if (!strncmp(arg, "-C", 2)) {
- detect_rename = 2;
+ detect_rename = DIFF_DETECT_COPY;
diff_score_opt = diff_scoreopt_parse(arg);
continue;
}
@@ -209,10 +209,14 @@ int main(int argc, char **argv)
usage(diff_cache_usage);
}
- if (argc != 2 || get_sha1(argv[1], tree_sha1))
+ if (argc < 2 || get_sha1(argv[1], tree_sha1))
usage(diff_cache_usage);
+ argv++;
+ argc--;
- diff_setup(reverse_diff, diff_output_format);
+ /* The rest is for paths restriction. */
+
+ diff_setup(reverse_diff);
mark_merge_entries();
@@ -224,9 +228,12 @@ int main(int argc, char **argv)
ret = diff_cache(active_cache, active_nr);
if (detect_rename)
- diff_detect_rename(detect_rename, diff_score_opt);
+ diffcore_rename(detect_rename, diff_score_opt);
+ diffcore_prune();
if (pickaxe)
- diff_pickaxe(pickaxe);
- diff_flush(NULL, 0);
+ diffcore_pickaxe(pickaxe);
+ if (2 <= argc)
+ diffcore_pathspec(argv + 1);
+ diff_flush(diff_output_format);
return ret;
}
diff --git a/diff-files.c b/diff-files.c
--- a/diff-files.c
+++ b/diff-files.c
@@ -16,21 +16,6 @@ static int diff_score_opt = 0;
static const char *pickaxe = NULL;
static int silent = 0;
-static int matches_pathspec(struct cache_entry *ce, char **spec, int cnt)
-{
- int i;
- int namelen = ce_namelen(ce);
- for (i = 0; i < cnt; i++) {
- int speclen = strlen(spec[i]);
- if (! strncmp(spec[i], ce->name, speclen) &&
- speclen <= namelen &&
- (ce->name[speclen] == 0 ||
- ce->name[speclen] == '/'))
- return 1;
- }
- return 0;
-}
-
static void show_unmerge(const char *path)
{
diff_unmerge(path);
@@ -48,7 +33,7 @@ static void show_modified(int oldmode, i
diff_change(oldmode, mode, old_sha1, sha1, path, NULL);
}
-int main(int argc, char **argv)
+int main(int argc, const char **argv)
{
static const unsigned char null_sha1[20] = { 0, };
int entries = read_cache();
@@ -71,11 +56,11 @@ int main(int argc, char **argv)
pickaxe = argv[1] + 2;
else if (!strncmp(argv[1], "-M", 2)) {
diff_score_opt = diff_scoreopt_parse(argv[1]);
- detect_rename = 1;
+ detect_rename = DIFF_DETECT_RENAME;
}
else if (!strncmp(argv[1], "-C", 2)) {
diff_score_opt = diff_scoreopt_parse(argv[1]);
- detect_rename = 2;
+ detect_rename = DIFF_DETECT_COPY;
}
else
usage(diff_files_usage);
@@ -90,7 +75,7 @@ int main(int argc, char **argv)
exit(1);
}
- diff_setup(reverse_diff, diff_output_format);
+ diff_setup(reverse_diff);
for (i = 0; i < entries; i++) {
struct stat st;
@@ -98,10 +83,6 @@ int main(int argc, char **argv)
struct cache_entry *ce = active_cache[i];
int changed;
- if (1 < argc &&
- ! matches_pathspec(ce, argv+1, argc-1))
- continue;
-
if (ce_stage(ce)) {
show_unmerge(ce->name);
while (i < entries &&
@@ -122,7 +103,7 @@ int main(int argc, char **argv)
continue;
}
changed = ce_match_stat(ce, &st);
- if (!changed && detect_rename < 2)
+ if (!changed && detect_rename < DIFF_DETECT_COPY)
continue;
oldmode = ntohl(ce->ce_mode);
@@ -133,9 +114,12 @@ int main(int argc, char **argv)
ce->name);
}
if (detect_rename)
- diff_detect_rename(detect_rename, diff_score_opt);
+ diffcore_rename(detect_rename, diff_score_opt);
+ diffcore_prune();
if (pickaxe)
- diff_pickaxe(pickaxe);
- diff_flush(NULL, 0);
+ diffcore_pickaxe(pickaxe);
+ if (1 < argc)
+ diffcore_pathspec(argv + 1);
+ diff_flush(diff_output_format);
return 0;
}
diff --git a/diff-helper.c b/diff-helper.c
--- a/diff-helper.c
+++ b/diff-helper.c
@@ -77,11 +77,11 @@ int main(int ac, const char **av) {
else if (av[1][1] == 'P') /* hidden from the help */
diff_output_style = DIFF_FORMAT_MACHINE;
else if (av[1][1] == 'M') {
- detect_rename = 1;
+ detect_rename = DIFF_DETECT_RENAME;
diff_score_opt = diff_scoreopt_parse(av[1]);
}
else if (av[1][1] == 'C') {
- detect_rename = 2;
+ detect_rename = DIFF_DETECT_COPY;
diff_score_opt = diff_scoreopt_parse(av[1]);
}
else if (av[1][1] == 'S') {
@@ -93,7 +93,7 @@ int main(int ac, const char **av) {
}
/* the remaining parameters are paths patterns */
- diff_setup(reverse_diff, diff_output_style);
+ diff_setup(reverse_diff);
while (1) {
int status;
read_line(&sb1, stdin, line_termination);
@@ -121,14 +121,17 @@ int main(int ac, const char **av) {
status = parse_diff_raw(sb1.buf+1, NULL, NULL);
if (status) {
unrecognized:
- diff_flush(av+1, ac-1);
+ diff_flush(diff_output_style);
printf("%s%c", sb1.buf, line_termination);
}
}
if (detect_rename)
- diff_detect_rename(detect_rename, diff_score_opt);
+ diffcore_rename(detect_rename, diff_score_opt);
+ diffcore_prune();
if (pickaxe)
- diff_pickaxe(pickaxe);
- diff_flush(av+1, ac-1);
+ diffcore_pickaxe(pickaxe);
+ if (ac)
+ diffcore_pathspec(av + 1);
+ diff_flush(diff_output_style);
return 0;
}
diff --git a/diff-tree.c b/diff-tree.c
--- a/diff-tree.c
+++ b/diff-tree.c
@@ -18,7 +18,7 @@ static const char *header_prefix = "";
// What paths are we interested in?
static int nr_paths = 0;
-static char **paths = NULL;
+static const char **paths = NULL;
static int *pathlens = NULL;
static int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const char *base);
@@ -67,11 +67,6 @@ static void show_file(const char *prefix
const char *path;
const unsigned char *sha1 = extract(tree, size, &path, &mode);
- if (header) {
- printf("%s", header);
- header = NULL;
- }
-
if (silent)
return;
@@ -137,10 +132,6 @@ static int compare_tree_entry(void *tree
return retval;
}
- if (header) {
- printf("%s", header);
- header = NULL;
- }
if (silent)
return 0;
@@ -268,16 +259,29 @@ static int diff_tree_sha1(const unsigned
static void call_diff_setup(void)
{
- diff_setup(reverse_diff, diff_output_format);
+ diff_setup(reverse_diff);
}
-static void call_diff_flush(void)
+static int call_diff_flush()
{
if (detect_rename)
- diff_detect_rename(detect_rename, diff_score_opt);
- if (pickaxe)
- diff_pickaxe(pickaxe);
- diff_flush(NULL, 0);
+ diffcore_rename(detect_rename, diff_score_opt);
+ diffcore_prune();
+ if (pickaxe) {
+ diffcore_pickaxe(pickaxe);
+ if (diff_queue_is_empty()) {
+ diff_flush(DIFF_FORMAT_NO_OUTPUT);
+ return 0;
+ }
+ }
+ if (nr_paths)
+ diffcore_pathspec(paths);
+ if (header) {
+ printf("%s", header);
+ header = NULL;
+ }
+ diff_flush(diff_output_format);
+ return 1;
}
static int diff_tree_sha1_top(const unsigned char *old,
@@ -462,7 +466,7 @@ static int diff_tree_stdin(char *line)
static char *diff_tree_usage =
"git-diff-tree [-p] [-r] [-z] [--stdin] [-M] [-C] [-R] [-S<string>] [-m] [-s] [-v] <tree-ish> <tree-ish>";
-int main(int argc, char **argv)
+int main(int argc, const char **argv)
{
int nr_sha1;
char line[1000];
@@ -470,7 +474,7 @@ int main(int argc, char **argv)
nr_sha1 = 0;
for (;;) {
- char *arg;
+ const char *arg;
argv++;
argc--;
@@ -509,12 +513,12 @@ int main(int argc, char **argv)
continue;
}
if (!strncmp(arg, "-M", 2)) {
- detect_rename = 1;
+ detect_rename = DIFF_DETECT_RENAME;
diff_score_opt = diff_scoreopt_parse(arg);
continue;
}
if (!strncmp(arg, "-C", 2)) {
- detect_rename = 2;
+ detect_rename = DIFF_DETECT_COPY;
diff_score_opt = diff_scoreopt_parse(arg);
continue;
}
diff --git a/diff.c b/diff.c
--- a/diff.c
+++ b/diff.c
@@ -16,8 +16,6 @@ static int reverse_diff;
static int generate_patch;
static int line_termination = '\n';
static int inter_name_termination = '\t';
-static const char **pathspec;
-static int speccnt;
static const char *external_diff(void)
{
@@ -286,6 +284,12 @@ int diff_populate_filespec(struct diff_f
return 0;
}
+void diff_free_filepair(struct diff_filepair *p)
+{
+ free(p->xfrm_msg);
+ free(p);
+}
+
void diff_free_filespec_data(struct diff_filespec *s)
{
if (s->should_free)
@@ -390,25 +394,6 @@ static void remove_tempfile_on_signal(in
remove_tempfile();
}
-static int matches_pathspec(const char *name)
-{
- int i;
- int namelen;
-
- if (speccnt == 0)
- return 1;
-
- namelen = strlen(name);
- for (i = 0; i < speccnt; i++) {
- int speclen = strlen(pathspec[i]);
- if (! strncmp(pathspec[i], name, speclen) &&
- speclen <= namelen &&
- (name[speclen] == 0 || name[speclen] == '/'))
- return 1;
- }
- return 0;
-}
-
/* An external diff command takes:
*
* diff-cmd name infile1 infile1-sha1 infile1-mode \
@@ -426,9 +411,6 @@ static void run_external_diff(const char
int status;
static int atexit_asked = 0;
- if (!matches_pathspec(name) && (!other || !matches_pathspec(other)))
- return;
-
if (one && two) {
prepare_temp_file(name, &temp[0], one);
prepare_temp_file(other ? : name, &temp[1], two);
@@ -496,47 +478,26 @@ static void run_external_diff(const char
remove_tempfile();
}
-int diff_scoreopt_parse(const char *opt)
+void diff_setup(int reverse_diff_)
{
- int diglen, num, scale, i;
- if (opt[0] != '-' || (opt[1] != 'M' && opt[1] != 'C'))
- return -1; /* that is not a -M nor -C option */
- diglen = strspn(opt+2, "0123456789");
- if (diglen == 0 || strlen(opt+2) != diglen)
- return 0; /* use default */
- sscanf(opt+2, "%d", &num);
- for (i = 0, scale = 1; i < diglen; i++)
- scale *= 10;
-
- /* user says num divided by scale and we say internally that
- * is MAX_SCORE * num / scale.
- */
- return MAX_SCORE * num / scale;
+ reverse_diff = reverse_diff_;
}
-void diff_setup(int reverse_diff_, int diff_output_style)
+struct diff_queue_struct diff_queued_diff;
+
+void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp)
{
- reverse_diff = reverse_diff_;
- generate_patch = 0;
- switch (diff_output_style) {
- case DIFF_FORMAT_HUMAN:
- line_termination = '\n';
- inter_name_termination = '\t';
- break;
- case DIFF_FORMAT_MACHINE:
- line_termination = inter_name_termination = 0;
- break;
- case DIFF_FORMAT_PATCH:
- generate_patch = 1;
- break;
+ if (queue->alloc <= queue->nr) {
+ queue->alloc = alloc_nr(queue->alloc);
+ queue->queue = xrealloc(queue->queue,
+ sizeof(dp) * queue->alloc);
}
+ queue->queue[queue->nr++] = dp;
}
-struct diff_queue_struct diff_queued_diff;
-
struct diff_filepair *diff_queue(struct diff_queue_struct *queue,
- struct diff_filespec *one,
- struct diff_filespec *two)
+ struct diff_filespec *one,
+ struct diff_filespec *two)
{
struct diff_filepair *dp = xmalloc(sizeof(*dp));
dp->one = one;
@@ -544,20 +505,16 @@ struct diff_filepair *diff_queue(struct
dp->xfrm_msg = 0;
dp->orig_order = queue->nr;
dp->xfrm_work = 0;
- if (queue->alloc <= queue->nr) {
- queue->alloc = alloc_nr(queue->alloc);
- queue->queue = xrealloc(queue->queue,
- sizeof(dp) * queue->alloc);
- }
- queue->queue[queue->nr++] = dp;
+ diff_q(queue, dp);
return dp;
}
static void diff_flush_raw(struct diff_filepair *p)
{
- /*
- * We used to reject rename/copy but new diff-raw can express them.
- */
+ if (DIFF_PAIR_UNMERGED(p)) {
+ printf("U %s%c", p->one->path, line_termination);
+ return;
+ }
printf(":%06o %06o %s ",
p->one->mode, p->two->mode, sha1_to_hex(p->one->sha1));
printf("%s%c%s%c%s%c",
@@ -576,19 +533,26 @@ static void diff_flush_patch(struct diff
(DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
return; /* no tree diffs in patch format */
- run_external_diff(name, other, p->one, p->two, p->xfrm_msg);
+ if (DIFF_PAIR_UNMERGED(p))
+ run_external_diff(name, NULL, NULL, NULL, NULL);
+ else
+ run_external_diff(name, other, p->one, p->two, p->xfrm_msg);
}
-static int identical(struct diff_filespec *one, struct diff_filespec *two)
+static int uninteresting(struct diff_filepair *p)
{
/* This function is written stricter than necessary to support
* the currently implemented transformers, but the idea is to
* let transformers to produce diff_filepairs any way they want,
* and filter and clean them up here before producing the output.
*/
+ struct diff_filespec *one, *two;
- if (!DIFF_FILE_VALID(one) && !DIFF_FILE_VALID(two))
- return 1; /* not interesting */
+ if (DIFF_PAIR_UNMERGED(p))
+ return 0; /* unmerged is interesting */
+
+ one = p->one;
+ two = p->two;
/* deletion, addition, mode change and renames are all interesting. */
if (DIFF_FILE_VALID(one) != DIFF_FILE_VALID(two) ||
@@ -607,9 +571,44 @@ static int identical(struct diff_filespe
return 0;
}
+void diffcore_prune(void)
+{
+ /*
+ * Although rename/copy detection wants to have "no-change"
+ * entries fed into them, the downstream do not need to see
+ * them. This function removes such entries.
+ *
+ * The applications that use rename/copy should:
+ *
+ * (1) feed change and "no-change" entries via diff_queue().
+ * (2) call diffcore_rename, and any other future diffcore_xxx
+ * that would benefit by still having "no-change" entries.
+ * (3) call diffcore_prune
+ * (4) call other diffcore_xxx that do not need to see
+ * "no-change" entries.
+ */
+ struct diff_queue_struct *q = &diff_queued_diff;
+ struct diff_queue_struct outq;
+ int i;
+
+ outq.queue = NULL;
+ outq.nr = outq.alloc = 0;
+
+ for (i = 0; i < q->nr; i++) {
+ struct diff_filepair *p = q->queue[i];
+ if (!uninteresting(p))
+ diff_q(&outq, p);
+ else
+ diff_free_filepair(p);
+ }
+ free(q->queue);
+ *q = outq;
+ return;
+}
+
static void diff_flush_one(struct diff_filepair *p)
{
- if (identical(p->one, p->two))
+ if (uninteresting(p))
return;
if (generate_patch)
diff_flush_patch(p);
@@ -624,23 +623,32 @@ int diff_queue_is_empty(void)
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
- if (!identical(p->one, p->two))
+ if (!uninteresting(p))
return 0;
}
return 1;
}
-void diff_flush(const char **pathspec_, int speccnt_)
+void diff_flush(int diff_output_style)
{
struct diff_queue_struct *q = &diff_queued_diff;
int i;
- pathspec = pathspec_;
- speccnt = speccnt_;
-
+ generate_patch = 0;
+ switch (diff_output_style) {
+ case DIFF_FORMAT_HUMAN:
+ line_termination = '\n';
+ inter_name_termination = '\t';
+ break;
+ case DIFF_FORMAT_MACHINE:
+ line_termination = inter_name_termination = 0;
+ break;
+ case DIFF_FORMAT_PATCH:
+ generate_patch = 1;
+ break;
+ }
for (i = 0; i < q->nr; i++)
diff_flush_one(q->queue[i]);
-
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
diff_free_filespec_data(p->one);
@@ -669,7 +677,7 @@ void diff_addremove(int addremove, unsig
* which but should not make any difference).
* Feeding the same new and old to diff_change() should
* also have the same effect. diff_flush() should
- * filter the identical ones out at the final output
+ * filter uninteresting ones out at the final output
* stage.
*/
if (reverse_diff)
@@ -739,8 +747,8 @@ void diff_change(unsigned old_mode, unsi
void diff_unmerge(const char *path)
{
- if (generate_patch)
- run_external_diff(path, NULL, NULL, NULL, NULL);
- else
- printf("U %s%c", path, line_termination);
+ struct diff_filespec *one, *two;
+ one = alloc_filespec(path);
+ two = alloc_filespec(path);
+ diff_queue(&diff_queued_diff, one, two);
}
diff --git a/diff.h b/diff.h
--- a/diff.h
+++ b/diff.h
@@ -26,16 +26,24 @@ extern void diff_unmerge(const char *pat
extern int diff_scoreopt_parse(const char *opt);
-#define DIFF_FORMAT_HUMAN 0
-#define DIFF_FORMAT_MACHINE 1
-#define DIFF_FORMAT_PATCH 2
-extern void diff_setup(int reverse, int diff_output_style);
+#define DIFF_FORMAT_HUMAN 0
+#define DIFF_FORMAT_MACHINE 1
+#define DIFF_FORMAT_PATCH 2
+#define DIFF_FORMAT_NO_OUTPUT 3
+extern void diff_setup(int reverse);
-extern void diff_detect_rename(int, int);
-extern void diff_pickaxe(const char *);
+#define DIFF_DETECT_RENAME 1
+#define DIFF_DETECT_COPY 2
+
+extern void diffcore_rename(int rename_copy, int minimum_score);
+
+extern void diffcore_prune(void);
+
+extern void diffcore_pickaxe(const char *needle);
+extern void diffcore_pathspec(const char **pathspec);
extern int diff_queue_is_empty(void);
-extern void diff_flush(const char **, int);
+extern void diff_flush(int output_style);
#endif /* DIFF_H */
diff --git a/diffcore-pathspec.c b/diffcore-pathspec.c
new file mode 100644
--- /dev/null
+++ b/diffcore-pathspec.c
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2005 Junio C Hamano
+ */
+#include "cache.h"
+#include "diff.h"
+#include "diffcore.h"
+#include "delta.h"
+
+struct path_spec {
+ const char *spec;
+ int len;
+};
+
+static int matches_pathspec(const char *name, struct path_spec *s, int cnt)
+{
+ int i;
+ int namelen;
+
+ if (cnt == 0)
+ return 1;
+
+ namelen = strlen(name);
+ for (i = 0; i < cnt; i++) {
+ int len = s->len;
+ if (! strncmp(s->spec, name, len) &&
+ len <= namelen &&
+ (name[len] == 0 || name[len] == '/'))
+ return 1;
+ }
+ return 0;
+}
+
+void diffcore_pathspec(const char **pathspec)
+{
+ struct diff_queue_struct *q = &diff_queued_diff;
+ int i, speccnt;
+ struct diff_queue_struct outq;
+ struct path_spec *spec;
+
+ outq.queue = NULL;
+ outq.nr = outq.alloc = 0;
+
+ for (i = 0; pathspec[i]; i++)
+ ;
+ speccnt = i;
+ spec = xmalloc(sizeof(*spec) * speccnt);
+ for (i = 0; pathspec[i]; i++) {
+ spec[i].spec = pathspec[i];
+ spec[i].len = strlen(pathspec[i]);
+ }
+
+ for (i = 0; i < q->nr; i++) {
+ struct diff_filepair *p = q->queue[i];
+ if (matches_pathspec(p->one->path, spec, speccnt) ||
+ matches_pathspec(p->two->path, spec, speccnt))
+ diff_q(&outq, p);
+ else
+ diff_free_filepair(p);
+ }
+ free(q->queue);
+ *q = outq;
+ return;
+}
diff --git a/diffcore-pickaxe.c b/diffcore-pickaxe.c
--- a/diffcore-pickaxe.c
+++ b/diffcore-pickaxe.c
@@ -21,7 +21,7 @@ static int contains(struct diff_filespec
return 0;
}
-void diff_pickaxe(const char *needle)
+void diffcore_pickaxe(const char *needle)
{
struct diff_queue_struct *q = &diff_queued_diff;
unsigned long len = strlen(needle);
@@ -32,24 +32,23 @@ void diff_pickaxe(const char *needle)
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
+ int onum = outq.nr;
if (!DIFF_FILE_VALID(p->one)) {
if (!DIFF_FILE_VALID(p->two))
continue; /* ignore nonsense */
/* created */
if (contains(p->two, needle, len))
- diff_queue(&outq, p->one, p->two);
+ diff_q(&outq, p);
}
else if (!DIFF_FILE_VALID(p->two)) {
if (contains(p->one, needle, len))
- diff_queue(&outq, p->one, p->two);
+ diff_q(&outq, p);
}
else if (contains(p->one, needle, len) !=
contains(p->two, needle, len))
- diff_queue(&outq, p->one, p->two);
- }
- for (i = 0; i < q->nr; i++) {
- struct diff_filepair *p = q->queue[i];
- free(p);
+ diff_q(&outq, p);
+ if (onum == outq.nr)
+ diff_free_filepair(p);
}
free(q->queue);
*q = outq;
diff --git a/diffcore-rename.c b/diffcore-rename.c
--- a/diffcore-rename.c
+++ b/diffcore-rename.c
@@ -224,8 +224,25 @@ static int needs_to_stay(struct diff_que
return 0;
}
-void diff_detect_rename(int detect_rename,
- int minimum_score)
+int diff_scoreopt_parse(const char *opt)
+{
+ int diglen, num, scale, i;
+ if (opt[0] != '-' || (opt[1] != 'M' && opt[1] != 'C'))
+ return -1; /* that is not a -M nor -C option */
+ diglen = strspn(opt+2, "0123456789");
+ if (diglen == 0 || strlen(opt+2) != diglen)
+ return 0; /* use default */
+ sscanf(opt+2, "%d", &num);
+ for (i = 0, scale = 1; i < diglen; i++)
+ scale *= 10;
+
+ /* user says num divided by scale and we say internally that
+ * is MAX_SCORE * num / scale.
+ */
+ return MAX_SCORE * num / scale;
+}
+
+void diffcore_rename(int detect_rename, int minimum_score)
{
struct diff_queue_struct *q = &diff_queued_diff;
struct diff_queue_struct outq;
@@ -235,6 +252,8 @@ void diff_detect_rename(int detect_renam
int h, i, j;
int num_create, num_src, dst_cnt, src_cnt;
+ if (!minimum_score)
+ minimum_score = DEFAULT_MINIMUM_SCORE;
outq.queue = NULL;
outq.nr = outq.alloc = 0;
diff --git a/diffcore.h b/diffcore.h
--- a/diffcore.h
+++ b/diffcore.h
@@ -45,6 +45,8 @@ struct diff_filepair {
int orig_order; /* the original order of insertion into the queue */
int xfrm_work; /* for use by tramsformers, not by diffcore */
};
+#define DIFF_PAIR_UNMERGED(p) \
+ (!DIFF_FILE_VALID((p)->one) && !DIFF_FILE_VALID((p)->two))
struct diff_queue_struct {
struct diff_filepair **queue;
@@ -56,5 +58,7 @@ extern struct diff_queue_struct diff_que
extern struct diff_filepair *diff_queue(struct diff_queue_struct *,
struct diff_filespec *,
struct diff_filespec *);
+extern void diff_q(struct diff_queue_struct *, struct diff_filepair *);
+extern void diff_free_filepair(struct diff_filepair *);
#endif
------------------------------------------------
^ permalink raw reply
* Re: Kernel nightly snapshots..
From: Russell King @ 2005-05-22 17:01 UTC (permalink / raw)
To: Git Mailing List
In-Reply-To: <20050522120954.GH15178@cip.informatik.uni-erlangen.de>
On Sun, May 22, 2005 at 02:09:54PM +0200, Thomas Glanzmann wrote:
> Hello,
>
> > That should be done against the 2.6 kernel, and that tree is already
> > available.
>
> it is a shame that 2.6 doesn't even boot on this machine[1]. And even if
> the patch doesn't do its way upstream its good to have something like
> git available to to vendortracking.
>
> Thomas
>
> [1] http://bugzilla.kernel.org/show_bug.cgi?id=4415
This bugzilla entry unfortunately gives me two problems:
1. I don't know what a 2.6.x-hh kernel is, or what modifications there
are from the 2.6 mainline kernel.
2. I don't have visibility of this jornada list, nor what diagnosis
has been done so far.
It's also worth pointing out that the patch there is for a 2.4 kernel,
and therefore probably isn't suitable for 2.6 as is.
What I can say is that there's been very little flow of patches into
mainline for Jornada 7xx - the last attempt was back in January 2002.
Many of the problems from that time stemmed from me having a separate
tree, which caused the expectation that I would handle integration of
_anything_. Since the -rmk tree is no longer a public offering, and
usable ARM support is merged into mainline, this expectation has been
removed.
What this does mean, however, is that from my point of view, Jornada
is a dead and unmaintained machine as far as 2.6 goes, and is ripe for
removal from the kernel source - the only reason it builds today is
because I've been tweaking it to keep it building. Whether it actually
works or not is a completely different matter.
The way to stop it from being removed is for someone to step up and
maintain the thing in mainline. How easy this would be is also
something I have no view on, since I've no idea what's outstanding,
nor what unmerged handhelds features Jornada 7xx depends on.
All in all, due to the above, I think submitting bugs for -hh kernels
to the mainline bugzilla is a worthless exercise unless they can be
proven to be relevant to mainline kernels.
Sorry.
--
Russell King
^ permalink raw reply
* How stop tracking a file?
From: jeff millar @ 2005-05-22 16:48 UTC (permalink / raw)
To: git
cg-rm does two things
rm -f "$@"
git-update-cache --remove -- "$@"
Does cg support a way to stop tracking a file without deleting it?
The idea was to cg-init an entire directory (such as /etc/ or some
existing software project) and then selectivly stop tracking files,
such as *.o, selected binaries, ld.so.cache, etc. as they turned up.
thanks,
jeff
^ permalink raw reply
* Re: [PATCH] Diffcore updates.
From: Junio C Hamano @ 2005-05-22 16:47 UTC (permalink / raw)
To: Linus Torvalds; +Cc: git
In-Reply-To: <Pine.LNX.4.58.0505220939390.2307@ppc970.osdl.org>
>>>>> "LT" == Linus Torvalds <torvalds@osdl.org> writes:
LT> Maybe you should make "jit" warn about unadded files ;)
Sorry my bad. I do not run jit-status often enough.
^ permalink raw reply
* Re: [PATCH] Diffcore updates.
From: Linus Torvalds @ 2005-05-22 16:40 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
In-Reply-To: <7vbr73ha2c.fsf@assigned-by-dhcp.cox.net>
On Sun, 22 May 2005, Junio C Hamano wrote:
>
> Linus, this truly makes diff-tree with the pickaxe very pleasant to
> use. Please give it a try.
I can't. You split "diffcore_pathspec()" into a new common library file,
but you didn't add that to the archive, so your patch doesn't contain it.
Maybe you should make "jit" warn about unadded files ;)
Linus
^ permalink raw reply
* Re: cogito - how do I ???
From: Linus Torvalds @ 2005-05-22 16:23 UTC (permalink / raw)
To: Sam Ravnborg; +Cc: Sean, git
In-Reply-To: <20050522071435.GA10681@mars.ravnborg.org>
On Sun, 22 May 2005, Sam Ravnborg wrote:
>
> > > > 1) Something similar to "bk changes -R". I use this to see what has
> > > > happened upstream - to see if I really want to merge stuff.
> > >
> > > Not sure what bk did here, but you can do something like:
> > >
> > > cg-pull origin
> > > cg-log -c -r origin
> >
> > In the raw git interfaces, you'd basically have to do the same thing that
> > "git-pull-script" does, except that _instead_ of calling the
> > git-resolve-script thing, you'd do
> >
> > git-rev-tree MERGE_HEAD ^HEAD | git-diff-tree -v -m -s --stdin
> That looks ... long.
That's why people don't generally use git natively.
I want teach people what the "raw" interfaces are not because you're
supposed to use them, but because I expect that the raw ones are useful
for scripting.
> In bk the usage pattern was to check what was in mainline _before_
> fetching and merging.
In git (and cogito, although it's less obvious), the "fetching" is totally
separate from the "merging". In BK, the two were the same - you couldn't
merge without fetching, and you couldn't fetch without merging.
> So it seems that with git/cogoto one has to fetch the chages, inspect
> them, and then decide to apply or not.
Well, that's really what you ended up largely doing in BK too, since even
if it _looks_ like you first inspect them with "bk changes -R", the fact
is, in order to do that, you do have to _fetch_ the data first. It's just
that BK (a) fetched just the changeset changes (I think) and (b) then
threw the data away.
With git, you can also do the "fetch just the changeset changes", since if
you use "git-http-pull" you can instruct it to first _only_ fetch the
actual commits, and forget about the actual data. But since git considers
"fetching" and "merging" totally separate phases, it's up to your scripts
whether they leave the objects around or not afterwards. The normal
operaion is to leave everything around, since that means that if/when you
do decide to merge, you already have the data, and you don't need to
re-fetch.
If you decide to throw it away, you first remove the reference to the
stuff you pulled, and then use "git-prune-script" to get rid of the
objects you used. Right now that is admittedly quite expensive, it's
considered a "rare" thing to do (sicne even if you decide not to merge,
the extra objects never hurt - you can prune things once a week if you
care).
> When the fetches changes stay in MERGE_HEAD I assume my work when
> committed will be based on top of HEAD - so I do not have to know
> if I have fetched some (unmerged) updates.
Yes. Note that MERGE_HEAD ends up being just a totally temporary reference
to the top (that you decided not to merge). It has no meaning for git
itself, and the naming and meaning is purely as a git-pull-script (and
git-resolve-script) internal temporary thing.
> > And again, without the porcelain this is:
> >
> > git-diff-tree -v -p <name>
>
> The key here is the SHA1. I hoped to avoid specifying SHA1's with
> cogito, I so often miss one character when doing copy'n'paste.
You don't have to use the raw SHA1. git understands tags and references,
so for example, if you take the "fetch" part of git-pull-script (I really
should split it up into "git-fetch-script"), then you can, for example, do
git-diff-tree -v -p MERGE_HEAD
to see the top of the (unmerged) thing. Similarly, doing a
git-rev-list MERGE_HEAD | git-diff-tree --stdin -v -s
will give you the changelog for the unmerged side. No SHA1's necessary.
Of course, if you don't have a reference to the thing you want to look at,
you do need to figure out the SHA1 some way. But for example, gitk will
work fine for the unmerged stuff too - ie you can do
gitk MERGE_HEAD ^HEAD
_before_ you merge, and get all the nice graphical tools to inspect what
the hell there is that is new there..
Notice how this "fetch is independent of merge" thing thus means that you
can do a lot _more_ than "bk changes -R" ever did. But yes, it's a bit
more complex too (so normally you'd probably only use the porcelain
layer).
Linus
^ permalink raw reply
* running git-update-cache --refresh on different machines on a NFS share always ends up in a lot of io/cpu/time waste
From: Thomas Glanzmann @ 2005-05-22 12:28 UTC (permalink / raw)
To: GIT
Hello,
I wonder why 'git-update-cache --refresh' running in the same directory
shared via NFS ends up in reindexing the whole files when running on
different machines on a NFS share.
Is there a reason for this or can it easily be fixes. I also wonder if
the locking which is used to lock the cache is 'nfs safe'.
Thomas
^ permalink raw reply
* Re: Kernel nightly snapshots..
From: Thomas Glanzmann @ 2005-05-22 12:09 UTC (permalink / raw)
To: Git Mailing List
In-Reply-To: <1116763160.19183.15.camel@localhost.localdomain>
Hello,
> That should be done against the 2.6 kernel, and that tree is already
> available.
it is a shame that 2.6 doesn't even boot on this machine[1]. And even if
the patch doesn't do its way upstream its good to have something like
git available to to vendortracking.
Thomas
[1] http://bugzilla.kernel.org/show_bug.cgi?id=4415
^ permalink raw reply
* Re: Kernel nightly snapshots..
From: David Woodhouse @ 2005-05-22 11:59 UTC (permalink / raw)
To: Thomas Glanzmann; +Cc: Marcelo Tosatti, H. Peter Anvin, Git Mailing List
In-Reply-To: <20050522115038.GC15178@cip.informatik.uni-erlangen.de>
On Sun, 2005-05-22 at 13:50 +0200, Thomas Glanzmann wrote:
> do you have a timeframe? A friend of mine just asked me were to find the
> tree he wants to merge his jornada handheld pda stuff.
That should be done against the 2.6 kernel, and that tree is already
available.
--
dwmw2
^ permalink raw reply
* Re: Kernel nightly snapshots..
From: Thomas Glanzmann @ 2005-05-22 11:50 UTC (permalink / raw)
To: Marcelo Tosatti; +Cc: H. Peter Anvin, David Woodhouse, Git Mailing List
In-Reply-To: <20050506215142.GA15357@logos.cnet>
Hello,
> Not yet. I should be able to put a "beta" version
> next week.
do you have a timeframe? A friend of mine just asked me were to find the
tree he wants to merge his jornada handheld pda stuff.
Thomas
^ permalink raw reply
* [PATCH] Diffcore updates.
From: Junio C Hamano @ 2005-05-22 9:41 UTC (permalink / raw)
To: Linus Torvalds; +Cc: git
In-Reply-To: <7v1x80dluj.fsf@assigned-by-dhcp.cox.net>
Linus, this truly makes diff-tree with the pickaxe very pleasant to
use. Please give it a try.
------------
This patch moves the path selection logic from individual
programs to a new diffcore transformer (diff-tree still needs
to have its own for performance reasons). Also the header
printing code in diff-tree was tweaked not to produce anything
when pickaxe is in effect and there is nothing interesting to
report. An interesting example is the following in the GIT
archive itself:
$ git-whatchanged -p -C -S'or something in a real script'
Signed-off-by: Junio C Hamano <junkio@cox.net>
---
Makefile | 9 +--
diff-cache.c | 26 ++++++----
diff-files.c | 37 +++-----------
diff-helper.c | 16 +++---
diff-tree.c | 43 ++++++++--------
diff.c | 137 +++++++++++++++++++++--------------------------------
diff.h | 20 ++++---
diffcore-pickaxe.c | 15 ++---
diffcore-rename.c | 23 ++++++++
diffcore.h | 4 +
10 files changed, 162 insertions(+), 168 deletions(-)
diff --git a/Makefile b/Makefile
--- a/Makefile
+++ b/Makefile
@@ -45,7 +45,7 @@ LIB_H += strbuf.h
LIB_OBJS += strbuf.o
LIB_H += diff.h
-LIB_OBJS += diff.o diffcore-rename.o diffcore-pickaxe.o
+LIB_OBJS += diff.o diffcore-rename.o diffcore-pickaxe.o diffcore-pathspec.o
LIB_OBJS += gitenv.o
@@ -123,9 +123,10 @@ sha1_file.o: $(LIB_H)
usage.o: $(LIB_H)
strbuf.o: $(LIB_H)
gitenv.o: $(LIB_H)
-diff.o: $(LIB_H)
-diffcore-rename.o : $(LIB_H)
-diffcore-pickaxe.o : $(LIB_H)
+diff.o: $(LIB_H) diffcore.h
+diffcore-rename.o : $(LIB_H) diffcore.h
+diffcore-pathspec.o : $(LIB_H) diffcore.h
+diffcore-pickaxe.o : $(LIB_H) diffcore.h
test: all
make -C t/ all
diff --git a/diff-cache.c b/diff-cache.c
--- a/diff-cache.c
+++ b/diff-cache.c
@@ -71,7 +71,7 @@ static int show_modified(struct cache_en
oldmode = old->ce_mode;
if (mode == oldmode && !memcmp(sha1, old->sha1, 20) &&
- detect_rename < 2)
+ detect_rename < DIFF_DETECT_COPY)
return 0;
mode = ntohl(mode);
@@ -156,7 +156,7 @@ static void mark_merge_entries(void)
static char *diff_cache_usage =
"git-diff-cache [-p] [-r] [-z] [-m] [-M] [-C] [-R] [-S<string>] [--cached] <tree-ish>";
-int main(int argc, char **argv)
+int main(int argc, const char **argv)
{
unsigned char tree_sha1[20];
void *tree;
@@ -165,7 +165,7 @@ int main(int argc, char **argv)
read_cache();
while (argc > 2) {
- char *arg = argv[1];
+ const char *arg = argv[1];
argv++;
argc--;
if (!strcmp(arg, "-r")) {
@@ -177,12 +177,12 @@ int main(int argc, char **argv)
continue;
}
if (!strncmp(arg, "-M", 2)) {
- detect_rename = 1;
+ detect_rename = DIFF_DETECT_RENAME;
diff_score_opt = diff_scoreopt_parse(arg);
continue;
}
if (!strncmp(arg, "-C", 2)) {
- detect_rename = 2;
+ detect_rename = DIFF_DETECT_COPY;
diff_score_opt = diff_scoreopt_parse(arg);
continue;
}
@@ -209,10 +209,14 @@ int main(int argc, char **argv)
usage(diff_cache_usage);
}
- if (argc != 2 || get_sha1(argv[1], tree_sha1))
+ if (argc < 2 || get_sha1(argv[1], tree_sha1))
usage(diff_cache_usage);
+ argv++;
+ argc--;
- diff_setup(reverse_diff, diff_output_format);
+ /* The rest is for paths restriction. */
+
+ diff_setup(reverse_diff);
mark_merge_entries();
@@ -224,9 +228,11 @@ int main(int argc, char **argv)
ret = diff_cache(active_cache, active_nr);
if (detect_rename)
- diff_detect_rename(detect_rename, diff_score_opt);
+ diffcore_rename(detect_rename, diff_score_opt);
if (pickaxe)
- diff_pickaxe(pickaxe);
- diff_flush(NULL, 0);
+ diffcore_pickaxe(pickaxe);
+ if (2 <= argc)
+ diffcore_pathspec(argv + 1);
+ diff_flush(diff_output_format);
return ret;
}
diff --git a/diff-files.c b/diff-files.c
--- a/diff-files.c
+++ b/diff-files.c
@@ -16,21 +16,6 @@ static int diff_score_opt = 0;
static const char *pickaxe = NULL;
static int silent = 0;
-static int matches_pathspec(struct cache_entry *ce, char **spec, int cnt)
-{
- int i;
- int namelen = ce_namelen(ce);
- for (i = 0; i < cnt; i++) {
- int speclen = strlen(spec[i]);
- if (! strncmp(spec[i], ce->name, speclen) &&
- speclen <= namelen &&
- (ce->name[speclen] == 0 ||
- ce->name[speclen] == '/'))
- return 1;
- }
- return 0;
-}
-
static void show_unmerge(const char *path)
{
diff_unmerge(path);
@@ -48,7 +33,7 @@ static void show_modified(int oldmode, i
diff_change(oldmode, mode, old_sha1, sha1, path, NULL);
}
-int main(int argc, char **argv)
+int main(int argc, const char **argv)
{
static const unsigned char null_sha1[20] = { 0, };
int entries = read_cache();
@@ -71,11 +56,11 @@ int main(int argc, char **argv)
pickaxe = argv[1] + 2;
else if (!strncmp(argv[1], "-M", 2)) {
diff_score_opt = diff_scoreopt_parse(argv[1]);
- detect_rename = 1;
+ detect_rename = DIFF_DETECT_RENAME;
}
else if (!strncmp(argv[1], "-C", 2)) {
diff_score_opt = diff_scoreopt_parse(argv[1]);
- detect_rename = 2;
+ detect_rename = DIFF_DETECT_COPY;
}
else
usage(diff_files_usage);
@@ -90,7 +75,7 @@ int main(int argc, char **argv)
exit(1);
}
- diff_setup(reverse_diff, diff_output_format);
+ diff_setup(reverse_diff);
for (i = 0; i < entries; i++) {
struct stat st;
@@ -98,10 +83,6 @@ int main(int argc, char **argv)
struct cache_entry *ce = active_cache[i];
int changed;
- if (1 < argc &&
- ! matches_pathspec(ce, argv+1, argc-1))
- continue;
-
if (ce_stage(ce)) {
show_unmerge(ce->name);
while (i < entries &&
@@ -122,7 +103,7 @@ int main(int argc, char **argv)
continue;
}
changed = ce_match_stat(ce, &st);
- if (!changed && detect_rename < 2)
+ if (!changed && detect_rename < DIFF_DETECT_COPY)
continue;
oldmode = ntohl(ce->ce_mode);
@@ -133,9 +114,11 @@ int main(int argc, char **argv)
ce->name);
}
if (detect_rename)
- diff_detect_rename(detect_rename, diff_score_opt);
+ diffcore_rename(detect_rename, diff_score_opt);
if (pickaxe)
- diff_pickaxe(pickaxe);
- diff_flush(NULL, 0);
+ diffcore_pickaxe(pickaxe);
+ if (1 < argc)
+ diffcore_pathspec(argv + 1);
+ diff_flush(diff_output_format);
return 0;
}
diff --git a/diff-helper.c b/diff-helper.c
--- a/diff-helper.c
+++ b/diff-helper.c
@@ -77,11 +77,11 @@ int main(int ac, const char **av) {
else if (av[1][1] == 'P') /* hidden from the help */
diff_output_style = DIFF_FORMAT_MACHINE;
else if (av[1][1] == 'M') {
- detect_rename = 1;
+ detect_rename = DIFF_DETECT_RENAME;
diff_score_opt = diff_scoreopt_parse(av[1]);
}
else if (av[1][1] == 'C') {
- detect_rename = 2;
+ detect_rename = DIFF_DETECT_COPY;
diff_score_opt = diff_scoreopt_parse(av[1]);
}
else if (av[1][1] == 'S') {
@@ -93,7 +93,7 @@ int main(int ac, const char **av) {
}
/* the remaining parameters are paths patterns */
- diff_setup(reverse_diff, diff_output_style);
+ diff_setup(reverse_diff);
while (1) {
int status;
read_line(&sb1, stdin, line_termination);
@@ -121,14 +121,16 @@ int main(int ac, const char **av) {
status = parse_diff_raw(sb1.buf+1, NULL, NULL);
if (status) {
unrecognized:
- diff_flush(av+1, ac-1);
+ diff_flush(diff_output_style);
printf("%s%c", sb1.buf, line_termination);
}
}
if (detect_rename)
- diff_detect_rename(detect_rename, diff_score_opt);
+ diffcore_rename(detect_rename, diff_score_opt);
if (pickaxe)
- diff_pickaxe(pickaxe);
- diff_flush(av+1, ac-1);
+ diffcore_pickaxe(pickaxe);
+ if (ac)
+ diffcore_pathspec(av + 1);
+ diff_flush(diff_output_style);
return 0;
}
diff --git a/diff-tree.c b/diff-tree.c
--- a/diff-tree.c
+++ b/diff-tree.c
@@ -18,7 +18,7 @@ static const char *header_prefix = "";
// What paths are we interested in?
static int nr_paths = 0;
-static char **paths = NULL;
+static const char **paths = NULL;
static int *pathlens = NULL;
static int diff_tree_sha1(const unsigned char *old, const unsigned char *new, const char *base);
@@ -67,11 +67,6 @@ static void show_file(const char *prefix
const char *path;
const unsigned char *sha1 = extract(tree, size, &path, &mode);
- if (header) {
- printf("%s", header);
- header = NULL;
- }
-
if (silent)
return;
@@ -137,10 +132,6 @@ static int compare_tree_entry(void *tree
return retval;
}
- if (header) {
- printf("%s", header);
- header = NULL;
- }
if (silent)
return 0;
@@ -268,16 +259,28 @@ static int diff_tree_sha1(const unsigned
static void call_diff_setup(void)
{
- diff_setup(reverse_diff, diff_output_format);
+ diff_setup(reverse_diff);
}
-static void call_diff_flush(void)
+static int call_diff_flush()
{
if (detect_rename)
- diff_detect_rename(detect_rename, diff_score_opt);
- if (pickaxe)
- diff_pickaxe(pickaxe);
- diff_flush(NULL, 0);
+ diffcore_rename(detect_rename, diff_score_opt);
+ if (pickaxe) {
+ diffcore_pickaxe(pickaxe);
+ if (diff_queue_is_empty()) {
+ diff_flush(DIFF_FORMAT_NO_OUTPUT);
+ return 0;
+ }
+ }
+ if (nr_paths)
+ diffcore_pathspec(paths);
+ if (header) {
+ printf("%s", header);
+ header = NULL;
+ }
+ diff_flush(diff_output_format);
+ return 1;
}
static int diff_tree_sha1_top(const unsigned char *old,
@@ -462,7 +465,7 @@ static int diff_tree_stdin(char *line)
static char *diff_tree_usage =
"git-diff-tree [-p] [-r] [-z] [--stdin] [-M] [-C] [-R] [-S<string>] [-m] [-s] [-v] <tree-ish> <tree-ish>";
-int main(int argc, char **argv)
+int main(int argc, const char **argv)
{
int nr_sha1;
char line[1000];
@@ -470,7 +473,7 @@ int main(int argc, char **argv)
nr_sha1 = 0;
for (;;) {
- char *arg;
+ const char *arg;
argv++;
argc--;
@@ -509,12 +512,12 @@ int main(int argc, char **argv)
continue;
}
if (!strncmp(arg, "-M", 2)) {
- detect_rename = 1;
+ detect_rename = DIFF_DETECT_RENAME;
diff_score_opt = diff_scoreopt_parse(arg);
continue;
}
if (!strncmp(arg, "-C", 2)) {
- detect_rename = 2;
+ detect_rename = DIFF_DETECT_COPY;
diff_score_opt = diff_scoreopt_parse(arg);
continue;
}
diff --git a/diff.c b/diff.c
--- a/diff.c
+++ b/diff.c
@@ -16,8 +16,6 @@ static int reverse_diff;
static int generate_patch;
static int line_termination = '\n';
static int inter_name_termination = '\t';
-static const char **pathspec;
-static int speccnt;
static const char *external_diff(void)
{
@@ -286,6 +284,12 @@ int diff_populate_filespec(struct diff_f
return 0;
}
+void diff_free_filepair(struct diff_filepair *p)
+{
+ free(p->xfrm_msg);
+ free(p);
+}
+
void diff_free_filespec_data(struct diff_filespec *s)
{
if (s->should_free)
@@ -390,25 +394,6 @@ static void remove_tempfile_on_signal(in
remove_tempfile();
}
-static int matches_pathspec(const char *name)
-{
- int i;
- int namelen;
-
- if (speccnt == 0)
- return 1;
-
- namelen = strlen(name);
- for (i = 0; i < speccnt; i++) {
- int speclen = strlen(pathspec[i]);
- if (! strncmp(pathspec[i], name, speclen) &&
- speclen <= namelen &&
- (name[speclen] == 0 || name[speclen] == '/'))
- return 1;
- }
- return 0;
-}
-
/* An external diff command takes:
*
* diff-cmd name infile1 infile1-sha1 infile1-mode \
@@ -426,9 +411,6 @@ static void run_external_diff(const char
int status;
static int atexit_asked = 0;
- if (!matches_pathspec(name) && (!other || !matches_pathspec(other)))
- return;
-
if (one && two) {
prepare_temp_file(name, &temp[0], one);
prepare_temp_file(other ? : name, &temp[1], two);
@@ -496,47 +478,26 @@ static void run_external_diff(const char
remove_tempfile();
}
-int diff_scoreopt_parse(const char *opt)
+void diff_setup(int reverse_diff_)
{
- int diglen, num, scale, i;
- if (opt[0] != '-' || (opt[1] != 'M' && opt[1] != 'C'))
- return -1; /* that is not a -M nor -C option */
- diglen = strspn(opt+2, "0123456789");
- if (diglen == 0 || strlen(opt+2) != diglen)
- return 0; /* use default */
- sscanf(opt+2, "%d", &num);
- for (i = 0, scale = 1; i < diglen; i++)
- scale *= 10;
-
- /* user says num divided by scale and we say internally that
- * is MAX_SCORE * num / scale.
- */
- return MAX_SCORE * num / scale;
+ reverse_diff = reverse_diff_;
}
-void diff_setup(int reverse_diff_, int diff_output_style)
+struct diff_queue_struct diff_queued_diff;
+
+void diff_q(struct diff_queue_struct *queue, struct diff_filepair *dp)
{
- reverse_diff = reverse_diff_;
- generate_patch = 0;
- switch (diff_output_style) {
- case DIFF_FORMAT_HUMAN:
- line_termination = '\n';
- inter_name_termination = '\t';
- break;
- case DIFF_FORMAT_MACHINE:
- line_termination = inter_name_termination = 0;
- break;
- case DIFF_FORMAT_PATCH:
- generate_patch = 1;
- break;
+ if (queue->alloc <= queue->nr) {
+ queue->alloc = alloc_nr(queue->alloc);
+ queue->queue = xrealloc(queue->queue,
+ sizeof(dp) * queue->alloc);
}
+ queue->queue[queue->nr++] = dp;
}
-struct diff_queue_struct diff_queued_diff;
-
struct diff_filepair *diff_queue(struct diff_queue_struct *queue,
- struct diff_filespec *one,
- struct diff_filespec *two)
+ struct diff_filespec *one,
+ struct diff_filespec *two)
{
struct diff_filepair *dp = xmalloc(sizeof(*dp));
dp->one = one;
@@ -544,20 +505,16 @@ struct diff_filepair *diff_queue(struct
dp->xfrm_msg = 0;
dp->orig_order = queue->nr;
dp->xfrm_work = 0;
- if (queue->alloc <= queue->nr) {
- queue->alloc = alloc_nr(queue->alloc);
- queue->queue = xrealloc(queue->queue,
- sizeof(dp) * queue->alloc);
- }
- queue->queue[queue->nr++] = dp;
+ diff_q(queue, dp);
return dp;
}
static void diff_flush_raw(struct diff_filepair *p)
{
- /*
- * We used to reject rename/copy but new diff-raw can express them.
- */
+ if (DIFF_PAIR_UNMERGED(p)) {
+ printf("U %s%c", p->one->path, line_termination);
+ return;
+ }
printf(":%06o %06o %s ",
p->one->mode, p->two->mode, sha1_to_hex(p->one->sha1));
printf("%s%c%s%c%s%c",
@@ -576,19 +533,26 @@ static void diff_flush_patch(struct diff
(DIFF_FILE_VALID(p->two) && S_ISDIR(p->two->mode)))
return; /* no tree diffs in patch format */
- run_external_diff(name, other, p->one, p->two, p->xfrm_msg);
+ if (DIFF_PAIR_UNMERGED(p))
+ run_external_diff(name, NULL, NULL, NULL, NULL);
+ else
+ run_external_diff(name, other, p->one, p->two, p->xfrm_msg);
}
-static int identical(struct diff_filespec *one, struct diff_filespec *two)
+static int interesting(struct diff_filepair *p)
{
/* This function is written stricter than necessary to support
* the currently implemented transformers, but the idea is to
* let transformers to produce diff_filepairs any way they want,
* and filter and clean them up here before producing the output.
*/
+ struct diff_filespec *one, *two;
+
+ if (DIFF_PAIR_UNMERGED(p))
+ return 0; /* unmerged is interesting */
- if (!DIFF_FILE_VALID(one) && !DIFF_FILE_VALID(two))
- return 1; /* not interesting */
+ one = p->one;
+ two = p->two;
/* deletion, addition, mode change and renames are all interesting. */
if (DIFF_FILE_VALID(one) != DIFF_FILE_VALID(two) ||
@@ -609,7 +573,7 @@ static int identical(struct diff_filespe
static void diff_flush_one(struct diff_filepair *p)
{
- if (identical(p->one, p->two))
+ if (interesting(p))
return;
if (generate_patch)
diff_flush_patch(p);
@@ -624,23 +588,32 @@ int diff_queue_is_empty(void)
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
- if (!identical(p->one, p->two))
+ if (!interesting(p))
return 0;
}
return 1;
}
-void diff_flush(const char **pathspec_, int speccnt_)
+void diff_flush(int diff_output_style)
{
struct diff_queue_struct *q = &diff_queued_diff;
int i;
- pathspec = pathspec_;
- speccnt = speccnt_;
-
+ generate_patch = 0;
+ switch (diff_output_style) {
+ case DIFF_FORMAT_HUMAN:
+ line_termination = '\n';
+ inter_name_termination = '\t';
+ break;
+ case DIFF_FORMAT_MACHINE:
+ line_termination = inter_name_termination = 0;
+ break;
+ case DIFF_FORMAT_PATCH:
+ generate_patch = 1;
+ break;
+ }
for (i = 0; i < q->nr; i++)
diff_flush_one(q->queue[i]);
-
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
diff_free_filespec_data(p->one);
@@ -669,7 +642,7 @@ void diff_addremove(int addremove, unsig
* which but should not make any difference).
* Feeding the same new and old to diff_change() should
* also have the same effect. diff_flush() should
- * filter the identical ones out at the final output
+ * filter uninteresting ones out at the final output
* stage.
*/
if (reverse_diff)
@@ -739,8 +712,8 @@ void diff_change(unsigned old_mode, unsi
void diff_unmerge(const char *path)
{
- if (generate_patch)
- run_external_diff(path, NULL, NULL, NULL, NULL);
- else
- printf("U %s%c", path, line_termination);
+ struct diff_filespec *one, *two;
+ one = alloc_filespec(path);
+ two = alloc_filespec(path);
+ diff_queue(&diff_queued_diff, one, two);
}
diff --git a/diff.h b/diff.h
--- a/diff.h
+++ b/diff.h
@@ -26,16 +26,20 @@ extern void diff_unmerge(const char *pat
extern int diff_scoreopt_parse(const char *opt);
-#define DIFF_FORMAT_HUMAN 0
-#define DIFF_FORMAT_MACHINE 1
-#define DIFF_FORMAT_PATCH 2
-extern void diff_setup(int reverse, int diff_output_style);
-
-extern void diff_detect_rename(int, int);
-extern void diff_pickaxe(const char *);
+#define DIFF_FORMAT_HUMAN 0
+#define DIFF_FORMAT_MACHINE 1
+#define DIFF_FORMAT_PATCH 2
+#define DIFF_FORMAT_NO_OUTPUT 3
+extern void diff_setup(int reverse);
+
+#define DIFF_DETECT_RENAME 1
+#define DIFF_DETECT_COPY 2
+extern void diffcore_rename(int rename_copy, int minimum_score);
+extern void diffcore_pickaxe(const char *needle);
+extern void diffcore_pathspec(const char **pathspec);
extern int diff_queue_is_empty(void);
-extern void diff_flush(const char **, int);
+extern void diff_flush(int output_style);
#endif /* DIFF_H */
diff --git a/diffcore-pickaxe.c b/diffcore-pickaxe.c
--- a/diffcore-pickaxe.c
+++ b/diffcore-pickaxe.c
@@ -21,7 +21,7 @@ static int contains(struct diff_filespec
return 0;
}
-void diff_pickaxe(const char *needle)
+void diffcore_pickaxe(const char *needle)
{
struct diff_queue_struct *q = &diff_queued_diff;
unsigned long len = strlen(needle);
@@ -32,24 +32,23 @@ void diff_pickaxe(const char *needle)
for (i = 0; i < q->nr; i++) {
struct diff_filepair *p = q->queue[i];
+ int onum = outq.nr;
if (!DIFF_FILE_VALID(p->one)) {
if (!DIFF_FILE_VALID(p->two))
continue; /* ignore nonsense */
/* created */
if (contains(p->two, needle, len))
- diff_queue(&outq, p->one, p->two);
+ diff_q(&outq, p);
}
else if (!DIFF_FILE_VALID(p->two)) {
if (contains(p->one, needle, len))
- diff_queue(&outq, p->one, p->two);
+ diff_q(&outq, p);
}
else if (contains(p->one, needle, len) !=
contains(p->two, needle, len))
- diff_queue(&outq, p->one, p->two);
- }
- for (i = 0; i < q->nr; i++) {
- struct diff_filepair *p = q->queue[i];
- free(p);
+ diff_q(&outq, p);
+ if (onum == outq.nr)
+ diff_free_filepair(p);
}
free(q->queue);
*q = outq;
diff --git a/diffcore-rename.c b/diffcore-rename.c
--- a/diffcore-rename.c
+++ b/diffcore-rename.c
@@ -224,8 +224,25 @@ static int needs_to_stay(struct diff_que
return 0;
}
-void diff_detect_rename(int detect_rename,
- int minimum_score)
+int diff_scoreopt_parse(const char *opt)
+{
+ int diglen, num, scale, i;
+ if (opt[0] != '-' || (opt[1] != 'M' && opt[1] != 'C'))
+ return -1; /* that is not a -M nor -C option */
+ diglen = strspn(opt+2, "0123456789");
+ if (diglen == 0 || strlen(opt+2) != diglen)
+ return 0; /* use default */
+ sscanf(opt+2, "%d", &num);
+ for (i = 0, scale = 1; i < diglen; i++)
+ scale *= 10;
+
+ /* user says num divided by scale and we say internally that
+ * is MAX_SCORE * num / scale.
+ */
+ return MAX_SCORE * num / scale;
+}
+
+void diffcore_rename(int detect_rename, int minimum_score)
{
struct diff_queue_struct *q = &diff_queued_diff;
struct diff_queue_struct outq;
@@ -235,6 +252,8 @@ void diff_detect_rename(int detect_renam
int h, i, j;
int num_create, num_src, dst_cnt, src_cnt;
+ if (!minimum_score)
+ minimum_score = DEFAULT_MINIMUM_SCORE;
outq.queue = NULL;
outq.nr = outq.alloc = 0;
diff --git a/diffcore.h b/diffcore.h
--- a/diffcore.h
+++ b/diffcore.h
@@ -45,6 +45,8 @@ struct diff_filepair {
int orig_order; /* the original order of insertion into the queue */
int xfrm_work; /* for use by tramsformers, not by diffcore */
};
+#define DIFF_PAIR_UNMERGED(p) \
+ (!DIFF_FILE_VALID((p)->one) && !DIFF_FILE_VALID((p)->two))
struct diff_queue_struct {
struct diff_filepair **queue;
@@ -56,5 +58,7 @@ extern struct diff_queue_struct diff_que
extern struct diff_filepair *diff_queue(struct diff_queue_struct *,
struct diff_filespec *,
struct diff_filespec *);
+extern void diff_q(struct diff_queue_struct *, struct diff_filepair *);
+extern void diff_free_filepair(struct diff_filepair *);
#endif
------------------------------------------------
^ permalink raw reply
* [PATCH] Fix tweak in similarity estimator.
From: Junio C Hamano @ 2005-05-22 8:31 UTC (permalink / raw)
To: Linus Torvalds; +Cc: Git Mailing List
In-Reply-To: <7vis1bd9y4.fsf@assigned-by-dhcp.cox.net>
>>>>> "JCH" == Junio C Hamano <junkio@cox.net> writes:
JCH> Plain -C (or -M) not working was a bug I now understand why,
JCH> and I would not be surprised that -C10 may give ridiculous
JCH> or hilarious results (false hits), but I am having trouble
JCH> reproducing the -C90 case. Will do some more digging later.
An embarrasing math thinko was causing this confusion.
------------
Fix tweak in similarity estimator.
There was a screwy math bug in the estimator that confused what
-C1 meant and what -C9 meant, only in one of the early "cheap"
check, which resulted in quite confusing behaviour.
Signed-off-by: Junio C Hamano <junkio@cox.net>
---
diffcore-rename.c | 4 ++--
1 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/diffcore-rename.c b/diffcore-rename.c
--- a/diffcore-rename.c
+++ b/diffcore-rename.c
@@ -77,12 +77,12 @@ static int estimate_similarity(struct di
/* We would not consider edits that change the file size so
* drastically. delta_size must be smaller than
- * minimum_score/MAX_SCORE * min(src->size, dst->size).
+ * (MAX_SCORE-minimum_score)/MAX_SCORE * min(src->size, dst->size).
* Note that base_size == 0 case is handled here already
* and the final score computation below would not have a
* divide-by-zero issue.
*/
- if (base_size * minimum_score < delta_size * MAX_SCORE)
+ if (base_size * (MAX_SCORE-minimum_score) < delta_size * MAX_SCORE)
return 0;
delta = diff_delta(src->data, src->size,
^ permalink raw reply
* Re: cogito - how do I ???
From: Sam Ravnborg @ 2005-05-22 7:14 UTC (permalink / raw)
To: Linus Torvalds; +Cc: Sean, git
In-Reply-To: <Pine.LNX.4.58.0505211635440.2206@ppc970.osdl.org>
> > > 1) Something similar to "bk changes -R". I use this to see what has
> > > happened upstream - to see if I really want to merge stuff.
> >
> > Not sure what bk did here, but you can do something like:
> >
> > cg-pull origin
> > cg-log -c -r origin
>
> In the raw git interfaces, you'd basically have to do the same thing that
> "git-pull-script" does, except that _instead_ of calling the
> git-resolve-script thing, you'd do
>
> git-rev-tree MERGE_HEAD ^HEAD | git-diff-tree -v -m -s --stdin
That looks ... long.
I can teach my fingers to use: cg-log, but the above is just too much
to type/remeber do a daily operation.
In bk the usage pattern was to check what was in mainline _before_
fetching and merging. So it seems that with git/cogoto one
has to fetch the chages, inspect them, and then decide to apply or not.
When the fetches changes stay in MERGE_HEAD I assume my work when
committed will be based on top of HEAD - so I do not have to know
if I have fetched some (unmerged) updates.
> to show what is in the downloaded MERGE_HEAD but not in HEAD.
>
> > > 2) Export of individual patches. "bk export -tpatch -r1.2345"
> > > I have nu public git repository yet so I have to feed changes as
> > > plain patches. Browsing cg-* I did not find the command to do this.
> >
> > cg-diff -p -r SHA1
>
> And again, without the porcelain this is:
>
> git-diff-tree -v -p <name>
The key here is the SHA1. I hoped to avoid specifying SHA1's with
cogito, I so often miss one character when doing copy'n'paste.
Thanks all for the replies. Now I feel a bit more confident in this.
Sam
^ permalink raw reply
* seek request
From: Zack Brown @ 2005-05-22 7:11 UTC (permalink / raw)
To: Git Mailing List
Hi folks,
In Cogito, it would be nice to have a
cg-seek +
that would seek to the next archive state. This way, I could start off seeking
back to the beginning of an archive, and quickly step forward, looking at files
as I went, to the present.
A corresponding
cg-seek -
would go the reverse direction, back toward the beginning of a project.
I'm not sure how useful this would be for actual source code - I suspect any
benefit would be minimal - but the benefit for documentation and text files,
where the only way to test improvements is to read them by eye, would be
significant.
Be well,
Zack
--
Zack Brown
^ permalink raw reply
* Re: [PATCH] The diff-raw format updates.
From: Junio C Hamano @ 2005-05-22 6:57 UTC (permalink / raw)
To: Linus Torvalds; +Cc: Git Mailing List
In-Reply-To: <Pine.LNX.4.58.0505212253350.2206@ppc970.osdl.org>
>>>>> "LT" == Linus Torvalds <torvalds@osdl.org> writes:
LT> Doing "-C50" to ask for at least 50% similarity makes it ok (and it finds
LT> the "git-pull-script" -> "git-resolve-script" thing), but there's
LT> something strange going on, becuase -C10 and -C90 don't work, even if -C40
LT> and -C50 _do_ work.
Plain -C (or -M) not working was a bug I now understand why,
and I would not be surprised that -C10 may give ridiculous
or hilarious results (false hits), but I am having trouble
reproducing the -C90 case. Will do some more digging later.
^ permalink raw reply
* Re: [PATCH] The diff-raw format updates.
From: Junio C Hamano @ 2005-05-22 6:33 UTC (permalink / raw)
To: Linus Torvalds; +Cc: Git Mailing List
In-Reply-To: <Pine.LNX.4.58.0505212253350.2206@ppc970.osdl.org>
>>>>> "LT" == Linus Torvalds <torvalds@osdl.org> writes:
LT> On Sat, 21 May 2005, Junio C Hamano wrote:
>>
>> Update the diff-raw format as Linus and I discussed, except that
>> it does not use sequence of underscore '_' letters to express
>> nonexistence. All '0' mode is used for that purpose instead.
LT> Ok, it all looks very nice, but it looks like -C is still broken ;)
Well it is not _still_ broken, but rather was introduced by the
code reorganization to expose diff_rename_detect(). Sorry about
the lack of testing.
------------
Add the code to set default minimum score back in.
When the minimum score is specified as 0 (meaning "use default
value"), set it to the default as we are told.
Signed-off-by: Junio C Hamano <junkio@cox.net>
---
$ jit-diff
# - linus: [PATCH] The diff-raw format updates.
# + (working tree)
diff --git a/diffcore-rename.c b/diffcore-rename.c
--- a/diffcore-rename.c
+++ b/diffcore-rename.c
@@ -235,6 +235,8 @@ void diff_detect_rename(int detect_renam
int h, i, j;
int num_create, num_src, dst_cnt, src_cnt;
+ if (!minimum_score)
+ minimum_score = DEFAULT_MINIMUM_SCORE;
outq.queue = NULL;
outq.nr = outq.alloc = 0;
^ permalink raw reply
* Re: [PATCH] The diff-raw format updates.
From: Linus Torvalds @ 2005-05-22 6:01 UTC (permalink / raw)
To: Junio C Hamano; +Cc: Git Mailing List
In-Reply-To: <7vvf5cc779.fsf_-_@assigned-by-dhcp.cox.net>
On Sat, 21 May 2005, Junio C Hamano wrote:
>
> Update the diff-raw format as Linus and I discussed, except that
> it does not use sequence of underscore '_' letters to express
> nonexistence. All '0' mode is used for that purpose instead.
Ok, it all looks very nice, but it looks like -C is still broken ;)
Do
git-whatchanged -C -p
and you'll see this hilarious entry as the first "copy" entry:
diff --git a/Documentation/git-diff-cache.txt b/diffcore-pickaxe.c
similarity index 0%
copy from Documentation/git-diff-cache.txt
copy to diffcore-pickaxe.c
--- a/Documentation/git-diff-cache.txt
+++ b/diffcore-pickaxe.c
@@ -1,150 +1,56 @@
..
it even says "similarity index 0%", adn that sure is accurate ;)
Doing "-C50" to ask for at least 50% similarity makes it ok (and it finds
the "git-pull-script" -> "git-resolve-script" thing), but there's
something strange going on, becuase -C10 and -C90 don't work, even if -C40
and -C50 _do_ work.
Linus
^ permalink raw reply
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox