]> git.ipfire.org Git - thirdparty/git.git/blame - builtin/grep.c
strmap: enable allocations to come from a mem_pool
[thirdparty/git.git] / builtin / grep.c
CommitLineData
5010cb5f
JH
1/*
2 * Builtin "git grep"
3 *
4 * Copyright (c) 2006 Junio C Hamano
5 */
f8adbec9 6#define USE_THE_INDEX_COMPATIBILITY_MACROS
5010cb5f 7#include "cache.h"
627d9342 8#include "repository.h"
b2141fc1 9#include "config.h"
5010cb5f
JH
10#include "blob.h"
11#include "tree.h"
12#include "commit.h"
13#include "tag.h"
1362671f 14#include "tree-walk.h"
5010cb5f 15#include "builtin.h"
3e230fa1 16#include "parse-options.h"
678e484b
JS
17#include "string-list.h"
18#include "run-command.h"
60ecac98 19#include "userdiff.h"
83b5d2f5 20#include "grep.h"
493b7a08 21#include "quote.h"
59332d13 22#include "dir.h"
64acde94 23#include "pathspec.h"
0281e487 24#include "submodule.h"
74ed4371 25#include "submodule-config.h"
90c62155 26#include "object-store.h"
6c307626 27#include "packfile.h"
5b594f45 28
3e230fa1 29static char const * const grep_usage[] = {
9c9b4f2f 30 N_("git grep [<options>] [-e] <pattern> [<rev>...] [[--] <path>...]"),
3e230fa1
RS
31 NULL
32};
33
0281e487 34static int recurse_submodules;
0281e487 35
89f09dd3 36static int num_threads;
5b594f45 37
89f09dd3 38static pthread_t *threads;
5b594f45 39
5b594f45
FK
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.
43 */
9cba13ca 44struct work_item {
8f24a632 45 struct grep_source source;
5b594f45
FK
46 char done;
47 struct strbuf out;
48};
49
50/* In the range [todo_done, todo_start) in 'todo' we have work_items
51 * that have been or are processed by a consumer thread. We haven't
52 * written the result for these to stdout yet.
53 *
54 * The work_items in [todo_start, todo_end) are waiting to be picked
55 * up by a consumer thread.
56 *
57 * The ranges are modulo TODO_SIZE.
58 */
59#define TODO_SIZE 128
60static struct work_item todo[TODO_SIZE];
61static int todo_start;
62static int todo_end;
63static int todo_done;
64
65/* Has all work items been added? */
66static int all_work_added;
67
68/* This lock protects all the variables above. */
69static pthread_mutex_t grep_mutex;
70
1487a12b
JH
71static inline void grep_lock(void)
72{
8df4c295 73 pthread_mutex_lock(&grep_mutex);
1487a12b
JH
74}
75
76static inline void grep_unlock(void)
77{
8df4c295 78 pthread_mutex_unlock(&grep_mutex);
1487a12b
JH
79}
80
5b594f45
FK
81/* Signalled when a new work_item is added to todo. */
82static pthread_cond_t cond_add;
83
84/* Signalled when the result from one work_item is written to
85 * stdout.
86 */
87static pthread_cond_t cond_write;
88
89/* Signalled when we are finished with everything. */
90static pthread_cond_t cond_result;
91
08303c36 92static int skip_first_line;
431d6e7b 93
70a9fef2 94static void add_work(struct grep_opt *opt, struct grep_source *gs)
5b594f45 95{
70a9fef2
MT
96 if (opt->binary != GREP_BINARY_TEXT)
97 grep_source_load_driver(gs, opt->repo->index);
98
5b594f45
FK
99 grep_lock();
100
101 while ((todo_end+1) % ARRAY_SIZE(todo) == todo_done) {
102 pthread_cond_wait(&cond_write, &grep_mutex);
103 }
104
e2e05d61 105 todo[todo_end].source = *gs;
5b594f45
FK
106 todo[todo_end].done = 0;
107 strbuf_reset(&todo[todo_end].out);
108 todo_end = (todo_end + 1) % ARRAY_SIZE(todo);
109
110 pthread_cond_signal(&cond_add);
111 grep_unlock();
112}
113
114static struct work_item *get_work(void)
115{
116 struct work_item *ret;
117
118 grep_lock();
119 while (todo_start == todo_end && !all_work_added) {
120 pthread_cond_wait(&cond_add, &grep_mutex);
121 }
122
123 if (todo_start == todo_end && all_work_added) {
124 ret = NULL;
125 } else {
126 ret = &todo[todo_start];
127 todo_start = (todo_start + 1) % ARRAY_SIZE(todo);
128 }
129 grep_unlock();
130 return ret;
131}
132
5b594f45
FK
133static void work_done(struct work_item *w)
134{
135 int old_done;
136
137 grep_lock();
138 w->done = 1;
139 old_done = todo_done;
140 for(; todo[todo_done].done && todo_done != todo_start;
141 todo_done = (todo_done+1) % ARRAY_SIZE(todo)) {
142 w = &todo[todo_done];
431d6e7b 143 if (w->out.len) {
08303c36
RS
144 const char *p = w->out.buf;
145 size_t len = w->out.len;
146
147 /* Skip the leading hunk mark of the first file. */
148 if (skip_first_line) {
149 while (len) {
150 len--;
151 if (*p++ == '\n')
152 break;
153 }
154 skip_first_line = 0;
155 }
156
157 write_or_die(1, p, len);
431d6e7b 158 }
8f24a632 159 grep_source_clear(&w->source);
5b594f45
FK
160 }
161
162 if (old_done != todo_done)
163 pthread_cond_signal(&cond_write);
164
165 if (all_work_added && todo_done == todo_end)
166 pthread_cond_signal(&cond_result);
167
168 grep_unlock();
169}
170
171static void *run(void *arg)
172{
173 int hit = 0;
174 struct grep_opt *opt = arg;
175
176 while (1) {
177 struct work_item *w = get_work();
178 if (!w)
179 break;
180
181 opt->output_priv = w;
f9ee2fcd 182 hit |= grep_source(opt, &w->source);
8f24a632 183 grep_source_clear_data(&w->source);
5b594f45
FK
184 work_done(w);
185 }
bfac23d9
DM
186 free_grep_patterns(arg);
187 free(arg);
5b594f45
FK
188
189 return (void*) (intptr_t) hit;
190}
191
192static void strbuf_out(struct grep_opt *opt, const void *buf, size_t size)
193{
194 struct work_item *w = opt->output_priv;
195 strbuf_add(&w->out, buf, size);
196}
197
198static void start_threads(struct grep_opt *opt)
199{
200 int i;
201
202 pthread_mutex_init(&grep_mutex, NULL);
0579f91d 203 pthread_mutex_init(&grep_attr_mutex, NULL);
5b594f45
FK
204 pthread_cond_init(&cond_add, NULL);
205 pthread_cond_init(&cond_write, NULL);
206 pthread_cond_init(&cond_result, NULL);
78db6ea9 207 grep_use_locks = 1;
1d1729ca 208 enable_obj_read_lock();
5b594f45
FK
209
210 for (i = 0; i < ARRAY_SIZE(todo); i++) {
211 strbuf_init(&todo[i].out, 0);
212 }
213
89f09dd3
VL
214 threads = xcalloc(num_threads, sizeof(*threads));
215 for (i = 0; i < num_threads; i++) {
5b594f45
FK
216 int err;
217 struct grep_opt *o = grep_opt_dup(opt);
218 o->output = strbuf_out;
6d423dd5
ÆAB
219 if (i)
220 o->debug = 0;
5b594f45
FK
221 compile_grep_patterns(o);
222 err = pthread_create(&threads[i], NULL, run, o);
223
224 if (err)
2fc5f9f1 225 die(_("grep: failed to create thread: %s"),
5b594f45
FK
226 strerror(err));
227 }
228}
229
230static int wait_all(void)
231{
232 int hit = 0;
233 int i;
234
4002e87c 235 if (!HAVE_THREADS)
fd6263fb 236 BUG("Never call this function unless you have started threads");
4002e87c 237
5b594f45
FK
238 grep_lock();
239 all_work_added = 1;
240
241 /* Wait until all work is done. */
242 while (todo_done != todo_end)
243 pthread_cond_wait(&cond_result, &grep_mutex);
244
245 /* Wake up all the consumer threads so they can see that there
246 * is no more work to do.
247 */
248 pthread_cond_broadcast(&cond_add);
249 grep_unlock();
250
89f09dd3 251 for (i = 0; i < num_threads; i++) {
5b594f45
FK
252 void *h;
253 pthread_join(threads[i], &h);
254 hit |= (int) (intptr_t) h;
255 }
256
89f09dd3
VL
257 free(threads);
258
5b594f45 259 pthread_mutex_destroy(&grep_mutex);
0579f91d 260 pthread_mutex_destroy(&grep_attr_mutex);
5b594f45
FK
261 pthread_cond_destroy(&cond_add);
262 pthread_cond_destroy(&cond_write);
263 pthread_cond_destroy(&cond_result);
78db6ea9 264 grep_use_locks = 0;
1d1729ca 265 disable_obj_read_lock();
5b594f45
FK
266
267 return hit;
268}
5b594f45 269
15fabd1b
JH
270static int grep_cmd_config(const char *var, const char *value, void *cb)
271{
272 int st = grep_config(var, value, cb);
33c643bb 273 if (git_color_default_config(var, value, cb) < 0)
15fabd1b 274 st = -1;
89f09dd3
VL
275
276 if (!strcmp(var, "grep.threads")) {
277 num_threads = git_config_int(var, value);
278 if (num_threads < 0)
279 die(_("invalid number of threads specified (%d) for %s"),
280 num_threads, var);
fd6263fb 281 else if (!HAVE_THREADS && num_threads > 1) {
d1edee4a
ÆAB
282 /*
283 * TRANSLATORS: %s is the configuration
284 * variable for tweaking threads, currently
285 * grep.threads
286 */
287 warning(_("no threads support, ignoring %s"), var);
fd6263fb 288 num_threads = 1;
d1edee4a 289 }
89f09dd3
VL
290 }
291
9071c078
SB
292 if (!strcmp(var, "submodule.recurse"))
293 recurse_submodules = git_config_bool(var, value);
294
15fabd1b
JH
295 return st;
296}
297
45115d84
MT
298static void grep_source_name(struct grep_opt *opt, const char *filename,
299 int tree_name_len, struct strbuf *out)
300{
301 strbuf_reset(out);
302
303 if (opt->null_following_name) {
304 if (opt->relative && opt->prefix_length) {
305 struct strbuf rel_buf = STRBUF_INIT;
306 const char *rel_name =
307 relative_path(filename + tree_name_len,
308 opt->prefix, &rel_buf);
309
310 if (tree_name_len)
311 strbuf_add(out, filename, tree_name_len);
312
313 strbuf_addstr(out, rel_name);
314 strbuf_release(&rel_buf);
315 } else {
316 strbuf_addstr(out, filename);
317 }
318 return;
319 }
320
321 if (opt->relative && opt->prefix_length)
88910c99 322 quote_path(filename + tree_name_len, opt->prefix, out, 0);
45115d84
MT
323 else
324 quote_c_style(filename + tree_name_len, out, NULL, 0);
325
326 if (tree_name_len)
327 strbuf_insert(out, 0, filename, tree_name_len);
328}
329
1db11086 330static int grep_oid(struct grep_opt *opt, const struct object_id *oid,
55c61688
NTND
331 const char *filename, int tree_name_len,
332 const char *path)
5b594f45
FK
333{
334 struct strbuf pathbuf = STRBUF_INIT;
e2e05d61 335 struct grep_source gs;
5b594f45 336
45115d84 337 grep_source_name(opt, filename, tree_name_len, &pathbuf);
e2e05d61 338 grep_source_init(&gs, GREP_SOURCE_OID, pathbuf.buf, path, oid);
38ef24dc 339 strbuf_release(&pathbuf);
e2e05d61 340
fd6263fb 341 if (num_threads > 1) {
e2e05d61
RV
342 /*
343 * add_work() copies gs and thus assumes ownership of
344 * its fields, so do not call grep_source_clear()
345 */
346 add_work(opt, &gs);
5b594f45 347 return 0;
4002e87c 348 } else {
5b594f45 349 int hit;
5010cb5f 350
8f24a632 351 hit = grep_source(opt, &gs);
dc49cd76 352
8f24a632
JK
353 grep_source_clear(&gs);
354 return hit;
5010cb5f 355 }
5b594f45
FK
356}
357
358static int grep_file(struct grep_opt *opt, const char *filename)
359{
360 struct strbuf buf = STRBUF_INIT;
e2e05d61 361 struct grep_source gs;
5b594f45 362
45115d84 363 grep_source_name(opt, filename, 0, &buf);
e2e05d61 364 grep_source_init(&gs, GREP_SOURCE_FILE, buf.buf, filename, filename);
38ef24dc 365 strbuf_release(&buf);
e2e05d61 366
fd6263fb 367 if (num_threads > 1) {
e2e05d61
RV
368 /*
369 * add_work() copies gs and thus assumes ownership of
370 * its fields, so do not call grep_source_clear()
371 */
372 add_work(opt, &gs);
5b594f45 373 return 0;
4002e87c 374 } else {
5b594f45 375 int hit;
5b594f45 376
8f24a632
JK
377 hit = grep_source(opt, &gs);
378
379 grep_source_clear(&gs);
5b594f45
FK
380 return hit;
381 }
5010cb5f
JH
382}
383
678e484b
JS
384static void append_path(struct grep_opt *opt, const void *data, size_t len)
385{
386 struct string_list *path_list = opt->output_priv;
387
388 if (len == 1 && *(const char *)data == '\0')
389 return;
0c72cead 390 string_list_append(path_list, xstrndup(data, len));
678e484b
JS
391}
392
393static void run_pager(struct grep_opt *opt, const char *prefix)
394{
395 struct string_list *path_list = opt->output_priv;
850d2fec 396 struct child_process child = CHILD_PROCESS_INIT;
678e484b
JS
397 int i, status;
398
399 for (i = 0; i < path_list->nr; i++)
22f9b7f3 400 strvec_push(&child.args, path_list->items[i].string);
850d2fec
JK
401 child.dir = prefix;
402 child.use_shell = 1;
678e484b 403
850d2fec 404 status = run_command(&child);
678e484b
JS
405 if (status)
406 exit(status);
678e484b
JS
407}
408
dba093dd 409static int grep_cache(struct grep_opt *opt,
f9ee2fcd
BW
410 const struct pathspec *pathspec, int cached);
411static int grep_tree(struct grep_opt *opt, const struct pathspec *pathspec,
412 struct tree_desc *tree, struct strbuf *base, int tn_len,
dba093dd 413 int check_attr);
0281e487 414
dba093dd 415static int grep_submodule(struct grep_opt *opt,
f9ee2fcd
BW
416 const struct pathspec *pathspec,
417 const struct object_id *oid,
6a289d45 418 const char *filename, const char *path, int cached)
0281e487 419{
d5498e08 420 struct repository subrepo;
dba093dd 421 struct repository *superproject = opt->repo;
faf123c7 422 const struct submodule *sub;
dba093dd 423 struct grep_opt subopt;
f9ee2fcd 424 int hit;
74ed4371 425
faf123c7 426 sub = submodule_from_path(superproject, &null_oid, path);
76e9bdc4 427
c441ea4e 428 if (!is_submodule_active(superproject, path))
f9ee2fcd 429 return 0;
0281e487 430
c441ea4e 431 if (repo_submodule_init(&subrepo, superproject, sub))
f9ee2fcd 432 return 0;
be80a239 433
c441ea4e
MT
434 /*
435 * NEEDSWORK: repo_read_gitmodules() might call
436 * add_to_alternates_memory() via config_from_gitmodules(). This
437 * operation causes a race condition with concurrent object readings
438 * performed by the worker threads. That's why we need obj_read_lock()
439 * here. It should be removed once it's no longer necessary to add the
440 * subrepo's odbs to the in-memory alternates list.
441 */
442 obj_read_lock();
d7992421 443 repo_read_gitmodules(&subrepo, 0);
0281e487 444
74ed4371 445 /*
f9ee2fcd
BW
446 * NEEDSWORK: This adds the submodule's object directory to the list of
447 * alternates for the single in-memory object store. This has some bad
448 * consequences for memory (processed objects will never be freed) and
449 * performance (this increases the number of pack files git has to pay
450 * attention to, to the sum of the number of pack files in all the
451 * repositories processed so far). This can be removed once the object
452 * store is no longer global and instead is a member of the repository
453 * object.
74ed4371 454 */
5d3635db 455 add_to_alternates_memory(subrepo.objects->odb->path);
1d1729ca 456 obj_read_unlock();
74ed4371 457
dba093dd 458 memcpy(&subopt, opt, sizeof(subopt));
7589e636 459 subopt.repo = &subrepo;
dba093dd 460
f9ee2fcd
BW
461 if (oid) {
462 struct object *object;
463 struct tree_desc tree;
464 void *data;
465 unsigned long size;
466 struct strbuf base = STRBUF_INIT;
74ed4371 467
1d1729ca 468 obj_read_lock();
98c6871f 469 object = parse_object_or_die(oid, NULL);
1d1729ca 470 obj_read_unlock();
d3b4705a
NTND
471 data = read_object_with_reference(&subrepo,
472 &object->oid, tree_type,
f9ee2fcd 473 &size, NULL);
f9ee2fcd
BW
474 if (!data)
475 die(_("unable to read tree (%s)"), oid_to_hex(&object->oid));
0281e487 476
f9ee2fcd
BW
477 strbuf_addstr(&base, filename);
478 strbuf_addch(&base, '/');
0281e487 479
f9ee2fcd 480 init_tree_desc(&tree, data, size);
dba093dd
NTND
481 hit = grep_tree(&subopt, pathspec, &tree, &base, base.len,
482 object->type == OBJ_COMMIT);
f9ee2fcd
BW
483 strbuf_release(&base);
484 free(data);
485 } else {
6a289d45 486 hit = grep_cache(&subopt, pathspec, cached);
e6fac7f3 487 }
0281e487 488
d5498e08 489 repo_clear(&subrepo);
f9ee2fcd 490 return hit;
0281e487
BW
491}
492
dba093dd 493static int grep_cache(struct grep_opt *opt,
f9ee2fcd 494 const struct pathspec *pathspec, int cached)
5010cb5f 495{
dba093dd 496 struct repository *repo = opt->repo;
5010cb5f
JH
497 int hit = 0;
498 int nr;
0281e487
BW
499 struct strbuf name = STRBUF_INIT;
500 int name_base_len = 0;
f9ee2fcd
BW
501 if (repo->submodule_prefix) {
502 name_base_len = strlen(repo->submodule_prefix);
503 strbuf_addstr(&name, repo->submodule_prefix);
0281e487
BW
504 }
505
b2aa84c7 506 if (repo_read_index(repo) < 0)
5507067d 507 die(_("index file corrupt"));
5010cb5f 508
f9ee2fcd
BW
509 for (nr = 0; nr < repo->index->cache_nr; nr++) {
510 const struct cache_entry *ce = repo->index->cache[nr];
0281e487
BW
511 strbuf_setlen(&name, name_base_len);
512 strbuf_addstr(&name, ce->name);
513
514 if (S_ISREG(ce->ce_mode) &&
a4009b0b 515 match_pathspec(repo->index, pathspec, name.buf, name.len, 0, NULL,
0281e487
BW
516 S_ISDIR(ce->ce_mode) ||
517 S_ISGITLINK(ce->ce_mode))) {
518 /*
519 * If CE_VALID is on, we assume worktree file and its
520 * cache entry are identical, even if worktree file has
521 * been modified, so use cache version instead
522 */
523 if (cached || (ce->ce_flags & CE_VALID) ||
524 ce_skip_worktree(ce)) {
525 if (ce_stage(ce) || ce_intent_to_add(ce))
526 continue;
f9ee2fcd
BW
527 hit |= grep_oid(opt, &ce->oid, name.buf,
528 0, name.buf);
0281e487 529 } else {
f9ee2fcd 530 hit |= grep_file(opt, name.buf);
0281e487
BW
531 }
532 } else if (recurse_submodules && S_ISGITLINK(ce->ce_mode) &&
a4009b0b 533 submodule_path_match(repo->index, pathspec, name.buf, NULL)) {
6a289d45
MT
534 hit |= grep_submodule(opt, pathspec, NULL, ce->name,
535 ce->name, cached);
0281e487 536 } else {
5010cb5f 537 continue;
36f2587f 538 }
0281e487 539
36f2587f
JH
540 if (ce_stage(ce)) {
541 do {
542 nr++;
f9ee2fcd
BW
543 } while (nr < repo->index->cache_nr &&
544 !strcmp(ce->name, repo->index->cache[nr]->name));
36f2587f
JH
545 nr--; /* compensate for loop control */
546 }
c8610a2e
JH
547 if (hit && opt->status_only)
548 break;
5010cb5f 549 }
0281e487
BW
550
551 strbuf_release(&name);
5010cb5f
JH
552 return hit;
553}
554
f34bbc15 555static int grep_tree(struct grep_opt *opt, const struct pathspec *pathspec,
55c61688 556 struct tree_desc *tree, struct strbuf *base, int tn_len,
dba093dd 557 int check_attr)
5010cb5f 558{
dba093dd 559 struct repository *repo = opt->repo;
d688cf07
NTND
560 int hit = 0;
561 enum interesting match = entry_not_interesting;
4c068a98 562 struct name_entry entry;
e5e062b6 563 int old_baselen = base->len;
74ed4371
BW
564 struct strbuf name = STRBUF_INIT;
565 int name_base_len = 0;
f9ee2fcd
BW
566 if (repo->submodule_prefix) {
567 strbuf_addstr(&name, repo->submodule_prefix);
74ed4371
BW
568 name_base_len = name.len;
569 }
5010cb5f 570
4c068a98 571 while (tree_entry(tree, &entry)) {
0de16337 572 int te_len = tree_entry_len(&entry);
e5e062b6 573
d688cf07 574 if (match != all_entries_interesting) {
74ed4371 575 strbuf_addstr(&name, base->buf + tn_len);
67022e02
NTND
576 match = tree_entry_interesting(repo->index,
577 &entry, &name,
74ed4371
BW
578 0, pathspec);
579 strbuf_setlen(&name, name_base_len);
580
d688cf07 581 if (match == all_entries_not_interesting)
97d0b74a 582 break;
d688cf07 583 if (match == entry_not_interesting)
1376e507
NTND
584 continue;
585 }
5010cb5f 586
1376e507 587 strbuf_add(base, entry.path, te_len);
e0eb889f 588
1376e507 589 if (S_ISREG(entry.mode)) {
ea82b2a0 590 hit |= grep_oid(opt, &entry.oid, base->buf, tn_len,
55c61688 591 check_attr ? base->buf + tn_len : NULL);
74ed4371 592 } else if (S_ISDIR(entry.mode)) {
21666f1a 593 enum object_type type;
5010cb5f
JH
594 struct tree_desc sub;
595 void *data;
6fda5e51
LT
596 unsigned long size;
597
1d1729ca 598 data = read_object_file(&entry.oid, &type, &size);
5010cb5f 599 if (!data)
2fc5f9f1 600 die(_("unable to read tree (%s)"),
ea82b2a0 601 oid_to_hex(&entry.oid));
1376e507
NTND
602
603 strbuf_addch(base, '/');
6fda5e51 604 init_tree_desc(&sub, data, size);
55c61688 605 hit |= grep_tree(opt, pathspec, &sub, base, tn_len,
dba093dd 606 check_attr);
5010cb5f 607 free(data);
74ed4371 608 } else if (recurse_submodules && S_ISGITLINK(entry.mode)) {
7589e636 609 hit |= grep_submodule(opt, pathspec, &entry.oid,
6a289d45
MT
610 base->buf, base->buf + tn_len,
611 1); /* ignored */
5010cb5f 612 }
74ed4371 613
e5e062b6
NTND
614 strbuf_setlen(base, old_baselen);
615
c8610a2e
JH
616 if (hit && opt->status_only)
617 break;
5010cb5f 618 }
74ed4371
BW
619
620 strbuf_release(&name);
5010cb5f
JH
621 return hit;
622}
623
f34bbc15 624static int grep_object(struct grep_opt *opt, const struct pathspec *pathspec,
6856077a 625 struct object *obj, const char *name, const char *path)
5010cb5f 626{
1974632c 627 if (obj->type == OBJ_BLOB)
1db11086 628 return grep_oid(opt, &obj->oid, name, 0, path);
1974632c 629 if (obj->type == OBJ_COMMIT || obj->type == OBJ_TREE) {
5010cb5f
JH
630 struct tree_desc tree;
631 void *data;
6fda5e51 632 unsigned long size;
e5e062b6
NTND
633 struct strbuf base;
634 int hit, len;
635
d3b4705a
NTND
636 data = read_object_with_reference(opt->repo,
637 &obj->oid, tree_type,
6fda5e51 638 &size, NULL);
5010cb5f 639 if (!data)
f2fd0760 640 die(_("unable to read tree (%s)"), oid_to_hex(&obj->oid));
e5e062b6
NTND
641
642 len = name ? strlen(name) : 0;
643 strbuf_init(&base, PATH_MAX + len + 1);
644 if (len) {
645 strbuf_add(&base, name, len);
646 strbuf_addch(&base, ':');
647 }
6fda5e51 648 init_tree_desc(&tree, data, size);
55c61688 649 hit = grep_tree(opt, pathspec, &tree, &base, base.len,
dba093dd 650 obj->type == OBJ_COMMIT);
e5e062b6 651 strbuf_release(&base);
5010cb5f
JH
652 free(data);
653 return hit;
654 }
debca9d2 655 die(_("unable to grep from object of type %s"), type_name(obj->type));
5010cb5f
JH
656}
657
f34bbc15 658static int grep_objects(struct grep_opt *opt, const struct pathspec *pathspec,
30d00c39
JN
659 const struct object_array *list)
660{
661 unsigned int i;
662 int hit = 0;
663 const unsigned int nr = list->nr;
664
665 for (i = 0; i < nr; i++) {
666 struct object *real_obj;
d5b0bac5 667
1d1729ca 668 obj_read_lock();
dba093dd 669 real_obj = deref_tag(opt->repo, list->objects[i].item,
a74093da 670 NULL, 0);
1d1729ca 671 obj_read_unlock();
74ed4371
BW
672
673 /* load the gitmodules file for this rev */
674 if (recurse_submodules) {
dba093dd 675 submodule_free(opt->repo);
1d1729ca 676 obj_read_lock();
cd73de47 677 gitmodules_config_oid(&real_obj->oid);
1d1729ca 678 obj_read_unlock();
74ed4371 679 }
6856077a
JT
680 if (grep_object(opt, pathspec, real_obj, list->objects[i].name,
681 list->objects[i].path)) {
30d00c39
JN
682 hit = 1;
683 if (opt->status_only)
684 break;
685 }
686 }
687 return hit;
688}
689
dbfae86a 690static int grep_directory(struct grep_opt *opt, const struct pathspec *pathspec,
85975c0c 691 int exc_std, int use_index)
59332d13
JH
692{
693 struct dir_struct dir;
694 int i, hit = 0;
695
eceba532 696 dir_init(&dir);
85975c0c
JK
697 if (!use_index)
698 dir.flags |= DIR_NO_GITLINKS;
0a93fb8a
JH
699 if (exc_std)
700 setup_standard_excludes(&dir);
59332d13 701
dba093dd 702 fill_directory(&dir, opt->repo->index, pathspec);
59332d13
JH
703 for (i = 0; i < dir.nr; i++) {
704 hit |= grep_file(opt, dir.entries[i]->name);
705 if (hit && opt->status_only)
706 break;
707 }
eceba532 708 dir_clear(&dir);
59332d13
JH
709 return hit;
710}
711
ff3c7f9a
RS
712static int context_callback(const struct option *opt, const char *arg,
713 int unset)
3e230fa1
RS
714{
715 struct grep_opt *grep_opt = opt->value;
716 int value;
717 const char *endp;
718
719 if (unset) {
720 grep_opt->pre_context = grep_opt->post_context = 0;
721 return 0;
722 }
723 value = strtol(arg, (char **)&endp, 10);
724 if (*endp) {
2fc5f9f1 725 return error(_("switch `%c' expects a numerical value"),
3e230fa1
RS
726 opt->short_name);
727 }
728 grep_opt->pre_context = grep_opt->post_context = value;
729 return 0;
730}
731
ff3c7f9a 732static int file_callback(const struct option *opt, const char *arg, int unset)
3e230fa1
RS
733{
734 struct grep_opt *grep_opt = opt->value;
517fe807 735 int from_stdin;
3e230fa1
RS
736 FILE *patterns;
737 int lno = 0;
cfe370c6 738 struct strbuf sb = STRBUF_INIT;
3e230fa1 739
517fe807
JK
740 BUG_ON_OPT_NEG(unset);
741
742 from_stdin = !strcmp(arg, "-");
c41dd2fd 743 patterns = from_stdin ? stdin : fopen(arg, "r");
3e230fa1 744 if (!patterns)
2fc5f9f1 745 die_errno(_("cannot open '%s'"), arg);
a5518431 746 while (strbuf_getline(&sb, patterns) == 0) {
3e230fa1
RS
747 /* ignore empty line like grep does */
748 if (sb.len == 0)
749 continue;
ed40a095 750
ec830611
RS
751 append_grep_pat(grep_opt, sb.buf, sb.len, arg, ++lno,
752 GREP_PATTERN);
3e230fa1 753 }
c41dd2fd
RS
754 if (!from_stdin)
755 fclose(patterns);
3e230fa1
RS
756 strbuf_release(&sb);
757 return 0;
758}
759
ff3c7f9a 760static int not_callback(const struct option *opt, const char *arg, int unset)
3e230fa1
RS
761{
762 struct grep_opt *grep_opt = opt->value;
517fe807
JK
763 BUG_ON_OPT_NEG(unset);
764 BUG_ON_OPT_ARG(arg);
3e230fa1
RS
765 append_grep_pattern(grep_opt, "--not", "command line", 0, GREP_NOT);
766 return 0;
767}
768
ff3c7f9a 769static int and_callback(const struct option *opt, const char *arg, int unset)
3e230fa1
RS
770{
771 struct grep_opt *grep_opt = opt->value;
517fe807
JK
772 BUG_ON_OPT_NEG(unset);
773 BUG_ON_OPT_ARG(arg);
3e230fa1
RS
774 append_grep_pattern(grep_opt, "--and", "command line", 0, GREP_AND);
775 return 0;
776}
777
ff3c7f9a 778static int open_callback(const struct option *opt, const char *arg, int unset)
3e230fa1
RS
779{
780 struct grep_opt *grep_opt = opt->value;
517fe807
JK
781 BUG_ON_OPT_NEG(unset);
782 BUG_ON_OPT_ARG(arg);
3e230fa1
RS
783 append_grep_pattern(grep_opt, "(", "command line", 0, GREP_OPEN_PAREN);
784 return 0;
785}
786
ff3c7f9a 787static int close_callback(const struct option *opt, const char *arg, int unset)
3e230fa1
RS
788{
789 struct grep_opt *grep_opt = opt->value;
517fe807
JK
790 BUG_ON_OPT_NEG(unset);
791 BUG_ON_OPT_ARG(arg);
3e230fa1
RS
792 append_grep_pattern(grep_opt, ")", "command line", 0, GREP_CLOSE_PAREN);
793 return 0;
794}
795
ff3c7f9a
RS
796static int pattern_callback(const struct option *opt, const char *arg,
797 int unset)
3e230fa1
RS
798{
799 struct grep_opt *grep_opt = opt->value;
517fe807 800 BUG_ON_OPT_NEG(unset);
3e230fa1
RS
801 append_grep_pattern(grep_opt, arg, "-e option", 0, GREP_PATTERN);
802 return 0;
803}
5010cb5f 804
a633fca0 805int cmd_grep(int argc, const char **argv, const char *prefix)
5010cb5f 806{
5010cb5f 807 int hit = 0;
0a93fb8a 808 int cached = 0, untracked = 0, opt_exclude = -1;
5acd64ed 809 int seen_dashdash = 0;
bbc09c22 810 int external_grep_allowed__ignored;
0af88c15 811 const char *show_in_pager = NULL, *default_pager = "dummy";
5010cb5f 812 struct grep_opt opt;
3cd47459 813 struct object_array list = OBJECT_ARRAY_INIT;
f34bbc15 814 struct pathspec pathspec;
183113a5 815 struct string_list path_list = STRING_LIST_INIT_NODUP;
5acd64ed 816 int i;
3e230fa1 817 int dummy;
ff38d1a9 818 int use_index = 1;
84befcd0 819 int pattern_type_arg = GREP_PATTERN_TYPE_UNSPECIFIED;
131f3c96 820 int allow_revs;
cca2c172 821
3e230fa1 822 struct option options[] = {
d5d09d47 823 OPT_BOOL(0, "cached", &cached,
4b407bc5 824 N_("search in index instead of in the work tree")),
cbb08c2e 825 OPT_NEGBIT(0, "no-index", &use_index,
f63cf8c9 826 N_("find in contents not managed by git"), 1),
d5d09d47 827 OPT_BOOL(0, "untracked", &untracked,
4b407bc5 828 N_("search in both tracked and untracked files")),
0a93fb8a 829 OPT_SET_INT(0, "exclude-standard", &opt_exclude,
77fdb8a8 830 N_("ignore files specified via '.gitignore'"), 1),
0281e487 831 OPT_BOOL(0, "recurse-submodules", &recurse_submodules,
4fb1c6aa 832 N_("recursively search in each submodule")),
3e230fa1 833 OPT_GROUP(""),
d5d09d47 834 OPT_BOOL('v', "invert-match", &opt.invert,
4b407bc5 835 N_("show non-matching lines")),
d5d09d47 836 OPT_BOOL('i', "ignore-case", &opt.ignore_case,
4b407bc5 837 N_("case insensitive matching")),
d5d09d47 838 OPT_BOOL('w', "word-regexp", &opt.word_regexp,
4b407bc5 839 N_("match patterns only at word boundaries")),
3e230fa1 840 OPT_SET_INT('a', "text", &opt.binary,
4b407bc5 841 N_("process binary files as text"), GREP_BINARY_TEXT),
3e230fa1 842 OPT_SET_INT('I', NULL, &opt.binary,
4b407bc5 843 N_("don't match patterns in binary files"),
3e230fa1 844 GREP_BINARY_NOMATCH),
335ec3bf
JK
845 OPT_BOOL(0, "textconv", &opt.allow_textconv,
846 N_("process binary files with textconv filters")),
0a09e5ed
RS
847 OPT_SET_INT('r', "recursive", &opt.max_depth,
848 N_("search in subdirectories (default)"), -1),
4b407bc5
NTND
849 { OPTION_INTEGER, 0, "max-depth", &opt.max_depth, N_("depth"),
850 N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
a91f453f 851 NULL, 1 },
3e230fa1 852 OPT_GROUP(""),
84befcd0 853 OPT_SET_INT('E', "extended-regexp", &pattern_type_arg,
4b407bc5 854 N_("use extended POSIX regular expressions"),
84befcd0
S
855 GREP_PATTERN_TYPE_ERE),
856 OPT_SET_INT('G', "basic-regexp", &pattern_type_arg,
4b407bc5 857 N_("use basic POSIX regular expressions (default)"),
84befcd0
S
858 GREP_PATTERN_TYPE_BRE),
859 OPT_SET_INT('F', "fixed-strings", &pattern_type_arg,
4b407bc5 860 N_("interpret patterns as fixed strings"),
84befcd0
S
861 GREP_PATTERN_TYPE_FIXED),
862 OPT_SET_INT('P', "perl-regexp", &pattern_type_arg,
4b407bc5 863 N_("use Perl-compatible regular expressions"),
84befcd0 864 GREP_PATTERN_TYPE_PCRE),
3e230fa1 865 OPT_GROUP(""),
d5d09d47 866 OPT_BOOL('n', "line-number", &opt.linenum, N_("show line numbers")),
a449f27f 867 OPT_BOOL(0, "column", &opt.columnnum, N_("show column number of first match")),
4b407bc5
NTND
868 OPT_NEGBIT('h', NULL, &opt.pathname, N_("don't show filenames"), 1),
869 OPT_BIT('H', NULL, &opt.pathname, N_("show filenames"), 1),
3e230fa1 870 OPT_NEGBIT(0, "full-name", &opt.relative,
4b407bc5 871 N_("show filenames relative to top directory"), 1),
d5d09d47 872 OPT_BOOL('l', "files-with-matches", &opt.name_only,
4b407bc5 873 N_("show only filenames instead of matching lines")),
d5d09d47 874 OPT_BOOL(0, "name-only", &opt.name_only,
4b407bc5 875 N_("synonym for --files-with-matches")),
d5d09d47 876 OPT_BOOL('L', "files-without-match",
3e230fa1 877 &opt.unmatch_name_only,
4b407bc5 878 N_("show only the names of files without match")),
caf2de33
NTND
879 OPT_BOOL_F('z', "null", &opt.null_following_name,
880 N_("print NUL after filenames"),
881 PARSE_OPT_NOCOMPLETE),
9d8db06e
TB
882 OPT_BOOL('o', "only-matching", &opt.only_matching,
883 N_("show only matching parts of a line")),
d5d09d47 884 OPT_BOOL('c', "count", &opt.count,
4b407bc5
NTND
885 N_("show the number of matches instead of matching lines")),
886 OPT__COLOR(&opt.color, N_("highlight matches")),
d5d09d47 887 OPT_BOOL(0, "break", &opt.file_break,
4b407bc5 888 N_("print empty line between matches from different files")),
d5d09d47 889 OPT_BOOL(0, "heading", &opt.heading,
4b407bc5 890 N_("show filename only once above matches from same file")),
3e230fa1 891 OPT_GROUP(""),
4b407bc5
NTND
892 OPT_CALLBACK('C', "context", &opt, N_("n"),
893 N_("show <n> context lines before and after matches"),
3e230fa1 894 context_callback),
317f63c2 895 OPT_INTEGER('B', "before-context", &opt.pre_context,
4b407bc5 896 N_("show <n> context lines before matches")),
317f63c2 897 OPT_INTEGER('A', "after-context", &opt.post_context,
4b407bc5 898 N_("show <n> context lines after matches")),
89f09dd3
VL
899 OPT_INTEGER(0, "threads", &num_threads,
900 N_("use <n> worker threads")),
4b407bc5 901 OPT_NUMBER_CALLBACK(&opt, N_("shortcut for -C NUM"),
3e230fa1 902 context_callback),
d5d09d47 903 OPT_BOOL('p', "show-function", &opt.funcname,
4b407bc5 904 N_("show a line with the function name before matches")),
d5d09d47 905 OPT_BOOL('W', "function-context", &opt.funcbody,
4b407bc5 906 N_("show the surrounding function")),
3e230fa1 907 OPT_GROUP(""),
4b407bc5
NTND
908 OPT_CALLBACK('f', NULL, &opt, N_("file"),
909 N_("read patterns from file"), file_callback),
203c8533
DL
910 OPT_CALLBACK_F('e', NULL, &opt, N_("pattern"),
911 N_("match <pattern>"), PARSE_OPT_NONEG, pattern_callback),
912 OPT_CALLBACK_F(0, "and", &opt, NULL,
913 N_("combine patterns specified with -e"),
914 PARSE_OPT_NOARG | PARSE_OPT_NONEG, and_callback),
d5d09d47 915 OPT_BOOL(0, "or", &dummy, ""),
203c8533
DL
916 OPT_CALLBACK_F(0, "not", &opt, NULL, "",
917 PARSE_OPT_NOARG | PARSE_OPT_NONEG, not_callback),
918 OPT_CALLBACK_F('(', NULL, &opt, NULL, "",
919 PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH,
920 open_callback),
921 OPT_CALLBACK_F(')', NULL, &opt, NULL, "",
922 PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH,
923 close_callback),
d52ee6e6 924 OPT__QUIET(&opt.status_only,
4b407bc5 925 N_("indicate hit with exit status without output")),
d5d09d47 926 OPT_BOOL(0, "all-match", &opt.all_match,
4b407bc5 927 N_("show only matches from files that match all patterns")),
3e4a67b4
NTND
928 OPT_SET_INT_F(0, "debug", &opt.debug,
929 N_("show parse tree for grep expression"),
930 1, PARSE_OPT_HIDDEN),
3e230fa1 931 OPT_GROUP(""),
0af88c15 932 { OPTION_STRING, 'O', "open-files-in-pager", &show_in_pager,
4b407bc5 933 N_("pager"), N_("show matching files in the pager"),
caf2de33
NTND
934 PARSE_OPT_OPTARG | PARSE_OPT_NOCOMPLETE,
935 NULL, (intptr_t)default_pager },
936 OPT_BOOL_F(0, "ext-grep", &external_grep_allowed__ignored,
937 N_("allow calling of grep(1) (ignored by this build)"),
938 PARSE_OPT_NOCOMPLETE),
3e230fa1
RS
939 OPT_END()
940 };
5010cb5f 941
38bbc2ea 942 init_grep_defaults(the_repository);
15fabd1b 943 git_config(grep_cmd_config, NULL);
38bbc2ea 944 grep_init(&opt, the_repository, prefix);
7e8f59d5 945
5010cb5f 946 /*
5acd64ed
JH
947 * If there is no -- then the paths must exist in the working
948 * tree. If there is no explicit pattern specified with -e or
949 * -f, we take the first unrecognized non option to be the
950 * pattern, but then what follows it must be zero or more
951 * valid refs up to the -- (if exists), and then existing
952 * paths. If there is an explicit pattern, then the first
82e5a82f 953 * unrecognized non option is the beginning of the refs list
5acd64ed 954 * that continues up to the -- (if exists), and then paths.
5010cb5f 955 */
37782920 956 argc = parse_options(argc, argv, prefix, options, grep_usage,
3e230fa1 957 PARSE_OPT_KEEP_DASHDASH |
44415499 958 PARSE_OPT_STOP_AT_NON_OPTION);
c5c31d33 959 grep_commit_pattern_type(pattern_type_arg, &opt);
3e230fa1 960
ecd9ba61
TG
961 if (use_index && !startup_info->have_repository) {
962 int fallback = 0;
963 git_config_get_bool("grep.fallbacktonoindex", &fallback);
964 if (fallback)
965 use_index = 0;
966 else
967 /* die the same way as if we did it at the beginning */
968 setup_git_directory();
969 }
c56c48dd
PB
970 /* Ignore --recurse-submodules if --no-index is given or implied */
971 if (!use_index)
972 recurse_submodules = 0;
59332d13 973
1123c67c
JK
974 /*
975 * skip a -- separator; we know it cannot be
976 * separating revisions from pathnames if
977 * we haven't even had any patterns yet
978 */
979 if (argc > 0 && !opt.pattern_list && !strcmp(argv[0], "--")) {
980 argv++;
981 argc--;
982 }
983
3e230fa1
RS
984 /* First unrecognized non-option token */
985 if (argc > 0 && !opt.pattern_list) {
986 append_grep_pattern(&opt, argv[0], "command line", 0,
987 GREP_PATTERN);
988 argv++;
989 argc--;
5010cb5f 990 }
5acd64ed 991
0af88c15
JS
992 if (show_in_pager == default_pager)
993 show_in_pager = git_pager(1);
678e484b 994 if (show_in_pager) {
e7b082a4 995 opt.color = 0;
0af88c15
JS
996 opt.name_only = 1;
997 opt.null_following_name = 1;
998 opt.output_priv = &path_list;
999 opt.output = append_path;
0c72cead 1000 string_list_append(&path_list, show_in_pager);
678e484b
JS
1001 }
1002
f9b9faf6 1003 if (!opt.pattern_list)
1a07e59c 1004 die(_("no pattern given"));
5b594f45 1005
9d8db06e
TB
1006 /* --only-matching has no effect with --invert. */
1007 if (opt.invert)
1008 opt.only_matching = 0;
1009
b5b81136
JK
1010 /*
1011 * We have to find "--" in a separate pass, because its presence
1012 * influences how we will parse arguments that come before it.
1013 */
1014 for (i = 0; i < argc; i++) {
1015 if (!strcmp(argv[i], "--")) {
1016 seen_dashdash = 1;
1017 break;
1018 }
1019 }
1020
1021 /*
1022 * Resolve any rev arguments. If we have a dashdash, then everything up
1023 * to it must resolve as a rev. If not, then we stop at the first
1024 * non-rev and assume everything else is a path.
1025 */
131f3c96 1026 allow_revs = use_index && !untracked;
3e230fa1 1027 for (i = 0; i < argc; i++) {
5acd64ed 1028 const char *arg = argv[i];
1db11086 1029 struct object_id oid;
afa15f3c 1030 struct object_context oc;
20d6421c
JK
1031 struct object *object;
1032
dca3b5f5
JT
1033 if (!strcmp(arg, "--")) {
1034 i++;
dca3b5f5
JT
1035 break;
1036 }
20d6421c 1037
131f3c96 1038 if (!allow_revs) {
d0ffc069 1039 if (seen_dashdash)
131f3c96 1040 die(_("--no-index or --untracked cannot be used with revs"));
d0ffc069
JK
1041 break;
1042 }
1043
3a7a698e
NTND
1044 if (get_oid_with_context(the_repository, arg,
1045 GET_OID_RECORD_PATH,
e82caf38 1046 &oid, &oc)) {
b5b81136
JK
1047 if (seen_dashdash)
1048 die(_("unable to resolve revision: %s"), arg);
20d6421c 1049 break;
b5b81136 1050 }
20d6421c 1051
c251c83d 1052 object = parse_object_or_die(&oid, arg);
20d6421c
JK
1053 if (!seen_dashdash)
1054 verify_non_filename(prefix, arg);
1055 add_object_array_with_path(object, arg, &list, oc.mode, oc.path);
dc944b65 1056 free(oc.path);
1362671f 1057 }
5acd64ed 1058
b5b81136
JK
1059 /*
1060 * Anything left over is presumed to be a path. But in the non-dashdash
1061 * "do what I mean" case, we verify and complain when that isn't true.
1062 */
a0fe2b0d
JK
1063 if (!seen_dashdash) {
1064 int j;
1065 for (j = i; j < argc; j++)
131f3c96 1066 verify_filename(prefix, argv[j], j == i && allow_revs);
a0fe2b0d
JK
1067 }
1068
1069 parse_pathspec(&pathspec, 0,
1070 PATHSPEC_PREFER_CWD |
1071 (opt.max_depth != -1 ? PATHSPEC_MAXDEPTH_VALID : 0),
1072 prefix, argv + i);
1073 pathspec.max_depth = opt.max_depth;
1074 pathspec.recursive = 1;
eef3df5a 1075 pathspec.recurse_submodules = !!recurse_submodules;
a0fe2b0d 1076
56ceb64e
JH
1077 if (recurse_submodules && untracked)
1078 die(_("--untracked not supported with --recurse-submodules"));
c441ea4e 1079
1184a95e 1080 if (show_in_pager) {
fd6263fb
NTND
1081 if (num_threads > 1)
1082 warning(_("invalid option combination, ignoring --threads"));
1083 num_threads = 1;
1084 } else if (!HAVE_THREADS && num_threads > 1) {
d1edee4a 1085 warning(_("no threads support, ignoring --threads"));
fd6263fb
NTND
1086 num_threads = 1;
1087 } else if (num_threads < 0)
1088 die(_("invalid number of threads specified (%d)"), num_threads);
1089 else if (num_threads == 0)
f1928f04 1090 num_threads = HAVE_THREADS ? online_cpus() : 1;
53b8d931 1091
fd6263fb
NTND
1092 if (num_threads > 1) {
1093 if (!HAVE_THREADS)
1094 BUG("Somebody got num_threads calculation wrong!");
1095 if (!(opt.name_only || opt.unmatch_name_only || opt.count)
1096 && (opt.pre_context || opt.post_context ||
1097 opt.file_break || opt.funcbody))
1098 skip_first_line = 1;
c441ea4e
MT
1099
1100 /*
6c307626
MT
1101 * Pre-read gitmodules (if not read already) and force eager
1102 * initialization of packed_git to prevent racy lazy
1103 * reading/initialization once worker threads are started.
c441ea4e
MT
1104 */
1105 if (recurse_submodules)
1106 repo_read_gitmodules(the_repository, 1);
6c307626
MT
1107 if (startup_info->have_repository)
1108 (void)get_packed_git(the_repository);
c441ea4e 1109
fd6263fb 1110 start_threads(&opt);
4002e87c 1111 } else {
6d423dd5
ÆAB
1112 /*
1113 * The compiled patterns on the main path are only
1114 * used when not using threading. Otherwise
fd6263fb 1115 * start_threads() above calls compile_grep_patterns()
6d423dd5
ÆAB
1116 * for each thread.
1117 */
1118 compile_grep_patterns(&opt);
53b8d931 1119 }
53b8d931 1120
678e484b 1121 if (show_in_pager && (cached || list.nr))
e4fe4ba5 1122 die(_("--open-files-in-pager only works on the worktree"));
678e484b
JS
1123
1124 if (show_in_pager && opt.pattern_list && !opt.pattern_list->next) {
1125 const char *pager = path_list.items[0].string;
1126 int len = strlen(pager);
1127
1128 if (len > 4 && is_dir_sep(pager[len - 5]))
1129 pager += len - 4;
1130
f7febbea
JS
1131 if (opt.ignore_case && !strcmp("less", pager))
1132 string_list_append(&path_list, "-I");
1133
678e484b
JS
1134 if (!strcmp("less", pager) || !strcmp("vi", pager)) {
1135 struct strbuf buf = STRBUF_INIT;
1136 strbuf_addf(&buf, "+/%s%s",
1137 strcmp("less", pager) ? "" : "*",
1138 opt.pattern_list->pattern);
fd99c2dd
RS
1139 string_list_append(&path_list,
1140 strbuf_detach(&buf, NULL));
678e484b
JS
1141 }
1142 }
1143
c2048f0b 1144 if (!show_in_pager && !opt.status_only)
678e484b
JS
1145 setup_pager();
1146
0a93fb8a 1147 if (!use_index && (untracked || cached))
1a07e59c 1148 die(_("--cached or --untracked cannot be used with --no-index"));
678e484b 1149
0a93fb8a 1150 if (!use_index || untracked) {
0a93fb8a 1151 int use_exclude = (opt_exclude < 0) ? use_index : !!opt_exclude;
85975c0c 1152 hit = grep_directory(&opt, &pathspec, use_exclude, use_index);
dbfae86a 1153 } else if (0 <= opt_exclude) {
1a07e59c 1154 die(_("--[no-]exclude-standard cannot be used for tracked contents"));
685359cf 1155 } else if (!list.nr) {
6577f542
NTND
1156 if (!cached)
1157 setup_work_tree();
5b594f45 1158
dba093dd 1159 hit = grep_cache(&opt, &pathspec, cached);
685359cf
JS
1160 } else {
1161 if (cached)
1a07e59c 1162 die(_("both --cached and trees are given"));
f9ee2fcd 1163
6856077a 1164 hit = grep_objects(&opt, &pathspec, &list);
5010cb5f 1165 }
5b594f45 1166
fd6263fb 1167 if (num_threads > 1)
5b594f45 1168 hit |= wait_all();
678e484b
JS
1169 if (hit && show_in_pager)
1170 run_pager(&opt, prefix);
7861fa07 1171 clear_pathspec(&pathspec);
b48fb5b6 1172 free_grep_patterns(&opt);
513f2b0b 1173 grep_destroy();
5010cb5f
JH
1174 return !hit;
1175}