submodule: Use cat instead of echo to avoid DOS line-endings
[git/dscho.git] / builtin / grep.c
blobb18491bc8cbb4a1112e0432d541d2fa6de66d52b
1 /*
2 * Builtin "git grep"
4 * Copyright (c) 2006 Junio C Hamano
5 */
6 #include "cache.h"
7 #include "blob.h"
8 #include "tree.h"
9 #include "commit.h"
10 #include "tag.h"
11 #include "tree-walk.h"
12 #include "builtin.h"
13 #include "parse-options.h"
14 #include "string-list.h"
15 #include "run-command.h"
16 #include "userdiff.h"
17 #include "grep.h"
18 #include "quote.h"
19 #include "dir.h"
20 #include "thread-utils.h"
21 #include "attr.h"
23 static char const * const grep_usage[] = {
24 "git grep [options] [-e] <pattern> [<rev>...] [[--] <path>...]",
25 NULL
28 static int use_threads = 1;
30 #ifndef NO_PTHREADS
31 #define THREADS 8
32 static pthread_t threads[THREADS];
34 static void *load_sha1(const unsigned char *sha1, unsigned long *size,
35 const char *name);
36 static void *load_file(const char *filename, size_t *sz);
38 enum work_type {WORK_SHA1, WORK_FILE};
40 /* We use one producer thread and THREADS consumer
41 * threads. The producer adds struct work_items to 'todo' and the
42 * consumers pick work items from the same array.
44 struct work_item {
45 enum work_type type;
46 char *name;
48 /* if type == WORK_SHA1, then 'identifier' is a SHA1,
49 * otherwise type == WORK_FILE, and 'identifier' is a NUL
50 * terminated filename.
52 void *identifier;
53 char done;
54 struct strbuf out;
57 /* In the range [todo_done, todo_start) in 'todo' we have work_items
58 * that have been or are processed by a consumer thread. We haven't
59 * written the result for these to stdout yet.
61 * The work_items in [todo_start, todo_end) are waiting to be picked
62 * up by a consumer thread.
64 * The ranges are modulo TODO_SIZE.
66 #define TODO_SIZE 128
67 static struct work_item todo[TODO_SIZE];
68 static int todo_start;
69 static int todo_end;
70 static int todo_done;
72 /* Has all work items been added? */
73 static int all_work_added;
75 /* This lock protects all the variables above. */
76 static pthread_mutex_t grep_mutex;
78 static inline void grep_lock(void)
80 if (use_threads)
81 pthread_mutex_lock(&grep_mutex);
84 static inline void grep_unlock(void)
86 if (use_threads)
87 pthread_mutex_unlock(&grep_mutex);
90 /* Used to serialize calls to read_sha1_file. */
91 static pthread_mutex_t read_sha1_mutex;
93 static inline void read_sha1_lock(void)
95 if (use_threads)
96 pthread_mutex_lock(&read_sha1_mutex);
99 static inline void read_sha1_unlock(void)
101 if (use_threads)
102 pthread_mutex_unlock(&read_sha1_mutex);
105 /* Signalled when a new work_item is added to todo. */
106 static pthread_cond_t cond_add;
108 /* Signalled when the result from one work_item is written to
109 * stdout.
111 static pthread_cond_t cond_write;
113 /* Signalled when we are finished with everything. */
114 static pthread_cond_t cond_result;
116 static int skip_first_line;
118 static void add_work(enum work_type type, char *name, void *id)
120 grep_lock();
122 while ((todo_end+1) % ARRAY_SIZE(todo) == todo_done) {
123 pthread_cond_wait(&cond_write, &grep_mutex);
126 todo[todo_end].type = type;
127 todo[todo_end].name = name;
128 todo[todo_end].identifier = id;
129 todo[todo_end].done = 0;
130 strbuf_reset(&todo[todo_end].out);
131 todo_end = (todo_end + 1) % ARRAY_SIZE(todo);
133 pthread_cond_signal(&cond_add);
134 grep_unlock();
137 static struct work_item *get_work(void)
139 struct work_item *ret;
141 grep_lock();
142 while (todo_start == todo_end && !all_work_added) {
143 pthread_cond_wait(&cond_add, &grep_mutex);
146 if (todo_start == todo_end && all_work_added) {
147 ret = NULL;
148 } else {
149 ret = &todo[todo_start];
150 todo_start = (todo_start + 1) % ARRAY_SIZE(todo);
152 grep_unlock();
153 return ret;
156 static void grep_sha1_async(struct grep_opt *opt, char *name,
157 const unsigned char *sha1)
159 unsigned char *s;
160 s = xmalloc(20);
161 memcpy(s, sha1, 20);
162 add_work(WORK_SHA1, name, s);
165 static void grep_file_async(struct grep_opt *opt, char *name,
166 const char *filename)
168 add_work(WORK_FILE, name, xstrdup(filename));
171 static void work_done(struct work_item *w)
173 int old_done;
175 grep_lock();
176 w->done = 1;
177 old_done = todo_done;
178 for(; todo[todo_done].done && todo_done != todo_start;
179 todo_done = (todo_done+1) % ARRAY_SIZE(todo)) {
180 w = &todo[todo_done];
181 if (w->out.len) {
182 const char *p = w->out.buf;
183 size_t len = w->out.len;
185 /* Skip the leading hunk mark of the first file. */
186 if (skip_first_line) {
187 while (len) {
188 len--;
189 if (*p++ == '\n')
190 break;
192 skip_first_line = 0;
195 write_or_die(1, p, len);
197 free(w->name);
198 free(w->identifier);
201 if (old_done != todo_done)
202 pthread_cond_signal(&cond_write);
204 if (all_work_added && todo_done == todo_end)
205 pthread_cond_signal(&cond_result);
207 grep_unlock();
210 static int skip_binary(struct grep_opt *opt, const char *filename)
212 if ((opt->binary & GREP_BINARY_NOMATCH)) {
213 static struct git_attr *attr_text;
214 struct git_attr_check check;
216 if (!attr_text)
217 attr_text = git_attr("text");
218 memset(&check, 0, sizeof(check));
219 check.attr = attr_text;
220 return !git_check_attr(filename, 1, &check) &&
221 ATTR_FALSE(check.value);
223 return 0;
226 static void *run(void *arg)
228 int hit = 0;
229 struct grep_opt *opt = arg;
231 while (1) {
232 struct work_item *w = get_work();
233 if (!w)
234 break;
236 if (skip_binary(opt, (const char *)w->identifier))
237 continue;
239 opt->output_priv = w;
240 if (w->type == WORK_SHA1) {
241 unsigned long sz;
242 void* data = load_sha1(w->identifier, &sz, w->name);
244 if (data) {
245 hit |= grep_buffer(opt, w->name, data, sz);
246 free(data);
248 } else if (w->type == WORK_FILE) {
249 size_t sz;
250 void* data = load_file(w->identifier, &sz);
251 if (data) {
252 hit |= grep_buffer(opt, w->name, data, sz);
253 free(data);
255 } else {
256 assert(0);
259 work_done(w);
261 free_grep_patterns(arg);
262 free(arg);
264 return (void*) (intptr_t) hit;
267 static void strbuf_out(struct grep_opt *opt, const void *buf, size_t size)
269 struct work_item *w = opt->output_priv;
270 strbuf_add(&w->out, buf, size);
273 static void start_threads(struct grep_opt *opt)
275 int i;
277 pthread_mutex_init(&grep_mutex, NULL);
278 pthread_mutex_init(&read_sha1_mutex, NULL);
279 pthread_cond_init(&cond_add, NULL);
280 pthread_cond_init(&cond_write, NULL);
281 pthread_cond_init(&cond_result, NULL);
283 for (i = 0; i < ARRAY_SIZE(todo); i++) {
284 strbuf_init(&todo[i].out, 0);
287 for (i = 0; i < ARRAY_SIZE(threads); i++) {
288 int err;
289 struct grep_opt *o = grep_opt_dup(opt);
290 o->output = strbuf_out;
291 compile_grep_patterns(o);
292 err = pthread_create(&threads[i], NULL, run, o);
294 if (err)
295 die(_("grep: failed to create thread: %s"),
296 strerror(err));
300 static int wait_all(void)
302 int hit = 0;
303 int i;
305 grep_lock();
306 all_work_added = 1;
308 /* Wait until all work is done. */
309 while (todo_done != todo_end)
310 pthread_cond_wait(&cond_result, &grep_mutex);
312 /* Wake up all the consumer threads so they can see that there
313 * is no more work to do.
315 pthread_cond_broadcast(&cond_add);
316 grep_unlock();
318 for (i = 0; i < ARRAY_SIZE(threads); i++) {
319 void *h;
320 pthread_join(threads[i], &h);
321 hit |= (int) (intptr_t) h;
324 pthread_mutex_destroy(&grep_mutex);
325 pthread_mutex_destroy(&read_sha1_mutex);
326 pthread_cond_destroy(&cond_add);
327 pthread_cond_destroy(&cond_write);
328 pthread_cond_destroy(&cond_result);
330 return hit;
332 #else /* !NO_PTHREADS */
333 #define read_sha1_lock()
334 #define read_sha1_unlock()
336 static int wait_all(void)
338 return 0;
340 #endif
342 static int grep_config(const char *var, const char *value, void *cb)
344 struct grep_opt *opt = cb;
345 char *color = NULL;
347 switch (userdiff_config(var, value)) {
348 case 0: break;
349 case -1: return -1;
350 default: return 0;
353 if (!strcmp(var, "grep.extendedregexp")) {
354 if (git_config_bool(var, value))
355 opt->regflags |= REG_EXTENDED;
356 else
357 opt->regflags &= ~REG_EXTENDED;
358 return 0;
361 if (!strcmp(var, "grep.linenumber")) {
362 opt->linenum = git_config_bool(var, value);
363 return 0;
366 if (!strcmp(var, "color.grep"))
367 opt->color = git_config_colorbool(var, value);
368 else if (!strcmp(var, "color.grep.context"))
369 color = opt->color_context;
370 else if (!strcmp(var, "color.grep.filename"))
371 color = opt->color_filename;
372 else if (!strcmp(var, "color.grep.function"))
373 color = opt->color_function;
374 else if (!strcmp(var, "color.grep.linenumber"))
375 color = opt->color_lineno;
376 else if (!strcmp(var, "color.grep.match"))
377 color = opt->color_match;
378 else if (!strcmp(var, "color.grep.selected"))
379 color = opt->color_selected;
380 else if (!strcmp(var, "color.grep.separator"))
381 color = opt->color_sep;
382 else
383 return git_color_default_config(var, value, cb);
384 if (color) {
385 if (!value)
386 return config_error_nonbool(var);
387 color_parse(value, var, color);
389 return 0;
392 static void *lock_and_read_sha1_file(const unsigned char *sha1, enum object_type *type, unsigned long *size)
394 void *data;
396 read_sha1_lock();
397 data = read_sha1_file(sha1, type, size);
398 read_sha1_unlock();
399 return data;
402 static void *load_sha1(const unsigned char *sha1, unsigned long *size,
403 const char *name)
405 enum object_type type;
406 void *data = lock_and_read_sha1_file(sha1, &type, size);
408 if (!data)
409 error(_("'%s': unable to read %s"), name, sha1_to_hex(sha1));
411 return data;
414 static int grep_sha1(struct grep_opt *opt, const unsigned char *sha1,
415 const char *filename, int tree_name_len)
417 struct strbuf pathbuf = STRBUF_INIT;
418 char *name;
420 if (opt->relative && opt->prefix_length) {
421 quote_path_relative(filename + tree_name_len, -1, &pathbuf,
422 opt->prefix);
423 strbuf_insert(&pathbuf, 0, filename, tree_name_len);
424 } else {
425 strbuf_addstr(&pathbuf, filename);
428 name = strbuf_detach(&pathbuf, NULL);
430 #ifndef NO_PTHREADS
431 if (use_threads) {
432 grep_sha1_async(opt, name, sha1);
433 return 0;
434 } else
435 #endif
437 int hit;
438 unsigned long sz;
439 void *data = load_sha1(sha1, &sz, name);
440 if (!data)
441 hit = 0;
442 else
443 hit = grep_buffer(opt, name, data, sz);
445 free(data);
446 free(name);
447 return hit;
451 static void *load_file(const char *filename, size_t *sz)
453 struct stat st;
454 char *data;
455 int i;
457 if (lstat(filename, &st) < 0) {
458 err_ret:
459 if (errno != ENOENT)
460 error(_("'%s': %s"), filename, strerror(errno));
461 return NULL;
463 if (!S_ISREG(st.st_mode))
464 return NULL;
465 *sz = xsize_t(st.st_size);
466 i = open(filename, O_RDONLY);
467 if (i < 0)
468 goto err_ret;
469 data = xmalloc(*sz + 1);
470 if (st.st_size != read_in_full(i, data, *sz)) {
471 error(_("'%s': short read %s"), filename, strerror(errno));
472 close(i);
473 free(data);
474 return NULL;
476 close(i);
477 data[*sz] = 0;
478 return data;
481 static int grep_file(struct grep_opt *opt, const char *filename)
483 struct strbuf buf = STRBUF_INIT;
484 char *name;
486 if (opt->relative && opt->prefix_length)
487 quote_path_relative(filename, -1, &buf, opt->prefix);
488 else
489 strbuf_addstr(&buf, filename);
490 name = strbuf_detach(&buf, NULL);
492 #ifndef NO_PTHREADS
493 if (use_threads) {
494 grep_file_async(opt, name, filename);
495 return 0;
496 } else
497 #endif
499 int hit;
500 size_t sz;
501 void *data = load_file(filename, &sz);
502 if (!data)
503 hit = 0;
504 else
505 hit = grep_buffer(opt, name, data, sz);
507 free(data);
508 free(name);
509 return hit;
513 static void append_path(struct grep_opt *opt, const void *data, size_t len)
515 struct string_list *path_list = opt->output_priv;
517 if (len == 1 && *(const char *)data == '\0')
518 return;
519 string_list_append(path_list, xstrndup(data, len));
522 static void run_pager(struct grep_opt *opt, const char *prefix)
524 struct string_list *path_list = opt->output_priv;
525 const char **argv = xmalloc(sizeof(const char *) * (path_list->nr + 1));
526 int i, status;
528 for (i = 0; i < path_list->nr; i++)
529 argv[i] = path_list->items[i].string;
530 argv[path_list->nr] = NULL;
532 if (prefix && chdir(prefix))
533 die(_("Failed to chdir: %s"), prefix);
534 status = run_command_v_opt(argv, RUN_USING_SHELL);
535 if (status)
536 exit(status);
537 free(argv);
540 static int grep_cache(struct grep_opt *opt, const struct pathspec *pathspec, int cached)
542 int hit = 0;
543 int nr;
544 read_cache();
546 for (nr = 0; nr < active_nr; nr++) {
547 struct cache_entry *ce = active_cache[nr];
548 if (!S_ISREG(ce->ce_mode))
549 continue;
550 if (!match_pathspec_depth(pathspec, ce->name, ce_namelen(ce), 0, NULL))
551 continue;
552 if (skip_binary(opt, ce->name))
553 continue;
556 * If CE_VALID is on, we assume worktree file and its cache entry
557 * are identical, even if worktree file has been modified, so use
558 * cache version instead
560 if (cached || (ce->ce_flags & CE_VALID) || ce_skip_worktree(ce)) {
561 if (ce_stage(ce))
562 continue;
563 hit |= grep_sha1(opt, ce->sha1, ce->name, 0);
565 else
566 hit |= grep_file(opt, ce->name);
567 if (ce_stage(ce)) {
568 do {
569 nr++;
570 } while (nr < active_nr &&
571 !strcmp(ce->name, active_cache[nr]->name));
572 nr--; /* compensate for loop control */
574 if (hit && opt->status_only)
575 break;
577 return hit;
580 static int grep_tree(struct grep_opt *opt, const struct pathspec *pathspec,
581 struct tree_desc *tree, struct strbuf *base, int tn_len)
583 int hit = 0;
584 enum interesting match = entry_not_interesting;
585 struct name_entry entry;
586 int old_baselen = base->len;
588 while (tree_entry(tree, &entry)) {
589 int te_len = tree_entry_len(&entry);
591 if (match != all_entries_interesting) {
592 match = tree_entry_interesting(&entry, base, tn_len, pathspec);
593 if (match == all_entries_not_interesting)
594 break;
595 if (match == entry_not_interesting)
596 continue;
599 strbuf_add(base, entry.path, te_len);
601 if (S_ISREG(entry.mode)) {
602 hit |= grep_sha1(opt, entry.sha1, base->buf, tn_len);
604 else if (S_ISDIR(entry.mode)) {
605 enum object_type type;
606 struct tree_desc sub;
607 void *data;
608 unsigned long size;
610 data = lock_and_read_sha1_file(entry.sha1, &type, &size);
611 if (!data)
612 die(_("unable to read tree (%s)"),
613 sha1_to_hex(entry.sha1));
615 strbuf_addch(base, '/');
616 init_tree_desc(&sub, data, size);
617 hit |= grep_tree(opt, pathspec, &sub, base, tn_len);
618 free(data);
620 strbuf_setlen(base, old_baselen);
622 if (hit && opt->status_only)
623 break;
625 return hit;
628 static int grep_object(struct grep_opt *opt, const struct pathspec *pathspec,
629 struct object *obj, const char *name)
631 if (obj->type == OBJ_BLOB)
632 return grep_sha1(opt, obj->sha1, name, 0);
633 if (obj->type == OBJ_COMMIT || obj->type == OBJ_TREE) {
634 struct tree_desc tree;
635 void *data;
636 unsigned long size;
637 struct strbuf base;
638 int hit, len;
640 read_sha1_lock();
641 data = read_object_with_reference(obj->sha1, tree_type,
642 &size, NULL);
643 read_sha1_unlock();
645 if (!data)
646 die(_("unable to read tree (%s)"), sha1_to_hex(obj->sha1));
648 len = name ? strlen(name) : 0;
649 strbuf_init(&base, PATH_MAX + len + 1);
650 if (len) {
651 strbuf_add(&base, name, len);
652 strbuf_addch(&base, ':');
654 init_tree_desc(&tree, data, size);
655 hit = grep_tree(opt, pathspec, &tree, &base, base.len);
656 strbuf_release(&base);
657 free(data);
658 return hit;
660 die(_("unable to grep from object of type %s"), typename(obj->type));
663 static int grep_objects(struct grep_opt *opt, const struct pathspec *pathspec,
664 const struct object_array *list)
666 unsigned int i;
667 int hit = 0;
668 const unsigned int nr = list->nr;
670 for (i = 0; i < nr; i++) {
671 struct object *real_obj;
672 real_obj = deref_tag(list->objects[i].item, NULL, 0);
673 if (grep_object(opt, pathspec, real_obj, list->objects[i].name)) {
674 hit = 1;
675 if (opt->status_only)
676 break;
679 return hit;
682 static int grep_directory(struct grep_opt *opt, const struct pathspec *pathspec,
683 int exc_std)
685 struct dir_struct dir;
686 int i, hit = 0;
688 memset(&dir, 0, sizeof(dir));
689 if (exc_std)
690 setup_standard_excludes(&dir);
692 fill_directory(&dir, pathspec->raw);
693 for (i = 0; i < dir.nr; i++) {
694 const char *name = dir.entries[i]->name;
695 int namelen = strlen(name);
696 if (!match_pathspec_depth(pathspec, name, namelen, 0, NULL))
697 continue;
698 hit |= grep_file(opt, dir.entries[i]->name);
699 if (hit && opt->status_only)
700 break;
702 return hit;
705 static int context_callback(const struct option *opt, const char *arg,
706 int unset)
708 struct grep_opt *grep_opt = opt->value;
709 int value;
710 const char *endp;
712 if (unset) {
713 grep_opt->pre_context = grep_opt->post_context = 0;
714 return 0;
716 value = strtol(arg, (char **)&endp, 10);
717 if (*endp) {
718 return error(_("switch `%c' expects a numerical value"),
719 opt->short_name);
721 grep_opt->pre_context = grep_opt->post_context = value;
722 return 0;
725 static int file_callback(const struct option *opt, const char *arg, int unset)
727 struct grep_opt *grep_opt = opt->value;
728 int from_stdin = !strcmp(arg, "-");
729 FILE *patterns;
730 int lno = 0;
731 struct strbuf sb = STRBUF_INIT;
733 patterns = from_stdin ? stdin : fopen(arg, "r");
734 if (!patterns)
735 die_errno(_("cannot open '%s'"), arg);
736 while (strbuf_getline(&sb, patterns, '\n') == 0) {
737 char *s;
738 size_t len;
740 /* ignore empty line like grep does */
741 if (sb.len == 0)
742 continue;
744 s = strbuf_detach(&sb, &len);
745 append_grep_pat(grep_opt, s, len, arg, ++lno, GREP_PATTERN);
747 if (!from_stdin)
748 fclose(patterns);
749 strbuf_release(&sb);
750 return 0;
753 static int not_callback(const struct option *opt, const char *arg, int unset)
755 struct grep_opt *grep_opt = opt->value;
756 append_grep_pattern(grep_opt, "--not", "command line", 0, GREP_NOT);
757 return 0;
760 static int and_callback(const struct option *opt, const char *arg, int unset)
762 struct grep_opt *grep_opt = opt->value;
763 append_grep_pattern(grep_opt, "--and", "command line", 0, GREP_AND);
764 return 0;
767 static int open_callback(const struct option *opt, const char *arg, int unset)
769 struct grep_opt *grep_opt = opt->value;
770 append_grep_pattern(grep_opt, "(", "command line", 0, GREP_OPEN_PAREN);
771 return 0;
774 static int close_callback(const struct option *opt, const char *arg, int unset)
776 struct grep_opt *grep_opt = opt->value;
777 append_grep_pattern(grep_opt, ")", "command line", 0, GREP_CLOSE_PAREN);
778 return 0;
781 static int pattern_callback(const struct option *opt, const char *arg,
782 int unset)
784 struct grep_opt *grep_opt = opt->value;
785 append_grep_pattern(grep_opt, arg, "-e option", 0, GREP_PATTERN);
786 return 0;
789 static int help_callback(const struct option *opt, const char *arg, int unset)
791 return -1;
794 int cmd_grep(int argc, const char **argv, const char *prefix)
796 int hit = 0;
797 int cached = 0, untracked = 0, opt_exclude = -1;
798 int seen_dashdash = 0;
799 int external_grep_allowed__ignored;
800 const char *show_in_pager = NULL, *default_pager = "dummy";
801 struct grep_opt opt;
802 struct object_array list = OBJECT_ARRAY_INIT;
803 const char **paths = NULL;
804 struct pathspec pathspec;
805 struct string_list path_list = STRING_LIST_INIT_NODUP;
806 int i;
807 int dummy;
808 int use_index = 1;
809 enum {
810 pattern_type_unspecified = 0,
811 pattern_type_bre,
812 pattern_type_ere,
813 pattern_type_fixed,
814 pattern_type_pcre,
816 int pattern_type = pattern_type_unspecified;
818 struct option options[] = {
819 OPT_BOOLEAN(0, "cached", &cached,
820 "search in index instead of in the work tree"),
821 { OPTION_BOOLEAN, 0, "index", &use_index, NULL,
822 "finds in contents not managed by git",
823 PARSE_OPT_NOARG | PARSE_OPT_NEGHELP },
824 OPT_BOOLEAN(0, "untracked", &untracked,
825 "search in both tracked and untracked files"),
826 OPT_SET_INT(0, "exclude-standard", &opt_exclude,
827 "search also in ignored files", 1),
828 OPT_GROUP(""),
829 OPT_BOOLEAN('v', "invert-match", &opt.invert,
830 "show non-matching lines"),
831 OPT_BOOLEAN('i', "ignore-case", &opt.ignore_case,
832 "case insensitive matching"),
833 OPT_BOOLEAN('w', "word-regexp", &opt.word_regexp,
834 "match patterns only at word boundaries"),
835 OPT_SET_INT('a', "text", &opt.binary,
836 "process binary files as text", GREP_BINARY_TEXT),
837 OPT_SET_INT('I', NULL, &opt.binary,
838 "don't match patterns in binary files",
839 GREP_BINARY_NOMATCH),
840 { OPTION_INTEGER, 0, "max-depth", &opt.max_depth, "depth",
841 "descend at most <depth> levels", PARSE_OPT_NONEG,
842 NULL, 1 },
843 OPT_GROUP(""),
844 OPT_SET_INT('E', "extended-regexp", &pattern_type,
845 "use extended POSIX regular expressions",
846 pattern_type_ere),
847 OPT_SET_INT('G', "basic-regexp", &pattern_type,
848 "use basic POSIX regular expressions (default)",
849 pattern_type_bre),
850 OPT_SET_INT('F', "fixed-strings", &pattern_type,
851 "interpret patterns as fixed strings",
852 pattern_type_fixed),
853 OPT_SET_INT('P', "perl-regexp", &pattern_type,
854 "use Perl-compatible regular expressions",
855 pattern_type_pcre),
856 OPT_GROUP(""),
857 OPT_BOOLEAN('n', "line-number", &opt.linenum, "show line numbers"),
858 OPT_NEGBIT('h', NULL, &opt.pathname, "don't show filenames", 1),
859 OPT_BIT('H', NULL, &opt.pathname, "show filenames", 1),
860 OPT_NEGBIT(0, "full-name", &opt.relative,
861 "show filenames relative to top directory", 1),
862 OPT_BOOLEAN('l', "files-with-matches", &opt.name_only,
863 "show only filenames instead of matching lines"),
864 OPT_BOOLEAN(0, "name-only", &opt.name_only,
865 "synonym for --files-with-matches"),
866 OPT_BOOLEAN('L', "files-without-match",
867 &opt.unmatch_name_only,
868 "show only the names of files without match"),
869 OPT_BOOLEAN('z', "null", &opt.null_following_name,
870 "print NUL after filenames"),
871 OPT_BOOLEAN('c', "count", &opt.count,
872 "show the number of matches instead of matching lines"),
873 OPT__COLOR(&opt.color, "highlight matches"),
874 OPT_BOOLEAN(0, "break", &opt.file_break,
875 "print empty line between matches from different files"),
876 OPT_BOOLEAN(0, "heading", &opt.heading,
877 "show filename only once above matches from same file"),
878 OPT_GROUP(""),
879 OPT_CALLBACK('C', "context", &opt, "n",
880 "show <n> context lines before and after matches",
881 context_callback),
882 OPT_INTEGER('B', "before-context", &opt.pre_context,
883 "show <n> context lines before matches"),
884 OPT_INTEGER('A', "after-context", &opt.post_context,
885 "show <n> context lines after matches"),
886 OPT_NUMBER_CALLBACK(&opt, "shortcut for -C NUM",
887 context_callback),
888 OPT_BOOLEAN('p', "show-function", &opt.funcname,
889 "show a line with the function name before matches"),
890 OPT_BOOLEAN('W', "function-context", &opt.funcbody,
891 "show the surrounding function"),
892 OPT_GROUP(""),
893 OPT_CALLBACK('f', NULL, &opt, "file",
894 "read patterns from file", file_callback),
895 { OPTION_CALLBACK, 'e', NULL, &opt, "pattern",
896 "match <pattern>", PARSE_OPT_NONEG, pattern_callback },
897 { OPTION_CALLBACK, 0, "and", &opt, NULL,
898 "combine patterns specified with -e",
899 PARSE_OPT_NOARG | PARSE_OPT_NONEG, and_callback },
900 OPT_BOOLEAN(0, "or", &dummy, ""),
901 { OPTION_CALLBACK, 0, "not", &opt, NULL, "",
902 PARSE_OPT_NOARG | PARSE_OPT_NONEG, not_callback },
903 { OPTION_CALLBACK, '(', NULL, &opt, NULL, "",
904 PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH,
905 open_callback },
906 { OPTION_CALLBACK, ')', NULL, &opt, NULL, "",
907 PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH,
908 close_callback },
909 OPT__QUIET(&opt.status_only,
910 "indicate hit with exit status without output"),
911 OPT_BOOLEAN(0, "all-match", &opt.all_match,
912 "show only matches from files that match all patterns"),
913 OPT_GROUP(""),
914 { OPTION_STRING, 'O', "open-files-in-pager", &show_in_pager,
915 "pager", "show matching files in the pager",
916 PARSE_OPT_OPTARG, NULL, (intptr_t)default_pager },
917 OPT_BOOLEAN(0, "ext-grep", &external_grep_allowed__ignored,
918 "allow calling of grep(1) (ignored by this build)"),
919 { OPTION_CALLBACK, 0, "help-all", &options, NULL, "show usage",
920 PARSE_OPT_HIDDEN | PARSE_OPT_NOARG, help_callback },
921 OPT_END()
925 * 'git grep -h', unlike 'git grep -h <pattern>', is a request
926 * to show usage information and exit.
928 if (argc == 2 && !strcmp(argv[1], "-h"))
929 usage_with_options(grep_usage, options);
931 memset(&opt, 0, sizeof(opt));
932 opt.prefix = prefix;
933 opt.prefix_length = (prefix && *prefix) ? strlen(prefix) : 0;
934 opt.relative = 1;
935 opt.pathname = 1;
936 opt.pattern_tail = &opt.pattern_list;
937 opt.header_tail = &opt.header_list;
938 opt.regflags = REG_NEWLINE;
939 opt.max_depth = -1;
941 strcpy(opt.color_context, "");
942 strcpy(opt.color_filename, "");
943 strcpy(opt.color_function, "");
944 strcpy(opt.color_lineno, "");
945 strcpy(opt.color_match, GIT_COLOR_BOLD_RED);
946 strcpy(opt.color_selected, "");
947 strcpy(opt.color_sep, GIT_COLOR_CYAN);
948 opt.color = -1;
949 git_config(grep_config, &opt);
952 * If there is no -- then the paths must exist in the working
953 * tree. If there is no explicit pattern specified with -e or
954 * -f, we take the first unrecognized non option to be the
955 * pattern, but then what follows it must be zero or more
956 * valid refs up to the -- (if exists), and then existing
957 * paths. If there is an explicit pattern, then the first
958 * unrecognized non option is the beginning of the refs list
959 * that continues up to the -- (if exists), and then paths.
961 argc = parse_options(argc, argv, prefix, options, grep_usage,
962 PARSE_OPT_KEEP_DASHDASH |
963 PARSE_OPT_STOP_AT_NON_OPTION |
964 PARSE_OPT_NO_INTERNAL_HELP);
965 switch (pattern_type) {
966 case pattern_type_fixed:
967 opt.fixed = 1;
968 opt.pcre = 0;
969 break;
970 case pattern_type_bre:
971 opt.fixed = 0;
972 opt.pcre = 0;
973 opt.regflags &= ~REG_EXTENDED;
974 break;
975 case pattern_type_ere:
976 opt.fixed = 0;
977 opt.pcre = 0;
978 opt.regflags |= REG_EXTENDED;
979 break;
980 case pattern_type_pcre:
981 opt.fixed = 0;
982 opt.pcre = 1;
983 break;
984 default:
985 break; /* nothing */
988 if (use_index && !startup_info->have_repository)
989 /* die the same way as if we did it at the beginning */
990 setup_git_directory();
993 * skip a -- separator; we know it cannot be
994 * separating revisions from pathnames if
995 * we haven't even had any patterns yet
997 if (argc > 0 && !opt.pattern_list && !strcmp(argv[0], "--")) {
998 argv++;
999 argc--;
1002 /* First unrecognized non-option token */
1003 if (argc > 0 && !opt.pattern_list) {
1004 append_grep_pattern(&opt, argv[0], "command line", 0,
1005 GREP_PATTERN);
1006 argv++;
1007 argc--;
1010 if (show_in_pager == default_pager)
1011 show_in_pager = git_pager(1);
1012 if (show_in_pager) {
1013 opt.color = 0;
1014 opt.name_only = 1;
1015 opt.null_following_name = 1;
1016 opt.output_priv = &path_list;
1017 opt.output = append_path;
1018 string_list_append(&path_list, show_in_pager);
1019 use_threads = 0;
1021 if ((opt.binary & GREP_BINARY_NOMATCH))
1022 use_threads = 0;
1024 if (!opt.pattern_list)
1025 die(_("no pattern given."));
1026 if (!opt.fixed && opt.ignore_case)
1027 opt.regflags |= REG_ICASE;
1029 #ifndef NO_PTHREADS
1030 if (online_cpus() == 1 || !grep_threads_ok(&opt))
1031 use_threads = 0;
1033 if (use_threads) {
1034 if (opt.pre_context || opt.post_context || opt.file_break ||
1035 opt.funcbody)
1036 skip_first_line = 1;
1037 start_threads(&opt);
1039 #else
1040 use_threads = 0;
1041 #endif
1043 compile_grep_patterns(&opt);
1045 /* Check revs and then paths */
1046 for (i = 0; i < argc; i++) {
1047 const char *arg = argv[i];
1048 unsigned char sha1[20];
1049 /* Is it a rev? */
1050 if (!get_sha1(arg, sha1)) {
1051 struct object *object = parse_object(sha1);
1052 if (!object)
1053 die(_("bad object %s"), arg);
1054 add_object_array(object, arg, &list);
1055 continue;
1057 if (!strcmp(arg, "--")) {
1058 i++;
1059 seen_dashdash = 1;
1061 break;
1064 /* The rest are paths */
1065 if (!seen_dashdash) {
1066 int j;
1067 for (j = i; j < argc; j++)
1068 verify_filename(prefix, argv[j]);
1071 paths = get_pathspec(prefix, argv + i);
1072 init_pathspec(&pathspec, paths);
1073 pathspec.max_depth = opt.max_depth;
1074 pathspec.recursive = 1;
1076 if (show_in_pager && (cached || list.nr))
1077 die(_("--open-files-in-pager only works on the worktree"));
1079 if (show_in_pager && opt.pattern_list && !opt.pattern_list->next) {
1080 const char *pager = path_list.items[0].string;
1081 int len = strlen(pager);
1083 if (len > 4 && is_dir_sep(pager[len - 5]))
1084 pager += len - 4;
1086 if (opt.ignore_case && !strcmp("less", pager))
1087 string_list_append(&path_list, "-i");
1089 if (!strcmp("less", pager) || !strcmp("vi", pager)) {
1090 struct strbuf buf = STRBUF_INIT;
1091 strbuf_addf(&buf, "+/%s%s",
1092 strcmp("less", pager) ? "" : "*",
1093 opt.pattern_list->pattern);
1094 string_list_append(&path_list, buf.buf);
1095 strbuf_detach(&buf, NULL);
1099 if (!show_in_pager)
1100 setup_pager();
1102 if (!use_index && (untracked || cached))
1103 die(_("--cached or --untracked cannot be used with --no-index."));
1105 if (!use_index || untracked) {
1106 int use_exclude = (opt_exclude < 0) ? use_index : !!opt_exclude;
1107 if (list.nr)
1108 die(_("--no-index or --untracked cannot be used with revs."));
1109 hit = grep_directory(&opt, &pathspec, use_exclude);
1110 } else if (0 <= opt_exclude) {
1111 die(_("--[no-]exclude-standard cannot be used for tracked contents."));
1112 } else if (!list.nr) {
1113 if (!cached)
1114 setup_work_tree();
1116 hit = grep_cache(&opt, &pathspec, cached);
1117 } else {
1118 if (cached)
1119 die(_("both --cached and trees are given."));
1120 hit = grep_objects(&opt, &pathspec, &list);
1123 if (use_threads)
1124 hit |= wait_all();
1125 if (hit && show_in_pager)
1126 run_pager(&opt, prefix);
1127 free_grep_patterns(&opt);
1128 return !hit;