char *ps_matched = NULL;

struct lock_file lock_file = LOCK_INIT;

argc = parse_options(argc, argv, prefix, builtin_add_options,

builtin_add_usage, PARSE_OPT_KEEP_ARGV0);

* Copyright (C) 2006 Ryan Anderson

*/

#include "git-compat-util.h"

#include "builtin.h"

#include "strvec.h"

int cmd_annotate(int argc,

const char **argv,

const char *prefix,

{

struct strvec args = STRVEC_INIT;

strvec_pushl(&args, "annotate", "-c", NULL);

strvec_push(&args, argv[i]);

}

* Copyright (c) 2006 Franck Bui-Huu

* Copyright (c) 2006 Rene Scharfe

*/

#include "builtin.h"

#include "archive.h"

#include "gettext.h"

int cmd_archive(int argc,

const char **argv,

const char *prefix,

{

const char *exec = "git-upload-archive";

char *output = NULL;

setvbuf(stderr, NULL, _IOLBF, BUFSIZ);

out:

free(output);

N_("update ignored files (default)"),

PARSE_OPT_NOCOMPLETE),

OPT_BOOL(0, "ignore-other-worktrees", &opts->ignore_other_worktrees,

OPT_END()

};

struct option *newopts = parse_options_concat(prevopts, options);

N_("create a shallow clone of that depth")),

OPT_STRING(0, "shallow-since", &option_since, N_("time"),

N_("create a shallow clone since a specific time")),

OPT_BOOL(0, "single-branch", &option_single_branch,

N_("clone only one branch, HEAD or --branch")),

OPT_BOOL(0, "no-tags", &option_no_tags,

* data from the --bundle-uri option.

*/

if (bundle_uri) {

int has_heuristic = 0;

/* At this point, we need the_repository to match the cloned repo. */

if (repo_init(the_repository, git_dir, work_tree))

warning(_("failed to initialize the repo, skipping bundle URI"));

bundle_uri);

else if (has_heuristic)

git_config_set_gently("fetch.bundleuri", bundle_uri);

} else {

/*

* Populate transport->got_remote_bundle_uri and

if (transport->bundles &&

hashmap_get_size(&transport->bundles->bundles)) {

/* At this point, we need the_repository to match the cloned repo. */

if (repo_init(the_repository, git_dir, work_tree))

warning(_("failed to initialize the repo, skipping bundle URI"));

else if (fetch_bundle_list(the_repository,

transport->bundles))

warning(_("failed to fetch advertised bundles"));

} else {

clear_bundle_list(transport->bundles);

FREE_AND_NULL(transport->bundles);

* is specified explicitly.

*/

static enum commit_msg_cleanup_mode cleanup_mode;

static enum commit_whence whence;

static int use_editor = 1, include_status = 1;

repo_unuse_commit_buffer(the_repository, commit, buffer);

}

static int prepare_to_commit(const char *index_file, const char *prefix,

struct commit *current_head,

struct wt_status *s,

s->use_color = 0;

committable = run_status(s->fp, index_file, prefix, 1, s);

s->use_color = saved_color_setting;

} else {

struct object_id oid;

const char *parent = "HEAD";

if (0 <= edit_flag)

use_editor = edit_flag;

handle_untracked_files_arg(s);

if (all && argc > 0)

include_status = git_config_bool(k, v);

return 0;

}

if (!strcmp(k, "commit.gpgsign")) {

sign_commit = git_config_bool(k, v) ? "" : NULL;

return 0;

struct repository *repo UNUSED)

{

static struct wt_status s;

static struct option builtin_commit_options[] = {

OPT__QUIET(&quiet, N_("suppress summary after successful commit")),

OPT__VERBOSE(&verbose, N_("show diff in commit message template")),

if (verbose == -1)

verbose = (config_commit_verbose < 0) ? 0 : config_commit_verbose;

if (dry_run)

return dry_run_commit(argv, prefix, current_head, &s);

index_file = prepare_index(argv, prefix, current_head, 0);

N_("git config list [<file-option>] [<display-option>] [--includes]"),

N_("git config get [<file-option>] [<display-option>] [--includes] [--all] [--regexp] [--value=<value>] [--fixed-value] [--default=<default>] <name>"),

N_("git config set [<file-option>] [--type=<type>] [--all] [--value=<value>] [--fixed-value] <name> <value>"),

N_("git config rename-section [<file-option>] <old-name> <new-name>"),

N_("git config remove-section [<file-option>] <name>"),

N_("git config edit [<file-option>]"),

};

static const char *const builtin_config_unset_usage[] = {

NULL

};

static int connection_closed(int error)

{

}

static int connection_fatally_broken(int error)

#else

{

const char * const usage[] = {

"git credential-cache [options] <action>",

/* Write the file contents for the left and right sides of the difftool

* dir-diff representation for submodules and symlinks. Symlinks and submodules

* are written as regular text files so that external diff tools can diff them

* displays for symlink and submodule diffs.

*/

static void write_standin_files(struct pair_entry *entry,

if (e->idx.offset) {

duplicate_count_by_type[type]++;

return 1;

e->type = type;

e->pack_id = MAX_PACK_ID;

e->idx.offset = 1; /* just not zero! */

duplicate_count_by_type[OBJ_BLOB]++;

truncate_pack(&checkpoint);

e->type = OBJ_BLOB;

e->pack_id = MAX_PACK_ID;

e->idx.offset = 1; /* just not zero! */

strvec_pushl(&argv, "-c", "fetch.bundleURI=",

"fetch", "--append", "--no-auto-gc",

"--no-write-commit-graph", NULL);

add_options_to_argv(&argv, config);

if (max_children != 1 && list->nr != 1) {

N_("deepen history of shallow clone")),

OPT_STRING(0, "shallow-since", &deepen_since, N_("time"),

N_("deepen history of shallow repository based on time")),

OPT_INTEGER(0, "deepen", &deepen_relative,

N_("deepen history of shallow clone")),

OPT_SET_INT_F(0, "unshallow", &unshallow,

int dummy;

int use_index = 1;

int allow_revs;

struct option options[] = {

OPT_BOOL(0, "cached", &cached,

* Optimize out the case where the amount of matches is limited to zero.

* We do this to keep results consistent with GNU grep(1).

*/

if (show_in_pager) {

if (num_threads > 1)

hit |= wait_all();

if (hit && show_in_pager)

run_pager(&opt, prefix);

clear_pathspec(&pathspec);

string_list_clear(&path_list, 0);

free_grep_patterns(&opt);

object_array_clear(&list);

free_repos();

}

#include "csum-file.h"

#include "blob.h"

#include "commit.h"

#include "tree.h"

#include "progress.h"

#include "fsck.h"

#include "object-file.h"

#include "object-store-ll.h"

#include "oid-array.h"

#include "replace-object.h"

#include "promisor-remote.h"

#include "setup.h"

static const char index_pack_usage[] =

"git index-pack [-v] [-o <index-file>] [--keep | --keep=<msg>] [--[no-]rev-index] [--verify] [--strict[=<msg-id>=<severity>...]] [--fsck-objects[=<msg-id>=<severity>...]] (<pack-file> | --stdin [--fix-thin] [<pack-file>])";

static int input_fd, output_fd;

static const char *curr_pack;

static struct thread_local *thread_data;

static int nr_dispatched;

static int threads_active;

return 0;

}

static void sha1_object(const void *data, struct object_entry *obj_entry,

unsigned long size, enum object_type type,

const struct object_id *oid)

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;

struct strbuf *name, unsigned char *hash,

const char *ext, int make_read_only_if_same)

{

if (!*final_name)

*final_name = odb_pack_name(name, hash, ext);

if (finalize_object_file(curr_name, *final_name))

free(chain_histogram);

}

int cmd_index_pack(int argc,

const char **argv,

const char *prefix,

{

int i, fix_thin_pack = 0, verify = 0, stat_only = 0, rev_index;

const char *curr_index;

const char *index_name = NULL, *pack_name = NULL, *rev_index_name = NULL;

const char *keep_msg = NULL;

const char *promisor_msg = NULL;

} 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);

free((void *) curr_pack);

if (!index_name)

free((void *) curr_index);

/*

* Let the caller know this pack is not self contained

{

LIST_HEAD(head);

struct strbuf sb = STRBUF_INIT;

FILE *outfile = stdout;

trailer_config_init();

if (opts->in_place)

outfile = create_in_place_tempfile(file);

if (!opts->only_trailers)

fprintf(outfile, "\n");

}

/* Print trailer block. */

free_trailers(&head);

if (!opts->only_trailers)

if (opts->in_place)

if (rename_tempfile(&trailers_tempfile, file))

status = 0; /* we found something */

}

ref_sorting_release(sorting);

ref_array_clear(&ref_array);

if (transport_disconnect(transport))

transport_ls_refs_options_release(&transport_options);

strvec_clear(&pattern);

return status;

}

clean = merge_recursive(&o, head, remoteheads->item,

reversed, &result);

free_commit_list(reversed);

if (clean < 0) {

rollback_lock_file(&lock);

static const char *separator = "\n";

static const char * const git_notes_usage[] = {

N_("git notes [--ref <notes-ref>] [list [<object>]]"),

N_("git notes [--ref <notes-ref>] copy [-f] <from-object> <to-object>"),

N_("git notes [--ref <notes-ref>] edit [--allow-empty] [<object>]"),

N_("git notes [--ref <notes-ref>] show [<object>]"),

N_("git notes [--ref <notes-ref>] merge [-v | -q] [-s <strategy>] <notes-ref>"),

OPT_CALLBACK_F('c', "reedit-message", &d, N_("object"),

N_("reuse and edit specified note object"), PARSE_OPT_NONEG,

parse_reedit_arg),

OPT_CALLBACK_F('C', "reuse-message", &d, N_("object"),

N_("reuse specified note object"), PARSE_OPT_NONEG,

parse_reuse_arg),

OPT_CALLBACK_F('C', "reuse-message", &d, N_("object"),

N_("reuse specified note object"), PARSE_OPT_NONEG,

parse_reuse_arg),

OPT_BOOL(0, "allow-empty", &allow_empty,

N_("allow storing empty note")),

OPT_CALLBACK_F(0, "separator", &separator,

static uint16_t write_bitmap_options = BITMAP_OPT_HASH_CACHE;

static int exclude_promisor_objects;

static int use_delta_islands;

if (p == *found_pack)

offset = *found_offset;

else

if (offset) {

if (!*found_pack) {

while (p) {

if ((!p->pack_local || p->pack_keep ||

p->pack_keep_in_core) &&

last_found = p;

return 1;

}

return 0;

}

int cmd_pack_objects(int argc,

const char **argv,

const char *prefix,

option_parse_missing_action),

OPT_BOOL(0, "exclude-promisor-objects", &exclude_promisor_objects,

N_("do not pack objects in promisor packfiles")),

OPT_BOOL(0, "delta-islands", &use_delta_islands,

N_("respect islands during delta compression")),

OPT_STRING_LIST(0, "uri-protocol", &uri_protocols,

strvec_push(&rp, "--unpacked");

}

if (exclude_promisor_objects) {

use_internal_rev_list = 1;

fetch_if_missing = 0;

strvec_push(&rp, "--exclude-promisor-objects");

}

if (unpack_unreachable || keep_unreachable || pack_loose_unreachable)

use_internal_rev_list = 1;

repo_init_revisions(the_repository, &revs, NULL);

list_objects_filter_copy(&revs.filter, &filter_options);

get_object_list(&revs, rp.nr, rp.v);

release_revisions(&revs);

}

#include "packfile.h"

#include "object-store-ll.h"

#define BLKSIZE 512

(*list)->size = 0;

}

static struct llist * llist_copy(struct llist *list)

{

struct llist *ret;

return p;

}

static inline size_t pack_list_size(struct pack_list *pl)

{

size_t ret = 0;

/* return if there are no objects missing from the unique set */

if (missing->size == 0) {

return;

}

}

while (non_unique) {

/* sort the non_unique packs, greater size of remaining_objects first */

sort_pack_list(&non_unique);

if (non_unique->remaining_objects->size == 0)

for (pl = non_unique->next; pl && pl->remaining_objects->size > 0; pl = pl->next)

llist_sorted_difference_inplace(pl->remaining_objects, non_unique->remaining_objects);

}

}

static void load_all_objects(void)

int cmd_pack_redundant(int argc, const char **argv, const char *prefix UNUSED, struct repository *repo UNUSED) {

int i; int i_still_use_this = 0; struct pack_list *min = NULL, *red, *pl;

struct llist *ignore;

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

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

/* ignore objects given on stdin */

llist_init(&ignore);

if (!isatty(0)) {

while (fgets(buf, sizeof(buf), stdin)) {

die("Bad object ID on stdin: %s", buf);

}

}

llist_sorted_difference_inplace(all_objects, ignore);

pl = red = pack_list_difference(local_packs, min);

while (pl) {

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

pl->pack->pack_name);

pl = pl->next;

}

fprintf(stderr, "%luMB of redundant packs in total.\n",

(unsigned long)pack_set_bytecount(red)/(1024*1024));

return 0;

}

OPT_PASSTHRU_ARGV(0, "shallow-since", &opt_fetch, N_("time"),

N_("deepen history of shallow repository based on time"),

0),

0),

OPT_PASSTHRU_ARGV(0, "deepen", &opt_fetch, N_("n"),

N_("deepen history of shallow clone"),

RECURSE_SUBMODULES_ON_DEMAND : RECURSE_SUBMODULES_OFF;

recurse_submodules = val;

} else if (!strcmp(k, "push.pushoption")) {

} else if (!strcmp(k, "color.push")) {

push_use_color = git_config_colorbool(k, v);

return 0;

struct command {

struct command *next;

const char *error_string;

struct ref_push_report *report;

unsigned int skip_update:1,

did_not_exist:1,

hint->run_proc_receive |= RUN_PROC_RECEIVE_RETURNED;

if (!strcmp(head, "ng")) {

if (p)

else

hint->error_string = "failed";

code = -1;

while (commands) {

struct command *next = commands->next;

free(commands);

commands = next;

}

if (revs->max_count >= 0)

return -1;

bitmap_git = prepare_bitmap_walk(revs, filter_provided_objects);

if (!bitmap_git)

return -1;

const char * const * usage_str = revert_or_cherry_pick_usage(opts);

const char *me = action_name(opts);

const char *cleanup_arg = NULL;

enum empty_action empty_opt = EMPTY_COMMIT_UNSPECIFIED;

int cmd = 0;

struct option base_options[] = {

OPT_CALLBACK('m', "mainline", opts, N_("parent-number"),

N_("select mainline parent"), option_parse_m),

OPT_RERERE_AUTOUPDATE(&opts->allow_rerere_auto),

OPT_STRVEC('X', "strategy-option", &opts->xopts, N_("option"),

N_("option for merge strategy")),

N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },

OPT_END()

};

usage_with_options(usage_str, options);

/* These option values will be free()d */

if (!opts->strategy && getenv("GIT_TEST_MERGE_ALGORITHM"))

opts->strategy = xstrdup(getenv("GIT_TEST_MERGE_ALGORITHM"));

free(options);

/* stable plumbing output; do not modify or localize */

fprintf(stderr, "Everything up-to-date\n");

free_refs(remote_refs);

free_refs(local_refs);

refspec_clear(&rs);

struct parse_opt_ctx_t ctx;

git_config(git_default_config, NULL);

shortlog_init(&log);

repo_init_revisions(the_repository, &rev, prefix);

int quiet = 0;

int pathspec_file_nul = 0;

const char *stash_msg = NULL;

struct pathspec ps;

struct option options[] = {

OPT_BOOL('k', "keep-index", &keep_index,

ret = do_push_stash(&ps, stash_msg, quiet, keep_index, patch_mode,

include_untracked, only_staged);

clear_pathspec(&ps);

return ret;

}

int ret = -1;

if (sign_buffer(buffer, &sig, keyid))

if (compat) {

const struct git_hash_algo *algo = the_repository->hash_algo;

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;

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;

}