diff options
Diffstat (limited to 'third_party/git/grep.c')
| -rw-r--r-- | third_party/git/grep.c | 2198 |
1 files changed, 0 insertions, 2198 deletions
diff --git a/third_party/git/grep.c b/third_party/git/grep.c deleted file mode 100644 index cd952ef5d3..0000000000 --- a/third_party/git/grep.c +++ /dev/null @@ -1,2198 +0,0 @@ -#include "cache.h" -#include "config.h" -#include "grep.h" -#include "object-store.h" -#include "userdiff.h" -#include "xdiff-interface.h" -#include "diff.h" -#include "diffcore.h" -#include "commit.h" -#include "quote.h" -#include "help.h" - -static int grep_source_load(struct grep_source *gs); -static int grep_source_is_binary(struct grep_source *gs, - struct index_state *istate); - -static struct grep_opt grep_defaults; - -static const char *color_grep_slots[] = { - [GREP_COLOR_CONTEXT] = "context", - [GREP_COLOR_FILENAME] = "filename", - [GREP_COLOR_FUNCTION] = "function", - [GREP_COLOR_LINENO] = "lineNumber", - [GREP_COLOR_COLUMNNO] = "column", - [GREP_COLOR_MATCH_CONTEXT] = "matchContext", - [GREP_COLOR_MATCH_SELECTED] = "matchSelected", - [GREP_COLOR_SELECTED] = "selected", - [GREP_COLOR_SEP] = "separator", -}; - -static void std_output(struct grep_opt *opt, const void *buf, size_t size) -{ - fwrite(buf, size, 1, stdout); -} - -static void color_set(char *dst, const char *color_bytes) -{ - xsnprintf(dst, COLOR_MAXLEN, "%s", color_bytes); -} - -/* - * Initialize the grep_defaults template with hardcoded defaults. - * We could let the compiler do this, but without C99 initializers - * the code gets unwieldy and unreadable, so... - */ -void init_grep_defaults(struct repository *repo) -{ - struct grep_opt *opt = &grep_defaults; - static int run_once; - - if (run_once) - return; - run_once++; - - memset(opt, 0, sizeof(*opt)); - opt->repo = repo; - opt->relative = 1; - opt->pathname = 1; - opt->max_depth = -1; - opt->pattern_type_option = GREP_PATTERN_TYPE_UNSPECIFIED; - color_set(opt->colors[GREP_COLOR_CONTEXT], ""); - color_set(opt->colors[GREP_COLOR_FILENAME], ""); - color_set(opt->colors[GREP_COLOR_FUNCTION], ""); - color_set(opt->colors[GREP_COLOR_LINENO], ""); - color_set(opt->colors[GREP_COLOR_COLUMNNO], ""); - color_set(opt->colors[GREP_COLOR_MATCH_CONTEXT], GIT_COLOR_BOLD_RED); - color_set(opt->colors[GREP_COLOR_MATCH_SELECTED], GIT_COLOR_BOLD_RED); - color_set(opt->colors[GREP_COLOR_SELECTED], ""); - color_set(opt->colors[GREP_COLOR_SEP], GIT_COLOR_CYAN); - opt->only_matching = 0; - opt->color = -1; - opt->output = std_output; -} - -static int parse_pattern_type_arg(const char *opt, const char *arg) -{ - if (!strcmp(arg, "default")) - return GREP_PATTERN_TYPE_UNSPECIFIED; - else if (!strcmp(arg, "basic")) - return GREP_PATTERN_TYPE_BRE; - else if (!strcmp(arg, "extended")) - return GREP_PATTERN_TYPE_ERE; - else if (!strcmp(arg, "fixed")) - return GREP_PATTERN_TYPE_FIXED; - else if (!strcmp(arg, "perl")) - return GREP_PATTERN_TYPE_PCRE; - die("bad %s argument: %s", opt, arg); -} - -define_list_config_array_extra(color_grep_slots, {"match"}); - -/* - * Read the configuration file once and store it in - * the grep_defaults template. - */ -int grep_config(const char *var, const char *value, void *cb) -{ - struct grep_opt *opt = &grep_defaults; - const char *slot; - - if (userdiff_config(var, value) < 0) - return -1; - - if (!strcmp(var, "grep.extendedregexp")) { - opt->extended_regexp_option = git_config_bool(var, value); - return 0; - } - - if (!strcmp(var, "grep.patterntype")) { - opt->pattern_type_option = parse_pattern_type_arg(var, value); - return 0; - } - - if (!strcmp(var, "grep.linenumber")) { - opt->linenum = git_config_bool(var, value); - return 0; - } - if (!strcmp(var, "grep.column")) { - opt->columnnum = git_config_bool(var, value); - return 0; - } - - if (!strcmp(var, "grep.fullname")) { - opt->relative = !git_config_bool(var, value); - return 0; - } - - if (!strcmp(var, "color.grep")) - opt->color = git_config_colorbool(var, value); - if (!strcmp(var, "color.grep.match")) { - if (grep_config("color.grep.matchcontext", value, cb) < 0) - return -1; - if (grep_config("color.grep.matchselected", value, cb) < 0) - return -1; - } else if (skip_prefix(var, "color.grep.", &slot)) { - int i = LOOKUP_CONFIG(color_grep_slots, slot); - char *color; - - if (i < 0) - return -1; - color = opt->colors[i]; - if (!value) - return config_error_nonbool(var); - return color_parse(value, color); - } - return 0; -} - -/* - * Initialize one instance of grep_opt and copy the - * default values from the template we read the configuration - * information in an earlier call to git_config(grep_config). - */ -void grep_init(struct grep_opt *opt, struct repository *repo, const char *prefix) -{ - struct grep_opt *def = &grep_defaults; - int i; - - memset(opt, 0, sizeof(*opt)); - opt->repo = repo; - opt->prefix = prefix; - opt->prefix_length = (prefix && *prefix) ? strlen(prefix) : 0; - opt->pattern_tail = &opt->pattern_list; - opt->header_tail = &opt->header_list; - - opt->only_matching = def->only_matching; - opt->color = def->color; - opt->extended_regexp_option = def->extended_regexp_option; - opt->pattern_type_option = def->pattern_type_option; - opt->linenum = def->linenum; - opt->columnnum = def->columnnum; - opt->max_depth = def->max_depth; - opt->pathname = def->pathname; - opt->relative = def->relative; - opt->output = def->output; - - for (i = 0; i < NR_GREP_COLORS; i++) - color_set(opt->colors[i], def->colors[i]); -} - -static void grep_set_pattern_type_option(enum grep_pattern_type pattern_type, struct grep_opt *opt) -{ - /* - * When committing to the pattern type by setting the relevant - * fields in grep_opt it's generally not necessary to zero out - * the fields we're not choosing, since they won't have been - * set by anything. The extended_regexp_option field is the - * only exception to this. - * - * This is because in the process of parsing grep.patternType - * & grep.extendedRegexp we set opt->pattern_type_option and - * opt->extended_regexp_option, respectively. We then - * internally use opt->extended_regexp_option to see if we're - * compiling an ERE. It must be unset if that's not actually - * the case. - */ - if (pattern_type != GREP_PATTERN_TYPE_ERE && - opt->extended_regexp_option) - opt->extended_regexp_option = 0; - - switch (pattern_type) { - case GREP_PATTERN_TYPE_UNSPECIFIED: - /* fall through */ - - case GREP_PATTERN_TYPE_BRE: - break; - - case GREP_PATTERN_TYPE_ERE: - opt->extended_regexp_option = 1; - break; - - case GREP_PATTERN_TYPE_FIXED: - opt->fixed = 1; - break; - - case GREP_PATTERN_TYPE_PCRE: -#ifdef USE_LIBPCRE2 - opt->pcre2 = 1; -#else - /* - * It's important that pcre1 always be assigned to - * even when there's no USE_LIBPCRE* defined. We still - * call the PCRE stub function, it just dies with - * "cannot use Perl-compatible regexes[...]". - */ - opt->pcre1 = 1; -#endif - break; - } -} - -void grep_commit_pattern_type(enum grep_pattern_type pattern_type, struct grep_opt *opt) -{ - if (pattern_type != GREP_PATTERN_TYPE_UNSPECIFIED) - grep_set_pattern_type_option(pattern_type, opt); - else if (opt->pattern_type_option != GREP_PATTERN_TYPE_UNSPECIFIED) - grep_set_pattern_type_option(opt->pattern_type_option, opt); - else if (opt->extended_regexp_option) - /* - * This branch *must* happen after setting from the - * opt->pattern_type_option above, we don't want - * grep.extendedRegexp to override grep.patternType! - */ - grep_set_pattern_type_option(GREP_PATTERN_TYPE_ERE, opt); -} - -static struct grep_pat *create_grep_pat(const char *pat, size_t patlen, - const char *origin, int no, - enum grep_pat_token t, - enum grep_header_field field) -{ - struct grep_pat *p = xcalloc(1, sizeof(*p)); - p->pattern = xmemdupz(pat, patlen); - p->patternlen = patlen; - p->origin = origin; - p->no = no; - p->token = t; - p->field = field; - return p; -} - -static void do_append_grep_pat(struct grep_pat ***tail, struct grep_pat *p) -{ - **tail = p; - *tail = &p->next; - p->next = NULL; - - switch (p->token) { - case GREP_PATTERN: /* atom */ - case GREP_PATTERN_HEAD: - case GREP_PATTERN_BODY: - for (;;) { - struct grep_pat *new_pat; - size_t len = 0; - char *cp = p->pattern + p->patternlen, *nl = NULL; - while (++len <= p->patternlen) { - if (*(--cp) == '\n') { - nl = cp; - break; - } - } - if (!nl) - break; - new_pat = create_grep_pat(nl + 1, len - 1, p->origin, - p->no, p->token, p->field); - new_pat->next = p->next; - if (!p->next) - *tail = &new_pat->next; - p->next = new_pat; - *nl = '\0'; - p->patternlen -= len; - } - break; - default: - break; - } -} - -void append_header_grep_pattern(struct grep_opt *opt, - enum grep_header_field field, const char *pat) -{ - struct grep_pat *p = create_grep_pat(pat, strlen(pat), "header", 0, - GREP_PATTERN_HEAD, field); - if (field == GREP_HEADER_REFLOG) - opt->use_reflog_filter = 1; - do_append_grep_pat(&opt->header_tail, p); -} - -void append_grep_pattern(struct grep_opt *opt, const char *pat, - const char *origin, int no, enum grep_pat_token t) -{ - append_grep_pat(opt, pat, strlen(pat), origin, no, t); -} - -void append_grep_pat(struct grep_opt *opt, const char *pat, size_t patlen, - const char *origin, int no, enum grep_pat_token t) -{ - struct grep_pat *p = create_grep_pat(pat, patlen, origin, no, t, 0); - do_append_grep_pat(&opt->pattern_tail, p); -} - -struct grep_opt *grep_opt_dup(const struct grep_opt *opt) -{ - struct grep_pat *pat; - struct grep_opt *ret = xmalloc(sizeof(struct grep_opt)); - *ret = *opt; - - ret->pattern_list = NULL; - ret->pattern_tail = &ret->pattern_list; - - for(pat = opt->pattern_list; pat != NULL; pat = pat->next) - { - if(pat->token == GREP_PATTERN_HEAD) - append_header_grep_pattern(ret, pat->field, - pat->pattern); - else - append_grep_pat(ret, pat->pattern, pat->patternlen, - pat->origin, pat->no, pat->token); - } - - return ret; -} - -static NORETURN void compile_regexp_failed(const struct grep_pat *p, - const char *error) -{ - char where[1024]; - - if (p->no) - xsnprintf(where, sizeof(where), "In '%s' at %d, ", p->origin, p->no); - else if (p->origin) - xsnprintf(where, sizeof(where), "%s, ", p->origin); - else - where[0] = 0; - - die("%s'%s': %s", where, p->pattern, error); -} - -static int is_fixed(const char *s, size_t len) -{ - size_t i; - - for (i = 0; i < len; i++) { - if (is_regex_special(s[i])) - return 0; - } - - return 1; -} - -static int has_null(const char *s, size_t len) -{ - /* - * regcomp cannot accept patterns with NULs so when using it - * we consider any pattern containing a NUL fixed. - */ - if (memchr(s, 0, len)) - return 1; - - return 0; -} - -#ifdef USE_LIBPCRE1 -static void compile_pcre1_regexp(struct grep_pat *p, const struct grep_opt *opt) -{ - const char *error; - int erroffset; - int options = PCRE_MULTILINE; - - if (opt->ignore_case) { - if (has_non_ascii(p->pattern)) - p->pcre1_tables = pcre_maketables(); - options |= PCRE_CASELESS; - } - if (is_utf8_locale() && has_non_ascii(p->pattern)) - options |= PCRE_UTF8; - - p->pcre1_regexp = pcre_compile(p->pattern, options, &error, &erroffset, - p->pcre1_tables); - if (!p->pcre1_regexp) - compile_regexp_failed(p, error); - - p->pcre1_extra_info = pcre_study(p->pcre1_regexp, GIT_PCRE_STUDY_JIT_COMPILE, &error); - if (!p->pcre1_extra_info && error) - die("%s", error); - -#ifdef GIT_PCRE1_USE_JIT - pcre_config(PCRE_CONFIG_JIT, &p->pcre1_jit_on); - if (p->pcre1_jit_on == 1) { - p->pcre1_jit_stack = pcre_jit_stack_alloc(1, 1024 * 1024); - if (!p->pcre1_jit_stack) - die("Couldn't allocate PCRE JIT stack"); - pcre_assign_jit_stack(p->pcre1_extra_info, NULL, p->pcre1_jit_stack); - } else if (p->pcre1_jit_on != 0) { - BUG("The pcre1_jit_on variable should be 0 or 1, not %d", - p->pcre1_jit_on); - } -#endif -} - -static int pcre1match(struct grep_pat *p, const char *line, const char *eol, - regmatch_t *match, int eflags) -{ - int ovector[30], ret, flags = 0; - - if (eflags & REG_NOTBOL) - flags |= PCRE_NOTBOL; - -#ifdef GIT_PCRE1_USE_JIT - if (p->pcre1_jit_on) { - ret = pcre_jit_exec(p->pcre1_regexp, p->pcre1_extra_info, line, - eol - line, 0, flags, ovector, - ARRAY_SIZE(ovector), p->pcre1_jit_stack); - } else -#endif - { - ret = pcre_exec(p->pcre1_regexp, p->pcre1_extra_info, line, - eol - line, 0, flags, ovector, - ARRAY_SIZE(ovector)); - } - - if (ret < 0 && ret != PCRE_ERROR_NOMATCH) - die("pcre_exec failed with error code %d", ret); - if (ret > 0) { - ret = 0; - match->rm_so = ovector[0]; - match->rm_eo = ovector[1]; - } - - return ret; -} - -static void free_pcre1_regexp(struct grep_pat *p) -{ - pcre_free(p->pcre1_regexp); -#ifdef GIT_PCRE1_USE_JIT - if (p->pcre1_jit_on) { - pcre_free_study(p->pcre1_extra_info); - pcre_jit_stack_free(p->pcre1_jit_stack); - } else -#endif - { - pcre_free(p->pcre1_extra_info); - } - pcre_free((void *)p->pcre1_tables); -} -#else /* !USE_LIBPCRE1 */ -static void compile_pcre1_regexp(struct grep_pat *p, const struct grep_opt *opt) -{ - die("cannot use Perl-compatible regexes when not compiled with USE_LIBPCRE"); -} - -static int pcre1match(struct grep_pat *p, const char *line, const char *eol, - regmatch_t *match, int eflags) -{ - return 1; -} - -static void free_pcre1_regexp(struct grep_pat *p) -{ -} -#endif /* !USE_LIBPCRE1 */ - -#ifdef USE_LIBPCRE2 -static void compile_pcre2_pattern(struct grep_pat *p, const struct grep_opt *opt) -{ - int error; - PCRE2_UCHAR errbuf[256]; - PCRE2_SIZE erroffset; - int options = PCRE2_MULTILINE; - const uint8_t *character_tables = NULL; - int jitret; - int patinforet; - size_t jitsizearg; - - assert(opt->pcre2); - - p->pcre2_compile_context = NULL; - - if (opt->ignore_case) { - if (has_non_ascii(p->pattern)) { - character_tables = pcre2_maketables(NULL); - p->pcre2_compile_context = pcre2_compile_context_create(NULL); - pcre2_set_character_tables(p->pcre2_compile_context, character_tables); - } - options |= PCRE2_CASELESS; - } - if (is_utf8_locale() && has_non_ascii(p->pattern)) - options |= PCRE2_UTF; - - p->pcre2_pattern = pcre2_compile((PCRE2_SPTR)p->pattern, - p->patternlen, options, &error, &erroffset, - p->pcre2_compile_context); - - if (p->pcre2_pattern) { - p->pcre2_match_data = pcre2_match_data_create_from_pattern(p->pcre2_pattern, NULL); - if (!p->pcre2_match_data) - die("Couldn't allocate PCRE2 match data"); - } else { - pcre2_get_error_message(error, errbuf, sizeof(errbuf)); - compile_regexp_failed(p, (const char *)&errbuf); - } - - pcre2_config(PCRE2_CONFIG_JIT, &p->pcre2_jit_on); - if (p->pcre2_jit_on == 1) { - jitret = pcre2_jit_compile(p->pcre2_pattern, PCRE2_JIT_COMPLETE); - if (jitret) - die("Couldn't JIT the PCRE2 pattern '%s', got '%d'\n", p->pattern, jitret); - - /* - * The pcre2_config(PCRE2_CONFIG_JIT, ...) call just - * tells us whether the library itself supports JIT, - * but to see whether we're going to be actually using - * JIT we need to extract PCRE2_INFO_JITSIZE from the - * pattern *after* we do pcre2_jit_compile() above. - * - * This is because if the pattern contains the - * (*NO_JIT) verb (see pcre2syntax(3)) - * pcre2_jit_compile() will exit early with 0. If we - * then proceed to call pcre2_jit_match() further down - * the line instead of pcre2_match() we'll either - * segfault (pre PCRE 10.31) or run into a fatal error - * (post PCRE2 10.31) - */ - patinforet = pcre2_pattern_info(p->pcre2_pattern, PCRE2_INFO_JITSIZE, &jitsizearg); - if (patinforet) - BUG("pcre2_pattern_info() failed: %d", patinforet); - if (jitsizearg == 0) { - p->pcre2_jit_on = 0; - return; - } - - p->pcre2_jit_stack = pcre2_jit_stack_create(1, 1024 * 1024, NULL); - if (!p->pcre2_jit_stack) - die("Couldn't allocate PCRE2 JIT stack"); - p->pcre2_match_context = pcre2_match_context_create(NULL); - if (!p->pcre2_match_context) - die("Couldn't allocate PCRE2 match context"); - pcre2_jit_stack_assign(p->pcre2_match_context, NULL, p->pcre2_jit_stack); - } else if (p->pcre2_jit_on != 0) { - BUG("The pcre2_jit_on variable should be 0 or 1, not %d", - p->pcre2_jit_on); - } -} - -static int pcre2match(struct grep_pat *p, const char *line, const char *eol, - regmatch_t *match, int eflags) -{ - int ret, flags = 0; - PCRE2_SIZE *ovector; - PCRE2_UCHAR errbuf[256]; - - if (eflags & REG_NOTBOL) - flags |= PCRE2_NOTBOL; - - if (p->pcre2_jit_on) - ret = pcre2_jit_match(p->pcre2_pattern, (unsigned char *)line, - eol - line, 0, flags, p->pcre2_match_data, - NULL); - else - ret = pcre2_match(p->pcre2_pattern, (unsigned char *)line, - eol - line, 0, flags, p->pcre2_match_data, - NULL); - - if (ret < 0 && ret != PCRE2_ERROR_NOMATCH) { - pcre2_get_error_message(ret, errbuf, sizeof(errbuf)); - die("%s failed with error code %d: %s", - (p->pcre2_jit_on ? "pcre2_jit_match" : "pcre2_match"), ret, - errbuf); - } - if (ret > 0) { - ovector = pcre2_get_ovector_pointer(p->pcre2_match_data); - ret = 0; - match->rm_so = (int)ovector[0]; - match->rm_eo = (int)ovector[1]; - } - - return ret; -} - -static void free_pcre2_pattern(struct grep_pat *p) -{ - pcre2_compile_context_free(p->pcre2_compile_context); - pcre2_code_free(p->pcre2_pattern); - pcre2_match_data_free(p->pcre2_match_data); - pcre2_jit_stack_free(p->pcre2_jit_stack); - pcre2_match_context_free(p->pcre2_match_context); -} -#else /* !USE_LIBPCRE2 */ -static void compile_pcre2_pattern(struct grep_pat *p, const struct grep_opt *opt) -{ - /* - * Unreachable until USE_LIBPCRE2 becomes synonymous with - * USE_LIBPCRE. See the sibling comment in - * grep_set_pattern_type_option(). - */ - die("cannot use Perl-compatible regexes when not compiled with USE_LIBPCRE"); -} - -static int pcre2match(struct grep_pat *p, const char *line, const char *eol, - regmatch_t *match, int eflags) -{ - return 1; -} - -static void free_pcre2_pattern(struct grep_pat *p) -{ -} -#endif /* !USE_LIBPCRE2 */ - -static void compile_fixed_regexp(struct grep_pat *p, struct grep_opt *opt) -{ - struct strbuf sb = STRBUF_INIT; - int err; - int regflags = 0; - - basic_regex_quote_buf(&sb, p->pattern); - if (opt->ignore_case) - regflags |= REG_ICASE; - err = regcomp(&p->regexp, sb.buf, regflags); - if (opt->debug) - fprintf(stderr, "fixed %s\n", sb.buf); - strbuf_release(&sb); - if (err) { - char errbuf[1024]; - regerror(err, &p->regexp, errbuf, sizeof(errbuf)); - compile_regexp_failed(p, errbuf); - } -} - -static void compile_regexp(struct grep_pat *p, struct grep_opt *opt) -{ - int ascii_only; - int err; - int regflags = REG_NEWLINE; - - p->word_regexp = opt->word_regexp; - p->ignore_case = opt->ignore_case; - ascii_only = !has_non_ascii(p->pattern); - - /* - * Even when -F (fixed) asks us to do a non-regexp search, we - * may not be able to correctly case-fold when -i - * (ignore-case) is asked (in which case, we'll synthesize a - * regexp to match the pattern that matches regexp special - * characters literally, while ignoring case differences). On - * the other hand, even without -F, if the pattern does not - * have any regexp special characters and there is no need for - * case-folding search, we can internally turn it into a - * simple string match using kws. p->fixed tells us if we - * want to use kws. - */ - if (opt->fixed || - has_null(p->pattern, p->patternlen) || - is_fixed(p->pattern, p->patternlen)) - p->fixed = !p->ignore_case || ascii_only; - - if (p->fixed) { - p->kws = kwsalloc(p->ignore_case ? tolower_trans_tbl : NULL); - kwsincr(p->kws, p->pattern, p->patternlen); - kwsprep(p->kws); - return; - } else if (opt->fixed) { - /* - * We come here when the pattern has the non-ascii - * characters we cannot case-fold, and asked to - * ignore-case. - */ - compile_fixed_regexp(p, opt); - return; - } - - if (opt->pcre2) { - compile_pcre2_pattern(p, opt); - return; - } - - if (opt->pcre1) { - compile_pcre1_regexp(p, opt); - return; - } - - if (p->ignore_case) - regflags |= REG_ICASE; - if (opt->extended_regexp_option) - regflags |= REG_EXTENDED; - err = regcomp(&p->regexp, p->pattern, regflags); - if (err) { - char errbuf[1024]; - regerror(err, &p->regexp, errbuf, 1024); - compile_regexp_failed(p, errbuf); - } -} - -static struct grep_expr *compile_pattern_or(struct grep_pat **); -static struct grep_expr *compile_pattern_atom(struct grep_pat **list) -{ - struct grep_pat *p; - struct grep_expr *x; - - p = *list; - if (!p) - return NULL; - switch (p->token) { - case GREP_PATTERN: /* atom */ - case GREP_PATTERN_HEAD: - case GREP_PATTERN_BODY: - x = xcalloc(1, sizeof (struct grep_expr)); - x->node = GREP_NODE_ATOM; - x->u.atom = p; - *list = p->next; - return x; - case GREP_OPEN_PAREN: - *list = p->next; - x = compile_pattern_or(list); - if (!*list || (*list)->token != GREP_CLOSE_PAREN) - die("unmatched parenthesis"); - *list = (*list)->next; - return x; - default: - return NULL; - } -} - -static struct grep_expr *compile_pattern_not(struct grep_pat **list) -{ - struct grep_pat *p; - struct grep_expr *x; - - p = *list; - if (!p) - return NULL; - switch (p->token) { - case GREP_NOT: - if (!p->next) - die("--not not followed by pattern expression"); - *list = p->next; - x = xcalloc(1, sizeof (struct grep_expr)); - x->node = GREP_NODE_NOT; - x->u.unary = compile_pattern_not(list); - if (!x->u.unary) - die("--not followed by non pattern expression"); - return x; - default: - return compile_pattern_atom(list); - } -} - -static struct grep_expr *compile_pattern_and(struct grep_pat **list) -{ - struct grep_pat *p; - struct grep_expr *x, *y, *z; - - x = compile_pattern_not(list); - p = *list; - if (p && p->token == GREP_AND) { - if (!p->next) - die("--and not followed by pattern expression"); - *list = p->next; - y = compile_pattern_and(list); - if (!y) - die("--and not followed by pattern expression"); - z = xcalloc(1, sizeof (struct grep_expr)); - z->node = GREP_NODE_AND; - z->u.binary.left = x; - z->u.binary.right = y; - return z; - } - return x; -} - -static struct grep_expr *compile_pattern_or(struct grep_pat **list) -{ - struct grep_pat *p; - struct grep_expr *x, *y, *z; - - x = compile_pattern_and(list); - p = *list; - if (x && p && p->token != GREP_CLOSE_PAREN) { - y = compile_pattern_or(list); - if (!y) - die("not a pattern expression %s", p->pattern); - z = xcalloc(1, sizeof (struct grep_expr)); - z->node = GREP_NODE_OR; - z->u.binary.left = x; - z->u.binary.right = y; - return z; - } - return x; -} - -static struct grep_expr *compile_pattern_expr(struct grep_pat **list) -{ - return compile_pattern_or(list); -} - -static void indent(int in) -{ - while (in-- > 0) - fputc(' ', stderr); -} - -static void dump_grep_pat(struct grep_pat *p) -{ - switch (p->token) { - case GREP_AND: fprintf(stderr, "*and*"); break; - case GREP_OPEN_PAREN: fprintf(stderr, "*(*"); break; - case GREP_CLOSE_PAREN: fprintf(stderr, "*)*"); break; - case GREP_NOT: fprintf(stderr, "*not*"); break; - case GREP_OR: fprintf(stderr, "*or*"); break; - - case GREP_PATTERN: fprintf(stderr, "pattern"); break; - case GREP_PATTERN_HEAD: fprintf(stderr, "pattern_head"); break; - case GREP_PATTERN_BODY: fprintf(stderr, "pattern_body"); break; - } - - switch (p->token) { - default: break; - case GREP_PATTERN_HEAD: - fprintf(stderr, "<head %d>", p->field); break; - case GREP_PATTERN_BODY: - fprintf(stderr, "<body>"); break; - } - switch (p->token) { - default: break; - case GREP_PATTERN_HEAD: - case GREP_PATTERN_BODY: - case GREP_PATTERN: - fprintf(stderr, "%.*s", (int)p->patternlen, p->pattern); - break; - } - fputc('\n', stderr); -} - -static void dump_grep_expression_1(struct grep_expr *x, int in) -{ - indent(in); - switch (x->node) { - case GREP_NODE_TRUE: - fprintf(stderr, "true\n"); - break; - case GREP_NODE_ATOM: - dump_grep_pat(x->u.atom); - break; - case GREP_NODE_NOT: - fprintf(stderr, "(not\n"); - dump_grep_expression_1(x->u.unary, in+1); - indent(in); - fprintf(stderr, ")\n"); - break; - case GREP_NODE_AND: - fprintf(stderr, "(and\n"); - dump_grep_expression_1(x->u.binary.left, in+1); - dump_grep_expression_1(x->u.binary.right, in+1); - indent(in); - fprintf(stderr, ")\n"); - break; - case GREP_NODE_OR: - fprintf(stderr, "(or\n"); - dump_grep_expression_1(x->u.binary.left, in+1); - dump_grep_expression_1(x->u.binary.right, in+1); - indent(in); - fprintf(stderr, ")\n"); - break; - } -} - -static void dump_grep_expression(struct grep_opt *opt) -{ - struct grep_expr *x = opt->pattern_expression; - - if (opt->all_match) - fprintf(stderr, "[all-match]\n"); - dump_grep_expression_1(x, 0); - fflush(NULL); -} - -static struct grep_expr *grep_true_expr(void) -{ - struct grep_expr *z = xcalloc(1, sizeof(*z)); - z->node = GREP_NODE_TRUE; - return z; -} - -static struct grep_expr *grep_or_expr(struct grep_expr *left, struct grep_expr *right) -{ - struct grep_expr *z = xcalloc(1, sizeof(*z)); - z->node = GREP_NODE_OR; - z->u.binary.left = left; - z->u.binary.right = right; - return z; -} - -static struct grep_expr *prep_header_patterns(struct grep_opt *opt) -{ - struct grep_pat *p; - struct grep_expr *header_expr; - struct grep_expr *(header_group[GREP_HEADER_FIELD_MAX]); - enum grep_header_field fld; - - if (!opt->header_list) - return NULL; - - for (p = opt->header_list; p; p = p->next) { - if (p->token != GREP_PATTERN_HEAD) - BUG("a non-header pattern in grep header list."); - if (p->field < GREP_HEADER_FIELD_MIN || - GREP_HEADER_FIELD_MAX <= p->field) - BUG("unknown header field %d", p->field); - compile_regexp(p, opt); - } - - for (fld = 0; fld < GREP_HEADER_FIELD_MAX; fld++) - header_group[fld] = NULL; - - for (p = opt->header_list; p; p = p->next) { - struct grep_expr *h; - struct grep_pat *pp = p; - - h = compile_pattern_atom(&pp); - if (!h || pp != p->next) - BUG("malformed header expr"); - if (!header_group[p->field]) { - header_group[p->field] = h; - continue; - } - header_group[p->field] = grep_or_expr(h, header_group[p->field]); - } - - header_expr = NULL; - - for (fld = 0; fld < GREP_HEADER_FIELD_MAX; fld++) { - if (!header_group[fld]) - continue; - if (!header_expr) - header_expr = grep_true_expr(); - header_expr = grep_or_expr(header_group[fld], header_expr); - } - return header_expr; -} - -static struct grep_expr *grep_splice_or(struct grep_expr *x, struct grep_expr *y) -{ - struct grep_expr *z = x; - - while (x) { - assert(x->node == GREP_NODE_OR); - if (x->u.binary.right && - x->u.binary.right->node == GREP_NODE_TRUE) { - x->u.binary.right = y; - break; - } - x = x->u.binary.right; - } - return z; -} - -static void compile_grep_patterns_real(struct grep_opt *opt) -{ - struct grep_pat *p; - struct grep_expr *header_expr = prep_header_patterns(opt); - - for (p = opt->pattern_list; p; p = p->next) { - switch (p->token) { - case GREP_PATTERN: /* atom */ - case GREP_PATTERN_HEAD: - case GREP_PATTERN_BODY: - compile_regexp(p, opt); - break; - default: - opt->extended = 1; - break; - } - } - - if (opt->all_match || header_expr) - opt->extended = 1; - else if (!opt->extended && !opt->debug) - return; - - p = opt->pattern_list; - if (p) - opt->pattern_expression = compile_pattern_expr(&p); - if (p) - die("incomplete pattern expression: %s", p->pattern); - - if (!header_expr) - return; - - if (!opt->pattern_expression) - opt->pattern_expression = header_expr; - else if (opt->all_match) - opt->pattern_expression = grep_splice_or(header_expr, - opt->pattern_expression); - else - opt->pattern_expression = grep_or_expr(opt->pattern_expression, - header_expr); - opt->all_match = 1; -} - -void compile_grep_patterns(struct grep_opt *opt) -{ - compile_grep_patterns_real(opt); - if (opt->debug) - dump_grep_expression(opt); -} - -static void free_pattern_expr(struct grep_expr *x) -{ - switch (x->node) { - case GREP_NODE_TRUE: - case GREP_NODE_ATOM: - break; - case GREP_NODE_NOT: - free_pattern_expr(x->u.unary); - break; - case GREP_NODE_AND: - case GREP_NODE_OR: - free_pattern_expr(x->u.binary.left); - free_pattern_expr(x->u.binary.right); - break; - } - free(x); -} - -void free_grep_patterns(struct grep_opt *opt) -{ - struct grep_pat *p, *n; - - for (p = opt->pattern_list; p; p = n) { - n = p->next; - switch (p->token) { - case GREP_PATTERN: /* atom */ - case GREP_PATTERN_HEAD: - case GREP_PATTERN_BODY: - if (p->kws) - kwsfree(p->kws); - else if (p->pcre1_regexp) - free_pcre1_regexp(p); - else if (p->pcre2_pattern) - free_pcre2_pattern(p); - else - regfree(&p->regexp); - free(p->pattern); - break; - default: - break; - } - free(p); - } - - if (!opt->extended) - return; - free_pattern_expr(opt->pattern_expression); -} - -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 output_color(struct grep_opt *opt, const void *data, size_t size, - const char *color) -{ - if (want_color(opt->color) && color && color[0]) { - opt->output(opt, color, strlen(color)); - opt->output(opt, data, size); - opt->output(opt, GIT_COLOR_RESET, strlen(GIT_COLOR_RESET)); - } else - opt->output(opt, data, size); -} - -static void output_sep(struct grep_opt *opt, char sign) -{ - if (opt->null_following_name) - opt->output(opt, "\0", 1); - else - output_color(opt, &sign, 1, opt->colors[GREP_COLOR_SEP]); -} - -static void show_name(struct grep_opt *opt, const char *name) -{ - output_color(opt, name, strlen(name), opt->colors[GREP_COLOR_FILENAME]); - opt->output(opt, opt->null_following_name ? "\0" : "\n", 1); -} - -static int fixmatch(struct grep_pat *p, char *line, char *eol, - regmatch_t *match) -{ - struct kwsmatch kwsm; - size_t offset = kwsexec(p->kws, line, eol - line, &kwsm); - if (offset == -1) { - match->rm_so = match->rm_eo = -1; - return REG_NOMATCH; - } else { - match->rm_so = offset; - match->rm_eo = match->rm_so + kwsm.size[0]; - return 0; - } -} - -static int patmatch(struct grep_pat *p, char *line, char *eol, - regmatch_t *match, int eflags) -{ - int hit; - - if (p->fixed) - hit = !fixmatch(p, line, eol, match); - else if (p->pcre1_regexp) - hit = !pcre1match(p, line, eol, match, eflags); - else if (p->pcre2_pattern) - hit = !pcre2match(p, line, eol, match, eflags); - else - hit = !regexec_buf(&p->regexp, line, eol - line, 1, match, - eflags); - - return hit; -} - -static int strip_timestamp(char *bol, char **eol_p) -{ - char *eol = *eol_p; - int ch; - - while (bol < --eol) { - if (*eol != '>') - continue; - *eol_p = ++eol; - ch = *eol; - *eol = '\0'; - return ch; - } - return 0; -} - -static struct { - const char *field; - size_t len; -} header_field[] = { - { "author ", 7 }, - { "committer ", 10 }, - { "reflog ", 7 }, -}; - -static int match_one_pattern(struct grep_pat *p, char *bol, char *eol, - enum grep_context ctx, - regmatch_t *pmatch, int eflags) -{ - int hit = 0; - int saved_ch = 0; - const char *start = bol; - - if ((p->token != GREP_PATTERN) && - ((p->token == GREP_PATTERN_HEAD) != (ctx == GREP_CONTEXT_HEAD))) - return 0; - - if (p->token == GREP_PATTERN_HEAD) { - const char *field; - size_t len; - assert(p->field < ARRAY_SIZE(header_field)); - field = header_field[p->field].field; - len = header_field[p->field].len; - if (strncmp(bol, field, len)) - return 0; - bol += len; - switch (p->field) { - case GREP_HEADER_AUTHOR: - case GREP_HEADER_COMMITTER: - saved_ch = strip_timestamp(bol, &eol); - break; - default: - break; - } - } - - again: - hit = patmatch(p, bol, eol, pmatch, eflags); - - if (hit && p->word_regexp) { - 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"); - - /* Match beginning must be either beginning of the - * line, or at word boundary (i.e. the last char must - * not be a word char). Similarly, match end must be - * either end of the line, or at word boundary - * (i.e. the next char must not be a word char). - */ - if ( ((pmatch[0].rm_so == 0) || - !word_char(bol[pmatch[0].rm_so-1])) && - ((pmatch[0].rm_eo == (eol-bol)) || - !word_char(bol[pmatch[0].rm_eo])) ) - ; - else - hit = 0; - - /* Words consist of at least one character. */ - if (pmatch->rm_so == pmatch->rm_eo) - hit = 0; - - if (!hit && pmatch[0].rm_so + bol + 1 < eol) { - /* There could be more than one match on the - * line, and the first match might not be - * strict word match. But later ones could be! - * Forward to the next possible start, i.e. the - * next position following a non-word char. - */ - bol = pmatch[0].rm_so + bol + 1; - while (word_char(bol[-1]) && bol < eol) - bol++; - eflags |= REG_NOTBOL; - if (bol < eol) - goto again; - } - } - if (p->token == GREP_PATTERN_HEAD && saved_ch) - *eol = saved_ch; - if (hit) { - pmatch[0].rm_so += bol - start; - pmatch[0].rm_eo += bol - start; - } - return hit; -} - -static int match_expr_eval(struct grep_opt *opt, struct grep_expr *x, char *bol, - char *eol, enum grep_context ctx, ssize_t *col, - ssize_t *icol, int collect_hits) -{ - int h = 0; - - if (!x) - die("Not a valid grep expression"); - switch (x->node) { - case GREP_NODE_TRUE: - h = 1; - break; - case GREP_NODE_ATOM: - { - regmatch_t tmp; - h = match_one_pattern(x->u.atom, bol, eol, ctx, - &tmp, 0); - if (h && (*col < 0 || tmp.rm_so < *col)) - *col = tmp.rm_so; - } - break; - case GREP_NODE_NOT: - /* - * Upon visiting a GREP_NODE_NOT, col and icol become swapped. - */ - h = !match_expr_eval(opt, x->u.unary, bol, eol, ctx, icol, col, - 0); - break; - case GREP_NODE_AND: - h = match_expr_eval(opt, x->u.binary.left, bol, eol, ctx, col, - icol, 0); - if (h || opt->columnnum) { - /* - * Don't short-circuit AND when given --column, since a - * NOT earlier in the tree may turn this into an OR. In - * this case, see the below comment. - */ - h &= match_expr_eval(opt, x->u.binary.right, bol, eol, - ctx, col, icol, 0); - } - break; - case GREP_NODE_OR: - if (!(collect_hits || opt->columnnum)) { - /* - * Don't short-circuit OR when given --column (or - * collecting hits) to ensure we don't skip a later - * child that would produce an earlier match. - */ - return (match_expr_eval(opt, x->u.binary.left, bol, eol, - ctx, col, icol, 0) || - match_expr_eval(opt, x->u.binary.right, bol, - eol, ctx, col, icol, 0)); - } - h = match_expr_eval(opt, x->u.binary.left, bol, eol, ctx, col, - icol, 0); - if (collect_hits) - x->u.binary.left->hit |= h; - h |= match_expr_eval(opt, x->u.binary.right, bol, eol, ctx, col, - icol, collect_hits); - break; - default: - die("Unexpected node type (internal error) %d", x->node); - } - if (collect_hits) - x->hit |= h; - return h; -} - -static int match_expr(struct grep_opt *opt, char *bol, char *eol, - enum grep_context ctx, ssize_t *col, - ssize_t *icol, int collect_hits) -{ - struct grep_expr *x = opt->pattern_expression; - return match_expr_eval(opt, x, bol, eol, ctx, col, icol, collect_hits); -} - -static int match_line(struct grep_opt *opt, char *bol, char *eol, - ssize_t *col, ssize_t *icol, - enum grep_context ctx, int collect_hits) -{ - struct grep_pat *p; - int hit = 0; - - if (opt->extended) - return match_expr(opt, bol, eol, ctx, col, icol, - collect_hits); - - /* we do not call with collect_hits without being extended */ - for (p = opt->pattern_list; p; p = p->next) { - regmatch_t tmp; - if (match_one_pattern(p, bol, eol, ctx, &tmp, 0)) { - hit |= 1; - if (!opt->columnnum) { - /* - * Without --column, any single match on a line - * is enough to know that it needs to be - * printed. With --column, scan _all_ patterns - * to find the earliest. - */ - break; - } - if (*col < 0 || tmp.rm_so < *col) - *col = tmp.rm_so; - } - } - return hit; -} - -static int match_next_pattern(struct grep_pat *p, char *bol, char *eol, - enum grep_context ctx, - regmatch_t *pmatch, int eflags) -{ - regmatch_t match; - - if (!match_one_pattern(p, bol, eol, ctx, &match, eflags)) - return 0; - if (match.rm_so < 0 || match.rm_eo < 0) - return 0; - if (pmatch->rm_so >= 0 && pmatch->rm_eo >= 0) { - if (match.rm_so > pmatch->rm_so) - return 1; - if (match.rm_so == pmatch->rm_so && match.rm_eo < pmatch->rm_eo) - return 1; - } - pmatch->rm_so = match.rm_so; - pmatch->rm_eo = match.rm_eo; - return 1; -} - -static int next_match(struct grep_opt *opt, char *bol, char *eol, - enum grep_context ctx, regmatch_t *pmatch, int eflags) -{ - struct grep_pat *p; - int hit = 0; - - pmatch->rm_so = pmatch->rm_eo = -1; - if (bol < eol) { - for (p = opt->pattern_list; p; p = p->next) { - switch (p->token) { - case GREP_PATTERN: /* atom */ - case GREP_PATTERN_HEAD: - case GREP_PATTERN_BODY: - hit |= match_next_pattern(p, bol, eol, ctx, - pmatch, eflags); - break; - default: - break; - } - } - } - return hit; -} - -static void show_line_header(struct grep_opt *opt, const char *name, - unsigned lno, ssize_t cno, char sign) -{ - if (opt->heading && opt->last_shown == 0) { - output_color(opt, name, strlen(name), opt->colors[GREP_COLOR_FILENAME]); - opt->output(opt, "\n", 1); - } - opt->last_shown = lno; - - if (!opt->heading && opt->pathname) { - output_color(opt, name, strlen(name), opt->colors[GREP_COLOR_FILENAME]); - output_sep(opt, sign); - } - if (opt->linenum) { - char buf[32]; - xsnprintf(buf, sizeof(buf), "%d", lno); - output_color(opt, buf, strlen(buf), opt->colors[GREP_COLOR_LINENO]); - output_sep(opt, sign); - } - /* - * Treat 'cno' as the 1-indexed offset from the start of a non-context - * line to its first match. Otherwise, 'cno' is 0 indicating that we are - * being called with a context line. - */ - if (opt->columnnum && cno) { - char buf[32]; - xsnprintf(buf, sizeof(buf), "%"PRIuMAX, (uintmax_t)cno); - output_color(opt, buf, strlen(buf), opt->colors[GREP_COLOR_COLUMNNO]); - output_sep(opt, sign); - } -} - -static void show_line(struct grep_opt *opt, char *bol, char *eol, - const char *name, unsigned lno, ssize_t cno, char sign) -{ - int rest = eol - bol; - const char *match_color = NULL; - const char *line_color = NULL; - - if (opt->file_break && opt->last_shown == 0) { - if (opt->show_hunk_mark) - opt->output(opt, "\n", 1); - } else if (opt->pre_context || opt->post_context || opt->funcbody) { - if (opt->last_shown == 0) { - if (opt->show_hunk_mark) { - output_color(opt, "--", 2, opt->colors[GREP_COLOR_SEP]); - opt->output(opt, "\n", 1); - } - } else if (lno > opt->last_shown + 1) { - output_color(opt, "--", 2, opt->colors[GREP_COLOR_SEP]); - opt->output(opt, "\n", 1); - } - } - if (!opt->only_matching) { - /* - * In case the line we're being called with contains more than - * one match, leave printing each header to the loop below. - */ - show_line_header(opt, name, lno, cno, sign); - } - if (opt->color || opt->only_matching) { - regmatch_t match; - enum grep_context ctx = GREP_CONTEXT_BODY; - int ch = *eol; - int eflags = 0; - - if (opt->color) { - if (sign == ':') - match_color = opt->colors[GREP_COLOR_MATCH_SELECTED]; - else - match_color = opt->colors[GREP_COLOR_MATCH_CONTEXT]; - if (sign == ':') - line_color = opt->colors[GREP_COLOR_SELECTED]; - else if (sign == '-') - line_color = opt->colors[GREP_COLOR_CONTEXT]; - else if (sign == '=') - line_color = opt->colors[GREP_COLOR_FUNCTION]; - } - *eol = '\0'; - while (next_match(opt, bol, eol, ctx, &match, eflags)) { - if (match.rm_so == match.rm_eo) - break; - - if (opt->only_matching) - show_line_header(opt, name, lno, cno, sign); - else - output_color(opt, bol, match.rm_so, line_color); - output_color(opt, bol + match.rm_so, - match.rm_eo - match.rm_so, match_color); - if (opt->only_matching) - opt->output(opt, "\n", 1); - bol += match.rm_eo; - cno += match.rm_eo; - rest -= match.rm_eo; - eflags = REG_NOTBOL; - } - *eol = ch; - } - if (!opt->only_matching) { - output_color(opt, bol, rest, line_color); - opt->output(opt, "\n", 1); - } -} - -int grep_use_locks; - -/* - * This lock protects access to the gitattributes machinery, which is - * not thread-safe. - */ -pthread_mutex_t grep_attr_mutex; - -static inline void grep_attr_lock(void) -{ - if (grep_use_locks) - pthread_mutex_lock(&grep_attr_mutex); -} - -static inline void grep_attr_unlock(void) -{ - if (grep_use_locks) - pthread_mutex_unlock(&grep_attr_mutex); -} - -/* - * Same as git_attr_mutex, but protecting the thread-unsafe object db access. - */ -pthread_mutex_t grep_read_mutex; - -static int match_funcname(struct grep_opt *opt, struct grep_source *gs, char *bol, char *eol) -{ - xdemitconf_t *xecfg = opt->priv; - if (xecfg && !xecfg->find_func) { - grep_source_load_driver(gs, opt->repo->index); - if (gs->driver->funcname.pattern) { - const struct userdiff_funcname *pe = &gs->driver->funcname; - xdiff_set_find_func(xecfg, pe->pattern, pe->cflags); - } else { - xecfg = opt->priv = NULL; - } - } - - if (xecfg) { - char buf[1]; - return xecfg->find_func(bol, eol - bol, buf, 1, - xecfg->find_func_priv) >= 0; - } - - if (bol == eol) - return 0; - if (isalpha(*bol) || *bol == '_' || *bol == '$') - return 1; - return 0; -} - -static void show_funcname_line(struct grep_opt *opt, struct grep_source *gs, - char *bol, unsigned lno) -{ - while (bol > gs->buf) { - char *eol = --bol; - - while (bol > gs->buf && bol[-1] != '\n') - bol--; - lno--; - - if (lno <= opt->last_shown) - break; - - if (match_funcname(opt, gs, bol, eol)) { - show_line(opt, bol, eol, gs->name, lno, 0, '='); - break; - } - } -} - -static int is_empty_line(const char *bol, const char *eol); - -static void show_pre_context(struct grep_opt *opt, struct grep_source *gs, - char *bol, char *end, unsigned lno) -{ - unsigned cur = lno, from = 1, funcname_lno = 0, orig_from; - int funcname_needed = !!opt->funcname, comment_needed = 0; - - if (opt->pre_context < lno) - from = lno - opt->pre_context; - if (from <= opt->last_shown) - from = opt->last_shown + 1; - orig_from = from; - if (opt->funcbody) { - if (match_funcname(opt, gs, bol, end)) - comment_needed = 1; - else - funcname_needed = 1; - from = opt->last_shown + 1; - } - - /* Rewind. */ - while (bol > gs->buf && cur > from) { - char *next_bol = bol; - char *eol = --bol; - - while (bol > gs->buf && bol[-1] != '\n') - bol--; - cur--; - if (comment_needed && (is_empty_line(bol, eol) || - match_funcname(opt, gs, bol, eol))) { - comment_needed = 0; - from = orig_from; - if (cur < from) { - cur++; - bol = next_bol; - break; - } - } - if (funcname_needed && match_funcname(opt, gs, bol, eol)) { - funcname_lno = cur; - funcname_needed = 0; - if (opt->funcbody) - comment_needed = 1; - else - from = orig_from; - } - } - - /* We need to look even further back to find a function signature. */ - if (opt->funcname && funcname_needed) - show_funcname_line(opt, gs, bol, cur); - - /* Back forward. */ - while (cur < lno) { - char *eol = bol, sign = (cur == funcname_lno) ? '=' : '-'; - - while (*eol != '\n') - eol++; - show_line(opt, bol, eol, gs->name, cur, 0, sign); - bol = eol + 1; - cur++; - } -} - -static int should_lookahead(struct grep_opt *opt) -{ - struct grep_pat *p; - - if (opt->extended) - return 0; /* punt for too complex stuff */ - if (opt->invert) - return 0; - for (p = opt->pattern_list; p; p = p->next) { - if (p->token != GREP_PATTERN) - return 0; /* punt for "header only" and stuff */ - } - return 1; -} - -static int look_ahead(struct grep_opt *opt, - unsigned long *left_p, - unsigned *lno_p, - char **bol_p) -{ - unsigned lno = *lno_p; - char *bol = *bol_p; - struct grep_pat *p; - char *sp, *last_bol; - regoff_t earliest = -1; - - for (p = opt->pattern_list; p; p = p->next) { - int hit; - regmatch_t m; - - hit = patmatch(p, bol, bol + *left_p, &m, 0); - if (!hit || m.rm_so < 0 || m.rm_eo < 0) - continue; - if (earliest < 0 || m.rm_so < earliest) - earliest = m.rm_so; - } - - if (earliest < 0) { - *bol_p = bol + *left_p; - *left_p = 0; - return 1; - } - for (sp = bol + earliest; bol < sp && sp[-1] != '\n'; sp--) - ; /* find the beginning of the line */ - last_bol = sp; - - for (sp = bol; sp < last_bol; sp++) { - if (*sp == '\n') - lno++; - } - *left_p -= last_bol - bol; - *bol_p = last_bol; - *lno_p = lno; - return 0; -} - -static int fill_textconv_grep(struct repository *r, - struct userdiff_driver *driver, - struct grep_source *gs) -{ - struct diff_filespec *df; - char *buf; - size_t size; - - if (!driver || !driver->textconv) - return grep_source_load(gs); - - /* - * The textconv interface is intimately tied to diff_filespecs, so we - * have to pretend to be one. If we could unify the grep_source - * and diff_filespec structs, this mess could just go away. - */ - df = alloc_filespec(gs->path); - switch (gs->type) { - case GREP_SOURCE_OID: - fill_filespec(df, gs->identifier, 1, 0100644); - break; - case GREP_SOURCE_FILE: - fill_filespec(df, &null_oid, 0, 0100644); - break; - default: - BUG("attempt to textconv something without a path?"); - } - - /* - * fill_textconv is not remotely thread-safe; it may load objects - * behind the scenes, and it modifies the global diff tempfile - * structure. - */ - grep_read_lock(); - size = fill_textconv(r, driver, df, &buf); - grep_read_unlock(); - free_filespec(df); - - /* - * The normal fill_textconv usage by the diff machinery would just keep - * the textconv'd buf separate from the diff_filespec. But much of the - * grep code passes around a grep_source and assumes that its "buf" - * pointer is the beginning of the thing we are searching. So let's - * install our textconv'd version into the grep_source, taking care not - * to leak any existing buffer. - */ - grep_source_clear_data(gs); - gs->buf = buf; - gs->size = size; - - return 0; -} - -static int is_empty_line(const char *bol, const char *eol) -{ - while (bol < eol && isspace(*bol)) - bol++; - return bol == eol; -} - -static int grep_source_1(struct grep_opt *opt, struct grep_source *gs, int collect_hits) -{ - char *bol; - char *peek_bol = NULL; - unsigned long left; - unsigned lno = 1; - unsigned last_hit = 0; - int binary_match_only = 0; - unsigned count = 0; - int try_lookahead = 0; - int show_function = 0; - struct userdiff_driver *textconv = NULL; - enum grep_context ctx = GREP_CONTEXT_HEAD; - xdemitconf_t xecfg; - - if (!opt->status_only && gs->name == NULL) - BUG("grep call which could print a name requires " - "grep_source.name be non-NULL"); - - if (!opt->output) - opt->output = std_output; - - if (opt->pre_context || opt->post_context || opt->file_break || - opt->funcbody) { - /* Show hunk marks, except for the first file. */ - if (opt->last_shown) - opt->show_hunk_mark = 1; - /* - * If we're using threads then we can't easily identify - * the first file. Always put hunk marks in that case - * and skip the very first one later in work_done(). - */ - if (opt->output != std_output) - opt->show_hunk_mark = 1; - } - opt->last_shown = 0; - - if (opt->allow_textconv) { - grep_source_load_driver(gs, opt->repo->index); - /* - * We might set up the shared textconv cache data here, which - * is not thread-safe. - */ - grep_attr_lock(); - textconv = userdiff_get_textconv(opt->repo, gs->driver); - grep_attr_unlock(); - } - - /* - * We know the result of a textconv is text, so we only have to care - * about binary handling if we are not using it. - */ - if (!textconv) { - switch (opt->binary) { - case GREP_BINARY_DEFAULT: - if (grep_source_is_binary(gs, opt->repo->index)) - binary_match_only = 1; - break; - case GREP_BINARY_NOMATCH: - if (grep_source_is_binary(gs, opt->repo->index)) - return 0; /* Assume unmatch */ - break; - case GREP_BINARY_TEXT: - break; - default: - BUG("unknown binary handling mode"); - } - } - - memset(&xecfg, 0, sizeof(xecfg)); - opt->priv = &xecfg; - - try_lookahead = should_lookahead(opt); - - if (fill_textconv_grep(opt->repo, textconv, gs) < 0) - return 0; - - bol = gs->buf; - left = gs->size; - while (left) { - char *eol, ch; - int hit; - ssize_t cno; - ssize_t col = -1, icol = -1; - - /* - * look_ahead() skips quickly to the line that possibly - * has the next hit; don't call it if we need to do - * something more than just skipping the current line - * in response to an unmatch for the current line. E.g. - * inside a post-context window, we will show the current - * line as a context around the previous hit when it - * doesn't hit. - */ - if (try_lookahead - && !(last_hit - && (show_function || - lno <= last_hit + opt->post_context)) - && look_ahead(opt, &left, &lno, &bol)) - break; - eol = end_of_line(bol, &left); - ch = *eol; - *eol = 0; - - if ((ctx == GREP_CONTEXT_HEAD) && (eol == bol)) - ctx = GREP_CONTEXT_BODY; - - hit = match_line(opt, bol, eol, &col, &icol, ctx, collect_hits); - *eol = ch; - - if (collect_hits) - goto next_line; - - /* "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 (opt->status_only) - return 1; - if (opt->name_only) { - show_name(opt, gs->name); - return 1; - } - if (opt->count) - goto next_line; - if (binary_match_only) { - opt->output(opt, "Binary file ", 12); - output_color(opt, gs->name, strlen(gs->name), - opt->colors[GREP_COLOR_FILENAME]); - opt->output(opt, " matches\n", 9); - return 1; - } - /* Hit at this line. If we haven't shown the - * pre-context lines, we would need to show them. - */ - if (opt->pre_context || opt->funcbody) - show_pre_context(opt, gs, bol, eol, lno); - else if (opt->funcname) - show_funcname_line(opt, gs, bol, lno); - cno = opt->invert ? icol : col; - if (cno < 0) { - /* - * A negative cno indicates that there was no - * match on the line. We are thus inverted and - * being asked to show all lines that _don't_ - * match a given expression. Therefore, set cno - * to 0 to suggest the whole line matches. - */ - cno = 0; - } - show_line(opt, bol, eol, gs->name, lno, cno + 1, ':'); - last_hit = lno; - if (opt->funcbody) - show_function = 1; - goto next_line; - } - if (show_function && (!peek_bol || peek_bol < bol)) { - unsigned long peek_left = left; - char *peek_eol = eol; - - /* - * Trailing empty lines are not interesting. - * Peek past them to see if they belong to the - * body of the current function. - */ - peek_bol = bol; - while (is_empty_line(peek_bol, peek_eol)) { - peek_bol = peek_eol + 1; - peek_eol = end_of_line(peek_bol, &peek_left); - } - - if (match_funcname(opt, gs, peek_bol, peek_eol)) - show_function = 0; - } - if (show_function || - (last_hit && lno <= last_hit + opt->post_context)) { - /* If the last hit is within the post context, - * we need to show this line. - */ - show_line(opt, bol, eol, gs->name, lno, col + 1, '-'); - } - - next_line: - bol = eol + 1; - if (!left) - break; - left--; - lno++; - } - - if (collect_hits) - return 0; - - if (opt->status_only) - return opt->unmatch_name_only; - if (opt->unmatch_name_only) { - /* We did not see any hit, so we want to show this */ - show_name(opt, gs->name); - return 1; - } - - xdiff_clear_find_func(&xecfg); - opt->priv = NULL; - - /* 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) { - char buf[32]; - if (opt->pathname) { - output_color(opt, gs->name, strlen(gs->name), - opt->colors[GREP_COLOR_FILENAME]); - output_sep(opt, ':'); - } - xsnprintf(buf, sizeof(buf), "%u\n", count); - opt->output(opt, buf, strlen(buf)); - return 1; - } - return !!last_hit; -} - -static void clr_hit_marker(struct grep_expr *x) -{ - /* All-hit markers are meaningful only at the very top level - * OR node. - */ - while (1) { - x->hit = 0; - if (x->node != GREP_NODE_OR) - return; - x->u.binary.left->hit = 0; - x = x->u.binary.right; - } -} - -static int chk_hit_marker(struct grep_expr *x) -{ - /* Top level nodes have hit markers. See if they all are hits */ - while (1) { - if (x->node != GREP_NODE_OR) - return x->hit; - if (!x->u.binary.left->hit) - return 0; - x = x->u.binary.right; - } -} - -int grep_source(struct grep_opt *opt, struct grep_source *gs) -{ - /* - * we do not have to do the two-pass grep when we do not check - * buffer-wide "all-match". - */ - if (!opt->all_match) - return grep_source_1(opt, gs, 0); - - /* Otherwise the toplevel "or" terms hit a bit differently. - * We first clear hit markers from them. - */ - clr_hit_marker(opt->pattern_expression); - grep_source_1(opt, gs, 1); - - if (!chk_hit_marker(opt->pattern_expression)) - return 0; - - return grep_source_1(opt, gs, 0); -} - -int grep_buffer(struct grep_opt *opt, char *buf, unsigned long size) -{ - struct grep_source gs; - int r; - - grep_source_init(&gs, GREP_SOURCE_BUF, NULL, NULL, NULL); - gs.buf = buf; - gs.size = size; - - r = grep_source(opt, &gs); - - grep_source_clear(&gs); - return r; -} - -void grep_source_init(struct grep_source *gs, enum grep_source_type type, - const char *name, const char *path, - const void *identifier) -{ - gs->type = type; - gs->name = xstrdup_or_null(name); - gs->path = xstrdup_or_null(path); - gs->buf = NULL; - gs->size = 0; - gs->driver = NULL; - - switch (type) { - case GREP_SOURCE_FILE: - gs->identifier = xstrdup(identifier); - break; - case GREP_SOURCE_OID: - gs->identifier = oiddup(identifier); - break; - case GREP_SOURCE_BUF: - gs->identifier = NULL; - break; - } -} - -void grep_source_clear(struct grep_source *gs) -{ - FREE_AND_NULL(gs->name); - FREE_AND_NULL(gs->path); - FREE_AND_NULL(gs->identifier); - grep_source_clear_data(gs); -} - -void grep_source_clear_data(struct grep_source *gs) -{ - switch (gs->type) { - case GREP_SOURCE_FILE: - case GREP_SOURCE_OID: - FREE_AND_NULL(gs->buf); - gs->size = 0; - break; - case GREP_SOURCE_BUF: - /* leave user-provided buf intact */ - break; - } -} - -static int grep_source_load_oid(struct grep_source *gs) -{ - enum object_type type; - - grep_read_lock(); - gs->buf = read_object_file(gs->identifier, &type, &gs->size); - grep_read_unlock(); - - if (!gs->buf) - return error(_("'%s': unable to read %s"), - gs->name, - oid_to_hex(gs->identifier)); - return 0; -} - -static int grep_source_load_file(struct grep_source *gs) -{ - const char *filename = gs->identifier; - struct stat st; - char *data; - size_t size; - int i; - - if (lstat(filename, &st) < 0) { - err_ret: - if (errno != ENOENT) - error_errno(_("failed to stat '%s'"), filename); - return -1; - } - if (!S_ISREG(st.st_mode)) - return -1; - size = xsize_t(st.st_size); - i = open(filename, O_RDONLY); - if (i < 0) - goto err_ret; - data = xmallocz(size); - if (st.st_size != read_in_full(i, data, size)) { - error_errno(_("'%s': short read"), filename); - close(i); - free(data); - return -1; - } - close(i); - - gs->buf = data; - gs->size = size; - return 0; -} - -static int grep_source_load(struct grep_source *gs) -{ - if (gs->buf) - return 0; - - switch (gs->type) { - case GREP_SOURCE_FILE: - return grep_source_load_file(gs); - case GREP_SOURCE_OID: - return grep_source_load_oid(gs); - case GREP_SOURCE_BUF: - return gs->buf ? 0 : -1; - } - BUG("invalid grep_source type to load"); -} - -void grep_source_load_driver(struct grep_source *gs, - struct index_state *istate) -{ - if (gs->driver) - return; - - grep_attr_lock(); - if (gs->path) - gs->driver = userdiff_find_by_path(istate, gs->path); - if (!gs->driver) - gs->driver = userdiff_find_by_name("default"); - grep_attr_unlock(); -} - -static int grep_source_is_binary(struct grep_source *gs, - struct index_state *istate) -{ - grep_source_load_driver(gs, istate); - if (gs->driver->binary != -1) - return gs->driver->binary; - - if (!grep_source_load(gs)) - return buffer_is_binary(gs->buf, gs->size); - - return 0; -} |