2 * Copyright (C) 2005 Junio C Hamano
13 * The diff API is for programs that compare two sets of files (e.g. two trees,
14 * one tree and the index) and present the found difference in various ways.
15 * The calling program is responsible for feeding the API pairs of files, one
16 * from the "old" set and the corresponding one from "new" set, that are
18 * The library called through this API is called diffcore, and is responsible
21 * - finding total rewrites (`-B`), renames (`-M`) and copies (`-C`), and
22 * changes that touch a string (`-S`), as specified by the caller.
24 * - outputting the differences in various formats, as specified by the caller.
29 * - Prepare `struct diff_options` to record the set of diff options, and then
30 * call `repo_diff_setup()` to initialize this structure. This sets up the
33 * - Fill in the options structure to specify desired output format, rename
34 * detection, etc. `diff_opt_parse()` can be used to parse options given
35 * from the command line in a way consistent with existing git-diff family
38 * - Call `diff_setup_done()`; this inspects the options set up so far for
39 * internal consistency and make necessary tweaking to it (e.g. if textual
40 * patch output was asked, recursive behaviour is turned on); the callback
41 * set_default in diff_options can be used to tweak this more.
43 * - As you find different pairs of files, call `diff_change()` to feed
44 * modified files, `diff_addremove()` to feed created or deleted files, or
45 * `diff_unmerge()` to feed a file whose state is 'unmerged' to the API.
46 * These are thin wrappers to a lower-level `diff_queue()` function that is
47 * flexible enough to record any of these kinds of changes.
49 * - Once you finish feeding the pairs of files, call `diffcore_std()`.
50 * This will tell the diffcore library to go ahead and do its work.
52 * - Calling `diff_flush()` will produce the output, it will call
53 * `diff_free()` to free any resources, e.g. those allocated in
56 * - Set `.no_free = 1` before calling `diff_flush()` to defer the
57 * freeing of allocated memory in diff_options. This is useful when
58 * `diff_flush()` is being called in a loop, rather than as a
59 * one-off. When setting `.no_free = 1` you must ensure that
60 * `diff_free()` is called at the end, either by flipping the flag
61 * before the last `diff_flush()` call, or by flipping it before
62 * calling `diff_free()` yourself.
65 struct combine_diff_path
;
69 struct diff_queue_struct
;
75 struct userdiff_driver
;
77 typedef int (*pathchange_fn_t
)(struct diff_options
*options
,
78 struct combine_diff_path
*path
);
80 typedef void (*change_fn_t
)(struct diff_options
*options
,
81 unsigned old_mode
, unsigned new_mode
,
82 const struct object_id
*old_oid
,
83 const struct object_id
*new_oid
,
84 int old_oid_valid
, int new_oid_valid
,
86 unsigned old_dirty_submodule
, unsigned new_dirty_submodule
);
88 typedef void (*add_remove_fn_t
)(struct diff_options
*options
,
89 int addremove
, unsigned mode
,
90 const struct object_id
*oid
,
92 const char *fullpath
, unsigned dirty_submodule
);
94 typedef void (*diff_format_fn_t
)(struct diff_queue_struct
*q
,
95 struct diff_options
*options
, void *data
);
97 typedef struct strbuf
*(*diff_prefix_fn_t
)(struct diff_options
*opt
, void *data
);
99 #define DIFF_FORMAT_RAW 0x0001
100 #define DIFF_FORMAT_DIFFSTAT 0x0002
101 #define DIFF_FORMAT_NUMSTAT 0x0004
102 #define DIFF_FORMAT_SUMMARY 0x0008
103 #define DIFF_FORMAT_PATCH 0x0010
104 #define DIFF_FORMAT_SHORTSTAT 0x0020
105 #define DIFF_FORMAT_DIRSTAT 0x0040
107 /* These override all above */
108 #define DIFF_FORMAT_NAME 0x0100
109 #define DIFF_FORMAT_NAME_STATUS 0x0200
110 #define DIFF_FORMAT_CHECKDIFF 0x0400
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.
115 #define DIFF_FORMAT_NO_OUTPUT 0x0800
117 #define DIFF_FORMAT_CALLBACK 0x1000
119 #define DIFF_FLAGS_INIT { 0 }
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.
127 unsigned tree_in_recursive
;
129 /* Affects the way how a file that is seemingly binary is treated. */
134 * Tells the patch output format not to use abbreviated object names on the
139 /* Affects if diff-files shows removed files. */
140 unsigned silent_on_remove
;
143 * Tells the diffcore library that the caller is feeding unchanged
144 * filepairs to allow copies from unmodified files be detected.
146 unsigned find_copies_harder
;
148 unsigned follow_renames
;
149 unsigned rename_empty
;
151 /* Internal; used for optimization to see if there is any change. */
152 unsigned has_changes
;
157 * Tells diff-files that the input is not tracked files but files in random
158 * locations on the filesystem.
163 * Tells output routine that it is Ok to call user specified patch output
164 * routine. Plumbing disables this to ensure stable output.
166 unsigned allow_external
;
169 * For communication between the calling program and the options parser;
170 * tell the calling program to signal the presence of difference using
173 unsigned exit_with_status
;
176 * Tells the library that the calling program is feeding the filepairs
177 * reversed; `one` is two, and `two` is one.
179 unsigned reverse_diff
;
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
;
191 unsigned ignore_submodule_set
;
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
;
200 unsigned suppress_hunk_header_line_count
;
203 static inline void diff_flags_or(struct diff_flags
*a
,
204 const struct diff_flags
*b
)
206 char *tmp_a
= (char *)a
;
207 const char *tmp_b
= (const char *)b
;
210 for (i
= 0; i
< sizeof(struct diff_flags
); i
++)
211 tmp_a
[i
] |= tmp_b
[i
];
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)
218 #define DIFF_WITH_ALG(opts, flag) (((opts)->xdl_opts & ~XDF_DIFF_ALGORITHM_MASK) | XDF_##flag)
220 enum diff_words_type
{
222 DIFF_WORDS_PORCELAIN
,
227 enum diff_submodule_format
{
228 DIFF_SUBMODULE_SHORT
= 0,
230 DIFF_SUBMODULE_INLINE_DIFF
234 * the set of options the calling program wants to affect the operation of
235 * diffcore library with.
237 struct diff_options
{
238 const char *orderfile
;
241 * A constant string (can and typically does contain newlines to look for
242 * a block of text, not just a single line) to filter out the filepairs
243 * that do not change the number of strings contained in its preimage and
244 * postimage of the diff_queue.
249 regex_t
**ignore_regex
;
250 size_t ignore_regex_nr
, ignore_regex_alloc
;
252 const char *single_follow
;
253 const char *a_prefix
, *b_prefix
;
254 const char *line_prefix
;
255 size_t line_prefix_length
;
258 * collection of boolean options that affects the operation, but some do
259 * not have anything to do with the diffcore library.
261 struct diff_flags flags
;
263 /* diff-filter bits */
268 /* Number of context lines to generate in patch output. */
271 int interhunkcontext
;
273 /* Affects the way detection logic for complete rewrites, renames and
279 int irreversible_delete
;
280 int skip_stat_unmatch
;
281 int line_termination
;
283 /* The output format used when `diff_flush()` is run. */
286 unsigned pickaxe_opts
;
288 /* Affects the way detection logic for complete rewrites, renames and
294 int needed_rename_limit
;
295 int degraded_cc_to_c
;
296 int show_rename_progress
;
297 int dirstat_permille
;
300 /* Number of hexdigits to abbreviate raw format output to. */
303 /* If non-zero, then stop computing after this many changes. */
306 int ita_invisible_in_index
;
307 /* white-space error highlighting */
308 #define WSEH_NEW (1<<12)
309 #define WSEH_CONTEXT (1<<13)
310 #define WSEH_OLD (1<<14)
311 unsigned ws_error_highlight
;
314 const char *stat_sep
;
317 /* see Documentation/diff-options.txt */
319 size_t anchors_nr
, anchors_alloc
;
323 int stat_graph_width
;
325 const char *word_regex
;
326 enum diff_words_type word_diff
;
327 enum diff_submodule_format submodule_format
;
329 struct oidset
*objfind
;
331 /* this is set by diffcore for DIFF_FORMAT_PATCH */
334 /* to support internal diff recursion by --follow hack*/
337 /* Callback which allows tweaking the options in diff_setup_done(). */
338 void (*set_default
)(struct diff_options
*);
343 #define OUTPUT_INDICATOR_NEW 0
344 #define OUTPUT_INDICATOR_OLD 1
345 #define OUTPUT_INDICATOR_CONTEXT 2
346 char output_indicators
[3];
348 struct pathspec pathspec
;
349 pathchange_fn_t pathchange
;
351 add_remove_fn_t add_remove
;
352 void *change_fn_data
;
353 diff_format_fn_t format_callback
;
354 void *format_callback_data
;
355 diff_prefix_fn_t output_prefix
;
356 void *output_prefix_data
;
358 int diff_path_counter
;
360 struct emitted_diff_symbols
*emitted_symbols
;
363 COLOR_MOVED_PLAIN
= 1,
364 COLOR_MOVED_BLOCKS
= 2,
365 COLOR_MOVED_ZEBRA
= 3,
366 COLOR_MOVED_ZEBRA_DIM
= 4,
368 #define COLOR_MOVED_DEFAULT COLOR_MOVED_ZEBRA
369 #define COLOR_MOVED_MIN_ALNUM_COUNT 20
371 /* XDF_WHITESPACE_FLAGS regarding block detection are set at 2, 3, 4 */
372 #define COLOR_MOVED_WS_ALLOW_INDENTATION_CHANGE (1<<5)
373 #define COLOR_MOVED_WS_ERROR (1<<0)
374 unsigned color_moved_ws_handling
;
376 struct repository
*repo
;
377 struct option
*parseopts
;
382 unsigned diff_filter_bit(char status
);
384 void diff_emit_submodule_del(struct diff_options
*o
, const char *line
);
385 void diff_emit_submodule_add(struct diff_options
*o
, const char *line
);
386 void diff_emit_submodule_untracked(struct diff_options
*o
, const char *path
);
387 void diff_emit_submodule_modified(struct diff_options
*o
, const char *path
);
388 void diff_emit_submodule_header(struct diff_options
*o
, const char *header
);
389 void diff_emit_submodule_error(struct diff_options
*o
, const char *err
);
390 void diff_emit_submodule_pipethrough(struct diff_options
*o
,
391 const char *line
, int len
);
396 struct diffstat_file
{
400 const char *comments
;
401 unsigned is_unmerged
:1;
402 unsigned is_binary
:1;
403 unsigned is_renamed
:1;
404 unsigned is_interesting
:1;
405 uintmax_t added
, deleted
;
419 DIFF_FILE_OLD_MOVED
= 9,
420 DIFF_FILE_OLD_MOVED_ALT
= 10,
421 DIFF_FILE_OLD_MOVED_DIM
= 11,
422 DIFF_FILE_OLD_MOVED_ALT_DIM
= 12,
423 DIFF_FILE_NEW_MOVED
= 13,
424 DIFF_FILE_NEW_MOVED_ALT
= 14,
425 DIFF_FILE_NEW_MOVED_DIM
= 15,
426 DIFF_FILE_NEW_MOVED_ALT_DIM
= 16,
427 DIFF_CONTEXT_DIM
= 17,
428 DIFF_FILE_OLD_DIM
= 18,
429 DIFF_FILE_NEW_DIM
= 19,
430 DIFF_CONTEXT_BOLD
= 20,
431 DIFF_FILE_OLD_BOLD
= 21,
432 DIFF_FILE_NEW_BOLD
= 22,
435 const char *diff_get_color(int diff_use_color
, enum color_diff ix
);
436 #define diff_get_color_opt(o, ix) \
437 diff_get_color((o)->use_color, ix)
440 const char *diff_line_prefix(struct diff_options
*);
443 extern const char mime_boundary_leader
[];
445 struct combine_diff_path
*diff_tree_paths(
446 struct combine_diff_path
*p
, const struct object_id
*oid
,
447 const struct object_id
**parents_oid
, int nparent
,
448 struct strbuf
*base
, struct diff_options
*opt
);
449 void diff_tree_oid(const struct object_id
*old_oid
,
450 const struct object_id
*new_oid
,
451 const char *base
, struct diff_options
*opt
);
452 void diff_root_tree_oid(const struct object_id
*new_oid
, const char *base
,
453 struct diff_options
*opt
);
455 struct combine_diff_path
{
456 struct combine_diff_path
*next
;
459 struct object_id oid
;
460 struct combine_diff_parent
{
463 struct object_id oid
;
465 } parent
[FLEX_ARRAY
];
467 #define combine_diff_path_size(n, l) \
468 st_add4(sizeof(struct combine_diff_path), (l), 1, \
469 st_mult(sizeof(struct combine_diff_parent), (n)))
471 void show_combined_diff(struct combine_diff_path
*elem
, int num_parent
,
474 void diff_tree_combined(const struct object_id
*oid
, const struct oid_array
*parents
, struct rev_info
*rev
);
476 void diff_tree_combined_merge(const struct commit
*commit
, struct rev_info
*rev
);
478 void diff_set_mnemonic_prefix(struct diff_options
*options
, const char *a
, const char *b
);
480 int diff_can_quit_early(struct diff_options
*);
482 void diff_addremove(struct diff_options
*,
485 const struct object_id
*oid
,
487 const char *fullpath
, unsigned dirty_submodule
);
489 void diff_change(struct diff_options
*,
490 unsigned mode1
, unsigned mode2
,
491 const struct object_id
*old_oid
,
492 const struct object_id
*new_oid
,
493 int old_oid_valid
, int new_oid_valid
,
494 const char *fullpath
,
495 unsigned dirty_submodule1
, unsigned dirty_submodule2
);
497 struct diff_filepair
*diff_unmerge(struct diff_options
*, const char *path
);
499 void compute_diffstat(struct diff_options
*options
, struct diffstat_t
*diffstat
,
500 struct diff_queue_struct
*q
);
501 void free_diffstat_info(struct diffstat_t
*diffstat
);
503 #define DIFF_SETUP_REVERSE 1
504 #define DIFF_SETUP_USE_SIZE_CACHE 4
507 * Poor man's alternative to parse-option, to allow both stuck form
508 * (--option=value) and separate form (--option value).
510 int parse_long_opt(const char *opt
, const char **argv
,
511 const char **optarg
);
513 int git_diff_basic_config(const char *var
, const char *value
, void *cb
);
514 int git_diff_heuristic_config(const char *var
, const char *value
, void *cb
);
515 void init_diff_ui_defaults(void);
516 int git_diff_ui_config(const char *var
, const char *value
, void *cb
);
517 #ifndef NO_THE_REPOSITORY_COMPATIBILITY_MACROS
518 #define diff_setup(diffopts) repo_diff_setup(the_repository, diffopts)
520 void repo_diff_setup(struct repository
*, struct diff_options
*);
521 int diff_opt_parse(struct diff_options
*, const char **, int, const char *);
522 void diff_setup_done(struct diff_options
*);
523 int git_config_rename(const char *var
, const char *value
);
525 #define DIFF_DETECT_RENAME 1
526 #define DIFF_DETECT_COPY 2
528 #define DIFF_PICKAXE_ALL 1
529 #define DIFF_PICKAXE_REGEX 2
531 #define DIFF_PICKAXE_KIND_S 4 /* traditional plumbing counter */
532 #define DIFF_PICKAXE_KIND_G 8 /* grep in the patch */
533 #define DIFF_PICKAXE_KIND_OBJFIND 16 /* specific object IDs */
535 #define DIFF_PICKAXE_KINDS_MASK (DIFF_PICKAXE_KIND_S | \
536 DIFF_PICKAXE_KIND_G | \
537 DIFF_PICKAXE_KIND_OBJFIND)
539 #define DIFF_PICKAXE_IGNORE_CASE 32
541 void diffcore_std(struct diff_options
*);
542 void diffcore_fix_diff_index(void);
544 #define COMMON_DIFF_OPTIONS_HELP \
545 "\ncommon diff options:\n" \
546 " -z output diff-raw with lines terminated with NUL.\n" \
547 " -p output patch format.\n" \
548 " -u synonym for -p.\n" \
549 " --patch-with-raw\n" \
550 " output both a patch and the diff-raw format.\n" \
551 " --stat show diffstat instead of patch.\n" \
552 " --numstat show numeric diffstat instead of patch.\n" \
553 " --patch-with-stat\n" \
554 " output a patch and prepend its diffstat.\n" \
555 " --name-only show only names of changed files.\n" \
556 " --name-status show names and status of changed files.\n" \
557 " --full-index show full object name on index lines.\n" \
558 " --abbrev=<n> abbreviate object names in diff-tree header and diff-raw.\n" \
559 " -R swap input file pairs.\n" \
560 " -B detect complete rewrites.\n" \
561 " -M detect renames.\n" \
562 " -C detect copies.\n" \
563 " --find-copies-harder\n" \
564 " try unchanged files as candidate for copy detection.\n" \
565 " -l<n> limit rename attempts up to <n> paths.\n" \
566 " -O<file> reorder diffs according to the <file>.\n" \
567 " -S<string> find filepair whose only one side contains the string.\n" \
569 " show all files diff when -S is used and hit is found.\n" \
570 " -a --text treat all files as text.\n"
572 int diff_queue_is_empty(void);
573 void diff_flush(struct diff_options
*);
574 void diff_free(struct diff_options
*);
575 void diff_warn_rename_limit(const char *varname
, int needed
, int degraded_cc
);
577 /* diff-raw status letters */
578 #define DIFF_STATUS_ADDED 'A'
579 #define DIFF_STATUS_COPIED 'C'
580 #define DIFF_STATUS_DELETED 'D'
581 #define DIFF_STATUS_MODIFIED 'M'
582 #define DIFF_STATUS_RENAMED 'R'
583 #define DIFF_STATUS_TYPE_CHANGED 'T'
584 #define DIFF_STATUS_UNKNOWN 'X'
585 #define DIFF_STATUS_UNMERGED 'U'
587 /* these are not diff-raw status letters proper, but used by
588 * diffcore-filter insn to specify additional restrictions.
590 #define DIFF_STATUS_FILTER_AON '*'
591 #define DIFF_STATUS_FILTER_BROKEN 'B'
594 * This is different from find_unique_abbrev() in that
595 * it stuffs the result with dots for alignment.
597 const char *diff_aligned_abbrev(const struct object_id
*sha1
, int);
599 void diff_get_merge_base(const struct rev_info
*revs
, struct object_id
*mb
);
601 /* do not report anything on removed paths */
602 #define DIFF_SILENT_ON_REMOVED 01
603 /* report racily-clean paths as modified */
604 #define DIFF_RACY_IS_MODIFIED 02
605 int run_diff_files(struct rev_info
*revs
, unsigned int option
);
607 #define DIFF_INDEX_CACHED 01
608 #define DIFF_INDEX_MERGE_BASE 02
609 int run_diff_index(struct rev_info
*revs
, unsigned int option
);
611 int do_diff_cache(const struct object_id
*, struct diff_options
*);
612 int diff_flush_patch_id(struct diff_options
*, struct object_id
*, int, int);
613 void flush_one_hunk(struct object_id
*result
, git_hash_ctx
*ctx
);
615 int diff_result_code(struct diff_options
*, int);
617 int diff_no_index(struct rev_info
*,
618 int implicit_no_index
, int, const char **);
620 int index_differs_from(struct repository
*r
, const char *def
,
621 const struct diff_flags
*flags
,
622 int ita_invisible_in_index
);
625 * Emit an interdiff of two object ID's to 'diff_options.file' optionally
626 * indented by 'indent' spaces.
628 void show_interdiff(const struct object_id
*, const struct object_id
*,
629 int indent
, struct diff_options
*);
632 * Fill the contents of the filespec "df", respecting any textconv defined by
633 * its userdiff driver. The "driver" parameter must come from a
634 * previous call to get_textconv(), and therefore should either be NULL or have
637 * Note that the memory ownership of the resulting buffer depends on whether
638 * the driver field is NULL. If it is, then the memory belongs to the filespec
639 * struct. If it is non-NULL, then "outbuf" points to a newly allocated buffer
640 * that should be freed by the caller.
642 size_t fill_textconv(struct repository
*r
,
643 struct userdiff_driver
*driver
,
644 struct diff_filespec
*df
,
648 * Look up the userdiff driver for the given filespec, and return it if
649 * and only if it has textconv enabled (otherwise return NULL). The result
650 * can be passed to fill_textconv().
652 struct userdiff_driver
*get_textconv(struct repository
*r
,
653 struct diff_filespec
*one
);
656 * Prepare diff_filespec and convert it using diff textconv API
657 * if the textconv driver exists.
658 * Return 1 if the conversion succeeds, 0 otherwise.
660 int textconv_object(struct repository
*repo
,
663 const struct object_id
*oid
, int oid_valid
,
664 char **buf
, unsigned long *buf_size
);
666 int parse_rename_score(const char **cp_p
);
668 long parse_algorithm_value(const char *value
);
670 void print_stat_summary(FILE *fp
, int files
,
671 int insertions
, int deletions
);
672 void setup_diff_pager(struct diff_options
*);