Browse Source
* jc/grep: (22 commits) Fix silly typo in new builtin grep builtin-grep: unparse more command line options. builtin-grep: use external grep when we can take advantage of it builtin-grep: -F (--fixed-strings) builtin-grep: -w fix builtin-grep: typofix builtin-grep: tighten argument parsing. builtin-grep: documentation Teach -f <file> option to builtin-grep. builtin-grep: -L (--files-without-match). builtin-grep: binary files -a and -I builtin-grep: terminate correctly at EOF builtin-grep: tighten path wildcard vs tree traversal. builtin-grep: support -w (--word-regexp). builtin-grep: support -c (--count). builtin-grep: allow more than one patterns. builtin-grep: allow -<n> and -[ABC]<n> notation for context lines. builtin-grep: printf %.*s length is int, not ptrdiff_t. builtin-grep: do not use setup_revisions() builtin-grep: support '-l' option. ...maint
Junio C Hamano
19 years ago
5 changed files with 951 additions and 24 deletions
@ -0,0 +1,885 @@
@@ -0,0 +1,885 @@
|
||||
/* |
||||
* 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 <regex.h> |
||||
#include <fnmatch.h> |
||||
#include <sys/wait.h> |
||||
|
||||
/* |
||||
* 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 <= 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; |
||||
} |
||||
|
||||
struct grep_pat { |
||||
struct grep_pat *next; |
||||
const char *origin; |
||||
int no; |
||||
const char *pattern; |
||||
regex_t regexp; |
||||
}; |
||||
|
||||
struct grep_opt { |
||||
struct grep_pat *pattern_list; |
||||
struct grep_pat **pattern_tail; |
||||
regex_t regexp; |
||||
unsigned linenum:1; |
||||
unsigned invert:1; |
||||
unsigned name_only:1; |
||||
unsigned unmatch_name_only:1; |
||||
unsigned count:1; |
||||
unsigned word_regexp:1; |
||||
unsigned fixed:1; |
||||
#define GREP_BINARY_DEFAULT 0 |
||||
#define GREP_BINARY_NOMATCH 1 |
||||
#define GREP_BINARY_TEXT 2 |
||||
unsigned binary:2; |
||||
int regflags; |
||||
unsigned pre_context; |
||||
unsigned post_context; |
||||
}; |
||||
|
||||
static void add_pattern(struct grep_opt *opt, const char *pat, |
||||
const char *origin, int no) |
||||
{ |
||||
struct grep_pat *p = xcalloc(1, sizeof(*p)); |
||||
p->pattern = pat; |
||||
p->origin = origin; |
||||
p->no = no; |
||||
*opt->pattern_tail = p; |
||||
opt->pattern_tail = &p->next; |
||||
p->next = NULL; |
||||
} |
||||
|
||||
static void compile_patterns(struct grep_opt *opt) |
||||
{ |
||||
struct grep_pat *p; |
||||
for (p = opt->pattern_list; p; p = p->next) { |
||||
int err = regcomp(&p->regexp, p->pattern, opt->regflags); |
||||
if (err) { |
||||
char errbuf[1024]; |
||||
char where[1024]; |
||||
if (p->no) |
||||
sprintf(where, "In '%s' at %d, ", |
||||
p->origin, p->no); |
||||
else if (p->origin) |
||||
sprintf(where, "%s, ", p->origin); |
||||
else |
||||
where[0] = 0; |
||||
regerror(err, &p->regexp, errbuf, 1024); |
||||
regfree(&p->regexp); |
||||
die("%s'%s': %s", where, p->pattern, errbuf); |
||||
} |
||||
} |
||||
} |
||||
|
||||
static char *end_of_line(char *cp, unsigned long *left) |
||||
{ |
||||
unsigned long l = *left; |
||||
while (l && *cp != '\n') { |
||||
l--; |
||||
cp++; |
||||
} |
||||
*left = l; |
||||
return cp; |
||||
} |
||||
|
||||
static int word_char(char ch) |
||||
{ |
||||
return isalnum(ch) || ch == '_'; |
||||
} |
||||
|
||||
static void show_line(struct grep_opt *opt, const char *bol, const char *eol, |
||||
const char *name, unsigned lno, char sign) |
||||
{ |
||||
printf("%s%c", name, sign); |
||||
if (opt->linenum) |
||||
printf("%d%c", lno, sign); |
||||
printf("%.*s\n", (int)(eol-bol), bol); |
||||
} |
||||
|
||||
/* |
||||
* NEEDSWORK: share code with diff.c |
||||
*/ |
||||
#define FIRST_FEW_BYTES 8000 |
||||
static int buffer_is_binary(const char *ptr, unsigned long size) |
||||
{ |
||||
if (FIRST_FEW_BYTES < size) |
||||
size = FIRST_FEW_BYTES; |
||||
if (memchr(ptr, 0, size)) |
||||
return 1; |
||||
return 0; |
||||
} |
||||
|
||||
static int fixmatch(const char *pattern, char *line, regmatch_t *match) |
||||
{ |
||||
char *hit = strstr(line, pattern); |
||||
if (!hit) { |
||||
match->rm_so = match->rm_eo = -1; |
||||
return REG_NOMATCH; |
||||
} |
||||
else { |
||||
match->rm_so = hit - line; |
||||
match->rm_eo = match->rm_so + strlen(pattern); |
||||
return 0; |
||||
} |
||||
} |
||||
|
||||
static int grep_buffer(struct grep_opt *opt, const char *name, |
||||
char *buf, unsigned long size) |
||||
{ |
||||
char *bol = buf; |
||||
unsigned long left = size; |
||||
unsigned lno = 1; |
||||
struct pre_context_line { |
||||
char *bol; |
||||
char *eol; |
||||
} *prev = NULL, *pcl; |
||||
unsigned last_hit = 0; |
||||
unsigned last_shown = 0; |
||||
int binary_match_only = 0; |
||||
const char *hunk_mark = ""; |
||||
unsigned count = 0; |
||||
|
||||
if (buffer_is_binary(buf, size)) { |
||||
switch (opt->binary) { |
||||
case GREP_BINARY_DEFAULT: |
||||
binary_match_only = 1; |
||||
break; |
||||
case GREP_BINARY_NOMATCH: |
||||
return 0; /* Assume unmatch */ |
||||
break; |
||||
default: |
||||
break; |
||||
} |
||||
} |
||||
|
||||
if (opt->pre_context) |
||||
prev = xcalloc(opt->pre_context, sizeof(*prev)); |
||||
if (opt->pre_context || opt->post_context) |
||||
hunk_mark = "--\n"; |
||||
|
||||
while (left) { |
||||
regmatch_t pmatch[10]; |
||||
char *eol, ch; |
||||
int hit = 0; |
||||
struct grep_pat *p; |
||||
|
||||
eol = end_of_line(bol, &left); |
||||
ch = *eol; |
||||
*eol = 0; |
||||
|
||||
for (p = opt->pattern_list; p; p = p->next) { |
||||
if (!opt->fixed) { |
||||
regex_t *exp = &p->regexp; |
||||
hit = !regexec(exp, bol, ARRAY_SIZE(pmatch), |
||||
pmatch, 0); |
||||
} |
||||
else { |
||||
hit = !fixmatch(p->pattern, bol, pmatch); |
||||
} |
||||
|
||||
if (hit && opt->word_regexp) { |
||||
/* Match beginning must be either |
||||
* beginning of the line, or at word |
||||
* boundary (i.e. the last char must |
||||
* not be alnum or underscore). |
||||
*/ |
||||
if ((pmatch[0].rm_so < 0) || |
||||
(eol - bol) <= pmatch[0].rm_so || |
||||
(pmatch[0].rm_eo < 0) || |
||||
(eol - bol) < pmatch[0].rm_eo) |
||||
die("regexp returned nonsense"); |
||||
if (pmatch[0].rm_so != 0 && |
||||
word_char(bol[pmatch[0].rm_so-1])) |
||||
hit = 0; |
||||
if (pmatch[0].rm_eo != (eol-bol) && |
||||
word_char(bol[pmatch[0].rm_eo])) |
||||
hit = 0; |
||||
} |
||||
if (hit) |
||||
break; |
||||
} |
||||
/* "grep -v -e foo -e bla" should list lines |
||||
* that do not have either, so inversion should |
||||
* be done outside. |
||||
*/ |
||||
if (opt->invert) |
||||
hit = !hit; |
||||
if (opt->unmatch_name_only) { |
||||
if (hit) |
||||
return 0; |
||||
goto next_line; |
||||
} |
||||
if (hit) { |
||||
count++; |
||||
if (binary_match_only) { |
||||
printf("Binary file %s matches\n", name); |
||||
return 1; |
||||
} |
||||
if (opt->name_only) { |
||||
printf("%s\n", name); |
||||
return 1; |
||||
} |
||||
/* Hit at this line. If we haven't shown the |
||||
* pre-context lines, we would need to show them. |
||||
* When asked to do "count", this still show |
||||
* the context which is nonsense, but the user |
||||
* deserves to get that ;-). |
||||
*/ |
||||
if (opt->pre_context) { |
||||
unsigned from; |
||||
if (opt->pre_context < lno) |
||||
from = lno - opt->pre_context; |
||||
else |
||||
from = 1; |
||||
if (from <= last_shown) |
||||
from = last_shown + 1; |
||||
if (last_shown && from != last_shown + 1) |
||||
printf(hunk_mark); |
||||
while (from < lno) { |
||||
pcl = &prev[lno-from-1]; |
||||
show_line(opt, pcl->bol, pcl->eol, |
||||
name, from, '-'); |
||||
from++; |
||||
} |
||||
last_shown = lno-1; |
||||
} |
||||
if (last_shown && lno != last_shown + 1) |
||||
printf(hunk_mark); |
||||
if (!opt->count) |
||||
show_line(opt, bol, eol, name, lno, ':'); |
||||
last_shown = last_hit = lno; |
||||
} |
||||
else if (last_hit && |
||||
lno <= last_hit + opt->post_context) { |
||||
/* If the last hit is within the post context, |
||||
* we need to show this line. |
||||
*/ |
||||
if (last_shown && lno != last_shown + 1) |
||||
printf(hunk_mark); |
||||
show_line(opt, bol, eol, name, lno, '-'); |
||||
last_shown = lno; |
||||
} |
||||
if (opt->pre_context) { |
||||
memmove(prev+1, prev, |
||||
(opt->pre_context-1) * sizeof(*prev)); |
||||
prev->bol = bol; |
||||
prev->eol = eol; |
||||
} |
||||
|
||||
next_line: |
||||
*eol = ch; |
||||
bol = eol + 1; |
||||
if (!left) |
||||
break; |
||||
left--; |
||||
lno++; |
||||
} |
||||
|
||||
if (opt->unmatch_name_only) { |
||||
/* We did not see any hit, so we want to show this */ |
||||
printf("%s\n", name); |
||||
return 1; |
||||
} |
||||
|
||||
/* NEEDSWORK: |
||||
* The real "grep -c foo *.c" gives many "bar.c:0" lines, |
||||
* which feels mostly useless but sometimes useful. Maybe |
||||
* make it another option? For now suppress them. |
||||
*/ |
||||
if (opt->count && count) |
||||
printf("%s:%u\n", name, count); |
||||
return !!last_hit; |
||||
} |
||||
|
||||
static int grep_sha1(struct grep_opt *opt, const unsigned char *sha1, const char *name) |
||||
{ |
||||
unsigned long size; |
||||
char *data; |
||||
char type[20]; |
||||
int hit; |
||||
data = read_sha1_file(sha1, type, &size); |
||||
if (!data) { |
||||
error("'%s': unable to read %s", name, sha1_to_hex(sha1)); |
||||
return 0; |
||||
} |
||||
hit = grep_buffer(opt, name, data, size); |
||||
free(data); |
||||
return hit; |
||||
} |
||||
|
||||
static int grep_file(struct grep_opt *opt, const char *filename) |
||||
{ |
||||
struct stat st; |
||||
int i; |
||||
char *data; |
||||
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; |
||||
i = open(filename, O_RDONLY); |
||||
if (i < 0) |
||||
goto err_ret; |
||||
data = xmalloc(st.st_size + 1); |
||||
if (st.st_size != xread(i, data, st.st_size)) { |
||||
error("'%s': short read %s", filename, strerror(errno)); |
||||
close(i); |
||||
free(data); |
||||
return 0; |
||||
} |
||||
close(i); |
||||
i = grep_buffer(opt, filename, data, st.st_size); |
||||
free(data); |
||||
return i; |
||||
} |
||||
|
||||
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) |
||||
|
||||
static int external_grep(struct grep_opt *opt, const char **paths, int cached) |
||||
{ |
||||
int i, nr, argc, hit, len; |
||||
const char *argv[MAXARGS+1]; |
||||
char randarg[ARGBUF]; |
||||
char *argptr = randarg; |
||||
struct grep_pat *p; |
||||
|
||||
len = nr = 0; |
||||
push_arg("grep"); |
||||
push_arg("-H"); |
||||
if (opt->fixed) |
||||
push_arg("-F"); |
||||
if (opt->linenum) |
||||
push_arg("-n"); |
||||
if (opt->regflags & REG_EXTENDED) |
||||
push_arg("-E"); |
||||
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); |
||||
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); |
||||
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); |
||||
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); |
||||
} |
||||
push_arg("--"); |
||||
|
||||
hit = 0; |
||||
argc = nr; |
||||
for (i = 0; i < active_nr; i++) { |
||||
struct cache_entry *ce = active_cache[i]; |
||||
if (ce_stage(ce) || !S_ISREG(ntohl(ce->ce_mode))) |
||||
continue; |
||||
if (!pathspec_matches(paths, ce->name)) |
||||
continue; |
||||
argv[argc++] = ce->name; |
||||
if (argc < MAXARGS) |
||||
continue; |
||||
hit += exec_grep(argc, argv); |
||||
argc = nr; |
||||
} |
||||
if (argc > nr) |
||||
hit += exec_grep(argc, argv); |
||||
return 0; |
||||
} |
||||
|
||||
static int grep_cache(struct grep_opt *opt, const char **paths, int cached) |
||||
{ |
||||
int hit = 0; |
||||
int nr; |
||||
read_cache(); |
||||
|
||||
#ifdef __unix__ |
||||
/* |
||||
* 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 (ce_stage(ce) || !S_ISREG(ntohl(ce->ce_mode))) |
||||
continue; |
||||
if (!pathspec_matches(paths, ce->name)) |
||||
continue; |
||||
if (cached) |
||||
hit |= grep_sha1(opt, ce->sha1, ce->name); |
||||
else |
||||
hit |= grep_file(opt, ce->name); |
||||
} |
||||
return hit; |
||||
} |
||||
|
||||
static int grep_tree(struct grep_opt *opt, const char **paths, |
||||
struct tree_desc *tree, |
||||
const char *tree_name, const char *base) |
||||
{ |
||||
unsigned mode; |
||||
int len; |
||||
int hit = 0; |
||||
const char *path; |
||||
const unsigned char *sha1; |
||||
char *down; |
||||
char *path_buf = xmalloc(PATH_MAX + strlen(tree_name) + 100); |
||||
|
||||
if (tree_name[0]) { |
||||
int offset = sprintf(path_buf, "%s:", tree_name); |
||||
down = path_buf + offset; |
||||
strcat(down, base); |
||||
} |
||||
else { |
||||
down = path_buf; |
||||
strcpy(down, base); |
||||
} |
||||
len = strlen(path_buf); |
||||
|
||||
while (tree->size) { |
||||
int pathlen; |
||||
sha1 = tree_entry_extract(tree, &path, &mode); |
||||
pathlen = strlen(path); |
||||
strcpy(path_buf + len, path); |
||||
|
||||
if (S_ISDIR(mode)) |
||||
/* Match "abc/" against pathspec to |
||||
* decide if we want to descend into "abc" |
||||
* directory. |
||||
*/ |
||||
strcpy(path_buf + len + pathlen, "/"); |
||||
|
||||
if (!pathspec_matches(paths, down)) |
||||
; |
||||
else if (S_ISREG(mode)) |
||||
hit |= grep_sha1(opt, sha1, path_buf); |
||||
else if (S_ISDIR(mode)) { |
||||
char type[20]; |
||||
struct tree_desc sub; |
||||
void *data; |
||||
data = read_sha1_file(sha1, type, &sub.size); |
||||
if (!data) |
||||
die("unable to read tree (%s)", |
||||
sha1_to_hex(sha1)); |
||||
sub.buf = data; |
||||
hit |= grep_tree(opt, paths, &sub, tree_name, down); |
||||
free(data); |
||||
} |
||||
update_tree_entry(tree); |
||||
} |
||||
return hit; |
||||
} |
||||
|
||||
static int grep_object(struct grep_opt *opt, const char **paths, |
||||
struct object *obj, const char *name) |
||||
{ |
||||
if (!strcmp(obj->type, blob_type)) |
||||
return grep_sha1(opt, obj->sha1, name); |
||||
if (!strcmp(obj->type, commit_type) || |
||||
!strcmp(obj->type, tree_type)) { |
||||
struct tree_desc tree; |
||||
void *data; |
||||
int hit; |
||||
data = read_object_with_reference(obj->sha1, tree_type, |
||||
&tree.size, NULL); |
||||
if (!data) |
||||
die("unable to read tree (%s)", sha1_to_hex(obj->sha1)); |
||||
tree.buf = data; |
||||
hit = grep_tree(opt, paths, &tree, name, ""); |
||||
free(data); |
||||
return hit; |
||||
} |
||||
die("unable to grep from object of type %s", obj->type); |
||||
} |
||||
|
||||
static const char builtin_grep_usage[] = |
||||
"git-grep <option>* <rev>* [-e] <pattern> [<path>...]"; |
||||
|
||||
int cmd_grep(int argc, const char **argv, char **envp) |
||||
{ |
||||
int hit = 0; |
||||
int cached = 0; |
||||
int seen_dashdash = 0; |
||||
struct grep_opt opt; |
||||
struct object_list *list, **tail, *object_list = NULL; |
||||
const char *prefix = setup_git_directory(); |
||||
const char **paths = NULL; |
||||
int i; |
||||
|
||||
memset(&opt, 0, sizeof(opt)); |
||||
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 |
||||
* unrecocnized non option is the beginning of the refs list |
||||
* that continues up to the -- (if exists), and then paths. |
||||
*/ |
||||
|
||||
tail = &object_list; |
||||
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)) { |
||||
/* We always show the pathname, so this |
||||
* is a noop. |
||||
*/ |
||||
continue; |
||||
} |
||||
if (!strcmp("-l", 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 (!strncmp("-A", arg, 2) || |
||||
!strncmp("-B", arg, 2) || |
||||
!strncmp("-C", arg, 2) || |
||||
(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) |
||||
usage(builtin_grep_usage); |
||||
scan = *++argv; |
||||
argc--; |
||||
} |
||||
else |
||||
scan = arg + 2; |
||||
break; |
||||
default: |
||||
scan = arg + 1; |
||||
break; |
||||
} |
||||
if (sscanf(scan, "%u", &num) != 1) |
||||
usage(builtin_grep_usage); |
||||
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) |
||||
usage(builtin_grep_usage); |
||||
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 (buf[len-1] == '\n') |
||||
buf[len-1] = 0; |
||||
/* ignore empty line like grep does */ |
||||
if (!buf[0]) |
||||
continue; |
||||
add_pattern(&opt, strdup(buf), argv[1], ++lno); |
||||
} |
||||
fclose(patterns); |
||||
argv++; |
||||
argc--; |
||||
continue; |
||||
} |
||||
if (!strcmp("-e", arg)) { |
||||
if (1 < argc) { |
||||
add_pattern(&opt, argv[1], "-e option", 0); |
||||
argv++; |
||||
argc--; |
||||
continue; |
||||
} |
||||
usage(builtin_grep_usage); |
||||
} |
||||
if (!strcmp("--", arg)) |
||||
break; |
||||
if (*arg == '-') |
||||
usage(builtin_grep_usage); |
||||
|
||||
/* First unrecognized non-option token */ |
||||
if (!opt.pattern_list) { |
||||
add_pattern(&opt, arg, "command line", 0); |
||||
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"); |
||||
if (!opt.fixed) |
||||
compile_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); |
||||
struct object_list *elem; |
||||
if (!object) |
||||
die("bad object %s", arg); |
||||
elem = object_list_insert(object, tail); |
||||
elem->name = arg; |
||||
tail = &elem->next; |
||||
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); |
||||
else if (prefix) { |
||||
paths = xcalloc(2, sizeof(const char *)); |
||||
paths[0] = prefix; |
||||
paths[1] = NULL; |
||||
} |
||||
|
||||
if (!object_list) |
||||
return !grep_cache(&opt, paths, cached); |
||||
|
||||
if (cached) |
||||
die("both --cached and trees are given."); |
||||
|
||||
for (list = object_list; list; list = list->next) { |
||||
struct object *real_obj; |
||||
real_obj = deref_tag(list->item, NULL, 0); |
||||
if (grep_object(&opt, paths, real_obj, list->name)) |
||||
hit = 1; |
||||
} |
||||
return !hit; |
||||
} |
||||
Loading…
Reference in new issue