Junio C Hamano | be3cfa8 | 2005-04-26 09:25:05 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2005 Junio C Hamano |
| 3 | */ |
Junio C Hamano | 86436c2 | 2005-04-25 18:22:47 -0700 | [diff] [blame] | 4 | #ifndef DIFF_H |
| 5 | #define DIFF_H |
| 6 | |
Junio C Hamano | 1b0c717 | 2006-03-29 22:55:43 -0800 | [diff] [blame] | 7 | #include "tree-walk.h" |
Nguyễn Thái Ngọc Duy | 64acde9 | 2013-07-14 15:35:25 +0700 | [diff] [blame] | 8 | #include "pathspec.h" |
brian m. carlson | 1ff57c1 | 2015-03-13 23:39:33 +0000 | [diff] [blame] | 9 | #include "object.h" |
Stefan Beller | 15af58c | 2018-01-04 14:50:42 -0800 | [diff] [blame] | 10 | #include "oidset.h" |
Linus Torvalds | 50f9a85 | 2006-01-31 14:10:56 -0800 | [diff] [blame] | 11 | |
Nguyễn Thái Ngọc Duy | 4a1b13a | 2019-01-27 07:35:29 +0700 | [diff] [blame] | 12 | struct combine_diff_path; |
| 13 | struct commit; |
| 14 | struct diff_filespec; |
Linus Torvalds | ac1b3d1 | 2005-10-20 21:05:05 -0700 | [diff] [blame] | 15 | struct diff_options; |
Jeff King | 0424558 | 2006-09-07 02:35:42 -0400 | [diff] [blame] | 16 | struct diff_queue_struct; |
brian m. carlson | 910650d | 2017-03-31 01:40:00 +0000 | [diff] [blame] | 17 | struct oid_array; |
Nguyễn Thái Ngọc Duy | 4a28847 | 2019-01-27 07:35:31 +0700 | [diff] [blame] | 18 | struct option; |
Nguyễn Thái Ngọc Duy | b78ea5f | 2018-09-21 17:57:19 +0200 | [diff] [blame] | 19 | struct repository; |
Nguyễn Thái Ngọc Duy | 4a1b13a | 2019-01-27 07:35:29 +0700 | [diff] [blame] | 20 | struct rev_info; |
| 21 | struct strbuf; |
| 22 | struct userdiff_driver; |
Kirill Smelkov | 72441af | 2014-04-07 01:46:26 +0400 | [diff] [blame] | 23 | |
| 24 | typedef int (*pathchange_fn_t)(struct diff_options *options, |
| 25 | struct combine_diff_path *path); |
Linus Torvalds | ac1b3d1 | 2005-10-20 21:05:05 -0700 | [diff] [blame] | 26 | |
| 27 | typedef void (*change_fn_t)(struct diff_options *options, |
| 28 | unsigned old_mode, unsigned new_mode, |
Brandon Williams | 94a0097 | 2017-05-30 10:30:49 -0700 | [diff] [blame] | 29 | const struct object_id *old_oid, |
| 30 | const struct object_id *new_oid, |
| 31 | int old_oid_valid, int new_oid_valid, |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 32 | const char *fullpath, |
| 33 | unsigned old_dirty_submodule, unsigned new_dirty_submodule); |
Linus Torvalds | ac1b3d1 | 2005-10-20 21:05:05 -0700 | [diff] [blame] | 34 | |
| 35 | typedef void (*add_remove_fn_t)(struct diff_options *options, |
| 36 | int addremove, unsigned mode, |
Brandon Williams | c26022e | 2017-05-30 10:30:47 -0700 | [diff] [blame] | 37 | const struct object_id *oid, |
| 38 | int oid_valid, |
Jens Lehmann | e3d42c4 | 2010-01-18 21:26:18 +0100 | [diff] [blame] | 39 | const char *fullpath, unsigned dirty_submodule); |
Linus Torvalds | ac1b3d1 | 2005-10-20 21:05:05 -0700 | [diff] [blame] | 40 | |
Jeff King | 0424558 | 2006-09-07 02:35:42 -0400 | [diff] [blame] | 41 | typedef void (*diff_format_fn_t)(struct diff_queue_struct *q, |
| 42 | struct diff_options *options, void *data); |
| 43 | |
Bo Yang | a3c158d | 2010-05-26 15:08:02 +0800 | [diff] [blame] | 44 | typedef struct strbuf *(*diff_prefix_fn_t)(struct diff_options *opt, void *data); |
| 45 | |
Timo Hirvonen | c674434 | 2006-06-24 20:21:53 +0300 | [diff] [blame] | 46 | #define DIFF_FORMAT_RAW 0x0001 |
| 47 | #define DIFF_FORMAT_DIFFSTAT 0x0002 |
Junio C Hamano | 74e2abe | 2006-10-12 03:01:00 -0700 | [diff] [blame] | 48 | #define DIFF_FORMAT_NUMSTAT 0x0004 |
| 49 | #define DIFF_FORMAT_SUMMARY 0x0008 |
| 50 | #define DIFF_FORMAT_PATCH 0x0010 |
Nicolas Pitre | ebd124c | 2006-12-14 23:15:44 -0500 | [diff] [blame] | 51 | #define DIFF_FORMAT_SHORTSTAT 0x0020 |
Linus Torvalds | 7df7c01 | 2008-02-12 13:26:31 -0800 | [diff] [blame] | 52 | #define DIFF_FORMAT_DIRSTAT 0x0040 |
Timo Hirvonen | c674434 | 2006-06-24 20:21:53 +0300 | [diff] [blame] | 53 | |
| 54 | /* These override all above */ |
Junio C Hamano | 74e2abe | 2006-10-12 03:01:00 -0700 | [diff] [blame] | 55 | #define DIFF_FORMAT_NAME 0x0100 |
| 56 | #define DIFF_FORMAT_NAME_STATUS 0x0200 |
| 57 | #define DIFF_FORMAT_CHECKDIFF 0x0400 |
Timo Hirvonen | c674434 | 2006-06-24 20:21:53 +0300 | [diff] [blame] | 58 | |
| 59 | /* Same as output_format = 0 but we know that -s flag was given |
| 60 | * and we should not give default value to output_format. |
| 61 | */ |
Junio C Hamano | 74e2abe | 2006-10-12 03:01:00 -0700 | [diff] [blame] | 62 | #define DIFF_FORMAT_NO_OUTPUT 0x0800 |
Timo Hirvonen | c674434 | 2006-06-24 20:21:53 +0300 | [diff] [blame] | 63 | |
Junio C Hamano | 74e2abe | 2006-10-12 03:01:00 -0700 | [diff] [blame] | 64 | #define DIFF_FORMAT_CALLBACK 0x1000 |
Jeff King | 0424558 | 2006-09-07 02:35:42 -0400 | [diff] [blame] | 65 | |
Brandon Williams | 02f2f56 | 2017-10-31 11:19:05 -0700 | [diff] [blame] | 66 | #define DIFF_FLAGS_INIT { 0 } |
| 67 | struct diff_flags { |
Nguyễn Thái Ngọc Duy | 2b393ef | 2019-01-27 07:35:30 +0700 | [diff] [blame] | 68 | unsigned recursive; |
| 69 | unsigned tree_in_recursive; |
| 70 | unsigned binary; |
| 71 | unsigned text; |
| 72 | unsigned full_index; |
| 73 | unsigned silent_on_remove; |
| 74 | unsigned find_copies_harder; |
| 75 | unsigned follow_renames; |
| 76 | unsigned rename_empty; |
| 77 | unsigned has_changes; |
| 78 | unsigned quick; |
| 79 | unsigned no_index; |
| 80 | unsigned allow_external; |
| 81 | unsigned exit_with_status; |
| 82 | unsigned reverse_diff; |
| 83 | unsigned check_failed; |
| 84 | unsigned relative_name; |
| 85 | unsigned ignore_submodules; |
| 86 | unsigned dirstat_cumulative; |
| 87 | unsigned dirstat_by_file; |
| 88 | unsigned allow_textconv; |
| 89 | unsigned textconv_set_via_cmdline; |
| 90 | unsigned diff_from_contents; |
| 91 | unsigned dirty_submodules; |
| 92 | unsigned ignore_untracked_in_submodules; |
| 93 | unsigned ignore_dirty_submodules; |
| 94 | unsigned override_submodule_config; |
| 95 | unsigned dirstat_by_line; |
| 96 | unsigned funccontext; |
| 97 | unsigned default_follow_renames; |
| 98 | unsigned stat_with_summary; |
| 99 | unsigned suppress_diff_headers; |
| 100 | unsigned dual_color_diffed_diffs; |
Brandon Williams | 02f2f56 | 2017-10-31 11:19:05 -0700 | [diff] [blame] | 101 | }; |
Johannes Schindelin | 752c0c2 | 2009-10-19 14:38:32 +0200 | [diff] [blame] | 102 | |
Brandon Williams | 02f2f56 | 2017-10-31 11:19:05 -0700 | [diff] [blame] | 103 | static inline void diff_flags_or(struct diff_flags *a, |
| 104 | const struct diff_flags *b) |
| 105 | { |
| 106 | char *tmp_a = (char *)a; |
| 107 | const char *tmp_b = (const char *)b; |
| 108 | int i; |
| 109 | |
| 110 | for (i = 0; i < sizeof(struct diff_flags); i++) |
| 111 | tmp_a[i] |= tmp_b[i]; |
| 112 | } |
| 113 | |
Keith Cascio | 628d5c2 | 2009-02-16 19:26:49 -0800 | [diff] [blame] | 114 | #define DIFF_XDL_TST(opts, flag) ((opts)->xdl_opts & XDF_##flag) |
| 115 | #define DIFF_XDL_SET(opts, flag) ((opts)->xdl_opts |= XDF_##flag) |
| 116 | #define DIFF_XDL_CLR(opts, flag) ((opts)->xdl_opts &= ~XDF_##flag) |
Pierre Habouzit | 8f67f8a | 2007-11-10 20:05:14 +0100 | [diff] [blame] | 117 | |
Junio C Hamano | 307ab20 | 2012-02-19 15:36:55 -0800 | [diff] [blame] | 118 | #define DIFF_WITH_ALG(opts, flag) (((opts)->xdl_opts & ~XDF_DIFF_ALGORITHM_MASK) | XDF_##flag) |
| 119 | |
Thomas Rast | 882749a | 2010-04-14 17:59:06 +0200 | [diff] [blame] | 120 | enum diff_words_type { |
| 121 | DIFF_WORDS_NONE = 0, |
| 122 | DIFF_WORDS_PORCELAIN, |
| 123 | DIFF_WORDS_PLAIN, |
| 124 | DIFF_WORDS_COLOR |
| 125 | }; |
| 126 | |
Jacob Keller | 61cfbc0 | 2016-08-31 16:27:21 -0700 | [diff] [blame] | 127 | enum diff_submodule_format { |
| 128 | DIFF_SUBMODULE_SHORT = 0, |
Jacob Keller | fd47ae6 | 2016-08-31 16:27:25 -0700 | [diff] [blame] | 129 | DIFF_SUBMODULE_LOG, |
| 130 | DIFF_SUBMODULE_INLINE_DIFF |
Jacob Keller | 61cfbc0 | 2016-08-31 16:27:21 -0700 | [diff] [blame] | 131 | }; |
| 132 | |
Junio C Hamano | 6b5ee13 | 2005-09-21 00:00:47 -0700 | [diff] [blame] | 133 | struct diff_options { |
Junio C Hamano | 6b5ee13 | 2005-09-21 00:00:47 -0700 | [diff] [blame] | 134 | const char *orderfile; |
| 135 | const char *pickaxe; |
Junio C Hamano | 2f3f8b2 | 2006-11-02 00:02:11 -0800 | [diff] [blame] | 136 | const char *single_follow; |
Johannes Schindelin | eab9a40 | 2007-12-18 19:32:14 +0000 | [diff] [blame] | 137 | const char *a_prefix, *b_prefix; |
Jacob Keller | 660e113 | 2016-08-31 16:27:20 -0700 | [diff] [blame] | 138 | const char *line_prefix; |
| 139 | size_t line_prefix_length; |
Brandon Williams | 02f2f56 | 2017-10-31 11:19:05 -0700 | [diff] [blame] | 140 | struct diff_flags flags; |
Junio C Hamano | 1ecc1cb | 2013-07-17 15:05:46 -0700 | [diff] [blame] | 141 | |
| 142 | /* diff-filter bits */ |
| 143 | unsigned int filter; |
| 144 | |
Jeff King | f1c9626 | 2011-08-17 22:03:12 -0700 | [diff] [blame] | 145 | int use_color; |
Linus Torvalds | ee1e541 | 2006-05-13 13:23:48 -0700 | [diff] [blame] | 146 | int context; |
René Scharfe | 6d0e674 | 2008-12-28 19:45:32 +0100 | [diff] [blame] | 147 | int interhunkcontext; |
Junio C Hamano | 6b5ee13 | 2005-09-21 00:00:47 -0700 | [diff] [blame] | 148 | int break_opt; |
| 149 | int detect_rename; |
Junio C Hamano | 467ddc1 | 2011-02-28 16:11:55 -0800 | [diff] [blame] | 150 | int irreversible_delete; |
Junio C Hamano | fb13227 | 2007-08-03 13:33:31 -0700 | [diff] [blame] | 151 | int skip_stat_unmatch; |
Junio C Hamano | 6b5ee13 | 2005-09-21 00:00:47 -0700 | [diff] [blame] | 152 | int line_termination; |
| 153 | int output_format; |
Stefan Beller | 929ed70 | 2018-01-04 14:50:39 -0800 | [diff] [blame] | 154 | unsigned pickaxe_opts; |
Junio C Hamano | 6b5ee13 | 2005-09-21 00:00:47 -0700 | [diff] [blame] | 155 | int rename_score; |
Junio C Hamano | 8082d8d | 2005-09-21 00:18:27 -0700 | [diff] [blame] | 156 | int rename_limit; |
Jeff King | bf0ab10 | 2011-02-19 05:20:51 -0500 | [diff] [blame] | 157 | int needed_rename_limit; |
Junio C Hamano | f31027c | 2011-01-06 13:50:06 -0800 | [diff] [blame] | 158 | int degraded_cc_to_c; |
Jeff King | 3ac942d | 2011-02-20 04:51:16 -0500 | [diff] [blame] | 159 | int show_rename_progress; |
Johan Herland | 712d2c7 | 2011-04-29 11:36:20 +0200 | [diff] [blame] | 160 | int dirstat_permille; |
Junio C Hamano | 6b5ee13 | 2005-09-21 00:00:47 -0700 | [diff] [blame] | 161 | int setup; |
Junio C Hamano | 47dd0d5 | 2005-12-13 17:21:41 -0800 | [diff] [blame] | 162 | int abbrev; |
Nguyễn Thái Ngọc Duy | 425a28e | 2016-10-24 17:42:19 +0700 | [diff] [blame] | 163 | int ita_invisible_in_index; |
Junio C Hamano | b8767f7 | 2015-05-26 10:11:28 -0700 | [diff] [blame] | 164 | /* white-space error highlighting */ |
Stefan Beller | 091f8e2 | 2017-06-29 17:06:53 -0700 | [diff] [blame] | 165 | #define WSEH_NEW (1<<12) |
| 166 | #define WSEH_CONTEXT (1<<13) |
| 167 | #define WSEH_OLD (1<<14) |
Junio C Hamano | b8767f7 | 2015-05-26 10:11:28 -0700 | [diff] [blame] | 168 | unsigned ws_error_highlight; |
Junio C Hamano | cd676a5 | 2008-02-12 14:26:02 -0800 | [diff] [blame] | 169 | const char *prefix; |
| 170 | int prefix_length; |
Johannes Schindelin | 698ce6f | 2006-05-20 15:40:29 +0200 | [diff] [blame] | 171 | const char *stat_sep; |
Johannes Schindelin | 0d21efa | 2006-06-14 17:40:23 +0200 | [diff] [blame] | 172 | long xdl_opts; |
Linus Torvalds | ac1b3d1 | 2005-10-20 21:05:05 -0700 | [diff] [blame] | 173 | |
Jonathan Tan | 2477ab2 | 2017-11-27 11:47:47 -0800 | [diff] [blame] | 174 | /* see Documentation/diff-options.txt */ |
| 175 | char **anchors; |
| 176 | size_t anchors_nr, anchors_alloc; |
| 177 | |
Junio C Hamano | a254002 | 2006-09-26 18:53:02 -0700 | [diff] [blame] | 178 | int stat_width; |
| 179 | int stat_name_width; |
Zbigniew Jędrzejewski-Szmek | 969fe57 | 2012-03-01 13:26:45 +0100 | [diff] [blame] | 180 | int stat_graph_width; |
Michael J Gruber | 808e1db | 2011-05-27 14:36:41 +0200 | [diff] [blame] | 181 | int stat_count; |
Johannes Schindelin | 2b6a541 | 2009-01-17 17:29:45 +0100 | [diff] [blame] | 182 | const char *word_regex; |
Thomas Rast | 882749a | 2010-04-14 17:59:06 +0200 | [diff] [blame] | 183 | enum diff_words_type word_diff; |
Jacob Keller | 61cfbc0 | 2016-08-31 16:27:21 -0700 | [diff] [blame] | 184 | enum diff_submodule_format submodule_format; |
Junio C Hamano | a254002 | 2006-09-26 18:53:02 -0700 | [diff] [blame] | 185 | |
Stefan Beller | 15af58c | 2018-01-04 14:50:42 -0800 | [diff] [blame] | 186 | struct oidset *objfind; |
| 187 | |
Johannes Schindelin | 34a5e1a | 2007-02-25 23:34:54 +0100 | [diff] [blame] | 188 | /* this is set by diffcore for DIFF_FORMAT_PATCH */ |
| 189 | int found_changes; |
| 190 | |
Junio C Hamano | 44c48a9 | 2010-08-13 12:17:45 -0700 | [diff] [blame] | 191 | /* to support internal diff recursion by --follow hack*/ |
| 192 | int found_follow; |
| 193 | |
Junio C Hamano | 6c37400 | 2013-05-10 17:10:11 +0200 | [diff] [blame] | 194 | void (*set_default)(struct diff_options *); |
| 195 | |
Daniel Barkalow | c0c7773 | 2008-03-09 22:43:39 -0400 | [diff] [blame] | 196 | FILE *file; |
| 197 | int close_file; |
| 198 | |
Stefan Beller | 7648b79 | 2018-08-17 13:43:52 -0700 | [diff] [blame] | 199 | #define OUTPUT_INDICATOR_NEW 0 |
| 200 | #define OUTPUT_INDICATOR_OLD 1 |
| 201 | #define OUTPUT_INDICATOR_CONTEXT 2 |
| 202 | char output_indicators[3]; |
| 203 | |
Nguyễn Thái Ngọc Duy | 66f1362 | 2010-12-15 22:02:38 +0700 | [diff] [blame] | 204 | struct pathspec pathspec; |
Kirill Smelkov | 72441af | 2014-04-07 01:46:26 +0400 | [diff] [blame] | 205 | pathchange_fn_t pathchange; |
Linus Torvalds | ac1b3d1 | 2005-10-20 21:05:05 -0700 | [diff] [blame] | 206 | change_fn_t change; |
| 207 | add_remove_fn_t add_remove; |
Jeff King | a937b37 | 2017-10-13 11:27:45 -0400 | [diff] [blame] | 208 | void *change_fn_data; |
Jeff King | 0424558 | 2006-09-07 02:35:42 -0400 | [diff] [blame] | 209 | diff_format_fn_t format_callback; |
| 210 | void *format_callback_data; |
Bo Yang | a3c158d | 2010-05-26 15:08:02 +0800 | [diff] [blame] | 211 | diff_prefix_fn_t output_prefix; |
| 212 | void *output_prefix_data; |
Zoltan Klinger | ee7fb0b | 2013-12-06 10:38:46 +1100 | [diff] [blame] | 213 | |
| 214 | int diff_path_counter; |
Stefan Beller | e6e045f | 2017-06-29 17:07:06 -0700 | [diff] [blame] | 215 | |
| 216 | struct emitted_diff_symbols *emitted_symbols; |
Stefan Beller | 2e2d5ac | 2017-06-30 13:53:07 -0700 | [diff] [blame] | 217 | enum { |
| 218 | COLOR_MOVED_NO = 0, |
Stefan Beller | 176841f | 2017-06-30 13:53:08 -0700 | [diff] [blame] | 219 | COLOR_MOVED_PLAIN = 1, |
Stefan Beller | 51da15e | 2018-07-16 16:05:39 -0700 | [diff] [blame] | 220 | COLOR_MOVED_BLOCKS = 2, |
| 221 | COLOR_MOVED_ZEBRA = 3, |
| 222 | COLOR_MOVED_ZEBRA_DIM = 4, |
Stefan Beller | 2e2d5ac | 2017-06-30 13:53:07 -0700 | [diff] [blame] | 223 | } color_moved; |
| 224 | #define COLOR_MOVED_DEFAULT COLOR_MOVED_ZEBRA |
Jonathan Tan | f0b8fb6 | 2017-08-15 18:27:39 -0700 | [diff] [blame] | 225 | #define COLOR_MOVED_MIN_ALNUM_COUNT 20 |
Stefan Beller | ca1f4ae | 2018-07-18 12:31:55 -0700 | [diff] [blame] | 226 | |
| 227 | /* XDF_WHITESPACE_FLAGS regarding block detection are set at 2, 3, 4 */ |
| 228 | #define COLOR_MOVED_WS_ALLOW_INDENTATION_CHANGE (1<<5) |
Stefan Beller | d173e79 | 2018-11-13 13:33:57 -0800 | [diff] [blame] | 229 | #define COLOR_MOVED_WS_ERROR (1<<0) |
| 230 | unsigned color_moved_ws_handling; |
Nguyễn Thái Ngọc Duy | b78ea5f | 2018-09-21 17:57:19 +0200 | [diff] [blame] | 231 | |
| 232 | struct repository *repo; |
Nguyễn Thái Ngọc Duy | 4a28847 | 2019-01-27 07:35:31 +0700 | [diff] [blame] | 233 | struct option *parseopts; |
Junio C Hamano | 6b5ee13 | 2005-09-21 00:00:47 -0700 | [diff] [blame] | 234 | }; |
| 235 | |
Nguyễn Thái Ngọc Duy | cdb5330 | 2019-03-24 15:20:14 +0700 | [diff] [blame] | 236 | unsigned diff_filter_bit(char status); |
| 237 | |
Stefan Beller | f359713 | 2017-06-29 17:07:00 -0700 | [diff] [blame] | 238 | void diff_emit_submodule_del(struct diff_options *o, const char *line); |
| 239 | void diff_emit_submodule_add(struct diff_options *o, const char *line); |
| 240 | void diff_emit_submodule_untracked(struct diff_options *o, const char *path); |
| 241 | void diff_emit_submodule_modified(struct diff_options *o, const char *path); |
| 242 | void diff_emit_submodule_header(struct diff_options *o, const char *header); |
| 243 | void diff_emit_submodule_error(struct diff_options *o, const char *err); |
| 244 | void diff_emit_submodule_pipethrough(struct diff_options *o, |
| 245 | const char *line, int len); |
| 246 | |
Jeff King | ce43697 | 2006-07-23 05:24:18 -0400 | [diff] [blame] | 247 | enum color_diff { |
| 248 | DIFF_RESET = 0, |
Jeff King | 8dbf3eb | 2015-05-27 16:48:46 -0400 | [diff] [blame] | 249 | DIFF_CONTEXT = 1, |
Jeff King | ce43697 | 2006-07-23 05:24:18 -0400 | [diff] [blame] | 250 | DIFF_METAINFO = 2, |
| 251 | DIFF_FRAGINFO = 3, |
| 252 | DIFF_FILE_OLD = 4, |
| 253 | DIFF_FILE_NEW = 5, |
| 254 | DIFF_COMMIT = 6, |
Junio C Hamano | 448c3ef | 2006-09-22 22:48:39 -0700 | [diff] [blame] | 255 | DIFF_WHITESPACE = 7, |
Stefan Beller | 2e2d5ac | 2017-06-30 13:53:07 -0700 | [diff] [blame] | 256 | DIFF_FUNCINFO = 8, |
| 257 | DIFF_FILE_OLD_MOVED = 9, |
| 258 | DIFF_FILE_OLD_MOVED_ALT = 10, |
Stefan Beller | 86b452e | 2017-06-30 13:53:09 -0700 | [diff] [blame] | 259 | DIFF_FILE_OLD_MOVED_DIM = 11, |
| 260 | DIFF_FILE_OLD_MOVED_ALT_DIM = 12, |
| 261 | DIFF_FILE_NEW_MOVED = 13, |
| 262 | DIFF_FILE_NEW_MOVED_ALT = 14, |
| 263 | DIFF_FILE_NEW_MOVED_DIM = 15, |
Johannes Schindelin | a7be92a | 2018-08-13 04:33:32 -0700 | [diff] [blame] | 264 | DIFF_FILE_NEW_MOVED_ALT_DIM = 16, |
| 265 | DIFF_CONTEXT_DIM = 17, |
| 266 | DIFF_FILE_OLD_DIM = 18, |
| 267 | DIFF_FILE_NEW_DIM = 19, |
| 268 | DIFF_CONTEXT_BOLD = 20, |
| 269 | DIFF_FILE_OLD_BOLD = 21, |
| 270 | DIFF_FILE_NEW_BOLD = 22, |
Jeff King | ce43697 | 2006-07-23 05:24:18 -0400 | [diff] [blame] | 271 | }; |
| 272 | const char *diff_get_color(int diff_use_color, enum color_diff ix); |
Pierre Habouzit | 8f67f8a | 2007-11-10 20:05:14 +0100 | [diff] [blame] | 273 | #define diff_get_color_opt(o, ix) \ |
Jeff King | f1c9626 | 2011-08-17 22:03:12 -0700 | [diff] [blame] | 274 | diff_get_color((o)->use_color, ix) |
Pierre Habouzit | 8f67f8a | 2007-11-10 20:05:14 +0100 | [diff] [blame] | 275 | |
Jeff King | ce43697 | 2006-07-23 05:24:18 -0400 | [diff] [blame] | 276 | |
John Keeping | f192223 | 2013-02-07 20:15:26 +0000 | [diff] [blame] | 277 | const char *diff_line_prefix(struct diff_options *); |
| 278 | |
| 279 | |
Johannes Schindelin | 698ce6f | 2006-05-20 15:40:29 +0200 | [diff] [blame] | 280 | extern const char mime_boundary_leader[]; |
| 281 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 282 | struct combine_diff_path *diff_tree_paths( |
Brandon Williams | fda94b4 | 2017-05-30 10:31:06 -0700 | [diff] [blame] | 283 | struct combine_diff_path *p, const struct object_id *oid, |
| 284 | const struct object_id **parents_oid, int nparent, |
Kirill Smelkov | 72441af | 2014-04-07 01:46:26 +0400 | [diff] [blame] | 285 | struct strbuf *base, struct diff_options *opt); |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 286 | int diff_tree_oid(const struct object_id *old_oid, |
| 287 | const struct object_id *new_oid, |
| 288 | const char *base, struct diff_options *opt); |
| 289 | int diff_root_tree_oid(const struct object_id *new_oid, const char *base, |
| 290 | struct diff_options *opt); |
Linus Torvalds | ac1b3d1 | 2005-10-20 21:05:05 -0700 | [diff] [blame] | 291 | |
Junio C Hamano | ea726d0 | 2006-01-28 00:03:38 -0800 | [diff] [blame] | 292 | struct combine_diff_path { |
| 293 | struct combine_diff_path *next; |
Junio C Hamano | ea726d0 | 2006-01-28 00:03:38 -0800 | [diff] [blame] | 294 | char *path; |
Junio C Hamano | 2454c96 | 2006-02-06 12:53:07 -0800 | [diff] [blame] | 295 | unsigned int mode; |
brian m. carlson | 1ff57c1 | 2015-03-13 23:39:33 +0000 | [diff] [blame] | 296 | struct object_id oid; |
Junio C Hamano | 2454c96 | 2006-02-06 12:53:07 -0800 | [diff] [blame] | 297 | struct combine_diff_parent { |
Junio C Hamano | d416df8 | 2006-02-10 02:30:52 -0800 | [diff] [blame] | 298 | char status; |
Junio C Hamano | 2454c96 | 2006-02-06 12:53:07 -0800 | [diff] [blame] | 299 | unsigned int mode; |
brian m. carlson | 1ff57c1 | 2015-03-13 23:39:33 +0000 | [diff] [blame] | 300 | struct object_id oid; |
Elijah Newren | d76ce4f | 2019-02-07 17:12:46 -0800 | [diff] [blame] | 301 | struct strbuf path; |
Junio C Hamano | 2454c96 | 2006-02-06 12:53:07 -0800 | [diff] [blame] | 302 | } parent[FLEX_ARRAY]; |
Junio C Hamano | ea726d0 | 2006-01-28 00:03:38 -0800 | [diff] [blame] | 303 | }; |
Junio C Hamano | 2454c96 | 2006-02-06 12:53:07 -0800 | [diff] [blame] | 304 | #define combine_diff_path_size(n, l) \ |
Jeff King | 5b442c4 | 2016-02-19 06:21:30 -0500 | [diff] [blame] | 305 | st_add4(sizeof(struct combine_diff_path), (l), 1, \ |
| 306 | st_mult(sizeof(struct combine_diff_parent), (n))) |
Junio C Hamano | ea726d0 | 2006-01-28 00:03:38 -0800 | [diff] [blame] | 307 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 308 | void show_combined_diff(struct combine_diff_path *elem, int num_parent, |
| 309 | int dense, struct rev_info *); |
Junio C Hamano | ea726d0 | 2006-01-28 00:03:38 -0800 | [diff] [blame] | 310 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 311 | void diff_tree_combined(const struct object_id *oid, const struct oid_array *parents, int dense, struct rev_info *rev); |
Junio C Hamano | 0fe7c1d | 2006-04-29 01:24:49 -0700 | [diff] [blame] | 312 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 313 | void diff_tree_combined_merge(const struct commit *commit, int dense, struct rev_info *rev); |
Junio C Hamano | af3feef | 2006-01-24 01:22:04 -0800 | [diff] [blame] | 314 | |
Junio C Hamano | a5a818e | 2008-08-18 20:08:09 -0700 | [diff] [blame] | 315 | void diff_set_mnemonic_prefix(struct diff_options *options, const char *a, const char *b); |
| 316 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 317 | int diff_can_quit_early(struct diff_options *); |
Junio C Hamano | 28b9264 | 2011-05-31 09:14:17 -0700 | [diff] [blame] | 318 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 319 | void diff_addremove(struct diff_options *, |
| 320 | int addremove, |
| 321 | unsigned mode, |
| 322 | const struct object_id *oid, |
| 323 | int oid_valid, |
| 324 | const char *fullpath, unsigned dirty_submodule); |
Junio C Hamano | 77eb272 | 2005-04-27 09:21:00 -0700 | [diff] [blame] | 325 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 326 | void diff_change(struct diff_options *, |
| 327 | unsigned mode1, unsigned mode2, |
| 328 | const struct object_id *old_oid, |
| 329 | const struct object_id *new_oid, |
| 330 | int old_oid_valid, int new_oid_valid, |
| 331 | const char *fullpath, |
| 332 | unsigned dirty_submodule1, unsigned dirty_submodule2); |
Junio C Hamano | 77eb272 | 2005-04-27 09:21:00 -0700 | [diff] [blame] | 333 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 334 | struct diff_filepair *diff_unmerge(struct diff_options *, const char *path); |
Junio C Hamano | 77eb272 | 2005-04-27 09:21:00 -0700 | [diff] [blame] | 335 | |
Junio C Hamano | 19feebc | 2005-05-27 15:54:37 -0700 | [diff] [blame] | 336 | #define DIFF_SETUP_REVERSE 1 |
Junio C Hamano | f0c6b2a | 2005-05-27 15:56:38 -0700 | [diff] [blame] | 337 | #define DIFF_SETUP_USE_SIZE_CACHE 4 |
Junio C Hamano | ce24067 | 2005-06-03 01:36:43 -0700 | [diff] [blame] | 338 | |
Matthieu Moy | dea007f | 2010-08-05 10:22:52 +0200 | [diff] [blame] | 339 | /* |
Nicolas Vigier | b0d12fc | 2013-10-31 12:08:28 +0100 | [diff] [blame] | 340 | * Poor man's alternative to parse-option, to allow both stuck form |
Matthieu Moy | dea007f | 2010-08-05 10:22:52 +0200 | [diff] [blame] | 341 | * (--option=value) and separate form (--option value). |
| 342 | */ |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 343 | int parse_long_opt(const char *opt, const char **argv, |
| 344 | const char **optarg); |
Matthieu Moy | dea007f | 2010-08-05 10:22:52 +0200 | [diff] [blame] | 345 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 346 | int git_diff_basic_config(const char *var, const char *value, void *cb); |
| 347 | int git_diff_heuristic_config(const char *var, const char *value, void *cb); |
| 348 | void init_diff_ui_defaults(void); |
| 349 | int git_diff_ui_config(const char *var, const char *value, void *cb); |
Nguyễn Thái Ngọc Duy | e675765 | 2018-09-21 17:57:24 +0200 | [diff] [blame] | 350 | #ifndef NO_THE_REPOSITORY_COMPATIBILITY_MACROS |
| 351 | #define diff_setup(diffopts) repo_diff_setup(the_repository, diffopts) |
| 352 | #endif |
| 353 | void repo_diff_setup(struct repository *, struct diff_options *); |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 354 | int diff_opt_parse(struct diff_options *, const char **, int, const char *); |
| 355 | void diff_setup_done(struct diff_options *); |
| 356 | int git_config_rename(const char *var, const char *value); |
Junio C Hamano | 86436c2 | 2005-04-25 18:22:47 -0700 | [diff] [blame] | 357 | |
Junio C Hamano | 6b14d7f | 2005-05-22 10:04:37 -0700 | [diff] [blame] | 358 | #define DIFF_DETECT_RENAME 1 |
| 359 | #define DIFF_DETECT_COPY 2 |
| 360 | |
Junio C Hamano | 367cec1 | 2005-05-27 15:55:28 -0700 | [diff] [blame] | 361 | #define DIFF_PICKAXE_ALL 1 |
Petr Baudis | d01d8c6 | 2006-03-29 02:16:33 +0200 | [diff] [blame] | 362 | #define DIFF_PICKAXE_REGEX 2 |
Junio C Hamano | f345b0a | 2005-05-30 00:08:37 -0700 | [diff] [blame] | 363 | |
Junio C Hamano | f506b8e | 2010-08-23 10:17:03 -0700 | [diff] [blame] | 364 | #define DIFF_PICKAXE_KIND_S 4 /* traditional plumbing counter */ |
| 365 | #define DIFF_PICKAXE_KIND_G 8 /* grep in the patch */ |
Stefan Beller | 15af58c | 2018-01-04 14:50:42 -0800 | [diff] [blame] | 366 | #define DIFF_PICKAXE_KIND_OBJFIND 16 /* specific object IDs */ |
Junio C Hamano | f506b8e | 2010-08-23 10:17:03 -0700 | [diff] [blame] | 367 | |
Stefan Beller | 15af58c | 2018-01-04 14:50:42 -0800 | [diff] [blame] | 368 | #define DIFF_PICKAXE_KINDS_MASK (DIFF_PICKAXE_KIND_S | \ |
| 369 | DIFF_PICKAXE_KIND_G | \ |
| 370 | DIFF_PICKAXE_KIND_OBJFIND) |
Stefan Beller | cf63051 | 2018-01-04 14:50:41 -0800 | [diff] [blame] | 371 | |
Stefan Beller | c1ddc46 | 2018-01-04 14:50:40 -0800 | [diff] [blame] | 372 | #define DIFF_PICKAXE_IGNORE_CASE 32 |
Junio C Hamano | f2ce9fd | 2005-06-11 20:57:13 -0700 | [diff] [blame] | 373 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 374 | void diffcore_std(struct diff_options *); |
Jeff King | 784c0da | 2019-02-14 00:48:03 -0500 | [diff] [blame] | 375 | void diffcore_fix_diff_index(void); |
Junio C Hamano | f2ce9fd | 2005-06-11 20:57:13 -0700 | [diff] [blame] | 376 | |
Junio C Hamano | dda2d79 | 2005-07-13 12:52:35 -0700 | [diff] [blame] | 377 | #define COMMON_DIFF_OPTIONS_HELP \ |
| 378 | "\ncommon diff options:\n" \ |
Junio C Hamano | 8082d8d | 2005-09-21 00:18:27 -0700 | [diff] [blame] | 379 | " -z output diff-raw with lines terminated with NUL.\n" \ |
| 380 | " -p output patch format.\n" \ |
| 381 | " -u synonym for -p.\n" \ |
Petr Baudis | 5c91da2 | 2006-04-11 13:22:17 +0200 | [diff] [blame] | 382 | " --patch-with-raw\n" \ |
| 383 | " output both a patch and the diff-raw format.\n" \ |
Johannes Schindelin | d75f795 | 2006-04-14 00:15:30 +0200 | [diff] [blame] | 384 | " --stat show diffstat instead of patch.\n" \ |
Junio C Hamano | 74e2abe | 2006-10-12 03:01:00 -0700 | [diff] [blame] | 385 | " --numstat show numeric diffstat instead of patch.\n" \ |
Johannes Schindelin | 2935327 | 2006-04-15 13:41:18 +0200 | [diff] [blame] | 386 | " --patch-with-stat\n" \ |
| 387 | " output a patch and prepend its diffstat.\n" \ |
Junio C Hamano | 8082d8d | 2005-09-21 00:18:27 -0700 | [diff] [blame] | 388 | " --name-only show only names of changed files.\n" \ |
Junio C Hamano | 946f5f7 | 2005-09-21 00:20:06 -0700 | [diff] [blame] | 389 | " --name-status show names and status of changed files.\n" \ |
Junio C Hamano | 47dd0d5 | 2005-12-13 17:21:41 -0800 | [diff] [blame] | 390 | " --full-index show full object name on index lines.\n" \ |
Junio C Hamano | 913419f | 2005-12-18 02:03:15 -0800 | [diff] [blame] | 391 | " --abbrev=<n> abbreviate object names in diff-tree header and diff-raw.\n" \ |
Junio C Hamano | 8082d8d | 2005-09-21 00:18:27 -0700 | [diff] [blame] | 392 | " -R swap input file pairs.\n" \ |
| 393 | " -B detect complete rewrites.\n" \ |
| 394 | " -M detect renames.\n" \ |
| 395 | " -C detect copies.\n" \ |
Junio C Hamano | dda2d79 | 2005-07-13 12:52:35 -0700 | [diff] [blame] | 396 | " --find-copies-harder\n" \ |
Junio C Hamano | 8082d8d | 2005-09-21 00:18:27 -0700 | [diff] [blame] | 397 | " try unchanged files as candidate for copy detection.\n" \ |
| 398 | " -l<n> limit rename attempts up to <n> paths.\n" \ |
| 399 | " -O<file> reorder diffs according to the <file>.\n" \ |
| 400 | " -S<string> find filepair whose only one side contains the string.\n" \ |
Junio C Hamano | dda2d79 | 2005-07-13 12:52:35 -0700 | [diff] [blame] | 401 | " --pickaxe-all\n" \ |
Stephan Feder | ca49920 | 2006-07-07 15:57:08 +0200 | [diff] [blame] | 402 | " show all files diff when -S is used and hit is found.\n" \ |
| 403 | " -a --text treat all files as text.\n" |
Junio C Hamano | dda2d79 | 2005-07-13 12:52:35 -0700 | [diff] [blame] | 404 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 405 | int diff_queue_is_empty(void); |
| 406 | void diff_flush(struct diff_options*); |
| 407 | void diff_warn_rename_limit(const char *varname, int needed, int degraded_cc); |
Junio C Hamano | 86436c2 | 2005-04-25 18:22:47 -0700 | [diff] [blame] | 408 | |
Junio C Hamano | e7baa4f | 2005-07-25 13:05:44 -0700 | [diff] [blame] | 409 | /* diff-raw status letters */ |
Junio C Hamano | ca8c915 | 2005-07-25 14:31:19 -0700 | [diff] [blame] | 410 | #define DIFF_STATUS_ADDED 'A' |
Junio C Hamano | e7baa4f | 2005-07-25 13:05:44 -0700 | [diff] [blame] | 411 | #define DIFF_STATUS_COPIED 'C' |
| 412 | #define DIFF_STATUS_DELETED 'D' |
| 413 | #define DIFF_STATUS_MODIFIED 'M' |
| 414 | #define DIFF_STATUS_RENAMED 'R' |
| 415 | #define DIFF_STATUS_TYPE_CHANGED 'T' |
| 416 | #define DIFF_STATUS_UNKNOWN 'X' |
| 417 | #define DIFF_STATUS_UNMERGED 'U' |
| 418 | |
| 419 | /* these are not diff-raw status letters proper, but used by |
| 420 | * diffcore-filter insn to specify additional restrictions. |
| 421 | */ |
Junio C Hamano | 0b34379 | 2005-10-04 17:44:17 -0700 | [diff] [blame] | 422 | #define DIFF_STATUS_FILTER_AON '*' |
Junio C Hamano | e7baa4f | 2005-07-25 13:05:44 -0700 | [diff] [blame] | 423 | #define DIFF_STATUS_FILTER_BROKEN 'B' |
| 424 | |
Jeff King | d5e3b01 | 2016-10-20 02:19:43 -0400 | [diff] [blame] | 425 | /* |
| 426 | * This is different from find_unique_abbrev() in that |
| 427 | * it stuffs the result with dots for alignment. |
| 428 | */ |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 429 | const char *diff_aligned_abbrev(const struct object_id *sha1, int); |
Junio C Hamano | 47dd0d5 | 2005-12-13 17:21:41 -0800 | [diff] [blame] | 430 | |
Junio C Hamano | 4bd5b7d | 2007-11-10 00:15:03 -0800 | [diff] [blame] | 431 | /* do not report anything on removed paths */ |
| 432 | #define DIFF_SILENT_ON_REMOVED 01 |
Junio C Hamano | fb63d7f | 2007-11-09 18:22:52 -0800 | [diff] [blame] | 433 | /* report racily-clean paths as modified */ |
| 434 | #define DIFF_RACY_IS_MODIFIED 02 |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 435 | int run_diff_files(struct rev_info *revs, unsigned int option); |
| 436 | int run_diff_index(struct rev_info *revs, int cached); |
Junio C Hamano | e09ad6e | 2006-04-22 02:43:00 -0700 | [diff] [blame] | 437 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 438 | int do_diff_cache(const struct object_id *, struct diff_options *); |
| 439 | int diff_flush_patch_id(struct diff_options *, struct object_id *, int); |
Johannes Schindelin | fcb3d0a | 2006-06-25 03:51:08 +0200 | [diff] [blame] | 440 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 441 | int diff_result_code(struct diff_options *, int); |
Junio C Hamano | da31b35 | 2007-12-13 23:40:27 -0800 | [diff] [blame] | 442 | |
Junio C Hamano | dcd6a8c | 2019-04-25 16:41:12 +0900 | [diff] [blame] | 443 | int diff_no_index(struct rev_info *, |
Nguyễn Thái Ngọc Duy | 16bb3d7 | 2019-03-24 15:20:13 +0700 | [diff] [blame] | 444 | int implicit_no_index, int, const char **); |
Junio C Hamano | 0569e9b | 2008-05-23 22:28:56 -0700 | [diff] [blame] | 445 | |
Nguyễn Thái Ngọc Duy | ffc00a4 | 2018-11-10 06:49:04 +0100 | [diff] [blame] | 446 | int index_differs_from(struct repository *r, const char *def, |
| 447 | const struct diff_flags *flags, |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 448 | int ita_invisible_in_index); |
Stephan Beyer | 75f3ff2 | 2009-02-10 15:30:35 +0100 | [diff] [blame] | 449 | |
Jeff King | a64e6a4 | 2016-02-22 13:28:54 -0500 | [diff] [blame] | 450 | /* |
| 451 | * Fill the contents of the filespec "df", respecting any textconv defined by |
| 452 | * its userdiff driver. The "driver" parameter must come from a |
| 453 | * previous call to get_textconv(), and therefore should either be NULL or have |
| 454 | * textconv enabled. |
| 455 | * |
| 456 | * Note that the memory ownership of the resulting buffer depends on whether |
| 457 | * the driver field is NULL. If it is, then the memory belongs to the filespec |
| 458 | * struct. If it is non-NULL, then "outbuf" points to a newly allocated buffer |
| 459 | * that should be freed by the caller. |
| 460 | */ |
Nguyễn Thái Ngọc Duy | 6afaf80 | 2018-09-21 17:57:22 +0200 | [diff] [blame] | 461 | size_t fill_textconv(struct repository *r, |
| 462 | struct userdiff_driver *driver, |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 463 | struct diff_filespec *df, |
| 464 | char **outbuf); |
Axel Bonnet | a788d7d | 2010-06-07 17:23:36 +0200 | [diff] [blame] | 465 | |
Jeff King | a64e6a4 | 2016-02-22 13:28:54 -0500 | [diff] [blame] | 466 | /* |
| 467 | * Look up the userdiff driver for the given filespec, and return it if |
| 468 | * and only if it has textconv enabled (otherwise return NULL). The result |
| 469 | * can be passed to fill_textconv(). |
| 470 | */ |
Nguyễn Thái Ngọc Duy | bd7ad45 | 2018-11-10 06:49:06 +0100 | [diff] [blame] | 471 | struct userdiff_driver *get_textconv(struct repository *r, |
Nguyễn Thái Ngọc Duy | acd00ea | 2018-09-21 17:57:33 +0200 | [diff] [blame] | 472 | struct diff_filespec *one); |
Axel Bonnet | a788d7d | 2010-06-07 17:23:36 +0200 | [diff] [blame] | 473 | |
Jeff Smith | 3a35cb2 | 2017-05-24 00:15:10 -0500 | [diff] [blame] | 474 | /* |
| 475 | * Prepare diff_filespec and convert it using diff textconv API |
| 476 | * if the textconv driver exists. |
| 477 | * Return 1 if the conversion succeeds, 0 otherwise. |
| 478 | */ |
Nguyễn Thái Ngọc Duy | 6afaf80 | 2018-09-21 17:57:22 +0200 | [diff] [blame] | 479 | int textconv_object(struct repository *repo, |
| 480 | const char *path, |
| 481 | unsigned mode, |
| 482 | const struct object_id *oid, int oid_valid, |
| 483 | char **buf, unsigned long *buf_size); |
Jeff Smith | 3a35cb2 | 2017-05-24 00:15:10 -0500 | [diff] [blame] | 484 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 485 | int parse_rename_score(const char **cp_p); |
Kevin Ballard | 10ae752 | 2010-09-27 16:58:25 -0700 | [diff] [blame] | 486 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 487 | long parse_algorithm_value(const char *value); |
Michal Privoznik | 07924d4 | 2013-01-16 08:51:58 +0100 | [diff] [blame] | 488 | |
Nguyễn Thái Ngọc Duy | f758a7f | 2018-06-30 11:20:26 +0200 | [diff] [blame] | 489 | void print_stat_summary(FILE *fp, int files, |
| 490 | int insertions, int deletions); |
| 491 | void setup_diff_pager(struct diff_options *); |
Nguyễn Thái Ngọc Duy | 7f81463 | 2012-02-01 19:55:07 +0700 | [diff] [blame] | 492 | |
Junio C Hamano | 86436c2 | 2005-04-25 18:22:47 -0700 | [diff] [blame] | 493 | #endif /* DIFF_H */ |