*

* Copyright (C) 2006 Linus Torvalds

*/

#include "builtin.h"

#include "advice.h"

#include "config.h"

char flip,

int show_only)

{

struct cache_entry *ce = repo->index->cache[i];

int err;

const struct pathspec *pathspec,

int flags)

{

struct cache_entry *ce = repo->index->cache[i];

if (!include_sparse &&

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

#include "advice.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "copy.h"

#include "environment.h"

* Copyright (c) 2006, 2014 by its authors

* See COPYING for licensing conditions

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "color.h"

reset = GIT_COLOR_RESET;

}

for (cnt = 0; cnt < ent->num_lines; cnt++) {

char ch;

if (opt & OUTPUT_COLOR_LINE) {

if (cnt > 0) {

length--;

putchar('?');

}

if (opt & OUTPUT_ANNOTATE_COMPAT) {

const char *name;

if (opt & OUTPUT_SHOW_EMAIL)

* Copyright (c) 2006 Kristian Høgsberg <krh@redhat.com>

* Based on git-branch.sh by Junio C Hamano.

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "color.h"

char *target = NULL;

int flags = 0;

free(name);

name = mkpathdup(fmt, bname.buf);

int recovery = 0, oldref_usage = 0;

struct worktree **worktrees = get_worktrees();

/*

* Bad name --- this could be an attempt to rename a

* ref that we used to allow to be created by accident.

die(_("cannot give description to detached HEAD"));

branch_name = head;

} else if (argc == 1) {

branch_name = buf.buf;

} else {

die(_("cannot edit description of more than one branch"));

if (!argc)

branch = branch_get(NULL);

else if (argc == 1) {

branch = branch_get(buf.buf);

} else

die(_("too many arguments to set new upstream"));

if (!argc)

branch = branch_get(NULL);

else if (argc == 1) {

branch = branch_get(buf.buf);

} else

die(_("too many arguments to unset upstream"));

strvec_pushl(&extra_index_pack_args, "-v", "--progress-title",

_("Unbundling objects"), NULL);

ret = !!unbundle(the_repository, &header, bundle_fd,

list_bundle_refs(&header, argc, argv);

bundle_header_release(&header);

*

* Copyright (C) Linus Torvalds, 2005

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "convert.h"

cb.seen = &seen;

for_each_loose_object(batch_unordered_loose, &cb, 0);

oidset_clear(&seen);

} else {

struct oid_array sa = OID_ARRAY_INIT;

for_each_loose_object(collect_loose_object, &sa, 0);

oid_array_for_each_unique(&sa, batch_object_cb, &cb);

int nongit;

setup_git_directory_gently(&nongit);

!skip_prefix(sb.buf, "refs/heads/", &name))

die("'%s' is not a valid branch name", arg);

printf("%s\n", name);

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "entry.h"

* Copyright (C) 2005 Linus Torvalds

*

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "gettext.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "advice.h"

#include "branch.h"

&branch->oid, &branch->refname, 0))

repo_get_oid_committish(the_repository, branch->name, &branch->oid);

if (strcmp(buf.buf, branch->name)) {

free(branch->name);

branch->name = xstrdup(buf.buf);

*

* Based on git-clean.sh by Pavel Roskin

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

#include "config.h"

*

* Clone a repository into a different directory that does not yet exist.

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

* Copyright (c) 2007 Kristian Høgsberg <krh@redhat.com>

* Based on git-commit.sh by Junio C Hamano and Linus Torvalds

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "advice.h"

#include "config.h"

else {

loose_size += on_disk_bytes(st);

loose++;

packed_loose++;

}

return 0;

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "environment.h"

struct commit_name **slot;

seen_commits++;

slot = commit_names_peek(&commit_names, c);

n = slot ? *slot : NULL;

if (n) {

if (n->prio == 2)

annotated_cnt++;

}

}

for (cur_match = 0; cur_match < match_cnt; cur_match++) {

struct possible_tag *t = &all_matches[cur_match];

fprintf(stderr, _("traversed %lu commits\n"), seen_commits);

if (gave_up_on) {

fprintf(stderr,

oid_to_hex(&gave_up_on->object.oid));

}

}

*

* Copyright (C) Linus Torvalds, 2005

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "diff.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "diff.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "diff.h"

*

* Copyright (c) 2006 Junio C Hamano

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "ewah/ewok.h"

*

* Copyright (C) 2016 Johannes Schindelin

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

char *lbase_dir = NULL, *rbase_dir = NULL;

size_t ldir_len, rdir_len, wtdir_len;

const char *workdir, *tmp;

FILE *fp = NULL;

struct hashmap working_tree_dups = HASHMAP_INIT(working_tree_entry_cmp,

NULL);

*

* Copyright (C) 2007 Johannes E. Schindelin

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "gettext.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

#include "environment.h"

#include "delta.h"

#include "pack.h"

#include "path.h"

#include "refs.h"

#include "csum-file.h"

#include "quote.h"

p->pack_fd = pack_fd;

p->do_not_close = 1;

pack_file = hashfd(pack_fd, p->pack_name);

pack_data = p;

struct strbuf name = STRBUF_INIT;

int keep_fd;

keep_fd = odb_pack_keep(name.buf);

if (keep_fd < 0)

die_errno("cannot create keep file");

if (close(keep_fd))

die_errno("failed to write keep file");

if (finalize_object_file(pack_data->pack_name, name.buf))

die("cannot store pack file");

if (finalize_object_file(curr_index_name, name.buf))

die("cannot store index file");

free((void *)curr_index_name);

for (k = 0; k < pack_id; k++) {

struct packed_git *p = all_packs[k];

unlink_or_warn(name.buf);

}

strbuf_release(&name);

idx_name = keep_pack(create_index());

/* Register the packfile with core git's machinery. */

if (!new_p)

die("core git rejected index %s", idx_name);

all_packs[pack_id] = new_p;

tree_content_replace(&b->branch_tree, &oid, mode, NULL);

return;

}

tree_content_set(&b->branch_tree, path.buf, &oid, mode, NULL);

}

leaf.tree);

return;

}

tree_content_set(&b->branch_tree, dest.buf,

&leaf.versions[1].oid,

leaf.versions[1].mode,

int cmd_fast_import(int argc,

const char **argv,

const char *prefix,

{

unsigned int i;

fprintf(stderr, " pools: %10lu KiB\n", (unsigned long)((tree_entry_allocd + fi_mem_pool.pool_alloc) /1024));

fprintf(stderr, " objects: %10" PRIuMAX " KiB\n", (alloc_count*sizeof(struct object_entry))/1024);

fprintf(stderr, "---------------------------------------------------------------------\n");

fprintf(stderr, "---------------------------------------------------------------------\n");

fprintf(stderr, "\n");

}

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "gettext.h"

#include "hex.h"

/*

* "git fetch"

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "advice.h"

#include "config.h"

return retcode;

}

static int do_fetch(struct transport *transport,

struct refspec *rs,

const struct fetch_config *config)

"refs/tags/");

}

if (must_list_refs) {

trace2_region_enter("fetch", "remote_refs", the_repository);

remote_refs = transport_get_remote_refs(transport,

"you need to specify exactly one branch with the --set-upstream option"));

}

}

cleanup:

if (retcode) {

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "gettext.h"

{

static const char *config_key = NULL;

int keep_going = 0;

const struct string_list *values;

int err;

else if (err)

return 0;

int ret = run_command_on_repo(values->items[i].string, argc, argv);

if (ret) {

if (!keep_going)

return 0;

obj->flags |= REACHABLE;

/*

* Further recursion does not need to be performed on this

* object since it is a promisor object (so it does not need to

* do a full fsck

*/

if (!(obj->flags & HAS_OBJ)) {

return;

return; /* it is in pack - forget about it */

printf_ln(_("missing %s %s"),

printable_type(&obj->oid, obj->type),

* traversal.

*/

for_each_loose_object(mark_loose_unreachable_referents, NULL, 0);

}

/* Look up all the requirements, warn about missing objects.. */

refname, timestamp);

obj->flags |= USED;

mark_object_reachable(obj);

error(_("%s: invalid reflog entry %s"),

refname, oid_to_hex(oid));

errors_found |= ERROR_REACHABLE;

obj = parse_object(the_repository, oid);

if (!obj) {

/*

* Increment default_refs anyway, because this is a

* valid ref.

if (connectivity_only) {

for_each_loose_object(mark_loose_for_connectivity, NULL, 0);

} else {

prepare_alt_odb(the_repository);

for (odb = the_repository->objects->odb; odb; odb = odb->next)

&oid);

if (!obj || !(obj->flags & HAS_OBJ)) {

continue;

error(_("%s: object missing"), oid_to_hex(&oid));

errors_found |= ERROR_OBJECT;

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

#include "config.h"

*

* Copyright (c) 2006 Shawn O. Pearce

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

#include "date.h"

char *repack_filter_to;

unsigned long big_pack_threshold;

unsigned long max_delta_cache_size;

};

#define GC_CONFIG_INIT { \

.prune_expire = xstrdup("2.weeks.ago"), \

.prune_worktrees_expire = xstrdup("3.months.ago"), \

.max_delta_cache_size = DEFAULT_DELTA_CACHE_SIZE, \

}

static void gc_config_release(struct gc_config *cfg)

{

const char *value;

char *owned = NULL;

if (!git_config_get_value("gc.packrefs", &value)) {

if (value && !strcmp(value, "notbare"))

git_config_get_ulong("gc.bigpackthreshold", &cfg->big_pack_threshold);

git_config_get_ulong("pack.deltacachesize", &cfg->max_delta_cache_size);

if (!git_config_get_string("gc.repackfilter", &owned)) {

free(cfg->repack_filter);

cfg->repack_filter = owned;

* read_sha1_file() (either at delta calculation phase, or

* writing phase) also fills up the delta base cache

*/

/* and of course pack-objects has its own delta cache */

heap += cfg->max_delta_cache_size;

*

* Copyright (c) 2006 Junio C Hamano

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

#include "gettext.h"

/*

* Builtin help command

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "exec-cmd.h"

struct string_list keys = STRING_LIST_INIT_DUP;

struct string_list keys_uniq = STRING_LIST_INIT_DUP;

struct string_list_item *item;

for (p = config_name_list; *p; p++) {

const char *var = *p;

e->prefix, e->placeholder);

string_list_sort(&keys);

const char *var = keys.items[i].string;

const char *wildcard, *tag, *cut;

const char *dot = NULL;

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "delta.h"

static const char *curr_pack;

/*

*/

static struct thread_local_data *thread_data;

static int nr_dispatched;

return 0;

}

{

}

{

if (obj->type == OBJ_TREE) {

struct tree *tree = (struct tree *)obj;

*/

return;

while (tree_entry_gently(&desc, &entry))

} else if (obj->type == OBJ_COMMIT) {

struct commit *commit = (struct commit *) obj;

struct commit_list *parents = commit->parents;

for (; parents; parents = parents->next)

} else if (obj->type == OBJ_TAG) {

struct tag *tag = (struct tag *) obj;

}

}

free(has_data);

}

read_lock();

if (type == OBJ_BLOB) {

struct blob *blob = lookup_blob(the_repository, oid);

die(_("fsck error in packed object"));

if (strict && fsck_walk(obj, NULL, &fsck_options))

die(_("Not all child objects of %s are reachable"), oid_to_hex(&obj->oid));

if (obj->type == OBJ_TREE) {

struct tree *item = (struct tree *) obj;

* recursively checking if the resulting object is used as a base

* for some more deltas.

*/

{

int i;

nr_ref_deltas + nr_ofs_deltas);

nr_dispatched = 0;

if (nr_threads > 1 || getenv("GIT_FORCE_THREADS")) {

init_thread();

work_lock();

if (pack_name)

filename = derive_filename(pack_name, "pack", suffix, &name_buf);

else

fd = odb_pack_keep(filename);

if (fd < 0) {

{

if (!*final_name || strcmp(*final_name, curr_name)) {

if (!*final_name)

if (finalize_object_file(curr_name, *final_name))

die(_("unable to rename temporary '*.%s' file to '%s'"),

ext, *final_name);

if (do_fsck_object) {

struct packed_git *p;

if (p)

install_packed_git(the_repository, p);

}

else

opts->flags &= ~WRITE_REV;

}

return git_default_config(k, v, ctx, cb);

}

static void read_idx_option(struct pack_idx_option *opts, const char *pack_name)

{

if (!p)

die(_("Cannot open existing pack file '%s'"), pack_name);

struct strbuf line = STRBUF_INIT;

struct oidset_iter iter;

struct object_id *oid;

return;

if (write_in_full(cmd.in, oid_to_hex(oid), the_hash_algo->hexsz) < 0 ||

write_in_full(cmd.in, "\n", 1) < 0)

die(_("failed to feed local object to pack-objects"));

}

close(cmd.in);

out = xfdopen(cmd.out, "r");

} else if (skip_to_optional_arg(arg, "--keep", &keep_msg)) {

; /* nothing to do */

} else if (skip_to_optional_arg(arg, "--promisor", &promisor_msg)) {

} else if (starts_with(arg, "--threads=")) {

char *end;

nr_threads = strtoul(arg+10, &end, 0);

parse_pack_objects(pack_hash);

if (report_end_of_input)

write_in_full(2, "\0", 1);

conclude_pack(fix_thin_pack, curr_pack, pack_hash);

free(ofs_deltas);

free(ref_deltas);

* (C) Copyright 2006 Linus Torvalds

* 2006 Junio Hamano

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

#include "config.h"

* but we didn't actually show the commit.

*/

rev->max_count++;

/*

* We may show a given commit multiple times when

*/

free_commit_buffer(the_repository->parsed_objects,

commit);

*

* Copyright (C) Linus Torvalds, 2005

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "convert.h"

* It just splits a mbox into a list of files: "0001" "0002" ..

* so you can process them further from there.

*/

#include "builtin.h"

#include "gettext.h"

#include "string-list.h"

char *file = NULL;

FILE *f = NULL;

int ret = -1;

struct string_list list = STRING_LIST_INIT_DUP;

list.cmp = maildir_filename_cmp;

if (populate_maildir_list(&list, maildir) < 0)

goto out;

char *name;

free(file);

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

#include "diff.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "hex.h"

#include "read-cache-ll.h"

*

* Pretend we resolved the heads, but declare our tree trumps everybody else.

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "git-compat-util.h"

#include "builtin.h"

#include "diff.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "tree-walk.h"

#include "xdiff-interface.h"

if (!result.clean) {

struct string_list conflicted_files = STRING_LIST_INIT_NODUP;

const char *last = NULL;

merge_get_conflicted_files(&result, &conflicted_files);

const char *name = conflicted_files.items[i].string;

struct stage_info *c = conflicted_files.items[i].util;

if (!o->name_only)

if (xopts.nr && o.mode == MODE_TRIVIAL)

die(_("--trivial-merge is incompatible with all other options"));

if (parse_merge_opt(&o.merge_options, xopts.v[x]))

die(_("unknown strategy option: -X%s"), xopts.v[x]);

*

* Based on git-merge.sh by Junio C Hamano.

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

char *found_ref = NULL;

int len, early;

remote = bname.buf;

oidclr(&branch_head, the_repository->hash_algo);

static int cmd_multi_pack_index_write(int argc, const char **argv,

const char *prefix,

{

struct option *options;

static struct option builtin_multi_pack_index_write_options[] = {

read_packs_from_stdin(&packs);

opts.preferred_pack,

opts.refs_snapshot, opts.flags);

}

opts.refs_snapshot, opts.flags);

free(opts.refs_snapshot);

*

* Copyright (C) 2006 Johannes Schindelin

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "environment.h"

#include "gettext.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "environment.h"

#include "gettext.h"

return 0;

if (ignore_packed_keep_in_core && p->pack_keep_in_core)

return 0;

return 0;

}

static int cruft_include_check_obj(struct object *obj, void *data UNUSED)

{

}

static int cruft_include_check(struct commit *commit, void *data)

* Quietly ignore EXPECTED missing objects. This avoids problems with

* staging them now and getting an odd error later.

*/

return;

show_object(obj, name, data);

static void add_objects_in_unpacked_packs(void)

{

FOR_EACH_OBJECT_PACK_ORDER |

FOR_EACH_OBJECT_LOCAL_ONLY |

FOR_EACH_OBJECT_SKIP_IN_CORE_KEPT_PACKS |

* This file is licensed under the GPL v2.

*

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

static void sort_pack_list(struct pack_list **pl)

{

struct pack_list **ary, *p;

size_t n = pack_list_size(*pl);

if (n < 2)

QSORT(ary, n, cmp_remaining_objects);

/* link them back again */

ary[i]->next = ary[i + 1];

ary[n - 1]->next = NULL;

*pl = ary[0];

pl = red = pack_list_difference(local_packs, min);

while (pl) {

printf("%s\n%s\n",

pl->pack->pack_name);

pl = pl->next;

}

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "gettext.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "diff.h"

#include "parse-options.h"

#include "setup.h"

{

if (patchlen)

printf("%s %s\n", oid_to_hex(result), oid_to_hex(id));

}

{

char *src = line;

char *dst = line;

return 1;

}

{

int before = -1, after = -1;

int diff_is_binary = 0;

char pre_oid_str[GIT_MAX_HEXSZ + 1], post_oid_str[GIT_MAX_HEXSZ + 1];

while (strbuf_getwholeline(line_buf, stdin, '\n') != EOF) {

char *line = line_buf->buf;

const char *p = line;

/* Possibly skip over the prefix added by "log" or "format-patch" */

if (!skip_prefix(line, "commit ", &p) &&

static void generate_id_list(int stable, int verbatim)

{

struct object_id oid, n, result;

struct strbuf line_buf = STRBUF_INIT;

oidclr(&oid, the_repository->hash_algo);

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "commit.h"

#include "diff.h"

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "advice.h"

#include "config.h"

static int already_up_to_date(struct object_id *orig_head,

struct oid_array *merge_heads)

{

struct commit *ours;

ours = lookup_commit_reference(the_repository, orig_head);

struct commit_list *list = NULL;

struct commit *theirs;

int ok;

/*

* "git push"

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "advice.h"

#include "branch.h"

const struct string_list *push_options,

struct remote *remote)

{

struct strvec *url;

struct refspec *push_refspec = &rs;

}

errs = 0;

url = push_url_of_remote(remote);

struct transport *transport =

transport_get(remote, url->v[i]);

if (flags & TRANSPORT_PUSH_OPTIONS)

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "gettext.h"

#include "object-name.h"

{

struct diff_options diffopt = { NULL };

struct strvec other_arg = STRVEC_INIT;

struct range_diff_options range_diff_opts = {

.creation_factor = RANGE_DIFF_CREATION_FACTOR_DEFAULT,

.diffopt = &diffopt,

OPT_PASSTHRU_ARGV(0, "notes", &other_arg,

N_("notes"), N_("passed to 'git log'"),

PARSE_OPT_OPTARG),

OPT_BOOL(0, "left-only", &left_only,

N_("only emit output related to the first range")),

OPT_BOOL(0, "right-only", &right_only,

if (!simple_color)

diffopt.use_color = 1;

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

if (!strcmp(argv[i], "--")) {

dash_dash = i;

res = show_range_diff(range1.buf, range2.buf, &range_diff_opts);

strvec_clear(&other_arg);

strbuf_release(&range1);

strbuf_release(&range2);

*

* Copyright (c) 2018 Pratik Karki

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "gettext.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "gettext.h"

return result;

}

static int set_head(int argc, const char **argv, const char *prefix,

struct repository *repo UNUSED)

{

char *head_name = NULL;

struct option options[] = {

OPT_BOOL('a', "auto", &opt_a,

};

argc = parse_options(argc, argv, prefix, options,

builtin_remote_sethead_usage, 0);

if (!opt_a && !opt_d && argc == 2) {

head_name = xstrdup(argv[1]);

head_name = xstrdup(states.heads.items[0].string);

free_remote_ref_states(&states);

} else if (opt_d && !opt_a && argc == 1) {

} else

usage_with_options(builtin_remote_sethead_usage, options);

}

return result;

}

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "dir.h"

* {type -> existing pack order} ordering when computing deltas instead

* of a {type -> size} ordering, which may produce better deltas.

*/

FOR_EACH_OBJECT_PROMISOR_ONLY);

if (cmd.in == -1) {

unsigned flags = 0;

if (git_env_bool(GIT_TEST_MULTI_PACK_INDEX_WRITE_INCREMENTAL, 0))

flags |= MIDX_WRITE_INCREMENTAL;

NULL, NULL, flags);

}

* "git replay" builtin command

*/

#include "git-compat-util.h"

#include "builtin.h"

#include "environment.h"

#include "hex.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "gettext.h"

struct repository *repo UNUSED)

{

struct string_list merge_rr = STRING_LIST_INIT_DUP;

struct option options[] = {

OPT_SET_INT(0, "rerere-autoupdate", &autoupdate,

if (setup_rerere(the_repository, &merge_rr,

flags | RERERE_READONLY) < 0)

return 0;

printf("%s\n", merge_rr.items[i].string);

} else if (!strcmp(argv[0], "remaining")) {

rerere_remaining(the_repository, &merge_rr);

if (merge_rr.items[i].util != RERERE_RESOLVED)

printf("%s\n", merge_rr.items[i].string);

else

if (setup_rerere(the_repository, &merge_rr,

flags | RERERE_READONLY) < 0)

return 0;

const char *path = merge_rr.items[i].string;

const struct rerere_id *id = merge_rr.items[i].util;

if (diff_two(rerere_path(id, "preimage"), path, path, path))

*

* Copyright (c) 2005, 2006 Linus Torvalds and Junio C Hamano

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "advice.h"

#include "config.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "commit.h"

return;

case MA_ALLOW_PROMISOR:

return;

die("unexpected missing %s object '%s'",

type_name(obj->type), oid_to_hex(&obj->oid));

*

* Copyright (C) Linus Torvalds, 2005

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "git-compat-util.h"

#include "builtin.h"

#include "parse-options.h"

*

* Copyright (C) Linus Torvalds 2006

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "advice.h"

#include "config.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "commit.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "environment.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "gettext.h"

#include "hash.h"

repo_set_hash_algo(the_repository, hash_algo);

}

hashsz = the_hash_algo->rawsz;

if (fread(top_index, 2 * 4, 1, stdin) != 1)

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "dir.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

#include "config.h"

struct tree *tree[ARRAY_SIZE(oid)];

struct tree_desc tree_desc[ARRAY_SIZE(oid)];

struct unpack_trees_options unpack_tree_opt = { 0 };

tree[i] = parse_tree_indirect(oid[i]);

if (parse_tree(tree[i]) < 0)

die(_("failed to parse tree"));

repo_read_index_preload(the_repository, NULL, 0);

if (!include_untracked && ps->nr) {

char *ps_matched = xcalloc(ps->nr, 1);

/* TODO: audit for interaction with sparse-index. */

ensure_full_index(the_repository->index);

ce_path_match(the_repository->index, the_repository->index->cache[i], ps,

ps_matched);

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

#include "environment.h"

struct pathspec *pathspec,

struct module_list *list)

{

char *ps_matched = NULL;

parse_pathspec(pathspec, 0,

if (repo_read_index(the_repository) < 0)

die(_("index file corrupt"));

const struct cache_entry *ce = the_repository->index->cache[i];

if (!match_pathspec(the_repository->index, pathspec, ce->name, ce_namelen(ce),

die(_("index file corrupt"));

if (ps.nr) {

char *ps_matched = xcalloc(ps.nr, 1);

/* TODO: audit for interaction with sparse-index. */

* Since there is only one pathspec, we just need to

* check ps_matched[0] to know if a cache entry matched.

*/

ce_path_match(the_repository->index, the_repository->index->cache[i], &ps,

ps_matched);

* Carlos Rica <jasampler@gmail.com>

* Based on git-tag.sh and mktag.c by Linus Torvalds.

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "advice.h"

#include "config.h"

return 0;

}

int cmd_tag(int argc,

const char **argv,

const char *prefix,

if (repo_get_oid(the_repository, object_ref, &object))

die(_("Failed to resolve '%s' as a valid ref."), object_ref);

die(_("'%s' is not a valid tag name."), tag);

if (refs_read_ref(get_main_ref_store(the_repository), ref.buf, &prev))

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "bulk-checkin.h"

#include "config.h"

*

* Copyright (C) Linus Torvalds, 2005

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "bulk-checkin.h"

#include "config.h"

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "config.h"

#include "gettext.h"

N_("interrupt transfer after <n> seconds of inactivity")),

OPT_END()

};

packet_trace_identity("upload-pack");

disable_replace_refs();

dir = argv[0];

die("'%s' does not appear to be a git repository", dir);

switch (determine_protocol_version_server()) {

*

* Copyright (C) Eric Biederman, 2005

*/

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "attr.h"

if ((val = ptr->read(0))) {

if (ptr->multivalued && *val) {

struct string_list list = STRING_LIST_INIT_DUP;

string_list_split(&list, val, '\n', -1);

printf("%s=%s\n", ptr->name, list.items[i].string);

string_list_clear(&list, 0);

} else {

#define USE_THE_REPOSITORY_VARIABLE

#include "builtin.h"

#include "abspath.h"

#include "advice.h"

int quiet;

int checkout;

int orphan;

const char *keep_locked;

};

static int show_only;

static int verbose;

static int guess_remote;

static timestamp_t expire;

static int git_worktree_config(const char *var, const char *value,

if (!strcmp(var, "worktree.guessremote")) {

guess_remote = git_config_bool(var, value);

return 0;

}

return git_default_config(var, value, ctx, cb);

const struct add_opts *opts)

{

struct strbuf sb_git = STRBUF_INIT, sb_repo = STRBUF_INIT;

const char *name;

struct strvec child_env = STRVEC_INIT;

unsigned int counter = 0;

worktrees = NULL;

/* is 'refname' a branch or commit? */

refs_ref_exists(get_main_ref_store(the_repository), symref.buf)) {

is_branch = 1;

if (!opts->force)

strbuf_reset(&sb);

strbuf_addf(&sb, "%s/gitdir", sb_repo.buf);

strbuf_reset(&sb);

strbuf_addf(&sb, "%s/commondir", sb_repo.buf);

write_file(sb.buf, "../..");

strvec_clear(&child_env);

strbuf_release(&sb);

strbuf_release(&symref);

strbuf_release(&sb_repo);

strbuf_release(&sb_git);

strbuf_release(&sb_name);

free_worktree(wt);

return ret;

fprintf_ln(stderr, _("Preparing worktree (new branch '%s')"), new_branch);

} else {

struct strbuf s = STRBUF_INIT;

refs_ref_exists(get_main_ref_store(the_repository), s.buf))

fprintf_ln(stderr, _("Preparing worktree (checking out '%s')"),

branch);

char *branchname = xstrndup(s, n);

struct strbuf ref = STRBUF_INIT;

refs_ref_exists(get_main_ref_store(the_repository),

ref.buf);

strbuf_release(&ref);

PARSE_OPT_NOARG | PARSE_OPT_OPTARG),

OPT_BOOL(0, "guess-remote", &guess_remote,

N_("try to match the new branch name with a remote-tracking branch")),

OPT_END()

};

int ret;

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

opts.checkout = 1;

ac = parse_options(ac, av, prefix, options, git_worktree_add_usage, 0);

if (!!opts.detach + !!new_branch + !!new_branch_force > 1)

die(_("options '%s', '%s', and '%s' cannot be used together"), "-b", "-B", "--detach");

new_branch = new_branch_force;

if (!opts.force &&

refs_ref_exists(get_main_ref_store(the_repository), symref.buf))

die_if_checked_out(symref.buf, 0);

strbuf_release(&symref);

OPT__FORCE(&force,

N_("force move even if worktree is dirty or locked"),

PARSE_OPT_NOCOMPLETE),

OPT_END()

};

struct worktree **worktrees, *wt;

if (rename(wt->path, dst.buf) == -1)

die_errno(_("failed to move '%s' to '%s'"), wt->path, dst.buf);

strbuf_release(&dst);

free_worktrees(worktrees);

const char **p;

const char *self[] = { ".", NULL };

struct option options[] = {

OPT_END()

};

int rc = 0;

ac = parse_options(ac, av, prefix, options, git_worktree_repair_usage, 0);

p = ac > 0 ? av : self;

for (; *p; p++)

return rc;

}