From: Junio C Hamano <gitster@pobox.com>
Date: Mon, 3 Aug 2015 18:01:27 +0000 (-0700)
Subject: Merge branch 'jk/date-mode-format'
X-Git-Tag: v2.6.0-rc0~90
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/d939af12bd96db7ad3e671a0585ad8570aa7e9d3?hp=-c

Merge branch 'jk/date-mode-format'

Teach "git log" and friends a new "--date=format:..." option to
format timestamps using system's strftime(3).

* jk/date-mode-format:
strbuf: make strbuf_addftime more robust
introduce "format" date-mode
convert "enum date_mode" into a struct
show-branch: use DATE_RELATIVE instead of magic number
---

d939af12bd96db7ad3e671a0585ad8570aa7e9d3
diff --combined archive.c
index 936a5945dd,30bda56d15..01b0899b3f
--- a/archive.c
+++ b/archive.c
@@@ -1,5 -1,4 +1,5 @@@
  #include "cache.h"
 +#include "refs.h"
  #include "commit.h"
  #include "tree-walk.h"
  #include "attr.h"
@@@ -34,7 -33,7 +34,7 @@@ static void format_subst(const struct c
  	char *to_free = NULL;
  	struct strbuf fmt = STRBUF_INIT;
  	struct pretty_print_context ctx = {0};
- 	ctx.date_mode = DATE_NORMAL;
+ 	ctx.date_mode.type = DATE_NORMAL;
  	ctx.abbrev = DEFAULT_ABBREV;
  
  	if (src == buf->buf)
diff --combined builtin/blame.c
index 272a222687,7cc499dd34..04e4864f8b
--- a/builtin/blame.c
+++ b/builtin/blame.c
@@@ -6,7 -6,6 +6,7 @@@
   */
  
  #include "cache.h"
 +#include "refs.h"
  #include "builtin.h"
  #include "blob.h"
  #include "commit.h"
@@@ -51,7 -50,7 +51,7 @@@ static int xdl_opts
  static int abbrev = -1;
  static int no_whole_file_rename;
  
- static enum date_mode blame_date_mode = DATE_ISO8601;
+ static struct date_mode blame_date_mode = { DATE_ISO8601 };
  static size_t blame_date_width;
  
  static struct string_list mailmap;
@@@ -1828,7 -1827,7 +1828,7 @@@ static const char *format_time(unsigne
  		size_t time_width;
  		int tz;
  		tz = atoi(tz_str);
- 		time_str = show_date(time, tz, blame_date_mode);
+ 		time_str = show_date(time, tz, &blame_date_mode);
  		strbuf_addstr(&time_buf, time_str);
  		/*
  		 * Add space paddings to time_buf to display a fixed width
@@@ -2188,7 -2187,7 +2188,7 @@@ static int git_blame_config(const char 
  	if (!strcmp(var, "blame.date")) {
  		if (!value)
  			return config_error_nonbool(var);
- 		blame_date_mode = parse_date_format(value);
+ 		parse_date_format(value, &blame_date_mode);
  		return 0;
  	}
  
@@@ -2570,13 -2569,13 +2570,13 @@@ parse_done
  
  	if (cmd_is_annotate) {
  		output_option |= OUTPUT_ANNOTATE_COMPAT;
- 		blame_date_mode = DATE_ISO8601;
+ 		blame_date_mode.type = DATE_ISO8601;
  	} else {
  		blame_date_mode = revs.date_mode;
  	}
  
  	/* The maximum width used to show the dates */
- 	switch (blame_date_mode) {
+ 	switch (blame_date_mode.type) {
  	case DATE_RFC2822:
  		blame_date_width = sizeof("Thu, 19 Oct 2006 16:00:04 -0700");
  		break;
@@@ -2605,6 -2604,9 +2605,9 @@@
  	case DATE_NORMAL:
  		blame_date_width = sizeof("Thu Oct 19 16:00:04 2006 -0700");
  		break;
+ 	case DATE_STRFTIME:
+ 		blame_date_width = strlen(show_date(0, 0, &blame_date_mode)) + 1; /* add the null */
+ 		break;
  	}
  	blame_date_width -= 1; /* strip the null */
  
diff --combined builtin/log.c
index c851c7cc23,b101558bb2..b50ef7510c
--- a/builtin/log.c
+++ b/builtin/log.c
@@@ -5,7 -5,6 +5,7 @@@
   *		 2006 Junio Hamano
   */
  #include "cache.h"
 +#include "refs.h"
  #include "color.h"
  #include "commit.h"
  #include "diff.h"
@@@ -32,7 -31,6 +32,7 @@@ static const char *default_date_mode = 
  
  static int default_abbrev_commit;
  static int default_show_root = 1;
 +static int default_follow;
  static int decoration_style;
  static int decoration_given;
  static int use_mailmap_config;
@@@ -104,8 -102,6 +104,8 @@@ static void cmd_log_init_defaults(struc
  {
  	if (fmt_pretty)
  		get_commit_format(fmt_pretty, rev);
 +	if (default_follow)
 +		DIFF_OPT_SET(&rev->diffopt, DEFAULT_FOLLOW_RENAMES);
  	rev->verbose_header = 1;
  	DIFF_OPT_SET(&rev->diffopt, RECURSIVE);
  	rev->diffopt.stat_width = -1; /* use full terminal width */
@@@ -116,7 -112,7 +116,7 @@@
  	DIFF_OPT_SET(&rev->diffopt, ALLOW_TEXTCONV);
  
  	if (default_date_mode)
- 		rev->date_mode = parse_date_format(default_date_mode);
+ 		parse_date_format(default_date_mode, &rev->date_mode);
  	rev->diffopt.touched_flags = 0;
  }
  
@@@ -394,10 -390,6 +394,10 @@@ static int git_log_config(const char *v
  		default_show_root = git_config_bool(var, value);
  		return 0;
  	}
 +	if (!strcmp(var, "log.follow")) {
 +		default_follow = git_config_bool(var, value);
 +		return 0;
 +	}
  	if (skip_prefix(var, "color.decorate.", &slot_name))
  		return parse_decorate_color_config(var, slot_name, value);
  	if (!strcmp(var, "log.mailmap")) {
@@@ -626,14 -618,6 +626,14 @@@ int cmd_log_reflog(int argc, const cha
  	return cmd_log_walk(&rev);
  }
  
 +static void default_follow_tweak(struct rev_info *rev,
 +				 struct setup_revision_opt *opt)
 +{
 +	if (DIFF_OPT_TST(&rev->diffopt, DEFAULT_FOLLOW_RENAMES) &&
 +	    rev->prune_data.nr == 1)
 +		DIFF_OPT_SET(&rev->diffopt, FOLLOW_RENAMES);
 +}
 +
  int cmd_log(int argc, const char **argv, const char *prefix)
  {
  	struct rev_info rev;
@@@ -647,7 -631,6 +647,7 @@@
  	memset(&opt, 0, sizeof(opt));
  	opt.def = "HEAD";
  	opt.revarg_opt = REVARG_COMMITTISH;
 +	opt.tweak = default_follow_tweak;
  	cmd_log_init(argc, argv, prefix, &rev, &opt);
  	return cmd_log_walk(&rev);
  }
@@@ -956,7 -939,7 +956,7 @@@ static void make_cover_letter(struct re
  
  	msg = body;
  	pp.fmt = CMIT_FMT_EMAIL;
- 	pp.date_mode = DATE_RFC2822;
+ 	pp.date_mode.type = DATE_RFC2822;
  	pp_user_info(&pp, NULL, &sb, committer, encoding);
  	pp_title_line(&pp, &msg, &sb, encoding, need_8bit_cte);
  	pp_remainder(&pp, &msg, &sb, 0);
diff --combined cache.h
index 6997b2cd47,04c1907d52..6bb7119032
--- a/cache.h
+++ b/cache.h
@@@ -397,7 -397,6 +397,7 @@@ static inline enum object_type object_t
  #define EXEC_PATH_ENVIRONMENT "GIT_EXEC_PATH"
  #define CEILING_DIRECTORIES_ENVIRONMENT "GIT_CEILING_DIRECTORIES"
  #define NO_REPLACE_OBJECTS_ENVIRONMENT "GIT_NO_REPLACE_OBJECTS"
 +#define GIT_REPLACE_REF_BASE_ENVIRONMENT "GIT_REPLACE_REF_BASE"
  #define GITATTRIBUTES_FILE ".gitattributes"
  #define INFOATTRIBUTES_FILE "info/attributes"
  #define ATTRIBUTE_MACRO_PREFIX "[attr]"
@@@ -447,17 -446,7 +447,17 @@@ extern int get_common_dir(struct strbu
  extern const char *get_git_namespace(void);
  extern const char *strip_namespace(const char *namespaced_ref);
  extern const char *get_git_work_tree(void);
 -extern const char *read_gitfile(const char *path);
 +
 +#define READ_GITFILE_ERR_STAT_FAILED 1
 +#define READ_GITFILE_ERR_NOT_A_FILE 2
 +#define READ_GITFILE_ERR_OPEN_FAILED 3
 +#define READ_GITFILE_ERR_READ_FAILED 4
 +#define READ_GITFILE_ERR_INVALID_FORMAT 5
 +#define READ_GITFILE_ERR_NO_PATH 6
 +#define READ_GITFILE_ERR_NOT_A_REPO 7
 +#define READ_GITFILE_ERR_TOO_LARGE 8
 +extern const char *read_gitfile_gently(const char *path, int *return_error_code);
 +#define read_gitfile(path) read_gitfile_gently((path), NULL)
  extern const char *resolve_gitdir(const char *suspect);
  extern void set_git_work_tree(const char *tree);
  
@@@ -596,6 -585,8 +596,6 @@@ extern void update_index_if_able(struc
  extern int hold_locked_index(struct lock_file *, int);
  extern void set_alternate_index_output(const char *);
  
 -extern int delete_ref(const char *, const unsigned char *sha1, unsigned int flags);
 -
  /* Environment bits from configuration mechanism */
  extern int trust_executable_bit;
  extern int trust_ctime;
@@@ -631,7 -622,6 +631,7 @@@ extern unsigned long pack_size_limit_cf
   * been sought but there were none.
   */
  extern int check_replace_refs;
 +extern char *git_replace_ref_base;
  
  extern int fsync_object_files;
  extern int core_preload_index;
@@@ -1030,10 -1020,76 +1030,10 @@@ extern int get_oid_hex(const char *hex
  
  extern char *sha1_to_hex(const unsigned char *sha1);	/* static buffer result! */
  extern char *oid_to_hex(const struct object_id *oid);	/* same static buffer as sha1_to_hex */
 -extern int read_ref_full(const char *refname, int resolve_flags,
 -			 unsigned char *sha1, int *flags);
 -extern int read_ref(const char *refname, unsigned char *sha1);
  
 -/*
 - * Resolve a reference, recursively following symbolic refererences.
 - *
 - * Store the referred-to object's name in sha1 and return the name of
 - * the non-symbolic reference that ultimately pointed at it.  The
 - * return value, if not NULL, is a pointer into either a static buffer
 - * or the input ref.
 - *
 - * If the reference cannot be resolved to an object, the behavior
 - * depends on the RESOLVE_REF_READING flag:
 - *
 - * - If RESOLVE_REF_READING is set, return NULL.
 - *
 - * - If RESOLVE_REF_READING is not set, clear sha1 and return the name of
 - *   the last reference name in the chain, which will either be a non-symbolic
 - *   reference or an undefined reference.  If this is a prelude to
 - *   "writing" to the ref, the return value is the name of the ref
 - *   that will actually be created or changed.
 - *
 - * If the RESOLVE_REF_NO_RECURSE flag is passed, only resolves one
 - * level of symbolic reference.  The value stored in sha1 for a symbolic
 - * reference will always be null_sha1 in this case, and the return
 - * value is the reference that the symref refers to directly.
 - *
 - * If flags is non-NULL, set the value that it points to the
 - * combination of REF_ISPACKED (if the reference was found among the
 - * packed references), REF_ISSYMREF (if the initial reference was a
 - * symbolic reference), REF_BAD_NAME (if the reference name is ill
 - * formed --- see RESOLVE_REF_ALLOW_BAD_NAME below), and REF_ISBROKEN
 - * (if the ref is malformed or has a bad name). See refs.h for more detail
 - * on each flag.
 - *
 - * If ref is not a properly-formatted, normalized reference, return
 - * NULL.  If more than MAXDEPTH recursive symbolic lookups are needed,
 - * give up and return NULL.
 - *
 - * RESOLVE_REF_ALLOW_BAD_NAME allows resolving refs even when their
 - * name is invalid according to git-check-ref-format(1).  If the name
 - * is bad then the value stored in sha1 will be null_sha1 and the two
 - * flags REF_ISBROKEN and REF_BAD_NAME will be set.
 - *
 - * Even with RESOLVE_REF_ALLOW_BAD_NAME, names that escape the refs/
 - * directory and do not consist of all caps and underscores cannot be
 - * resolved. The function returns NULL for such ref names.
 - * Caps and underscores refers to the special refs, such as HEAD,
 - * FETCH_HEAD and friends, that all live outside of the refs/ directory.
 - */
 -#define RESOLVE_REF_READING 0x01
 -#define RESOLVE_REF_NO_RECURSE 0x02
 -#define RESOLVE_REF_ALLOW_BAD_NAME 0x04
 -extern const char *resolve_ref_unsafe(const char *ref, int resolve_flags, unsigned char *sha1, int *flags);
 -extern char *resolve_refdup(const char *ref, int resolve_flags, unsigned char *sha1, int *flags);
 -
 -extern int dwim_ref(const char *str, int len, unsigned char *sha1, char **ref);
 -extern int dwim_log(const char *str, int len, unsigned char *sha1, char **ref);
  extern int interpret_branch_name(const char *str, int len, struct strbuf *);
  extern int get_sha1_mb(const char *str, unsigned char *sha1);
  
 -/*
 - * Return true iff abbrev_name is a possible abbreviation for
 - * full_name according to the rules defined by ref_rev_parse_rules in
 - * refs.c.
 - */
 -extern int refname_match(const char *abbrev_name, const char *full_name);
 -
 -extern int create_symref(const char *ref, const char *refs_heads_master, const char *logmsg);
  extern int validate_headref(const char *ref);
  
  extern int base_name_compare(const char *name1, int len1, int mode1, const char *name2, int len2, int mode2);
@@@ -1049,18 -1105,30 +1049,30 @@@ extern void *read_object_with_reference
  extern struct object *peel_to_type(const char *name, int namelen,
  				   struct object *o, enum object_type);
  
- enum date_mode {
- 	DATE_NORMAL = 0,
- 	DATE_RELATIVE,
- 	DATE_SHORT,
- 	DATE_LOCAL,
- 	DATE_ISO8601,
- 	DATE_ISO8601_STRICT,
- 	DATE_RFC2822,
- 	DATE_RAW
+ struct date_mode {
+ 	enum date_mode_type {
+ 		DATE_NORMAL = 0,
+ 		DATE_RELATIVE,
+ 		DATE_SHORT,
+ 		DATE_LOCAL,
+ 		DATE_ISO8601,
+ 		DATE_ISO8601_STRICT,
+ 		DATE_RFC2822,
+ 		DATE_STRFTIME,
+ 		DATE_RAW
+ 	} type;
+ 	const char *strftime_fmt;
  };
  
- const char *show_date(unsigned long time, int timezone, enum date_mode mode);
+ /*
+  * Convenience helper for passing a constant type, like:
+  *
+  *   show_date(t, tz, DATE_MODE(NORMAL));
+  */
+ #define DATE_MODE(t) date_mode_from_type(DATE_##t)
+ struct date_mode *date_mode_from_type(enum date_mode_type type);
+ 
+ const char *show_date(unsigned long time, int timezone, const struct date_mode *mode);
  void show_date_relative(unsigned long time, int tz, const struct timeval *now,
  			struct strbuf *timebuf);
  int parse_date(const char *date, struct strbuf *out);
@@@ -1070,7 -1138,7 +1082,7 @@@ void datestamp(struct strbuf *out)
  #define approxidate(s) approxidate_careful((s), NULL)
  unsigned long approxidate_careful(const char *, int *);
  unsigned long approxidate_relative(const char *date, const struct timeval *now);
- enum date_mode parse_date_format(const char *format);
+ void parse_date_format(const char *format, struct date_mode *mode);
  int date_overflows(unsigned long date);
  
  #define IDENT_STRICT	       1
@@@ -1107,7 -1175,8 +1119,8 @@@ extern int split_ident_line(struct iden
   * the ident_split. It will also sanity-check the values and produce
   * a well-known sentinel date if they appear bogus.
   */
- const char *show_ident_date(const struct ident_split *id, enum date_mode mode);
+ const char *show_ident_date(const struct ident_split *id,
+ 			    const struct date_mode *mode);
  
  /*
   * Compare split idents for equality or strict ordering. Note that we
diff --combined commit.h
index 4983bdd3d3,1496882d7b..5d58be0017
--- a/commit.h
+++ b/commit.h
@@@ -145,7 -145,7 +145,7 @@@ struct pretty_print_context 
  	const char *subject;
  	const char *after_subject;
  	int preserve_subject;
- 	enum date_mode date_mode;
+ 	struct date_mode date_mode;
  	unsigned date_mode_explicit:1;
  	int need_8bit_cte;
  	char *notes_message;
@@@ -379,7 -379,7 +379,7 @@@ extern void print_commit_list(struct co
   * at all.  This may allocate memory for sig->gpg_output, sig->gpg_status,
   * sig->signer and sig->key.
   */
 -extern void check_commit_signature(const struct commit *commit, struct signature_check *sigc);
 +extern int check_commit_signature(const struct commit *commit, struct signature_check *sigc);
  
  int compare_commits_by_commit_date(const void *a_, const void *b_, void *unused);
  
diff --combined fast-import.c
index 6a0c0ac570,9363cc7829..2ad4fee07e
--- a/fast-import.c
+++ b/fast-import.c
@@@ -134,17 -134,16 +134,17 @@@ Format of STDIN stream
    ts    ::= # time since the epoch in seconds, ascii base10 notation;
    tz    ::= # GIT style timezone;
  
 -     # note: comments, ls and cat requests may appear anywhere
 -     # in the input, except within a data command.  Any form
 -     # of the data command always escapes the related input
 -     # from comment processing.
 +     # note: comments, get-mark, ls-tree, and cat-blob requests may
 +     # appear anywhere in the input, except within a data command. Any
 +     # form of the data command always escapes the related input from
 +     # comment processing.
       #
       # In case it is not clear, the '#' that starts the comment
       # must be the first character on that line (an lf
       # preceded it).
       #
  
 +  get_mark ::= 'get-mark' sp idnum lf;
    cat_blob ::= 'cat-blob' sp (hexsha1 | idnum) lf;
    ls_tree  ::= 'ls' sp (hexsha1 | idnum) sp path_str lf;
  
@@@ -373,7 -372,6 +373,7 @@@ static volatile sig_atomic_t checkpoint
  static int cat_blob_fd = STDOUT_FILENO;
  
  static void parse_argv(void);
 +static void parse_get_mark(const char *p);
  static void parse_cat_blob(const char *p);
  static void parse_ls(const char *p, struct branch *b);
  
@@@ -423,7 -421,7 +423,7 @@@ static void write_crash_report(const ch
  	fprintf(rpt, "fast-import crash report:\n");
  	fprintf(rpt, "    fast-import process: %"PRIuMAX"\n", (uintmax_t) getpid());
  	fprintf(rpt, "    parent process     : %"PRIuMAX"\n", (uintmax_t) getppid());
- 	fprintf(rpt, "    at %s\n", show_date(time(NULL), 0, DATE_LOCAL));
+ 	fprintf(rpt, "    at %s\n", show_date(time(NULL), 0, DATE_MODE(LOCAL)));
  	fputc('\n', rpt);
  
  	fputs("fatal: ", rpt);
@@@ -1694,13 -1692,13 +1694,13 @@@ static int update_branch(struct branch 
  	unsigned char old_sha1[20];
  	struct strbuf err = STRBUF_INIT;
  
 -	if (read_ref(b->name, old_sha1))
 -		hashclr(old_sha1);
  	if (is_null_sha1(b->sha1)) {
  		if (b->delete)
 -			delete_ref(b->name, old_sha1, 0);
 +			delete_ref(b->name, NULL, 0);
  		return 0;
  	}
 +	if (read_ref(b->name, old_sha1))
 +		hashclr(old_sha1);
  	if (!force_update && !is_null_sha1(old_sha1)) {
  		struct commit *old_cmit, *new_cmit;
  
@@@ -1909,10 -1907,6 +1909,10 @@@ static int read_next_command(void
  			rc->prev->next = rc;
  			cmd_tail = rc;
  		}
 +		if (skip_prefix(command_buf.buf, "get-mark ", &p)) {
 +			parse_get_mark(p);
 +			continue;
 +		}
  		if (skip_prefix(command_buf.buf, "cat-blob ", &p)) {
  			parse_cat_blob(p);
  			continue;
@@@ -2594,12 -2588,14 +2594,12 @@@ static int parse_from(struct branch *b
  {
  	const char *from;
  	struct branch *s;
 +	unsigned char sha1[20];
  
  	if (!skip_prefix(command_buf.buf, "from ", &from))
  		return 0;
  
 -	if (b->branch_tree.tree) {
 -		release_tree_content_recursive(b->branch_tree.tree);
 -		b->branch_tree.tree = NULL;
 -	}
 +	hashcpy(sha1, b->branch_tree.versions[1].sha1);
  
  	s = lookup_branch(from);
  	if (b == s)
@@@ -2614,16 -2610,14 +2614,16 @@@
  		struct object_entry *oe = find_mark(idnum);
  		if (oe->type != OBJ_COMMIT)
  			die("Mark :%" PRIuMAX " not a commit", idnum);
 -		hashcpy(b->sha1, oe->idx.sha1);
 -		if (oe->pack_id != MAX_PACK_ID) {
 -			unsigned long size;
 -			char *buf = gfi_unpack_entry(oe, &size);
 -			parse_from_commit(b, buf, size);
 -			free(buf);
 -		} else
 -			parse_from_existing(b);
 +		if (hashcmp(b->sha1, oe->idx.sha1)) {
 +			hashcpy(b->sha1, oe->idx.sha1);
 +			if (oe->pack_id != MAX_PACK_ID) {
 +				unsigned long size;
 +				char *buf = gfi_unpack_entry(oe, &size);
 +				parse_from_commit(b, buf, size);
 +				free(buf);
 +			} else
 +				parse_from_existing(b);
 +		}
  	} else if (!get_sha1(from, b->sha1)) {
  		parse_from_existing(b);
  		if (is_null_sha1(b->sha1))
@@@ -2632,11 -2626,6 +2632,11 @@@
  	else
  		die("Invalid ref name or SHA1 expression: %s", from);
  
 +	if (b->branch_tree.tree && hashcmp(sha1, b->branch_tree.versions[1].sha1)) {
 +		release_tree_content_recursive(b->branch_tree.tree);
 +		b->branch_tree.tree = NULL;
 +	}
 +
  	read_next_command();
  	return 1;
  }
@@@ -2930,23 -2919,6 +2930,23 @@@ static void cat_blob(struct object_entr
  		free(buf);
  }
  
 +static void parse_get_mark(const char *p)
 +{
 +	struct object_entry *oe = oe;
 +	char output[42];
 +
 +	/* get-mark SP <object> LF */
 +	if (*p != ':')
 +		die("Not a mark: %s", p);
 +
 +	oe = find_mark(parse_mark_ref_eol(p));
 +	if (!oe)
 +		die("Unknown mark: %s", command_buf.buf);
 +
 +	snprintf(output, sizeof(output), "%s\n", sha1_to_hex(oe->idx.sha1));
 +	cat_blob_write(output, 41);
 +}
 +
  static void parse_cat_blob(const char *p)
  {
  	struct object_entry *oe = oe;
@@@ -3268,8 -3240,6 +3268,8 @@@ static int parse_one_feature(const cha
  		option_import_marks(arg, from_stream, 1);
  	} else if (skip_prefix(feature, "export-marks=", &arg)) {
  		option_export_marks(arg);
 +	} else if (!strcmp(feature, "get-mark")) {
 +		; /* Don't die - this feature is supported */
  	} else if (!strcmp(feature, "cat-blob")) {
  		; /* Don't die - this feature is supported */
  	} else if (!strcmp(feature, "relative-marks")) {
diff --combined log-tree.c
index e2f6de73ef,e57e6b62cc..7b1b57aaf6
--- a/log-tree.c
+++ b/log-tree.c
@@@ -97,12 -97,11 +97,12 @@@ static int add_ref_decoration(const cha
  
  	assert(cb_data == NULL);
  
 -	if (starts_with(refname, "refs/replace/")) {
 +	if (starts_with(refname, git_replace_ref_base)) {
  		struct object_id original_oid;
  		if (!check_replace_refs)
  			return 0;
 -		if (get_oid_hex(refname + 13, &original_oid)) {
 +		if (get_oid_hex(refname + strlen(git_replace_ref_base),
 +				&original_oid)) {
  			warning("invalid replace ref %s", refname);
  			return 0;
  		}
@@@ -640,7 -639,7 +640,7 @@@ void show_log(struct rev_info *opt
  			 */
  			show_reflog_message(opt->reflog_info,
  					    opt->commit_format == CMIT_FMT_ONELINE,
- 					    opt->date_mode,
+ 					    &opt->date_mode,
  					    opt->date_mode_explicit);
  			if (opt->commit_format == CMIT_FMT_ONELINE)
  				return;
diff --combined ref-filter.c
index 6e09da88ca,0000000000..f38dee4f60
mode 100644,000000..100644
--- a/ref-filter.c
+++ b/ref-filter.c
@@@ -1,1106 -1,0 +1,1106 @@@
 +#include "builtin.h"
 +#include "cache.h"
 +#include "parse-options.h"
 +#include "refs.h"
 +#include "wildmatch.h"
 +#include "commit.h"
 +#include "remote.h"
 +#include "color.h"
 +#include "tag.h"
 +#include "quote.h"
 +#include "ref-filter.h"
 +
 +typedef enum { FIELD_STR, FIELD_ULONG, FIELD_TIME } cmp_type;
 +
 +static struct {
 +	const char *name;
 +	cmp_type cmp_type;
 +} valid_atom[] = {
 +	{ "refname" },
 +	{ "objecttype" },
 +	{ "objectsize", FIELD_ULONG },
 +	{ "objectname" },
 +	{ "tree" },
 +	{ "parent" },
 +	{ "numparent", FIELD_ULONG },
 +	{ "object" },
 +	{ "type" },
 +	{ "tag" },
 +	{ "author" },
 +	{ "authorname" },
 +	{ "authoremail" },
 +	{ "authordate", FIELD_TIME },
 +	{ "committer" },
 +	{ "committername" },
 +	{ "committeremail" },
 +	{ "committerdate", FIELD_TIME },
 +	{ "tagger" },
 +	{ "taggername" },
 +	{ "taggeremail" },
 +	{ "taggerdate", FIELD_TIME },
 +	{ "creator" },
 +	{ "creatordate", FIELD_TIME },
 +	{ "subject" },
 +	{ "body" },
 +	{ "contents" },
 +	{ "contents:subject" },
 +	{ "contents:body" },
 +	{ "contents:signature" },
 +	{ "upstream" },
 +	{ "push" },
 +	{ "symref" },
 +	{ "flag" },
 +	{ "HEAD" },
 +	{ "color" },
 +};
 +
 +/*
 + * An atom is a valid field atom listed above, possibly prefixed with
 + * a "*" to denote deref_tag().
 + *
 + * We parse given format string and sort specifiers, and make a list
 + * of properties that we need to extract out of objects.  ref_array_item
 + * structure will hold an array of values extracted that can be
 + * indexed with the "atom number", which is an index into this
 + * array.
 + */
 +static const char **used_atom;
 +static cmp_type *used_atom_type;
 +static int used_atom_cnt, need_tagged, need_symref;
 +static int need_color_reset_at_eol;
 +
 +/*
 + * Used to parse format string and sort specifiers
 + */
 +int parse_ref_filter_atom(const char *atom, const char *ep)
 +{
 +	const char *sp;
 +	int i, at;
 +
 +	sp = atom;
 +	if (*sp == '*' && sp < ep)
 +		sp++; /* deref */
 +	if (ep <= sp)
 +		die("malformed field name: %.*s", (int)(ep-atom), atom);
 +
 +	/* Do we have the atom already used elsewhere? */
 +	for (i = 0; i < used_atom_cnt; i++) {
 +		int len = strlen(used_atom[i]);
 +		if (len == ep - atom && !memcmp(used_atom[i], atom, len))
 +			return i;
 +	}
 +
 +	/* Is the atom a valid one? */
 +	for (i = 0; i < ARRAY_SIZE(valid_atom); i++) {
 +		int len = strlen(valid_atom[i].name);
 +		/*
 +		 * If the atom name has a colon, strip it and everything after
 +		 * it off - it specifies the format for this entry, and
 +		 * shouldn't be used for checking against the valid_atom
 +		 * table.
 +		 */
 +		const char *formatp = strchr(sp, ':');
 +		if (!formatp || ep < formatp)
 +			formatp = ep;
 +		if (len == formatp - sp && !memcmp(valid_atom[i].name, sp, len))
 +			break;
 +	}
 +
 +	if (ARRAY_SIZE(valid_atom) <= i)
 +		die("unknown field name: %.*s", (int)(ep-atom), atom);
 +
 +	/* Add it in, including the deref prefix */
 +	at = used_atom_cnt;
 +	used_atom_cnt++;
 +	REALLOC_ARRAY(used_atom, used_atom_cnt);
 +	REALLOC_ARRAY(used_atom_type, used_atom_cnt);
 +	used_atom[at] = xmemdupz(atom, ep - atom);
 +	used_atom_type[at] = valid_atom[i].cmp_type;
 +	if (*atom == '*')
 +		need_tagged = 1;
 +	if (!strcmp(used_atom[at], "symref"))
 +		need_symref = 1;
 +	return at;
 +}
 +
 +/*
 + * In a format string, find the next occurrence of %(atom).
 + */
 +static const char *find_next(const char *cp)
 +{
 +	while (*cp) {
 +		if (*cp == '%') {
 +			/*
 +			 * %( is the start of an atom;
 +			 * %% is a quoted per-cent.
 +			 */
 +			if (cp[1] == '(')
 +				return cp;
 +			else if (cp[1] == '%')
 +				cp++; /* skip over two % */
 +			/* otherwise this is a singleton, literal % */
 +		}
 +		cp++;
 +	}
 +	return NULL;
 +}
 +
 +/*
 + * Make sure the format string is well formed, and parse out
 + * the used atoms.
 + */
 +int verify_ref_format(const char *format)
 +{
 +	const char *cp, *sp;
 +
 +	need_color_reset_at_eol = 0;
 +	for (cp = format; *cp && (sp = find_next(cp)); ) {
 +		const char *color, *ep = strchr(sp, ')');
 +		int at;
 +
 +		if (!ep)
 +			return error("malformed format string %s", sp);
 +		/* sp points at "%(" and ep points at the closing ")" */
 +		at = parse_ref_filter_atom(sp + 2, ep);
 +		cp = ep + 1;
 +
 +		if (skip_prefix(used_atom[at], "color:", &color))
 +			need_color_reset_at_eol = !!strcmp(color, "reset");
 +	}
 +	return 0;
 +}
 +
 +/*
 + * Given an object name, read the object data and size, and return a
 + * "struct object".  If the object data we are returning is also borrowed
 + * by the "struct object" representation, set *eaten as well---it is a
 + * signal from parse_object_buffer to us not to free the buffer.
 + */
 +static void *get_obj(const unsigned char *sha1, struct object **obj, unsigned long *sz, int *eaten)
 +{
 +	enum object_type type;
 +	void *buf = read_sha1_file(sha1, &type, sz);
 +
 +	if (buf)
 +		*obj = parse_object_buffer(sha1, type, *sz, buf, eaten);
 +	else
 +		*obj = NULL;
 +	return buf;
 +}
 +
 +static int grab_objectname(const char *name, const unsigned char *sha1,
 +			    struct atom_value *v)
 +{
 +	if (!strcmp(name, "objectname")) {
 +		char *s = xmalloc(41);
 +		strcpy(s, sha1_to_hex(sha1));
 +		v->s = s;
 +		return 1;
 +	}
 +	if (!strcmp(name, "objectname:short")) {
 +		v->s = xstrdup(find_unique_abbrev(sha1, DEFAULT_ABBREV));
 +		return 1;
 +	}
 +	return 0;
 +}
 +
 +/* See grab_values */
 +static void grab_common_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
 +{
 +	int i;
 +
 +	for (i = 0; i < used_atom_cnt; i++) {
 +		const char *name = used_atom[i];
 +		struct atom_value *v = &val[i];
 +		if (!!deref != (*name == '*'))
 +			continue;
 +		if (deref)
 +			name++;
 +		if (!strcmp(name, "objecttype"))
 +			v->s = typename(obj->type);
 +		else if (!strcmp(name, "objectsize")) {
 +			char *s = xmalloc(40);
 +			sprintf(s, "%lu", sz);
 +			v->ul = sz;
 +			v->s = s;
 +		}
 +		else if (deref)
 +			grab_objectname(name, obj->sha1, v);
 +	}
 +}
 +
 +/* See grab_values */
 +static void grab_tag_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
 +{
 +	int i;
 +	struct tag *tag = (struct tag *) obj;
 +
 +	for (i = 0; i < used_atom_cnt; i++) {
 +		const char *name = used_atom[i];
 +		struct atom_value *v = &val[i];
 +		if (!!deref != (*name == '*'))
 +			continue;
 +		if (deref)
 +			name++;
 +		if (!strcmp(name, "tag"))
 +			v->s = tag->tag;
 +		else if (!strcmp(name, "type") && tag->tagged)
 +			v->s = typename(tag->tagged->type);
 +		else if (!strcmp(name, "object") && tag->tagged) {
 +			char *s = xmalloc(41);
 +			strcpy(s, sha1_to_hex(tag->tagged->sha1));
 +			v->s = s;
 +		}
 +	}
 +}
 +
 +/* See grab_values */
 +static void grab_commit_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
 +{
 +	int i;
 +	struct commit *commit = (struct commit *) obj;
 +
 +	for (i = 0; i < used_atom_cnt; i++) {
 +		const char *name = used_atom[i];
 +		struct atom_value *v = &val[i];
 +		if (!!deref != (*name == '*'))
 +			continue;
 +		if (deref)
 +			name++;
 +		if (!strcmp(name, "tree")) {
 +			char *s = xmalloc(41);
 +			strcpy(s, sha1_to_hex(commit->tree->object.sha1));
 +			v->s = s;
 +		}
 +		if (!strcmp(name, "numparent")) {
 +			char *s = xmalloc(40);
 +			v->ul = commit_list_count(commit->parents);
 +			sprintf(s, "%lu", v->ul);
 +			v->s = s;
 +		}
 +		else if (!strcmp(name, "parent")) {
 +			int num = commit_list_count(commit->parents);
 +			int i;
 +			struct commit_list *parents;
 +			char *s = xmalloc(41 * num + 1);
 +			v->s = s;
 +			for (i = 0, parents = commit->parents;
 +			     parents;
 +			     parents = parents->next, i = i + 41) {
 +				struct commit *parent = parents->item;
 +				strcpy(s+i, sha1_to_hex(parent->object.sha1));
 +				if (parents->next)
 +					s[i+40] = ' ';
 +			}
 +			if (!i)
 +				*s = '\0';
 +		}
 +	}
 +}
 +
 +static const char *find_wholine(const char *who, int wholen, const char *buf, unsigned long sz)
 +{
 +	const char *eol;
 +	while (*buf) {
 +		if (!strncmp(buf, who, wholen) &&
 +		    buf[wholen] == ' ')
 +			return buf + wholen + 1;
 +		eol = strchr(buf, '\n');
 +		if (!eol)
 +			return "";
 +		eol++;
 +		if (*eol == '\n')
 +			return ""; /* end of header */
 +		buf = eol;
 +	}
 +	return "";
 +}
 +
 +static const char *copy_line(const char *buf)
 +{
 +	const char *eol = strchrnul(buf, '\n');
 +	return xmemdupz(buf, eol - buf);
 +}
 +
 +static const char *copy_name(const char *buf)
 +{
 +	const char *cp;
 +	for (cp = buf; *cp && *cp != '\n'; cp++) {
 +		if (!strncmp(cp, " <", 2))
 +			return xmemdupz(buf, cp - buf);
 +	}
 +	return "";
 +}
 +
 +static const char *copy_email(const char *buf)
 +{
 +	const char *email = strchr(buf, '<');
 +	const char *eoemail;
 +	if (!email)
 +		return "";
 +	eoemail = strchr(email, '>');
 +	if (!eoemail)
 +		return "";
 +	return xmemdupz(email, eoemail + 1 - email);
 +}
 +
 +static char *copy_subject(const char *buf, unsigned long len)
 +{
 +	char *r = xmemdupz(buf, len);
 +	int i;
 +
 +	for (i = 0; i < len; i++)
 +		if (r[i] == '\n')
 +			r[i] = ' ';
 +
 +	return r;
 +}
 +
 +static void grab_date(const char *buf, struct atom_value *v, const char *atomname)
 +{
 +	const char *eoemail = strstr(buf, "> ");
 +	char *zone;
 +	unsigned long timestamp;
 +	long tz;
- 	enum date_mode date_mode = DATE_NORMAL;
++	struct date_mode date_mode = { DATE_NORMAL };
 +	const char *formatp;
 +
 +	/*
 +	 * We got here because atomname ends in "date" or "date<something>";
 +	 * it's not possible that <something> is not ":<format>" because
 +	 * parse_ref_filter_atom() wouldn't have allowed it, so we can assume that no
 +	 * ":" means no format is specified, and use the default.
 +	 */
 +	formatp = strchr(atomname, ':');
 +	if (formatp != NULL) {
 +		formatp++;
- 		date_mode = parse_date_format(formatp);
++		parse_date_format(formatp, &date_mode);
 +	}
 +
 +	if (!eoemail)
 +		goto bad;
 +	timestamp = strtoul(eoemail + 2, &zone, 10);
 +	if (timestamp == ULONG_MAX)
 +		goto bad;
 +	tz = strtol(zone, NULL, 10);
 +	if ((tz == LONG_MIN || tz == LONG_MAX) && errno == ERANGE)
 +		goto bad;
- 	v->s = xstrdup(show_date(timestamp, tz, date_mode));
++	v->s = xstrdup(show_date(timestamp, tz, &date_mode));
 +	v->ul = timestamp;
 +	return;
 + bad:
 +	v->s = "";
 +	v->ul = 0;
 +}
 +
 +/* See grab_values */
 +static void grab_person(const char *who, struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
 +{
 +	int i;
 +	int wholen = strlen(who);
 +	const char *wholine = NULL;
 +
 +	for (i = 0; i < used_atom_cnt; i++) {
 +		const char *name = used_atom[i];
 +		struct atom_value *v = &val[i];
 +		if (!!deref != (*name == '*'))
 +			continue;
 +		if (deref)
 +			name++;
 +		if (strncmp(who, name, wholen))
 +			continue;
 +		if (name[wholen] != 0 &&
 +		    strcmp(name + wholen, "name") &&
 +		    strcmp(name + wholen, "email") &&
 +		    !starts_with(name + wholen, "date"))
 +			continue;
 +		if (!wholine)
 +			wholine = find_wholine(who, wholen, buf, sz);
 +		if (!wholine)
 +			return; /* no point looking for it */
 +		if (name[wholen] == 0)
 +			v->s = copy_line(wholine);
 +		else if (!strcmp(name + wholen, "name"))
 +			v->s = copy_name(wholine);
 +		else if (!strcmp(name + wholen, "email"))
 +			v->s = copy_email(wholine);
 +		else if (starts_with(name + wholen, "date"))
 +			grab_date(wholine, v, name);
 +	}
 +
 +	/*
 +	 * For a tag or a commit object, if "creator" or "creatordate" is
 +	 * requested, do something special.
 +	 */
 +	if (strcmp(who, "tagger") && strcmp(who, "committer"))
 +		return; /* "author" for commit object is not wanted */
 +	if (!wholine)
 +		wholine = find_wholine(who, wholen, buf, sz);
 +	if (!wholine)
 +		return;
 +	for (i = 0; i < used_atom_cnt; i++) {
 +		const char *name = used_atom[i];
 +		struct atom_value *v = &val[i];
 +		if (!!deref != (*name == '*'))
 +			continue;
 +		if (deref)
 +			name++;
 +
 +		if (starts_with(name, "creatordate"))
 +			grab_date(wholine, v, name);
 +		else if (!strcmp(name, "creator"))
 +			v->s = copy_line(wholine);
 +	}
 +}
 +
 +static void find_subpos(const char *buf, unsigned long sz,
 +			const char **sub, unsigned long *sublen,
 +			const char **body, unsigned long *bodylen,
 +			unsigned long *nonsiglen,
 +			const char **sig, unsigned long *siglen)
 +{
 +	const char *eol;
 +	/* skip past header until we hit empty line */
 +	while (*buf && *buf != '\n') {
 +		eol = strchrnul(buf, '\n');
 +		if (*eol)
 +			eol++;
 +		buf = eol;
 +	}
 +	/* skip any empty lines */
 +	while (*buf == '\n')
 +		buf++;
 +
 +	/* parse signature first; we might not even have a subject line */
 +	*sig = buf + parse_signature(buf, strlen(buf));
 +	*siglen = strlen(*sig);
 +
 +	/* subject is first non-empty line */
 +	*sub = buf;
 +	/* subject goes to first empty line */
 +	while (buf < *sig && *buf && *buf != '\n') {
 +		eol = strchrnul(buf, '\n');
 +		if (*eol)
 +			eol++;
 +		buf = eol;
 +	}
 +	*sublen = buf - *sub;
 +	/* drop trailing newline, if present */
 +	if (*sublen && (*sub)[*sublen - 1] == '\n')
 +		*sublen -= 1;
 +
 +	/* skip any empty lines */
 +	while (*buf == '\n')
 +		buf++;
 +	*body = buf;
 +	*bodylen = strlen(buf);
 +	*nonsiglen = *sig - buf;
 +}
 +
 +/* See grab_values */
 +static void grab_sub_body_contents(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
 +{
 +	int i;
 +	const char *subpos = NULL, *bodypos = NULL, *sigpos = NULL;
 +	unsigned long sublen = 0, bodylen = 0, nonsiglen = 0, siglen = 0;
 +
 +	for (i = 0; i < used_atom_cnt; i++) {
 +		const char *name = used_atom[i];
 +		struct atom_value *v = &val[i];
 +		if (!!deref != (*name == '*'))
 +			continue;
 +		if (deref)
 +			name++;
 +		if (strcmp(name, "subject") &&
 +		    strcmp(name, "body") &&
 +		    strcmp(name, "contents") &&
 +		    strcmp(name, "contents:subject") &&
 +		    strcmp(name, "contents:body") &&
 +		    strcmp(name, "contents:signature"))
 +			continue;
 +		if (!subpos)
 +			find_subpos(buf, sz,
 +				    &subpos, &sublen,
 +				    &bodypos, &bodylen, &nonsiglen,
 +				    &sigpos, &siglen);
 +
 +		if (!strcmp(name, "subject"))
 +			v->s = copy_subject(subpos, sublen);
 +		else if (!strcmp(name, "contents:subject"))
 +			v->s = copy_subject(subpos, sublen);
 +		else if (!strcmp(name, "body"))
 +			v->s = xmemdupz(bodypos, bodylen);
 +		else if (!strcmp(name, "contents:body"))
 +			v->s = xmemdupz(bodypos, nonsiglen);
 +		else if (!strcmp(name, "contents:signature"))
 +			v->s = xmemdupz(sigpos, siglen);
 +		else if (!strcmp(name, "contents"))
 +			v->s = xstrdup(subpos);
 +	}
 +}
 +
 +/*
 + * We want to have empty print-string for field requests
 + * that do not apply (e.g. "authordate" for a tag object)
 + */
 +static void fill_missing_values(struct atom_value *val)
 +{
 +	int i;
 +	for (i = 0; i < used_atom_cnt; i++) {
 +		struct atom_value *v = &val[i];
 +		if (v->s == NULL)
 +			v->s = "";
 +	}
 +}
 +
 +/*
 + * val is a list of atom_value to hold returned values.  Extract
 + * the values for atoms in used_atom array out of (obj, buf, sz).
 + * when deref is false, (obj, buf, sz) is the object that is
 + * pointed at by the ref itself; otherwise it is the object the
 + * ref (which is a tag) refers to.
 + */
 +static void grab_values(struct atom_value *val, int deref, struct object *obj, void *buf, unsigned long sz)
 +{
 +	grab_common_values(val, deref, obj, buf, sz);
 +	switch (obj->type) {
 +	case OBJ_TAG:
 +		grab_tag_values(val, deref, obj, buf, sz);
 +		grab_sub_body_contents(val, deref, obj, buf, sz);
 +		grab_person("tagger", val, deref, obj, buf, sz);
 +		break;
 +	case OBJ_COMMIT:
 +		grab_commit_values(val, deref, obj, buf, sz);
 +		grab_sub_body_contents(val, deref, obj, buf, sz);
 +		grab_person("author", val, deref, obj, buf, sz);
 +		grab_person("committer", val, deref, obj, buf, sz);
 +		break;
 +	case OBJ_TREE:
 +		/* grab_tree_values(val, deref, obj, buf, sz); */
 +		break;
 +	case OBJ_BLOB:
 +		/* grab_blob_values(val, deref, obj, buf, sz); */
 +		break;
 +	default:
 +		die("Eh?  Object of type %d?", obj->type);
 +	}
 +}
 +
 +static inline char *copy_advance(char *dst, const char *src)
 +{
 +	while (*src)
 +		*dst++ = *src++;
 +	return dst;
 +}
 +
 +/*
 + * Parse the object referred by ref, and grab needed value.
 + */
 +static void populate_value(struct ref_array_item *ref)
 +{
 +	void *buf;
 +	struct object *obj;
 +	int eaten, i;
 +	unsigned long size;
 +	const unsigned char *tagged;
 +
 +	ref->value = xcalloc(used_atom_cnt, sizeof(struct atom_value));
 +
 +	if (need_symref && (ref->flag & REF_ISSYMREF) && !ref->symref) {
 +		unsigned char unused1[20];
 +		ref->symref = resolve_refdup(ref->refname, RESOLVE_REF_READING,
 +					     unused1, NULL);
 +		if (!ref->symref)
 +			ref->symref = "";
 +	}
 +
 +	/* Fill in specials first */
 +	for (i = 0; i < used_atom_cnt; i++) {
 +		const char *name = used_atom[i];
 +		struct atom_value *v = &ref->value[i];
 +		int deref = 0;
 +		const char *refname;
 +		const char *formatp;
 +		struct branch *branch = NULL;
 +
 +		if (*name == '*') {
 +			deref = 1;
 +			name++;
 +		}
 +
 +		if (starts_with(name, "refname"))
 +			refname = ref->refname;
 +		else if (starts_with(name, "symref"))
 +			refname = ref->symref ? ref->symref : "";
 +		else if (starts_with(name, "upstream")) {
 +			const char *branch_name;
 +			/* only local branches may have an upstream */
 +			if (!skip_prefix(ref->refname, "refs/heads/",
 +					 &branch_name))
 +				continue;
 +			branch = branch_get(branch_name);
 +
 +			refname = branch_get_upstream(branch, NULL);
 +			if (!refname)
 +				continue;
 +		} else if (starts_with(name, "push")) {
 +			const char *branch_name;
 +			if (!skip_prefix(ref->refname, "refs/heads/",
 +					 &branch_name))
 +				continue;
 +			branch = branch_get(branch_name);
 +
 +			refname = branch_get_push(branch, NULL);
 +			if (!refname)
 +				continue;
 +		} else if (starts_with(name, "color:")) {
 +			char color[COLOR_MAXLEN] = "";
 +
 +			if (color_parse(name + 6, color) < 0)
 +				die(_("unable to parse format"));
 +			v->s = xstrdup(color);
 +			continue;
 +		} else if (!strcmp(name, "flag")) {
 +			char buf[256], *cp = buf;
 +			if (ref->flag & REF_ISSYMREF)
 +				cp = copy_advance(cp, ",symref");
 +			if (ref->flag & REF_ISPACKED)
 +				cp = copy_advance(cp, ",packed");
 +			if (cp == buf)
 +				v->s = "";
 +			else {
 +				*cp = '\0';
 +				v->s = xstrdup(buf + 1);
 +			}
 +			continue;
 +		} else if (!deref && grab_objectname(name, ref->objectname, v)) {
 +			continue;
 +		} else if (!strcmp(name, "HEAD")) {
 +			const char *head;
 +			unsigned char sha1[20];
 +
 +			head = resolve_ref_unsafe("HEAD", RESOLVE_REF_READING,
 +						  sha1, NULL);
 +			if (!strcmp(ref->refname, head))
 +				v->s = "*";
 +			else
 +				v->s = " ";
 +			continue;
 +		} else
 +			continue;
 +
 +		formatp = strchr(name, ':');
 +		if (formatp) {
 +			int num_ours, num_theirs;
 +
 +			formatp++;
 +			if (!strcmp(formatp, "short"))
 +				refname = shorten_unambiguous_ref(refname,
 +						      warn_ambiguous_refs);
 +			else if (!strcmp(formatp, "track") &&
 +				 (starts_with(name, "upstream") ||
 +				  starts_with(name, "push"))) {
 +				char buf[40];
 +
 +				if (stat_tracking_info(branch, &num_ours,
 +						       &num_theirs, NULL))
 +					continue;
 +
 +				if (!num_ours && !num_theirs)
 +					v->s = "";
 +				else if (!num_ours) {
 +					sprintf(buf, "[behind %d]", num_theirs);
 +					v->s = xstrdup(buf);
 +				} else if (!num_theirs) {
 +					sprintf(buf, "[ahead %d]", num_ours);
 +					v->s = xstrdup(buf);
 +				} else {
 +					sprintf(buf, "[ahead %d, behind %d]",
 +						num_ours, num_theirs);
 +					v->s = xstrdup(buf);
 +				}
 +				continue;
 +			} else if (!strcmp(formatp, "trackshort") &&
 +				   (starts_with(name, "upstream") ||
 +				    starts_with(name, "push"))) {
 +				assert(branch);
 +
 +				if (stat_tracking_info(branch, &num_ours,
 +							&num_theirs, NULL))
 +					continue;
 +
 +				if (!num_ours && !num_theirs)
 +					v->s = "=";
 +				else if (!num_ours)
 +					v->s = "<";
 +				else if (!num_theirs)
 +					v->s = ">";
 +				else
 +					v->s = "<>";
 +				continue;
 +			} else
 +				die("unknown %.*s format %s",
 +				    (int)(formatp - name), name, formatp);
 +		}
 +
 +		if (!deref)
 +			v->s = refname;
 +		else {
 +			int len = strlen(refname);
 +			char *s = xmalloc(len + 4);
 +			sprintf(s, "%s^{}", refname);
 +			v->s = s;
 +		}
 +	}
 +
 +	for (i = 0; i < used_atom_cnt; i++) {
 +		struct atom_value *v = &ref->value[i];
 +		if (v->s == NULL)
 +			goto need_obj;
 +	}
 +	return;
 +
 + need_obj:
 +	buf = get_obj(ref->objectname, &obj, &size, &eaten);
 +	if (!buf)
 +		die("missing object %s for %s",
 +		    sha1_to_hex(ref->objectname), ref->refname);
 +	if (!obj)
 +		die("parse_object_buffer failed on %s for %s",
 +		    sha1_to_hex(ref->objectname), ref->refname);
 +
 +	grab_values(ref->value, 0, obj, buf, size);
 +	if (!eaten)
 +		free(buf);
 +
 +	/*
 +	 * If there is no atom that wants to know about tagged
 +	 * object, we are done.
 +	 */
 +	if (!need_tagged || (obj->type != OBJ_TAG))
 +		return;
 +
 +	/*
 +	 * If it is a tag object, see if we use a value that derefs
 +	 * the object, and if we do grab the object it refers to.
 +	 */
 +	tagged = ((struct tag *)obj)->tagged->sha1;
 +
 +	/*
 +	 * NEEDSWORK: This derefs tag only once, which
 +	 * is good to deal with chains of trust, but
 +	 * is not consistent with what deref_tag() does
 +	 * which peels the onion to the core.
 +	 */
 +	buf = get_obj(tagged, &obj, &size, &eaten);
 +	if (!buf)
 +		die("missing object %s for %s",
 +		    sha1_to_hex(tagged), ref->refname);
 +	if (!obj)
 +		die("parse_object_buffer failed on %s for %s",
 +		    sha1_to_hex(tagged), ref->refname);
 +	grab_values(ref->value, 1, obj, buf, size);
 +	if (!eaten)
 +		free(buf);
 +}
 +
 +/*
 + * Given a ref, return the value for the atom.  This lazily gets value
 + * out of the object by calling populate value.
 + */
 +static void get_ref_atom_value(struct ref_array_item *ref, int atom, struct atom_value **v)
 +{
 +	if (!ref->value) {
 +		populate_value(ref);
 +		fill_missing_values(ref->value);
 +	}
 +	*v = &ref->value[atom];
 +}
 +
 +/*
 + * Return 1 if the refname matches one of the patterns, otherwise 0.
 + * A pattern can be path prefix (e.g. a refname "refs/heads/master"
 + * matches a pattern "refs/heads/") or a wildcard (e.g. the same ref
 + * matches "refs/heads/m*",too).
 + */
 +static int match_name_as_path(const char **pattern, const char *refname)
 +{
 +	int namelen = strlen(refname);
 +	for (; *pattern; pattern++) {
 +		const char *p = *pattern;
 +		int plen = strlen(p);
 +
 +		if ((plen <= namelen) &&
 +		    !strncmp(refname, p, plen) &&
 +		    (refname[plen] == '\0' ||
 +		     refname[plen] == '/' ||
 +		     p[plen-1] == '/'))
 +			return 1;
 +		if (!wildmatch(p, refname, WM_PATHNAME, NULL))
 +			return 1;
 +	}
 +	return 0;
 +}
 +
 +/* Allocate space for a new ref_array_item and copy the objectname and flag to it */
 +static struct ref_array_item *new_ref_array_item(const char *refname,
 +						 const unsigned char *objectname,
 +						 int flag)
 +{
 +	size_t len = strlen(refname);
 +	struct ref_array_item *ref = xcalloc(1, sizeof(struct ref_array_item) + len + 1);
 +	memcpy(ref->refname, refname, len);
 +	ref->refname[len] = '\0';
 +	hashcpy(ref->objectname, objectname);
 +	ref->flag = flag;
 +
 +	return ref;
 +}
 +
 +/*
 + * A call-back given to for_each_ref().  Filter refs and keep them for
 + * later object processing.
 + */
 +static int ref_filter_handler(const char *refname, const struct object_id *oid, int flag, void *cb_data)
 +{
 +	struct ref_filter_cbdata *ref_cbdata = cb_data;
 +	struct ref_filter *filter = ref_cbdata->filter;
 +	struct ref_array_item *ref;
 +
 +	if (flag & REF_BAD_NAME) {
 +		warning("ignoring ref with broken name %s", refname);
 +		return 0;
 +	}
 +
 +	if (flag & REF_ISBROKEN) {
 +		warning("ignoring broken ref %s", refname);
 +		return 0;
 +	}
 +
 +	if (*filter->name_patterns && !match_name_as_path(filter->name_patterns, refname))
 +		return 0;
 +
 +	/*
 +	 * We do not open the object yet; sort may only need refname
 +	 * to do its job and the resulting list may yet to be pruned
 +	 * by maxcount logic.
 +	 */
 +	ref = new_ref_array_item(refname, oid->hash, flag);
 +
 +	REALLOC_ARRAY(ref_cbdata->array->items, ref_cbdata->array->nr + 1);
 +	ref_cbdata->array->items[ref_cbdata->array->nr++] = ref;
 +	return 0;
 +}
 +
 +/*  Free memory allocated for a ref_array_item */
 +static void free_array_item(struct ref_array_item *item)
 +{
 +	free((char *)item->symref);
 +	free(item);
 +}
 +
 +/* Free all memory allocated for ref_array */
 +void ref_array_clear(struct ref_array *array)
 +{
 +	int i;
 +
 +	for (i = 0; i < array->nr; i++)
 +		free_array_item(array->items[i]);
 +	free(array->items);
 +	array->items = NULL;
 +	array->nr = array->alloc = 0;
 +}
 +
 +/*
 + * API for filtering a set of refs. Based on the type of refs the user
 + * has requested, we iterate through those refs and apply filters
 + * as per the given ref_filter structure and finally store the
 + * filtered refs in the ref_array structure.
 + */
 +int filter_refs(struct ref_array *array, struct ref_filter *filter, unsigned int type)
 +{
 +	struct ref_filter_cbdata ref_cbdata;
 +
 +	ref_cbdata.array = array;
 +	ref_cbdata.filter = filter;
 +
 +	if (type & (FILTER_REFS_ALL | FILTER_REFS_INCLUDE_BROKEN))
 +		return for_each_rawref(ref_filter_handler, &ref_cbdata);
 +	else if (type & FILTER_REFS_ALL)
 +		return for_each_ref(ref_filter_handler, &ref_cbdata);
 +	else
 +		die("filter_refs: invalid type");
 +	return 0;
 +}
 +
 +static int cmp_ref_sorting(struct ref_sorting *s, struct ref_array_item *a, struct ref_array_item *b)
 +{
 +	struct atom_value *va, *vb;
 +	int cmp;
 +	cmp_type cmp_type = used_atom_type[s->atom];
 +
 +	get_ref_atom_value(a, s->atom, &va);
 +	get_ref_atom_value(b, s->atom, &vb);
 +	switch (cmp_type) {
 +	case FIELD_STR:
 +		cmp = strcmp(va->s, vb->s);
 +		break;
 +	default:
 +		if (va->ul < vb->ul)
 +			cmp = -1;
 +		else if (va->ul == vb->ul)
 +			cmp = 0;
 +		else
 +			cmp = 1;
 +		break;
 +	}
 +	return (s->reverse) ? -cmp : cmp;
 +}
 +
 +static struct ref_sorting *ref_sorting;
 +static int compare_refs(const void *a_, const void *b_)
 +{
 +	struct ref_array_item *a = *((struct ref_array_item **)a_);
 +	struct ref_array_item *b = *((struct ref_array_item **)b_);
 +	struct ref_sorting *s;
 +
 +	for (s = ref_sorting; s; s = s->next) {
 +		int cmp = cmp_ref_sorting(s, a, b);
 +		if (cmp)
 +			return cmp;
 +	}
 +	return 0;
 +}
 +
 +void ref_array_sort(struct ref_sorting *sorting, struct ref_array *array)
 +{
 +	ref_sorting = sorting;
 +	qsort(array->items, array->nr, sizeof(struct ref_array_item *), compare_refs);
 +}
 +
 +static void print_value(struct atom_value *v, int quote_style)
 +{
 +	struct strbuf sb = STRBUF_INIT;
 +	switch (quote_style) {
 +	case QUOTE_NONE:
 +		fputs(v->s, stdout);
 +		break;
 +	case QUOTE_SHELL:
 +		sq_quote_buf(&sb, v->s);
 +		break;
 +	case QUOTE_PERL:
 +		perl_quote_buf(&sb, v->s);
 +		break;
 +	case QUOTE_PYTHON:
 +		python_quote_buf(&sb, v->s);
 +		break;
 +	case QUOTE_TCL:
 +		tcl_quote_buf(&sb, v->s);
 +		break;
 +	}
 +	if (quote_style != QUOTE_NONE) {
 +		fputs(sb.buf, stdout);
 +		strbuf_release(&sb);
 +	}
 +}
 +
 +static int hex1(char ch)
 +{
 +	if ('0' <= ch && ch <= '9')
 +		return ch - '0';
 +	else if ('a' <= ch && ch <= 'f')
 +		return ch - 'a' + 10;
 +	else if ('A' <= ch && ch <= 'F')
 +		return ch - 'A' + 10;
 +	return -1;
 +}
 +static int hex2(const char *cp)
 +{
 +	if (cp[0] && cp[1])
 +		return (hex1(cp[0]) << 4) | hex1(cp[1]);
 +	else
 +		return -1;
 +}
 +
 +static void emit(const char *cp, const char *ep)
 +{
 +	while (*cp && (!ep || cp < ep)) {
 +		if (*cp == '%') {
 +			if (cp[1] == '%')
 +				cp++;
 +			else {
 +				int ch = hex2(cp + 1);
 +				if (0 <= ch) {
 +					putchar(ch);
 +					cp += 3;
 +					continue;
 +				}
 +			}
 +		}
 +		putchar(*cp);
 +		cp++;
 +	}
 +}
 +
 +void show_ref_array_item(struct ref_array_item *info, const char *format, int quote_style)
 +{
 +	const char *cp, *sp, *ep;
 +
 +	for (cp = format; *cp && (sp = find_next(cp)); cp = ep + 1) {
 +		struct atom_value *atomv;
 +
 +		ep = strchr(sp, ')');
 +		if (cp < sp)
 +			emit(cp, sp);
 +		get_ref_atom_value(info, parse_ref_filter_atom(sp + 2, ep), &atomv);
 +		print_value(atomv, quote_style);
 +	}
 +	if (*cp) {
 +		sp = cp + strlen(cp);
 +		emit(cp, sp);
 +	}
 +	if (need_color_reset_at_eol) {
 +		struct atom_value resetv;
 +		char color[COLOR_MAXLEN] = "";
 +
 +		if (color_parse("reset", color) < 0)
 +			die("BUG: couldn't parse 'reset' as a color");
 +		resetv.s = color;
 +		print_value(&resetv, quote_style);
 +	}
 +	putchar('\n');
 +}
 +
 +/*  If no sorting option is given, use refname to sort as default */
 +struct ref_sorting *ref_default_sorting(void)
 +{
 +	static const char cstr_name[] = "refname";
 +
 +	struct ref_sorting *sorting = xcalloc(1, sizeof(*sorting));
 +
 +	sorting->next = NULL;
 +	sorting->atom = parse_ref_filter_atom(cstr_name, cstr_name + strlen(cstr_name));
 +	return sorting;
 +}
 +
 +int parse_opt_ref_sorting(const struct option *opt, const char *arg, int unset)
 +{
 +	struct ref_sorting **sorting_tail = opt->value;
 +	struct ref_sorting *s;
 +	int len;
 +
 +	if (!arg) /* should --no-sort void the list ? */
 +		return -1;
 +
 +	s = xcalloc(1, sizeof(*s));
 +	s->next = *sorting_tail;
 +	*sorting_tail = s;
 +
 +	if (*arg == '-') {
 +		s->reverse = 1;
 +		arg++;
 +	}
 +	len = strlen(arg);
 +	s->atom = parse_ref_filter_atom(arg, arg+len);
 +	return 0;
 +}
diff --combined refs.c
index fb568d7a31,83a6bea3a5..ce8cd8d450
--- a/refs.c
+++ b/refs.c
@@@ -1314,13 -1314,7 +1314,13 @@@ static struct ref_dir *get_packed_refs(
  	return get_packed_ref_dir(get_packed_ref_cache(refs));
  }
  
 -void add_packed_ref(const char *refname, const unsigned char *sha1)
 +/*
 + * Add a reference to the in-memory packed reference cache.  This may
 + * only be called while the packed-refs file is locked (see
 + * lock_packed_refs()).  To actually write the packed-refs file, call
 + * commit_packed_refs().
 + */
 +static void add_packed_ref(const char *refname, const unsigned char *sha1)
  {
  	struct packed_ref_cache *packed_ref_cache =
  		get_packed_ref_cache(&ref_cache);
@@@ -1747,11 -1741,9 +1747,11 @@@ const char *resolve_ref_unsafe(const ch
  	return ret;
  }
  
 -char *resolve_refdup(const char *ref, int resolve_flags, unsigned char *sha1, int *flags)
 +char *resolve_refdup(const char *refname, int resolve_flags,
 +		     unsigned char *sha1, int *flags)
  {
 -	return xstrdup_or_null(resolve_ref_unsafe(ref, resolve_flags, sha1, flags));
 +	return xstrdup_or_null(resolve_ref_unsafe(refname, resolve_flags,
 +						  sha1, flags));
  }
  
  /* The argument to filter_refs */
@@@ -2130,8 -2122,7 +2130,8 @@@ int for_each_remote_ref_submodule(cons
  
  int for_each_replace_ref(each_ref_fn fn, void *cb_data)
  {
 -	return do_for_each_ref(&ref_cache, "refs/replace/", fn, 13, 0, cb_data);
 +	return do_for_each_ref(&ref_cache, git_replace_ref_base, fn,
 +			       strlen(git_replace_ref_base), 0, cb_data);
  }
  
  int head_ref_namespaced(each_ref_fn fn, void *cb_data)
@@@ -2539,12 -2530,8 +2539,12 @@@ static int write_packed_entry_fn(struc
  	return 0;
  }
  
 -/* This should return a meaningful errno on failure */
 -int lock_packed_refs(int flags)
 +/*
 + * Lock the packed-refs file for writing. Flags is passed to
 + * hold_lock_file_for_update(). Return 0 on success. On errors, set
 + * errno appropriately and return a nonzero value.
 + */
 +static int lock_packed_refs(int flags)
  {
  	static int timeout_configured = 0;
  	static int timeout_value = 1000;
@@@ -2574,12 -2561,10 +2574,12 @@@
  }
  
  /*
 - * Commit the packed refs changes.
 - * On error we must make sure that errno contains a meaningful value.
 + * Write the current version of the packed refs cache from memory to
 + * disk. The packed-refs file must already be locked for writing (see
 + * lock_packed_refs()). Return zero on success. On errors, set errno
 + * and return a nonzero value
   */
 -int commit_packed_refs(void)
 +static int commit_packed_refs(void)
  {
  	struct packed_ref_cache *packed_ref_cache =
  		get_packed_ref_cache(&ref_cache);
@@@ -2608,12 -2593,7 +2608,12 @@@
  	return error;
  }
  
 -void rollback_packed_refs(void)
 +/*
 + * Rollback the lockfile for the packed-refs file, and discard the
 + * in-memory packed reference cache.  (The packed-refs file will be
 + * read anew if it is needed again after this function is called.)
 + */
 +static void rollback_packed_refs(void)
  {
  	struct packed_ref_cache *packed_ref_cache =
  		get_packed_ref_cache(&ref_cache);
@@@ -2771,14 -2751,7 +2771,14 @@@ int pack_refs(unsigned int flags
  	return 0;
  }
  
 -int repack_without_refs(struct string_list *refnames, struct strbuf *err)
 +/*
 + * Rewrite the packed-refs file, omitting any refs listed in
 + * 'refnames'. On error, leave packed-refs unchanged, write an error
 + * message to 'err', and return a nonzero value.
 + *
 + * The refs in 'refnames' needn't be sorted. `err` must not be NULL.
 + */
 +static int repack_without_refs(struct string_list *refnames, struct strbuf *err)
  {
  	struct ref_dir *packed;
  	struct string_list_item *refname;
@@@ -2843,15 -2816,15 +2843,15 @@@ static int delete_ref_loose(struct ref_
  	return 0;
  }
  
 -int delete_ref(const char *refname, const unsigned char *sha1, unsigned int flags)
 +int delete_ref(const char *refname, const unsigned char *old_sha1,
 +	       unsigned int flags)
  {
  	struct ref_transaction *transaction;
  	struct strbuf err = STRBUF_INIT;
  
  	transaction = ref_transaction_begin(&err);
  	if (!transaction ||
 -	    ref_transaction_delete(transaction, refname,
 -				   (sha1 && !is_null_sha1(sha1)) ? sha1 : NULL,
 +	    ref_transaction_delete(transaction, refname, old_sha1,
  				   flags, NULL, &err) ||
  	    ref_transaction_commit(transaction, &err)) {
  		error("%s", err.buf);
@@@ -2864,44 -2837,6 +2864,44 @@@
  	return 0;
  }
  
 +int delete_refs(struct string_list *refnames)
 +{
 +	struct strbuf err = STRBUF_INIT;
 +	int i, result = 0;
 +
 +	if (!refnames->nr)
 +		return 0;
 +
 +	result = repack_without_refs(refnames, &err);
 +	if (result) {
 +		/*
 +		 * If we failed to rewrite the packed-refs file, then
 +		 * it is unsafe to try to remove loose refs, because
 +		 * doing so might expose an obsolete packed value for
 +		 * a reference that might even point at an object that
 +		 * has been garbage collected.
 +		 */
 +		if (refnames->nr == 1)
 +			error(_("could not delete reference %s: %s"),
 +			      refnames->items[0].string, err.buf);
 +		else
 +			error(_("could not delete references: %s"), err.buf);
 +
 +		goto out;
 +	}
 +
 +	for (i = 0; i < refnames->nr; i++) {
 +		const char *refname = refnames->items[i].string;
 +
 +		if (delete_ref(refname, NULL, 0))
 +			result |= error(_("could not remove reference %s"), refname);
 +	}
 +
 +out:
 +	strbuf_release(&err);
 +	return result;
 +}
 +
  /*
   * People using contrib's git-new-workdir have .git/logs/refs ->
   * /some/other/path/.git/logs/refs, and that may live on another device.
@@@ -3436,14 -3371,14 +3436,14 @@@ static int read_ref_at_ent(unsigned cha
  			hashcpy(cb->sha1, nsha1);
  			if (hashcmp(cb->osha1, nsha1))
  				warning("Log for ref %s has gap after %s.",
- 					cb->refname, show_date(cb->date, cb->tz, DATE_RFC2822));
+ 					cb->refname, show_date(cb->date, cb->tz, DATE_MODE(RFC2822)));
  		}
  		else if (cb->date == cb->at_time)
  			hashcpy(cb->sha1, nsha1);
  		else if (hashcmp(nsha1, cb->sha1))
  			warning("Log for ref %s unexpectedly ended on %s.",
  				cb->refname, show_date(cb->date, cb->tz,
- 						   DATE_RFC2822));
+ 						       DATE_MODE(RFC2822)));
  		hashcpy(cb->osha1, osha1);
  		hashcpy(cb->nsha1, nsha1);
  		cb->found_it = 1;
@@@ -4103,98 -4038,6 +4103,98 @@@ cleanup
  	return ret;
  }
  
 +static int ref_present(const char *refname,
 +		       const struct object_id *oid, int flags, void *cb_data)
 +{
 +	struct string_list *affected_refnames = cb_data;
 +
 +	return string_list_has_string(affected_refnames, refname);
 +}
 +
 +int initial_ref_transaction_commit(struct ref_transaction *transaction,
 +				   struct strbuf *err)
 +{
 +	struct ref_dir *loose_refs = get_loose_refs(&ref_cache);
 +	struct ref_dir *packed_refs = get_packed_refs(&ref_cache);
 +	int ret = 0, i;
 +	int n = transaction->nr;
 +	struct ref_update **updates = transaction->updates;
 +	struct string_list affected_refnames = STRING_LIST_INIT_NODUP;
 +
 +	assert(err);
 +
 +	if (transaction->state != REF_TRANSACTION_OPEN)
 +		die("BUG: commit called for transaction that is not open");
 +
 +	/* Fail if a refname appears more than once in the transaction: */
 +	for (i = 0; i < n; i++)
 +		string_list_append(&affected_refnames, updates[i]->refname);
 +	string_list_sort(&affected_refnames);
 +	if (ref_update_reject_duplicates(&affected_refnames, err)) {
 +		ret = TRANSACTION_GENERIC_ERROR;
 +		goto cleanup;
 +	}
 +
 +	/*
 +	 * It's really undefined to call this function in an active
 +	 * repository or when there are existing references: we are
 +	 * only locking and changing packed-refs, so (1) any
 +	 * simultaneous processes might try to change a reference at
 +	 * the same time we do, and (2) any existing loose versions of
 +	 * the references that we are setting would have precedence
 +	 * over our values. But some remote helpers create the remote
 +	 * "HEAD" and "master" branches before calling this function,
 +	 * so here we really only check that none of the references
 +	 * that we are creating already exists.
 +	 */
 +	if (for_each_rawref(ref_present, &affected_refnames))
 +		die("BUG: initial ref transaction called with existing refs");
 +
 +	for (i = 0; i < n; i++) {
 +		struct ref_update *update = updates[i];
 +
 +		if ((update->flags & REF_HAVE_OLD) &&
 +		    !is_null_sha1(update->old_sha1))
 +			die("BUG: initial ref transaction with old_sha1 set");
 +		if (verify_refname_available(update->refname,
 +					     &affected_refnames, NULL,
 +					     loose_refs, err) ||
 +		    verify_refname_available(update->refname,
 +					     &affected_refnames, NULL,
 +					     packed_refs, err)) {
 +			ret = TRANSACTION_NAME_CONFLICT;
 +			goto cleanup;
 +		}
 +	}
 +
 +	if (lock_packed_refs(0)) {
 +		strbuf_addf(err, "unable to lock packed-refs file: %s",
 +			    strerror(errno));
 +		ret = TRANSACTION_GENERIC_ERROR;
 +		goto cleanup;
 +	}
 +
 +	for (i = 0; i < n; i++) {
 +		struct ref_update *update = updates[i];
 +
 +		if ((update->flags & REF_HAVE_NEW) &&
 +		    !is_null_sha1(update->new_sha1))
 +			add_packed_ref(update->refname, update->new_sha1);
 +	}
 +
 +	if (commit_packed_refs()) {
 +		strbuf_addf(err, "unable to commit packed-refs file: %s",
 +			    strerror(errno));
 +		ret = TRANSACTION_GENERIC_ERROR;
 +		goto cleanup;
 +	}
 +
 +cleanup:
 +	transaction->state = REF_TRANSACTION_CLOSED;
 +	string_list_clear(&affected_refnames, 0);
 +	return ret;
 +}
 +
  char *shorten_unambiguous_ref(const char *refname, int strict)
  {
  	int i;
diff --combined revision.c
index ab97ffd459,887e65e6e5..cf60c5d817
--- a/revision.c
+++ b/revision.c
@@@ -361,8 -361,8 +361,8 @@@ static int everybody_uninteresting(stru
  		list = list->next;
  		if (commit->object.flags & UNINTERESTING)
  			continue;
 -		if (interesting_cache)
 -			*interesting_cache = commit;
 +
 +		*interesting_cache = commit;
  		return 0;
  	}
  	return 1;
@@@ -1996,10 -1996,10 +1996,10 @@@ static int handle_revision_opt(struct r
  	} else if (!strcmp(arg, "--full-history")) {
  		revs->simplify_history = 0;
  	} else if (!strcmp(arg, "--relative-date")) {
- 		revs->date_mode = DATE_RELATIVE;
+ 		revs->date_mode.type = DATE_RELATIVE;
  		revs->date_mode_explicit = 1;
  	} else if ((argcount = parse_long_opt("date", argv, &optarg))) {
- 		revs->date_mode = parse_date_format(optarg);
+ 		parse_date_format(optarg, &revs->date_mode);
  		revs->date_mode_explicit = 1;
  		return argcount;
  	} else if (!strcmp(arg, "--log-size")) {
diff --combined strbuf.c
index bbaf32eef6,e5e7370092..cce5eed14a
--- a/strbuf.c
+++ b/strbuf.c
@@@ -526,10 -526,9 +526,10 @@@ int strbuf_getwholeline_fd(struct strbu
  	return 0;
  }
  
 -int strbuf_read_file(struct strbuf *sb, const char *path, size_t hint)
 +ssize_t strbuf_read_file(struct strbuf *sb, const char *path, size_t hint)
  {
 -	int fd, len;
 +	int fd;
 +	ssize_t len;
  
  	fd = open(path, O_RDONLY);
  	if (fd < 0)
@@@ -710,3 -709,36 +710,36 @@@ char *xstrfmt(const char *fmt, ...
  
  	return ret;
  }
+ 
+ void strbuf_addftime(struct strbuf *sb, const char *fmt, const struct tm *tm)
+ {
+ 	size_t hint = 128;
+ 	size_t len;
+ 
+ 	if (!*fmt)
+ 		return;
+ 
+ 	strbuf_grow(sb, hint);
+ 	len = strftime(sb->buf + sb->len, sb->alloc - sb->len, fmt, tm);
+ 
+ 	if (!len) {
+ 		/*
+ 		 * strftime reports "0" if it could not fit the result in the buffer.
+ 		 * Unfortunately, it also reports "0" if the requested time string
+ 		 * takes 0 bytes. So our strategy is to munge the format so that the
+ 		 * output contains at least one character, and then drop the extra
+ 		 * character before returning.
+ 		 */
+ 		struct strbuf munged_fmt = STRBUF_INIT;
+ 		strbuf_addf(&munged_fmt, "%s ", fmt);
+ 		while (!len) {
+ 			hint *= 2;
+ 			strbuf_grow(sb, hint);
+ 			len = strftime(sb->buf + sb->len, sb->alloc - sb->len,
+ 				       munged_fmt.buf, tm);
+ 		}
+ 		strbuf_release(&munged_fmt);
+ 		len--; /* drop munged space */
+ 	}
+ 	strbuf_setlen(sb, sb->len + len);
+ }
diff --combined strbuf.h
index 4a48c0031a,8c8f8d56f9..aef2794651
--- a/strbuf.h
+++ b/strbuf.h
@@@ -344,6 -344,11 +344,11 @@@ extern void strbuf_commented_addf(struc
  __attribute__((format (printf,2,0)))
  extern void strbuf_vaddf(struct strbuf *sb, const char *fmt, va_list ap);
  
+ /**
+  * Add the time specified by `tm`, as formatted by `strftime`.
+  */
+ extern void strbuf_addftime(struct strbuf *sb, const char *fmt, const struct tm *tm);
+ 
  /**
   * Read a given size of data from a FILE* pointer to the buffer.
   *
@@@ -365,7 -370,7 +370,7 @@@ extern ssize_t strbuf_read(struct strbu
   * Read the contents of a file, specified by its path. The third argument
   * can be used to give a hint about the file size, to avoid reallocs.
   */
 -extern int strbuf_read_file(struct strbuf *sb, const char *path, size_t hint);
 +extern ssize_t strbuf_read_file(struct strbuf *sb, const char *path, size_t hint);
  
  /**
   * Read the target of a symbolic link, specified by its path.  The third