UI, Workflows & Features

------------------------

Performance, Internal Implementation, Development Support etc.

--------------------------------------------------------------

Fixes since v2.48

-----------------

* Other code cleanup, docfix, build fix, etc.

Set this option to `true` to make the diff driver cache the text

conversion outputs. See linkgit:gitattributes[5] for details.

`diff.indentHeuristic`::

Set this option to `false` to disable the default heuristics

that shift diff hunk boundaries to make patches easier to read.

and requires that a corresponding difftool.<guitool>.cmd variable

is defined.

difftool.<tool>.cmd::

Specify the command to invoke the specified diff tool.

The specified command is evaluated in shell with the following

$ git config credential.helper 'cache --timeout=3600'

-------------------------------------------------------

GIT

---

Part of the linkgit:git[1] suite

The merge driver can learn the pathname in which the merged result

will be stored via placeholder `%P`. The conflict labels to be used

for the common ancestor, local head and other head can be passed by

`conflict-marker-size`

^^^^^^^^^^^^^^^^^^^^^^

and `--no-color`.

Aggregating short options

~~~~~~~~~~~~~~~~~~~~~~~~~

Commands that support the enhanced option parser allow you to aggregate short

credential-generating helper might generate credentials for certain servers via

some API.

You may also have third-party helpers installed; search for

`credential-*` in the output of `git help -a`, and consult the

=== Available helpers

The community maintains a comprehensive list of Git credential helpers at

https://git-scm.com/doc/credential-helpers.

host. Subsequent authentication happens in the background. Many popular Git

hosts support OAuth.

CREDENTIAL CONTEXTS

-------------------

command: asciidoc_html_options,

input: article,

output: fs.stem(article) + '.html',

install: true,

install_dir: get_option('datadir') / 'doc/git-doc/technical',

)

THIRD_PARTY_SOURCES += $(UNIT_TEST_DIR)/clar/clar/%

CLAR_TEST_SUITES += u-ctype

CLAR_TEST_SUITES += u-mem-pool

CLAR_TEST_SUITES += u-prio-queue

CLAR_TEST_SUITES += u-reftable-tree

CLAR_TEST_OBJS += $(UNIT_TEST_DIR)/unit-test.o

UNIT_TEST_PROGRAMS += t-example-decorate

UNIT_TEST_PROGRAMS += t-hashmap

UNIT_TEST_PROGRAMS += t-oid-array

UNIT_TEST_PROGRAMS += t-oidmap

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

s->use_color ? GIT_COLOR_RESET : "", COLOR_MAXLEN);

FREE_AND_NULL(s->interactive_diff_filter);

FREE_AND_NULL(s->interactive_diff_algorithm);

if (s->use_single_key)

setbuf(stdin, NULL);

}

size_t *binary_count)

{

struct object_id head_oid;

"HEAD", RESOLVE_REF_READING,

&head_oid, NULL);

struct collection_status s = { 0 };

s.skip_unseen = filter && i;

opt.def = is_initial ?

repo_init_revisions(r, &rev, NULL);

setup_revisions(0, NULL, &rev, &opt);

size_t count, i, j;

struct object_id oid;

"HEAD", RESOLVE_REF_READING,

&oid,

NULL);

ssize_t count, i;

struct object_id oid;

"HEAD", RESOLVE_REF_READING,

&oid,

NULL);

if (file_diff->hunk_nr) {

if (rendered_hunk_index != hunk_index) {

if (use_pager) {

sigchain_push(SIGPIPE, SIG_IGN);

}

render_hunk(s, hunk, 0, colored, &s->buf);

}

static struct commit **get_bad_and_good_commits(struct repository *r,

{

struct commit **rev;

ALLOC_ARRAY(rev, 1 + good_revs.nr);

rev[n++] = get_commit_reference(r, current_bad_oid);

* for early success, this will be converted back to 0 in

* check_good_are_ancestors_of_bad().

*/

{

enum bisect_error res = BISECT_OK;

struct commit_list *result = NULL;

return res;

}

struct commit **rev, const char *prefix)

{

struct strvec rev_argv = STRVEC_INIT;

{

char *filename;

struct stat st;

enum bisect_error res = BISECT_OK;

struct commit **rev;

int ret = 0;

struct mailinfo mi;

if (state->utf8)

mi.metainfo_charset = get_commit_output_encoding();

}

strbuf_release(&msg);

} else if (*reply == 'v' || *reply == 'V') {

struct child_process cp = CHILD_PROCESS_INIT;

if (!pager)

if (len < 0)

die_errno(_("failed to read '%s'"), patch_path);

write_in_full(1, sb.buf, sb.len);

strbuf_release(&sb);

return 0;

OPT_END()

};

git_config(git_default_config, NULL);

sb.found_guilty_entry = &found_guilty_entry;

sb.found_guilty_entry_data = &pi;

if (show_progress)

assign_blame(&sb, opt);

stop_progress(&pi.progress);

if (!incremental)

else

goto cleanup;

filter.kind = FILTER_REFS_BRANCHES;

filter.abbrev = -1;

/*

* Try to set sort keys from config. If config does not set any,

strbuf_addftime(&zip_path, option_suffix, localtime_r(&now, &tm), 0, 0);

strbuf_addstr(&zip_path, ".zip");

die_errno(_("unable to create diagnostics archive %s"), zip_path.buf);

strbuf_release(&zip_path);

BUG_ON_NON_EMPTY_PREFIX(prefix);

if (argc == 3 && !strcmp(argv[1], "--branch"))

return check_ref_format_branch(argv[2]);

OPT_END()

};

git_config(git_default_config, NULL);

argc = parse_options(argc, argv, prefix, checkout_worker_options,

OPT_END()

};

git_config(git_default_config, NULL);

prefix_length = prefix ? strlen(prefix) : 0;

oidset_init(&commits, 0);

if (opts.progress)

progress = start_delayed_progress(

_("Collecting commits from input"), 0);

while (strbuf_getline(&buf, stdin) != EOF) {

git_config(git_default_config, NULL);

argc = parse_options(argc, argv, prefix, options, commit_tree_usage, 0);

OPT_END(),

};

prepare_repo_settings(the_repository);

the_repository->settings.command_requires_full_index = 0;

struct strbuf err = STRBUF_INIT;

int ret = 0;

prepare_repo_settings(the_repository);

the_repository->settings.command_requires_full_index = 0;

git_config(git_default_config, NULL);

usage(usage_msg);

op = argv[1];

die("unable to read credential from stdin");

if (!strcmp(op, "fill")) {

credential_next_state(&c);

credential_write(&c, stdout, CREDENTIAL_OP_RESPONSE);

} else if (!strcmp(op, "approve")) {

credential_set_all_capabilities(&c, CREDENTIAL_OP_HELPER);

} else if (!strcmp(op, "reject")) {

credential_set_all_capabilities(&c, CREDENTIAL_OP_HELPER);

} else {

usage(usage_msg);

}

#include "builtin.h"

#include "abspath.h"

#include "gettext.h"

}

/* Prepare diagnostics */

die_errno(_("unable to create diagnostics archive %s"),

zip_path.buf);

int result;

unsigned options = 0;

git_config(git_diff_basic_config, NULL); /* no "diff" UI options */

int i;

int result;

git_config(git_diff_basic_config, NULL); /* no "diff" UI options */

int read_stdin = 0;

int merge_base = 0;

git_config(git_diff_basic_config, NULL); /* no "diff" UI options */

{

unsigned int i;

reset_pack_idx_option(&pack_idx_opts);

git_pack_config();

list_objects_filter_init(&args.filter_options);

args.uploadpack = "git-upload-pack";

for (i = 1; i < argc && *argv[i] == '-'; i++) {

const char *arg = argv[i];

unsigned int nr = 0;

int result = 0;

if (show_progress)

while (pending.nr) {

result |= traverse_one_object(object_array_pop(&pending));

display_progress(progress, ++nr);

fprintf_ln(stderr, _("Checking object directory"));

if (show_progress)

for_each_loose_file_in_objdir(path, fsck_loose, fsck_cruft, fsck_subdir,

&cb_data);

if (show_progress) {

for (struct packed_git *p = get_all_packs(r); p; p = p->next)

pack_count++;

pack_count = 0;

}

total += p->num_objects;

}

}

for (p = get_all_packs(the_repository); p;

p = p->next) {

OPT_END()

};

die(_("fsmonitor--daemon not supported on this platform"));

}

OPT_END()

};

strvec_pushl(&reflog, "reflog", "expire", "--all", NULL);

strvec_pushl(&repack, "repack", "-d", "-l", NULL);

if (getenv("GIT_TEST_MAINT_SCHEDULER"))

return 13;

}

static int is_launchctl_available(void)

#define HEADERSIZE (2 * RECORDSIZE)

int cmd_get_tar_commit_id(int argc,

const char *prefix,

struct repository *repo UNUSED)

{

BUG_ON_NON_EMPTY_PREFIX(prefix);

if (argc != 1)

usage(builtin_get_tar_commit_id_usage);

}

if (show_in_pager == default_pager)

if (show_in_pager) {

opt.color = 0;

opt.name_only = 1;

}

if (!show_in_pager && !opt.status_only)

die_for_incompatible_opt3(!use_index, "--no-index",

untracked, "--untracked",

case HELP_ACTION_ALL:

opt_mode_usage(argc, "--all", help_format);

if (verbose) {

list_all_cmds_help(show_external_commands,

show_aliases);

return 0;

return 0;

case HELP_ACTION_CONFIG:

opt_mode_usage(argc, "--config", help_format);

list_config_help(SHOW_CONFIG_HUMAN);

printf("\n%s\n", _("'git help config' for more information"));

return 0;

max = get_max_object_index();

if (verbose)

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

foreign_nr += check_object(get_indexed_object(i));

if (verbose)

progress = start_progress(

progress_title ? progress_title :

from_stdin ? _("Receiving objects") : _("Indexing objects"),

nr_objects);

QSORT(ref_deltas, nr_ref_deltas, compare_ref_delta_entry);

if (verbose || show_resolving_progress)

nr_ref_deltas + nr_ofs_deltas);

nr_dispatched = 0;

*/

fetch_if_missing = 0;

disable_replace_refs();

fsck_options.walk = mark_link;

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

static void set_default_decoration_filter(struct decoration_filter *decoration_filter)

{

char *value = NULL;

struct string_list *include = decoration_filter->include_ref_pattern;

const struct string_list *config_exclude;

* No command-line or config options were given, so

* populate with sensible defaults.

*/

if (!ref_namespace[i].decoration)

continue;

if (rev->line_level_traverse)

line_log_init(rev, line_cb.prefix, &line_cb.args);

}

static void cmd_log_init(int argc, const char **argv, const char *prefix,

unsigned long size;

enum object_type type;

char *buf = repo_read_object_file(the_repository, oid, &type, &size);

if (!buf)

return error(_("could not read object %s"), oid_to_hex(oid));

assert(type == OBJ_TAG);

while (offset < size && buf[offset] != '\n') {

const char *ident;

while (new_offset < size && buf[new_offset++] != '\n')

; /* do nothing */

static char *find_branch_name(struct rev_info *rev)

{

struct object_id branch_oid;

const struct object_id *tip_oid;

const char *ref, *v;

char *full_ref, *branch = NULL;

if (rev->cmdline.rev[i].flags & UNINTERESTING)

continue;

return NULL;

}

return NULL;

if (repo_dwim_ref(the_repository, ref, strlen(ref), &branch_oid,

&full_ref, 0) &&

skip_prefix(full_ref, "refs/heads/", &v) &&

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

struct commit **list,

{

struct commit *base = NULL;

struct commit **rev;

switch (cfg->auto_base) {

case AUTO_BASE_NEVER:

static void prepare_bases(struct base_tree_info *bases,

struct commit *base,

struct commit **list,

{

struct commit *commit;

struct rev_info revs;

struct diff_options diffopt;

struct commit_base commit_base;

if (!base)

return;

repo_init_revisions(the_repository, &revs, NULL);

revs.max_parents = 1;

revs.topo_order = 1;

list[i]->object.flags &= ~UNINTERESTING;

add_pending_object(&revs, &list[i]->object, "rev_list");

*commit_base_at(&commit_base, list[i]) = 1;

struct rev_info rev;

char *to_free = NULL;

struct setup_revision_opt s_r_opt;

int use_stdout = 0;

int start_number = -1;

int just_numbers = 0;

fmt_patch_suffix = cfg.fmt_patch_suffix;

/* Make sure "0000-$sub.patch" gives non-negative length for $sub */

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

if (cover_from_description_arg)

rev.commit_format = CMIT_FMT_MBOXRD;

if (use_stdout) {

} else if (!rev.diffopt.close_file) {

int saved;

rev.add_signoff = cfg.do_signoff;

if (show_progress)

int shown;

/* Make the second and subsequent mails replies to the first */

if (cfg.thread) {

/* Have we already had a message ID? */

};

int ret = 0;

prepare_repo_settings(the_repository);

the_repository->settings.command_requires_full_index = 0;

OPT_END()

};

meta_charset.policy = CHARSET_DEFAULT;

argc = parse_options(argc, argv, prefix, options, mailinfo_usage, 0);

BUG_ON_NON_EMPTY_PREFIX(prefix);

for (argp = argv+1; *argp; argp++) {

const char *arg = *argp;

continue;

} else if ( arg[1] == 'f' ) {

nr = strtol(arg+2, NULL, 10);

} else if ( arg[1] == 'b' && !arg[2] ) {

allow_bare = 1;

} else if (!strcmp(arg, "--keep-cr")) {

#include "parse-options.h"

#include "commit-reach.h"

{

struct commit_list *result = NULL, *r;

struct repository *repo UNUSED)

{

struct commit **rev;

int show_all = 0;

int cmdmode = 0;

int ret;

}

}

int cmd_merge_index(int argc,

const char **argv,

const char *prefix UNUSED,

*/

signal(SIGCHLD, SIG_DFL);

if (argc < 3)

repo_read_index(the_repository);

const char *prefix UNUSED,

struct repository *repo UNUSED)

{

/*

* The contents of the current index becomes the tree we

if (argv[0] && ends_with(argv[0], "-subtree"))

o.subtree_shift = "";

if (argc < 4)

usagef(builtin_merge_recursive_usage, argv[0]);

void *branch_to_free;

int orig_argc = argc;

prepare_repo_settings(the_repository);

the_repository->settings.command_requires_full_index = 0;

struct object_entry **write_order;

if (progress > pack_to_stdout)

ALLOC_ARRAY(written_list, to_pack.nr_objects);

write_order = compute_write_order();

struct object_entry **sorted_by_offset;

if (progress)

to_pack.nr_objects);

CALLOC_ARRAY(sorted_by_offset, to_pack.nr_objects);

unsigned nr_done = 0;

if (progress)

nr_deltas);

QSORT(delta_list, n, type_size_sort);

ll_find_deltas(delta_list, n, window+1, depth, &nr_done);

static void enumerate_cruft_objects(void)

{

if (progress)

add_objects_in_unpacked_packs();

add_unreachable_loose_objects();

revs.ignore_missing_links = 1;

if (progress)

ret = add_unseen_recent_objects_to_traversal(&revs, cruft_expiration,

set_cruft_mtime, 1);

stop_progress(&progress_state);

if (prepare_revision_walk(&revs))

die(_("revision walk setup failed"));

if (progress)

nr_seen = 0;

traverse_commit_list(&revs, show_cruft_commit, show_cruft_object, NULL);

prepare_packing_data(the_repository, &to_pack);

if (progress && !cruft)

if (stdin_packs) {

/* avoids adding objects in excluded packs */

ignore_packed_keep_in_core = 1;

struct strbuf idx_name = STRBUF_INIT;

char buf[GIT_MAX_HEXSZ + 2]; /* hex hash + \n + \0 */

for (i = 1; i < argc; i++) {

const char *arg = argv[i];

return;

if (show_progress)

mark_reachable_objects(revs, 1, expire, progress);

stop_progress(&progress);

initialized = 1;

};

int i;

prepare_repo_settings(the_repository);

the_repository->settings.command_requires_full_index = 0;

char *path;

if (git_config_pathname(&path, var, value))

strbuf_addf(&fsck_msg_types, "%cskiplist=%s",

fsck_msg_types.len ? ',' : '=', path);

free(path);

strvec_push(&child.args, alt_shallow_file);

}

if (!tmp_objdir) {

if (err_fd > 0)

close(err_fd);

}

}

if (auto_update_server_info)

clear_shallow_info(&si);

}

if (use_sideband)

{

BUG_ON_NON_EMPTY_PREFIX(prefix);

if (argc != 3)

usage(usage_msg);

BUG_ON_NON_EMPTY_PREFIX(prefix);

if (argc != 3)

usage(usage_msg);

* Count symrefs twice, since "renaming" them is done by

* deleting and recreating them in two separate passes.

*/

rename.remote_branches->nr + rename.symrefs_nr);

}

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

}

if (run_update_server_info)

if (git_env_bool(GIT_TEST_MULTI_PACK_INDEX, 0)) {

unsigned flags = 0;

const char *show_progress = NULL;

int ret = 0;

git_config(git_default_config, NULL);

repo_init_revisions(the_repository, &revs, prefix);

revs.limited = 1;

if (show_progress)

if (use_bitmap_index) {

if (!try_bitmap_count(&revs, filter_provided_objects))

int seen_end_of_options = 0;

enum format_type format = FORMAT_DEFAULT;

if (argc > 1 && !strcmp("--parseopt", argv[1]))

return cmd_parseopt(argc - 1, argv + 1, prefix);

set_ref_status_for_push(remote_refs, args.send_mirror,

args.force_update);

if (helper_status)

print_helper_status(remote_refs);

return path;

}

int cmd_unpack_file(int argc,

const char **argv,

const char *prefix UNUSED,

{

struct object_id oid;

if (repo_get_oid(the_repository, argv[1], &oid))

die("Not a valid object name %s", argv[1]);

use(sizeof(struct pack_header));

if (!quiet)

CALLOC_ARRAY(obj_list, nr_objects);

begin_odb_transaction();

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

quiet = !isatty(2);

for (i = 1 ; i < argc; i++) {

const char *arg = argv[i];

OPT_END()

};

git_config(git_default_config, NULL);

if (argc > 0)

usage_with_options(update_server_info_usage, options);

}

const char *arg_cmd = "argument ";

int ret;

usage(upload_archive_usage);

if (!enter_repo(argv[1], 0))

BUG_ON_NON_EMPTY_PREFIX(prefix);

/*

* Set up sideband subprocess.

#include "builtin.h"

#include "exec-cmd.h"

#include "gettext.h"

switch (determine_protocol_version_server()) {

case protocol_v2:

if (advertise_refs)

else

break;

case protocol_v1:

/*

static char *pager(int ident_flag UNUSED)

{

if (!pgm)

pgm = "cat";

const struct git_var *git_var;

char *val;

if (argc != 2)

usage(var_usage);

if (!odb_transaction_nesting || bulk_fsync_objdir)

return;

if (bulk_fsync_objdir)

tmp_objdir_replace_primary_odb(bulk_fsync_objdir, 0);

}

if (ctx->report_progress)

ctx->progress = start_delayed_progress(

_("Loading known commits in commit graph"),

ctx->oids.nr);

for (i = 0; i < ctx->oids.nr; i++) {

*/

if (ctx->report_progress)

ctx->progress = start_delayed_progress(

_("Expanding reachable commits in commit graph"),

0);

for (i = 0; i < ctx->oids.nr; i++) {

if (ctx->report_progress)

ctx->progress = start_delayed_progress(

_("Clearing commit marks in commit graph"),

ctx->oids.nr);

for (i = 0; i < ctx->oids.nr; i++) {

if (ctx->report_progress)

info.progress = ctx->progress

= start_delayed_progress(

_("Computing commit graph topological levels"),

ctx->commits.nr);

if (ctx->report_progress)

info.progress = ctx->progress

= start_delayed_progress(

_("Computing commit graph generation numbers"),

ctx->commits.nr);

if (ctx->report_progress)

progress = start_delayed_progress(

_("Computing commit changed paths Bloom filters"),

ctx->commits.nr);

data.commits = &commits;

if (flags & COMMIT_GRAPH_WRITE_PROGRESS)

data.progress = start_delayed_progress(

_("Collecting referenced commits"), 0);

refs_for_each_ref(get_main_ref_store(the_repository), add_ref_to_set,

"Finding commits for commit graph in %"PRIuMAX" packs",

pack_indexes->nr),

(uintmax_t)pack_indexes->nr);

ctx->progress_done = 0;

}

for (i = 0; i < pack_indexes->nr; i++) {

{

if (ctx->report_progress)

ctx->progress = start_delayed_progress(

_("Finding commits for commit graph among packed objects"),

ctx->approx_nr_objects);

for_each_packed_object(ctx->r, add_packed_commits, ctx,

ctx->num_extra_edges = 0;

if (ctx->report_progress)

ctx->progress = start_delayed_progress(

_("Finding extra edges in commit graph"),

ctx->oids.nr);

oid_array_sort(&ctx->oids);

get_num_chunks(cf)),

get_num_chunks(cf));

ctx->progress = start_delayed_progress(

progress_title.buf,

st_mult(get_num_chunks(cf), ctx->commits.nr));

}

if (ctx->report_progress)

ctx->progress = start_delayed_progress(

_("Scanning merged commits"),

ctx->commits.nr);

current_graph_number--;

if (ctx->report_progress)

merge_commit_graph(ctx, g);

stop_progress(&ctx->progress);

if (!(flags & COMMIT_GRAPH_VERIFY_SHALLOW))

total += g->num_commits_in_base;

total);

}

#define USE_THE_REPOSITORY_VARIABLE

#include "git-compat-util.h"

#include "commit.h"

static int queue_has_nonstale(struct prio_queue *queue)

{

struct commit *commit = queue->array[i].data;

if (!(commit->object.flags & STALE))

return 1;

}

static int remove_redundant_no_gen(struct repository *r,

{

struct commit **work;

unsigned char *redundant;

CALLOC_ARRAY(work, cnt);

redundant = xcalloc(cnt, 1);

for (i = filled = 0; i < cnt; i++)

if (!redundant[i])

array[filled++] = work[i];

free(work);

free(redundant);

free(filled_index);

}

static int remove_redundant_with_gen(struct repository *r,

{

timestamp_t min_generation = GENERATION_NUMBER_INFINITY;

struct commit **walk_start, **sorted;

size_t walk_start_nr = 0, walk_start_alloc = cnt;

/*

* Sort the input by generation number, ascending. This allows

* terminate early. Otherwise, we will do the same amount of work

* as before.

*/

/* push the STALE bits up to min generation */

struct commit_list *stack = NULL;

while (stack) {

struct commit_list *parents;

clear_commit_marks_many(walk_start_nr, walk_start, STALE);

free(walk_start);

}

{

/*

* Some commit in the array may be an ancestor of

* that number.

*/

if (generation_numbers_enabled(r)) {

/*

* If we have a single commit with finite generation

* number, then the _with_gen algorithm is preferred.

*/

if (commit_graph_generation(array[i]) < GENERATION_NUMBER_INFINITY)

}

}

}

static int get_merge_bases_many_0(struct repository *r,

struct commit *one,

struct commit **twos,

int cleanup,

struct commit_list **result)

{

struct commit_list *list;

struct commit **rslt;

if (merge_bases_many(r, one, n, twos, result) < 0)

return -1;

clear_commit_marks(one, all_flags);

clear_commit_marks_many(n, twos, all_flags);

free(rslt);

return -1;

}

int repo_get_merge_bases_many(struct repository *r,

struct commit *one,

struct commit **twos,

struct commit_list **result)

{

int repo_get_merge_bases_many_dirty(struct repository *r,

struct commit *one,

struct commit **twos,

struct commit_list **result)

{

struct commit_list *p;

struct commit_list *result = NULL, **tail = &result;

struct commit **array;

if (!heads)

return NULL;

p->item->object.flags &= ~STALE;

}

}

free(array);

return NULL;

}

for (i = 0; i < num_head; i++)

tail = &commit_list_insert(array[i], tail)->next;

free(array);

int can_all_from_reach_with_flag(struct object_array *from,

unsigned int with_flag,

unsigned int assign_flag,

timestamp_t min_generation)

{

struct commit **list = NULL;

int result = 1;

ALLOC_ARRAY(list, from->nr);

int cutoff_by_min_date)

{

struct object_array from_objs = OBJECT_ARRAY_INIT;

struct commit_list *from_iter = from, *to_iter = to;

int result;

timestamp_t min_generation = GENERATION_NUMBER_INFINITY;

while (from_iter) {

return result;

}

unsigned int reachable_flag)

{

struct commit **item;

struct commit *rev2,

struct commit_list **result);

int repo_get_merge_bases_many(struct repository *r,

struct commit **twos,

struct commit_list **result);

/* To be used only when object flags after this call no longer matter */

int repo_get_merge_bases_many_dirty(struct repository *r,

struct commit **twos,

struct commit_list **result);

int can_all_from_reach_with_flag(struct object_array *from,

unsigned int with_flag,

unsigned int assign_flag,

timestamp_t min_generation);

int can_all_from_reach(struct commit_list *from, struct commit_list *to,

int commit_date_cutoff);

* This method uses the PARENT1 and PARENT2 flags during its operation,

* so be sure these flags are not set before calling the method.

*/

unsigned int reachable_flag);

struct ahead_behind_count {

}

}

{

struct commit_list *list = NULL;

clear_commit_marks_1(&list, *commit, mark);

commit++;

}

struct commit *pop_commit(struct commit_list **stack);

void clear_commit_marks(struct commit *commit, unsigned int mark);

enum rev_sort_order {

__git_config_vars_all="$(git --no-pager help --config)"

}

__git_compute_first_level_config_vars_for_section ()

{

local section="$1"

__git_compute_config_vars

local this_section="__git_first_level_config_vars_for_section_${section}"

printf -v "__git_first_level_config_vars_for_section_${section}" %s \

"$(echo "$__git_config_vars" | awk -F. "/^${section}\.[a-z]/ { print \$2 }")"

}

local section="$1"

__git_compute_config_vars_all

local this_section="__git_second_level_config_vars_for_section_${section}"

printf -v "__git_second_level_config_vars_for_section_${section}" %s \

"$(echo "$__git_config_vars_all" | awk -F. "/^${section}\.</ { print \$3 }")"

}

local section="${pfx%.*.}"

__git_compute_second_level_config_vars_for_section "${section}"

local this_section="__git_second_level_config_vars_for_section_${section}"

return

;;

branch.*)

__gitcomp_direct "$(__git_heads "$pfx" "$cur_" ".")"

__git_compute_first_level_config_vars_for_section "${section}"

local this_section="__git_first_level_config_vars_for_section_${section}"

return

;;

pager.*)

__gitcomp_nl "$(__git_remotes)" "$pfx" "$cur_" "."

__git_compute_first_level_config_vars_for_section "${section}"

local this_section="__git_first_level_config_vars_for_section_${section}"

return

;;

submodule.*)

__gitcomp_nl "$(__git config -f "$(__git rev-parse --show-toplevel)/.gitmodules" --get-regexp 'submodule.*.path' | awk -F. '{print $2}')" "$pfx" "$cur_" "."

__git_compute_first_level_config_vars_for_section "${section}"

local this_section="__git_first_level_config_vars_for_section_${section}"

return

;;

*.*)

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

return matches;

}

{

char *normalized_url;

struct urlmatch_config config = URLMATCH_CONFIG_INIT;

credential_format(c, &url);

normalized_url = url_normalize(url.buf, &config.url);

string_list_clear(&config.vars, 1);

free(normalized_url);

urlmatch_config_release(&config);

return xstrdup(r);

}

{

int interactive;

char *value;

!interactive) {

"interactive/skipped", 1);

return -1;

}

int same = !strcmp(value, "never");

free(value);

if (same) {

"interactive/skipped", 1);

return -1;

}

}

if (!c->username)

c->username = credential_ask_one("Username", c,

PROMPT_ASKPASS|PROMPT_ECHO);

if (!c->password)

c->password = credential_ask_one("Password", c,

PROMPT_ASKPASS);

return 0;

}

return r;

}

{

int i;

credential_next_state(c);

c->multistage = 0;

if (all_capabilities)

credential_set_all_capabilities(c, CREDENTIAL_OP_INITIAL);

c->helpers.items[i].string);

}

(!c->username && !c->password && !c->credential))

die("unable to get password from user");

}

{

int i;

credential_next_state(c);

for (i = 0; i < c->helpers.nr; i++)

credential_do(c, c->helpers.items[i].string, "store");

c->approved = 1;

}

{

int i;

credential_next_state(c);

for (i = 0; i < c->helpers.nr; i++)

credential_do(c, c->helpers.items[i].string, "erase");

#include "string-list.h"

#include "strvec.h"

/**

* The credentials API provides an abstracted way of gathering

* authentication credentials from the user.

* // Fill in the username and password fields by contacting

* // helpers and/or asking the user. The function will die if it

* // fails.

*

* // Otherwise, we have a username and password. Try to use it.

*

* If all_capabilities is set, this is an internal user that is prepared

* to deal with all known capabilities, and we should advertise that fact.

*/

/**

* Inform the credential subsystem that the provided credentials

* that they may store the result to be used again. Any errors

* from helpers are ignored.

*/

/**

* Inform the credential subsystem that the provided credentials

* for another call to `credential_fill`). Any errors from helpers

* are ignored.

*/

/**

* Enable all of the supported credential flags in this credential.

QSORT(todo, nr, tree_depth_compare);

if (progress)

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

struct object_entry *ent = todo[i].entry;

#include "git-compat-util.h"

#include "diagnose.h"

#include "compat/disk.h"

#include "object-store-ll.h"

#include "packfile.h"

#include "parse-options.h"

#include "write-or-die.h"

struct archive_dir {

return res;

}

{

struct strvec archiver_args = STRVEC_INIT;

char **argv_copy = NULL;

strbuf_addstr(&buf, "Collecting diagnostic info\n\n");

get_version_info(&buf, 1);

get_disk_info(&buf);

write_or_die(stdout_fd, buf.buf, buf.len);

strvec_pushf(&archiver_args,

strbuf_reset(&buf);

strbuf_addstr(&buf, "--add-virtual-file=packs-local.txt:");

foreach_alt_odb(dir_file_stats, &buf);

strvec_push(&archiver_args, buf.buf);

}

strvec_pushl(&archiver_args, "--prefix=",

/* `write_archive()` modifies the `argv` passed to it. Let it. */

argv_copy = xmemdupz(archiver_args.v,

sizeof(char *) * archiver_args.nr);

res = write_archive(archiver_args.nr, (const char **)argv_copy, NULL,

if (res) {

error(_("failed to write archive"));

goto diagnose_cleanup;

#include "strbuf.h"

struct option;

enum diagnose_mode {

DIAGNOSE_NONE,

int option_parse_diagnose(const struct option *opt, const char *arg, int unset);

#endif /* DIAGNOSE_H */

* --exit-code" in hooks and other scripts, we do not do so.

*/

if (!opt->flags.exit_with_status &&

}

trace2_region_enter("diff", "inexact renames", options->repo);

if (options->show_rename_progress) {

progress = start_delayed_progress(

_("Performing inexact rename detection"),

(uint64_t)num_destinations * (uint64_t)num_sources);

}

dco->state = CE_RETRY;

if (show_progress)

while (dco->filters.nr > 0) {

for_each_string_list_item(filter, &dco->filters) {

struct string_list available_paths = STRING_LIST_INIT_DUP;

char *path ;

if (git_config_pathname(&path, var, value))

strbuf_addf(msg_types, "%cskiplist=%s",

msg_types->len ? ',' : '=', path);

free(path);

struct strbuf sb = STRBUF_INIT;

if (git_config_pathname(&path, var, value))

strbuf_addf(&sb, "skiplist=%s", path);

free(path);

fsck_set_msg_types(options, sb.buf);

void warning(const char *err, ...) __attribute__((format (printf, 1, 2)));

void warning_errno(const char *err, ...) __attribute__((format (printf, 1, 2)));

#ifndef NO_OPENSSL

#ifdef APPLE_COMMON_CRYPTO

#include "compat/apple-common-crypto.h"

return result

if "$local" == "true":

# Set our http root directory

# This is a work around for a missing directory argument in older Python versions

require_init=

files=

remote=

rebase=

merge=

checkout=

depth=

progress=

dissociate=

jobs=

recommend_shallow=

filter=

#

# Add a new submodule to the working tree, .gitmodules and the index

cmd_add()

{

# parse $args after "submodule ... add".

while test $# -ne 0

do

case "$1" in

-b | --branch)

case "$2" in '') usage ;; esac

shift

;;

-f | --force)

force=$1

;;

-q|--quiet)

;;

--progress)

;;

--reference)

case "$2" in '') usage ;; esac

shift

;;

--reference=*)

;;

--ref-format)

case "$2" in '') usage ;; esac

ref_format="$1"

;;

--dissociate)

;;

--name)

case "$2" in '') usage ;; esac

shift

;;

--depth)

case "$2" in '') usage ;; esac

depth="--depth=$2"

shift

;;

--depth=*)

;;

--)

shift

fi

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper add \

${ref_format:+"$ref_format"} \

${depth:+"$depth"} \

-- \

"$@"

do

case "$1" in

-q|--quiet)

;;

--recursive)

;;

-*)

usage

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper foreach \

-- \

"$@"

}

do

case "$1" in

-q|--quiet)

;;

--)

shift

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper init \

-- \

"$@"

}

cmd_deinit()

{

# parse $args after "submodule ... deinit".

while test $# -ne 0

do

case "$1" in

force=$1

;;

-q|--quiet)

;;

--all)

;;

--)

shift

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper deinit \

-- \

"$@"

}

do

case "$1" in

-q|--quiet)

;;

-v|--verbose)

;;

--progress)

;;

-i|--init)

;;

--require-init)

;;

--remote)

;;

-N|--no-fetch)

;;

-f|--force)

force=$1

;;

-r|--rebase)

;;

--ref-format)

case "$2" in '') usage ;; esac

reference="$1"

;;

--dissociate)

;;

-m|--merge)

;;

--recursive)

;;

--checkout)

;;

;;

--depth)

case "$2" in '') usage ;; esac

shift

;;

--depth=*)

;;

-j|--jobs)

case "$2" in '') usage ;; esac

jobs="--jobs=$2"

shift

;;

;;

;;

--filter)

case "$2" in '') usage ;; esac

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper update \

${ref_format:+"$ref_format"} \

${reference:+"$reference"} \

${depth:+"$depth"} \

$single_branch \

$recommend_shallow \

$jobs \

# $@ = requested path

#

cmd_set_branch() {

while test $# -ne 0

do

case "$1" in

# we don't do anything with this but we need to accept it

;;

-d|--default)

;;

-b|--branch)

case "$2" in '') usage ;; esac

shift

;;

--)

shift

break

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper set-branch \

-- \

"$@"

}

# $@ = requested path, requested url

#

cmd_set_url() {

while test $# -ne 0

do

case "$1" in

-q|--quiet)

;;

--)

shift

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper set-url \

-- \

"$@"

}

# $@ = [commit (default 'HEAD'),] requested paths (default all)

#

cmd_summary() {

# parse $args after "submodule ... summary".

while test $# -ne 0

do

case "$1" in

--cached)

;;

--files)

;;

--for-status)

;;

-n|--summary-limit)

shift

;;

;;

--)

shift

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper summary \

-- \

"$@"

}

do

case "$1" in

-q|--quiet)

;;

--cached)

;;

--recursive)

;;

--)

shift

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper status \

-- \

"$@"

}

#

cmd_sync()

{

while test $# -ne 0

do

case "$1" in

-q|--quiet)

shift

;;

--recursive)

shift

;;

--)

done

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper sync \

-- \

"$@"

}

command=$1

;;

-q|--quiet)

;;

--cached)

;;

--)

break

setenv("GIT_PAGER", "cat", 1);

break;

case 1:

break;

default:

break;

{

if (use_pager != -1 || pager_in_use())

return;

if (use_pager == -1)

use_pager = def;

commit_pager_choice();

precompose_argv_prefix(argc, argv, NULL);

if (use_pager == -1 && run_setup &&

!(p->option & DELAY_PAGER_CONFIG))

if (use_pager == -1 && p->option & USE_PAGER)

use_pager = 1;

if (run_setup && startup_info->have_repository)

/* get_git_dir() may set up repo, avoid that */

commit_pager_choice();

if (!help && p->option & NEED_WORK_TREE)

int status;

if (use_pager == -1 && !is_builtin(argv[0]))

commit_pager_choice();

strvec_pushf(&cmd.args, "git-%s", argv[0]);

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

if (!column_colors) {

char *string;

/* not configured -- use default */

graph_set_column_colors(column_colors_ansi,

column_colors_ansi_max);

}

}

if (http_auth.password) {

if (always_auth_proactively()) {

{

if (proxy_auth.username) {

if (!proxy_auth.password && !proxy_auth.credential)

set_proxyauth_name_password(result);

}

cert_auth.host = xstrdup("");

cert_auth.username = xstrdup("");

cert_auth.path = xstrdup(ssl_cert);

}

return 1;

}

proxy_cert_auth.host = xstrdup("");

proxy_cert_auth.username = xstrdup("");

proxy_cert_auth.path = xstrdup(http_proxy_ssl_cert);

}

return 1;

}

curl_errorstr, sizeof(curl_errorstr));

if (results->curl_result == CURLE_OK) {

return HTTP_OK;

} else if (results->curl_result == CURLE_SSL_CERTPROBLEM) {

/*

* with the certificate. So we reject the credential to

* avoid caching or saving a bad password.

*/

return HTTP_NOAUTH;

} else if (results->curl_result == CURLE_SSL_PINNEDPUBKEYNOTMATCH) {

return HTTP_NOMATCHPUBLICKEY;

credential_clear_secrets(&http_auth);

return HTTP_REAUTH;

}

if (always_auth_proactively())

http_proactive_auth = PROACTIVE_AUTH_NONE;

return HTTP_NOAUTH;

}

} else {

if (results->http_connectcode == 407)

if (!curl_errorstr[0])

strlcpy(curl_errorstr,

curl_easy_strerror(results->curl_result),

int ret;

if (always_auth_proactively())

ret = http_request(url, result, target, options);

BUG("Unknown http_request target");

}

ret = http_request(url, result, target, options);

}

cred->username = xstrdup_or_null(srvc->user);

cred->password = xstrdup_or_null(srvc->pass);

if (!srvc->user)

srvc->user = xstrdup(cred->username);

} /* !preauth */

if (cred.username)

credential_clear(&cred);

/* check the target mailbox exists */

bail:

if (cred.username)

credential_clear(&cred);

out:

if (cred.username) {

if (res == CURLE_OK)

else if (res == CURLE_LOGIN_DENIED)

}

credential_clear(&cred);

* into the alternative object store list as the primary.

*/

if (opt->remerge_diff && !opt->remerge_objdir) {

if (!opt->remerge_objdir)

return error(_("unable to create temporary object directory"));

tmp_objdir_replace_primary_odb(opt->remerge_objdir, 1);

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

return 0;

}

{

memset(mi, 0, sizeof(*mi));

strbuf_init(&mi->name, 0);

mi->header_stage = 1;

mi->use_inbody_headers = 1;

mi->content_top = mi->content;

}

void clear_mailinfo(struct mailinfo *mi)

#define MAX_BOUNDARIES 5

enum quoted_cr_action {

quoted_cr_unset = -1,

quoted_cr_nowarn,

};

int mailinfo_parse_quoted_cr_action(const char *actionstr, int *action);

int mailinfo(struct mailinfo *, const char *msg, const char *patch);

void clear_mailinfo(struct mailinfo *);

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

#include "tree.h"

#include "tree-walk.h"

#include "object-store-ll.h"

static int score_missing(unsigned mode)

{

return score;

}

const struct object_id *hash)

{

void *buffer;

enum object_type type;

unsigned long size;

if (!buffer)

die("unable to read tree (%s)", oid_to_hex(hash));

if (type != OBJ_TREE)

/*

* Inspect two trees, and give a score that tells how similar they are.

*/

{

struct tree_desc one;

struct tree_desc two;

int score = 0;

for (;;) {

/*

* Match one itself and its subtrees with two and pick the best match.

*/

const struct object_id *hash2,

int *best_score,

char **best_match,

int recurse_limit)

{

struct tree_desc one;

while (one.size) {

const char *path;

elem = tree_entry_extract(&one, &path, &mode);

if (!S_ISDIR(mode))

goto next;

if (*best_score < score) {

free(*best_match);

*best_match = xstrfmt("%s%s", base, path);

}

if (recurse_limit) {

char *newbase = xstrfmt("%s%s/", base, path);

newbase, recurse_limit - 1);

free(newbase);

}

* A tree "oid1" has a subdirectory at "prefix". Come up with a tree object by

* replacing it with another tree "oid2".

*/

const struct object_id *oid2, struct object_id *result)

{

char *subpath;

if (*subpath)

subpath++;

if (!buf)

die("cannot read tree %s", oid_to_hex(oid1));

init_tree_desc(&desc, oid1, buf, sz);

oid_to_hex(oid1));

if (*subpath) {

struct object_id tree_oid;

if (status)

return status;

rewrite_with = &subtree;

} else {

rewrite_with = oid2;

}

status = write_object_file(buf, sz, OBJ_TREE, result);

free(buf);

return status;

if (!depth_limit)

depth_limit = 2;

add_prefix = xcalloc(1, 1);

del_prefix = xcalloc(1, 1);

* See if one's subtree resembles two; if so we need to prefix

* two with a few fake trees to match the prefix.

*/

/*

* See if two's subtree resembles one; if so we need to

* pick only subtree of two.

*/

/* Assume we do not have to do any shifting */

oidcpy(shifted, hash2);

if (!*add_prefix)

goto out;

out:

free(add_prefix);

if (candidate == 3) {

/* Both are plausible -- we need to evaluate the score */

int score;

candidate = 0;

if (score > best_score) {

candidate = 1;

best_score = score;

}

if (score > best_score)

candidate = 2;

}

* shift tree2 down by adding shift_prefix above it

* to match tree1.

*/

else

/*

* shift tree2 up by removing shift_prefix from it

endif

https_backend = get_option('https_backend')

core_foundation_framework = dependency('CoreFoundation', required: security_framework.found())

if https_backend == 'auto' and security_framework.found()

https_backend = 'CommonCrypto'

endif

openssl = dependency('openssl', required: openssl_required, default_options: ['default_library=static'])

if https_backend == 'auto' and openssl.found()

https_backend = 'openssl'

libgit_c_args += '-DNO_OPENSSL'

endif

if sha1_backend == 'sha1dc'

libgit_c_args += '-DSHA1_DC'

libgit_c_args += '-DSHA1DC_NO_STANDARD_INCLUDES=1'

'sha1dc/sha1.c',

'sha1dc/ubc_check.c',

]

libgit_c_args += '-DCOMMON_DIGEST_FOR_OPENSSL'

# Apple CommonCrypto requires chunking

libgit_c_args += '-DSHA1_MAX_BLOCK_SIZE=1024L*1024L*1024L'

libgit_dependencies += openssl

libgit_sources += 'block-sha1/sha1.c'

endif

if sha256_backend == 'openssl'

libgit_c_args += '-DSHA256_OPENSSL'

libgit_dependencies += openssl

'version.c',

version_def_h,

],

dependencies: libgit_dependencies,

include_directories: libgit_include_directories,

)

'perl': perl_features_enabled,

'python': python.found(),

}, section: 'Auto-detected features')

# Backends.

option('https_backend', type: 'combo', value: 'auto', choices: ['auto', 'openssl', 'CommonCrypto', 'none'],

description: 'The HTTPS backend to use when connecting to remotes.')

option('sha256_backend', type: 'combo', choices: ['openssl', 'nettle', 'gcrypt', 'block'], value: 'block',

# Build tweaks.

option('macos_use_homebrew_gettext', type: 'boolean', value: true,

ctx.pack_paths_checked = 0;

if (flags & MIDX_PROGRESS)

else

ctx.progress = NULL;

CALLOC_ARRAY(count, m->num_packs);

if (flags & MIDX_PROGRESS)

m->num_objects);

for (i = 0; i < m->num_objects; i++) {

int pack_int_id = nth_midxed_pack_int_id(m, i);

stop_progress(&progress);

if (flags & MIDX_PROGRESS)

m->num_packs);

for (i = 0; i < m->num_packs; i++) {

char *pack_name;

midx_report(_("incorrect checksum"));

if (flags & MIDX_PROGRESS)

m->num_packs + m->num_packs_in_base);

for (i = 0; i < m->num_packs + m->num_packs_in_base; i++) {

if (prepare_midx_pack(r, m, i))

}

if (flags & MIDX_PROGRESS)

m->num_objects - 1);

for (curr = m; curr; curr = curr->base_midx) {

}

if (flags & MIDX_PROGRESS)

m->num_objects);

display_progress(progress, 0); /* TODO: Measure QSORT() progress */

QSORT(pairs, m->num_objects, compare_pair_pos_vs_id);

stop_progress(&progress);

if (flags & MIDX_PROGRESS)

for (i = 0; i < m->num_objects + m->num_objects_in_base; i++) {

struct object_id oid;

struct pack_entry e;

hash_object_body(algo, &c, buf, len, oid, hdr, hdrlen);

}

{

int ret = 0;

goto out;

}

goto out;

}

while (1) {

ssize_t sz_a, sz_b;

if (sz_a < 0) {

goto out;

}

if (sz_b < 0) {

goto out;

}

ret = error(_("files '%s' and '%s' differ in contents"),

goto out;

}

break;

}

out:

return ret;

}

int finalize_object_file_flags(const char *tmpfile, const char *filename,

enum finalize_object_file_flags flags)

{

if (object_creation_mode == OBJECT_CREATION_USES_RENAMES)

goto try_rename;

* left to unlink.

*/

if (ret && ret != EEXIST) {

try_rename:

if (!stat(filename, &st))

ret = EEXIST;

errno = saved_errno;

return error_errno(_("unable to write file %s"), filename);

}

return -1;

unlink_or_warn(tmpfile);

}

return 0;

}

static int get_describe_name(struct repository *r,

const char *name, int len,

struct object_id *oid)

/* We must be looking at g in "SOMETHING-g"

* for it to be describe output.

*/

cp++;

len -= cp - name;

return get_short_oid(r,

return -1;

}

for (cp = name, bracket_depth = 0; *cp; cp++) {

bracket_depth++;

bracket_depth--;

break;

}

if (*cp == ':') {

struct object_id tree_oid;

res = parse_attr_line(buf, "dummy", 0, 0);

if (res) {

for (j = 0; j < res->num_attr; j++) {

const char *setto = res->state[j].setto;

if (ATTR_TRUE(setto) || ATTR_FALSE(setto) ||

int closed = 1; /* until proven otherwise */

if (writer->show_progress)

writer->selected_nr);

trace2_region_enter("pack-bitmap-write", "building_bitmaps_total",

the_repository);

}

if (writer->show_progress)

for (;;) {

struct commit *chosen = NULL;

tdata.trees = ewah_to_bitmap(bitmap_git->trees);

tdata.blobs = ewah_to_bitmap(bitmap_git->blobs);

tdata.tags = ewah_to_bitmap(bitmap_git->tags);

tdata.seen = 0;

traverse_commit_list(revs, &test_show_commit, &test_show_object, &tdata);

#include "git-compat-util.h"

#include "config.h"

#include "editor.h"

return 0;

}

{

const char *pager;

pager = getenv("GIT_PAGER");

if (!pager) {

if (!pager_program)

core_pager_config, NULL);

pager = pager_program;

}

pager_process->trace2_child_class = "pager";

}

{

static int once = 0;

if (!pager)

return;

}

/* returns 0 for "no pager", 1 for "use pager", and -1 for "not specified" */

{

struct pager_command_config_data data;

data.want = -1;

data.value = NULL;

if (data.value)

pager_program = data.value;

#define PAGER_H

struct child_process;

void wait_for_pager(void);

int pager_in_use(void);

int term_columns(void);

void term_clear_line(void);

int decimal_width(uintmax_t);

void prepare_pager_args(struct child_process *, const char *pager);

extern int pager_use_color;

!opts->argh || !!strpbrk(opts->argh, "()<>[]|");

if (opts->flags & PARSE_OPT_OPTARG)

if (opts->long_name)

else

else

return utf8_fprintf(outfile, s, opts->argh ? _(opts->argh) : _("..."));

}

exit(129);

}

void NORETURN usage_msg_opt(const char *msg,

const char * const *usagestr,

const struct option *options)

NORETURN void usage_with_options(const char * const *usagestr,

const struct option *options);

NORETURN void usage_msg_opt(const char *msg,

const char * const *usagestr,

const struct option *options);

memset(&pd, 0, sizeof(pd));

if (refresh_flags & REFRESH_PROGRESS && isatty(2)) {

pthread_mutex_init(&pd.mutex, NULL);

}

typedef int (*prio_queue_compare_fn)(const void *one, const void *two, void *cb_data);

struct prio_queue_entry {

void *data;

};

struct prio_queue {

prio_queue_compare_fn compare;

void *cb_data;

size_t alloc, nr;

struct prio_queue_entry *array;

*/

#define GIT_TEST_PROGRESS_ONLY

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

};

struct progress {

const char *title;

uint64_t last_value;

uint64_t total;

display(progress, n, NULL);

}

unsigned delay, unsigned sparse)

{

struct progress *progress = xmalloc(sizeof(*progress));

progress->title = title;

progress->total = total;

progress->last_value = -1;

progress->title_len = utf8_strwidth(title);

progress->split = 0;

set_progress_signal();

return progress;

}

return delay_in_secs;

}

{

}

{

}

/*

* When "sparse" is set, stop_progress() will automatically force the done

* message to show 100%.

*/

{

}

uint64_t total)

{

}

static void finish_if_sparse(struct progress *progress)

static void log_trace2(struct progress *progress)

{

progress->total);

if (progress->throughput)

progress->throughput->curr_total);

}

void stop_progress_msg(struct progress **p_progress, const char *msg)

#include "gettext.h"

struct progress;

#ifdef GIT_TEST_PROGRESS_ONLY

void display_throughput(struct progress *progress, uint64_t total);

void display_progress(struct progress *progress, uint64_t n);

uint64_t total);

void stop_progress_msg(struct progress **p_progress, const char *msg);

static inline void stop_progress(struct progress **p_progress)

void prune_packed_objects(int opts)

{

if (opts & PRUNE_PACKED_VERBOSE)

for_each_loose_file_in_objdir(repo_get_object_directory(the_repository),

prune_object, NULL, prune_subdir, &opts);

return;

if (writer->show_progress)

writer->pseudo_merge_groups.nr);

refs_for_each_ref(get_main_ref_store(the_repository),

int t2_sum_scan = 0;

if (flags & REFRESH_PROGRESS && isatty(2))

istate->cache_nr);

trace_performance_enter();

istate->cache_tree = cache_tree_read(data, sz);

break;

case CACHE_EXT_RESOLVE_UNDO:

break;

case CACHE_EXT_LINK:

if (read_link_extension(istate, data, sz))

istate->resolve_undo) {

strbuf_reset(&sb);

err = write_index_ext_header(f, eoie_c, CACHE_EXT_RESOLVE_UNDO,

sb.len) < 0;

hashwrite(f, sb.buf, sb.len);

struct commit_list **check_reachable,

int include_reached)

{

struct commit **to_clear;

if (!*check_reachable)

close(fd);

fd = -1;

sleep_millisec(delay);

}

static int format_name(struct reftable_buf *dest, uint64_t min, uint64_t max)

{

char buf[100];

snprintf(buf, sizeof(buf), "0x%012" PRIx64 "-0x%012" PRIx64 "-%08x",

min, max, rnd);

reftable_buf_reset(dest);

do {

err = probe_rpc(rpc, &results);

if (err == HTTP_REAUTH)

} while (err == HTTP_REAUTH);

if (err != HTTP_OK)

return -1;

rpc->any_written = 0;

err = run_slot(slot, NULL);

if (err == HTTP_REAUTH && !large_request) {

curl_slist_free_all(headers);

goto retry;

}

struct tips {

struct commit **tip;

};

static void add_to_tips(struct tips *tips, const struct object_id *oid)

const int reachable_flag = 1;

struct commit_list *found_commits;

struct commit **src_commits;

ALLOC_ARRAY(src_commits, alloc_src_commits);

for_each_string_list_item(item, &src_tag) {

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

ui->mode[stage - 1] = ce->ce_mode;

}

{

struct string_list_item *item;

for_each_string_list_item(item, resolve_undo) {

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

if (!ui->mode[i])

continue;

}

}

}

{

struct string_list *resolve_undo;

size_t len;

char *endptr;

int i;

CALLOC_ARRAY(resolve_undo, 1);

resolve_undo->strdup_strings = 1;

continue;

if (size < rawsz)

goto error;

size -= rawsz;

data += rawsz;

}

};

void record_resolve_undo(struct index_state *, struct cache_entry *);

void resolve_undo_clear_index(struct index_state *);

int unmerge_index_entry(struct index_state *, const char *, struct resolve_undo_info *, unsigned);

void unmerge_index(struct index_state *, const struct pathspec *, unsigned);

#include "git-compat-util.h"

#include "config.h"

#include "commit.h"

die("bad %s argument: %s", opt->long_name, arg);

}

{

if (negative &&

OBJECT_INFO_SKIP_FETCH_OBJECT |

OBJECT_INFO_QUICK))

return;

/*

* Make a pack stream and spit it out into file descriptor fd

*/

struct oid_array *negotiated,

struct send_pack_args *args)

{

FILE *po_in;

int rc;

strvec_push(&po.args, "pack-objects");

strvec_push(&po.args, "--all-progress-implied");

strvec_push(&po.args, "--revs");

strvec_push(&po.args, "-q");

if (args->progress)

strvec_push(&po.args, "--progress");

strvec_push(&po.args, "--shallow");

if (args->disable_bitmaps)

strvec_push(&po.args, "--no-use-bitmap-index");

*/

po_in = xfdopen(po.in, "w");

for (size_t i = 0; i < advertised->nr; i++)

for (size_t i = 0; i < negotiated->nr; i++)

while (refs) {

if (!is_null_oid(&refs->old_oid))

if (!is_null_oid(&refs->new_oid))

refs = refs->next;

}

*/

if (rc > 128 && rc != 141)

error("pack-objects died of signal %d", rc - 128);

return -1;

}

return 0;

}

return 0;

}

{

struct ref *hint;

int ret;

int new_report = 0;

int once = 0;

hint = NULL;

ret = receive_unpack_status(reader);

while (1) {

if (!strcmp(key, "refname"))

report->ref_name = xstrdup_or_null(val);

else if (!strcmp(key, "old-oid") && val &&

report->old_oid = oiddup(&old_oid);

else if (!strcmp(key, "new-oid") && val &&

report->new_oid = oiddup(&new_oid);

else if (!strcmp(key, "forced-update"))

report->forced_update = 1;

new_report = 1;

}

}

return ret;

}

return 0;

}

{

return;

for_each_commit_graft(advertise_shallow_grafts_cb, sb);

}

}

}

const struct ref *remote_refs,

struct oid_array *commons)

{

struct child_process child = CHILD_PROCESS_INIT;

const struct ref *ref;

int nr_negotiation_tip = 0;

child.git_cmd = 1;

break;

if (read_len != len)

die("invalid length read %d", read_len);

die("invalid hash");

oid_array_append(commons, &oid);

} while (1);

}

}

int fd[], struct child_process *conn,

struct ref *remote_refs,

struct oid_array *extra_have)

goto out;

}

if (push_negotiate) {

}

args->disable_bitmaps = !use_bitmaps;

/* Does the other end support the reporting? */

if (server_supports("report-status-v2"))

if (server_supports("push-options"))

push_options_supported = 1;

die(_("the receiving end does not support this repository's hash algorithm"));

if (args->push_cert != SEND_PACK_PUSH_CERT_NEVER) {

if (use_push_options)

strbuf_addstr(&cap_buf, " push-options");

if (object_format_supported)

if (agent_supported)

strbuf_addf(&cap_buf, " agent=%s", git_user_agent_sanitized());

if (advertise_sid)

}

if (!args->dry_run)

/*

* Finally, tell the other end!

}

if (args->stateless_rpc) {

packet_buf_flush(&req_buf);

send_sideband(out, -1, req_buf.buf, req_buf.len, LARGE_PACKET_MAX);

}

PACKET_READ_DIE_ON_ERR_PACKET);

if (need_pack_data && cmds_sent) {

if (args->stateless_rpc)

close(out);

if (git_connection_is_socket(conn))

* we get one).

*/

if (status_report)

if (use_sideband) {

close(demux.out);

packet_flush(out);

if (status_report && cmds_sent)

else

ret = 0;

if (args->stateless_rpc)

struct child_process;

struct oid_array;

struct ref;

/* Possible values for push_cert field in send_pack_args. */

#define SEND_PACK_PUSH_CERT_NEVER 0

int option_parse_push_signed(const struct option *opt,

const char *arg, int unset);

int fd[], struct child_process *conn,

struct ref *remote_refs, struct oid_array *extra_have);

#include "git-compat-util.h"

#include "repository.h"

#include "config.h"

},

};

{

struct strbuf capability = STRBUF_INIT;

struct strbuf value = STRBUF_INIT;

for (size_t i = 0; i < ARRAY_SIZE(capabilities); i++) {

struct protocol_capability *c = &capabilities[i];

strbuf_addstr(&capability, c->name);

if (value.len) {

return NULL;

}

{

const char *value;

const struct protocol_capability *c = get_capability(key, &value);

return 0;

if (c->receive)

return 1;

}

{

const char *out;

if (*command)

die("command '%s' requested after already requesting command '%s'",

out, (*command)->name);

die("invalid command '%s'", out);

*command = cmd;

PROCESS_REQUEST_DONE,

};

{

enum request_state state = PROCESS_REQUEST_KEYS;

struct packet_reader reader;

case PACKET_READ_EOF:

BUG("Should have already died when seeing EOF");

case PACKET_READ_NORMAL:

seen_capability_or_command = 1;

else

die("unknown capability '%s'", reader.line);

if (!command)

die("no command requested");

die("mismatched object format: server %s; client %s",

hash_algos[client_hash_algo].name);

return 0;

}

{

if (!stateless_rpc)

/*

* If stateless-rpc was requested then exit after

* a single request/response exchange

*/

if (stateless_rpc) {

} else {

for (;;)

break;

}

}

#ifndef SERVE_H

#define SERVE_H

#endif /* SERVE_H */

#define DISABLE_SIGN_COMPARE_WARNINGS

#include "git-compat-util.h"

#include "tempfile.h"

struct update_info_ctx {

FILE *cur_fp;

FILE *old_fp; /* becomes NULL if it differs from cur_fp */

struct strbuf cur_sb;

* it into place. The contents of the file come from "generate", which

* should return non-zero if it encounters an error.

*/

int (*generate)(struct update_info_ctx *),

int force)

{

struct tempfile *f = NULL;

int ret = -1;

struct update_info_ctx uic = {

.cur_fp = NULL,

.old_fp = NULL,

.cur_sb = STRBUF_INIT,

void *cb_data)

{

struct update_info_ctx *uic = cb_data;

if (!o)

return -1;

return -1;

if (o->type == OBJ_TAG) {

if (o)

if (uic_printf(uic, "%s %s^{}\n",

oid_to_hex(&o->oid), path) < 0)

static int generate_info_refs(struct update_info_ctx *uic)

{

add_info_ref, uic);

}

{

free(path);

return ret;

}

return 1;

}

{

struct packed_git *p;

int stale;

int i;

size_t alloc = 0;

/* we ignore things on alternate path since they are

* not available to the pullers in general.

*/

return 0;

}

{

char *infofile = mkpathdup("%s/info/packs",

int ret;

free_pack_info();

free(infofile);

return ret;

}

/* public */

{

/* We would add more dumb-server support files later,

* including index of available pack files and their

* intended audiences.

*/

int errs = 0;

/* remove leftover rev-cache file if there is any */

return errs;

}

#ifndef SERVER_INFO_H

#define SERVER_INFO_H

/* Dumb servers support */

#endif /* SERVER_INFO_H */

#define USE_THE_REPOSITORY_VARIABLE

#include "git-compat-util.h"

#include "hex.h"

struct commit_list *get_shallow_commits(struct object_array *heads, int depth,

int shallow_flag, int not_shallow_flag)

{

struct commit_list *result = NULL;

struct object_array stack = OBJECT_ARRAY_INIT;

struct commit *commit = NULL;

const struct oid_array *extra,

unsigned flags)

{

for_each_commit_graft(write_one_shallow, &data);

if (!extra)

return data.count;

strbuf_addstr(out, oid_to_hex(extra->oid + i));

strbuf_addch(out, '\n');

data.count++;

*/

void prepare_shallow_info(struct shallow_info *info, struct oid_array *sa)

{

trace_printf_key(&trace_shallow, "shallow: prepare_shallow_info\n");

memset(info, 0, sizeof(*info));

info->shallow = sa;

return;

ALLOC_ARRAY(info->ours, sa->nr);

ALLOC_ARRAY(info->theirs, sa->nr);

if (repo_has_object_file(the_repository, sa->oid + i)) {

struct commit_graft *graft;

graft = lookup_commit_graft(the_repository,

void remove_nonexistent_theirs_shallow(struct shallow_info *info)

{

struct object_id *oid = info->shallow->oid;

trace_printf_key(&trace_shallow, "shallow: remove_nonexistent_theirs_shallow\n");

for (i = dst = 0; i < info->nr_theirs; i++) {

if (i != dst)

unsigned nr = DIV_ROUND_UP(info->nr_bits, 32);

unsigned size = nr * sizeof(uint32_t);

void *p;

if (size > POOL_SIZE)

BUG("pool size too small for %d in paint_alloc()",

size);

{

unsigned int i, nr;

struct commit_list *head = NULL;

size_t bitmap_size = st_mult(sizeof(uint32_t), bitmap_nr);

struct commit *c = lookup_commit_reference_gently(the_repository, oid,

1);

struct object_id *oid = info->shallow->oid;

struct oid_array *ref = info->ref;

unsigned int i, nr;

struct paint_info pi;

trace_printf_key(&trace_shallow, "shallow: assign_shallow_commits_to_refs\n");

struct commit_array {

struct commit **commits;

};

static int add_ref(const char *refname UNUSED,

return 0;

}

{

if (!ref_status)

return;

if (bitmap[i / 32] & (1U << (i % 32)))

ref_status[i]++;

}

struct object_id *oid = info->shallow->oid;

struct commit *c;

uint32_t **bitmap;

struct commit_array ca;

trace_printf_key(&trace_shallow, "shallow: post_assign_shallow\n");

*/

struct shallow_info {

struct oid_array *shallow;

struct oid_array *ref;

/* for receive-pack */

int *reachable;

int *shallow_ref;

struct commit **commits;

};

void prepare_shallow_info(struct shallow_info *, struct oid_array *);

while (count) {

unsigned long chunk = count < sizeof(buf) ? count : sizeof(buf);

perror("failed to read");

return 5;

}

*

* See 't0500-progress-display.sh' for examples.

*/

#define GIT_TEST_PROGRESS_ONLY

#include "test-tool.h"

#include "parse-options.h"

#include "progress.h"

#include "strbuf.h"

#include "string-list.h"

else

die("invalid input: '%s'", line.buf);

} else if (skip_prefix(line.buf, "progress ", (const char **) &end)) {

uint64_t item_count = strtoull(end, &end, 10);

if (*end != '\0')

struct commit_list *X, *Y;

struct object_array X_obj = OBJECT_ARRAY_INIT;

struct commit **X_array, **Y_array;

struct strbuf buf = STRBUF_INIT;

struct repository *r = the_repository;

clear_contains_cache(&cache);

} else if (!strcmp(av[1], "get_reachable_subset")) {

const int reachable_flag = 1;

struct commit_list *current;

struct commit_list *list = get_reachable_subset(X_array, X_nr,

Y_array, Y_nr,

oid_to_hex(&list->item->object.oid));

count++;

}

if (Y_array[i]->object.flags & reachable_flag)

count--;

}

#include "test-tool.h"

#include "gettext.h"

#include "parse-options.h"

#include "serve.h"

#include "setup.h"

PARSE_OPT_KEEP_UNKNOWN_OPT);

if (advertise_capabilities)

else

return 0;

}

if (argc < 2)

usage_with_options(simple_ipc_usage, options);

if (argc == 2 && !strcmp(argv[1], "SUPPORTS_SIMPLE_IPC"))

return 0;

clar_test_suites = [

'unit-tests/u-ctype.c',

'unit-tests/u-mem-pool.c',

'unit-tests/u-prio-queue.c',

'unit-tests/u-reftable-tree.c',

unit_test_programs = [

'unit-tests/t-example-decorate.c',

'unit-tests/t-hashmap.c',

'unit-tests/t-oid-array.c',

'unit-tests/t-oidmap.c',

(

GIT_CEILING_DIRECTORIES=$(pwd) &&

export GIT_CEILING_DIRECTORIES &&

) &&

test_grep usage output

'

done <builtins

git config extensions.objectformat $test_hash_algo &&

git config extensions.compatobjectformat $test_compat_hash_algo &&

echo_without_newline "$hello_content" > hello &&

'

run_blob_tests () {

test_cmp expect actual

'

test_expect_success 'setup blobs which are likely to delta' '

test-tool genrandom foo 10240 >foo &&

{ cat foo && echo plus; } >foo-plus &&

test_expect_success 'fsck with invalid or bogus skipList input' '

git -c fsck.skipList=/dev/null -c fsck.missingEmail=ignore fsck &&

test_must_fail git -c fsck.skipList=does-not-exist -c fsck.missingEmail=ignore fsck 2>err &&

test_grep "could not open.*: does-not-exist" err &&

test_must_fail git -c fsck.skipList=.git/config -c fsck.missingEmail=ignore fsck 2>err &&

test_must_be_empty err

'

test_expect_success 'push with receive.fsck.skipList' '

git push . $commit:refs/heads/bogus &&

rm -rf dst &&

test_must_fail git --git-dir=dst/.git fetch "file://$(pwd)" $refspec &&

# Invalid and/or bogus skipList input

git --git-dir=dst/.git config fetch.fsck.skipList /dev/null &&

test_must_fail git --git-dir=dst/.git fetch "file://$(pwd)" $refspec &&

git --git-dir=dst/.git config fetch.fsck.skipList does-not-exist &&

check_describe A-3-gHASH HEAD^^2

check_describe B HEAD^^2^

check_describe R-1-gHASH HEAD^^^

check_describe c-7-gHASH --tags HEAD

check_describe c-6-gHASH --tags HEAD^

check_describe e-1-gHASH --tags HEAD^^

check_describe c-2-gHASH --tags HEAD^^2

check_describe B --tags HEAD^^2^

check_describe e --tags HEAD^^^

check_describe e --tags --exact-match HEAD^^^

test_must_fail git describe --exact-match --always

'

test_done

git reset --hard third &&

rm -f file2 &&

test_must_fail git merge branch3 &&

git diff --exit-code file3 &&

git diff --exit-code branch3 file3 &&

git reset --merge HEAD &&

git diff --exit-code --cached

'

git reset --hard third &&

rm -f file2 &&

test_must_fail git merge branch3 &&

git diff --exit-code file3 &&

git diff --exit-code branch3 file3 &&

test_must_fail git reset --keep HEAD 2>err.log &&

git submodule foreach "echo be --quiet" > ../expected &&

git submodule foreach echo be --quiet > ../actual

) &&

test_cmp expected actual

'

test_expect_success 'option-like arguments passed to foreach recurse correctly' '

git -C clone2 submodule foreach --recursive "echo be --an-option" >expect &&

git -C clone2 submodule foreach --recursive echo be --an-option >actual &&

test_cmp expect actual

'

cd broken &&

git init &&

>.git/index &&

) &&

test_grep "[Uu]sage: git merge" broken/usage

'

test -n "$test_skip_test_preamble" ||

say >&3 "expecting success of $TEST_NUMBER.$test_count '$1': $test_body"

if test_run_ "$test_body" &&

then

test_ok_ "$1"

else

teardown_malloc_check

}

grep -qv sanitizer::GetThreadStackTopAndBottom

}

check_test_results_san_file_ () {

then

return

fi &&

hash, to ensure that the compressed part is larger than the original.

*/

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

}

reftable_writer_set_limits(w, update_index, update_index);

err = reftable_writer_add_log(w, &log);

};

for (i = 0; i < sizeof(message) - 1; i++)

reftable_writer_set_limits(w, 1, 1);

#include "hex.h"

#include "strbuf.h"

static void check_hash_data(const void *data, size_t data_length,

const char *expected_hashes[])

{

for (size_t i = 1; i < ARRAY_SIZE(hash_algos); i++) {

git_hash_ctx ctx;

algop->update_fn(&ctx, data, data_length);

algop->final_fn(hash, &ctx);

}

}

/* Works with a NUL terminated string. Doesn't work if it should contain a NUL character. */

#define TEST_HASH_STR(data, expected_sha1, expected_sha256) do { \

const char *expected_hashes[] = { expected_sha1, expected_sha256 }; \

} while (0)

/* Only works with a literal string, useful when it contains a NUL character. */

#define TEST_HASH_LITERAL(literal, expected_sha1, expected_sha256) do { \

const char *expected_hashes[] = { expected_sha1, expected_sha256 }; \

} while (0)

{

TEST_HASH_STR("",

"da39a3ee5e6b4b0d3255bfef95601890afd80709",

"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");

TEST_HASH_STR("a",

"86f7e437faa5a7fce15d1ddcb9eaeaea377667b8",

"ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb");

TEST_HASH_STR("abc",

"a9993e364706816aba3e25717850c26c9cd0d89d",

"ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");

TEST_HASH_STR("message digest",

"c12252ceda8be8994d5fa0290a47231c1d16aae3",

"f7846f55cf23e14eebeab5b4e1550cad5b509e3348fbc4efa3a1413d393cb650");

TEST_HASH_STR("abcdefghijklmnopqrstuvwxyz",

"32d10c7b8cf96570ca04ce37f2a19d84240d3a89",

"71c480df93d6ae2f1efad1447c66c9525e316218cf51fc8d9ed832f2daf18b73");

TEST_HASH_STR(aaaaaaaaaa_100000.buf,

"34aa973cd4c4daa4f61eeb2bdbad27316534016f",

"cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0");

TEST_HASH_STR(alphabet_100000.buf,

"e7da7c55b3484fdf52aebec9cbe7b85a98f02fd4",

"e406ba321ca712ad35a698bf0af8d61fc4dc40eca6bdcea4697962724ccbde35");

TEST_HASH_LITERAL("blob 0\0",

"e69de29bb2d1d6434b8b29ae775ad8c2e48c5391",

"473a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813");

TEST_HASH_LITERAL("blob 3\0abc",

"f2ba8f84ab5c1bce84a7b441cb1959cfc7093b7f",

"c1cf6e465077930e88dc5136641d402f72a229ddd996f627d60e9639eaba35a6");

TEST_HASH_LITERAL("tree 0\0",

"4b825dc642cb6eb9a060e54bf8d69288fbee4904",

"6ef19b41225c5369f1c104d45d8d85efa9b057b53b14b4b9b939dd74decc5321");

}