+#include "diff.h"
+#include "diffcore.h"
+#include "commit.h"
+#include "quote.h"
+
+static int grep_source_load(struct grep_source *gs);
+static int grep_source_is_binary(struct grep_source *gs);
+
+static struct grep_opt grep_defaults;
+
+static void std_output(struct grep_opt *opt, const void *buf, size_t size)
+{
+ fwrite(buf, size, 1, stdout);
+}
+
+/*
+ * 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(void)
+{
+ struct grep_opt *opt = &grep_defaults;
+ static int run_once;
+
+ if (run_once)
+ return;
+ run_once++;
+
+ memset(opt, 0, sizeof(*opt));
+ opt->relative = 1;
+ opt->pathname = 1;
+ opt->max_depth = -1;
+ opt->pattern_type_option = GREP_PATTERN_TYPE_UNSPECIFIED;
+ color_set(opt->color_context, "");
+ color_set(opt->color_filename, "");
+ color_set(opt->color_function, "");
+ color_set(opt->color_lineno, "");
+ color_set(opt->color_match_context, GIT_COLOR_BOLD_RED);
+ color_set(opt->color_match_selected, GIT_COLOR_BOLD_RED);
+ color_set(opt->color_selected, "");
+ color_set(opt->color_sep, GIT_COLOR_CYAN);
+ 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);
+}
+
+/*
+ * 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;
+ char *color = NULL;
+
+ 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.fullname")) {
+ opt->relative = !git_config_bool(var, value);
+ return 0;
+ }
+
+ if (!strcmp(var, "color.grep"))
+ opt->color = git_config_colorbool(var, value);
+ else if (!strcmp(var, "color.grep.context"))
+ color = opt->color_context;
+ else if (!strcmp(var, "color.grep.filename"))
+ color = opt->color_filename;
+ else if (!strcmp(var, "color.grep.function"))
+ color = opt->color_function;
+ else if (!strcmp(var, "color.grep.linenumber"))
+ color = opt->color_lineno;
+ else if (!strcmp(var, "color.grep.matchcontext"))
+ color = opt->color_match_context;
+ else if (!strcmp(var, "color.grep.matchselected"))
+ color = opt->color_match_selected;
+ else if (!strcmp(var, "color.grep.selected"))
+ color = opt->color_selected;
+ else if (!strcmp(var, "color.grep.separator"))
+ color = opt->color_sep;
+ else if (!strcmp(var, "color.grep.match")) {
+ int rc = 0;
+ if (!value)
+ return config_error_nonbool(var);
+ rc |= color_parse(value, opt->color_match_context);
+ rc |= color_parse(value, opt->color_match_selected);
+ return rc;
+ }
+
+ if (color) {
+ 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, const char *prefix)
+{
+ struct grep_opt *def = &grep_defaults;
+
+ memset(opt, 0, sizeof(*opt));
+ opt->prefix = prefix;
+ opt->prefix_length = (prefix && *prefix) ? strlen(prefix) : 0;
+ opt->pattern_tail = &opt->pattern_list;
+ opt->header_tail = &opt->header_list;
+
+ 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->max_depth = def->max_depth;
+ opt->pathname = def->pathname;
+ opt->relative = def->relative;
+ opt->output = def->output;
+
+ color_set(opt->color_context, def->color_context);
+ color_set(opt->color_filename, def->color_filename);
+ color_set(opt->color_function, def->color_function);
+ color_set(opt->color_lineno, def->color_lineno);
+ color_set(opt->color_match_context, def->color_match_context);
+ color_set(opt->color_match_selected, def->color_match_selected);
+ color_set(opt->color_selected, def->color_selected);
+ color_set(opt->color_sep, def->color_sep);
+}
+
+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);
+}