mirror of
https://github.com/git/git
synced 2024-08-25 10:45:59 +00:00
![Jeff King](/assets/img/avatar_default.png)
Previously, we just chose whether to allow external grep based on the __unix__ define. However, there are systems which define this macro but which have an inferior group (e.g., one that does not support all options used by t7002). This allows users to accept the potential speed penalty to get a more consistent grep experience (and to pass the testsuite). Signed-off-by: Jeff King <peff@peff.net> Signed-off-by: Junio C Hamano <gitster@pobox.com>
798 lines
18 KiB
C
798 lines
18 KiB
C
/*
|
|
* Builtin "git grep"
|
|
*
|
|
* Copyright (c) 2006 Junio C Hamano
|
|
*/
|
|
#include "cache.h"
|
|
#include "blob.h"
|
|
#include "tree.h"
|
|
#include "commit.h"
|
|
#include "tag.h"
|
|
#include "tree-walk.h"
|
|
#include "builtin.h"
|
|
#include "grep.h"
|
|
|
|
#ifndef NO_EXTERNAL_GREP
|
|
#ifdef __unix__
|
|
#define NO_EXTERNAL_GREP 0
|
|
#else
|
|
#define NO_EXTERNAL_GREP 1
|
|
#endif
|
|
#endif
|
|
|
|
/*
|
|
* git grep pathspecs are somewhat different from diff-tree pathspecs;
|
|
* pathname wildcards are allowed.
|
|
*/
|
|
static int pathspec_matches(const char **paths, const char *name)
|
|
{
|
|
int namelen, i;
|
|
if (!paths || !*paths)
|
|
return 1;
|
|
namelen = strlen(name);
|
|
for (i = 0; paths[i]; i++) {
|
|
const char *match = paths[i];
|
|
int matchlen = strlen(match);
|
|
const char *cp, *meta;
|
|
|
|
if (!matchlen ||
|
|
((matchlen <= namelen) &&
|
|
!strncmp(name, match, matchlen) &&
|
|
(match[matchlen-1] == '/' ||
|
|
name[matchlen] == '\0' || name[matchlen] == '/')))
|
|
return 1;
|
|
if (!fnmatch(match, name, 0))
|
|
return 1;
|
|
if (name[namelen-1] != '/')
|
|
continue;
|
|
|
|
/* We are being asked if the directory ("name") is worth
|
|
* descending into.
|
|
*
|
|
* Find the longest leading directory name that does
|
|
* not have metacharacter in the pathspec; the name
|
|
* we are looking at must overlap with that directory.
|
|
*/
|
|
for (cp = match, meta = NULL; cp - match < matchlen; cp++) {
|
|
char ch = *cp;
|
|
if (ch == '*' || ch == '[' || ch == '?') {
|
|
meta = cp;
|
|
break;
|
|
}
|
|
}
|
|
if (!meta)
|
|
meta = cp; /* fully literal */
|
|
|
|
if (namelen <= meta - match) {
|
|
/* Looking at "Documentation/" and
|
|
* the pattern says "Documentation/howto/", or
|
|
* "Documentation/diff*.txt". The name we
|
|
* have should match prefix.
|
|
*/
|
|
if (!memcmp(match, name, namelen))
|
|
return 1;
|
|
continue;
|
|
}
|
|
|
|
if (meta - match < namelen) {
|
|
/* Looking at "Documentation/howto/" and
|
|
* the pattern says "Documentation/h*";
|
|
* match up to "Do.../h"; this avoids descending
|
|
* into "Documentation/technical/".
|
|
*/
|
|
if (!memcmp(match, name, meta - match))
|
|
return 1;
|
|
continue;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int grep_sha1(struct grep_opt *opt, const unsigned char *sha1, const char *name, int tree_name_len)
|
|
{
|
|
unsigned long size;
|
|
char *data;
|
|
enum object_type type;
|
|
char *to_free = NULL;
|
|
int hit;
|
|
|
|
data = read_sha1_file(sha1, &type, &size);
|
|
if (!data) {
|
|
error("'%s': unable to read %s", name, sha1_to_hex(sha1));
|
|
return 0;
|
|
}
|
|
if (opt->relative && opt->prefix_length) {
|
|
static char name_buf[PATH_MAX];
|
|
char *cp;
|
|
int name_len = strlen(name) - opt->prefix_length + 1;
|
|
|
|
if (!tree_name_len)
|
|
name += opt->prefix_length;
|
|
else {
|
|
if (ARRAY_SIZE(name_buf) <= name_len)
|
|
cp = to_free = xmalloc(name_len);
|
|
else
|
|
cp = name_buf;
|
|
memcpy(cp, name, tree_name_len);
|
|
strcpy(cp + tree_name_len,
|
|
name + tree_name_len + opt->prefix_length);
|
|
name = cp;
|
|
}
|
|
}
|
|
hit = grep_buffer(opt, name, data, size);
|
|
free(data);
|
|
free(to_free);
|
|
return hit;
|
|
}
|
|
|
|
static int grep_file(struct grep_opt *opt, const char *filename)
|
|
{
|
|
struct stat st;
|
|
int i;
|
|
char *data;
|
|
size_t sz;
|
|
|
|
if (lstat(filename, &st) < 0) {
|
|
err_ret:
|
|
if (errno != ENOENT)
|
|
error("'%s': %s", filename, strerror(errno));
|
|
return 0;
|
|
}
|
|
if (!st.st_size)
|
|
return 0; /* empty file -- no grep hit */
|
|
if (!S_ISREG(st.st_mode))
|
|
return 0;
|
|
sz = xsize_t(st.st_size);
|
|
i = open(filename, O_RDONLY);
|
|
if (i < 0)
|
|
goto err_ret;
|
|
data = xmalloc(sz + 1);
|
|
if (st.st_size != read_in_full(i, data, sz)) {
|
|
error("'%s': short read %s", filename, strerror(errno));
|
|
close(i);
|
|
free(data);
|
|
return 0;
|
|
}
|
|
close(i);
|
|
if (opt->relative && opt->prefix_length)
|
|
filename += opt->prefix_length;
|
|
i = grep_buffer(opt, filename, data, sz);
|
|
free(data);
|
|
return i;
|
|
}
|
|
|
|
#if !NO_EXTERNAL_GREP
|
|
static int exec_grep(int argc, const char **argv)
|
|
{
|
|
pid_t pid;
|
|
int status;
|
|
|
|
argv[argc] = NULL;
|
|
pid = fork();
|
|
if (pid < 0)
|
|
return pid;
|
|
if (!pid) {
|
|
execvp("grep", (char **) argv);
|
|
exit(255);
|
|
}
|
|
while (waitpid(pid, &status, 0) < 0) {
|
|
if (errno == EINTR)
|
|
continue;
|
|
return -1;
|
|
}
|
|
if (WIFEXITED(status)) {
|
|
if (!WEXITSTATUS(status))
|
|
return 1;
|
|
return 0;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
#define MAXARGS 1000
|
|
#define ARGBUF 4096
|
|
#define push_arg(a) do { \
|
|
if (nr < MAXARGS) argv[nr++] = (a); \
|
|
else die("maximum number of args exceeded"); \
|
|
} while (0)
|
|
|
|
/*
|
|
* If you send a singleton filename to grep, it does not give
|
|
* the name of the file. GNU grep has "-H" but we would want
|
|
* that behaviour in a portable way.
|
|
*
|
|
* So we keep two pathnames in argv buffer unsent to grep in
|
|
* the main loop if we need to do more than one grep.
|
|
*/
|
|
static int flush_grep(struct grep_opt *opt,
|
|
int argc, int arg0, const char **argv, int *kept)
|
|
{
|
|
int status;
|
|
int count = argc - arg0;
|
|
const char *kept_0 = NULL;
|
|
|
|
if (count <= 2) {
|
|
/*
|
|
* Because we keep at least 2 paths in the call from
|
|
* the main loop (i.e. kept != NULL), and MAXARGS is
|
|
* far greater than 2, this usually is a call to
|
|
* conclude the grep. However, the user could attempt
|
|
* to overflow the argv buffer by giving too many
|
|
* options to leave very small number of real
|
|
* arguments even for the call in the main loop.
|
|
*/
|
|
if (kept)
|
|
die("insanely many options to grep");
|
|
|
|
/*
|
|
* If we have two or more paths, we do not have to do
|
|
* anything special, but we need to push /dev/null to
|
|
* get "-H" behaviour of GNU grep portably but when we
|
|
* are not doing "-l" nor "-L" nor "-c".
|
|
*/
|
|
if (count == 1 &&
|
|
!opt->name_only &&
|
|
!opt->unmatch_name_only &&
|
|
!opt->count) {
|
|
argv[argc++] = "/dev/null";
|
|
argv[argc] = NULL;
|
|
}
|
|
}
|
|
|
|
else if (kept) {
|
|
/*
|
|
* Called because we found many paths and haven't finished
|
|
* iterating over the cache yet. We keep two paths
|
|
* for the concluding call. argv[argc-2] and argv[argc-1]
|
|
* has the last two paths, so save the first one away,
|
|
* replace it with NULL while sending the list to grep,
|
|
* and recover them after we are done.
|
|
*/
|
|
*kept = 2;
|
|
kept_0 = argv[argc-2];
|
|
argv[argc-2] = NULL;
|
|
argc -= 2;
|
|
}
|
|
|
|
status = exec_grep(argc, argv);
|
|
|
|
if (kept_0) {
|
|
/*
|
|
* Then recover them. Now the last arg is beyond the
|
|
* terminating NULL which is at argc, and the second
|
|
* from the last is what we saved away in kept_0
|
|
*/
|
|
argv[arg0++] = kept_0;
|
|
argv[arg0] = argv[argc+1];
|
|
}
|
|
return status;
|
|
}
|
|
|
|
static int external_grep(struct grep_opt *opt, const char **paths, int cached)
|
|
{
|
|
int i, nr, argc, hit, len, status;
|
|
const char *argv[MAXARGS+1];
|
|
char randarg[ARGBUF];
|
|
char *argptr = randarg;
|
|
struct grep_pat *p;
|
|
|
|
if (opt->extended || (opt->relative && opt->prefix_length))
|
|
return -1;
|
|
len = nr = 0;
|
|
push_arg("grep");
|
|
if (opt->fixed)
|
|
push_arg("-F");
|
|
if (opt->linenum)
|
|
push_arg("-n");
|
|
if (!opt->pathname)
|
|
push_arg("-h");
|
|
if (opt->regflags & REG_EXTENDED)
|
|
push_arg("-E");
|
|
if (opt->regflags & REG_ICASE)
|
|
push_arg("-i");
|
|
if (opt->word_regexp)
|
|
push_arg("-w");
|
|
if (opt->name_only)
|
|
push_arg("-l");
|
|
if (opt->unmatch_name_only)
|
|
push_arg("-L");
|
|
if (opt->count)
|
|
push_arg("-c");
|
|
if (opt->post_context || opt->pre_context) {
|
|
if (opt->post_context != opt->pre_context) {
|
|
if (opt->pre_context) {
|
|
push_arg("-B");
|
|
len += snprintf(argptr, sizeof(randarg)-len,
|
|
"%u", opt->pre_context) + 1;
|
|
if (sizeof(randarg) <= len)
|
|
die("maximum length of args exceeded");
|
|
push_arg(argptr);
|
|
argptr += len;
|
|
}
|
|
if (opt->post_context) {
|
|
push_arg("-A");
|
|
len += snprintf(argptr, sizeof(randarg)-len,
|
|
"%u", opt->post_context) + 1;
|
|
if (sizeof(randarg) <= len)
|
|
die("maximum length of args exceeded");
|
|
push_arg(argptr);
|
|
argptr += len;
|
|
}
|
|
}
|
|
else {
|
|
push_arg("-C");
|
|
len += snprintf(argptr, sizeof(randarg)-len,
|
|
"%u", opt->post_context) + 1;
|
|
if (sizeof(randarg) <= len)
|
|
die("maximum length of args exceeded");
|
|
push_arg(argptr);
|
|
argptr += len;
|
|
}
|
|
}
|
|
for (p = opt->pattern_list; p; p = p->next) {
|
|
push_arg("-e");
|
|
push_arg(p->pattern);
|
|
}
|
|
|
|
hit = 0;
|
|
argc = nr;
|
|
for (i = 0; i < active_nr; i++) {
|
|
struct cache_entry *ce = active_cache[i];
|
|
char *name;
|
|
int kept;
|
|
if (!S_ISREG(ce->ce_mode))
|
|
continue;
|
|
if (!pathspec_matches(paths, ce->name))
|
|
continue;
|
|
name = ce->name;
|
|
if (name[0] == '-') {
|
|
int len = ce_namelen(ce);
|
|
name = xmalloc(len + 3);
|
|
memcpy(name, "./", 2);
|
|
memcpy(name + 2, ce->name, len + 1);
|
|
}
|
|
argv[argc++] = name;
|
|
if (MAXARGS <= argc) {
|
|
status = flush_grep(opt, argc, nr, argv, &kept);
|
|
if (0 < status)
|
|
hit = 1;
|
|
argc = nr + kept;
|
|
}
|
|
if (ce_stage(ce)) {
|
|
do {
|
|
i++;
|
|
} while (i < active_nr &&
|
|
!strcmp(ce->name, active_cache[i]->name));
|
|
i--; /* compensate for loop control */
|
|
}
|
|
}
|
|
if (argc > nr) {
|
|
status = flush_grep(opt, argc, nr, argv, NULL);
|
|
if (0 < status)
|
|
hit = 1;
|
|
}
|
|
return hit;
|
|
}
|
|
#endif
|
|
|
|
static int grep_cache(struct grep_opt *opt, const char **paths, int cached)
|
|
{
|
|
int hit = 0;
|
|
int nr;
|
|
read_cache();
|
|
|
|
#if !NO_EXTERNAL_GREP
|
|
/*
|
|
* Use the external "grep" command for the case where
|
|
* we grep through the checked-out files. It tends to
|
|
* be a lot more optimized
|
|
*/
|
|
if (!cached) {
|
|
hit = external_grep(opt, paths, cached);
|
|
if (hit >= 0)
|
|
return hit;
|
|
}
|
|
#endif
|
|
|
|
for (nr = 0; nr < active_nr; nr++) {
|
|
struct cache_entry *ce = active_cache[nr];
|
|
if (!S_ISREG(ce->ce_mode))
|
|
continue;
|
|
if (!pathspec_matches(paths, ce->name))
|
|
continue;
|
|
if (cached) {
|
|
if (ce_stage(ce))
|
|
continue;
|
|
hit |= grep_sha1(opt, ce->sha1, ce->name, 0);
|
|
}
|
|
else
|
|
hit |= grep_file(opt, ce->name);
|
|
if (ce_stage(ce)) {
|
|
do {
|
|
nr++;
|
|
} while (nr < active_nr &&
|
|
!strcmp(ce->name, active_cache[nr]->name));
|
|
nr--; /* compensate for loop control */
|
|
}
|
|
}
|
|
free_grep_patterns(opt);
|
|
return hit;
|
|
}
|
|
|
|
static int grep_tree(struct grep_opt *opt, const char **paths,
|
|
struct tree_desc *tree,
|
|
const char *tree_name, const char *base)
|
|
{
|
|
int len;
|
|
int hit = 0;
|
|
struct name_entry entry;
|
|
char *down;
|
|
int tn_len = strlen(tree_name);
|
|
char *path_buf = xmalloc(PATH_MAX + tn_len + 100);
|
|
|
|
if (tn_len) {
|
|
tn_len = sprintf(path_buf, "%s:", tree_name);
|
|
down = path_buf + tn_len;
|
|
strcat(down, base);
|
|
}
|
|
else {
|
|
down = path_buf;
|
|
strcpy(down, base);
|
|
}
|
|
len = strlen(path_buf);
|
|
|
|
while (tree_entry(tree, &entry)) {
|
|
strcpy(path_buf + len, entry.path);
|
|
|
|
if (S_ISDIR(entry.mode))
|
|
/* Match "abc/" against pathspec to
|
|
* decide if we want to descend into "abc"
|
|
* directory.
|
|
*/
|
|
strcpy(path_buf + len + tree_entry_len(entry.path, entry.sha1), "/");
|
|
|
|
if (!pathspec_matches(paths, down))
|
|
;
|
|
else if (S_ISREG(entry.mode))
|
|
hit |= grep_sha1(opt, entry.sha1, path_buf, tn_len);
|
|
else if (S_ISDIR(entry.mode)) {
|
|
enum object_type type;
|
|
struct tree_desc sub;
|
|
void *data;
|
|
unsigned long size;
|
|
|
|
data = read_sha1_file(entry.sha1, &type, &size);
|
|
if (!data)
|
|
die("unable to read tree (%s)",
|
|
sha1_to_hex(entry.sha1));
|
|
init_tree_desc(&sub, data, size);
|
|
hit |= grep_tree(opt, paths, &sub, tree_name, down);
|
|
free(data);
|
|
}
|
|
}
|
|
return hit;
|
|
}
|
|
|
|
static int grep_object(struct grep_opt *opt, const char **paths,
|
|
struct object *obj, const char *name)
|
|
{
|
|
if (obj->type == OBJ_BLOB)
|
|
return grep_sha1(opt, obj->sha1, name, 0);
|
|
if (obj->type == OBJ_COMMIT || obj->type == OBJ_TREE) {
|
|
struct tree_desc tree;
|
|
void *data;
|
|
unsigned long size;
|
|
int hit;
|
|
data = read_object_with_reference(obj->sha1, tree_type,
|
|
&size, NULL);
|
|
if (!data)
|
|
die("unable to read tree (%s)", sha1_to_hex(obj->sha1));
|
|
init_tree_desc(&tree, data, size);
|
|
hit = grep_tree(opt, paths, &tree, name, "");
|
|
free(data);
|
|
return hit;
|
|
}
|
|
die("unable to grep from object of type %s", typename(obj->type));
|
|
}
|
|
|
|
static const char builtin_grep_usage[] =
|
|
"git-grep <option>* <rev>* [-e] <pattern> [<path>...]";
|
|
|
|
static const char emsg_invalid_context_len[] =
|
|
"%s: invalid context length argument";
|
|
static const char emsg_missing_context_len[] =
|
|
"missing context length argument";
|
|
static const char emsg_missing_argument[] =
|
|
"option requires an argument -%s";
|
|
|
|
int cmd_grep(int argc, const char **argv, const char *prefix)
|
|
{
|
|
int hit = 0;
|
|
int cached = 0;
|
|
int seen_dashdash = 0;
|
|
struct grep_opt opt;
|
|
struct object_array list = { 0, 0, NULL };
|
|
const char **paths = NULL;
|
|
int i;
|
|
|
|
memset(&opt, 0, sizeof(opt));
|
|
opt.prefix_length = (prefix && *prefix) ? strlen(prefix) : 0;
|
|
opt.relative = 1;
|
|
opt.pathname = 1;
|
|
opt.pattern_tail = &opt.pattern_list;
|
|
opt.regflags = REG_NEWLINE;
|
|
|
|
/*
|
|
* 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
|
|
* unrecognized non option is the beginning of the refs list
|
|
* that continues up to the -- (if exists), and then paths.
|
|
*/
|
|
|
|
while (1 < argc) {
|
|
const char *arg = argv[1];
|
|
argc--; argv++;
|
|
if (!strcmp("--cached", arg)) {
|
|
cached = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp("-a", arg) ||
|
|
!strcmp("--text", arg)) {
|
|
opt.binary = GREP_BINARY_TEXT;
|
|
continue;
|
|
}
|
|
if (!strcmp("-i", arg) ||
|
|
!strcmp("--ignore-case", arg)) {
|
|
opt.regflags |= REG_ICASE;
|
|
continue;
|
|
}
|
|
if (!strcmp("-I", arg)) {
|
|
opt.binary = GREP_BINARY_NOMATCH;
|
|
continue;
|
|
}
|
|
if (!strcmp("-v", arg) ||
|
|
!strcmp("--invert-match", arg)) {
|
|
opt.invert = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp("-E", arg) ||
|
|
!strcmp("--extended-regexp", arg)) {
|
|
opt.regflags |= REG_EXTENDED;
|
|
continue;
|
|
}
|
|
if (!strcmp("-F", arg) ||
|
|
!strcmp("--fixed-strings", arg)) {
|
|
opt.fixed = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp("-G", arg) ||
|
|
!strcmp("--basic-regexp", arg)) {
|
|
opt.regflags &= ~REG_EXTENDED;
|
|
continue;
|
|
}
|
|
if (!strcmp("-n", arg)) {
|
|
opt.linenum = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp("-h", arg)) {
|
|
opt.pathname = 0;
|
|
continue;
|
|
}
|
|
if (!strcmp("-H", arg)) {
|
|
opt.pathname = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp("-l", arg) ||
|
|
!strcmp("--name-only", arg) ||
|
|
!strcmp("--files-with-matches", arg)) {
|
|
opt.name_only = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp("-L", arg) ||
|
|
!strcmp("--files-without-match", arg)) {
|
|
opt.unmatch_name_only = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp("-c", arg) ||
|
|
!strcmp("--count", arg)) {
|
|
opt.count = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp("-w", arg) ||
|
|
!strcmp("--word-regexp", arg)) {
|
|
opt.word_regexp = 1;
|
|
continue;
|
|
}
|
|
if (!prefixcmp(arg, "-A") ||
|
|
!prefixcmp(arg, "-B") ||
|
|
!prefixcmp(arg, "-C") ||
|
|
(arg[0] == '-' && '1' <= arg[1] && arg[1] <= '9')) {
|
|
unsigned num;
|
|
const char *scan;
|
|
switch (arg[1]) {
|
|
case 'A': case 'B': case 'C':
|
|
if (!arg[2]) {
|
|
if (argc <= 1)
|
|
die(emsg_missing_context_len);
|
|
scan = *++argv;
|
|
argc--;
|
|
}
|
|
else
|
|
scan = arg + 2;
|
|
break;
|
|
default:
|
|
scan = arg + 1;
|
|
break;
|
|
}
|
|
if (strtoul_ui(scan, 10, &num))
|
|
die(emsg_invalid_context_len, scan);
|
|
switch (arg[1]) {
|
|
case 'A':
|
|
opt.post_context = num;
|
|
break;
|
|
default:
|
|
case 'C':
|
|
opt.post_context = num;
|
|
case 'B':
|
|
opt.pre_context = num;
|
|
break;
|
|
}
|
|
continue;
|
|
}
|
|
if (!strcmp("-f", arg)) {
|
|
FILE *patterns;
|
|
int lno = 0;
|
|
char buf[1024];
|
|
if (argc <= 1)
|
|
die(emsg_missing_argument, arg);
|
|
patterns = fopen(argv[1], "r");
|
|
if (!patterns)
|
|
die("'%s': %s", argv[1], strerror(errno));
|
|
while (fgets(buf, sizeof(buf), patterns)) {
|
|
int len = strlen(buf);
|
|
if (len && buf[len-1] == '\n')
|
|
buf[len-1] = 0;
|
|
/* ignore empty line like grep does */
|
|
if (!buf[0])
|
|
continue;
|
|
append_grep_pattern(&opt, xstrdup(buf),
|
|
argv[1], ++lno,
|
|
GREP_PATTERN);
|
|
}
|
|
fclose(patterns);
|
|
argv++;
|
|
argc--;
|
|
continue;
|
|
}
|
|
if (!strcmp("--not", arg)) {
|
|
append_grep_pattern(&opt, arg, "command line", 0,
|
|
GREP_NOT);
|
|
continue;
|
|
}
|
|
if (!strcmp("--and", arg)) {
|
|
append_grep_pattern(&opt, arg, "command line", 0,
|
|
GREP_AND);
|
|
continue;
|
|
}
|
|
if (!strcmp("--or", arg))
|
|
continue; /* no-op */
|
|
if (!strcmp("(", arg)) {
|
|
append_grep_pattern(&opt, arg, "command line", 0,
|
|
GREP_OPEN_PAREN);
|
|
continue;
|
|
}
|
|
if (!strcmp(")", arg)) {
|
|
append_grep_pattern(&opt, arg, "command line", 0,
|
|
GREP_CLOSE_PAREN);
|
|
continue;
|
|
}
|
|
if (!strcmp("--all-match", arg)) {
|
|
opt.all_match = 1;
|
|
continue;
|
|
}
|
|
if (!strcmp("-e", arg)) {
|
|
if (1 < argc) {
|
|
append_grep_pattern(&opt, argv[1],
|
|
"-e option", 0,
|
|
GREP_PATTERN);
|
|
argv++;
|
|
argc--;
|
|
continue;
|
|
}
|
|
die(emsg_missing_argument, arg);
|
|
}
|
|
if (!strcmp("--full-name", arg)) {
|
|
opt.relative = 0;
|
|
continue;
|
|
}
|
|
if (!strcmp("--", arg)) {
|
|
/* later processing wants to have this at argv[1] */
|
|
argv--;
|
|
argc++;
|
|
break;
|
|
}
|
|
if (*arg == '-')
|
|
usage(builtin_grep_usage);
|
|
|
|
/* First unrecognized non-option token */
|
|
if (!opt.pattern_list) {
|
|
append_grep_pattern(&opt, arg, "command line", 0,
|
|
GREP_PATTERN);
|
|
break;
|
|
}
|
|
else {
|
|
/* We are looking at the first path or rev;
|
|
* it is found at argv[1] after leaving the
|
|
* loop.
|
|
*/
|
|
argc++; argv--;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!opt.pattern_list)
|
|
die("no pattern given.");
|
|
if ((opt.regflags != REG_NEWLINE) && opt.fixed)
|
|
die("cannot mix --fixed-strings and regexp");
|
|
compile_grep_patterns(&opt);
|
|
|
|
/* Check revs and then paths */
|
|
for (i = 1; i < argc; i++) {
|
|
const char *arg = argv[i];
|
|
unsigned char sha1[20];
|
|
/* Is it a rev? */
|
|
if (!get_sha1(arg, sha1)) {
|
|
struct object *object = parse_object(sha1);
|
|
if (!object)
|
|
die("bad object %s", arg);
|
|
add_object_array(object, arg, &list);
|
|
continue;
|
|
}
|
|
if (!strcmp(arg, "--")) {
|
|
i++;
|
|
seen_dashdash = 1;
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* The rest are paths */
|
|
if (!seen_dashdash) {
|
|
int j;
|
|
for (j = i; j < argc; j++)
|
|
verify_filename(prefix, argv[j]);
|
|
}
|
|
|
|
if (i < argc) {
|
|
paths = get_pathspec(prefix, argv + i);
|
|
if (opt.prefix_length && opt.relative) {
|
|
/* Make sure we do not get outside of paths */
|
|
for (i = 0; paths[i]; i++)
|
|
if (strncmp(prefix, paths[i], opt.prefix_length))
|
|
die("git-grep: cannot generate relative filenames containing '..'");
|
|
}
|
|
}
|
|
else if (prefix) {
|
|
paths = xcalloc(2, sizeof(const char *));
|
|
paths[0] = prefix;
|
|
paths[1] = NULL;
|
|
}
|
|
|
|
if (!list.nr)
|
|
return !grep_cache(&opt, paths, cached);
|
|
|
|
if (cached)
|
|
die("both --cached and trees are given.");
|
|
|
|
for (i = 0; i < list.nr; i++) {
|
|
struct object *real_obj;
|
|
real_obj = deref_tag(list.objects[i].item, NULL, 0);
|
|
if (grep_object(&opt, paths, real_obj, list.objects[i].name))
|
|
hit = 1;
|
|
}
|
|
free_grep_patterns(&opt);
|
|
return !hit;
|
|
}
|