blob: 7d2f8e5adb69c428847bc23b81bf822c916ccdea [file] [log] [blame]
Junio C Hamano5010cb52006-04-30 23:28:15 -07001/*
2 * Builtin "git grep"
3 *
4 * Copyright (c) 2006 Junio C Hamano
5 */
Nguyễn Thái Ngọc Duyf8adbec2019-01-24 15:29:12 +07006#define USE_THE_INDEX_COMPATIBILITY_MACROS
Junio C Hamano5010cb52006-04-30 23:28:15 -07007#include "cache.h"
Brandon Williams627d9342017-06-22 11:43:46 -07008#include "repository.h"
Brandon Williamsb2141fc2017-06-14 11:07:36 -07009#include "config.h"
Junio C Hamano5010cb52006-04-30 23:28:15 -070010#include "blob.h"
11#include "tree.h"
12#include "commit.h"
13#include "tag.h"
Junio C Hamano13626712006-05-01 15:58:29 -070014#include "tree-walk.h"
Junio C Hamano5010cb52006-04-30 23:28:15 -070015#include "builtin.h"
René Scharfe3e230fa2009-05-07 21:46:48 +020016#include "parse-options.h"
Johannes Schindelin678e4842010-06-12 11:36:51 -050017#include "string-list.h"
18#include "run-command.h"
René Scharfe60ecac92009-07-02 00:07:24 +020019#include "userdiff.h"
Junio C Hamano83b5d2f2006-09-17 16:02:52 -070020#include "grep.h"
Clemens Buchacher493b7a02009-09-05 14:31:17 +020021#include "quote.h"
Junio C Hamano59332d12010-02-06 10:40:08 -080022#include "dir.h"
Nguyễn Thái Ngọc Duy64acde92013-07-14 15:35:25 +070023#include "pathspec.h"
Brandon Williams0281e482016-12-16 11:03:20 -080024#include "submodule.h"
Brandon Williams74ed4372016-12-16 11:03:21 -080025#include "submodule-config.h"
Stefan Beller90c62152018-03-23 18:20:55 +010026#include "object-store.h"
Matheus Tavares6c307622020-01-15 23:39:57 -030027#include "packfile.h"
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +010028
René Scharfe3e230fa2009-05-07 21:46:48 +020029static char const * const grep_usage[] = {
Alex Henrie9c9b4f22015-01-13 00:44:47 -070030 N_("git grep [<options>] [-e] <pattern> [<rev>...] [[--] <path>...]"),
René Scharfe3e230fa2009-05-07 21:46:48 +020031 NULL
32};
33
Brandon Williams0281e482016-12-16 11:03:20 -080034static int recurse_submodules;
Brandon Williams0281e482016-12-16 11:03:20 -080035
Victor Leschuk89f09dd2015-12-15 18:31:39 +030036static int num_threads;
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +010037
Victor Leschuk89f09dd2015-12-15 18:31:39 +030038static pthread_t *threads;
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +010039
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +010040/* 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 */
Jonathan Nieder9cba13c2011-03-16 02:08:34 -050044struct work_item {
Jeff King8f24a632012-02-02 03:19:37 -050045 struct grep_source source;
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +010046 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
Junio C Hamano1487a122011-10-26 11:45:15 -070071static inline void grep_lock(void)
72{
Ævar Arnfjörð Bjarmason8df4c292017-05-25 19:45:35 +000073 pthread_mutex_lock(&grep_mutex);
Junio C Hamano1487a122011-10-26 11:45:15 -070074}
75
76static inline void grep_unlock(void)
77{
Ævar Arnfjörð Bjarmason8df4c292017-05-25 19:45:35 +000078 pthread_mutex_unlock(&grep_mutex);
Junio C Hamano1487a122011-10-26 11:45:15 -070079}
80
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +010081/* 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
René Scharfe08303c32011-06-05 17:24:15 +020092static int skip_first_line;
René Scharfe431d6e72010-03-15 17:21:10 +010093
Matheus Tavares70a9fef2020-01-15 23:39:59 -030094static void add_work(struct grep_opt *opt, struct grep_source *gs)
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +010095{
Matheus Tavares70a9fef2020-01-15 23:39:59 -030096 if (opt->binary != GREP_BINARY_TEXT)
97 grep_source_load_driver(gs, opt->repo->index);
98
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +010099 grep_lock();
100
101 while ((todo_end+1) % ARRAY_SIZE(todo) == todo_done) {
102 pthread_cond_wait(&cond_write, &grep_mutex);
103 }
104
Rasmus Villemoese2e05d62018-02-23 15:47:56 +0100105 todo[todo_end].source = *gs;
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100106 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
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100133static 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];
René Scharfe431d6e72010-03-15 17:21:10 +0100143 if (w->out.len) {
René Scharfe08303c32011-06-05 17:24:15 +0200144 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);
René Scharfe431d6e72010-03-15 17:21:10 +0100158 }
Jeff King8f24a632012-02-02 03:19:37 -0500159 grep_source_clear(&w->source);
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100160 }
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;
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700182 hit |= grep_source(opt, &w->source);
Jeff King8f24a632012-02-02 03:19:37 -0500183 grep_source_clear_data(&w->source);
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100184 work_done(w);
185 }
Dan McGeebfac23d2010-01-30 09:42:58 -0600186 free_grep_patterns(arg);
187 free(arg);
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100188
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);
Thomas Rast0579f912011-12-12 22:16:07 +0100203 pthread_mutex_init(&grep_attr_mutex, NULL);
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100204 pthread_cond_init(&cond_add, NULL);
205 pthread_cond_init(&cond_write, NULL);
206 pthread_cond_init(&cond_result, NULL);
Jeff King78db6ea2012-02-02 03:18:29 -0500207 grep_use_locks = 1;
Matheus Tavares1d1729c2020-01-15 23:39:54 -0300208 enable_obj_read_lock();
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100209
210 for (i = 0; i < ARRAY_SIZE(todo); i++) {
211 strbuf_init(&todo[i].out, 0);
212 }
213
René Scharfeca56dad2021-03-13 17:17:22 +0100214 CALLOC_ARRAY(threads, num_threads);
Victor Leschuk89f09dd2015-12-15 18:31:39 +0300215 for (i = 0; i < num_threads; i++) {
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100216 int err;
217 struct grep_opt *o = grep_opt_dup(opt);
218 o->output = strbuf_out;
219 compile_grep_patterns(o);
220 err = pthread_create(&threads[i], NULL, run, o);
221
222 if (err)
Ævar Arnfjörð Bjarmason2fc5f9f2011-02-22 23:41:55 +0000223 die(_("grep: failed to create thread: %s"),
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100224 strerror(err));
225 }
226}
227
228static int wait_all(void)
229{
230 int hit = 0;
231 int i;
232
Nguyễn Thái Ngọc Duy4002e872018-11-03 09:48:43 +0100233 if (!HAVE_THREADS)
Nguyễn Thái Ngọc Duyfd6263f2018-11-03 09:48:44 +0100234 BUG("Never call this function unless you have started threads");
Nguyễn Thái Ngọc Duy4002e872018-11-03 09:48:43 +0100235
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100236 grep_lock();
237 all_work_added = 1;
238
239 /* Wait until all work is done. */
240 while (todo_done != todo_end)
241 pthread_cond_wait(&cond_result, &grep_mutex);
242
243 /* Wake up all the consumer threads so they can see that there
244 * is no more work to do.
245 */
246 pthread_cond_broadcast(&cond_add);
247 grep_unlock();
248
Victor Leschuk89f09dd2015-12-15 18:31:39 +0300249 for (i = 0; i < num_threads; i++) {
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100250 void *h;
251 pthread_join(threads[i], &h);
252 hit |= (int) (intptr_t) h;
253 }
254
Victor Leschuk89f09dd2015-12-15 18:31:39 +0300255 free(threads);
256
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100257 pthread_mutex_destroy(&grep_mutex);
Thomas Rast0579f912011-12-12 22:16:07 +0100258 pthread_mutex_destroy(&grep_attr_mutex);
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100259 pthread_cond_destroy(&cond_add);
260 pthread_cond_destroy(&cond_write);
261 pthread_cond_destroy(&cond_result);
Jeff King78db6ea2012-02-02 03:18:29 -0500262 grep_use_locks = 0;
Matheus Tavares1d1729c2020-01-15 23:39:54 -0300263 disable_obj_read_lock();
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100264
265 return hit;
266}
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100267
Junio C Hamano15fabd12012-10-09 16:04:12 -0700268static int grep_cmd_config(const char *var, const char *value, void *cb)
269{
270 int st = grep_config(var, value, cb);
Jeff King33c643b2017-10-13 13:24:31 -0400271 if (git_color_default_config(var, value, cb) < 0)
Junio C Hamano15fabd12012-10-09 16:04:12 -0700272 st = -1;
Victor Leschuk89f09dd2015-12-15 18:31:39 +0300273
274 if (!strcmp(var, "grep.threads")) {
275 num_threads = git_config_int(var, value);
276 if (num_threads < 0)
277 die(_("invalid number of threads specified (%d) for %s"),
278 num_threads, var);
Nguyễn Thái Ngọc Duyfd6263f2018-11-03 09:48:44 +0100279 else if (!HAVE_THREADS && num_threads > 1) {
Ævar Arnfjörð Bjarmasond1edee42017-05-25 19:45:34 +0000280 /*
281 * TRANSLATORS: %s is the configuration
282 * variable for tweaking threads, currently
283 * grep.threads
284 */
285 warning(_("no threads support, ignoring %s"), var);
Nguyễn Thái Ngọc Duyfd6263f2018-11-03 09:48:44 +0100286 num_threads = 1;
Ævar Arnfjörð Bjarmasond1edee42017-05-25 19:45:34 +0000287 }
Victor Leschuk89f09dd2015-12-15 18:31:39 +0300288 }
289
Stefan Beller9071c072017-05-31 17:30:48 -0700290 if (!strcmp(var, "submodule.recurse"))
291 recurse_submodules = git_config_bool(var, value);
292
Junio C Hamano15fabd12012-10-09 16:04:12 -0700293 return st;
294}
295
Matheus Tavares45115d82020-04-19 03:33:24 -0300296static void grep_source_name(struct grep_opt *opt, const char *filename,
297 int tree_name_len, struct strbuf *out)
298{
299 strbuf_reset(out);
300
301 if (opt->null_following_name) {
302 if (opt->relative && opt->prefix_length) {
303 struct strbuf rel_buf = STRBUF_INIT;
304 const char *rel_name =
305 relative_path(filename + tree_name_len,
306 opt->prefix, &rel_buf);
307
308 if (tree_name_len)
309 strbuf_add(out, filename, tree_name_len);
310
311 strbuf_addstr(out, rel_name);
312 strbuf_release(&rel_buf);
313 } else {
314 strbuf_addstr(out, filename);
315 }
316 return;
317 }
318
319 if (opt->relative && opt->prefix_length)
Junio C Hamano88910c92020-09-10 10:01:54 -0700320 quote_path(filename + tree_name_len, opt->prefix, out, 0);
Matheus Tavares45115d82020-04-19 03:33:24 -0300321 else
322 quote_c_style(filename + tree_name_len, out, NULL, 0);
323
324 if (tree_name_len)
325 strbuf_insert(out, 0, filename, tree_name_len);
326}
327
brian m. carlson1db11082017-02-21 23:47:25 +0000328static int grep_oid(struct grep_opt *opt, const struct object_id *oid,
Nguyễn Thái Ngọc Duy55c61682012-10-12 17:49:38 +0700329 const char *filename, int tree_name_len,
330 const char *path)
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100331{
332 struct strbuf pathbuf = STRBUF_INIT;
Rasmus Villemoese2e05d62018-02-23 15:47:56 +0100333 struct grep_source gs;
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100334
Matheus Tavares45115d82020-04-19 03:33:24 -0300335 grep_source_name(opt, filename, tree_name_len, &pathbuf);
Rasmus Villemoese2e05d62018-02-23 15:47:56 +0100336 grep_source_init(&gs, GREP_SOURCE_OID, pathbuf.buf, path, oid);
Rasmus Villemoes38ef24d2018-02-23 15:47:57 +0100337 strbuf_release(&pathbuf);
Rasmus Villemoese2e05d62018-02-23 15:47:56 +0100338
Nguyễn Thái Ngọc Duyfd6263f2018-11-03 09:48:44 +0100339 if (num_threads > 1) {
Rasmus Villemoese2e05d62018-02-23 15:47:56 +0100340 /*
341 * add_work() copies gs and thus assumes ownership of
342 * its fields, so do not call grep_source_clear()
343 */
344 add_work(opt, &gs);
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100345 return 0;
Nguyễn Thái Ngọc Duy4002e872018-11-03 09:48:43 +0100346 } else {
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100347 int hit;
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100348
Jeff King8f24a632012-02-02 03:19:37 -0500349 hit = grep_source(opt, &gs);
350
351 grep_source_clear(&gs);
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100352 return hit;
353 }
354}
355
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100356static int grep_file(struct grep_opt *opt, const char *filename)
357{
358 struct strbuf buf = STRBUF_INIT;
Rasmus Villemoese2e05d62018-02-23 15:47:56 +0100359 struct grep_source gs;
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100360
Matheus Tavares45115d82020-04-19 03:33:24 -0300361 grep_source_name(opt, filename, 0, &buf);
Rasmus Villemoese2e05d62018-02-23 15:47:56 +0100362 grep_source_init(&gs, GREP_SOURCE_FILE, buf.buf, filename, filename);
Rasmus Villemoes38ef24d2018-02-23 15:47:57 +0100363 strbuf_release(&buf);
Rasmus Villemoese2e05d62018-02-23 15:47:56 +0100364
Nguyễn Thái Ngọc Duyfd6263f2018-11-03 09:48:44 +0100365 if (num_threads > 1) {
Rasmus Villemoese2e05d62018-02-23 15:47:56 +0100366 /*
367 * add_work() copies gs and thus assumes ownership of
368 * its fields, so do not call grep_source_clear()
369 */
370 add_work(opt, &gs);
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100371 return 0;
Nguyễn Thái Ngọc Duy4002e872018-11-03 09:48:43 +0100372 } else {
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100373 int hit;
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100374
Jeff King8f24a632012-02-02 03:19:37 -0500375 hit = grep_source(opt, &gs);
376
377 grep_source_clear(&gs);
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +0100378 return hit;
379 }
Junio C Hamano5010cb52006-04-30 23:28:15 -0700380}
381
Johannes Schindelin678e4842010-06-12 11:36:51 -0500382static void append_path(struct grep_opt *opt, const void *data, size_t len)
383{
384 struct string_list *path_list = opt->output_priv;
385
386 if (len == 1 && *(const char *)data == '\0')
387 return;
Julian Phillips0c72cea2010-06-26 00:41:39 +0100388 string_list_append(path_list, xstrndup(data, len));
Johannes Schindelin678e4842010-06-12 11:36:51 -0500389}
390
391static void run_pager(struct grep_opt *opt, const char *prefix)
392{
393 struct string_list *path_list = opt->output_priv;
Jeff King850d2fe2016-02-22 17:44:21 -0500394 struct child_process child = CHILD_PROCESS_INIT;
Johannes Schindelin678e4842010-06-12 11:36:51 -0500395 int i, status;
396
397 for (i = 0; i < path_list->nr; i++)
Jeff King22f9b7f2020-07-28 16:24:27 -0400398 strvec_push(&child.args, path_list->items[i].string);
Jeff King850d2fe2016-02-22 17:44:21 -0500399 child.dir = prefix;
400 child.use_shell = 1;
Johannes Schindelin678e4842010-06-12 11:36:51 -0500401
Jeff King850d2fe2016-02-22 17:44:21 -0500402 status = run_command(&child);
Johannes Schindelin678e4842010-06-12 11:36:51 -0500403 if (status)
404 exit(status);
Johannes Schindelin678e4842010-06-12 11:36:51 -0500405}
406
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700407static int grep_cache(struct grep_opt *opt,
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700408 const struct pathspec *pathspec, int cached);
409static int grep_tree(struct grep_opt *opt, const struct pathspec *pathspec,
410 struct tree_desc *tree, struct strbuf *base, int tn_len,
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700411 int check_attr);
Brandon Williams0281e482016-12-16 11:03:20 -0800412
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700413static int grep_submodule(struct grep_opt *opt,
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700414 const struct pathspec *pathspec,
415 const struct object_id *oid,
Matheus Tavares6a289d42019-07-30 13:53:27 -0300416 const char *filename, const char *path, int cached)
Brandon Williams0281e482016-12-16 11:03:20 -0800417{
Stefan Bellerd5498e02018-11-28 16:27:53 -0800418 struct repository subrepo;
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700419 struct repository *superproject = opt->repo;
Matheus Tavaresfaf123c2020-01-15 23:39:50 -0300420 const struct submodule *sub;
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700421 struct grep_opt subopt;
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700422 int hit;
Brandon Williamse6fac7f2016-12-16 11:03:22 -0800423
brian m. carlson14228442021-04-26 01:02:56 +0000424 sub = submodule_from_path(superproject, null_oid(), path);
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700425
Matheus Tavaresc441ea42020-01-15 23:39:56 -0300426 if (!is_submodule_active(superproject, path))
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700427 return 0;
Antonio Ospite76e9bdc2018-10-25 18:18:12 +0200428
Matheus Tavaresc441ea42020-01-15 23:39:56 -0300429 if (repo_submodule_init(&subrepo, superproject, sub))
Antonio Ospite76e9bdc2018-10-25 18:18:12 +0200430 return 0;
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700431
Brandon Williams0281e482016-12-16 11:03:20 -0800432 /*
Matheus Tavaresc441ea42020-01-15 23:39:56 -0300433 * NEEDSWORK: repo_read_gitmodules() might call
434 * add_to_alternates_memory() via config_from_gitmodules(). This
435 * operation causes a race condition with concurrent object readings
436 * performed by the worker threads. That's why we need obj_read_lock()
437 * here. It should be removed once it's no longer necessary to add the
438 * subrepo's odbs to the in-memory alternates list.
Brandon Williamse6fac7f2016-12-16 11:03:22 -0800439 */
Matheus Tavaresc441ea42020-01-15 23:39:56 -0300440 obj_read_lock();
Matheus Tavaresd7992422020-01-15 23:39:55 -0300441 repo_read_gitmodules(&subrepo, 0);
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700442
443 /*
444 * NEEDSWORK: This adds the submodule's object directory to the list of
445 * alternates for the single in-memory object store. This has some bad
446 * consequences for memory (processed objects will never be freed) and
447 * performance (this increases the number of pack files git has to pay
448 * attention to, to the sum of the number of pack files in all the
449 * repositories processed so far). This can be removed once the object
450 * store is no longer global and instead is a member of the repository
451 * object.
452 */
Junio C Hamano5d3635d2019-01-29 12:47:54 -0800453 add_to_alternates_memory(subrepo.objects->odb->path);
Matheus Tavares1d1729c2020-01-15 23:39:54 -0300454 obj_read_unlock();
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700455
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700456 memcpy(&subopt, opt, sizeof(subopt));
Junio C Hamano7589e632019-02-06 22:05:22 -0800457 subopt.repo = &subrepo;
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700458
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700459 if (oid) {
460 struct object *object;
461 struct tree_desc tree;
462 void *data;
463 unsigned long size;
464 struct strbuf base = STRBUF_INIT;
465
Matheus Tavares1d1729c2020-01-15 23:39:54 -0300466 obj_read_lock();
René Scharfe98c68712020-07-28 23:40:38 +0200467 object = parse_object_or_die(oid, NULL);
Matheus Tavares1d1729c2020-01-15 23:39:54 -0300468 obj_read_unlock();
Nguyễn Thái Ngọc Duyd3b47052019-06-27 16:28:47 +0700469 data = read_object_with_reference(&subrepo,
470 &object->oid, tree_type,
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700471 &size, NULL);
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700472 if (!data)
473 die(_("unable to read tree (%s)"), oid_to_hex(&object->oid));
474
475 strbuf_addstr(&base, filename);
476 strbuf_addch(&base, '/');
477
478 init_tree_desc(&tree, data, size);
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700479 hit = grep_tree(&subopt, pathspec, &tree, &base, base.len,
480 object->type == OBJ_COMMIT);
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700481 strbuf_release(&base);
482 free(data);
483 } else {
Matheus Tavares6a289d42019-07-30 13:53:27 -0300484 hit = grep_cache(&subopt, pathspec, cached);
Brandon Williamse6fac7f2016-12-16 11:03:22 -0800485 }
Brandon Williams0281e482016-12-16 11:03:20 -0800486
Stefan Bellerd5498e02018-11-28 16:27:53 -0800487 repo_clear(&subrepo);
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700488 return hit;
Brandon Williams0281e482016-12-16 11:03:20 -0800489}
490
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700491static int grep_cache(struct grep_opt *opt,
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700492 const struct pathspec *pathspec, int cached)
Junio C Hamano5010cb52006-04-30 23:28:15 -0700493{
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700494 struct repository *repo = opt->repo;
Junio C Hamano5010cb52006-04-30 23:28:15 -0700495 int hit = 0;
496 int nr;
Brandon Williams0281e482016-12-16 11:03:20 -0800497 struct strbuf name = STRBUF_INIT;
498 int name_base_len = 0;
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700499 if (repo->submodule_prefix) {
500 name_base_len = strlen(repo->submodule_prefix);
501 strbuf_addstr(&name, repo->submodule_prefix);
Brandon Williams0281e482016-12-16 11:03:20 -0800502 }
503
Stefan Bellerb2aa84c2018-05-14 18:04:25 -0700504 if (repo_read_index(repo) < 0)
Nguyễn Thái Ngọc Duy55070672018-07-21 09:49:23 +0200505 die(_("index file corrupt"));
Junio C Hamano5010cb52006-04-30 23:28:15 -0700506
Derrick Stolee46eb6e32021-04-01 01:49:48 +0000507 /* TODO: audit for interaction with sparse-index. */
508 ensure_full_index(repo->index);
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700509 for (nr = 0; nr < repo->index->cache_nr; nr++) {
510 const struct cache_entry *ce = repo->index->cache[nr];
Matheus Tavares42d906b2021-02-09 18:33:30 -0300511
512 if (!cached && ce_skip_worktree(ce))
513 continue;
514
Brandon Williams0281e482016-12-16 11:03:20 -0800515 strbuf_setlen(&name, name_base_len);
516 strbuf_addstr(&name, ce->name);
517
518 if (S_ISREG(ce->ce_mode) &&
Nguyễn Thái Ngọc Duya4009b02018-08-13 18:14:34 +0200519 match_pathspec(repo->index, pathspec, name.buf, name.len, 0, NULL,
Brandon Williams0281e482016-12-16 11:03:20 -0800520 S_ISDIR(ce->ce_mode) ||
521 S_ISGITLINK(ce->ce_mode))) {
522 /*
523 * If CE_VALID is on, we assume worktree file and its
524 * cache entry are identical, even if worktree file has
525 * been modified, so use cache version instead
526 */
Matheus Tavares42d906b2021-02-09 18:33:30 -0300527 if (cached || (ce->ce_flags & CE_VALID)) {
Brandon Williams0281e482016-12-16 11:03:20 -0800528 if (ce_stage(ce) || ce_intent_to_add(ce))
529 continue;
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700530 hit |= grep_oid(opt, &ce->oid, name.buf,
531 0, name.buf);
Brandon Williams0281e482016-12-16 11:03:20 -0800532 } else {
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700533 hit |= grep_file(opt, name.buf);
Brandon Williams0281e482016-12-16 11:03:20 -0800534 }
535 } else if (recurse_submodules && S_ISGITLINK(ce->ce_mode) &&
Nguyễn Thái Ngọc Duya4009b02018-08-13 18:14:34 +0200536 submodule_path_match(repo->index, pathspec, name.buf, NULL)) {
Matheus Tavares6a289d42019-07-30 13:53:27 -0300537 hit |= grep_submodule(opt, pathspec, NULL, ce->name,
538 ce->name, cached);
Brandon Williams0281e482016-12-16 11:03:20 -0800539 } else {
Junio C Hamano5010cb52006-04-30 23:28:15 -0700540 continue;
Junio C Hamano36f25872006-11-26 12:47:52 -0800541 }
Brandon Williams0281e482016-12-16 11:03:20 -0800542
Junio C Hamano36f25872006-11-26 12:47:52 -0800543 if (ce_stage(ce)) {
544 do {
545 nr++;
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700546 } while (nr < repo->index->cache_nr &&
547 !strcmp(ce->name, repo->index->cache[nr]->name));
Junio C Hamano36f25872006-11-26 12:47:52 -0800548 nr--; /* compensate for loop control */
549 }
Junio C Hamanoc8610a22010-01-25 15:37:23 -0800550 if (hit && opt->status_only)
551 break;
Junio C Hamano5010cb52006-04-30 23:28:15 -0700552 }
Brandon Williams0281e482016-12-16 11:03:20 -0800553
554 strbuf_release(&name);
Junio C Hamano5010cb52006-04-30 23:28:15 -0700555 return hit;
556}
557
Nguyễn Thái Ngọc Duyf34bbc12010-12-15 22:02:51 +0700558static int grep_tree(struct grep_opt *opt, const struct pathspec *pathspec,
Nguyễn Thái Ngọc Duy55c61682012-10-12 17:49:38 +0700559 struct tree_desc *tree, struct strbuf *base, int tn_len,
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700560 int check_attr)
Junio C Hamano5010cb52006-04-30 23:28:15 -0700561{
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700562 struct repository *repo = opt->repo;
Nguyễn Thái Ngọc Duyd688cf02011-10-24 17:36:10 +1100563 int hit = 0;
564 enum interesting match = entry_not_interesting;
Linus Torvalds4c068a92006-05-30 09:45:45 -0700565 struct name_entry entry;
Nguyễn Thái Ngọc Duye5e062b2010-12-17 19:44:25 +0700566 int old_baselen = base->len;
Brandon Williams74ed4372016-12-16 11:03:21 -0800567 struct strbuf name = STRBUF_INIT;
568 int name_base_len = 0;
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -0700569 if (repo->submodule_prefix) {
570 strbuf_addstr(&name, repo->submodule_prefix);
Brandon Williams74ed4372016-12-16 11:03:21 -0800571 name_base_len = name.len;
572 }
Junio C Hamano5010cb52006-04-30 23:28:15 -0700573
Linus Torvalds4c068a92006-05-30 09:45:45 -0700574 while (tree_entry(tree, &entry)) {
Nguyễn Thái Ngọc Duy0de16332011-10-24 17:36:09 +1100575 int te_len = tree_entry_len(&entry);
Nguyễn Thái Ngọc Duye5e062b2010-12-17 19:44:25 +0700576
Nguyễn Thái Ngọc Duyd688cf02011-10-24 17:36:10 +1100577 if (match != all_entries_interesting) {
Brandon Williams74ed4372016-12-16 11:03:21 -0800578 strbuf_addstr(&name, base->buf + tn_len);
Nguyễn Thái Ngọc Duy67022e02018-11-18 17:47:57 +0100579 match = tree_entry_interesting(repo->index,
580 &entry, &name,
Brandon Williams74ed4372016-12-16 11:03:21 -0800581 0, pathspec);
582 strbuf_setlen(&name, name_base_len);
583
Nguyễn Thái Ngọc Duyd688cf02011-10-24 17:36:10 +1100584 if (match == all_entries_not_interesting)
Nguyễn Thái Ngọc Duy97d0b742011-03-25 16:34:20 +0700585 break;
Nguyễn Thái Ngọc Duyd688cf02011-10-24 17:36:10 +1100586 if (match == entry_not_interesting)
Nguyễn Thái Ngọc Duy1376e502010-12-17 19:45:33 +0700587 continue;
588 }
589
Nguyễn Thái Ngọc Duye5e062b2010-12-17 19:44:25 +0700590 strbuf_add(base, entry.path, te_len);
Junio C Hamano5010cb52006-04-30 23:28:15 -0700591
Nguyễn Thái Ngọc Duy1376e502010-12-17 19:45:33 +0700592 if (S_ISREG(entry.mode)) {
brian m. carlsonea82b2a2019-01-15 00:39:44 +0000593 hit |= grep_oid(opt, &entry.oid, base->buf, tn_len,
Nguyễn Thái Ngọc Duy55c61682012-10-12 17:49:38 +0700594 check_attr ? base->buf + tn_len : NULL);
Brandon Williams74ed4372016-12-16 11:03:21 -0800595 } else if (S_ISDIR(entry.mode)) {
Nicolas Pitre21666f12007-02-26 14:55:59 -0500596 enum object_type type;
Junio C Hamano5010cb52006-04-30 23:28:15 -0700597 struct tree_desc sub;
598 void *data;
Linus Torvalds6fda5e52007-03-21 10:08:25 -0700599 unsigned long size;
600
Matheus Tavares1d1729c2020-01-15 23:39:54 -0300601 data = read_object_file(&entry.oid, &type, &size);
Junio C Hamano5010cb52006-04-30 23:28:15 -0700602 if (!data)
Ævar Arnfjörð Bjarmason2fc5f9f2011-02-22 23:41:55 +0000603 die(_("unable to read tree (%s)"),
brian m. carlsonea82b2a2019-01-15 00:39:44 +0000604 oid_to_hex(&entry.oid));
Nguyễn Thái Ngọc Duy1376e502010-12-17 19:45:33 +0700605
606 strbuf_addch(base, '/');
Linus Torvalds6fda5e52007-03-21 10:08:25 -0700607 init_tree_desc(&sub, data, size);
Nguyễn Thái Ngọc Duy55c61682012-10-12 17:49:38 +0700608 hit |= grep_tree(opt, pathspec, &sub, base, tn_len,
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700609 check_attr);
Junio C Hamano5010cb52006-04-30 23:28:15 -0700610 free(data);
Brandon Williams74ed4372016-12-16 11:03:21 -0800611 } else if (recurse_submodules && S_ISGITLINK(entry.mode)) {
Junio C Hamano7589e632019-02-06 22:05:22 -0800612 hit |= grep_submodule(opt, pathspec, &entry.oid,
Matheus Tavares6a289d42019-07-30 13:53:27 -0300613 base->buf, base->buf + tn_len,
614 1); /* ignored */
Junio C Hamano5010cb52006-04-30 23:28:15 -0700615 }
Brandon Williams74ed4372016-12-16 11:03:21 -0800616
Nguyễn Thái Ngọc Duye5e062b2010-12-17 19:44:25 +0700617 strbuf_setlen(base, old_baselen);
618
Junio C Hamanoc8610a22010-01-25 15:37:23 -0800619 if (hit && opt->status_only)
620 break;
Junio C Hamano5010cb52006-04-30 23:28:15 -0700621 }
Brandon Williams74ed4372016-12-16 11:03:21 -0800622
623 strbuf_release(&name);
Junio C Hamano5010cb52006-04-30 23:28:15 -0700624 return hit;
625}
626
Nguyễn Thái Ngọc Duyf34bbc12010-12-15 22:02:51 +0700627static int grep_object(struct grep_opt *opt, const struct pathspec *pathspec,
Jonathan Tan68560772018-03-28 15:35:27 -0700628 struct object *obj, const char *name, const char *path)
Junio C Hamano5010cb52006-04-30 23:28:15 -0700629{
Linus Torvalds19746322006-07-11 20:45:31 -0700630 if (obj->type == OBJ_BLOB)
brian m. carlson1db11082017-02-21 23:47:25 +0000631 return grep_oid(opt, &obj->oid, name, 0, path);
Linus Torvalds19746322006-07-11 20:45:31 -0700632 if (obj->type == OBJ_COMMIT || obj->type == OBJ_TREE) {
Junio C Hamano5010cb52006-04-30 23:28:15 -0700633 struct tree_desc tree;
634 void *data;
Linus Torvalds6fda5e52007-03-21 10:08:25 -0700635 unsigned long size;
Nguyễn Thái Ngọc Duye5e062b2010-12-17 19:44:25 +0700636 struct strbuf base;
637 int hit, len;
638
Nguyễn Thái Ngọc Duyd3b47052019-06-27 16:28:47 +0700639 data = read_object_with_reference(opt->repo,
640 &obj->oid, tree_type,
Linus Torvalds6fda5e52007-03-21 10:08:25 -0700641 &size, NULL);
Junio C Hamano5010cb52006-04-30 23:28:15 -0700642 if (!data)
brian m. carlsonf2fd0762015-11-10 02:22:28 +0000643 die(_("unable to read tree (%s)"), oid_to_hex(&obj->oid));
Nguyễn Thái Ngọc Duye5e062b2010-12-17 19:44:25 +0700644
645 len = name ? strlen(name) : 0;
646 strbuf_init(&base, PATH_MAX + len + 1);
647 if (len) {
648 strbuf_add(&base, name, len);
649 strbuf_addch(&base, ':');
650 }
Linus Torvalds6fda5e52007-03-21 10:08:25 -0700651 init_tree_desc(&tree, data, size);
Nguyễn Thái Ngọc Duy55c61682012-10-12 17:49:38 +0700652 hit = grep_tree(opt, pathspec, &tree, &base, base.len,
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700653 obj->type == OBJ_COMMIT);
Nguyễn Thái Ngọc Duye5e062b2010-12-17 19:44:25 +0700654 strbuf_release(&base);
Junio C Hamano5010cb52006-04-30 23:28:15 -0700655 free(data);
656 return hit;
657 }
Brandon Williamsdebca9d2018-02-14 10:59:24 -0800658 die(_("unable to grep from object of type %s"), type_name(obj->type));
Junio C Hamano5010cb52006-04-30 23:28:15 -0700659}
660
Nguyễn Thái Ngọc Duyf34bbc12010-12-15 22:02:51 +0700661static int grep_objects(struct grep_opt *opt, const struct pathspec *pathspec,
Jonathan Nieder30d00c32010-06-12 11:31:18 -0500662 const struct object_array *list)
663{
664 unsigned int i;
665 int hit = 0;
666 const unsigned int nr = list->nr;
667
668 for (i = 0; i < nr; i++) {
669 struct object *real_obj;
Matheus Tavaresd5b0bac2020-01-15 23:39:51 -0300670
Matheus Tavares1d1729c2020-01-15 23:39:54 -0300671 obj_read_lock();
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700672 real_obj = deref_tag(opt->repo, list->objects[i].item,
Stefan Bellera74093d2018-06-28 18:22:05 -0700673 NULL, 0);
Matheus Tavares1d1729c2020-01-15 23:39:54 -0300674 obj_read_unlock();
Brandon Williams74ed4372016-12-16 11:03:21 -0800675
René Scharfee30b1522020-10-11 18:03:28 +0200676 if (!real_obj) {
677 char hex[GIT_MAX_HEXSZ + 1];
678 const char *name = list->objects[i].name;
679
680 if (!name) {
681 oid_to_hex_r(hex, &list->objects[i].item->oid);
682 name = hex;
683 }
684 die(_("invalid object '%s' given."), name);
685 }
686
Brandon Williams74ed4372016-12-16 11:03:21 -0800687 /* load the gitmodules file for this rev */
688 if (recurse_submodules) {
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700689 submodule_free(opt->repo);
Matheus Tavares1d1729c2020-01-15 23:39:54 -0300690 obj_read_lock();
brian m. carlsoncd73de42017-07-13 23:49:20 +0000691 gitmodules_config_oid(&real_obj->oid);
Matheus Tavares1d1729c2020-01-15 23:39:54 -0300692 obj_read_unlock();
Brandon Williams74ed4372016-12-16 11:03:21 -0800693 }
Jonathan Tan68560772018-03-28 15:35:27 -0700694 if (grep_object(opt, pathspec, real_obj, list->objects[i].name,
695 list->objects[i].path)) {
Jonathan Nieder30d00c32010-06-12 11:31:18 -0500696 hit = 1;
697 if (opt->status_only)
698 break;
699 }
700 }
701 return hit;
702}
703
Junio C Hamanodbfae862011-10-04 18:40:41 -0700704static int grep_directory(struct grep_opt *opt, const struct pathspec *pathspec,
Jeff King85975c02016-03-07 10:51:21 -0500705 int exc_std, int use_index)
Junio C Hamano59332d12010-02-06 10:40:08 -0800706{
Ævar Arnfjörð Bjarmasonce93a4c2021-07-01 12:51:27 +0200707 struct dir_struct dir = DIR_INIT;
Junio C Hamano59332d12010-02-06 10:40:08 -0800708 int i, hit = 0;
709
Jeff King85975c02016-03-07 10:51:21 -0500710 if (!use_index)
711 dir.flags |= DIR_NO_GITLINKS;
Junio C Hamano0a93fb82011-09-27 13:43:12 -0700712 if (exc_std)
713 setup_standard_excludes(&dir);
Junio C Hamano59332d12010-02-06 10:40:08 -0800714
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +0700715 fill_directory(&dir, opt->repo->index, pathspec);
Junio C Hamano59332d12010-02-06 10:40:08 -0800716 for (i = 0; i < dir.nr; i++) {
717 hit |= grep_file(opt, dir.entries[i]->name);
718 if (hit && opt->status_only)
719 break;
720 }
Elijah Newreneceba532020-08-18 22:58:26 +0000721 dir_clear(&dir);
Junio C Hamano59332d12010-02-06 10:40:08 -0800722 return hit;
723}
724
René Scharfeff3c7f92009-05-21 00:05:22 +0200725static int context_callback(const struct option *opt, const char *arg,
726 int unset)
René Scharfe3e230fa2009-05-07 21:46:48 +0200727{
728 struct grep_opt *grep_opt = opt->value;
729 int value;
730 const char *endp;
Junio C Hamano5010cb52006-04-30 23:28:15 -0700731
René Scharfe3e230fa2009-05-07 21:46:48 +0200732 if (unset) {
733 grep_opt->pre_context = grep_opt->post_context = 0;
734 return 0;
735 }
736 value = strtol(arg, (char **)&endp, 10);
737 if (*endp) {
Ævar Arnfjörð Bjarmason2fc5f9f2011-02-22 23:41:55 +0000738 return error(_("switch `%c' expects a numerical value"),
René Scharfe3e230fa2009-05-07 21:46:48 +0200739 opt->short_name);
740 }
741 grep_opt->pre_context = grep_opt->post_context = value;
742 return 0;
743}
744
René Scharfeff3c7f92009-05-21 00:05:22 +0200745static int file_callback(const struct option *opt, const char *arg, int unset)
René Scharfe3e230fa2009-05-07 21:46:48 +0200746{
747 struct grep_opt *grep_opt = opt->value;
Jeff King517fe802018-11-05 01:45:42 -0500748 int from_stdin;
René Scharfe3e230fa2009-05-07 21:46:48 +0200749 FILE *patterns;
750 int lno = 0;
Matt Kraaicfe370c2009-10-16 07:13:25 -0700751 struct strbuf sb = STRBUF_INIT;
René Scharfe3e230fa2009-05-07 21:46:48 +0200752
Jeff King517fe802018-11-05 01:45:42 -0500753 BUG_ON_OPT_NEG(unset);
754
755 from_stdin = !strcmp(arg, "-");
René Scharfec41dd2f2011-03-19 19:33:15 +0100756 patterns = from_stdin ? stdin : fopen(arg, "r");
René Scharfe3e230fa2009-05-07 21:46:48 +0200757 if (!patterns)
Ævar Arnfjörð Bjarmason2fc5f9f2011-02-22 23:41:55 +0000758 die_errno(_("cannot open '%s'"), arg);
Junio C Hamanoa5518432015-10-28 13:53:47 -0700759 while (strbuf_getline(&sb, patterns) == 0) {
René Scharfe3e230fa2009-05-07 21:46:48 +0200760 /* ignore empty line like grep does */
761 if (sb.len == 0)
762 continue;
René Scharfeed40a092010-05-22 23:43:43 +0200763
René Scharfeec830612012-05-21 18:10:09 +0200764 append_grep_pat(grep_opt, sb.buf, sb.len, arg, ++lno,
765 GREP_PATTERN);
René Scharfe3e230fa2009-05-07 21:46:48 +0200766 }
René Scharfec41dd2f2011-03-19 19:33:15 +0100767 if (!from_stdin)
768 fclose(patterns);
René Scharfe3e230fa2009-05-07 21:46:48 +0200769 strbuf_release(&sb);
770 return 0;
771}
772
René Scharfeff3c7f92009-05-21 00:05:22 +0200773static int not_callback(const struct option *opt, const char *arg, int unset)
René Scharfe3e230fa2009-05-07 21:46:48 +0200774{
775 struct grep_opt *grep_opt = opt->value;
Jeff King517fe802018-11-05 01:45:42 -0500776 BUG_ON_OPT_NEG(unset);
777 BUG_ON_OPT_ARG(arg);
René Scharfe3e230fa2009-05-07 21:46:48 +0200778 append_grep_pattern(grep_opt, "--not", "command line", 0, GREP_NOT);
779 return 0;
780}
781
René Scharfeff3c7f92009-05-21 00:05:22 +0200782static int and_callback(const struct option *opt, const char *arg, int unset)
René Scharfe3e230fa2009-05-07 21:46:48 +0200783{
784 struct grep_opt *grep_opt = opt->value;
Jeff King517fe802018-11-05 01:45:42 -0500785 BUG_ON_OPT_NEG(unset);
786 BUG_ON_OPT_ARG(arg);
René Scharfe3e230fa2009-05-07 21:46:48 +0200787 append_grep_pattern(grep_opt, "--and", "command line", 0, GREP_AND);
788 return 0;
789}
790
René Scharfeff3c7f92009-05-21 00:05:22 +0200791static int open_callback(const struct option *opt, const char *arg, int unset)
René Scharfe3e230fa2009-05-07 21:46:48 +0200792{
793 struct grep_opt *grep_opt = opt->value;
Jeff King517fe802018-11-05 01:45:42 -0500794 BUG_ON_OPT_NEG(unset);
795 BUG_ON_OPT_ARG(arg);
René Scharfe3e230fa2009-05-07 21:46:48 +0200796 append_grep_pattern(grep_opt, "(", "command line", 0, GREP_OPEN_PAREN);
797 return 0;
798}
799
René Scharfeff3c7f92009-05-21 00:05:22 +0200800static int close_callback(const struct option *opt, const char *arg, int unset)
René Scharfe3e230fa2009-05-07 21:46:48 +0200801{
802 struct grep_opt *grep_opt = opt->value;
Jeff King517fe802018-11-05 01:45:42 -0500803 BUG_ON_OPT_NEG(unset);
804 BUG_ON_OPT_ARG(arg);
René Scharfe3e230fa2009-05-07 21:46:48 +0200805 append_grep_pattern(grep_opt, ")", "command line", 0, GREP_CLOSE_PAREN);
806 return 0;
807}
808
René Scharfeff3c7f92009-05-21 00:05:22 +0200809static int pattern_callback(const struct option *opt, const char *arg,
810 int unset)
René Scharfe3e230fa2009-05-07 21:46:48 +0200811{
812 struct grep_opt *grep_opt = opt->value;
Jeff King517fe802018-11-05 01:45:42 -0500813 BUG_ON_OPT_NEG(unset);
René Scharfe3e230fa2009-05-07 21:46:48 +0200814 append_grep_pattern(grep_opt, arg, "-e option", 0, GREP_PATTERN);
815 return 0;
816}
817
Linus Torvaldsa633fca2006-07-28 22:44:25 -0700818int cmd_grep(int argc, const char **argv, const char *prefix)
Junio C Hamano5010cb52006-04-30 23:28:15 -0700819{
Junio C Hamano5010cb52006-04-30 23:28:15 -0700820 int hit = 0;
Junio C Hamano0a93fb82011-09-27 13:43:12 -0700821 int cached = 0, untracked = 0, opt_exclude = -1;
Junio C Hamano5acd64e2006-05-08 23:55:47 -0700822 int seen_dashdash = 0;
Junio C Hamanobbc09c22010-01-12 19:06:41 -0800823 int external_grep_allowed__ignored;
Johannes Schindelin0af88c12010-06-12 11:39:46 -0500824 const char *show_in_pager = NULL, *default_pager = "dummy";
Junio C Hamano5010cb52006-04-30 23:28:15 -0700825 struct grep_opt opt;
Thiago Farina3cd47452010-08-28 23:04:17 -0300826 struct object_array list = OBJECT_ARRAY_INIT;
Nguyễn Thái Ngọc Duyf34bbc12010-12-15 22:02:51 +0700827 struct pathspec pathspec;
Thiago Farina183113a2010-07-04 16:46:19 -0300828 struct string_list path_list = STRING_LIST_INIT_NODUP;
Junio C Hamano5acd64e2006-05-08 23:55:47 -0700829 int i;
René Scharfe3e230fa2009-05-07 21:46:48 +0200830 int dummy;
Nguyễn Thái Ngọc Duyff38d1a2010-08-05 22:06:39 -0500831 int use_index = 1;
J Smith84befcd2012-08-03 10:53:50 -0400832 int pattern_type_arg = GREP_PATTERN_TYPE_UNSPECIFIED;
Jeff King131f3c92017-02-14 16:54:36 -0500833 int allow_revs;
Junio C Hamanocca2c172011-05-09 18:48:36 -0700834
René Scharfe3e230fa2009-05-07 21:46:48 +0200835 struct option options[] = {
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200836 OPT_BOOL(0, "cached", &cached,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700837 N_("search in index instead of in the work tree")),
René Scharfecbb08c22012-02-28 20:06:09 +0100838 OPT_NEGBIT(0, "no-index", &use_index,
Nguyễn Thái Ngọc Duyf63cf8c2012-08-20 19:32:55 +0700839 N_("find in contents not managed by git"), 1),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200840 OPT_BOOL(0, "untracked", &untracked,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700841 N_("search in both tracked and untracked files")),
Junio C Hamano0a93fb82011-09-27 13:43:12 -0700842 OPT_SET_INT(0, "exclude-standard", &opt_exclude,
Nguyễn Thái Ngọc Duy77fdb8a2015-02-27 21:01:58 +0700843 N_("ignore files specified via '.gitignore'"), 1),
Brandon Williams0281e482016-12-16 11:03:20 -0800844 OPT_BOOL(0, "recurse-submodules", &recurse_submodules,
Brandon Williams4fb1c6a2017-03-17 10:22:53 -0700845 N_("recursively search in each submodule")),
René Scharfe3e230fa2009-05-07 21:46:48 +0200846 OPT_GROUP(""),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200847 OPT_BOOL('v', "invert-match", &opt.invert,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700848 N_("show non-matching lines")),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200849 OPT_BOOL('i', "ignore-case", &opt.ignore_case,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700850 N_("case insensitive matching")),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200851 OPT_BOOL('w', "word-regexp", &opt.word_regexp,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700852 N_("match patterns only at word boundaries")),
René Scharfe3e230fa2009-05-07 21:46:48 +0200853 OPT_SET_INT('a', "text", &opt.binary,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700854 N_("process binary files as text"), GREP_BINARY_TEXT),
René Scharfe3e230fa2009-05-07 21:46:48 +0200855 OPT_SET_INT('I', NULL, &opt.binary,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700856 N_("don't match patterns in binary files"),
René Scharfe3e230fa2009-05-07 21:46:48 +0200857 GREP_BINARY_NOMATCH),
Jeff King335ec3b2013-05-10 17:10:15 +0200858 OPT_BOOL(0, "textconv", &opt.allow_textconv,
859 N_("process binary files with textconv filters")),
René Scharfe0a09e5e2018-10-01 21:15:57 +0200860 OPT_SET_INT('r', "recursive", &opt.max_depth,
861 N_("search in subdirectories (default)"), -1),
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700862 { OPTION_INTEGER, 0, "max-depth", &opt.max_depth, N_("depth"),
863 N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
Michał Kiedrowicza91f4532009-07-22 19:52:15 +0200864 NULL, 1 },
René Scharfe3e230fa2009-05-07 21:46:48 +0200865 OPT_GROUP(""),
J Smith84befcd2012-08-03 10:53:50 -0400866 OPT_SET_INT('E', "extended-regexp", &pattern_type_arg,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700867 N_("use extended POSIX regular expressions"),
J Smith84befcd2012-08-03 10:53:50 -0400868 GREP_PATTERN_TYPE_ERE),
869 OPT_SET_INT('G', "basic-regexp", &pattern_type_arg,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700870 N_("use basic POSIX regular expressions (default)"),
J Smith84befcd2012-08-03 10:53:50 -0400871 GREP_PATTERN_TYPE_BRE),
872 OPT_SET_INT('F', "fixed-strings", &pattern_type_arg,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700873 N_("interpret patterns as fixed strings"),
J Smith84befcd2012-08-03 10:53:50 -0400874 GREP_PATTERN_TYPE_FIXED),
875 OPT_SET_INT('P', "perl-regexp", &pattern_type_arg,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700876 N_("use Perl-compatible regular expressions"),
J Smith84befcd2012-08-03 10:53:50 -0400877 GREP_PATTERN_TYPE_PCRE),
René Scharfe3e230fa2009-05-07 21:46:48 +0200878 OPT_GROUP(""),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200879 OPT_BOOL('n', "line-number", &opt.linenum, N_("show line numbers")),
Taylor Blaua449f272018-06-22 10:49:45 -0500880 OPT_BOOL(0, "column", &opt.columnnum, N_("show column number of first match")),
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700881 OPT_NEGBIT('h', NULL, &opt.pathname, N_("don't show filenames"), 1),
882 OPT_BIT('H', NULL, &opt.pathname, N_("show filenames"), 1),
René Scharfe3e230fa2009-05-07 21:46:48 +0200883 OPT_NEGBIT(0, "full-name", &opt.relative,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700884 N_("show filenames relative to top directory"), 1),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200885 OPT_BOOL('l', "files-with-matches", &opt.name_only,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700886 N_("show only filenames instead of matching lines")),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200887 OPT_BOOL(0, "name-only", &opt.name_only,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700888 N_("synonym for --files-with-matches")),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200889 OPT_BOOL('L', "files-without-match",
René Scharfe3e230fa2009-05-07 21:46:48 +0200890 &opt.unmatch_name_only,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700891 N_("show only the names of files without match")),
Nguyễn Thái Ngọc Duycaf2de32018-02-09 18:01:59 +0700892 OPT_BOOL_F('z', "null", &opt.null_following_name,
893 N_("print NUL after filenames"),
894 PARSE_OPT_NOCOMPLETE),
Taylor Blau9d8db062018-07-09 15:33:47 -0500895 OPT_BOOL('o', "only-matching", &opt.only_matching,
896 N_("show only matching parts of a line")),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200897 OPT_BOOL('c', "count", &opt.count,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700898 N_("show the number of matches instead of matching lines")),
899 OPT__COLOR(&opt.color, N_("highlight matches")),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200900 OPT_BOOL(0, "break", &opt.file_break,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700901 N_("print empty line between matches from different files")),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200902 OPT_BOOL(0, "heading", &opt.heading,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700903 N_("show filename only once above matches from same file")),
René Scharfe3e230fa2009-05-07 21:46:48 +0200904 OPT_GROUP(""),
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700905 OPT_CALLBACK('C', "context", &opt, N_("n"),
906 N_("show <n> context lines before and after matches"),
René Scharfe3e230fa2009-05-07 21:46:48 +0200907 context_callback),
René Scharfe317f63c2011-08-01 19:22:52 +0200908 OPT_INTEGER('B', "before-context", &opt.pre_context,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700909 N_("show <n> context lines before matches")),
René Scharfe317f63c2011-08-01 19:22:52 +0200910 OPT_INTEGER('A', "after-context", &opt.post_context,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700911 N_("show <n> context lines after matches")),
Victor Leschuk89f09dd2015-12-15 18:31:39 +0300912 OPT_INTEGER(0, "threads", &num_threads,
913 N_("use <n> worker threads")),
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700914 OPT_NUMBER_CALLBACK(&opt, N_("shortcut for -C NUM"),
René Scharfe3e230fa2009-05-07 21:46:48 +0200915 context_callback),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200916 OPT_BOOL('p', "show-function", &opt.funcname,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700917 N_("show a line with the function name before matches")),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200918 OPT_BOOL('W', "function-context", &opt.funcbody,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700919 N_("show the surrounding function")),
René Scharfe3e230fa2009-05-07 21:46:48 +0200920 OPT_GROUP(""),
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700921 OPT_CALLBACK('f', NULL, &opt, N_("file"),
922 N_("read patterns from file"), file_callback),
Denton Liu203c8532020-04-28 04:36:28 -0400923 OPT_CALLBACK_F('e', NULL, &opt, N_("pattern"),
924 N_("match <pattern>"), PARSE_OPT_NONEG, pattern_callback),
925 OPT_CALLBACK_F(0, "and", &opt, NULL,
926 N_("combine patterns specified with -e"),
927 PARSE_OPT_NOARG | PARSE_OPT_NONEG, and_callback),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200928 OPT_BOOL(0, "or", &dummy, ""),
Denton Liu203c8532020-04-28 04:36:28 -0400929 OPT_CALLBACK_F(0, "not", &opt, NULL, "",
930 PARSE_OPT_NOARG | PARSE_OPT_NONEG, not_callback),
931 OPT_CALLBACK_F('(', NULL, &opt, NULL, "",
932 PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH,
933 open_callback),
934 OPT_CALLBACK_F(')', NULL, &opt, NULL, "",
935 PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH,
936 close_callback),
René Scharfed52ee6e2010-11-08 19:06:54 +0100937 OPT__QUIET(&opt.status_only,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700938 N_("indicate hit with exit status without output")),
Stefan Bellerd5d09d42013-08-03 13:51:19 +0200939 OPT_BOOL(0, "all-match", &opt.all_match,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700940 N_("show only matches from files that match all patterns")),
René Scharfe3e230fa2009-05-07 21:46:48 +0200941 OPT_GROUP(""),
Johannes Schindelin0af88c12010-06-12 11:39:46 -0500942 { OPTION_STRING, 'O', "open-files-in-pager", &show_in_pager,
Nguyễn Thái Ngọc Duy4b407bc2012-08-20 19:32:15 +0700943 N_("pager"), N_("show matching files in the pager"),
Nguyễn Thái Ngọc Duycaf2de32018-02-09 18:01:59 +0700944 PARSE_OPT_OPTARG | PARSE_OPT_NOCOMPLETE,
945 NULL, (intptr_t)default_pager },
946 OPT_BOOL_F(0, "ext-grep", &external_grep_allowed__ignored,
947 N_("allow calling of grep(1) (ignored by this build)"),
948 PARSE_OPT_NOCOMPLETE),
René Scharfe3e230fa2009-05-07 21:46:48 +0200949 OPT_END()
950 };
Junio C Hamano5010cb52006-04-30 23:28:15 -0700951
Junio C Hamano15fabd12012-10-09 16:04:12 -0700952 git_config(grep_cmd_config, NULL);
Nguyễn Thái Ngọc Duy38bbc2e2018-09-21 17:57:23 +0200953 grep_init(&opt, the_repository, prefix);
René Scharfe7e8f59d2009-03-07 13:32:32 +0100954
Junio C Hamano5010cb52006-04-30 23:28:15 -0700955 /*
Junio C Hamano5acd64e2006-05-08 23:55:47 -0700956 * If there is no -- then the paths must exist in the working
957 * tree. If there is no explicit pattern specified with -e or
958 * -f, we take the first unrecognized non option to be the
959 * pattern, but then what follows it must be zero or more
960 * valid refs up to the -- (if exists), and then existing
961 * paths. If there is an explicit pattern, then the first
Pavel Roskin82e5a822006-07-10 01:50:18 -0400962 * unrecognized non option is the beginning of the refs list
Junio C Hamano5acd64e2006-05-08 23:55:47 -0700963 * that continues up to the -- (if exists), and then paths.
Junio C Hamano5010cb52006-04-30 23:28:15 -0700964 */
Stephen Boyd37782922009-05-23 11:53:12 -0700965 argc = parse_options(argc, argv, prefix, options, grep_usage,
René Scharfe3e230fa2009-05-07 21:46:48 +0200966 PARSE_OPT_KEEP_DASHDASH |
René Scharfe44415492015-11-17 11:25:53 +0100967 PARSE_OPT_STOP_AT_NON_OPTION);
Junio C Hamanoc5c31d32012-10-03 14:47:48 -0700968 grep_commit_pattern_type(pattern_type_arg, &opt);
Junio C Hamano5acd64e2006-05-08 23:55:47 -0700969
Thomas Gummererecd9ba62016-01-12 11:40:26 +0100970 if (use_index && !startup_info->have_repository) {
971 int fallback = 0;
972 git_config_get_bool("grep.fallbacktonoindex", &fallback);
973 if (fallback)
974 use_index = 0;
975 else
976 /* die the same way as if we did it at the beginning */
977 setup_git_directory();
978 }
Philippe Blainc56c48d2020-01-30 13:37:28 +0000979 /* Ignore --recurse-submodules if --no-index is given or implied */
980 if (!use_index)
981 recurse_submodules = 0;
Junio C Hamano59332d12010-02-06 10:40:08 -0800982
Jeff King1123c672010-02-06 23:44:15 -0500983 /*
984 * skip a -- separator; we know it cannot be
985 * separating revisions from pathnames if
986 * we haven't even had any patterns yet
987 */
988 if (argc > 0 && !opt.pattern_list && !strcmp(argv[0], "--")) {
989 argv++;
990 argc--;
991 }
992
René Scharfe3e230fa2009-05-07 21:46:48 +0200993 /* First unrecognized non-option token */
994 if (argc > 0 && !opt.pattern_list) {
995 append_grep_pattern(&opt, argv[0], "command line", 0,
996 GREP_PATTERN);
997 argv++;
998 argc--;
Junio C Hamano5010cb52006-04-30 23:28:15 -0700999 }
Junio C Hamano5acd64e2006-05-08 23:55:47 -07001000
Johannes Schindelin0af88c12010-06-12 11:39:46 -05001001 if (show_in_pager == default_pager)
1002 show_in_pager = git_pager(1);
Johannes Schindelin678e4842010-06-12 11:36:51 -05001003 if (show_in_pager) {
Nazri Ramliye7b082a2010-07-02 21:55:06 -05001004 opt.color = 0;
Johannes Schindelin0af88c12010-06-12 11:39:46 -05001005 opt.name_only = 1;
1006 opt.null_following_name = 1;
1007 opt.output_priv = &path_list;
1008 opt.output = append_path;
Julian Phillips0c72cea2010-06-26 00:41:39 +01001009 string_list_append(&path_list, show_in_pager);
Johannes Schindelin678e4842010-06-12 11:36:51 -05001010 }
1011
Junio C Hamanof9b9faf2006-05-02 15:40:49 -07001012 if (!opt.pattern_list)
Nguyễn Thái Ngọc Duy1a07e592018-07-21 09:49:19 +02001013 die(_("no pattern given"));
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +01001014
Taylor Blau9d8db062018-07-09 15:33:47 -05001015 /* --only-matching has no effect with --invert. */
1016 if (opt.invert)
1017 opt.only_matching = 0;
1018
Jeff Kingb5b81132017-02-14 01:05:55 -05001019 /*
1020 * We have to find "--" in a separate pass, because its presence
1021 * influences how we will parse arguments that come before it.
1022 */
1023 for (i = 0; i < argc; i++) {
1024 if (!strcmp(argv[i], "--")) {
1025 seen_dashdash = 1;
1026 break;
1027 }
1028 }
1029
1030 /*
1031 * Resolve any rev arguments. If we have a dashdash, then everything up
1032 * to it must resolve as a rev. If not, then we stop at the first
1033 * non-rev and assume everything else is a path.
1034 */
Jeff King131f3c92017-02-14 16:54:36 -05001035 allow_revs = use_index && !untracked;
René Scharfe3e230fa2009-05-07 21:46:48 +02001036 for (i = 0; i < argc; i++) {
Junio C Hamano5acd64e2006-05-08 23:55:47 -07001037 const char *arg = argv[i];
brian m. carlson1db11082017-02-21 23:47:25 +00001038 struct object_id oid;
Michael J Gruberafa15f32013-05-10 17:10:16 +02001039 struct object_context oc;
Jeff King20d64212017-02-14 01:04:17 -05001040 struct object *object;
1041
Jonathan Tandca3b5f2017-02-14 01:03:03 -05001042 if (!strcmp(arg, "--")) {
1043 i++;
Jonathan Tandca3b5f2017-02-14 01:03:03 -05001044 break;
1045 }
Jeff King20d64212017-02-14 01:04:17 -05001046
Jeff King131f3c92017-02-14 16:54:36 -05001047 if (!allow_revs) {
Jeff Kingd0ffc062017-02-14 01:07:29 -05001048 if (seen_dashdash)
Jeff King131f3c92017-02-14 16:54:36 -05001049 die(_("--no-index or --untracked cannot be used with revs"));
Jeff Kingd0ffc062017-02-14 01:07:29 -05001050 break;
1051 }
1052
Nguyễn Thái Ngọc Duy3a7a6982019-01-12 09:13:28 +07001053 if (get_oid_with_context(the_repository, arg,
1054 GET_OID_RECORD_PATH,
brian m. carlsone82caf32017-07-13 23:49:28 +00001055 &oid, &oc)) {
Jeff Kingb5b81132017-02-14 01:05:55 -05001056 if (seen_dashdash)
1057 die(_("unable to resolve revision: %s"), arg);
Jeff King20d64212017-02-14 01:04:17 -05001058 break;
Jeff Kingb5b81132017-02-14 01:05:55 -05001059 }
Jeff King20d64212017-02-14 01:04:17 -05001060
brian m. carlsonc251c832017-05-06 22:10:38 +00001061 object = parse_object_or_die(&oid, arg);
Jeff King20d64212017-02-14 01:04:17 -05001062 if (!seen_dashdash)
1063 verify_non_filename(prefix, arg);
1064 add_object_array_with_path(object, arg, &list, oc.mode, oc.path);
Jeff Kingdc944b62017-05-19 08:54:43 -04001065 free(oc.path);
Junio C Hamano13626712006-05-01 15:58:29 -07001066 }
Junio C Hamano5acd64e2006-05-08 23:55:47 -07001067
Jeff Kingb5b81132017-02-14 01:05:55 -05001068 /*
1069 * Anything left over is presumed to be a path. But in the non-dashdash
1070 * "do what I mean" case, we verify and complain when that isn't true.
1071 */
Jeff Kinga0fe2b02017-02-14 01:02:38 -05001072 if (!seen_dashdash) {
1073 int j;
1074 for (j = i; j < argc; j++)
Jeff King131f3c92017-02-14 16:54:36 -05001075 verify_filename(prefix, argv[j], j == i && allow_revs);
Jeff Kinga0fe2b02017-02-14 01:02:38 -05001076 }
1077
1078 parse_pathspec(&pathspec, 0,
1079 PATHSPEC_PREFER_CWD |
1080 (opt.max_depth != -1 ? PATHSPEC_MAXDEPTH_VALID : 0),
1081 prefix, argv + i);
1082 pathspec.max_depth = opt.max_depth;
1083 pathspec.recursive = 1;
Brandon Williamseef3df52017-12-04 16:07:34 -08001084 pathspec.recurse_submodules = !!recurse_submodules;
Jeff Kinga0fe2b02017-02-14 01:02:38 -05001085
Junio C Hamano56ceb642020-02-14 12:54:20 -08001086 if (recurse_submodules && untracked)
1087 die(_("--untracked not supported with --recurse-submodules"));
Matheus Tavaresc441ea42020-01-15 23:39:56 -03001088
Matheus Tavares1184a952020-01-15 23:39:58 -03001089 if (show_in_pager) {
Nguyễn Thái Ngọc Duyfd6263f2018-11-03 09:48:44 +01001090 if (num_threads > 1)
1091 warning(_("invalid option combination, ignoring --threads"));
1092 num_threads = 1;
1093 } else if (!HAVE_THREADS && num_threads > 1) {
Ævar Arnfjörð Bjarmasond1edee42017-05-25 19:45:34 +00001094 warning(_("no threads support, ignoring --threads"));
Nguyễn Thái Ngọc Duyfd6263f2018-11-03 09:48:44 +01001095 num_threads = 1;
1096 } else if (num_threads < 0)
1097 die(_("invalid number of threads specified (%d)"), num_threads);
1098 else if (num_threads == 0)
Matheus Tavaresf1928f02020-01-15 23:40:00 -03001099 num_threads = HAVE_THREADS ? online_cpus() : 1;
Thomas Rast53b8d932011-12-12 22:16:08 +01001100
Nguyễn Thái Ngọc Duyfd6263f2018-11-03 09:48:44 +01001101 if (num_threads > 1) {
1102 if (!HAVE_THREADS)
1103 BUG("Somebody got num_threads calculation wrong!");
Albert Yale50dd0f22012-01-23 18:52:44 +01001104 if (!(opt.name_only || opt.unmatch_name_only || opt.count)
1105 && (opt.pre_context || opt.post_context ||
1106 opt.file_break || opt.funcbody))
Thomas Rast53b8d932011-12-12 22:16:08 +01001107 skip_first_line = 1;
Matheus Tavaresc441ea42020-01-15 23:39:56 -03001108
1109 /*
Matheus Tavares6c307622020-01-15 23:39:57 -03001110 * Pre-read gitmodules (if not read already) and force eager
1111 * initialization of packed_git to prevent racy lazy
1112 * reading/initialization once worker threads are started.
Matheus Tavaresc441ea42020-01-15 23:39:56 -03001113 */
1114 if (recurse_submodules)
1115 repo_read_gitmodules(the_repository, 1);
Matheus Tavares6c307622020-01-15 23:39:57 -03001116 if (startup_info->have_repository)
1117 (void)get_packed_git(the_repository);
Matheus Tavaresc441ea42020-01-15 23:39:56 -03001118
Thomas Rast53b8d932011-12-12 22:16:08 +01001119 start_threads(&opt);
Nguyễn Thái Ngọc Duyfd6263f2018-11-03 09:48:44 +01001120 } else {
1121 /*
1122 * The compiled patterns on the main path are only
1123 * used when not using threading. Otherwise
1124 * start_threads() above calls compile_grep_patterns()
1125 * for each thread.
1126 */
1127 compile_grep_patterns(&opt);
Thomas Rast53b8d932011-12-12 22:16:08 +01001128 }
Thomas Rast53b8d932011-12-12 22:16:08 +01001129
Johannes Schindelin678e4842010-06-12 11:36:51 -05001130 if (show_in_pager && (cached || list.nr))
Ævar Arnfjörð Bjarmasone4fe4ba2011-02-22 23:41:56 +00001131 die(_("--open-files-in-pager only works on the worktree"));
Johannes Schindelin678e4842010-06-12 11:36:51 -05001132
1133 if (show_in_pager && opt.pattern_list && !opt.pattern_list->next) {
1134 const char *pager = path_list.items[0].string;
1135 int len = strlen(pager);
1136
1137 if (len > 4 && is_dir_sep(pager[len - 5]))
1138 pager += len - 4;
1139
Johannes Schindelinf7febbe2011-02-08 00:17:24 -06001140 if (opt.ignore_case && !strcmp("less", pager))
1141 string_list_append(&path_list, "-I");
1142
Johannes Schindelin678e4842010-06-12 11:36:51 -05001143 if (!strcmp("less", pager) || !strcmp("vi", pager)) {
1144 struct strbuf buf = STRBUF_INIT;
1145 strbuf_addf(&buf, "+/%s%s",
1146 strcmp("less", pager) ? "" : "*",
1147 opt.pattern_list->pattern);
René Scharfefd99c2d2019-08-25 15:26:40 +02001148 string_list_append(&path_list,
1149 strbuf_detach(&buf, NULL));
Johannes Schindelin678e4842010-06-12 11:36:51 -05001150 }
1151 }
1152
Wilhelm Schuermannc2048f02015-03-18 19:00:13 +01001153 if (!show_in_pager && !opt.status_only)
Johannes Schindelin678e4842010-06-12 11:36:51 -05001154 setup_pager();
1155
Junio C Hamano0a93fb82011-09-27 13:43:12 -07001156 if (!use_index && (untracked || cached))
Nguyễn Thái Ngọc Duy1a07e592018-07-21 09:49:19 +02001157 die(_("--cached or --untracked cannot be used with --no-index"));
Johannes Schindelin678e4842010-06-12 11:36:51 -05001158
Matheus Tavares0c5d83b2021-02-08 16:43:28 -03001159 if (untracked && cached)
1160 die(_("--untracked cannot be used with --cached"));
1161
Junio C Hamano0a93fb82011-09-27 13:43:12 -07001162 if (!use_index || untracked) {
Junio C Hamano0a93fb82011-09-27 13:43:12 -07001163 int use_exclude = (opt_exclude < 0) ? use_index : !!opt_exclude;
Jeff King85975c02016-03-07 10:51:21 -05001164 hit = grep_directory(&opt, &pathspec, use_exclude, use_index);
Junio C Hamanodbfae862011-10-04 18:40:41 -07001165 } else if (0 <= opt_exclude) {
Nguyễn Thái Ngọc Duy1a07e592018-07-21 09:49:19 +02001166 die(_("--[no-]exclude-standard cannot be used for tracked contents"));
Johannes Schindelin685359c2010-06-12 11:32:11 -05001167 } else if (!list.nr) {
Nguyễn Thái Ngọc Duy6577f542008-08-28 20:04:30 +07001168 if (!cached)
1169 setup_work_tree();
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +01001170
Nguyễn Thái Ngọc Duydba093d2019-01-12 09:13:22 +07001171 hit = grep_cache(&opt, &pathspec, cached);
Johannes Schindelin685359c2010-06-12 11:32:11 -05001172 } else {
1173 if (cached)
Nguyễn Thái Ngọc Duy1a07e592018-07-21 09:49:19 +02001174 die(_("both --cached and trees are given"));
Brandon Williamsf9ee2fc2017-08-02 12:49:23 -07001175
Jonathan Tan68560772018-03-28 15:35:27 -07001176 hit = grep_objects(&opt, &pathspec, &list);
Junio C Hamano5010cb52006-04-30 23:28:15 -07001177 }
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +01001178
Nguyễn Thái Ngọc Duyfd6263f2018-11-03 09:48:44 +01001179 if (num_threads > 1)
Fredrik Kuivinen5b594f42010-01-25 23:51:39 +01001180 hit |= wait_all();
Johannes Schindelin678e4842010-06-12 11:36:51 -05001181 if (hit && show_in_pager)
1182 run_pager(&opt, prefix);
Ævar Arnfjörð Bjarmason7861fa02017-04-09 19:59:00 +00001183 clear_pathspec(&pathspec);
Junio C Hamanob48fb5b2006-09-27 16:27:10 -07001184 free_grep_patterns(&opt);
Junio C Hamano5010cb52006-04-30 23:28:15 -07001185 return !hit;
1186}