# on non-x86 architectures (e.g. PowerPC), while the OpenSSL version (default
# choice) has very fast version optimized for i586.
#
- # Define NO_OPENSSL environment variable if you do not have OpenSSL. You will
- # miss out git-rev-list --merge-order. This also implies MOZILLA_SHA1.
+ # Define NO_OPENSSL environment variable if you do not have OpenSSL.
+ # This also implies MOZILLA_SHA1.
#
# Define NO_CURL if you do not have curl installed. git-http-pull and
# git-http-push are not built, and you cannot use http:// and https://
@$(SHELL_PATH) ./GIT-VERSION-GEN
-include GIT-VERSION-FILE
+ uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
+ uname_M := $(shell sh -c 'uname -m 2>/dev/null || echo not')
+ uname_O := $(shell sh -c 'uname -o 2>/dev/null || echo not')
+ uname_R := $(shell sh -c 'uname -r 2>/dev/null || echo not')
+ uname_P := $(shell sh -c 'uname -p 2>/dev/null || echo not')
+
# CFLAGS and LDFLAGS are for the users to override from the command line.
CFLAGS = -g -O2 -Wall
prefix = $(HOME)
bindir = $(prefix)/bin
- gitexecdir = $(prefix)/bin
+ gitexecdir = $(bindir)
template_dir = $(prefix)/share/git-core/templates/
GIT_PYTHON_DIR = $(prefix)/share/git-core/python
# DESTDIR=
git-merge-one-file.sh git-parse-remote.sh \
git-prune.sh git-pull.sh git-push.sh git-rebase.sh \
git-repack.sh git-request-pull.sh git-reset.sh \
- git-resolve.sh git-revert.sh git-sh-setup.sh \
+ git-resolve.sh git-revert.sh git-rm.sh git-sh-setup.sh \
git-tag.sh git-verify-tag.sh git-whatchanged.sh \
git-applymbox.sh git-applypatch.sh git-am.sh \
git-merge.sh git-merge-stupid.sh git-merge-octopus.sh \
SCRIPT_PERL = \
git-archimport.perl git-cvsimport.perl git-relink.perl \
git-shortlog.perl git-fmt-merge-msg.perl git-rerere.perl \
+ git-annotate.perl git-cvsserver.perl \
git-svnimport.perl git-mv.perl git-cvsexportcommit.perl
SCRIPT_PYTHON = \
# The ones that do not have to link with lcrypto nor lz.
SIMPLE_PROGRAMS = \
- git-get-tar-commit-id$X git-mailinfo$X git-mailsplit$X \
+ git-get-tar-commit-id$X git-mailsplit$X \
git-stripspace$X git-daemon$X
# ... and all the rest that could be moved out of bindir to gitexecdir
git-convert-objects$X git-diff-files$X \
git-diff-index$X git-diff-stages$X \
git-diff-tree$X git-fetch-pack$X git-fsck-objects$X \
- git-hash-object$X git-index-pack$X git-init-db$X \
- git-local-fetch$X git-ls-files$X git-ls-tree$X git-merge-base$X \
+ git-hash-object$X git-index-pack$X git-init-db$X git-local-fetch$X \
+ git-ls-files$X git-ls-tree$X git-mailinfo$X git-merge-base$X \
git-merge-index$X git-mktag$X git-mktree$X git-pack-objects$X git-patch-id$X \
git-peek-remote$X git-prune-packed$X git-read-tree$X \
git-receive-pack$X git-rev-list$X git-rev-parse$X \
git-upload-pack$X git-verify-pack$X git-write-tree$X \
git-update-ref$X git-symbolic-ref$X git-check-ref-format$X \
git-name-rev$X git-pack-redundant$X git-repo-config$X git-var$X \
- git-describe$X git-merge-tree$X
+ git-describe$X git-merge-tree$X git-blame$X
# what 'all' will build and 'install' will install, in gitexecdir
ALL_PROGRAMS = $(PROGRAMS) $(SIMPLE_PROGRAMS) $(SCRIPTS)
LIB_H = \
blob.h cache.h commit.h count-delta.h csum-file.h delta.h \
- diff.h epoch.h object.h pack.h pkt-line.h quote.h refs.h \
- run-command.h strbuf.h tag.h tree.h git-compat-util.h
+ diff.h object.h pack.h pkt-line.h quote.h refs.h \
+ run-command.h strbuf.h tag.h tree.h git-compat-util.h revision.h
DIFF_OBJS = \
diff.o diffcore-break.o diffcore-order.o diffcore-pathspec.o \
quote.o read-cache.o refs.o run-command.o \
server-info.o setup.o sha1_file.o sha1_name.o strbuf.o \
tag.o tree.o usage.o config.o environment.o ctype.o copy.o \
- fetch-clone.o \
+ fetch-clone.o revision.o pager.o \
$(DIFF_OBJS)
LIBS = $(LIB_FILE)
LIBS += -lz
- # Shell quote;
- # Result of this needs to be placed inside ''
- shq = $(subst ','\'',$(1))
- # This has surrounding ''
- shellquote = '$(call shq,$(1))'
-
#
# Platform specific tweaks
#
# We choose to avoid "if .. else if .. else .. endif endif"
# because maintaining the nesting to match is a pain. If
# we had "elif" things would have been much nicer...
- uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
- uname_M := $(shell sh -c 'uname -m 2>/dev/null || echo not')
- uname_O := $(shell sh -c 'uname -o 2>/dev/null || echo not')
- uname_R := $(shell sh -c 'uname -r 2>/dev/null || echo not')
ifeq ($(uname_S),Darwin)
NEEDS_SSL_WITH_CRYPTO = YesPlease
ifeq ($(uname_S),SunOS)
NEEDS_SOCKET = YesPlease
NEEDS_NSL = YesPlease
- NEEDS_LIBICONV = YesPlease
SHELL_PATH = /bin/bash
NO_STRCASESTR = YesPlease
ifeq ($(uname_R),5.8)
+ NEEDS_LIBICONV = YesPlease
NO_UNSETENV = YesPlease
NO_SETENV = YesPlease
endif
ifdef WITH_OWN_SUBPROCESS_PY
PYMODULES += compat/subprocess.py
else
- ifneq ($(shell $(PYTHON_PATH) -c 'import subprocess;print"OK"' 2>/dev/null),OK)
- PYMODULES += compat/subprocess.py
+ ifeq ($(NO_PYTHON),)
+ ifneq ($(shell $(PYTHON_PATH) -c 'import subprocess;print"OK"' 2>/dev/null),OK)
+ PYMODULES += compat/subprocess.py
+ endif
endif
endif
endif
ifndef NO_OPENSSL
- LIB_OBJS += epoch.o
OPENSSL_LIBSSL = -lssl
ifdef OPENSSLDIR
# Again this may be problematic -- gcc does not always want -R.
ALL_CFLAGS += -DNO_ACCURATE_DIFF
endif
- ALL_CFLAGS += -DSHA1_HEADER=$(call shellquote,$(SHA1_HEADER)) $(COMPAT_CFLAGS)
+ # Shell quote (do not use $(call) to accomodate ancient setups);
+
+ SHA1_HEADER_SQ = $(subst ','\'',$(SHA1_HEADER))
+
+ DESTDIR_SQ = $(subst ','\'',$(DESTDIR))
+ bindir_SQ = $(subst ','\'',$(bindir))
+ gitexecdir_SQ = $(subst ','\'',$(gitexecdir))
+ template_dir_SQ = $(subst ','\'',$(template_dir))
+
+ SHELL_PATH_SQ = $(subst ','\'',$(SHELL_PATH))
+ PERL_PATH_SQ = $(subst ','\'',$(PERL_PATH))
+ PYTHON_PATH_SQ = $(subst ','\'',$(PYTHON_PATH))
+ GIT_PYTHON_DIR_SQ = $(subst ','\'',$(GIT_PYTHON_DIR))
+
+ ALL_CFLAGS += -DSHA1_HEADER='$(SHA1_HEADER_SQ)' $(COMPAT_CFLAGS)
LIB_OBJS += $(COMPAT_OBJS)
export prefix TAR INSTALL DESTDIR SHELL_PATH template_dir
### Build rules
git$X: git.c $(LIB_FILE)
$(CC) -DGIT_VERSION='"$(GIT_VERSION)"' \
- $(CFLAGS) $(COMPAT_CFLAGS) -o $@ $(filter %.c,$^) $(LIB_FILE)
+ $(ALL_CFLAGS) -o $@ $(filter %.c,$^) $(LIB_FILE) $(LIBS)
$(patsubst %.sh,%,$(SCRIPT_SH)) : % : %.sh
rm -f $@
- sed -e '1s|#!.*/sh|#!$(call shq,$(SHELL_PATH))|' \
+ sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \
-e 's/@@GIT_VERSION@@/$(GIT_VERSION)/g' \
-e 's/@@NO_CURL@@/$(NO_CURL)/g' \
-e 's/@@NO_PYTHON@@/$(NO_PYTHON)/g' \
$(patsubst %.perl,%,$(SCRIPT_PERL)) : % : %.perl
rm -f $@
- sed -e '1s|#!.*perl|#!$(call shq,$(PERL_PATH))|' \
+ sed -e '1s|#!.*perl|#!$(PERL_PATH_SQ)|' \
-e 's/@@GIT_VERSION@@/$(GIT_VERSION)/g' \
$@.perl >$@
chmod +x $@
$(patsubst %.py,%,$(SCRIPT_PYTHON)) : % : %.py
rm -f $@
- sed -e '1s|#!.*python|#!$(call shq,$(PYTHON_PATH))|' \
- -e 's|@@GIT_PYTHON_PATH@@|$(call shq,$(GIT_PYTHON_DIR))|g' \
+ sed -e '1s|#!.*python|#!$(PYTHON_PATH_SQ)|' \
+ -e 's|@@GIT_PYTHON_PATH@@|$(GIT_PYTHON_DIR_SQ)|g' \
-e 's/@@GIT_VERSION@@/$(GIT_VERSION)/g' \
$@.py >$@
chmod +x $@
%.o: %.S
$(CC) -o $*.o -c $(ALL_CFLAGS) $<
- exec_cmd.o: ALL_CFLAGS += -DGIT_EXEC_PATH=\"$(gitexecdir)\"
+ exec_cmd.o: exec_cmd.c
+ $(CC) -o $*.o -c $(ALL_CFLAGS) '-DGIT_EXEC_PATH="$(gitexecdir_SQ)"' $<
git-%$X: %.o $(LIB_FILE)
$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) $(LIBS)
- git-mailinfo$X : SIMPLE_LIB += $(LIB_4_ICONV)
$(SIMPLE_PROGRAMS) : $(LIB_FILE)
$(SIMPLE_PROGRAMS) : git-%$X : %.o
$(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) \
$(LIB_FILE) $(SIMPLE_LIB)
- git-http-fetch$X: fetch.o http.o
- git-http-push$X: http.o
+ git-mailinfo$X: mailinfo.o $(LIB_FILE)
+ $(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) \
+ $(LIB_FILE) $(SIMPLE_LIB) $(LIB_4_ICONV)
+
git-local-fetch$X: fetch.o
git-ssh-fetch$X: rsh.o fetch.o
git-ssh-upload$X: rsh.o
git-ssh-pull$X: rsh.o fetch.o
git-ssh-push$X: rsh.o
- git-http-fetch$X: LIBS += $(CURL_LIBCURL)
- git-http-push$X: LIBS += $(CURL_LIBCURL) $(EXPAT_LIBEXPAT)
- git-rev-list$X: LIBS += $(OPENSSL_LIBSSL)
+ git-http-fetch$X: fetch.o http.o http-fetch.o $(LIB_FILE)
+ $(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) \
+ $(LIBS) $(CURL_LIBCURL)
+
+ git-http-push$X: http.o http-push.o $(LIB_FILE)
+ $(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) \
+ $(LIBS) $(CURL_LIBCURL) $(EXPAT_LIBEXPAT)
+
+ git-rev-list$X: rev-list.o $(LIB_FILE)
+ $(CC) $(ALL_CFLAGS) -o $@ $(ALL_LDFLAGS) $(filter %.o,$^) \
+ $(LIBS) $(OPENSSL_LIBSSL)
init-db.o: init-db.c
$(CC) -c $(ALL_CFLAGS) \
- -DDEFAULT_GIT_TEMPLATE_DIR=$(call shellquote,"$(template_dir)") $*.c
+ -DDEFAULT_GIT_TEMPLATE_DIR='"$(template_dir_SQ)"' $*.c
$(LIB_OBJS): $(LIB_H)
$(patsubst git-%$X,%.o,$(PROGRAMS)): $(LIB_H)
### Installation rules
install: all
- $(INSTALL) -d -m755 $(call shellquote,$(DESTDIR)$(bindir))
- $(INSTALL) -d -m755 $(call shellquote,$(DESTDIR)$(gitexecdir))
- $(INSTALL) $(ALL_PROGRAMS) $(call shellquote,$(DESTDIR)$(gitexecdir))
- $(INSTALL) git$X gitk $(call shellquote,$(DESTDIR)$(bindir))
+ $(INSTALL) -d -m755 '$(DESTDIR_SQ)$(bindir_SQ)'
+ $(INSTALL) -d -m755 '$(DESTDIR_SQ)$(gitexecdir_SQ)'
+ $(INSTALL) $(ALL_PROGRAMS) '$(DESTDIR_SQ)$(gitexecdir_SQ)'
+ $(INSTALL) git$X gitk '$(DESTDIR_SQ)$(bindir_SQ)'
$(MAKE) -C templates install
- $(INSTALL) -d -m755 $(call shellquote,$(DESTDIR)$(GIT_PYTHON_DIR))
- $(INSTALL) $(PYMODULES) $(call shellquote,$(DESTDIR)$(GIT_PYTHON_DIR))
+ $(INSTALL) -d -m755 '$(DESTDIR_SQ)$(GIT_PYTHON_DIR_SQ)'
+ $(INSTALL) $(PYMODULES) '$(DESTDIR_SQ)$(GIT_PYTHON_DIR_SQ)'
install-doc:
$(MAKE) -C Documentation install
--- /dev/null
- #include "epoch.h"
+#include <assert.h>
+
+#include "cache.h"
+#include "refs.h"
+#include "tag.h"
+#include "commit.h"
+#include "tree.h"
+#include "blob.h"
+#include "diff.h"
+
+#define DEBUG 0
+
+struct commit** blame_lines;
+int num_blame_lines;
+
+struct util_info
+{
+ int* line_map;
+ int num_lines;
+ unsigned char sha1[20]; /* blob sha, not commit! */
+ char* buf;
+ unsigned long size;
+// const char* path;
+};
+
+struct chunk
+{
+ int off1, len1; // ---
+ int off2, len2; // +++
+};
+
+struct patch
+{
+ struct chunk* chunks;
+ int num;
+};
+
+static void get_blob(struct commit* commit);
+
+int num_get_patch = 0;
+int num_commits = 0;
+
+struct patch* get_patch(struct commit* commit, struct commit* other)
+{
+ struct patch* ret = xmalloc(sizeof(struct patch));
+ ret->chunks = NULL;
+ ret->num = 0;
+
+ struct util_info* info_c = (struct util_info*) commit->object.util;
+ struct util_info* info_o = (struct util_info*) other->object.util;
+
+ if(!memcmp(info_c->sha1, info_o->sha1, 20))
+ return ret;
+
+ get_blob(commit);
+ get_blob(other);
+
+ FILE* fout = fopen("/tmp/git-blame-tmp1", "w");
+ if(!fout)
+ die("fopen tmp1 failed: %s", strerror(errno));
+
+ if(fwrite(info_c->buf, info_c->size, 1, fout) != 1)
+ die("fwrite 1 failed: %s", strerror(errno));
+ fclose(fout);
+
+ fout = fopen("/tmp/git-blame-tmp2", "w");
+ if(!fout)
+ die("fopen tmp2 failed: %s", strerror(errno));
+
+ if(fwrite(info_o->buf, info_o->size, 1, fout) != 1)
+ die("fwrite 2 failed: %s", strerror(errno));
+ fclose(fout);
+
+ FILE* fin = popen("diff -u0 /tmp/git-blame-tmp1 /tmp/git-blame-tmp2", "r");
+ if(!fin)
+ die("popen failed: %s", strerror(errno));
+
+ char buf[1024];
+ while(fgets(buf, sizeof(buf), fin)) {
+ if(buf[0] != '@' || buf[1] != '@')
+ continue;
+
+ if(DEBUG)
+ printf("chunk line: %s", buf);
+ ret->num++;
+ ret->chunks = xrealloc(ret->chunks, sizeof(struct chunk)*ret->num);
+ struct chunk* chunk = &ret->chunks[ret->num-1];
+
+ assert(!strncmp(buf, "@@ -", 4));
+
+ char* start = buf+4;
+ char* sp = index(start, ' ');
+ *sp = '\0';
+ if(index(start, ',')) {
+ int ret = sscanf(start, "%d,%d", &chunk->off1, &chunk->len1);
+ assert(ret == 2);
+ } else {
+ int ret = sscanf(start, "%d", &chunk->off1);
+ assert(ret == 1);
+ chunk->len1 = 1;
+ }
+ *sp = ' ';
+
+ start = sp+1;
+ sp = index(start, ' ');
+ *sp = '\0';
+ if(index(start, ',')) {
+ int ret = sscanf(start, "%d,%d", &chunk->off2, &chunk->len2);
+ assert(ret == 2);
+ } else {
+ int ret = sscanf(start, "%d", &chunk->off2);
+ assert(ret == 1);
+ chunk->len2 = 1;
+ }
+ *sp = ' ';
+
+ if(chunk->off1 > 0)
+ chunk->off1 -= 1;
+ if(chunk->off2 > 0)
+ chunk->off2 -= 1;
+
+ assert(chunk->off1 >= 0);
+ assert(chunk->off2 >= 0);
+ }
+ fclose(fin);
+
+ num_get_patch++;
+ return ret;
+}
+
+void free_patch(struct patch* p)
+{
+ free(p->chunks);
+ free(p);
+}
+
+static int get_blob_sha1_internal(unsigned char *sha1, const char *base, int baselen,
+ const char *pathname, unsigned mode, int stage);
+
+
+static unsigned char blob_sha1[20];
+static int get_blob_sha1(struct tree* t, const char* pathname, unsigned char* sha1)
+{
+ const char *pathspec[2];
+ pathspec[0] = pathname;
+ pathspec[1] = NULL;
+ memset(blob_sha1, 0, sizeof(blob_sha1));
+ read_tree_recursive(t, "", 0, 0, pathspec, get_blob_sha1_internal);
+
+ int i;
+ for(i = 0; i < 20; i++) {
+ if(blob_sha1[i] != 0)
+ break;
+ }
+
+ if(i == 20)
+ return -1;
+
+ memcpy(sha1, blob_sha1, 20);
+ return 0;
+}
+
+static int get_blob_sha1_internal(unsigned char *sha1, const char *base, int baselen,
+ const char *pathname, unsigned mode, int stage)
+{
+// printf("Got blob: %s base: '%s' baselen: %d pathname: '%s' mode: %o stage: %d\n",
+// sha1_to_hex(sha1), base, baselen, pathname, mode, stage);
+
+ if(S_ISDIR(mode))
+ return READ_TREE_RECURSIVE;
+
+ memcpy(blob_sha1, sha1, 20);
+ return -1;
+}
+
+static void get_blob(struct commit* commit)
+{
+ struct util_info* info = commit->object.util;
+ char type[20];
+
+ if(info->buf)
+ return;
+
+ info->buf = read_sha1_file(info->sha1, type, &info->size);
+ assert(!strcmp(type, "blob"));
+}
+
+void print_patch(struct patch* p)
+{
+ printf("Num chunks: %d\n", p->num);
+ int i;
+ for(i = 0; i < p->num; i++) {
+ printf("%d,%d %d,%d\n", p->chunks[i].off1, p->chunks[i].len1, p->chunks[i].off2, p->chunks[i].len2);
+ }
+}
+
+
+// p is a patch from commit to other.
+void fill_line_map(struct commit* commit, struct commit* other, struct patch* p)
+{
+ int num_lines = ((struct util_info*) commit->object.util)->num_lines;
+ int* line_map = ((struct util_info*) commit->object.util)->line_map;
+ int num_lines2 = ((struct util_info*) other->object.util)->num_lines;
+ int* line_map2 = ((struct util_info*) other->object.util)->line_map;
+ int cur_chunk = 0;
+ int i1, i2;
+
+ if(p->num && DEBUG)
+ print_patch(p);
+
+ for(i1 = 0; i1 < num_lines; i1++)
+ line_map[i1] = -1;
+
+ if(DEBUG)
+ printf("num lines 1: %d num lines 2: %d\n", num_lines, num_lines2);
+
+ for(i1 = 0, i2 = 0; i1 < num_lines; i1++, i2++) {
+ if(DEBUG > 1)
+ printf("%d %d\n", i1, i2);
+
+ if(i2 >= num_lines2)
+ break;
+
+ line_map[i1] = line_map2[i2];
+
+ struct chunk* chunk = NULL;
+ if(cur_chunk < p->num)
+ chunk = &p->chunks[cur_chunk];
+
+ if(chunk && chunk->off1 == i1) {
+ i2 = chunk->off2;
+
+ if(chunk->len1 > 0)
+ i1 += chunk->len1-1;
+ if(chunk->len2 > 0)
+ i2 += chunk->len2-1;
+ cur_chunk++;
+ }
+ }
+}
+
+int map_line(struct commit* commit, int line)
+{
+ struct util_info* info = commit->object.util;
+ assert(line >= 0 && line < info->num_lines);
+ return info->line_map[line];
+}
+
+int fill_util_info(struct commit* commit, const char* path)
+{
+ if(commit->object.util)
+ return 0;
+
+ struct util_info* util = xmalloc(sizeof(struct util_info));
+ util->buf = NULL;
+ util->size = 0;
+ util->num_lines = -1;
+ util->line_map = NULL;
+
+ commit->object.util = util;
+
+ if(get_blob_sha1(commit->tree, path, util->sha1))
+ return -1;
+
+ return 0;
+}
+
+void alloc_line_map(struct commit* commit)
+{
+ struct util_info* util = commit->object.util;
+
+ if(util->line_map)
+ return;
+
+ get_blob(commit);
+
+ int i;
+ util->num_lines = 0;
+ for(i = 0; i < util->size; i++) {
+ if(util->buf[i] == '\n')
+ util->num_lines++;
+ }
+ util->line_map = xmalloc(sizeof(int)*util->num_lines);
+}
+
+void copy_line_map(struct commit* dst, struct commit* src)
+{
+ struct util_info* u_dst = dst->object.util;
+ struct util_info* u_src = src->object.util;
+
+ u_dst->line_map = u_src->line_map;
+ u_dst->num_lines = u_src->num_lines;
+ u_dst->buf = u_src->buf;
+ u_dst->size = u_src->size;
+}
+
+void process_commits(struct commit_list* list, const char* path)
+{
+ int i;
+
+ while(list) {
+ struct commit* commit = pop_commit(&list);
+ struct commit_list* parents;
+ struct util_info* info;
+
+ info = commit->object.util;
+ num_commits++;
+ if(DEBUG)
+ printf("\nProcessing commit: %d %s\n", num_commits, sha1_to_hex(commit->object.sha1));
+ for(parents = commit->parents;
+ parents != NULL; parents = parents->next) {
+ struct commit* parent = parents->item;
+
+ if(parse_commit(parent) < 0)
+ die("parse_commit error");
+
+ if(DEBUG)
+ printf("parent: %s\n", sha1_to_hex(parent->object.sha1));
+
+ if(fill_util_info(parent, path))
+ continue;
+
+ // Temporarily assign everything to the parent.
+ int num_blame = 0;
+ for(i = 0; i < num_blame_lines; i++) {
+ if(blame_lines[i] == commit) {
+ num_blame++;
+ blame_lines[i] = parent;
+ }
+ }
+
+ if(num_blame == 0)
+ continue;
+
+ struct patch* patch = get_patch(parent, commit);
+ if(patch->num == 0) {
+ copy_line_map(parent, commit);
+ } else {
+ alloc_line_map(parent);
+ fill_line_map(parent, commit, patch);
+ }
+
+ for(i = 0; i < patch->num; i++) {
+ int l;
+ for(l = 0; l < patch->chunks[i].len2; l++) {
+ int mapped_line = map_line(commit, patch->chunks[i].off2 + l);
+ if(mapped_line != -1 && blame_lines[mapped_line] == parent)
+ blame_lines[mapped_line] = commit;
+ }
+ }
+ free_patch(patch);
+ }
+ }
+}
+
+#define SEEN 1
+struct commit_list* get_commit_list(struct commit* commit, const char* pathname)
+{
+ struct commit_list* ret = NULL;
+ struct commit_list* process = NULL;
+ unsigned char sha1[20];
+
+ commit_list_insert(commit, &process);
+
+ while(process) {
+ struct commit* com = pop_commit(&process);
+ if(com->object.flags & SEEN)
+ continue;
+
+ com->object.flags |= SEEN;
+ commit_list_insert(com, &ret);
+ struct commit_list* parents;
+
+ parse_commit(com);
+
+ for(parents = com->parents;
+ parents != NULL; parents = parents->next) {
+ struct commit* parent = parents->item;
+
+ parse_commit(parent);
+
+ if(!get_blob_sha1(parent->tree, pathname, sha1))
+ commit_list_insert(parent, &process);
+ }
+ }
+
+ return ret;
+}
+
+int main(int argc, const char **argv)
+{
+ unsigned char sha1[20];
+ struct commit *commit;
+ const char* filename;
+ int i;
+
+ setup_git_directory();
+
+ if (argc != 3)
+ die("Usage: blame commit-ish file");
+
+ if (get_sha1(argv[1], sha1))
+ die("get_sha1 failed");
+
+ commit = lookup_commit_reference(sha1);
+
+ filename = argv[2];
+
+ struct commit_list* list = get_commit_list(commit, filename);
+ sort_in_topological_order(&list, 1);
+
+ if(fill_util_info(commit, filename)) {
+ printf("%s not found in %s\n", filename, argv[1]);
+ return 0;
+ }
+ alloc_line_map(commit);
+
+ struct util_info* util = commit->object.util;
+ num_blame_lines = util->num_lines;
+ blame_lines = xmalloc(sizeof(struct commit*)*num_blame_lines);
+
+
+ for(i = 0; i < num_blame_lines; i++) {
+ blame_lines[i] = commit;
+
+ ((struct util_info*) commit->object.util)->line_map[i] = i;
+ }
+
+ process_commits(list, filename);
+
+ for(i = 0; i < num_blame_lines; i++) {
+ printf("%d %s\n", i+1-1, sha1_to_hex(blame_lines[i]->object.sha1));
+// printf("%d %s\n", i+1-1, find_unique_abbrev(blame_lines[i]->object.sha1, 6));
+ }
+
+ if(DEBUG) {
+ printf("num get patch: %d\n", num_get_patch);
+ printf("num commits: %d\n", num_commits);
+ }
+
+ return 0;
+}