* git-fmt-merge-msg cleanup
From: Linus Torvalds @ 2006-03-09 1:56 UTC (permalink / raw)
To: Junio C Hamano, Git Mailing List
Since I've started using the "merge.summary" flag in my repo, my merge
messages look nicer, but I dislike how I get notifications of merges
within merges.
So I'd suggest this trivial change..
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
----
diff --git a/git-fmt-merge-msg.perl b/git-fmt-merge-msg.perl
index dae383f..afe80e6 100755
--- a/git-fmt-merge-msg.perl
+++ b/git-fmt-merge-msg.perl
@@ -47,7 +47,7 @@ sub current_branch {
sub shortlog {
my ($tip) = @_;
my @result;
- foreach ( qx{git-log --topo-order --pretty=oneline $tip ^HEAD} ) {
+ foreach ( qx{git-log --no-merges --topo-order --pretty=oneline $tip ^HEAD} ) {
s/^[0-9a-f]{40}\s+//;
push @result, $_;
}
^ permalink raw reply related
* Re: [PATCH 0/3] Teach git-blame about renames
From: Junio C Hamano @ 2006-03-09 0:27 UTC (permalink / raw)
To: Fredrik Kuivinen; +Cc: git
In-Reply-To: <20060308225412.GA461@c165.ib.student.liu.se>
Fredrik Kuivinen <freku045@student.liu.se> writes:
(from part 1/3)
> +void default_setter(struct commit* c, void* data)
> +{
> + c->object.util = data;
> +}
> +
> +void* default_getter(struct commit* c)
> +{
> + return c->object.util;
> +}
> +
These names are too generic to be used as a global.
The rest of the git code tends to say "void *default_getter()".
(from part 2/3)
> @@ -224,7 +224,7 @@ static struct commit_list *find_bisectio
> nr = 0;
> p = list;
> while (p) {
> - if (!revs.paths || (p->item->object.flags & TREECHANGE))
> + if (!revs.prune_data || (p->item->object.flags & TREECHANGE))
> nr++;
> p = p->next;
> }
Here you test with revs.prune_data, but the rest you test with
revs.prune_fn. It is conceivable that some prune_fn could be
written without using prune_data, so I'd suggest to check
consistently with prune_fn.
> -static int compare_tree(struct tree *t1, struct tree *t2)
> +int compare_tree(struct tree *t1, struct tree *t2)
> ...
> -static int same_tree_as_empty(struct tree *t1)
> +int same_tree_as_empty(struct tree *t1)
Maybe the names are a bit too generic to be used as a global?
> - if (revs->paths)
> + /* if (revs->paths)
> try_to_simplify_commit(revs, commit);
> + */
Leftover commenting.
(from part 3/3)
> - struct util_info *util;
> - if (commit->object.util)
> - return 0;
> + struct util_info *util = commit->object.util;
> +
> + if(util)
> + return util;
The rest of the git code tends to say "if (util)".
^ permalink raw reply
* [PATCH 3/3] blame: Rename detection
From: Fredrik Kuivinen @ 2006-03-08 23:00 UTC (permalink / raw)
To: git; +Cc: junkio
In-Reply-To: <20060308225412.GA461@c165.ib.student.liu.se>
Signed-off-by: Fredrik Kuivinen <freku045@student.liu.se>
---
The output format could certainly be improved. Any suggestions?
blame.c | 239 ++++++++++++++++++++++++++++++++++++++++++++++++++++-----------
1 files changed, 199 insertions(+), 40 deletions(-)
diff --git a/blame.c b/blame.c
index 90338af..2cc4c96 100644
--- a/blame.c
+++ b/blame.c
@@ -14,6 +14,7 @@
#include "tree.h"
#include "blob.h"
#include "diff.h"
+#include "diffcore.h"
#include "revision.h"
#define DEBUG 0
@@ -34,7 +35,9 @@ struct util_info {
char *buf;
unsigned long size;
int num_lines;
-// const char* path;
+ const char* pathname;
+
+ void* topo_data;
};
struct chunk {
@@ -342,25 +345,34 @@ static int map_line(struct commit *commi
return info->line_map[line];
}
-static int fill_util_info(struct commit *commit, const char *path)
+static struct util_info* get_util(struct commit *commit)
{
- struct util_info *util;
- if (commit->object.util)
- return 0;
+ struct util_info *util = commit->object.util;
+
+ if(util)
+ return util;
util = xmalloc(sizeof(struct util_info));
+ util->buf = NULL;
+ util->size = 0;
+ util->line_map = NULL;
+ util->num_lines = -1;
+ util->pathname = NULL;
+ commit->object.util = util;
+ return util;
+}
+
+static int fill_util_info(struct commit *commit)
+{
+ struct util_info *util = commit->object.util;
- if (get_blob_sha1(commit->tree, path, util->sha1)) {
- free(util);
+ assert(util);
+ assert(util->pathname);
+
+ if (get_blob_sha1(commit->tree, util->pathname, util->sha1))
return 1;
- } else {
- util->buf = NULL;
- util->size = 0;
- util->line_map = NULL;
- util->num_lines = -1;
- commit->object.util = util;
+ else
return 0;
- }
}
static void alloc_line_map(struct commit *commit)
@@ -389,10 +401,11 @@ static void alloc_line_map(struct commit
static void init_first_commit(struct commit* commit, const char* filename)
{
- struct util_info* util;
+ struct util_info* util = commit->object.util;
int i;
- if (fill_util_info(commit, filename))
+ util->pathname = filename;
+ if (fill_util_info(commit))
die("fill_util_info failed");
alloc_line_map(commit);
@@ -453,7 +466,7 @@ static void process_commits(struct rev_i
if(num_parents == 0)
*initial = commit;
- if(fill_util_info(commit, path))
+ if(fill_util_info(commit))
continue;
alloc_line_map(commit);
@@ -471,7 +484,7 @@ static void process_commits(struct rev_i
printf("parent: %s\n",
sha1_to_hex(parent->object.sha1));
- if(fill_util_info(parent, path)) {
+ if(fill_util_info(parent)) {
num_parents--;
continue;
}
@@ -511,6 +524,135 @@ static void process_commits(struct rev_i
} while ((commit = get_revision(rev)) != NULL);
}
+
+static int compare_tree_path(struct rev_info* revs,
+ struct commit* c1, struct commit* c2)
+{
+ const char* paths[2];
+ struct util_info* util = c2->object.util;
+ paths[0] = util->pathname;
+ paths[1] = NULL;
+
+ diff_tree_setup_paths(get_pathspec(revs->prefix, paths));
+ return compare_tree(c1->tree, c2->tree);
+}
+
+
+static int same_tree_as_empty_path(struct rev_info *revs, struct tree* t1,
+ const char* path)
+{
+ const char* paths[2];
+ paths[0] = path;
+ paths[1] = NULL;
+
+ diff_tree_setup_paths(get_pathspec(revs->prefix, paths));
+ return same_tree_as_empty(t1);
+}
+
+static const char* find_rename(struct commit* commit, struct commit* parent)
+{
+ struct util_info* cutil = commit->object.util;
+ struct diff_options diff_opts;
+ const char *paths[1];
+ int i;
+
+ if(DEBUG) {
+ printf("find_rename commit: %s ",
+ sha1_to_hex(commit->object.sha1));
+ puts(sha1_to_hex(parent->object.sha1));
+ }
+
+ diff_setup(&diff_opts);
+ diff_opts.recursive = 1;
+ diff_opts.detect_rename = DIFF_DETECT_RENAME;
+ paths[0] = NULL;
+ diff_tree_setup_paths(paths);
+ if(diff_setup_done(&diff_opts) < 0)
+ die("diff_setup_done failed");
+
+ diff_tree_sha1(commit->tree->object.sha1, parent->tree->object.sha1,
+ "", &diff_opts);
+ diffcore_std(&diff_opts);
+
+ for(i = 0; i < diff_queued_diff.nr; i++) {
+ struct diff_filepair *p = diff_queued_diff.queue[i];
+
+ if(p->status == 'R' && !strcmp(p->one->path, cutil->pathname)) {
+ if(DEBUG)
+ printf("rename %s -> %s\n", p->one->path, p->two->path);
+ return p->two->path;
+ }
+ }
+
+ return 0;
+}
+
+static void simplify_commit(struct rev_info *revs, struct commit *commit)
+{
+ struct commit_list **pp, *parent;
+
+ if (!commit->tree)
+ return;
+
+ if (!commit->parents) {
+ struct util_info* util = commit->object.util;
+ if (!same_tree_as_empty_path(revs, commit->tree,
+ util->pathname))
+ commit->object.flags |= TREECHANGE;
+ return;
+ }
+
+ pp = &commit->parents;
+ while ((parent = *pp) != NULL) {
+ struct commit *p = parent->item;
+
+ if (p->object.flags & UNINTERESTING) {
+ pp = &parent->next;
+ continue;
+ }
+
+ parse_commit(p);
+ switch (compare_tree_path(revs, p, commit)) {
+ case TREE_SAME:
+ parent->next = NULL;
+ commit->parents = parent;
+ get_util(p)->pathname = get_util(commit)->pathname;
+ return;
+
+ case TREE_NEW:
+ {
+
+ struct util_info* util = commit->object.util;
+ if (revs->remove_empty_trees &&
+ same_tree_as_empty_path(revs, p->tree,
+ util->pathname)) {
+ const char* new_name = find_rename(commit, p);
+ if(new_name) {
+ struct util_info* putil = get_util(p);
+ if(!putil->pathname)
+ putil->pathname = strdup(new_name);
+ } else {
+ *pp = parent->next;
+ continue;
+ }
+ }
+ }
+
+ /* fallthrough */
+ case TREE_DIFFERENT:
+ pp = &parent->next;
+ if(!get_util(p)->pathname)
+ get_util(p)->pathname =
+ get_util(commit)->pathname;
+ continue;
+ }
+ die("bad tree compare for commit %s",
+ sha1_to_hex(commit->object.sha1));
+ }
+ commit->object.flags |= TREECHANGE;
+}
+
+
struct commit_info
{
char* author;
@@ -569,6 +711,18 @@ static const char* format_time(unsigned
return time_buf;
}
+static void topo_setter(struct commit* c, void* data)
+{
+ struct util_info* util = c->object.util;
+ util->topo_data = data;
+}
+
+static void* topo_getter(struct commit* c)
+{
+ struct util_info* util = c->object.util;
+ return util->topo_data;
+}
+
int main(int argc, const char **argv)
{
int i;
@@ -580,8 +734,8 @@ int main(int argc, const char **argv)
int sha1_len = 8;
int compability = 0;
int options = 1;
+ struct commit* start_commit;
- int num_args;
const char* args[10];
struct rev_info rev;
@@ -634,28 +788,29 @@ int main(int argc, const char **argv)
strcpy(filename_buf, filename);
filename = filename_buf;
- {
- struct commit* c;
- if (get_sha1(commit, sha1))
- die("get_sha1 failed, commit '%s' not found", commit);
- c = lookup_commit_reference(sha1);
-
- if (fill_util_info(c, filename)) {
- printf("%s not found in %s\n", filename, commit);
- return 1;
- }
+ if (get_sha1(commit, sha1))
+ die("get_sha1 failed, commit '%s' not found", commit);
+ start_commit = lookup_commit_reference(sha1);
+ get_util(start_commit)->pathname = filename;
+ if (fill_util_info(start_commit)) {
+ printf("%s not found in %s\n", filename, commit);
+ return 1;
}
- num_args = 0;
- args[num_args++] = NULL;
- args[num_args++] = "--topo-order";
- args[num_args++] = "--remove-empty";
- args[num_args++] = commit;
- args[num_args++] = "--";
- args[num_args++] = filename;
- args[num_args] = NULL;
- setup_revisions(num_args, args, &rev, "HEAD");
+ init_revisions(&rev);
+ rev.remove_empty_trees = 1;
+ rev.topo_order = 1;
+ rev.prune_fn = simplify_commit;
+ rev.topo_setter = topo_setter;
+ rev.topo_getter = topo_getter;
+ rev.limited = 1;
+
+ commit_list_insert(start_commit, &rev.commits);
+
+ args[0] = filename;
+ args[1] = NULL;
+ diff_tree_setup_paths(args);
prepare_revision_walk(&rev);
process_commits(&rev, filename, &initial);
@@ -665,17 +820,21 @@ int main(int argc, const char **argv)
for (i = 0; i < num_blame_lines; i++) {
struct commit *c = blame_lines[i];
+ struct util_info* u;
+
if (!c)
c = initial;
+ u = c->object.util;
get_commit_info(c, &ci);
fwrite(sha1_to_hex(c->object.sha1), sha1_len, 1, stdout);
if(compability)
printf("\t(%10s\t%10s\t%d)", ci.author,
format_time(ci.author_time, ci.author_tz), i+1);
else
- printf(" (%-15.15s %10s %*d) ", ci.author,
- format_time(ci.author_time, ci.author_tz),
+ printf(" %s (%-15.15s %10s %*d) ", u->pathname,
+ ci.author, format_time(ci.author_time,
+ ci.author_tz),
max_digits, i+1);
if(i == num_blame_lines - 1) {
^ permalink raw reply related
* [PATCH 2/3] rev-lib: Make it easy to do rename tracking
From: Fredrik Kuivinen @ 2006-03-08 22:59 UTC (permalink / raw)
To: git; +Cc: junkio
In-Reply-To: <20060308225412.GA461@c165.ib.student.liu.se>
prune_fn in the rev_info structure is called in place of
try_to_simplify_commit. This makes it possible to do rename tracking
with a custom try_to_simplify_commit-like function.
This commit also introduces init_revisions which initialises the rev_info
structure with default values.
Signed-off-by: Fredrik Kuivinen <freku045@student.liu.se>
---
rev-list.c | 6 +++---
revision.c | 59 +++++++++++++++++++++++++++++++++++++----------------------
revision.h | 20 +++++++++++++++++++-
3 files changed, 59 insertions(+), 26 deletions(-)
diff --git a/rev-list.c b/rev-list.c
index 8e4d83e..83a8ec2 100644
--- a/rev-list.c
+++ b/rev-list.c
@@ -190,7 +190,7 @@ static int count_distance(struct commit_
if (commit->object.flags & (UNINTERESTING | COUNTED))
break;
- if (!revs.paths || (commit->object.flags & TREECHANGE))
+ if (!revs.prune_data || (commit->object.flags & TREECHANGE))
nr++;
commit->object.flags |= COUNTED;
p = commit->parents;
@@ -224,7 +224,7 @@ static struct commit_list *find_bisectio
nr = 0;
p = list;
while (p) {
- if (!revs.paths || (p->item->object.flags & TREECHANGE))
+ if (!revs.prune_data || (p->item->object.flags & TREECHANGE))
nr++;
p = p->next;
}
@@ -234,7 +234,7 @@ static struct commit_list *find_bisectio
for (p = list; p; p = p->next) {
int distance;
- if (revs.paths && !(p->item->object.flags & TREECHANGE))
+ if (revs.prune_data && !(p->item->object.flags & TREECHANGE))
continue;
distance = count_distance(p);
diff --git a/revision.c b/revision.c
index 2a33637..991dfe8 100644
--- a/revision.c
+++ b/revision.c
@@ -197,9 +197,6 @@ static int everybody_uninteresting(struc
return 1;
}
-#define TREE_SAME 0
-#define TREE_NEW 1
-#define TREE_DIFFERENT 2
static int tree_difference = TREE_SAME;
static void file_add_remove(struct diff_options *options,
@@ -241,7 +238,7 @@ static struct diff_options diff_opt = {
.change = file_change,
};
-static int compare_tree(struct tree *t1, struct tree *t2)
+int compare_tree(struct tree *t1, struct tree *t2)
{
if (!t1)
return TREE_NEW;
@@ -253,7 +250,7 @@ static int compare_tree(struct tree *t1,
return tree_difference;
}
-static int same_tree_as_empty(struct tree *t1)
+int same_tree_as_empty(struct tree *t1)
{
int retval;
void *tree;
@@ -321,6 +318,7 @@ static void try_to_simplify_commit(struc
commit->object.flags |= TREECHANGE;
}
+
static void add_parents_to_list(struct rev_info *revs, struct commit *commit, struct commit_list **list)
{
struct commit_list *parent = commit->parents;
@@ -358,8 +356,11 @@ static void add_parents_to_list(struct r
* simplify the commit history and find the parent
* that has no differences in the path set if one exists.
*/
- if (revs->paths)
+ /* if (revs->paths)
try_to_simplify_commit(revs, commit);
+ */
+ if (revs->prune_fn)
+ revs->prune_fn(revs, commit);
parent = commit->parents;
while (parent) {
@@ -381,9 +382,6 @@ static void limit_list(struct rev_info *
struct commit_list *newlist = NULL;
struct commit_list **p = &newlist;
- if (revs->paths)
- diff_tree_setup_paths(revs->paths);
-
while (list) {
struct commit_list *entry = list;
struct commit *commit = list->item;
@@ -435,6 +433,24 @@ static void handle_all(struct rev_info *
for_each_ref(handle_one_ref);
}
+
+void init_revisions(struct rev_info *revs)
+{
+ memset(revs, 0, sizeof(*revs));
+ revs->lifo = 1;
+ revs->dense = 1;
+ revs->prefix = setup_git_directory();
+ revs->max_age = -1;
+ revs->min_age = -1;
+ revs->max_count = -1;
+
+ revs->prune_fn = NULL;
+ revs->prune_data = NULL;
+
+ revs->topo_setter = default_setter;
+ revs->topo_getter = default_getter;
+}
+
/*
* Parse revision information, filling in the "rev_info" structure,
* and removing the used arguments from the argument list.
@@ -448,14 +464,8 @@ int setup_revisions(int argc, const char
const char **unrecognized = argv + 1;
int left = 1;
- memset(revs, 0, sizeof(*revs));
- revs->lifo = 1;
- revs->dense = 1;
- revs->prefix = setup_git_directory();
- revs->max_age = -1;
- revs->min_age = -1;
- revs->max_count = -1;
-
+ init_revisions(revs);
+
/* First, search for "--" */
seen_dashdash = 0;
for (i = 1; i < argc; i++) {
@@ -464,7 +474,7 @@ int setup_revisions(int argc, const char
continue;
argv[i] = NULL;
argc = i;
- revs->paths = get_pathspec(revs->prefix, argv + i + 1);
+ revs->prune_data = get_pathspec(revs->prefix, argv + i + 1);
seen_dashdash = 1;
break;
}
@@ -628,7 +638,7 @@ int setup_revisions(int argc, const char
if (lstat(argv[j], &st) < 0)
die("'%s': %s", arg, strerror(errno));
}
- revs->paths = get_pathspec(revs->prefix, argv + i);
+ revs->prune_data = get_pathspec(revs->prefix, argv + i);
break;
}
commit = get_commit_reference(revs, arg, sha1, flags ^ local_flags);
@@ -642,8 +652,13 @@ int setup_revisions(int argc, const char
commit = get_commit_reference(revs, def, sha1, 0);
add_one_commit(commit, revs);
}
- if (revs->paths)
+
+ if (revs->prune_data) {
+ diff_tree_setup_paths(revs->prune_data);
+ revs->prune_fn = try_to_simplify_commit;
revs->limited = 1;
+ }
+
return left;
}
@@ -653,7 +668,7 @@ void prepare_revision_walk(struct rev_in
if (revs->limited)
limit_list(revs);
if (revs->topo_order)
- sort_in_topological_order(&revs->commits, revs->lifo);
+ sort_in_topological_order_fun(&revs->commits, revs->lifo, revs->topo_setter, revs->topo_getter);
}
static int rewrite_one(struct commit **pp)
@@ -709,7 +724,7 @@ struct commit *get_revision(struct rev_i
return NULL;
if (revs->no_merges && commit->parents && commit->parents->next)
goto next;
- if (revs->paths && revs->dense) {
+ if (revs->prune_fn && revs->dense) {
if (!(commit->object.flags & TREECHANGE))
goto next;
rewrite_parents(commit);
diff --git a/revision.h b/revision.h
index 31e8f61..510d936 100644
--- a/revision.h
+++ b/revision.h
@@ -7,6 +7,10 @@
#define SHOWN (1u<<3)
#define TMP_MARK (1u<<4) /* for isolated cases; clean after use */
+struct rev_info;
+
+typedef void (prune_fn_t)(struct rev_info *revs, struct commit *commit);
+
struct rev_info {
/* Starting list */
struct commit_list *commits;
@@ -14,7 +18,9 @@ struct rev_info {
/* Basic information */
const char *prefix;
- const char **paths;
+
+ void* prune_data;
+ prune_fn_t* prune_fn;
/* Traversal flags */
unsigned int dense:1,
@@ -33,9 +39,21 @@ struct rev_info {
int max_count;
unsigned long max_age;
unsigned long min_age;
+
+ set_fn_t topo_setter;
+ get_fn_t topo_getter;
};
+#define TREE_SAME 0
+#define TREE_NEW 1
+#define TREE_DIFFERENT 2
+
/* revision.c */
+extern int same_tree_as_empty(struct tree *t1);
+extern int compare_tree(struct tree *t1, struct tree *t2);
+
+
+extern void init_revisions(struct rev_info *revs);
extern int setup_revisions(int argc, const char **argv, struct rev_info *revs, const char *def);
extern void prepare_revision_walk(struct rev_info *revs);
extern struct commit *get_revision(struct rev_info *revs);
^ permalink raw reply related
* [PATCH 1/3] Make it possible to not clobber object.util in sort_in_topological_order
From: Fredrik Kuivinen @ 2006-03-08 22:59 UTC (permalink / raw)
To: git; +Cc: junkio
In-Reply-To: <20060308225412.GA461@c165.ib.student.liu.se>
Signed-off-by: Fredrik Kuivinen <freku045@student.liu.se>
---
commit.c | 27 +++++++++++++++++++++------
commit.h | 9 +++++++++
2 files changed, 30 insertions(+), 6 deletions(-)
diff --git a/commit.c b/commit.c
index 06d5439..2552ffd 100644
--- a/commit.c
+++ b/commit.c
@@ -569,11 +569,26 @@ int count_parents(struct commit * commit
return count;
}
+void default_setter(struct commit* c, void* data)
+{
+ c->object.util = data;
+}
+
+void* default_getter(struct commit* c)
+{
+ return c->object.util;
+}
+
/*
* Performs an in-place topological sort on the list supplied.
*/
void sort_in_topological_order(struct commit_list ** list, int lifo)
{
+ sort_in_topological_order_fun(list, lifo, default_setter, default_getter);
+}
+
+void sort_in_topological_order_fun(struct commit_list ** list, int lifo, set_fn_t setter, get_fn_t getter)
+{
struct commit_list * next = *list;
struct commit_list * work = NULL, **insert;
struct commit_list ** pptr = list;
@@ -596,7 +611,7 @@ void sort_in_topological_order(struct co
next=*list;
while (next) {
next_nodes->list_item = next;
- next->item->object.util = next_nodes;
+ setter(next->item, next_nodes);
next_nodes++;
next = next->next;
}
@@ -606,7 +621,7 @@ void sort_in_topological_order(struct co
struct commit_list * parents = next->item->parents;
while (parents) {
struct commit * parent=parents->item;
- struct sort_node * pn = (struct sort_node *)parent->object.util;
+ struct sort_node * pn = (struct sort_node *) getter(parent);
if (pn)
pn->indegree++;
@@ -624,7 +639,7 @@ void sort_in_topological_order(struct co
next=*list;
insert = &work;
while (next) {
- struct sort_node * node = (struct sort_node *)next->item->object.util;
+ struct sort_node * node = (struct sort_node *) getter(next->item);
if (node->indegree == 0) {
insert = &commit_list_insert(next->item, insert)->next;
@@ -637,12 +652,12 @@ void sort_in_topological_order(struct co
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;
+ struct sort_node * work_node = (struct sort_node *) getter(work_item);
struct commit_list * parents = work_item->parents;
while (parents) {
struct commit * parent=parents->item;
- struct sort_node * pn = (struct sort_node *)parent->object.util;
+ struct sort_node * pn = (struct sort_node *) getter(parent);
if (pn) {
/*
@@ -667,7 +682,7 @@ void sort_in_topological_order(struct co
*pptr = work_node->list_item;
pptr = &(*pptr)->next;
*pptr = NULL;
- work_item->object.util = NULL;
+ setter(work_item, NULL);
}
free(nodes);
}
diff --git a/commit.h b/commit.h
index 70a7c75..0be61eb 100644
--- a/commit.h
+++ b/commit.h
@@ -76,4 +76,13 @@ int count_parents(struct commit * commit
* sorted in the dates order.
*/
void sort_in_topological_order(struct commit_list ** list, int lifo);
+
+typedef void (*set_fn_t)(struct commit*, void* data);
+typedef void* (*get_fn_t)(struct commit*);
+
+void default_setter(struct commit* c, void* data);
+void* default_getter(struct commit* c);
+
+void sort_in_topological_order(struct commit_list ** list, int lifo);
+void sort_in_topological_order_fun(struct commit_list ** list, int lifo, set_fn_t, get_fn_t);
#endif /* COMMIT_H */
^ permalink raw reply related
* [PATCH 0/3] Teach git-blame about renames
From: Fredrik Kuivinen @ 2006-03-08 22:54 UTC (permalink / raw)
To: git; +Cc: junkio
Hi,
This patch series teaches git-blame about renames. To do this I have
changed the revision.h interface a bit. In particular, it is now
possible for the user of revision.h to specify a
try_to_simply_commit-like function. That function can then do the
rename tracking.
I have also made a small change to sort_in_topological_order to make
it possible to use the object.util field at the same time as a
topological sort is done. Previously the object.util field was
clobbered by the topological sort. In the new interface the auxiliary
data that the topological sort needs to store for each commit object
is stored with a setter function and retrieved by a getter. Pointers
to those functions are passed to sort_in_topological_order.
- Fredrik
^ permalink raw reply
* Re: git-svn, tree moves, and --no-stop-on-copy
From: Yann Dirson @ 2006-03-08 22:41 UTC (permalink / raw)
To: Eric Wong; +Cc: GIT list
In-Reply-To: <20060308221524.GF12638@nowhere.earth>
On Wed, Mar 08, 2006 at 11:15:24PM +0100, Yann Dirson wrote:
> OTOH, this does work:
>
> svn co -r1 https://svn.sourceforge.net/svnroot/ufoai/trunk@1
Let's go further:
@@ -224,12 +227,14 @@ sub fetch {
unless (-d $SVN_WC) {
my @svn_co = ('svn','co',"-r$base->{revision}");
push @svn_co,'--ignore-externals' unless $_no_ignore_ext;
- sys(@svn_co, $SVN_URL, $SVN_WC);
+ sys(@svn_co, $SVN_URL . "\@$base->{revision}", $SVN_WC);
chdir $SVN_WC or croak $!;
That allows git-svn not to fail at r1 (or at r3 when checking out
trunk/src only), and the 1st fetch runs OK.
The second fetch runs OK as well, but it shows the following somewhat
scary stuff before starting the import:
Checked out revision 166.
refs/remotes/git-newsvn
fatal: 'refs/remotes/git-newsvn': No such file or directory
r166 = 38a6ba0e3db486c65a611c54c53f838210ce7551
The results looks fine. I don't know if it is expected to have the
master head stuck at remotes/git-oldsvn, though.
Thanks much for your help!
--
Yann Dirson <ydirson@altern.org> |
Debian-related: <dirson@debian.org> | Support Debian GNU/Linux:
| Freedom, Power, Stability, Gratis
http://ydirson.free.fr/ | Check <http://www.debian.org/>
^ permalink raw reply
* Re: git-svn, tree moves, and --no-stop-on-copy
From: Yann Dirson @ 2006-03-08 22:15 UTC (permalink / raw)
To: Eric Wong; +Cc: GIT list
In-Reply-To: <20060308014207.GA31137@localdomain>
On Tue, Mar 07, 2006 at 05:42:07PM -0800, Eric Wong wrote:
> If you want full repository history for reorganized repositories,
> easiest way is to pay the price for full repository and all of its
> history.
>
> git-svn init https://svn.sourceforge.net/svnroot/ufoai
> git-svn fetch
> # this puts all your branches and tags into one single big git tree.
>
> However, the following should always work: (after the following patch,
>
> GIT_SVN_ID=git-oldsvn git-svn init \
> https://svn.sourceforge.net/svnroot/ufoai/trunk
> GIT_SVN_ID=git-oldsvn git-svn fetch -r1:165
>
> GIT_SVN_ID=git-newsvn git-svn init
> https://svn.sourceforge.net/svnroot/ufoai/ufoai/trunk
> GIT_SVN_ID=git-newsvn git-svn fetch \
> 166=`git-rev-parse refs/remotes/git-oldsvn`
Thanks much for the hint - it should definitively be a good example
for the doc.
> Unfortunately, it does not, at least with svn 1.2.3... I have a patch
> coming that should fix things for 1.1.1 (and give better 1.1.x support
> in general). I'm not sure, but it feels like something is screwed up
> with svn 1.2.3dfsg1-3:
>
> This works: svn log -r1 https://svn.sourceforge.net/svnroot/ufoai/trunk
> This doesn't: svn co -r1 https://svn.sourceforge.net/svnroot/ufoai/trunk
>
> But this: svn co -r1 https://svn.sourceforge.net/svnroot/ufoai
> will create the following structure:
> ufoai/{trunk,branches,tags}
>
> I'm quite puzzled about it, as I swear I've seen it work on a different
> project recently (of course I cannot remember which :<)
Looks like svn may be looking at the current revision to find out
which path you are requesting, and that path does not exist any more.
Could look like something normal, if "svn log" complained - but the
problem may just be with "svn log".
OTOH, this does work:
svn co -r1 https://svn.sourceforge.net/svnroot/ufoai/trunk@1
> In the face of repository reorgs, git-svn is happiest tracking partial
> history. Or tracking the entire repository from the root.
Well, that could be a solution, if I could 1) filter out parts of the
tree I do not care about, and 2) strip the leading /whatever/trunk.
Not sure it's worth it :)
> Hopefully I've been reasonably coherent, having insomnia lately.
At least, my state of insomnia makes it look perferctly coherent :)
Best regards,
--
Yann Dirson <ydirson@altern.org> |
Debian-related: <dirson@debian.org> | Support Debian GNU/Linux:
| Freedom, Power, Stability, Gratis
http://ydirson.free.fr/ | Check <http://www.debian.org/>
^ permalink raw reply
* Re: git-rev-list bug?
From: Junio C Hamano @ 2006-03-08 20:16 UTC (permalink / raw)
To: Catalin Marinas; +Cc: git
In-Reply-To: <b0943d9e0603080819i227c637fo@mail.gmail.com>
"Catalin Marinas" <catalin.marinas@gmail.com> writes:
> Sorry if this was previously discussed. I ran git-rev-list on a linear
> graph and tried to filter the results by a file name:
>
> git rev-list since.. path/to/file
>
> but it always shows the child commit of "since" even if it didn't
> touch the file. The same behaviour is for git-log (since it uses
> git-rev-list) but git-whatchanged seems to be fine.
>
> Is this the intended behaviour? The "stg patches" command based on
> git-rev-list used to work fine a few weeks ago but now it is always
> reporting the bottom patch in the stack as modifying a given file.
I can confirm that this is a recent breakage, but since it is
unfortunately my day-job day the more detailed analysis and fix
needs to wait. Sorry.
^ permalink raw reply
* endless loop: ?
From: Matthias Urlichs @ 2006-03-08 20:04 UTC (permalink / raw)
To: git
Hmmm...
# ps axurw
smurf 26367 84.1 0.2 3200 2068 pts/1 R 20:08 40:30 /usr/bin/git-rev-list --objects 5771c72e2908fb68906020d07d4e0cb77d2
# strace -p 26367
stat64("/daten/src/noris/kundet.git/.git/objects/23/ae4dd0bab2f05dba8a3c77d4c792542b07b73e", {st_mode=S_IFREG|0644, st_size=204, ...}) = 0
[ lots of different filenames, however ..:]
# strace -p 26367 | grep ae4dd
stat64("/daten/src/noris/kundet.git/.git/objects/23/ae4dd0bab2f05dba8a3c77d4c792542b07b73e", {st_mode=S_IFREG|0644, st_size=204, ...}) = 0
[ lots of repetitions of the same filename => we're in a bad loop of some sort ]
# gdb /daten/src/git/git/git-rev-list 26367
(gdb) whe
#0 0xffffe410 in __kernel_vsyscall ()
#1 0xb7ec08f8 in _xstat () from /lib/tls/i686/cmov/libc.so.6
#2 0x0804e2f0 in find_sha1_file (
sha1=0x81ddb20 "#\uffffM\u043a\uffff\uffff]\uffff\212<w\uffff\uffff\222T+\a\uffff>\uffffr\005\b\uffff\uffff\035\b",
st=0xbf87b450) at stat.h:366
#3 0x0804e752 in has_sha1_file (
sha1=0x81ddb20 "#\uffffM\u043a\uffff\uffff]\uffff\212<w\uffff\uffff\222T+\a\uffff>\uffffr\005\b\uffff\uffff\035\b")
at sha1_file.c:1600
#4 0x080514f8 in mark_parents_uninteresting (commit=0x0) at revision.c:106
#5 0x080514ed in mark_parents_uninteresting (commit=0x0) at revision.c:96
[ bah ]
#104 0x080514ed in mark_parents_uninteresting (commit=0x0) at revision.c:96
#105 0x080516d8 in prepare_revision_walk (revs=0x8066560) at revision.c:347
#106 0x08049ab4 in main (argc=1, argv=0xbf87c294) at rev-list.c:352
I'll dig further tomorrow...
^ permalink raw reply
* [PATCH] diff-delta: bound hash list length to avoid O(m*n) behavior
From: Nicolas Pitre @ 2006-03-08 19:32 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
The diff-delta code can exhibit O(m*n) behavior with some patological
data set where most hash entries end up in the same hash bucket.
To prevent this, a limit is imposed to the number of entries that can
exist in the same hash bucket.
Because of the above the code is a tiny bit more expensive on average,
even if some small optimizations were added as well to atenuate the
overhead. But the problematic samples used to diagnoze the issue are now
orders of magnitude less expensive to process with only a slight loss in
compression.
Signed-off-by: Nicolas Pitre <nico@cam.org>
---
For example, Carl Baldwin provided me with a couple 20MB files, and
deltifying one against another one with test-delta takes around
TEN MINUTES for only one delta on my P4 @ 3GHz.
Nnow imagine using git-repack -a with a default window
of 10 ...
With this patch the test-delta time dropped to only 9 seconds. And the
resulting delta, once compressed, is about 2% larger.
diff --git a/diff-delta.c b/diff-delta.c
index 2ed5984..aaee7be 100644
--- a/diff-delta.c
+++ b/diff-delta.c
@@ -40,17 +40,18 @@ struct index {
static struct index ** delta_index(const unsigned char *buf,
unsigned long bufsize,
+ unsigned long trg_bufsize,
unsigned int *hash_shift)
{
- unsigned int hsize, hshift, entries, blksize, i;
+ unsigned int i, hsize, hshift, hlimit, entries, *hash_count;
const unsigned char *data;
struct index *entry, **hash;
void *mem;
/* determine index hash size */
- entries = (bufsize + BLK_SIZE - 1) / BLK_SIZE;
+ entries = bufsize / BLK_SIZE;
hsize = entries / 4;
- for (i = 4; (1 << i) < hsize && i < 16; i++);
+ for (i = 4; (1 << i) < hsize && i < 31; i++);
hsize = 1 << i;
hshift = 32 - i;
*hash_shift = hshift;
@@ -63,20 +64,62 @@ static struct index ** delta_index(const
entry = mem + hsize * sizeof(*hash);
memset(hash, 0, hsize * sizeof(*hash));
- /* then populate it */
+ /* allocate an array to count hash entries */
+ hash_count = calloc(hsize, sizeof(*hash_count));
+ if (!hash_count) {
+ free(hash);
+ return NULL;
+ }
+
+ /* then populate the index */
data = buf + entries * BLK_SIZE - BLK_SIZE;
- blksize = bufsize - (data - buf);
while (data >= buf) {
- unsigned int val = adler32(0, data, blksize);
+ unsigned int val = adler32(0, data, BLK_SIZE);
i = HASH(val, hshift);
entry->ptr = data;
entry->val = val;
entry->next = hash[i];
hash[i] = entry++;
- blksize = BLK_SIZE;
+ hash_count[i]++;
data -= BLK_SIZE;
}
+ /*
+ * Determine a limit on the number of entries in the same hash
+ * bucket. This guard us against patological data sets causing
+ * really bad hash distribution with most entries in the same hash
+ * bucket that would bring us to O(m*n) computing costs (m and n
+ * corresponding to reference and target buffer sizes).
+ *
+ * The more the target buffer is large, the more it is important to
+ * have small entry lists for each hash buckets. With such a limit
+ * the cost is bounded to something more like O(m+n).
+ */
+ hlimit = (1 << 26) / trg_bufsize;
+ if (hlimit < 4*BLK_SIZE)
+ hlimit = 4*BLK_SIZE;
+
+ /*
+ * Now make sure none of the hash buckets has more entries than
+ * we're willing to test. Otherwise we cull the entry list
+ * uniformly to still preserve a good repartition across
+ * the reference buffer.
+ */
+ for (i = 0; i < hsize; i++) {
+ if (hash_count[i] < hlimit)
+ continue;
+ entry = hash[i];
+ do {
+ struct index *keep = entry;
+ int skip = hash_count[i] / hlimit / 2;
+ do {
+ entry = entry->next;
+ } while(--skip && entry);
+ keep->next = entry;
+ } while(entry);
+ }
+ free(hash_count);
+
return hash;
}
@@ -100,7 +143,7 @@ void *diff_delta(void *from_buf, unsigne
if (!from_size || !to_size)
return NULL;
- hash = delta_index(from_buf, from_size, &hash_shift);
+ hash = delta_index(from_buf, from_size, to_size, &hash_shift);
if (!hash)
return NULL;
@@ -141,29 +184,27 @@ void *diff_delta(void *from_buf, unsigne
while (data < top) {
unsigned int moff = 0, msize = 0;
- unsigned int blksize = MIN(top - data, BLK_SIZE);
- unsigned int val = adler32(0, data, blksize);
- i = HASH(val, hash_shift);
- for (entry = hash[i]; entry; entry = entry->next) {
- const unsigned char *ref = entry->ptr;
- const unsigned char *src = data;
- unsigned int ref_size = ref_top - ref;
- if (entry->val != val)
- continue;
- if (ref_size > top - src)
- ref_size = top - src;
- while (ref_size && *src++ == *ref) {
- ref++;
- ref_size--;
- }
- ref_size = ref - entry->ptr;
- if (ref_size > msize) {
- /* this is our best match so far */
- moff = entry->ptr - ref_data;
- msize = ref_size;
- if (msize >= 0x10000) {
- msize = 0x10000;
+ if (data + BLK_SIZE <= top) {
+ unsigned int val = adler32(0, data, BLK_SIZE);
+ i = HASH(val, hash_shift);
+ for (entry = hash[i]; entry; entry = entry->next) {
+ const unsigned char *ref = entry->ptr;
+ const unsigned char *src = data;
+ unsigned int ref_size = ref_top - ref;
+ if (entry->val != val)
+ continue;
+ if (ref_size > top - src)
+ ref_size = top - src;
+ if (ref_size > 0x10000)
+ ref_size = 0x10000;
+ if (ref_size <= msize)
break;
+ while (ref_size-- && *src++ == *ref)
+ ref++;
+ if (msize < ref - entry->ptr) {
+ /* this is our best match so far */
+ msize = ref - entry->ptr;
+ moff = entry->ptr - ref_data;
}
}
}
^ permalink raw reply related
* Re: [PATCH] git-blame: Make the output human readable
From: linux @ 2006-03-08 19:06 UTC (permalink / raw)
To: linux, vsu; +Cc: git, junkio
In-Reply-To: <20060308183059.GD9555@procyon.home>
> So that mk_wcwidth() must be used unconditionally, and not as a
> fallback for systems which do not provide wcwidth() in libc.
Ah, the light dawns! I now understand your confusion.
That was exactly the idea; apologies for being unclear.
Kind of like the existing issspace(), isdigit(), isalpha(), etc.
implementations in git-compat-util.h to avoid the mysteries and vagaries
of locales. A UTF-8-only solution is desired.
^ permalink raw reply
* gitk: bug report: invalid command name "contmergediff"
From: Rutger Nijlunsing @ 2006-03-08 18:37 UTC (permalink / raw)
To: git
Bug report on gitk, maybe already reported.
do:
gitk HEAD~1000..
...select first commit (why is this not done automatically?), and keep
pressing down-arrow.
This gives me:
Error: invalid command name "contmergediff"
with detail window:
invalid command name "contmergediff"
invalid command name "contmergediff"
while executing
"contmergediff $ids"
(procedure "gettreediffline" line 14)
invoked from within
"gettreediffline file7 de84f99c12d1819479116685393afb1ebe99810b"
--
Rutger Nijlunsing ---------------------------------- eludias ed dse.nl
never attribute to a conspiracy which can be explained by incompetence
----------------------------------------------------------------------
^ permalink raw reply
* Re: [PATCH] git-blame: Make the output human readable
From: Sergey Vlasov @ 2006-03-08 18:30 UTC (permalink / raw)
To: linux; +Cc: git, junkio
In-Reply-To: <20060308180422.27978.qmail@science.horizon.com>
[-- Attachment #1: Type: text/plain, Size: 1004 bytes --]
On Wed, Mar 08, 2006 at 01:04:22PM -0500, linux@horizon.com wrote:
> > And this won't work, unless you also add that wcwidth() implementation
> > to git.
>
> That was the general idea. It is freely usable.
>
> > The problem is that the wchar_t encoding is not specified anywhere -
> > glibc uses Unicode for it, but other systems can use whatever they want
> > (even locale-dependent).
>
> Why is that a problem? None of the code mentioned even uses wchar_t.
> The code I wrote converts from UTF-8 to straight Unicode, and that's
> what Markus Kuhn's wcwidth() expects as an argument.
wcwidth() is a standard library function which takes a wchar_t:
http://www.opengroup.org/onlinepubs/009695399/functions/wcwidth.html
It is easy to write a program which assumes that wchar_t is Unicode
without noticing it, because it will work fine with glibc...
So that mk_wcwidth() must be used unconditionally, and not as a
fallback for systems which do not provide wcwidth() in libc.
[-- Attachment #2: Type: application/pgp-signature, Size: 189 bytes --]
^ permalink raw reply
* [PATCH] test-delta needs zlib to compile
From: Nicolas Pitre @ 2006-03-08 18:19 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
Signed-off-by: Nicolas Pitre <nico@cam.org>
---
diff --git a/Makefile b/Makefile
index a5eb0c4..89d67d6 100644
--- a/Makefile
+++ b/Makefile
@@ -565,7 +565,7 @@ test-date$X: test-date.c date.o ctype.o
$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) test-date.c date.o ctype.o
test-delta$X: test-delta.c diff-delta.o patch-delta.o
- $(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $^
+ $(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $^ -lz
check:
for i in *.c; do sparse $(ALL_CFLAGS) $(SPARSE_FLAGS) $$i || exit; done
^ permalink raw reply related
* Re: [PATCH] git-blame: Make the output human readable
From: linux @ 2006-03-08 18:04 UTC (permalink / raw)
To: linux, vsu; +Cc: git, junkio
In-Reply-To: <20060308173249.1faed1d7.vsu@altlinux.ru>
> And this won't work, unless you also add that wcwidth() implementation
> to git.
That was the general idea. It is freely usable.
> The problem is that the wchar_t encoding is not specified anywhere -
> glibc uses Unicode for it, but other systems can use whatever they want
> (even locale-dependent).
Why is that a problem? None of the code mentioned even uses wchar_t.
The code I wrote converts from UTF-8 to straight Unicode, and that's
what Markus Kuhn's wcwidth() expects as an argument.
At no time do we ask the compiler for its opinion on the subject.
^ permalink raw reply
* Re: git-svn, tree moves, and --no-stop-on-copy
From: Matthias Urlichs @ 2006-03-08 17:02 UTC (permalink / raw)
To: git
In-Reply-To: <20060307220837.GB27397@nowhere.earth>
Hi, Yann Dirson wrote:
> "svn switch --relocate" does not seem to be of any help. Switching
> manually .git/git-svn/tree/ to the new repository location does not
> help either, since I must obviously update to r166 in that case, and
> then a further "git-svn fetch" fails because it does not find
> .git/git-svn/revs/166 aleady imported.
>
> Any idea as to how to get the work done ?
You can manually edit the .git/corr file. Simply add an entry for #166
that has your reorganized (if necessary) head's SHA1.
--
Matthias Urlichs
^ permalink raw reply
* git-rev-list bug?
From: Catalin Marinas @ 2006-03-08 16:19 UTC (permalink / raw)
To: git
Sorry if this was previously discussed. I ran git-rev-list on a linear
graph and tried to filter the results by a file name:
git rev-list since.. path/to/file
but it always shows the child commit of "since" even if it didn't
touch the file. The same behaviour is for git-log (since it uses
git-rev-list) but git-whatchanged seems to be fine.
Is this the intended behaviour? The "stg patches" command based on
git-rev-list used to work fine a few weeks ago but now it is always
reporting the bottom patch in the stack as modifying a given file.
Thanks.
--
Catalin
^ permalink raw reply
* Re: Update hook in Cygwin
From: Christopher Faylor @ 2006-03-08 15:54 UTC (permalink / raw)
To: Andreas Ericsson, Niklas H?glund, Shawn Pearce, git
In-Reply-To: <20060308144413.GA516@spearce.org>
On Wed, Mar 08, 2006 at 09:44:13AM -0500, Shawn Pearce wrote:
>BTW: chmod a-x .git/hooks/* also works as the Cygwin unixy permission
>layer will remember the change.
Using "chmod a-x" should work like linux as long as you're using an NTFS
filesystem and have not specifically turned off Cygwin's handling of this
kind of thing with the CYGWIN=nontsec environment variable.
i.e., it should work in most cases on W2K+
cgf
^ permalink raw reply
* Re: Update hook in Cygwin
From: Shawn Pearce @ 2006-03-08 14:44 UTC (permalink / raw)
To: Andreas Ericsson; +Cc: Niklas Höglund, git
In-Reply-To: <440EDDE4.9070405@op5.se>
Andreas Ericsson <ae@op5.se> wrote:
> Niklas Höglund wrote:
> >Hi.
> >
> >After creating a couple of repositories and pushing and cloning them,
> >I get the following:
> >
> >$ git push --all origin
> >...
> >hooks/update: line 88: mail: command not found
> >
> >This is in cygwin. I'm rather glad I don't have the mail command
> >installed, as I don't want mails going anywhere.
> >
> >The update hook contains the following comment:
> >
> ># To enable this hook:
> ># (1) change the recipient e-mail address
> ># (2) make this file executable by "chmod +x update".
> >
> >But my impression after a cursory look at it is that it would always
> >call "mail" whenever it is run, and since all files are executable in
> >Windows (AFAIK), it would always be run.
>
>
> I was under the impression that the cygwin abstraction layer had some
> unixy permission thing on top of NTFS. Perhaps that's wrong. If you
> remove the hook it won't be called.
I've seen the same thing with the hooks on Cywin. I would consider
it to be a bug in either GIT or Cygwin but I haven't decided
which yet.
If you look at the share/git-core/templates directory on a real
UNIX system would see that the hooks are not marked executable by
default when installed. They are copied non-executable into each
new repository by git-init-db. Since they aren't executable they
don't get run.
But on Cygwin the hooks appear to be getting installed and are marked
executable in share/git-core/templates. So when git-init-db copies
them over to the new repository they are by default enabled.
Removing the execute bit from the files in share/git-core/templates
doesn't help; for some reason git-init-db is still copying them with
the execute bit enabled. I haven't spent the time to figure out why
yet; so I just run rm .git/hooks/* on every repository I come across.
BTW: chmod a-x .git/hooks/* also works as the Cygwin unixy permission
layer will remember the change.
--
Shawn.
^ permalink raw reply
* Re: [PATCH] git-blame: Make the output human readable
From: Sergey Vlasov @ 2006-03-08 14:32 UTC (permalink / raw)
To: linux; +Cc: junkio, git
In-Reply-To: <20060306193326.19262.qmail@science.horizon.com>
[-- Attachment #1: Type: text/plain, Size: 973 bytes --]
On 6 Mar 2006 14:33:26 -0500 linux@horizon.com wrote:
> Well, getting 15 characters in UTF-8 is easy (just stop before the 16th
> byte for which ((b & 0xc0) != 0x80)), but what about combining characters?
>
> You've got accents and stuff to worry about. And the annoying fact that
> Unicode defined accents as suffixes, so you have to go past the 15th
> column to include all of the
>
> And then there's that fact that many characters are traditionally
> represented as double-wide forms, even on character terminals.
>
> See http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c for details
> an an example implementation of wcwidth().
>
[skip]
> /* Now find the width of it */
> w = wcwidth(c);
And this won't work, unless you also add that wcwidth() implementation
to git.
The problem is that the wchar_t encoding is not specified anywhere -
glibc uses Unicode for it, but other systems can use whatever they want
(even locale-dependent).
[-- Attachment #2: Type: application/pgp-signature, Size: 190 bytes --]
^ permalink raw reply
* Re: [PATCH] write_sha1_file(): Perform Z_FULL_FLUSH between header and data
From: Sergey Vlasov @ 2006-03-08 14:17 UTC (permalink / raw)
To: Junio C Hamano; +Cc: git
In-Reply-To: <7vhd69i4ep.fsf@assigned-by-dhcp.cox.net>
[-- Attachment #1: Type: text/plain, Size: 1732 bytes --]
On Wed, Mar 08, 2006 at 03:04:14AM -0800, Junio C Hamano wrote:
> Sergey Vlasov <vsu@altlinux.ru> writes:
> > However, a straight reuse still will not be possible, because
> > sha1write_compressed() uses deflateInit(&stream, Z_DEFAULT_COMPRESSION),
> > which writes zlib headers around the deflate stream, and the zlib footer
> > contains adler32 checksum. So, as a minimum, you will need to
> > decompress the object data, calculate its adler32 checksum and write the
> > zlib header yourself.
>
> Hmph. Thanks for helping, but it sounds like my original plan
> was not useful at all. Probably inflating would be still
> cheaper than inflating and then deflating, but it would not be
> as cool as a straight copy. Sigh...
Actually you can calculate adler32 checksum of object data from
adler32(header+data) (available at the end of the loose object file),
adler32(header) (which you will need to calculate) and len(data)
(which is available in the header):
#define ADLER32_BASE 65521UL
unsigned int adler32_split(unsigned int adler_full, unsigned int adler_1,
unsigned long len_2)
{
unsigned long s1_1 = adler_1 & 0xffff;
unsigned long s1_2 = (adler_1 >> 16) & 0xffff;
unsigned long rem = len_2 % ADLER32_BASE;
unsigned long s_1_offset = (s1_1 + ADLER32_BASE - 1) % ADLER32_BASE;
unsigned long s_2_offset = (s1_2 + s_1_offset*rem) % ADLER32_BASE;
unsigned long sf_1 = adler_full & 0xffff;
unsigned long sf_2 = (adler_full >> 16) & 0xffff;
unsigned long s2_1 = (sf_1 + ADLER32_BASE - s_1_offset) % ADLER32_BASE;
unsigned long s2_2 = (sf_2 + ADLER32_BASE - s_2_offset) % ADLER32_BASE;
return (s2_2 << 16) | s2_1;
}
However, the resulting code probably won't be pretty...
[-- Attachment #2: Type: application/pgp-signature, Size: 189 bytes --]
^ permalink raw reply
* Re: Update hook in Cygwin
From: Andreas Ericsson @ 2006-03-08 13:36 UTC (permalink / raw)
To: Niklas Höglund; +Cc: git
In-Reply-To: <ad8ce5c20603080416g5ed6d77el@mail.gmail.com>
Niklas Höglund wrote:
> Hi.
>
> After creating a couple of repositories and pushing and cloning them,
> I get the following:
>
> $ git push --all origin
> ...
> hooks/update: line 88: mail: command not found
>
> This is in cygwin. I'm rather glad I don't have the mail command
> installed, as I don't want mails going anywhere.
>
> The update hook contains the following comment:
>
> # To enable this hook:
> # (1) change the recipient e-mail address
> # (2) make this file executable by "chmod +x update".
>
> But my impression after a cursory look at it is that it would always
> call "mail" whenever it is run, and since all files are executable in
> Windows (AFAIK), it would always be run.
I was under the impression that the cygwin abstraction layer had some
unixy permission thing on top of NTFS. Perhaps that's wrong. If you
remove the hook it won't be called.
--
Andreas Ericsson andreas.ericsson@op5.se
OP5 AB www.op5.se
Tel: +46 8-230225 Fax: +46 8-230231
^ permalink raw reply
* Update hook in Cygwin
From: Niklas Höglund @ 2006-03-08 12:16 UTC (permalink / raw)
To: git
Hi.
After creating a couple of repositories and pushing and cloning them,
I get the following:
$ git push --all origin
...
hooks/update: line 88: mail: command not found
This is in cygwin. I'm rather glad I don't have the mail command
installed, as I don't want mails going anywhere.
The update hook contains the following comment:
# To enable this hook:
# (1) change the recipient e-mail address
# (2) make this file executable by "chmod +x update".
But my impression after a cursory look at it is that it would always
call "mail" whenever it is run, and since all files are executable in
Windows (AFAIK), it would always be run.
^ permalink raw reply
* Re: [PATCH] write_sha1_file(): Perform Z_FULL_FLUSH between header and data
From: Junio C Hamano @ 2006-03-08 11:04 UTC (permalink / raw)
To: Sergey Vlasov; +Cc: git
In-Reply-To: <20060308134519.78ea313d.vsu@altlinux.ru>
Sergey Vlasov <vsu@altlinux.ru> writes:
> However, a straight reuse still will not be possible, because
> sha1write_compressed() uses deflateInit(&stream, Z_DEFAULT_COMPRESSION),
> which writes zlib headers around the deflate stream, and the zlib footer
> contains adler32 checksum. So, as a minimum, you will need to
> decompress the object data, calculate its adler32 checksum and write the
> zlib header yourself.
Hmph. Thanks for helping, but it sounds like my original plan
was not useful at all. Probably inflating would be still
cheaper than inflating and then deflating, but it would not be
as cool as a straight copy. Sigh...
^ 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