sparse: Fix errors and silence warnings
[git/git.git] / builtin / grep.c
CommitLineData
5010cb5f
JH
1/*
2 * Builtin "git grep"
3 *
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"
1362671f 11#include "tree-walk.h"
5010cb5f 12#include "builtin.h"
3e230fa1 13#include "parse-options.h"
678e484b
JS
14#include "string-list.h"
15#include "run-command.h"
60ecac98 16#include "userdiff.h"
83b5d2f5 17#include "grep.h"
493b7a08 18#include "quote.h"
59332d13 19#include "dir.h"
93749194 20#include "thread-utils.h"
5b594f45 21
3e230fa1 22static char const * const grep_usage[] = {
62b4698e 23 "git grep [options] [-e] <pattern> [<rev>...] [[--] <path>...]",
3e230fa1
RS
24 NULL
25};
26
5b594f45
FK
27static int use_threads = 1;
28
29#ifndef NO_PTHREADS
30#define THREADS 8
31static pthread_t threads[THREADS];
32
33static void *load_sha1(const unsigned char *sha1, unsigned long *size,
34 const char *name);
35static void *load_file(const char *filename, size_t *sz);
36
37enum work_type {WORK_SHA1, WORK_FILE};
38
39/* We use one producer thread and THREADS consumer
40 * threads. The producer adds struct work_items to 'todo' and the
41 * consumers pick work items from the same array.
42 */
9cba13ca 43struct work_item {
5b594f45
FK
44 enum work_type type;
45 char *name;
46
47 /* if type == WORK_SHA1, then 'identifier' is a SHA1,
48 * otherwise type == WORK_FILE, and 'identifier' is a NUL
49 * terminated filename.
50 */
51 void *identifier;
52 char done;
53 struct strbuf out;
54};
55
56/* In the range [todo_done, todo_start) in 'todo' we have work_items
57 * that have been or are processed by a consumer thread. We haven't
58 * written the result for these to stdout yet.
59 *
60 * The work_items in [todo_start, todo_end) are waiting to be picked
61 * up by a consumer thread.
62 *
63 * The ranges are modulo TODO_SIZE.
64 */
65#define TODO_SIZE 128
66static struct work_item todo[TODO_SIZE];
67static int todo_start;
68static int todo_end;
69static int todo_done;
70
71/* Has all work items been added? */
72static int all_work_added;
73
74/* This lock protects all the variables above. */
75static pthread_mutex_t grep_mutex;
76
77/* Used to serialize calls to read_sha1_file. */
78static pthread_mutex_t read_sha1_mutex;
79
80#define grep_lock() pthread_mutex_lock(&grep_mutex)
81#define grep_unlock() pthread_mutex_unlock(&grep_mutex)
82#define read_sha1_lock() pthread_mutex_lock(&read_sha1_mutex)
83#define read_sha1_unlock() pthread_mutex_unlock(&read_sha1_mutex)
84
85/* Signalled when a new work_item is added to todo. */
86static pthread_cond_t cond_add;
87
88/* Signalled when the result from one work_item is written to
89 * stdout.
90 */
91static pthread_cond_t cond_write;
92
93/* Signalled when we are finished with everything. */
94static pthread_cond_t cond_result;
95
431d6e7b
RS
96static int print_hunk_marks_between_files;
97static int printed_something;
98
5b594f45
FK
99static void add_work(enum work_type type, char *name, void *id)
100{
101 grep_lock();
102
103 while ((todo_end+1) % ARRAY_SIZE(todo) == todo_done) {
104 pthread_cond_wait(&cond_write, &grep_mutex);
105 }
106
107 todo[todo_end].type = type;
108 todo[todo_end].name = name;
109 todo[todo_end].identifier = id;
110 todo[todo_end].done = 0;
111 strbuf_reset(&todo[todo_end].out);
112 todo_end = (todo_end + 1) % ARRAY_SIZE(todo);
113
114 pthread_cond_signal(&cond_add);
115 grep_unlock();
116}
117
118static struct work_item *get_work(void)
119{
120 struct work_item *ret;
121
122 grep_lock();
123 while (todo_start == todo_end && !all_work_added) {
124 pthread_cond_wait(&cond_add, &grep_mutex);
125 }
126
127 if (todo_start == todo_end && all_work_added) {
128 ret = NULL;
129 } else {
130 ret = &todo[todo_start];
131 todo_start = (todo_start + 1) % ARRAY_SIZE(todo);
132 }
133 grep_unlock();
134 return ret;
135}
136
137static void grep_sha1_async(struct grep_opt *opt, char *name,
138 const unsigned char *sha1)
139{
140 unsigned char *s;
141 s = xmalloc(20);
142 memcpy(s, sha1, 20);
143 add_work(WORK_SHA1, name, s);
144}
145
146static void grep_file_async(struct grep_opt *opt, char *name,
147 const char *filename)
148{
149 add_work(WORK_FILE, name, xstrdup(filename));
150}
151
152static void work_done(struct work_item *w)
153{
154 int old_done;
155
156 grep_lock();
157 w->done = 1;
158 old_done = todo_done;
159 for(; todo[todo_done].done && todo_done != todo_start;
160 todo_done = (todo_done+1) % ARRAY_SIZE(todo)) {
161 w = &todo[todo_done];
431d6e7b
RS
162 if (w->out.len) {
163 if (print_hunk_marks_between_files && printed_something)
164 write_or_die(1, "--\n", 3);
165 write_or_die(1, w->out.buf, w->out.len);
166 printed_something = 1;
167 }
5b594f45
FK
168 free(w->name);
169 free(w->identifier);
170 }
171
172 if (old_done != todo_done)
173 pthread_cond_signal(&cond_write);
174
175 if (all_work_added && todo_done == todo_end)
176 pthread_cond_signal(&cond_result);
177
178 grep_unlock();
179}
180
181static void *run(void *arg)
182{
183 int hit = 0;
184 struct grep_opt *opt = arg;
185
186 while (1) {
187 struct work_item *w = get_work();
188 if (!w)
189 break;
190
191 opt->output_priv = w;
192 if (w->type == WORK_SHA1) {
193 unsigned long sz;
194 void* data = load_sha1(w->identifier, &sz, w->name);
195
196 if (data) {
197 hit |= grep_buffer(opt, w->name, data, sz);
198 free(data);
199 }
200 } else if (w->type == WORK_FILE) {
201 size_t sz;
202 void* data = load_file(w->identifier, &sz);
203 if (data) {
204 hit |= grep_buffer(opt, w->name, data, sz);
205 free(data);
206 }
207 } else {
208 assert(0);
209 }
210
211 work_done(w);
212 }
bfac23d9
DM
213 free_grep_patterns(arg);
214 free(arg);
5b594f45
FK
215
216 return (void*) (intptr_t) hit;
217}
218
219static void strbuf_out(struct grep_opt *opt, const void *buf, size_t size)
220{
221 struct work_item *w = opt->output_priv;
222 strbuf_add(&w->out, buf, size);
223}
224
225static void start_threads(struct grep_opt *opt)
226{
227 int i;
228
229 pthread_mutex_init(&grep_mutex, NULL);
230 pthread_mutex_init(&read_sha1_mutex, NULL);
231 pthread_cond_init(&cond_add, NULL);
232 pthread_cond_init(&cond_write, NULL);
233 pthread_cond_init(&cond_result, NULL);
234
235 for (i = 0; i < ARRAY_SIZE(todo); i++) {
236 strbuf_init(&todo[i].out, 0);
237 }
238
239 for (i = 0; i < ARRAY_SIZE(threads); i++) {
240 int err;
241 struct grep_opt *o = grep_opt_dup(opt);
242 o->output = strbuf_out;
243 compile_grep_patterns(o);
244 err = pthread_create(&threads[i], NULL, run, o);
245
246 if (err)
2fc5f9f1 247 die(_("grep: failed to create thread: %s"),
5b594f45
FK
248 strerror(err));
249 }
250}
251
252static int wait_all(void)
253{
254 int hit = 0;
255 int i;
256
257 grep_lock();
258 all_work_added = 1;
259
260 /* Wait until all work is done. */
261 while (todo_done != todo_end)
262 pthread_cond_wait(&cond_result, &grep_mutex);
263
264 /* Wake up all the consumer threads so they can see that there
265 * is no more work to do.
266 */
267 pthread_cond_broadcast(&cond_add);
268 grep_unlock();
269
270 for (i = 0; i < ARRAY_SIZE(threads); i++) {
271 void *h;
272 pthread_join(threads[i], &h);
273 hit |= (int) (intptr_t) h;
274 }
275
276 pthread_mutex_destroy(&grep_mutex);
277 pthread_mutex_destroy(&read_sha1_mutex);
278 pthread_cond_destroy(&cond_add);
279 pthread_cond_destroy(&cond_write);
280 pthread_cond_destroy(&cond_result);
281
282 return hit;
283}
284#else /* !NO_PTHREADS */
285#define read_sha1_lock()
286#define read_sha1_unlock()
287
288static int wait_all(void)
289{
290 return 0;
291}
292#endif
293
7e8f59d5
RS
294static int grep_config(const char *var, const char *value, void *cb)
295{
296 struct grep_opt *opt = cb;
55f638bd 297 char *color = NULL;
7e8f59d5 298
60ecac98
RS
299 switch (userdiff_config(var, value)) {
300 case 0: break;
301 case -1: return -1;
302 default: return 0;
303 }
304
b22520a3
JR
305 if (!strcmp(var, "grep.extendedregexp")) {
306 if (git_config_bool(var, value))
307 opt->regflags |= REG_EXTENDED;
308 else
309 opt->regflags &= ~REG_EXTENDED;
310 return 0;
311 }
312
313 if (!strcmp(var, "grep.linenumber")) {
314 opt->linenum = git_config_bool(var, value);
315 return 0;
316 }
317
55f638bd 318 if (!strcmp(var, "color.grep"))
7e8f59d5 319 opt->color = git_config_colorbool(var, value, -1);
00588bb5
ML
320 else if (!strcmp(var, "color.grep.context"))
321 color = opt->color_context;
55f638bd
ML
322 else if (!strcmp(var, "color.grep.filename"))
323 color = opt->color_filename;
00588bb5
ML
324 else if (!strcmp(var, "color.grep.function"))
325 color = opt->color_function;
55f638bd
ML
326 else if (!strcmp(var, "color.grep.linenumber"))
327 color = opt->color_lineno;
328 else if (!strcmp(var, "color.grep.match"))
329 color = opt->color_match;
00588bb5
ML
330 else if (!strcmp(var, "color.grep.selected"))
331 color = opt->color_selected;
55f638bd
ML
332 else if (!strcmp(var, "color.grep.separator"))
333 color = opt->color_sep;
334 else
335 return git_color_default_config(var, value, cb);
336 if (color) {
7e8f59d5
RS
337 if (!value)
338 return config_error_nonbool(var);
55f638bd 339 color_parse(value, var, color);
7e8f59d5 340 }
55f638bd 341 return 0;
7e8f59d5
RS
342}
343
5f02d315
JH
344static void *lock_and_read_sha1_file(const unsigned char *sha1, enum object_type *type, unsigned long *size)
345{
346 void *data;
347
348 if (use_threads) {
349 read_sha1_lock();
350 data = read_sha1_file(sha1, type, size);
351 read_sha1_unlock();
352 } else {
353 data = read_sha1_file(sha1, type, size);
354 }
355 return data;
356}
357
5b594f45
FK
358static void *load_sha1(const unsigned char *sha1, unsigned long *size,
359 const char *name)
5010cb5f 360{
21666f1a 361 enum object_type type;
5f02d315 362 void *data = lock_and_read_sha1_file(sha1, &type, size);
5b594f45
FK
363
364 if (!data)
2fc5f9f1 365 error(_("'%s': unable to read %s"), name, sha1_to_hex(sha1));
5b594f45
FK
366
367 return data;
368}
369
370static int grep_sha1(struct grep_opt *opt, const unsigned char *sha1,
371 const char *filename, int tree_name_len)
372{
373 struct strbuf pathbuf = STRBUF_INIT;
374 char *name;
375
0d042fec 376 if (opt->relative && opt->prefix_length) {
5b594f45
FK
377 quote_path_relative(filename + tree_name_len, -1, &pathbuf,
378 opt->prefix);
379 strbuf_insert(&pathbuf, 0, filename, tree_name_len);
380 } else {
381 strbuf_addstr(&pathbuf, filename);
382 }
383
384 name = strbuf_detach(&pathbuf, NULL);
385
386#ifndef NO_PTHREADS
387 if (use_threads) {
388 grep_sha1_async(opt, name, sha1);
389 return 0;
390 } else
391#endif
392 {
393 int hit;
394 unsigned long sz;
395 void *data = load_sha1(sha1, &sz, name);
396 if (!data)
397 hit = 0;
398 else
399 hit = grep_buffer(opt, name, data, sz);
400
401 free(data);
402 free(name);
403 return hit;
0d042fec 404 }
5010cb5f
JH
405}
406
5b594f45 407static void *load_file(const char *filename, size_t *sz)
5010cb5f
JH
408{
409 struct stat st;
5010cb5f 410 char *data;
5b594f45 411 int i;
dc49cd76 412
5010cb5f
JH
413 if (lstat(filename, &st) < 0) {
414 err_ret:
415 if (errno != ENOENT)
2fc5f9f1 416 error(_("'%s': %s"), filename, strerror(errno));
1e4cd68c 417 return NULL;
5010cb5f 418 }
5010cb5f 419 if (!S_ISREG(st.st_mode))
1e4cd68c 420 return NULL;
5b594f45 421 *sz = xsize_t(st.st_size);
5010cb5f
JH
422 i = open(filename, O_RDONLY);
423 if (i < 0)
424 goto err_ret;
5b594f45
FK
425 data = xmalloc(*sz + 1);
426 if (st.st_size != read_in_full(i, data, *sz)) {
2fc5f9f1 427 error(_("'%s': short read %s"), filename, strerror(errno));
5010cb5f
JH
428 close(i);
429 free(data);
1e4cd68c 430 return NULL;
5010cb5f
JH
431 }
432 close(i);
5b594f45
FK
433 data[*sz] = 0;
434 return data;
435}
436
437static int grep_file(struct grep_opt *opt, const char *filename)
438{
439 struct strbuf buf = STRBUF_INIT;
440 char *name;
441
0d042fec 442 if (opt->relative && opt->prefix_length)
5b594f45
FK
443 quote_path_relative(filename, -1, &buf, opt->prefix);
444 else
445 strbuf_addstr(&buf, filename);
446 name = strbuf_detach(&buf, NULL);
447
448#ifndef NO_PTHREADS
449 if (use_threads) {
450 grep_file_async(opt, name, filename);
451 return 0;
452 } else
453#endif
454 {
455 int hit;
456 size_t sz;
457 void *data = load_file(filename, &sz);
458 if (!data)
459 hit = 0;
460 else
461 hit = grep_buffer(opt, name, data, sz);
462
463 free(data);
464 free(name);
465 return hit;
466 }
5010cb5f
JH
467}
468
678e484b
JS
469static void append_path(struct grep_opt *opt, const void *data, size_t len)
470{
471 struct string_list *path_list = opt->output_priv;
472
473 if (len == 1 && *(const char *)data == '\0')
474 return;
0c72cead 475 string_list_append(path_list, xstrndup(data, len));
678e484b
JS
476}
477
478static void run_pager(struct grep_opt *opt, const char *prefix)
479{
480 struct string_list *path_list = opt->output_priv;
481 const char **argv = xmalloc(sizeof(const char *) * (path_list->nr + 1));
482 int i, status;
483
484 for (i = 0; i < path_list->nr; i++)
485 argv[i] = path_list->items[i].string;
486 argv[path_list->nr] = NULL;
487
488 if (prefix && chdir(prefix))
2fc5f9f1 489 die(_("Failed to chdir: %s"), prefix);
678e484b
JS
490 status = run_command_v_opt(argv, RUN_USING_SHELL);
491 if (status)
492 exit(status);
493 free(argv);
494}
495
f34bbc15 496static int grep_cache(struct grep_opt *opt, const struct pathspec *pathspec, int cached)
5010cb5f
JH
497{
498 int hit = 0;
499 int nr;
500 read_cache();
501
502 for (nr = 0; nr < active_nr; nr++) {
503 struct cache_entry *ce = active_cache[nr];
7a51ed66 504 if (!S_ISREG(ce->ce_mode))
5010cb5f 505 continue;
2ed2437a 506 if (!match_pathspec_depth(pathspec, ce->name, ce_namelen(ce), 0, NULL))
5010cb5f 507 continue;
57d43466
NTND
508 /*
509 * If CE_VALID is on, we assume worktree file and its cache entry
510 * are identical, even if worktree file has been modified, so use
511 * cache version instead
512 */
b4d1690d 513 if (cached || (ce->ce_flags & CE_VALID) || ce_skip_worktree(ce)) {
36f2587f
JH
514 if (ce_stage(ce))
515 continue;
0d042fec 516 hit |= grep_sha1(opt, ce->sha1, ce->name, 0);
36f2587f 517 }
5010cb5f
JH
518 else
519 hit |= grep_file(opt, ce->name);
36f2587f
JH
520 if (ce_stage(ce)) {
521 do {
522 nr++;
523 } while (nr < active_nr &&
524 !strcmp(ce->name, active_cache[nr]->name));
525 nr--; /* compensate for loop control */
526 }
c8610a2e
JH
527 if (hit && opt->status_only)
528 break;
5010cb5f
JH
529 }
530 return hit;
531}
532
f34bbc15 533static int grep_tree(struct grep_opt *opt, const struct pathspec *pathspec,
e5e062b6 534 struct tree_desc *tree, struct strbuf *base, int tn_len)
5010cb5f 535{
1376e507 536 int hit = 0, matched = 0;
4c068a98 537 struct name_entry entry;
e5e062b6 538 int old_baselen = base->len;
5010cb5f 539
4c068a98 540 while (tree_entry(tree, &entry)) {
620e2bb9 541 int te_len = tree_entry_len(entry.path, entry.sha1);
e5e062b6 542
1376e507
NTND
543 if (matched != 2) {
544 matched = tree_entry_interesting(&entry, base, tn_len, pathspec);
545 if (matched == -1)
546 break; /* no more matches */
547 if (!matched)
548 continue;
549 }
5010cb5f 550
1376e507 551 strbuf_add(base, entry.path, te_len);
e0eb889f 552
1376e507 553 if (S_ISREG(entry.mode)) {
e5e062b6
NTND
554 hit |= grep_sha1(opt, entry.sha1, base->buf, tn_len);
555 }
4c068a98 556 else if (S_ISDIR(entry.mode)) {
21666f1a 557 enum object_type type;
5010cb5f
JH
558 struct tree_desc sub;
559 void *data;
6fda5e51
LT
560 unsigned long size;
561
5f02d315 562 data = lock_and_read_sha1_file(entry.sha1, &type, &size);
5010cb5f 563 if (!data)
2fc5f9f1 564 die(_("unable to read tree (%s)"),
4c068a98 565 sha1_to_hex(entry.sha1));
1376e507
NTND
566
567 strbuf_addch(base, '/');
6fda5e51 568 init_tree_desc(&sub, data, size);
e5e062b6 569 hit |= grep_tree(opt, pathspec, &sub, base, tn_len);
5010cb5f
JH
570 free(data);
571 }
e5e062b6
NTND
572 strbuf_setlen(base, old_baselen);
573
c8610a2e
JH
574 if (hit && opt->status_only)
575 break;
5010cb5f
JH
576 }
577 return hit;
578}
579
f34bbc15 580static int grep_object(struct grep_opt *opt, const struct pathspec *pathspec,
5010cb5f
JH
581 struct object *obj, const char *name)
582{
1974632c 583 if (obj->type == OBJ_BLOB)
0d042fec 584 return grep_sha1(opt, obj->sha1, name, 0);
1974632c 585 if (obj->type == OBJ_COMMIT || obj->type == OBJ_TREE) {
5010cb5f
JH
586 struct tree_desc tree;
587 void *data;
6fda5e51 588 unsigned long size;
e5e062b6
NTND
589 struct strbuf base;
590 int hit, len;
591
5010cb5f 592 data = read_object_with_reference(obj->sha1, tree_type,
6fda5e51 593 &size, NULL);
5010cb5f 594 if (!data)
2fc5f9f1 595 die(_("unable to read tree (%s)"), sha1_to_hex(obj->sha1));
e5e062b6
NTND
596
597 len = name ? strlen(name) : 0;
598 strbuf_init(&base, PATH_MAX + len + 1);
599 if (len) {
600 strbuf_add(&base, name, len);
601 strbuf_addch(&base, ':');
602 }
6fda5e51 603 init_tree_desc(&tree, data, size);
e5e062b6
NTND
604 hit = grep_tree(opt, pathspec, &tree, &base, base.len);
605 strbuf_release(&base);
5010cb5f
JH
606 free(data);
607 return hit;
608 }
2fc5f9f1 609 die(_("unable to grep from object of type %s"), typename(obj->type));
5010cb5f
JH
610}
611
f34bbc15 612static int grep_objects(struct grep_opt *opt, const struct pathspec *pathspec,
30d00c39
JN
613 const struct object_array *list)
614{
615 unsigned int i;
616 int hit = 0;
617 const unsigned int nr = list->nr;
618
619 for (i = 0; i < nr; i++) {
620 struct object *real_obj;
621 real_obj = deref_tag(list->objects[i].item, NULL, 0);
f34bbc15 622 if (grep_object(opt, pathspec, real_obj, list->objects[i].name)) {
30d00c39
JN
623 hit = 1;
624 if (opt->status_only)
625 break;
626 }
627 }
628 return hit;
629}
630
f34bbc15 631static int grep_directory(struct grep_opt *opt, const struct pathspec *pathspec)
59332d13
JH
632{
633 struct dir_struct dir;
634 int i, hit = 0;
635
636 memset(&dir, 0, sizeof(dir));
637 setup_standard_excludes(&dir);
638
f34bbc15 639 fill_directory(&dir, pathspec->raw);
59332d13 640 for (i = 0; i < dir.nr; i++) {
9d8b831b
JH
641 const char *name = dir.entries[i]->name;
642 int namelen = strlen(name);
643 if (!match_pathspec_depth(pathspec, name, namelen, 0, NULL))
644 continue;
59332d13
JH
645 hit |= grep_file(opt, dir.entries[i]->name);
646 if (hit && opt->status_only)
647 break;
648 }
59332d13
JH
649 return hit;
650}
651
ff3c7f9a
RS
652static int context_callback(const struct option *opt, const char *arg,
653 int unset)
3e230fa1
RS
654{
655 struct grep_opt *grep_opt = opt->value;
656 int value;
657 const char *endp;
658
659 if (unset) {
660 grep_opt->pre_context = grep_opt->post_context = 0;
661 return 0;
662 }
663 value = strtol(arg, (char **)&endp, 10);
664 if (*endp) {
2fc5f9f1 665 return error(_("switch `%c' expects a numerical value"),
3e230fa1
RS
666 opt->short_name);
667 }
668 grep_opt->pre_context = grep_opt->post_context = value;
669 return 0;
670}
671
ff3c7f9a 672static int file_callback(const struct option *opt, const char *arg, int unset)
3e230fa1
RS
673{
674 struct grep_opt *grep_opt = opt->value;
c41dd2fd 675 int from_stdin = !strcmp(arg, "-");
3e230fa1
RS
676 FILE *patterns;
677 int lno = 0;
cfe370c6 678 struct strbuf sb = STRBUF_INIT;
3e230fa1 679
c41dd2fd 680 patterns = from_stdin ? stdin : fopen(arg, "r");
3e230fa1 681 if (!patterns)
2fc5f9f1 682 die_errno(_("cannot open '%s'"), arg);
3e230fa1 683 while (strbuf_getline(&sb, patterns, '\n') == 0) {
ed40a095
RS
684 char *s;
685 size_t len;
686
3e230fa1
RS
687 /* ignore empty line like grep does */
688 if (sb.len == 0)
689 continue;
ed40a095
RS
690
691 s = strbuf_detach(&sb, &len);
692 append_grep_pat(grep_opt, s, len, arg, ++lno, GREP_PATTERN);
3e230fa1 693 }
c41dd2fd
RS
694 if (!from_stdin)
695 fclose(patterns);
3e230fa1
RS
696 strbuf_release(&sb);
697 return 0;
698}
699
ff3c7f9a 700static int not_callback(const struct option *opt, const char *arg, int unset)
3e230fa1
RS
701{
702 struct grep_opt *grep_opt = opt->value;
703 append_grep_pattern(grep_opt, "--not", "command line", 0, GREP_NOT);
704 return 0;
705}
706
ff3c7f9a 707static int and_callback(const struct option *opt, const char *arg, int unset)
3e230fa1
RS
708{
709 struct grep_opt *grep_opt = opt->value;
710 append_grep_pattern(grep_opt, "--and", "command line", 0, GREP_AND);
711 return 0;
712}
713
ff3c7f9a 714static int open_callback(const struct option *opt, const char *arg, int unset)
3e230fa1
RS
715{
716 struct grep_opt *grep_opt = opt->value;
717 append_grep_pattern(grep_opt, "(", "command line", 0, GREP_OPEN_PAREN);
718 return 0;
719}
720
ff3c7f9a 721static int close_callback(const struct option *opt, const char *arg, int unset)
3e230fa1
RS
722{
723 struct grep_opt *grep_opt = opt->value;
724 append_grep_pattern(grep_opt, ")", "command line", 0, GREP_CLOSE_PAREN);
725 return 0;
726}
727
ff3c7f9a
RS
728static int pattern_callback(const struct option *opt, const char *arg,
729 int unset)
3e230fa1
RS
730{
731 struct grep_opt *grep_opt = opt->value;
732 append_grep_pattern(grep_opt, arg, "-e option", 0, GREP_PATTERN);
733 return 0;
734}
5010cb5f 735
ff3c7f9a 736static int help_callback(const struct option *opt, const char *arg, int unset)
3e230fa1
RS
737{
738 return -1;
739}
088b084b 740
a633fca0 741int cmd_grep(int argc, const char **argv, const char *prefix)
5010cb5f 742{
5010cb5f 743 int hit = 0;
5010cb5f 744 int cached = 0;
5acd64ed 745 int seen_dashdash = 0;
bbc09c22 746 int external_grep_allowed__ignored;
0af88c15 747 const char *show_in_pager = NULL, *default_pager = "dummy";
5010cb5f 748 struct grep_opt opt;
3cd47459 749 struct object_array list = OBJECT_ARRAY_INIT;
1362671f 750 const char **paths = NULL;
f34bbc15 751 struct pathspec pathspec;
183113a5 752 struct string_list path_list = STRING_LIST_INIT_NODUP;
5acd64ed 753 int i;
3e230fa1 754 int dummy;
ff38d1a9 755 int use_index = 1;
3e230fa1
RS
756 struct option options[] = {
757 OPT_BOOLEAN(0, "cached", &cached,
758 "search in index instead of in the work tree"),
59332d13
JH
759 OPT_BOOLEAN(0, "index", &use_index,
760 "--no-index finds in contents not managed by git"),
3e230fa1
RS
761 OPT_GROUP(""),
762 OPT_BOOLEAN('v', "invert-match", &opt.invert,
763 "show non-matching lines"),
5183bf67
BC
764 OPT_BOOLEAN('i', "ignore-case", &opt.ignore_case,
765 "case insensitive matching"),
3e230fa1
RS
766 OPT_BOOLEAN('w', "word-regexp", &opt.word_regexp,
767 "match patterns only at word boundaries"),
768 OPT_SET_INT('a', "text", &opt.binary,
769 "process binary files as text", GREP_BINARY_TEXT),
770 OPT_SET_INT('I', NULL, &opt.binary,
771 "don't match patterns in binary files",
772 GREP_BINARY_NOMATCH),
a91f453f
MK
773 { OPTION_INTEGER, 0, "max-depth", &opt.max_depth, "depth",
774 "descend at most <depth> levels", PARSE_OPT_NONEG,
775 NULL, 1 },
3e230fa1
RS
776 OPT_GROUP(""),
777 OPT_BIT('E', "extended-regexp", &opt.regflags,
778 "use extended POSIX regular expressions", REG_EXTENDED),
779 OPT_NEGBIT('G', "basic-regexp", &opt.regflags,
780 "use basic POSIX regular expressions (default)",
781 REG_EXTENDED),
782 OPT_BOOLEAN('F', "fixed-strings", &opt.fixed,
783 "interpret patterns as fixed strings"),
784 OPT_GROUP(""),
7d6cb10b 785 OPT_BOOLEAN('n', "line-number", &opt.linenum, "show line numbers"),
3e230fa1
RS
786 OPT_NEGBIT('h', NULL, &opt.pathname, "don't show filenames", 1),
787 OPT_BIT('H', NULL, &opt.pathname, "show filenames", 1),
788 OPT_NEGBIT(0, "full-name", &opt.relative,
789 "show filenames relative to top directory", 1),
790 OPT_BOOLEAN('l', "files-with-matches", &opt.name_only,
791 "show only filenames instead of matching lines"),
792 OPT_BOOLEAN(0, "name-only", &opt.name_only,
793 "synonym for --files-with-matches"),
794 OPT_BOOLEAN('L', "files-without-match",
795 &opt.unmatch_name_only,
796 "show only the names of files without match"),
797 OPT_BOOLEAN('z', "null", &opt.null_following_name,
798 "print NUL after filenames"),
799 OPT_BOOLEAN('c', "count", &opt.count,
800 "show the number of matches instead of matching lines"),
73e9da01 801 OPT__COLOR(&opt.color, "highlight matches"),
3e230fa1
RS
802 OPT_GROUP(""),
803 OPT_CALLBACK('C', NULL, &opt, "n",
804 "show <n> context lines before and after matches",
805 context_callback),
806 OPT_INTEGER('B', NULL, &opt.pre_context,
807 "show <n> context lines before matches"),
808 OPT_INTEGER('A', NULL, &opt.post_context,
809 "show <n> context lines after matches"),
810 OPT_NUMBER_CALLBACK(&opt, "shortcut for -C NUM",
811 context_callback),
2944e4e6
RS
812 OPT_BOOLEAN('p', "show-function", &opt.funcname,
813 "show a line with the function name before matches"),
3e230fa1
RS
814 OPT_GROUP(""),
815 OPT_CALLBACK('f', NULL, &opt, "file",
816 "read patterns from file", file_callback),
817 { OPTION_CALLBACK, 'e', NULL, &opt, "pattern",
818 "match <pattern>", PARSE_OPT_NONEG, pattern_callback },
819 { OPTION_CALLBACK, 0, "and", &opt, NULL,
820 "combine patterns specified with -e",
821 PARSE_OPT_NOARG | PARSE_OPT_NONEG, and_callback },
822 OPT_BOOLEAN(0, "or", &dummy, ""),
823 { OPTION_CALLBACK, 0, "not", &opt, NULL, "",
824 PARSE_OPT_NOARG | PARSE_OPT_NONEG, not_callback },
825 { OPTION_CALLBACK, '(', NULL, &opt, NULL, "",
826 PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH,
827 open_callback },
828 { OPTION_CALLBACK, ')', NULL, &opt, NULL, "",
829 PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH,
830 close_callback },
d52ee6e6
RS
831 OPT__QUIET(&opt.status_only,
832 "indicate hit with exit status without output"),
3e230fa1
RS
833 OPT_BOOLEAN(0, "all-match", &opt.all_match,
834 "show only matches from files that match all patterns"),
835 OPT_GROUP(""),
0af88c15
JS
836 { OPTION_STRING, 'O', "open-files-in-pager", &show_in_pager,
837 "pager", "show matching files in the pager",
838 PARSE_OPT_OPTARG, NULL, (intptr_t)default_pager },
bbc09c22
JH
839 OPT_BOOLEAN(0, "ext-grep", &external_grep_allowed__ignored,
840 "allow calling of grep(1) (ignored by this build)"),
3e230fa1
RS
841 { OPTION_CALLBACK, 0, "help-all", &options, NULL, "show usage",
842 PARSE_OPT_HIDDEN | PARSE_OPT_NOARG, help_callback },
843 OPT_END()
844 };
5010cb5f 845
9c855c31
JN
846 /*
847 * 'git grep -h', unlike 'git grep -h <pattern>', is a request
848 * to show usage information and exit.
849 */
850 if (argc == 2 && !strcmp(argv[1], "-h"))
851 usage_with_options(grep_usage, options);
852
5010cb5f 853 memset(&opt, 0, sizeof(opt));
493b7a08 854 opt.prefix = prefix;
0d042fec
JH
855 opt.prefix_length = (prefix && *prefix) ? strlen(prefix) : 0;
856 opt.relative = 1;
7977f0ea 857 opt.pathname = 1;
f9b9faf6 858 opt.pattern_tail = &opt.pattern_list;
80235ba7 859 opt.header_tail = &opt.header_list;
5010cb5f 860 opt.regflags = REG_NEWLINE;
a91f453f 861 opt.max_depth = -1;
5010cb5f 862
00588bb5 863 strcpy(opt.color_context, "");
55f638bd 864 strcpy(opt.color_filename, "");
00588bb5 865 strcpy(opt.color_function, "");
55f638bd 866 strcpy(opt.color_lineno, "");
758df17a 867 strcpy(opt.color_match, GIT_COLOR_BOLD_RED);
00588bb5 868 strcpy(opt.color_selected, "");
55f638bd 869 strcpy(opt.color_sep, GIT_COLOR_CYAN);
7e8f59d5
RS
870 opt.color = -1;
871 git_config(grep_config, &opt);
872 if (opt.color == -1)
873 opt.color = git_use_color_default;
874
5010cb5f 875 /*
5acd64ed
JH
876 * If there is no -- then the paths must exist in the working
877 * tree. If there is no explicit pattern specified with -e or
878 * -f, we take the first unrecognized non option to be the
879 * pattern, but then what follows it must be zero or more
880 * valid refs up to the -- (if exists), and then existing
881 * paths. If there is an explicit pattern, then the first
82e5a82f 882 * unrecognized non option is the beginning of the refs list
5acd64ed 883 * that continues up to the -- (if exists), and then paths.
5010cb5f 884 */
37782920 885 argc = parse_options(argc, argv, prefix, options, grep_usage,
3e230fa1
RS
886 PARSE_OPT_KEEP_DASHDASH |
887 PARSE_OPT_STOP_AT_NON_OPTION |
888 PARSE_OPT_NO_INTERNAL_HELP);
889
ff38d1a9 890 if (use_index && !startup_info->have_repository)
59332d13
JH
891 /* die the same way as if we did it at the beginning */
892 setup_git_directory();
893
1123c67c
JK
894 /*
895 * skip a -- separator; we know it cannot be
896 * separating revisions from pathnames if
897 * we haven't even had any patterns yet
898 */
899 if (argc > 0 && !opt.pattern_list && !strcmp(argv[0], "--")) {
900 argv++;
901 argc--;
902 }
903
3e230fa1
RS
904 /* First unrecognized non-option token */
905 if (argc > 0 && !opt.pattern_list) {
906 append_grep_pattern(&opt, argv[0], "command line", 0,
907 GREP_PATTERN);
908 argv++;
909 argc--;
5010cb5f 910 }
5acd64ed 911
0af88c15
JS
912 if (show_in_pager == default_pager)
913 show_in_pager = git_pager(1);
678e484b 914 if (show_in_pager) {
e7b082a4 915 opt.color = 0;
0af88c15
JS
916 opt.name_only = 1;
917 opt.null_following_name = 1;
918 opt.output_priv = &path_list;
919 opt.output = append_path;
0c72cead 920 string_list_append(&path_list, show_in_pager);
0af88c15 921 use_threads = 0;
678e484b
JS
922 }
923
f9b9faf6 924 if (!opt.pattern_list)
2fc5f9f1 925 die(_("no pattern given."));
5183bf67
BC
926 if (!opt.fixed && opt.ignore_case)
927 opt.regflags |= REG_ICASE;
07ea91d8 928 if ((opt.regflags != REG_NEWLINE) && opt.fixed)
2fc5f9f1 929 die(_("cannot mix --fixed-strings and regexp"));
5b594f45
FK
930
931#ifndef NO_PTHREADS
932 if (online_cpus() == 1 || !grep_threads_ok(&opt))
933 use_threads = 0;
934
431d6e7b
RS
935 if (use_threads) {
936 if (opt.pre_context || opt.post_context)
937 print_hunk_marks_between_files = 1;
5b594f45 938 start_threads(&opt);
431d6e7b 939 }
5b594f45
FK
940#else
941 use_threads = 0;
942#endif
943
83b5d2f5 944 compile_grep_patterns(&opt);
5acd64ed
JH
945
946 /* Check revs and then paths */
3e230fa1 947 for (i = 0; i < argc; i++) {
5acd64ed 948 const char *arg = argv[i];
1362671f 949 unsigned char sha1[20];
5acd64ed
JH
950 /* Is it a rev? */
951 if (!get_sha1(arg, sha1)) {
952 struct object *object = parse_object(sha1);
5acd64ed 953 if (!object)
2fc5f9f1 954 die(_("bad object %s"), arg);
1f1e895f 955 add_object_array(object, arg, &list);
5acd64ed
JH
956 continue;
957 }
958 if (!strcmp(arg, "--")) {
959 i++;
960 seen_dashdash = 1;
961 }
962 break;
1362671f 963 }
5acd64ed
JH
964
965 /* The rest are paths */
966 if (!seen_dashdash) {
967 int j;
c39c4f47 968 for (j = i; j < argc; j++)
5acd64ed
JH
969 verify_filename(prefix, argv[j]);
970 }
971
493b7a08 972 if (i < argc)
5acd64ed 973 paths = get_pathspec(prefix, argv + i);
1362671f
JH
974 else if (prefix) {
975 paths = xcalloc(2, sizeof(const char *));
976 paths[0] = prefix;
977 paths[1] = NULL;
978 }
f34bbc15 979 init_pathspec(&pathspec, paths);
1376e507
NTND
980 pathspec.max_depth = opt.max_depth;
981 pathspec.recursive = 1;
5010cb5f 982
678e484b 983 if (show_in_pager && (cached || list.nr))
e4fe4ba5 984 die(_("--open-files-in-pager only works on the worktree"));
678e484b
JS
985
986 if (show_in_pager && opt.pattern_list && !opt.pattern_list->next) {
987 const char *pager = path_list.items[0].string;
988 int len = strlen(pager);
989
990 if (len > 4 && is_dir_sep(pager[len - 5]))
991 pager += len - 4;
992
993 if (!strcmp("less", pager) || !strcmp("vi", pager)) {
994 struct strbuf buf = STRBUF_INIT;
995 strbuf_addf(&buf, "+/%s%s",
996 strcmp("less", pager) ? "" : "*",
997 opt.pattern_list->pattern);
0c72cead 998 string_list_append(&path_list, buf.buf);
678e484b
JS
999 strbuf_detach(&buf, NULL);
1000 }
1001 }
1002
1003 if (!show_in_pager)
1004 setup_pager();
1005
1006
59332d13 1007 if (!use_index) {
59332d13 1008 if (cached)
2fc5f9f1 1009 die(_("--cached cannot be used with --no-index."));
59332d13 1010 if (list.nr)
2fc5f9f1 1011 die(_("--no-index cannot be used with revs."));
f34bbc15 1012 hit = grep_directory(&opt, &pathspec);
685359cf 1013 } else if (!list.nr) {
6577f542
NTND
1014 if (!cached)
1015 setup_work_tree();
5b594f45 1016
f34bbc15 1017 hit = grep_cache(&opt, &pathspec, cached);
685359cf
JS
1018 } else {
1019 if (cached)
2fc5f9f1 1020 die(_("both --cached and trees are given."));
f34bbc15 1021 hit = grep_objects(&opt, &pathspec, &list);
5010cb5f 1022 }
5b594f45
FK
1023
1024 if (use_threads)
1025 hit |= wait_all();
678e484b
JS
1026 if (hit && show_in_pager)
1027 run_pager(&opt, prefix);
b48fb5b6 1028 free_grep_patterns(&opt);
5010cb5f
JH
1029 return !hit;
1030}