自学教程：C++ usage_with_options函数代码示例

int cmd_fmt_merge_msg(int argc, const char **argv, const char *prefix){	const char *inpath = NULL;	const char *message = NULL;	int shortlog_len = -1;	struct option options[] = {		{ OPTION_INTEGER, 0, "log", &shortlog_len, "n",		  "populate log with at most <n> entries from shortlog",		  PARSE_OPT_OPTARG, NULL, DEFAULT_MERGE_LOG_LEN },		{ OPTION_INTEGER, 0, "summary", &shortlog_len, "n",		  "alias for --log (deprecated)",		  PARSE_OPT_OPTARG | PARSE_OPT_HIDDEN, NULL,		  DEFAULT_MERGE_LOG_LEN },		OPT_STRING('m', "message", &message, "text",			"use <text> as start of message"),		OPT_FILENAME('F', "file", &inpath, "file to read from"),		OPT_END()	};	FILE *in = stdin;	struct strbuf input = STRBUF_INIT, output = STRBUF_INIT;	int ret;	struct fmt_merge_msg_opts opts;	git_config(fmt_merge_msg_config, NULL);	argc = parse_options(argc, argv, prefix, options, fmt_merge_msg_usage,			     0);	if (argc > 0)		usage_with_options(fmt_merge_msg_usage, options);	if (shortlog_len < 0)		shortlog_len = (merge_log_config > 0) ? merge_log_config : 0;	if (inpath && strcmp(inpath, "-")) {		in = fopen(inpath, "r");		if (!in)			die_errno("cannot open '%s'", inpath);	}	if (strbuf_read(&input, fileno(in), 0) < 0)		die_errno("could not read input file");	if (message)		strbuf_addstr(&output, message);	memset(&opts, 0, sizeof(opts));	opts.add_title = !message;	opts.shortlog_len = shortlog_len;	ret = fmt_merge_msg(&input, &output, &opts);	if (ret)		return ret;	write_in_full(STDOUT_FILENO, output.buf, output.len);	return 0;}

int cmd_pack_refs(int argc, const char **argv, const char *prefix){	unsigned int flags = PACK_REFS_PRUNE;	struct option opts[] = {		OPT_BIT(0, "all",   &flags, N_("pack everything"), PACK_REFS_ALL),		OPT_BIT(0, "prune", &flags, N_("prune loose refs (default)"), PACK_REFS_PRUNE),		OPT_END(),	};	if (parse_options(argc, argv, prefix, opts, pack_refs_usage, 0))		usage_with_options(pack_refs_usage, opts);	return pack_refs(flags);}

int parse_options_subcommand(int argc, const char **argv, const struct option *options,			const char *const subcommands[], const char *usagestr[], int flags){	struct parse_opt_ctx_t ctx;	/* build usage string if it's not provided */	if (subcommands && !usagestr[0]) {		char *buf = NULL;		astrcatf(&buf, "%s %s [<options>] {", subcmd_config.exec_name, argv[0]);		for (int i = 0; subcommands[i]; i++) {			if (i)				astrcat(&buf, "|");			astrcat(&buf, subcommands[i]);		}		astrcat(&buf, "}");		usagestr[0] = buf;	}	parse_options_start(&ctx, argc, argv, flags);	switch (parse_options_step(&ctx, options, usagestr)) {	case PARSE_OPT_HELP:		exit(129);	case PARSE_OPT_DONE:		break;	case PARSE_OPT_LIST_OPTS:		while (options->type != OPTION_END) {			if (options->long_name)				printf("--%s ", options->long_name);			options++;		}		putchar('/n');		exit(130);	case PARSE_OPT_LIST_SUBCMDS:		if (subcommands) {			for (int i = 0; subcommands[i]; i++)				printf("%s ", subcommands[i]);		}		putchar('/n');		exit(130);	default: /* PARSE_OPT_UNKNOWN */		if (ctx.argv[0][1] == '-')			astrcatf(&error_buf, "unknown option `%s'",				 ctx.argv[0] + 2);		else			astrcatf(&error_buf, "unknown switch `%c'", *ctx.opt);		usage_with_options(usagestr, options);	}	return parse_options_end(&ctx);}

int cmd_push(int argc, const char **argv, const char *prefix){	int flags = 0;	int tags = 0;	int rc;	const char *repo = NULL;	/* default repository */	struct option options[] = {		OPT__VERBOSITY(&verbosity),		OPT_STRING( 0 , "repo", &repo, "repository", "repository"),		OPT_BIT( 0 , "all", &flags, "push all refs", TRANSPORT_PUSH_ALL),		OPT_BIT( 0 , "mirror", &flags, "mirror all refs",			    (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE)),		OPT_BOOLEAN( 0, "delete", &deleterefs, "delete refs"),		OPT_BOOLEAN( 0 , "tags", &tags, "push tags (can't be used with --all or --mirror)"),		OPT_BIT('n' , "dry-run", &flags, "dry run", TRANSPORT_PUSH_DRY_RUN),		OPT_BIT( 0,  "porcelain", &flags, "machine-readable output", TRANSPORT_PUSH_PORCELAIN),		OPT_BIT('f', "force", &flags, "force updates", TRANSPORT_PUSH_FORCE),		{ OPTION_CALLBACK, 0, "recurse-submodules", &flags, "check",			"controls recursive pushing of submodules",			PARSE_OPT_OPTARG, option_parse_recurse_submodules },		OPT_BOOLEAN( 0 , "thin", &thin, "use thin pack"),		OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", "receive pack program"),		OPT_STRING( 0 , "exec", &receivepack, "receive-pack", "receive pack program"),		OPT_BIT('u', "set-upstream", &flags, "set upstream for git pull/status",			TRANSPORT_PUSH_SET_UPSTREAM),		OPT_BOOLEAN(0, "progress", &progress, "force progress reporting"),		OPT_END()	};	packet_trace_identity("push");	git_config(git_default_config, NULL);	argc = parse_options(argc, argv, prefix, options, push_usage, 0);	if (deleterefs && (tags || (flags & (TRANSPORT_PUSH_ALL | TRANSPORT_PUSH_MIRROR))))		die(_("--delete is incompatible with --all, --mirror and --tags"));	if (deleterefs && argc < 2)		die(_("--delete doesn't make sense without any refs"));	if (tags)		add_refspec("refs/tags/*");	if (argc > 0) {		repo = argv[0];		set_refspecs(argv + 1, argc - 1);	}	rc = do_push(repo, flags);	if (rc == -1)		usage_with_options(push_usage, options);	else		return rc;}

void parse_revision_opt(struct rev_info *revs, struct parse_opt_ctx_t *ctx,			const struct option *options,			const char * const usagestr[]){	int n = handle_revision_opt(revs, ctx->argc, ctx->argv,				    &ctx->cpidx, ctx->out);	if (n <= 0) {		error("unknown option `%s'", ctx->argv[0]);		usage_with_options(usagestr, options);	}	ctx->argv += n;	ctx->argc -= n;}

int cmd_worktree(int ac, const char **av, const char *prefix){	struct option options[] = {		OPT_END()	};	if (ac < 2)		usage_with_options(worktree_usage, options);	if (!prefix)		prefix = "";	if (!strcmp(av[1], "add"))		return add(ac - 1, av + 1, prefix);	if (!strcmp(av[1], "prune"))		return prune(ac - 1, av + 1, prefix);	if (!strcmp(av[1], "list"))		return list(ac - 1, av + 1, prefix);	if (!strcmp(av[1], "lock"))		return lock_worktree(ac - 1, av + 1, prefix);	if (!strcmp(av[1], "unlock"))		return unlock_worktree(ac - 1, av + 1, prefix);	usage_with_options(worktree_usage, options);}

int cmd_push(int argc, const char **argv, const char *prefix){	int flags = 0;	int all = 0;	int mirror = 0;	int dry_run = 0;	int force = 0;	int tags = 0;	int rc;	const char *repo = NULL;	/* default repository */	struct option options[] = {		OPT__VERBOSE(&verbose),		OPT_STRING( 0 , "repo", &repo, "repository", "repository"),		OPT_BOOLEAN( 0 , "all", &all, "push all refs"),		OPT_BOOLEAN( 0 , "mirror", &mirror, "mirror all refs"),		OPT_BOOLEAN( 0 , "tags", &tags, "push tags"),		OPT_BOOLEAN( 0 , "dry-run", &dry_run, "dry run"),		OPT_BOOLEAN('f', "force", &force, "force updates"),		OPT_BOOLEAN( 0 , "thin", &thin, "use thin pack"),		OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", "receive pack program"),		OPT_STRING( 0 , "exec", &receivepack, "receive-pack", "receive pack program"),		OPT_END()	};	argc = parse_options(argc, argv, options, push_usage, 0);	if (force)		flags |= TRANSPORT_PUSH_FORCE;	if (dry_run)		flags |= TRANSPORT_PUSH_DRY_RUN;	if (verbose)		flags |= TRANSPORT_PUSH_VERBOSE;	if (tags)		add_refspec("refs/tags/*");	if (all)		flags |= TRANSPORT_PUSH_ALL;	if (mirror)		flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);	if (argc > 0) {		repo = argv[0];		set_refspecs(argv + 1, argc - 1);	}	rc = do_push(repo, flags);	if (rc == -1)		usage_with_options(push_usage, options);	else		return rc;}

static int __cmd_evlist(const char *file_name, struct perf_attr_details *details){	struct perf_session *session;	struct perf_evsel *pos;	struct perf_data_file file = {		.path = file_name,		.mode = PERF_DATA_MODE_READ,		.force = details->force,	};	session = perf_session__new(&file, 0, NULL);	if (session == NULL)		return -1;	evlist__for_each(session->evlist, pos)		perf_evsel__fprintf(pos, details, stdout);	perf_session__delete(session);	return 0;}int cmd_evlist(int argc, const char **argv, const char *prefix __maybe_unused){	struct perf_attr_details details = { .verbose = false, };	const struct option options[] = {	OPT_STRING('i', "input", &input_name, "file", "Input file name"),	OPT_BOOLEAN('F', "freq", &details.freq, "Show the sample frequency"),	OPT_BOOLEAN('v', "verbose", &details.verbose,		    "Show all event attr details"),	OPT_BOOLEAN('g', "group", &details.event_group,		    "Show event group information"),	OPT_BOOLEAN('f', "force", &details.force, "don't complain, do it"),	OPT_END()	};	const char * const evlist_usage[] = {		"perf evlist [<options>]",		NULL	};	argc = parse_options(argc, argv, options, evlist_usage, 0);	if (argc)		usage_with_options(evlist_usage, options);	if (details.event_group && (details.verbose || details.freq)) {		usage_with_options_msg(evlist_usage, options,			"--group option is not compatible with other options/n");	}	return __cmd_evlist(input_name, &details);}

static int get_ref(int argc, const char **argv, const char *prefix){	struct option options[] = { OPT_END() };	argc = parse_options(argc, argv, prefix, options,			     git_notes_get_ref_usage, 0);	if (argc) {		error("too many parameters");		usage_with_options(git_notes_get_ref_usage, options);	}	puts(default_notes_ref());	return 0;}

static int remove_worktree(int ac, const char **av, const char *prefix){	int force = 0;	struct option options[] = {		OPT_BOOL(0, "force", &force,			 N_("force removing even if the worktree is dirty")),		OPT_END()	};	struct worktree **worktrees, *wt;	struct strbuf errmsg = STRBUF_INIT;	const char *reason;	int ret = 0;	ac = parse_options(ac, av, prefix, options, worktree_usage, 0);	if (ac != 1)		usage_with_options(worktree_usage, options);	worktrees = get_worktrees(0);	wt = find_worktree(worktrees, prefix, av[0]);	if (!wt)		die(_("'%s' is not a working tree"), av[0]);	if (is_main_worktree(wt))		die(_("'%s' is a main working tree"), av[0]);	reason = is_worktree_locked(wt);	if (reason) {		if (*reason)			die(_("cannot remove a locked working tree, lock reason: %s"),			    reason);		die(_("cannot remove a locked working tree"));	}	if (validate_worktree(wt, &errmsg, WT_VALIDATE_WORKTREE_MISSING_OK))		die(_("validation failed, cannot remove working tree: %s"),		    errmsg.buf);	strbuf_release(&errmsg);	if (file_exists(wt->path)) {		if (!force)			check_clean_worktree(wt, av[0]);		ret |= delete_git_work_tree(wt);	}	/*	 * continue on even if ret is non-zero, there's no going back	 * from here.	 */	ret |= delete_git_dir(wt);	free_worktrees(worktrees);	return ret;}

void setup_sorting(const char * const usagestr[], const struct option *opts){	char *tmp, *tok, *str = strdup(sort_order);	for (tok = strtok_r(str, ", ", &tmp);			tok; tok = strtok_r(NULL, ", ", &tmp)) {		if (sort_dimension__add(tok) < 0) {			error("Unknown --sort key: `%s'", tok);			usage_with_options(usagestr, opts);		}	}	free(str);}

int main(int argc, char **argv){	const char * const usage[] = {		"git credential-store [<options>] <action>",		NULL	};	const char *op;	struct credential c = CREDENTIAL_INIT;	struct string_list fns = STRING_LIST_INIT_DUP;	char *file = NULL;	struct option options[] = {		OPT_STRING(0, "file", &file, "path",			   "fetch and store credentials in <path>"),		OPT_END()	};	umask(077);	argc = parse_options(argc, (const char **)argv, NULL, options, usage, 0);	if (argc != 1)		usage_with_options(usage, options);	op = argv[0];	if (file) {		string_list_append(&fns, file);	} else {		if ((file = expand_user_path("~/.git-credentials")))			string_list_append_nodup(&fns, file);		file = xdg_config_home("credentials");		if (file)			string_list_append_nodup(&fns, file);	}	if (!fns.nr)		die("unable to set up default path; use --file");	if (credential_read(&c, stdin) < 0)		die("unable to read credential");	if (!strcmp(op, "get"))		lookup_credential(&fns, &c);	else if (!strcmp(op, "erase"))		remove_credential(&fns, &c);	else if (!strcmp(op, "store"))		store_credential(&fns, &c);	else		; /* Ignore unknown operation. */	string_list_clear(&fns, 0);	return 0;}

int cmd_notes(int argc, const char **argv, const char *prefix){	int result;	const char *override_notes_ref = NULL;	struct option options[] = {		OPT_STRING(0, "ref", &override_notes_ref, "notes_ref",			   "use notes from <notes_ref>"),		OPT_END()	};	git_config(git_default_config, NULL);	argc = parse_options(argc, argv, prefix, options, git_notes_usage,			     PARSE_OPT_STOP_AT_NON_OPTION);	if (override_notes_ref) {		struct strbuf sb = STRBUF_INIT;		if (!prefixcmp(override_notes_ref, "refs/notes/"))			/* we're happy */;		else if (!prefixcmp(override_notes_ref, "notes/"))			strbuf_addstr(&sb, "refs/");		else			strbuf_addstr(&sb, "refs/notes/");		strbuf_addstr(&sb, override_notes_ref);		setenv("GIT_NOTES_REF", sb.buf, 1);		strbuf_release(&sb);	}	if (argc < 1 || !strcmp(argv[0], "list"))		result = list(argc, argv, prefix);	else if (!strcmp(argv[0], "add"))		result = add(argc, argv, prefix);	else if (!strcmp(argv[0], "copy"))		result = copy(argc, argv, prefix);	else if (!strcmp(argv[0], "append") || !strcmp(argv[0], "edit"))		result = append_edit(argc, argv, prefix);	else if (!strcmp(argv[0], "show"))		result = show(argc, argv, prefix);	else if (!strcmp(argv[0], "remove"))		result = remove_cmd(argc, argv, prefix);	else if (!strcmp(argv[0], "prune"))		result = prune(argc, argv, prefix);	else {		result = error("Unknown subcommand: %s", argv[0]);		usage_with_options(git_notes_usage, options);	}	return result ? 1 : 0;}

int cmd_update_server_info(int argc, const char **argv, const char *prefix){	int force = 0;	struct option options[] = {		OPT__FORCE(&force, N_("update the info files from scratch")),		OPT_END()	};	git_config(git_default_config, NULL);	argc = parse_options(argc, argv, prefix, options,			     update_server_info_usage, 0);	if (argc > 0)		usage_with_options(update_server_info_usage, options);	return !!update_server_info(force);}

static void parse_args(int argc, const char **argv){	const char * const * usage_str = revert_or_cherry_pick_usage();	int noop;#ifdef USE_CPLUSPLUS_FOR_INIT#pragma cplusplus on#endif	struct option options[] = {		OPT_BOOLEAN('n', "no-commit", &no_commit, "don't automatically commit"),		OPT_BOOLEAN('e', "edit", &edit, "edit the commit message"),		{ OPTION_BOOLEAN, 'r', NULL, &noop, NULL, "no-op (backward compatibility)",		  PARSE_OPT_NOARG | PARSE_OPT_HIDDEN, NULL, 0 },		OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),		OPT_INTEGER('m', "mainline", &mainline, "parent number"),		OPT_RERERE_AUTOUPDATE(&allow_rerere_auto),		OPT_STRING(0, "strategy", &strategy, "strategy", "merge strategy"),		OPT_CALLBACK('X', "strategy-option", &xopts, "option",			"option for merge strategy", option_parse_x),		OPT_END(),		OPT_END(),		OPT_END(),	};#ifdef USE_CPLUSPLUS_FOR_INIT#pragma cplusplus reset#endif	if (action == CHERRY_PICK) {		struct option cp_extra[] = {			OPT_BOOLEAN('x', NULL, &no_replay, "append commit name"),			OPT_BOOLEAN(0, "ff", &allow_ff, "allow fast-forward"),			OPT_END(),		};		if (parse_options_concat(options, ARRAY_SIZE(options), cp_extra))			die(_("program error"));	}	commit_argc = parse_options(argc, argv, NULL, options, usage_str,				    PARSE_OPT_KEEP_ARGV0 |				    PARSE_OPT_KEEP_UNKNOWN);	if (commit_argc < 2)		usage_with_options(usage_str, options);	commit_argv = argv;}

static int prune(int ac, const char **av, const char *prefix){	struct option options[] = {		OPT__DRY_RUN(&show_only, N_("do not remove, show only")),		OPT__VERBOSE(&verbose, N_("report pruned working trees")),		OPT_EXPIRY_DATE(0, "expire", &expire,				N_("expire working trees older than <time>")),		OPT_END()	};	expire = TIME_MAX;	ac = parse_options(ac, av, prefix, options, worktree_usage, 0);	if (ac)		usage_with_options(worktree_usage, options);	prune_worktrees();	return 0;}

int cmd_show_ref(int argc, const char **argv, const char *prefix){	if (argc == 2 && !strcmp(argv[1], "-h"))		usage_with_options(show_ref_usage, show_ref_options);	argc = parse_options(argc, argv, prefix, show_ref_options,			     show_ref_usage, PARSE_OPT_NO_INTERNAL_HELP);	if (exclude_arg)		return exclude_existing(exclude_existing_arg);	pattern = argv;	if (!*pattern)		pattern = NULL;	if (verify) {		if (!pattern)			die("--verify requires a reference");		while (*pattern) {			unsigned char sha1[20];			if (!prefixcmp(*pattern, "refs/") &&			    !read_ref(*pattern, sha1)) {				if (!quiet)					show_one(*pattern, sha1);			}			else if (!quiet)				die("'%s' - not a valid ref", *pattern);			else				return 1;			pattern++;		}		return 0;	}	if (show_head)		head_ref(show_ref, NULL);	for_each_ref(show_ref, NULL);	if (!found_match) {		if (verify && !quiet)			die("No match");		return 1;	}	return 0;}

int cmd_bisect__helper(int argc, const char **argv, const char *prefix){	int next_all = 0;	struct option options[] = {		OPT_BOOLEAN(0, "next-all", &next_all,			    "perform 'git bisect next'"),		OPT_END()	};	argc = parse_options(argc, argv, prefix, options,			     git_bisect_helper_usage, 0);	if (!next_all)		usage_with_options(git_bisect_helper_usage, options);	/* next-all */	return bisect_next_all(prefix);}

int cmd_column(int argc, const char **argv, const char *prefix){	struct string_list list = STRING_LIST_INIT_DUP;	struct strbuf sb = STRBUF_INIT;	struct column_options copts;	const char *command = NULL, *real_command = NULL;	struct option options[] = {		OPT_STRING(0, "command", &real_command, N_("name"), N_("lookup config vars")),		OPT_COLUMN(0, "mode", &colopts, N_("layout to use")),		OPT_INTEGER(0, "raw-mode", &colopts, N_("layout to use")),		OPT_INTEGER(0, "width", &copts.width, N_("Maximum width")),		OPT_STRING(0, "indent", &copts.indent, N_("string"), N_("Padding space on left border")),		OPT_INTEGER(0, "nl", &copts.nl, N_("Padding space on right border")),		OPT_INTEGER(0, "padding", &copts.padding, N_("Padding space between columns")),		OPT_END()	};	git_config(platform_core_config, NULL);	/* This one is special and must be the first one */	if (argc > 1 && starts_with(argv[1], "--command=")) {		command = argv[1] + 10;		git_config(column_config, (void *)command);	} else		git_config(column_config, NULL);	memset(&copts, 0, sizeof(copts));	copts.width = term_columns();	copts.padding = 1;	argc = parse_options(argc, argv, "", options, builtin_column_usage, 0);	if (argc)		usage_with_options(builtin_column_usage, options);	if (real_command || command) {		if (!real_command || !command || strcmp(real_command, command))			die(_("--command must be the first argument"));	}	finalize_colopts(&colopts, -1);	while (!strbuf_getline(&sb, stdin))		string_list_append(&list, sb.buf);	print_columns(&list, colopts, &copts);	return 0;}

int cmd_merge_base(int argc, const char **argv, const char *prefix){	struct commit **rev;	int rev_nr = 0;	int show_all = 0;	struct option options[] = {		OPT_BOOLEAN('a', "all", &show_all, "outputs all common ancestors"),		OPT_END()	};	git_config(git_default_config, NULL);	argc = parse_options(argc, argv, prefix, options, merge_base_usage, 0);	if (argc < 2)		usage_with_options(merge_base_usage, options);	rev = xmalloc(argc * sizeof(*rev));	while (argc-- > 0)		rev[rev_nr++] = get_commit_reference(*argv++);	return show_merge_base(rev, rev_nr, show_all);}

int main(int argc, const char **argv){	const char * const usage[] = {		"git credential-store [options] <action>",		NULL	};	const char *op;	struct credential c = CREDENTIAL_INIT;	char *file = NULL;	struct option options[] = {		OPT_STRING(0, "file", &file, "path",			   "fetch and store credentials in <path>"),		OPT_END()	};	umask(077);	argc = parse_options(argc, argv, NULL, options, usage, 0);	if (argc != 1)		usage_with_options(usage, options);	op = argv[0];	if (!file)		file = expand_user_path("~/.git-credentials");	if (!file)		die("unable to set up default path; use --file");	if (credential_read(&c, stdin) < 0)		die("unable to read credential");	if (!strcmp(op, "get"))		lookup_credential(file, &c);	else if (!strcmp(op, "erase"))		remove_credential(file, &c);	else if (!strcmp(op, "store"))		store_credential(file, &c);	else		; /* Ignore unknown operation. */	return 0;}

int cmd_push(int argc, const char **argv, const char *prefix){	int flags = 0;	int tags = 0;	int rc;	const char *repo = NULL;	/* default repository */	struct option options[] = {		OPT_BIT('q', "quiet", &flags, "be quiet", TRANSPORT_PUSH_QUIET),		OPT_BIT('v', "verbose", &flags, "be verbose", TRANSPORT_PUSH_VERBOSE),		OPT_STRING( 0 , "repo", &repo, "repository", "repository"),		OPT_BIT( 0 , "all", &flags, "push all refs", TRANSPORT_PUSH_ALL),		OPT_BIT( 0 , "mirror", &flags, "mirror all refs",			    (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE)),		OPT_BOOLEAN( 0 , "tags", &tags, "push tags"),		OPT_BIT('n' , "dry-run", &flags, "dry run", TRANSPORT_PUSH_DRY_RUN),		OPT_BIT( 0,  "porcelain", &flags, "machine-readable output", TRANSPORT_PUSH_PORCELAIN),		OPT_BIT('f', "force", &flags, "force updates", TRANSPORT_PUSH_FORCE),		OPT_BOOLEAN( 0 , "thin", &thin, "use thin pack"),		OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", "receive pack program"),		OPT_STRING( 0 , "exec", &receivepack, "receive-pack", "receive pack program"),		OPT_END()	};	argc = parse_options(argc, argv, prefix, options, push_usage, 0);	if (tags)		add_refspec("refs/tags/*");	if (argc > 0) {		repo = argv[0];		set_refspecs(argv + 1, argc - 1);	}	rc = do_push(repo, flags);	if (rc == -1)		usage_with_options(push_usage, options);	else		return rc;}

int main(int argc, const char **argv){	char *socket_path = NULL;	int timeout = 900;	const char *op;	const char * const usage[] = {		"git credential-cache [<options>] <action>",		NULL	};	struct option options[] = {		OPT_INTEGER(0, "timeout", &timeout,			    "number of seconds to cache credentials"),		OPT_STRING(0, "socket", &socket_path, "path",			   "path of cache-daemon socket"),		OPT_END()	};	argc = parse_options(argc, argv, NULL, options, usage, 0);	if (!argc)		usage_with_options(usage, options);	op = argv[0];	if (!socket_path)		socket_path = expand_user_path("~/.git-credential-cache/socket");	if (!socket_path)		die("unable to find a suitable socket path; use --socket");	if (!strcmp(op, "exit"))		do_cache(socket_path, op, timeout, 0);	else if (!strcmp(op, "get") || !strcmp(op, "erase"))		do_cache(socket_path, op, timeout, FLAG_RELAY);	else if (!strcmp(op, "store"))		do_cache(socket_path, op, timeout, FLAG_RELAY|FLAG_SPAWN);	else		; /* ignore unknown operation */	return 0;}

int cmd_main(int argc, const char **argv){	const char *dir;	int strict = 0;	struct option options[] = {		OPT_BOOL(0, "stateless-rpc", &stateless_rpc,			 N_("quit after a single request/response exchange")),		OPT_BOOL(0, "advertise-refs", &advertise_refs,			 N_("exit immediately after intial ref advertisement")),		OPT_BOOL(0, "strict", &strict,			 N_("do not try <directory>/.git/ if <directory> is no Git directory")),		OPT_INTEGER(0, "timeout", &timeout,			    N_("interrupt transfer after <n> seconds of inactivity")),		OPT_END()	};	packet_trace_identity("upload-pack");	check_replace_refs = 0;	argc = parse_options(argc, argv, NULL, options, upload_pack_usage, 0);	if (argc != 1)		usage_with_options(upload_pack_usage, options);	if (timeout)		daemon_mode = 1;	setup_path();	dir = argv[0];	if (!enter_repo(dir, strict))		die("'%s' does not appear to be a git repository", dir);	git_config(upload_pack_config, NULL);	upload_pack();	return 0;}

int cmd_verify_tag(int argc, const char **argv, const char *prefix){	int i = 1, verbose = 0, had_error = 0;	const struct option verify_tag_options[] = {		OPT__VERBOSE(&verbose, "print tag contents"),		OPT_END()	};	git_config(git_default_config, NULL);	argc = parse_options(argc, argv, prefix, verify_tag_options,			     verify_tag_usage, PARSE_OPT_KEEP_ARGV0);	if (argc <= i)		usage_with_options(verify_tag_usage, verify_tag_options);	/* sometimes the program was terminated because this signal	 * was received in the process of writing the gpg input: */	signal(SIGPIPE, SIG_IGN);	while (i < argc)		if (verify_tag(argv[i++], verbose))			had_error = 1;	return had_error;}

int parse_options(int argc, const char **argv, const char *prefix,		  const struct option *options, const char * const usagestr[],		  int flags){	struct parse_opt_ctx_t ctx;	parse_options_start(&ctx, argc, argv, prefix, flags);	switch (parse_options_step(&ctx, options, usagestr)) {	case PARSE_OPT_HELP:		exit(129);	case PARSE_OPT_DONE:		break;	default: /* PARSE_OPT_UNKNOWN */		if (ctx.argv[0][1] == '-') {			error("unknown option `%s'", ctx.argv[0] + 2);		} else {			error("unknown switch `%c'", *ctx.opt);		}		usage_with_options(usagestr, options);	}	return parse_options_end(&ctx);}

int cmd_stripspace(int argc, const char **argv, const char *prefix){	struct strbuf buf = STRBUF_INIT;	enum stripspace_mode mode = STRIP_DEFAULT;	int nongit;	const struct option options[] = {		OPT_CMDMODE('s', "strip-comments", &mode,			    N_("skip and remove all lines starting with comment character"),			    STRIP_COMMENTS),		OPT_CMDMODE('c', "comment-lines", &mode,			    N_("prepend comment character and space to each line"),			    COMMENT_LINES),		OPT_END()	};	argc = parse_options(argc, argv, prefix, options, stripspace_usage, 0);	if (argc)		usage_with_options(stripspace_usage, options);	if (mode == STRIP_COMMENTS || mode == COMMENT_LINES) {		setup_git_directory_gently(&nongit);		git_config(git_default_config, NULL);	}	if (strbuf_read(&buf, 0, 1024) < 0)		die_errno("could not read the input");	if (mode == STRIP_DEFAULT || mode == STRIP_COMMENTS)		strbuf_stripspace(&buf, mode == STRIP_COMMENTS);	else		comment_lines(&buf);	write_or_die(1, buf.buf, buf.len);	strbuf_release(&buf);	return 0;}

static int show(int argc, const char **argv, const char *prefix){	const char *object_ref;	struct notes_tree *t;	unsigned char object[20];	const unsigned char *note;	int retval;	struct option options[] = {		OPT_END()	};	argc = parse_options(argc, argv, prefix, options, git_notes_show_usage,			     0);	if (1 < argc) {		error("too many parameters");		usage_with_options(git_notes_show_usage, options);	}	object_ref = argc ? argv[0] : "HEAD";	if (get_sha1(object_ref, object))		die("Failed to resolve '%s' as a valid ref.", object_ref);	t = init_notes_check("show");	note = get_note(t, object);	if (!note)		retval = error("No note found for object %s.",			       sha1_to_hex(object));	else {		const char *show_args[3] = {"show", sha1_to_hex(note), NULL};		retval = execv_git_cmd(show_args);	}	free_notes(t);	return retval;}

int cmd_merge_base(int argc, const char **argv, const char *prefix){    struct commit **rev;    int rev_nr = 0;    int show_all = 0;    int octopus = 0;    int reduce = 0;    int is_ancestor = 0;    struct option options[] = {        OPT_BOOLEAN('a', "all", &show_all, N_("output all common ancestors")),        OPT_BOOLEAN(0, "octopus", &octopus, N_("find ancestors for a single n-way merge")),        OPT_BOOLEAN(0, "independent", &reduce, N_("list revs not reachable from others")),        OPT_BOOLEAN(0, "is-ancestor", &is_ancestor,        N_("is the first one ancestor of the other?")),        OPT_END()    };    git_config(git_default_config, NULL);    argc = parse_options(argc, argv, prefix, options, merge_base_usage, 0);    if (!octopus && !reduce && argc < 2)        usage_with_options(merge_base_usage, options);    if (is_ancestor && (show_all | octopus | reduce))        die("--is-ancestor cannot be used with other options");    if (is_ancestor)        return handle_is_ancestor(argc, argv);    if (reduce && (show_all || octopus))        die("--independent cannot be used with other options");    if (octopus || reduce)        return handle_octopus(argc, argv, reduce, show_all);    rev = xmalloc(argc * sizeof(*rev));    while (argc-- > 0)        rev[rev_nr++] = get_commit_reference(*argv++);    return show_merge_base(rev, rev_nr, show_all);}

int cmd_main(int argc, const char **argv){	const char *socket_path;	int ignore_sighup = 0;	static const char *usage[] = {		"git-credential-cache--daemon [opts] <socket_path>",		NULL	};	int debug = 0;	const struct option options[] = {		OPT_BOOL(0, "debug", &debug,			 N_("print debugging messages to stderr")),		OPT_END()	};	git_config_get_bool("credentialcache.ignoresighup", &ignore_sighup);	argc = parse_options(argc, argv, NULL, options, usage, 0);	socket_path = argv[0];	if (!socket_path)		usage_with_options(usage, options);	if (!is_absolute_path(socket_path))		die("socket directory must be an absolute path");	init_socket_directory(socket_path);	register_tempfile(&socket_file, socket_path);	if (ignore_sighup)		signal(SIGHUP, SIG_IGN);	serve_cache(socket_path, debug);	delete_tempfile(&socket_file);	return 0;}