🌐 AI搜索 & 代理 主页
Google Git
Sign in
chromium / external / github.com / git / git / refs/tags/v2.45.0 / . / diff.h
blob: 66bd8aeb2936fbe9d6610f7dc1202e31e1450ebb [file] [log] [blame]
Junio C Hamanobe3cfa82005-04-26 16:25:05[diff] [blame]1/*
2 * Copyright (C) 2005 Junio C Hamano
3 */
Junio C Hamano86436c22005-04-26 01:22:47[diff] [blame]4#ifndef DIFF_H
5#define DIFF_H
6
Elijah Newrendf6e8742023-05-16 06:34:00[diff] [blame]7#include "hash-ll.h"
Nguyễn Thái Ngọc Duy64acde92013-07-14 08:35:25[diff] [blame]8#include "pathspec.h"
Elijah Newrena64215b2023-02-24 00:09:30[diff] [blame]9#include "strbuf.h"
Linus Torvalds50f9a852006-01-31 22:10:56[diff] [blame]10
Elijah Newrendf6e8742023-05-16 06:34:00[diff] [blame]11struct oidset;
12
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]13/**
14 * The diff API is for programs that compare two sets of files (e.g. two trees,
15 * one tree and the index) and present the found difference in various ways.
16 * The calling program is responsible for feeding the API pairs of files, one
17 * from the "old" set and the corresponding one from "new" set, that are
18 * different.
19 * The library called through this API is called diffcore, and is responsible
20 * for two things.
21 *
22 * - finding total rewrites (`-B`), renames (`-M`) and copies (`-C`), and
23 * changes that touch a string (`-S`), as specified by the caller.
24 *
25 * - outputting the differences in various formats, as specified by the caller.
26 *
27 * Calling sequence
28 * ----------------
29 *
30 * - Prepare `struct diff_options` to record the set of diff options, and then
31 * call `repo_diff_setup()` to initialize this structure. This sets up the
32 * vanilla default.
33 *
34 * - Fill in the options structure to specify desired output format, rename
35 * detection, etc. `diff_opt_parse()` can be used to parse options given
36 * from the command line in a way consistent with existing git-diff family
37 * of programs.
38 *
39 * - Call `diff_setup_done()`; this inspects the options set up so far for
40 * internal consistency and make necessary tweaking to it (e.g. if textual
41 * patch output was asked, recursive behaviour is turned on); the callback
42 * set_default in diff_options can be used to tweak this more.
43 *
44 * - As you find different pairs of files, call `diff_change()` to feed
45 * modified files, `diff_addremove()` to feed created or deleted files, or
46 * `diff_unmerge()` to feed a file whose state is 'unmerged' to the API.
47 * These are thin wrappers to a lower-level `diff_queue()` function that is
48 * flexible enough to record any of these kinds of changes.
49 *
50 * - Once you finish feeding the pairs of files, call `diffcore_std()`.
51 * This will tell the diffcore library to go ahead and do its work.
52 *
Ævar Arnfjörð Bjarmasone900d492021-02-11 10:45:34[diff] [blame]53 * - Calling `diff_flush()` will produce the output, it will call
54 * `diff_free()` to free any resources, e.g. those allocated in
55 * `diff_opt_parse()`.
56 *
57 * - Set `.no_free = 1` before calling `diff_flush()` to defer the
58 * freeing of allocated memory in diff_options. This is useful when
59 * `diff_flush()` is being called in a loop, rather than as a
60 * one-off. When setting `.no_free = 1` you must ensure that
61 * `diff_free()` is called at the end, either by flipping the flag
62 * before the last `diff_flush()` call, or by flipping it before
63 * calling `diff_free()` yourself.
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]64 */
65
Nguyễn Thái Ngọc Duy4a1b13a2019-01-27 00:35:29[diff] [blame]66struct combine_diff_path;
67struct commit;
68struct diff_filespec;
Linus Torvaldsac1b3d12005-10-21 04:05:05[diff] [blame]69struct diff_options;
Jeff King04245582006-09-07 06:35:42[diff] [blame]70struct diff_queue_struct;
brian m. carlson910650d2017-03-31 01:40:00[diff] [blame]71struct oid_array;
Nguyễn Thái Ngọc Duy4a288472019-01-27 00:35:31[diff] [blame]72struct option;
Nguyễn Thái Ngọc Duyb78ea5f2018-09-21 15:57:19[diff] [blame]73struct repository;
Nguyễn Thái Ngọc Duy4a1b13a2019-01-27 00:35:29[diff] [blame]74struct rev_info;
Nguyễn Thái Ngọc Duy4a1b13a2019-01-27 00:35:29[diff] [blame]75struct userdiff_driver;
Kirill Smelkov72441af2014-04-06 21:46:26[diff] [blame]76
77typedef int (*pathchange_fn_t)(struct diff_options *options,
78 struct combine_diff_path *path);
Linus Torvaldsac1b3d12005-10-21 04:05:05[diff] [blame]79
80typedef void (*change_fn_t)(struct diff_options *options,
81 unsigned old_mode, unsigned new_mode,
Brandon Williams94a00972017-05-30 17:30:49[diff] [blame]82 const struct object_id *old_oid,
83 const struct object_id *new_oid,
84 int old_oid_valid, int new_oid_valid,
Jens Lehmanne3d42c42010-01-18 20:26:18[diff] [blame]85 const char *fullpath,
86 unsigned old_dirty_submodule, unsigned new_dirty_submodule);
Linus Torvaldsac1b3d12005-10-21 04:05:05[diff] [blame]87
88typedef void (*add_remove_fn_t)(struct diff_options *options,
89 int addremove, unsigned mode,
Brandon Williamsc26022e2017-05-30 17:30:47[diff] [blame]90 const struct object_id *oid,
91 int oid_valid,
Jens Lehmanne3d42c42010-01-18 20:26:18[diff] [blame]92 const char *fullpath, unsigned dirty_submodule);
Linus Torvaldsac1b3d12005-10-21 04:05:05[diff] [blame]93
Jeff King04245582006-09-07 06:35:42[diff] [blame]94typedef void (*diff_format_fn_t)(struct diff_queue_struct *q,
95 struct diff_options *options, void *data);
96
Bo Yanga3c158d2010-05-26 07:08:02[diff] [blame]97typedef struct strbuf *(*diff_prefix_fn_t)(struct diff_options *opt, void *data);
98
Timo Hirvonenc6744342006-06-24 17:21:53[diff] [blame]99#define DIFF_FORMAT_RAW 0x0001
100#define DIFF_FORMAT_DIFFSTAT 0x0002
Junio C Hamano74e2abe2006-10-12 10:01:00[diff] [blame]101#define DIFF_FORMAT_NUMSTAT 0x0004
102#define DIFF_FORMAT_SUMMARY 0x0008
103#define DIFF_FORMAT_PATCH 0x0010
Nicolas Pitreebd124c2006-12-15 04:15:44[diff] [blame]104#define DIFF_FORMAT_SHORTSTAT 0x0020
Linus Torvalds7df7c012008-02-12 21:26:31[diff] [blame]105#define DIFF_FORMAT_DIRSTAT 0x0040
Timo Hirvonenc6744342006-06-24 17:21:53[diff] [blame]106
107/* These override all above */
Junio C Hamano74e2abe2006-10-12 10:01:00[diff] [blame]108#define DIFF_FORMAT_NAME 0x0100
109#define DIFF_FORMAT_NAME_STATUS 0x0200
110#define DIFF_FORMAT_CHECKDIFF 0x0400
Timo Hirvonenc6744342006-06-24 17:21:53[diff] [blame]111
112/* Same as output_format = 0 but we know that -s flag was given
113 * and we should not give default value to output_format.
114 */
Junio C Hamano74e2abe2006-10-12 10:01:00[diff] [blame]115#define DIFF_FORMAT_NO_OUTPUT 0x0800
Timo Hirvonenc6744342006-06-24 17:21:53[diff] [blame]116
Junio C Hamano74e2abe2006-10-12 10:01:00[diff] [blame]117#define DIFF_FORMAT_CALLBACK 0x1000
Jeff King04245582006-09-07 06:35:42[diff] [blame]118
Brandon Williams02f2f562017-10-31 18:19:05[diff] [blame]119#define DIFF_FLAGS_INIT { 0 }
120struct diff_flags {
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]121
122 /**
123 * Tells if tree traversal done by tree-diff should recursively descend
124 * into a tree object pair that are different in preimage and postimage set.
125 */
Nguyễn Thái Ngọc Duy2b393ef2019-01-27 00:35:30[diff] [blame]126 unsigned recursive;
127 unsigned tree_in_recursive;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]128
129 /* Affects the way how a file that is seemingly binary is treated. */
Nguyễn Thái Ngọc Duy2b393ef2019-01-27 00:35:30[diff] [blame]130 unsigned binary;
131 unsigned text;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]132
133 /**
134 * Tells the patch output format not to use abbreviated object names on the
135 * "index" lines.
136 */
Nguyễn Thái Ngọc Duy2b393ef2019-01-27 00:35:30[diff] [blame]137 unsigned full_index;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]138
139 /* Affects if diff-files shows removed files. */
Nguyễn Thái Ngọc Duy2b393ef2019-01-27 00:35:30[diff] [blame]140 unsigned silent_on_remove;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]141
142 /**
143 * Tells the diffcore library that the caller is feeding unchanged
144 * filepairs to allow copies from unmodified files be detected.
145 */
Nguyễn Thái Ngọc Duy2b393ef2019-01-27 00:35:30[diff] [blame]146 unsigned find_copies_harder;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]147
Nguyễn Thái Ngọc Duy2b393ef2019-01-27 00:35:30[diff] [blame]148 unsigned follow_renames;
149 unsigned rename_empty;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]150
151 /* Internal; used for optimization to see if there is any change. */
Nguyễn Thái Ngọc Duy2b393ef2019-01-27 00:35:30[diff] [blame]152 unsigned has_changes;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]153
Nguyễn Thái Ngọc Duy2b393ef2019-01-27 00:35:30[diff] [blame]154 unsigned quick;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]155
156 /**
157 * Tells diff-files that the input is not tracked files but files in random
158 * locations on the filesystem.
159 */
Nguyễn Thái Ngọc Duy2b393ef2019-01-27 00:35:30[diff] [blame]160 unsigned no_index;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]161
162 /**
163 * Tells output routine that it is Ok to call user specified patch output
164 * routine. Plumbing disables this to ensure stable output.
165 */
Nguyễn Thái Ngọc Duy2b393ef2019-01-27 00:35:30[diff] [blame]166 unsigned allow_external;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]167
168 /**
169 * For communication between the calling program and the options parser;
170 * tell the calling program to signal the presence of difference using
171 * program exit code.
172 */
Nguyễn Thái Ngọc Duy2b393ef2019-01-27 00:35:30[diff] [blame]173 unsigned exit_with_status;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]174
175 /**
176 * Tells the library that the calling program is feeding the filepairs
177 * reversed; `one` is two, and `two` is one.
178 */
Nguyễn Thái Ngọc Duy2b393ef2019-01-27 00:35:30[diff] [blame]179 unsigned reverse_diff;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]180
Nguyễn Thái Ngọc Duy2b393ef2019-01-27 00:35:30[diff] [blame]181 unsigned check_failed;
182 unsigned relative_name;
183 unsigned ignore_submodules;
184 unsigned dirstat_cumulative;
185 unsigned dirstat_by_file;
186 unsigned allow_textconv;
187 unsigned textconv_set_via_cmdline;
188 unsigned diff_from_contents;
189 unsigned dirty_submodules;
190 unsigned ignore_untracked_in_submodules;
Sangeeta Jain8ef93122020-11-10 08:39:00[diff] [blame]191 unsigned ignore_submodule_set;
Nguyễn Thái Ngọc Duy2b393ef2019-01-27 00:35:30[diff] [blame]192 unsigned ignore_dirty_submodules;
193 unsigned override_submodule_config;
194 unsigned dirstat_by_line;
195 unsigned funccontext;
196 unsigned default_follow_renames;
197 unsigned stat_with_summary;
198 unsigned suppress_diff_headers;
199 unsigned dual_color_diffed_diffs;
Thomas Gummerer430be362019-07-11 16:08:48[diff] [blame]200 unsigned suppress_hunk_header_line_count;
Brandon Williams02f2f562017-10-31 18:19:05[diff] [blame]201};
Johannes Schindelin752c0c22009-10-19 12:38:32[diff] [blame]202
Brandon Williams02f2f562017-10-31 18:19:05[diff] [blame]203static inline void diff_flags_or(struct diff_flags *a,
204 const struct diff_flags *b)
205{
206 char *tmp_a = (char *)a;
207 const char *tmp_b = (const char *)b;
208 int i;
209
210 for (i = 0; i < sizeof(struct diff_flags); i++)
211 tmp_a[i] |= tmp_b[i];
212}
213
Keith Cascio628d5c22009-02-17 03:26:49[diff] [blame]214#define DIFF_XDL_TST(opts, flag) ((opts)->xdl_opts & XDF_##flag)
215#define DIFF_XDL_SET(opts, flag) ((opts)->xdl_opts |= XDF_##flag)
216#define DIFF_XDL_CLR(opts, flag) ((opts)->xdl_opts &= ~XDF_##flag)
Pierre Habouzit8f67f8a2007-11-10 19:05:14[diff] [blame]217
Junio C Hamano307ab202012-02-19 23:36:55[diff] [blame]218#define DIFF_WITH_ALG(opts, flag) (((opts)->xdl_opts & ~XDF_DIFF_ALGORITHM_MASK) | XDF_##flag)
219
Thomas Rast882749a2010-04-14 15:59:06[diff] [blame]220enum diff_words_type {
221 DIFF_WORDS_NONE = 0,
222 DIFF_WORDS_PORCELAIN,
223 DIFF_WORDS_PLAIN,
224 DIFF_WORDS_COLOR
225};
226
Jacob Keller61cfbc02016-08-31 23:27:21[diff] [blame]227enum diff_submodule_format {
228 DIFF_SUBMODULE_SHORT = 0,
Jacob Kellerfd47ae62016-08-31 23:27:25[diff] [blame]229 DIFF_SUBMODULE_LOG,
230 DIFF_SUBMODULE_INLINE_DIFF
Jacob Keller61cfbc02016-08-31 23:27:21[diff] [blame]231};
232
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]233/**
234 * the set of options the calling program wants to affect the operation of
235 * diffcore library with.
236 */
Junio C Hamano6b5ee132005-09-21 07:00:47[diff] [blame]237struct diff_options {
Junio C Hamano6b5ee132005-09-21 07:00:47[diff] [blame]238 const char *orderfile;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]239
Junio C Hamano1eb41362021-02-11 19:57:50[diff] [blame]240 /*
241 * "--rotate-to=<file>" would start showing at <file> and when
242 * the output reaches the end, wrap around by default.
243 * Setting skip_instead_of_rotate to true stops the output at the
244 * end, effectively discarding the earlier part of the output
245 * before <file>'s diff (this is used to implement the
246 * "--skip-to=<file>" option).
247 *
248 * When rotate_to_strict is set, it is an error if there is no
249 * <file> in the diff. Otherwise, the output starts at the
250 * path that is the same as, or first path that sorts after,
251 * <file>. Because it is unreasonable to require the exact
252 * match for "git log -p --rotate-to=<file>" (i.e. not all
253 * commit would touch that single <file>), "git log" sets it
254 * to false. "git diff" sets it to true to detect an error
255 * in the command line option.
256 */
257 const char *rotate_to;
258 int skip_instead_of_rotate;
259 int rotate_to_strict;
260
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]261 /**
262 * A constant string (can and typically does contain newlines to look for
263 * a block of text, not just a single line) to filter out the filepairs
264 * that do not change the number of strings contained in its preimage and
265 * postimage of the diff_queue.
266 */
Junio C Hamano6b5ee132005-09-21 07:00:47[diff] [blame]267 const char *pickaxe;
Ævar Arnfjörð Bjarmasona47fcbe2021-04-12 17:15:16[diff] [blame]268 unsigned pickaxe_opts;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]269
Michał Kępień296d4a92020-10-20 06:48:09[diff] [blame]270 /* -I<regex> */
271 regex_t **ignore_regex;
272 size_t ignore_regex_nr, ignore_regex_alloc;
273
Junio C Hamano2f3f8b22006-11-02 08:02:11[diff] [blame]274 const char *single_follow;
Johannes Schindelineab9a402007-12-18 19:32:14[diff] [blame]275 const char *a_prefix, *b_prefix;
Jacob Keller660e1132016-08-31 23:27:20[diff] [blame]276 const char *line_prefix;
277 size_t line_prefix_length;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]278
279 /**
280 * collection of boolean options that affects the operation, but some do
281 * not have anything to do with the diffcore library.
282 */
Brandon Williams02f2f562017-10-31 18:19:05[diff] [blame]283 struct diff_flags flags;
Junio C Hamano1ecc1cb2013-07-17 22:05:46[diff] [blame]284
285 /* diff-filter bits */
Johannes Schindelin75408ca2022-01-28 12:02:50[diff] [blame]286 unsigned int filter, filter_not;
Junio C Hamano1ecc1cb2013-07-17 22:05:46[diff] [blame]287
Jeff Kingf1c96262011-08-18 05:03:12[diff] [blame]288 int use_color;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]289
290 /* Number of context lines to generate in patch output. */
Linus Torvaldsee1e5412006-05-13 20:23:48[diff] [blame]291 int context;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]292
René Scharfe6d0e6742008-12-28 18:45:32[diff] [blame]293 int interhunkcontext;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]294
295 /* Affects the way detection logic for complete rewrites, renames and
296 * copies.
297 */
Junio C Hamano6b5ee132005-09-21 07:00:47[diff] [blame]298 int break_opt;
299 int detect_rename;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]300
Junio C Hamano467ddc12011-03-01 00:11:55[diff] [blame]301 int irreversible_delete;
Junio C Hamanofb132272007-08-03 20:33:31[diff] [blame]302 int skip_stat_unmatch;
Junio C Hamano6b5ee132005-09-21 07:00:47[diff] [blame]303 int line_termination;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]304
305 /* The output format used when `diff_flush()` is run. */
Junio C Hamano6b5ee132005-09-21 07:00:47[diff] [blame]306 int output_format;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]307
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]308 /* Affects the way detection logic for complete rewrites, renames and
309 * copies.
310 */
Junio C Hamano6b5ee132005-09-21 07:00:47[diff] [blame]311 int rename_score;
Junio C Hamano8082d8d2005-09-21 07:18:27[diff] [blame]312 int rename_limit;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]313
Jeff Kingbf0ab102011-02-19 10:20:51[diff] [blame]314 int needed_rename_limit;
Junio C Hamanof31027c2011-01-06 21:50:06[diff] [blame]315 int degraded_cc_to_c;
Jeff King3ac942d2011-02-20 09:51:16[diff] [blame]316 int show_rename_progress;
Johan Herland712d2c72011-04-29 09:36:20[diff] [blame]317 int dirstat_permille;
Junio C Hamano6b5ee132005-09-21 07:00:47[diff] [blame]318 int setup;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]319
320 /* Number of hexdigits to abbreviate raw format output to. */
Junio C Hamano47dd0d52005-12-14 01:21:41[diff] [blame]321 int abbrev;
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]322
Derrick Stoleee3696982020-03-30 00:31:27[diff] [blame]323 /* If non-zero, then stop computing after this many changes. */
324 int max_changes;
Derrick Stoleee3696982020-03-30 00:31:27[diff] [blame]325
Nguyễn Thái Ngọc Duy425a28e2016-10-24 10:42:19[diff] [blame]326 int ita_invisible_in_index;
Junio C Hamanob8767f72015-05-26 17:11:28[diff] [blame]327/* white-space error highlighting */
Stefan Beller091f8e22017-06-30 00:06:53[diff] [blame]328#define WSEH_NEW (1<<12)
329#define WSEH_CONTEXT (1<<13)
330#define WSEH_OLD (1<<14)
Junio C Hamanob8767f72015-05-26 17:11:28[diff] [blame]331 unsigned ws_error_highlight;
Junio C Hamanocd676a52008-02-12 22:26:02[diff] [blame]332 const char *prefix;
333 int prefix_length;
Johannes Schindelin698ce6f2006-05-20 13:40:29[diff] [blame]334 const char *stat_sep;
Nguyễn Thái Ngọc Duy7f125ff2019-05-29 09:11:14[diff] [blame]335 int xdl_opts;
John Caia4cf9002023-02-20 21:04:42[diff] [blame]336 int ignore_driver_algorithm;
Linus Torvaldsac1b3d12005-10-21 04:05:05[diff] [blame]337
Jonathan Tan2477ab22017-11-27 19:47:47[diff] [blame]338 /* see Documentation/diff-options.txt */
339 char **anchors;
340 size_t anchors_nr, anchors_alloc;
341
Junio C Hamanoa2540022006-09-27 01:53:02[diff] [blame]342 int stat_width;
343 int stat_name_width;
Zbigniew Jędrzejewski-Szmek969fe572012-03-01 12:26:45[diff] [blame]344 int stat_graph_width;
Michael J Gruber808e1db2011-05-27 12:36:41[diff] [blame]345 int stat_count;
Johannes Schindelin2b6a5412009-01-17 16:29:45[diff] [blame]346 const char *word_regex;
Thomas Rast882749a2010-04-14 15:59:06[diff] [blame]347 enum diff_words_type word_diff;
Jacob Keller61cfbc02016-08-31 23:27:21[diff] [blame]348 enum diff_submodule_format submodule_format;
Junio C Hamanoa2540022006-09-27 01:53:02[diff] [blame]349
Stefan Beller15af58c2018-01-04 22:50:42[diff] [blame]350 struct oidset *objfind;
351
Johannes Schindelin34a5e1a2007-02-25 22:34:54[diff] [blame]352 /* this is set by diffcore for DIFF_FORMAT_PATCH */
353 int found_changes;
354
Junio C Hamano44c48a92010-08-13 19:17:45[diff] [blame]355 /* to support internal diff recursion by --follow hack*/
356 int found_follow;
357
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]358 /* Callback which allows tweaking the options in diff_setup_done(). */
Junio C Hamano6c374002013-05-10 15:10:11[diff] [blame]359 void (*set_default)(struct diff_options *);
360
Daniel Barkalowc0c77732008-03-10 02:43:39[diff] [blame]361 FILE *file;
362 int close_file;
363
Stefan Beller7648b792018-08-17 20:43:52[diff] [blame]364#define OUTPUT_INDICATOR_NEW 0
365#define OUTPUT_INDICATOR_OLD 1
366#define OUTPUT_INDICATOR_CONTEXT 2
367 char output_indicators[3];
368
Nguyễn Thái Ngọc Duy66f13622010-12-15 15:02:38[diff] [blame]369 struct pathspec pathspec;
Kirill Smelkov72441af2014-04-06 21:46:26[diff] [blame]370 pathchange_fn_t pathchange;
Linus Torvaldsac1b3d12005-10-21 04:05:05[diff] [blame]371 change_fn_t change;
372 add_remove_fn_t add_remove;
Jeff Kinga937b372017-10-13 15:27:45[diff] [blame]373 void *change_fn_data;
Jeff King04245582006-09-07 06:35:42[diff] [blame]374 diff_format_fn_t format_callback;
375 void *format_callback_data;
Bo Yanga3c158d2010-05-26 07:08:02[diff] [blame]376 diff_prefix_fn_t output_prefix;
377 void *output_prefix_data;
Zoltan Klingeree7fb0b2013-12-05 23:38:46[diff] [blame]378
379 int diff_path_counter;
Stefan Bellere6e045f2017-06-30 00:07:06[diff] [blame]380
381 struct emitted_diff_symbols *emitted_symbols;
Stefan Beller2e2d5ac2017-06-30 20:53:07[diff] [blame]382 enum {
383 COLOR_MOVED_NO = 0,
Stefan Beller176841f2017-06-30 20:53:08[diff] [blame]384 COLOR_MOVED_PLAIN = 1,
Stefan Beller51da15e2018-07-16 23:05:39[diff] [blame]385 COLOR_MOVED_BLOCKS = 2,
386 COLOR_MOVED_ZEBRA = 3,
387 COLOR_MOVED_ZEBRA_DIM = 4,
Stefan Beller2e2d5ac2017-06-30 20:53:07[diff] [blame]388 } color_moved;
389 #define COLOR_MOVED_DEFAULT COLOR_MOVED_ZEBRA
Jonathan Tanf0b8fb62017-08-16 01:27:39[diff] [blame]390 #define COLOR_MOVED_MIN_ALNUM_COUNT 20
Stefan Bellerca1f4ae2018-07-18 19:31:55[diff] [blame]391
392 /* XDF_WHITESPACE_FLAGS regarding block detection are set at 2, 3, 4 */
393 #define COLOR_MOVED_WS_ALLOW_INDENTATION_CHANGE (1<<5)
Stefan Bellerd173e792018-11-13 21:33:57[diff] [blame]394 #define COLOR_MOVED_WS_ERROR (1<<0)
395 unsigned color_moved_ws_handling;
Nguyễn Thái Ngọc Duyb78ea5f2018-09-21 15:57:19[diff] [blame]396
397 struct repository *repo;
Elijah Newren95433ee2022-02-02 02:37:34[diff] [blame]398 struct strmap *additional_path_headers;
Ævar Arnfjörð Bjarmasone900d492021-02-11 10:45:34[diff] [blame]399
400 int no_free;
Junio C Hamano6b5ee132005-09-21 07:00:47[diff] [blame]401};
402
Nguyễn Thái Ngọc Duycdb53302019-03-24 08:20:14[diff] [blame]403unsigned diff_filter_bit(char status);
404
Stefan Bellerf3597132017-06-30 00:07:00[diff] [blame]405void diff_emit_submodule_del(struct diff_options *o, const char *line);
406void diff_emit_submodule_add(struct diff_options *o, const char *line);
407void diff_emit_submodule_untracked(struct diff_options *o, const char *path);
408void diff_emit_submodule_modified(struct diff_options *o, const char *path);
409void diff_emit_submodule_header(struct diff_options *o, const char *header);
410void diff_emit_submodule_error(struct diff_options *o, const char *err);
411void diff_emit_submodule_pipethrough(struct diff_options *o,
412 const char *line, int len);
413
Daniel Ferreirae4cb6592019-11-13 12:40:58[diff] [blame]414struct diffstat_t {
415 int nr;
416 int alloc;
417 struct diffstat_file {
418 char *from_name;
419 char *name;
420 char *print_name;
421 const char *comments;
422 unsigned is_unmerged:1;
423 unsigned is_binary:1;
424 unsigned is_renamed:1;
425 unsigned is_interesting:1;
426 uintmax_t added, deleted;
427 } **files;
428};
429
Jeff Kingce436972006-07-23 09:24:18[diff] [blame]430enum color_diff {
431 DIFF_RESET = 0,
Jeff King8dbf3eb2015-05-27 20:48:46[diff] [blame]432 DIFF_CONTEXT = 1,
Jeff Kingce436972006-07-23 09:24:18[diff] [blame]433 DIFF_METAINFO = 2,
434 DIFF_FRAGINFO = 3,
435 DIFF_FILE_OLD = 4,
436 DIFF_FILE_NEW = 5,
437 DIFF_COMMIT = 6,
Junio C Hamano448c3ef2006-09-23 05:48:39[diff] [blame]438 DIFF_WHITESPACE = 7,
Stefan Beller2e2d5ac2017-06-30 20:53:07[diff] [blame]439 DIFF_FUNCINFO = 8,
440 DIFF_FILE_OLD_MOVED = 9,
441 DIFF_FILE_OLD_MOVED_ALT = 10,
Stefan Beller86b452e2017-06-30 20:53:09[diff] [blame]442 DIFF_FILE_OLD_MOVED_DIM = 11,
443 DIFF_FILE_OLD_MOVED_ALT_DIM = 12,
444 DIFF_FILE_NEW_MOVED = 13,
445 DIFF_FILE_NEW_MOVED_ALT = 14,
446 DIFF_FILE_NEW_MOVED_DIM = 15,
Johannes Schindelina7be92a2018-08-13 11:33:32[diff] [blame]447 DIFF_FILE_NEW_MOVED_ALT_DIM = 16,
448 DIFF_CONTEXT_DIM = 17,
449 DIFF_FILE_OLD_DIM = 18,
450 DIFF_FILE_NEW_DIM = 19,
451 DIFF_CONTEXT_BOLD = 20,
452 DIFF_FILE_OLD_BOLD = 21,
453 DIFF_FILE_NEW_BOLD = 22,
Jeff Kingce436972006-07-23 09:24:18[diff] [blame]454};
Heba Waly13c4d7e2019-11-17 21:04:40[diff] [blame]455
Jeff Kingce436972006-07-23 09:24:18[diff] [blame]456const char *diff_get_color(int diff_use_color, enum color_diff ix);
Pierre Habouzit8f67f8a2007-11-10 19:05:14[diff] [blame]457#define diff_get_color_opt(o, ix) \
Jeff Kingf1c96262011-08-18 05:03:12[diff] [blame]458 diff_get_color((o)->use_color, ix)
Pierre Habouzit8f67f8a2007-11-10 19:05:14[diff] [blame]459
Jeff Kingce436972006-07-23 09:24:18[diff] [blame]460
John Keepingf1922232013-02-07 20:15:26[diff] [blame]461const char *diff_line_prefix(struct diff_options *);
462
463
Johannes Schindelin698ce6f2006-05-20 13:40:29[diff] [blame]464extern const char mime_boundary_leader[];
465
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]466struct combine_diff_path *diff_tree_paths(
Brandon Williamsfda94b42017-05-30 17:31:06[diff] [blame]467 struct combine_diff_path *p, const struct object_id *oid,
468 const struct object_id **parents_oid, int nparent,
Kirill Smelkov72441af2014-04-06 21:46:26[diff] [blame]469 struct strbuf *base, struct diff_options *opt);
SZEDER Gábor0ee3cb82020-06-05 13:00:27[diff] [blame]470void diff_tree_oid(const struct object_id *old_oid,
471 const struct object_id *new_oid,
472 const char *base, struct diff_options *opt);
473void diff_root_tree_oid(const struct object_id *new_oid, const char *base,
474 struct diff_options *opt);
Linus Torvaldsac1b3d12005-10-21 04:05:05[diff] [blame]475
Junio C Hamanoea726d02006-01-28 08:03:38[diff] [blame]476struct combine_diff_path {
477 struct combine_diff_path *next;
Junio C Hamanoea726d02006-01-28 08:03:38[diff] [blame]478 char *path;
Junio C Hamano2454c962006-02-06 20:53:07[diff] [blame]479 unsigned int mode;
brian m. carlson1ff57c12015-03-13 23:39:33[diff] [blame]480 struct object_id oid;
Junio C Hamano2454c962006-02-06 20:53:07[diff] [blame]481 struct combine_diff_parent {
Junio C Hamanod416df82006-02-10 10:30:52[diff] [blame]482 char status;
Junio C Hamano2454c962006-02-06 20:53:07[diff] [blame]483 unsigned int mode;
brian m. carlson1ff57c12015-03-13 23:39:33[diff] [blame]484 struct object_id oid;
Elijah Newrend76ce4f2019-02-08 01:12:46[diff] [blame]485 struct strbuf path;
Junio C Hamano2454c962006-02-06 20:53:07[diff] [blame]486 } parent[FLEX_ARRAY];
Junio C Hamanoea726d02006-01-28 08:03:38[diff] [blame]487};
Junio C Hamano2454c962006-02-06 20:53:07[diff] [blame]488#define combine_diff_path_size(n, l) \
Jeff King5b442c42016-02-19 11:21:30[diff] [blame]489 st_add4(sizeof(struct combine_diff_path), (l), 1, \
490 st_mult(sizeof(struct combine_diff_parent), (n)))
Junio C Hamanoea726d02006-01-28 08:03:38[diff] [blame]491
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]492void show_combined_diff(struct combine_diff_path *elem, int num_parent,
Sergey Organovd01141d2020-09-29 11:31:22[diff] [blame]493 struct rev_info *);
Junio C Hamanoea726d02006-01-28 08:03:38[diff] [blame]494
Sergey Organovd01141d2020-09-29 11:31:22[diff] [blame]495void diff_tree_combined(const struct object_id *oid, const struct oid_array *parents, struct rev_info *rev);
Junio C Hamano0fe7c1d2006-04-29 08:24:49[diff] [blame]496
Sergey Organovd01141d2020-09-29 11:31:22[diff] [blame]497void diff_tree_combined_merge(const struct commit *commit, struct rev_info *rev);
Junio C Hamanoaf3feef2006-01-24 09:22:04[diff] [blame]498
Junio C Hamanoa5a818e2008-08-19 03:08:09[diff] [blame]499void diff_set_mnemonic_prefix(struct diff_options *options, const char *a, const char *b);
Jeff King6799aad2023-03-09 06:07:06[diff] [blame]500void diff_set_noprefix(struct diff_options *options);
501void diff_set_default_prefix(struct diff_options *options);
Junio C Hamanoa5a818e2008-08-19 03:08:09[diff] [blame]502
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]503int diff_can_quit_early(struct diff_options *);
Junio C Hamano28b92642011-05-31 16:14:17[diff] [blame]504
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]505void diff_addremove(struct diff_options *,
506 int addremove,
507 unsigned mode,
508 const struct object_id *oid,
509 int oid_valid,
510 const char *fullpath, unsigned dirty_submodule);
Junio C Hamano77eb2722005-04-27 16:21:00[diff] [blame]511
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]512void diff_change(struct diff_options *,
513 unsigned mode1, unsigned mode2,
514 const struct object_id *old_oid,
515 const struct object_id *new_oid,
516 int old_oid_valid, int new_oid_valid,
517 const char *fullpath,
518 unsigned dirty_submodule1, unsigned dirty_submodule2);
Junio C Hamano77eb2722005-04-27 16:21:00[diff] [blame]519
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]520struct diff_filepair *diff_unmerge(struct diff_options *, const char *path);
Junio C Hamano77eb2722005-04-27 16:21:00[diff] [blame]521
Daniel Ferreirae4cb6592019-11-13 12:40:58[diff] [blame]522void compute_diffstat(struct diff_options *options, struct diffstat_t *diffstat,
523 struct diff_queue_struct *q);
524void free_diffstat_info(struct diffstat_t *diffstat);
525
Junio C Hamano19feebc2005-05-27 22:54:37[diff] [blame]526#define DIFF_SETUP_REVERSE 1
Junio C Hamanof0c6b2a2005-05-27 22:56:38[diff] [blame]527#define DIFF_SETUP_USE_SIZE_CACHE 4
Junio C Hamanoce240672005-06-03 08:36:43[diff] [blame]528
Matthieu Moydea007f2010-08-05 08:22:52[diff] [blame]529/*
Nicolas Vigierb0d12fc2013-10-31 11:08:28[diff] [blame]530 * Poor man's alternative to parse-option, to allow both stuck form
Matthieu Moydea007f2010-08-05 08:22:52[diff] [blame]531 * (--option=value) and separate form (--option value).
532 */
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]533int parse_long_opt(const char *opt, const char **argv,
534 const char **optarg);
Matthieu Moydea007f2010-08-05 08:22:52[diff] [blame]535
Glen Chooa4e7e312023-06-28 19:26:22[diff] [blame]536struct config_context;
537int git_diff_basic_config(const char *var, const char *value,
538 const struct config_context *ctx, void *cb);
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]539int git_diff_heuristic_config(const char *var, const char *value, void *cb);
540void init_diff_ui_defaults(void);
Glen Chooa4e7e312023-06-28 19:26:22[diff] [blame]541int git_diff_ui_config(const char *var, const char *value,
542 const struct config_context *ctx, void *cb);
Nguyễn Thái Ngọc Duye6757652018-09-21 15:57:24[diff] [blame]543void repo_diff_setup(struct repository *, struct diff_options *);
René Scharfec5630c42022-12-01 22:49:11[diff] [blame]544struct option *add_diff_options(const struct option *, struct diff_options *);
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]545int diff_opt_parse(struct diff_options *, const char **, int, const char *);
546void diff_setup_done(struct diff_options *);
Jeff King9eac5952023-06-01 17:41:06[diff] [blame]547
548/*
549 * Returns true if the pathspec can work with --follow mode. If die_on_error is
550 * set, die() with a specific error message rather than returning false.
551 */
552int diff_check_follow_pathspec(struct pathspec *ps, int die_on_error);
553
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]554int git_config_rename(const char *var, const char *value);
Junio C Hamano86436c22005-04-26 01:22:47[diff] [blame]555
Junio C Hamano6b14d7f2005-05-22 17:04:37[diff] [blame]556#define DIFF_DETECT_RENAME 1
557#define DIFF_DETECT_COPY 2
558
Junio C Hamano367cec12005-05-27 22:55:28[diff] [blame]559#define DIFF_PICKAXE_ALL 1
Petr Baudisd01d8c62006-03-29 00:16:33[diff] [blame]560#define DIFF_PICKAXE_REGEX 2
Junio C Hamanof345b0a2005-05-30 07:08:37[diff] [blame]561
Junio C Hamanof506b8e2010-08-23 17:17:03[diff] [blame]562#define DIFF_PICKAXE_KIND_S 4 /* traditional plumbing counter */
563#define DIFF_PICKAXE_KIND_G 8 /* grep in the patch */
Stefan Beller15af58c2018-01-04 22:50:42[diff] [blame]564#define DIFF_PICKAXE_KIND_OBJFIND 16 /* specific object IDs */
Junio C Hamanof506b8e2010-08-23 17:17:03[diff] [blame]565
Stefan Beller15af58c2018-01-04 22:50:42[diff] [blame]566#define DIFF_PICKAXE_KINDS_MASK (DIFF_PICKAXE_KIND_S | \
567 DIFF_PICKAXE_KIND_G | \
568 DIFF_PICKAXE_KIND_OBJFIND)
Ævar Arnfjörð Bjarmason188e9e22021-04-12 17:15:14[diff] [blame]569#define DIFF_PICKAXE_KINDS_G_REGEX_MASK (DIFF_PICKAXE_KIND_G | \
570 DIFF_PICKAXE_REGEX)
Ævar Arnfjörð Bjarmasond26ec882021-04-12 17:15:15[diff] [blame]571#define DIFF_PICKAXE_KINDS_ALL_OBJFIND_MASK (DIFF_PICKAXE_ALL | \
572 DIFF_PICKAXE_KIND_OBJFIND)
Stefan Bellercf630512018-01-04 22:50:41[diff] [blame]573
Stefan Bellerc1ddc462018-01-04 22:50:40[diff] [blame]574#define DIFF_PICKAXE_IGNORE_CASE 32
Junio C Hamanof2ce9fd2005-06-12 03:57:13[diff] [blame]575
Dragan Simic4ca7a3f2023-09-23 04:01:14[diff] [blame]576void init_diffstat_widths(struct diff_options *);
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]577void diffcore_std(struct diff_options *);
Jeff King784c0da2019-02-14 05:48:03[diff] [blame]578void diffcore_fix_diff_index(void);
Junio C Hamano8082d8d2005-09-21 07:18:27[diff] [blame]579
580#define COMMON_DIFF_OPTIONS_HELP \
581"\ncommon diff options:\n" \
Petr Baudis5c91da22006-04-11 11:22:17[diff] [blame]582" -z output diff-raw with lines terminated with NUL.\n" \
583" -p output patch format.\n" \
Johannes Schindelind75f7952006-04-13 22:15:30[diff] [blame]584" -u synonym for -p.\n" \
Junio C Hamano74e2abe2006-10-12 10:01:00[diff] [blame]585" --patch-with-raw\n" \
Johannes Schindelin29353272006-04-15 11:41:18[diff] [blame]586" output both a patch and the diff-raw format.\n" \
587" --stat show diffstat instead of patch.\n" \
Junio C Hamano8082d8d2005-09-21 07:18:27[diff] [blame]588" --numstat show numeric diffstat instead of patch.\n" \
Junio C Hamano946f5f72005-09-21 07:20:06[diff] [blame]589" --patch-with-stat\n" \
Junio C Hamano47dd0d52005-12-14 01:21:41[diff] [blame]590" output a patch and prepend its diffstat.\n" \
Junio C Hamano913419f2005-12-18 10:03:15[diff] [blame]591" --name-only show only names of changed files.\n" \
Junio C Hamano8082d8d2005-09-21 07:18:27[diff] [blame]592" --name-status show names and status of changed files.\n" \
593" --full-index show full object name on index lines.\n" \
594" --abbrev=<n> abbreviate object names in diff-tree header and diff-raw.\n" \
595" -R swap input file pairs.\n" \
Junio C Hamanodda2d792005-07-13 19:52:35[diff] [blame]596" -B detect complete rewrites.\n" \
Junio C Hamano8082d8d2005-09-21 07:18:27[diff] [blame]597" -M detect renames.\n" \
598" -C detect copies.\n" \
599" --find-copies-harder\n" \
600" try unchanged files as candidate for copy detection.\n" \
Junio C Hamanodda2d792005-07-13 19:52:35[diff] [blame]601" -l<n> limit rename attempts up to <n> paths.\n" \
Stephan Federca499202006-07-07 13:57:08[diff] [blame]602" -O<file> reorder diffs according to the <file>.\n" \
603" -S<string> find filepair whose only one side contains the string.\n" \
Junio C Hamanodda2d792005-07-13 19:52:35[diff] [blame]604" --pickaxe-all\n" \
Junio C Hamano38c6f782005-05-22 02:40:36[diff] [blame]605" show all files diff when -S is used and hit is found.\n" \
Junio C Hamano6b5ee132005-09-21 07:00:47[diff] [blame]606" -a --text treat all files as text.\n"
Junio C Hamano86436c22005-04-26 01:22:47[diff] [blame]607
Elijah Newren95433ee2022-02-02 02:37:34[diff] [blame]608int diff_queue_is_empty(struct diff_options *o);
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]609void diff_flush(struct diff_options*);
Ævar Arnfjörð Bjarmasone900d492021-02-11 10:45:34[diff] [blame]610void diff_free(struct diff_options*);
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]611void diff_warn_rename_limit(const char *varname, int needed, int degraded_cc);
Junio C Hamano86436c22005-04-26 01:22:47[diff] [blame]612
Junio C Hamanoe7baa4f2005-07-25 20:05:44[diff] [blame]613/* diff-raw status letters */
Junio C Hamanoca8c9152005-07-25 21:31:19[diff] [blame]614#define DIFF_STATUS_ADDED 'A'
Junio C Hamanoe7baa4f2005-07-25 20:05:44[diff] [blame]615#define DIFF_STATUS_COPIED 'C'
616#define DIFF_STATUS_DELETED 'D'
617#define DIFF_STATUS_MODIFIED 'M'
618#define DIFF_STATUS_RENAMED 'R'
619#define DIFF_STATUS_TYPE_CHANGED 'T'
620#define DIFF_STATUS_UNKNOWN 'X'
621#define DIFF_STATUS_UNMERGED 'U'
622
623/* these are not diff-raw status letters proper, but used by
624 * diffcore-filter insn to specify additional restrictions.
625 */
Junio C Hamano0b343792005-10-05 00:44:17[diff] [blame]626#define DIFF_STATUS_FILTER_AON '*'
Junio C Hamanoe7baa4f2005-07-25 20:05:44[diff] [blame]627#define DIFF_STATUS_FILTER_BROKEN 'B'
628
Jeff Kingd5e3b012016-10-20 06:19:43[diff] [blame]629/*
Ævar Arnfjörð Bjarmasonc7c33f52023-03-28 13:58:57[diff] [blame]630 * This is different from repo_find_unique_abbrev() in that
Jeff Kingd5e3b012016-10-20 06:19:43[diff] [blame]631 * it stuffs the result with dots for alignment.
632 */
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]633const char *diff_aligned_abbrev(const struct object_id *sha1, int);
Junio C Hamano47dd0d52005-12-14 01:21:41[diff] [blame]634
Denton Liu177a8302020-09-20 11:22:23[diff] [blame]635void diff_get_merge_base(const struct rev_info *revs, struct object_id *mb);
636
Junio C Hamano4bd5b7d2007-11-10 08:15:03[diff] [blame]637/* do not report anything on removed paths */
638#define DIFF_SILENT_ON_REMOVED 01
Junio C Hamanofb63d7f2007-11-10 02:22:52[diff] [blame]639/* report racily-clean paths as modified */
640#define DIFF_RACY_IS_MODIFIED 02
Jeff King25bd3ac2023-08-21 20:18:55[diff] [blame]641void run_diff_files(struct rev_info *revs, unsigned int option);
Denton Liu4c3fe822020-09-20 11:22:22[diff] [blame]642
643#define DIFF_INDEX_CACHED 01
Denton Liu0f5a1d42020-09-20 11:22:25[diff] [blame]644#define DIFF_INDEX_MERGE_BASE 02
Jeff King25bd3ac2023-08-21 20:18:55[diff] [blame]645void run_diff_index(struct rev_info *revs, unsigned int option);
Junio C Hamanoe09ad6e2006-04-22 09:43:00[diff] [blame]646
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]647int do_diff_cache(const struct object_id *, struct diff_options *);
Jerry Zhang51276c12022-10-24 20:07:40[diff] [blame]648int diff_flush_patch_id(struct diff_options *, struct object_id *, int);
brian m. carlson36261e42019-08-18 20:04:03[diff] [blame]649void flush_one_hunk(struct object_id *result, git_hash_ctx *ctx);
Johannes Schindelinfcb3d0a2006-06-25 01:51:08[diff] [blame]650
Jeff King5cc6b2d2023-08-21 20:20:46[diff] [blame]651int diff_result_code(struct diff_options *);
Junio C Hamanoda31b352007-12-14 07:40:27[diff] [blame]652
Junio C Hamanodcd6a8c2019-04-25 07:41:12[diff] [blame]653int diff_no_index(struct rev_info *,
Nguyễn Thái Ngọc Duy16bb3d72019-03-24 08:20:13[diff] [blame]654 int implicit_no_index, int, const char **);
Junio C Hamano0569e9b2008-05-24 05:28:56[diff] [blame]655
Nguyễn Thái Ngọc Duyffc00a42018-11-10 05:49:04[diff] [blame]656int index_differs_from(struct repository *r, const char *def,
657 const struct diff_flags *flags,
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]658 int ita_invisible_in_index);
Stephan Beyer75f3ff22009-02-10 14:30:35[diff] [blame]659
Eric Sunshine72a72392020-09-08 07:16:09[diff] [blame]660/*
661 * Emit an interdiff of two object ID's to 'diff_options.file' optionally
662 * indented by 'indent' spaces.
663 */
664void show_interdiff(const struct object_id *, const struct object_id *,
665 int indent, struct diff_options *);
Eric Sunshinecdffbdc2020-09-08 07:16:08[diff] [blame]666
Jeff Kinga64e6a42016-02-22 18:28:54[diff] [blame]667/*
668 * Fill the contents of the filespec "df", respecting any textconv defined by
669 * its userdiff driver. The "driver" parameter must come from a
670 * previous call to get_textconv(), and therefore should either be NULL or have
671 * textconv enabled.
672 *
673 * Note that the memory ownership of the resulting buffer depends on whether
674 * the driver field is NULL. If it is, then the memory belongs to the filespec
675 * struct. If it is non-NULL, then "outbuf" points to a newly allocated buffer
676 * that should be freed by the caller.
677 */
Nguyễn Thái Ngọc Duy6afaf802018-09-21 15:57:22[diff] [blame]678size_t fill_textconv(struct repository *r,
679 struct userdiff_driver *driver,
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]680 struct diff_filespec *df,
681 char **outbuf);
Axel Bonneta788d7d2010-06-07 15:23:36[diff] [blame]682
Jeff Kinga64e6a42016-02-22 18:28:54[diff] [blame]683/*
684 * Look up the userdiff driver for the given filespec, and return it if
685 * and only if it has textconv enabled (otherwise return NULL). The result
686 * can be passed to fill_textconv().
687 */
Nguyễn Thái Ngọc Duybd7ad452018-11-10 05:49:06[diff] [blame]688struct userdiff_driver *get_textconv(struct repository *r,
Nguyễn Thái Ngọc Duyacd00ea2018-09-21 15:57:33[diff] [blame]689 struct diff_filespec *one);
Axel Bonneta788d7d2010-06-07 15:23:36[diff] [blame]690
Jeff Smith3a35cb22017-05-24 05:15:10[diff] [blame]691/*
692 * Prepare diff_filespec and convert it using diff textconv API
693 * if the textconv driver exists.
694 * Return 1 if the conversion succeeds, 0 otherwise.
695 */
Nguyễn Thái Ngọc Duy6afaf802018-09-21 15:57:22[diff] [blame]696int textconv_object(struct repository *repo,
697 const char *path,
698 unsigned mode,
699 const struct object_id *oid, int oid_valid,
700 char **buf, unsigned long *buf_size);
Jeff Smith3a35cb22017-05-24 05:15:10[diff] [blame]701
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]702int parse_rename_score(const char **cp_p);
Kevin Ballard10ae7522010-09-27 23:58:25[diff] [blame]703
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]704long parse_algorithm_value(const char *value);
Michal Privoznik07924d42013-01-16 07:51:58[diff] [blame]705
Nguyễn Thái Ngọc Duyf758a7f2018-06-30 09:20:26[diff] [blame]706void print_stat_summary(FILE *fp, int files,
707 int insertions, int deletions);
708void setup_diff_pager(struct diff_options *);
Nguyễn Thái Ngọc Duy7f814632012-02-01 12:55:07[diff] [blame]709
Elijah Newreneaa966d2023-05-16 06:33:53[diff] [blame]710extern int diff_auto_refresh_index;
711
Junio C Hamano86436c22005-04-26 01:22:47[diff] [blame]712#endif /* DIFF_H */