aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/Makefile4
-rwxr-xr-xDocumentation/install-doc-quick.sh31
-rw-r--r--Makefile10
-rw-r--r--builtin-commit-tree.c15
-rw-r--r--builtin-merge-file.c20
-rw-r--r--builtin-rerere.c406
-rw-r--r--builtin.h1
-rw-r--r--compat/mmap.c25
-rw-r--r--git-compat-util.h8
-rw-r--r--git.c1
-rwxr-xr-xgitweb/gitweb.perl148
-rwxr-xr-xt/t4200-rerere.sh154
-rw-r--r--utf8.c278
-rw-r--r--utf8.h8
-rw-r--r--xdiff-interface.c19
-rw-r--r--xdiff-interface.h1
16 files changed, 1040 insertions, 89 deletions
diff --git a/Documentation/Makefile b/Documentation/Makefile
index d68bc4a78..93c7024b4 100644
--- a/Documentation/Makefile
+++ b/Documentation/Makefile
@@ -32,6 +32,7 @@ man7dir=$(mandir)/man7
# DESTDIR=
INSTALL?=install
+DOC_REF = origin/man
-include ../config.mak.autogen
@@ -112,3 +113,6 @@ $(patsubst %.txt,%.html,$(wildcard howto/*.txt)): %.html : %.txt
install-webdoc : html
sh ./install-webdoc.sh $(WEBDOC_DEST)
+
+quick-install:
+ sh ./install-doc-quick.sh $(DOC_REF) $(mandir)
diff --git a/Documentation/install-doc-quick.sh b/Documentation/install-doc-quick.sh
new file mode 100755
index 000000000..a64054948
--- /dev/null
+++ b/Documentation/install-doc-quick.sh
@@ -0,0 +1,31 @@
+#!/bin/sh
+# This requires a branch named in $head
+# (usually 'man' or 'html', provided by the git.git repository)
+set -e
+head="$1"
+mandir="$2"
+SUBDIRECTORY_OK=t
+USAGE='<refname> <target directory>'
+. git-sh-setup
+export GIT_DIR
+
+test -z "$mandir" && usage
+if ! git-rev-parse --verify "$head^0" >/dev/null; then
+ echo >&2 "head: $head does not exist in the current repository"
+ usage
+fi
+
+GIT_INDEX_FILE=`pwd`/.quick-doc.index
+export GIT_INDEX_FILE
+rm -f "$GIT_INDEX_FILE"
+git-read-tree $head
+git-checkout-index -a -f --prefix="$mandir"/
+
+if test -n "$GZ"; then
+ cd "$mandir"
+ for i in `git-ls-tree -r --name-only $head`
+ do
+ gzip < $i > $i.gz && rm $i
+ done
+fi
+rm -f "$GIT_INDEX_FILE"
diff --git a/Makefile b/Makefile
index 4362297e0..8827dee59 100644
--- a/Makefile
+++ b/Makefile
@@ -171,7 +171,6 @@ SCRIPT_SH = \
SCRIPT_PERL = \
git-archimport.perl git-cvsimport.perl git-relink.perl \
- git-rerere.perl \
git-cvsserver.perl \
git-svnimport.perl git-cvsexportcommit.perl \
git-send-email.perl git-svn.perl
@@ -230,7 +229,8 @@ LIB_H = \
archive.h blob.h cache.h commit.h csum-file.h delta.h grep.h \
diff.h object.h pack.h pkt-line.h quote.h refs.h list-objects.h sideband.h \
run-command.h strbuf.h tag.h tree.h git-compat-util.h revision.h \
- tree-walk.h log-tree.h dir.h path-list.h unpack-trees.h builtin.h
+ tree-walk.h log-tree.h dir.h path-list.h unpack-trees.h builtin.h \
+ utf8.h
DIFF_OBJS = \
diff.o diff-lib.o diffcore-break.o diffcore-order.o \
@@ -249,7 +249,8 @@ LIB_OBJS = \
revision.o pager.o tree-walk.o xdiff-interface.o \
write_or_die.o trace.o list-objects.o grep.o \
alloc.o merge-file.o path-list.o help.o unpack-trees.o $(DIFF_OBJS) \
- color.o wt-status.o archive-zip.o archive-tar.o
+ color.o wt-status.o archive-zip.o archive-tar.o \
+ utf8.o
BUILTIN_OBJS = \
builtin-add.o \
@@ -286,6 +287,7 @@ BUILTIN_OBJS = \
builtin-push.o \
builtin-read-tree.o \
builtin-repo-config.o \
+ builtin-rerere.o \
builtin-rev-list.o \
builtin-rev-parse.o \
builtin-rm.o \
@@ -824,6 +826,8 @@ install: all
install-doc:
$(MAKE) -C Documentation install
+quick-install-doc:
+ $(MAKE) -C Documentation quick-install
diff --git a/builtin-commit-tree.c b/builtin-commit-tree.c
index bc2877066..f64178798 100644
--- a/builtin-commit-tree.c
+++ b/builtin-commit-tree.c
@@ -7,6 +7,7 @@
#include "commit.h"
#include "tree.h"
#include "builtin.h"
+#include "utf8.h"
#define BLOCKING (1ul << 14)
@@ -32,7 +33,7 @@ static void add_buffer(char **bufp, unsigned int *sizep, const char *fmt, ...)
len = vsnprintf(one_line, sizeof(one_line), fmt, args);
va_end(args);
size = *sizep;
- newsize = size + len;
+ newsize = size + len + 1;
alloc = (size + 32767) & ~32767;
buf = *bufp;
if (newsize > alloc) {
@@ -40,7 +41,7 @@ static void add_buffer(char **bufp, unsigned int *sizep, const char *fmt, ...)
buf = xrealloc(buf, alloc);
*bufp = buf;
}
- *sizep = newsize;
+ *sizep = newsize - 1;
memcpy(buf + size, one_line, len);
}
@@ -77,6 +78,11 @@ static int new_parent(int idx)
return 1;
}
+static const char commit_utf8_warn[] =
+"Warning: commit message does not conform to UTF-8.\n"
+"You may want to amend it after fixing the message, or set the config\n"
+"variable i18n.commitencoding to the encoding your project uses.\n";
+
int cmd_commit_tree(int argc, const char **argv, const char *prefix)
{
int i;
@@ -130,6 +136,11 @@ int cmd_commit_tree(int argc, const char **argv, const char *prefix)
while (fgets(comment, sizeof(comment), stdin) != NULL)
add_buffer(&buffer, &size, "%s", comment);
+ /* And check the encoding */
+ buffer[size] = '\0';
+ if (!strcmp(git_commit_encoding, "utf-8") && !is_utf8(buffer))
+ fprintf(stderr, commit_utf8_warn);
+
if (!write_sha1_file(buffer, size, commit_type, commit_sha1)) {
printf("%s\n", sha1_to_hex(commit_sha1));
return 0;
diff --git a/builtin-merge-file.c b/builtin-merge-file.c
index 6c4c3a351..913577390 100644
--- a/builtin-merge-file.c
+++ b/builtin-merge-file.c
@@ -1,26 +1,10 @@
#include "cache.h"
#include "xdiff/xdiff.h"
+#include "xdiff-interface.h"
static const char merge_file_usage[] =
"git merge-file [-p | --stdout] [-q | --quiet] [-L name1 [-L orig [-L name2]]] file1 orig_file file2";
-static int read_file(mmfile_t *ptr, const char *filename)
-{
- struct stat st;
- FILE *f;
-
- if (stat(filename, &st))
- return error("Could not stat %s", filename);
- if ((f = fopen(filename, "rb")) == NULL)
- return error("Could not open %s", filename);
- ptr->ptr = xmalloc(st.st_size);
- if (fread(ptr->ptr, st.st_size, 1, f) != 1)
- return error("Could not read %s", filename);
- fclose(f);
- ptr->size = st.st_size;
- return 0;
-}
-
int cmd_merge_file(int argc, char **argv, char **envp)
{
char *names[3];
@@ -53,7 +37,7 @@ int cmd_merge_file(int argc, char **argv, char **envp)
names[i] = argv[i + 1];
for (i = 0; i < 3; i++)
- if (read_file(mmfs + i, argv[i + 1]))
+ if (read_mmfile(mmfs + i, argv[i + 1]))
return -1;
ret = xdl_merge(mmfs + 1, mmfs + 0, names[0], mmfs + 2, names[2],
diff --git a/builtin-rerere.c b/builtin-rerere.c
new file mode 100644
index 000000000..d064bd8bf
--- /dev/null
+++ b/builtin-rerere.c
@@ -0,0 +1,406 @@
+#include "cache.h"
+#include "path-list.h"
+#include "xdiff/xdiff.h"
+#include "xdiff-interface.h"
+
+#include <time.h>
+
+static const char git_rerere_usage[] =
+"git-rerere [clear | status | diff | gc]";
+
+/* these values are days */
+static int cutoff_noresolve = 15;
+static int cutoff_resolve = 60;
+
+static char *merge_rr_path;
+
+static const char *rr_path(const char *name, const char *file)
+{
+ return git_path("rr-cache/%s/%s", name, file);
+}
+
+static void read_rr(struct path_list *rr)
+{
+ unsigned char sha1[20];
+ char buf[PATH_MAX];
+ FILE *in = fopen(merge_rr_path, "r");
+ if (!in)
+ return;
+ while (fread(buf, 40, 1, in) == 1) {
+ int i;
+ char *name;
+ if (get_sha1_hex(buf, sha1))
+ die("corrupt MERGE_RR");
+ buf[40] = '\0';
+ name = xstrdup(buf);
+ if (fgetc(in) != '\t')
+ die("corrupt MERGE_RR");
+ for (i = 0; i < sizeof(buf) && (buf[i] = fgetc(in)); i++)
+ ; /* do nothing */
+ if (i == sizeof(buf))
+ die("filename too long");
+ path_list_insert(buf, rr)->util = xstrdup(name);
+ }
+ fclose(in);
+}
+
+static struct lock_file write_lock;
+
+static int write_rr(struct path_list *rr, int out_fd)
+{
+ int i;
+ for (i = 0; i < rr->nr; i++) {
+ const char *path = rr->items[i].path;
+ write(out_fd, rr->items[i].util, 40);
+ write(out_fd, "\t", 1);
+ write(out_fd, path, strlen(path) + 1);
+ }
+ close(out_fd);
+ return commit_lock_file(&write_lock);
+}
+
+struct buffer {
+ char *ptr;
+ int nr, alloc;
+};
+
+static void append_line(struct buffer *buffer, const char *line)
+{
+ int len = strlen(line);
+
+ if (buffer->nr + len > buffer->alloc) {
+ buffer->alloc = alloc_nr(buffer->nr + len);
+ buffer->ptr = xrealloc(buffer->ptr, buffer->alloc);
+ }
+ memcpy(buffer->ptr + buffer->nr, line, len);
+ buffer->nr += len;
+}
+
+static int handle_file(const char *path,
+ unsigned char *sha1, const char *output)
+{
+ SHA_CTX ctx;
+ char buf[1024];
+ int hunk = 0, hunk_no = 0;
+ struct buffer minus = { NULL, 0, 0 }, plus = { NULL, 0, 0 };
+ struct buffer *one = &minus, *two = &plus;
+ FILE *f = fopen(path, "r");
+ FILE *out;
+
+ if (!f)
+ return error("Could not open %s", path);
+
+ if (output) {
+ out = fopen(output, "w");
+ if (!out) {
+ fclose(f);
+ return error("Could not write %s", output);
+ }
+ } else
+ out = NULL;
+
+ if (sha1)
+ SHA1_Init(&ctx);
+
+ while (fgets(buf, sizeof(buf), f)) {
+ if (!strncmp("<<<<<<< ", buf, 8))
+ hunk = 1;
+ else if (!strncmp("=======", buf, 7))
+ hunk = 2;
+ else if (!strncmp(">>>>>>> ", buf, 8)) {
+ hunk_no++;
+ hunk = 0;
+ if (memcmp(one->ptr, two->ptr, one->nr < two->nr ?
+ one->nr : two->nr) > 0) {
+ struct buffer *swap = one;
+ one = two;
+ two = swap;
+ }
+ if (out) {
+ fputs("<<<<<<<\n", out);
+ fwrite(one->ptr, one->nr, 1, out);
+ fputs("=======\n", out);
+ fwrite(two->ptr, two->nr, 1, out);
+ fputs(">>>>>>>\n", out);
+ }
+ if (sha1) {
+ SHA1_Update(&ctx, one->ptr, one->nr);
+ SHA1_Update(&ctx, "\0", 1);
+ SHA1_Update(&ctx, two->ptr, two->nr);
+ SHA1_Update(&ctx, "\0", 1);
+ }
+ } else if (hunk == 1)
+ append_line(one, buf);
+ else if (hunk == 2)
+ append_line(two, buf);
+ else if (out)
+ fputs(buf, out);
+ }
+
+ fclose(f);
+ if (out)
+ fclose(out);
+ if (sha1)
+ SHA1_Final(sha1, &ctx);
+ return hunk_no;
+}
+
+static int find_conflict(struct path_list *conflict)
+{
+ int i;
+ if (read_cache() < 0)
+ return error("Could not read index");
+ for (i = 0; i + 2 < active_nr; i++) {
+ struct cache_entry *e1 = active_cache[i];
+ struct cache_entry *e2 = active_cache[i + 1];
+ struct cache_entry *e3 = active_cache[i + 2];
+ if (ce_stage(e1) == 1 && ce_stage(e2) == 2 &&
+ ce_stage(e3) == 3 && ce_same_name(e1, e2) &&
+ ce_same_name(e1, e3)) {
+ path_list_insert((const char *)e1->name, conflict);
+ i += 3;
+ }
+ }
+ return 0;
+}
+
+static int merge(const char *name, const char *path)
+{
+ int ret;
+ mmfile_t cur, base, other;
+ mmbuffer_t result = {NULL, 0};
+ xpparam_t xpp = {XDF_NEED_MINIMAL};
+
+ if (handle_file(path, NULL, rr_path(name, "thisimage")) < 0)
+ return 1;
+
+ if (read_mmfile(&cur, rr_path(name, "thisimage")) ||
+ read_mmfile(&base, rr_path(name, "preimage")) ||
+ read_mmfile(&other, rr_path(name, "postimage")))
+ return 1;
+ ret = xdl_merge(&base, &cur, "", &other, "",
+ &xpp, XDL_MERGE_ZEALOUS, &result);
+ if (!ret) {
+ FILE *f = fopen(path, "w");
+ if (!f)
+ return error("Could not write to %s", path);
+ fwrite(result.ptr, result.size, 1, f);
+ fclose(f);
+ }
+
+ free(cur.ptr);
+ free(base.ptr);
+ free(other.ptr);
+ free(result.ptr);
+
+ return ret;
+}
+
+static void unlink_rr_item(const char *name)
+{
+ unlink(rr_path(name, "thisimage"));
+ unlink(rr_path(name, "preimage"));
+ unlink(rr_path(name, "postimage"));
+ rmdir(git_path("rr-cache/%s", name));
+}
+
+static void garbage_collect(struct path_list *rr)
+{
+ struct path_list to_remove = { NULL, 0, 0, 1 };
+ char buf[1024];
+ DIR *dir;
+ struct dirent *e;
+ int len, i, cutoff;
+ time_t now = time(NULL), then;
+
+ strlcpy(buf, git_path("rr-cache"), sizeof(buf));
+ len = strlen(buf);
+ dir = opendir(buf);
+ strcpy(buf + len++, "/");
+ while ((e = readdir(dir))) {
+ const char *name = e->d_name;
+ struct stat st;
+ if (name[0] == '.' && (name[1] == '\0' ||
+ (name[1] == '.' && name[2] == '\0')))
+ continue;
+ i = snprintf(buf + len, sizeof(buf) - len, "%s", name);
+ strlcpy(buf + len + i, "/preimage", sizeof(buf) - len - i);
+ if (stat(buf, &st))
+ continue;
+ then = st.st_mtime;
+ strlcpy(buf + len + i, "/postimage", sizeof(buf) - len - i);
+ cutoff = stat(buf, &st) ? cutoff_noresolve : cutoff_resolve;
+ if (then < now - cutoff * 86400) {
+ buf[len + i] = '\0';
+ path_list_insert(xstrdup(name), &to_remove);
+ }
+ }
+ for (i = 0; i < to_remove.nr; i++)
+ unlink_rr_item(to_remove.items[i].path);
+ path_list_clear(&to_remove, 0);
+}
+
+static int outf(void *dummy, mmbuffer_t *ptr, int nbuf)
+{
+ int i;
+ for (i = 0; i < nbuf; i++)
+ write(1, ptr[i].ptr, ptr[i].size);
+ return 0;
+}
+
+static int diff_two(const char *file1, const char *label1,
+ const char *file2, const char *label2)
+{
+ xpparam_t xpp;
+ xdemitconf_t xecfg;
+ xdemitcb_t ecb;
+ mmfile_t minus, plus;
+
+ if (read_mmfile(&minus, file1) || read_mmfile(&plus, file2))
+ return 1;
+
+ printf("--- a/%s\n+++ b/%s\n", label1, label2);
+ fflush(stdout);
+ xpp.flags = XDF_NEED_MINIMAL;
+ xecfg.ctxlen = 3;
+ xecfg.flags = 0;
+ ecb.outf = outf;
+ xdl_diff(&minus, &plus, &xpp, &xecfg, &ecb);
+
+ free(minus.ptr);
+ free(plus.ptr);
+ return 0;
+}
+
+static int copy_file(const char *src, const char *dest)
+{
+ FILE *in, *out;
+ char buffer[32768];
+ int count;
+
+ if (!(in = fopen(src, "r")))
+ return error("Could not open %s", src);
+ if (!(out = fopen(dest, "w")))
+ return error("Could not open %s", dest);
+ while ((count = fread(buffer, 1, sizeof(buffer), in)))
+ fwrite(buffer, 1, count, out);
+ fclose(in);
+ fclose(out);
+ return 0;
+}
+
+static int do_plain_rerere(struct path_list *rr, int fd)
+{
+ struct path_list conflict = { NULL, 0, 0, 1 };
+ int i;
+
+ find_conflict(&conflict);
+
+ /*
+ * MERGE_RR records paths with conflicts immediately after merge
+ * failed. Some of the conflicted paths might have been hand resolved
+ * in the working tree since then, but the initial run would catch all
+ * and register their preimages.
+ */
+
+ for (i = 0; i < conflict.nr; i++) {
+ const char *path = conflict.items[i].path;
+ if (!path_list_has_path(rr, path)) {
+ unsigned char sha1[20];
+ char *hex;
+ int ret;
+ ret = handle_file(path, sha1, NULL);
+ if (ret < 1)
+ continue;
+ hex = xstrdup(sha1_to_hex(sha1));
+ path_list_insert(path, rr)->util = hex;
+ if (mkdir(git_path("rr-cache/%s", hex), 0755))
+ continue;;
+ handle_file(path, NULL, rr_path(hex, "preimage"));
+ fprintf(stderr, "Recorded preimage for '%s'\n", path);
+ }
+ }
+
+ /*
+ * Now some of the paths that had conflicts earlier might have been
+ * hand resolved. Others may be similar to a conflict already that
+ * was resolved before.
+ */
+
+ for (i = 0; i < rr->nr; i++) {
+ struct stat st;
+ int ret;
+ const char *path = rr->items[i].path;
+ const char *name = (const char *)rr->items[i].util;
+
+ if (!stat(rr_path(name, "preimage"), &st) &&
+ !stat(rr_path(name, "postimage"), &st)) {
+ if (!merge(name, path)) {
+ fprintf(stderr, "Resolved '%s' using "
+ "previous resolution.\n", path);
+ goto tail_optimization;
+ }
+ }
+
+ /* Let's see if we have resolved it. */
+ ret = handle_file(path, NULL, NULL);
+ if (ret)
+ continue;
+
+ fprintf(stderr, "Recorded resolution for '%s'.\n", path);
+ copy_file(path, rr_path(name, "postimage"));
+tail_optimization:
+ if (i < rr->nr - 1) {
+ memmove(rr->items + i,
+ rr->items + i + 1,
+ rr->nr - i - 1);
+ }
+ rr->nr--;
+ i--;
+ }
+
+ return write_rr(rr, fd);
+}
+
+int cmd_rerere(int argc, const char **argv, const char *prefix)
+{
+ struct path_list merge_rr = { NULL, 0, 0, 1 };
+ int i, fd = -1;
+ struct stat st;
+
+ if (stat(git_path("rr-cache"), &st) || !S_ISDIR(st.st_mode))
+ return 0;
+
+ merge_rr_path = xstrdup(git_path("rr-cache/MERGE_RR"));
+ fd = hold_lock_file_for_update(&write_lock, merge_rr_path, 1);
+ read_rr(&merge_rr);
+
+ if (argc < 2)
+ return do_plain_rerere(&merge_rr, fd);
+ else if (!strcmp(argv[1], "clear")) {
+ for (i = 0; i < merge_rr.nr; i++) {
+ const char *name = (const char *)merge_rr.items[i].util;
+ if (!stat(git_path("rr-cache/%s", name), &st) &&
+ S_ISDIR(st.st_mode) &&
+ stat(rr_path(name, "postimage"), &st))
+ unlink_rr_item(name);
+ }
+ unlink(merge_rr_path);
+ } else if (!strcmp(argv[1], "gc"))
+ garbage_collect(&merge_rr);
+ else if (!strcmp(argv[1], "status"))
+ for (i = 0; i < merge_rr.nr; i++)
+ printf("%s\n", merge_rr.items[i].path);
+ else if (!strcmp(argv[1], "diff"))
+ for (i = 0; i < merge_rr.nr; i++) {
+ const char *path = merge_rr.items[i].path;
+ const char *name = (const char *)merge_rr.items[i].util;
+ diff_two(rr_path(name, "preimage"), path, path, path);
+ }
+ else
+ usage(git_rerere_usage);
+
+ path_list_clear(&merge_rr, 1);
+ return 0;
+}
+
diff --git a/builtin.h b/builtin.h
index 08519e7c8..8ffd8b265 100644
--- a/builtin.h
+++ b/builtin.h
@@ -52,6 +52,7 @@ extern int cmd_prune_packed(int argc, const char **argv, const char *prefix);
extern int cmd_push(int argc, const char **argv, const char *prefix);
extern int cmd_read_tree(int argc, const char **argv, const char *prefix);
extern int cmd_repo_config(int argc, const char **argv, const char *prefix);
+extern int cmd_rerere(int argc, const char **argv, const char *prefix);
extern int cmd_rev_list(int argc, const char **argv, const char *prefix);
extern int cmd_rev_parse(int argc, const char **argv, const char *prefix);
extern int cmd_rm(int argc, const char **argv, const char *prefix);
diff --git a/compat/mmap.c b/compat/mmap.c
index 0fd46e793..4cfaee313 100644
--- a/compat/mmap.c
+++ b/compat/mmap.c
@@ -1,17 +1,11 @@
#include "../git-compat-util.h"
-void *gitfakemmap(void *start, size_t length, int prot , int flags, int fd, off_t offset)
+void *git_mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset)
{
- int n = 0;
- off_t current_offset = lseek(fd, 0, SEEK_CUR);
+ size_t n = 0;
if (start != NULL || !(flags & MAP_PRIVATE))
- die("Invalid usage of gitfakemmap.");
-
- if (lseek(fd, offset, SEEK_SET) < 0) {
- errno = EINVAL;
- return MAP_FAILED;
- }
+ die("Invalid usage of mmap when built with NO_MMAP");
start = xmalloc(length);
if (start == NULL) {
@@ -20,14 +14,16 @@ void *gitfakemmap(void *start, size_t length, int prot , int flags, int fd, off_
}
while (n < length) {
- int count = read(fd, start+n, length-n);
+ ssize_t count = pread(fd, (char *)start + n, length - n, offset + n);
if (count == 0) {
- memset(start+n, 0, length-n);
+ memset((char *)start+n, 0, length-n);
break;
}
if (count < 0) {
+ if (errno == EAGAIN || errno == EINTR)
+ continue;
free(start);
errno = EACCES;
return MAP_FAILED;
@@ -36,15 +32,10 @@ void *gitfakemmap(void *start, size_t length, int prot , int flags, int fd, off_
n += count;
}
- if (current_offset != lseek(fd, current_offset, SEEK_SET)) {
- errno = EINVAL;
- return MAP_FAILED;
- }
-
return start;
}
-int gitfakemunmap(void *start, size_t length)
+int git_munmap(void *start, size_t length)
{
free(start);
return 0;
diff --git a/git-compat-util.h b/git-compat-util.h
index f79365b36..5d9eb2615 100644
--- a/git-compat-util.h
+++ b/git-compat-util.h
@@ -87,10 +87,10 @@ extern void set_warn_routine(void (*routine)(const char *warn, va_list params));
#define MAP_FAILED ((void*)-1)
#endif
-#define mmap gitfakemmap
-#define munmap gitfakemunmap
-extern void *gitfakemmap(void *start, size_t length, int prot , int flags, int fd, off_t offset);
-extern int gitfakemunmap(void *start, size_t length);
+#define mmap git_mmap
+#define munmap git_munmap
+extern void *git_mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
+extern int git_munmap(void *start, size_t length);
#else /* NO_MMAP */
diff --git a/git.c b/git.c
index 7bb61d837..e732a098f 100644
--- a/git.c
+++ b/git.c
@@ -247,6 +247,7 @@ static void handle_internal_command(int argc, const char **argv, char **envp)
{ "push", cmd_push, RUN_SETUP },
{ "read-tree", cmd_read_tree, RUN_SETUP },
{ "repo-config", cmd_repo_config },
+ { "rerere", cmd_rerere, RUN_SETUP },
{ "rev-list", cmd_rev_list, RUN_SETUP },
{ "rev-parse", cmd_rev_parse, RUN_SETUP },
{ "rm", cmd_rm, RUN_SETUP },
diff --git a/gitweb/gitweb.perl b/gitweb/gitweb.perl
index 9a4f3b484..d01d68934 100755
--- a/gitweb/gitweb.perl
+++ b/gitweb/gitweb.perl
@@ -2852,6 +2852,58 @@ sub git_heads_body {
print "</table>\n";
}
+sub git_search_grep_body {
+ my ($greplist, $from, $to, $extra) = @_;
+ $from = 0 unless defined $from;
+ $to = $#{$greplist} if (!defined $to || $#{$greplist} < $to);
+
+ print "<table class=\"grep\" cellspacing=\"0\">\n";
+ my $alternate = 1;
+ for (my $i = $from; $i <= $to; $i++) {
+ my $commit = $greplist->[$i];
+ my %co = parse_commit($commit);
+ if (!%co) {
+ next;
+ }
+ if ($alternate) {
+ print "<tr class=\"dark\">\n";
+ } else {
+ print "<tr class=\"light\">\n";
+ }
+ $alternate ^= 1;
+ print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
+ "<td><i>" . esc_html(chop_str($co{'author_name'}, 15, 5)) . "</i></td>\n" .
+ "<td>" .
+ $cgi->a({-href => href(action=>"commit", hash=>$co{'id'}), -class => "list subject"},
+ esc_html(chop_str($co{'title'}, 50)) . "<br/>");
+ my $comment = $co{'comment'};
+ foreach my $line (@$comment) {
+ if ($line =~ m/^(.*)($searchtext)(.*)$/i) {
+ my $lead = esc_html($1) || "";
+ $lead = chop_str($lead, 30, 10);
+ my $match = esc_html($2) || "";
+ my $trail = esc_html($3) || "";
+ $trail = chop_str($trail, 30, 10);
+ my $text = "$lead<span class=\"match\">$match</span>$trail";
+ print chop_str($text, 80, 5) . "<br/>\n";
+ }
+ }
+ print "</td>\n" .
+ "<td class=\"link\">" .
+ $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
+ " | " .
+ $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
+ print "</td>\n" .
+ "</tr>\n";
+ }
+ if (defined $extra) {
+ print "<tr>\n" .
+ "<td colspan=\"3\">$extra</td>\n" .
+ "</tr>\n";
+ }
+ print "</table>\n";
+}
+
## ======================================================================
## ======================================================================
## actions
@@ -4174,6 +4226,9 @@ sub git_search {
if (!%co) {
die_error(undef, "Unknown commit object");
}
+ if (!defined $page) {
+ $page = 0;
+ }
$searchtype ||= 'commit';
if ($searchtype eq 'pickaxe') {
@@ -4186,11 +4241,7 @@ sub git_search {
}
git_header_html();
- git_print_page_nav('','', $hash,$co{'tree'},$hash);
- git_print_header_div('commit', esc_html($co{'title'}), $hash);
- print "<table cellspacing=\"0\">\n";
- my $alternate = 1;
if ($searchtype eq 'commit' or $searchtype eq 'author' or $searchtype eq 'committer') {
my $greptype;
if ($searchtype eq 'commit') {
@@ -4200,52 +4251,58 @@ sub git_search {
} elsif ($searchtype eq 'committer') {
$greptype = "--committer=";
}
- $/ = "\0";
open my $fd, "-|", git_cmd(), "rev-list",
- "--header", "--parents", ($greptype . $searchtext),
- $hash, "--"
+ ("--max-count=" . (100 * ($page+1))),
+ ($greptype . $searchtext),
+ $hash, "--"
or next;
- while (my $commit_text = <$fd>) {
- my @commit_lines = split "\n", $commit_text;
- my %co = parse_commit(undef, \@commit_lines);
- if (!%co) {
- next;
- }
- if ($alternate) {
- print "<tr class=\"dark\">\n";
- } else {
- print "<tr class=\"light\">\n";
- }
- $alternate ^= 1;
- print "<td title=\"$co{'age_string_age'}\"><i>$co{'age_string_date'}</i></td>\n" .
- "<td><i>" . esc_html(chop_str($co{'author_name'}, 15, 5)) . "</i></td>\n" .
- "<td>" .
- $cgi->a({-href => href(action=>"commit", hash=>$co{'id'}), -class => "list subject"},
- esc_html(chop_str($co{'title'}, 50)) . "<br/>");
- my $comment = $co{'comment'};
- foreach my $line (@$comment) {
- if ($line =~ m/^(.*)($searchtext)(.*)$/i) {
- my $lead = esc_html($1) || "";
- $lead = chop_str($lead, 30, 10);
- my $match = esc_html($2) || "";
- my $trail = esc_html($3) || "";
- $trail = chop_str($trail, 30, 10);
- my $text = "$lead<span class=\"match\">$match</span>$trail";
- print chop_str($text, 80, 5) . "<br/>\n";
- }
- }
- print "</td>\n" .
- "<td class=\"link\">" .
- $cgi->a({-href => href(action=>"commit", hash=>$co{'id'})}, "commit") .
- " | " .
- $cgi->a({-href => href(action=>"tree", hash=>$co{'tree'}, hash_base=>$co{'id'})}, "tree");
- print "</td>\n" .
- "</tr>\n";
- }
+ my @revlist = map { chomp; $_ } <$fd>;
close $fd;
+
+ my $paging_nav = '';
+ if ($page > 0) {
+ $paging_nav .=
+ $cgi->a({-href => href(action=>"search", hash=>$hash,
+ searchtext=>$searchtext, searchtype=>$searchtype)},
+ "first");
+ $paging_nav .= " &sdot; " .
+ $cgi->a({-href => href(action=>"search", hash=>$hash,
+ searchtext=>$searchtext, searchtype=>$searchtype,
+ page=>$page-1),
+ -accesskey => "p", -title => "Alt-p"}, "prev");
+ } else {
+ $paging_nav .= "first";
+ $paging_nav .= " &sdot; prev";
+ }
+ if ($#revlist >= (100 * ($page+1)-1)) {
+ $paging_nav .= " &sdot; " .
+ $cgi->a({-href => href(action=>"search", hash=>$hash,
+ searchtext=>$searchtext, searchtype=>$searchtype,
+ page=>$page+1),
+ -accesskey => "n", -title => "Alt-n"}, "next");
+ } else {
+ $paging_nav .= " &sdot; next";
+ }
+ my $next_link = '';
+ if ($#revlist >= (100 * ($page+1)-1)) {
+ $next_link =
+ $cgi->a({-href => href(action=>"search", hash=>$hash,
+ searchtext=>$searchtext, searchtype=>$searchtype,
+ page=>$page+1),
+ -accesskey => "n", -title => "Alt-n"}, "next");
+ }
+
+ git_print_page_nav('','', $hash,$co{'tree'},$hash, $paging_nav);
+ git_print_header_div('commit', esc_html($co{'title'}), $hash);
+ git_search_grep_body(\@revlist, ($page * 100), $#revlist, $next_link);
}
if ($searchtype eq 'pickaxe') {
+ git_print_page_nav('','', $hash,$co{'tree'},$hash);
+ git_print_header_div('commit', esc_html($co{'title'}), $hash);
+
+ print "<table cellspacing=\"0\">\n";
+ my $alternate = 1;
$/ = "\n";
my $git_command = git_cmd_str();
open my $fd, "-|", "$git_command rev-list $hash | " .
@@ -4300,8 +4357,9 @@ sub git_search {
}
}
close $fd;
+
+ print "</table>\n";
}
- print "</table>\n";
git_footer_html();
}
diff --git a/t/t4200-rerere.sh b/t/t4200-rerere.sh
new file mode 100755
index 000000000..5ee5b2309
--- /dev/null
+++ b/t/t4200-rerere.sh
@@ -0,0 +1,154 @@
+#!/bin/sh
+#
+# Copyright (c) 2006 Johannes E. Schindelin
+#
+
+test_description='git-rerere
+'
+
+. ./test-lib.sh
+
+cat > a1 << EOF
+Whether 'tis nobler in the mind to suffer
+The slings and arrows of outrageous fortune,
+Or to take arms against a sea of troubles,
+And by opposing end them? To die: to sleep;
+No more; and by a sleep to say we end
+The heart-ache and the thousand natural shocks
+That flesh is heir to, 'tis a consummation
+Devoutly to be wish'd.
+EOF
+
+git add a1
+git commit -q -a -m initial
+
+git checkout -b first
+cat >> a1 << EOF
+To die, to sleep;
+To sleep: perchance to dream: ay, there's the rub;
+For in that sleep of death what dreams may come
+When we have shuffled off this mortal coil,
+Must give us pause: there's the respect
+That makes calamity of so long life;
+EOF
+git commit -q -a -m first
+
+git checkout -b second master
+git show first:a1 | sed 's/To die, t/To die! T/' > a1
+git commit -q -a -m second
+
+# activate rerere
+mkdir .git/rr-cache
+
+test_expect_failure 'conflicting merge' 'git pull . first'
+
+sha1=4f58849a60b4f969a2848966b6d02893b783e8fb
+rr=.git/rr-cache/$sha1
+test_expect_success 'recorded preimage' "grep ======= $rr/preimage"
+
+test_expect_success 'no postimage or thisimage yet' \
+ "test ! -f $rr/postimage -a ! -f $rr/thisimage"
+
+git show first:a1 > a1
+
+cat > expect << EOF
+--- a/a1
++++ b/a1
+@@ -6,11 +6,7 @@
+ The heart-ache and the thousand natural shocks
+ That flesh is heir to, 'tis a consummation
+ Devoutly to be wish'd.
+-<<<<<<<
+-To die! To sleep;
+-=======
+ To die, to sleep;
+->>>>>>>
+ To sleep: perchance to dream: ay, there's the rub;
+ For in that sleep of death what dreams may come
+ When we have shuffled off this mortal coil,
+EOF
+
+git rerere diff > out
+
+test_expect_success 'rerere diff' 'diff -u expect out'
+
+cat > expect << EOF
+a1
+EOF
+
+git rerere status > out
+
+test_expect_success 'rerere status' 'diff -u expect out'
+
+test_expect_success 'commit succeeds' \
+ "git commit -q -a -m 'prefer first over second'"
+
+test_expect_success 'recorded postimage' "test -f $rr/postimage"
+
+git checkout -b third master
+git show second^:a1 | sed 's/To die: t/To die! T/' > a1
+git commit -q -a -m third
+
+test_expect_failure 'another conflicting merge' 'git pull . first'
+
+git show first:a1 | sed 's/To die: t/To die! T/' > expect
+test_expect_success 'rerere kicked in' "! grep ======= a1"
+
+test_expect_success 'rerere prefers first change' 'diff -u a1 expect'
+
+rm $rr/postimage
+echo "$sha1 a1" | tr '\012' '\0' > .git/rr-cache/MERGE_RR
+
+test_expect_success 'rerere clear' 'git rerere clear'
+
+test_expect_success 'clear removed the directory' "test ! -d $rr"
+
+mkdir $rr
+echo Hello > $rr/preimage
+echo World > $rr/postimage
+
+sha2=4000000000000000000000000000000000000000
+rr2=.git/rr-cache/$sha2
+mkdir $rr2
+echo Hello > $rr2/preimage
+
+case "$(date -d @11111111 +%s 2>/dev/null)" in
+[1-9]*)
+ # it is a recent GNU date. good.
+ now=$(date +%s)
+ almost_15_days_ago=$(($now+60-15*86400))
+ just_over_15_days_ago=$(($now-1-15*86400))
+ almost_60_days_ago=$(($now+60-60*86400))
+ just_over_60_days_ago=$(($now-1-60*86400))
+ predate1="$(date -d "@$almost_60_days_ago" +%c)"
+ predate2="$(date -d "@$almost_15_days_ago" +%c)"
+ postdate1="$(date -d "@$just_over_60_days_ago" +%c)"
+ postdate2="$(date -d "@$just_over_15_days_ago" +%c)"
+ ;;
+*)
+ # it is not GNU date. oh, well.
+ predate1="$(date)"
+ predate2="$(date)"
+ postdate1='1 Oct 2006 00:00:00'
+ postdate2='1 Dec 2006 00:00:00'
+esac
+
+touch -m -d "$predate1" $rr/preimage
+touch -m -d "$predate2" $rr2/preimage
+
+test_expect_success 'garbage collection (part1)' 'git rerere gc'
+
+test_expect_success 'young records still live' \
+ "test -f $rr/preimage -a -f $rr2/preimage"
+
+touch -m -d "$postdate1" $rr/preimage
+touch -m -d "$postdate2" $rr2/preimage
+
+test_expect_success 'garbage collection (part2)' 'git rerere gc'
+
+test_expect_success 'old records rest in peace' \
+ "test ! -f $rr/preimage -a ! -f $rr2/preimage"
+
+test_done
+
+
diff --git a/utf8.c b/utf8.c
new file mode 100644
index 000000000..8fa62571a
--- /dev/null
+++ b/utf8.c
@@ -0,0 +1,278 @@
+#include "git-compat-util.h"
+#include "utf8.h"
+
+/* This code is originally from http://www.cl.cam.ac.uk/~mgk25/ucs/ */
+
+struct interval {
+ int first;
+ int last;
+};
+
+/* auxiliary function for binary search in interval table */
+static int bisearch(wchar_t ucs, const struct interval *table, int max) {
+ int min = 0;
+ int mid;
+
+ if (ucs < table[0].first || ucs > table[max].last)
+ return 0;
+ while (max >= min) {
+ mid = (min + max) / 2;
+ if (ucs > table[mid].last)
+ min = mid + 1;
+ else if (ucs < table[mid].first)
+ max = mid - 1;
+ else
+ return 1;
+ }
+
+ return 0;
+}
+
+/* The following two functions define the column width of an ISO 10646
+ * character as follows:
+ *
+ * - The null character (U+0000) has a column width of 0.
+ *
+ * - Other C0/C1 control characters and DEL will lead to a return
+ * value of -1.
+ *
+ * - Non-spacing and enclosing combining characters (general
+ * category code Mn or Me in the Unicode database) have a
+ * column width of 0.
+ *
+ * - SOFT HYPHEN (U+00AD) has a column width of 1.
+ *
+ * - Other format characters (general category code Cf in the Unicode
+ * database) and ZERO WIDTH SPACE (U+200B) have a column width of 0.
+ *
+ * - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
+ * have a column width of 0.
+ *
+ * - Spacing characters in the East Asian Wide (W) or East Asian
+ * Full-width (F) category as defined in Unicode Technical
+ * Report #11 have a column width of 2.
+ *
+ * - All remaining characters (including all printable
+ * ISO 8859-1 and WGL4 characters, Unicode control characters,
+ * etc.) have a column width of 1.
+ *
+ * This implementation assumes that wchar_t characters are encoded
+ * in ISO 10646.
+ */
+
+static int wcwidth(wchar_t ch)
+{
+ /*
+ * Sorted list of non-overlapping intervals of non-spacing characters,
+ * generated by
+ * "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c".
+ */
+ static const struct interval combining[] = {
+ { 0x0300, 0x0357 }, { 0x035D, 0x036F }, { 0x0483, 0x0486 },
+ { 0x0488, 0x0489 }, { 0x0591, 0x05A1 }, { 0x05A3, 0x05B9 },
+ { 0x05BB, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 },
+ { 0x05C4, 0x05C4 }, { 0x0600, 0x0603 }, { 0x0610, 0x0615 },
+ { 0x064B, 0x0658 }, { 0x0670, 0x0670 }, { 0x06D6, 0x06E4 },
+ { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED }, { 0x070F, 0x070F },
+ { 0x0711, 0x0711 }, { 0x0730, 0x074A }, { 0x07A6, 0x07B0 },
+ { 0x0901, 0x0902 }, { 0x093C, 0x093C }, { 0x0941, 0x0948 },
+ { 0x094D, 0x094D }, { 0x0951, 0x0954 }, { 0x0962, 0x0963 },
+ { 0x0981, 0x0981 }, { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 },
+ { 0x09CD, 0x09CD }, { 0x09E2, 0x09E3 }, { 0x0A01, 0x0A02 },
+ { 0x0A3C, 0x0A3C }, { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 },
+ { 0x0A4B, 0x0A4D }, { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 },
+ { 0x0ABC, 0x0ABC }, { 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 },
+ { 0x0ACD, 0x0ACD }, { 0x0AE2, 0x0AE3 }, { 0x0B01, 0x0B01 },
+ { 0x0B3C, 0x0B3C }, { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 },
+ { 0x0B4D, 0x0B4D }, { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 },
+ { 0x0BC0, 0x0BC0 }, { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 },
+ { 0x0C46, 0x0C48 }, { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 },
+ { 0x0CBC, 0x0CBC }, { 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 },
+ { 0x0CCC, 0x0CCD }, { 0x0D41, 0x0D43 }, { 0x0D4D, 0x0D4D },
+ { 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 },
+ { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E },
+ { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC },
+ { 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 },
+ { 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E },
+ { 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 }, { 0x0F90, 0x0F97 },
+ { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 },
+ { 0x1032, 0x1032 }, { 0x1036, 0x1037 }, { 0x1039, 0x1039 },
+ { 0x1058, 0x1059 }, { 0x1160, 0x11FF }, { 0x1712, 0x1714 },
+ { 0x1732, 0x1734 }, { 0x1752, 0x1753 }, { 0x1772, 0x1773 },
+ { 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD }, { 0x17C6, 0x17C6 },
+ { 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD }, { 0x180B, 0x180D },
+ { 0x18A9, 0x18A9 }, { 0x1920, 0x1922 }, { 0x1927, 0x1928 },
+ { 0x1932, 0x1932 }, { 0x1939, 0x193B }, { 0x200B, 0x200F },
+ { 0x202A, 0x202E }, { 0x2060, 0x2063 }, { 0x206A, 0x206F },
+ { 0x20D0, 0x20EA }, { 0x302A, 0x302F }, { 0x3099, 0x309A },
+ { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F }, { 0xFE20, 0xFE23 },
+ { 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB }, { 0x1D167, 0x1D169 },
+ { 0x1D173, 0x1D182 }, { 0x1D185, 0x1D18B },
+ { 0x1D1AA, 0x1D1AD }, { 0xE0001, 0xE0001 },
+ { 0xE0020, 0xE007F }, { 0xE0100, 0xE01EF }
+ };
+
+ /* test for 8-bit control characters */
+ if (ch == 0)
+ return 0;
+ if (ch < 32 || (ch >= 0x7f && ch < 0xa0))
+ return -1;
+
+ /* binary search in table of non-spacing characters */
+ if (bisearch(ch, combining, sizeof(combining)
+ / sizeof(struct interval) - 1))
+ return 0;
+
+ /*
+ * If we arrive here, ch is neither a combining nor a C0/C1
+ * control character.
+ */
+
+ return 1 +
+ (ch >= 0x1100 &&
+ /* Hangul Jamo init. consonants */
+ (ch <= 0x115f ||
+ ch == 0x2329 || ch == 0x232a ||
+ /* CJK ... Yi */
+ (ch >= 0x2e80 && ch <= 0xa4cf &&
+ ch != 0x303f) ||
+ /* Hangul Syllables */
+ (ch >= 0xac00 && ch <= 0xd7a3) ||
+ /* CJK Compatibility Ideographs */
+ (ch >= 0xf900 && ch <= 0xfaff) ||
+ /* CJK Compatibility Forms */
+ (ch >= 0xfe30 && ch <= 0xfe6f) ||
+ /* Fullwidth Forms */
+ (ch >= 0xff00 && ch <= 0xff60) ||
+ (ch >= 0xffe0 && ch <= 0xffe6) ||
+ (ch >= 0x20000 && ch <= 0x2fffd) ||
+ (ch >= 0x30000 && ch <= 0x3fffd)));
+}
+
+/*
+ * This function returns the number of columns occupied by the character
+ * pointed to by the variable start. The pointer is updated to point at
+ * the next character. If it was not valid UTF-8, the pointer is set to NULL.
+ */
+int utf8_width(const char **start)
+{
+ unsigned char *s = (unsigned char *)*start;
+ wchar_t ch;
+
+ if (*s < 0x80) {
+ /* 0xxxxxxx */
+ ch = *s;
+ *start += 1;
+ } else if ((s[0] & 0xe0) == 0xc0) {
+ /* 110XXXXx 10xxxxxx */
+ if ((s[1] & 0xc0) != 0x80 ||
+ /* overlong? */
+ (s[0] & 0xfe) == 0xc0)
+ goto invalid;
+ ch = ((s[0] & 0x1f) << 6) | (s[1] & 0x3f);
+ *start += 2;
+ } else if ((s[0] & 0xf0) == 0xe0) {
+ /* 1110XXXX 10Xxxxxx 10xxxxxx */
+ if ((s[1] & 0xc0) != 0x80 ||
+ (s[2] & 0xc0) != 0x80 ||
+ /* overlong? */
+ (s[0] == 0xe0 && (s[1] & 0xe0) == 0x80) ||
+ /* surrogate? */
+ (s[0] == 0xed && (s[1] & 0xe0) == 0xa0) ||
+ /* U+FFFE or U+FFFF? */
+ (s[0] == 0xef && s[1] == 0xbf &&
+ (s[2] & 0xfe) == 0xbe))
+ goto invalid;
+ ch = ((s[0] & 0x0f) << 12) |
+ ((s[1] & 0x3f) << 6) | (s[2] & 0x3f);
+ *start += 3;
+ } else if ((s[0] & 0xf8) == 0xf0) {
+ /* 11110XXX 10XXxxxx 10xxxxxx 10xxxxxx */
+ if ((s[1] & 0xc0) != 0x80 ||
+ (s[2] & 0xc0) != 0x80 ||
+ (s[3] & 0xc0) != 0x80 ||
+ /* overlong? */
+ (s[0] == 0xf0 && (s[1] & 0xf0) == 0x80) ||
+ /* > U+10FFFF? */
+ (s[0] == 0xf4 && s[1] > 0x8f) || s[0] > 0xf4)
+ goto invalid;
+ ch = ((s[0] & 0x07) << 18) | ((s[1] & 0x3f) << 12) |
+ ((s[2] & 0x3f) << 6) | (s[3] & 0x3f);
+ *start += 4;
+ } else {
+invalid:
+ *start = NULL;
+ return 0;
+ }
+
+ return wcwidth(ch);
+}
+
+int is_utf8(const char *text)
+{
+ while (*text) {
+ if (*text == '\n' || *text == '\t' || *text == '\r') {
+ text++;
+ continue;
+ }
+ utf8_width(&text);
+ if (!text)
+ return 0;
+ }
+ return 1;
+}
+
+static void print_spaces(int count)
+{
+ static const char s[] = " ";
+ while (count >= sizeof(s)) {
+ fwrite(s, sizeof(s) - 1, 1, stdout);
+ count -= sizeof(s) - 1;
+ }
+ fwrite(s, count, 1, stdout);
+}
+
+/*
+ * Wrap the text, if necessary. The variable indent is the indent for the
+ * first line, indent2 is the indent for all other lines.
+ */
+void print_wrapped_text(const char *text, int indent, int indent2, int width)
+{
+ int w = indent, assume_utf8 = is_utf8(text);
+ const char *bol = text, *space = NULL;
+
+ for (;;) {
+ char c = *text;
+ if (!c || isspace(c)) {
+ if (w < width || !space) {
+ const char *start = bol;
+ if (space)
+ start = space;
+ else
+ print_spaces(indent);
+ fwrite(start, text - start, 1, stdout);
+ if (!c) {
+ putchar('\n');
+ return;
+ } else if (c == '\t')
+ w |= 0x07;
+ space = text;
+ w++;
+ text++;
+ }
+ else {
+ putchar('\n');
+ text = bol = space + 1;
+ space = NULL;
+ w = indent = indent2;
+ }
+ continue;
+ }
+ if (assume_utf8)
+ w += utf8_width(&text);
+ else {
+ w++;
+ text++;
+ }
+ }
+}
diff --git a/utf8.h b/utf8.h
new file mode 100644
index 000000000..a0d7f591a
--- /dev/null
+++ b/utf8.h
@@ -0,0 +1,8 @@
+#ifndef GIT_UTF8_H
+#define GIT_UTF8_H
+
+int utf8_width(const char **start);
+int is_utf8(const char *text);
+void print_wrapped_text(const char *text, int indent, int indent2, int len);
+
+#endif
diff --git a/xdiff-interface.c b/xdiff-interface.c
index 08602f522..6c1f99b14 100644
--- a/xdiff-interface.c
+++ b/xdiff-interface.c
@@ -102,3 +102,22 @@ int xdiff_outf(void *priv_, mmbuffer_t *mb, int nbuf)
}
return 0;
}
+
+int read_mmfile(mmfile_t *ptr, const char *filename)
+{
+ struct stat st;
+ FILE *f;
+
+ if (stat(filename, &st))
+ return error("Could not stat %s", filename);
+ if ((f = fopen(filename, "rb")) == NULL)
+ return error("Could not open %s", filename);
+ ptr->ptr = xmalloc(st.st_size);
+ if (fread(ptr->ptr, st.st_size, 1, f) != 1)
+ return error("Could not read %s", filename);
+ fclose(f);
+ ptr->size = st.st_size;
+ return 0;
+}
+
+
diff --git a/xdiff-interface.h b/xdiff-interface.h
index 1346908be..191880808 100644
--- a/xdiff-interface.h
+++ b/xdiff-interface.h
@@ -17,5 +17,6 @@ int xdiff_outf(void *priv_, mmbuffer_t *mb, int nbuf);
int parse_hunk_header(char *line, int len,
int *ob, int *on,
int *nb, int *nn);
+int read_mmfile(mmfile_t *ptr, const char *filename);
#endif
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-15 05:10:40 +0000