From: Junio C Hamano <gitster@pobox.com>
Date: Wed, 28 Dec 2011 19:42:46 +0000 (-0800)
Subject: Merge branch 'jk/maint-strbuf-missing-init' into maint
X-Git-Tag: v1.7.8.2~5
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/b42e81afe2d98faee7728ef02a558847fd08cf90?ds=inline;hp=-c

Merge branch 'jk/maint-strbuf-missing-init' into maint

* jk/maint-strbuf-missing-init:
commit, merge: initialize static strbuf
---

b42e81afe2d98faee7728ef02a558847fd08cf90
diff --combined builtin/commit.c
index b02e2c4e89,564042de39..d8d6dd5eaa
--- a/builtin/commit.c
+++ b/builtin/commit.c
@@@ -25,7 -25,6 +25,7 @@@
  #include "rerere.h"
  #include "unpack-trees.h"
  #include "quote.h"
 +#include "submodule.h"
  
  static const char * const builtin_commit_usage[] = {
  	"git commit [options] [--] <filepattern>...",
@@@ -38,53 -37,36 +38,53 @@@ static const char * const builtin_statu
  };
  
  static const char implicit_ident_advice[] =
 -"Your name and email address were configured automatically based\n"
 +N_("Your name and email address were configured automatically based\n"
  "on your username and hostname. Please check that they are accurate.\n"
  "You can suppress this message by setting them explicitly:\n"
  "\n"
 -"    git config --global user.name Your Name\n"
 +"    git config --global user.name \"Your Name\"\n"
  "    git config --global user.email you@example.com\n"
  "\n"
 -"If the identity used for this commit is wrong, you can fix it with:\n"
 +"After doing this, you may fix the identity used for this commit with:\n"
  "\n"
 -"    git commit --amend --author='Your Name <you@example.com>'\n";
 +"    git commit --amend --reset-author\n");
  
 -static unsigned char head_sha1[20];
 +static const char empty_amend_advice[] =
 +N_("You asked to amend the most recent commit, but doing so would make\n"
 +"it empty. You can repeat your command with --allow-empty, or you can\n"
 +"remove the commit entirely with \"git reset HEAD^\".\n");
  
 -static char *use_message_buffer;
 +static const char empty_cherry_pick_advice[] =
 +N_("The previous cherry-pick is now empty, possibly due to conflict resolution.\n"
 +"If you wish to commit it anyway, use:\n"
 +"\n"
 +"    git commit --allow-empty\n"
 +"\n"
 +"Otherwise, please use 'git reset'\n");
 +
 +static const char *use_message_buffer;
  static const char commit_editmsg[] = "COMMIT_EDITMSG";
  static struct lock_file index_lock; /* real index */
  static struct lock_file false_lock; /* used only for partial commits */
  static enum {
  	COMMIT_AS_IS = 1,
  	COMMIT_NORMAL,
 -	COMMIT_PARTIAL,
 +	COMMIT_PARTIAL
  } commit_style;
  
  static const char *logfile, *force_author;
  static const char *template_file;
 +/*
 + * The _message variables are commit names from which to take
 + * the commit message and/or authorship.
 + */
 +static const char *author_message, *author_message_buffer;
  static char *edit_message, *use_message;
 -static char *author_name, *author_email, *author_date;
 -static int all, edit_flag, also, interactive, only, amend, signoff;
 +static char *fixup_message, *squash_message;
 +static int all, edit_flag, also, interactive, patch_interactive, only, amend, signoff;
  static int quiet, verbose, no_verify, allow_empty, dry_run, renew_authorship;
 -static char *untracked_files_arg, *force_date;
 +static int no_post_rewrite, allow_empty_message;
 +static char *untracked_files_arg, *force_date, *ignore_submodule_arg;
  /*
   * The default commit message cleanup mode will remove the lines
   * beginning with # (shell comments) and leading and trailing
@@@ -95,23 -77,20 +95,23 @@@
  static enum {
  	CLEANUP_SPACE,
  	CLEANUP_NONE,
 -	CLEANUP_ALL,
 +	CLEANUP_ALL
  } cleanup_mode;
  static char *cleanup_arg;
  
 -static int use_editor = 1, initial_commit, in_merge, include_status = 1;
 +static enum commit_whence whence;
 +static int use_editor = 1, include_status = 1;
 +static int show_ignored_in_status;
  static const char *only_include_assumed;
- static struct strbuf message;
+ static struct strbuf message = STRBUF_INIT;
  
  static int null_termination;
  static enum {
  	STATUS_FORMAT_LONG,
  	STATUS_FORMAT_SHORT,
 -	STATUS_FORMAT_PORCELAIN,
 +	STATUS_FORMAT_PORCELAIN
  } status_format = STATUS_FORMAT_LONG;
 +static int status_show_branch;
  
  static int opt_parse_m(const struct option *opt, const char *arg, int unset)
  {
@@@ -126,19 -105,17 +126,19 @@@
  }
  
  static struct option builtin_commit_options[] = {
 -	OPT__QUIET(&quiet),
 -	OPT__VERBOSE(&verbose),
 +	OPT__QUIET(&quiet, "suppress summary after successful commit"),
 +	OPT__VERBOSE(&verbose, "show diff in commit message template"),
  
  	OPT_GROUP("Commit message options"),
 -	OPT_FILENAME('F', "file", &logfile, "read log from file"),
 -	OPT_STRING(0, "author", &force_author, "AUTHOR", "override author for commit"),
 -	OPT_STRING(0, "date", &force_date, "DATE", "override date for commit"),
 -	OPT_CALLBACK('m', "message", &message, "MESSAGE", "specify commit message", opt_parse_m),
 -	OPT_STRING('c', "reedit-message", &edit_message, "COMMIT", "reuse and edit message from specified commit"),
 -	OPT_STRING('C', "reuse-message", &use_message, "COMMIT", "reuse message from specified commit"),
 -	OPT_BOOLEAN(0, "reset-author", &renew_authorship, "the commit is authored by me now (used with -C-c/--amend)"),
 +	OPT_FILENAME('F', "file", &logfile, "read message from file"),
 +	OPT_STRING(0, "author", &force_author, "author", "override author for commit"),
 +	OPT_STRING(0, "date", &force_date, "date", "override date for commit"),
 +	OPT_CALLBACK('m', "message", &message, "message", "commit message", opt_parse_m),
 +	OPT_STRING('c', "reedit-message", &edit_message, "commit", "reuse and edit message from specified commit"),
 +	OPT_STRING('C', "reuse-message", &use_message, "commit", "reuse message from specified commit"),
 +	OPT_STRING(0, "fixup", &fixup_message, "commit", "use autosquash formatted message to fixup specified commit"),
 +	OPT_STRING(0, "squash", &squash_message, "commit", "use autosquash formatted message to squash specified commit"),
 +	OPT_BOOLEAN(0, "reset-author", &renew_authorship, "the commit is authored by me now (used with -C/-c/--amend)"),
  	OPT_BOOLEAN('s', "signoff", &signoff, "add Signed-off-by:"),
  	OPT_FILENAME('t', "template", &template_file, "use specified template file"),
  	OPT_BOOLEAN('e', "edit", &edit_flag, "force edit of commit"),
@@@ -150,62 -127,23 +150,62 @@@
  	OPT_BOOLEAN('a', "all", &all, "commit all changed files"),
  	OPT_BOOLEAN('i', "include", &also, "add specified files to index for commit"),
  	OPT_BOOLEAN(0, "interactive", &interactive, "interactively add files"),
 +	OPT_BOOLEAN('p', "patch", &patch_interactive, "interactively add changes"),
  	OPT_BOOLEAN('o', "only", &only, "commit only specified files"),
  	OPT_BOOLEAN('n', "no-verify", &no_verify, "bypass pre-commit hook"),
  	OPT_BOOLEAN(0, "dry-run", &dry_run, "show what would be committed"),
  	OPT_SET_INT(0, "short", &status_format, "show status concisely",
  		    STATUS_FORMAT_SHORT),
 +	OPT_BOOLEAN(0, "branch", &status_show_branch, "show branch information"),
  	OPT_SET_INT(0, "porcelain", &status_format,
 -		    "show porcelain output format", STATUS_FORMAT_PORCELAIN),
 +		    "machine-readable output", STATUS_FORMAT_PORCELAIN),
  	OPT_BOOLEAN('z', "null", &null_termination,
  		    "terminate entries with NUL"),
  	OPT_BOOLEAN(0, "amend", &amend, "amend previous commit"),
 +	OPT_BOOLEAN(0, "no-post-rewrite", &no_post_rewrite, "bypass post-rewrite hook"),
  	{ OPTION_STRING, 'u', "untracked-files", &untracked_files_arg, "mode", "show untracked files, optional modes: all, normal, no. (Default: all)", PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
 -	OPT_BOOLEAN(0, "allow-empty", &allow_empty, "ok to record an empty change"),
  	/* end commit contents options */
  
 +	{ OPTION_BOOLEAN, 0, "allow-empty", &allow_empty, NULL,
 +	  "ok to record an empty change",
 +	  PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 +	{ OPTION_BOOLEAN, 0, "allow-empty-message", &allow_empty_message, NULL,
 +	  "ok to record a change with an empty message",
 +	  PARSE_OPT_NOARG | PARSE_OPT_HIDDEN },
 +
  	OPT_END()
  };
  
 +static void determine_whence(struct wt_status *s)
 +{
 +	if (file_exists(git_path("MERGE_HEAD")))
 +		whence = FROM_MERGE;
 +	else if (file_exists(git_path("CHERRY_PICK_HEAD")))
 +		whence = FROM_CHERRY_PICK;
 +	else
 +		whence = FROM_COMMIT;
 +	if (s)
 +		s->whence = whence;
 +}
 +
 +static const char *whence_s(void)
 +{
 +	char *s = "";
 +
 +	switch (whence) {
 +	case FROM_COMMIT:
 +		break;
 +	case FROM_MERGE:
 +		s = "merge";
 +		break;
 +	case FROM_CHERRY_PICK:
 +		s = "cherry-pick";
 +		break;
 +	}
 +
 +	return s;
 +}
 +
  static void rollback_index_files(void)
  {
  	switch (commit_style) {
@@@ -254,11 -192,8 +254,11 @@@ static int list_paths(struct string_lis
  		;
  	m = xcalloc(1, i);
  
 -	if (with_tree)
 -		overlay_tree_on_cache(with_tree, prefix);
 +	if (with_tree) {
 +		char *max_prefix = common_prefix(pattern);
 +		overlay_tree_on_cache(with_tree, max_prefix ? max_prefix : prefix);
 +		free(max_prefix);
 +	}
  
  	for (i = 0; i < active_nr; i++) {
  		struct cache_entry *ce = active_cache[i];
@@@ -268,12 -203,12 +268,12 @@@
  			continue;
  		if (!match_pathspec(pattern, ce->name, ce_namelen(ce), 0, m))
  			continue;
 -		item = string_list_insert(ce->name, list);
 +		item = string_list_insert(list, ce->name);
  		if (ce_skip_worktree(ce))
  			item->util = item; /* better a valid pointer than a fake one */
  	}
  
 -	return report_path_error(m, pattern, prefix ? strlen(prefix) : 0);
 +	return report_path_error(m, pattern, prefix);
  }
  
  static void add_remove_files(struct string_list *list)
@@@ -289,19 -224,19 +289,19 @@@
  
  		if (!lstat(p->string, &st)) {
  			if (add_to_cache(p->string, &st, 0))
 -				die("updating files failed");
 +				die(_("updating files failed"));
  		} else
  			remove_file_from_cache(p->string);
  	}
  }
  
 -static void create_base_index(void)
 +static void create_base_index(const struct commit *current_head)
  {
  	struct tree *tree;
  	struct unpack_trees_options opts;
  	struct tree_desc t;
  
 -	if (initial_commit) {
 +	if (!current_head) {
  		discard_cache();
  		return;
  	}
@@@ -314,9 -249,9 +314,9 @@@
  	opts.dst_index = &the_index;
  
  	opts.fn = oneway_merge;
 -	tree = parse_tree_indirect(head_sha1);
 +	tree = parse_tree_indirect(current_head->object.sha1);
  	if (!tree)
 -		die("failed to unpack HEAD tree object");
 +		die(_("failed to unpack HEAD tree object"));
  	parse_tree(tree);
  	init_tree_desc(&t, tree->buffer, tree->size);
  	if (unpack_trees(1, &t, &opts))
@@@ -333,50 -268,29 +333,50 @@@ static void refresh_cache_or_die(int re
  		die_resolve_conflict("commit");
  }
  
 -static char *prepare_index(int argc, const char **argv, const char *prefix, int is_status)
 +static char *prepare_index(int argc, const char **argv, const char *prefix,
 +			   const struct commit *current_head, int is_status)
  {
  	int fd;
  	struct string_list partial;
  	const char **pathspec = NULL;
 +	char *old_index_env = NULL;
  	int refresh_flags = REFRESH_QUIET;
  
  	if (is_status)
  		refresh_flags |= REFRESH_UNMERGED;
 -	if (interactive) {
 -		if (interactive_add(argc, argv, prefix) != 0)
 -			die("interactive add failed");
 -		if (read_cache_preload(NULL) < 0)
 -			die("index file corrupt");
 -		commit_style = COMMIT_AS_IS;
 -		return get_index_file();
 -	}
  
  	if (*argv)
  		pathspec = get_pathspec(prefix, argv);
  
  	if (read_cache_preload(pathspec) < 0)
 -		die("index file corrupt");
 +		die(_("index file corrupt"));
 +
 +	if (interactive) {
 +		fd = hold_locked_index(&index_lock, 1);
 +
 +		refresh_cache_or_die(refresh_flags);
 +
 +		if (write_cache(fd, active_cache, active_nr) ||
 +		    close_lock_file(&index_lock))
 +			die(_("unable to create temporary index"));
 +
 +		old_index_env = getenv(INDEX_ENVIRONMENT);
 +		setenv(INDEX_ENVIRONMENT, index_lock.filename, 1);
 +
 +		if (interactive_add(argc, argv, prefix, patch_interactive) != 0)
 +			die(_("interactive add failed"));
 +
 +		if (old_index_env && *old_index_env)
 +			setenv(INDEX_ENVIRONMENT, old_index_env, 1);
 +		else
 +			unsetenv(INDEX_ENVIRONMENT);
 +
 +		discard_cache();
 +		read_cache_from(index_lock.filename);
 +
 +		commit_style = COMMIT_NORMAL;
 +		return index_lock.filename;
 +	}
  
  	/*
  	 * Non partial, non as-is commit.
@@@ -391,12 -305,12 +391,12 @@@
  	 * (B) on failure, rollback the real index.
  	 */
  	if (all || (also && pathspec && *pathspec)) {
 -		int fd = hold_locked_index(&index_lock, 1);
 +		fd = hold_locked_index(&index_lock, 1);
  		add_files_to_cache(also ? prefix : NULL, pathspec, 0);
  		refresh_cache_or_die(refresh_flags);
  		if (write_cache(fd, active_cache, active_nr) ||
  		    close_lock_file(&index_lock))
 -			die("unable to write new_index file");
 +			die(_("unable to write new_index file"));
  		commit_style = COMMIT_NORMAL;
  		return index_lock.filename;
  	}
@@@ -406,20 -320,16 +406,20 @@@
  	 *
  	 * (1) return the name of the real index file.
  	 *
 -	 * The caller should run hooks on the real index, and run
 -	 * hooks on the real index, and create commit from the_index.
 +	 * The caller should run hooks on the real index,
 +	 * and create commit from the_index.
  	 * We still need to refresh the index here.
  	 */
  	if (!pathspec || !*pathspec) {
  		fd = hold_locked_index(&index_lock, 1);
  		refresh_cache_or_die(refresh_flags);
 -		if (write_cache(fd, active_cache, active_nr) ||
 -		    commit_locked_index(&index_lock))
 -			die("unable to write new_index file");
 +		if (active_cache_changed) {
 +			if (write_cache(fd, active_cache, active_nr) ||
 +			    commit_locked_index(&index_lock))
 +				die(_("unable to write new_index file"));
 +		} else {
 +			rollback_lock_file(&index_lock);
 +		}
  		commit_style = COMMIT_AS_IS;
  		return get_index_file();
  	}
@@@ -445,37 -355,37 +445,37 @@@
  	 */
  	commit_style = COMMIT_PARTIAL;
  
 -	if (in_merge)
 -		die("cannot do a partial commit during a merge.");
 +	if (whence != FROM_COMMIT)
 +		die(_("cannot do a partial commit during a %s."), whence_s());
  
  	memset(&partial, 0, sizeof(partial));
  	partial.strdup_strings = 1;
 -	if (list_paths(&partial, initial_commit ? NULL : "HEAD", prefix, pathspec))
 +	if (list_paths(&partial, !current_head ? NULL : "HEAD", prefix, pathspec))
  		exit(1);
  
  	discard_cache();
  	if (read_cache() < 0)
 -		die("cannot read the index");
 +		die(_("cannot read the index"));
  
  	fd = hold_locked_index(&index_lock, 1);
  	add_remove_files(&partial);
  	refresh_cache(REFRESH_QUIET);
  	if (write_cache(fd, active_cache, active_nr) ||
  	    close_lock_file(&index_lock))
 -		die("unable to write new_index file");
 +		die(_("unable to write new_index file"));
  
  	fd = hold_lock_file_for_update(&false_lock,
  				       git_path("next-index-%"PRIuMAX,
  						(uintmax_t) getpid()),
  				       LOCK_DIE_ON_ERROR);
  
 -	create_base_index();
 +	create_base_index(current_head);
  	add_remove_files(&partial);
  	refresh_cache(REFRESH_QUIET);
  
  	if (write_cache(fd, active_cache, active_nr) ||
  	    close_lock_file(&false_lock))
 -		die("unable to write temporary index file");
 +		die(_("unable to write temporary index file"));
  
  	discard_cache();
  	read_cache_from(false_lock.filename);
@@@ -505,7 -415,7 +505,7 @@@ static int run_status(FILE *fp, const c
  
  	switch (status_format) {
  	case STATUS_FORMAT_SHORT:
 -		wt_shortstatus_print(s, null_termination);
 +		wt_shortstatus_print(s, null_termination, status_show_branch);
  		break;
  	case STATUS_FORMAT_PORCELAIN:
  		wt_porcelain_print(s, null_termination);
@@@ -518,14 -428,17 +518,14 @@@
  	return s->commitable;
  }
  
 -static int is_a_merge(const unsigned char *sha1)
 +static int is_a_merge(const struct commit *current_head)
  {
 -	struct commit *commit = lookup_commit(sha1);
 -	if (!commit || parse_commit(commit))
 -		die("could not parse HEAD commit");
 -	return !!(commit->parents && commit->parents->next);
 +	return !!(current_head->parents && current_head->parents->next);
  }
  
  static const char sign_off_header[] = "Signed-off-by: ";
  
 -static void determine_author_info(void)
 +static void determine_author_info(struct strbuf *author_ident)
  {
  	char *name, *email, *date;
  
@@@ -533,28 -446,22 +533,28 @@@
  	email = getenv("GIT_AUTHOR_EMAIL");
  	date = getenv("GIT_AUTHOR_DATE");
  
 -	if (use_message && !renew_authorship) {
 +	if (author_message) {
  		const char *a, *lb, *rb, *eol;
  
 -		a = strstr(use_message_buffer, "\nauthor ");
 +		a = strstr(author_message_buffer, "\nauthor ");
  		if (!a)
 -			die("invalid commit: %s", use_message);
 +			die(_("invalid commit: %s"), author_message);
  
 -		lb = strstr(a + 8, " <");
 -		rb = strstr(a + 8, "> ");
 -		eol = strchr(a + 8, '\n');
 -		if (!lb || !rb || !eol)
 -			die("invalid commit: %s", use_message);
 +		lb = strchrnul(a + strlen("\nauthor "), '<');
 +		rb = strchrnul(lb, '>');
 +		eol = strchrnul(rb, '\n');
 +		if (!*lb || !*rb || !*eol)
 +			die(_("invalid commit: %s"), author_message);
  
 -		name = xstrndup(a + 8, lb - (a + 8));
 -		email = xstrndup(lb + 2, rb - (lb + 2));
 -		date = xstrndup(rb + 2, eol - (rb + 2));
 +		if (lb == a + strlen("\nauthor "))
 +			/* \nauthor <foo@example.com> */
 +			name = xcalloc(1, 1);
 +		else
 +			name = xmemdupz(a + strlen("\nauthor "),
 +					(lb - strlen(" ") -
 +					 (a + strlen("\nauthor "))));
 +		email = xmemdupz(lb + strlen("<"), rb - (lb + strlen("<")));
 +		date = xmemdupz(rb + strlen("> "), eol - (rb + strlen("> ")));
  	}
  
  	if (force_author) {
@@@ -562,15 -469,17 +562,15 @@@
  		const char *rb = strchr(force_author, '>');
  
  		if (!lb || !rb)
 -			die("malformed --author parameter");
 +			die(_("malformed --author parameter"));
  		name = xstrndup(force_author, lb - force_author);
  		email = xstrndup(lb + 2, rb - (lb + 2));
  	}
  
  	if (force_date)
  		date = force_date;
 -
 -	author_name = name;
 -	author_email = email;
 -	author_date = date;
 +	strbuf_addstr(author_ident, fmt_ident(name, email, date,
 +					      IDENT_ERROR_ON_NO_NAME));
  }
  
  static int ends_rfc2822_footer(struct strbuf *sb)
@@@ -614,124 -523,68 +614,124 @@@
  	return 1;
  }
  
 +static char *cut_ident_timestamp_part(char *string)
 +{
 +	char *ket = strrchr(string, '>');
 +	if (!ket || ket[1] != ' ')
 +		die(_("Malformed ident string: '%s'"), string);
 +	*++ket = '\0';
 +	return ket;
 +}
 +
  static int prepare_to_commit(const char *index_file, const char *prefix,
 -			     struct wt_status *s)
 +			     struct commit *current_head,
 +			     struct wt_status *s,
 +			     struct strbuf *author_ident)
  {
  	struct stat statbuf;
 +	struct strbuf committer_ident = STRBUF_INIT;
  	int commitable, saved_color_setting;
  	struct strbuf sb = STRBUF_INIT;
  	char *buffer;
 -	FILE *fp;
  	const char *hook_arg1 = NULL;
  	const char *hook_arg2 = NULL;
  	int ident_shown = 0;
 +	int clean_message_contents = (cleanup_mode != CLEANUP_NONE);
  
  	if (!no_verify && run_hook(index_file, "pre-commit", NULL))
  		return 0;
  
 +	if (squash_message) {
 +		/*
 +		 * Insert the proper subject line before other commit
 +		 * message options add their content.
 +		 */
 +		if (use_message && !strcmp(use_message, squash_message))
 +			strbuf_addstr(&sb, "squash! ");
 +		else {
 +			struct pretty_print_context ctx = {0};
 +			struct commit *c;
 +			c = lookup_commit_reference_by_name(squash_message);
 +			if (!c)
 +				die(_("could not lookup commit %s"), squash_message);
 +			ctx.output_encoding = get_commit_output_encoding();
 +			format_commit_message(c, "squash! %s\n\n", &sb,
 +					      &ctx);
 +		}
 +	}
 +
  	if (message.len) {
  		strbuf_addbuf(&sb, &message);
  		hook_arg1 = "message";
  	} else if (logfile && !strcmp(logfile, "-")) {
  		if (isatty(0))
 -			fprintf(stderr, "(reading log message from standard input)\n");
 +			fprintf(stderr, _("(reading log message from standard input)\n"));
  		if (strbuf_read(&sb, 0, 0) < 0)
 -			die_errno("could not read log from standard input");
 +			die_errno(_("could not read log from standard input"));
  		hook_arg1 = "message";
  	} else if (logfile) {
  		if (strbuf_read_file(&sb, logfile, 0) < 0)
 -			die_errno("could not read log file '%s'",
 +			die_errno(_("could not read log file '%s'"),
  				  logfile);
  		hook_arg1 = "message";
  	} else if (use_message) {
  		buffer = strstr(use_message_buffer, "\n\n");
  		if (!buffer || buffer[2] == '\0')
 -			die("commit has empty message");
 +			die(_("commit has empty message"));
  		strbuf_add(&sb, buffer + 2, strlen(buffer + 2));
  		hook_arg1 = "commit";
  		hook_arg2 = use_message;
 +	} else if (fixup_message) {
 +		struct pretty_print_context ctx = {0};
 +		struct commit *commit;
 +		commit = lookup_commit_reference_by_name(fixup_message);
 +		if (!commit)
 +			die(_("could not lookup commit %s"), fixup_message);
 +		ctx.output_encoding = get_commit_output_encoding();
 +		format_commit_message(commit, "fixup! %s\n\n",
 +				      &sb, &ctx);
 +		hook_arg1 = "message";
  	} else if (!stat(git_path("MERGE_MSG"), &statbuf)) {
  		if (strbuf_read_file(&sb, git_path("MERGE_MSG"), 0) < 0)
 -			die_errno("could not read MERGE_MSG");
 +			die_errno(_("could not read MERGE_MSG"));
  		hook_arg1 = "merge";
  	} else if (!stat(git_path("SQUASH_MSG"), &statbuf)) {
  		if (strbuf_read_file(&sb, git_path("SQUASH_MSG"), 0) < 0)
 -			die_errno("could not read SQUASH_MSG");
 +			die_errno(_("could not read SQUASH_MSG"));
  		hook_arg1 = "squash";
 -	} else if (template_file && !stat(template_file, &statbuf)) {
 +	} else if (template_file) {
  		if (strbuf_read_file(&sb, template_file, 0) < 0)
 -			die_errno("could not read '%s'", template_file);
 +			die_errno(_("could not read '%s'"), template_file);
  		hook_arg1 = "template";
 +		clean_message_contents = 0;
  	}
  
  	/*
 -	 * This final case does not modify the template message,
 -	 * it just sets the argument to the prepare-commit-msg hook.
 +	 * The remaining cases don't modify the template message, but
 +	 * just set the argument(s) to the prepare-commit-msg hook.
  	 */
 -	else if (in_merge)
 +	else if (whence == FROM_MERGE)
  		hook_arg1 = "merge";
 +	else if (whence == FROM_CHERRY_PICK) {
 +		hook_arg1 = "commit";
 +		hook_arg2 = "CHERRY_PICK_HEAD";
 +	}
  
 -	fp = fopen(git_path(commit_editmsg), "w");
 -	if (fp == NULL)
 -		die_errno("could not open '%s'", git_path(commit_editmsg));
 +	if (squash_message) {
 +		/*
 +		 * If squash_commit was used for the commit subject,
 +		 * then we're possibly hijacking other commit log options.
 +		 * Reset the hook args to tell the real story.
 +		 */
 +		hook_arg1 = "message";
 +		hook_arg2 = "";
 +	}
  
 -	if (cleanup_mode != CLEANUP_NONE)
 +	s->fp = fopen(git_path(commit_editmsg), "w");
 +	if (s->fp == NULL)
 +		die_errno(_("could not open '%s'"), git_path(commit_editmsg));
 +
 +	if (clean_message_contents)
  		stripspace(&sb, 0);
  
  	if (signoff) {
@@@ -752,81 -605,77 +752,81 @@@
  		strbuf_release(&sob);
  	}
  
 -	if (fwrite(sb.buf, 1, sb.len, fp) < sb.len)
 -		die_errno("could not write commit template");
 +	if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)
 +		die_errno(_("could not write commit template"));
  
  	strbuf_release(&sb);
  
 -	determine_author_info();
 +	/* This checks and barfs if author is badly specified */
 +	determine_author_info(author_ident);
  
  	/* This checks if committer ident is explicitly given */
 -	git_committer_info(0);
 +	strbuf_addstr(&committer_ident, git_committer_info(0));
  	if (use_editor && include_status) {
 -		char *author_ident;
 -		const char *committer_ident;
 -
 -		if (in_merge)
 -			fprintf(fp,
 -				"#\n"
 -				"# It looks like you may be committing a MERGE.\n"
 -				"# If this is not correct, please remove the file\n"
 -				"#	%s\n"
 -				"# and try again.\n"
 -				"#\n",
 -				git_path("MERGE_HEAD"));
 -
 -		fprintf(fp,
 -			"\n"
 -			"# Please enter the commit message for your changes.");
 +		char *ai_tmp, *ci_tmp;
 +		if (whence != FROM_COMMIT)
 +			status_printf_ln(s, GIT_COLOR_NORMAL,
 +				_("\n"
 +				"It looks like you may be committing a %s.\n"
 +				"If this is not correct, please remove the file\n"
 +				"	%s\n"
 +				"and try again.\n"
 +				""),
 +				whence_s(),
 +				git_path(whence == FROM_MERGE
 +					 ? "MERGE_HEAD"
 +					 : "CHERRY_PICK_HEAD"));
 +
 +		fprintf(s->fp, "\n");
 +		status_printf(s, GIT_COLOR_NORMAL,
 +			_("Please enter the commit message for your changes."));
  		if (cleanup_mode == CLEANUP_ALL)
 -			fprintf(fp,
 -				" Lines starting\n"
 -				"# with '#' will be ignored, and an empty"
 -				" message aborts the commit.\n");
 +			status_printf_more(s, GIT_COLOR_NORMAL,
 +				_(" Lines starting\n"
 +				"with '#' will be ignored, and an empty"
 +				" message aborts the commit.\n"));
  		else /* CLEANUP_SPACE, that is. */
 -			fprintf(fp,
 -				" Lines starting\n"
 -				"# with '#' will be kept; you may remove them"
 +			status_printf_more(s, GIT_COLOR_NORMAL,
 +				_(" Lines starting\n"
 +				"with '#' will be kept; you may remove them"
  				" yourself if you want to.\n"
 -				"# An empty message aborts the commit.\n");
 +				"An empty message aborts the commit.\n"));
  		if (only_include_assumed)
 -			fprintf(fp, "# %s\n", only_include_assumed);
 -
 -		author_ident = xstrdup(fmt_name(author_name, author_email));
 -		committer_ident = fmt_name(getenv("GIT_COMMITTER_NAME"),
 -					   getenv("GIT_COMMITTER_EMAIL"));
 -		if (strcmp(author_ident, committer_ident))
 -			fprintf(fp,
 -				"%s"
 -				"# Author:    %s\n",
 -				ident_shown++ ? "" : "#\n",
 -				author_ident);
 -		free(author_ident);
 +			status_printf_ln(s, GIT_COLOR_NORMAL,
 +					"%s", only_include_assumed);
 +
 +		ai_tmp = cut_ident_timestamp_part(author_ident->buf);
 +		ci_tmp = cut_ident_timestamp_part(committer_ident.buf);
 +		if (strcmp(author_ident->buf, committer_ident.buf))
 +			status_printf_ln(s, GIT_COLOR_NORMAL,
 +				_("%s"
 +				"Author:    %s"),
 +				ident_shown++ ? "" : "\n",
 +				author_ident->buf);
  
  		if (!user_ident_sufficiently_given())
 -			fprintf(fp,
 -				"%s"
 -				"# Committer: %s\n",
 -				ident_shown++ ? "" : "#\n",
 -				committer_ident);
 +			status_printf_ln(s, GIT_COLOR_NORMAL,
 +				_("%s"
 +				"Committer: %s"),
 +				ident_shown++ ? "" : "\n",
 +				committer_ident.buf);
  
  		if (ident_shown)
 -			fprintf(fp, "#\n");
 +			status_printf_ln(s, GIT_COLOR_NORMAL, "");
  
  		saved_color_setting = s->use_color;
  		s->use_color = 0;
 -		commitable = run_status(fp, index_file, prefix, 1, s);
 +		commitable = run_status(s->fp, index_file, prefix, 1, s);
  		s->use_color = saved_color_setting;
 +
 +		*ai_tmp = ' ';
 +		*ci_tmp = ' ';
  	} else {
  		unsigned char sha1[20];
  		const char *parent = "HEAD";
  
  		if (!active_nr && read_cache() < 0)
 -			die("Cannot read index");
 +			die(_("Cannot read index"));
  
  		if (amend)
  			parent = "HEAD^1";
@@@ -836,22 -685,12 +836,22 @@@
  		else
  			commitable = index_differs_from(parent, 0);
  	}
 +	strbuf_release(&committer_ident);
  
 -	fclose(fp);
 +	fclose(s->fp);
  
 -	if (!commitable && !in_merge && !allow_empty &&
 -	    !(amend && is_a_merge(head_sha1))) {
 +	/*
 +	 * Reject an attempt to record a non-merge empty commit without
 +	 * explicit --allow-empty. In the cherry-pick case, it may be
 +	 * empty due to conflict resolution, which the user should okay.
 +	 */
 +	if (!commitable && whence != FROM_MERGE && !allow_empty &&
 +	    !(amend && is_a_merge(current_head))) {
  		run_status(stdout, index_file, prefix, 0, s);
 +		if (amend)
 +			fputs(_(empty_amend_advice), stderr);
 +		else if (whence == FROM_CHERRY_PICK)
 +			fputs(_(empty_cherry_pick_advice), stderr);
  		return 0;
  	}
  
@@@ -866,7 -705,7 +866,7 @@@
  		active_cache_tree = cache_tree();
  	if (cache_tree_update(active_cache_tree,
  			      active_cache, active_nr, 0, 0) < 0) {
 -		error("Error building trees");
 +		error(_("Error building trees"));
  		return 0;
  	}
  
@@@ -876,12 -715,11 +876,12 @@@
  
  	if (use_editor) {
  		char index[PATH_MAX];
 -		const char *env[2] = { index, NULL };
 +		const char *env[2] = { NULL };
 +		env[0] =  index;
  		snprintf(index, sizeof(index), "GIT_INDEX_FILE=%s", index_file);
  		if (launch_editor(git_path(commit_editmsg), NULL, env)) {
  			fprintf(stderr,
 -			"Please supply the message using either -m or -F option.\n");
 +			_("Please supply the message using either -m or -F option.\n"));
  			exit(1);
  		}
  	}
@@@ -961,7 -799,7 +961,7 @@@ static const char *find_author_by_nickn
  		format_commit_message(commit, "%an <%ae>", &buf, &ctx);
  		return strbuf_detach(&buf, NULL);
  	}
 -	die("No existing author found with '%s'", name);
 +	die(_("No existing author found with '%s'"), name);
  }
  
  
@@@ -976,35 -814,12 +976,35 @@@ static void handle_untracked_files_arg(
  	else if (!strcmp(untracked_files_arg, "all"))
  		s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
  	else
 -		die("Invalid untracked files mode '%s'", untracked_files_arg);
 +		die(_("Invalid untracked files mode '%s'"), untracked_files_arg);
 +}
 +
 +static const char *read_commit_message(const char *name)
 +{
 +	const char *out_enc, *out;
 +	struct commit *commit;
 +
 +	commit = lookup_commit_reference_by_name(name);
 +	if (!commit)
 +		die(_("could not lookup commit %s"), name);
 +	out_enc = get_commit_output_encoding();
 +	out = logmsg_reencode(commit, out_enc);
 +
 +	/*
 +	 * If we failed to reencode the buffer, just copy it
 +	 * byte for byte so the user can try to fix it up.
 +	 * This also handles the case where input and output
 +	 * encodings are identical.
 +	 */
 +	if (out == NULL)
 +		out = xstrdup(commit->buffer);
 +	return out;
  }
  
  static int parse_and_validate_options(int argc, const char *argv[],
  				      const char * const usage[],
  				      const char *prefix,
 +				      struct commit *current_head,
  				      struct wt_status *s)
  {
  	int f = 0;
@@@ -1016,63 -831,86 +1016,63 @@@
  		force_author = find_author_by_nickname(force_author);
  
  	if (force_author && renew_authorship)
 -		die("Using both --reset-author and --author does not make sense");
 +		die(_("Using both --reset-author and --author does not make sense"));
  
 -	if (logfile || message.len || use_message)
 +	if (logfile || message.len || use_message || fixup_message)
  		use_editor = 0;
  	if (edit_flag)
  		use_editor = 1;
  	if (!use_editor)
  		setenv("GIT_EDITOR", ":", 1);
  
 -	if (get_sha1("HEAD", head_sha1))
 -		initial_commit = 1;
 -
  	/* Sanity check options */
 -	if (amend && initial_commit)
 -		die("You have nothing to amend.");
 -	if (amend && in_merge)
 -		die("You are in the middle of a merge -- cannot amend.");
 -
 +	if (amend && !current_head)
 +		die(_("You have nothing to amend."));
 +	if (amend && whence != FROM_COMMIT)
 +		die(_("You are in the middle of a %s -- cannot amend."), whence_s());
 +	if (fixup_message && squash_message)
 +		die(_("Options --squash and --fixup cannot be used together"));
  	if (use_message)
  		f++;
  	if (edit_message)
  		f++;
 +	if (fixup_message)
 +		f++;
  	if (logfile)
  		f++;
  	if (f > 1)
 -		die("Only one of -c/-C/-F can be used.");
 +		die(_("Only one of -c/-C/-F/--fixup can be used."));
  	if (message.len && f > 0)
 -		die("Option -m cannot be combined with -c/-C/-F.");
 +		die((_("Option -m cannot be combined with -c/-C/-F/--fixup.")));
  	if (edit_message)
  		use_message = edit_message;
 -	if (amend && !use_message)
 +	if (amend && !use_message && !fixup_message)
  		use_message = "HEAD";
 -	if (!use_message && renew_authorship)
 -		die("--reset-author can be used only with -C, -c or --amend.");
 +	if (!use_message && whence != FROM_CHERRY_PICK && renew_authorship)
 +		die(_("--reset-author can be used only with -C, -c or --amend."));
  	if (use_message) {
 -		unsigned char sha1[20];
 -		static char utf8[] = "UTF-8";
 -		const char *out_enc;
 -		char *enc, *end;
 -		struct commit *commit;
 -
 -		if (get_sha1(use_message, sha1))
 -			die("could not lookup commit %s", use_message);
 -		commit = lookup_commit_reference(sha1);
 -		if (!commit || parse_commit(commit))
 -			die("could not parse commit %s", use_message);
 -
 -		enc = strstr(commit->buffer, "\nencoding");
 -		if (enc) {
 -			end = strchr(enc + 10, '\n');
 -			enc = xstrndup(enc + 10, end - (enc + 10));
 -		} else {
 -			enc = utf8;
 +		use_message_buffer = read_commit_message(use_message);
 +		if (!renew_authorship) {
 +			author_message = use_message;
 +			author_message_buffer = use_message_buffer;
  		}
 -		out_enc = git_commit_encoding ? git_commit_encoding : utf8;
 -
 -		if (strcmp(out_enc, enc))
 -			use_message_buffer =
 -				reencode_string(commit->buffer, out_enc, enc);
 -
 -		/*
 -		 * If we failed to reencode the buffer, just copy it
 -		 * byte for byte so the user can try to fix it up.
 -		 * This also handles the case where input and output
 -		 * encodings are identical.
 -		 */
 -		if (use_message_buffer == NULL)
 -			use_message_buffer = xstrdup(commit->buffer);
 -		if (enc != utf8)
 -			free(enc);
 +	}
 +	if (whence == FROM_CHERRY_PICK && !renew_authorship) {
 +		author_message = "CHERRY_PICK_HEAD";
 +		author_message_buffer = read_commit_message(author_message);
  	}
  
 +	if (patch_interactive)
 +		interactive = 1;
 +
  	if (!!also + !!only + !!all + !!interactive > 1)
 -		die("Only one of --include/--only/--all/--interactive can be used.");
 +		die(_("Only one of --include/--only/--all/--interactive/--patch can be used."));
  	if (argc == 0 && (also || (only && !amend)))
 -		die("No paths with --include/--only does not make sense.");
 +		die(_("No paths with --include/--only does not make sense."));
  	if (argc == 0 && only && amend)
 -		only_include_assumed = "Clever... amending the last one with dirty index.";
 +		only_include_assumed = _("Clever... amending the last one with dirty index.");
  	if (argc > 0 && !also && !only)
 -		only_include_assumed = "Explicit paths specified without -i nor -o; assuming --only paths...";
 +		only_include_assumed = _("Explicit paths specified without -i nor -o; assuming --only paths...");
  	if (!cleanup_arg || !strcmp(cleanup_arg, "default"))
  		cleanup_mode = use_editor ? CLEANUP_ALL : CLEANUP_SPACE;
  	else if (!strcmp(cleanup_arg, "verbatim"))
@@@ -1082,12 -920,14 +1082,12 @@@
  	else if (!strcmp(cleanup_arg, "strip"))
  		cleanup_mode = CLEANUP_ALL;
  	else
 -		die("Invalid cleanup mode %s", cleanup_arg);
 +		die(_("Invalid cleanup mode %s"), cleanup_arg);
  
  	handle_untracked_files_arg(s);
  
  	if (all && argc > 0)
 -		die("Paths with -a does not make sense.");
 -	else if (interactive && argc > 0)
 -		die("Paths with --interactive does not make sense.");
 +		die(_("Paths with -a does not make sense."));
  
  	if (null_termination && status_format == STATUS_FORMAT_LONG)
  		status_format = STATUS_FORMAT_PORCELAIN;
@@@ -1098,12 -938,12 +1098,12 @@@
  }
  
  static int dry_run_commit(int argc, const char **argv, const char *prefix,
 -			  struct wt_status *s)
 +			  const struct commit *current_head, struct wt_status *s)
  {
  	int commitable;
  	const char *index_file;
  
 -	index_file = prepare_index(argc, argv, prefix, 1);
 +	index_file = prepare_index(argc, argv, prefix, current_head, 1);
  	commitable = run_status(stdout, index_file, prefix, 0, s);
  	rollback_index_files();
  
@@@ -1114,8 -954,6 +1114,8 @@@ static int parse_status_slot(const cha
  {
  	if (!strcasecmp(var+offset, "header"))
  		return WT_STATUS_HEADER;
 +	if (!strcasecmp(var+offset, "branch"))
 +		return WT_STATUS_ONBRANCH;
  	if (!strcasecmp(var+offset, "updated")
  		|| !strcasecmp(var+offset, "added"))
  		return WT_STATUS_UPDATED;
@@@ -1142,7 -980,7 +1142,7 @@@ static int git_status_config(const cha
  		return 0;
  	}
  	if (!strcmp(k, "status.color") || !strcmp(k, "color.status")) {
 -		s->use_color = git_config_colorbool(k, v, -1);
 +		s->use_color = git_config_colorbool(k, v);
  		return 0;
  	}
  	if (!prefixcmp(k, "status.color.") || !prefixcmp(k, "color.status.")) {
@@@ -1168,7 -1006,7 +1168,7 @@@
  		else if (!strcmp(v, "all"))
  			s->show_untracked_files = SHOW_ALL_UNTRACKED_FILES;
  		else
 -			return error("Invalid untracked files mode '%s'", v);
 +			return error(_("Invalid untracked files mode '%s'"), v);
  		return 0;
  	}
  	return git_diff_ui_config(k, v, NULL);
@@@ -1177,16 -1015,13 +1177,16 @@@
  int cmd_status(int argc, const char **argv, const char *prefix)
  {
  	struct wt_status s;
 +	int fd;
  	unsigned char sha1[20];
  	static struct option builtin_status_options[] = {
 -		OPT__VERBOSE(&verbose),
 +		OPT__VERBOSE(&verbose, "be verbose"),
  		OPT_SET_INT('s', "short", &status_format,
  			    "show status concisely", STATUS_FORMAT_SHORT),
 +		OPT_BOOLEAN('b', "branch", &status_show_branch,
 +			    "show branch information"),
  		OPT_SET_INT(0, "porcelain", &status_format,
 -			    "show porcelain output format",
 +			    "machine-readable output",
  			    STATUS_FORMAT_PORCELAIN),
  		OPT_BOOLEAN('z', "null", &null_termination,
  			    "terminate entries with NUL"),
@@@ -1194,66 -1029,52 +1194,66 @@@
  		  "mode",
  		  "show untracked files, optional modes: all, normal, no. (Default: all)",
  		  PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
 +		OPT_BOOLEAN(0, "ignored", &show_ignored_in_status,
 +			    "show ignored files"),
 +		{ OPTION_STRING, 0, "ignore-submodules", &ignore_submodule_arg, "when",
 +		  "ignore changes to submodules, optional when: all, dirty, untracked. (Default: all)",
 +		  PARSE_OPT_OPTARG, NULL, (intptr_t)"all" },
  		OPT_END(),
  	};
  
 -	if (null_termination && status_format == STATUS_FORMAT_LONG)
 -		status_format = STATUS_FORMAT_PORCELAIN;
 +	if (argc == 2 && !strcmp(argv[1], "-h"))
 +		usage_with_options(builtin_status_usage, builtin_status_options);
  
  	wt_status_prepare(&s);
 +	gitmodules_config();
  	git_config(git_status_config, &s);
 -	in_merge = file_exists(git_path("MERGE_HEAD"));
 +	determine_whence(&s);
  	argc = parse_options(argc, argv, prefix,
  			     builtin_status_options,
  			     builtin_status_usage, 0);
 -	handle_untracked_files_arg(&s);
  
 +	if (null_termination && status_format == STATUS_FORMAT_LONG)
 +		status_format = STATUS_FORMAT_PORCELAIN;
 +
 +	handle_untracked_files_arg(&s);
 +	if (show_ignored_in_status)
 +		s.show_ignored_files = 1;
  	if (*argv)
  		s.pathspec = get_pathspec(prefix, argv);
  
 -	read_cache();
 +	read_cache_preload(s.pathspec);
  	refresh_index(&the_index, REFRESH_QUIET|REFRESH_UNMERGED, s.pathspec, NULL, NULL);
 +
 +	fd = hold_locked_index(&index_lock, 0);
 +	if (0 <= fd)
 +		update_index_if_able(&the_index, &index_lock);
 +
  	s.is_initial = get_sha1(s.reference, sha1) ? 1 : 0;
 -	s.in_merge = in_merge;
 +	s.ignore_submodule_arg = ignore_submodule_arg;
  	wt_status_collect(&s);
  
  	if (s.relative_paths)
  		s.prefix = prefix;
 -	if (s.use_color == -1)
 -		s.use_color = git_use_color_default;
 -	if (diff_use_color_default == -1)
 -		diff_use_color_default = git_use_color_default;
  
  	switch (status_format) {
  	case STATUS_FORMAT_SHORT:
 -		wt_shortstatus_print(&s, null_termination);
 +		wt_shortstatus_print(&s, null_termination, status_show_branch);
  		break;
  	case STATUS_FORMAT_PORCELAIN:
  		wt_porcelain_print(&s, null_termination);
  		break;
  	case STATUS_FORMAT_LONG:
  		s.verbose = verbose;
 +		s.ignore_submodule_arg = ignore_submodule_arg;
  		wt_status_print(&s);
  		break;
  	}
  	return 0;
  }
  
 -static void print_summary(const char *prefix, const unsigned char *sha1)
 +static void print_summary(const char *prefix, const unsigned char *sha1,
 +			  int initial_commit)
  {
  	struct rev_info rev;
  	struct commit *commit;
@@@ -1266,9 -1087,9 +1266,9 @@@
  
  	commit = lookup_commit(sha1);
  	if (!commit)
 -		die("couldn't look up newly created commit");
 +		die(_("couldn't look up newly created commit"));
  	if (!commit || parse_commit(commit))
 -		die("could not parse newly created commit");
 +		die(_("could not parse newly created commit"));
  
  	strbuf_addstr(&format, "format:%h] %s");
  
@@@ -1283,7 -1104,7 +1283,7 @@@
  		strbuf_addbuf_percentquote(&format, &committer_ident);
  		if (advice_implicit_identity) {
  			strbuf_addch(&format, '\n');
 -			strbuf_addstr(&format, implicit_ident_advice);
 +			strbuf_addstr(&format, _(implicit_ident_advice));
  		}
  	}
  	strbuf_release(&author_ident);
@@@ -1292,6 -1113,7 +1292,6 @@@
  	init_revisions(&rev, prefix);
  	setup_revisions(0, NULL, &rev, NULL);
  
 -	rev.abbrev = 0;
  	rev.diff = 1;
  	rev.diffopt.output_format =
  		DIFF_FORMAT_SHORTSTAT | DIFF_FORMAT_SUMMARY;
@@@ -1301,6 -1123,7 +1301,6 @@@
  	get_commit_format(format.buf, &rev);
  	rev.always_show_header = 0;
  	rev.diffopt.detect_rename = 1;
 -	rev.diffopt.rename_limit = 100;
  	rev.diffopt.break_opt = 0;
  	diff_setup_done(&rev.diffopt);
  
@@@ -1308,16 -1131,18 +1308,16 @@@
  		!prefixcmp(head, "refs/heads/") ?
  			head + 11 :
  			!strcmp(head, "HEAD") ?
 -				"detached HEAD" :
 +				_("detached HEAD") :
  				head,
 -		initial_commit ? " (root-commit)" : "");
 +		initial_commit ? _(" (root-commit)") : "");
  
  	if (!log_tree_commit(&rev, commit)) {
 -		struct pretty_print_context ctx = {0};
 -		struct strbuf buf = STRBUF_INIT;
 -		ctx.date_mode = DATE_NORMAL;
 -		format_commit_message(commit, format.buf + 7, &buf, &ctx);
 -		printf("%s\n", buf.buf);
 -		strbuf_release(&buf);
 +		rev.always_show_header = 1;
 +		rev.use_terminator = 1;
 +		log_tree_commit(&rev, commit);
  	}
 +
  	strbuf_release(&format);
  }
  
@@@ -1335,129 -1160,84 +1335,129 @@@ static int git_commit_config(const cha
  	return git_status_config(k, v, s);
  }
  
 +static const char post_rewrite_hook[] = "hooks/post-rewrite";
 +
 +static int run_rewrite_hook(const unsigned char *oldsha1,
 +			    const unsigned char *newsha1)
 +{
 +	/* oldsha1 SP newsha1 LF NUL */
 +	static char buf[2*40 + 3];
 +	struct child_process proc;
 +	const char *argv[3];
 +	int code;
 +	size_t n;
 +
 +	if (access(git_path(post_rewrite_hook), X_OK) < 0)
 +		return 0;
 +
 +	argv[0] = git_path(post_rewrite_hook);
 +	argv[1] = "amend";
 +	argv[2] = NULL;
 +
 +	memset(&proc, 0, sizeof(proc));
 +	proc.argv = argv;
 +	proc.in = -1;
 +	proc.stdout_to_stderr = 1;
 +
 +	code = start_command(&proc);
 +	if (code)
 +		return code;
 +	n = snprintf(buf, sizeof(buf), "%s %s\n",
 +		     sha1_to_hex(oldsha1), sha1_to_hex(newsha1));
 +	write_in_full(proc.in, buf, n);
 +	close(proc.in);
 +	return finish_command(&proc);
 +}
 +
  int cmd_commit(int argc, const char **argv, const char *prefix)
  {
  	struct strbuf sb = STRBUF_INIT;
 +	struct strbuf author_ident = STRBUF_INIT;
  	const char *index_file, *reflog_msg;
  	char *nl, *p;
 -	unsigned char commit_sha1[20];
 +	unsigned char sha1[20];
  	struct ref_lock *ref_lock;
  	struct commit_list *parents = NULL, **pptr = &parents;
  	struct stat statbuf;
  	int allow_fast_forward = 1;
  	struct wt_status s;
 +	struct commit *current_head = NULL;
 +
 +	if (argc == 2 && !strcmp(argv[1], "-h"))
 +		usage_with_options(builtin_commit_usage, builtin_commit_options);
  
  	wt_status_prepare(&s);
  	git_config(git_commit_config, &s);
 -	in_merge = file_exists(git_path("MERGE_HEAD"));
 -	s.in_merge = in_merge;
 +	determine_whence(&s);
  
 -	if (s.use_color == -1)
 -		s.use_color = git_use_color_default;
 -	argc = parse_and_validate_options(argc, argv, builtin_commit_usage,
 -					  prefix, &s);
 -	if (dry_run) {
 -		if (diff_use_color_default == -1)
 -			diff_use_color_default = git_use_color_default;
 -		return dry_run_commit(argc, argv, prefix, &s);
 +	if (get_sha1("HEAD", sha1))
 +		current_head = NULL;
 +	else {
 +		current_head = lookup_commit_or_die(sha1, "HEAD");
 +		if (!current_head || parse_commit(current_head))
 +			die(_("could not parse HEAD commit"));
  	}
 -	index_file = prepare_index(argc, argv, prefix, 0);
 +	argc = parse_and_validate_options(argc, argv, builtin_commit_usage,
 +					  prefix, current_head, &s);
 +	if (dry_run)
 +		return dry_run_commit(argc, argv, prefix, current_head, &s);
 +	index_file = prepare_index(argc, argv, prefix, current_head, 0);
  
  	/* Set up everything for writing the commit object.  This includes
  	   running hooks, writing the trees, and interacting with the user.  */
 -	if (!prepare_to_commit(index_file, prefix, &s)) {
 +	if (!prepare_to_commit(index_file, prefix,
 +			       current_head, &s, &author_ident)) {
  		rollback_index_files();
  		return 1;
  	}
  
  	/* Determine parents */
 -	if (initial_commit) {
 -		reflog_msg = "commit (initial)";
 +	reflog_msg = getenv("GIT_REFLOG_ACTION");
 +	if (!current_head) {
 +		if (!reflog_msg)
 +			reflog_msg = "commit (initial)";
  	} else if (amend) {
  		struct commit_list *c;
 -		struct commit *commit;
 -
 -		reflog_msg = "commit (amend)";
 -		commit = lookup_commit(head_sha1);
 -		if (!commit || parse_commit(commit))
 -			die("could not parse HEAD commit");
  
 -		for (c = commit->parents; c; c = c->next)
 +		if (!reflog_msg)
 +			reflog_msg = "commit (amend)";
 +		for (c = current_head->parents; c; c = c->next)
  			pptr = &commit_list_insert(c->item, pptr)->next;
 -	} else if (in_merge) {
 +	} else if (whence == FROM_MERGE) {
  		struct strbuf m = STRBUF_INIT;
 +		struct commit *commit;
  		FILE *fp;
  
 -		reflog_msg = "commit (merge)";
 -		pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
 +		if (!reflog_msg)
 +			reflog_msg = "commit (merge)";
 +		pptr = &commit_list_insert(current_head, pptr)->next;
  		fp = fopen(git_path("MERGE_HEAD"), "r");
  		if (fp == NULL)
 -			die_errno("could not open '%s' for reading",
 +			die_errno(_("could not open '%s' for reading"),
  				  git_path("MERGE_HEAD"));
  		while (strbuf_getline(&m, fp, '\n') != EOF) {
  			unsigned char sha1[20];
  			if (get_sha1_hex(m.buf, sha1) < 0)
 -				die("Corrupt MERGE_HEAD file (%s)", m.buf);
 -			pptr = &commit_list_insert(lookup_commit(sha1), pptr)->next;
 +				die(_("Corrupt MERGE_HEAD file (%s)"), m.buf);
 +			commit = lookup_commit_or_die(sha1, "MERGE_HEAD");
 +			pptr = &commit_list_insert(commit, pptr)->next;
  		}
  		fclose(fp);
  		strbuf_release(&m);
  		if (!stat(git_path("MERGE_MODE"), &statbuf)) {
  			if (strbuf_read_file(&sb, git_path("MERGE_MODE"), 0) < 0)
 -				die_errno("could not read MERGE_MODE");
 +				die_errno(_("could not read MERGE_MODE"));
  			if (!strcmp(sb.buf, "no-ff"))
  				allow_fast_forward = 0;
  		}
  		if (allow_fast_forward)
  			parents = reduce_heads(parents);
  	} else {
 -		reflog_msg = "commit";
 -		pptr = &commit_list_insert(lookup_commit(head_sha1), pptr)->next;
 +		if (!reflog_msg)
 +			reflog_msg = (whence == FROM_CHERRY_PICK)
 +					? "commit (cherry-pick)"
 +					: "commit";
 +		pptr = &commit_list_insert(current_head, pptr)->next;
  	}
  
  	/* Finally, get the commit message */
@@@ -1465,7 -1245,7 +1465,7 @@@
  	if (strbuf_read_file(&sb, git_path(commit_editmsg), 0) < 0) {
  		int saved_errno = errno;
  		rollback_index_files();
 -		die("could not read commit message: %s", strerror(saved_errno));
 +		die(_("could not read commit message: %s"), strerror(saved_errno));
  	}
  
  	/* Truncate the message just before the diff, if any. */
@@@ -1477,23 -1257,21 +1477,23 @@@
  
  	if (cleanup_mode != CLEANUP_NONE)
  		stripspace(&sb, cleanup_mode == CLEANUP_ALL);
 -	if (message_is_empty(&sb)) {
 +	if (message_is_empty(&sb) && !allow_empty_message) {
  		rollback_index_files();
 -		fprintf(stderr, "Aborting commit due to empty commit message.\n");
 +		fprintf(stderr, _("Aborting commit due to empty commit message.\n"));
  		exit(1);
  	}
  
 -	if (commit_tree(sb.buf, active_cache_tree->sha1, parents, commit_sha1,
 -			fmt_ident(author_name, author_email, author_date,
 -				IDENT_ERROR_ON_NO_NAME))) {
 +	if (commit_tree(sb.buf, active_cache_tree->sha1, parents, sha1,
 +			author_ident.buf)) {
  		rollback_index_files();
 -		die("failed to write commit object");
 +		die(_("failed to write commit object"));
  	}
 +	strbuf_release(&author_ident);
  
  	ref_lock = lock_any_ref_for_update("HEAD",
 -					   initial_commit ? NULL : head_sha1,
 +					   !current_head
 +					   ? NULL
 +					   : current_head->object.sha1,
  					   0);
  
  	nl = strchr(sb.buf, '\n');
@@@ -1506,39 -1284,27 +1506,39 @@@
  
  	if (!ref_lock) {
  		rollback_index_files();
 -		die("cannot lock HEAD ref");
 +		die(_("cannot lock HEAD ref"));
  	}
 -	if (write_ref_sha1(ref_lock, commit_sha1, sb.buf) < 0) {
 +	if (write_ref_sha1(ref_lock, sha1, sb.buf) < 0) {
  		rollback_index_files();
 -		die("cannot update HEAD ref");
 +		die(_("cannot update HEAD ref"));
  	}
  
 +	unlink(git_path("CHERRY_PICK_HEAD"));
 +	unlink(git_path("REVERT_HEAD"));
  	unlink(git_path("MERGE_HEAD"));
  	unlink(git_path("MERGE_MSG"));
  	unlink(git_path("MERGE_MODE"));
  	unlink(git_path("SQUASH_MSG"));
  
  	if (commit_index_files())
 -		die ("Repository has been updated, but unable to write\n"
 +		die (_("Repository has been updated, but unable to write\n"
  		     "new_index file. Check that disk is not full or quota is\n"
 -		     "not exceeded, and then \"git reset HEAD\" to recover.");
 +		     "not exceeded, and then \"git reset HEAD\" to recover."));
  
  	rerere(0);
  	run_hook(get_index_file(), "post-commit", NULL);
 +	if (amend && !no_post_rewrite) {
 +		struct notes_rewrite_cfg *cfg;
 +		cfg = init_copy_notes_for_rewrite("amend");
 +		if (cfg) {
 +			/* we are amending, so current_head is not NULL */
 +			copy_note_for_rewrite(cfg, current_head->object.sha1, sha1);
 +			finish_copy_notes_for_rewrite(cfg);
 +		}
 +		run_rewrite_hook(current_head->object.sha1, sha1);
 +	}
  	if (!quiet)
 -		print_summary(prefix, commit_sha1);
 +		print_summary(prefix, sha1, !current_head);
  
  	return 0;
  }
diff --combined builtin/merge.c
index 1387376248,c6e3e7fdaf..7d92e2064b
--- a/builtin/merge.c
+++ b/builtin/merge.c
@@@ -25,7 -25,6 +25,7 @@@
  #include "help.h"
  #include "merge-recursive.h"
  #include "resolve-undo.h"
 +#include "remote.h"
  
  #define DEFAULT_TWOHEAD (1<<0)
  #define DEFAULT_OCTOPUS (1<<1)
@@@ -38,30 -37,25 +38,30 @@@ struct strategy 
  };
  
  static const char * const builtin_merge_usage[] = {
 -	"git merge [options] <remote>...",
 -	"git merge [options] <msg> HEAD <remote>",
 +	"git merge [options] [<commit>...]",
 +	"git merge [options] <msg> HEAD <commit>",
 +	"git merge --abort",
  	NULL
  };
  
 -static int show_diffstat = 1, option_log, squash;
 +static int show_diffstat = 1, shortlog_len, squash;
  static int option_commit = 1, allow_fast_forward = 1;
 -static int fast_forward_only;
 +static int fast_forward_only, option_edit;
  static int allow_trivial = 1, have_message;
- static struct strbuf merge_msg;
+ static struct strbuf merge_msg = STRBUF_INIT;
  static struct commit_list *remoteheads;
 -static unsigned char head[20], stash[20];
  static struct strategy **use_strategies;
  static size_t use_strategies_nr, use_strategies_alloc;
  static const char **xopts;
  static size_t xopts_nr, xopts_alloc;
  static const char *branch;
 +static char *branch_mergeoptions;
 +static int option_renormalize;
  static int verbosity;
  static int allow_rerere_auto;
 +static int abort_current_merge;
 +static int show_progress = -1;
 +static int default_to_upstream;
  
  static struct strategy all_strategy[] = {
  	{ "recursive",  DEFAULT_TWOHEAD | NO_TRIVIAL },
@@@ -84,7 -78,7 +84,7 @@@ static int option_parse_message(const s
  		strbuf_addf(buf, "%s%s", buf->len ? "\n\n" : "", arg);
  		have_message = 1;
  	} else
 -		return error("switch `m' requires a value");
 +		return error(_("switch `m' requires a value"));
  	return 0;
  }
  
@@@ -121,13 -115,13 +121,13 @@@ static struct strategy *get_strategy(co
  		exclude_cmds(&main_cmds, &not_strategies);
  	}
  	if (!is_in_cmdlist(&main_cmds, name) && !is_in_cmdlist(&other_cmds, name)) {
 -		fprintf(stderr, "Could not find merge strategy '%s'.\n", name);
 -		fprintf(stderr, "Available strategies are:");
 +		fprintf(stderr, _("Could not find merge strategy '%s'.\n"), name);
 +		fprintf(stderr, _("Available strategies are:"));
  		for (i = 0; i < main_cmds.cnt; i++)
  			fprintf(stderr, " %s", main_cmds.names[i]->name);
  		fprintf(stderr, ".\n");
  		if (other_cmds.cnt) {
 -			fprintf(stderr, "Available custom strategies are:");
 +			fprintf(stderr, _("Available custom strategies are:"));
  			for (i = 0; i < other_cmds.cnt; i++)
  				fprintf(stderr, " %s", other_cmds.names[i]->name);
  			fprintf(stderr, ".\n");
@@@ -137,7 -131,6 +137,7 @@@
  
  	ret = xcalloc(1, sizeof(struct strategy));
  	ret->name = xstrdup(name);
 +	ret->attr = NO_TRIVIAL;
  	return ret;
  }
  
@@@ -182,15 -175,12 +182,15 @@@ static struct option builtin_merge_opti
  	OPT_BOOLEAN(0, "stat", &show_diffstat,
  		"show a diffstat at the end of the merge"),
  	OPT_BOOLEAN(0, "summary", &show_diffstat, "(synonym to --stat)"),
 -	OPT_BOOLEAN(0, "log", &option_log,
 -		"add list of one-line log to merge commit message"),
 +	{ OPTION_INTEGER, 0, "log", &shortlog_len, "n",
 +	  "add (at most <n>) entries from shortlog to merge commit message",
 +	  PARSE_OPT_OPTARG, NULL, DEFAULT_MERGE_LOG_LEN },
  	OPT_BOOLEAN(0, "squash", &squash,
  		"create a single commit instead of doing a merge"),
  	OPT_BOOLEAN(0, "commit", &option_commit,
  		"perform a commit if the merge succeeds (default)"),
 +	OPT_BOOLEAN('e', "edit", &option_edit,
 +		"edit message before committing"),
  	OPT_BOOLEAN(0, "ff", &allow_fast_forward,
  		"allow fast-forward (default)"),
  	OPT_BOOLEAN(0, "ff-only", &fast_forward_only,
@@@ -201,12 -191,9 +201,12 @@@
  	OPT_CALLBACK('X', "strategy-option", &xopts, "option=value",
  		"option for selected merge strategy", option_parse_x),
  	OPT_CALLBACK('m', "message", &merge_msg, "message",
 -		"message to be used for the merge commit (if any)",
 +		"merge commit message (for a non-fast-forward merge)",
  		option_parse_message),
  	OPT__VERBOSITY(&verbosity),
 +	OPT_BOOLEAN(0, "abort", &abort_current_merge,
 +		"abort the current in-progress merge"),
 +	OPT_SET_INT(0, "progress", &show_progress, "force progress reporting", 1),
  	OPT_END()
  };
  
@@@ -218,7 -205,7 +218,7 @@@ static void drop_save(void
  	unlink(git_path("MERGE_MODE"));
  }
  
 -static void save_state(void)
 +static int save_state(unsigned char *stash)
  {
  	int len;
  	struct child_process cp;
@@@ -231,36 -218,17 +231,36 @@@
  	cp.git_cmd = 1;
  
  	if (start_command(&cp))
 -		die("could not run stash.");
 +		die(_("could not run stash."));
  	len = strbuf_read(&buffer, cp.out, 1024);
  	close(cp.out);
  
  	if (finish_command(&cp) || len < 0)
 -		die("stash failed");
 -	else if (!len)
 -		return;
 +		die(_("stash failed"));
 +	else if (!len)		/* no changes */
 +		return -1;
  	strbuf_setlen(&buffer, buffer.len-1);
  	if (get_sha1(buffer.buf, stash))
 -		die("not a valid object: %s", buffer.buf);
 +		die(_("not a valid object: %s"), buffer.buf);
 +	return 0;
 +}
 +
 +static void read_empty(unsigned const char *sha1, int verbose)
 +{
 +	int i = 0;
 +	const char *args[7];
 +
 +	args[i++] = "read-tree";
 +	if (verbose)
 +		args[i++] = "-v";
 +	args[i++] = "-m";
 +	args[i++] = "-u";
 +	args[i++] = EMPTY_TREE_SHA1_HEX;
 +	args[i++] = sha1_to_hex(sha1);
 +	args[i] = NULL;
 +
 +	if (run_command_v_opt(args, RUN_GIT_CMD))
 +		die(_("read-tree failed"));
  }
  
  static void reset_hard(unsigned const char *sha1, int verbose)
@@@ -277,11 -245,10 +277,11 @@@
  	args[i] = NULL;
  
  	if (run_command_v_opt(args, RUN_GIT_CMD))
 -		die("read-tree failed");
 +		die(_("read-tree failed"));
  }
  
 -static void restore_state(void)
 +static void restore_state(const unsigned char *head,
 +			  const unsigned char *stash)
  {
  	struct strbuf sb = STRBUF_INIT;
  	const char *args[] = { "stash", "apply", NULL, NULL };
@@@ -307,29 -274,29 +307,29 @@@
  static void finish_up_to_date(const char *msg)
  {
  	if (verbosity >= 0)
 -		printf("%s%s\n", squash ? " (nothing to squash)" : "", msg);
 +		printf("%s%s\n", squash ? _(" (nothing to squash)") : "", msg);
  	drop_save();
  }
  
 -static void squash_message(void)
 +static void squash_message(struct commit *commit)
  {
  	struct rev_info rev;
 -	struct commit *commit;
  	struct strbuf out = STRBUF_INIT;
  	struct commit_list *j;
 +	const char *filename;
  	int fd;
  	struct pretty_print_context ctx = {0};
  
 -	printf("Squash commit -- not updating HEAD\n");
 -	fd = open(git_path("SQUASH_MSG"), O_WRONLY | O_CREAT, 0666);
 +	printf(_("Squash commit -- not updating HEAD\n"));
 +	filename = git_path("SQUASH_MSG");
 +	fd = open(filename, O_WRONLY | O_CREAT, 0666);
  	if (fd < 0)
 -		die_errno("Could not write to '%s'", git_path("SQUASH_MSG"));
 +		die_errno(_("Could not write to '%s'"), filename);
  
  	init_revisions(&rev, NULL);
  	rev.ignore_merges = 1;
  	rev.commit_format = CMIT_FMT_MEDIUM;
  
 -	commit = lookup_commit(head);
  	commit->object.flags |= UNINTERESTING;
  	add_pending_object(&rev, &commit->object, NULL);
  
@@@ -338,31 -305,28 +338,31 @@@
  
  	setup_revisions(0, NULL, &rev, NULL);
  	if (prepare_revision_walk(&rev))
 -		die("revision walk setup failed");
 +		die(_("revision walk setup failed"));
  
  	ctx.abbrev = rev.abbrev;
  	ctx.date_mode = rev.date_mode;
 +	ctx.fmt = rev.commit_format;
  
  	strbuf_addstr(&out, "Squashed commit of the following:\n");
  	while ((commit = get_revision(&rev)) != NULL) {
  		strbuf_addch(&out, '\n');
  		strbuf_addf(&out, "commit %s\n",
  			sha1_to_hex(commit->object.sha1));
 -		pretty_print_commit(rev.commit_format, commit, &out, &ctx);
 +		pretty_print_commit(&ctx, commit, &out);
  	}
  	if (write(fd, out.buf, out.len) < 0)
 -		die_errno("Writing SQUASH_MSG");
 +		die_errno(_("Writing SQUASH_MSG"));
  	if (close(fd))
 -		die_errno("Finishing SQUASH_MSG");
 +		die_errno(_("Finishing SQUASH_MSG"));
  	strbuf_release(&out);
  }
  
 -static void finish(const unsigned char *new_head, const char *msg)
 +static void finish(struct commit *head_commit,
 +		   const unsigned char *new_head, const char *msg)
  {
  	struct strbuf reflog_message = STRBUF_INIT;
 +	const unsigned char *head = head_commit->object.sha1;
  
  	if (!msg)
  		strbuf_addstr(&reflog_message, getenv("GIT_REFLOG_ACTION"));
@@@ -373,10 -337,10 +373,10 @@@
  			getenv("GIT_REFLOG_ACTION"), msg);
  	}
  	if (squash) {
 -		squash_message();
 +		squash_message(head_commit);
  	} else {
  		if (verbosity >= 0 && !merge_msg.len)
 -			printf("No merge message -- not updating HEAD\n");
 +			printf(_("No merge message -- not updating HEAD\n"));
  		else {
  			const char *argv_gc_auto[] = { "gc", "--auto", NULL };
  			update_ref(reflog_message.buf, "HEAD",
@@@ -395,8 -359,10 +395,8 @@@
  		opts.output_format |=
  			DIFF_FORMAT_SUMMARY | DIFF_FORMAT_DIFFSTAT;
  		opts.detect_rename = DIFF_DETECT_RENAME;
 -		if (diff_use_color_default > 0)
 -			DIFF_OPT_SET(&opts, COLOR_DIFF);
  		if (diff_setup_done(&opts) < 0)
 -			die("diff_setup_done failed");
 +			die(_("diff_setup_done failed"));
  		diff_tree_sha1(head, new_head, "", &opts);
  		diffcore_std(&opts);
  		diff_flush(&opts);
@@@ -408,16 -374,6 +408,16 @@@
  	strbuf_release(&reflog_message);
  }
  
 +static struct object *want_commit(const char *name)
 +{
 +	struct object *obj;
 +	unsigned char sha1[20];
 +	if (get_sha1(name, sha1))
 +		return NULL;
 +	obj = parse_object(sha1);
 +	return peel_to_type(name, 0, obj, OBJ_COMMIT);
 +}
 +
  /* Get the name for the merge commit's message. */
  static void merge_name(const char *remote, struct strbuf *msg)
  {
@@@ -433,9 -389,9 +433,9 @@@
  	remote = bname.buf;
  
  	memset(branch_head, 0, sizeof(branch_head));
 -	remote_head = peel_to_type(remote, 0, NULL, OBJ_COMMIT);
 +	remote_head = want_commit(remote);
  	if (!remote_head)
 -		die("'%s' does not point to a commit", remote);
 +		die(_("'%s' does not point to a commit"), remote);
  
  	if (dwim_ref(remote, strlen(remote), branch_head, &found_ref) > 0) {
  		if (!prefixcmp(found_ref, "refs/heads/")) {
@@@ -444,7 -400,7 +444,7 @@@
  			goto cleanup;
  		}
  		if (!prefixcmp(found_ref, "refs/remotes/")) {
 -			strbuf_addf(msg, "%s\t\tremote branch '%s' of .\n",
 +			strbuf_addf(msg, "%s\t\tremote-tracking branch '%s' of .\n",
  				    sha1_to_hex(branch_head), remote);
  			goto cleanup;
  		}
@@@ -481,7 -437,7 +481,7 @@@
  		strbuf_addstr(&truname, "refs/heads/");
  		strbuf_addstr(&truname, remote);
  		strbuf_setlen(&truname, truname.len - len);
 -		if (resolve_ref(truname.buf, buf_sha, 0, NULL)) {
 +		if (resolve_ref(truname.buf, buf_sha, 1, NULL)) {
  			strbuf_addf(msg,
  				    "%s\t\tbranch '%s'%s of .\n",
  				    sha1_to_hex(remote_head->sha1),
@@@ -494,16 -450,14 +494,16 @@@
  
  	if (!strcmp(remote, "FETCH_HEAD") &&
  			!access(git_path("FETCH_HEAD"), R_OK)) {
 +		const char *filename;
  		FILE *fp;
  		struct strbuf line = STRBUF_INIT;
  		char *ptr;
  
 -		fp = fopen(git_path("FETCH_HEAD"), "r");
 +		filename = git_path("FETCH_HEAD");
 +		fp = fopen(filename, "r");
  		if (!fp)
 -			die_errno("could not open '%s' for reading",
 -				  git_path("FETCH_HEAD"));
 +			die_errno(_("could not open '%s' for reading"),
 +				  filename);
  		strbuf_getline(&line, fp, '\n');
  		fclose(fp);
  		ptr = strstr(line.buf, "\tnot-for-merge\t");
@@@ -520,34 -474,25 +520,34 @@@ cleanup
  	strbuf_release(&bname);
  }
  
 +static void parse_branch_merge_options(char *bmo)
 +{
 +	const char **argv;
 +	int argc;
 +
 +	if (!bmo)
 +		return;
 +	argc = split_cmdline(bmo, &argv);
 +	if (argc < 0)
 +		die(_("Bad branch.%s.mergeoptions string: %s"), branch,
 +		    split_cmdline_strerror(argc));
 +	argv = xrealloc(argv, sizeof(*argv) * (argc + 2));
 +	memmove(argv + 1, argv, sizeof(*argv) * (argc + 1));
 +	argc++;
 +	argv[0] = "branch.*.mergeoptions";
 +	parse_options(argc, argv, NULL, builtin_merge_options,
 +		      builtin_merge_usage, 0);
 +	free(argv);
 +}
 +
  static int git_merge_config(const char *k, const char *v, void *cb)
  {
  	if (branch && !prefixcmp(k, "branch.") &&
  		!prefixcmp(k + 7, branch) &&
  		!strcmp(k + 7 + strlen(branch), ".mergeoptions")) {
 -		const char **argv;
 -		int argc;
 -		char *buf;
 -
 -		buf = xstrdup(v);
 -		argc = split_cmdline(buf, &argv);
 -		if (argc < 0)
 -			die("Bad branch.%s.mergeoptions string", branch);
 -		argv = xrealloc(argv, sizeof(*argv) * (argc + 2));
 -		memmove(argv + 1, argv, sizeof(*argv) * (argc + 1));
 -		argc++;
 -		parse_options(argc, argv, NULL, builtin_merge_options,
 -			      builtin_merge_usage, 0);
 -		free(buf);
 +		free(branch_mergeoptions);
 +		branch_mergeoptions = xstrdup(v);
 +		return 0;
  	}
  
  	if (!strcmp(k, "merge.diffstat") || !strcmp(k, "merge.stat"))
@@@ -556,29 -501,8 +556,29 @@@
  		return git_config_string(&pull_twohead, k, v);
  	else if (!strcmp(k, "pull.octopus"))
  		return git_config_string(&pull_octopus, k, v);
 -	else if (!strcmp(k, "merge.log") || !strcmp(k, "merge.summary"))
 -		option_log = git_config_bool(k, v);
 +	else if (!strcmp(k, "merge.renormalize"))
 +		option_renormalize = git_config_bool(k, v);
 +	else if (!strcmp(k, "merge.log") || !strcmp(k, "merge.summary")) {
 +		int is_bool;
 +		shortlog_len = git_config_bool_or_int(k, v, &is_bool);
 +		if (!is_bool && shortlog_len < 0)
 +			return error(_("%s: negative length %s"), k, v);
 +		if (is_bool && shortlog_len)
 +			shortlog_len = DEFAULT_MERGE_LOG_LEN;
 +		return 0;
 +	} else if (!strcmp(k, "merge.ff")) {
 +		int boolval = git_config_maybe_bool(k, v);
 +		if (0 <= boolval) {
 +			allow_fast_forward = boolval;
 +		} else if (v && !strcmp(v, "only")) {
 +			allow_fast_forward = 1;
 +			fast_forward_only = 1;
 +		} /* do not barf on values from future versions of git */
 +		return 0;
 +	} else if (!strcmp(k, "merge.defaulttoupstream")) {
 +		default_to_upstream = git_config_bool(k, v);
 +		return 0;
 +	}
  	return git_diff_ui_config(k, v, cb);
  }
  
@@@ -621,65 -545,16 +621,65 @@@ static int read_tree_trivial(unsigned c
  static void write_tree_trivial(unsigned char *sha1)
  {
  	if (write_cache_as_tree(sha1, 0, NULL))
 -		die("git write-tree failed to write a tree");
 +		die(_("git write-tree failed to write a tree"));
  }
  
 -static int try_merge_strategy(const char *strategy, struct commit_list *common,
 -			      const char *head_arg)
 +static const char *merge_argument(struct commit *commit)
 +{
 +	if (commit)
 +		return sha1_to_hex(commit->object.sha1);
 +	else
 +		return EMPTY_TREE_SHA1_HEX;
 +}
 +
 +int try_merge_command(const char *strategy, size_t xopts_nr,
 +		      const char **xopts, struct commit_list *common,
 +		      const char *head_arg, struct commit_list *remotes)
  {
  	const char **args;
  	int i = 0, x = 0, ret;
  	struct commit_list *j;
  	struct strbuf buf = STRBUF_INIT;
 +
 +	args = xmalloc((4 + xopts_nr + commit_list_count(common) +
 +			commit_list_count(remotes)) * sizeof(char *));
 +	strbuf_addf(&buf, "merge-%s", strategy);
 +	args[i++] = buf.buf;
 +	for (x = 0; x < xopts_nr; x++) {
 +		char *s = xmalloc(strlen(xopts[x])+2+1);
 +		strcpy(s, "--");
 +		strcpy(s+2, xopts[x]);
 +		args[i++] = s;
 +	}
 +	for (j = common; j; j = j->next)
 +		args[i++] = xstrdup(merge_argument(j->item));
 +	args[i++] = "--";
 +	args[i++] = head_arg;
 +	for (j = remotes; j; j = j->next)
 +		args[i++] = xstrdup(merge_argument(j->item));
 +	args[i] = NULL;
 +	ret = run_command_v_opt(args, RUN_GIT_CMD);
 +	strbuf_release(&buf);
 +	i = 1;
 +	for (x = 0; x < xopts_nr; x++)
 +		free((void *)args[i++]);
 +	for (j = common; j; j = j->next)
 +		free((void *)args[i++]);
 +	i += 2;
 +	for (j = remotes; j; j = j->next)
 +		free((void *)args[i++]);
 +	free(args);
 +	discard_cache();
 +	if (read_cache() < 0)
 +		die(_("failed to read the cache"));
 +	resolve_undo_clear();
 +
 +	return ret;
 +}
 +
 +static int try_merge_strategy(const char *strategy, struct commit_list *common,
 +			      struct commit *head, const char *head_arg)
 +{
  	int index_fd;
  	struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
  
@@@ -688,20 -563,19 +688,20 @@@
  	if (active_cache_changed &&
  			(write_cache(index_fd, active_cache, active_nr) ||
  			 commit_locked_index(lock)))
 -		return error("Unable to write index.");
 +		return error(_("Unable to write index."));
  	rollback_lock_file(lock);
  
  	if (!strcmp(strategy, "recursive") || !strcmp(strategy, "subtree")) {
 -		int clean;
 +		int clean, x;
  		struct commit *result;
  		struct lock_file *lock = xcalloc(1, sizeof(struct lock_file));
  		int index_fd;
  		struct commit_list *reversed = NULL;
  		struct merge_options o;
 +		struct commit_list *j;
  
  		if (remoteheads->next) {
 -			error("Not handling anything other than two heads merge.");
 +			error(_("Not handling anything other than two heads merge."));
  			return 2;
  		}
  
@@@ -709,13 -583,18 +709,13 @@@
  		if (!strcmp(strategy, "subtree"))
  			o.subtree_shift = "";
  
 -		for (x = 0; x < xopts_nr; x++) {
 -			if (!strcmp(xopts[x], "ours"))
 -				o.recursive_variant = MERGE_RECURSIVE_OURS;
 -			else if (!strcmp(xopts[x], "theirs"))
 -				o.recursive_variant = MERGE_RECURSIVE_THEIRS;
 -			else if (!strcmp(xopts[x], "subtree"))
 -				o.subtree_shift = "";
 -			else if (!prefixcmp(xopts[x], "subtree="))
 -				o.subtree_shift = xopts[x]+8;
 -			else
 -				die("Unknown option for merge-recursive: -X%s", xopts[x]);
 -		}
 +		o.renormalize = option_renormalize;
 +		o.show_rename_progress =
 +			show_progress == -1 ? isatty(2) : show_progress;
 +
 +		for (x = 0; x < xopts_nr; x++)
 +			if (parse_merge_opt(&o, xopts[x]))
 +				die(_("Unknown option for merge-recursive: -X%s"), xopts[x]);
  
  		o.branch1 = head_arg;
  		o.branch2 = remoteheads->item->util;
@@@ -724,17 -603,48 +724,17 @@@
  			commit_list_insert(j->item, &reversed);
  
  		index_fd = hold_locked_index(lock, 1);
 -		clean = merge_recursive(&o, lookup_commit(head),
 +		clean = merge_recursive(&o, head,
  				remoteheads->item, reversed, &result);
  		if (active_cache_changed &&
  				(write_cache(index_fd, active_cache, active_nr) ||
  				 commit_locked_index(lock)))
 -			die ("unable to write %s", get_index_file());
 +			die (_("unable to write %s"), get_index_file());
  		rollback_lock_file(lock);
  		return clean ? 0 : 1;
  	} else {
 -		args = xmalloc((4 + xopts_nr + commit_list_count(common) +
 -					commit_list_count(remoteheads)) * sizeof(char *));
 -		strbuf_addf(&buf, "merge-%s", strategy);
 -		args[i++] = buf.buf;
 -		for (x = 0; x < xopts_nr; x++) {
 -			char *s = xmalloc(strlen(xopts[x])+2+1);
 -			strcpy(s, "--");
 -			strcpy(s+2, xopts[x]);
 -			args[i++] = s;
 -		}
 -		for (j = common; j; j = j->next)
 -			args[i++] = xstrdup(sha1_to_hex(j->item->object.sha1));
 -		args[i++] = "--";
 -		args[i++] = head_arg;
 -		for (j = remoteheads; j; j = j->next)
 -			args[i++] = xstrdup(sha1_to_hex(j->item->object.sha1));
 -		args[i] = NULL;
 -		ret = run_command_v_opt(args, RUN_GIT_CMD);
 -		strbuf_release(&buf);
 -		i = 1;
 -		for (x = 0; x < xopts_nr; x++)
 -			free((void *)args[i++]);
 -		for (j = common; j; j = j->next)
 -			free((void *)args[i++]);
 -		i += 2;
 -		for (j = remoteheads; j; j = j->next)
 -			free((void *)args[i++]);
 -		free(args);
 -		discard_cache();
 -		if (read_cache() < 0)
 -			die("failed to read the cache");
 -		resolve_undo_clear();
 -		return ret;
 +		return try_merge_command(strategy, xopts_nr, xopts,
 +						common, head_arg, remoteheads);
  	}
  }
  
@@@ -757,7 -667,7 +757,7 @@@ static int count_unmerged_entries(void
  	return ret;
  }
  
 -static int checkout_fast_forward(unsigned char *head, unsigned char *remote)
 +int checkout_fast_forward(const unsigned char *head, const unsigned char *remote)
  {
  	struct tree *trees[MAX_UNPACK_TREES];
  	struct unpack_trees_options opts;
@@@ -775,7 -685,7 +775,7 @@@
  	memset(&t, 0, sizeof(t));
  	memset(&dir, 0, sizeof(dir));
  	dir.flags |= DIR_SHOW_IGNORED;
 -	dir.exclude_per_dir = ".gitignore";
 +	setup_standard_excludes(&dir);
  	opts.dir = &dir;
  
  	opts.head_idx = 1;
@@@ -785,7 -695,7 +785,7 @@@
  	opts.verbose_update = 1;
  	opts.merge = 1;
  	opts.fn = twoway_merge;
 -	opts.msgs = get_porcelain_error_msgs();
 +	setup_unpack_trees_porcelain(&opts, "merge");
  
  	trees[nr_trees] = parse_tree_indirect(head);
  	if (!trees[nr_trees++])
@@@ -801,7 -711,7 +801,7 @@@
  		return -1;
  	if (write_cache(fd, active_cache, active_nr) ||
  		commit_locked_index(lock_file))
 -		die("unable to write new index file");
 +		die(_("unable to write new index file"));
  	return 0;
  }
  
@@@ -849,78 -759,24 +849,78 @@@ static void add_strategies(const char *
  
  }
  
 -static int merge_trivial(void)
 +static void write_merge_msg(struct strbuf *msg)
 +{
 +	const char *filename = git_path("MERGE_MSG");
 +	int fd = open(filename, O_WRONLY | O_CREAT, 0666);
 +	if (fd < 0)
 +		die_errno(_("Could not open '%s' for writing"),
 +			  filename);
 +	if (write_in_full(fd, msg->buf, msg->len) != msg->len)
 +		die_errno(_("Could not write to '%s'"), filename);
 +	close(fd);
 +}
 +
 +static void read_merge_msg(struct strbuf *msg)
 +{
 +	const char *filename = git_path("MERGE_MSG");
 +	strbuf_reset(msg);
 +	if (strbuf_read_file(msg, filename, 0) < 0)
 +		die_errno(_("Could not read from '%s'"), filename);
 +}
 +
 +static void write_merge_state(void);
 +static void abort_commit(const char *err_msg)
 +{
 +	if (err_msg)
 +		error("%s", err_msg);
 +	fprintf(stderr,
 +		_("Not committing merge; use 'git commit' to complete the merge.\n"));
 +	write_merge_state();
 +	exit(1);
 +}
 +
 +static void prepare_to_commit(void)
 +{
 +	struct strbuf msg = STRBUF_INIT;
 +	strbuf_addbuf(&msg, &merge_msg);
 +	strbuf_addch(&msg, '\n');
 +	write_merge_msg(&msg);
 +	run_hook(get_index_file(), "prepare-commit-msg",
 +		 git_path("MERGE_MSG"), "merge", NULL, NULL);
 +	if (option_edit) {
 +		if (launch_editor(git_path("MERGE_MSG"), NULL, NULL))
 +			abort_commit(NULL);
 +	}
 +	read_merge_msg(&msg);
 +	stripspace(&msg, option_edit);
 +	if (!msg.len)
 +		abort_commit(_("Empty commit message."));
 +	strbuf_release(&merge_msg);
 +	strbuf_addbuf(&merge_msg, &msg);
 +	strbuf_release(&msg);
 +}
 +
 +static int merge_trivial(struct commit *head)
  {
  	unsigned char result_tree[20], result_commit[20];
  	struct commit_list *parent = xmalloc(sizeof(*parent));
  
  	write_tree_trivial(result_tree);
 -	printf("Wonderful.\n");
 -	parent->item = lookup_commit(head);
 +	printf(_("Wonderful.\n"));
 +	parent->item = head;
  	parent->next = xmalloc(sizeof(*parent->next));
  	parent->next->item = remoteheads->item;
  	parent->next->next = NULL;
 +	prepare_to_commit();
  	commit_tree(merge_msg.buf, result_tree, parent, result_commit, NULL);
 -	finish(result_commit, "In-index merge");
 +	finish(head, result_commit, "In-index merge");
  	drop_save();
  	return 0;
  }
  
 -static int finish_automerge(struct commit_list *common,
 +static int finish_automerge(struct commit *head,
 +			    struct commit_list *common,
  			    unsigned char *result_tree,
  			    const char *wt_strategy)
  {
@@@ -931,37 -787,35 +931,37 @@@
  	free_commit_list(common);
  	if (allow_fast_forward) {
  		parents = remoteheads;
 -		commit_list_insert(lookup_commit(head), &parents);
 +		commit_list_insert(head, &parents);
  		parents = reduce_heads(parents);
  	} else {
  		struct commit_list **pptr = &parents;
  
 -		pptr = &commit_list_insert(lookup_commit(head),
 +		pptr = &commit_list_insert(head,
  				pptr)->next;
  		for (j = remoteheads; j; j = j->next)
  			pptr = &commit_list_insert(j->item, pptr)->next;
  	}
 -	free_commit_list(remoteheads);
  	strbuf_addch(&merge_msg, '\n');
 +	prepare_to_commit();
 +	free_commit_list(remoteheads);
  	commit_tree(merge_msg.buf, result_tree, parents, result_commit, NULL);
 -	strbuf_addf(&buf, "Merge made by %s.", wt_strategy);
 -	finish(result_commit, buf.buf);
 +	strbuf_addf(&buf, "Merge made by the '%s' strategy.", wt_strategy);
 +	finish(head, result_commit, buf.buf);
  	strbuf_release(&buf);
  	drop_save();
  	return 0;
  }
  
 -static int suggest_conflicts(void)
 +static int suggest_conflicts(int renormalizing)
  {
 +	const char *filename;
  	FILE *fp;
  	int pos;
  
 -	fp = fopen(git_path("MERGE_MSG"), "a");
 +	filename = git_path("MERGE_MSG");
 +	fp = fopen(filename, "a");
  	if (!fp)
 -		die_errno("Could not open '%s' for writing",
 -			  git_path("MERGE_MSG"));
 +		die_errno(_("Could not open '%s' for writing"), filename);
  	fprintf(fp, "\nConflicts:\n");
  	for (pos = 0; pos < active_nr; pos++) {
  		struct cache_entry *ce = active_cache[pos];
@@@ -976,13 -830,12 +976,13 @@@
  	}
  	fclose(fp);
  	rerere(allow_rerere_auto);
 -	printf("Automatic merge failed; "
 -			"fix conflicts and then commit the result.\n");
 +	printf(_("Automatic merge failed; "
 +			"fix conflicts and then commit the result.\n"));
  	return 1;
  }
  
 -static struct commit *is_old_style_invocation(int argc, const char **argv)
 +static struct commit *is_old_style_invocation(int argc, const char **argv,
 +					      const unsigned char *head)
  {
  	struct commit *second_token = NULL;
  	if (argc > 2) {
@@@ -992,7 -845,7 +992,7 @@@
  			return NULL;
  		second_token = lookup_commit_reference_gently(second_sha1, 0);
  		if (!second_token)
 -			die("'%s' is not a commit", argv[1]);
 +			die(_("'%s' is not a commit"), argv[1]);
  		if (hashcmp(second_token->object.sha1, head))
  			return NULL;
  	}
@@@ -1022,158 -875,63 +1022,158 @@@ static int evaluate_result(void
  	return cnt;
  }
  
 +/*
 + * Pretend as if the user told us to merge with the tracking
 + * branch we have for the upstream of the current branch
 + */
 +static int setup_with_upstream(const char ***argv)
 +{
 +	struct branch *branch = branch_get(NULL);
 +	int i;
 +	const char **args;
 +
 +	if (!branch)
 +		die(_("No current branch."));
 +	if (!branch->remote)
 +		die(_("No remote for the current branch."));
 +	if (!branch->merge_nr)
 +		die(_("No default upstream defined for the current branch."));
 +
 +	args = xcalloc(branch->merge_nr + 1, sizeof(char *));
 +	for (i = 0; i < branch->merge_nr; i++) {
 +		if (!branch->merge[i]->dst)
 +			die(_("No remote tracking branch for %s from %s"),
 +			    branch->merge[i]->src, branch->remote_name);
 +		args[i] = branch->merge[i]->dst;
 +	}
 +	args[i] = NULL;
 +	*argv = args;
 +	return i;
 +}
 +
 +static void write_merge_state(void)
 +{
 +	const char *filename;
 +	int fd;
 +	struct commit_list *j;
 +	struct strbuf buf = STRBUF_INIT;
 +
 +	for (j = remoteheads; j; j = j->next)
 +		strbuf_addf(&buf, "%s\n",
 +			sha1_to_hex(j->item->object.sha1));
 +	filename = git_path("MERGE_HEAD");
 +	fd = open(filename, O_WRONLY | O_CREAT, 0666);
 +	if (fd < 0)
 +		die_errno(_("Could not open '%s' for writing"), filename);
 +	if (write_in_full(fd, buf.buf, buf.len) != buf.len)
 +		die_errno(_("Could not write to '%s'"), filename);
 +	close(fd);
 +	strbuf_addch(&merge_msg, '\n');
 +	write_merge_msg(&merge_msg);
 +
 +	filename = git_path("MERGE_MODE");
 +	fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 +	if (fd < 0)
 +		die_errno(_("Could not open '%s' for writing"), filename);
 +	strbuf_reset(&buf);
 +	if (!allow_fast_forward)
 +		strbuf_addf(&buf, "no-ff");
 +	if (write_in_full(fd, buf.buf, buf.len) != buf.len)
 +		die_errno(_("Could not write to '%s'"), filename);
 +	close(fd);
 +}
 +
  int cmd_merge(int argc, const char **argv, const char *prefix)
  {
  	unsigned char result_tree[20];
 +	unsigned char stash[20];
 +	unsigned char head_sha1[20];
 +	struct commit *head_commit;
  	struct strbuf buf = STRBUF_INIT;
  	const char *head_arg;
 -	int flag, head_invalid = 0, i;
 +	int flag, i;
  	int best_cnt = -1, merge_was_ok = 0, automerge_was_ok = 0;
  	struct commit_list *common = NULL;
  	const char *best_strategy = NULL, *wt_strategy = NULL;
  	struct commit_list **remotes = &remoteheads;
  
 -	if (read_cache_unmerged()) {
 -		die_resolve_conflict("merge");
 -	}
 -	if (file_exists(git_path("MERGE_HEAD"))) {
 -		/*
 -		 * There is no unmerged entry, don't advise 'git
 -		 * add/rm <file>', just 'git commit'.
 -		 */
 -		if (advice_resolve_conflict)
 -			die("You have not concluded your merge (MERGE_HEAD exists).\n"
 -			    "Please, commit your changes before you can merge.");
 -		else
 -			die("You have not concluded your merge (MERGE_HEAD exists).");
 -	}
 +	if (argc == 2 && !strcmp(argv[1], "-h"))
 +		usage_with_options(builtin_merge_usage, builtin_merge_options);
  
 -	resolve_undo_clear();
  	/*
  	 * Check if we are _not_ on a detached HEAD, i.e. if there is a
  	 * current branch.
  	 */
 -	branch = resolve_ref("HEAD", head, 0, &flag);
 +	branch = resolve_ref("HEAD", head_sha1, 0, &flag);
  	if (branch && !prefixcmp(branch, "refs/heads/"))
  		branch += 11;
 -	if (is_null_sha1(head))
 -		head_invalid = 1;
 +	if (!branch || is_null_sha1(head_sha1))
 +		head_commit = NULL;
 +	else
 +		head_commit = lookup_commit_or_die(head_sha1, "HEAD");
  
  	git_config(git_merge_config, NULL);
  
 -	/* for color.ui */
 -	if (diff_use_color_default == -1)
 -		diff_use_color_default = git_use_color_default;
 -
 +	if (branch_mergeoptions)
 +		parse_branch_merge_options(branch_mergeoptions);
  	argc = parse_options(argc, argv, prefix, builtin_merge_options,
  			builtin_merge_usage, 0);
 +
 +	if (verbosity < 0 && show_progress == -1)
 +		show_progress = 0;
 +
 +	if (abort_current_merge) {
 +		int nargc = 2;
 +		const char *nargv[] = {"reset", "--merge", NULL};
 +
 +		if (!file_exists(git_path("MERGE_HEAD")))
 +			die(_("There is no merge to abort (MERGE_HEAD missing)."));
 +
 +		/* Invoke 'git reset --merge' */
 +		return cmd_reset(nargc, nargv, prefix);
 +	}
 +
 +	if (read_cache_unmerged())
 +		die_resolve_conflict("merge");
 +
 +	if (file_exists(git_path("MERGE_HEAD"))) {
 +		/*
 +		 * There is no unmerged entry, don't advise 'git
 +		 * add/rm <file>', just 'git commit'.
 +		 */
 +		if (advice_resolve_conflict)
 +			die(_("You have not concluded your merge (MERGE_HEAD exists).\n"
 +				  "Please, commit your changes before you can merge."));
 +		else
 +			die(_("You have not concluded your merge (MERGE_HEAD exists)."));
 +	}
 +	if (file_exists(git_path("CHERRY_PICK_HEAD"))) {
 +		if (advice_resolve_conflict)
 +			die(_("You have not concluded your cherry-pick (CHERRY_PICK_HEAD exists).\n"
 +			    "Please, commit your changes before you can merge."));
 +		else
 +			die(_("You have not concluded your cherry-pick (CHERRY_PICK_HEAD exists)."));
 +	}
 +	resolve_undo_clear();
 +
  	if (verbosity < 0)
  		show_diffstat = 0;
  
  	if (squash) {
  		if (!allow_fast_forward)
 -			die("You cannot combine --squash with --no-ff.");
 +			die(_("You cannot combine --squash with --no-ff."));
  		option_commit = 0;
  	}
  
  	if (!allow_fast_forward && fast_forward_only)
 -		die("You cannot combine --no-ff with --ff-only.");
 +		die(_("You cannot combine --no-ff with --ff-only."));
  
 +	if (!abort_current_merge) {
 +		if (!argc && default_to_upstream)
 +			argc = setup_with_upstream(&argv);
 +		else if (argc == 1 && !strcmp(argv[0], "-"))
 +			argv[0] = "@{-1}";
 +	}
  	if (!argc)
  		usage_with_options(builtin_merge_usage,
  			builtin_merge_options);
@@@ -1187,13 -945,12 +1187,13 @@@
  	 * additional safety measure to check for it.
  	 */
  
 -	if (!have_message && is_old_style_invocation(argc, argv)) {
 +	if (!have_message && head_commit &&
 +	    is_old_style_invocation(argc, argv, head_commit->object.sha1)) {
  		strbuf_addstr(&merge_msg, argv[0]);
  		head_arg = argv[1];
  		argv += 2;
  		argc -= 2;
 -	} else if (head_invalid) {
 +	} else if (!head_commit) {
  		struct object *remote_head;
  		/*
  		 * If the merged head is a valid one there is no reason
@@@ -1201,22 -958,22 +1201,22 @@@
  		 * We do the same for "git pull".
  		 */
  		if (argc != 1)
 -			die("Can merge only exactly one commit into "
 -				"empty head");
 +			die(_("Can merge only exactly one commit into "
 +				"empty head"));
  		if (squash)
 -			die("Squash commit into empty head not supported yet");
 +			die(_("Squash commit into empty head not supported yet"));
  		if (!allow_fast_forward)
 -			die("Non-fast-forward commit does not make sense into "
 -			    "an empty head");
 -		remote_head = peel_to_type(argv[0], 0, NULL, OBJ_COMMIT);
 +			die(_("Non-fast-forward commit does not make sense into "
 +			    "an empty head"));
 +		remote_head = want_commit(argv[0]);
  		if (!remote_head)
 -			die("%s - not something we can merge", argv[0]);
 +			die(_("%s - not something we can merge"), argv[0]);
 +		read_empty(remote_head->sha1, 0);
  		update_ref("initial pull", "HEAD", remote_head->sha1, NULL, 0,
  				DIE_ON_ERR);
 -		reset_hard(remote_head->sha1, 0);
  		return 0;
  	} else {
 -		struct strbuf msg = STRBUF_INIT;
 +		struct strbuf merge_names = STRBUF_INIT;
  
  		/* We are invoked directly as the first-class UI. */
  		head_arg = "HEAD";
@@@ -1229,18 -986,16 +1229,18 @@@
  		 * codepath so we discard the error in this
  		 * loop.
  		 */
 -		if (!have_message) {
 -			for (i = 0; i < argc; i++)
 -				merge_name(argv[i], &msg);
 -			fmt_merge_msg(option_log, &msg, &merge_msg);
 +		for (i = 0; i < argc; i++)
 +			merge_name(argv[i], &merge_names);
 +
 +		if (!have_message || shortlog_len) {
 +			fmt_merge_msg(&merge_names, &merge_msg, !have_message,
 +				      shortlog_len);
  			if (merge_msg.len)
 -				strbuf_setlen(&merge_msg, merge_msg.len-1);
 +				strbuf_setlen(&merge_msg, merge_msg.len - 1);
  		}
  	}
  
 -	if (head_invalid || !argc)
 +	if (!head_commit || !argc)
  		usage_with_options(builtin_merge_usage,
  			builtin_merge_options);
  
@@@ -1254,9 -1009,9 +1254,9 @@@
  		struct object *o;
  		struct commit *commit;
  
 -		o = peel_to_type(argv[i], 0, NULL, OBJ_COMMIT);
 +		o = want_commit(argv[i]);
  		if (!o)
 -			die("%s - not something we can merge", argv[i]);
 +			die(_("%s - not something we can merge"), argv[i]);
  		commit = lookup_commit(o->sha1);
  		commit->util = (void *)argv[i];
  		remotes = &commit_list_insert(commit, remotes)->next;
@@@ -1281,16 -1036,17 +1281,16 @@@
  	}
  
  	if (!remoteheads->next)
 -		common = get_merge_bases(lookup_commit(head),
 -				remoteheads->item, 1);
 +		common = get_merge_bases(head_commit, remoteheads->item, 1);
  	else {
  		struct commit_list *list = remoteheads;
 -		commit_list_insert(lookup_commit(head), &list);
 +		commit_list_insert(head_commit, &list);
  		common = get_octopus_merge_bases(list);
  		free(list);
  	}
  
 -	update_ref("updating ORIG_HEAD", "ORIG_HEAD", head, NULL, 0,
 -		DIE_ON_ERR);
 +	update_ref("updating ORIG_HEAD", "ORIG_HEAD", head_commit->object.sha1,
 +		   NULL, 0, DIE_ON_ERR);
  
  	if (!common)
  		; /* No common ancestors found. We need a real merge. */
@@@ -1304,16 -1060,16 +1304,16 @@@
  		return 0;
  	} else if (allow_fast_forward && !remoteheads->next &&
  			!common->next &&
 -			!hashcmp(common->item->object.sha1, head)) {
 +			!hashcmp(common->item->object.sha1, head_commit->object.sha1)) {
  		/* Again the most common case of merging one remote. */
  		struct strbuf msg = STRBUF_INIT;
  		struct object *o;
  		char hex[41];
  
 -		strcpy(hex, find_unique_abbrev(head, DEFAULT_ABBREV));
 +		strcpy(hex, find_unique_abbrev(head_commit->object.sha1, DEFAULT_ABBREV));
  
  		if (verbosity >= 0)
 -			printf("Updating %s..%s\n",
 +			printf(_("Updating %s..%s\n"),
  				hex,
  				find_unique_abbrev(remoteheads->item->object.sha1,
  				DEFAULT_ABBREV));
@@@ -1321,14 -1077,15 +1321,14 @@@
  		if (have_message)
  			strbuf_addstr(&msg,
  				" (no commit created; -m option ignored)");
 -		o = peel_to_type(sha1_to_hex(remoteheads->item->object.sha1),
 -			0, NULL, OBJ_COMMIT);
 +		o = want_commit(sha1_to_hex(remoteheads->item->object.sha1));
  		if (!o)
  			return 1;
  
 -		if (checkout_fast_forward(head, remoteheads->item->object.sha1))
 +		if (checkout_fast_forward(head_commit->object.sha1, remoteheads->item->object.sha1))
  			return 1;
  
 -		finish(o->sha1, msg.buf);
 +		finish(head_commit, o->sha1, msg.buf);
  		drop_save();
  		return 0;
  	} else if (!remoteheads->next && common->next)
@@@ -1346,11 -1103,11 +1346,11 @@@
  		if (allow_trivial && !fast_forward_only) {
  			/* See if it is really trivial. */
  			git_committer_info(IDENT_ERROR_ON_NO_NAME);
 -			printf("Trying really trivial in-index merge...\n");
 +			printf(_("Trying really trivial in-index merge...\n"));
  			if (!read_tree_trivial(common->item->object.sha1,
 -					head, remoteheads->item->object.sha1))
 -				return merge_trivial();
 -			printf("Nope.\n");
 +					head_commit->object.sha1, remoteheads->item->object.sha1))
 +				return merge_trivial(head_commit);
 +			printf(_("Nope.\n"));
  		}
  	} else {
  		/*
@@@ -1368,7 -1125,8 +1368,7 @@@
  			 * merge_bases again, otherwise "git merge HEAD^
  			 * HEAD^^" would be missed.
  			 */
 -			common_one = get_merge_bases(lookup_commit(head),
 -				j->item, 1);
 +			common_one = get_merge_bases(head_commit, j->item, 1);
  			if (hashcmp(common_one->item->object.sha1,
  				j->item->object.sha1)) {
  				up_to_date = 0;
@@@ -1382,7 -1140,7 +1382,7 @@@
  	}
  
  	if (fast_forward_only)
 -		die("Not possible to fast-forward, aborting.");
 +		die(_("Not possible to fast-forward, aborting."));
  
  	/* We are going to make a new commit. */
  	git_committer_info(IDENT_ERROR_ON_NO_NAME);
@@@ -1395,21 -1153,24 +1395,21 @@@
  	 * sync with the head commit.  The strategies are responsible
  	 * to ensure this.
  	 */
 -	if (use_strategies_nr != 1) {
 -		/*
 -		 * Stash away the local changes so that we can try more
 -		 * than one.
 -		 */
 -		save_state();
 -	} else {
 -		memcpy(stash, null_sha1, 20);
 -	}
 +	if (use_strategies_nr == 1 ||
 +	    /*
 +	     * Stash away the local changes so that we can try more than one.
 +	     */
 +	    save_state(stash))
 +		hashcpy(stash, null_sha1);
  
  	for (i = 0; i < use_strategies_nr; i++) {
  		int ret;
  		if (i) {
 -			printf("Rewinding the tree to pristine...\n");
 -			restore_state();
 +			printf(_("Rewinding the tree to pristine...\n"));
 +			restore_state(head_commit->object.sha1, stash);
  		}
  		if (use_strategies_nr != 1)
 -			printf("Trying merge strategy %s...\n",
 +			printf(_("Trying merge strategy %s...\n"),
  				use_strategies[i]->name);
  		/*
  		 * Remember which strategy left the state in the working
@@@ -1418,7 -1179,7 +1418,7 @@@
  		wt_strategy = use_strategies[i]->name;
  
  		ret = try_merge_strategy(use_strategies[i]->name,
 -			common, head_arg);
 +					 common, head_commit, head_arg);
  		if (!option_commit && !ret) {
  			merge_was_ok = 1;
  			/*
@@@ -1460,41 -1221,72 +1460,41 @@@
  	 * auto resolved the merge cleanly.
  	 */
  	if (automerge_was_ok)
 -		return finish_automerge(common, result_tree, wt_strategy);
 +		return finish_automerge(head_commit, common, result_tree,
 +					wt_strategy);
  
  	/*
  	 * Pick the result from the best strategy and have the user fix
  	 * it up.
  	 */
  	if (!best_strategy) {
 -		restore_state();
 +		restore_state(head_commit->object.sha1, stash);
  		if (use_strategies_nr > 1)
  			fprintf(stderr,
 -				"No merge strategy handled the merge.\n");
 +				_("No merge strategy handled the merge.\n"));
  		else
 -			fprintf(stderr, "Merge with strategy %s failed.\n",
 +			fprintf(stderr, _("Merge with strategy %s failed.\n"),
  				use_strategies[0]->name);
  		return 2;
  	} else if (best_strategy == wt_strategy)
  		; /* We already have its result in the working tree. */
  	else {
 -		printf("Rewinding the tree to pristine...\n");
 -		restore_state();
 -		printf("Using the %s to prepare resolving by hand.\n",
 +		printf(_("Rewinding the tree to pristine...\n"));
 +		restore_state(head_commit->object.sha1, stash);
 +		printf(_("Using the %s to prepare resolving by hand.\n"),
  			best_strategy);
 -		try_merge_strategy(best_strategy, common, head_arg);
 +		try_merge_strategy(best_strategy, common, head_commit, head_arg);
  	}
  
  	if (squash)
 -		finish(NULL, NULL);
 -	else {
 -		int fd;
 -		struct commit_list *j;
 -
 -		for (j = remoteheads; j; j = j->next)
 -			strbuf_addf(&buf, "%s\n",
 -				sha1_to_hex(j->item->object.sha1));
 -		fd = open(git_path("MERGE_HEAD"), O_WRONLY | O_CREAT, 0666);
 -		if (fd < 0)
 -			die_errno("Could not open '%s' for writing",
 -				  git_path("MERGE_HEAD"));
 -		if (write_in_full(fd, buf.buf, buf.len) != buf.len)
 -			die_errno("Could not write to '%s'", git_path("MERGE_HEAD"));
 -		close(fd);
 -		strbuf_addch(&merge_msg, '\n');
 -		fd = open(git_path("MERGE_MSG"), O_WRONLY | O_CREAT, 0666);
 -		if (fd < 0)
 -			die_errno("Could not open '%s' for writing",
 -				  git_path("MERGE_MSG"));
 -		if (write_in_full(fd, merge_msg.buf, merge_msg.len) !=
 -			merge_msg.len)
 -			die_errno("Could not write to '%s'", git_path("MERGE_MSG"));
 -		close(fd);
 -		fd = open(git_path("MERGE_MODE"), O_WRONLY | O_CREAT | O_TRUNC, 0666);
 -		if (fd < 0)
 -			die_errno("Could not open '%s' for writing",
 -				  git_path("MERGE_MODE"));
 -		strbuf_reset(&buf);
 -		if (!allow_fast_forward)
 -			strbuf_addf(&buf, "no-ff");
 -		if (write_in_full(fd, buf.buf, buf.len) != buf.len)
 -			die_errno("Could not write to '%s'", git_path("MERGE_MODE"));
 -		close(fd);
 -	}
 +		finish(head_commit, NULL, NULL);
 +	else
 +		write_merge_state();
  
  	if (merge_was_ok) {
 -		fprintf(stderr, "Automatic merge went well; "
 -			"stopped before committing as requested\n");
 +		fprintf(stderr, _("Automatic merge went well; "
 +			"stopped before committing as requested\n"));
  		return 0;
  	} else
 -		return suggest_conflicts();
 +		return suggest_conflicts(option_renormalize);
  }