From 5010cb5fcca30269ad25f2eb38b31455af3205d7 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Sun, 30 Apr 2006 23:28:15 -0700
Subject: [PATCH 01/22] built-in "git grep"

This attempts to set up built-in "git grep" to further reduce
our dependence on the shell, while at the same time optionally
allowing to run grep against object database.  You could do
funky things like these:

	git grep --cached -e pattern	;# grep from index
	git grep -e pattern master	;# or in a rev
	git grep -e pattern master next ;# or in multiple revs
	git grep -e pattern pu^@	;# even like this with an
					;# extension from another topic ;-)
	git grep -e pattern master..next ;# or even from rev ranges
	git grep -e pattern master~20:Documentation
					;# or an arbitrary tree
	git grep -e pattern next:git-commit.sh
        				;# or an arbitrary blob

Right now, it does not understand and/or obey many options grep
should accept, and the pattern must be given with -e option due
to the way the parameter parser is structured, both of which
obviously need to be fixed for usability.

But this is going in the right direction.  The shell script
version is one of the worst Portability offender in the git
barebone Porcelainish; it uses xargs -0 to pass paths around and
shell arrays to sift flags and parameters.

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 Makefile       |   2 +-
 builtin-grep.c | 454 +++++++++++++++++++++++++++++++++++++++++++++++++
 builtin.h      |   1 +
 git.c          |   1 +
 4 files changed, 457 insertions(+), 1 deletion(-)
 create mode 100644 builtin-grep.c

diff --git a/Makefile b/Makefile
index 8ce27a65fb..8d5122bdd5 100644
--- a/Makefile
+++ b/Makefile
@@ -214,7 +214,7 @@ LIB_OBJS = \
 	$(DIFF_OBJS)
 
 BUILTIN_OBJS = \
-	builtin-log.o builtin-help.o
+	builtin-log.o builtin-help.o builtin-grep.o
 
 GITLIBS = $(LIB_FILE) $(XDIFF_LIB)
 LIBS = $(GITLIBS) -lz
diff --git a/builtin-grep.c b/builtin-grep.c
new file mode 100644
index 0000000000..36150bf4ef
--- /dev/null
+++ b/builtin-grep.c
@@ -0,0 +1,454 @@
+/*
+ * Builtin "git grep"
+ *
+ * Copyright (c) 2006 Junio C Hamano
+ */
+#include "cache.h"
+#include "blob.h"
+#include "tree.h"
+#include "commit.h"
+#include "tag.h"
+#include "diff.h"
+#include "revision.h"
+#include "builtin.h"
+#include <regex.h>
+
+static int pathspec_matches(struct diff_options *opt, const char *name)
+{
+	int i, j;
+	int namelen;
+	if (!opt->nr_paths)
+		return 1;
+	namelen = strlen(name);
+	for (i = 0; i < opt->nr_paths; i++) {
+		const char *match = opt->paths[i];
+		int matchlen = opt->pathlens[i];
+		if (matchlen <= namelen) {
+			if (!strncmp(name, match, matchlen))
+				return 1;
+			continue;
+		}
+		/* If name is "Documentation" and pathspec is
+		 * "Documentation/", they should match.  Maybe
+		 * we would want to strip it in get_pathspec()???
+		 */
+		if (strncmp(name, match, namelen))
+			continue;
+		for (j = namelen; j < matchlen; j++)
+			if (match[j] != '/')
+				break;
+		if (matchlen <= j)
+			return 1;
+	}
+	return 0;
+}
+
+struct grep_opt {
+	const char *pattern;
+	regex_t regexp;
+	unsigned linenum:1;
+	unsigned invert:1;
+	int regflags;
+	unsigned pre_context;
+	unsigned post_context;
+};
+
+static char *end_of_line(char *cp, unsigned long *left)
+{
+	unsigned long l = *left;
+	while (l && *cp != '\n') {
+		l--;
+		cp++;
+	}
+	*left = l;
+	return cp;
+}
+
+static void show_line(struct grep_opt *opt, const char *bol, const char *eol,
+		      const char *name, unsigned lno, char sign)
+{
+	printf("%s%c", name, sign);
+	if (opt->linenum)
+		printf("%d%c", lno, sign);
+	printf("%.*s\n", eol-bol, bol);
+}
+
+static int grep_buffer(struct grep_opt *opt, const char *name,
+		       char *buf, unsigned long size)
+{
+	char *bol = buf;
+	unsigned long left = size;
+	unsigned lno = 1;
+	struct pre_context_line {
+		char *bol;
+		char *eol;
+	} *prev = NULL, *pcl;
+	unsigned last_hit = 0;
+	unsigned last_shown = 0;
+	const char *hunk_mark = "";
+
+	if (opt->pre_context)
+		prev = xcalloc(opt->pre_context, sizeof(*prev));
+	if (opt->pre_context || opt->post_context)
+		hunk_mark = "--\n";
+
+	while (left) {
+		regmatch_t pmatch[10];
+		char *eol, ch;
+		int hit;
+
+		eol = end_of_line(bol, &left);
+		ch = *eol;
+		*eol = 0;
+
+		hit = !regexec(&opt->regexp, bol, ARRAY_SIZE(pmatch),
+			       pmatch, 0);
+		if (opt->invert)
+			hit = !hit;
+		if (hit) {
+			/* Hit at this line.  If we haven't shown the
+			 * pre-context lines, we would need to show them.
+			 */
+			if (opt->pre_context) {
+				unsigned from;
+				if (opt->pre_context < lno)
+					from = lno - opt->pre_context;
+				else
+					from = 1;
+				if (from <= last_shown)
+					from = last_shown + 1;
+				if (last_shown && from != last_shown + 1)
+					printf(hunk_mark);
+				while (from < lno) {
+					pcl = &prev[lno-from-1];
+					show_line(opt, pcl->bol, pcl->eol,
+						  name, from, '-');
+					from++;
+				}
+				last_shown = lno-1;
+			}
+			if (last_shown && lno != last_shown + 1)
+				printf(hunk_mark);
+			show_line(opt, bol, eol, name, lno, ':');
+			last_shown = last_hit = lno;
+		}
+		else if (last_hit &&
+			 lno <= last_hit + opt->post_context) {
+			/* If the last hit is within the post context,
+			 * we need to show this line.
+			 */
+			if (last_shown && lno != last_shown + 1)
+				printf(hunk_mark);
+			show_line(opt, bol, eol, name, lno, '-');
+			last_shown = lno;
+		}
+		if (opt->pre_context) {
+			memmove(prev+1, prev,
+				(opt->pre_context-1) * sizeof(*prev));
+			prev->bol = bol;
+			prev->eol = eol;
+		}
+		*eol = ch;
+		bol = eol + 1;
+		left--;
+		lno++;
+	}
+	return !!last_hit;
+}
+
+static int grep_sha1(struct grep_opt *opt, const unsigned char *sha1, const char *name)
+{
+	unsigned long size;
+	char *data;
+	char type[20];
+	int hit;
+	data = read_sha1_file(sha1, type, &size);
+	if (!data) {
+		error("'%s': unable to read %s", name, sha1_to_hex(sha1));
+		return 0;
+	}
+	hit = grep_buffer(opt, name, data, size);
+	free(data);
+	return hit;
+}
+
+static int grep_file(struct grep_opt *opt, const char *filename)
+{
+	struct stat st;
+	int i;
+	char *data;
+	if (lstat(filename, &st) < 0) {
+	err_ret:
+		if (errno != ENOENT)
+			error("'%s': %s", filename, strerror(errno));
+		return 0;
+	}
+	if (!st.st_size)
+		return 0; /* empty file -- no grep hit */
+	if (!S_ISREG(st.st_mode))
+		return 0;
+	i = open(filename, O_RDONLY);
+	if (i < 0)
+		goto err_ret;
+	data = xmalloc(st.st_size + 1);
+	if (st.st_size != xread(i, data, st.st_size)) {
+		error("'%s': short read %s", filename, strerror(errno));
+		close(i);
+		free(data);
+		return 0;
+	}
+	close(i);
+	i = grep_buffer(opt, filename, data, st.st_size);
+	free(data);
+	return i;
+}
+
+static int grep_cache(struct grep_opt *opt, struct rev_info *revs, int cached)
+{
+	int hit = 0;
+	int nr;
+	read_cache();
+
+	for (nr = 0; nr < active_nr; nr++) {
+		struct cache_entry *ce = active_cache[nr];
+		if (ce_stage(ce) || !S_ISREG(ntohl(ce->ce_mode)))
+			continue;
+		if (!pathspec_matches(&revs->diffopt, ce->name))
+			continue;
+		if (cached)
+			hit |= grep_sha1(opt, ce->sha1, ce->name);
+		else
+			hit |= grep_file(opt, ce->name);
+	}
+	return hit;
+}
+
+static int grep_tree(struct grep_opt *opt, struct rev_info *revs,
+		     struct tree_desc *tree,
+		     const char *tree_name, const char *base)
+{
+	unsigned mode;
+	int len;
+	int hit = 0;
+	const char *path;
+	const unsigned char *sha1;
+	char *down_base;
+	char *path_buf = xmalloc(PATH_MAX + strlen(tree_name) + 100);
+
+	if (tree_name[0]) {
+		int offset = sprintf(path_buf, "%s:", tree_name);
+		down_base = path_buf + offset;
+		strcat(down_base, base);
+	}
+	else {
+		down_base = path_buf;
+		strcpy(down_base, base);
+	}
+	len = strlen(path_buf);
+
+	while (tree->size) {
+		int pathlen;
+		sha1 = tree_entry_extract(tree, &path, &mode);
+		pathlen = strlen(path);
+		strcpy(path_buf + len, path);
+
+		if (!pathspec_matches(&revs->diffopt, down_base))
+			;
+		else if (S_ISREG(mode))
+			hit |= grep_sha1(opt, sha1, path_buf);
+		else if (S_ISDIR(mode)) {
+			char type[20];
+			struct tree_desc sub;
+			void *data;
+			data = read_sha1_file(sha1, type, &sub.size);
+			if (!data)
+				die("unable to read tree (%s)",
+				    sha1_to_hex(sha1));
+			strcpy(path_buf + len + pathlen, "/");
+			sub.buf = data;
+			hit = grep_tree(opt, revs, &sub, tree_name, down_base);
+			free(data);
+		}
+		update_tree_entry(tree);
+	}
+	return hit;
+}
+
+static int grep_object(struct grep_opt *opt, struct rev_info *revs,
+		       struct object *obj, const char *name)
+{
+	if (!strcmp(obj->type, blob_type))
+		return grep_sha1(opt, obj->sha1, name);
+	if (!strcmp(obj->type, commit_type) ||
+	    !strcmp(obj->type, tree_type)) {
+		struct tree_desc tree;
+		void *data;
+		int hit;
+		data = read_object_with_reference(obj->sha1, tree_type,
+						  &tree.size, NULL);
+		if (!data)
+			die("unable to read tree (%s)", sha1_to_hex(obj->sha1));
+		tree.buf = data;
+		hit = grep_tree(opt, revs, &tree, name, "");
+		free(data);
+		return hit;
+	}
+	die("unable to grep from object of type %s", obj->type);
+}
+
+static const char builtin_grep_usage[] =
+"git-grep <option>* <rev>* [-e] <pattern> [<path>...]";
+
+int cmd_grep(int argc, const char **argv, char **envp)
+{
+	struct rev_info rev;
+	const char **dst, **src;
+	int err;
+	int hit = 0;
+	int no_more_arg = 0;
+	int seen_range = 0;
+	int seen_noncommit = 0;
+	int cached = 0;
+	struct grep_opt opt;
+	struct object_list *list;
+
+	memset(&opt, 0, sizeof(opt));
+	opt.regflags = REG_NEWLINE;
+
+	/*
+	 * Interpret and remove the grep options upfront.  Sigh...
+	 */
+	for (dst = src = &argv[1]; src < argc + argv; ) {
+		const char *arg = *src++;
+		if (!no_more_arg) {
+			if (!strcmp("--", arg)) {
+				no_more_arg = 1;
+				*dst++ = arg;
+				continue;
+			}
+			if (!strcmp("--cached", arg)) {
+				cached = 1;
+				continue;
+			}
+			if (!strcmp("-i", arg) ||
+			    !strcmp("--ignore-case", arg)) {
+				opt.regflags |= REG_ICASE;
+				continue;
+			}
+			if (!strcmp("-v", arg) ||
+			    !strcmp("--invert-match", arg)) {
+				opt.invert = 1;
+				continue;
+			}
+			if (!strcmp("-E", arg) ||
+			    !strcmp("--extended-regexp", arg)) {
+				opt.regflags |= REG_EXTENDED;
+				continue;
+			}
+			if (!strcmp("-G", arg) ||
+			    !strcmp("--basic-regexp", arg)) {
+				opt.regflags &= ~REG_EXTENDED;
+				continue;
+			}
+			if (!strcmp("-e", arg)) {
+				if (src < argc + argv) {
+					opt.pattern = *src++;
+					continue;
+				}
+				usage(builtin_grep_usage);
+			}
+			if (!strcmp("-n", arg)) {
+				opt.linenum = 1;
+				continue;
+			}
+			if (!strcmp("-H", arg)) {
+				/* We always show the pathname, so this
+				 * is a noop.
+				 */
+				continue;
+			}
+			if (!strcmp("-A", arg) ||
+			    !strcmp("-B", arg) ||
+			    !strcmp("-C", arg)) {
+				unsigned num;
+				if ((argc + argv <= src) ||
+				    sscanf(*src++, "%u", &num) != 1)
+					usage(builtin_grep_usage);
+				switch (arg[1]) {
+				case 'A':
+					opt.post_context = num;
+					break;
+				case 'C':
+					opt.post_context = num;
+				case 'B':
+					opt.pre_context = num;
+					break;
+				}
+				continue;
+			}
+		}
+		*dst++ = arg;
+	}
+	if (!opt.pattern)
+		die("no pattern given.");
+
+	err = regcomp(&opt.regexp, opt.pattern, opt.regflags);
+	if (err) {
+		char errbuf[1024];
+		regerror(err, &opt.regexp, errbuf, 1024);
+		regfree(&opt.regexp);
+		die("'%s': %s", opt.pattern, errbuf);
+	}
+
+	init_revisions(&rev);
+	*dst = NULL;
+	argc = setup_revisions(dst - argv, argv, &rev, NULL);
+
+	/*
+	 * Do not walk "grep -e foo master next pu -- Documentation/"
+	 * but do walk "grep -e foo master..next -- Documentation/".
+	 * Ranged request mixed with a blob or tree object, like
+	 * "grep -e foo v1.0.0:Documentation/ master..next"
+	 * so detect that and complain.
+	 */
+	for (list = rev.pending_objects; list; list = list->next) {
+		struct object *real_obj;
+		if (list->item->flags & UNINTERESTING)
+			seen_range = 1;
+		real_obj = deref_tag(list->item, NULL, 0);
+		if (strcmp(real_obj->type, commit_type))
+			seen_noncommit = 1;
+	}
+	if (!rev.pending_objects)
+		return !grep_cache(&opt, &rev, cached);
+	if (cached)
+		die("both --cached and revisions given.");
+
+	if (seen_range && seen_noncommit)
+		die("both A..B and non commit are given.");
+	if (seen_range) {
+		struct commit *commit;
+		prepare_revision_walk(&rev);
+		while ((commit = get_revision(&rev)) != NULL) {
+			unsigned char *sha1 = commit->object.sha1;
+			const char *n = find_unique_abbrev(sha1, rev.abbrev);
+			char rev_name[41];
+			strcpy(rev_name, n);
+			if (grep_object(&opt, &rev, &commit->object, rev_name))
+				hit = 1;
+			commit->buffer = NULL;
+		}
+		return !hit;
+	}
+
+	/* all of them are non-commit; do not walk, and
+	 * do not lose their names.
+	 */
+	for (list = rev.pending_objects; list; list = list->next) {
+		struct object *real_obj;
+		real_obj = deref_tag(list->item, NULL, 0);
+		if (grep_object(&opt, &rev, real_obj, list->name))
+			hit = 1;
+	}
+	return !hit;
+}
diff --git a/builtin.h b/builtin.h
index 47408a0585..cf5de3b931 100644
--- a/builtin.h
+++ b/builtin.h
@@ -19,5 +19,6 @@ extern int cmd_version(int argc, const char **argv, char **envp);
 extern int cmd_whatchanged(int argc, const char **argv, char **envp);
 extern int cmd_show(int argc, const char **argv, char **envp);
 extern int cmd_log(int argc, const char **argv, char **envp);
+extern int cmd_grep(int argc, const char **argv, char **envp);
 
 #endif
diff --git a/git.c b/git.c
index 01b7e28b8c..893bddd768 100644
--- a/git.c
+++ b/git.c
@@ -46,6 +46,7 @@ static void handle_internal_command(int argc, const char **argv, char **envp)
 		{ "log", cmd_log },
 		{ "whatchanged", cmd_whatchanged },
 		{ "show", cmd_show },
+		{ "grep", cmd_grep },
 	};
 	int i;
 

From e0eb889f8e6597120527b0312874ff4c8448108e Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Mon, 1 May 2006 12:27:56 -0700
Subject: [PATCH 02/22] builtin-grep: wildcard pathspec fixes

This tweaks the pathspec wildcard used in builtin-grep to match
that of ls-files.  With this:

	git grep -e DEBUG -- '*/Kconfig*'

would work like the shell script version, and you could even do:

	git grep -e DEBUG --cached -- '*/Kconfig*' ;# from index
	git grep -e DEBUG v2.6.12 -- '*/Kconfig*' ;# from rev

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 89 ++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 64 insertions(+), 25 deletions(-)

diff --git a/builtin-grep.c b/builtin-grep.c
index 36150bf4ef..653b65ea10 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -12,33 +12,66 @@
 #include "revision.h"
 #include "builtin.h"
 #include <regex.h>
+#include <fnmatch.h>
 
+/*
+ * git grep pathspecs are somewhat different from diff-tree pathspecs;
+ * pathname wildcards are allowed.
+ */
 static int pathspec_matches(struct diff_options *opt, const char *name)
 {
-	int i, j;
-	int namelen;
+	int namelen, i;
 	if (!opt->nr_paths)
 		return 1;
 	namelen = strlen(name);
 	for (i = 0; i < opt->nr_paths; i++) {
 		const char *match = opt->paths[i];
 		int matchlen = opt->pathlens[i];
-		if (matchlen <= namelen) {
-			if (!strncmp(name, match, matchlen))
-				return 1;
-			continue;
-		}
-		/* If name is "Documentation" and pathspec is
-		 * "Documentation/", they should match.  Maybe
-		 * we would want to strip it in get_pathspec()???
-		 */
-		if (strncmp(name, match, namelen))
-			continue;
-		for (j = namelen; j < matchlen; j++)
-			if (match[j] != '/')
-				break;
-		if (matchlen <= j)
+		const char *slash, *cp;
+
+		if ((matchlen <= namelen) &&
+		    !strncmp(name, match, matchlen) &&
+		    (match[matchlen-1] == '/' ||
+		     name[matchlen] == '\0' || name[matchlen] == '/'))
 			return 1;
+		if (!fnmatch(match, name, 0))
+			return 1;
+		if (name[namelen-1] != '/')
+			continue;
+
+		/* We are being asked if the name directory is worth
+		 * descending into.
+		 *
+		 * Find the longest leading directory name that does
+		 * not have metacharacter in the pathspec; the name
+		 * we are looking at must overlap with that directory.
+		 */
+		for (cp = match, slash = NULL; cp - match < matchlen; cp++) {
+			char ch = *cp;
+			if (ch == '/')
+				slash = cp;
+			if (ch == '*' || ch == '[')
+				break;
+		}
+		if (!slash)
+			slash = match; /* toplevel */
+		else
+			slash++;
+		if (namelen <= slash - match) {
+			/* Looking at "Documentation/" and
+			 * the pattern says "Documentation/howto/", or
+			 * "Documentation/diff*.txt".
+			 */
+			if (!memcmp(match, name, namelen))
+				return 1;
+		}
+		else {
+			/* Looking at "Documentation/howto/" and
+			 * the pattern says "Documentation/h*".
+			 */
+			if (!memcmp(match, name, slash - match))
+				return 1;
+		}
 	}
 	return 0;
 }
@@ -232,17 +265,17 @@ static int grep_tree(struct grep_opt *opt, struct rev_info *revs,
 	int hit = 0;
 	const char *path;
 	const unsigned char *sha1;
-	char *down_base;
+	char *down;
 	char *path_buf = xmalloc(PATH_MAX + strlen(tree_name) + 100);
 
 	if (tree_name[0]) {
 		int offset = sprintf(path_buf, "%s:", tree_name);
-		down_base = path_buf + offset;
-		strcat(down_base, base);
+		down = path_buf + offset;
+		strcat(down, base);
 	}
 	else {
-		down_base = path_buf;
-		strcpy(down_base, base);
+		down = path_buf;
+		strcpy(down, base);
 	}
 	len = strlen(path_buf);
 
@@ -252,7 +285,14 @@ static int grep_tree(struct grep_opt *opt, struct rev_info *revs,
 		pathlen = strlen(path);
 		strcpy(path_buf + len, path);
 
-		if (!pathspec_matches(&revs->diffopt, down_base))
+		if (S_ISDIR(mode))
+			/* Match "abc/" against pathspec to
+			 * decide if we want to descend into "abc"
+			 * directory.
+			 */
+			strcpy(path_buf + len + pathlen, "/");
+
+		if (!pathspec_matches(&revs->diffopt, down))
 			;
 		else if (S_ISREG(mode))
 			hit |= grep_sha1(opt, sha1, path_buf);
@@ -264,9 +304,8 @@ static int grep_tree(struct grep_opt *opt, struct rev_info *revs,
 			if (!data)
 				die("unable to read tree (%s)",
 				    sha1_to_hex(sha1));
-			strcpy(path_buf + len + pathlen, "/");
 			sub.buf = data;
-			hit = grep_tree(opt, revs, &sub, tree_name, down_base);
+			hit |= grep_tree(opt, revs, &sub, tree_name, down);
 			free(data);
 		}
 		update_tree_entry(tree);

From df0e7aa8644eef5ebc018bf838739e25f3494b6c Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Mon, 1 May 2006 12:39:21 -0700
Subject: [PATCH 03/22] builtin-grep: support '-l' option.

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/builtin-grep.c b/builtin-grep.c
index 653b65ea10..c3e6701aa0 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -81,6 +81,7 @@ struct grep_opt {
 	regex_t regexp;
 	unsigned linenum:1;
 	unsigned invert:1;
+	unsigned name_only:1;
 	int regflags;
 	unsigned pre_context;
 	unsigned post_context;
@@ -139,6 +140,10 @@ static int grep_buffer(struct grep_opt *opt, const char *name,
 		if (opt->invert)
 			hit = !hit;
 		if (hit) {
+			if (opt->name_only) {
+				printf("%s\n", name);
+				return 1;
+			}
 			/* Hit at this line.  If we haven't shown the
 			 * pre-context lines, we would need to show them.
 			 */
@@ -406,6 +411,11 @@ int cmd_grep(int argc, const char **argv, char **envp)
 				 */
 				continue;
 			}
+			if (!strcmp("-l", arg) ||
+			    !strcmp("--files-with-matches", arg)) {
+				opt.name_only = 1;
+				continue;
+			}
 			if (!strcmp("-A", arg) ||
 			    !strcmp("-B", arg) ||
 			    !strcmp("-C", arg)) {

From 1362671f6a716e1a34abbcab43adfb68c7e2fd3b Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Mon, 1 May 2006 15:58:29 -0700
Subject: [PATCH 04/22] builtin-grep: do not use setup_revisions()

Grep may want to grok multiple revisions, but it does not make
much sense to walk revisions while doing so.  This stops calling
the code to parse parameters for the revision walker.  The
parameter parsing for the optional "-e" option becomes a lot
simpler with it as well.

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 265 ++++++++++++++++++++++++++-----------------------
 1 file changed, 139 insertions(+), 126 deletions(-)

diff --git a/builtin-grep.c b/builtin-grep.c
index c3e6701aa0..4be1514a4e 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -8,8 +8,7 @@
 #include "tree.h"
 #include "commit.h"
 #include "tag.h"
-#include "diff.h"
-#include "revision.h"
+#include "tree-walk.h"
 #include "builtin.h"
 #include <regex.h>
 #include <fnmatch.h>
@@ -18,15 +17,15 @@
  * git grep pathspecs are somewhat different from diff-tree pathspecs;
  * pathname wildcards are allowed.
  */
-static int pathspec_matches(struct diff_options *opt, const char *name)
+static int pathspec_matches(const char **paths, const char *name)
 {
 	int namelen, i;
-	if (!opt->nr_paths)
+	if (!paths || !*paths)
 		return 1;
 	namelen = strlen(name);
-	for (i = 0; i < opt->nr_paths; i++) {
-		const char *match = opt->paths[i];
-		int matchlen = opt->pathlens[i];
+	for (i = 0; paths[i]; i++) {
+		const char *match = paths[i];
+		int matchlen = strlen(match);
 		const char *slash, *cp;
 
 		if ((matchlen <= namelen) &&
@@ -241,7 +240,7 @@ static int grep_file(struct grep_opt *opt, const char *filename)
 	return i;
 }
 
-static int grep_cache(struct grep_opt *opt, struct rev_info *revs, int cached)
+static int grep_cache(struct grep_opt *opt, const char **paths, int cached)
 {
 	int hit = 0;
 	int nr;
@@ -251,7 +250,7 @@ static int grep_cache(struct grep_opt *opt, struct rev_info *revs, int cached)
 		struct cache_entry *ce = active_cache[nr];
 		if (ce_stage(ce) || !S_ISREG(ntohl(ce->ce_mode)))
 			continue;
-		if (!pathspec_matches(&revs->diffopt, ce->name))
+		if (!pathspec_matches(paths, ce->name))
 			continue;
 		if (cached)
 			hit |= grep_sha1(opt, ce->sha1, ce->name);
@@ -261,7 +260,7 @@ static int grep_cache(struct grep_opt *opt, struct rev_info *revs, int cached)
 	return hit;
 }
 
-static int grep_tree(struct grep_opt *opt, struct rev_info *revs,
+static int grep_tree(struct grep_opt *opt, const char **paths,
 		     struct tree_desc *tree,
 		     const char *tree_name, const char *base)
 {
@@ -297,7 +296,7 @@ static int grep_tree(struct grep_opt *opt, struct rev_info *revs,
 			 */
 			strcpy(path_buf + len + pathlen, "/");
 
-		if (!pathspec_matches(&revs->diffopt, down))
+		if (!pathspec_matches(paths, down))
 			;
 		else if (S_ISREG(mode))
 			hit |= grep_sha1(opt, sha1, path_buf);
@@ -310,7 +309,7 @@ static int grep_tree(struct grep_opt *opt, struct rev_info *revs,
 				die("unable to read tree (%s)",
 				    sha1_to_hex(sha1));
 			sub.buf = data;
-			hit |= grep_tree(opt, revs, &sub, tree_name, down);
+			hit |= grep_tree(opt, paths, &sub, tree_name, down);
 			free(data);
 		}
 		update_tree_entry(tree);
@@ -318,7 +317,7 @@ static int grep_tree(struct grep_opt *opt, struct rev_info *revs,
 	return hit;
 }
 
-static int grep_object(struct grep_opt *opt, struct rev_info *revs,
+static int grep_object(struct grep_opt *opt, const char **paths,
 		       struct object *obj, const char *name)
 {
 	if (!strcmp(obj->type, blob_type))
@@ -333,7 +332,7 @@ static int grep_object(struct grep_opt *opt, struct rev_info *revs,
 		if (!data)
 			die("unable to read tree (%s)", sha1_to_hex(obj->sha1));
 		tree.buf = data;
-		hit = grep_tree(opt, revs, &tree, name, "");
+		hit = grep_tree(opt, paths, &tree, name, "");
 		free(data);
 		return hit;
 	}
@@ -345,102 +344,119 @@ static const char builtin_grep_usage[] =
 
 int cmd_grep(int argc, const char **argv, char **envp)
 {
-	struct rev_info rev;
-	const char **dst, **src;
 	int err;
 	int hit = 0;
-	int no_more_arg = 0;
-	int seen_range = 0;
+	int no_more_flags = 0;
 	int seen_noncommit = 0;
 	int cached = 0;
 	struct grep_opt opt;
-	struct object_list *list;
+	struct object_list *list, **tail, *object_list = NULL;
+	const char *prefix = setup_git_directory();
+	const char **paths = NULL;
 
 	memset(&opt, 0, sizeof(opt));
 	opt.regflags = REG_NEWLINE;
 
 	/*
-	 * Interpret and remove the grep options upfront.  Sigh...
+	 * No point using rev_info, really.
 	 */
-	for (dst = src = &argv[1]; src < argc + argv; ) {
-		const char *arg = *src++;
-		if (!no_more_arg) {
-			if (!strcmp("--", arg)) {
-				no_more_arg = 1;
-				*dst++ = arg;
-				continue;
-			}
-			if (!strcmp("--cached", arg)) {
-				cached = 1;
-				continue;
-			}
-			if (!strcmp("-i", arg) ||
-			    !strcmp("--ignore-case", arg)) {
-				opt.regflags |= REG_ICASE;
-				continue;
-			}
-			if (!strcmp("-v", arg) ||
-			    !strcmp("--invert-match", arg)) {
-				opt.invert = 1;
-				continue;
-			}
-			if (!strcmp("-E", arg) ||
-			    !strcmp("--extended-regexp", arg)) {
-				opt.regflags |= REG_EXTENDED;
-				continue;
-			}
-			if (!strcmp("-G", arg) ||
-			    !strcmp("--basic-regexp", arg)) {
-				opt.regflags &= ~REG_EXTENDED;
-				continue;
-			}
-			if (!strcmp("-e", arg)) {
-				if (src < argc + argv) {
-					opt.pattern = *src++;
-					continue;
-				}
-				usage(builtin_grep_usage);
-			}
-			if (!strcmp("-n", arg)) {
-				opt.linenum = 1;
-				continue;
-			}
-			if (!strcmp("-H", arg)) {
-				/* We always show the pathname, so this
-				 * is a noop.
-				 */
-				continue;
-			}
-			if (!strcmp("-l", arg) ||
-			    !strcmp("--files-with-matches", arg)) {
-				opt.name_only = 1;
-				continue;
-			}
-			if (!strcmp("-A", arg) ||
-			    !strcmp("-B", arg) ||
-			    !strcmp("-C", arg)) {
-				unsigned num;
-				if ((argc + argv <= src) ||
-				    sscanf(*src++, "%u", &num) != 1)
-					usage(builtin_grep_usage);
-				switch (arg[1]) {
-				case 'A':
-					opt.post_context = num;
-					break;
-				case 'C':
-					opt.post_context = num;
-				case 'B':
-					opt.pre_context = num;
-					break;
-				}
-				continue;
-			}
+	while (1 < argc) {
+		const char *arg = argv[1];
+		argc--; argv++;
+		if (!strcmp("--cached", arg)) {
+			cached = 1;
+			continue;
+		}
+		if (!strcmp("-i", arg) ||
+		    !strcmp("--ignore-case", arg)) {
+			opt.regflags |= REG_ICASE;
+			continue;
+		}
+		if (!strcmp("-v", arg) ||
+		    !strcmp("--invert-match", arg)) {
+			opt.invert = 1;
+			continue;
+		}
+		if (!strcmp("-E", arg) ||
+		    !strcmp("--extended-regexp", arg)) {
+			opt.regflags |= REG_EXTENDED;
+			continue;
+		}
+		if (!strcmp("-G", arg) ||
+		    !strcmp("--basic-regexp", arg)) {
+			opt.regflags &= ~REG_EXTENDED;
+			continue;
+		}
+		if (!strcmp("-n", arg)) {
+			opt.linenum = 1;
+			continue;
+		}
+		if (!strcmp("-H", arg)) {
+			/* We always show the pathname, so this
+			 * is a noop.
+			 */
+			continue;
+		}
+		if (!strcmp("-l", arg) ||
+		    !strcmp("--files-with-matches", arg)) {
+			opt.name_only = 1;
+			continue;
+		}
+		if (!strcmp("-A", arg) ||
+		    !strcmp("-B", arg) ||
+		    !strcmp("-C", arg)) {
+			unsigned num;
+			if (argc <= 1 ||
+			    sscanf(*++argv, "%u", &num) != 1)
+				usage(builtin_grep_usage);
+			argc--;
+			switch (arg[1]) {
+			case 'A':
+				opt.post_context = num;
+				break;
+			case 'C':
+				opt.post_context = num;
+			case 'B':
+				opt.pre_context = num;
+				break;
+			}
+			continue;
+		}
+		if (!strcmp("-e", arg)) {
+			if (1 < argc) {
+				/* We probably would want to do
+				 * -e pat1 -e pat2 as well later...
+				 */
+				if (opt.pattern)
+					die("more than one pattern?");
+				opt.pattern = *++argv;
+				argc--;
+				continue;
+			}
+			usage(builtin_grep_usage);
+		}
+		if (!strcmp("--", arg)) {
+			no_more_flags = 1;
+			continue;
+		}
+		/* Either unrecognized option or a single pattern */
+		if (!no_more_flags && *arg == '-')
+			usage(builtin_grep_usage);
+		if (!opt.pattern) {
+			opt.pattern = arg;
+			break;
+		}
+		else {
+			/* We are looking at the first path or rev;
+			 * it is found at argv[0] after leaving the
+			 * loop.
+			 */
+			argc++; argv--;
+			break;
 		}
-		*dst++ = arg;
 	}
 	if (!opt.pattern)
 		die("no pattern given.");
-
 	err = regcomp(&opt.regexp, opt.pattern, opt.regflags);
 	if (err) {
 		char errbuf[1024];
@@ -448,11 +464,32 @@ int cmd_grep(int argc, const char **argv, char **envp)
 		regfree(&opt.regexp);
 		die("'%s': %s", opt.pattern, errbuf);
 	}
+	tail = &object_list;
+	while (1 < argc) {
+		struct object *object;
+		struct object_list *elem;
+		const char *arg = argv[1];
+		unsigned char sha1[20];
+		if (get_sha1(arg, sha1) < 0)
+			break;
+		object = parse_object(sha1);
+		if (!object)
+			die("bad object %s", arg);
+		elem = object_list_insert(object, tail);
+		elem->name = arg;
+		tail = &elem->next;
+		argc--; argv++;
+	}
+	if (1 < argc)
+		paths = get_pathspec(prefix, argv + 1);
+	else if (prefix) {
+		paths = xcalloc(2, sizeof(const char *));
+		paths[0] = prefix;
+		paths[1] = NULL;
+	}
 
-	init_revisions(&rev);
-	*dst = NULL;
-	argc = setup_revisions(dst - argv, argv, &rev, NULL);
-
+	if (!object_list)
+		return !grep_cache(&opt, paths, cached);
 	/*
 	 * Do not walk "grep -e foo master next pu -- Documentation/"
 	 * but do walk "grep -e foo master..next -- Documentation/".
@@ -460,43 +497,19 @@ int cmd_grep(int argc, const char **argv, char **envp)
 	 * "grep -e foo v1.0.0:Documentation/ master..next"
 	 * so detect that and complain.
 	 */
-	for (list = rev.pending_objects; list; list = list->next) {
+	for (list = object_list; list; list = list->next) {
 		struct object *real_obj;
-		if (list->item->flags & UNINTERESTING)
-			seen_range = 1;
 		real_obj = deref_tag(list->item, NULL, 0);
 		if (strcmp(real_obj->type, commit_type))
 			seen_noncommit = 1;
 	}
-	if (!rev.pending_objects)
-		return !grep_cache(&opt, &rev, cached);
 	if (cached)
 		die("both --cached and revisions given.");
 
-	if (seen_range && seen_noncommit)
-		die("both A..B and non commit are given.");
-	if (seen_range) {
-		struct commit *commit;
-		prepare_revision_walk(&rev);
-		while ((commit = get_revision(&rev)) != NULL) {
-			unsigned char *sha1 = commit->object.sha1;
-			const char *n = find_unique_abbrev(sha1, rev.abbrev);
-			char rev_name[41];
-			strcpy(rev_name, n);
-			if (grep_object(&opt, &rev, &commit->object, rev_name))
-				hit = 1;
-			commit->buffer = NULL;
-		}
-		return !hit;
-	}
-
-	/* all of them are non-commit; do not walk, and
-	 * do not lose their names.
-	 */
-	for (list = rev.pending_objects; list; list = list->next) {
+	for (list = object_list; list; list = list->next) {
 		struct object *real_obj;
 		real_obj = deref_tag(list->item, NULL, 0);
-		if (grep_object(&opt, &rev, real_obj, list->name))
+		if (grep_object(&opt, paths, real_obj, list->name))
 			hit = 1;
 	}
 	return !hit;

From a24f1e254e9dbea80b8173d72e0f75fec25b38a7 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Tue, 2 May 2006 01:28:02 -0700
Subject: [PATCH 05/22] builtin-grep: printf %.*s length is int, not ptrdiff_t.

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/builtin-grep.c b/builtin-grep.c
index 4be1514a4e..eb821b41b9 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -103,7 +103,7 @@ static void show_line(struct grep_opt *opt, const char *bol, const char *eol,
 	printf("%s%c", name, sign);
 	if (opt->linenum)
 		printf("%d%c", lno, sign);
-	printf("%.*s\n", eol-bol, bol);
+	printf("%.*s\n", (int)(eol-bol), bol);
 }
 
 static int grep_buffer(struct grep_opt *opt, const char *name,

From f462ebb48bf9126335671e878336e3faf3914802 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Tue, 2 May 2006 15:17:05 -0700
Subject: [PATCH 06/22] builtin-grep: allow -<n> and -[ABC]<n> notation for
 context lines.

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 28 ++++++++++++++++++++++------
 1 file changed, 22 insertions(+), 6 deletions(-)

diff --git a/builtin-grep.c b/builtin-grep.c
index eb821b41b9..a551d34021 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -402,18 +402,34 @@ int cmd_grep(int argc, const char **argv, char **envp)
 			opt.name_only = 1;
 			continue;
 		}
-		if (!strcmp("-A", arg) ||
-		    !strcmp("-B", arg) ||
-		    !strcmp("-C", arg)) {
+		if (!strncmp("-A", arg, 2) ||
+		    !strncmp("-B", arg, 2) ||
+		    !strncmp("-C", arg, 2) ||
+		    (arg[0] == '-' && '1' <= arg[1] && arg[1] <= '9')) {
 			unsigned num;
-			if (argc <= 1 ||
-			    sscanf(*++argv, "%u", &num) != 1)
+			const char *scan;
+			switch (arg[1]) {
+			case 'A': case 'B': case 'C':
+				if (!arg[2]) {
+					if (argc <= 1)
+						usage(builtin_grep_usage);
+					scan = *++argv;
+					argc--;
+				}
+				else
+					scan = arg + 2;
+				break;
+			default:
+				scan = arg + 1;
+				break;
+			}
+			if (sscanf(scan, "%u", &num) != 1)
 				usage(builtin_grep_usage);
-			argc--;
 			switch (arg[1]) {
 			case 'A':
 				opt.post_context = num;
 				break;
+			default:
 			case 'C':
 				opt.post_context = num;
 			case 'B':

From f9b9faf6f8a408b7129e2c95234f698da2171f4b Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Tue, 2 May 2006 15:40:49 -0700
Subject: [PATCH 07/22] builtin-grep: allow more than one patterns.

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 72 +++++++++++++++++++++++++++++++++++---------------
 1 file changed, 51 insertions(+), 21 deletions(-)

diff --git a/builtin-grep.c b/builtin-grep.c
index a551d34021..b8351200dd 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -75,9 +75,16 @@ static int pathspec_matches(const char **paths, const char *name)
 	return 0;
 }
 
-struct grep_opt {
+struct grep_pat {
+	struct grep_pat *next;
 	const char *pattern;
 	regex_t regexp;
+};
+
+struct grep_opt {
+	struct grep_pat *pattern_list;
+	struct grep_pat **pattern_tail;
+	regex_t regexp;
 	unsigned linenum:1;
 	unsigned invert:1;
 	unsigned name_only:1;
@@ -86,6 +93,29 @@ struct grep_opt {
 	unsigned post_context;
 };
 
+static void add_pattern(struct grep_opt *opt, const char *pat)
+{
+	struct grep_pat *p = xcalloc(1, sizeof(*p));
+	p->pattern = pat;
+	*opt->pattern_tail = p;
+	opt->pattern_tail = &p->next;
+	p->next = NULL;
+}
+
+static void compile_patterns(struct grep_opt *opt)
+{
+	struct grep_pat *p;
+	for (p = opt->pattern_list; p; p = p->next) {
+		int err = regcomp(&p->regexp, p->pattern, opt->regflags);
+		if (err) {
+			char errbuf[1024];
+			regerror(err, &p->regexp, errbuf, 1024);
+			regfree(&p->regexp);
+			die("'%s': %s", p->pattern, errbuf);
+		}
+	}
+}
+
 static char *end_of_line(char *cp, unsigned long *left)
 {
 	unsigned long l = *left;
@@ -128,14 +158,24 @@ static int grep_buffer(struct grep_opt *opt, const char *name,
 	while (left) {
 		regmatch_t pmatch[10];
 		char *eol, ch;
-		int hit;
+		int hit = 0;
+		struct grep_pat *p;
 
 		eol = end_of_line(bol, &left);
 		ch = *eol;
 		*eol = 0;
 
-		hit = !regexec(&opt->regexp, bol, ARRAY_SIZE(pmatch),
-			       pmatch, 0);
+		for (p = opt->pattern_list; p; p = p->next) {
+			regex_t *exp = &p->regexp;
+			hit = !regexec(exp, bol, ARRAY_SIZE(pmatch),
+				       pmatch, 0);
+			if (hit)
+				break;
+		}
+		/* "grep -v -e foo -e bla" should list lines
+		 * that do not have either, so inversion should
+		 * be done outside.
+		 */
 		if (opt->invert)
 			hit = !hit;
 		if (hit) {
@@ -344,7 +384,6 @@ static const char builtin_grep_usage[] =
 
 int cmd_grep(int argc, const char **argv, char **envp)
 {
-	int err;
 	int hit = 0;
 	int no_more_flags = 0;
 	int seen_noncommit = 0;
@@ -355,6 +394,7 @@ int cmd_grep(int argc, const char **argv, char **envp)
 	const char **paths = NULL;
 
 	memset(&opt, 0, sizeof(opt));
+	opt.pattern_tail = &opt.pattern_list;
 	opt.regflags = REG_NEWLINE;
 
 	/*
@@ -440,12 +480,8 @@ int cmd_grep(int argc, const char **argv, char **envp)
 		}
 		if (!strcmp("-e", arg)) {
 			if (1 < argc) {
-				/* We probably would want to do
-				 * -e pat1 -e pat2 as well later...
-				 */
-				if (opt.pattern)
-					die("more than one pattern?");
-				opt.pattern = *++argv;
+				add_pattern(&opt, argv[1]);
+				argv++;
 				argc--;
 				continue;
 			}
@@ -458,8 +494,8 @@ int cmd_grep(int argc, const char **argv, char **envp)
 		/* Either unrecognized option or a single pattern */
 		if (!no_more_flags && *arg == '-')
 			usage(builtin_grep_usage);
-		if (!opt.pattern) {
-			opt.pattern = arg;
+		if (!opt.pattern_list) {
+			add_pattern(&opt, arg);
 			break;
 		}
 		else {
@@ -471,15 +507,9 @@ int cmd_grep(int argc, const char **argv, char **envp)
 			break;
 		}
 	}
-	if (!opt.pattern)
+	if (!opt.pattern_list)
 		die("no pattern given.");
-	err = regcomp(&opt.regexp, opt.pattern, opt.regflags);
-	if (err) {
-		char errbuf[1024];
-		regerror(err, &opt.regexp, errbuf, 1024);
-		regfree(&opt.regexp);
-		die("'%s': %s", opt.pattern, errbuf);
-	}
+	compile_patterns(&opt);
 	tail = &object_list;
 	while (1 < argc) {
 		struct object *object;

From 2c866cf1c2b2f3a289b7f3c21adb4f05af6626e4 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Tue, 2 May 2006 15:40:49 -0700
Subject: [PATCH 08/22] builtin-grep: support -c (--count).

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/builtin-grep.c b/builtin-grep.c
index b8351200dd..f1800a54d4 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -88,6 +88,7 @@ struct grep_opt {
 	unsigned linenum:1;
 	unsigned invert:1;
 	unsigned name_only:1;
+	unsigned count:1;
 	int regflags;
 	unsigned pre_context;
 	unsigned post_context;
@@ -149,6 +150,7 @@ static int grep_buffer(struct grep_opt *opt, const char *name,
 	unsigned last_hit = 0;
 	unsigned last_shown = 0;
 	const char *hunk_mark = "";
+	unsigned count = 0;
 
 	if (opt->pre_context)
 		prev = xcalloc(opt->pre_context, sizeof(*prev));
@@ -179,12 +181,16 @@ static int grep_buffer(struct grep_opt *opt, const char *name,
 		if (opt->invert)
 			hit = !hit;
 		if (hit) {
+			count++;
 			if (opt->name_only) {
 				printf("%s\n", name);
 				return 1;
 			}
 			/* Hit at this line.  If we haven't shown the
 			 * pre-context lines, we would need to show them.
+			 * When asked to do "count", this still show
+			 * the context which is nonsense, but the user
+			 * deserves to get that ;-).
 			 */
 			if (opt->pre_context) {
 				unsigned from;
@@ -206,7 +212,8 @@ static int grep_buffer(struct grep_opt *opt, const char *name,
 			}
 			if (last_shown && lno != last_shown + 1)
 				printf(hunk_mark);
-			show_line(opt, bol, eol, name, lno, ':');
+			if (!opt->count)
+				show_line(opt, bol, eol, name, lno, ':');
 			last_shown = last_hit = lno;
 		}
 		else if (last_hit &&
@@ -230,6 +237,13 @@ static int grep_buffer(struct grep_opt *opt, const char *name,
 		left--;
 		lno++;
 	}
+	/* NEEDSWORK:
+	 * The real "grep -c foo *.c" gives many "bar.c:0" lines,
+	 * which feels mostly useless but sometimes useful.  Maybe
+	 * make it another option?  For now suppress them.
+	 */
+	if (opt->count && count)
+		printf("%s:%u\n", name, count);
 	return !!last_hit;
 }
 
@@ -442,6 +456,11 @@ int cmd_grep(int argc, const char **argv, char **envp)
 			opt.name_only = 1;
 			continue;
 		}
+		if (!strcmp("-c", arg) ||
+		    !strcmp("--count", arg)) {
+			opt.count = 1;
+			continue;
+		}
 		if (!strncmp("-A", arg, 2) ||
 		    !strncmp("-B", arg, 2) ||
 		    !strncmp("-C", arg, 2) ||

From 7839a25eab7177024b809fbb3796907e3eed17c1 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Tue, 2 May 2006 15:40:49 -0700
Subject: [PATCH 09/22] builtin-grep: support -w (--word-regexp).

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/builtin-grep.c b/builtin-grep.c
index f1800a54d4..09e3677824 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -89,6 +89,7 @@ struct grep_opt {
 	unsigned invert:1;
 	unsigned name_only:1;
 	unsigned count:1;
+	unsigned word_regexp:1;
 	int regflags;
 	unsigned pre_context;
 	unsigned post_context;
@@ -128,6 +129,11 @@ static char *end_of_line(char *cp, unsigned long *left)
 	return cp;
 }
 
+static int word_char(char ch)
+{
+	return isalnum(ch) || ch == '_';
+}
+
 static void show_line(struct grep_opt *opt, const char *bol, const char *eol,
 		      const char *name, unsigned lno, char sign)
 {
@@ -171,6 +177,25 @@ static int grep_buffer(struct grep_opt *opt, const char *name,
 			regex_t *exp = &p->regexp;
 			hit = !regexec(exp, bol, ARRAY_SIZE(pmatch),
 				       pmatch, 0);
+
+			if (hit && opt->word_regexp) {
+				/* Match beginning must be either
+				 * beginning of the line, or at word
+				 * boundary (i.e. the last char must
+				 * not be alnum or underscore).
+				 */
+				if ((pmatch[0].rm_so < 0) ||
+				    (eol - bol) <= pmatch[0].rm_so ||
+				    (pmatch[0].rm_eo < 0) ||
+				    (eol - bol) < pmatch[0].rm_eo)
+					die("regexp returned nonsense");
+				if (pmatch[0].rm_so != 0 &&
+				    word_char(bol[pmatch[0].rm_so-1]))
+					continue; /* not a word boundary */
+				if ((eol-bol) < pmatch[0].rm_eo &&
+				    word_char(bol[pmatch[0].rm_eo]))
+					continue; /* not a word boundary */
+			}
 			if (hit)
 				break;
 		}
@@ -461,6 +486,11 @@ int cmd_grep(int argc, const char **argv, char **envp)
 			opt.count = 1;
 			continue;
 		}
+		if (!strcmp("-w", arg) ||
+		    !strcmp("--word-regexp", arg)) {
+			opt.word_regexp = 1;
+			continue;
+		}
 		if (!strncmp("-A", arg, 2) ||
 		    !strncmp("-B", arg, 2) ||
 		    !strncmp("-C", arg, 2) ||

From 1e3d90e0135274ad89cd8ee0722e2dd043ec0052 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Tue, 2 May 2006 17:27:07 -0700
Subject: [PATCH 10/22] builtin-grep: tighten path wildcard vs tree traversal.

The earlier code descended into Documentation/technical when
given "Documentation/how*" as the pattern, which was too loose.

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 35 ++++++++++++++++++++---------------
 1 file changed, 20 insertions(+), 15 deletions(-)

diff --git a/builtin-grep.c b/builtin-grep.c
index 09e3677824..2124fa62e8 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -26,7 +26,7 @@ static int pathspec_matches(const char **paths, const char *name)
 	for (i = 0; paths[i]; i++) {
 		const char *match = paths[i];
 		int matchlen = strlen(match);
-		const char *slash, *cp;
+		const char *cp, *meta;
 
 		if ((matchlen <= namelen) &&
 		    !strncmp(name, match, matchlen) &&
@@ -38,38 +38,43 @@ static int pathspec_matches(const char **paths, const char *name)
 		if (name[namelen-1] != '/')
 			continue;
 
-		/* We are being asked if the name directory is worth
+		/* We are being asked if the directory ("name") is worth
 		 * descending into.
 		 *
 		 * Find the longest leading directory name that does
 		 * not have metacharacter in the pathspec; the name
 		 * we are looking at must overlap with that directory.
 		 */
-		for (cp = match, slash = NULL; cp - match < matchlen; cp++) {
+		for (cp = match, meta = NULL; cp - match < matchlen; cp++) {
 			char ch = *cp;
-			if (ch == '/')
-				slash = cp;
-			if (ch == '*' || ch == '[')
+			if (ch == '*' || ch == '[' || ch == '?') {
+				meta = cp;
 				break;
+			}
 		}
-		if (!slash)
-			slash = match; /* toplevel */
-		else
-			slash++;
-		if (namelen <= slash - match) {
+		if (!meta)
+			meta = cp; /* fully literal */
+
+		if (namelen <= meta - match) {
 			/* Looking at "Documentation/" and
 			 * the pattern says "Documentation/howto/", or
-			 * "Documentation/diff*.txt".
+			 * "Documentation/diff*.txt".  The name we
+			 * have should match prefix.
 			 */
 			if (!memcmp(match, name, namelen))
 				return 1;
+			continue;
 		}
-		else {
+
+		if (meta - match < namelen) {
 			/* Looking at "Documentation/howto/" and
-			 * the pattern says "Documentation/h*".
+			 * the pattern says "Documentation/h*";
+			 * match up to "Do.../h"; this avoids descending
+			 * into "Documentation/technical/".
 			 */
-			if (!memcmp(match, name, slash - match))
+			if (!memcmp(match, name, meta - match))
 				return 1;
+			continue;
 		}
 	}
 	return 0;

From 7ed36f56e33bd838d06521a37a916516397e9e8b Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Wed, 3 May 2006 21:03:25 -0700
Subject: [PATCH 11/22] builtin-grep: terminate correctly at EOF

It barfed and segfaulted with an incomplete line.

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/builtin-grep.c b/builtin-grep.c
index 2124fa62e8..e87b5cb48d 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -264,6 +264,8 @@ static int grep_buffer(struct grep_opt *opt, const char *name,
 		}
 		*eol = ch;
 		bol = eol + 1;
+		if (!left)
+			break;
 		left--;
 		lno++;
 	}

From b8d0f5a00313bc5fb173f77c9a91a94f94a5aa1b Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Wed, 3 May 2006 21:05:29 -0700
Subject: [PATCH 12/22] builtin-grep: binary files -a and -I

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/builtin-grep.c b/builtin-grep.c
index e87b5cb48d..0d6115763b 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -95,6 +95,10 @@ struct grep_opt {
 	unsigned name_only:1;
 	unsigned count:1;
 	unsigned word_regexp:1;
+#define GREP_BINARY_DEFAULT	0
+#define GREP_BINARY_NOMATCH	1
+#define GREP_BINARY_TEXT	2
+	unsigned binary:2;
 	int regflags;
 	unsigned pre_context;
 	unsigned post_context;
@@ -148,6 +152,19 @@ static void show_line(struct grep_opt *opt, const char *bol, const char *eol,
 	printf("%.*s\n", (int)(eol-bol), bol);
 }
 
+/*
+ * NEEDSWORK: share code with diff.c
+ */
+#define FIRST_FEW_BYTES 8000
+static int buffer_is_binary(const char *ptr, unsigned long size)
+{
+	if (FIRST_FEW_BYTES < size)
+		size = FIRST_FEW_BYTES;
+	if (memchr(ptr, 0, size))
+		return 1;
+	return 0;
+}
+
 static int grep_buffer(struct grep_opt *opt, const char *name,
 		       char *buf, unsigned long size)
 {
@@ -160,9 +177,23 @@ static int grep_buffer(struct grep_opt *opt, const char *name,
 	} *prev = NULL, *pcl;
 	unsigned last_hit = 0;
 	unsigned last_shown = 0;
+	int binary_match_only = 0;
 	const char *hunk_mark = "";
 	unsigned count = 0;
 
+	if (buffer_is_binary(buf, size)) {
+		switch (opt->binary) {
+		case GREP_BINARY_DEFAULT:
+			binary_match_only = 1;
+			break;
+		case GREP_BINARY_NOMATCH:
+			return 0; /* Assume unmatch */
+			break;
+		default:
+			break;
+		}
+	}
+
 	if (opt->pre_context)
 		prev = xcalloc(opt->pre_context, sizeof(*prev));
 	if (opt->pre_context || opt->post_context)
@@ -212,6 +243,10 @@ static int grep_buffer(struct grep_opt *opt, const char *name,
 			hit = !hit;
 		if (hit) {
 			count++;
+			if (binary_match_only) {
+				printf("Binary file %s matches\n", name);
+				return 1;
+			}
 			if (opt->name_only) {
 				printf("%s\n", name);
 				return 1;
@@ -453,11 +488,20 @@ int cmd_grep(int argc, const char **argv, char **envp)
 			cached = 1;
 			continue;
 		}
+		if (!strcmp("-a", arg) ||
+		    !strcmp("--text", arg)) {
+			opt.binary = GREP_BINARY_TEXT;
+			continue;
+		}
 		if (!strcmp("-i", arg) ||
 		    !strcmp("--ignore-case", arg)) {
 			opt.regflags |= REG_ICASE;
 			continue;
 		}
+		if (!strcmp("-I", arg)) {
+			opt.binary = GREP_BINARY_NOMATCH;
+			continue;
+		}
 		if (!strcmp("-v", arg) ||
 		    !strcmp("--invert-match", arg)) {
 			opt.invert = 1;

From e23d2d6b765162902bd8b722e1659f002b97a302 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Wed, 3 May 2006 21:46:29 -0700
Subject: [PATCH 13/22] builtin-grep: -L (--files-without-match).

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/builtin-grep.c b/builtin-grep.c
index 0d6115763b..c89ee33a1e 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -93,6 +93,7 @@ struct grep_opt {
 	unsigned linenum:1;
 	unsigned invert:1;
 	unsigned name_only:1;
+	unsigned unmatch_name_only:1;
 	unsigned count:1;
 	unsigned word_regexp:1;
 #define GREP_BINARY_DEFAULT	0
@@ -241,6 +242,11 @@ static int grep_buffer(struct grep_opt *opt, const char *name,
 		 */
 		if (opt->invert)
 			hit = !hit;
+		if (opt->unmatch_name_only) {
+			if (hit)
+				return 0;
+			goto next_line;
+		}
 		if (hit) {
 			count++;
 			if (binary_match_only) {
@@ -297,6 +303,8 @@ static int grep_buffer(struct grep_opt *opt, const char *name,
 			prev->bol = bol;
 			prev->eol = eol;
 		}
+
+	next_line:
 		*eol = ch;
 		bol = eol + 1;
 		if (!left)
@@ -304,6 +312,13 @@ static int grep_buffer(struct grep_opt *opt, const char *name,
 		left--;
 		lno++;
 	}
+
+	if (opt->unmatch_name_only) {
+		/* We did not see any hit, so we want to show this */
+		printf("%s\n", name);
+		return 1;
+	}
+
 	/* NEEDSWORK:
 	 * The real "grep -c foo *.c" gives many "bar.c:0" lines,
 	 * which feels mostly useless but sometimes useful.  Maybe
@@ -532,6 +547,11 @@ int cmd_grep(int argc, const char **argv, char **envp)
 			opt.name_only = 1;
 			continue;
 		}
+		if (!strcmp("-L", arg) ||
+		    !strcmp("--files-without-match", arg)) {
+			opt.unmatch_name_only = 1;
+			continue;
+		}
 		if (!strcmp("-c", arg) ||
 		    !strcmp("--count", arg)) {
 			opt.count = 1;

From aa8c79ad03264c9e6b184379fb5f4bc34aefe0d6 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Mon, 8 May 2006 13:28:27 -0700
Subject: [PATCH 14/22] Teach -f <file> option to builtin-grep.

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 61 ++++++++++++++++++++++++++++++++++----------------
 1 file changed, 42 insertions(+), 19 deletions(-)

diff --git a/builtin-grep.c b/builtin-grep.c
index c89ee33a1e..a762c48a5a 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -82,6 +82,8 @@ static int pathspec_matches(const char **paths, const char *name)
 
 struct grep_pat {
 	struct grep_pat *next;
+	const char *origin;
+	int no;
 	const char *pattern;
 	regex_t regexp;
 };
@@ -105,10 +107,13 @@ struct grep_opt {
 	unsigned post_context;
 };
 
-static void add_pattern(struct grep_opt *opt, const char *pat)
+static void add_pattern(struct grep_opt *opt, const char *pat,
+			const char *origin, int no)
 {
 	struct grep_pat *p = xcalloc(1, sizeof(*p));
 	p->pattern = pat;
+	p->origin = origin;
+	p->no = no;
 	*opt->pattern_tail = p;
 	opt->pattern_tail = &p->next;
 	p->next = NULL;
@@ -121,9 +126,17 @@ static void compile_patterns(struct grep_opt *opt)
 		int err = regcomp(&p->regexp, p->pattern, opt->regflags);
 		if (err) {
 			char errbuf[1024];
+			char where[1024];
+			if (p->no)
+				sprintf(where, "In '%s' at %d, ",
+					p->origin, p->no);
+			else if (p->origin)
+				sprintf(where, "%s, ", p->origin);
+			else
+				where[0] = 0;
 			regerror(err, &p->regexp, errbuf, 1024);
 			regfree(&p->regexp);
-			die("'%s': %s", p->pattern, errbuf);
+			die("%s'%s': %s", where, p->pattern, errbuf);
 		}
 	}
 }
@@ -482,7 +495,6 @@ int cmd_grep(int argc, const char **argv, char **envp)
 {
 	int hit = 0;
 	int no_more_flags = 0;
-	int seen_noncommit = 0;
 	int cached = 0;
 	struct grep_opt opt;
 	struct object_list *list, **tail, *object_list = NULL;
@@ -598,9 +610,32 @@ int cmd_grep(int argc, const char **argv, char **envp)
 			}
 			continue;
 		}
+		if (!strcmp("-f", arg)) {
+			FILE *patterns;
+			int lno = 0;
+			char buf[1024];
+			if (argc <= 1)
+				usage(builtin_grep_usage);
+			patterns = fopen(argv[1], "r");
+			if (!patterns)
+				die("'%s': %s", strerror(errno));
+			while (fgets(buf, sizeof(buf), patterns)) {
+				int len = strlen(buf);
+				if (buf[len-1] == '\n')
+					buf[len-1] = 0;
+				/* ignore empty line like grep does */
+				if (!buf[0])
+					continue;
+				add_pattern(&opt, strdup(buf), argv[1], ++lno);
+			}
+			fclose(patterns);
+			argv++;
+			argc--;
+			continue;
+		}
 		if (!strcmp("-e", arg)) {
 			if (1 < argc) {
-				add_pattern(&opt, argv[1]);
+				add_pattern(&opt, argv[1], "-e option", 0);
 				argv++;
 				argc--;
 				continue;
@@ -615,7 +650,7 @@ int cmd_grep(int argc, const char **argv, char **envp)
 		if (!no_more_flags && *arg == '-')
 			usage(builtin_grep_usage);
 		if (!opt.pattern_list) {
-			add_pattern(&opt, arg);
+			add_pattern(&opt, arg, "command line", 0);
 			break;
 		}
 		else {
@@ -656,21 +691,9 @@ int cmd_grep(int argc, const char **argv, char **envp)
 
 	if (!object_list)
 		return !grep_cache(&opt, paths, cached);
-	/*
-	 * Do not walk "grep -e foo master next pu -- Documentation/"
-	 * but do walk "grep -e foo master..next -- Documentation/".
-	 * Ranged request mixed with a blob or tree object, like
-	 * "grep -e foo v1.0.0:Documentation/ master..next"
-	 * so detect that and complain.
-	 */
-	for (list = object_list; list; list = list->next) {
-		struct object *real_obj;
-		real_obj = deref_tag(list->item, NULL, 0);
-		if (strcmp(real_obj->type, commit_type))
-			seen_noncommit = 1;
-	}
+
 	if (cached)
-		die("both --cached and revisions given.");
+		die("both --cached and trees are given.");
 
 	for (list = object_list; list; list = list->next) {
 		struct object *real_obj;

From 1c57119c70332faf206b5c7e2f3639b96a221717 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Mon, 8 May 2006 13:28:49 -0700
Subject: [PATCH 15/22] builtin-grep: documentation

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 Documentation/git-grep.txt | 85 +++++++++++++++++++++++++++-----------
 1 file changed, 62 insertions(+), 23 deletions(-)

diff --git a/Documentation/git-grep.txt b/Documentation/git-grep.txt
index d55456ae93..56b683ae56 100644
--- a/Documentation/git-grep.txt
+++ b/Documentation/git-grep.txt
@@ -8,43 +8,82 @@ git-grep - Print lines matching a pattern
 
 SYNOPSIS
 --------
-'git-grep' [<option>...] [-e] <pattern> [--] [<path>...]
+[verse]
+'git-grep' [--cached]
+	   [-a | --text] [-I] [-i | --ignore-case] [-w | --word-regexp]
+	   [-v | --invert-match]
+	   [-E | --extended-regexp]  [-G | --basic-regexp]
+	   [-n] [-l | --files-with-matches] [-L | --files-without-match]
+	   [-c | --count]
+	   [-A <post-context>] [-B <pre-context>] [-C <context>]
+	   [-f <file>] [-e <pattern>]
+	   [<tree>...]
+	   [--] [<path>...]
 
 DESCRIPTION
 -----------
-Searches list of files `git-ls-files` produces for lines
-containing a match to the given pattern.
+Look for specified patterns in the working tree files, blobs
+registered in the index file, or given tree objects.
 
 
 OPTIONS
 -------
+--cached::
+	Instead of searching in the working tree files, check
+	the blobs registerd in the index file.
+
+-a | --text::
+	Process binary files as if they were text.
+
+-i | --ignore-case::
+	Ignore case differences between the patterns and the
+	files.
+
+-w | --word-regexp::
+	Match the pattern only at word boundary (either begin at the
+	beginning of a line, or preceded by a non-word character; end at
+	the end of a line or followed by a non-word character).
+
+-v | --invert-match::
+	Select non-matching lines.
+
+-E | --extended-regexp | -G | --basic-regexp::
+	Use POSIX extended/basic regexp for patterns.  Default
+	is to use basic regexp.
+
+-n::
+	Prefix the line number to matching lines.
+
+-l | --files-with-matches | -L | --files-without-match::
+	Instead of showing every matched line, show only the
+	names of files that contain (or do not contain) matches.
+
+-c | --count::
+	Instead of showing every matched line, show the number of
+	lines that match.
+
+-[ABC] <context>::
+	Show `context` trailing (`A` -- after), or leading (`B`
+	-- before), or both (`C` -- context) lines, and place a
+	line containing `--` between continguous groups of
+	matches.
+
+-f <file>::
+	Read patterns from <file>, one per line.
+
+`<tree>...`::
+	Search blobs in the trees for specified patterns.
+
 `--`::
 	Signals the end of options; the rest of the parameters
 	are <path> limiters.
 
-<option>...::
-	Either an option to pass to `grep` or `git-ls-files`.
-+
-The following are the specific `git-ls-files` options
-that may be given: `-o`, `--cached`, `--deleted`, `--others`,
-`--killed`, `--ignored`, `--modified`, `--exclude=\*`,
-`--exclude-from=\*`, and `--exclude-per-directory=\*`.
-+
-All other options will be passed to `grep`.
-
-<pattern>::
-	The pattern to look for.  The first non option is taken
-	as the pattern; if your pattern begins with a dash, use
-	`-e <pattern>`.
-
-<path>...::
-	Optional paths to limit the set of files to be searched;
-	passed to `git-ls-files`.
-
 
 Author
 ------
-Written by Linus Torvalds <torvalds@osdl.org>
+Originally written by Linus Torvalds <torvalds@osdl.org>, later
+revamped by Junio C Hamano.
+
 
 Documentation
 --------------

From 5acd64edec37a7d9783af1a2be99772d466e8f02 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Mon, 8 May 2006 23:55:47 -0700
Subject: [PATCH 16/22] builtin-grep: tighten argument parsing.

I mistyped

	git grep next -e '"^@"' '*.c'

and got many hits that contain "next" without complaint.
Obviously what I meant to say was:

	git grep -e '"^@"' next -- '*.c'

This tightens the argument parsing rule a bit:

 - All "grep" parameters should come first;

 - If there is no -e nor -f to specify pattern, the first non
   option string is the parameter;

 - After that, zero or more revs can follow.

 - An optional '--' can be present, and is skipped.

 - All the rest are pathspecs.  If '--' was not there, they must
   be paths that exist in the working tree.

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 76 +++++++++++++++++++++++++++++++++-----------------
 1 file changed, 50 insertions(+), 26 deletions(-)

diff --git a/builtin-grep.c b/builtin-grep.c
index a762c48a5a..26a3fc387f 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -494,20 +494,30 @@ static const char builtin_grep_usage[] =
 int cmd_grep(int argc, const char **argv, char **envp)
 {
 	int hit = 0;
-	int no_more_flags = 0;
 	int cached = 0;
+	int seen_dashdash = 0;
 	struct grep_opt opt;
 	struct object_list *list, **tail, *object_list = NULL;
 	const char *prefix = setup_git_directory();
 	const char **paths = NULL;
+	int i;
 
 	memset(&opt, 0, sizeof(opt));
 	opt.pattern_tail = &opt.pattern_list;
 	opt.regflags = REG_NEWLINE;
 
 	/*
-	 * No point using rev_info, really.
+	 * If there is no -- then the paths must exist in the working
+	 * tree.  If there is no explicit pattern specified with -e or
+	 * -f, we take the first unrecognized non option to be the
+	 * pattern, but then what follows it must be zero or more
+	 * valid refs up to the -- (if exists), and then existing
+	 * paths.  If there is an explicit pattern, then the first
+	 * unrecocnized non option is the beginning of the refs list
+	 * that continues up to the -- (if exists), and then paths.
 	 */
+
+	tail = &object_list;
 	while (1 < argc) {
 		const char *arg = argv[1];
 		argc--; argv++;
@@ -618,7 +628,7 @@ int cmd_grep(int argc, const char **argv, char **envp)
 				usage(builtin_grep_usage);
 			patterns = fopen(argv[1], "r");
 			if (!patterns)
-				die("'%s': %s", strerror(errno));
+				die("'%s': %s", argv[1], strerror(errno));
 			while (fgets(buf, sizeof(buf), patterns)) {
 				int len = strlen(buf);
 				if (buf[len-1] == '\n')
@@ -642,47 +652,61 @@ int cmd_grep(int argc, const char **argv, char **envp)
 			}
 			usage(builtin_grep_usage);
 		}
-		if (!strcmp("--", arg)) {
-			no_more_flags = 1;
-			continue;
-		}
-		/* Either unrecognized option or a single pattern */
-		if (!no_more_flags && *arg == '-')
+		if (!strcmp("--", arg))
+			break;
+		if (*arg == '-')
 			usage(builtin_grep_usage);
+
+		/* First unrecognized non-option token */
 		if (!opt.pattern_list) {
 			add_pattern(&opt, arg, "command line", 0);
 			break;
 		}
 		else {
 			/* We are looking at the first path or rev;
-			 * it is found at argv[0] after leaving the
+			 * it is found at argv[1] after leaving the
 			 * loop.
 			 */
 			argc++; argv--;
 			break;
 		}
 	}
+
 	if (!opt.pattern_list)
 		die("no pattern given.");
 	compile_patterns(&opt);
-	tail = &object_list;
-	while (1 < argc) {
-		struct object *object;
-		struct object_list *elem;
-		const char *arg = argv[1];
+
+	/* Check revs and then paths */
+	for (i = 1; i < argc; i++) {
+		const char *arg = argv[i];
 		unsigned char sha1[20];
-		if (get_sha1(arg, sha1) < 0)
-			break;
-		object = parse_object(sha1);
-		if (!object)
-			die("bad object %s", arg);
-		elem = object_list_insert(object, tail);
-		elem->name = arg;
-		tail = &elem->next;
-		argc--; argv++;
+		/* Is it a rev? */
+		if (!get_sha1(arg, sha1)) {
+			struct object *object = parse_object(sha1);
+			struct object_list *elem;
+			if (!object)
+				die("bad object %s", arg);
+			elem = object_list_insert(object, tail);
+			elem->name = arg;
+			tail = &elem->next;
+			continue;
+		}
+		if (!strcmp(arg, "--")) {
+			i++;
+			seen_dashdash = 1;
+		}
+		break;
 	}
-	if (1 < argc)
-		paths = get_pathspec(prefix, argv + 1);
+
+	/* The rest are paths */
+	if (!seen_dashdash) {
+		int j;
+		for (j = i; j < argc; i++)
+			verify_filename(prefix, argv[j]);
+	}
+
+	if (i < argc)
+		paths = get_pathspec(prefix, argv + i);
 	else if (prefix) {
 		paths = xcalloc(2, sizeof(const char *));
 		paths[0] = prefix;

From c39c4f4746ba4543b532594543d252e2bad62234 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Tue, 9 May 2006 18:15:21 -0700
Subject: [PATCH 17/22] builtin-grep: typofix

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/builtin-grep.c b/builtin-grep.c
index 26a3fc387f..d290074af2 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -701,7 +701,7 @@ int cmd_grep(int argc, const char **argv, char **envp)
 	/* The rest are paths */
 	if (!seen_dashdash) {
 		int j;
-		for (j = i; j < argc; i++)
+		for (j = i; j < argc; j++)
 			verify_filename(prefix, argv[j]);
 	}
 

From 02ab1c490dc4827446c851468eb01ecc23b6cc48 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Tue, 9 May 2006 18:27:56 -0700
Subject: [PATCH 18/22] builtin-grep: -w fix

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/builtin-grep.c b/builtin-grep.c
index d290074af2..52ac521afe 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -241,10 +241,10 @@ static int grep_buffer(struct grep_opt *opt, const char *name,
 					die("regexp returned nonsense");
 				if (pmatch[0].rm_so != 0 &&
 				    word_char(bol[pmatch[0].rm_so-1]))
-					continue; /* not a word boundary */
-				if ((eol-bol) < pmatch[0].rm_eo &&
+					hit = 0;
+				if (pmatch[0].rm_eo != (eol-bol) &&
 				    word_char(bol[pmatch[0].rm_eo]))
-					continue; /* not a word boundary */
+					hit = 0;
 			}
 			if (hit)
 				break;

From 07ea91d84f3c7bb075d4716ee40096e3b12a4c86 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Tue, 9 May 2006 18:28:41 -0700
Subject: [PATCH 19/22] builtin-grep: -F (--fixed-strings)

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 Documentation/git-grep.txt |  2 +-
 builtin-grep.c             | 36 ++++++++++++++++++++++++++++++++----
 2 files changed, 33 insertions(+), 5 deletions(-)

diff --git a/Documentation/git-grep.txt b/Documentation/git-grep.txt
index 56b683ae56..74102b7944 100644
--- a/Documentation/git-grep.txt
+++ b/Documentation/git-grep.txt
@@ -12,7 +12,7 @@ SYNOPSIS
 'git-grep' [--cached]
 	   [-a | --text] [-I] [-i | --ignore-case] [-w | --word-regexp]
 	   [-v | --invert-match]
-	   [-E | --extended-regexp]  [-G | --basic-regexp]
+	   [-E | --extended-regexp] [-G | --basic-regexp] [-F | --fixed-strings]
 	   [-n] [-l | --files-with-matches] [-L | --files-without-match]
 	   [-c | --count]
 	   [-A <post-context>] [-B <pre-context>] [-C <context>]
diff --git a/builtin-grep.c b/builtin-grep.c
index 52ac521afe..fead356629 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -98,6 +98,7 @@ struct grep_opt {
 	unsigned unmatch_name_only:1;
 	unsigned count:1;
 	unsigned word_regexp:1;
+	unsigned fixed:1;
 #define GREP_BINARY_DEFAULT	0
 #define GREP_BINARY_NOMATCH	1
 #define GREP_BINARY_TEXT	2
@@ -179,6 +180,20 @@ static int buffer_is_binary(const char *ptr, unsigned long size)
 	return 0;
 }
 
+static int fixmatch(const char *pattern, char *line, regmatch_t *match)
+{
+	char *hit = strstr(line, pattern);
+	if (!hit) {
+		match->rm_so = match->rm_eo = -1;
+		return REG_NOMATCH;
+	}
+	else {
+		match->rm_so = hit - line;
+		match->rm_eo = match->rm_so + strlen(pattern);
+		return 0;
+	}
+}
+
 static int grep_buffer(struct grep_opt *opt, const char *name,
 		       char *buf, unsigned long size)
 {
@@ -224,9 +239,14 @@ static int grep_buffer(struct grep_opt *opt, const char *name,
 		*eol = 0;
 
 		for (p = opt->pattern_list; p; p = p->next) {
-			regex_t *exp = &p->regexp;
-			hit = !regexec(exp, bol, ARRAY_SIZE(pmatch),
-				       pmatch, 0);
+			if (!opt->fixed) {
+				regex_t *exp = &p->regexp;
+				hit = !regexec(exp, bol, ARRAY_SIZE(pmatch),
+					       pmatch, 0);
+			}
+			else {
+				hit = !fixmatch(p->pattern, bol, pmatch);
+			}
 
 			if (hit && opt->word_regexp) {
 				/* Match beginning must be either
@@ -549,6 +569,11 @@ int cmd_grep(int argc, const char **argv, char **envp)
 			opt.regflags |= REG_EXTENDED;
 			continue;
 		}
+		if (!strcmp("-F", arg) ||
+		    !strcmp("--fixed-strings", arg)) {
+			opt.fixed = 1;
+			continue;
+		}
 		if (!strcmp("-G", arg) ||
 		    !strcmp("--basic-regexp", arg)) {
 			opt.regflags &= ~REG_EXTENDED;
@@ -674,7 +699,10 @@ int cmd_grep(int argc, const char **argv, char **envp)
 
 	if (!opt.pattern_list)
 		die("no pattern given.");
-	compile_patterns(&opt);
+	if ((opt.regflags != REG_NEWLINE) && opt.fixed)
+		die("cannot mix --fixed-strings and regexp");
+	if (!opt.fixed)
+		compile_patterns(&opt);
 
 	/* Check revs and then paths */
 	for (i = 1; i < argc; i++) {

From 1e2398d7fad308dcc6019709244b40303b51b54d Mon Sep 17 00:00:00 2001
From: Linus Torvalds <torvalds@osdl.org>
Date: Sun, 14 May 2006 20:49:15 -0700
Subject: [PATCH 20/22] builtin-grep: use external grep when we can take
 advantage of it

It's not perfect, but it gets the "git grep some-random-string" down to
the good old half-a-second range for the kernel.

It should convert more of the argument flags for "grep", that should be
trivial to expand (I did a few just as an example). It should also bother
to try to return the right "hit" value (which it doesn't, right now - the
code is kind of there, but I didn't actually bother to do it _right_).

Also, right now it _just_ limits by number of arguments, but it should
also strictly speaking limit by total argument size (ie add up the length
of the filenames, and do the "exec_grep()" flush call if it's bigger than
some random value like 32kB).

But I think that it's _conceptually_ doing all the right things, and it
seems to work. So maybe somebody else can do some of the final polish.

Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 79 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 79 insertions(+)

diff --git a/builtin-grep.c b/builtin-grep.c
index fead356629..14471db7cb 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -12,6 +12,7 @@
 #include "builtin.h"
 #include <regex.h>
 #include <fnmatch.h>
+#include <sys/wait.h>
 
 /*
  * git grep pathspecs are somewhat different from diff-tree pathspecs;
@@ -409,12 +410,90 @@ static int grep_file(struct grep_opt *opt, const char *filename)
 	return i;
 }
 
+static int exec_grep(int argc, const char **argv)
+{
+	pid_t pid;
+	int status;
+
+	argv[argc] = NULL;
+	pid = fork();
+	if (pid < 0)
+		return pid;
+	if (!pid) {
+		execvp("grep", (char **) argv);
+		exit(255);
+	}
+	while (waitpid(pid, &status, 0) < 0) {
+		if (errno == EINTR)
+			continue;
+		return -1;
+	}
+	if (WIFEXITED(status)) {
+		if (!WEXITSTATUS(status))
+			return 1;
+		return 0;
+	}
+	return -1;
+}
+
+#define MAXARGS 1000
+
+static int external_grep(struct grep_opt *opt, const char **paths, int cached)
+{
+	int i, nr, argc, hit;
+	const char *argv[MAXARGS+1];
+	struct grep_pat *p;
+
+	nr = 0;
+	argv[nr++] = "grep";
+	if (opt->word_regexp)
+		argv[nr++] = "-w";
+	if (opt->name_only)
+		argv[nr++] = "-l";
+	for (p = opt->pattern_list; p; p = p->next) {
+		argv[nr++] = "-e";
+		argv[nr++] = p->pattern;
+	}
+	argv[nr++] = "--";
+
+	hit = 0;
+	argc = nr;
+	for (i = 0; i < active_nr; i++) {
+		struct cache_entry *ce = active_cache[i];
+		if (ce_stage(ce) || !S_ISREG(ntohl(ce->ce_mode)))
+			continue;
+		if (!pathspec_matches(paths, ce->name))
+			continue;
+		argv[argc++] = ce->name;
+		if (argc < MAXARGS)
+			continue;
+		hit += exec_grep(argc, argv);
+		argc = nr;
+	}
+	if (argc > nr)
+		hit += exec_grep(argc, argv);
+	return 0;
+}
+
 static int grep_cache(struct grep_opt *opt, const char **paths, int cached)
 {
 	int hit = 0;
 	int nr;
 	read_cache();
 
+#ifdef __unix__
+	/*
+	 * Use the external "grep" command for the case where
+	 * we grep through the checked-out files. It tends to
+	 * be a lot more optimized
+	 */
+	if (!cached) {
+		hit = external_grep(opt, paths, cached);
+		if (hit >= 0)
+			return hit;
+	}
+#endif
+
 	for (nr = 0; nr < active_nr; nr++) {
 		struct cache_entry *ce = active_cache[nr];
 		if (ce_stage(ce) || !S_ISREG(ntohl(ce->ce_mode)))

From ffa0a7ab36c1e8a528e4cc0ff451f5fea68658a8 Mon Sep 17 00:00:00 2001
From: Junio C Hamano <junkio@cox.net>
Date: Mon, 15 May 2006 13:28:01 -0700
Subject: [PATCH 21/22] builtin-grep: unparse more command line options.

The earlier one to use external grep missed some often used options.

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 67 +++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 58 insertions(+), 9 deletions(-)

diff --git a/builtin-grep.c b/builtin-grep.c
index 14471db7cb..3d6e515f1f 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -437,24 +437,73 @@ static int exec_grep(int argc, const char **argv)
 }
 
 #define MAXARGS 1000
+#define ARGBUF 4096
+#define push_arg(a) do { \
+	if (nr < MAXARGS) argv[nr++] = (a); \
+	else die("maximum number of args exceeded"); \
+	} while (0)
 
 static int external_grep(struct grep_opt *opt, const char **paths, int cached)
 {
-	int i, nr, argc, hit;
+	int i, nr, argc, hit, len;
 	const char *argv[MAXARGS+1];
+	char randarg[ARGBUF];
+	char *argptr = randarg;
 	struct grep_pat *p;
 
-	nr = 0;
-	argv[nr++] = "grep";
+	len = nr = 0;
+	push_arg("grep");
+	push_arg("-H");
+	if (opt->fixed)
+		push_arg("-H");
+	if (opt->linenum)
+		push_arg("-n");
+	if (opt->regflags & REG_EXTENDED)
+		push_arg("-E");
 	if (opt->word_regexp)
-		argv[nr++] = "-w";
+		push_arg("-w");
 	if (opt->name_only)
-		argv[nr++] = "-l";
-	for (p = opt->pattern_list; p; p = p->next) {
-		argv[nr++] = "-e";
-		argv[nr++] = p->pattern;
+		push_arg("-l");
+	if (opt->unmatch_name_only)
+		push_arg("-L");
+	if (opt->count)
+		push_arg("-c");
+	if (opt->post_context || opt->pre_context) {
+		if (opt->post_context != opt->pre_context) {
+			if (opt->pre_context) {
+				push_arg("-B");
+				len += snprintf(argptr, sizeof(randarg)-len,
+						"%u", opt->pre_context);
+				if (sizeof(randarg) <= len)
+					die("maximum length of args exceeded");
+				push_arg(argptr);
+				argptr += len;
+			}
+			if (opt->post_context) {
+				push_arg("-A");
+				len += snprintf(argptr, sizeof(randarg)-len,
+						"%u", opt->post_context);
+				if (sizeof(randarg) <= len)
+					die("maximum length of args exceeded");
+				push_arg(argptr);
+				argptr += len;
+			}
+		}
+		else {
+			push_arg("-C");
+			len += snprintf(argptr, sizeof(randarg)-len,
+					"%u", opt->post_context);
+			if (sizeof(randarg) <= len)
+				die("maximum length of args exceeded");
+			push_arg(argptr);
+			argptr += len;
+		}
 	}
-	argv[nr++] = "--";
+	for (p = opt->pattern_list; p; p = p->next) {
+		push_arg("-e");
+		push_arg(p->pattern);
+	}
+	push_arg("--");
 
 	hit = 0;
 	argc = nr;

From f66475199cbf50d9da9db617a280aac3196b2250 Mon Sep 17 00:00:00 2001
From: Linus Torvalds <torvalds@osdl.org>
Date: Mon, 15 May 2006 17:54:01 -0700
Subject: [PATCH 22/22] Fix silly typo in new builtin grep

The "-F" flag apparently got mis-translated due to some over-eager
copy-paste work into a duplicate "-H" when using the external grep.

Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 builtin-grep.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/builtin-grep.c b/builtin-grep.c
index 3d6e515f1f..66111de514 100644
--- a/builtin-grep.c
+++ b/builtin-grep.c
@@ -455,7 +455,7 @@ static int external_grep(struct grep_opt *opt, const char **paths, int cached)
 	push_arg("grep");
 	push_arg("-H");
 	if (opt->fixed)
-		push_arg("-H");
+		push_arg("-F");
 	if (opt->linenum)
 		push_arg("-n");
 	if (opt->regflags & REG_EXTENDED)