[thirdparty/git.git] / git-mergetool--lib.sh

# git-mergetool--lib is a shell library for common merge tool functions

: ${MERGE_TOOLS_DIR=$(git --exec-path)/mergetools}

IFS='
'

mode_ok () {
	if diff_mode
	then
		can_diff
	elif merge_mode
	then
		can_merge
	else
		false
	fi
}

is_available () {
	merge_tool_path=$(translate_merge_tool_path "$1") &&
	type "$merge_tool_path" >/dev/null 2>&1
}

list_config_tools () {
	section=$1
	line_prefix=${2:-}

	git config --get-regexp $section'\..*\.cmd' |
	while read -r key value
	do
		toolname=${key#$section.}
		toolname=${toolname%.cmd}

		printf "%s%s\n" "$line_prefix" "$toolname"
	done
}

show_tool_names () {
	condition=${1:-true} per_line_prefix=${2:-} preamble=${3:-}
	not_found_msg=${4:-}
	extra_content=${5:-}

	shown_any=
	( cd "$MERGE_TOOLS_DIR" && ls ) | {
		while read toolname
		do
			if setup_tool "$toolname" 2>/dev/null &&
				(eval "$condition" "$toolname")
			then
				if test -n "$preamble"
				then
					printf "%s\n" "$preamble"
					preamble=
				fi
				shown_any=yes
				printf "%s%s\n" "$per_line_prefix" "$toolname"
			fi
		done

		if test -n "$extra_content"
		then
			if test -n "$preamble"
			then
				# Note: no '\n' here since we don't want a
				# blank line if there is no initial content.
				printf "%s" "$preamble"
				preamble=
			fi
			shown_any=yes
			printf "\n%s\n" "$extra_content"
		fi

		if test -n "$preamble" && test -n "$not_found_msg"
		then
			printf "%s\n" "$not_found_msg"
		fi

		test -n "$shown_any"
	}
}

diff_mode() {
	test "$TOOL_MODE" = diff
}

merge_mode() {
	test "$TOOL_MODE" = merge
}

translate_merge_tool_path () {
	echo "$1"
}

check_unchanged () {
	if test "$MERGED" -nt "$BACKUP"
	then
		return 0
	else
		while true
		do
			echo "$MERGED seems unchanged."
			printf "Was the merge successful [y/n]? "
			read answer || return 1
			case "$answer" in
			y*|Y*) return 0 ;;
			n*|N*) return 1 ;;
			esac
		done
	fi
}

valid_tool () {
	setup_tool "$1" && return 0
	cmd=$(get_merge_tool_cmd "$1")
	test -n "$cmd"
}

setup_user_tool () {
	merge_tool_cmd=$(get_merge_tool_cmd "$tool")
	test -n "$merge_tool_cmd" || return 1

	diff_cmd () {
		( eval $merge_tool_cmd )
	}

	merge_cmd () {
		( eval $merge_tool_cmd )
	}
}

setup_tool () {
	tool="$1"

	# Fallback definitions, to be overridden by tools.
	can_merge () {
		return 0
	}

	can_diff () {
		return 0
	}

	diff_cmd () {
		return 1
	}

	merge_cmd () {
		return 1
	}

	translate_merge_tool_path () {
		echo "$1"
	}

	# Most tools' exit codes cannot be trusted, so By default we ignore
	# their exit code and check the merged file's modification time in
	# check_unchanged() to determine whether or not the merge was
	# successful.  The return value from run_merge_cmd, by default, is
	# determined by check_unchanged().
	#
	# When a tool's exit code can be trusted then the return value from
	# run_merge_cmd is simply the tool's exit code, and check_unchanged()
	# is not called.
	#
	# The return value of exit_code_trustable() tells us whether or not we
	# can trust the tool's exit code.
	#
	# User-defined and built-in tools default to false.
	# Built-in tools advertise that their exit code is trustable by
	# redefining exit_code_trustable() to true.

	exit_code_trustable () {
		false
	}


	if ! test -f "$MERGE_TOOLS_DIR/$tool"
	then
		setup_user_tool
		return $?
	fi

	# Load the redefined functions
	. "$MERGE_TOOLS_DIR/$tool"
	# Now let the user override the default command for the tool.  If
	# they have not done so then this will return 1 which we ignore.
	setup_user_tool

	if merge_mode && ! can_merge
	then
		echo "error: '$tool' can not be used to resolve merges" >&2
		return 1
	elif diff_mode && ! can_diff
	then
		echo "error: '$tool' can only be used to resolve merges" >&2
		return 1
	fi
	return 0
}

get_merge_tool_cmd () {
	merge_tool="$1"
	if diff_mode
	then
		git config "difftool.$merge_tool.cmd" ||
		git config "mergetool.$merge_tool.cmd"
	else
		git config "mergetool.$merge_tool.cmd"
	fi
}

trust_exit_code () {
	if git config --bool "mergetool.$1.trustExitCode"
	then
		:; # OK
	elif exit_code_trustable
	then
		echo true
	else
		echo false
	fi
}


# Entry point for running tools
run_merge_tool () {
	# If GIT_PREFIX is empty then we cannot use it in tools
	# that expect to be able to chdir() to its value.
	GIT_PREFIX=${GIT_PREFIX:-.}
	export GIT_PREFIX

	merge_tool_path=$(get_merge_tool_path "$1") || exit
	base_present="$2"

	# Bring tool-specific functions into scope
	setup_tool "$1" || return 1

	if merge_mode
	then
		run_merge_cmd "$1"
	else
		run_diff_cmd "$1"
	fi
}

# Run a either a configured or built-in diff tool
run_diff_cmd () {
	diff_cmd "$1"
}

# Run a either a configured or built-in merge tool
run_merge_cmd () {
	mergetool_trust_exit_code=$(trust_exit_code "$1")
	if test "$mergetool_trust_exit_code" = "true"
	then
		merge_cmd "$1"
	else
		touch "$BACKUP"
		merge_cmd "$1"
		check_unchanged
	fi
}

list_merge_tool_candidates () {
	if merge_mode
	then
		tools="tortoisemerge"
	else
		tools="kompare"
	fi
	if test -n "$DISPLAY"
	then
		if test -n "$GNOME_DESKTOP_SESSION_ID"
		then
			tools="meld opendiff kdiff3 tkdiff xxdiff $tools"
		else
			tools="opendiff kdiff3 tkdiff xxdiff meld $tools"
		fi
		tools="$tools gvimdiff diffuse diffmerge ecmerge"
		tools="$tools p4merge araxis bc codecompare"
	fi
	case "${VISUAL:-$EDITOR}" in
	*vim*)
		tools="$tools vimdiff emerge"
		;;
	*)
		tools="$tools emerge vimdiff"
		;;
	esac
}

show_tool_help () {
	tool_opt="'git ${TOOL_MODE}tool --tool=<tool>'"

	tab='	'
	LF='
'
	any_shown=no

	cmd_name=${TOOL_MODE}tool
	config_tools=$({
		diff_mode && list_config_tools difftool "$tab$tab"
		list_config_tools mergetool "$tab$tab"
	} | sort)
	extra_content=
	if test -n "$config_tools"
	then
		extra_content="${tab}user-defined:${LF}$config_tools"
	fi

	show_tool_names 'mode_ok && is_available' "$tab$tab" \
		"$tool_opt may be set to one of the following:" \
		"No suitable tool for 'git $cmd_name --tool=<tool>' found." \
		"$extra_content" &&
		any_shown=yes

	show_tool_names 'mode_ok && ! is_available' "$tab$tab" \
		"${LF}The following tools are valid, but not currently available:" &&
		any_shown=yes

	if test "$any_shown" = yes
	then
		echo
		echo "Some of the tools listed above only work in a windowed"
		echo "environment. If run in a terminal-only session, they will fail."
	fi
	exit 0
}

guess_merge_tool () {
	list_merge_tool_candidates
	cat >&2 <<-EOF

	This message is displayed because '$TOOL_MODE.tool' is not configured.
	See 'git ${TOOL_MODE}tool --tool-help' or 'git help config' for more details.
	'git ${TOOL_MODE}tool' will now attempt to use one of the following tools:
	$tools
	EOF

	# Loop over each candidate and stop when a valid merge tool is found.
	IFS=' '
	for tool in $tools
	do
		is_available "$tool" && echo "$tool" && return 0
	done

	echo >&2 "No known ${TOOL_MODE} tool is available."
	return 1
}

get_configured_merge_tool () {
	# Diff mode first tries diff.tool and falls back to merge.tool.
	# Merge mode only checks merge.tool
	if diff_mode
	then
		merge_tool=$(git config diff.tool || git config merge.tool)
	else
		merge_tool=$(git config merge.tool)
	fi
	if test -n "$merge_tool" && ! valid_tool "$merge_tool"
	then
		echo >&2 "git config option $TOOL_MODE.tool set to unknown tool: $merge_tool"
		echo >&2 "Resetting to default..."
		return 1
	fi
	echo "$merge_tool"
}

get_merge_tool_path () {
	# A merge tool has been set, so verify that it's valid.
	merge_tool="$1"
	if ! valid_tool "$merge_tool"
	then
		echo >&2 "Unknown merge tool $merge_tool"
		exit 1
	fi
	if diff_mode
	then
		merge_tool_path=$(git config difftool."$merge_tool".path ||
				  git config mergetool."$merge_tool".path)
	else
		merge_tool_path=$(git config mergetool."$merge_tool".path)
	fi
	if test -z "$merge_tool_path"
	then
		merge_tool_path=$(translate_merge_tool_path "$merge_tool")
	fi
	if test -z "$(get_merge_tool_cmd "$merge_tool")" &&
		! type "$merge_tool_path" >/dev/null 2>&1
	then
		echo >&2 "The $TOOL_MODE tool $merge_tool is not available as"\
			 "'$merge_tool_path'"
		exit 1
	fi
	echo "$merge_tool_path"
}

get_merge_tool () {
	# Check if a merge tool has been configured
	merge_tool=$(get_configured_merge_tool)
	# Try to guess an appropriate merge tool if no tool has been set.
	if test -z "$merge_tool"
	then
		merge_tool=$(guess_merge_tool) || exit
	fi
	echo "$merge_tool"
}

mergetool_find_win32_cmd () {
	executable=$1
	sub_directory=$2

	# Use $executable if it exists in $PATH
	if type -p "$executable" >/dev/null 2>&1
	then
		printf '%s' "$executable"
		return
	fi

	# Look for executable in the typical locations
	for directory in $(env | grep -Ei '^PROGRAM(FILES(\(X86\))?|W6432)=' |
		cut -d '=' -f 2- | sort -u)
	do
		if test -n "$directory" && test -x "$directory/$sub_directory/$executable"
		then
			printf '%s' "$directory/$sub_directory/$executable"
			return
		fi
	done

	printf '%s' "$executable"
}
Commit	Line	Data
11d62145	1	# git-mergetool--lib is a shell library for common merge tool functions
f35ec546 DA	2
f35ec546 DA	3	: ${MERGE_TOOLS_DIR=$(git --exec-path)/mergetools}
073678b8	4
719518f5 DA	5	IFS='
	6	'
	7
17a1f1c5 DA	8	mode_ok () {
	9	if diff_mode
	10	then
	11	can_diff
	12	elif merge_mode
	13	then
	14	can_merge
	15	else
	16	false
	17	fi
	18	}
	19
	20	is_available () {
	21	merge_tool_path=$(translate_merge_tool_path "$1") &&
	22	type "$merge_tool_path" >/dev/null 2>&1
	23	}
	24
665682c9 JK	25	list_config_tools () {
	26	section=$1
	27	line_prefix=${2:-}
	28
	29	git config --get-regexp $section'\..*\.cmd' \|
	30	while read -r key value
	31	do
	32	toolname=${key#$section.}
	33	toolname=${toolname%.cmd}
	34
	35	printf "%s%s\n" "$line_prefix" "$toolname"
	36	done
	37	}
	38
17a1f1c5 DA	39	show_tool_names () {
	40	condition=${1:-true} per_line_prefix=${2:-} preamble=${3:-}
	41	not_found_msg=${4:-}
665682c9	42	extra_content=${5:-}
17a1f1c5 DA	43
	44	shown_any=
	45	( cd "$MERGE_TOOLS_DIR" && ls ) \| {
	46	while read toolname
	47	do
	48	if setup_tool "$toolname" 2>/dev/null &&
	49	(eval "$condition" "$toolname")
	50	then
	51	if test -n "$preamble"
	52	then
	53	printf "%s\n" "$preamble"
	54	preamble=
	55	fi
	56	shown_any=yes
	57	printf "%s%s\n" "$per_line_prefix" "$toolname"
	58	fi
	59	done
	60
665682c9 JK	61	if test -n "$extra_content"
	62	then
	63	if test -n "$preamble"
	64	then
	65	# Note: no '\n' here since we don't want a
	66	# blank line if there is no initial content.
	67	printf "%s" "$preamble"
	68	preamble=
	69	fi
	70	shown_any=yes
	71	printf "\n%s\n" "$extra_content"
	72	fi
	73
17a1f1c5 DA	74	if test -n "$preamble" && test -n "$not_found_msg"
	75	then
	76	printf "%s\n" "$not_found_msg"
	77	fi
	78
	79	test -n "$shown_any"
	80	}
	81	}
	82
21d0ba7e DA	83	diff_mode() {
	84	test "$TOOL_MODE" = diff
	85	}
	86
	87	merge_mode() {
	88	test "$TOOL_MODE" = merge
	89	}
	90
	91	translate_merge_tool_path () {
bc7a96a8	92	echo "$1"
21d0ba7e DA	93	}
	94
	95	check_unchanged () {
240dc3e8 DA	96	if test "$MERGED" -nt "$BACKUP"
240dc3e8 DA	97	then
1b6a5343	98	return 0
21d0ba7e	99	else
240dc3e8 DA	100	while true
240dc3e8 DA	101	do
21d0ba7e	102	echo "$MERGED seems unchanged."
cce076e3	103	printf "Was the merge successful [y/n]? "
e622f41d	104	read answer \|\| return 1
21d0ba7e	105	case "$answer" in
1b6a5343 DA	106	y\|Y) return 0 ;;
1b6a5343 DA	107	n\|N) return 1 ;;
21d0ba7e DA	108	esac
	109	done
	110	fi
	111	}
	112
	113	valid_tool () {
80ff2b68 DA	114	setup_tool "$1" && return 0
	115	cmd=$(get_merge_tool_cmd "$1")
	116	test -n "$cmd"
bc7a96a8 DA	117	}
bc7a96a8 DA	118
d2512fc9 JK	119	setup_user_tool () {
	120	merge_tool_cmd=$(get_merge_tool_cmd "$tool")
	121	test -n "$merge_tool_cmd" \|\| return 1
	122
	123	diff_cmd () {
	124	( eval $merge_tool_cmd )
d2512fc9 JK	125	}
	126
	127	merge_cmd () {
7c10605d	128	( eval $merge_tool_cmd )
d2512fc9 JK	129	}
	130	}
	131
bc7a96a8	132	setup_tool () {
073678b8 DA	133	tool="$1"
073678b8 DA	134
98e023de	135	# Fallback definitions, to be overridden by tools.
073678b8 DA	136	can_merge () {
	137	return 0
	138	}
	139
	140	can_diff () {
	141	return 0
	142	}
	143
	144	diff_cmd () {
1b6a5343	145	return 1
073678b8 DA	146	}
	147
	148	merge_cmd () {
1b6a5343	149	return 1
073678b8	150	}
bc7a96a8	151
073678b8 DA	152	translate_merge_tool_path () {
	153	echo "$1"
	154	}
	155
7c10605d DA	156	# Most tools' exit codes cannot be trusted, so By default we ignore
	157	# their exit code and check the merged file's modification time in
	158	# check_unchanged() to determine whether or not the merge was
	159	# successful. The return value from run_merge_cmd, by default, is
	160	# determined by check_unchanged().
	161	#
	162	# When a tool's exit code can be trusted then the return value from
	163	# run_merge_cmd is simply the tool's exit code, and check_unchanged()
	164	# is not called.
	165	#
	166	# The return value of exit_code_trustable() tells us whether or not we
	167	# can trust the tool's exit code.
	168	#
	169	# User-defined and built-in tools default to false.
	170	# Built-in tools advertise that their exit code is trustable by
	171	# redefining exit_code_trustable() to true.
	172
	173	exit_code_trustable () {
	174	false
	175	}
	176
	177
073678b8	178	if ! test -f "$MERGE_TOOLS_DIR/$tool"
bc7a96a8	179	then
d2512fc9 JK	180	setup_user_tool
d2512fc9 JK	181	return $?
bc7a96a8 DA	182	fi
	183
	184	# Load the redefined functions
073678b8	185	. "$MERGE_TOOLS_DIR/$tool"
d2512fc9 JK	186	# Now let the user override the default command for the tool. If
	187	# they have not done so then this will return 1 which we ignore.
	188	setup_user_tool
bc7a96a8 DA	189
	190	if merge_mode && ! can_merge
	191	then
	192	echo "error: '$tool' can not be used to resolve merges" >&2
62957bea	193	return 1
bc7a96a8 DA	194	elif diff_mode && ! can_diff
	195	then
	196	echo "error: '$tool' can only be used to resolve merges" >&2
62957bea	197	return 1
bc7a96a8 DA	198	fi
bc7a96a8 DA	199	return 0
21d0ba7e DA	200	}
	201
	202	get_merge_tool_cmd () {
bc7a96a8	203	merge_tool="$1"
240dc3e8 DA	204	if diff_mode
240dc3e8 DA	205	then
80ff2b68 DA	206	git config "difftool.$merge_tool.cmd" \|\|
80ff2b68 DA	207	git config "mergetool.$merge_tool.cmd"
47d65924	208	else
80ff2b68	209	git config "mergetool.$merge_tool.cmd"
47d65924	210	fi
21d0ba7e DA	211	}
21d0ba7e DA	212
7c10605d DA	213	trust_exit_code () {
	214	if git config --bool "mergetool.$1.trustExitCode"
	215	then
	216	:; # OK
	217	elif exit_code_trustable
	218	then
	219	echo true
	220	else
	221	echo false
	222	fi
	223	}
	224
	225
bc7a96a8	226	# Entry point for running tools
21d0ba7e	227	run_merge_tool () {
f9ad901f DA	228	# If GIT_PREFIX is empty then we cannot use it in tools
	229	# that expect to be able to chdir() to its value.
	230	GIT_PREFIX=${GIT_PREFIX:-.}
	231	export GIT_PREFIX
	232
80ff2b68	233	merge_tool_path=$(get_merge_tool_path "$1") \|\| exit
21d0ba7e	234	base_present="$2"
21d0ba7e	235
bc7a96a8	236	# Bring tool-specific functions into scope
d2512fc9	237	setup_tool "$1" \|\| return 1
bc7a96a8 DA	238
	239	if merge_mode
	240	then
a427ef7a	241	run_merge_cmd "$1"
bc7a96a8	242	else
a427ef7a	243	run_diff_cmd "$1"
bc7a96a8	244	fi
21d0ba7e DA	245	}
21d0ba7e DA	246
a427ef7a DA	247	# Run a either a configured or built-in diff tool
a427ef7a DA	248	run_diff_cmd () {
d2512fc9	249	diff_cmd "$1"
a427ef7a DA	250	}
	251
	252	# Run a either a configured or built-in merge tool
	253	run_merge_cmd () {
7c10605d DA	254	mergetool_trust_exit_code=$(trust_exit_code "$1")
	255	if test "$mergetool_trust_exit_code" = "true"
	256	then
	257	merge_cmd "$1"
	258	else
	259	touch "$BACKUP"
	260	merge_cmd "$1"
	261	check_unchanged
	262	fi
a427ef7a DA	263	}
a427ef7a DA	264
109859e2	265	list_merge_tool_candidates () {
240dc3e8 DA	266	if merge_mode
240dc3e8 DA	267	then
21d0ba7e DA	268	tools="tortoisemerge"
	269	else
	270	tools="kompare"
	271	fi
240dc3e8 DA	272	if test -n "$DISPLAY"
	273	then
	274	if test -n "$GNOME_DESKTOP_SESSION_ID"
	275	then
21d0ba7e DA	276	tools="meld opendiff kdiff3 tkdiff xxdiff $tools"
	277	else
	278	tools="opendiff kdiff3 tkdiff xxdiff meld $tools"
	279	fi
c5f424fd	280	tools="$tools gvimdiff diffuse diffmerge ecmerge"
f13f9b0e	281	tools="$tools p4merge araxis bc codecompare"
21d0ba7e	282	fi
7b104229 RS	283	case "${VISUAL:-$EDITOR}" in
7b104229 RS	284	vim)
21d0ba7e	285	tools="$tools vimdiff emerge"
7b104229 RS	286	;;
7b104229 RS	287	*)
21d0ba7e	288	tools="$tools emerge vimdiff"
7b104229 RS	289	;;
7b104229 RS	290	esac
109859e2 JH	291	}
109859e2 JH	292
4a8273a3	293	show_tool_help () {
2b7ca916	294	tool_opt="'git ${TOOL_MODE}tool --tool=<tool>'"
88d3406a	295
17a1f1c5 DA	296	tab=' '
	297	LF='
	298	'
	299	any_shown=no
62b6f7e0 JK	300
62b6f7e0 JK	301	cmd_name=${TOOL_MODE}tool
665682c9 JK	302	config_tools=$({
	303	diff_mode && list_config_tools difftool "$tab$tab"
	304	list_config_tools mergetool "$tab$tab"
	305	} \| sort)
	306	extra_content=
	307	if test -n "$config_tools"
	308	then
	309	extra_content="${tab}user-defined:${LF}$config_tools"
	310	fi
	311
17a1f1c5 DA	312	show_tool_names 'mode_ok && is_available' "$tab$tab" \
17a1f1c5 DA	313	"$tool_opt may be set to one of the following:" \
665682c9 JK	314	"No suitable tool for 'git $cmd_name --tool=<tool>' found." \
665682c9 JK	315	"$extra_content" &&
17a1f1c5 DA	316	any_shown=yes
	317
	318	show_tool_names 'mode_ok && ! is_available' "$tab$tab" \
	319	"${LF}The following tools are valid, but not currently available:" &&
	320	any_shown=yes
	321
	322	if test "$any_shown" = yes
4a8273a3 JK	323	then
	324	echo
	325	echo "Some of the tools listed above only work in a windowed"
	326	echo "environment. If run in a terminal-only session, they will fail."
	327	fi
	328	exit 0
	329	}
	330
109859e2 JH	331	guess_merge_tool () {
109859e2 JH	332	list_merge_tool_candidates
5338a6a9 DA	333	cat >&2 <<-EOF
	334
	335	This message is displayed because '$TOOL_MODE.tool' is not configured.
	336	See 'git ${TOOL_MODE}tool --tool-help' or 'git help config' for more details.
	337	'git ${TOOL_MODE}tool' will now attempt to use one of the following tools:
	338	$tools
	339	EOF
21d0ba7e DA	340
21d0ba7e DA	341	# Loop over each candidate and stop when a valid merge tool is found.
f67986b9	342	IFS=' '
17a1f1c5	343	for tool in $tools
21d0ba7e	344	do
17a1f1c5	345	is_available "$tool" && echo "$tool" && return 0
21d0ba7e DA	346	done
21d0ba7e DA	347
17a1f1c5	348	echo >&2 "No known ${TOOL_MODE} tool is available."
47d65924	349	return 1
21d0ba7e DA	350	}
	351
	352	get_configured_merge_tool () {
	353	# Diff mode first tries diff.tool and falls back to merge.tool.
	354	# Merge mode only checks merge.tool
240dc3e8 DA	355	if diff_mode
240dc3e8 DA	356	then
47d65924 DA	357	merge_tool=$(git config diff.tool \|\| git config merge.tool)
	358	else
	359	merge_tool=$(git config merge.tool)
21d0ba7e	360	fi
240dc3e8 DA	361	if test -n "$merge_tool" && ! valid_tool "$merge_tool"
240dc3e8 DA	362	then
21d0ba7e DA	363	echo >&2 "git config option $TOOL_MODE.tool set to unknown tool: $merge_tool"
	364	echo >&2 "Resetting to default..."
	365	return 1
	366	fi
47d65924	367	echo "$merge_tool"
21d0ba7e DA	368	}
	369
	370	get_merge_tool_path () {
	371	# A merge tool has been set, so verify that it's valid.
bc7a96a8	372	merge_tool="$1"
240dc3e8 DA	373	if ! valid_tool "$merge_tool"
240dc3e8 DA	374	then
21d0ba7e DA	375	echo >&2 "Unknown merge tool $merge_tool"
	376	exit 1
	377	fi
240dc3e8 DA	378	if diff_mode
240dc3e8 DA	379	then
47d65924	380	merge_tool_path=$(git config difftool."$merge_tool".path \|\|
285c6cbf	381	git config mergetool."$merge_tool".path)
47d65924 DA	382	else
47d65924 DA	383	merge_tool_path=$(git config mergetool."$merge_tool".path)
21d0ba7e	384	fi
240dc3e8 DA	385	if test -z "$merge_tool_path"
240dc3e8 DA	386	then
80ff2b68	387	merge_tool_path=$(translate_merge_tool_path "$merge_tool")
21d0ba7e	388	fi
47d65924	389	if test -z "$(get_merge_tool_cmd "$merge_tool")" &&
240dc3e8 DA	390	! type "$merge_tool_path" >/dev/null 2>&1
240dc3e8 DA	391	then
47d65924	392	echo >&2 "The $TOOL_MODE tool $merge_tool is not available as"\
285c6cbf	393	"'$merge_tool_path'"
21d0ba7e DA	394	exit 1
	395	fi
	396	echo "$merge_tool_path"
	397	}
	398
	399	get_merge_tool () {
21d0ba7e	400	# Check if a merge tool has been configured
80ff2b68	401	merge_tool=$(get_configured_merge_tool)
21d0ba7e	402	# Try to guess an appropriate merge tool if no tool has been set.
240dc3e8 DA	403	if test -z "$merge_tool"
240dc3e8 DA	404	then
80ff2b68	405	merge_tool=$(guess_merge_tool) \|\| exit
21d0ba7e DA	406	fi
	407	echo "$merge_tool"
	408	}
e36d7167 JN	409
	410	mergetool_find_win32_cmd () {
	411	executable=$1
	412	sub_directory=$2
	413
	414	# Use $executable if it exists in $PATH
	415	if type -p "$executable" >/dev/null 2>&1
	416	then
	417	printf '%s' "$executable"
	418	return
	419	fi
	420
	421	# Look for executable in the typical locations
	422	for directory in $(env \| grep -Ei '^PROGRAM(FILES(\(X86\))?\|W6432)=' \|
	423	cut -d '=' -f 2- \| sort -u)
	424	do
	425	if test -n "$directory" && test -x "$directory/$sub_directory/$executable"
	426	then
	427	printf '%s' "$directory/$sub_directory/$executable"
	428	return
	429	fi
	430	done
	431
	432	printf '%s' "$executable"
	433	}