2 * "git difftool" builtin command
4 * This is a wrapper around the GIT_EXTERNAL_DIFF-compatible
5 * git-difftool--helper script.
7 * This script exports GIT_EXTERNAL_DIFF and GIT_PAGER for use by git.
8 * The GIT_DIFF* variables are exported for use by git-difftool--helper.
10 * Any arguments that are unknown to this script are forwarded to 'git diff'.
12 * Copyright (C) 2016 Johannes Schindelin
14 #define USE_THE_INDEX_VARIABLE
19 #include "run-command.h"
20 #include "environment.h"
23 #include "parse-options.h"
24 #include "read-cache-ll.h"
25 #include "sparse-index.h"
29 #include "object-file.h"
30 #include "object-store-ll.h"
35 static int trust_exit_code
;
37 static const char *const builtin_difftool_usage
[] = {
38 N_("git difftool [<options>] [<commit> [<commit>]] [--] [<path>...]"),
42 static int difftool_config(const char *var
, const char *value
,
43 const struct config_context
*ctx
, void *cb
)
45 if (!strcmp(var
, "difftool.trustexitcode")) {
46 trust_exit_code
= git_config_bool(var
, value
);
50 return git_default_config(var
, value
, ctx
, cb
);
53 static int print_tool_help(void)
55 struct child_process cmd
= CHILD_PROCESS_INIT
;
58 strvec_pushl(&cmd
.args
, "mergetool", "--tool-help=diff", NULL
);
59 return run_command(&cmd
);
62 static int parse_index_info(char *p
, int *mode1
, int *mode2
,
63 struct object_id
*oid1
, struct object_id
*oid2
,
67 return error("expected ':', got '%c'", *p
);
68 *mode1
= (int)strtol(p
+ 1, &p
, 8);
70 return error("expected ' ', got '%c'", *p
);
71 *mode2
= (int)strtol(p
+ 1, &p
, 8);
73 return error("expected ' ', got '%c'", *p
);
74 if (parse_oid_hex(++p
, oid1
, (const char **)&p
))
75 return error("expected object ID, got '%s'", p
);
77 return error("expected ' ', got '%c'", *p
);
78 if (parse_oid_hex(++p
, oid2
, (const char **)&p
))
79 return error("expected object ID, got '%s'", p
);
81 return error("expected ' ', got '%c'", *p
);
84 return error("missing status");
85 if (p
[1] && !isdigit(p
[1]))
86 return error("unexpected trailer: '%s'", p
+ 1);
91 * Remove any trailing slash from $workdir
92 * before starting to avoid double slashes in symlink targets.
94 static void add_path(struct strbuf
*buf
, size_t base_len
, const char *path
)
96 strbuf_setlen(buf
, base_len
);
97 if (buf
->len
&& buf
->buf
[buf
->len
- 1] != '/')
98 strbuf_addch(buf
, '/');
99 strbuf_addstr(buf
, path
);
103 * Determine whether we can simply reuse the file in the worktree.
105 static int use_wt_file(const char *workdir
, const char *name
,
106 struct object_id
*oid
)
108 struct strbuf buf
= STRBUF_INIT
;
112 strbuf_addstr(&buf
, workdir
);
113 add_path(&buf
, buf
.len
, name
);
115 if (!lstat(buf
.buf
, &st
) && !S_ISLNK(st
.st_mode
)) {
116 struct object_id wt_oid
;
117 int fd
= open(buf
.buf
, O_RDONLY
);
120 !index_fd(&the_index
, &wt_oid
, fd
, &st
, OBJ_BLOB
, name
, 0)) {
121 if (is_null_oid(oid
)) {
122 oidcpy(oid
, &wt_oid
);
124 } else if (oideq(oid
, &wt_oid
))
129 strbuf_release(&buf
);
134 struct working_tree_entry
{
135 struct hashmap_entry entry
;
136 char path
[FLEX_ARRAY
];
139 static int working_tree_entry_cmp(const void *cmp_data UNUSED
,
140 const struct hashmap_entry
*eptr
,
141 const struct hashmap_entry
*entry_or_key
,
142 const void *keydata UNUSED
)
144 const struct working_tree_entry
*a
, *b
;
146 a
= container_of(eptr
, const struct working_tree_entry
, entry
);
147 b
= container_of(entry_or_key
, const struct working_tree_entry
, entry
);
149 return strcmp(a
->path
, b
->path
);
153 * The `left` and `right` entries hold paths for the symlinks hashmap,
154 * and a SHA-1 surrounded by brief text for submodules.
157 struct hashmap_entry entry
;
158 char left
[PATH_MAX
], right
[PATH_MAX
];
159 const char path
[FLEX_ARRAY
];
162 static int pair_cmp(const void *cmp_data UNUSED
,
163 const struct hashmap_entry
*eptr
,
164 const struct hashmap_entry
*entry_or_key
,
165 const void *keydata UNUSED
)
167 const struct pair_entry
*a
, *b
;
169 a
= container_of(eptr
, const struct pair_entry
, entry
);
170 b
= container_of(entry_or_key
, const struct pair_entry
, entry
);
172 return strcmp(a
->path
, b
->path
);
175 static void add_left_or_right(struct hashmap
*map
, const char *path
,
176 const char *content
, int is_right
)
178 struct pair_entry
*e
, *existing
;
180 FLEX_ALLOC_STR(e
, path
, path
);
181 hashmap_entry_init(&e
->entry
, strhash(path
));
182 existing
= hashmap_get_entry(map
, e
, entry
, NULL
);
187 e
->left
[0] = e
->right
[0] = '\0';
188 hashmap_add(map
, &e
->entry
);
190 strlcpy(is_right
? e
->right
: e
->left
, content
, PATH_MAX
);
194 struct hashmap_entry entry
;
195 char path
[FLEX_ARRAY
];
198 static int path_entry_cmp(const void *cmp_data UNUSED
,
199 const struct hashmap_entry
*eptr
,
200 const struct hashmap_entry
*entry_or_key
,
203 const struct path_entry
*a
, *b
;
205 a
= container_of(eptr
, const struct path_entry
, entry
);
206 b
= container_of(entry_or_key
, const struct path_entry
, entry
);
208 return strcmp(a
->path
, key
? key
: b
->path
);
211 static void changed_files(struct hashmap
*result
, const char *index_path
,
214 struct child_process update_index
= CHILD_PROCESS_INIT
;
215 struct child_process diff_files
= CHILD_PROCESS_INIT
;
216 struct strbuf buf
= STRBUF_INIT
;
217 const char *git_dir
= absolute_path(get_git_dir());
220 strvec_pushl(&update_index
.args
,
221 "--git-dir", git_dir
, "--work-tree", workdir
,
222 "update-index", "--really-refresh", "-q",
224 update_index
.no_stdin
= 1;
225 update_index
.no_stdout
= 1;
226 update_index
.no_stderr
= 1;
227 update_index
.git_cmd
= 1;
228 update_index
.use_shell
= 0;
229 update_index
.clean_on_exit
= 1;
230 update_index
.dir
= workdir
;
231 strvec_pushf(&update_index
.env
, "GIT_INDEX_FILE=%s", index_path
);
232 /* Ignore any errors of update-index */
233 run_command(&update_index
);
235 strvec_pushl(&diff_files
.args
,
236 "--git-dir", git_dir
, "--work-tree", workdir
,
237 "diff-files", "--name-only", "-z", NULL
);
238 diff_files
.no_stdin
= 1;
239 diff_files
.git_cmd
= 1;
240 diff_files
.use_shell
= 0;
241 diff_files
.clean_on_exit
= 1;
243 diff_files
.dir
= workdir
;
244 strvec_pushf(&diff_files
.env
, "GIT_INDEX_FILE=%s", index_path
);
245 if (start_command(&diff_files
))
246 die("could not obtain raw diff");
247 fp
= xfdopen(diff_files
.out
, "r");
248 while (!strbuf_getline_nul(&buf
, fp
)) {
249 struct path_entry
*entry
;
250 FLEX_ALLOC_STR(entry
, path
, buf
.buf
);
251 hashmap_entry_init(&entry
->entry
, strhash(buf
.buf
));
252 hashmap_add(result
, &entry
->entry
);
255 if (finish_command(&diff_files
))
256 die("diff-files did not exit properly");
257 strbuf_release(&buf
);
260 static int ensure_leading_directories(char *path
)
262 switch (safe_create_leading_directories(path
)) {
267 return error(_("could not create leading directories "
273 * Unconditional writing of a plain regular file is what
274 * "git difftool --dir-diff" wants to do for symlinks. We are preparing two
275 * temporary directories to be fed to a Git-unaware tool that knows how to
276 * show a diff of two directories (e.g. "diff -r A B").
278 * Because the tool is Git-unaware, if a symbolic link appears in either of
279 * these temporary directories, it will try to dereference and show the
280 * difference of the target of the symbolic link, which is not what we want,
281 * as the goal of the dir-diff mode is to produce an output that is logically
282 * equivalent to what "git diff" produces.
284 * Most importantly, we want to get textual comparison of the result of the
285 * readlink(2). get_symlink() provides that---it returns the contents of
286 * the symlink that gets written to a regular file to force the external tool
287 * to compare the readlink(2) result as text, even on a filesystem that is
288 * capable of doing a symbolic link.
290 static char *get_symlink(const struct object_id
*oid
, const char *path
)
293 if (is_null_oid(oid
)) {
294 /* The symlink is unknown to Git so read from the filesystem */
295 struct strbuf link
= STRBUF_INIT
;
297 if (strbuf_readlink(&link
, path
, strlen(path
)))
298 die(_("could not read symlink %s"), path
);
299 } else if (strbuf_read_file(&link
, path
, 128))
300 die(_("could not read symlink file %s"), path
);
302 data
= strbuf_detach(&link
, NULL
);
304 enum object_type type
;
306 data
= repo_read_object_file(the_repository
, oid
, &type
,
309 die(_("could not read object %s for symlink %s"),
310 oid_to_hex(oid
), path
);
316 static int checkout_path(unsigned mode
, struct object_id
*oid
,
317 const char *path
, const struct checkout
*state
)
319 struct cache_entry
*ce
;
322 ce
= make_transient_cache_entry(mode
, oid
, path
, 0, NULL
);
323 ret
= checkout_entry(ce
, state
, NULL
, NULL
);
325 discard_cache_entry(ce
);
329 static void write_file_in_directory(struct strbuf
*dir
, size_t dir_len
,
330 const char *path
, const char *content
)
332 add_path(dir
, dir_len
, path
);
333 ensure_leading_directories(dir
->buf
);
335 write_file(dir
->buf
, "%s", content
);
338 /* Write the file contents for the left and right sides of the difftool
339 * dir-diff representation for submodules and symlinks. Symlinks and submodules
340 * are written as regular text files so that external diff tools can diff them
341 * as text files, resulting in behavior that is analogous to to what "git diff"
342 * displays for symlink and submodule diffs.
344 static void write_standin_files(struct pair_entry
*entry
,
345 struct strbuf
*ldir
, size_t ldir_len
,
346 struct strbuf
*rdir
, size_t rdir_len
)
349 write_file_in_directory(ldir
, ldir_len
, entry
->path
, entry
->left
);
351 write_file_in_directory(rdir
, rdir_len
, entry
->path
, entry
->right
);
354 static int run_dir_diff(const char *extcmd
, int symlinks
, const char *prefix
,
355 struct child_process
*child
)
357 struct strbuf info
= STRBUF_INIT
, lpath
= STRBUF_INIT
;
358 struct strbuf rpath
= STRBUF_INIT
, buf
= STRBUF_INIT
;
359 struct strbuf ldir
= STRBUF_INIT
, rdir
= STRBUF_INIT
;
360 struct strbuf wtdir
= STRBUF_INIT
;
361 struct strbuf tmpdir
= STRBUF_INIT
;
362 char *lbase_dir
= NULL
, *rbase_dir
= NULL
;
363 size_t ldir_len
, rdir_len
, wtdir_len
;
364 const char *workdir
, *tmp
;
367 struct hashmap working_tree_dups
= HASHMAP_INIT(working_tree_entry_cmp
,
369 struct hashmap submodules
= HASHMAP_INIT(pair_cmp
, NULL
);
370 struct hashmap symlinks2
= HASHMAP_INIT(pair_cmp
, NULL
);
371 struct hashmap_iter iter
;
372 struct pair_entry
*entry
;
373 struct index_state wtindex
= INDEX_STATE_INIT(the_repository
);
374 struct checkout lstate
, rstate
;
376 struct child_process cmd
= CHILD_PROCESS_INIT
;
377 struct hashmap wt_modified
, tmp_modified
;
378 int indices_loaded
= 0;
380 workdir
= get_git_work_tree();
382 /* Setup temp directories */
383 tmp
= getenv("TMPDIR");
384 strbuf_add_absolute_path(&tmpdir
, tmp
? tmp
: "/tmp");
385 strbuf_trim_trailing_dir_sep(&tmpdir
);
386 strbuf_addstr(&tmpdir
, "/git-difftool.XXXXXX");
387 if (!mkdtemp(tmpdir
.buf
)) {
388 ret
= error("could not create '%s'", tmpdir
.buf
);
391 strbuf_addf(&ldir
, "%s/left/", tmpdir
.buf
);
392 strbuf_addf(&rdir
, "%s/right/", tmpdir
.buf
);
393 strbuf_addstr(&wtdir
, workdir
);
394 if (!wtdir
.len
|| !is_dir_sep(wtdir
.buf
[wtdir
.len
- 1]))
395 strbuf_addch(&wtdir
, '/');
396 mkdir(ldir
.buf
, 0700);
397 mkdir(rdir
.buf
, 0700);
399 memset(&lstate
, 0, sizeof(lstate
));
400 lstate
.base_dir
= lbase_dir
= xstrdup(ldir
.buf
);
401 lstate
.base_dir_len
= ldir
.len
;
403 memset(&rstate
, 0, sizeof(rstate
));
404 rstate
.base_dir
= rbase_dir
= xstrdup(rdir
.buf
);
405 rstate
.base_dir_len
= rdir
.len
;
410 wtdir_len
= wtdir
.len
;
414 child
->use_shell
= 0;
415 child
->clean_on_exit
= 1;
418 if (start_command(child
))
419 die("could not obtain raw diff");
420 fp
= xfdopen(child
->out
, "r");
422 /* Build index info for left and right sides of the diff */
424 while (!strbuf_getline_nul(&info
, fp
)) {
426 struct object_id loid
, roid
;
428 const char *src_path
, *dst_path
;
430 if (starts_with(info
.buf
, "::"))
431 die(N_("combined diff formats ('-c' and '--cc') are "
433 "directory diff mode ('-d' and '--dir-diff')."));
435 if (parse_index_info(info
.buf
, &lmode
, &rmode
, &loid
, &roid
,
438 if (strbuf_getline_nul(&lpath
, fp
))
440 src_path
= lpath
.buf
;
443 if (status
!= 'C' && status
!= 'R') {
446 if (strbuf_getline_nul(&rpath
, fp
))
448 dst_path
= rpath
.buf
;
451 if (S_ISGITLINK(lmode
) || S_ISGITLINK(rmode
)) {
453 strbuf_addf(&buf
, "Subproject commit %s",
455 add_left_or_right(&submodules
, src_path
, buf
.buf
, 0);
457 strbuf_addf(&buf
, "Subproject commit %s",
459 if (oideq(&loid
, &roid
))
460 strbuf_addstr(&buf
, "-dirty");
461 add_left_or_right(&submodules
, dst_path
, buf
.buf
, 1);
465 if (S_ISLNK(lmode
)) {
466 char *content
= get_symlink(&loid
, src_path
);
467 add_left_or_right(&symlinks2
, src_path
, content
, 0);
471 if (S_ISLNK(rmode
)) {
472 char *content
= get_symlink(&roid
, dst_path
);
473 add_left_or_right(&symlinks2
, dst_path
, content
, 1);
477 if (lmode
&& status
!= 'C') {
478 if (checkout_path(lmode
, &loid
, src_path
, &lstate
)) {
479 ret
= error("could not write '%s'", src_path
);
484 if (rmode
&& !S_ISLNK(rmode
)) {
485 struct working_tree_entry
*entry
;
487 /* Avoid duplicate working_tree entries */
488 FLEX_ALLOC_STR(entry
, path
, dst_path
);
489 hashmap_entry_init(&entry
->entry
, strhash(dst_path
));
490 if (hashmap_get(&working_tree_dups
, &entry
->entry
,
495 hashmap_add(&working_tree_dups
, &entry
->entry
);
497 if (!use_wt_file(workdir
, dst_path
, &roid
)) {
498 if (checkout_path(rmode
, &roid
, dst_path
,
500 ret
= error("could not write '%s'",
504 } else if (!is_null_oid(&roid
)) {
506 * Changes in the working tree need special
507 * treatment since they are not part of the
510 struct cache_entry
*ce2
=
511 make_cache_entry(&wtindex
, rmode
, &roid
,
514 add_index_entry(&wtindex
, ce2
,
515 ADD_CACHE_JUST_APPEND
);
517 add_path(&rdir
, rdir_len
, dst_path
);
518 if (ensure_leading_directories(rdir
.buf
)) {
519 ret
= error("could not create "
520 "directory for '%s'",
524 add_path(&wtdir
, wtdir_len
, dst_path
);
526 if (symlink(wtdir
.buf
, rdir
.buf
)) {
527 ret
= error_errno("could not symlink '%s' to '%s'", wtdir
.buf
, rdir
.buf
);
532 if (stat(wtdir
.buf
, &st
))
534 if (copy_file(rdir
.buf
, wtdir
.buf
,
536 ret
= error("could not copy '%s' to '%s'", wtdir
.buf
, rdir
.buf
);
546 if (finish_command(child
)) {
547 ret
= error("error occurred running diff --raw");
555 * Changes to submodules require special treatment.This loop writes a
556 * temporary file to both the left and right directories to show the
557 * change in the recorded SHA1 for the submodule.
559 hashmap_for_each_entry(&submodules
, &iter
, entry
,
560 entry
/* member name */) {
561 write_standin_files(entry
, &ldir
, ldir_len
, &rdir
, rdir_len
);
565 * Symbolic links require special treatment. The standard "git diff"
566 * shows only the link itself, not the contents of the link target.
567 * This loop replicates that behavior.
569 hashmap_for_each_entry(&symlinks2
, &iter
, entry
,
570 entry
/* member name */) {
572 write_standin_files(entry
, &ldir
, ldir_len
, &rdir
, rdir_len
);
575 strbuf_setlen(&ldir
, ldir_len
);
576 strbuf_setlen(&rdir
, rdir_len
);
579 strvec_push(&cmd
.args
, extcmd
);
581 strvec_push(&cmd
.args
, "difftool--helper");
583 setenv("GIT_DIFFTOOL_DIRDIFF", "true", 1);
585 strvec_pushl(&cmd
.args
, ldir
.buf
, rdir
.buf
, NULL
);
586 ret
= run_command(&cmd
);
588 /* TODO: audit for interaction with sparse-index. */
589 ensure_full_index(&wtindex
);
592 * If the diff includes working copy files and those
593 * files were modified during the diff, then the changes
594 * should be copied back to the working tree.
595 * Do not copy back files when symlinks are used and the
596 * external tool did not replace the original link with a file.
598 * These hashes are loaded lazily since they aren't needed
599 * in the common case of --symlinks and the difftool updating
600 * files through the symlink.
602 hashmap_init(&wt_modified
, path_entry_cmp
, NULL
, wtindex
.cache_nr
);
603 hashmap_init(&tmp_modified
, path_entry_cmp
, NULL
, wtindex
.cache_nr
);
605 for (i
= 0; i
< wtindex
.cache_nr
; i
++) {
606 struct hashmap_entry dummy
;
607 const char *name
= wtindex
.cache
[i
]->name
;
610 add_path(&rdir
, rdir_len
, name
);
611 if (lstat(rdir
.buf
, &st
))
614 if ((symlinks
&& S_ISLNK(st
.st_mode
)) || !S_ISREG(st
.st_mode
))
617 if (!indices_loaded
) {
618 struct lock_file lock
= LOCK_INIT
;
620 strbuf_addf(&buf
, "%s/wtindex", tmpdir
.buf
);
621 if (hold_lock_file_for_update(&lock
, buf
.buf
, 0) < 0 ||
622 write_locked_index(&wtindex
, &lock
, COMMIT_LOCK
)) {
623 ret
= error("could not write %s", buf
.buf
);
626 changed_files(&wt_modified
, buf
.buf
, workdir
);
627 strbuf_setlen(&rdir
, rdir_len
);
628 changed_files(&tmp_modified
, buf
.buf
, rdir
.buf
);
629 add_path(&rdir
, rdir_len
, name
);
633 hashmap_entry_init(&dummy
, strhash(name
));
634 if (hashmap_get(&tmp_modified
, &dummy
, name
)) {
635 add_path(&wtdir
, wtdir_len
, name
);
636 if (hashmap_get(&wt_modified
, &dummy
, name
)) {
637 warning(_("both files modified: '%s' and '%s'."),
638 wtdir
.buf
, rdir
.buf
);
639 warning(_("working tree file has been left."));
642 } else if (unlink(wtdir
.buf
) ||
643 copy_file(wtdir
.buf
, rdir
.buf
, st
.st_mode
))
644 warning_errno(_("could not copy '%s' to '%s'"),
645 rdir
.buf
, wtdir
.buf
);
650 warning(_("temporary files exist in '%s'."), tmpdir
.buf
);
651 warning(_("you may want to cleanup or recover these."));
654 remove_dir_recursively(&tmpdir
, 0);
656 warning(_("failed: %d"), ret
);
665 strbuf_release(&ldir
);
666 strbuf_release(&rdir
);
667 strbuf_release(&wtdir
);
668 strbuf_release(&buf
);
669 strbuf_release(&tmpdir
);
671 return (ret
< 0) ? 1 : ret
;
674 static int run_file_diff(int prompt
, const char *prefix
,
675 struct child_process
*child
)
677 const char *env
[] = {
678 "GIT_PAGER=", "GIT_EXTERNAL_DIFF=git-difftool--helper", NULL
,
683 env
[2] = "GIT_DIFFTOOL_PROMPT=true";
685 env
[2] = "GIT_DIFFTOOL_NO_PROMPT=true";
689 strvec_pushv(&child
->env
, env
);
691 return run_command(child
);
694 int cmd_difftool(int argc
, const char **argv
, const char *prefix
)
696 int use_gui_tool
= -1, dir_diff
= 0, prompt
= -1, symlinks
= 0,
697 tool_help
= 0, no_index
= 0;
698 static char *difftool_cmd
= NULL
, *extcmd
= NULL
;
699 struct option builtin_difftool_options
[] = {
700 OPT_BOOL('g', "gui", &use_gui_tool
,
701 N_("use `diff.guitool` instead of `diff.tool`")),
702 OPT_BOOL('d', "dir-diff", &dir_diff
,
703 N_("perform a full-directory diff")),
704 OPT_SET_INT_F('y', "no-prompt", &prompt
,
705 N_("do not prompt before launching a diff tool"),
707 OPT_SET_INT_F(0, "prompt", &prompt
, NULL
,
708 1, PARSE_OPT_NONEG
| PARSE_OPT_HIDDEN
),
709 OPT_BOOL(0, "symlinks", &symlinks
,
710 N_("use symlinks in dir-diff mode")),
711 OPT_STRING('t', "tool", &difftool_cmd
, N_("tool"),
712 N_("use the specified diff tool")),
713 OPT_BOOL(0, "tool-help", &tool_help
,
714 N_("print a list of diff tools that may be used with "
716 OPT_BOOL(0, "trust-exit-code", &trust_exit_code
,
717 N_("make 'git-difftool' exit when an invoked diff "
718 "tool returns a non-zero exit code")),
719 OPT_STRING('x', "extcmd", &extcmd
, N_("command"),
720 N_("specify a custom command for viewing diffs")),
721 OPT_BOOL(0, "no-index", &no_index
, N_("passed to `diff`")),
724 struct child_process child
= CHILD_PROCESS_INIT
;
726 git_config(difftool_config
, NULL
);
727 symlinks
= has_symlinks
;
729 argc
= parse_options(argc
, argv
, prefix
, builtin_difftool_options
,
730 builtin_difftool_usage
, PARSE_OPT_KEEP_UNKNOWN_OPT
|
731 PARSE_OPT_KEEP_DASHDASH
);
734 return print_tool_help();
736 if (!no_index
&& !startup_info
->have_repository
)
737 die(_("difftool requires worktree or --no-index"));
741 setenv(GIT_DIR_ENVIRONMENT
, absolute_path(get_git_dir()), 1);
742 setenv(GIT_WORK_TREE_ENVIRONMENT
, absolute_path(get_git_work_tree()), 1);
744 die(_("options '%s' and '%s' cannot be used together"), "--dir-diff", "--no-index");
746 die_for_incompatible_opt3(use_gui_tool
== 1, "--gui",
747 !!difftool_cmd
, "--tool",
748 !!extcmd
, "--extcmd");
751 * Explicitly specified GUI option is forwarded to git-mergetool--lib.sh;
752 * empty or unset means "use the difftool.guiDefault config or default to
755 if (use_gui_tool
== 1)
756 setenv("GIT_MERGETOOL_GUI", "true", 1);
757 else if (use_gui_tool
== 0)
758 setenv("GIT_MERGETOOL_GUI", "false", 1);
762 setenv("GIT_DIFF_TOOL", difftool_cmd
, 1);
764 die(_("no <tool> given for --tool=<tool>"));
769 setenv("GIT_DIFFTOOL_EXTCMD", extcmd
, 1);
771 die(_("no <cmd> given for --extcmd=<cmd>"));
774 setenv("GIT_DIFFTOOL_TRUST_EXIT_CODE",
775 trust_exit_code
? "true" : "false", 1);
778 * In directory diff mode, 'git-difftool--helper' is called once
779 * to compare the a / b directories. In file diff mode, 'git diff'
780 * will invoke a separate instance of 'git-difftool--helper' for
781 * each file that changed.
783 strvec_push(&child
.args
, "diff");
785 strvec_push(&child
.args
, "--no-index");
787 strvec_pushl(&child
.args
, "--raw", "--no-abbrev", "-z", NULL
);
788 strvec_pushv(&child
.args
, argv
);
791 return run_dir_diff(extcmd
, symlinks
, prefix
, &child
);
792 return run_file_diff(prompt
, prefix
, &child
);