options 2254 builtin/am.c struct option options[] = { options 2347 builtin/am.c argc = parse_options(argc, argv, prefix, options, usage, 0); options 83 builtin/apply.c static int options; options 4362 builtin/apply.c static int apply_patch(int fd, const char *filename, int options) options 4377 builtin/apply.c patch->inaccurate_eof = !!(options & INACCURATE_EOF); options 4378 builtin/apply.c patch->recount = !!(options & RECOUNT); options 4581 builtin/apply.c OPT_BIT(0, "inaccurate-eof", &options, options 4584 builtin/apply.c OPT_BIT(0, "recount", &options, options 4632 builtin/apply.c errs |= apply_patch(0, "<stdin>", options); options 4643 builtin/apply.c errs |= apply_patch(fd, arg, options); options 4648 builtin/apply.c errs |= apply_patch(0, "<stdin>", options); options 15 builtin/bisect--helper.c struct option options[] = { options 23 builtin/bisect--helper.c argc = parse_options(argc, argv, prefix, options, options 27 builtin/bisect--helper.c usage_with_options(git_bisect_helper_usage, options); options 2511 builtin/blame.c static const struct option options[] = { options 2552 builtin/blame.c parse_options_start(&ctx, argc, argv, prefix, options, options 2555 builtin/blame.c switch (parse_options_step(&ctx, options, blame_opt_usage)) { options 2568 builtin/blame.c parse_revision_opt(&revs, &ctx, options, blame_opt_usage); options 2656 builtin/blame.c usage_with_options(blame_opt_usage, options); options 2667 builtin/blame.c usage_with_options(blame_opt_usage, options); options 2671 builtin/blame.c usage_with_options(blame_opt_usage, options); options 810 builtin/branch.c struct option options[] = { options 867 builtin/branch.c usage_with_options(builtin_branch_usage, options); options 883 builtin/branch.c argc = parse_options(argc, argv, prefix, options, builtin_branch_usage, options 894 builtin/branch.c usage_with_options(builtin_branch_usage, options); options 1041 builtin/branch.c usage_with_options(builtin_branch_usage, options); options 465 builtin/cat-file.c const struct option options[] = { options 492 builtin/cat-file.c argc = parse_options(argc, argv, prefix, options, cat_file_usage, 0); options 498 builtin/cat-file.c usage_with_options(cat_file_usage, options); options 505 builtin/cat-file.c usage_with_options(cat_file_usage, options); options 508 builtin/cat-file.c usage_with_options(cat_file_usage, options); options 512 builtin/cat-file.c usage_with_options(cat_file_usage, options); options 1132 builtin/checkout.c struct option options[] = { options 1172 builtin/checkout.c argc = parse_options(argc, argv, prefix, options, checkout_usage, options 894 builtin/clean.c struct option options[] = { options 915 builtin/clean.c argc = parse_options(argc, argv, prefix, options, builtin_clean_usage, options 25 builtin/column.c struct option options[] = { options 46 builtin/column.c argc = parse_options(argc, argv, "", options, builtin_column_usage, 0); options 48 builtin/column.c usage_with_options(builtin_column_usage, options); options 1121 builtin/commit.c const struct option *options, options 1129 builtin/commit.c argc = parse_options(argc, argv, prefix, options, usage, 0); options 395 builtin/describe.c struct option options[] = { options 418 builtin/describe.c argc = parse_options(argc, argv, prefix, options, describe_usage, 0); options 21 builtin/diff-files.c unsigned options = 0; options 37 builtin/diff-files.c options |= DIFF_SILENT_ON_REMOVED; options 68 builtin/diff-files.c result = run_diff_files(&rev, options); options 223 builtin/diff.c unsigned int options = 0; options 233 builtin/diff.c options |= DIFF_SILENT_ON_REMOVED; options 256 builtin/diff.c return run_diff_files(revs, options); options 342 builtin/fast-export.c struct diff_options *options, void *data) options 978 builtin/fast-export.c struct option options[] = { options 1005 builtin/fast-export.c usage_with_options (fast_export_usage, options); options 1014 builtin/fast-export.c argc = parse_options(argc, argv, prefix, options, fast_export_usage, options 1018 builtin/fast-export.c usage_with_options (fast_export_usage, options); options 1212 builtin/fetch.c struct argv_array options = ARGV_ARRAY_INIT; options 1214 builtin/fetch.c add_options_to_argv(&options); options 1215 builtin/fetch.c result = fetch_populated_submodules(&options, options 1219 builtin/fetch.c argv_array_clear(&options); options 668 builtin/fmt-merge-msg.c struct option options[] = { options 688 builtin/fmt-merge-msg.c argc = parse_options(argc, argv, prefix, options, fmt_merge_msg_usage, options 691 builtin/fmt-merge-msg.c usage_with_options(fmt_merge_msg_usage, options); options 96 builtin/fsck.c static int mark_object(struct object *obj, int type, void *data, struct fsck_options *options) options 178 builtin/fsck.c static int mark_used(struct object *obj, int type, void *data, struct fsck_options *options) options 636 builtin/grep.c struct option options[] = { options 751 builtin/grep.c usage_with_options(grep_usage, options); options 767 builtin/grep.c argc = parse_options(argc, argv, prefix, options, grep_usage, options 196 builtin/index-pack.c static int mark_link(struct object *obj, int type, void *data, struct fsck_options *options) options 24 builtin/interpret-trailers.c struct option options[] = { options 31 builtin/interpret-trailers.c argc = parse_options(argc, argv, prefix, options, options 1639 builtin/log.c struct option options[] = { options 1645 builtin/log.c argc = parse_options(argc, argv, prefix, options, cherry_usage, 0); options 1664 builtin/log.c usage_with_options(cherry_usage, options); options 213 builtin/merge-base.c struct option options[] = { options 227 builtin/merge-base.c argc = parse_options(argc, argv, prefix, options, merge_base_usage, 0); options 231 builtin/merge-base.c usage_with_options(merge_base_usage, options); options 248 builtin/merge-base.c usage_with_options(merge_base_usage, options); options 253 builtin/merge-base.c usage_with_options(merge_base_usage, options); options 32 builtin/merge-file.c struct option options[] = { options 60 builtin/merge-file.c argc = parse_options(argc, argv, prefix, options, merge_file_usage, 0); options 62 builtin/merge-file.c usage_with_options(merge_file_usage, options); options 350 builtin/notes.c struct option options[] = { options 355 builtin/notes.c argc = parse_options(argc, argv, prefix, options, options 360 builtin/notes.c usage_with_options(git_notes_list_usage, options); options 391 builtin/notes.c struct option options[] = { options 410 builtin/notes.c argc = parse_options(argc, argv, prefix, options, git_notes_add_usage, options 415 builtin/notes.c usage_with_options(git_notes_add_usage, options); options 476 builtin/notes.c struct option options[] = { options 485 builtin/notes.c argc = parse_options(argc, argv, prefix, options, git_notes_copy_usage, options 491 builtin/notes.c usage_with_options(git_notes_copy_usage, options); options 499 builtin/notes.c usage_with_options(git_notes_copy_usage, options); options 503 builtin/notes.c usage_with_options(git_notes_copy_usage, options); options 554 builtin/notes.c struct option options[] = { options 574 builtin/notes.c argc = parse_options(argc, argv, prefix, options, usage, options 579 builtin/notes.c usage_with_options(usage, options); options 638 builtin/notes.c struct option options[] = { options 642 builtin/notes.c argc = parse_options(argc, argv, prefix, options, git_notes_show_usage, options 647 builtin/notes.c usage_with_options(git_notes_show_usage, options); options 763 builtin/notes.c struct option options[] = { options 781 builtin/notes.c argc = parse_options(argc, argv, prefix, options, options 788 builtin/notes.c usage_with_options(git_notes_merge_usage, options); options 793 builtin/notes.c usage_with_options(git_notes_merge_usage, options); options 796 builtin/notes.c usage_with_options(git_notes_merge_usage, options); options 817 builtin/notes.c usage_with_options(git_notes_merge_usage, options); options 890 builtin/notes.c struct option options[] = { options 901 builtin/notes.c argc = parse_options(argc, argv, prefix, options, options 932 builtin/notes.c struct option options[] = { options 938 builtin/notes.c argc = parse_options(argc, argv, prefix, options, git_notes_prune_usage, options 943 builtin/notes.c usage_with_options(git_notes_prune_usage, options); options 958 builtin/notes.c struct option options[] = { OPT_END() }; options 959 builtin/notes.c argc = parse_options(argc, argv, prefix, options, options 964 builtin/notes.c usage_with_options(git_notes_get_ref_usage, options); options 975 builtin/notes.c struct option options[] = { options 982 builtin/notes.c argc = parse_options(argc, argv, prefix, options, git_notes_usage, options 1013 builtin/notes.c usage_with_options(git_notes_usage, options); options 104 builtin/prune.c const struct option options[] = { options 120 builtin/prune.c argc = parse_options(argc, argv, prefix, options, prune_usage, 0); options 537 builtin/push.c struct option options[] = { options 575 builtin/push.c argc = parse_options(argc, argv, prefix, options, push_usage, 0); options 593 builtin/push.c usage_with_options(push_usage, options); options 152 builtin/remote.c struct option options[] = { options 168 builtin/remote.c argc = parse_options(argc, argv, NULL, options, builtin_remote_add_usage, options 172 builtin/remote.c usage_with_options(builtin_remote_add_usage, options); options 611 builtin/remote.c struct option options[] = { options 622 builtin/remote.c usage_with_options(builtin_remote_rename_usage, options); options 748 builtin/remote.c struct option options[] = { options 765 builtin/remote.c usage_with_options(builtin_remote_rm_usage, options); options 1127 builtin/remote.c struct option options[] = { options 1135 builtin/remote.c argc = parse_options(argc, argv, NULL, options, builtin_remote_show_usage, options 1234 builtin/remote.c struct option options[] = { options 1241 builtin/remote.c argc = parse_options(argc, argv, NULL, options, builtin_remote_sethead_usage, options 1267 builtin/remote.c usage_with_options(builtin_remote_sethead_usage, options); options 1338 builtin/remote.c struct option options[] = { options 1343 builtin/remote.c argc = parse_options(argc, argv, NULL, options, builtin_remote_prune_usage, options 1347 builtin/remote.c usage_with_options(builtin_remote_prune_usage, options); options 1367 builtin/remote.c struct option options[] = { options 1376 builtin/remote.c argc = parse_options(argc, argv, NULL, options, builtin_remote_update_usage, options 1454 builtin/remote.c struct option options[] = { options 1459 builtin/remote.c argc = parse_options(argc, argv, NULL, options, options 1463 builtin/remote.c usage_with_options(builtin_remote_setbranches_usage, options); options 1482 builtin/remote.c struct option options[] = { options 1491 builtin/remote.c argc = parse_options(argc, argv, NULL, options, builtin_remote_seturl_usage, options 1498 builtin/remote.c usage_with_options(builtin_remote_seturl_usage, options); options 1558 builtin/remote.c struct option options[] = { options 1564 builtin/remote.c argc = parse_options(argc, argv, prefix, options, builtin_remote_usage, options 1589 builtin/remote.c usage_with_options(builtin_remote_usage, options); options 431 builtin/replace.c struct option options[] = { options 444 builtin/replace.c argc = parse_options(argc, argv, prefix, options, git_replace_usage, 0); options 451 builtin/replace.c git_replace_usage, options); options 458 builtin/replace.c git_replace_usage, options); options 462 builtin/replace.c git_replace_usage, options); options 468 builtin/replace.c git_replace_usage, options); options 474 builtin/replace.c git_replace_usage, options); options 480 builtin/replace.c git_replace_usage, options); options 486 builtin/replace.c git_replace_usage, options); options 492 builtin/replace.c git_replace_usage, options); options 56 builtin/rerere.c struct option options[] = { options 62 builtin/rerere.c argc = parse_options(argc, argv, prefix, options, rerere_usage, 0); options 112 builtin/rerere.c usage_with_options(rerere_usage, options); options 275 builtin/reset.c const struct option options[] = { options 294 builtin/reset.c argc = parse_options(argc, argv, prefix, options, git_reset_usage, options 79 builtin/revert.c struct option options[] = { options 111 builtin/revert.c if (parse_options_concat(options, ARRAY_SIZE(options), cp_extra)) options 115 builtin/revert.c argc = parse_options(argc, argv, NULL, options, usage_str, options 172 builtin/revert.c usage_with_options(usage_str, options); options 181 builtin/revert.c usage_with_options(usage_str, options); options 156 builtin/send-pack.c struct option options[] = { options 182 builtin/send-pack.c argc = parse_options(argc, argv, prefix, options, send_pack_usage, 0); options 190 builtin/send-pack.c usage_with_options(send_pack_usage, options); options 230 builtin/send-pack.c usage_with_options(send_pack_usage, options); options 228 builtin/shortlog.c static const struct option options[] = { options 245 builtin/shortlog.c parse_options_start(&ctx, argc, argv, prefix, options, options 249 builtin/shortlog.c switch (parse_options_step(&ctx, options, shortlog_usage)) { options 255 builtin/shortlog.c parse_revision_opt(&rev, &ctx, options, shortlog_usage); options 262 builtin/shortlog.c usage_with_options(shortlog_usage, options); options 33 builtin/stripspace.c const struct option options[] = { options 43 builtin/stripspace.c argc = parse_options(argc, argv, prefix, options, stripspace_usage, 0); options 45 builtin/stripspace.c usage_with_options(stripspace_usage, options); options 38 builtin/symbolic-ref.c struct option options[] = { options 48 builtin/symbolic-ref.c argc = parse_options(argc, argv, prefix, options, options 55 builtin/symbolic-ref.c usage_with_options(git_symbolic_ref_usage, options); options 73 builtin/symbolic-ref.c usage_with_options(git_symbolic_ref_usage, options); options 589 builtin/tag.c struct option options[] = { options 640 builtin/tag.c argc = parse_options(argc, argv, prefix, options, git_tag_usage, 0); options 652 builtin/tag.c usage_with_options(git_tag_usage, options); options 182 builtin/unpack-objects.c static int check_object(struct object *obj, int type, void *data, struct fsck_options *options) options 916 builtin/update-index.c struct option options[] = { options 1005 builtin/update-index.c usage_with_options(update_index_usage, options); options 1025 builtin/update-index.c options, PARSE_OPT_STOP_AT_NON_OPTION); options 1028 builtin/update-index.c parseopt_state = parse_options_step(&ctx, options, options 1056 builtin/update-index.c usage_with_options(update_index_usage, options); options 361 builtin/update-ref.c struct option options[] = { options 373 builtin/update-ref.c argc = parse_options(argc, argv, prefix, options, git_update_ref_usage, options 388 builtin/update-ref.c usage_with_options(git_update_ref_usage, options); options 400 builtin/update-ref.c usage_with_options(git_update_ref_usage, options); options 404 builtin/update-ref.c usage_with_options(git_update_ref_usage, options); options 410 builtin/update-ref.c usage_with_options(git_update_ref_usage, options); options 13 builtin/update-server-info.c struct option options[] = { options 19 builtin/update-server-info.c argc = parse_options(argc, argv, prefix, options, options 22 builtin/update-server-info.c usage_with_options(update_server_info_usage, options); options 120 builtin/worktree.c struct option options[] = { options 129 builtin/worktree.c ac = parse_options(ac, av, prefix, options, worktree_usage, 0); options 131 builtin/worktree.c usage_with_options(worktree_usage, options); options 315 builtin/worktree.c struct option options[] = { options 326 builtin/worktree.c ac = parse_options(ac, av, prefix, options, worktree_usage, 0); options 330 builtin/worktree.c usage_with_options(worktree_usage, options); options 364 builtin/worktree.c struct option options[] = { options 369 builtin/worktree.c usage_with_options(worktree_usage, options); options 374 builtin/worktree.c usage_with_options(worktree_usage, options); options 351 cache.h #define ce_match_stat(ce, st, options) ie_match_stat(&the_index, (ce), (st), (options)) options 352 cache.h #define ce_modified(ce, st, options) ie_modified(&the_index, (ce), (st), (options)) options 1866 compat/mingw.c pid_t waitpid(pid_t pid, int *status, int options) options 1875 compat/mingw.c if (pid > 0 && options & WNOHANG) { options 1880 compat/mingw.c options &= ~WNOHANG; options 1883 compat/mingw.c if (options == 0) { options 145 compat/mingw.h pid_t waitpid(pid_t pid, int *status, int options); options 253 credential-cache--daemon.c const struct option options[] = { options 259 credential-cache--daemon.c argc = parse_options(argc, argv, NULL, options, usage, 0); options 263 credential-cache--daemon.c usage_with_options(usage, options); options 94 credential-cache.c struct option options[] = { options 102 credential-cache.c argc = parse_options(argc, argv, NULL, options, usage, 0); options 104 credential-cache.c usage_with_options(usage, options); options 155 credential-store.c struct option options[] = { options 163 credential-store.c argc = parse_options(argc, (const char **)argv, NULL, options, usage, 0); options 165 credential-store.c usage_with_options(usage, options); options 78 diff.c static int parse_dirstat_params(struct diff_options *options, const char *params_string, options 91 diff.c DIFF_OPT_CLR(options, DIRSTAT_BY_LINE); options 92 diff.c DIFF_OPT_CLR(options, DIRSTAT_BY_FILE); options 94 diff.c DIFF_OPT_SET(options, DIRSTAT_BY_LINE); options 95 diff.c DIFF_OPT_CLR(options, DIRSTAT_BY_FILE); options 97 diff.c DIFF_OPT_CLR(options, DIRSTAT_BY_LINE); options 98 diff.c DIFF_OPT_SET(options, DIRSTAT_BY_FILE); options 100 diff.c DIFF_OPT_CLR(options, DIRSTAT_CUMULATIVE); options 102 diff.c DIFF_OPT_SET(options, DIRSTAT_CUMULATIVE); options 114 diff.c options->dirstat_permille = permille; options 131 diff.c static int parse_submodule_params(struct diff_options *options, const char *value) options 134 diff.c DIFF_OPT_SET(options, SUBMODULE_LOG); options 136 diff.c DIFF_OPT_CLR(options, SUBMODULE_LOG); options 1533 diff.c static void show_stats(struct diffstat_t *data, struct diff_options *options) options 1546 diff.c line_prefix = diff_line_prefix(options); options 1547 diff.c count = options->stat_count ? options->stat_count : data->nr; options 1549 diff.c reset = diff_get_color_opt(options, DIFF_RESET); options 1550 diff.c add_c = diff_get_color_opt(options, DIFF_FILE_NEW); options 1551 diff.c del_c = diff_get_color_opt(options, DIFF_FILE_OLD); options 1618 diff.c if (options->stat_width == -1) options 1619 diff.c width = term_columns() - options->output_prefix_length; options 1621 diff.c width = options->stat_width ? options->stat_width : 80; options 1625 diff.c if (options->stat_graph_width == -1) options 1626 diff.c options->stat_graph_width = diff_stat_graph_width; options 1641 diff.c if (options->stat_graph_width && options 1642 diff.c options->stat_graph_width < graph_width) options 1643 diff.c graph_width = options->stat_graph_width; options 1645 diff.c name_width = (options->stat_name_width > 0 && options 1646 diff.c options->stat_name_width < max_len) ? options 1647 diff.c options->stat_name_width : max_len; options 1659 diff.c if (options->stat_graph_width && options 1660 diff.c graph_width > options->stat_graph_width) options 1661 diff.c graph_width = options->stat_graph_width; options 1700 diff.c fprintf(options->file, "%s", line_prefix); options 1701 diff.c show_name(options->file, prefix, name, len); options 1702 diff.c fprintf(options->file, " %*s", number_width, "Bin"); options 1704 diff.c putc('\n', options->file); options 1707 diff.c fprintf(options->file, " %s%"PRIuMAX"%s", options 1709 diff.c fprintf(options->file, " -> "); options 1710 diff.c fprintf(options->file, "%s%"PRIuMAX"%s", options 1712 diff.c fprintf(options->file, " bytes"); options 1713 diff.c fprintf(options->file, "\n"); options 1717 diff.c fprintf(options->file, "%s", line_prefix); options 1718 diff.c show_name(options->file, prefix, name, len); options 1719 diff.c fprintf(options->file, " Unmerged\n"); options 1742 diff.c fprintf(options->file, "%s", line_prefix); options 1743 diff.c show_name(options->file, prefix, name, len); options 1744 diff.c fprintf(options->file, " %*"PRIuMAX"%s", options 1747 diff.c show_graph(options->file, '+', add, add_c, reset); options 1748 diff.c show_graph(options->file, '-', del, del_c, reset); options 1749 diff.c fprintf(options->file, "\n"); options 1770 diff.c fprintf(options->file, "%s ...\n", line_prefix); options 1773 diff.c fprintf(options->file, "%s", line_prefix); options 1774 diff.c print_stat_summary(options->file, total_files, adds, dels); options 1777 diff.c static void show_shortstats(struct diffstat_t *data, struct diff_options *options) options 1796 diff.c fprintf(options->file, "%s", diff_line_prefix(options)); options 1797 diff.c print_stat_summary(options->file, total_files, adds, dels); options 1800 diff.c static void show_numstat(struct diffstat_t *data, struct diff_options *options) options 1810 diff.c fprintf(options->file, "%s", diff_line_prefix(options)); options 1813 diff.c fprintf(options->file, "-\t-\t"); options 1815 diff.c fprintf(options->file, options 1818 diff.c if (options->line_termination) { options 1821 diff.c write_name_quoted(file->name, options->file, options 1822 diff.c options->line_termination); options 1824 diff.c fputs(file->print_name, options->file); options 1825 diff.c putc(options->line_termination, options->file); options 1829 diff.c putc('\0', options->file); options 1830 diff.c write_name_quoted(file->from_name, options->file, '\0'); options 1832 diff.c write_name_quoted(file->name, options->file, '\0'); options 1905 diff.c static void show_dirstat(struct diff_options *options) options 1915 diff.c dir.permille = options->dirstat_permille; options 1916 diff.c dir.cumulative = DIFF_OPT_TST(options, DIRSTAT_CUMULATIVE); options 1942 diff.c if (DIFF_OPT_TST(options, DIRSTAT_BY_FILE)) { options 2001 diff.c gather_dirstat(options, &dir, changed, "", 0); options 2004 diff.c static void show_dirstat_by_line(struct diffstat_t *data, struct diff_options *options) options 2016 diff.c dir.permille = options->dirstat_permille; options 2017 diff.c dir.cumulative = DIFF_OPT_TST(options, DIRSTAT_CUMULATIVE); options 2045 diff.c gather_dirstat(options, &dir, changed, "", 0); options 2256 diff.c void diff_set_mnemonic_prefix(struct diff_options *options, const char *a, const char *b) options 2258 diff.c if (!options->a_prefix) options 2259 diff.c options->a_prefix = a; options 2260 diff.c if (!options->b_prefix) options 2261 diff.c options->b_prefix = b; options 3261 diff.c void diff_setup(struct diff_options *options) options 3263 diff.c memcpy(options, &default_diff_options, sizeof(*options)); options 3265 diff.c options->file = stdout; options 3267 diff.c options->line_termination = '\n'; options 3268 diff.c options->break_opt = -1; options 3269 diff.c options->rename_limit = -1; options 3270 diff.c options->dirstat_permille = diff_dirstat_permille_default; options 3271 diff.c options->context = diff_context_default; options 3272 diff.c options->ws_error_highlight = WSEH_NEW; options 3273 diff.c DIFF_OPT_SET(options, RENAME_EMPTY); options 3276 diff.c options->change = diff_change; options 3277 diff.c options->add_remove = diff_addremove; options 3278 diff.c options->use_color = diff_use_color_default; options 3279 diff.c options->detect_rename = diff_detect_rename_default; options 3280 diff.c options->xdl_opts |= diff_algorithm; options 3282 diff.c options->orderfile = diff_order_file_cfg; options 3285 diff.c options->a_prefix = options->b_prefix = ""; options 3287 diff.c options->a_prefix = "a/"; options 3288 diff.c options->b_prefix = "b/"; options 3292 diff.c void diff_setup_done(struct diff_options *options) options 3296 diff.c if (options->set_default) options 3297 diff.c options->set_default(options); options 3299 diff.c if (options->output_format & DIFF_FORMAT_NAME) options 3301 diff.c if (options->output_format & DIFF_FORMAT_NAME_STATUS) options 3303 diff.c if (options->output_format & DIFF_FORMAT_CHECKDIFF) options 3305 diff.c if (options->output_format & DIFF_FORMAT_NO_OUTPUT) options 3317 diff.c if (DIFF_XDL_TST(options, IGNORE_WHITESPACE) || options 3318 diff.c DIFF_XDL_TST(options, IGNORE_WHITESPACE_CHANGE) || options 3319 diff.c DIFF_XDL_TST(options, IGNORE_WHITESPACE_AT_EOL)) options 3320 diff.c DIFF_OPT_SET(options, DIFF_FROM_CONTENTS); options 3322 diff.c DIFF_OPT_CLR(options, DIFF_FROM_CONTENTS); options 3324 diff.c if (DIFF_OPT_TST(options, FIND_COPIES_HARDER)) options 3325 diff.c options->detect_rename = DIFF_DETECT_COPY; options 3327 diff.c if (!DIFF_OPT_TST(options, RELATIVE_NAME)) options 3328 diff.c options->prefix = NULL; options 3329 diff.c if (options->prefix) options 3330 diff.c options->prefix_length = strlen(options->prefix); options 3332 diff.c options->prefix_length = 0; options 3334 diff.c if (options->output_format & (DIFF_FORMAT_NAME | options 3338 diff.c options->output_format &= ~(DIFF_FORMAT_RAW | options 3350 diff.c if (options->output_format & (DIFF_FORMAT_PATCH | options 3357 diff.c DIFF_OPT_SET(options, RECURSIVE); options 3361 diff.c if (options->pickaxe) options 3362 diff.c DIFF_OPT_SET(options, RECURSIVE); options 3367 diff.c if (options->output_format & DIFF_FORMAT_PATCH) options 3368 diff.c DIFF_OPT_SET(options, DIRTY_SUBMODULES); options 3370 diff.c if (options->detect_rename && options->rename_limit < 0) options 3371 diff.c options->rename_limit = diff_rename_limit_default; options 3372 diff.c if (options->setup & DIFF_SETUP_USE_CACHE) { options 3382 diff.c if (options->abbrev <= 0 || 40 < options->abbrev) options 3383 diff.c options->abbrev = 40; /* full */ options 3390 diff.c if (DIFF_OPT_TST(options, QUICK)) { options 3391 diff.c options->output_format = DIFF_FORMAT_NO_OUTPUT; options 3392 diff.c DIFF_OPT_SET(options, EXIT_WITH_STATUS); options 3395 diff.c options->diff_path_counter = 0; options 3397 diff.c if (DIFF_OPT_TST(options, FOLLOW_RENAMES) && options->pathspec.nr != 1) options 3484 diff.c static int stat_opt(struct diff_options *options, const char **av) options 3488 diff.c int width = options->stat_width; options 3489 diff.c int name_width = options->stat_name_width; options 3490 diff.c int graph_width = options->stat_graph_width; options 3491 diff.c int count = options->stat_count; options 3549 diff.c options->output_format |= DIFF_FORMAT_DIFFSTAT; options 3550 diff.c options->stat_name_width = name_width; options 3551 diff.c options->stat_graph_width = graph_width; options 3552 diff.c options->stat_width = width; options 3553 diff.c options->stat_count = count; options 3557 diff.c static int parse_dirstat_opt(struct diff_options *options, const char *params) options 3560 diff.c if (parse_dirstat_params(options, params, &errmsg)) options 3568 diff.c options->output_format |= DIFF_FORMAT_DIRSTAT; options 3572 diff.c static int parse_submodule_opt(struct diff_options *options, const char *value) options 3574 diff.c if (parse_submodule_params(options, value)) options 3698 diff.c int diff_opt_parse(struct diff_options *options, const char **av, int ac) options 3706 diff.c || opt_arg(arg, 'U', "unified", &options->context)) options 3707 diff.c enable_patch_output(&options->output_format); options 3709 diff.c options->output_format |= DIFF_FORMAT_RAW; options 3711 diff.c enable_patch_output(&options->output_format); options 3712 diff.c options->output_format |= DIFF_FORMAT_RAW; options 3714 diff.c options->output_format |= DIFF_FORMAT_NUMSTAT; options 3716 diff.c options->output_format |= DIFF_FORMAT_SHORTSTAT; options 3718 diff.c return parse_dirstat_opt(options, ""); options 3720 diff.c return parse_dirstat_opt(options, arg); options 3722 diff.c return parse_dirstat_opt(options, arg); options 3724 diff.c return parse_dirstat_opt(options, "cumulative"); options 3726 diff.c return parse_dirstat_opt(options, "files"); options 3728 diff.c parse_dirstat_opt(options, "files"); options 3729 diff.c return parse_dirstat_opt(options, arg); options 3732 diff.c options->output_format |= DIFF_FORMAT_CHECKDIFF; options 3734 diff.c options->output_format |= DIFF_FORMAT_SUMMARY; options 3736 diff.c enable_patch_output(&options->output_format); options 3737 diff.c options->output_format |= DIFF_FORMAT_DIFFSTAT; options 3739 diff.c options->output_format |= DIFF_FORMAT_NAME; options 3741 diff.c options->output_format |= DIFF_FORMAT_NAME_STATUS; options 3743 diff.c options->output_format |= DIFF_FORMAT_NO_OUTPUT; options 3746 diff.c return stat_opt(options, av); options 3751 diff.c if ((options->break_opt = diff_scoreopt_parse(arg)) == -1) options 3756 diff.c if ((options->rename_score = diff_scoreopt_parse(arg)) == -1) options 3758 diff.c options->detect_rename = DIFF_DETECT_RENAME; options 3761 diff.c options->irreversible_delete = 1; options 3765 diff.c if (options->detect_rename == DIFF_DETECT_COPY) options 3766 diff.c DIFF_OPT_SET(options, FIND_COPIES_HARDER); options 3767 diff.c if ((options->rename_score = diff_scoreopt_parse(arg)) == -1) options 3769 diff.c options->detect_rename = DIFF_DETECT_COPY; options 3772 diff.c options->detect_rename = 0; options 3774 diff.c DIFF_OPT_SET(options, RENAME_EMPTY); options 3776 diff.c DIFF_OPT_CLR(options, RENAME_EMPTY); options 3778 diff.c DIFF_OPT_SET(options, RELATIVE_NAME); options 3780 diff.c DIFF_OPT_SET(options, RELATIVE_NAME); options 3781 diff.c options->prefix = arg; options 3786 diff.c DIFF_XDL_SET(options, NEED_MINIMAL); options 3788 diff.c DIFF_XDL_CLR(options, NEED_MINIMAL); options 3790 diff.c DIFF_XDL_SET(options, IGNORE_WHITESPACE); options 3792 diff.c DIFF_XDL_SET(options, IGNORE_WHITESPACE_CHANGE); options 3794 diff.c DIFF_XDL_SET(options, IGNORE_WHITESPACE_AT_EOL); options 3796 diff.c DIFF_XDL_SET(options, IGNORE_BLANK_LINES); options 3798 diff.c options->xdl_opts = DIFF_WITH_ALG(options, PATIENCE_DIFF); options 3800 diff.c options->xdl_opts = DIFF_WITH_ALG(options, HISTOGRAM_DIFF); options 3807 diff.c DIFF_XDL_CLR(options, NEED_MINIMAL); options 3808 diff.c options->xdl_opts &= ~XDF_DIFF_ALGORITHM_MASK; options 3809 diff.c options->xdl_opts |= value; options 3815 diff.c enable_patch_output(&options->output_format); options 3816 diff.c DIFF_OPT_SET(options, BINARY); options 3819 diff.c DIFF_OPT_SET(options, FULL_INDEX); options 3821 diff.c DIFF_OPT_SET(options, TEXT); options 3823 diff.c DIFF_OPT_SET(options, REVERSE_DIFF); options 3825 diff.c DIFF_OPT_SET(options, FIND_COPIES_HARDER); options 3827 diff.c DIFF_OPT_SET(options, FOLLOW_RENAMES); options 3829 diff.c DIFF_OPT_CLR(options, FOLLOW_RENAMES); options 3830 diff.c DIFF_OPT_CLR(options, DEFAULT_FOLLOW_RENAMES); options 3832 diff.c options->use_color = 1; options 3837 diff.c options->use_color = value; options 3840 diff.c options->use_color = 0; options 3842 diff.c options->use_color = 1; options 3843 diff.c options->word_diff = DIFF_WORDS_COLOR; options 3846 diff.c options->use_color = 1; options 3847 diff.c options->word_diff = DIFF_WORDS_COLOR; options 3848 diff.c options->word_regex = arg; options 3851 diff.c if (options->word_diff == DIFF_WORDS_NONE) options 3852 diff.c options->word_diff = DIFF_WORDS_PLAIN; options 3856 diff.c options->word_diff = DIFF_WORDS_PLAIN; options 3858 diff.c options->use_color = 1; options 3859 diff.c options->word_diff = DIFF_WORDS_COLOR; options 3862 diff.c options->word_diff = DIFF_WORDS_PORCELAIN; options 3864 diff.c options->word_diff = DIFF_WORDS_NONE; options 3869 diff.c if (options->word_diff == DIFF_WORDS_NONE) options 3870 diff.c options->word_diff = DIFF_WORDS_PLAIN; options 3871 diff.c options->word_regex = optarg; options 3875 diff.c DIFF_OPT_SET(options, EXIT_WITH_STATUS); options 3877 diff.c DIFF_OPT_SET(options, QUICK); options 3879 diff.c DIFF_OPT_SET(options, ALLOW_EXTERNAL); options 3881 diff.c DIFF_OPT_CLR(options, ALLOW_EXTERNAL); options 3883 diff.c DIFF_OPT_SET(options, ALLOW_TEXTCONV); options 3885 diff.c DIFF_OPT_CLR(options, ALLOW_TEXTCONV); options 3887 diff.c DIFF_OPT_SET(options, OVERRIDE_SUBMODULE_CONFIG); options 3888 diff.c handle_ignore_submodules_arg(options, "all"); options 3890 diff.c DIFF_OPT_SET(options, OVERRIDE_SUBMODULE_CONFIG); options 3891 diff.c handle_ignore_submodules_arg(options, arg); options 3893 diff.c DIFF_OPT_SET(options, SUBMODULE_LOG); options 3895 diff.c return parse_submodule_opt(options, arg); options 3897 diff.c return parse_ws_error_highlight(options, arg); options 3901 diff.c options->line_termination = 0; options 3903 diff.c options->rename_limit = strtoul(optarg, NULL, 10); options 3907 diff.c options->pickaxe = optarg; options 3908 diff.c options->pickaxe_opts |= DIFF_PICKAXE_KIND_S; options 3911 diff.c options->pickaxe = optarg; options 3912 diff.c options->pickaxe_opts |= DIFF_PICKAXE_KIND_G; options 3916 diff.c options->pickaxe_opts |= DIFF_PICKAXE_ALL; options 3918 diff.c options->pickaxe_opts |= DIFF_PICKAXE_REGEX; options 3920 diff.c options->orderfile = optarg; options 3924 diff.c int offending = parse_diff_filter_opt(optarg, options); options 3931 diff.c options->abbrev = DEFAULT_ABBREV; options 3933 diff.c options->abbrev = strtoul(arg, NULL, 10); options 3934 diff.c if (options->abbrev < MINIMUM_ABBREV) options 3935 diff.c options->abbrev = MINIMUM_ABBREV; options 3936 diff.c else if (40 < options->abbrev) options 3937 diff.c options->abbrev = 40; options 3940 diff.c options->a_prefix = optarg; options 3944 diff.c options->b_prefix = optarg; options 3948 diff.c options->a_prefix = options->b_prefix = ""; options 3950 diff.c &options->interhunkcontext)) options 3953 diff.c DIFF_OPT_SET(options, FUNCCONTEXT); options 3955 diff.c DIFF_OPT_SET(options, FUNCCONTEXT); options 3957 diff.c DIFF_OPT_CLR(options, FUNCCONTEXT); options 3959 diff.c options->file = fopen(optarg, "w"); options 3960 diff.c if (!options->file) options 3962 diff.c options->close_file = 1; options 4435 diff.c static int diff_get_patch_id(struct diff_options *options, unsigned char *sha1) options 4527 diff.c int diff_flush_patch_id(struct diff_options *options, unsigned char *sha1) options 4531 diff.c int result = diff_get_patch_id(options, sha1); options 4589 diff.c void diff_flush(struct diff_options *options) options 4592 diff.c int i, output_format = options->output_format; options 4610 diff.c flush_one_pair(p, options); options 4615 diff.c if (output_format & DIFF_FORMAT_DIRSTAT && DIFF_OPT_TST(options, DIRSTAT_BY_LINE)) options 4626 diff.c diff_flush_stat(p, options, &diffstat); options 4629 diff.c show_numstat(&diffstat, options); options 4631 diff.c show_stats(&diffstat, options); options 4633 diff.c show_shortstats(&diffstat, options); options 4635 diff.c show_dirstat_by_line(&diffstat, options); options 4640 diff.c show_dirstat(options); options 4644 diff.c diff_summary(options, q->queue[i]); options 4650 diff.c DIFF_OPT_TST(options, EXIT_WITH_STATUS) && options 4651 diff.c DIFF_OPT_TST(options, DIFF_FROM_CONTENTS)) { options 4657 diff.c if (options->close_file) options 4658 diff.c fclose(options->file); options 4659 diff.c options->file = fopen("/dev/null", "w"); options 4660 diff.c if (!options->file) options 4662 diff.c options->close_file = 1; options 4666 diff.c diff_flush_patch(p, options); options 4667 diff.c if (options->found_changes) options 4674 diff.c fprintf(options->file, "%s%c", options 4675 diff.c diff_line_prefix(options), options 4676 diff.c options->line_termination); options 4677 diff.c if (options->stat_sep) { options 4679 diff.c fputs(options->stat_sep, options->file); options 4686 diff.c diff_flush_patch(p, options); options 4691 diff.c options->format_callback(q, options, options->format_callback_data); options 4698 diff.c if (options->close_file) options 4699 diff.c fclose(options->file); options 4706 diff.c if (DIFF_OPT_TST(options, DIFF_FROM_CONTENTS)) { options 4707 diff.c if (options->found_changes) options 4708 diff.c DIFF_OPT_SET(options, HAS_CHANGES); options 4710 diff.c DIFF_OPT_CLR(options, HAS_CHANGES); options 4714 diff.c static int match_filter(const struct diff_options *options, const struct diff_filepair *p) options 4718 diff.c filter_bit_tst(DIFF_STATUS_FILTER_BROKEN, options)) || options 4720 diff.c filter_bit_tst(DIFF_STATUS_MODIFIED, options)))) || options 4722 diff.c filter_bit_tst(p->status, options))); options 4725 diff.c static void diffcore_apply_filter(struct diff_options *options) options 4733 diff.c if (!options->filter) options 4736 diff.c if (filter_bit_tst(DIFF_STATUS_FILTER_AON, options)) { options 4739 diff.c if (match_filter(options, q->queue[i])) options 4757 diff.c if (match_filter(options, p)) options 4850 diff.c void diffcore_fix_diff_index(struct diff_options *options) options 4856 diff.c void diffcore_std(struct diff_options *options) options 4859 diff.c if (options->skip_stat_unmatch) options 4860 diff.c diffcore_skip_stat_unmatch(options); options 4861 diff.c if (!options->found_follow) { options 4863 diff.c if (options->break_opt != -1) options 4864 diff.c diffcore_break(options->break_opt); options 4865 diff.c if (options->detect_rename) options 4866 diff.c diffcore_rename(options); options 4867 diff.c if (options->break_opt != -1) options 4870 diff.c if (options->pickaxe) options 4871 diff.c diffcore_pickaxe(options); options 4872 diff.c if (options->orderfile) options 4873 diff.c diffcore_order(options->orderfile); options 4874 diff.c if (!options->found_follow) options 4877 diff.c diffcore_apply_filter(options); options 4879 diff.c if (diff_queued_diff.nr && !DIFF_OPT_TST(options, DIFF_FROM_CONTENTS)) options 4880 diff.c DIFF_OPT_SET(options, HAS_CHANGES); options 4882 diff.c DIFF_OPT_CLR(options, HAS_CHANGES); options 4884 diff.c options->found_follow = 0; options 4919 diff.c static int is_submodule_ignored(const char *path, struct diff_options *options) options 4922 diff.c unsigned orig_flags = options->flags; options 4923 diff.c if (!DIFF_OPT_TST(options, OVERRIDE_SUBMODULE_CONFIG)) options 4924 diff.c set_diffopt_flags_from_submodule_config(options, path); options 4925 diff.c if (DIFF_OPT_TST(options, IGNORE_SUBMODULES)) options 4927 diff.c options->flags = orig_flags; options 4931 diff.c void diff_addremove(struct diff_options *options, options 4939 diff.c if (S_ISGITLINK(mode) && is_submodule_ignored(concatpath, options)) options 4954 diff.c if (DIFF_OPT_TST(options, REVERSE_DIFF)) options 4958 diff.c if (options->prefix && options 4959 diff.c strncmp(concatpath, options->prefix, options->prefix_length)) options 4973 diff.c if (!DIFF_OPT_TST(options, DIFF_FROM_CONTENTS)) options 4974 diff.c DIFF_OPT_SET(options, HAS_CHANGES); options 4977 diff.c void diff_change(struct diff_options *options, options 4989 diff.c is_submodule_ignored(concatpath, options)) options 4992 diff.c if (DIFF_OPT_TST(options, REVERSE_DIFF)) { options 5003 diff.c if (options->prefix && options 5004 diff.c strncmp(concatpath, options->prefix, options->prefix_length)) options 5015 diff.c if (DIFF_OPT_TST(options, DIFF_FROM_CONTENTS)) options 5018 diff.c if (DIFF_OPT_TST(options, QUICK) && options->skip_stat_unmatch && options 5022 diff.c DIFF_OPT_SET(options, HAS_CHANGES); options 5025 diff.c struct diff_filepair *diff_unmerge(struct diff_options *options, const char *path) options 5030 diff.c if (options->prefix && options 5031 diff.c strncmp(path, options->prefix, options->prefix_length)) options 21 diff.h typedef int (*pathchange_fn_t)(struct diff_options *options, options 24 diff.h typedef void (*change_fn_t)(struct diff_options *options, options 32 diff.h typedef void (*add_remove_fn_t)(struct diff_options *options, options 39 diff.h struct diff_options *options, void *data); options 235 diff.h void diff_set_mnemonic_prefix(struct diff_options *options, const char *a, const char *b); options 273 diffcore-rename.c struct diff_options *options) options 299 diffcore-rename.c if (source->rename_used && options->detect_rename != DIFF_DETECT_COPY) options 338 diffcore-rename.c static int find_exact_renames(struct diff_options *options) options 350 diffcore-rename.c renames += find_identical_files(&file_table, i, options); options 381 diffcore-rename.c struct diff_options *options) options 383 diffcore-rename.c int rename_limit = options->rename_limit; options 387 diffcore-rename.c options->needed_rename_limit = 0; options 404 diffcore-rename.c options->needed_rename_limit = options 408 diffcore-rename.c if (!DIFF_OPT_TST(options, FIND_COPIES_HARDER)) options 444 diffcore-rename.c void diffcore_rename(struct diff_options *options) options 446 diffcore-rename.c int detect_rename = options->detect_rename; options 447 diffcore-rename.c int minimum_score = options->rename_score; options 463 diffcore-rename.c else if (options->single_follow && options 464 diffcore-rename.c strcmp(options->single_follow, p->two->path)) options 466 diffcore-rename.c else if (!DIFF_OPT_TST(options, RENAME_EMPTY) && options 476 diffcore-rename.c else if (!DIFF_OPT_TST(options, RENAME_EMPTY) && options 507 diffcore-rename.c rename_count = find_exact_renames(options); options 523 diffcore-rename.c switch (too_many_rename_candidates(num_create, options)) { options 527 diffcore-rename.c options->degraded_cc_to_c = 1; options 534 diffcore-rename.c if (options->show_rename_progress) { options 114 fsck.c struct fsck_options *options) options 120 fsck.c if (options->msg_type) options 121 fsck.c msg_type = options->msg_type[msg_id]; options 124 fsck.c if (options->strict && msg_type == FSCK_WARN) options 131 fsck.c static void init_skiplist(struct fsck_options *options, const char *path) options 138 fsck.c if (options->skiplist) options 139 fsck.c sorted = options->skiplist->sorted; options 142 fsck.c options->skiplist = &skiplist; options 188 fsck.c void fsck_set_msg_type(struct fsck_options *options, options 200 fsck.c if (!options->msg_type) { options 204 fsck.c msg_type[i] = fsck_msg_type(i, options); options 205 fsck.c options->msg_type = msg_type; options 208 fsck.c options->msg_type[id] = type; options 211 fsck.c void fsck_set_msg_types(struct fsck_options *options, const char *values) options 235 fsck.c init_skiplist(options, buf + equal + 1); options 243 fsck.c fsck_set_msg_type(options, buf, buf + equal + 1); options 268 fsck.c static int report(struct fsck_options *options, struct object *object, options 273 fsck.c int msg_type = fsck_msg_type(id, options), result; options 278 fsck.c if (options->skiplist && object && options 279 fsck.c sha1_array_lookup(options->skiplist, object->sha1) >= 0) options 291 fsck.c result = options->error_func(object, msg_type, sb.buf); options 298 fsck.c static int fsck_walk_tree(struct tree *tree, void *data, struct fsck_options *options) options 314 fsck.c result = options->walk(&lookup_tree(entry.sha1)->object, OBJ_TREE, data, options); options 316 fsck.c result = options->walk(&lookup_blob(entry.sha1)->object, OBJ_BLOB, data, options); options 329 fsck.c static int fsck_walk_commit(struct commit *commit, void *data, struct fsck_options *options) options 338 fsck.c result = options->walk((struct object *)commit->tree, OBJ_TREE, data, options); options 345 fsck.c result = options->walk((struct object *)parents->item, OBJ_COMMIT, data, options); options 355 fsck.c static int fsck_walk_tag(struct tag *tag, void *data, struct fsck_options *options) options 359 fsck.c return options->walk(tag->tagged, OBJ_ANY, data, options); options 362 fsck.c int fsck_walk(struct object *obj, void *data, struct fsck_options *options) options 370 fsck.c return fsck_walk_tree((struct tree *)obj, data, options); options 372 fsck.c return fsck_walk_commit((struct commit *)obj, data, options); options 374 fsck.c return fsck_walk_tag((struct tag *)obj, data, options); options 427 fsck.c static int fsck_tree(struct tree *item, struct fsck_options *options) options 483 fsck.c if (!options->strict) options 508 fsck.c retval += report(options, &item->object, FSCK_MSG_NULL_SHA1, "contains entries pointing to null sha1"); options 510 fsck.c retval += report(options, &item->object, FSCK_MSG_FULL_PATHNAME, "contains full pathnames"); options 512 fsck.c retval += report(options, &item->object, FSCK_MSG_EMPTY_NAME, "contains empty pathname"); options 514 fsck.c retval += report(options, &item->object, FSCK_MSG_HAS_DOT, "contains '.'"); options 516 fsck.c retval += report(options, &item->object, FSCK_MSG_HAS_DOTDOT, "contains '..'"); options 518 fsck.c retval += report(options, &item->object, FSCK_MSG_HAS_DOTGIT, "contains '.git'"); options 520 fsck.c retval += report(options, &item->object, FSCK_MSG_ZERO_PADDED_FILEMODE, "contains zero-padded file modes"); options 522 fsck.c retval += report(options, &item->object, FSCK_MSG_BAD_FILEMODE, "contains bad file modes"); options 524 fsck.c retval += report(options, &item->object, FSCK_MSG_DUPLICATE_ENTRIES, "contains duplicate file entries"); options 526 fsck.c retval += report(options, &item->object, FSCK_MSG_TREE_NOT_SORTED, "not properly sorted"); options 531 fsck.c struct object *obj, struct fsck_options *options) options 539 fsck.c return report(options, obj, options 557 fsck.c return report(options, obj, options 561 fsck.c static int fsck_ident(const char **ident, struct object *obj, struct fsck_options *options) options 571 fsck.c return report(options, obj, FSCK_MSG_MISSING_NAME_BEFORE_EMAIL, "invalid author/committer line - missing space before email"); options 574 fsck.c return report(options, obj, FSCK_MSG_BAD_NAME, "invalid author/committer line - bad name"); options 576 fsck.c return report(options, obj, FSCK_MSG_MISSING_EMAIL, "invalid author/committer line - missing email"); options 578 fsck.c return report(options, obj, FSCK_MSG_MISSING_SPACE_BEFORE_EMAIL, "invalid author/committer line - missing space before email"); options 582 fsck.c return report(options, obj, FSCK_MSG_BAD_EMAIL, "invalid author/committer line - bad email"); options 585 fsck.c return report(options, obj, FSCK_MSG_MISSING_SPACE_BEFORE_DATE, "invalid author/committer line - missing space before date"); options 588 fsck.c return report(options, obj, FSCK_MSG_ZERO_PADDED_DATE, "invalid author/committer line - zero-padded date"); options 590 fsck.c return report(options, obj, FSCK_MSG_BAD_DATE_OVERFLOW, "invalid author/committer line - date causes integer overflow"); options 592 fsck.c return report(options, obj, FSCK_MSG_BAD_DATE, "invalid author/committer line - bad date"); options 600 fsck.c return report(options, obj, FSCK_MSG_BAD_TIMEZONE, "invalid author/committer line - bad time zone"); options 606 fsck.c unsigned long size, struct fsck_options *options) options 613 fsck.c if (verify_headers(buffer, size, &commit->object, options)) options 617 fsck.c return report(options, &commit->object, FSCK_MSG_MISSING_TREE, "invalid format - expected 'tree' line"); options 619 fsck.c err = report(options, &commit->object, FSCK_MSG_BAD_TREE_SHA1, "invalid 'tree' line format - bad sha1"); options 626 fsck.c err = report(options, &commit->object, FSCK_MSG_BAD_PARENT_SHA1, "invalid 'parent' line format - bad sha1"); options 639 fsck.c err = report(options, &commit->object, FSCK_MSG_MISSING_GRAFT, "graft objects missing"); options 645 fsck.c err = report(options, &commit->object, FSCK_MSG_MISSING_PARENT, "parent objects missing"); options 653 fsck.c err = fsck_ident(&buffer, &commit->object, options); options 658 fsck.c err = report(options, &commit->object, FSCK_MSG_MISSING_AUTHOR, "invalid format - expected 'author' line"); options 660 fsck.c err = report(options, &commit->object, FSCK_MSG_MULTIPLE_AUTHORS, "invalid format - multiple 'author' lines"); options 664 fsck.c return report(options, &commit->object, FSCK_MSG_MISSING_COMMITTER, "invalid format - expected 'committer' line"); options 665 fsck.c err = fsck_ident(&buffer, &commit->object, options); options 669 fsck.c return report(options, &commit->object, FSCK_MSG_BAD_TREE, "could not load commit's tree %s", sha1_to_hex(tree_sha1)); options 675 fsck.c unsigned long size, struct fsck_options *options) options 678 fsck.c int ret = fsck_commit_buffer(commit, buffer, size, options); options 685 fsck.c unsigned long size, struct fsck_options *options) options 701 fsck.c return report(options, &tag->object, options 706 fsck.c ret = report(options, &tag->object, options 714 fsck.c if (verify_headers(buffer, size, &tag->object, options)) options 718 fsck.c ret = report(options, &tag->object, FSCK_MSG_MISSING_OBJECT, "invalid format - expected 'object' line"); options 722 fsck.c ret = report(options, &tag->object, FSCK_MSG_BAD_OBJECT_SHA1, "invalid 'object' line format - bad sha1"); options 729 fsck.c ret = report(options, &tag->object, FSCK_MSG_MISSING_TYPE_ENTRY, "invalid format - expected 'type' line"); options 734 fsck.c ret = report(options, &tag->object, FSCK_MSG_MISSING_TYPE, "invalid format - unexpected end after 'type' line"); options 738 fsck.c ret = report(options, &tag->object, FSCK_MSG_BAD_TYPE, "invalid 'type' value"); options 744 fsck.c ret = report(options, &tag->object, FSCK_MSG_MISSING_TAG_ENTRY, "invalid format - expected 'tag' line"); options 749 fsck.c ret = report(options, &tag->object, FSCK_MSG_MISSING_TAG, "invalid format - unexpected end after 'type' line"); options 754 fsck.c ret = report(options, &tag->object, FSCK_MSG_BAD_TAG_NAME, options 764 fsck.c ret = report(options, &tag->object, FSCK_MSG_MISSING_TAGGER_ENTRY, "invalid format - expected 'tagger' line"); options 769 fsck.c ret = fsck_ident(&buffer, &tag->object, options); options 778 fsck.c unsigned long size, struct fsck_options *options) options 783 fsck.c return report(options, &tag->object, FSCK_MSG_BAD_TAG_OBJECT, "could not load tagged object"); options 785 fsck.c return fsck_tag_buffer(tag, data, size, options); options 789 fsck.c struct fsck_options *options) options 792 fsck.c return report(options, obj, FSCK_MSG_BAD_OBJECT_SHA1, "no valid object to fsck"); options 797 fsck.c return fsck_tree((struct tree *) obj, options); options 800 fsck.c size, options); options 803 fsck.c size, options); options 805 fsck.c return report(options, obj, FSCK_MSG_UNKNOWN_TYPE, "unknown type '%d' (internal fsck error)", options 10 fsck.h void fsck_set_msg_type(struct fsck_options *options, options 12 fsck.h void fsck_set_msg_types(struct fsck_options *options, const char *values); options 23 fsck.h typedef int (*fsck_walk_func)(struct object *obj, int type, void *data, struct fsck_options *options); options 48 fsck.h int fsck_walk(struct object *obj, void *data, struct fsck_options *options); options 51 fsck.h struct fsck_options *options); options 323 grep.c int options = PCRE_MULTILINE; options 326 grep.c options |= PCRE_CASELESS; options 328 grep.c p->pcre_regexp = pcre_compile(p->pattern, options, &error, &erroffset, options 210 http-push.c static struct curl_slist *get_dav_token_headers(struct remote_lock *lock, enum dav_header_flag options) options 215 http-push.c if (options & DAV_HEADER_IF) { options 220 http-push.c if (options & DAV_HEADER_LOCK) { options 225 http-push.c if (options & DAV_HEADER_TIMEOUT) { options 1182 http.c const struct http_get_options *options) options 1220 http.c if (options && options->no_cache) options 1222 http.c if (options && options->keep_error) options 1233 http.c if (options && options->content_type) { options 1236 http.c extract_content_type(&raw, options->content_type, options 1237 http.c options->charset); options 1241 http.c if (options && options->effective_url) options 1243 http.c options->effective_url); options 1303 http.c struct http_get_options *options) options 1305 http.c int ret = http_request(url, result, target, options); options 1307 http.c if (options && options->effective_url && options->base_url) { options 1308 http.c if (update_url_from_redirect(options->base_url, options 1309 http.c url, options->effective_url)) { options 1310 http.c credential_from_url(&http_auth, options->base_url->buf); options 1311 http.c url = options->effective_url->buf; options 1324 http.c if (options && options->keep_error) { options 1336 http.c return http_request(url, result, target, options); options 1341 http.c struct http_get_options *options) options 1343 http.c return http_request_reauth(url, result, HTTP_REQUEST_STRBUF, options); options 1353 http.c struct http_get_options *options) options 1367 http.c ret = http_request_reauth(url, result, HTTP_REQUEST_FILE, options); options 1379 http.c struct http_get_options options = {0}; options 1384 http.c options.no_cache = 1; options 1387 http.c if (http_get_strbuf(url, &buffer, &options) == HTTP_OK) { options 1471 http.c struct http_get_options options = {0}; options 1481 http.c options.no_cache = 1; options 1482 http.c ret = http_get_strbuf(url, &buf, &options); options 179 http.h int http_get_strbuf(const char *url, struct strbuf *result, struct http_get_options *options); options 202 merge-recursive.c const char *path, int stage, int refresh, int options) options 210 merge-recursive.c return add_cache_entry(ce, options); options 547 merge-recursive.c int options = ADD_CACHE_OK_TO_ADD | ADD_CACHE_SKIP_DFCHECK; options 552 merge-recursive.c if (add_cacheinfo(o->mode, o->sha1, path, 1, 0, options)) options 555 merge-recursive.c if (add_cacheinfo(a->mode, a->sha1, path, 2, 0, options)) options 558 merge-recursive.c if (add_cacheinfo(b->mode, b->sha1, path, 3, 0, options)) options 511 pack-bitmap-write.c uint16_t options) options 528 pack-bitmap-write.c header.options = htons(flags | options); options 539 pack-bitmap-write.c if (options & BITMAP_OPT_HASH_CACHE) options 153 pack-bitmap.c uint32_t flags = ntohs(header->options); options 11 pack-bitmap.h uint16_t options; options 55 pack-bitmap.h uint16_t options); options 205 parse-options.c static int parse_short_opt(struct parse_opt_ctx_t *p, const struct option *options) options 207 parse-options.c const struct option *all_opts = options; options 210 parse-options.c for (; options->type != OPTION_END; options++) { options 211 parse-options.c if (options->short_name == *p->opt) { options 213 parse-options.c return get_value(p, options, all_opts, OPT_SHORT); options 220 parse-options.c if (options->type == OPTION_NUMBER) options 221 parse-options.c numopt = options; options 240 parse-options.c const struct option *options) options 242 parse-options.c const struct option *all_opts = options; options 247 parse-options.c for (; options->type != OPTION_END; options++) { options 248 parse-options.c const char *rest, *long_name = options->long_name; options 257 parse-options.c if (options->type == OPTION_ARGUMENT) { options 261 parse-options.c return opterror(options, "takes no value", flags); options 283 parse-options.c abbrev_option = options; options 288 parse-options.c if (options->flags & PARSE_OPT_NONEG) options 318 parse-options.c return get_value(p, options, all_opts, flags ^ opt_flags); options 335 parse-options.c const struct option *options) options 337 parse-options.c const struct option *all_opts = options; options 339 parse-options.c for (; options->type != OPTION_END; options++) { options 340 parse-options.c if (!(options->flags & PARSE_OPT_NODASH)) options 342 parse-options.c if (options->short_name == arg[0] && arg[1] == '\0') options 343 parse-options.c return get_value(p, options, all_opts, OPT_SHORT); options 348 parse-options.c static void check_typos(const char *arg, const struct option *options) options 358 parse-options.c for (; options->type != OPTION_END; options++) { options 359 parse-options.c if (!options->long_name) options 361 parse-options.c if (starts_with(options->long_name, arg)) { options 414 parse-options.c const struct option *options, int flags) options 426 parse-options.c parse_options_check(options); options 434 parse-options.c const struct option *options, options 446 parse-options.c if (parse_nodash_opt(ctx, arg, options) == 0) options 457 parse-options.c return parse_options_usage(ctx, usagestr, options, 0); options 458 parse-options.c switch (parse_short_opt(ctx, options)) { options 460 parse-options.c return parse_options_usage(ctx, usagestr, options, 1); options 463 parse-options.c check_typos(arg + 1, options); options 467 parse-options.c check_typos(arg + 1, options); options 470 parse-options.c return parse_options_usage(ctx, usagestr, options, 0); options 471 parse-options.c switch (parse_short_opt(ctx, options)) { options 473 parse-options.c return parse_options_usage(ctx, usagestr, options, 1); options 497 parse-options.c return usage_with_options_internal(ctx, usagestr, options, 1, 0); options 499 parse-options.c return parse_options_usage(ctx, usagestr, options, 0); options 500 parse-options.c switch (parse_long_opt(ctx, arg + 2, options)) { options 502 parse-options.c return parse_options_usage(ctx, usagestr, options, 1); options 524 parse-options.c const struct option *options, const char * const usagestr[], options 529 parse-options.c parse_options_start(&ctx, argc, argv, prefix, options, flags); options 530 parse-options.c switch (parse_options_step(&ctx, options, usagestr)) { options 545 parse-options.c usage_with_options(usagestr, options); options 653 parse-options.c const struct option *options) options 656 parse-options.c usage_with_options(usagestr, options); options 169 parse-options.h const struct option *options, options 173 parse-options.h const struct option *options); options 177 parse-options.h const struct option *options); options 210 parse-options.h const struct option *options, int flags); options 213 parse-options.h const struct option *options, options 7 patch-ids.c static int commit_patch_id(struct commit *commit, struct diff_options *options, options 12 patch-ids.c commit->object.sha1, "", options); options 14 patch-ids.c diff_root_tree_sha1(commit->object.sha1, "", options); options 15 patch-ids.c diffcore_std(options); options 16 patch-ids.c return diff_flush_patch_id(options, sha1); options 137 pkt-line.c void *dst, unsigned size, int options) options 158 pkt-line.c if (options & PACKET_READ_GENTLE_ON_EOF) options 193 pkt-line.c char *buffer, unsigned size, int options) options 198 pkt-line.c ret = get_packet_data(fd, src_buf, src_len, linelen, 4, options); options 211 pkt-line.c ret = get_packet_data(fd, src_buf, src_len, buffer, len, options); options 215 pkt-line.c if ((options & PACKET_READ_CHOMP_NEWLINE) && options 61 pkt-line.h *buffer, unsigned size, int options); options 24 read-cache.c unsigned int options); options 308 read-cache.c unsigned int options) options 311 read-cache.c int ignore_valid = options & CE_MATCH_IGNORE_VALID; options 312 read-cache.c int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; options 313 read-cache.c int assume_racy_is_modified = options & CE_MATCH_RACY_IS_DIRTY; options 364 read-cache.c struct stat *st, unsigned int options) options 368 read-cache.c changed = ie_match_stat(istate, ce, st, options); options 1061 read-cache.c unsigned int options, int *err, options 1067 read-cache.c int refresh = options & CE_MATCH_REFRESH; options 1068 read-cache.c int ignore_valid = options & CE_MATCH_IGNORE_VALID; options 1069 read-cache.c int ignore_skip_worktree = options & CE_MATCH_IGNORE_SKIP_WORKTREE; options 1070 read-cache.c int ignore_missing = options & CE_MATCH_IGNORE_MISSING; options 1105 read-cache.c changed = ie_match_stat(istate, ce, &st, options); options 1131 read-cache.c if (ie_modified(istate, ce, &st, options)) { options 1178 read-cache.c unsigned int options = (CE_MATCH_REFRESH | options 1222 read-cache.c new = refresh_cache_ent(istate, ce, options, &cache_errno, &changed); options 1259 read-cache.c unsigned int options) options 1261 read-cache.c return refresh_cache_ent(&the_index, ce, options, NULL, NULL); options 33 remote-curl.c static struct options options; options 43 remote-curl.c options.verbosity = v; options 48 remote-curl.c options.progress = 1; options 50 remote-curl.c options.progress = 0; options 60 remote-curl.c options.depth = v; options 65 remote-curl.c options.followtags = 1; options 67 remote-curl.c options.followtags = 0; options 74 remote-curl.c options.dry_run = 1; options 76 remote-curl.c options.dry_run = 0; options 83 remote-curl.c options.check_self_contained_and_connected = 1; options 85 remote-curl.c options.check_self_contained_and_connected = 0; options 98 remote-curl.c options.cloning = 1; options 100 remote-curl.c options.cloning = 0; options 106 remote-curl.c options.update_shallow = 1; options 108 remote-curl.c options.update_shallow = 0; options 114 remote-curl.c options.push_cert = SEND_PACK_PUSH_CERT_ALWAYS; options 116 remote-curl.c options.push_cert = SEND_PACK_PUSH_CERT_NEVER; options 118 remote-curl.c options.push_cert = SEND_PACK_PUSH_CERT_IF_ASKED; options 247 remote-curl.c struct http_get_options options; options 264 remote-curl.c memset(&options, 0, sizeof(options)); options 265 remote-curl.c options.content_type = &type; options 266 remote-curl.c options.charset = &charset; options 267 remote-curl.c options.effective_url = &effective_url; options 268 remote-curl.c options.base_url = &url; options 269 remote-curl.c options.no_cache = 1; options 270 remote-curl.c options.keep_error = 1; options 272 remote-curl.c http_ret = http_get_strbuf(refs_url.buf, &buffer, &options); options 552 remote-curl.c if (options.verbosity > 1) { options 597 remote-curl.c if (options.verbosity > 1) { options 609 remote-curl.c if (options.verbosity > 1) { options 705 remote-curl.c if (options.depth) options 714 remote-curl.c walker->get_verbosely = options.verbosity >= 3; options 739 remote-curl.c if (options.followtags) options 741 remote-curl.c if (options.thin) options 743 remote-curl.c if (options.verbosity >= 3) { options 747 remote-curl.c if (options.check_self_contained_and_connected) options 749 remote-curl.c if (options.cloning) options 751 remote-curl.c if (options.update_shallow) options 753 remote-curl.c if (!options.progress) options 755 remote-curl.c if (options.depth) { options 757 remote-curl.c strbuf_addf(&buf, "--depth=%lu", options.depth); options 856 remote-curl.c if (options.dry_run) options 858 remote-curl.c if (options.verbosity > 1) options 883 remote-curl.c if (options.thin) options 885 remote-curl.c if (options.dry_run) options 887 remote-curl.c if (options.push_cert == SEND_PACK_PUSH_CERT_ALWAYS) options 889 remote-curl.c else if (options.push_cert == SEND_PACK_PUSH_CERT_IF_ASKED) options 891 remote-curl.c if (options.verbosity == 0) options 893 remote-curl.c else if (options.verbosity > 1) options 895 remote-curl.c argv_array_push(&args, options.progress ? "--progress" : "--no-progress"); options 979 remote-curl.c options.verbosity = 1; options 980 remote-curl.c options.progress = !!isatty(2); options 981 remote-curl.c options.thin = 1; options 460 revision.c static void file_add_remove(struct diff_options *options, options 470 revision.c DIFF_OPT_SET(options, HAS_CHANGES); options 473 revision.c static void file_change(struct diff_options *options, options 482 revision.c DIFF_OPT_SET(options, HAS_CHANGES); options 2070 revision.c const struct option *options, options 2077 revision.c usage_with_options(usagestr, options); options 241 revision.h const struct option *options, options 386 submodule.c struct diff_options *options, options 512 submodule.c struct diff_options *options, options 611 submodule.c int fetch_populated_submodules(const struct argv_array *options, options 626 submodule.c for (i = 0; i < options->argc; i++) options 627 submodule.c argv_array_push(&argv, options->argv[i]); options 32 submodule.h int fetch_populated_submodules(const struct argv_array *options, options 40 test-parse-options.c struct option options[] = { options 84 test-parse-options.c argc = parse_options(argc, (const char **)argv, prefix, options, usage, 0); options 440 transport.c struct git_transport_options options; options 491 transport.c for_push ? data->options.receivepack : options 492 transport.c data->options.uploadpack, options 523 transport.c args.uploadpack = data->options.uploadpack; options 524 transport.c args.keep_pack = data->options.keep; options 526 transport.c args.use_thin_pack = data->options.thin; options 527 transport.c args.include_tag = data->options.followtags; options 531 transport.c args.depth = data->options.depth; options 533 transport.c data->options.check_self_contained_and_connected; options 535 transport.c args.update_shallow = data->options.update_shallow; options 556 transport.c data->options.self_contained_and_connected = options 823 transport.c args.use_thin_pack = data->options.thin; options 887 transport.c data->options = *transport->smart_options; options 900 transport.c transport->smart_options = &(data->options); options 1016 transport.c ret->smart_options = &(data->options); options 12 unpack-trees.h struct unpack_trees_options *options); options 78 unpack-trees.h struct unpack_trees_options *options); options 409 wt-status.c struct diff_options *options, options 459 wt-status.c struct diff_options *options,