+#include "hash.h"

+ /*

+ * We could to redo the "apply.c" machinery to make this

+ * arbitrary fallback unnecessary, but it is dubious that it

+ * is worth the effort.

+ * cf. https://lore.kernel.org/git/xmqqcypfcmn4.fsf@gitster.g/

+ */

+ if (!the_hash_algo)

+ repo_set_hash_algo(the_repository, GIT_HASH_SHA1);

+

+ char *str;

+ if (0 < abbrev && abbrev < (int)the_hash_algo->hexsz)

+ abbrev = the_hash_algo->hexsz;

+ if (!startup_info->have_repository) {

+ ret = error(_("need a repository to verify a bundle"));

+ goto cleanup;

+ }

+

+static char *parse_remote_branch(const char *arg,

+ struct object_id *rev,

+ int could_be_checkout_paths)

+ char *remote = unique_tracking_name(arg, rev, &num_matches);

+ char *remote = NULL;

+ remote = parse_remote_branch(arg, rev,

+ could_be_checkout_paths);

+ free(remote);

+ init_db(git_dir, real_git_dir, option_template, GIT_HASH_UNKNOWN,

+ UNLEAK(repo);

+static char *template_file;

+static char *cleanup_arg;

+#define CONFIG_LOCATION_OPTIONS(opts) \

+ OPT_GROUP(N_("Config file location")), \

+ OPT_BOOL(0, "global", &opts.use_global_config, N_("use global config file")), \

+ OPT_BOOL(0, "system", &opts.use_system_config, N_("use system config file")), \

+ OPT_BOOL(0, "local", &opts.use_local_config, N_("use repository config file")), \

+ OPT_BOOL(0, "worktree", &opts.use_worktree_config, N_("use per-worktree config file")), \

+ OPT_STRING('f', "file", &opts.source.file, N_("file"), N_("use given config file")), \

+ OPT_STRING(0, "blob", &opts.source.blob, N_("blob-id"), N_("read config from given blob object"))

+

+struct config_location_options {

+ struct git_config_source source;

+ struct config_options options;

+ char *file_to_free;

+ int use_global_config;

+ int use_system_config;

+ int use_local_config;

+ int use_worktree_config;

+ int respect_includes_opt;

+};

+#define CONFIG_LOCATION_OPTIONS_INIT { \

+ .respect_includes_opt = -1, \

+}

+

+#define CONFIG_TYPE_OPTIONS(type) \

+ OPT_GROUP(N_("Type")), \

+ OPT_CALLBACK('t', "type", &type, N_("type"), N_("value is given this type"), option_parse_type), \

+ OPT_CALLBACK_VALUE(0, "bool", &type, N_("value is \"true\" or \"false\""), TYPE_BOOL), \

+ OPT_CALLBACK_VALUE(0, "int", &type, N_("value is decimal number"), TYPE_INT), \

+ OPT_CALLBACK_VALUE(0, "bool-or-int", &type, N_("value is --bool or --int"), TYPE_BOOL_OR_INT), \

+ OPT_CALLBACK_VALUE(0, "bool-or-str", &type, N_("value is --bool or string"), TYPE_BOOL_OR_STR), \

+ OPT_CALLBACK_VALUE(0, "path", &type, N_("value is a path (file or directory name)"), TYPE_PATH), \

+ OPT_CALLBACK_VALUE(0, "expiry-date", &type, N_("value is an expiry date"), TYPE_EXPIRY_DATE)

+

+#define CONFIG_DISPLAY_OPTIONS(opts) \

+ OPT_GROUP(N_("Display options")), \

+ OPT_BOOL('z', "null", &opts.end_nul, N_("terminate values with NUL byte")), \

+ OPT_BOOL(0, "name-only", &opts.omit_values, N_("show variable names only")), \

+ OPT_BOOL(0, "show-origin", &opts.show_origin, N_("show origin of config (file, standard input, blob, command line)")), \

+ OPT_BOOL(0, "show-scope", &opts.show_scope, N_("show scope of config (worktree, local, global, system, command)")), \

+ OPT_BOOL(0, "show-names", &opts.show_keys, N_("show config keys in addition to their values")), \

+ CONFIG_TYPE_OPTIONS(opts.type)

+

+struct config_display_options {

+ int end_nul;

+ int omit_values;

+ int show_origin;

+ int show_scope;

+ int show_keys;

+ int type;

+ char *default_value;

+ /* Populated via `display_options_init()`. */

+ int term;

+ int delim;

+ int key_delim;

+};

+#define CONFIG_DISPLAY_OPTIONS_INIT { \

+ .term = '\n', \

+ .delim = '=', \

+ .key_delim = ' ', \

+}

+ exit(129);

+ exit(129);

+static void show_config_origin(const struct config_display_options *opts,

+ const struct key_value_info *kvi,

+ const char term = opts->end_nul ? '\0' : '\t';

+ if (opts->end_nul)

+static void show_config_scope(const struct config_display_options *opts,

+ const struct key_value_info *kvi,

+ const char term = opts->end_nul ? '\0' : '\t';

+ void *cb)

+ const struct config_display_options *opts = cb;

+ if (opts->show_origin || opts->show_scope) {

+ if (opts->show_scope)

+ show_config_scope(opts, kvi, &buf);

+ if (opts->show_origin)

+ show_config_origin(opts, kvi, &buf);

+ if (!opts->omit_values && value_)

+ printf("%s%c%s%c", key_, opts->delim, value_, opts->term);

+ printf("%s%c", key_, opts->term);

+static int format_config(const struct config_display_options *opts,

+ struct strbuf *buf, const char *key_,

+ if (opts->show_scope)

+ show_config_scope(opts, kvi, buf);

+ if (opts->show_origin)

+ show_config_origin(opts, kvi, buf);

+ if (opts->show_keys)

+ if (!opts->omit_values) {

+ if (opts->show_keys)

+ strbuf_addch(buf, opts->key_delim);

+ if (opts->type == TYPE_INT)

+ else if (opts->type == TYPE_BOOL)

+ else if (opts->type == TYPE_BOOL_OR_INT) {

+ } else if (opts->type == TYPE_BOOL_OR_STR) {

+ } else if (opts->type == TYPE_PATH) {

+ char *v;

+ } else if (opts->type == TYPE_EXPIRY_DATE) {

+ } else if (opts->type == TYPE_COLOR) {

+ if (opts->show_keys)

+ strbuf_addch(buf, opts->term);

+#define GET_VALUE_ALL (1 << 0)

+#define GET_VALUE_KEY_REGEXP (1 << 1)

+

+struct collect_config_data {

+ const struct config_display_options *display_opts;

+ struct strbuf_list *values;

+ const char *value_pattern;

+ const char *key;

+ regex_t *regexp;

+ regex_t *key_regexp;

+ int do_not_match;

+ unsigned get_value_flags;

+ unsigned flags;

+};

+

+ struct collect_config_data *data = cb;

+ struct strbuf_list *values = data->values;

+ if (!(data->get_value_flags & GET_VALUE_KEY_REGEXP) &&

+ strcmp(key_, data->key))

+ if ((data->get_value_flags & GET_VALUE_KEY_REGEXP) &&

+ regexec(data->key_regexp, key_, 0, NULL, 0))

+ if ((data->flags & CONFIG_FLAGS_FIXED_VALUE) &&

+ strcmp(data->value_pattern, (value_?value_:"")))

+ if (data->regexp &&

+ (data->do_not_match ^ !!regexec(data->regexp, (value_?value_:""), 0, NULL, 0)))

+ return format_config(data->display_opts, &values->items[values->nr++],

+ key_, value_, kvi);

+static int get_value(const struct config_location_options *opts,

+ const struct config_display_options *display_opts,

+ const char *key_, const char *regex_,

+ unsigned get_value_flags, unsigned flags)

+ struct collect_config_data data = {

+ .display_opts = display_opts,

+ .values = &values,

+ .get_value_flags = get_value_flags,

+ .flags = flags,

+ };

+ char *key = NULL;

+ if (get_value_flags & GET_VALUE_KEY_REGEXP) {

+ data.key_regexp = (regex_t*)xmalloc(sizeof(regex_t));

+ if (regcomp(data.key_regexp, key, REG_EXTENDED)) {

+ FREE_AND_NULL(data.key_regexp);

+

+ data.key = key;

+ data.value_pattern = regex_;

+ data.do_not_match = 1;

+ data.regexp = (regex_t*)xmalloc(sizeof(regex_t));

+ if (regcomp(data.regexp, regex_, REG_EXTENDED)) {

+ FREE_AND_NULL(data.regexp);

+ config_with_options(collect_config, &data,

+ &opts->source, the_repository,

+ &opts->options);

+ if (!values.nr && display_opts->default_value) {

+ if (format_config(display_opts, item, key_,

+ display_opts->default_value, &kvi) < 0)

+ display_opts->default_value);

+ if ((get_value_flags & GET_VALUE_ALL) || i == values.nr - 1)

+ if (data.key_regexp) {

+ regfree(data.key_regexp);

+ free(data.key_regexp);

+ if (data.regexp) {

+ regfree(data.regexp);

+ free(data.regexp);

+ int type, struct key_value_info *kvi)

+struct get_color_config_data {

+ int get_color_found;

+ const char *get_color_slot;

+ char parsed_color[COLOR_MAXLEN];

+};

+ void *cb)

+ struct get_color_config_data *data = cb;

+

+ if (!strcmp(var, data->get_color_slot)) {

+ if (color_parse(value, data->parsed_color) < 0)

+ data->get_color_found = 1;

+static void get_color(const struct config_location_options *opts,

+ const char *var, const char *def_color)

+ struct get_color_config_data data = {

+ .get_color_slot = var,

+ .parsed_color[0] = '\0',

+ };

+

+ config_with_options(git_get_color_config, &data,

+ &opts->source, the_repository,

+ &opts->options);

+

+ if (!data.get_color_found && def_color) {

+ if (color_parse(def_color, data.parsed_color) < 0)

+ fputs(data.parsed_color, stdout);

+struct get_colorbool_config_data {

+ int get_colorbool_found;

+ int get_diff_color_found;

+ int get_color_ui_found;

+ const char *get_colorbool_slot;

+};

+

+ void *cb)

+ struct get_colorbool_config_data *data = cb;

+

+ if (!strcmp(var, data->get_colorbool_slot))

+ data->get_colorbool_found = git_config_colorbool(var, value);

+ data->get_diff_color_found = git_config_colorbool(var, value);

+ data->get_color_ui_found = git_config_colorbool(var, value);

+static int get_colorbool(const struct config_location_options *opts,

+ const char *var, int print)

+ struct get_colorbool_config_data data = {

+ .get_colorbool_slot = var,

+ .get_colorbool_found = -1,

+ .get_diff_color_found = -1,

+ .get_color_ui_found = -1,

+ };

+

+ config_with_options(git_get_colorbool_config, &data,

+ &opts->source, the_repository,

+ &opts->options);

+

+ if (data.get_colorbool_found < 0) {

+ if (!strcmp(data.get_colorbool_slot, "color.diff"))

+ data.get_colorbool_found = data.get_diff_color_found;

+ if (data.get_colorbool_found < 0)

+ data.get_colorbool_found = data.get_color_ui_found;

+ if (data.get_colorbool_found < 0)

+ data.get_colorbool_found = GIT_COLOR_AUTO;

+ data.get_colorbool_found = want_color(data.get_colorbool_found);

+ printf("%s\n", data.get_colorbool_found ? "true" : "false");

+ return data.get_colorbool_found ? 0 : 1;

+static void check_write(const struct git_config_source *source)

+ if (!source->file && !startup_info->have_repository)

+ if (source->use_stdin)

+ if (source->blob)

+static int get_urlmatch(const struct config_location_options *opts,

+ const struct config_display_options *_display_opts,

+ const char *var, const char *url)

+ struct config_display_options display_opts = *_display_opts;

+ display_opts.show_keys = 0;

+ display_opts.show_keys = 1;

+ &opts->source, the_repository,

+ &opts->options);

+ format_config(&display_opts, &buf, item->string,

+static void location_options_init(struct config_location_options *opts,

+ const char *prefix)

+ if (!opts->source.file)

+ opts->source.file = opts->file_to_free =

+ xstrdup_or_null(getenv(CONFIG_ENVIRONMENT));

+

+ if (opts->use_global_config + opts->use_system_config +

+ opts->use_local_config + opts->use_worktree_config +

+ !!opts->source.file + !!opts->source.blob > 1) {

+ exit(129);

+ if (opts->use_local_config)

+ if (opts->source.blob)

+ if (opts->use_worktree_config)

+ if (opts->source.file &&

+ !strcmp(opts->source.file, "-")) {

+ opts->source.file = NULL;

+ opts->source.use_stdin = 1;

+ opts->source.scope = CONFIG_SCOPE_COMMAND;

+ if (opts->use_global_config) {

+ opts->source.file = opts->file_to_free = git_global_config();

+ if (!opts->source.file)

+ opts->source.scope = CONFIG_SCOPE_GLOBAL;

+ } else if (opts->use_system_config) {

+ opts->source.file = opts->file_to_free = git_system_config();

+ opts->source.scope = CONFIG_SCOPE_SYSTEM;

+ } else if (opts->use_local_config) {

+ opts->source.file = opts->file_to_free = git_pathdup("config");

+ opts->source.scope = CONFIG_SCOPE_LOCAL;

+ } else if (opts->use_worktree_config) {

+ opts->source.file = opts->file_to_free =

+ git_pathdup("config.worktree");

+ opts->source.file = opts->file_to_free =

+ git_pathdup("config");

+ opts->source.scope = CONFIG_SCOPE_LOCAL;

+ } else if (opts->source.file) {

+ if (!is_absolute_path(opts->source.file) && prefix)

+ opts->source.file = opts->file_to_free =

+ prefix_filename(prefix, opts->source.file);

+ opts->source.scope = CONFIG_SCOPE_COMMAND;

+ } else if (opts->source.blob) {

+ opts->source.scope = CONFIG_SCOPE_COMMAND;

+ if (opts->respect_includes_opt == -1)

+ opts->options.respect_includes = !opts->source.file;

+ opts->options.respect_includes = opts->respect_includes_opt;

+ opts->options.commondir = get_git_common_dir();

+ opts->options.git_dir = get_git_dir();

+static void location_options_release(struct config_location_options *opts)

+{

+ free(opts->file_to_free);

+static void display_options_init(struct config_display_options *opts)

+ if (opts->end_nul) {

+ opts->term = '\0';

+ opts->delim = '\n';

+ opts->key_delim = '\n';

+ }

+ struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

+ struct config_display_options display_opts = CONFIG_DISPLAY_OPTIONS_INIT;

+ CONFIG_LOCATION_OPTIONS(location_opts),

+ CONFIG_DISPLAY_OPTIONS(display_opts),

+ OPT_BOOL(0, "includes", &location_opts.respect_includes_opt,

+ N_("respect include directives on lookup")),

+ location_options_init(&location_opts, prefix);

+ display_options_init(&display_opts);

+ if (config_with_options(show_all_config, &display_opts,

+ &location_opts.source, the_repository,

+ &location_opts.options) < 0) {

+ if (location_opts.source.file)

+ location_opts.source.file);

+ location_options_release(&location_opts);

+ struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

+ struct config_display_options display_opts = CONFIG_DISPLAY_OPTIONS_INIT;

+ unsigned get_value_flags = 0;

+ CONFIG_LOCATION_OPTIONS(location_opts),

+ OPT_BIT(0, "all", &get_value_flags, N_("return all values for multi-valued config options"), GET_VALUE_ALL),

+ OPT_BIT(0, "regexp", &get_value_flags, N_("interpret the name as a regular expression"), GET_VALUE_KEY_REGEXP),

+ CONFIG_DISPLAY_OPTIONS(display_opts),

+ OPT_BOOL(0, "includes", &location_opts.respect_includes_opt,

+ N_("respect include directives on lookup")),

+ OPT_STRING(0, "default", &display_opts.default_value,

+ N_("value"), N_("use default value when missing entry")),

+ int ret;

+ if (display_opts.default_value &&

+ ((get_value_flags & GET_VALUE_ALL) || url))

+ if (url && ((get_value_flags & GET_VALUE_ALL) ||

+ (get_value_flags & GET_VALUE_KEY_REGEXP) ||

+ value_pattern))

+ location_options_init(&location_opts, prefix);

+ display_options_init(&display_opts);

+ ret = get_urlmatch(&location_opts, &display_opts, argv[0], url);

+ else

+ ret = get_value(&location_opts, &display_opts, argv[0], value_pattern,

+ get_value_flags, flags);

+

+ location_options_release(&location_opts);

+ return ret;

+ struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

+ int flags = 0, append = 0, type = 0;

+ CONFIG_LOCATION_OPTIONS(location_opts),

+ CONFIG_TYPE_OPTIONS(type),

+ location_options_init(&location_opts, prefix);

+ check_write(&location_opts.source);

+ value = normalize_value(argv[0], argv[1], type, &default_kvi);

+ ret = git_config_set_multivar_in_file_gently(location_opts.source.file,

+ ret = git_config_set_in_file_gently(location_opts.source.file,

+ location_options_release(&location_opts);

+ struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

+ CONFIG_LOCATION_OPTIONS(location_opts),

+ int ret;

+ location_options_init(&location_opts, prefix);

+ check_write(&location_opts.source);

+ ret = git_config_set_multivar_in_file_gently(location_opts.source.file,

+ argv[0], NULL, value_pattern,

+ NULL, flags);

+ ret = git_config_set_in_file_gently(location_opts.source.file, argv[0],

+ NULL, NULL);

+

+ location_options_release(&location_opts);

+ return ret;

+ struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

+ CONFIG_LOCATION_OPTIONS(location_opts),

+ location_options_init(&location_opts, prefix);

+ check_write(&location_opts.source);

+ ret = git_config_rename_section_in_file(location_opts.source.file,

+ goto out;

+ ret = 0;

+out:

+ location_options_release(&location_opts);

+ return ret;

+ struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

+ CONFIG_LOCATION_OPTIONS(location_opts),

+ location_options_init(&location_opts, prefix);

+ check_write(&location_opts.source);

+ ret = git_config_rename_section_in_file(location_opts.source.file,

+ goto out;

+ ret = 0;

+out:

+ location_options_release(&location_opts);

+ return ret;

+static int show_editor(struct config_location_options *opts)

+ if (!opts->source.file && !startup_info->have_repository)

+ if (opts->source.use_stdin)

+ if (opts->source.blob)

+ config_file = opts->source.file ?

+ xstrdup(opts->source.file) :

+ if (opts->use_global_config) {

+ struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

+ CONFIG_LOCATION_OPTIONS(location_opts),

+ int ret;

+ location_options_init(&location_opts, prefix);

+ check_write(&location_opts.source);

+ ret = show_editor(&location_opts);

+ location_options_release(&location_opts);

+ return ret;

+static int cmd_config_actions(int argc, const char **argv, const char *prefix)

+ enum {

+ ACTION_GET = (1<<0),

+ ACTION_GET_ALL = (1<<1),

+ ACTION_GET_REGEXP = (1<<2),

+ ACTION_REPLACE_ALL = (1<<3),

+ ACTION_ADD = (1<<4),

+ ACTION_UNSET = (1<<5),

+ ACTION_UNSET_ALL = (1<<6),

+ ACTION_RENAME_SECTION = (1<<7),

+ ACTION_REMOVE_SECTION = (1<<8),

+ ACTION_LIST = (1<<9),

+ ACTION_EDIT = (1<<10),

+ ACTION_SET = (1<<11),

+ ACTION_SET_ALL = (1<<12),

+ ACTION_GET_COLOR = (1<<13),

+ ACTION_GET_COLORBOOL = (1<<14),

+ ACTION_GET_URLMATCH = (1<<15),

+ };

+ struct config_location_options location_opts = CONFIG_LOCATION_OPTIONS_INIT;

+ struct config_display_options display_opts = CONFIG_DISPLAY_OPTIONS_INIT;

+ const char *comment_arg = NULL;

+ int actions = 0;

+ unsigned flags = 0;

+ struct option opts[] = {

+ CONFIG_LOCATION_OPTIONS(location_opts),

+ OPT_GROUP(N_("Action")),

+ OPT_CMDMODE(0, "get", &actions, N_("get value: name [<value-pattern>]"), ACTION_GET),

+ OPT_CMDMODE(0, "get-all", &actions, N_("get all values: key [<value-pattern>]"), ACTION_GET_ALL),

+ OPT_CMDMODE(0, "get-regexp", &actions, N_("get values for regexp: name-regex [<value-pattern>]"), ACTION_GET_REGEXP),

+ OPT_CMDMODE(0, "get-urlmatch", &actions, N_("get value specific for the URL: section[.var] URL"), ACTION_GET_URLMATCH),

+ OPT_CMDMODE(0, "replace-all", &actions, N_("replace all matching variables: name value [<value-pattern>]"), ACTION_REPLACE_ALL),

+ OPT_CMDMODE(0, "add", &actions, N_("add a new variable: name value"), ACTION_ADD),

+ OPT_CMDMODE(0, "unset", &actions, N_("remove a variable: name [<value-pattern>]"), ACTION_UNSET),

+ OPT_CMDMODE(0, "unset-all", &actions, N_("remove all matches: name [<value-pattern>]"), ACTION_UNSET_ALL),

+ OPT_CMDMODE(0, "rename-section", &actions, N_("rename section: old-name new-name"), ACTION_RENAME_SECTION),

+ OPT_CMDMODE(0, "remove-section", &actions, N_("remove a section: name"), ACTION_REMOVE_SECTION),

+ OPT_CMDMODE('l', "list", &actions, N_("list all"), ACTION_LIST),

+ OPT_CMDMODE('e', "edit", &actions, N_("open an editor"), ACTION_EDIT),

+ OPT_CMDMODE(0, "get-color", &actions, N_("find the color configured: slot [<default>]"), ACTION_GET_COLOR),

+ OPT_CMDMODE(0, "get-colorbool", &actions, N_("find the color setting: slot [<stdout-is-tty>]"), ACTION_GET_COLORBOOL),

+ CONFIG_DISPLAY_OPTIONS(display_opts),

+ OPT_GROUP(N_("Other")),

+ OPT_STRING(0, "default", &display_opts.default_value,

+ N_("value"), N_("with --get, use default value when missing entry")),

+ OPT_STRING(0, "comment", &comment_arg, N_("value"), N_("human-readable comment string (# will be prepended as needed)")),

+ OPT_BIT(0, "fixed-value", &flags, N_("use string equality when comparing values to value pattern"), CONFIG_FLAGS_FIXED_VALUE),

+ OPT_BOOL(0, "includes", &location_opts.respect_includes_opt,

+ N_("respect include directives on lookup")),

+ OPT_END(),

+ };

+ argc = parse_options(argc, argv, prefix, opts,

+ location_options_init(&location_opts, prefix);

+ display_options_init(&display_opts);

+ if ((actions & (ACTION_GET_COLOR|ACTION_GET_COLORBOOL)) && display_opts.type) {

+ exit(129);

+ error(_("no action specified"));

+ exit(129);

+ if (display_opts.omit_values &&

+ exit(129);

+ if (display_opts.show_origin && !(actions &

+ exit(129);

+ if (display_opts.default_value && !(actions & ACTION_GET)) {

+ exit(129);

+ exit(129);

+ if (flags & CONFIG_FLAGS_FIXED_VALUE) {

+ exit(129);

+ /*

+ * The following actions may produce more than one line of output and

+ * should therefore be paged.

+ */

+ if (actions & (ACTION_LIST | ACTION_GET_ALL | ACTION_GET_REGEXP | ACTION_GET_URLMATCH))

+ if (config_with_options(show_all_config, &display_opts,

+ &location_opts.source, the_repository,

+ &location_opts.options) < 0) {

+ if (location_opts.source.file)

+ location_opts.source.file);

+ ret = show_editor(&location_opts);

+ check_write(&location_opts.source);

+ value = normalize_value(argv[0], argv[1], display_opts.type, &default_kvi);

+ ret = git_config_set_in_file_gently(location_opts.source.file, argv[0], comment, value);

+ check_write(&location_opts.source);

+ value = normalize_value(argv[0], argv[1], display_opts.type, &default_kvi);

+ ret = git_config_set_multivar_in_file_gently(location_opts.source.file,

+ check_write(&location_opts.source);

+ value = normalize_value(argv[0], argv[1], display_opts.type, &default_kvi);

+ ret = git_config_set_multivar_in_file_gently(location_opts.source.file,

+ check_write(&location_opts.source);

+ value = normalize_value(argv[0], argv[1], display_opts.type, &default_kvi);

+ ret = git_config_set_multivar_in_file_gently(location_opts.source.file,

+ ret = get_value(&location_opts, &display_opts, argv[0], argv[1],

+ 0, flags);

+ ret = get_value(&location_opts, &display_opts, argv[0], argv[1],

+ GET_VALUE_ALL, flags);

+ display_opts.show_keys = 1;

+ ret = get_value(&location_opts, &display_opts, argv[0], argv[1],

+ GET_VALUE_ALL|GET_VALUE_KEY_REGEXP, flags);

+ ret = get_urlmatch(&location_opts, &display_opts, argv[0], argv[1]);

+ check_write(&location_opts.source);

+ ret = git_config_set_multivar_in_file_gently(location_opts.source.file,

+ argv[0], NULL, argv[1],

+ NULL, flags);

+ ret = git_config_set_in_file_gently(location_opts.source.file,

+ argv[0], NULL, NULL);

+ check_write(&location_opts.source);

+ ret = git_config_set_multivar_in_file_gently(location_opts.source.file,

+ argv[0], NULL, argv[1],

+ NULL, flags | CONFIG_FLAGS_MULTI_REPLACE);

+ check_write(&location_opts.source);

+ ret = git_config_rename_section_in_file(location_opts.source.file,

+ goto out;

+ check_write(&location_opts.source);

+ ret = git_config_rename_section_in_file(location_opts.source.file,

+ goto out;

+ get_color(&location_opts, argv[0], argv[1]);

+ ret = get_colorbool(&location_opts, argv[0], argc == 2);

+out:

+ location_options_release(&location_opts);

+

+int cmd_config(int argc, const char **argv, const char *prefix)

+{

+ parse_opt_subcommand_fn *subcommand = NULL;

+ struct option subcommand_opts[] = {

+ OPT_SUBCOMMAND("list", &subcommand, cmd_config_list),

+ OPT_SUBCOMMAND("get", &subcommand, cmd_config_get),

+ OPT_SUBCOMMAND("set", &subcommand, cmd_config_set),

+ OPT_SUBCOMMAND("unset", &subcommand, cmd_config_unset),

+ OPT_SUBCOMMAND("rename-section", &subcommand, cmd_config_rename_section),

+ OPT_SUBCOMMAND("remove-section", &subcommand, cmd_config_remove_section),

+ OPT_SUBCOMMAND("edit", &subcommand, cmd_config_edit),

+ OPT_END(),

+ };

+

+ /*

+ * This is somewhat hacky: we first parse the command line while

+ * keeping all args intact in order to determine whether a subcommand

+ * has been specified. If so, we re-parse it a second time, but this

+ * time we drop KEEP_ARGV0. This is so that we don't munge the command

+ * line in case no subcommand was given, which would otherwise confuse

+ * us when parsing the legacy-style modes that don't use subcommands.

+ */

+ argc = parse_options(argc, argv, prefix, subcommand_opts, builtin_config_usage,

+ PARSE_OPT_SUBCOMMAND_OPTIONAL|PARSE_OPT_KEEP_ARGV0|PARSE_OPT_KEEP_UNKNOWN_OPT);

+ if (subcommand) {

+ argc = parse_options(argc, argv, prefix, subcommand_opts, builtin_config_usage,

+ PARSE_OPT_SUBCOMMAND_OPTIONAL|PARSE_OPT_KEEP_UNKNOWN_OPT);

+ return subcommand(argc, argv, prefix);

+ }

+

+ return cmd_config_actions(argc, argv, prefix);

+}

+

+ credential_clear(&c);

+ /*

+ * When operating outside of a Git repository we need to have a hash

+ * algorithm at hand so that we can generate the blob hashes. We

+ * default to SHA1 here, but may eventually want to change this to be

+ * configurable via a command line option.

+ */

+ if (nongit)

+ repo_set_hash_algo(the_repository, GIT_HASH_SHA1);

+

+ strvec_push(&child->env, "GIT_PAGER=");

+ strvec_push(&child->env, "GIT_EXTERNAL_DIFF=git-difftool--helper");

+ strvec_push(&child->env, "GIT_DIFFTOOL_PROMPT=true");

+ strvec_push(&child->env, "GIT_DIFFTOOL_NO_PROMPT=true");

+ if (nongit && !the_hash_algo)

+ repo_set_hash_algo(the_repository, GIT_HASH_SHA1);

+

+ struct trailer_info *info;

+ info = parse_trailers(opts, sb.buf, &head);

+ fwrite(sb.buf, 1, trailer_block_start(info), outfile);

+ if (!opts->only_trailers && !blank_line_before_trailer_block(info))

+ fwrite(sb.buf + trailer_block_end(info), 1, sb.len - trailer_block_end(info), outfile);

+ trailer_info_release(info);

+struct log_config {

+ int default_abbrev_commit;

+ int default_show_root;

+ int default_follow;

+ int default_show_signature;

+ int default_encode_email_headers;

+ int decoration_style;

+ int decoration_given;

+ int use_mailmap_config;

+ char *fmt_patch_subject_prefix;

+ int fmt_patch_name_max;

+ char *fmt_pretty;

+ char *default_date_mode;

+};

+

+static void log_config_init(struct log_config *cfg)

+{

+ memset(cfg, 0, sizeof(*cfg));

+ cfg->default_show_root = 1;

+ cfg->default_encode_email_headers = 1;

+ cfg->use_mailmap_config = 1;

+ cfg->fmt_patch_subject_prefix = xstrdup("PATCH");

+ cfg->fmt_patch_name_max = FORMAT_PATCH_NAME_MAX_DEFAULT;

+ cfg->decoration_style = auto_decoration_style();

+}

+

+static void log_config_release(struct log_config *cfg)

+{

+ free(cfg->default_date_mode);

+ free(cfg->fmt_pretty);

+ free(cfg->fmt_patch_subject_prefix);

+}

+

+static int decorate_callback(const struct option *opt, const char *arg,

+ struct log_config *cfg = opt->value;

+

+ cfg->decoration_style = 0;

+ cfg->decoration_style = parse_decoration_style(arg);

+ cfg->decoration_style = DECORATE_SHORT_REFS;

+ if (cfg->decoration_style < 0)

+ cfg->decoration_given = 1;

+static void cmd_log_init_defaults(struct rev_info *rev,

+ struct log_config *cfg)

+ if (cfg->fmt_pretty)

+ get_commit_format(cfg->fmt_pretty, rev);

+ if (cfg->default_follow)

+ rev->abbrev_commit = cfg->default_abbrev_commit;

+ rev->show_root_diff = cfg->default_show_root;

+ rev->subject_prefix = cfg->fmt_patch_subject_prefix;

+ rev->patch_name_max = cfg->fmt_patch_name_max;

+ rev->show_signature = cfg->default_show_signature;

+ rev->encode_email_headers = cfg->default_encode_email_headers;

+ if (cfg->default_date_mode)

+ parse_date_format(cfg->default_date_mode, &rev->date_mode);

+ struct rev_info *rev, struct setup_revision_opt *opt,

+ struct log_config *cfg)

+ OPT_CALLBACK_F(0, "decorate", cfg, NULL, N_("decorate options"),

+ mailmap = cfg->use_mailmap_config;

+ if (!cfg->decoration_given)

+ cfg->decoration_style = 0;

+ cfg->decoration_style = 0;

+ } else if (!cfg->decoration_style) {

+ cfg->decoration_style = DECORATE_SHORT_REFS;

+ if (cfg->decoration_style || rev->simplify_by_decoration) {

+ if (cfg->decoration_style)

+ load_ref_decorations(&decoration_filter, cfg->decoration_style);

+ struct rev_info *rev, struct setup_revision_opt *opt,

+ struct log_config *cfg)

+ cmd_log_init_defaults(rev, cfg);

+ cmd_log_init_finish(argc, argv, prefix, rev, opt, cfg);

+ struct log_config *cfg = cb;

+ if (!strcmp(var, "format.pretty")) {

+ FREE_AND_NULL(cfg->fmt_pretty);

+ return git_config_string(&cfg->fmt_pretty, var, value);

+ }

+ if (!strcmp(var, "format.subjectprefix")) {

+ FREE_AND_NULL(cfg->fmt_patch_subject_prefix);

+ return git_config_string(&cfg->fmt_patch_subject_prefix, var, value);

+ }

+ cfg->fmt_patch_name_max = git_config_int(var, value, ctx->kvi);

+ cfg->default_encode_email_headers = git_config_bool(var, value);

+ cfg->default_abbrev_commit = git_config_bool(var, value);

+ if (!strcmp(var, "log.date")) {

+ FREE_AND_NULL(cfg->default_date_mode);

+ return git_config_string(&cfg->default_date_mode, var, value);

+ }

+ cfg->decoration_style = parse_decoration_style(value);

+ if (cfg->decoration_style < 0)

+ cfg->decoration_style = 0; /* maybe warn? */

+ cfg->default_show_root = git_config_bool(var, value);

+ cfg->default_follow = git_config_bool(var, value);

+ cfg->use_mailmap_config = git_config_bool(var, value);

+ cfg->default_show_signature = git_config_bool(var, value);

+ struct log_config cfg;

+ int ret;

+ log_config_init(&cfg);

+ init_diff_ui_defaults();

+ git_config(git_log_config, &cfg);

+ cmd_log_init(argc, argv, prefix, &rev, &opt, &cfg);

+

+ ret = cmd_log_walk(&rev);

+

+ release_revisions(&rev);

+ log_config_release(&cfg);

+ return ret;

+ struct log_config cfg;

+ log_config_init(&cfg);

+ init_diff_ui_defaults();

+ git_config(git_log_config, &cfg);

+ cmd_log_init(argc, argv, prefix, &rev, &opt, &cfg);

+ if (!rev.no_walk) {

+ ret = cmd_log_walk(&rev);

+ release_revisions(&rev);

+ log_config_release(&cfg);

+ return ret;

+ }

+ release_revisions(&rev);

+ log_config_release(&cfg);

+ return ret;

+ struct log_config cfg;

+ int ret;

+ log_config_init(&cfg);

+ init_diff_ui_defaults();

+ git_config(git_log_config, &cfg);

+ cmd_log_init_defaults(&rev, &cfg);

+ cmd_log_init_finish(argc, argv, prefix, &rev, &opt, &cfg);

+ ret = cmd_log_walk(&rev);

+

+ release_revisions(&rev);

+ log_config_release(&cfg);

+ return ret;

+ struct log_config cfg;

+ int ret;

+ log_config_init(&cfg);

+ init_diff_ui_defaults();

+ git_config(git_log_config, &cfg);

+ cmd_log_init(argc, argv, prefix, &rev, &opt, &cfg);

+ ret = cmd_log_walk(&rev);

+ release_revisions(&rev);

+ log_config_release(&cfg);

+ return ret;

+/* format-patch */

+

+struct format_config {

+ struct log_config log;

+ enum thread_level thread;

+ int do_signoff;

+ enum auto_base_setting auto_base;

+ char *base_commit;

+ char *from;

+ char *signature;

+ char *signature_file;

+ enum cover_setting config_cover_letter;

+ char *config_output_directory;

+ enum cover_from_description cover_from_description_mode;

+ int show_notes;

+ struct display_notes_opt notes_opt;

+ int numbered_cmdline_opt;

+ int numbered;

+ int auto_number;

+ char *default_attach;

+ struct string_list extra_hdr;

+ struct string_list extra_to;

+ struct string_list extra_cc;

+ int keep_subject;

+ int subject_prefix;

+ struct strbuf sprefix;

+ char *fmt_patch_suffix;

+};

+

+static void format_config_init(struct format_config *cfg)

+{

+ memset(cfg, 0, sizeof(*cfg));

+ log_config_init(&cfg->log);

+ cfg->cover_from_description_mode = COVER_FROM_MESSAGE;

+ cfg->auto_number = 1;

+ string_list_init_dup(&cfg->extra_hdr);

+ string_list_init_dup(&cfg->extra_to);

+ string_list_init_dup(&cfg->extra_cc);

+ strbuf_init(&cfg->sprefix, 0);

+ cfg->fmt_patch_suffix = xstrdup(".patch");

+}

+

+static void format_config_release(struct format_config *cfg)

+{

+ log_config_release(&cfg->log);

+ free(cfg->base_commit);

+ free(cfg->from);

+ free(cfg->signature);

+ free(cfg->signature_file);

+ free(cfg->config_output_directory);

+ free(cfg->default_attach);

+ string_list_clear(&cfg->extra_hdr, 0);

+ string_list_clear(&cfg->extra_to, 0);

+ string_list_clear(&cfg->extra_cc, 0);

+ strbuf_release(&cfg->sprefix);

+ free(cfg->fmt_patch_suffix);

+}

+static void add_header(struct format_config *cfg, const char *value)

+{

+ struct string_list_item *item;

+ int len = strlen(value);

+ while (len && value[len - 1] == '\n')

+ len--;

+

+ if (!strncasecmp(value, "to: ", 4)) {

+ item = string_list_append(&cfg->extra_to, value + 4);

+ len -= 4;

+ } else if (!strncasecmp(value, "cc: ", 4)) {

+ item = string_list_append(&cfg->extra_cc, value + 4);

+ len -= 4;

+ } else {

+ item = string_list_append(&cfg->extra_hdr, value);

+ }

+

+ item->string[len] = '\0';

+}

+

+ struct format_config *cfg = cb;

+

+ add_header(cfg, value);

+ if (!strcmp(var, "format.suffix")) {

+ FREE_AND_NULL(cfg->fmt_patch_suffix);

+ return git_config_string(&cfg->fmt_patch_suffix, var, value);

+ }

+ string_list_append(&cfg->extra_to, value);

+ string_list_append(&cfg->extra_cc, value);

+ cfg->auto_number = 1;

+ cfg->numbered = git_config_bool(var, value);

+ cfg->auto_number = cfg->auto_number && cfg->numbered;

+ if (value && *value) {

+ FREE_AND_NULL(cfg->default_attach);

+ cfg->default_attach = xstrdup(value);

+ } else if (value && !*value) {

+ FREE_AND_NULL(cfg->default_attach);

+ } else {

+ FREE_AND_NULL(cfg->default_attach);

+ cfg->default_attach = xstrdup(git_version_string);

+ }

+ cfg->thread = THREAD_DEEP;

+ cfg->thread = THREAD_SHALLOW;

+ cfg->thread = git_config_bool(var, value) ? THREAD_SHALLOW : THREAD_UNSET;

+ cfg->do_signoff = git_config_bool(var, value);

+ if (!strcmp(var, "format.signature")) {

+ FREE_AND_NULL(cfg->signature);

+ return git_config_string(&cfg->signature, var, value);

+ }

+ if (!strcmp(var, "format.signaturefile")) {

+ FREE_AND_NULL(cfg->signature_file);

+ return git_config_pathname(&cfg->signature_file, var, value);

+ }

+ cfg->config_cover_letter = COVER_AUTO;

+ cfg->config_cover_letter = git_config_bool(var, value) ? COVER_ON : COVER_OFF;

+ if (!strcmp(var, "format.outputdirectory")) {

+ FREE_AND_NULL(cfg->config_output_directory);

+ return git_config_string(&cfg->config_output_directory, var, value);

+ }

+ cfg->auto_base = AUTO_BASE_WHEN_ABLE;

+ cfg->auto_base = git_config_bool(var, value) ? AUTO_BASE_ALWAYS : AUTO_BASE_NEVER;

+ FREE_AND_NULL(cfg->from);

+ cfg->from = xstrdup(value);

+ cfg->from = xstrdup(git_committer_info(IDENT_NO_DATE));

+ enable_ref_display_notes(&cfg->notes_opt, &cfg->show_notes, value);

+ enable_default_display_notes(&cfg->notes_opt, &cfg->show_notes);

+ disable_display_notes(&cfg->notes_opt, &cfg->show_notes);

+ cfg->cover_from_description_mode = parse_cover_from_description(value);

+ return git_log_config(var, value, ctx, &cfg->log);

+static void print_signature(const char *signature, FILE *file)

+ int need_8bit_cte,

+ const struct format_config *cfg)

+ if (cfg->cover_from_description_mode == COVER_FROM_NONE)

+ if (cfg->cover_from_description_mode == COVER_FROM_SUBJECT ||

+ cfg->cover_from_description_mode == COVER_FROM_AUTO)

+ if (cfg->cover_from_description_mode == COVER_FROM_MESSAGE ||

+ (cfg->cover_from_description_mode == COVER_FROM_AUTO &&

+ subject_sb.len > COVER_FROM_AUTO_MAX_SUBJECT_LEN))

+ int quiet,

+ const struct format_config *cfg)

+ encoding, need_8bit_cte, cfg);

+struct keep_callback_data {

+ struct format_config *cfg;

+ struct rev_info *revs;

+};

+ struct keep_callback_data *data = opt->value;

+ data->revs->total = -1;

+ data->cfg->keep_subject = 1;

+ struct format_config *cfg = opt->value;

+ cfg->subject_prefix = 1;

+ strbuf_reset(&cfg->sprefix);

+ strbuf_addstr(&cfg->sprefix, arg);

+ struct format_config *cfg = opt->value;

+ cfg->numbered = cfg->numbered_cmdline_opt = unset ? 0 : 1;

+ cfg->auto_number = 0;

+ struct format_config *cfg = opt->value;

+

+ cfg->thread = THREAD_UNSET;

+ cfg->thread = THREAD_SHALLOW;

+ cfg->thread = THREAD_DEEP;

+static int header_callback(const struct option *opt, const char *arg,

+ struct format_config *cfg = opt->value;

+

+ string_list_clear(&cfg->extra_hdr, 0);

+ string_list_clear(&cfg->extra_to, 0);

+ string_list_clear(&cfg->extra_cc, 0);

+ add_header(cfg, arg);

+ struct format_config *cfg = opt->value;

+ cfg->auto_base = AUTO_BASE_NEVER;

+ FREE_AND_NULL(cfg->base_commit);

+ cfg->auto_base = AUTO_BASE_ALWAYS;

+ FREE_AND_NULL(cfg->base_commit);

+ cfg->auto_base = AUTO_BASE_NEVER;

+ cfg->base_commit = xstrdup(arg);

+static struct commit *get_base_commit(const struct format_config *cfg,

+ switch (cfg->auto_base) {

+ if (cfg->base_commit) {

+ if (cfg->base_commit) {

+ die_on_failure = cfg->auto_base == AUTO_BASE_ALWAYS;

+ base = lookup_commit_reference_by_name(cfg->base_commit);

+ die(_("unknown commit %s"), cfg->base_commit);

+ struct format_config cfg;

+ const char *signature = git_version_string;

+ const char *signature_file_arg = NULL;

+ struct keep_callback_data keep_callback_data = {

+ .cfg = &cfg,

+ .revs = &rev,

+ };

+ const char *fmt_patch_suffix = NULL;

+ OPT_CALLBACK_F('n', "numbered", &cfg, NULL,

+ OPT_CALLBACK_F('N', "no-numbered", &cfg, NULL,

+ OPT_BOOL('s', "signoff", &cfg.do_signoff, N_("add a Signed-off-by trailer")),

+ OPT_INTEGER(0, "filename-max-length", &cfg.log.fmt_patch_name_max,

+ OPT_CALLBACK_F(0, "subject-prefix", &cfg, N_("prefix"),

+ OPT_CALLBACK_F('k', "keep-subject", &keep_callback_data, NULL,

+ OPT_CALLBACK(0, "add-header", &cfg, N_("header"),

+ OPT_STRING_LIST(0, "to", &cfg.extra_to, N_("email"), N_("add To: header")),

+ OPT_STRING_LIST(0, "cc", &cfg.extra_cc, N_("email"), N_("add Cc: header")),

+ OPT_CALLBACK_F(0, "from", &cfg.from, N_("ident"),

+ OPT_CALLBACK_F(0, "thread", &cfg, N_("style"),

+ OPT_CALLBACK_F(0, "base", &cfg, N_("base-commit"),

+ OPT_FILENAME(0, "signature-file", &signature_file_arg,

+ format_config_init(&cfg);

+ init_diff_ui_defaults();

+ init_display_notes(&cfg.notes_opt);

+ git_config(git_format_config, &cfg);

+ rev.show_notes = cfg.show_notes;

+ memcpy(&rev.notes_opt, &cfg.notes_opt, sizeof(cfg.notes_opt));

+ rev.encode_email_headers = cfg.log.default_encode_email_headers;

+ strbuf_addstr(&cfg.sprefix, cfg.log.fmt_patch_subject_prefix);

+ if (cfg.default_attach) {

+ rev.mime_boundary = cfg.default_attach;

+ if (!fmt_patch_suffix)

+ fmt_patch_suffix = cfg.fmt_patch_suffix;

+

+ if (cfg.log.fmt_patch_name_max <= strlen("0000-") + strlen(fmt_patch_suffix))

+ cfg.log.fmt_patch_name_max = strlen("0000-") + strlen(fmt_patch_suffix);

+ cfg.cover_from_description_mode = parse_cover_from_description(cover_from_description_arg);

+ cfg.subject_prefix = 1;

+ strbuf_addf(&cfg.sprefix, " %s", rfc + 1);

+ strbuf_insertf(&cfg.sprefix, 0, "%s ", rfc);

+ strbuf_addf(&cfg.sprefix, " v%s", reroll_count);

+ rev.subject_prefix = cfg.sprefix.buf;

+ for (i = 0; i < cfg.extra_hdr.nr; i++) {

+ strbuf_addstr(&buf, cfg.extra_hdr.items[i].string);

+ if (cfg.extra_to.nr)

+ for (i = 0; i < cfg.extra_to.nr; i++) {

+ strbuf_addstr(&buf, cfg.extra_to.items[i].string);

+ if (i + 1 < cfg.extra_to.nr)

+ if (cfg.extra_cc.nr)

+ for (i = 0; i < cfg.extra_cc.nr; i++) {

+ strbuf_addstr(&buf, cfg.extra_cc.items[i].string);

+ if (i + 1 < cfg.extra_cc.nr)

+ if (cfg.from) {

+ if (split_ident_line(&rev.from_ident, cfg.from, strlen(cfg.from)))

+ die(_("invalid ident line: %s"), cfg.from);

+ if (cfg.numbered && cfg.keep_subject && !cfg.numbered_cmdline_opt)

+ cfg.numbered = 0;

+ if (cfg.numbered && cfg.keep_subject)

+ if (cfg.keep_subject && cfg.subject_prefix)

+ rev.preserve_subject = cfg.keep_subject;

+ rev.patch_name_max = cfg.log.fmt_patch_name_max;

+ output_directory = cfg.config_output_directory;

+ if (cfg.config_cover_letter == COVER_AUTO)

+ cover_letter = (cfg.config_cover_letter == COVER_ON);

+ if (!cfg.keep_subject && cfg.auto_number && (total > 1 || cover_letter))

+ cfg.numbered = 1;

+ if (cfg.numbered)

+ creation_factor = CREATION_FACTOR_FOR_THE_SAME_SERIES;

+ /*

+ * The order of precedence is:

+ *

+ * 1. The `--signature` and `--no-signature` options.

+ * 2. The `--signature-file` option.

+ * 3. The `format.signature` config.

+ * 4. The `format.signatureFile` config.

+ * 5. Default `git_version_string`.

+ */

+ } else if (signature_file_arg || (cfg.signature_file && !cfg.signature)) {

+ const char *signature_file = signature_file_arg ?

+ signature_file_arg : cfg.signature_file;

+ } else if (cfg.signature) {

+ signature = cfg.signature;

+ base = get_base_commit(&cfg, list, nr);

+ if (in_reply_to || cfg.thread || cover_letter) {

+ if (cfg.thread)

+ origin, nr, list, description_file, branch_name, quiet, &cfg);

+ print_signature(signature, rev.diffopt.file);

+ rev.add_signoff = cfg.do_signoff;

+ if (cfg.thread) {

+ if (cfg.thread == THREAD_SHALLOW

+ print_signature(signature, rev.diffopt.file);

+ release_revisions(&rev);

+ format_config_release(&cfg);

+ return 0;

+static char *pull_twohead, *pull_octopus;

+static char *cleanup_arg;

+#include "strvec.h"

+static void internal_prefix_pathspec(struct strvec *out,

+ const char *prefix,

+ const char **pathspec,

+ int count, unsigned flags)

+ for (int i = 0; i < count; i++) {

+ size_t length = strlen(pathspec[i]);

+ size_t to_copy = length;

+ const char *maybe_basename;

+ char *trimmed, *prefixed_path;

+

+ trimmed = xmemdupz(pathspec[i], to_copy);

+ maybe_basename = (flags & DUP_BASENAME) ? basename(trimmed) : trimmed;

+ prefixed_path = prefix_path(prefix, prefixlen, maybe_basename);

+ strvec_push(out, prefixed_path);

+ free(prefixed_path);

+ free(trimmed);

+static char *add_slash(const char *path)

+ return xstrdup(path);

+static const char *submodule_gitfile_path(const char *src, int first)

+ const char *path;

+

+

+

+ path = read_gitfile(submodule_dotgit.buf);

+ if (path)

+ return path;

+ return SUBMODULE_WITH_GITDIR;

+ char *src_w_slash = add_slash(src);

+

+ free(src_w_slash);

+ char *with_slash = add_slash(name);

+ free(with_slash);

+static void remove_empty_src_dirs(const char **src_dir, size_t src_dir_nr)

+{

+ size_t i;

+ struct strbuf a_src_dir = STRBUF_INIT;

+

+ for (i = 0; i < src_dir_nr; i++) {

+ int dummy;

+ strbuf_addstr(&a_src_dir, src_dir[i]);

+ /*

+ * if entries under a_src_dir are all moved away,

+ * recursively remove a_src_dir to cleanup

+ */

+ if (index_range_of_same_dir(a_src_dir.buf, a_src_dir.len,

+ &dummy, &dummy) < 1) {

+ remove_dir_recursively(&a_src_dir, 0);

+ }

+ strbuf_reset(&a_src_dir);

+ }

+

+ strbuf_release(&a_src_dir);

+}

+

+ struct strvec sources = STRVEC_INIT;

+ struct strvec dest_paths = STRVEC_INIT;

+ struct strvec destinations = STRVEC_INIT;

+ struct strvec submodule_gitfiles_to_free = STRVEC_INIT;

+ const char **submodule_gitfiles;

+ char *dst_w_slash = NULL;

+ struct strvec src_dir = STRVEC_INIT;

+ struct string_list src_for_dst = STRING_LIST_INIT_DUP;

+ struct string_list only_match_skip_worktree = STRING_LIST_INIT_DUP;

+ struct string_list dirty_paths = STRING_LIST_INIT_DUP;

+ int ret;

+ internal_prefix_pathspec(&sources, prefix, argv, argc, 0);

+ internal_prefix_pathspec(&dest_paths, prefix, argv + argc, 1, flags);

+ dst_w_slash = add_slash(dest_paths.v[0]);

+ submodule_gitfiles = xcalloc(argc, sizeof(char *));

+ if (dest_paths.v[0][0] == '\0')

+ internal_prefix_pathspec(&destinations, dest_paths.v[0], argv, argc, DUP_BASENAME);

+ else if (!lstat(dest_paths.v[0], &st) && S_ISDIR(st.st_mode)) {

+ internal_prefix_pathspec(&destinations, dst_w_slash, argv, argc, DUP_BASENAME);

+ } else if (!path_in_sparse_checkout(dst_w_slash, the_repository->index) &&

+ empty_dir_has_sparse_contents(dst_w_slash)) {

+ internal_prefix_pathspec(&destinations, dst_w_slash, argv, argc, DUP_BASENAME);

+ dst_mode = SKIP_WORKTREE_DIR;

+ } else if (argc != 1) {

+ die(_("destination '%s' is not a directory"), dest_paths.v[0]);

+ strvec_pushv(&destinations, dest_paths.v);

+

+ /*

+ * <destination> is a file outside of sparse-checkout

+ * cone. Insist on cone mode here for backward

+ * compatibility. We don't want dst_mode to be assigned

+ * for a file when the repo is using no-cone mode (which

+ * is deprecated at this point) sparse-checkout. As

+ * SPARSE here is only considering cone-mode situation.

+ */

+ if (!path_in_cone_mode_sparse_checkout(destinations.v[0], the_repository->index))

+ dst_mode = SPARSE;

+ const char *src = sources.v[i], *dst = destinations.v[i];

+ char *src_w_slash = add_slash(src);

+ free(src_w_slash);

+ free(src_w_slash);

+ char *dst_with_slash;

+ size_t dst_with_slash_len;

+ int j, n;

+ const char *path = submodule_gitfile_path(src, first);

+ if (path != SUBMODULE_WITH_GITDIR)

+ path = strvec_push(&submodule_gitfiles_to_free, path);

+ submodule_gitfiles[i] = path;

+ strvec_push(&src_dir, src);

+ REALLOC_ARRAY(submodule_gitfiles, n);

+ dst_with_slash = add_slash(dst);

+ dst_with_slash_len = strlen(dst_with_slash);

+ char *prefixed_path = prefix_path(dst_with_slash, dst_with_slash_len, path + length + 1);

+

+ strvec_push(&sources, path);

+ strvec_push(&destinations, prefixed_path);

+

+ submodule_gitfiles[argc + j] = NULL;

+

+ free(prefixed_path);

+

+ free(dst_with_slash);

+ strvec_remove(&sources, i);

+ strvec_remove(&destinations, i);

+ MOVE_ARRAY(submodule_gitfiles + i,

+ submodule_gitfiles + i + 1, n);

+ if (!ignore_errors) {

+ ret = 1;

+ goto out;

+ }

+ const char *src = sources.v[i], *dst = destinations.v[i];

+ if (submodule_gitfiles[i]) {

+ if (submodule_gitfiles[i] != SUBMODULE_WITH_GITDIR)

+ submodule_gitfiles[i],

+ remove_empty_src_dirs(src_dir.v, src_dir.nr);

+ ret = 0;

+

+out:

+ strvec_clear(&src_dir);

+ free(dst_w_slash);

+ string_list_clear(&only_match_skip_worktree, 0);

+ strvec_clear(&sources);

+ strvec_clear(&dest_paths);

+ strvec_clear(&destinations);

+ strvec_clear(&submodule_gitfiles_to_free);

+ free(submodule_gitfiles);

+ return ret;

+ struct bitmap_writer bitmap_writer;

+ bitmap_writer_init(&bitmap_writer);

+ bitmap_writer_set_checksum(&bitmap_writer, hash);

+ bitmap_writer_build_type_index(&bitmap_writer,

+ bitmap_writer_show_progress(&bitmap_writer,

+ progress);

+ bitmap_writer_select_commits(&bitmap_writer,

+ indexed_commits,

+ indexed_commits_nr);

+ if (bitmap_writer_build(&bitmap_writer, &to_pack) < 0)

+ bitmap_writer_finish(&bitmap_writer,

+ written_list, nr_written,

+ bitmap_writer_free(&bitmap_writer);

+#include "setup.h"

+ /*

+ * We rely on `the_hash_algo` to compute patch IDs. This is dubious as

+ * it means that the hash algorithm now depends on the object hash of

+ * the repository, even though git-patch-id(1) clearly defines that

+ * patch IDs always use SHA1.

+ *

+ * NEEDSWORK: This hack should be removed in favor of converting

+ * the code that computes patch IDs to always use SHA1.

+ */

+ if (!the_hash_algo)

+ repo_set_hash_algo(the_repository, GIT_HASH_SHA1);

+

+ char *default_backend;

+static char *cert_nonce_seed;

+ char *path;

+ free(path);

+ char *window;

+ char *window_memory;

+ char *depth;

+ char *threads;

+ else if ((int)the_hash_algo->hexsz <= abbrev)

+ abbrev = the_hash_algo->hexsz;

+ if (!nongit && setup_revisions(argc, argv, &rev, NULL) != 1) {

+ string_list_clear(&sl, 0);

+ } else {

+ write_patterns_to_file(stdout, &pl);

+ struct pattern_list *old_pl;

+ old_pl = r->index->sparse_checkout_patterns;

+ if (r->index->sparse_checkout_patterns != pl) {

+ clear_pattern_list(r->index->sparse_checkout_patterns);

+ FREE_AND_NULL(r->index->sparse_checkout_patterns);

+ }

+ r->index->sparse_checkout_patterns = old_pl;

+

+

+ string_list_clear(&sl, 0);

+ clear_pattern_list(&pl);

+ free(sparse_filename);

+

+ add_pattern("/*", empty_base, 0, &pl, 0);

+ add_pattern("!/*/", empty_base, 0, &pl, 0);

+ struct pattern_entry *dup;

+ dup = hashmap_get_entry(&pl->parent_hashmap, e, ent, NULL);

+ if (!dup) {

+ } else {

+ free(e->pattern);

+ free(e);

+ e = dup;

+ }

+ strbuf_release(&line);

+ while (!strbuf_getline(&line, file))

+ add_pattern(line.buf, empty_base, 0, pl, 0);

+

+ strbuf_release(&line);

+ add_pattern("/*", empty_base, 0, &pl, 0);

+ strbuf_addstrings(&sb, "../", count_slashes(path));

+static char *dwim_branch(const char *path, char **new_branch)

+ char *branchname = xstrndup(s, n);

+ char *remote = unique_tracking_name(*new_branch, &oid, NULL);

+ char *branch_to_free = NULL;

+ char *new_branch_to_free = NULL;

+ char *s = dwim_branch(path, &new_branch_to_free);

+ branch = branch_to_free = s;

+ new_branch = new_branch_to_free;

+ char *remote;

+ free(branch_to_free);

+ free(new_branch_to_free);