mirrors/git
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use OPT_CALLBACK and OPT_CALLBACK_F

Browse Source 
In the codebase, there are many options which use OPTION_CALLBACK in a
plain ol' struct definition. However, we have the OPT_CALLBACK and
OPT_CALLBACK_F macros which are meant to abstract these plain struct
definitions away. These macros are useful as they semantically signal to
developers that these are just normal callback option with nothing fancy
happening.

Replace plain struct definitions of OPTION_CALLBACK with OPT_CALLBACK or
OPT_CALLBACK_F where applicable. The heavy lifting was done using the
following (disgusting) shell script:

	#!/bin/sh

	do_replacement () {
		tr '\n' '\r' |
			sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\s*0,\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK(\1,\2,\3,\4,\5,\6)/g' |
			sed -e 's/{\s*OPTION_CALLBACK,\s*\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\([^,]*\),\(\s*[^[:space:]}]*\)\s*}/OPT_CALLBACK_F(\1,\2,\3,\4,\5,\6,\7)/g' |
			tr '\r' '\n'
	}

	for f in $(git ls-files \*.c)
	do
		do_replacement <"$f" >"$f.tmp"
		mv "$f.tmp" "$f"
	done

The result was manually inspected and then reformatted to match the
style of the surrounding code. Finally, using
`git grep OPTION_CALLBACK \*.c`, leftover results which were not handled
by the script were manually transformed.

Signed-off-by: Denton Liu <liu.denton@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
This commit is contained in:
Denton Liu
2020-04-28 04:36:28 -04:00
committed by Junio C Hamano
parent e870325ee8
commit 203c85339f
31 changed files with 173 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
apply.c
View File

@ -4964,15 +4964,15 @@ int apply_parse_options(int argc, const char **argv,
const char * const *apply_usage) const char * const *apply_usage)
{ {
struct option builtin_apply_options[] = { struct option builtin_apply_options[] = {
{ OPTION_CALLBACK, 0, "exclude", state, N_("path"), OPT_CALLBACK_F(0, "exclude", state, N_("path"),
N_("don't apply changes matching the given path"), N_("don't apply changes matching the given path"),
PARSE_OPT_NONEG, apply_option_parse_exclude }, PARSE_OPT_NONEG, apply_option_parse_exclude),
{ OPTION_CALLBACK, 0, "include", state, N_("path"), OPT_CALLBACK_F(0, "include", state, N_("path"),
N_("apply changes matching the given path"), N_("apply changes matching the given path"),
PARSE_OPT_NONEG, apply_option_parse_include }, PARSE_OPT_NONEG, apply_option_parse_include),
{ OPTION_CALLBACK, 'p', NULL, state, N_("num"), OPT_CALLBACK('p', NULL, state, N_("num"),
N_("remove <num> leading slashes from traditional diff paths"), N_("remove <num> leading slashes from traditional diff paths"),
0, apply_option_parse_p }, apply_option_parse_p),
OPT_BOOL(0, "no-add", &state->no_add, OPT_BOOL(0, "no-add", &state->no_add,
N_("ignore additions made by the patch")), N_("ignore additions made by the patch")),
OPT_BOOL(0, "stat", &state->diffstat, OPT_BOOL(0, "stat", &state->diffstat,
@ -5005,15 +5005,15 @@ int apply_parse_options(int argc, const char **argv,
N_("paths are separated with NUL character"), '\0'), N_("paths are separated with NUL character"), '\0'),
OPT_INTEGER('C', NULL, &state->p_context, OPT_INTEGER('C', NULL, &state->p_context,
N_("ensure at least <n> lines of context match")), N_("ensure at least <n> lines of context match")),
{ OPTION_CALLBACK, 0, "whitespace", state, N_("action"), OPT_CALLBACK(0, "whitespace", state, N_("action"),
N_("detect new or modified lines that have whitespace errors"), N_("detect new or modified lines that have whitespace errors"),
0, apply_option_parse_whitespace }, apply_option_parse_whitespace),
{ OPTION_CALLBACK, 0, "ignore-space-change", state, NULL, OPT_CALLBACK_F(0, "ignore-space-change", state, NULL,
N_("ignore changes in whitespace when finding context"), N_("ignore changes in whitespace when finding context"),
PARSE_OPT_NOARG, apply_option_parse_space_change }, PARSE_OPT_NOARG, apply_option_parse_space_change),
{ OPTION_CALLBACK, 0, "ignore-whitespace", state, NULL, OPT_CALLBACK_F(0, "ignore-whitespace", state, NULL,
N_("ignore changes in whitespace when finding context"), N_("ignore changes in whitespace when finding context"),
PARSE_OPT_NOARG, apply_option_parse_space_change }, PARSE_OPT_NOARG, apply_option_parse_space_change),
OPT_BOOL('R', "reverse", &state->apply_in_reverse, OPT_BOOL('R', "reverse", &state->apply_in_reverse,
N_("apply the patch in reverse")), N_("apply the patch in reverse")),
OPT_BOOL(0, "unidiff-zero", &state->unidiff_zero, OPT_BOOL(0, "unidiff-zero", &state->unidiff_zero,
@ -5029,9 +5029,9 @@ int apply_parse_options(int argc, const char **argv,
OPT_BIT(0, "recount", options, OPT_BIT(0, "recount", options,
N_("do not trust the line counts in the hunk headers"), N_("do not trust the line counts in the hunk headers"),
APPLY_OPT_RECOUNT), APPLY_OPT_RECOUNT),
{ OPTION_CALLBACK, 0, "directory", state, N_("root"), OPT_CALLBACK(0, "directory", state, N_("root"),
N_("prepend <root> to all filenames"), N_("prepend <root> to all filenames"),
0, apply_option_parse_directory }, apply_option_parse_directory),
OPT_END() OPT_END()
}; };

4
builtin/add.c
View File

@ -330,10 +330,10 @@ static struct option builtin_add_options[] = {
OPT_BOOL(0, "renormalize", &add_renormalize, N_("renormalize EOL of tracked files (implies -u)")), OPT_BOOL(0, "renormalize", &add_renormalize, N_("renormalize EOL of tracked files (implies -u)")),
OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")), OPT_BOOL('N', "intent-to-add", &intent_to_add, N_("record only the fact that the path will be added later")),
OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")), OPT_BOOL('A', "all", &addremove_explicit, N_("add changes from all tracked and untracked files")),
{ OPTION_CALLBACK, 0, "ignore-removal", &addremove_explicit, OPT_CALLBACK_F(0, "ignore-removal", &addremove_explicit,
NULL /* takes no arguments */, NULL /* takes no arguments */,
N_("ignore paths removed in the working tree (same as --no-all)"), N_("ignore paths removed in the working tree (same as --no-all)"),
PARSE_OPT_NOARG, ignore_removal_cb }, PARSE_OPT_NOARG, ignore_removal_cb),
OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")), OPT_BOOL( 0 , "refresh", &refresh_only, N_("don't add, only refresh the index")),
OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")), OPT_BOOL( 0 , "ignore-errors", &ignore_add_errors, N_("just skip files which cannot be added because of errors")),
OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")), OPT_BOOL( 0 , "ignore-missing", &ignore_missing, N_("check if - even missing - files are ignored in dry run")),

4
builtin/blame.c
View File

@ -864,8 +864,8 @@ int cmd_blame(int argc, const char **argv, const char *prefix)
OPT_BIT(0, "minimal", &xdl_opts, N_("Spend extra cycles to find better match"), XDF_NEED_MINIMAL), OPT_BIT(0, "minimal", &xdl_opts, N_("Spend extra cycles to find better match"), XDF_NEED_MINIMAL),
OPT_STRING('S', NULL, &revs_file, N_("file"), N_("Use revisions from <file> instead of calling git-rev-list")), OPT_STRING('S', NULL, &revs_file, N_("file"), N_("Use revisions from <file> instead of calling git-rev-list")),
OPT_STRING(0, "contents", &contents_from, N_("file"), N_("Use <file>'s contents as the final image")), OPT_STRING(0, "contents", &contents_from, N_("file"), N_("Use <file>'s contents as the final image")),
{ OPTION_CALLBACK, 'C', NULL, &opt, N_("score"), N_("Find line copies within and across files"), PARSE_OPT_OPTARG, blame_copy_callback }, OPT_CALLBACK_F('C', NULL, &opt, N_("score"), N_("Find line copies within and across files"), PARSE_OPT_OPTARG, blame_copy_callback),
{ OPTION_CALLBACK, 'M', NULL, &opt, N_("score"), N_("Find line movements within and across files"), PARSE_OPT_OPTARG, blame_move_callback }, OPT_CALLBACK_F('M', NULL, &opt, N_("score"), N_("Find line movements within and across files"), PARSE_OPT_OPTARG, blame_move_callback),
OPT_STRING_LIST('L', NULL, &range_list, N_("n,m"), N_("Process only line range n,m, counting from 1")), OPT_STRING_LIST('L', NULL, &range_list, N_("n,m"), N_("Process only line range n,m, counting from 1")),
OPT__ABBREV(&abbrev), OPT__ABBREV(&abbrev),
OPT_END() OPT_END()

6
builtin/branch.c
View File

@ -653,10 +653,8 @@ int cmd_branch(int argc, const char **argv, const char *prefix)
OPT_NO_MERGED(&filter, N_("print only branches that are not merged")), OPT_NO_MERGED(&filter, N_("print only branches that are not merged")),
OPT_COLUMN(0, "column", &colopts, N_("list branches in columns")), OPT_COLUMN(0, "column", &colopts, N_("list branches in columns")),
OPT_REF_SORT(sorting_tail), OPT_REF_SORT(sorting_tail),
{ OPT_CALLBACK(0, "points-at", &filter.points_at, N_("object"),
OPTION_CALLBACK, 0, "points-at", &filter.points_at, N_("object"), N_("print only branches of the object"), parse_opt_object_name),
N_("print only branches of the object"), 0, parse_opt_object_name
},
OPT_BOOL('i', "ignore-case", &icase, N_("sorting and filtering are case insensitive")), OPT_BOOL('i', "ignore-case", &icase, N_("sorting and filtering are case insensitive")),
OPT_STRING( 0 , "format", &format.format, N_("format"), N_("format to use for the output")), OPT_STRING( 0 , "format", &format.format, N_("format"), N_("format to use for the output")),
OPT_END(), OPT_END(),

8
builtin/cat-file.c
View File

@ -650,14 +650,14 @@ int cmd_cat_file(int argc, const char **argv, const char *prefix)
OPT_BOOL(0, "allow-unknown-type", &unknown_type, OPT_BOOL(0, "allow-unknown-type", &unknown_type,
N_("allow -s and -t to work with broken/corrupt objects")), N_("allow -s and -t to work with broken/corrupt objects")),
OPT_BOOL(0, "buffer", &batch.buffer_output, N_("buffer --batch output")), OPT_BOOL(0, "buffer", &batch.buffer_output, N_("buffer --batch output")),
{ OPTION_CALLBACK, 0, "batch", &batch, "format", OPT_CALLBACK_F(0, "batch", &batch, "format",
N_("show info and content of objects fed from the standard input"), N_("show info and content of objects fed from the standard input"),
PARSE_OPT_OPTARG | PARSE_OPT_NONEG, PARSE_OPT_OPTARG | PARSE_OPT_NONEG,
batch_option_callback }, batch_option_callback),
{ OPTION_CALLBACK, 0, "batch-check", &batch, "format", OPT_CALLBACK_F(0, "batch-check", &batch, "format",
N_("show info about objects fed from the standard input"), N_("show info about objects fed from the standard input"),
PARSE_OPT_OPTARG | PARSE_OPT_NONEG, PARSE_OPT_OPTARG | PARSE_OPT_NONEG,
batch_option_callback }, batch_option_callback),
OPT_BOOL(0, "follow-symlinks", &batch.follow_symlinks, OPT_BOOL(0, "follow-symlinks", &batch.follow_symlinks,
N_("follow in-tree symlinks (used with --batch or --batch-check)")), N_("follow in-tree symlinks (used with --batch or --batch-check)")),
OPT_BOOL(0, "batch-all-objects", &batch.all_objects, OPT_BOOL(0, "batch-all-objects", &batch.all_objects,

4
builtin/checkout-index.c
View File

@ -177,9 +177,9 @@ int cmd_checkout_index(int argc, const char **argv, const char *prefix)
N_("write the content to temporary files")), N_("write the content to temporary files")),
OPT_STRING(0, "prefix", &state.base_dir, N_("string"), OPT_STRING(0, "prefix", &state.base_dir, N_("string"),
N_("when creating files, prepend <string>")), N_("when creating files, prepend <string>")),
{ OPTION_CALLBACK, 0, "stage", NULL, "(1|2|3|all)", OPT_CALLBACK_F(0, "stage", NULL, "(1|2|3|all)",
N_("copy out the files from named stage"), N_("copy out the files from named stage"),
PARSE_OPT_NONEG, option_parse_stage }, PARSE_OPT_NONEG, option_parse_stage),
OPT_END() OPT_END()
}; };

4
builtin/checkout.c
View File

@ -1486,9 +1486,9 @@ static struct option *add_common_options(struct checkout_opts *opts,
{ {
struct option options[] = { struct option options[] = {
OPT__QUIET(&opts->quiet, N_("suppress progress reporting")), OPT__QUIET(&opts->quiet, N_("suppress progress reporting")),
{ OPTION_CALLBACK, 0, "recurse-submodules", NULL, OPT_CALLBACK_F(0, "recurse-submodules", NULL,
"checkout", "control recursive updating of submodules", "checkout", "control recursive updating of submodules",
PARSE_OPT_OPTARG, option_parse_recurse_submodules_worktree_updater }, PARSE_OPT_OPTARG, option_parse_recurse_submodules_worktree_updater),
OPT_BOOL(0, "progress", &opts->show_progress, N_("force progress reporting")), OPT_BOOL(0, "progress", &opts->show_progress, N_("force progress reporting")),
OPT_BOOL('m', "merge", &opts->merge, N_("perform a 3-way merge with the new branch")), OPT_BOOL('m', "merge", &opts->merge, N_("perform a 3-way merge with the new branch")),
OPT_STRING(0, "conflict", &opts->conflict_style, N_("style"), OPT_STRING(0, "conflict", &opts->conflict_style, N_("style"),

4
builtin/clean.c
View File

@ -906,8 +906,8 @@ int cmd_clean(int argc, const char **argv, const char *prefix)
OPT_BOOL('i', "interactive", &interactive, N_("interactive cleaning")), OPT_BOOL('i', "interactive", &interactive, N_("interactive cleaning")),
OPT_BOOL('d', NULL, &remove_directories, OPT_BOOL('d', NULL, &remove_directories,
N_("remove whole directories")), N_("remove whole directories")),
{ OPTION_CALLBACK, 'e', "exclude", &exclude_list, N_("pattern"), OPT_CALLBACK_F('e', "exclude", &exclude_list, N_("pattern"),
N_("add <pattern> to ignore rules"), PARSE_OPT_NONEG, exclude_cb }, N_("add <pattern> to ignore rules"), PARSE_OPT_NONEG, exclude_cb),
OPT_BOOL('x', NULL, &ignored, N_("remove ignored files, too")), OPT_BOOL('x', NULL, &ignored, N_("remove ignored files, too")),
OPT_BOOL('X', NULL, &ignored_only, OPT_BOOL('X', NULL, &ignored_only,
N_("remove only ignored files")), N_("remove only ignored files")),

12
builtin/commit-tree.c
View File

@ -108,15 +108,15 @@ int cmd_commit_tree(int argc, const char **argv, const char *prefix)
struct object_id commit_oid; struct object_id commit_oid;
struct option options[] = { struct option options[] = {
{ OPTION_CALLBACK, 'p', NULL, &parents, N_("parent"), OPT_CALLBACK_F('p', NULL, &parents, N_("parent"),
N_("id of a parent commit object"), PARSE_OPT_NONEG, N_("id of a parent commit object"), PARSE_OPT_NONEG,
parse_parent_arg_callback }, parse_parent_arg_callback),
{ OPTION_CALLBACK, 'm', NULL, &buffer, N_("message"), OPT_CALLBACK_F('m', NULL, &buffer, N_("message"),
N_("commit message"), PARSE_OPT_NONEG, N_("commit message"), PARSE_OPT_NONEG,
parse_message_arg_callback }, parse_message_arg_callback),
{ OPTION_CALLBACK, 'F', NULL, &buffer, N_("file"), OPT_CALLBACK_F('F', NULL, &buffer, N_("file"),
N_("read commit log message from file"), PARSE_OPT_NONEG, N_("read commit log message from file"), PARSE_OPT_NONEG,
parse_file_arg_callback }, parse_file_arg_callback),
{ OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"), { OPTION_STRING, 'S', "gpg-sign", &sign_commit, N_("key-id"),
N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" }, N_("GPG sign commit"), PARSE_OPT_OPTARG, NULL, (intptr_t) "" },
OPT_END() OPT_END()

8
builtin/commit.c
View File

@ -1372,9 +1372,9 @@ int cmd_status(int argc, const char **argv, const char *prefix)
N_("show stash information")), N_("show stash information")),
OPT_BOOL(0, "ahead-behind", &s.ahead_behind_flags, OPT_BOOL(0, "ahead-behind", &s.ahead_behind_flags,
N_("compute full ahead/behind values")), N_("compute full ahead/behind values")),
{ OPTION_CALLBACK, 0, "porcelain", &status_format, OPT_CALLBACK_F(0, "porcelain", &status_format,
N_("version"), N_("machine-readable output"), N_("version"), N_("machine-readable output"),
PARSE_OPT_OPTARG, opt_parse_porcelain }, PARSE_OPT_OPTARG, opt_parse_porcelain),
OPT_SET_INT(0, "long", &status_format, OPT_SET_INT(0, "long", &status_format,
N_("show status in long format (default)"), N_("show status in long format (default)"),
STATUS_FORMAT_LONG), STATUS_FORMAT_LONG),
@ -1393,9 +1393,9 @@ int cmd_status(int argc, const char **argv, const char *prefix)
PARSE_OPT_OPTARG, NULL, (intptr_t)"all" }, PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")), OPT_COLUMN(0, "column", &s.colopts, N_("list untracked files in columns")),
OPT_BOOL(0, "no-renames", &no_renames, N_("do not detect renames")), OPT_BOOL(0, "no-renames", &no_renames, N_("do not detect renames")),
{ OPTION_CALLBACK, 'M', "find-renames", &rename_score_arg, OPT_CALLBACK_F('M', "find-renames", &rename_score_arg,
N_("n"), N_("detect renames, optionally set similarity index"), N_("n"), N_("detect renames, optionally set similarity index"),
PARSE_OPT_OPTARG | PARSE_OPT_NONEG, opt_parse_rename_score }, PARSE_OPT_OPTARG | PARSE_OPT_NONEG, opt_parse_rename_score),
OPT_END(), OPT_END(),
}; };

12
builtin/fetch.c
View File

@ -156,9 +156,9 @@ static struct option builtin_fetch_options[] = {
N_("prune remote-tracking branches no longer on remote")), N_("prune remote-tracking branches no longer on remote")),
OPT_BOOL('P', "prune-tags", &prune_tags, OPT_BOOL('P', "prune-tags", &prune_tags,
N_("prune local tags no longer on remote and clobber changed tags")), N_("prune local tags no longer on remote and clobber changed tags")),
{ OPTION_CALLBACK, 0, "recurse-submodules", &recurse_submodules, N_("on-demand"), OPT_CALLBACK_F(0, "recurse-submodules", &recurse_submodules, N_("on-demand"),
N_("control recursive fetching of submodules"), N_("control recursive fetching of submodules"),
PARSE_OPT_OPTARG, option_fetch_parse_recurse_submodules }, PARSE_OPT_OPTARG, option_fetch_parse_recurse_submodules),
OPT_BOOL(0, "dry-run", &dry_run, OPT_BOOL(0, "dry-run", &dry_run,
N_("dry run")), N_("dry run")),
OPT_BOOL('k', "keep", &keep, N_("keep downloaded pack")), OPT_BOOL('k', "keep", &keep, N_("keep downloaded pack")),
@ -178,15 +178,15 @@ static struct option builtin_fetch_options[] = {
1, PARSE_OPT_NONEG), 1, PARSE_OPT_NONEG),
{ OPTION_STRING, 0, "submodule-prefix", &submodule_prefix, N_("dir"), { OPTION_STRING, 0, "submodule-prefix", &submodule_prefix, N_("dir"),
N_("prepend this to submodule path output"), PARSE_OPT_HIDDEN }, N_("prepend this to submodule path output"), PARSE_OPT_HIDDEN },
{ OPTION_CALLBACK, 0, "recurse-submodules-default", OPT_CALLBACK_F(0, "recurse-submodules-default",
&recurse_submodules_default, N_("on-demand"), &recurse_submodules_default, N_("on-demand"),
N_("default for recursive fetching of submodules " N_("default for recursive fetching of submodules "
"(lower priority than config files)"), "(lower priority than config files)"),
PARSE_OPT_HIDDEN, option_fetch_parse_recurse_submodules }, PARSE_OPT_HIDDEN, option_fetch_parse_recurse_submodules),
OPT_BOOL(0, "update-shallow", &update_shallow, OPT_BOOL(0, "update-shallow", &update_shallow,
N_("accept refs that update .git/shallow")), N_("accept refs that update .git/shallow")),
{ OPTION_CALLBACK, 0, "refmap", NULL, N_("refmap"), OPT_CALLBACK_F(0, "refmap", NULL, N_("refmap"),
N_("specify fetch refmap"), PARSE_OPT_NONEG, parse_refmap_arg }, N_("specify fetch refmap"), PARSE_OPT_NONEG, parse_refmap_arg),
OPT_STRING_LIST('o', "server-option", &server_options, N_("server-specific"), N_("option to transmit")), OPT_STRING_LIST('o', "server-option", &server_options, N_("server-specific"), N_("option to transmit")),
OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"), OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"),
TRANSPORT_FAMILY_IPV4), TRANSPORT_FAMILY_IPV4),

26
builtin/grep.c
View File

@ -886,20 +886,20 @@ int cmd_grep(int argc, const char **argv, const char *prefix)
OPT_GROUP(""), OPT_GROUP(""),
OPT_CALLBACK('f', NULL, &opt, N_("file"), OPT_CALLBACK('f', NULL, &opt, N_("file"),
N_("read patterns from file"), file_callback), N_("read patterns from file"), file_callback),
{ OPTION_CALLBACK, 'e', NULL, &opt, N_("pattern"), OPT_CALLBACK_F('e', NULL, &opt, N_("pattern"),
N_("match <pattern>"), PARSE_OPT_NONEG, pattern_callback }, N_("match <pattern>"), PARSE_OPT_NONEG, pattern_callback),
{ OPTION_CALLBACK, 0, "and", &opt, NULL, OPT_CALLBACK_F(0, "and", &opt, NULL,
N_("combine patterns specified with -e"), N_("combine patterns specified with -e"),
PARSE_OPT_NOARG | PARSE_OPT_NONEG, and_callback }, PARSE_OPT_NOARG | PARSE_OPT_NONEG, and_callback),
OPT_BOOL(0, "or", &dummy, ""), OPT_BOOL(0, "or", &dummy, ""),
{ OPTION_CALLBACK, 0, "not", &opt, NULL, "", OPT_CALLBACK_F(0, "not", &opt, NULL, "",
PARSE_OPT_NOARG | PARSE_OPT_NONEG, not_callback }, PARSE_OPT_NOARG | PARSE_OPT_NONEG, not_callback),
{ OPTION_CALLBACK, '(', NULL, &opt, NULL, "", OPT_CALLBACK_F('(', NULL, &opt, NULL, "",
PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH, PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH,
open_callback }, open_callback),
{ OPTION_CALLBACK, ')', NULL, &opt, NULL, "", OPT_CALLBACK_F(')', NULL, &opt, NULL, "",
PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH, PARSE_OPT_NOARG | PARSE_OPT_NONEG | PARSE_OPT_NODASH,
close_callback }, close_callback),
OPT__QUIET(&opt.status_only, OPT__QUIET(&opt.status_only,
N_("indicate hit with exit status without output")), N_("indicate hit with exit status without output")),
OPT_BOOL(0, "all-match", &opt.all_match, OPT_BOOL(0, "all-match", &opt.all_match,

4
builtin/interpret-trailers.c
View File

@ -105,8 +105,8 @@ int cmd_interpret_trailers(int argc, const char **argv, const char *prefix)
OPT_BOOL(0, "only-trailers", &opts.only_trailers, N_("output only the trailers")), OPT_BOOL(0, "only-trailers", &opts.only_trailers, N_("output only the trailers")),
OPT_BOOL(0, "only-input", &opts.only_input, N_("do not apply config rules")), OPT_BOOL(0, "only-input", &opts.only_input, N_("do not apply config rules")),
OPT_BOOL(0, "unfold", &opts.unfold, N_("join whitespace-continued values")), OPT_BOOL(0, "unfold", &opts.unfold, N_("join whitespace-continued values")),
{ OPTION_CALLBACK, 0, "parse", &opts, NULL, N_("set parsing options"), OPT_CALLBACK_F(0, "parse", &opts, NULL, N_("set parsing options"),
PARSE_OPT_NOARG | PARSE_OPT_NONEG, parse_opt_parse }, PARSE_OPT_NOARG | PARSE_OPT_NONEG, parse_opt_parse),
OPT_BOOL(0, "no-divider", &opts.no_divider, N_("do not treat --- specially")), OPT_BOOL(0, "no-divider", &opts.no_divider, N_("do not treat --- specially")),
OPT_CALLBACK(0, "trailer", &trailers, N_("trailer"), OPT_CALLBACK(0, "trailer", &trailers, N_("trailer"),
N_("trailer(s) to add"), option_parse_trailer), N_("trailer(s) to add"), option_parse_trailer),

54
builtin/log.c
View File

@ -179,8 +179,8 @@ static void cmd_log_init_finish(int argc, const char **argv, const char *prefix,
N_("pattern"), N_("only decorate refs that match <pattern>")), N_("pattern"), N_("only decorate refs that match <pattern>")),
OPT_STRING_LIST(0, "decorate-refs-exclude", &decorate_refs_exclude, OPT_STRING_LIST(0, "decorate-refs-exclude", &decorate_refs_exclude,
N_("pattern"), N_("do not decorate refs that match <pattern>")), N_("pattern"), N_("do not decorate refs that match <pattern>")),
{ OPTION_CALLBACK, 0, "decorate", NULL, NULL, N_("decorate options"), OPT_CALLBACK_F(0, "decorate", NULL, NULL, N_("decorate options"),
PARSE_OPT_OPTARG, decorate_callback}, PARSE_OPT_OPTARG, decorate_callback),
OPT_CALLBACK('L', NULL, &line_cb, "n,m:file", OPT_CALLBACK('L', NULL, &line_cb, "n,m:file",
N_("Process line range n,m in file, counting from 1"), N_("Process line range n,m in file, counting from 1"),
log_line_range_callback), log_line_range_callback),
@ -1631,12 +1631,12 @@ int cmd_format_patch(int argc, const char **argv, const char *prefix)
int creation_factor = -1; int creation_factor = -1;
const struct option builtin_format_patch_options[] = { const struct option builtin_format_patch_options[] = {
{ OPTION_CALLBACK, 'n', "numbered", &numbered, NULL, OPT_CALLBACK_F('n', "numbered", &numbered, NULL,
N_("use [PATCH n/m] even with a single patch"), N_("use [PATCH n/m] even with a single patch"),
PARSE_OPT_NOARG, numbered_callback }, PARSE_OPT_NOARG, numbered_callback),
{ OPTION_CALLBACK, 'N', "no-numbered", &numbered, NULL, OPT_CALLBACK_F('N', "no-numbered", &numbered, NULL,
N_("use [PATCH] even with multiple patches"), N_("use [PATCH] even with multiple patches"),
PARSE_OPT_NOARG | PARSE_OPT_NONEG, no_numbered_callback }, PARSE_OPT_NOARG | PARSE_OPT_NONEG, no_numbered_callback),
OPT_BOOL('s', "signoff", &do_signoff, N_("add Signed-off-by:")), OPT_BOOL('s', "signoff", &do_signoff, N_("add Signed-off-by:")),
OPT_BOOL(0, "stdout", &use_stdout, OPT_BOOL(0, "stdout", &use_stdout,
N_("print patches to standard out")), N_("print patches to standard out")),
@ -1650,21 +1650,21 @@ int cmd_format_patch(int argc, const char **argv, const char *prefix)
N_("start numbering patches at <n> instead of 1")), N_("start numbering patches at <n> instead of 1")),
OPT_INTEGER('v', "reroll-count", &reroll_count, OPT_INTEGER('v', "reroll-count", &reroll_count,
N_("mark the series as Nth re-roll")), N_("mark the series as Nth re-roll")),
{ OPTION_CALLBACK, 0, "rfc", &rev, NULL, OPT_CALLBACK_F(0, "rfc", &rev, NULL,
N_("Use [RFC PATCH] instead of [PATCH]"), N_("Use [RFC PATCH] instead of [PATCH]"),
PARSE_OPT_NOARG | PARSE_OPT_NONEG, rfc_callback }, PARSE_OPT_NOARG | PARSE_OPT_NONEG, rfc_callback),
OPT_STRING(0, "cover-from-description", &cover_from_description_arg, OPT_STRING(0, "cover-from-description", &cover_from_description_arg,
N_("cover-from-description-mode"), N_("cover-from-description-mode"),
N_("generate parts of a cover letter based on a branch's description")), N_("generate parts of a cover letter based on a branch's description")),
{ OPTION_CALLBACK, 0, "subject-prefix", &rev, N_("prefix"), OPT_CALLBACK_F(0, "subject-prefix", &rev, N_("prefix"),
N_("Use [<prefix>] instead of [PATCH]"), N_("Use [<prefix>] instead of [PATCH]"),
PARSE_OPT_NONEG, subject_prefix_callback }, PARSE_OPT_NONEG, subject_prefix_callback),
{ OPTION_CALLBACK, 'o', "output-directory", &output_directory, OPT_CALLBACK_F('o', "output-directory", &output_directory,
N_("dir"), N_("store resulting files in <dir>"), N_("dir"), N_("store resulting files in <dir>"),
PARSE_OPT_NONEG, output_directory_callback }, PARSE_OPT_NONEG, output_directory_callback),
{ OPTION_CALLBACK, 'k', "keep-subject", &rev, NULL, OPT_CALLBACK_F('k', "keep-subject", &rev, NULL,
N_("don't strip/add [PATCH]"), N_("don't strip/add [PATCH]"),
PARSE_OPT_NOARG | PARSE_OPT_NONEG, keep_callback }, PARSE_OPT_NOARG | PARSE_OPT_NONEG, keep_callback),
OPT_BOOL(0, "no-binary", &no_binary_diff, OPT_BOOL(0, "no-binary", &no_binary_diff,
N_("don't output binary diffs")), N_("don't output binary diffs")),
OPT_BOOL(0, "zero-commit", &zero_commit, OPT_BOOL(0, "zero-commit", &zero_commit,
@ -1675,27 +1675,25 @@ int cmd_format_patch(int argc, const char **argv, const char *prefix)
N_("show patch format instead of default (patch + stat)"), N_("show patch format instead of default (patch + stat)"),
1, PARSE_OPT_NONEG), 1, PARSE_OPT_NONEG),
OPT_GROUP(N_("Messaging")), OPT_GROUP(N_("Messaging")),
{ OPTION_CALLBACK, 0, "add-header", NULL, N_("header"), OPT_CALLBACK(0, "add-header", NULL, N_("header"),
N_("add email header"), 0, header_callback }, N_("add email header"), header_callback),
{ OPTION_CALLBACK, 0, "to", NULL, N_("email"), N_("add To: header"), OPT_CALLBACK(0, "to", NULL, N_("email"), N_("add To: header"), to_callback),
0, to_callback }, OPT_CALLBACK(0, "cc", NULL, N_("email"), N_("add Cc: header"), cc_callback),
{ OPTION_CALLBACK, 0, "cc", NULL, N_("email"), N_("add Cc: header"), OPT_CALLBACK_F(0, "from", &from, N_("ident"),
0, cc_callback },
{ OPTION_CALLBACK, 0, "from", &from, N_("ident"),
N_("set From address to <ident> (or committer ident if absent)"), N_("set From address to <ident> (or committer ident if absent)"),
PARSE_OPT_OPTARG, from_callback }, PARSE_OPT_OPTARG, from_callback),
OPT_STRING(0, "in-reply-to", &in_reply_to, N_("message-id"), OPT_STRING(0, "in-reply-to", &in_reply_to, N_("message-id"),
N_("make first mail a reply to <message-id>")), N_("make first mail a reply to <message-id>")),
{ OPTION_CALLBACK, 0, "attach", &rev, N_("boundary"), OPT_CALLBACK_F(0, "attach", &rev, N_("boundary"),
N_("attach the patch"), PARSE_OPT_OPTARG, N_("attach the patch"), PARSE_OPT_OPTARG,
attach_callback }, attach_callback),
{ OPTION_CALLBACK, 0, "inline", &rev, N_("boundary"), OPT_CALLBACK_F(0, "inline", &rev, N_("boundary"),
N_("inline the patch"), N_("inline the patch"),
PARSE_OPT_OPTARG | PARSE_OPT_NONEG, PARSE_OPT_OPTARG | PARSE_OPT_NONEG,
inline_callback }, inline_callback),
{ OPTION_CALLBACK, 0, "thread", &thread, N_("style"), OPT_CALLBACK_F(0, "thread", &thread, N_("style"),
N_("enable message threading, styles: shallow, deep"), N_("enable message threading, styles: shallow, deep"),
PARSE_OPT_OPTARG, thread_callback }, PARSE_OPT_OPTARG, thread_callback),
OPT_STRING(0, "signature", &signature, N_("signature"), OPT_STRING(0, "signature", &signature, N_("signature"),
N_("add a signature")), N_("add a signature")),
OPT_STRING(0, "base", &base_commit, N_("base-commit"), OPT_STRING(0, "base", &base_commit, N_("base-commit"),

12
builtin/ls-files.c
View File

@ -554,18 +554,18 @@ int cmd_ls_files(int argc, const char **argv, const char *cmd_prefix)
N_("show unmerged files in the output")), N_("show unmerged files in the output")),
OPT_BOOL(0, "resolve-undo", &show_resolve_undo, OPT_BOOL(0, "resolve-undo", &show_resolve_undo,
N_("show resolve-undo information")), N_("show resolve-undo information")),
{ OPTION_CALLBACK, 'x', "exclude", &exclude_list, N_("pattern"), OPT_CALLBACK_F('x', "exclude", &exclude_list, N_("pattern"),
N_("skip files matching pattern"), N_("skip files matching pattern"),
PARSE_OPT_NONEG, option_parse_exclude }, PARSE_OPT_NONEG, option_parse_exclude),
{ OPTION_CALLBACK, 'X', "exclude-from", &dir, N_("file"), OPT_CALLBACK_F('X', "exclude-from", &dir, N_("file"),
N_("exclude patterns are read from <file>"), N_("exclude patterns are read from <file>"),
PARSE_OPT_NONEG, option_parse_exclude_from }, PARSE_OPT_NONEG, option_parse_exclude_from),
OPT_STRING(0, "exclude-per-directory", &dir.exclude_per_dir, N_("file"), OPT_STRING(0, "exclude-per-directory", &dir.exclude_per_dir, N_("file"),
N_("read additional per-directory exclude patterns in <file>")), N_("read additional per-directory exclude patterns in <file>")),
{ OPTION_CALLBACK, 0, "exclude-standard", &dir, NULL, OPT_CALLBACK_F(0, "exclude-standard", &dir, NULL,
N_("add the standard git exclusions"), N_("add the standard git exclusions"),
PARSE_OPT_NOARG | PARSE_OPT_NONEG, PARSE_OPT_NOARG | PARSE_OPT_NONEG,
option_parse_exclude_standard }, option_parse_exclude_standard),
OPT_SET_INT_F(0, "full-name", &prefix_len, OPT_SET_INT_F(0, "full-name", &prefix_len,
N_("make the output relative to the project top directory"), N_("make the output relative to the project top directory"),
0, PARSE_OPT_NONEG), 0, PARSE_OPT_NONEG),

4
builtin/merge.c
View File

@ -241,9 +241,9 @@ static int option_parse_n(const struct option *opt,
} }
static struct option builtin_merge_options[] = { static struct option builtin_merge_options[] = {
{ OPTION_CALLBACK, 'n', NULL, NULL, NULL, OPT_CALLBACK_F('n', NULL, NULL, NULL,
N_("do not show a diffstat at the end of the merge"), N_("do not show a diffstat at the end of the merge"),
PARSE_OPT_NOARG, option_parse_n }, PARSE_OPT_NOARG, option_parse_n),
OPT_BOOL(0, "stat", &show_diffstat, OPT_BOOL(0, "stat", &show_diffstat,
N_("show a diffstat at the end of the merge")), N_("show a diffstat at the end of the merge")),
OPT_BOOL(0, "summary", &show_diffstat, N_("(synonym to --stat)")), OPT_BOOL(0, "summary", &show_diffstat, N_("(synonym to --stat)")),

32
builtin/notes.c
View File

@ -406,18 +406,18 @@ static int add(int argc, const char **argv, const char *prefix)
const struct object_id *note; const struct object_id *note;
struct note_data d = { 0, 0, NULL, STRBUF_INIT }; struct note_data d = { 0, 0, NULL, STRBUF_INIT };
struct option options[] = { struct option options[] = {
{ OPTION_CALLBACK, 'm', "message", &d, N_("message"), OPT_CALLBACK_F('m', "message", &d, N_("message"),
N_("note contents as a string"), PARSE_OPT_NONEG, N_("note contents as a string"), PARSE_OPT_NONEG,
parse_msg_arg}, parse_msg_arg),
{ OPTION_CALLBACK, 'F', "file", &d, N_("file"), OPT_CALLBACK_F('F', "file", &d, N_("file"),
N_("note contents in a file"), PARSE_OPT_NONEG, N_("note contents in a file"), PARSE_OPT_NONEG,
parse_file_arg}, parse_file_arg),
{ OPTION_CALLBACK, 'c', "reedit-message", &d, N_("object"), OPT_CALLBACK_F('c', "reedit-message", &d, N_("object"),
N_("reuse and edit specified note object"), PARSE_OPT_NONEG, N_("reuse and edit specified note object"), PARSE_OPT_NONEG,
parse_reedit_arg}, parse_reedit_arg),
{ OPTION_CALLBACK, 'C', "reuse-message", &d, N_("object"), OPT_CALLBACK_F('C', "reuse-message", &d, N_("object"),
N_("reuse specified note object"), PARSE_OPT_NONEG, N_("reuse specified note object"), PARSE_OPT_NONEG,
parse_reuse_arg}, parse_reuse_arg),
OPT_BOOL(0, "allow-empty", &allow_empty, OPT_BOOL(0, "allow-empty", &allow_empty,
N_("allow storing empty note")), N_("allow storing empty note")),
OPT__FORCE(&force, N_("replace existing notes"), PARSE_OPT_NOCOMPLETE), OPT__FORCE(&force, N_("replace existing notes"), PARSE_OPT_NOCOMPLETE),
@ -572,18 +572,18 @@ static int append_edit(int argc, const char **argv, const char *prefix)
const char * const *usage; const char * const *usage;
struct note_data d = { 0, 0, NULL, STRBUF_INIT }; struct note_data d = { 0, 0, NULL, STRBUF_INIT };
struct option options[] = { struct option options[] = {
{ OPTION_CALLBACK, 'm', "message", &d, N_("message"), OPT_CALLBACK_F('m', "message", &d, N_("message"),
N_("note contents as a string"), PARSE_OPT_NONEG, N_("note contents as a string"), PARSE_OPT_NONEG,
parse_msg_arg}, parse_msg_arg),
{ OPTION_CALLBACK, 'F', "file", &d, N_("file"), OPT_CALLBACK_F('F', "file", &d, N_("file"),
N_("note contents in a file"), PARSE_OPT_NONEG, N_("note contents in a file"), PARSE_OPT_NONEG,
parse_file_arg}, parse_file_arg),
{ OPTION_CALLBACK, 'c', "reedit-message", &d, N_("object"), OPT_CALLBACK_F('c', "reedit-message", &d, N_("object"),
N_("reuse and edit specified note object"), PARSE_OPT_NONEG, N_("reuse and edit specified note object"), PARSE_OPT_NONEG,
parse_reedit_arg}, parse_reedit_arg),
{ OPTION_CALLBACK, 'C', "reuse-message", &d, N_("object"), OPT_CALLBACK_F('C', "reuse-message", &d, N_("object"),
N_("reuse specified note object"), PARSE_OPT_NONEG, N_("reuse specified note object"), PARSE_OPT_NONEG,
parse_reuse_arg}, parse_reuse_arg),
OPT_BOOL(0, "allow-empty", &allow_empty, OPT_BOOL(0, "allow-empty", &allow_empty,
N_("allow storing empty note")), N_("allow storing empty note")),
OPT_END() OPT_END()

12
builtin/pack-objects.c
View File

@ -3380,9 +3380,9 @@ int cmd_pack_objects(int argc, const char **argv, const char *prefix)
OPT_BOOL(0, "all-progress-implied", OPT_BOOL(0, "all-progress-implied",
&all_progress_implied, &all_progress_implied,
N_("similar to --all-progress when progress meter is shown")), N_("similar to --all-progress when progress meter is shown")),
{ OPTION_CALLBACK, 0, "index-version", NULL, N_("<version>[,<offset>]"), OPT_CALLBACK_F(0, "index-version", NULL, N_("<version>[,<offset>]"),
N_("write the pack index file in the specified idx format version"), N_("write the pack index file in the specified idx format version"),
PARSE_OPT_NONEG, option_parse_index_version }, PARSE_OPT_NONEG, option_parse_index_version),
OPT_MAGNITUDE(0, "max-pack-size", &pack_size_limit, OPT_MAGNITUDE(0, "max-pack-size", &pack_size_limit,
N_("maximum size of each output pack file")), N_("maximum size of each output pack file")),
OPT_BOOL(0, "local", &local, OPT_BOOL(0, "local", &local,
@ -3427,9 +3427,9 @@ int cmd_pack_objects(int argc, const char **argv, const char *prefix)
N_("keep unreachable objects")), N_("keep unreachable objects")),
OPT_BOOL(0, "pack-loose-unreachable", &pack_loose_unreachable, OPT_BOOL(0, "pack-loose-unreachable", &pack_loose_unreachable,
N_("pack loose unreachable objects")), N_("pack loose unreachable objects")),
{ OPTION_CALLBACK, 0, "unpack-unreachable", NULL, N_("time"), OPT_CALLBACK_F(0, "unpack-unreachable", NULL, N_("time"),
N_("unpack unreachable objects newer than <time>"), N_("unpack unreachable objects newer than <time>"),
PARSE_OPT_OPTARG, option_parse_unpack_unreachable }, PARSE_OPT_OPTARG, option_parse_unpack_unreachable),
OPT_BOOL(0, "sparse", &sparse, OPT_BOOL(0, "sparse", &sparse,
N_("use the sparse reachability algorithm")), N_("use the sparse reachability algorithm")),
OPT_BOOL(0, "thin", &thin, OPT_BOOL(0, "thin", &thin,
@ -3454,9 +3454,9 @@ int cmd_pack_objects(int argc, const char **argv, const char *prefix)
N_("write a bitmap index if possible"), N_("write a bitmap index if possible"),
WRITE_BITMAP_QUIET, PARSE_OPT_HIDDEN), WRITE_BITMAP_QUIET, PARSE_OPT_HIDDEN),
OPT_PARSE_LIST_OBJECTS_FILTER(&filter_options), OPT_PARSE_LIST_OBJECTS_FILTER(&filter_options),
{ OPTION_CALLBACK, 0, "missing", NULL, N_("action"), OPT_CALLBACK_F(0, "missing", NULL, N_("action"),
N_("handling for missing objects"), PARSE_OPT_NONEG, N_("handling for missing objects"), PARSE_OPT_NONEG,
option_parse_missing_action }, option_parse_missing_action),
OPT_BOOL(0, "exclude-promisor-objects", &exclude_promisor_objects, OPT_BOOL(0, "exclude-promisor-objects", &exclude_promisor_objects,
N_("do not pack objects in promisor packfiles")), N_("do not pack objects in promisor packfiles")),
OPT_BOOL(0, "delta-islands", &use_delta_islands, OPT_BOOL(0, "delta-islands", &use_delta_islands,

8
builtin/pull.c
View File

@ -118,17 +118,17 @@ static struct option pull_options[] = {
OPT_PASSTHRU(0, "progress", &opt_progress, NULL, OPT_PASSTHRU(0, "progress", &opt_progress, NULL,
N_("force progress reporting"), N_("force progress reporting"),
PARSE_OPT_NOARG), PARSE_OPT_NOARG),
{ OPTION_CALLBACK, 0, "recurse-submodules", OPT_CALLBACK_F(0, "recurse-submodules",
&recurse_submodules, N_("on-demand"), &recurse_submodules, N_("on-demand"),
N_("control for recursive fetching of submodules"), N_("control for recursive fetching of submodules"),
PARSE_OPT_OPTARG, option_fetch_parse_recurse_submodules }, PARSE_OPT_OPTARG, option_fetch_parse_recurse_submodules),
/* Options passed to git-merge or git-rebase */ /* Options passed to git-merge or git-rebase */
OPT_GROUP(N_("Options related to merging")), OPT_GROUP(N_("Options related to merging")),
{ OPTION_CALLBACK, 'r', "rebase", &opt_rebase, OPT_CALLBACK_F('r', "rebase", &opt_rebase,
"(false|true|merges|preserve|interactive)", "(false|true|merges|preserve|interactive)",
N_("incorporate changes by rebasing rather than merging"), N_("incorporate changes by rebasing rather than merging"),
PARSE_OPT_OPTARG, parse_opt_rebase }, PARSE_OPT_OPTARG, parse_opt_rebase),
OPT_PASSTHRU('n', NULL, &opt_diffstat, NULL, OPT_PASSTHRU('n', NULL, &opt_diffstat, NULL,
N_("do not show a diffstat at the end of the merge"), N_("do not show a diffstat at the end of the merge"),
PARSE_OPT_NOARG | PARSE_OPT_NONEG), PARSE_OPT_NOARG | PARSE_OPT_NONEG),

12
builtin/push.c
View File

@ -548,10 +548,9 @@ int cmd_push(int argc, const char **argv, const char *prefix)
OPT_BIT('n' , "dry-run", &flags, N_("dry run"), TRANSPORT_PUSH_DRY_RUN), OPT_BIT('n' , "dry-run", &flags, N_("dry run"), TRANSPORT_PUSH_DRY_RUN),
OPT_BIT( 0, "porcelain", &flags, N_("machine-readable output"), TRANSPORT_PUSH_PORCELAIN), OPT_BIT( 0, "porcelain", &flags, N_("machine-readable output"), TRANSPORT_PUSH_PORCELAIN),
OPT_BIT('f', "force", &flags, N_("force updates"), TRANSPORT_PUSH_FORCE), OPT_BIT('f', "force", &flags, N_("force updates"), TRANSPORT_PUSH_FORCE),
{ OPTION_CALLBACK, OPT_CALLBACK_F(0, CAS_OPT_NAME, &cas, N_("<refname>:<expect>"),
0, CAS_OPT_NAME, &cas, N_("<refname>:<expect>"), N_("require old value of ref to be at this value"),
N_("require old value of ref to be at this value"), PARSE_OPT_OPTARG | PARSE_OPT_LITERAL_ARGHELP, parseopt_push_cas_option),
PARSE_OPT_OPTARG | PARSE_OPT_LITERAL_ARGHELP, parseopt_push_cas_option },
{ OPTION_CALLBACK, 0, "recurse-submodules", &recurse_submodules, "(check|on-demand|no)", { OPTION_CALLBACK, 0, "recurse-submodules", &recurse_submodules, "(check|on-demand|no)",
N_("control recursive pushing of submodules"), N_("control recursive pushing of submodules"),
PARSE_OPT_OPTARG, option_parse_recurse_submodules }, PARSE_OPT_OPTARG, option_parse_recurse_submodules },
@ -566,9 +565,8 @@ int cmd_push(int argc, const char **argv, const char *prefix)
OPT_BIT(0, "no-verify", &flags, N_("bypass pre-push hook"), TRANSPORT_PUSH_NO_HOOK), OPT_BIT(0, "no-verify", &flags, N_("bypass pre-push hook"), TRANSPORT_PUSH_NO_HOOK),
OPT_BIT(0, "follow-tags", &flags, N_("push missing but relevant tags"), OPT_BIT(0, "follow-tags", &flags, N_("push missing but relevant tags"),
TRANSPORT_PUSH_FOLLOW_TAGS), TRANSPORT_PUSH_FOLLOW_TAGS),
{ OPTION_CALLBACK, OPT_CALLBACK_F(0, "signed", &push_cert, "(yes|no|if-asked)", N_("GPG sign the push"),
0, "signed", &push_cert, "(yes|no|if-asked)", N_("GPG sign the push"), PARSE_OPT_OPTARG, option_parse_push_signed),
PARSE_OPT_OPTARG, option_parse_push_signed },
OPT_BIT(0, "atomic", &flags, N_("request atomic transaction on remote side"), TRANSPORT_PUSH_ATOMIC), OPT_BIT(0, "atomic", &flags, N_("request atomic transaction on remote side"), TRANSPORT_PUSH_ATOMIC),
OPT_STRING_LIST('o', "push-option", &push_options_cmdline, N_("server-specific"), N_("option to transmit")), OPT_STRING_LIST('o', "push-option", &push_options_cmdline, N_("server-specific"), N_("option to transmit")),
OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"), OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"),

12
builtin/read-tree.c
View File

@ -120,9 +120,9 @@ int cmd_read_tree(int argc, const char **argv, const char *cmd_prefix)
int prefix_set = 0; int prefix_set = 0;
struct lock_file lock_file = LOCK_INIT; struct lock_file lock_file = LOCK_INIT;
const struct option read_tree_options[] = { const struct option read_tree_options[] = {
{ OPTION_CALLBACK, 0, "index-output", NULL, N_("file"), OPT_CALLBACK_F(0, "index-output", NULL, N_("file"),
N_("write resulting index to <file>"), N_("write resulting index to <file>"),
PARSE_OPT_NONEG, index_output_cb }, PARSE_OPT_NONEG, index_output_cb),
OPT_BOOL(0, "empty", &read_empty, OPT_BOOL(0, "empty", &read_empty,
N_("only empty the index")), N_("only empty the index")),
OPT__VERBOSE(&opts.verbose_update, N_("be verbose")), OPT__VERBOSE(&opts.verbose_update, N_("be verbose")),
@ -140,10 +140,10 @@ int cmd_read_tree(int argc, const char **argv, const char *cmd_prefix)
PARSE_OPT_NONEG }, PARSE_OPT_NONEG },
OPT_BOOL('u', NULL, &opts.update, OPT_BOOL('u', NULL, &opts.update,
N_("update working tree with merge result")), N_("update working tree with merge result")),
{ OPTION_CALLBACK, 0, "exclude-per-directory", &opts, OPT_CALLBACK_F(0, "exclude-per-directory", &opts,
N_("gitignore"), N_("gitignore"),
N_("allow explicitly ignored files to be overwritten"), N_("allow explicitly ignored files to be overwritten"),
PARSE_OPT_NONEG, exclude_per_directory_cb }, PARSE_OPT_NONEG, exclude_per_directory_cb),
OPT_BOOL('i', NULL, &opts.index_only, OPT_BOOL('i', NULL, &opts.index_only,
N_("don't check the working tree after merging")), N_("don't check the working tree after merging")),
OPT__DRY_RUN(&opts.dry_run, N_("don't update the index or the work tree")), OPT__DRY_RUN(&opts.dry_run, N_("don't update the index or the work tree")),
@ -151,9 +151,9 @@ int cmd_read_tree(int argc, const char **argv, const char *cmd_prefix)
N_("skip applying sparse checkout filter")), N_("skip applying sparse checkout filter")),
OPT_BOOL(0, "debug-unpack", &opts.debug_unpack, OPT_BOOL(0, "debug-unpack", &opts.debug_unpack,
N_("debug unpack-trees")), N_("debug unpack-trees")),
{ OPTION_CALLBACK, 0, "recurse-submodules", NULL, OPT_CALLBACK_F(0, "recurse-submodules", NULL,
"checkout", "control recursive updating of submodules", "checkout", "control recursive updating of submodules",
PARSE_OPT_OPTARG, option_parse_recurse_submodules_worktree_updater }, PARSE_OPT_OPTARG, option_parse_recurse_submodules_worktree_updater),
OPT__QUIET(&opts.quiet, N_("suppress feedback messages")), OPT__QUIET(&opts.quiet, N_("suppress feedback messages")),
OPT_END() OPT_END()
}; };

20
builtin/rebase.c
View File

@ -474,10 +474,10 @@ int cmd_rebase__interactive(int argc, const char **argv, const char *prefix)
struct option options[] = { struct option options[] = {
OPT_NEGBIT(0, "ff", &opts.flags, N_("allow fast-forward"), OPT_NEGBIT(0, "ff", &opts.flags, N_("allow fast-forward"),
REBASE_FORCE), REBASE_FORCE),
{ OPTION_CALLBACK, 'k', "keep-empty", &options, NULL, OPT_CALLBACK_F('k', "keep-empty", &options, NULL,
N_("keep commits which start empty"), N_("keep commits which start empty"),
PARSE_OPT_NOARG | PARSE_OPT_HIDDEN, PARSE_OPT_NOARG | PARSE_OPT_HIDDEN,
parse_opt_keep_empty }, parse_opt_keep_empty),
OPT_BOOL_F(0, "allow-empty-message", &opts.allow_empty_message, OPT_BOOL_F(0, "allow-empty-message", &opts.allow_empty_message,
N_("allow commits with empty messages"), N_("allow commits with empty messages"),
PARSE_OPT_HIDDEN), PARSE_OPT_HIDDEN),
@ -1532,18 +1532,18 @@ int cmd_rebase(int argc, const char **argv, const char *prefix)
OPT_CMDMODE(0, "show-current-patch", &action, OPT_CMDMODE(0, "show-current-patch", &action,
N_("show the patch file being applied or merged"), N_("show the patch file being applied or merged"),
ACTION_SHOW_CURRENT_PATCH), ACTION_SHOW_CURRENT_PATCH),
{ OPTION_CALLBACK, 0, "apply", &options, NULL, OPT_CALLBACK_F(0, "apply", &options, NULL,
N_("use apply strategies to rebase"), N_("use apply strategies to rebase"),
PARSE_OPT_NOARG | PARSE_OPT_NONEG, PARSE_OPT_NOARG | PARSE_OPT_NONEG,
parse_opt_am }, parse_opt_am),
{ OPTION_CALLBACK, 'm', "merge", &options, NULL, OPT_CALLBACK_F('m', "merge", &options, NULL,
N_("use merging strategies to rebase"), N_("use merging strategies to rebase"),
PARSE_OPT_NOARG | PARSE_OPT_NONEG, PARSE_OPT_NOARG | PARSE_OPT_NONEG,
parse_opt_merge }, parse_opt_merge),
{ OPTION_CALLBACK, 'i', "interactive", &options, NULL, OPT_CALLBACK_F('i', "interactive", &options, NULL,
N_("let the user edit the list of commits to rebase"), N_("let the user edit the list of commits to rebase"),
PARSE_OPT_NOARG | PARSE_OPT_NONEG, PARSE_OPT_NOARG | PARSE_OPT_NONEG,
parse_opt_interactive }, parse_opt_interactive),
OPT_SET_INT_F('p', "preserve-merges", &options.type, OPT_SET_INT_F('p', "preserve-merges", &options.type,
N_("(DEPRECATED) try to recreate merges instead of " N_("(DEPRECATED) try to recreate merges instead of "
"ignoring them"), "ignoring them"),
@ -1552,10 +1552,10 @@ int cmd_rebase(int argc, const char **argv, const char *prefix)
OPT_CALLBACK_F(0, "empty", &options, "{drop,keep,ask}", OPT_CALLBACK_F(0, "empty", &options, "{drop,keep,ask}",
N_("how to handle commits that become empty"), N_("how to handle commits that become empty"),
PARSE_OPT_NONEG, parse_opt_empty), PARSE_OPT_NONEG, parse_opt_empty),
{ OPTION_CALLBACK, 'k', "keep-empty", &options, NULL, OPT_CALLBACK_F('k', "keep-empty", &options, NULL,
N_("keep commits which start empty"), N_("keep commits which start empty"),
PARSE_OPT_NOARG | PARSE_OPT_HIDDEN, PARSE_OPT_NOARG | PARSE_OPT_HIDDEN,
parse_opt_keep_empty }, parse_opt_keep_empty),
OPT_BOOL(0, "autosquash", &options.autosquash, OPT_BOOL(0, "autosquash", &options.autosquash,
N_("move commits that begin with " N_("move commits that begin with "
"squash!/fixup! under -i")), "squash!/fixup! under -i")),

4
builtin/remote.c
View File

@ -170,9 +170,9 @@ static int add(int argc, const char **argv)
OPT_STRING_LIST('t', "track", &track, N_("branch"), OPT_STRING_LIST('t', "track", &track, N_("branch"),
N_("branch(es) to track")), N_("branch(es) to track")),
OPT_STRING('m', "master", &master, N_("branch"), N_("master branch")), OPT_STRING('m', "master", &master, N_("branch"), N_("master branch")),
{ OPTION_CALLBACK, 0, "mirror", &mirror, "(push|fetch)", OPT_CALLBACK_F(0, "mirror", &mirror, "(push|fetch)",
N_("set up remote as a mirror to push to or fetch from"), N_("set up remote as a mirror to push to or fetch from"),
PARSE_OPT_OPTARG | PARSE_OPT_COMP_ARG, parse_mirror_opt }, PARSE_OPT_OPTARG | PARSE_OPT_COMP_ARG, parse_mirror_opt),
OPT_END() OPT_END()
}; };

4
builtin/reset.c
View File

@ -302,9 +302,9 @@ int cmd_reset(int argc, const char **argv, const char *prefix)
N_("reset HEAD, index and working tree"), MERGE), N_("reset HEAD, index and working tree"), MERGE),
OPT_SET_INT(0, "keep", &reset_type, OPT_SET_INT(0, "keep", &reset_type,
N_("reset HEAD but keep local changes"), KEEP), N_("reset HEAD but keep local changes"), KEEP),
{ OPTION_CALLBACK, 0, "recurse-submodules", NULL, OPT_CALLBACK_F(0, "recurse-submodules", NULL,
"reset", "control recursive updating of submodules", "reset", "control recursive updating of submodules",
PARSE_OPT_OPTARG, option_parse_recurse_submodules_worktree_updater }, PARSE_OPT_OPTARG, option_parse_recurse_submodules_worktree_updater),
OPT_BOOL('p', "patch", &patch_mode, N_("select hunks interactively")), OPT_BOOL('p', "patch", &patch_mode, N_("select hunks interactively")),
OPT_BOOL('N', "intent-to-add", &intent_to_add, OPT_BOOL('N', "intent-to-add", &intent_to_add,
N_("record only the fact that removed paths will be added later")), N_("record only the fact that removed paths will be added later")),

10
builtin/send-pack.c
View File

@ -165,9 +165,8 @@ int cmd_send_pack(int argc, const char **argv, const char *prefix)
OPT_BOOL('n' , "dry-run", &dry_run, N_("dry run")), OPT_BOOL('n' , "dry-run", &dry_run, N_("dry run")),
OPT_BOOL(0, "mirror", &send_mirror, N_("mirror all refs")), OPT_BOOL(0, "mirror", &send_mirror, N_("mirror all refs")),
OPT_BOOL('f', "force", &force_update, N_("force updates")), OPT_BOOL('f', "force", &force_update, N_("force updates")),
{ OPTION_CALLBACK, OPT_CALLBACK_F(0, "signed", &push_cert, "(yes|no|if-asked)", N_("GPG sign the push"),
0, "signed", &push_cert, "(yes|no|if-asked)", N_("GPG sign the push"), PARSE_OPT_OPTARG, option_parse_push_signed),
PARSE_OPT_OPTARG, option_parse_push_signed },
OPT_STRING_LIST(0, "push-option", &push_options, OPT_STRING_LIST(0, "push-option", &push_options,
N_("server-specific"), N_("server-specific"),
N_("option to transmit")), N_("option to transmit")),
@ -177,10 +176,9 @@ int cmd_send_pack(int argc, const char **argv, const char *prefix)
OPT_BOOL(0, "stateless-rpc", &stateless_rpc, N_("use stateless RPC protocol")), OPT_BOOL(0, "stateless-rpc", &stateless_rpc, N_("use stateless RPC protocol")),
OPT_BOOL(0, "stdin", &from_stdin, N_("read refs from stdin")), OPT_BOOL(0, "stdin", &from_stdin, N_("read refs from stdin")),
OPT_BOOL(0, "helper-status", &helper_status, N_("print status from remote helper")), OPT_BOOL(0, "helper-status", &helper_status, N_("print status from remote helper")),
{ OPTION_CALLBACK, OPT_CALLBACK_F(0, CAS_OPT_NAME, &cas, N_("<refname>:<expect>"),
0, CAS_OPT_NAME, &cas, N_("<refname>:<expect>"),
N_("require old value of ref to be at this value"), N_("require old value of ref to be at this value"),
PARSE_OPT_OPTARG, parseopt_push_cas_option }, PARSE_OPT_OPTARG, parseopt_push_cas_option),
OPT_END() OPT_END()
}; };

4
builtin/shortlog.c
View File

@ -268,9 +268,9 @@ int cmd_shortlog(int argc, const char **argv, const char *prefix)
N_("Suppress commit descriptions, only provides commit count")), N_("Suppress commit descriptions, only provides commit count")),
OPT_BOOL('e', "email", &log.email, OPT_BOOL('e', "email", &log.email,
N_("Show the email address of each author")), N_("Show the email address of each author")),
{ OPTION_CALLBACK, 'w', NULL, &log, N_("<w>[,<i1>[,<i2>]]"), OPT_CALLBACK_F('w', NULL, &log, N_("<w>[,<i1>[,<i2>]]"),
N_("Linewrap output"), PARSE_OPT_OPTARG, N_("Linewrap output"), PARSE_OPT_OPTARG,
&parse_wrap_args }, &parse_wrap_args),
OPT_END(), OPT_END(),
}; };

4
builtin/show-branch.c
View File

@ -671,11 +671,11 @@ int cmd_show_branch(int ac, const char **av, const char *prefix)
N_("topologically sort, maintaining date order " N_("topologically sort, maintaining date order "
"where possible"), "where possible"),
REV_SORT_BY_COMMIT_DATE), REV_SORT_BY_COMMIT_DATE),
{ OPTION_CALLBACK, 'g', "reflog", &reflog_base, N_("<n>[,<base>]"), OPT_CALLBACK_F('g', "reflog", &reflog_base, N_("<n>[,<base>]"),
N_("show <n> most recent ref-log entries starting at " N_("show <n> most recent ref-log entries starting at "
"base"), "base"),
PARSE_OPT_OPTARG | PARSE_OPT_NONEG, PARSE_OPT_OPTARG | PARSE_OPT_NONEG,
parse_reflog_param }, parse_reflog_param),
OPT_END() OPT_END()
}; };

12
builtin/show-ref.c
View File

@ -169,15 +169,15 @@ static const struct option show_ref_options[] = {
N_("show the HEAD reference, even if it would be filtered out")), N_("show the HEAD reference, even if it would be filtered out")),
OPT_BOOL('d', "dereference", &deref_tags, OPT_BOOL('d', "dereference", &deref_tags,
N_("dereference tags into object IDs")), N_("dereference tags into object IDs")),
{ OPTION_CALLBACK, 's', "hash", &abbrev, N_("n"), OPT_CALLBACK_F('s', "hash", &abbrev, N_("n"),
N_("only show SHA1 hash using <n> digits"), N_("only show SHA1 hash using <n> digits"),
PARSE_OPT_OPTARG, &hash_callback }, PARSE_OPT_OPTARG, &hash_callback),
OPT__ABBREV(&abbrev), OPT__ABBREV(&abbrev),
OPT__QUIET(&quiet, OPT__QUIET(&quiet,
N_("do not print results to stdout (useful with --verify)")), N_("do not print results to stdout (useful with --verify)")),
{ OPTION_CALLBACK, 0, "exclude-existing", &exclude_existing_arg, OPT_CALLBACK_F(0, "exclude-existing", &exclude_existing_arg,
N_("pattern"), N_("show refs from stdin that aren't in local repository"), N_("pattern"), N_("show refs from stdin that aren't in local repository"),
PARSE_OPT_OPTARG | PARSE_OPT_NONEG, exclude_existing_callback }, PARSE_OPT_OPTARG | PARSE_OPT_NONEG, exclude_existing_callback),
OPT_END() OPT_END()
}; };

4
builtin/tag.c
View File

@ -410,8 +410,8 @@ int cmd_tag(int argc, const char **argv, const char *prefix)
OPT_GROUP(N_("Tag creation options")), OPT_GROUP(N_("Tag creation options")),
OPT_BOOL('a', "annotate", &annotate, OPT_BOOL('a', "annotate", &annotate,
N_("annotated tag, needs a message")), N_("annotated tag, needs a message")),
{ OPTION_CALLBACK, 'm', "message", &msg, N_("message"), OPT_CALLBACK_F('m', "message", &msg, N_("message"),
N_("tag message"), PARSE_OPT_NONEG, parse_msg_arg }, N_("tag message"), PARSE_OPT_NONEG, parse_msg_arg),
OPT_FILENAME('F', "file", &msgfile, N_("read message from file")), OPT_FILENAME('F', "file", &msgfile, N_("read message from file")),
OPT_BOOL('e', "edit", &edit_flag, N_("force edit of tag message")), OPT_BOOL('e', "edit", &edit_flag, N_("force edit of tag message")),
OPT_BOOL('s', "sign", &opt.sign, N_("annotated and GPG-signed tag")), OPT_BOOL('s', "sign", &opt.sign, N_("annotated and GPG-signed tag")),

16
builtin/update-index.c
View File

@ -985,14 +985,14 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
OPT_BIT(0, "unmerged", &refresh_args.flags, OPT_BIT(0, "unmerged", &refresh_args.flags,
N_("refresh even if index contains unmerged entries"), N_("refresh even if index contains unmerged entries"),
REFRESH_UNMERGED), REFRESH_UNMERGED),
{OPTION_CALLBACK, 0, "refresh", &refresh_args, NULL, OPT_CALLBACK_F(0, "refresh", &refresh_args, NULL,
N_("refresh stat information"), N_("refresh stat information"),
PARSE_OPT_NOARG | PARSE_OPT_NONEG, PARSE_OPT_NOARG | PARSE_OPT_NONEG,
refresh_callback}, refresh_callback),
{OPTION_CALLBACK, 0, "really-refresh", &refresh_args, NULL, OPT_CALLBACK_F(0, "really-refresh", &refresh_args, NULL,
N_("like --refresh, but ignore assume-unchanged setting"), N_("like --refresh, but ignore assume-unchanged setting"),
PARSE_OPT_NOARG | PARSE_OPT_NONEG, PARSE_OPT_NOARG | PARSE_OPT_NONEG,
really_refresh_callback}, really_refresh_callback),
{OPTION_LOWLEVEL_CALLBACK, 0, "cacheinfo", NULL, {OPTION_LOWLEVEL_CALLBACK, 0, "cacheinfo", NULL,
N_("<mode>,<object>,<path>"), N_("<mode>,<object>,<path>"),
N_("add the specified entry to the index"), N_("add the specified entry to the index"),
@ -1000,10 +1000,10 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
PARSE_OPT_NONEG | PARSE_OPT_LITERAL_ARGHELP, PARSE_OPT_NONEG | PARSE_OPT_LITERAL_ARGHELP,
NULL, 0, NULL, 0,
cacheinfo_callback}, cacheinfo_callback},
{OPTION_CALLBACK, 0, "chmod", &set_executable_bit, "(+|-)x", OPT_CALLBACK_F(0, "chmod", &set_executable_bit, "(+|-)x",
N_("override the executable bit of the listed files"), N_("override the executable bit of the listed files"),
PARSE_OPT_NONEG, PARSE_OPT_NONEG,
chmod_callback}, chmod_callback),
{OPTION_SET_INT, 0, "assume-unchanged", &mark_valid_only, NULL, {OPTION_SET_INT, 0, "assume-unchanged", &mark_valid_only, NULL,
N_("mark files as \"not changing\""), N_("mark files as \"not changing\""),
PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, MARK_FLAG}, PARSE_OPT_NOARG | PARSE_OPT_NONEG, NULL, MARK_FLAG},
@ -1045,10 +1045,10 @@ int cmd_update_index(int argc, const char **argv, const char *prefix)
REFRESH_IGNORE_MISSING), REFRESH_IGNORE_MISSING),
OPT_SET_INT(0, "verbose", &verbose, OPT_SET_INT(0, "verbose", &verbose,
N_("report actions to standard output"), 1), N_("report actions to standard output"), 1),
{OPTION_CALLBACK, 0, "clear-resolve-undo", NULL, NULL, OPT_CALLBACK_F(0, "clear-resolve-undo", NULL, NULL,
N_("(for porcelains) forget saved unresolved conflicts"), N_("(for porcelains) forget saved unresolved conflicts"),
PARSE_OPT_NOARG | PARSE_OPT_NONEG, PARSE_OPT_NOARG | PARSE_OPT_NONEG,
resolve_undo_clear_callback}, resolve_undo_clear_callback),
OPT_INTEGER(0, "index-version", &preferred_index_format, OPT_INTEGER(0, "index-version", &preferred_index_format,
N_("write index in this format")), N_("write index in this format")),
OPT_BOOL(0, "split-index", &split_index, OPT_BOOL(0, "split-index", &split_index,

6
list-objects-filter-options.h
View File

@ -82,9 +82,9 @@ int opt_parse_list_objects_filter(const struct option *opt,
const char *arg, int unset); const char *arg, int unset);
#define OPT_PARSE_LIST_OBJECTS_FILTER(fo) \ #define OPT_PARSE_LIST_OBJECTS_FILTER(fo) \
{ OPTION_CALLBACK, 0, CL_ARG__FILTER, fo, N_("args"), \ OPT_CALLBACK(0, CL_ARG__FILTER, fo, N_("args"), \
N_("object filtering"), 0, \ N_("object filtering"), \
opt_parse_list_objects_filter } opt_parse_list_objects_filter)
/* /*
* Translates abbreviated numbers in the filter's filter_spec into their * Translates abbreviated numbers in the filter's filter_spec into their