2006-05-01 06:28:15 +00:00
|
|
|
/*
|
|
|
|
* Builtin "git grep"
|
|
|
|
*
|
|
|
|
* Copyright (c) 2006 Junio C Hamano
|
|
|
|
*/
|
2019-01-24 08:29:12 +00:00
|
|
|
#define USE_THE_INDEX_COMPATIBILITY_MACROS
|
2006-05-01 06:28:15 +00:00
|
|
|
#include "cache.h"
|
2017-06-22 18:43:46 +00:00
|
|
|
#include "repository.h"
|
2017-06-14 18:07:36 +00:00
|
|
|
#include "config.h"
|
2006-05-01 06:28:15 +00:00
|
|
|
#include "blob.h"
|
|
|
|
#include "tree.h"
|
|
|
|
#include "commit.h"
|
|
|
|
#include "tag.h"
|
2006-05-01 22:58:29 +00:00
|
|
|
#include "tree-walk.h"
|
2006-05-01 06:28:15 +00:00
|
|
|
#include "builtin.h"
|
2009-05-07 19:46:48 +00:00
|
|
|
#include "parse-options.h"
|
2010-06-12 16:36:51 +00:00
|
|
|
#include "string-list.h"
|
|
|
|
#include "run-command.h"
|
2009-07-01 22:07:24 +00:00
|
|
|
#include "userdiff.h"
|
2006-09-17 23:02:52 +00:00
|
|
|
#include "grep.h"
|
2009-09-05 12:31:17 +00:00
|
|
|
#include "quote.h"
|
2010-02-06 18:40:08 +00:00
|
|
|
#include "dir.h"
|
2013-07-14 08:35:25 +00:00
|
|
|
#include "pathspec.h"
|
2016-12-16 19:03:20 +00:00
|
|
|
#include "submodule.h"
|
2016-12-16 19:03:21 +00:00
|
|
|
#include "submodule-config.h"
|
2018-03-23 17:20:55 +00:00
|
|
|
#include "object-store.h"
|
2010-01-25 22:51:39 +00:00
|
|
|
|
2009-05-07 19:46:48 +00:00
|
|
|
static char const * const grep_usage[] = {
|
2015-01-13 07:44:47 +00:00
|
|
|
N_("git grep [<options>] [-e] <pattern> [<rev>...] [[--] <path>...]"),
|
2009-05-07 19:46:48 +00:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2016-12-16 19:03:20 +00:00
|
|
|
static int recurse_submodules;
|
|
|
|
|
2015-12-15 15:31:39 +00:00
|
|
|
#define GREP_NUM_THREADS_DEFAULT 8
|
|
|
|
static int num_threads;
|
2010-01-25 22:51:39 +00:00
|
|
|
|
2015-12-15 15:31:39 +00:00
|
|
|
static pthread_t *threads;
|
2010-01-25 22:51:39 +00:00
|
|
|
|
|
|
|
/* We use one producer thread and THREADS consumer
|
|
|
|
* threads. The producer adds struct work_items to 'todo' and the
|
|
|
|
* consumers pick work items from the same array.
|
|
|
|
*/
|
2011-03-16 07:08:34 +00:00
|
|
|
struct work_item {
|
2012-02-02 08:19:37 +00:00
|
|
|
struct grep_source source;
|
2010-01-25 22:51:39 +00:00
|
|
|
char done;
|
|
|
|
struct strbuf out;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* In the range [todo_done, todo_start) in 'todo' we have work_items
|
|
|
|
* that have been or are processed by a consumer thread. We haven't
|
|
|
|
* written the result for these to stdout yet.
|
|
|
|
*
|
|
|
|
* The work_items in [todo_start, todo_end) are waiting to be picked
|
|
|
|
* up by a consumer thread.
|
|
|
|
*
|
|
|
|
* The ranges are modulo TODO_SIZE.
|
|
|
|
*/
|
|
|
|
#define TODO_SIZE 128
|
|
|
|
static struct work_item todo[TODO_SIZE];
|
|
|
|
static int todo_start;
|
|
|
|
static int todo_end;
|
|
|
|
static int todo_done;
|
|
|
|
|
|
|
|
/* Has all work items been added? */
|
|
|
|
static int all_work_added;
|
|
|
|
|
|
|
|
/* This lock protects all the variables above. */
|
|
|
|
static pthread_mutex_t grep_mutex;
|
|
|
|
|
2011-10-26 18:45:15 +00:00
|
|
|
static inline void grep_lock(void)
|
|
|
|
{
|
2017-05-25 19:45:35 +00:00
|
|
|
pthread_mutex_lock(&grep_mutex);
|
2011-10-26 18:45:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline void grep_unlock(void)
|
|
|
|
{
|
2017-05-25 19:45:35 +00:00
|
|
|
pthread_mutex_unlock(&grep_mutex);
|
2011-10-26 18:45:15 +00:00
|
|
|
}
|
|
|
|
|
2010-01-25 22:51:39 +00:00
|
|
|
/* Signalled when a new work_item is added to todo. */
|
|
|
|
static pthread_cond_t cond_add;
|
|
|
|
|
|
|
|
/* Signalled when the result from one work_item is written to
|
|
|
|
* stdout.
|
|
|
|
*/
|
|
|
|
static pthread_cond_t cond_write;
|
|
|
|
|
|
|
|
/* Signalled when we are finished with everything. */
|
|
|
|
static pthread_cond_t cond_result;
|
|
|
|
|
2011-06-05 15:24:15 +00:00
|
|
|
static int skip_first_line;
|
2010-03-15 16:21:10 +00:00
|
|
|
|
2018-02-23 14:47:56 +00:00
|
|
|
static void add_work(struct grep_opt *opt, const struct grep_source *gs)
|
2010-01-25 22:51:39 +00:00
|
|
|
{
|
|
|
|
grep_lock();
|
|
|
|
|
|
|
|
while ((todo_end+1) % ARRAY_SIZE(todo) == todo_done) {
|
|
|
|
pthread_cond_wait(&cond_write, &grep_mutex);
|
|
|
|
}
|
|
|
|
|
2018-02-23 14:47:56 +00:00
|
|
|
todo[todo_end].source = *gs;
|
2012-02-02 08:24:28 +00:00
|
|
|
if (opt->binary != GREP_BINARY_TEXT)
|
2018-09-21 15:57:33 +00:00
|
|
|
grep_source_load_driver(&todo[todo_end].source,
|
|
|
|
opt->repo->index);
|
2010-01-25 22:51:39 +00:00
|
|
|
todo[todo_end].done = 0;
|
|
|
|
strbuf_reset(&todo[todo_end].out);
|
|
|
|
todo_end = (todo_end + 1) % ARRAY_SIZE(todo);
|
|
|
|
|
|
|
|
pthread_cond_signal(&cond_add);
|
|
|
|
grep_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct work_item *get_work(void)
|
|
|
|
{
|
|
|
|
struct work_item *ret;
|
|
|
|
|
|
|
|
grep_lock();
|
|
|
|
while (todo_start == todo_end && !all_work_added) {
|
|
|
|
pthread_cond_wait(&cond_add, &grep_mutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (todo_start == todo_end && all_work_added) {
|
|
|
|
ret = NULL;
|
|
|
|
} else {
|
|
|
|
ret = &todo[todo_start];
|
|
|
|
todo_start = (todo_start + 1) % ARRAY_SIZE(todo);
|
|
|
|
}
|
|
|
|
grep_unlock();
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void work_done(struct work_item *w)
|
|
|
|
{
|
|
|
|
int old_done;
|
|
|
|
|
|
|
|
grep_lock();
|
|
|
|
w->done = 1;
|
|
|
|
old_done = todo_done;
|
|
|
|
for(; todo[todo_done].done && todo_done != todo_start;
|
|
|
|
todo_done = (todo_done+1) % ARRAY_SIZE(todo)) {
|
|
|
|
w = &todo[todo_done];
|
2010-03-15 16:21:10 +00:00
|
|
|
if (w->out.len) {
|
2011-06-05 15:24:15 +00:00
|
|
|
const char *p = w->out.buf;
|
|
|
|
size_t len = w->out.len;
|
|
|
|
|
|
|
|
/* Skip the leading hunk mark of the first file. */
|
|
|
|
if (skip_first_line) {
|
|
|
|
while (len) {
|
|
|
|
len--;
|
|
|
|
if (*p++ == '\n')
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
skip_first_line = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
write_or_die(1, p, len);
|
2010-03-15 16:21:10 +00:00
|
|
|
}
|
2012-02-02 08:19:37 +00:00
|
|
|
grep_source_clear(&w->source);
|
2010-01-25 22:51:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (old_done != todo_done)
|
|
|
|
pthread_cond_signal(&cond_write);
|
|
|
|
|
|
|
|
if (all_work_added && todo_done == todo_end)
|
|
|
|
pthread_cond_signal(&cond_result);
|
|
|
|
|
|
|
|
grep_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *run(void *arg)
|
|
|
|
{
|
|
|
|
int hit = 0;
|
|
|
|
struct grep_opt *opt = arg;
|
|
|
|
|
|
|
|
while (1) {
|
|
|
|
struct work_item *w = get_work();
|
|
|
|
if (!w)
|
|
|
|
break;
|
|
|
|
|
|
|
|
opt->output_priv = w;
|
2017-08-02 19:49:23 +00:00
|
|
|
hit |= grep_source(opt, &w->source);
|
2012-02-02 08:19:37 +00:00
|
|
|
grep_source_clear_data(&w->source);
|
2010-01-25 22:51:39 +00:00
|
|
|
work_done(w);
|
|
|
|
}
|
2010-01-30 15:42:58 +00:00
|
|
|
free_grep_patterns(arg);
|
|
|
|
free(arg);
|
2010-01-25 22:51:39 +00:00
|
|
|
|
|
|
|
return (void*) (intptr_t) hit;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void strbuf_out(struct grep_opt *opt, const void *buf, size_t size)
|
|
|
|
{
|
|
|
|
struct work_item *w = opt->output_priv;
|
|
|
|
strbuf_add(&w->out, buf, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void start_threads(struct grep_opt *opt)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
pthread_mutex_init(&grep_mutex, NULL);
|
2012-02-02 08:18:41 +00:00
|
|
|
pthread_mutex_init(&grep_read_mutex, NULL);
|
2011-12-12 21:16:07 +00:00
|
|
|
pthread_mutex_init(&grep_attr_mutex, NULL);
|
2010-01-25 22:51:39 +00:00
|
|
|
pthread_cond_init(&cond_add, NULL);
|
|
|
|
pthread_cond_init(&cond_write, NULL);
|
|
|
|
pthread_cond_init(&cond_result, NULL);
|
grep: make locking flag global
The low-level grep code traditionally didn't care about
threading, as it doesn't do any threading itself and didn't
call out to other non-thread-safe code. That changed with
0579f91 (grep: enable threading with -p and -W using lazy
attribute lookup, 2011-12-12), which pushed the lookup of
funcname attributes (which is not thread-safe) into the
low-level grep code.
As a result, the low-level code learned about a new global
"grep_attr_mutex" to serialize access to the attribute code.
A multi-threaded caller (e.g., builtin/grep.c) is expected
to initialize the mutex and set "use_threads" in the
grep_opt structure. The low-level code only uses the lock if
use_threads is set.
However, putting the use_threads flag into the grep_opt
struct is not the most logical place. Whether threading is
in use is not something that matters for each call to
grep_buffer, but is instead global to the whole program
(i.e., if any thread is doing multi-threaded grep, every
other thread, even if it thinks it is doing its own
single-threaded grep, would need to use the locking). In
practice, this distinction isn't a problem for us, because
the only user of multi-threaded grep is "git-grep", which
does nothing except call grep.
This patch turns the opt->use_threads flag into a global
flag. More important than the nit-picking semantic argument
above is that this means that the locking functions don't
need to actually have access to a grep_opt to know whether
to lock. Which in turn can make adding new locks simpler, as
we don't need to pass around a grep_opt.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-02-02 08:18:29 +00:00
|
|
|
grep_use_locks = 1;
|
2010-01-25 22:51:39 +00:00
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(todo); i++) {
|
|
|
|
strbuf_init(&todo[i].out, 0);
|
|
|
|
}
|
|
|
|
|
2015-12-15 15:31:39 +00:00
|
|
|
threads = xcalloc(num_threads, sizeof(*threads));
|
|
|
|
for (i = 0; i < num_threads; i++) {
|
2010-01-25 22:51:39 +00:00
|
|
|
int err;
|
|
|
|
struct grep_opt *o = grep_opt_dup(opt);
|
|
|
|
o->output = strbuf_out;
|
grep: don't redundantly compile throwaway patterns under threading
Change the pattern compilation logic under threading so that grep
doesn't compile a pattern it never ends up using on the non-threaded
code path, only to compile it again N times for N threads which will
each use their own copy, ignoring the initially compiled pattern.
This redundant compilation dates back to the initial introduction of
the threaded grep in commit 5b594f457a ("Threaded grep",
2010-01-25).
There was never any reason for doing this redundant work other than an
oversight in the initial commit. Jeff King suggested on-list in
<20170414212325.fefrl3qdjigwyitd@sigill.intra.peff.net> that this
might be needed to check the pattern for sanity before threaded
execution commences.
That's not the case. The pattern is compiled under threading in
start_threads() before any concurrent execution has started by calling
pthread_create(), so if the pattern contains an error we still do the
right thing. I.e. die with one error before any threaded execution has
commenced, instead of e.g. spewing out an error for each N threads,
which could be a regression a change like this might inadvertently
introduce.
This change is not meant as an optimization, any performance gains
from this are in the hundreds to thousands of nanoseconds at most. If
we wanted more performance here we could just re-use the compiled
patterns in multiple threads (regcomp(3) is thread-safe), or partially
re-use them and the associated structures in the case of later PCRE
JIT changes.
Rather, it's just to make the code easier to reason about. It's
confusing to debug this under threading & non-threading when the
threading codepaths redundantly compile a pattern which is never used.
The reason the patterns are recompiled is as a side-effect of
duplicating the whole grep_opt structure, which is not thread safe,
writable, and munged during execution. The grep_opt structure then
points to the grep_pat structure where pattern or patterns are stored.
I looked into e.g. splitting the API into some "do & alloc threadsafe
stuff", "spawn thread", "do and alloc non-threadsafe stuff", but the
execution time of grep_opt_dup() & pattern compilation is trivial
compared to actually executing the grep, so there was no point. Even
with the more expensive JIT changes to follow the most expensive PCRE
patterns take something like 0.0X milliseconds to compile at most[1].
The undocumented --debug mode added in commit 17bf35a3c7 ("grep: teach
--debug option to dump the parse tree", 2012-09-13) still works
properly with this change. It only emits debugging info during pattern
compilation, which is now dumped by the pattern compiled just before
the first thread is started.
1. http://sljit.sourceforge.net/pcre.html
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-25 20:05:22 +00:00
|
|
|
if (i)
|
|
|
|
o->debug = 0;
|
2010-01-25 22:51:39 +00:00
|
|
|
compile_grep_patterns(o);
|
|
|
|
err = pthread_create(&threads[i], NULL, run, o);
|
|
|
|
|
|
|
|
if (err)
|
2011-02-22 23:41:55 +00:00
|
|
|
die(_("grep: failed to create thread: %s"),
|
2010-01-25 22:51:39 +00:00
|
|
|
strerror(err));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wait_all(void)
|
|
|
|
{
|
|
|
|
int hit = 0;
|
|
|
|
int i;
|
|
|
|
|
2018-11-03 08:48:43 +00:00
|
|
|
if (!HAVE_THREADS)
|
2018-11-03 08:48:44 +00:00
|
|
|
BUG("Never call this function unless you have started threads");
|
2018-11-03 08:48:43 +00:00
|
|
|
|
2010-01-25 22:51:39 +00:00
|
|
|
grep_lock();
|
|
|
|
all_work_added = 1;
|
|
|
|
|
|
|
|
/* Wait until all work is done. */
|
|
|
|
while (todo_done != todo_end)
|
|
|
|
pthread_cond_wait(&cond_result, &grep_mutex);
|
|
|
|
|
|
|
|
/* Wake up all the consumer threads so they can see that there
|
|
|
|
* is no more work to do.
|
|
|
|
*/
|
|
|
|
pthread_cond_broadcast(&cond_add);
|
|
|
|
grep_unlock();
|
|
|
|
|
2015-12-15 15:31:39 +00:00
|
|
|
for (i = 0; i < num_threads; i++) {
|
2010-01-25 22:51:39 +00:00
|
|
|
void *h;
|
|
|
|
pthread_join(threads[i], &h);
|
|
|
|
hit |= (int) (intptr_t) h;
|
|
|
|
}
|
|
|
|
|
2015-12-15 15:31:39 +00:00
|
|
|
free(threads);
|
|
|
|
|
2010-01-25 22:51:39 +00:00
|
|
|
pthread_mutex_destroy(&grep_mutex);
|
2012-02-02 08:18:41 +00:00
|
|
|
pthread_mutex_destroy(&grep_read_mutex);
|
2011-12-12 21:16:07 +00:00
|
|
|
pthread_mutex_destroy(&grep_attr_mutex);
|
2010-01-25 22:51:39 +00:00
|
|
|
pthread_cond_destroy(&cond_add);
|
|
|
|
pthread_cond_destroy(&cond_write);
|
|
|
|
pthread_cond_destroy(&cond_result);
|
grep: make locking flag global
The low-level grep code traditionally didn't care about
threading, as it doesn't do any threading itself and didn't
call out to other non-thread-safe code. That changed with
0579f91 (grep: enable threading with -p and -W using lazy
attribute lookup, 2011-12-12), which pushed the lookup of
funcname attributes (which is not thread-safe) into the
low-level grep code.
As a result, the low-level code learned about a new global
"grep_attr_mutex" to serialize access to the attribute code.
A multi-threaded caller (e.g., builtin/grep.c) is expected
to initialize the mutex and set "use_threads" in the
grep_opt structure. The low-level code only uses the lock if
use_threads is set.
However, putting the use_threads flag into the grep_opt
struct is not the most logical place. Whether threading is
in use is not something that matters for each call to
grep_buffer, but is instead global to the whole program
(i.e., if any thread is doing multi-threaded grep, every
other thread, even if it thinks it is doing its own
single-threaded grep, would need to use the locking). In
practice, this distinction isn't a problem for us, because
the only user of multi-threaded grep is "git-grep", which
does nothing except call grep.
This patch turns the opt->use_threads flag into a global
flag. More important than the nit-picking semantic argument
above is that this means that the locking functions don't
need to actually have access to a grep_opt to know whether
to lock. Which in turn can make adding new locks simpler, as
we don't need to pass around a grep_opt.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-02-02 08:18:29 +00:00
|
|
|
grep_use_locks = 0;
|
2010-01-25 22:51:39 +00:00
|
|
|
|
|
|
|
return hit;
|
|
|
|
}
|
|
|
|
|
2012-10-09 23:04:12 +00:00
|
|
|
static int grep_cmd_config(const char *var, const char *value, void *cb)
|
|
|
|
{
|
|
|
|
int st = grep_config(var, value, cb);
|
2017-10-13 17:24:31 +00:00
|
|
|
if (git_color_default_config(var, value, cb) < 0)
|
2012-10-09 23:04:12 +00:00
|
|
|
st = -1;
|
2015-12-15 15:31:39 +00:00
|
|
|
|
|
|
|
if (!strcmp(var, "grep.threads")) {
|
|
|
|
num_threads = git_config_int(var, value);
|
|
|
|
if (num_threads < 0)
|
|
|
|
die(_("invalid number of threads specified (%d) for %s"),
|
|
|
|
num_threads, var);
|
2018-11-03 08:48:44 +00:00
|
|
|
else if (!HAVE_THREADS && num_threads > 1) {
|
2017-05-25 19:45:34 +00:00
|
|
|
/*
|
|
|
|
* TRANSLATORS: %s is the configuration
|
|
|
|
* variable for tweaking threads, currently
|
|
|
|
* grep.threads
|
|
|
|
*/
|
|
|
|
warning(_("no threads support, ignoring %s"), var);
|
2018-11-03 08:48:44 +00:00
|
|
|
num_threads = 1;
|
2017-05-25 19:45:34 +00:00
|
|
|
}
|
2015-12-15 15:31:39 +00:00
|
|
|
}
|
|
|
|
|
2017-06-01 00:30:48 +00:00
|
|
|
if (!strcmp(var, "submodule.recurse"))
|
|
|
|
recurse_submodules = git_config_bool(var, value);
|
|
|
|
|
2012-10-09 23:04:12 +00:00
|
|
|
return st;
|
|
|
|
}
|
|
|
|
|
2017-02-21 23:47:25 +00:00
|
|
|
static void *lock_and_read_oid_file(const struct object_id *oid, enum object_type *type, unsigned long *size)
|
2010-02-16 02:34:28 +00:00
|
|
|
{
|
|
|
|
void *data;
|
|
|
|
|
2012-02-02 08:18:41 +00:00
|
|
|
grep_read_lock();
|
sha1_file: convert read_sha1_file to struct object_id
Convert read_sha1_file to take a pointer to struct object_id and rename
it read_object_file. Do the same for read_sha1_file_extended.
Convert one use in grep.c to use the new function without any other code
change, since the pointer being passed is a void pointer that is already
initialized with a pointer to struct object_id. Update the declaration
and definitions of the modified functions, and apply the following
semantic patch to convert the remaining callers:
@@
expression E1, E2, E3;
@@
- read_sha1_file(E1.hash, E2, E3)
+ read_object_file(&E1, E2, E3)
@@
expression E1, E2, E3;
@@
- read_sha1_file(E1->hash, E2, E3)
+ read_object_file(E1, E2, E3)
@@
expression E1, E2, E3, E4;
@@
- read_sha1_file_extended(E1.hash, E2, E3, E4)
+ read_object_file_extended(&E1, E2, E3, E4)
@@
expression E1, E2, E3, E4;
@@
- read_sha1_file_extended(E1->hash, E2, E3, E4)
+ read_object_file_extended(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-03-12 02:27:53 +00:00
|
|
|
data = read_object_file(oid, type, size);
|
2012-02-02 08:18:41 +00:00
|
|
|
grep_read_unlock();
|
2010-01-25 22:51:39 +00:00
|
|
|
return data;
|
|
|
|
}
|
|
|
|
|
2017-02-21 23:47:25 +00:00
|
|
|
static int grep_oid(struct grep_opt *opt, const struct object_id *oid,
|
2012-10-12 10:49:38 +00:00
|
|
|
const char *filename, int tree_name_len,
|
|
|
|
const char *path)
|
2010-01-25 22:51:39 +00:00
|
|
|
{
|
|
|
|
struct strbuf pathbuf = STRBUF_INIT;
|
2018-02-23 14:47:56 +00:00
|
|
|
struct grep_source gs;
|
2010-01-25 22:51:39 +00:00
|
|
|
|
2017-08-02 19:49:23 +00:00
|
|
|
if (opt->relative && opt->prefix_length) {
|
|
|
|
quote_path_relative(filename + tree_name_len, opt->prefix, &pathbuf);
|
|
|
|
strbuf_insert(&pathbuf, 0, filename, tree_name_len);
|
2010-01-25 22:51:39 +00:00
|
|
|
} else {
|
|
|
|
strbuf_addstr(&pathbuf, filename);
|
|
|
|
}
|
|
|
|
|
2018-02-23 14:47:56 +00:00
|
|
|
grep_source_init(&gs, GREP_SOURCE_OID, pathbuf.buf, path, oid);
|
2018-02-23 14:47:57 +00:00
|
|
|
strbuf_release(&pathbuf);
|
2018-02-23 14:47:56 +00:00
|
|
|
|
2018-11-03 08:48:44 +00:00
|
|
|
if (num_threads > 1) {
|
2018-02-23 14:47:56 +00:00
|
|
|
/*
|
|
|
|
* add_work() copies gs and thus assumes ownership of
|
|
|
|
* its fields, so do not call grep_source_clear()
|
|
|
|
*/
|
|
|
|
add_work(opt, &gs);
|
2010-01-25 22:51:39 +00:00
|
|
|
return 0;
|
2018-11-03 08:48:43 +00:00
|
|
|
} else {
|
2010-01-25 22:51:39 +00:00
|
|
|
int hit;
|
2006-05-01 06:28:15 +00:00
|
|
|
|
2012-02-02 08:19:37 +00:00
|
|
|
hit = grep_source(opt, &gs);
|
2007-03-07 01:44:37 +00:00
|
|
|
|
2012-02-02 08:19:37 +00:00
|
|
|
grep_source_clear(&gs);
|
|
|
|
return hit;
|
2006-05-01 06:28:15 +00:00
|
|
|
}
|
2010-01-25 22:51:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int grep_file(struct grep_opt *opt, const char *filename)
|
|
|
|
{
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
2018-02-23 14:47:56 +00:00
|
|
|
struct grep_source gs;
|
2010-01-25 22:51:39 +00:00
|
|
|
|
2017-08-02 19:49:23 +00:00
|
|
|
if (opt->relative && opt->prefix_length)
|
|
|
|
quote_path_relative(filename, opt->prefix, &buf);
|
|
|
|
else
|
|
|
|
strbuf_addstr(&buf, filename);
|
2010-01-25 22:51:39 +00:00
|
|
|
|
2018-02-23 14:47:56 +00:00
|
|
|
grep_source_init(&gs, GREP_SOURCE_FILE, buf.buf, filename, filename);
|
2018-02-23 14:47:57 +00:00
|
|
|
strbuf_release(&buf);
|
2018-02-23 14:47:56 +00:00
|
|
|
|
2018-11-03 08:48:44 +00:00
|
|
|
if (num_threads > 1) {
|
2018-02-23 14:47:56 +00:00
|
|
|
/*
|
|
|
|
* add_work() copies gs and thus assumes ownership of
|
|
|
|
* its fields, so do not call grep_source_clear()
|
|
|
|
*/
|
|
|
|
add_work(opt, &gs);
|
2010-01-25 22:51:39 +00:00
|
|
|
return 0;
|
2018-11-03 08:48:43 +00:00
|
|
|
} else {
|
2010-01-25 22:51:39 +00:00
|
|
|
int hit;
|
|
|
|
|
2012-02-02 08:19:37 +00:00
|
|
|
hit = grep_source(opt, &gs);
|
|
|
|
|
|
|
|
grep_source_clear(&gs);
|
2010-01-25 22:51:39 +00:00
|
|
|
return hit;
|
|
|
|
}
|
2006-05-01 06:28:15 +00:00
|
|
|
}
|
|
|
|
|
2010-06-12 16:36:51 +00:00
|
|
|
static void append_path(struct grep_opt *opt, const void *data, size_t len)
|
|
|
|
{
|
|
|
|
struct string_list *path_list = opt->output_priv;
|
|
|
|
|
|
|
|
if (len == 1 && *(const char *)data == '\0')
|
|
|
|
return;
|
2010-06-25 23:41:39 +00:00
|
|
|
string_list_append(path_list, xstrndup(data, len));
|
2010-06-12 16:36:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void run_pager(struct grep_opt *opt, const char *prefix)
|
|
|
|
{
|
|
|
|
struct string_list *path_list = opt->output_priv;
|
2016-02-22 22:44:21 +00:00
|
|
|
struct child_process child = CHILD_PROCESS_INIT;
|
2010-06-12 16:36:51 +00:00
|
|
|
int i, status;
|
|
|
|
|
|
|
|
for (i = 0; i < path_list->nr; i++)
|
2016-02-22 22:44:21 +00:00
|
|
|
argv_array_push(&child.args, path_list->items[i].string);
|
|
|
|
child.dir = prefix;
|
|
|
|
child.use_shell = 1;
|
2010-06-12 16:36:51 +00:00
|
|
|
|
2016-02-22 22:44:21 +00:00
|
|
|
status = run_command(&child);
|
2010-06-12 16:36:51 +00:00
|
|
|
if (status)
|
|
|
|
exit(status);
|
|
|
|
}
|
|
|
|
|
2019-01-12 02:13:22 +00:00
|
|
|
static int grep_cache(struct grep_opt *opt,
|
2017-08-02 19:49:23 +00:00
|
|
|
const struct pathspec *pathspec, int cached);
|
|
|
|
static int grep_tree(struct grep_opt *opt, const struct pathspec *pathspec,
|
|
|
|
struct tree_desc *tree, struct strbuf *base, int tn_len,
|
2019-01-12 02:13:22 +00:00
|
|
|
int check_attr);
|
2016-12-16 19:03:20 +00:00
|
|
|
|
2019-01-12 02:13:22 +00:00
|
|
|
static int grep_submodule(struct grep_opt *opt,
|
2017-08-02 19:49:23 +00:00
|
|
|
const struct pathspec *pathspec,
|
|
|
|
const struct object_id *oid,
|
2019-07-30 16:53:27 +00:00
|
|
|
const char *filename, const char *path, int cached)
|
2016-12-16 19:03:20 +00:00
|
|
|
{
|
2018-11-29 00:27:53 +00:00
|
|
|
struct repository subrepo;
|
2019-01-12 02:13:22 +00:00
|
|
|
struct repository *superproject = opt->repo;
|
2018-11-29 00:27:53 +00:00
|
|
|
const struct submodule *sub = submodule_from_path(superproject,
|
|
|
|
&null_oid, path);
|
2019-01-12 02:13:22 +00:00
|
|
|
struct grep_opt subopt;
|
2017-08-02 19:49:23 +00:00
|
|
|
int hit;
|
2016-12-16 19:03:21 +00:00
|
|
|
|
2018-10-25 16:18:12 +00:00
|
|
|
/*
|
|
|
|
* NEEDSWORK: submodules functions need to be protected because they
|
|
|
|
* access the object store via config_from_gitmodules(): the latter
|
|
|
|
* uses get_oid() which, for now, relies on the global the_repository
|
|
|
|
* object.
|
|
|
|
*/
|
|
|
|
grep_read_lock();
|
|
|
|
|
|
|
|
if (!is_submodule_active(superproject, path)) {
|
|
|
|
grep_read_unlock();
|
2017-08-02 19:49:23 +00:00
|
|
|
return 0;
|
2018-10-25 16:18:12 +00:00
|
|
|
}
|
2016-12-16 19:03:20 +00:00
|
|
|
|
2018-11-29 00:27:53 +00:00
|
|
|
if (repo_submodule_init(&subrepo, superproject, sub)) {
|
2018-10-25 16:18:12 +00:00
|
|
|
grep_read_unlock();
|
2017-08-02 19:49:23 +00:00
|
|
|
return 0;
|
2018-10-25 16:18:12 +00:00
|
|
|
}
|
2017-03-17 17:22:55 +00:00
|
|
|
|
2018-11-29 00:27:53 +00:00
|
|
|
repo_read_gitmodules(&subrepo);
|
2016-12-16 19:03:20 +00:00
|
|
|
|
2016-12-16 19:03:21 +00:00
|
|
|
/*
|
2017-08-02 19:49:23 +00:00
|
|
|
* NEEDSWORK: This adds the submodule's object directory to the list of
|
|
|
|
* alternates for the single in-memory object store. This has some bad
|
|
|
|
* consequences for memory (processed objects will never be freed) and
|
|
|
|
* performance (this increases the number of pack files git has to pay
|
|
|
|
* attention to, to the sum of the number of pack files in all the
|
|
|
|
* repositories processed so far). This can be removed once the object
|
|
|
|
* store is no longer global and instead is a member of the repository
|
|
|
|
* object.
|
2016-12-16 19:03:21 +00:00
|
|
|
*/
|
2019-01-29 20:47:54 +00:00
|
|
|
add_to_alternates_memory(subrepo.objects->odb->path);
|
2017-11-01 20:45:06 +00:00
|
|
|
grep_read_unlock();
|
2016-12-16 19:03:21 +00:00
|
|
|
|
2019-01-12 02:13:22 +00:00
|
|
|
memcpy(&subopt, opt, sizeof(subopt));
|
2019-02-07 06:05:22 +00:00
|
|
|
subopt.repo = &subrepo;
|
2019-01-12 02:13:22 +00:00
|
|
|
|
2017-08-02 19:49:23 +00:00
|
|
|
if (oid) {
|
|
|
|
struct object *object;
|
|
|
|
struct tree_desc tree;
|
|
|
|
void *data;
|
|
|
|
unsigned long size;
|
|
|
|
struct strbuf base = STRBUF_INIT;
|
2016-12-16 19:03:21 +00:00
|
|
|
|
2017-08-02 19:49:23 +00:00
|
|
|
object = parse_object_or_die(oid, oid_to_hex(oid));
|
2016-12-16 19:03:20 +00:00
|
|
|
|
2017-08-02 19:49:23 +00:00
|
|
|
grep_read_lock();
|
2019-06-27 09:28:47 +00:00
|
|
|
data = read_object_with_reference(&subrepo,
|
|
|
|
&object->oid, tree_type,
|
2017-08-02 19:49:23 +00:00
|
|
|
&size, NULL);
|
|
|
|
grep_read_unlock();
|
2016-12-16 19:03:20 +00:00
|
|
|
|
2017-08-02 19:49:23 +00:00
|
|
|
if (!data)
|
|
|
|
die(_("unable to read tree (%s)"), oid_to_hex(&object->oid));
|
2016-12-16 19:03:20 +00:00
|
|
|
|
2017-08-02 19:49:23 +00:00
|
|
|
strbuf_addstr(&base, filename);
|
|
|
|
strbuf_addch(&base, '/');
|
2016-12-16 19:03:20 +00:00
|
|
|
|
2017-08-02 19:49:23 +00:00
|
|
|
init_tree_desc(&tree, data, size);
|
2019-01-12 02:13:22 +00:00
|
|
|
hit = grep_tree(&subopt, pathspec, &tree, &base, base.len,
|
|
|
|
object->type == OBJ_COMMIT);
|
2017-08-02 19:49:23 +00:00
|
|
|
strbuf_release(&base);
|
|
|
|
free(data);
|
|
|
|
} else {
|
2019-07-30 16:53:27 +00:00
|
|
|
hit = grep_cache(&subopt, pathspec, cached);
|
2016-12-16 19:03:22 +00:00
|
|
|
}
|
2016-12-16 19:03:20 +00:00
|
|
|
|
2018-11-29 00:27:53 +00:00
|
|
|
repo_clear(&subrepo);
|
2017-08-02 19:49:23 +00:00
|
|
|
return hit;
|
2016-12-16 19:03:20 +00:00
|
|
|
}
|
|
|
|
|
2019-01-12 02:13:22 +00:00
|
|
|
static int grep_cache(struct grep_opt *opt,
|
2017-08-02 19:49:23 +00:00
|
|
|
const struct pathspec *pathspec, int cached)
|
2006-05-01 06:28:15 +00:00
|
|
|
{
|
2019-01-12 02:13:22 +00:00
|
|
|
struct repository *repo = opt->repo;
|
2006-05-01 06:28:15 +00:00
|
|
|
int hit = 0;
|
|
|
|
int nr;
|
2016-12-16 19:03:20 +00:00
|
|
|
struct strbuf name = STRBUF_INIT;
|
|
|
|
int name_base_len = 0;
|
2017-08-02 19:49:23 +00:00
|
|
|
if (repo->submodule_prefix) {
|
|
|
|
name_base_len = strlen(repo->submodule_prefix);
|
|
|
|
strbuf_addstr(&name, repo->submodule_prefix);
|
2016-12-16 19:03:20 +00:00
|
|
|
}
|
|
|
|
|
2018-05-15 01:04:25 +00:00
|
|
|
if (repo_read_index(repo) < 0)
|
2018-07-21 07:49:23 +00:00
|
|
|
die(_("index file corrupt"));
|
2006-05-01 06:28:15 +00:00
|
|
|
|
2017-08-02 19:49:23 +00:00
|
|
|
for (nr = 0; nr < repo->index->cache_nr; nr++) {
|
|
|
|
const struct cache_entry *ce = repo->index->cache[nr];
|
2016-12-16 19:03:20 +00:00
|
|
|
strbuf_setlen(&name, name_base_len);
|
|
|
|
strbuf_addstr(&name, ce->name);
|
|
|
|
|
|
|
|
if (S_ISREG(ce->ce_mode) &&
|
2018-08-13 16:14:34 +00:00
|
|
|
match_pathspec(repo->index, pathspec, name.buf, name.len, 0, NULL,
|
2016-12-16 19:03:20 +00:00
|
|
|
S_ISDIR(ce->ce_mode) ||
|
|
|
|
S_ISGITLINK(ce->ce_mode))) {
|
|
|
|
/*
|
|
|
|
* If CE_VALID is on, we assume worktree file and its
|
|
|
|
* cache entry are identical, even if worktree file has
|
|
|
|
* been modified, so use cache version instead
|
|
|
|
*/
|
|
|
|
if (cached || (ce->ce_flags & CE_VALID) ||
|
|
|
|
ce_skip_worktree(ce)) {
|
|
|
|
if (ce_stage(ce) || ce_intent_to_add(ce))
|
|
|
|
continue;
|
2017-08-02 19:49:23 +00:00
|
|
|
hit |= grep_oid(opt, &ce->oid, name.buf,
|
|
|
|
0, name.buf);
|
2016-12-16 19:03:20 +00:00
|
|
|
} else {
|
2017-08-02 19:49:23 +00:00
|
|
|
hit |= grep_file(opt, name.buf);
|
2016-12-16 19:03:20 +00:00
|
|
|
}
|
|
|
|
} else if (recurse_submodules && S_ISGITLINK(ce->ce_mode) &&
|
2018-08-13 16:14:34 +00:00
|
|
|
submodule_path_match(repo->index, pathspec, name.buf, NULL)) {
|
2019-07-30 16:53:27 +00:00
|
|
|
hit |= grep_submodule(opt, pathspec, NULL, ce->name,
|
|
|
|
ce->name, cached);
|
2016-12-16 19:03:20 +00:00
|
|
|
} else {
|
2006-05-01 06:28:15 +00:00
|
|
|
continue;
|
2006-11-26 20:47:52 +00:00
|
|
|
}
|
2016-12-16 19:03:20 +00:00
|
|
|
|
2006-11-26 20:47:52 +00:00
|
|
|
if (ce_stage(ce)) {
|
|
|
|
do {
|
|
|
|
nr++;
|
2017-08-02 19:49:23 +00:00
|
|
|
} while (nr < repo->index->cache_nr &&
|
|
|
|
!strcmp(ce->name, repo->index->cache[nr]->name));
|
2006-11-26 20:47:52 +00:00
|
|
|
nr--; /* compensate for loop control */
|
|
|
|
}
|
2010-01-25 23:37:23 +00:00
|
|
|
if (hit && opt->status_only)
|
|
|
|
break;
|
2006-05-01 06:28:15 +00:00
|
|
|
}
|
2016-12-16 19:03:20 +00:00
|
|
|
|
|
|
|
strbuf_release(&name);
|
2006-05-01 06:28:15 +00:00
|
|
|
return hit;
|
|
|
|
}
|
|
|
|
|
2010-12-15 15:02:51 +00:00
|
|
|
static int grep_tree(struct grep_opt *opt, const struct pathspec *pathspec,
|
2012-10-12 10:49:38 +00:00
|
|
|
struct tree_desc *tree, struct strbuf *base, int tn_len,
|
2019-01-12 02:13:22 +00:00
|
|
|
int check_attr)
|
2006-05-01 06:28:15 +00:00
|
|
|
{
|
2019-01-12 02:13:22 +00:00
|
|
|
struct repository *repo = opt->repo;
|
2011-10-24 06:36:10 +00:00
|
|
|
int hit = 0;
|
|
|
|
enum interesting match = entry_not_interesting;
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
struct name_entry entry;
|
2010-12-17 12:44:25 +00:00
|
|
|
int old_baselen = base->len;
|
2016-12-16 19:03:21 +00:00
|
|
|
struct strbuf name = STRBUF_INIT;
|
|
|
|
int name_base_len = 0;
|
2017-08-02 19:49:23 +00:00
|
|
|
if (repo->submodule_prefix) {
|
|
|
|
strbuf_addstr(&name, repo->submodule_prefix);
|
2016-12-16 19:03:21 +00:00
|
|
|
name_base_len = name.len;
|
|
|
|
}
|
2006-05-01 06:28:15 +00:00
|
|
|
|
tree_entry(): new tree-walking helper function
This adds a "tree_entry()" function that combines the common operation of
doing a "tree_entry_extract()" + "update_tree_entry()".
It also has a simplified calling convention, designed for simple loops
that traverse over a whole tree: the arguments are pointers to the tree
descriptor and a name_entry structure to fill in, and it returns a boolean
"true" if there was an entry left to be gotten in the tree.
This allows tree traversal with
struct tree_desc desc;
struct name_entry entry;
desc.buf = tree->buffer;
desc.size = tree->size;
while (tree_entry(&desc, &entry) {
... use "entry.{path, sha1, mode, pathlen}" ...
}
which is not only shorter than writing it out in full, it's hopefully less
error prone too.
[ It's actually a tad faster too - we don't need to recalculate the entry
pathlength in both extract and update, but need to do it only once.
Also, some callers can avoid doing a "strlen()" on the result, since
it's returned as part of the name_entry structure.
However, by now we're talking just 1% speedup on "git-rev-list --objects
--all", and we're definitely at the point where tree walking is no
longer the issue any more. ]
NOTE! Not everybody wants to use this new helper function, since some of
the tree walkers very much on purpose do the descriptor update separately
from the entry extraction. So the "extract + update" sequence still
remains as the core sequence, this is just a simplified interface.
We should probably add a silly two-line inline helper function for
initializing the descriptor from the "struct tree" too, just to cut down
on the noise from that common "desc" initializer.
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
Signed-off-by: Junio C Hamano <junkio@cox.net>
2006-05-30 16:45:45 +00:00
|
|
|
while (tree_entry(tree, &entry)) {
|
2011-10-24 06:36:09 +00:00
|
|
|
int te_len = tree_entry_len(&entry);
|
2010-12-17 12:44:25 +00:00
|
|
|
|
2011-10-24 06:36:10 +00:00
|
|
|
if (match != all_entries_interesting) {
|
2016-12-16 19:03:21 +00:00
|
|
|
strbuf_addstr(&name, base->buf + tn_len);
|
2018-11-18 16:47:57 +00:00
|
|
|
match = tree_entry_interesting(repo->index,
|
|
|
|
&entry, &name,
|
2016-12-16 19:03:21 +00:00
|
|
|
0, pathspec);
|
|
|
|
strbuf_setlen(&name, name_base_len);
|
|
|
|
|
2011-10-24 06:36:10 +00:00
|
|
|
if (match == all_entries_not_interesting)
|
2011-03-25 09:34:20 +00:00
|
|
|
break;
|
2011-10-24 06:36:10 +00:00
|
|
|
if (match == entry_not_interesting)
|
2010-12-17 12:45:33 +00:00
|
|
|
continue;
|
|
|
|
}
|
2006-05-01 06:28:15 +00:00
|
|
|
|
2010-12-17 12:45:33 +00:00
|
|
|
strbuf_add(base, entry.path, te_len);
|
2006-05-01 19:27:56 +00:00
|
|
|
|
2010-12-17 12:45:33 +00:00
|
|
|
if (S_ISREG(entry.mode)) {
|
2019-01-15 00:39:44 +00:00
|
|
|
hit |= grep_oid(opt, &entry.oid, base->buf, tn_len,
|
2012-10-12 10:49:38 +00:00
|
|
|
check_attr ? base->buf + tn_len : NULL);
|
2016-12-16 19:03:21 +00:00
|
|
|
} else if (S_ISDIR(entry.mode)) {
|
2007-02-26 19:55:59 +00:00
|
|
|
enum object_type type;
|
2006-05-01 06:28:15 +00:00
|
|
|
struct tree_desc sub;
|
|
|
|
void *data;
|
2007-03-21 17:08:25 +00:00
|
|
|
unsigned long size;
|
|
|
|
|
2019-01-15 00:39:44 +00:00
|
|
|
data = lock_and_read_oid_file(&entry.oid, &type, &size);
|
2006-05-01 06:28:15 +00:00
|
|
|
if (!data)
|
2011-02-22 23:41:55 +00:00
|
|
|
die(_("unable to read tree (%s)"),
|
2019-01-15 00:39:44 +00:00
|
|
|
oid_to_hex(&entry.oid));
|
2010-12-17 12:45:33 +00:00
|
|
|
|
|
|
|
strbuf_addch(base, '/');
|
2007-03-21 17:08:25 +00:00
|
|
|
init_tree_desc(&sub, data, size);
|
2012-10-12 10:49:38 +00:00
|
|
|
hit |= grep_tree(opt, pathspec, &sub, base, tn_len,
|
2019-01-12 02:13:22 +00:00
|
|
|
check_attr);
|
2006-05-01 06:28:15 +00:00
|
|
|
free(data);
|
2016-12-16 19:03:21 +00:00
|
|
|
} else if (recurse_submodules && S_ISGITLINK(entry.mode)) {
|
2019-02-07 06:05:22 +00:00
|
|
|
hit |= grep_submodule(opt, pathspec, &entry.oid,
|
2019-07-30 16:53:27 +00:00
|
|
|
base->buf, base->buf + tn_len,
|
|
|
|
1); /* ignored */
|
2006-05-01 06:28:15 +00:00
|
|
|
}
|
2016-12-16 19:03:21 +00:00
|
|
|
|
2010-12-17 12:44:25 +00:00
|
|
|
strbuf_setlen(base, old_baselen);
|
|
|
|
|
2010-01-25 23:37:23 +00:00
|
|
|
if (hit && opt->status_only)
|
|
|
|
break;
|
2006-05-01 06:28:15 +00:00
|
|
|
}
|
2016-12-16 19:03:21 +00:00
|
|
|
|
|
|
|
strbuf_release(&name);
|
2006-05-01 06:28:15 +00:00
|
|
|
return hit;
|
|
|
|
}
|
|
|
|
|
2010-12-15 15:02:51 +00:00
|
|
|
static int grep_object(struct grep_opt *opt, const struct pathspec *pathspec,
|
2018-03-28 22:35:27 +00:00
|
|
|
struct object *obj, const char *name, const char *path)
|
2006-05-01 06:28:15 +00:00
|
|
|
{
|
2006-07-12 03:45:31 +00:00
|
|
|
if (obj->type == OBJ_BLOB)
|
2017-02-21 23:47:25 +00:00
|
|
|
return grep_oid(opt, &obj->oid, name, 0, path);
|
2006-07-12 03:45:31 +00:00
|
|
|
if (obj->type == OBJ_COMMIT || obj->type == OBJ_TREE) {
|
2006-05-01 06:28:15 +00:00
|
|
|
struct tree_desc tree;
|
|
|
|
void *data;
|
2007-03-21 17:08:25 +00:00
|
|
|
unsigned long size;
|
2010-12-17 12:44:25 +00:00
|
|
|
struct strbuf base;
|
|
|
|
int hit, len;
|
|
|
|
|
2012-02-02 08:18:41 +00:00
|
|
|
grep_read_lock();
|
2019-06-27 09:28:47 +00:00
|
|
|
data = read_object_with_reference(opt->repo,
|
|
|
|
&obj->oid, tree_type,
|
2007-03-21 17:08:25 +00:00
|
|
|
&size, NULL);
|
2012-02-02 08:18:41 +00:00
|
|
|
grep_read_unlock();
|
2011-08-30 13:45:38 +00:00
|
|
|
|
2006-05-01 06:28:15 +00:00
|
|
|
if (!data)
|
2015-11-10 02:22:28 +00:00
|
|
|
die(_("unable to read tree (%s)"), oid_to_hex(&obj->oid));
|
2010-12-17 12:44:25 +00:00
|
|
|
|
|
|
|
len = name ? strlen(name) : 0;
|
|
|
|
strbuf_init(&base, PATH_MAX + len + 1);
|
|
|
|
if (len) {
|
|
|
|
strbuf_add(&base, name, len);
|
|
|
|
strbuf_addch(&base, ':');
|
|
|
|
}
|
2007-03-21 17:08:25 +00:00
|
|
|
init_tree_desc(&tree, data, size);
|
2012-10-12 10:49:38 +00:00
|
|
|
hit = grep_tree(opt, pathspec, &tree, &base, base.len,
|
2019-01-12 02:13:22 +00:00
|
|
|
obj->type == OBJ_COMMIT);
|
2010-12-17 12:44:25 +00:00
|
|
|
strbuf_release(&base);
|
2006-05-01 06:28:15 +00:00
|
|
|
free(data);
|
|
|
|
return hit;
|
|
|
|
}
|
2018-02-14 18:59:24 +00:00
|
|
|
die(_("unable to grep from object of type %s"), type_name(obj->type));
|
2006-05-01 06:28:15 +00:00
|
|
|
}
|
|
|
|
|
2010-12-15 15:02:51 +00:00
|
|
|
static int grep_objects(struct grep_opt *opt, const struct pathspec *pathspec,
|
2010-06-12 16:31:18 +00:00
|
|
|
const struct object_array *list)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
int hit = 0;
|
|
|
|
const unsigned int nr = list->nr;
|
|
|
|
|
|
|
|
for (i = 0; i < nr; i++) {
|
|
|
|
struct object *real_obj;
|
2019-01-12 02:13:22 +00:00
|
|
|
real_obj = deref_tag(opt->repo, list->objects[i].item,
|
2018-06-29 01:22:05 +00:00
|
|
|
NULL, 0);
|
2016-12-16 19:03:21 +00:00
|
|
|
|
|
|
|
/* load the gitmodules file for this rev */
|
|
|
|
if (recurse_submodules) {
|
2019-01-12 02:13:22 +00:00
|
|
|
submodule_free(opt->repo);
|
2017-07-13 23:49:20 +00:00
|
|
|
gitmodules_config_oid(&real_obj->oid);
|
2016-12-16 19:03:21 +00:00
|
|
|
}
|
2018-03-28 22:35:27 +00:00
|
|
|
if (grep_object(opt, pathspec, real_obj, list->objects[i].name,
|
|
|
|
list->objects[i].path)) {
|
2010-06-12 16:31:18 +00:00
|
|
|
hit = 1;
|
|
|
|
if (opt->status_only)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return hit;
|
|
|
|
}
|
|
|
|
|
2011-10-05 01:40:41 +00:00
|
|
|
static int grep_directory(struct grep_opt *opt, const struct pathspec *pathspec,
|
grep: turn off gitlink detection for --no-index
If we are running "git grep --no-index" outside of a git
repository, we behave roughly like "grep -r", examining all
files in the current directory and its subdirectories.
However, because we use fill_directory() to do the
recursion, it will skip over any directories which look like
sub-repositories.
For a normal git operation (like "git grep" in a repository)
this makes sense; we do not want to cross the boundary out
of our current repository into a submodule. But for
"--no-index" without a repository, we should look at all
files, including embedded repositories.
There is one exception, though: we probably should _not_
descend into ".git" directories. Doing so is inefficient and
unlikely to turn up useful hits.
This patch drops our use of dir.c's gitlink-detection, but
we do still avoid ".git". That makes us more like tools such
as "ack" or "ag", which also know to avoid cruft in .git.
As a bonus, this also drops our usage of the ref code
when we are outside of a repository, making the transition
to pluggable ref backends cleaner.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-03-07 15:51:21 +00:00
|
|
|
int exc_std, int use_index)
|
2010-02-06 18:40:08 +00:00
|
|
|
{
|
|
|
|
struct dir_struct dir;
|
|
|
|
int i, hit = 0;
|
|
|
|
|
|
|
|
memset(&dir, 0, sizeof(dir));
|
grep: turn off gitlink detection for --no-index
If we are running "git grep --no-index" outside of a git
repository, we behave roughly like "grep -r", examining all
files in the current directory and its subdirectories.
However, because we use fill_directory() to do the
recursion, it will skip over any directories which look like
sub-repositories.
For a normal git operation (like "git grep" in a repository)
this makes sense; we do not want to cross the boundary out
of our current repository into a submodule. But for
"--no-index" without a repository, we should look at all
files, including embedded repositories.
There is one exception, though: we probably should _not_
descend into ".git" directories. Doing so is inefficient and
unlikely to turn up useful hits.
This patch drops our use of dir.c's gitlink-detection, but
we do still avoid ".git". That makes us more like tools such
as "ack" or "ag", which also know to avoid cruft in .git.
As a bonus, this also drops our usage of the ref code
when we are outside of a repository, making the transition
to pluggable ref backends cleaner.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-03-07 15:51:21 +00:00
|
|
|
if (!use_index)
|
|
|
|
dir.flags |= DIR_NO_GITLINKS;
|
2011-09-27 20:43:12 +00:00
|
|
|
if (exc_std)
|
|
|
|
setup_standard_excludes(&dir);
|
2010-02-06 18:40:08 +00:00
|
|
|
|
2019-01-12 02:13:22 +00:00
|
|
|
fill_directory(&dir, opt->repo->index, pathspec);
|
2010-02-06 18:40:08 +00:00
|
|
|
for (i = 0; i < dir.nr; i++) {
|
2019-01-12 02:13:22 +00:00
|
|
|
if (!dir_path_match(opt->repo->index, dir.entries[i], pathspec, 0, NULL))
|
2011-02-16 22:39:00 +00:00
|
|
|
continue;
|
2010-02-06 18:40:08 +00:00
|
|
|
hit |= grep_file(opt, dir.entries[i]->name);
|
|
|
|
if (hit && opt->status_only)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return hit;
|
|
|
|
}
|
|
|
|
|
2009-05-20 22:05:22 +00:00
|
|
|
static int context_callback(const struct option *opt, const char *arg,
|
|
|
|
int unset)
|
2009-05-07 19:46:48 +00:00
|
|
|
{
|
|
|
|
struct grep_opt *grep_opt = opt->value;
|
|
|
|
int value;
|
|
|
|
const char *endp;
|
|
|
|
|
|
|
|
if (unset) {
|
|
|
|
grep_opt->pre_context = grep_opt->post_context = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
value = strtol(arg, (char **)&endp, 10);
|
|
|
|
if (*endp) {
|
2011-02-22 23:41:55 +00:00
|
|
|
return error(_("switch `%c' expects a numerical value"),
|
2009-05-07 19:46:48 +00:00
|
|
|
opt->short_name);
|
|
|
|
}
|
|
|
|
grep_opt->pre_context = grep_opt->post_context = value;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-20 22:05:22 +00:00
|
|
|
static int file_callback(const struct option *opt, const char *arg, int unset)
|
2009-05-07 19:46:48 +00:00
|
|
|
{
|
|
|
|
struct grep_opt *grep_opt = opt->value;
|
assert NOARG/NONEG behavior of parse-options callbacks
When we define a parse-options callback, the flags we put in the option
struct must match what the callback expects. For example, a callback
which does not handle the "unset" parameter should only be used with
PARSE_OPT_NONEG. But since the callback and the option struct are not
defined next to each other, it's easy to get this wrong (as earlier
patches in this series show).
Fortunately, the compiler can help us here: compiling with
-Wunused-parameters can show us which callbacks ignore their "unset"
parameters (and likewise, ones that ignore "arg" expect to be triggered
with PARSE_OPT_NOARG).
But after we've inspected a callback and determined that all of its
callers use the right flags, what do we do next? We'd like to silence
the compiler warning, but do so in a way that will catch any wrong calls
in the future.
We can do that by actually checking those variables and asserting that
they match our expectations. Because this is such a common pattern,
we'll introduce some helper macros. The resulting messages aren't
as descriptive as we could make them, but the file/line information from
BUG() is enough to identify the problem (and anyway, the point is that
these should never be seen).
Each of the annotated callbacks in this patch triggers
-Wunused-parameters, and was manually inspected to make sure all callers
use the correct options (so none of these BUGs should be triggerable).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-05 06:45:42 +00:00
|
|
|
int from_stdin;
|
2009-05-07 19:46:48 +00:00
|
|
|
FILE *patterns;
|
|
|
|
int lno = 0;
|
2009-10-16 14:13:25 +00:00
|
|
|
struct strbuf sb = STRBUF_INIT;
|
2009-05-07 19:46:48 +00:00
|
|
|
|
assert NOARG/NONEG behavior of parse-options callbacks
When we define a parse-options callback, the flags we put in the option
struct must match what the callback expects. For example, a callback
which does not handle the "unset" parameter should only be used with
PARSE_OPT_NONEG. But since the callback and the option struct are not
defined next to each other, it's easy to get this wrong (as earlier
patches in this series show).
Fortunately, the compiler can help us here: compiling with
-Wunused-parameters can show us which callbacks ignore their "unset"
parameters (and likewise, ones that ignore "arg" expect to be triggered
with PARSE_OPT_NOARG).
But after we've inspected a callback and determined that all of its
callers use the right flags, what do we do next? We'd like to silence
the compiler warning, but do so in a way that will catch any wrong calls
in the future.
We can do that by actually checking those variables and asserting that
they match our expectations. Because this is such a common pattern,
we'll introduce some helper macros. The resulting messages aren't
as descriptive as we could make them, but the file/line information from
BUG() is enough to identify the problem (and anyway, the point is that
these should never be seen).
Each of the annotated callbacks in this patch triggers
-Wunused-parameters, and was manually inspected to make sure all callers
use the correct options (so none of these BUGs should be triggerable).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-05 06:45:42 +00:00
|
|
|
BUG_ON_OPT_NEG(unset);
|
|
|
|
|
|
|
|
from_stdin = !strcmp(arg, "-");
|
2011-03-19 18:33:15 +00:00
|
|
|
patterns = from_stdin ? stdin : fopen(arg, "r");
|
2009-05-07 19:46:48 +00:00
|
|
|
if (!patterns)
|
2011-02-22 23:41:55 +00:00
|
|
|
die_errno(_("cannot open '%s'"), arg);
|
2015-10-28 20:53:47 +00:00
|
|
|
while (strbuf_getline(&sb, patterns) == 0) {
|
2009-05-07 19:46:48 +00:00
|
|
|
/* ignore empty line like grep does */
|
|
|
|
if (sb.len == 0)
|
|
|
|
continue;
|
2010-05-22 21:43:43 +00:00
|
|
|
|
2012-05-21 16:10:09 +00:00
|
|
|
append_grep_pat(grep_opt, sb.buf, sb.len, arg, ++lno,
|
|
|
|
GREP_PATTERN);
|
2009-05-07 19:46:48 +00:00
|
|
|
}
|
2011-03-19 18:33:15 +00:00
|
|
|
if (!from_stdin)
|
|
|
|
fclose(patterns);
|
2009-05-07 19:46:48 +00:00
|
|
|
strbuf_release(&sb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-20 22:05:22 +00:00
|
|
|
static int not_callback(const struct option *opt, const char *arg, int unset)
|
2009-05-07 19:46:48 +00:00
|
|
|
{
|
|
|
|
struct grep_opt *grep_opt = opt->value;
|
assert NOARG/NONEG behavior of parse-options callbacks
When we define a parse-options callback, the flags we put in the option
struct must match what the callback expects. For example, a callback
which does not handle the "unset" parameter should only be used with
PARSE_OPT_NONEG. But since the callback and the option struct are not
defined next to each other, it's easy to get this wrong (as earlier
patches in this series show).
Fortunately, the compiler can help us here: compiling with
-Wunused-parameters can show us which callbacks ignore their "unset"
parameters (and likewise, ones that ignore "arg" expect to be triggered
with PARSE_OPT_NOARG).
But after we've inspected a callback and determined that all of its
callers use the right flags, what do we do next? We'd like to silence
the compiler warning, but do so in a way that will catch any wrong calls
in the future.
We can do that by actually checking those variables and asserting that
they match our expectations. Because this is such a common pattern,
we'll introduce some helper macros. The resulting messages aren't
as descriptive as we could make them, but the file/line information from
BUG() is enough to identify the problem (and anyway, the point is that
these should never be seen).
Each of the annotated callbacks in this patch triggers
-Wunused-parameters, and was manually inspected to make sure all callers
use the correct options (so none of these BUGs should be triggerable).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-05 06:45:42 +00:00
|
|
|
BUG_ON_OPT_NEG(unset);
|
|
|
|
BUG_ON_OPT_ARG(arg);
|
2009-05-07 19:46:48 +00:00
|
|
|
append_grep_pattern(grep_opt, "--not", "command line", 0, GREP_NOT);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-20 22:05:22 +00:00
|
|
|
static int and_callback(const struct option *opt, const char *arg, int unset)
|
2009-05-07 19:46:48 +00:00
|
|
|
{
|
|
|
|
struct grep_opt *grep_opt = opt->value;
|
assert NOARG/NONEG behavior of parse-options callbacks
When we define a parse-options callback, the flags we put in the option
struct must match what the callback expects. For example, a callback
which does not handle the "unset" parameter should only be used with
PARSE_OPT_NONEG. But since the callback and the option struct are not
defined next to each other, it's easy to get this wrong (as earlier
patches in this series show).
Fortunately, the compiler can help us here: compiling with
-Wunused-parameters can show us which callbacks ignore their "unset"
parameters (and likewise, ones that ignore "arg" expect to be triggered
with PARSE_OPT_NOARG).
But after we've inspected a callback and determined that all of its
callers use the right flags, what do we do next? We'd like to silence
the compiler warning, but do so in a way that will catch any wrong calls
in the future.
We can do that by actually checking those variables and asserting that
they match our expectations. Because this is such a common pattern,
we'll introduce some helper macros. The resulting messages aren't
as descriptive as we could make them, but the file/line information from
BUG() is enough to identify the problem (and anyway, the point is that
these should never be seen).
Each of the annotated callbacks in this patch triggers
-Wunused-parameters, and was manually inspected to make sure all callers
use the correct options (so none of these BUGs should be triggerable).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-05 06:45:42 +00:00
|
|
|
BUG_ON_OPT_NEG(unset);
|
|
|
|
BUG_ON_OPT_ARG(arg);
|
2009-05-07 19:46:48 +00:00
|
|
|
append_grep_pattern(grep_opt, "--and", "command line", 0, GREP_AND);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-20 22:05:22 +00:00
|
|
|
static int open_callback(const struct option *opt, const char *arg, int unset)
|
2009-05-07 19:46:48 +00:00
|
|
|
{
|
|
|
|
struct grep_opt *grep_opt = opt->value;
|
assert NOARG/NONEG behavior of parse-options callbacks
When we define a parse-options callback, the flags we put in the option
struct must match what the callback expects. For example, a callback
which does not handle the "unset" parameter should only be used with
PARSE_OPT_NONEG. But since the callback and the option struct are not
defined next to each other, it's easy to get this wrong (as earlier
patches in this series show).
Fortunately, the compiler can help us here: compiling with
-Wunused-parameters can show us which callbacks ignore their "unset"
parameters (and likewise, ones that ignore "arg" expect to be triggered
with PARSE_OPT_NOARG).
But after we've inspected a callback and determined that all of its
callers use the right flags, what do we do next? We'd like to silence
the compiler warning, but do so in a way that will catch any wrong calls
in the future.
We can do that by actually checking those variables and asserting that
they match our expectations. Because this is such a common pattern,
we'll introduce some helper macros. The resulting messages aren't
as descriptive as we could make them, but the file/line information from
BUG() is enough to identify the problem (and anyway, the point is that
these should never be seen).
Each of the annotated callbacks in this patch triggers
-Wunused-parameters, and was manually inspected to make sure all callers
use the correct options (so none of these BUGs should be triggerable).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-05 06:45:42 +00:00
|
|
|
BUG_ON_OPT_NEG(unset);
|
|
|
|
BUG_ON_OPT_ARG(arg);
|
2009-05-07 19:46:48 +00:00
|
|
|
append_grep_pattern(grep_opt, "(", "command line", 0, GREP_OPEN_PAREN);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-20 22:05:22 +00:00
|
|
|
static int close_callback(const struct option *opt, const char *arg, int unset)
|
2009-05-07 19:46:48 +00:00
|
|
|
{
|
|
|
|
struct grep_opt *grep_opt = opt->value;
|
assert NOARG/NONEG behavior of parse-options callbacks
When we define a parse-options callback, the flags we put in the option
struct must match what the callback expects. For example, a callback
which does not handle the "unset" parameter should only be used with
PARSE_OPT_NONEG. But since the callback and the option struct are not
defined next to each other, it's easy to get this wrong (as earlier
patches in this series show).
Fortunately, the compiler can help us here: compiling with
-Wunused-parameters can show us which callbacks ignore their "unset"
parameters (and likewise, ones that ignore "arg" expect to be triggered
with PARSE_OPT_NOARG).
But after we've inspected a callback and determined that all of its
callers use the right flags, what do we do next? We'd like to silence
the compiler warning, but do so in a way that will catch any wrong calls
in the future.
We can do that by actually checking those variables and asserting that
they match our expectations. Because this is such a common pattern,
we'll introduce some helper macros. The resulting messages aren't
as descriptive as we could make them, but the file/line information from
BUG() is enough to identify the problem (and anyway, the point is that
these should never be seen).
Each of the annotated callbacks in this patch triggers
-Wunused-parameters, and was manually inspected to make sure all callers
use the correct options (so none of these BUGs should be triggerable).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-05 06:45:42 +00:00
|
|
|
BUG_ON_OPT_NEG(unset);
|
|
|
|
BUG_ON_OPT_ARG(arg);
|
2009-05-07 19:46:48 +00:00
|
|
|
append_grep_pattern(grep_opt, ")", "command line", 0, GREP_CLOSE_PAREN);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-05-20 22:05:22 +00:00
|
|
|
static int pattern_callback(const struct option *opt, const char *arg,
|
|
|
|
int unset)
|
2009-05-07 19:46:48 +00:00
|
|
|
{
|
|
|
|
struct grep_opt *grep_opt = opt->value;
|
assert NOARG/NONEG behavior of parse-options callbacks
When we define a parse-options callback, the flags we put in the option
struct must match what the callback expects. For example, a callback
which does not handle the "unset" parameter should only be used with
PARSE_OPT_NONEG. But since the callback and the option struct are not
defined next to each other, it's easy to get this wrong (as earlier
patches in this series show).
Fortunately, the compiler can help us here: compiling with
-Wunused-parameters can show us which callbacks ignore their "unset"
parameters (and likewise, ones that ignore "arg" expect to be triggered
with PARSE_OPT_NOARG).
But after we've inspected a callback and determined that all of its
callers use the right flags, what do we do next? We'd like to silence
the compiler warning, but do so in a way that will catch any wrong calls
in the future.
We can do that by actually checking those variables and asserting that
they match our expectations. Because this is such a common pattern,
we'll introduce some helper macros. The resulting messages aren't
as descriptive as we could make them, but the file/line information from
BUG() is enough to identify the problem (and anyway, the point is that
these should never be seen).
Each of the annotated callbacks in this patch triggers
-Wunused-parameters, and was manually inspected to make sure all callers
use the correct options (so none of these BUGs should be triggerable).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2018-11-05 06:45:42 +00:00
|
|
|
BUG_ON_OPT_NEG(unset);
|
2009-05-07 19:46:48 +00:00
|
|
|
append_grep_pattern(grep_opt, arg, "-e option", 0, GREP_PATTERN);
|
|
|
|
return 0;
|
|
|
|
}
|
2006-05-01 06:28:15 +00:00
|
|
|
|
2006-07-29 05:44:25 +00:00
|
|
|
int cmd_grep(int argc, const char **argv, const char *prefix)
|
2006-05-01 06:28:15 +00:00
|
|
|
{
|
|
|
|
int hit = 0;
|
2011-09-27 20:43:12 +00:00
|
|
|
int cached = 0, untracked = 0, opt_exclude = -1;
|
2006-05-09 06:55:47 +00:00
|
|
|
int seen_dashdash = 0;
|
2010-01-13 03:06:41 +00:00
|
|
|
int external_grep_allowed__ignored;
|
2010-06-12 16:39:46 +00:00
|
|
|
const char *show_in_pager = NULL, *default_pager = "dummy";
|
2006-05-01 06:28:15 +00:00
|
|
|
struct grep_opt opt;
|
2010-08-29 02:04:17 +00:00
|
|
|
struct object_array list = OBJECT_ARRAY_INIT;
|
2010-12-15 15:02:51 +00:00
|
|
|
struct pathspec pathspec;
|
2010-07-04 19:46:19 +00:00
|
|
|
struct string_list path_list = STRING_LIST_INIT_NODUP;
|
2006-05-09 06:55:47 +00:00
|
|
|
int i;
|
2009-05-07 19:46:48 +00:00
|
|
|
int dummy;
|
2010-08-06 03:06:39 +00:00
|
|
|
int use_index = 1;
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
int pattern_type_arg = GREP_PATTERN_TYPE_UNSPECIFIED;
|
2017-02-14 21:54:36 +00:00
|
|
|
int allow_revs;
|
2011-05-10 01:48:36 +00:00
|
|
|
|
2009-05-07 19:46:48 +00:00
|
|
|
struct option options[] = {
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "cached", &cached,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("search in index instead of in the work tree")),
|
2012-02-28 19:06:09 +00:00
|
|
|
OPT_NEGBIT(0, "no-index", &use_index,
|
2012-08-20 12:32:55 +00:00
|
|
|
N_("find in contents not managed by git"), 1),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "untracked", &untracked,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("search in both tracked and untracked files")),
|
2011-09-27 20:43:12 +00:00
|
|
|
OPT_SET_INT(0, "exclude-standard", &opt_exclude,
|
2015-02-27 14:01:58 +00:00
|
|
|
N_("ignore files specified via '.gitignore'"), 1),
|
2016-12-16 19:03:20 +00:00
|
|
|
OPT_BOOL(0, "recurse-submodules", &recurse_submodules,
|
2017-03-17 17:22:53 +00:00
|
|
|
N_("recursively search in each submodule")),
|
2009-05-07 19:46:48 +00:00
|
|
|
OPT_GROUP(""),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('v', "invert-match", &opt.invert,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("show non-matching lines")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('i', "ignore-case", &opt.ignore_case,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("case insensitive matching")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('w', "word-regexp", &opt.word_regexp,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("match patterns only at word boundaries")),
|
2009-05-07 19:46:48 +00:00
|
|
|
OPT_SET_INT('a', "text", &opt.binary,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("process binary files as text"), GREP_BINARY_TEXT),
|
2009-05-07 19:46:48 +00:00
|
|
|
OPT_SET_INT('I', NULL, &opt.binary,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("don't match patterns in binary files"),
|
2009-05-07 19:46:48 +00:00
|
|
|
GREP_BINARY_NOMATCH),
|
2013-05-10 15:10:15 +00:00
|
|
|
OPT_BOOL(0, "textconv", &opt.allow_textconv,
|
|
|
|
N_("process binary files with textconv filters")),
|
2018-10-01 19:15:57 +00:00
|
|
|
OPT_SET_INT('r', "recursive", &opt.max_depth,
|
|
|
|
N_("search in subdirectories (default)"), -1),
|
2012-08-20 12:32:15 +00:00
|
|
|
{ OPTION_INTEGER, 0, "max-depth", &opt.max_depth, N_("depth"),
|
|
|
|
N_("descend at most <depth> levels"), PARSE_OPT_NONEG,
|
grep: Add --max-depth option.
It is useful to grep directories non-recursively, e.g. when one wants to
look for all files in the toplevel directory, but not in any subdirectory,
or in Documentation/, but not in Documentation/technical/.
This patch adds support for --max-depth <depth> option to git-grep. If it is
given, git-grep descends at most <depth> levels of directories below paths
specified on the command line.
Note that if path specified on command line contains wildcards, this option
makes no sense, e.g.
$ git grep -l --max-depth 0 GNU -- 'contrib/*'
(note the quotes) will search all files in contrib/, even in
subdirectories, because '*' matches all files.
Documentation updates, bash-completion and simple test cases are also
provided.
Signed-off-by: Michał Kiedrowicz <michal.kiedrowicz@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2009-07-22 17:52:15 +00:00
|
|
|
NULL, 1 },
|
2009-05-07 19:46:48 +00:00
|
|
|
OPT_GROUP(""),
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
OPT_SET_INT('E', "extended-regexp", &pattern_type_arg,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("use extended POSIX regular expressions"),
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
GREP_PATTERN_TYPE_ERE),
|
|
|
|
OPT_SET_INT('G', "basic-regexp", &pattern_type_arg,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("use basic POSIX regular expressions (default)"),
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
GREP_PATTERN_TYPE_BRE),
|
|
|
|
OPT_SET_INT('F', "fixed-strings", &pattern_type_arg,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("interpret patterns as fixed strings"),
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
GREP_PATTERN_TYPE_FIXED),
|
|
|
|
OPT_SET_INT('P', "perl-regexp", &pattern_type_arg,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("use Perl-compatible regular expressions"),
|
grep: add a grep.patternType configuration setting
The grep.extendedRegexp configuration setting enables the -E flag on grep
by default but there are no equivalents for the -G, -F and -P flags.
Rather than adding an additional setting for grep.fooRegexp for current
and future pattern matching options, add a grep.patternType setting that
can accept appropriate values for modifying the default grep pattern
matching behavior. The current values are "basic", "extended", "fixed",
"perl" and "default" for setting -G, -E, -F, -P and the default behavior
respectively.
When grep.patternType is set to a value other than "default", the
grep.extendedRegexp setting is ignored. The value of "default" restores
the current default behavior, including the grep.extendedRegexp
behavior.
Signed-off-by: J Smith <dark.panda@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2012-08-03 14:53:50 +00:00
|
|
|
GREP_PATTERN_TYPE_PCRE),
|
2009-05-07 19:46:48 +00:00
|
|
|
OPT_GROUP(""),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('n', "line-number", &opt.linenum, N_("show line numbers")),
|
2018-06-22 15:49:45 +00:00
|
|
|
OPT_BOOL(0, "column", &opt.columnnum, N_("show column number of first match")),
|
2012-08-20 12:32:15 +00:00
|
|
|
OPT_NEGBIT('h', NULL, &opt.pathname, N_("don't show filenames"), 1),
|
|
|
|
OPT_BIT('H', NULL, &opt.pathname, N_("show filenames"), 1),
|
2009-05-07 19:46:48 +00:00
|
|
|
OPT_NEGBIT(0, "full-name", &opt.relative,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("show filenames relative to top directory"), 1),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('l', "files-with-matches", &opt.name_only,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("show only filenames instead of matching lines")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "name-only", &opt.name_only,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("synonym for --files-with-matches")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('L', "files-without-match",
|
2009-05-07 19:46:48 +00:00
|
|
|
&opt.unmatch_name_only,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("show only the names of files without match")),
|
2018-02-09 11:01:59 +00:00
|
|
|
OPT_BOOL_F('z', "null", &opt.null_following_name,
|
|
|
|
N_("print NUL after filenames"),
|
|
|
|
PARSE_OPT_NOCOMPLETE),
|
2018-07-09 20:33:47 +00:00
|
|
|
OPT_BOOL('o', "only-matching", &opt.only_matching,
|
|
|
|
N_("show only matching parts of a line")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('c', "count", &opt.count,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("show the number of matches instead of matching lines")),
|
|
|
|
OPT__COLOR(&opt.color, N_("highlight matches")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "break", &opt.file_break,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("print empty line between matches from different files")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "heading", &opt.heading,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("show filename only once above matches from same file")),
|
2009-05-07 19:46:48 +00:00
|
|
|
OPT_GROUP(""),
|
2012-08-20 12:32:15 +00:00
|
|
|
OPT_CALLBACK('C', "context", &opt, N_("n"),
|
|
|
|
N_("show <n> context lines before and after matches"),
|
2009-05-07 19:46:48 +00:00
|
|
|
context_callback),
|
2011-08-01 17:22:52 +00:00
|
|
|
OPT_INTEGER('B', "before-context", &opt.pre_context,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("show <n> context lines before matches")),
|
2011-08-01 17:22:52 +00:00
|
|
|
OPT_INTEGER('A', "after-context", &opt.post_context,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("show <n> context lines after matches")),
|
2015-12-15 15:31:39 +00:00
|
|
|
OPT_INTEGER(0, "threads", &num_threads,
|
|
|
|
N_("use <n> worker threads")),
|
2012-08-20 12:32:15 +00:00
|
|
|
OPT_NUMBER_CALLBACK(&opt, N_("shortcut for -C NUM"),
|
2009-05-07 19:46:48 +00:00
|
|
|
context_callback),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('p', "show-function", &opt.funcname,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("show a line with the function name before matches")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL('W', "function-context", &opt.funcbody,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("show the surrounding function")),
|
2009-05-07 19:46:48 +00:00
|
|
|
OPT_GROUP(""),
|
2012-08-20 12:32:15 +00:00
|
|
|
OPT_CALLBACK('f', NULL, &opt, N_("file"),
|
|
|
|
N_("read patterns from file"), file_callback),
|
|
|
|
{ OPTION_CALLBACK, 'e', NULL, &opt, N_("pattern"),
|
|
|
|
N_("match <pattern>"), PARSE_OPT_NONEG, pattern_callback },
|
2009-05-07 19:46:48 +00:00
|
|
|
{ OPTION_CALLBACK, 0, "and", &opt, NULL,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("combine patterns specified with -e"),
|
2009-05-07 19:46:48 +00:00
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG, and_callback },
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "or", &dummy, ""),
|
2009-05-07 19:46:48 +00:00
|
|
|
{ OPTION_CALLBACK, 0, "not", &opt, NULL, "",
|
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG, not_callback },
|
|
|
|
{ OPTION_CALLBACK, '(', NULL, &opt, NULL, "",
|
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH,
|
|
|
|
open_callback },
|
|
|
|
{ OPTION_CALLBACK, ')', NULL, &opt, NULL, "",
|
|
|
|
PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH,
|
|
|
|
close_callback },
|
2010-11-08 18:06:54 +00:00
|
|
|
OPT__QUIET(&opt.status_only,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("indicate hit with exit status without output")),
|
2013-08-03 11:51:19 +00:00
|
|
|
OPT_BOOL(0, "all-match", &opt.all_match,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("show only matches from files that match all patterns")),
|
2018-05-20 15:42:58 +00:00
|
|
|
OPT_SET_INT_F(0, "debug", &opt.debug,
|
|
|
|
N_("show parse tree for grep expression"),
|
|
|
|
1, PARSE_OPT_HIDDEN),
|
2009-05-07 19:46:48 +00:00
|
|
|
OPT_GROUP(""),
|
2010-06-12 16:39:46 +00:00
|
|
|
{ OPTION_STRING, 'O', "open-files-in-pager", &show_in_pager,
|
2012-08-20 12:32:15 +00:00
|
|
|
N_("pager"), N_("show matching files in the pager"),
|
2018-02-09 11:01:59 +00:00
|
|
|
PARSE_OPT_OPTARG | PARSE_OPT_NOCOMPLETE,
|
|
|
|
NULL, (intptr_t)default_pager },
|
|
|
|
OPT_BOOL_F(0, "ext-grep", &external_grep_allowed__ignored,
|
|
|
|
N_("allow calling of grep(1) (ignored by this build)"),
|
|
|
|
PARSE_OPT_NOCOMPLETE),
|
2009-05-07 19:46:48 +00:00
|
|
|
OPT_END()
|
|
|
|
};
|
2006-05-01 06:28:15 +00:00
|
|
|
|
2018-09-21 15:57:23 +00:00
|
|
|
init_grep_defaults(the_repository);
|
2012-10-09 23:04:12 +00:00
|
|
|
git_config(grep_cmd_config, NULL);
|
2018-09-21 15:57:23 +00:00
|
|
|
grep_init(&opt, the_repository, prefix);
|
2009-03-07 12:32:32 +00:00
|
|
|
|
2006-05-01 06:28:15 +00:00
|
|
|
/*
|
2006-05-09 06:55:47 +00:00
|
|
|
* If there is no -- then the paths must exist in the working
|
|
|
|
* tree. If there is no explicit pattern specified with -e or
|
|
|
|
* -f, we take the first unrecognized non option to be the
|
|
|
|
* pattern, but then what follows it must be zero or more
|
|
|
|
* valid refs up to the -- (if exists), and then existing
|
|
|
|
* paths. If there is an explicit pattern, then the first
|
2006-07-10 05:50:18 +00:00
|
|
|
* unrecognized non option is the beginning of the refs list
|
2006-05-09 06:55:47 +00:00
|
|
|
* that continues up to the -- (if exists), and then paths.
|
2006-05-01 06:28:15 +00:00
|
|
|
*/
|
2009-05-23 18:53:12 +00:00
|
|
|
argc = parse_options(argc, argv, prefix, options, grep_usage,
|
2009-05-07 19:46:48 +00:00
|
|
|
PARSE_OPT_KEEP_DASHDASH |
|
2015-11-17 10:25:53 +00:00
|
|
|
PARSE_OPT_STOP_AT_NON_OPTION);
|
2012-10-03 21:47:48 +00:00
|
|
|
grep_commit_pattern_type(pattern_type_arg, &opt);
|
2009-05-07 19:46:48 +00:00
|
|
|
|
2016-01-12 10:40:26 +00:00
|
|
|
if (use_index && !startup_info->have_repository) {
|
|
|
|
int fallback = 0;
|
|
|
|
git_config_get_bool("grep.fallbacktonoindex", &fallback);
|
|
|
|
if (fallback)
|
|
|
|
use_index = 0;
|
|
|
|
else
|
|
|
|
/* die the same way as if we did it at the beginning */
|
|
|
|
setup_git_directory();
|
|
|
|
}
|
2010-02-06 18:40:08 +00:00
|
|
|
|
2010-02-07 04:44:15 +00:00
|
|
|
/*
|
|
|
|
* skip a -- separator; we know it cannot be
|
|
|
|
* separating revisions from pathnames if
|
|
|
|
* we haven't even had any patterns yet
|
|
|
|
*/
|
|
|
|
if (argc > 0 && !opt.pattern_list && !strcmp(argv[0], "--")) {
|
|
|
|
argv++;
|
|
|
|
argc--;
|
|
|
|
}
|
|
|
|
|
2009-05-07 19:46:48 +00:00
|
|
|
/* First unrecognized non-option token */
|
|
|
|
if (argc > 0 && !opt.pattern_list) {
|
|
|
|
append_grep_pattern(&opt, argv[0], "command line", 0,
|
|
|
|
GREP_PATTERN);
|
|
|
|
argv++;
|
|
|
|
argc--;
|
2006-05-01 06:28:15 +00:00
|
|
|
}
|
2006-05-09 06:55:47 +00:00
|
|
|
|
2010-06-12 16:39:46 +00:00
|
|
|
if (show_in_pager == default_pager)
|
|
|
|
show_in_pager = git_pager(1);
|
2010-06-12 16:36:51 +00:00
|
|
|
if (show_in_pager) {
|
2010-07-03 02:55:06 +00:00
|
|
|
opt.color = 0;
|
2010-06-12 16:39:46 +00:00
|
|
|
opt.name_only = 1;
|
|
|
|
opt.null_following_name = 1;
|
|
|
|
opt.output_priv = &path_list;
|
|
|
|
opt.output = append_path;
|
2010-06-25 23:41:39 +00:00
|
|
|
string_list_append(&path_list, show_in_pager);
|
2010-06-12 16:36:51 +00:00
|
|
|
}
|
|
|
|
|
2006-05-02 22:40:49 +00:00
|
|
|
if (!opt.pattern_list)
|
2018-07-21 07:49:19 +00:00
|
|
|
die(_("no pattern given"));
|
2010-01-25 22:51:39 +00:00
|
|
|
|
2018-07-09 20:33:47 +00:00
|
|
|
/* --only-matching has no effect with --invert. */
|
|
|
|
if (opt.invert)
|
|
|
|
opt.only_matching = 0;
|
|
|
|
|
grep: fix "--" rev/pathspec disambiguation
If we see "git grep pattern rev -- file" then we apply the
usual rev/pathspec disambiguation rules: any "rev" before
the "--" must be a revision, and we do not need to apply the
verify_non_filename() check.
But there are two bugs here:
1. We keep a seen_dashdash flag to handle this case, but
we set it in the same left-to-right pass over the
arguments in which we parse "rev".
So when we see "rev", we do not yet know that there is
a "--", and we mistakenly complain if there is a
matching file.
We can fix this by making a preliminary pass over the
arguments to find the "--", and only then checking the rev
arguments.
2. If we can't resolve "rev" but there isn't a dashdash,
that's OK. We treat it like a path, and complain later
if it doesn't exist.
But if there _is_ a dashdash, then we know it must be a
rev, and should treat it as such, complaining if it
does not resolve. The current code instead ignores it
and tries to treat it like a path.
This patch fixes both bugs, and tries to comment the parsing
flow a bit better.
It adds tests that cover the two bugs, but also some related
situations (which already worked, but this confirms that our
fixes did not break anything).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-02-14 06:05:55 +00:00
|
|
|
/*
|
|
|
|
* We have to find "--" in a separate pass, because its presence
|
|
|
|
* influences how we will parse arguments that come before it.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < argc; i++) {
|
|
|
|
if (!strcmp(argv[i], "--")) {
|
|
|
|
seen_dashdash = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Resolve any rev arguments. If we have a dashdash, then everything up
|
|
|
|
* to it must resolve as a rev. If not, then we stop at the first
|
|
|
|
* non-rev and assume everything else is a path.
|
|
|
|
*/
|
2017-02-14 21:54:36 +00:00
|
|
|
allow_revs = use_index && !untracked;
|
2009-05-07 19:46:48 +00:00
|
|
|
for (i = 0; i < argc; i++) {
|
2006-05-09 06:55:47 +00:00
|
|
|
const char *arg = argv[i];
|
2017-02-21 23:47:25 +00:00
|
|
|
struct object_id oid;
|
2013-05-10 15:10:16 +00:00
|
|
|
struct object_context oc;
|
2017-02-14 06:04:17 +00:00
|
|
|
struct object *object;
|
|
|
|
|
2017-02-14 06:03:03 +00:00
|
|
|
if (!strcmp(arg, "--")) {
|
|
|
|
i++;
|
|
|
|
break;
|
|
|
|
}
|
2017-02-14 06:04:17 +00:00
|
|
|
|
2017-02-14 21:54:36 +00:00
|
|
|
if (!allow_revs) {
|
grep: avoid resolving revision names in --no-index case
We disallow the use of revisions with --no-index, but we
don't actually check and complain until well after we've
parsed the revisions.
This is the cause of a few problems:
1. We shouldn't be calling get_sha1() at all when we aren't
in a repository, as it might access the ref or object
databases. For now, this should generally just return
failure, but eventually it will become a BUG().
2. When there's a "--" disambiguator and you're outside a
repository, we'll complain early with "unable to resolve
revision". But we can give a much more specific error.
3. When there isn't a "--" disambiguator, we still do the
normal rev/path checks. This is silly, as we know we
cannot have any revs with --no-index. Everything we see
must be a path.
Outside of a repository this doesn't matter (since we
know it won't resolve), but inside one, we may complain
unnecessarily if a filename happens to also match a
refname.
This patch skips the get_sha1() call entirely in the
no-index case, and behaves as if it failed (with the
exception of giving a better error message).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-02-14 06:07:29 +00:00
|
|
|
if (seen_dashdash)
|
2017-02-14 21:54:36 +00:00
|
|
|
die(_("--no-index or --untracked cannot be used with revs"));
|
grep: avoid resolving revision names in --no-index case
We disallow the use of revisions with --no-index, but we
don't actually check and complain until well after we've
parsed the revisions.
This is the cause of a few problems:
1. We shouldn't be calling get_sha1() at all when we aren't
in a repository, as it might access the ref or object
databases. For now, this should generally just return
failure, but eventually it will become a BUG().
2. When there's a "--" disambiguator and you're outside a
repository, we'll complain early with "unable to resolve
revision". But we can give a much more specific error.
3. When there isn't a "--" disambiguator, we still do the
normal rev/path checks. This is silly, as we know we
cannot have any revs with --no-index. Everything we see
must be a path.
Outside of a repository this doesn't matter (since we
know it won't resolve), but inside one, we may complain
unnecessarily if a filename happens to also match a
refname.
This patch skips the get_sha1() call entirely in the
no-index case, and behaves as if it failed (with the
exception of giving a better error message).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-02-14 06:07:29 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2019-01-12 02:13:28 +00:00
|
|
|
if (get_oid_with_context(the_repository, arg,
|
|
|
|
GET_OID_RECORD_PATH,
|
sha1_name: convert get_sha1* to get_oid*
Now that all the callers of get_sha1 directly or indirectly use struct
object_id, rename the functions starting with get_sha1 to start with
get_oid. Convert the internals in sha1_name.c to use struct object_id
as well, and eliminate explicit length checks where possible. Convert a
use of 40 in get_oid_basic to GIT_SHA1_HEXSZ.
Outside of sha1_name.c and cache.h, this transition was made with the
following semantic patch:
@@
expression E1, E2;
@@
- get_sha1(E1, E2.hash)
+ get_oid(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1(E1, E2->hash)
+ get_oid(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2.hash)
+ get_oid_committish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_committish(E1, E2->hash)
+ get_oid_committish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2.hash)
+ get_oid_treeish(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_treeish(E1, E2->hash)
+ get_oid_treeish(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2.hash)
+ get_oid_commit(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_commit(E1, E2->hash)
+ get_oid_commit(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2.hash)
+ get_oid_tree(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_tree(E1, E2->hash)
+ get_oid_tree(E1, E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2.hash)
+ get_oid_blob(E1, &E2)
@@
expression E1, E2;
@@
- get_sha1_blob(E1, E2->hash)
+ get_oid_blob(E1, E2)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3.hash, E4)
+ get_oid_with_context(E1, E2, &E3, E4)
@@
expression E1, E2, E3, E4;
@@
- get_sha1_with_context(E1, E2, E3->hash, E4)
+ get_oid_with_context(E1, E2, E3, E4)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-07-13 23:49:28 +00:00
|
|
|
&oid, &oc)) {
|
grep: fix "--" rev/pathspec disambiguation
If we see "git grep pattern rev -- file" then we apply the
usual rev/pathspec disambiguation rules: any "rev" before
the "--" must be a revision, and we do not need to apply the
verify_non_filename() check.
But there are two bugs here:
1. We keep a seen_dashdash flag to handle this case, but
we set it in the same left-to-right pass over the
arguments in which we parse "rev".
So when we see "rev", we do not yet know that there is
a "--", and we mistakenly complain if there is a
matching file.
We can fix this by making a preliminary pass over the
arguments to find the "--", and only then checking the rev
arguments.
2. If we can't resolve "rev" but there isn't a dashdash,
that's OK. We treat it like a path, and complain later
if it doesn't exist.
But if there _is_ a dashdash, then we know it must be a
rev, and should treat it as such, complaining if it
does not resolve. The current code instead ignores it
and tries to treat it like a path.
This patch fixes both bugs, and tries to comment the parsing
flow a bit better.
It adds tests that cover the two bugs, but also some related
situations (which already worked, but this confirms that our
fixes did not break anything).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-02-14 06:05:55 +00:00
|
|
|
if (seen_dashdash)
|
|
|
|
die(_("unable to resolve revision: %s"), arg);
|
2017-02-14 06:04:17 +00:00
|
|
|
break;
|
grep: fix "--" rev/pathspec disambiguation
If we see "git grep pattern rev -- file" then we apply the
usual rev/pathspec disambiguation rules: any "rev" before
the "--" must be a revision, and we do not need to apply the
verify_non_filename() check.
But there are two bugs here:
1. We keep a seen_dashdash flag to handle this case, but
we set it in the same left-to-right pass over the
arguments in which we parse "rev".
So when we see "rev", we do not yet know that there is
a "--", and we mistakenly complain if there is a
matching file.
We can fix this by making a preliminary pass over the
arguments to find the "--", and only then checking the rev
arguments.
2. If we can't resolve "rev" but there isn't a dashdash,
that's OK. We treat it like a path, and complain later
if it doesn't exist.
But if there _is_ a dashdash, then we know it must be a
rev, and should treat it as such, complaining if it
does not resolve. The current code instead ignores it
and tries to treat it like a path.
This patch fixes both bugs, and tries to comment the parsing
flow a bit better.
It adds tests that cover the two bugs, but also some related
situations (which already worked, but this confirms that our
fixes did not break anything).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-02-14 06:05:55 +00:00
|
|
|
}
|
2017-02-14 06:04:17 +00:00
|
|
|
|
object: convert parse_object* to take struct object_id
Make parse_object, parse_object_or_die, and parse_object_buffer take a
pointer to struct object_id. Remove the temporary variables inserted
earlier, since they are no longer necessary. Transform all of the
callers using the following semantic patch:
@@
expression E1;
@@
- parse_object(E1.hash)
+ parse_object(&E1)
@@
expression E1;
@@
- parse_object(E1->hash)
+ parse_object(E1)
@@
expression E1, E2;
@@
- parse_object_or_die(E1.hash, E2)
+ parse_object_or_die(&E1, E2)
@@
expression E1, E2;
@@
- parse_object_or_die(E1->hash, E2)
+ parse_object_or_die(E1, E2)
@@
expression E1, E2, E3, E4, E5;
@@
- parse_object_buffer(E1.hash, E2, E3, E4, E5)
+ parse_object_buffer(&E1, E2, E3, E4, E5)
@@
expression E1, E2, E3, E4, E5;
@@
- parse_object_buffer(E1->hash, E2, E3, E4, E5)
+ parse_object_buffer(E1, E2, E3, E4, E5)
Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-06 22:10:38 +00:00
|
|
|
object = parse_object_or_die(&oid, arg);
|
2017-02-14 06:04:17 +00:00
|
|
|
if (!seen_dashdash)
|
|
|
|
verify_non_filename(prefix, arg);
|
|
|
|
add_object_array_with_path(object, arg, &list, oc.mode, oc.path);
|
2017-05-19 12:54:43 +00:00
|
|
|
free(oc.path);
|
2006-05-01 22:58:29 +00:00
|
|
|
}
|
2006-05-09 06:55:47 +00:00
|
|
|
|
grep: fix "--" rev/pathspec disambiguation
If we see "git grep pattern rev -- file" then we apply the
usual rev/pathspec disambiguation rules: any "rev" before
the "--" must be a revision, and we do not need to apply the
verify_non_filename() check.
But there are two bugs here:
1. We keep a seen_dashdash flag to handle this case, but
we set it in the same left-to-right pass over the
arguments in which we parse "rev".
So when we see "rev", we do not yet know that there is
a "--", and we mistakenly complain if there is a
matching file.
We can fix this by making a preliminary pass over the
arguments to find the "--", and only then checking the rev
arguments.
2. If we can't resolve "rev" but there isn't a dashdash,
that's OK. We treat it like a path, and complain later
if it doesn't exist.
But if there _is_ a dashdash, then we know it must be a
rev, and should treat it as such, complaining if it
does not resolve. The current code instead ignores it
and tries to treat it like a path.
This patch fixes both bugs, and tries to comment the parsing
flow a bit better.
It adds tests that cover the two bugs, but also some related
situations (which already worked, but this confirms that our
fixes did not break anything).
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-02-14 06:05:55 +00:00
|
|
|
/*
|
|
|
|
* Anything left over is presumed to be a path. But in the non-dashdash
|
|
|
|
* "do what I mean" case, we verify and complain when that isn't true.
|
|
|
|
*/
|
2017-02-14 06:02:38 +00:00
|
|
|
if (!seen_dashdash) {
|
|
|
|
int j;
|
|
|
|
for (j = i; j < argc; j++)
|
2017-02-14 21:54:36 +00:00
|
|
|
verify_filename(prefix, argv[j], j == i && allow_revs);
|
2017-02-14 06:02:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
parse_pathspec(&pathspec, 0,
|
|
|
|
PATHSPEC_PREFER_CWD |
|
|
|
|
(opt.max_depth != -1 ? PATHSPEC_MAXDEPTH_VALID : 0),
|
|
|
|
prefix, argv + i);
|
|
|
|
pathspec.max_depth = opt.max_depth;
|
|
|
|
pathspec.recursive = 1;
|
2017-12-05 00:07:34 +00:00
|
|
|
pathspec.recurse_submodules = !!recurse_submodules;
|
2017-02-14 06:02:38 +00:00
|
|
|
|
2018-11-03 08:48:44 +00:00
|
|
|
if (list.nr || cached || show_in_pager) {
|
|
|
|
if (num_threads > 1)
|
|
|
|
warning(_("invalid option combination, ignoring --threads"));
|
|
|
|
num_threads = 1;
|
|
|
|
} else if (!HAVE_THREADS && num_threads > 1) {
|
2017-05-25 19:45:34 +00:00
|
|
|
warning(_("no threads support, ignoring --threads"));
|
2018-11-03 08:48:44 +00:00
|
|
|
num_threads = 1;
|
|
|
|
} else if (num_threads < 0)
|
|
|
|
die(_("invalid number of threads specified (%d)"), num_threads);
|
|
|
|
else if (num_threads == 0)
|
|
|
|
num_threads = HAVE_THREADS ? GREP_NUM_THREADS_DEFAULT : 1;
|
2011-12-12 21:16:08 +00:00
|
|
|
|
2018-11-03 08:48:44 +00:00
|
|
|
if (num_threads > 1) {
|
|
|
|
if (!HAVE_THREADS)
|
|
|
|
BUG("Somebody got num_threads calculation wrong!");
|
|
|
|
if (!(opt.name_only || opt.unmatch_name_only || opt.count)
|
|
|
|
&& (opt.pre_context || opt.post_context ||
|
|
|
|
opt.file_break || opt.funcbody))
|
|
|
|
skip_first_line = 1;
|
|
|
|
start_threads(&opt);
|
2018-11-03 08:48:43 +00:00
|
|
|
} else {
|
grep: don't redundantly compile throwaway patterns under threading
Change the pattern compilation logic under threading so that grep
doesn't compile a pattern it never ends up using on the non-threaded
code path, only to compile it again N times for N threads which will
each use their own copy, ignoring the initially compiled pattern.
This redundant compilation dates back to the initial introduction of
the threaded grep in commit 5b594f457a ("Threaded grep",
2010-01-25).
There was never any reason for doing this redundant work other than an
oversight in the initial commit. Jeff King suggested on-list in
<20170414212325.fefrl3qdjigwyitd@sigill.intra.peff.net> that this
might be needed to check the pattern for sanity before threaded
execution commences.
That's not the case. The pattern is compiled under threading in
start_threads() before any concurrent execution has started by calling
pthread_create(), so if the pattern contains an error we still do the
right thing. I.e. die with one error before any threaded execution has
commenced, instead of e.g. spewing out an error for each N threads,
which could be a regression a change like this might inadvertently
introduce.
This change is not meant as an optimization, any performance gains
from this are in the hundreds to thousands of nanoseconds at most. If
we wanted more performance here we could just re-use the compiled
patterns in multiple threads (regcomp(3) is thread-safe), or partially
re-use them and the associated structures in the case of later PCRE
JIT changes.
Rather, it's just to make the code easier to reason about. It's
confusing to debug this under threading & non-threading when the
threading codepaths redundantly compile a pattern which is never used.
The reason the patterns are recompiled is as a side-effect of
duplicating the whole grep_opt structure, which is not thread safe,
writable, and munged during execution. The grep_opt structure then
points to the grep_pat structure where pattern or patterns are stored.
I looked into e.g. splitting the API into some "do & alloc threadsafe
stuff", "spawn thread", "do and alloc non-threadsafe stuff", but the
execution time of grep_opt_dup() & pattern compilation is trivial
compared to actually executing the grep, so there was no point. Even
with the more expensive JIT changes to follow the most expensive PCRE
patterns take something like 0.0X milliseconds to compile at most[1].
The undocumented --debug mode added in commit 17bf35a3c7 ("grep: teach
--debug option to dump the parse tree", 2012-09-13) still works
properly with this change. It only emits debugging info during pattern
compilation, which is now dumped by the pattern compiled just before
the first thread is started.
1. http://sljit.sourceforge.net/pcre.html
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-25 20:05:22 +00:00
|
|
|
/*
|
|
|
|
* The compiled patterns on the main path are only
|
|
|
|
* used when not using threading. Otherwise
|
2018-11-03 08:48:44 +00:00
|
|
|
* start_threads() above calls compile_grep_patterns()
|
grep: don't redundantly compile throwaway patterns under threading
Change the pattern compilation logic under threading so that grep
doesn't compile a pattern it never ends up using on the non-threaded
code path, only to compile it again N times for N threads which will
each use their own copy, ignoring the initially compiled pattern.
This redundant compilation dates back to the initial introduction of
the threaded grep in commit 5b594f457a ("Threaded grep",
2010-01-25).
There was never any reason for doing this redundant work other than an
oversight in the initial commit. Jeff King suggested on-list in
<20170414212325.fefrl3qdjigwyitd@sigill.intra.peff.net> that this
might be needed to check the pattern for sanity before threaded
execution commences.
That's not the case. The pattern is compiled under threading in
start_threads() before any concurrent execution has started by calling
pthread_create(), so if the pattern contains an error we still do the
right thing. I.e. die with one error before any threaded execution has
commenced, instead of e.g. spewing out an error for each N threads,
which could be a regression a change like this might inadvertently
introduce.
This change is not meant as an optimization, any performance gains
from this are in the hundreds to thousands of nanoseconds at most. If
we wanted more performance here we could just re-use the compiled
patterns in multiple threads (regcomp(3) is thread-safe), or partially
re-use them and the associated structures in the case of later PCRE
JIT changes.
Rather, it's just to make the code easier to reason about. It's
confusing to debug this under threading & non-threading when the
threading codepaths redundantly compile a pattern which is never used.
The reason the patterns are recompiled is as a side-effect of
duplicating the whole grep_opt structure, which is not thread safe,
writable, and munged during execution. The grep_opt structure then
points to the grep_pat structure where pattern or patterns are stored.
I looked into e.g. splitting the API into some "do & alloc threadsafe
stuff", "spawn thread", "do and alloc non-threadsafe stuff", but the
execution time of grep_opt_dup() & pattern compilation is trivial
compared to actually executing the grep, so there was no point. Even
with the more expensive JIT changes to follow the most expensive PCRE
patterns take something like 0.0X milliseconds to compile at most[1].
The undocumented --debug mode added in commit 17bf35a3c7 ("grep: teach
--debug option to dump the parse tree", 2012-09-13) still works
properly with this change. It only emits debugging info during pattern
compilation, which is now dumped by the pattern compiled just before
the first thread is started.
1. http://sljit.sourceforge.net/pcre.html
Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2017-05-25 20:05:22 +00:00
|
|
|
* for each thread.
|
|
|
|
*/
|
|
|
|
compile_grep_patterns(&opt);
|
2011-12-12 21:16:08 +00:00
|
|
|
}
|
|
|
|
|
2010-06-12 16:36:51 +00:00
|
|
|
if (show_in_pager && (cached || list.nr))
|
2011-02-22 23:41:56 +00:00
|
|
|
die(_("--open-files-in-pager only works on the worktree"));
|
2010-06-12 16:36:51 +00:00
|
|
|
|
|
|
|
if (show_in_pager && opt.pattern_list && !opt.pattern_list->next) {
|
|
|
|
const char *pager = path_list.items[0].string;
|
|
|
|
int len = strlen(pager);
|
|
|
|
|
|
|
|
if (len > 4 && is_dir_sep(pager[len - 5]))
|
|
|
|
pager += len - 4;
|
|
|
|
|
2011-02-08 06:17:24 +00:00
|
|
|
if (opt.ignore_case && !strcmp("less", pager))
|
|
|
|
string_list_append(&path_list, "-I");
|
|
|
|
|
2010-06-12 16:36:51 +00:00
|
|
|
if (!strcmp("less", pager) || !strcmp("vi", pager)) {
|
|
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
strbuf_addf(&buf, "+/%s%s",
|
|
|
|
strcmp("less", pager) ? "" : "*",
|
|
|
|
opt.pattern_list->pattern);
|
2019-08-25 13:26:40 +00:00
|
|
|
string_list_append(&path_list,
|
|
|
|
strbuf_detach(&buf, NULL));
|
2010-06-12 16:36:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-16 19:03:21 +00:00
|
|
|
if (recurse_submodules && (!use_index || untracked))
|
2018-07-21 07:49:19 +00:00
|
|
|
die(_("option not supported with --recurse-submodules"));
|
2016-12-16 19:03:20 +00:00
|
|
|
|
2015-03-18 18:00:13 +00:00
|
|
|
if (!show_in_pager && !opt.status_only)
|
2010-06-12 16:36:51 +00:00
|
|
|
setup_pager();
|
|
|
|
|
2011-09-27 20:43:12 +00:00
|
|
|
if (!use_index && (untracked || cached))
|
2018-07-21 07:49:19 +00:00
|
|
|
die(_("--cached or --untracked cannot be used with --no-index"));
|
2010-06-12 16:36:51 +00:00
|
|
|
|
2011-09-27 20:43:12 +00:00
|
|
|
if (!use_index || untracked) {
|
|
|
|
int use_exclude = (opt_exclude < 0) ? use_index : !!opt_exclude;
|
grep: turn off gitlink detection for --no-index
If we are running "git grep --no-index" outside of a git
repository, we behave roughly like "grep -r", examining all
files in the current directory and its subdirectories.
However, because we use fill_directory() to do the
recursion, it will skip over any directories which look like
sub-repositories.
For a normal git operation (like "git grep" in a repository)
this makes sense; we do not want to cross the boundary out
of our current repository into a submodule. But for
"--no-index" without a repository, we should look at all
files, including embedded repositories.
There is one exception, though: we probably should _not_
descend into ".git" directories. Doing so is inefficient and
unlikely to turn up useful hits.
This patch drops our use of dir.c's gitlink-detection, but
we do still avoid ".git". That makes us more like tools such
as "ack" or "ag", which also know to avoid cruft in .git.
As a bonus, this also drops our usage of the ref code
when we are outside of a repository, making the transition
to pluggable ref backends cleaner.
Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
2016-03-07 15:51:21 +00:00
|
|
|
hit = grep_directory(&opt, &pathspec, use_exclude, use_index);
|
2011-10-05 01:40:41 +00:00
|
|
|
} else if (0 <= opt_exclude) {
|
2018-07-21 07:49:19 +00:00
|
|
|
die(_("--[no-]exclude-standard cannot be used for tracked contents"));
|
2010-06-12 16:32:11 +00:00
|
|
|
} else if (!list.nr) {
|
2008-08-28 13:04:30 +00:00
|
|
|
if (!cached)
|
|
|
|
setup_work_tree();
|
2010-01-25 22:51:39 +00:00
|
|
|
|
2019-01-12 02:13:22 +00:00
|
|
|
hit = grep_cache(&opt, &pathspec, cached);
|
2010-06-12 16:32:11 +00:00
|
|
|
} else {
|
|
|
|
if (cached)
|
2018-07-21 07:49:19 +00:00
|
|
|
die(_("both --cached and trees are given"));
|
2017-08-02 19:49:23 +00:00
|
|
|
|
2018-03-28 22:35:27 +00:00
|
|
|
hit = grep_objects(&opt, &pathspec, &list);
|
2006-05-01 06:28:15 +00:00
|
|
|
}
|
2010-01-25 22:51:39 +00:00
|
|
|
|
2018-11-03 08:48:44 +00:00
|
|
|
if (num_threads > 1)
|
2010-01-25 22:51:39 +00:00
|
|
|
hit |= wait_all();
|
2010-06-12 16:36:51 +00:00
|
|
|
if (hit && show_in_pager)
|
|
|
|
run_pager(&opt, prefix);
|
2017-04-09 19:59:00 +00:00
|
|
|
clear_pathspec(&pathspec);
|
2006-09-27 23:27:10 +00:00
|
|
|
free_grep_patterns(&opt);
|
2006-05-01 06:28:15 +00:00
|
|
|
return !hit;
|
|
|
|
}
|