X-Git-Url: https://git.octo.it/?a=blobdiff_plain;f=builtin-grep.c;h=5fac5701e6ccebdbe83b00d2e2df19343d3aea0e;hb=0e8a002c59cbaca692dac81320be44c965588291;hp=c89ee33a1ede4e032cae850315ee2b2185a64457;hpb=e23d2d6b765162902bd8b722e1659f002b97a302;p=git.git

diff --git a/builtin-grep.c b/builtin-grep.c
index c89ee33a..5fac5701 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;
@@ -82,6 +83,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;
 };
@@ -96,6 +99,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
@@ -105,10 +109,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 +128,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);
 		}
 	}
 }
@@ -166,6 +181,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)
 {
@@ -211,9 +240,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
@@ -228,10 +262,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;
@@ -376,12 +410,158 @@ 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
+#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, len;
+	const char *argv[MAXARGS+1];
+	char randarg[ARGBUF];
+	char *argptr = randarg;
+	struct grep_pat *p;
+
+	len = nr = 0;
+	push_arg("grep");
+	if (opt->fixed)
+		push_arg("-F");
+	if (opt->linenum)
+		push_arg("-n");
+	if (opt->regflags & REG_EXTENDED)
+		push_arg("-E");
+	if (opt->regflags & REG_ICASE)
+		push_arg("-i");
+	if (opt->word_regexp)
+		push_arg("-w");
+	if (opt->name_only)
+		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;
+		}
+	}
+	for (p = opt->pattern_list; p; p = p->next) {
+		push_arg("-e");
+		push_arg(p->pattern);
+	}
+
+	/*
+	 * To make sure we get the header printed out when we want it,
+	 * add /dev/null to the paths to grep.  This is unnecessary
+	 * (and wrong) with "-l" or "-L", which always print out the
+	 * name anyway.
+	 *
+	 * GNU grep has "-H", but this is portable.
+	 */
+	if (!opt->name_only && !opt->unmatch_name_only)
+		push_arg("/dev/null");
+
+	hit = 0;
+	argc = nr;
+	for (i = 0; i < active_nr; i++) {
+		struct cache_entry *ce = active_cache[i];
+		char *name;
+		if (ce_stage(ce) || !S_ISREG(ntohl(ce->ce_mode)))
+			continue;
+		if (!pathspec_matches(paths, ce->name))
+			continue;
+		name = ce->name;
+		if (name[0] == '-') {
+			int len = ce_namelen(ce);
+			name = xmalloc(len + 3);
+			memcpy(name, "./", 2);
+			memcpy(name + 2, ce->name, len + 1);
+		}
+		argv[argc++] = 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)))
@@ -400,11 +580,9 @@ static int grep_tree(struct grep_opt *opt, const char **paths,
 		     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;
+	struct name_entry entry;
 	char *down;
 	char *path_buf = xmalloc(PATH_MAX + strlen(tree_name) + 100);
 
@@ -419,36 +597,32 @@ static int grep_tree(struct grep_opt *opt, const char **paths,
 	}
 	len = strlen(path_buf);
 
-	while (tree->size) {
-		int pathlen;
-		sha1 = tree_entry_extract(tree, &path, &mode);
-		pathlen = strlen(path);
-		strcpy(path_buf + len, path);
+	while (tree_entry(tree, &entry)) {
+		strcpy(path_buf + len, entry.path);
 
-		if (S_ISDIR(mode))
+		if (S_ISDIR(entry.mode))
 			/* Match "abc/" against pathspec to
 			 * decide if we want to descend into "abc"
 			 * directory.
 			 */
-			strcpy(path_buf + len + pathlen, "/");
+			strcpy(path_buf + len + entry.pathlen, "/");
 
 		if (!pathspec_matches(paths, down))
 			;
-		else if (S_ISREG(mode))
-			hit |= grep_sha1(opt, sha1, path_buf);
-		else if (S_ISDIR(mode)) {
+		else if (S_ISREG(entry.mode))
+			hit |= grep_sha1(opt, entry.sha1, path_buf);
+		else if (S_ISDIR(entry.mode)) {
 			char type[20];
 			struct tree_desc sub;
 			void *data;
-			data = read_sha1_file(sha1, type, &sub.size);
+			data = read_sha1_file(entry.sha1, type, &sub.size);
 			if (!data)
 				die("unable to read tree (%s)",
-				    sha1_to_hex(sha1));
+				    sha1_to_hex(entry.sha1));
 			sub.buf = data;
 			hit |= grep_tree(opt, paths, &sub, tree_name, down);
 			free(data);
 		}
-		update_tree_entry(tree);
 	}
 	return hit;
 }
@@ -481,21 +655,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 seen_noncommit = 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++;
@@ -527,6 +710,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;
@@ -598,56 +786,96 @@ 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", argv[1], 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;
 			}
 			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);
+			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];
+	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++) {
+		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; j++)
+			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;
@@ -656,21 +884,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;