From: Junio C Hamano <gitster@pobox.com>
Date: Fri, 29 Sep 2017 02:23:42 +0000 (+0900)
Subject: Merge branch 'rj/no-sign-compare'
X-Git-Tag: v2.15.0-rc0~30
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/14a8168e2fed3934f1f9afb286f1c64345d06790?ds=inline;hp=-c

Merge branch 'rj/no-sign-compare'

Many codepaths have been updated to squelch -Wsign-compare
warnings.

* rj/no-sign-compare:
ALLOC_GROW: avoid -Wsign-compare warnings
cache.h: hex2chr() - avoid -Wsign-compare warnings
commit-slab.h: avoid -Wsign-compare warnings
git-compat-util.h: xsize_t() - avoid -Wsign-compare warnings
---

14a8168e2fed3934f1f9afb286f1c64345d06790
diff --combined builtin/pack-objects.c
index f721137eaf,b40cdfe64a..5ee2c48ffb
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@@ -25,7 -25,6 +25,7 @@@
  #include "sha1-array.h"
  #include "argv-array.h"
  #include "mru.h"
 +#include "packfile.h"
  
  static const char *pack_usage[] = {
  	N_("git pack-objects --stdout [<options>...] [< <ref-list> | < <object-list>]"),
@@@ -1012,7 -1011,7 +1012,7 @@@ static int want_object_in_pack(const un
  			return want;
  	}
  
 -	for (entry = packed_git_mru->head; entry; entry = entry->next) {
 +	for (entry = packed_git_mru.head; entry; entry = entry->next) {
  		struct packed_git *p = entry->item;
  		off_t offset;
  
@@@ -1030,7 -1029,7 +1030,7 @@@
  			}
  			want = want_found_object(exclude, p);
  			if (!exclude && want > 0)
 -				mru_mark(packed_git_mru, entry);
 +				mru_mark(&packed_git_mru, entry);
  			if (want != -1)
  				return want;
  		}
@@@ -2171,10 -2170,7 +2171,10 @@@ static void *threaded_find_deltas(void 
  {
  	struct thread_params *me = arg;
  
 +	progress_lock();
  	while (me->remaining) {
 +		progress_unlock();
 +
  		find_deltas(me->list, &me->remaining,
  			    me->window, me->depth, me->processed);
  
@@@ -2196,10 -2192,7 +2196,10 @@@
  			pthread_cond_wait(&me->cond, &me->mutex);
  		me->data_ready = 0;
  		pthread_mutex_unlock(&me->mutex);
 +
 +		progress_lock();
  	}
 +	progress_unlock();
  	/* leave ->working 1 so that this doesn't get more work assigned */
  	return NULL;
  }
@@@ -2563,8 -2556,8 +2563,8 @@@ struct in_pack_object 
  };
  
  struct in_pack {
- 	int alloc;
- 	int nr;
+ 	unsigned int alloc;
+ 	unsigned int nr;
  	struct in_pack_object *array;
  };
  
diff --combined cache.h
index 49b083ee0a,5cc116ba42..ea6c236e0f
--- a/cache.h
+++ b/cache.h
@@@ -4,7 -4,6 +4,7 @@@
  #include "git-compat-util.h"
  #include "strbuf.h"
  #include "hashmap.h"
 +#include "mru.h"
  #include "advice.h"
  #include "gettext.h"
  #include "convert.h"
@@@ -418,6 -417,7 +418,6 @@@ static inline enum object_type object_t
  #define GIT_WORK_TREE_ENVIRONMENT "GIT_WORK_TREE"
  #define GIT_PREFIX_ENVIRONMENT "GIT_PREFIX"
  #define GIT_SUPER_PREFIX_ENVIRONMENT "GIT_INTERNAL_SUPER_PREFIX"
 -#define GIT_TOPLEVEL_PREFIX_ENVIRONMENT "GIT_INTERNAL_TOPLEVEL_PREFIX"
  #define DEFAULT_GIT_DIR_ENVIRONMENT ".git"
  #define DB_ENVIRONMENT "GIT_OBJECT_DIRECTORY"
  #define INDEX_ENVIRONMENT "GIT_INDEX_FILE"
@@@ -433,7 -433,6 +433,7 @@@
  #define GITATTRIBUTES_FILE ".gitattributes"
  #define INFOATTRIBUTES_FILE "info/attributes"
  #define ATTRIBUTE_MACRO_PREFIX "[attr]"
 +#define GITMODULES_FILE ".gitmodules"
  #define GIT_NOTES_REF_ENVIRONMENT "GIT_NOTES_REF"
  #define GIT_NOTES_DEFAULT_REF "refs/notes/commits"
  #define GIT_NOTES_DISPLAY_REF_ENVIRONMENT "GIT_NOTES_DISPLAY_REF"
@@@ -685,8 -684,8 +685,8 @@@ extern int ie_modified(const struct ind
  
  #define HASH_WRITE_OBJECT 1
  #define HASH_FORMAT_CHECK 2
 -extern int index_fd(unsigned char *sha1, int fd, struct stat *st, enum object_type type, const char *path, unsigned flags);
 -extern int index_path(unsigned char *sha1, const char *path, struct stat *st, unsigned flags);
 +extern int index_fd(struct object_id *oid, int fd, struct stat *st, enum object_type type, const char *path, unsigned flags);
 +extern int index_path(struct object_id *oid, const char *path, struct stat *st, unsigned flags);
  
  /*
   * Record to sd the data from st that we use to check whether a file
@@@ -903,6 -902,20 +903,6 @@@ extern void check_repository_format(voi
   */
  extern const char *sha1_file_name(const unsigned char *sha1);
  
 -/*
 - * Return the name of the (local) packfile with the specified sha1 in
 - * its name.  The return value is a pointer to memory that is
 - * overwritten each time this function is called.
 - */
 -extern char *sha1_pack_name(const unsigned char *sha1);
 -
 -/*
 - * Return the name of the (local) pack index file with the specified
 - * sha1 in its name.  The return value is a pointer to memory that is
 - * overwritten each time this function is called.
 - */
 -extern char *sha1_pack_index_name(const unsigned char *sha1);
 -
  /*
   * Return an abbreviated sha1 unique within this repository's object database.
   * The result will be at least `len` characters long, and will be NUL
@@@ -1179,7 -1192,7 +1179,7 @@@ static inline const unsigned char *look
  extern int sha1_object_info(const unsigned char *, unsigned long *);
  extern int hash_sha1_file(const void *buf, unsigned long len, const char *type, unsigned char *sha1);
  extern int write_sha1_file(const void *buf, unsigned long len, const char *type, unsigned char *return_sha1);
 -extern int hash_sha1_file_literally(const void *buf, unsigned long len, const char *type, unsigned char *sha1, unsigned flags);
 +extern int hash_sha1_file_literally(const void *buf, unsigned long len, const char *type, struct object_id *oid, unsigned flags);
  extern int pretend_sha1_file(void *, unsigned long, enum object_type, unsigned char *);
  extern int force_object_loose(const unsigned char *sha1, time_t mtime);
  extern int git_open_cloexec(const char *name, int flags);
@@@ -1188,10 -1201,15 +1188,10 @@@ extern void *map_sha1_file(const unsign
  extern int unpack_sha1_header(git_zstream *stream, unsigned char *map, unsigned long mapsize, void *buffer, unsigned long bufsiz);
  extern int parse_sha1_header(const char *hdr, unsigned long *sizep);
  
 -/* global flag to enable extra checks when accessing packed objects */
 -extern int do_check_packed_object_crc;
 -
  extern int check_sha1_signature(const unsigned char *sha1, void *buf, unsigned long size, const char *type);
  
  extern int finalize_object_file(const char *tmpfile, const char *filename);
  
 -extern int has_sha1_pack(const unsigned char *sha1);
 -
  /*
   * Open the loose object at path, check its sha1, and return the contents,
   * type, and size. If the object is a blob, then "contents" may return NULL,
@@@ -1227,6 -1245,8 +1227,6 @@@ extern int has_object_file_with_flags(c
   */
  extern int has_loose_object_nonlocal(const unsigned char *sha1);
  
 -extern int has_pack_index(const unsigned char *sha1);
 -
  extern void assert_sha1_type(const unsigned char *sha1, enum object_type expect);
  
  /* Helper to check and "touch" a file */
@@@ -1244,8 -1264,8 +1244,8 @@@ static inline unsigned int hexval(unsig
   */
  static inline int hex2chr(const char *s)
  {
- 	int val = hexval(s[0]);
- 	return (val < 0) ? val : (val << 4) | hexval(s[1]);
+ 	unsigned int val = hexval(s[0]);
+ 	return (val & ~0xf) ? val : (val << 4) | hexval(s[1]);
  }
  
  /* Convert to/from hex/sha1 representation */
@@@ -1264,37 -1284,38 +1264,37 @@@ struct object_context 
  	 */
  	struct strbuf symlink_path;
  	/*
 -	 * If GET_SHA1_RECORD_PATH is set, this will record path (if any)
 +	 * If GET_OID_RECORD_PATH is set, this will record path (if any)
  	 * found when resolving the name. The caller is responsible for
  	 * releasing the memory.
  	 */
  	char *path;
  };
  
 -#define GET_SHA1_QUIETLY           01
 -#define GET_SHA1_COMMIT            02
 -#define GET_SHA1_COMMITTISH        04
 -#define GET_SHA1_TREE             010
 -#define GET_SHA1_TREEISH          020
 -#define GET_SHA1_BLOB             040
 -#define GET_SHA1_FOLLOW_SYMLINKS 0100
 -#define GET_SHA1_RECORD_PATH     0200
 -#define GET_SHA1_ONLY_TO_DIE    04000
 -
 -#define GET_SHA1_DISAMBIGUATORS \
 -	(GET_SHA1_COMMIT | GET_SHA1_COMMITTISH | \
 -	GET_SHA1_TREE | GET_SHA1_TREEISH | \
 -	GET_SHA1_BLOB)
 -
 -extern int get_sha1(const char *str, unsigned char *sha1);
 -extern int get_sha1_commit(const char *str, unsigned char *sha1);
 -extern int get_sha1_committish(const char *str, unsigned char *sha1);
 -extern int get_sha1_tree(const char *str, unsigned char *sha1);
 -extern int get_sha1_treeish(const char *str, unsigned char *sha1);
 -extern int get_sha1_blob(const char *str, unsigned char *sha1);
 -extern void maybe_die_on_misspelt_object_name(const char *name, const char *prefix);
 -extern int get_sha1_with_context(const char *str, unsigned flags, unsigned char *sha1, struct object_context *oc);
 +#define GET_OID_QUIETLY           01
 +#define GET_OID_COMMIT            02
 +#define GET_OID_COMMITTISH        04
 +#define GET_OID_TREE             010
 +#define GET_OID_TREEISH          020
 +#define GET_OID_BLOB             040
 +#define GET_OID_FOLLOW_SYMLINKS 0100
 +#define GET_OID_RECORD_PATH     0200
 +#define GET_OID_ONLY_TO_DIE    04000
 +
 +#define GET_OID_DISAMBIGUATORS \
 +	(GET_OID_COMMIT | GET_OID_COMMITTISH | \
 +	GET_OID_TREE | GET_OID_TREEISH | \
 +	GET_OID_BLOB)
  
  extern int get_oid(const char *str, struct object_id *oid);
 +extern int get_oid_commit(const char *str, struct object_id *oid);
 +extern int get_oid_committish(const char *str, struct object_id *oid);
 +extern int get_oid_tree(const char *str, struct object_id *oid);
 +extern int get_oid_treeish(const char *str, struct object_id *oid);
 +extern int get_oid_blob(const char *str, struct object_id *oid);
 +extern void maybe_die_on_misspelt_object_name(const char *name, const char *prefix);
 +extern int get_oid_with_context(const char *str, unsigned flags, struct object_id *oid, struct object_context *oc);
 +
  
  typedef int each_abbrev_fn(const struct object_id *oid, void *);
  extern int for_each_abbrev(const char *prefix, each_abbrev_fn, void *);
@@@ -1590,7 -1611,8 +1590,7 @@@ extern struct packed_git 
   * A most-recently-used ordered version of the packed_git list, which can
   * be iterated instead of packed_git (and marked via mru_mark).
   */
 -struct mru;
 -extern struct mru *packed_git_mru;
 +extern struct mru packed_git_mru;
  
  struct pack_entry {
  	off_t offset;
@@@ -1598,6 -1620,29 +1598,6 @@@
  	struct packed_git *p;
  };
  
 -extern struct packed_git *parse_pack_index(unsigned char *sha1, const char *idx_path);
 -
 -/* A hook to report invalid files in pack directory */
 -#define PACKDIR_FILE_PACK 1
 -#define PACKDIR_FILE_IDX 2
 -#define PACKDIR_FILE_GARBAGE 4
 -extern void (*report_garbage)(unsigned seen_bits, const char *path);
 -
 -extern void prepare_packed_git(void);
 -extern void reprepare_packed_git(void);
 -extern void install_packed_git(struct packed_git *pack);
 -
 -/*
 - * Give a rough count of objects in the repository. This sacrifices accuracy
 - * for speed.
 - */
 -unsigned long approximate_object_count(void);
 -
 -extern struct packed_git *find_sha1_pack(const unsigned char *sha1,
 -					 struct packed_git *packs);
 -
 -extern void pack_report(void);
 -
  /*
   * Create a temporary file rooted in the object database directory, or
   * die on failure. The filename is taken from "pattern", which should have the
@@@ -1606,6 -1651,15 +1606,6 @@@
   */
  extern int odb_mkstemp(struct strbuf *template, const char *pattern);
  
 -/*
 - * Generate the filename to be used for a pack file with checksum "sha1" and
 - * extension "ext". The result is written into the strbuf "buf", overwriting
 - * any existing contents. A pointer to buf->buf is returned as a convenience.
 - *
 - * Example: odb_pack_name(out, sha1, "idx") => ".git/objects/pack/pack-1234..idx"
 - */
 -extern char *odb_pack_name(struct strbuf *buf, const unsigned char *sha1, const char *ext);
 -
  /*
   * Create a pack .keep file named "name" (which should generally be the output
   * of odb_pack_name). Returns a file descriptor opened for writing, or -1 on
@@@ -1613,6 -1667,67 +1613,6 @@@
   */
  extern int odb_pack_keep(const char *name);
  
 -/*
 - * mmap the index file for the specified packfile (if it is not
 - * already mmapped).  Return 0 on success.
 - */
 -extern int open_pack_index(struct packed_git *);
 -
 -/*
 - * munmap the index file for the specified packfile (if it is
 - * currently mmapped).
 - */
 -extern void close_pack_index(struct packed_git *);
 -
 -extern unsigned char *use_pack(struct packed_git *, struct pack_window **, off_t, unsigned long *);
 -extern void close_pack_windows(struct packed_git *);
 -extern void close_all_packs(void);
 -extern void unuse_pack(struct pack_window **);
 -extern void clear_delta_base_cache(void);
 -extern struct packed_git *add_packed_git(const char *path, size_t path_len, int local);
 -
 -/*
 - * Make sure that a pointer access into an mmap'd index file is within bounds,
 - * and can provide at least 8 bytes of data.
 - *
 - * Note that this is only necessary for variable-length segments of the file
 - * (like the 64-bit extended offset table), as we compare the size to the
 - * fixed-length parts when we open the file.
 - */
 -extern void check_pack_index_ptr(const struct packed_git *p, const void *ptr);
 -
 -/*
 - * Return the SHA-1 of the nth object within the specified packfile.
 - * Open the index if it is not already open.  The return value points
 - * at the SHA-1 within the mmapped index.  Return NULL if there is an
 - * error.
 - */
 -extern const unsigned char *nth_packed_object_sha1(struct packed_git *, uint32_t n);
 -/*
 - * Like nth_packed_object_sha1, but write the data into the object specified by
 - * the the first argument.  Returns the first argument on success, and NULL on
 - * error.
 - */
 -extern const struct object_id *nth_packed_object_oid(struct object_id *, struct packed_git *, uint32_t n);
 -
 -/*
 - * Return the offset of the nth object within the specified packfile.
 - * The index must already be opened.
 - */
 -extern off_t nth_packed_object_offset(const struct packed_git *, uint32_t n);
 -
 -/*
 - * If the object named sha1 is present in the specified packfile,
 - * return its offset within the packfile; otherwise, return 0.
 - */
 -extern off_t find_pack_entry_one(const unsigned char *sha1, struct packed_git *);
 -
 -extern int is_pack_valid(struct packed_git *);
 -extern void *unpack_entry(struct packed_git *, off_t, enum object_type *, unsigned long *);
 -extern unsigned long unpack_object_header_buffer(const unsigned char *buf, unsigned long len, enum object_type *type, unsigned long *sizep);
 -extern unsigned long get_size_from_delta(struct packed_git *, struct pack_window **, off_t);
 -extern int unpack_object_header(struct packed_git *, struct pack_window **, off_t *, unsigned long *);
 -
  /*
   * Iterate over the files in the loose-object parts of the object
   * directory "path", triggering the following callbacks:
@@@ -1662,12 -1777,17 +1662,12 @@@ int for_each_loose_file_in_objdir_buf(s
  				      void *data);
  
  /*
 - * Iterate over loose and packed objects in both the local
 + * Iterate over loose objects in both the local
   * repository and any alternates repositories (unless the
   * LOCAL_ONLY flag is set).
   */
  #define FOR_EACH_OBJECT_LOCAL_ONLY 0x1
 -typedef int each_packed_object_fn(const struct object_id *oid,
 -				  struct packed_git *pack,
 -				  uint32_t pos,
 -				  void *data);
  extern int for_each_loose_object(each_loose_object_fn, void *, unsigned flags);
 -extern int for_each_packed_object(each_packed_object_fn, void *, unsigned flags);
  
  struct object_info {
  	/* Request */
@@@ -1717,6 -1837,7 +1717,6 @@@
  /* Do not retry packed storage after checking packed and loose storage */
  #define OBJECT_INFO_QUICK 8
  extern int sha1_object_info_extended(const unsigned char *, struct object_info *, unsigned flags);
 -extern int packed_object_info(struct packed_git *pack, off_t offset, struct object_info *);
  
  /* Dumb servers support */
  extern int update_server_info(int);
@@@ -1835,8 -1956,6 +1835,8 @@@ void shift_tree_by(const struct object_
  #define WS_TRAILING_SPACE      (WS_BLANK_AT_EOL|WS_BLANK_AT_EOF)
  #define WS_DEFAULT_RULE (WS_TRAILING_SPACE|WS_SPACE_BEFORE_TAB|8)
  #define WS_TAB_WIDTH_MASK        077
 +/* All WS_* -- when extended, adapt diff.c emit_symbol */
 +#define WS_RULE_MASK           07777
  extern unsigned whitespace_rule_cfg;
  extern unsigned whitespace_rule(const char *);
  extern unsigned parse_whitespace_rule(const char *);
diff --combined config.c
index 7ab37bacae,149bee1c71..345d78c2ba
--- a/config.c
+++ b/config.c
@@@ -929,7 -929,7 +929,7 @@@ ssize_t git_config_ssize_t(const char *
  	return ret;
  }
  
 -int git_parse_maybe_bool(const char *value)
 +static int git_parse_maybe_bool_text(const char *value)
  {
  	if (!value)
  		return 1;
@@@ -946,9 -946,9 +946,9 @@@
  	return -1;
  }
  
 -int git_config_maybe_bool(const char *name, const char *value)
 +int git_parse_maybe_bool(const char *value)
  {
 -	int v = git_parse_maybe_bool(value);
 +	int v = git_parse_maybe_bool_text(value);
  	if (0 <= v)
  		return v;
  	if (git_parse_int(value, &v))
@@@ -958,7 -958,7 +958,7 @@@
  
  int git_config_bool_or_int(const char *name, const char *value, int *is_bool)
  {
 -	int v = git_parse_maybe_bool(value);
 +	int v = git_parse_maybe_bool_text(value);
  	if (0 <= v) {
  		*is_bool = 1;
  		return v;
@@@ -1464,9 -1464,9 +1464,9 @@@ int git_config_from_mem(config_fn_t fn
  	return do_config_from(&top, fn, data);
  }
  
 -int git_config_from_blob_sha1(config_fn_t fn,
 +int git_config_from_blob_oid(config_fn_t fn,
  			      const char *name,
 -			      const unsigned char *sha1,
 +			      const struct object_id *oid,
  			      void *data)
  {
  	enum object_type type;
@@@ -1474,7 -1474,7 +1474,7 @@@
  	unsigned long size;
  	int ret;
  
 -	buf = read_sha1_file(sha1, &type, &size);
 +	buf = read_sha1_file(oid->hash, &type, &size);
  	if (!buf)
  		return error("unable to load config blob object '%s'", name);
  	if (type != OBJ_BLOB) {
@@@ -1492,11 -1492,11 +1492,11 @@@ static int git_config_from_blob_ref(con
  				    const char *name,
  				    void *data)
  {
 -	unsigned char sha1[20];
 +	struct object_id oid;
  
 -	if (get_sha1(name, sha1) < 0)
 +	if (get_oid(name, &oid) < 0)
  		return error("unable to resolve config blob '%s'", name);
 -	return git_config_from_blob_sha1(fn, name, sha1, data);
 +	return git_config_from_blob_oid(fn, name, &oid, data);
  }
  
  const char *git_etc_gitconfig(void)
@@@ -1719,19 -1719,17 +1719,19 @@@ static int configset_add_value(struct c
  }
  
  static int config_set_element_cmp(const void *unused_cmp_data,
 -				  const struct config_set_element *e1,
 -				  const struct config_set_element *e2,
 +				  const void *entry,
 +				  const void *entry_or_key,
  				  const void *unused_keydata)
  {
 +	const struct config_set_element *e1 = entry;
 +	const struct config_set_element *e2 = entry_or_key;
 +
  	return strcmp(e1->key, e2->key);
  }
  
  void git_configset_init(struct config_set *cs)
  {
 -	hashmap_init(&cs->config_hash, (hashmap_cmp_fn)config_set_element_cmp,
 -		     NULL, 0);
 +	hashmap_init(&cs->config_hash, config_set_element_cmp, NULL, 0);
  	cs->hash_initialized = 1;
  	cs->list.nr = 0;
  	cs->list.alloc = 0;
@@@ -1852,7 -1850,7 +1852,7 @@@ int git_configset_get_maybe_bool(struc
  {
  	const char *value;
  	if (!git_configset_get_value(cs, key, &value)) {
 -		*dest = git_config_maybe_bool(key, value);
 +		*dest = git_parse_maybe_bool(value);
  		if (*dest == -1)
  			return -1;
  		return 0;
@@@ -2059,23 -2057,6 +2059,23 @@@ int git_config_get_pathname(const char 
  	return repo_config_get_pathname(the_repository, key, dest);
  }
  
 +/*
 + * Note: This function exists solely to maintain backward compatibility with
 + * 'fetch' and 'update_clone' storing configuration in '.gitmodules' and should
 + * NOT be used anywhere else.
 + *
 + * Runs the provided config function on the '.gitmodules' file found in the
 + * working directory.
 + */
 +void config_from_gitmodules(config_fn_t fn, void *data)
 +{
 +	if (the_repository->worktree) {
 +		char *file = repo_worktree_path(the_repository, GITMODULES_FILE);
 +		git_config_from_file(fn, file, data);
 +		free(file);
 +	}
 +}
 +
  int git_config_get_expiry(const char *key, const char **output)
  {
  	int ret = git_config_get_string_const(key, output);
@@@ -2089,28 -2070,6 +2089,28 @@@
  	return ret;
  }
  
 +int git_config_get_expiry_in_days(const char *key, timestamp_t *expiry, timestamp_t now)
 +{
 +	char *expiry_string;
 +	intmax_t days;
 +	timestamp_t when;
 +
 +	if (git_config_get_string(key, &expiry_string))
 +		return 1; /* no such thing */
 +
 +	if (git_parse_signed(expiry_string, &days, maximum_signed_value_of_type(int))) {
 +		const int scale = 86400;
 +		*expiry = now - days * scale;
 +		return 0;
 +	}
 +
 +	if (!parse_expiry_date(expiry_string, &when)) {
 +		*expiry = when;
 +		return 0;
 +	}
 +	return -1; /* thing exists but cannot be parsed */
 +}
 +
  int git_config_get_untracked_cache(void)
  {
  	int val = -1;
@@@ -2200,7 -2159,7 +2200,7 @@@ static struct 
  	size_t *offset;
  	unsigned int offset_alloc;
  	enum { START, SECTION_SEEN, SECTION_END_SEEN, KEY_SEEN } state;
- 	int seen;
+ 	unsigned int seen;
  } store;
  
  static int matches(const char *key, const char *value)
@@@ -2292,11 -2251,10 +2292,11 @@@ static int write_error(const char *file
  	return 4;
  }
  
 -static int store_write_section(int fd, const char *key)
 +static ssize_t write_section(int fd, const char *key)
  {
  	const char *dot;
 -	int i, success;
 +	int i;
 +	ssize_t ret;
  	struct strbuf sb = STRBUF_INIT;
  
  	dot = memchr(key, '.', store.baselen);
@@@ -2312,16 -2270,15 +2312,16 @@@
  		strbuf_addf(&sb, "[%.*s]\n", store.baselen, key);
  	}
  
 -	success = write_in_full(fd, sb.buf, sb.len) == sb.len;
 +	ret = write_in_full(fd, sb.buf, sb.len);
  	strbuf_release(&sb);
  
 -	return success;
 +	return ret;
  }
  
 -static int store_write_pair(int fd, const char *key, const char *value)
 +static ssize_t write_pair(int fd, const char *key, const char *value)
  {
 -	int i, success;
 +	int i;
 +	ssize_t ret;
  	int length = strlen(key + store.baselen + 1);
  	const char *quote = "";
  	struct strbuf sb = STRBUF_INIT;
@@@ -2355,17 -2312,16 +2355,17 @@@
  		case '"':
  		case '\\':
  			strbuf_addch(&sb, '\\');
 +			/* fallthrough */
  		default:
  			strbuf_addch(&sb, value[i]);
  			break;
  		}
  	strbuf_addf(&sb, "%s\n", quote);
  
 -	success = write_in_full(fd, sb.buf, sb.len) == sb.len;
 +	ret = write_in_full(fd, sb.buf, sb.len);
  	strbuf_release(&sb);
  
 -	return success;
 +	return ret;
  }
  
  static ssize_t find_beginning_of_line(const char *contents, size_t size,
@@@ -2448,7 -2404,7 +2448,7 @@@ int git_config_set_multivar_in_file_gen
  {
  	int fd = -1, in_fd = -1;
  	int ret;
 -	struct lock_file *lock = NULL;
 +	struct lock_file lock = LOCK_INIT;
  	char *filename_buf = NULL;
  	char *contents = NULL;
  	size_t contents_sz;
@@@ -2467,7 -2423,8 +2467,7 @@@
  	 * The lock serves a purpose in addition to locking: the new
  	 * contents of .git/config will be written into it.
  	 */
 -	lock = xcalloc(1, sizeof(struct lock_file));
 -	fd = hold_lock_file_for_update(lock, config_filename, 0);
 +	fd = hold_lock_file_for_update(&lock, config_filename, 0);
  	if (fd < 0) {
  		error_errno("could not lock config file %s", config_filename);
  		free(store.key);
@@@ -2494,8 -2451,8 +2494,8 @@@
  		}
  
  		store.key = (char *)key;
 -		if (!store_write_section(fd, key) ||
 -		    !store_write_pair(fd, key, value))
 +		if (write_section(fd, key) < 0 ||
 +		    write_pair(fd, key, value) < 0)
  			goto write_err_out;
  	} else {
  		struct stat st;
@@@ -2580,8 -2537,8 +2580,8 @@@
  		close(in_fd);
  		in_fd = -1;
  
 -		if (chmod(get_lock_file_path(lock), st.st_mode & 07777) < 0) {
 -			error_errno("chmod on %s failed", get_lock_file_path(lock));
 +		if (chmod(get_lock_file_path(&lock), st.st_mode & 07777) < 0) {
 +			error_errno("chmod on %s failed", get_lock_file_path(&lock));
  			ret = CONFIG_NO_WRITE;
  			goto out_free;
  		}
@@@ -2605,10 -2562,11 +2605,10 @@@
  			/* write the first part of the config */
  			if (copy_end > copy_begin) {
  				if (write_in_full(fd, contents + copy_begin,
 -						  copy_end - copy_begin) <
 -				    copy_end - copy_begin)
 +						  copy_end - copy_begin) < 0)
  					goto write_err_out;
  				if (new_line &&
 -				    write_str_in_full(fd, "\n") != 1)
 +				    write_str_in_full(fd, "\n") < 0)
  					goto write_err_out;
  			}
  			copy_begin = store.offset[i];
@@@ -2617,36 -2575,46 +2617,36 @@@
  		/* write the pair (value == NULL means unset) */
  		if (value != NULL) {
  			if (store.state == START) {
 -				if (!store_write_section(fd, key))
 +				if (write_section(fd, key) < 0)
  					goto write_err_out;
  			}
 -			if (!store_write_pair(fd, key, value))
 +			if (write_pair(fd, key, value) < 0)
  				goto write_err_out;
  		}
  
  		/* write the rest of the config */
  		if (copy_begin < contents_sz)
  			if (write_in_full(fd, contents + copy_begin,
 -					  contents_sz - copy_begin) <
 -			    contents_sz - copy_begin)
 +					  contents_sz - copy_begin) < 0)
  				goto write_err_out;
  
  		munmap(contents, contents_sz);
  		contents = NULL;
  	}
  
 -	if (commit_lock_file(lock) < 0) {
 +	if (commit_lock_file(&lock) < 0) {
  		error_errno("could not write config file %s", config_filename);
  		ret = CONFIG_NO_WRITE;
 -		lock = NULL;
  		goto out_free;
  	}
  
 -	/*
 -	 * lock is committed, so don't try to roll it back below.
 -	 * NOTE: Since lockfile.c keeps a linked list of all created
 -	 * lock_file structures, it isn't safe to free(lock).  It's
 -	 * better to just leave it hanging around.
 -	 */
 -	lock = NULL;
  	ret = 0;
  
  	/* Invalidate the config cache */
  	git_config_clear();
  
  out_free:
 -	if (lock)
 -		rollback_lock_file(lock);
 +	rollback_lock_file(&lock);
  	free(filename_buf);
  	if (contents)
  		munmap(contents, contents_sz);
@@@ -2655,7 -2623,7 +2655,7 @@@
  	return ret;
  
  write_err_out:
 -	ret = write_error(get_lock_file_path(lock));
 +	ret = write_error(get_lock_file_path(&lock));
  	goto out_free;
  
  }
@@@ -2804,7 -2772,7 +2804,7 @@@ int git_config_rename_section_in_file(c
  					continue;
  				}
  				store.baselen = strlen(new_name);
 -				if (!store_write_section(out_fd, new_name)) {
 +				if (write_section(out_fd, new_name) < 0) {
  					ret = write_error(get_lock_file_path(lock));
  					goto out;
  				}
@@@ -2830,7 -2798,7 +2830,7 @@@
  		if (remove)
  			continue;
  		length = strlen(output);
 -		if (write_in_full(out_fd, output, length) != length) {
 +		if (write_in_full(out_fd, output, length) < 0) {
  			ret = write_error(get_lock_file_path(lock));
  			goto out;
  		}
diff --combined diff.c
index 3c6a3e0faa,c7cf683e0b..4da0714cb5
--- a/diff.c
+++ b/diff.c
@@@ -16,12 -16,10 +16,12 @@@
  #include "userdiff.h"
  #include "submodule-config.h"
  #include "submodule.h"
 +#include "hashmap.h"
  #include "ll-merge.h"
  #include "string-list.h"
  #include "argv-array.h"
  #include "graph.h"
 +#include "packfile.h"
  
  #ifdef NO_FAST_WORKING_DIRECTORY
  #define FAST_WORKING_DIRECTORY 0
@@@ -34,7 -32,6 +34,7 @@@ static int diff_indent_heuristic = 1
  static int diff_rename_limit_default = 400;
  static int diff_suppress_blank_empty;
  static int diff_use_color_default = -1;
 +static int diff_color_moved_default;
  static int diff_context_default = 3;
  static int diff_interhunk_context_default;
  static const char *diff_word_regex_cfg;
@@@ -59,14 -56,6 +59,14 @@@ static char diff_colors[][COLOR_MAXLEN
  	GIT_COLOR_YELLOW,	/* COMMIT */
  	GIT_COLOR_BG_RED,	/* WHITESPACE */
  	GIT_COLOR_NORMAL,	/* FUNCINFO */
 +	GIT_COLOR_BOLD_MAGENTA,	/* OLD_MOVED */
 +	GIT_COLOR_BOLD_BLUE,	/* OLD_MOVED ALTERNATIVE */
 +	GIT_COLOR_FAINT,	/* OLD_MOVED_DIM */
 +	GIT_COLOR_FAINT_ITALIC,	/* OLD_MOVED_ALTERNATIVE_DIM */
 +	GIT_COLOR_BOLD_CYAN,	/* NEW_MOVED */
 +	GIT_COLOR_BOLD_YELLOW,	/* NEW_MOVED ALTERNATIVE */
 +	GIT_COLOR_FAINT,	/* NEW_MOVED_DIM */
 +	GIT_COLOR_FAINT_ITALIC,	/* NEW_MOVED_ALTERNATIVE_DIM */
  };
  
  static NORETURN void die_want_option(const char *option_name)
@@@ -92,22 -81,6 +92,22 @@@ static int parse_diff_color_slot(const 
  		return DIFF_WHITESPACE;
  	if (!strcasecmp(var, "func"))
  		return DIFF_FUNCINFO;
 +	if (!strcasecmp(var, "oldmoved"))
 +		return DIFF_FILE_OLD_MOVED;
 +	if (!strcasecmp(var, "oldmovedalternative"))
 +		return DIFF_FILE_OLD_MOVED_ALT;
 +	if (!strcasecmp(var, "oldmoveddimmed"))
 +		return DIFF_FILE_OLD_MOVED_DIM;
 +	if (!strcasecmp(var, "oldmovedalternativedimmed"))
 +		return DIFF_FILE_OLD_MOVED_ALT_DIM;
 +	if (!strcasecmp(var, "newmoved"))
 +		return DIFF_FILE_NEW_MOVED;
 +	if (!strcasecmp(var, "newmovedalternative"))
 +		return DIFF_FILE_NEW_MOVED_ALT;
 +	if (!strcasecmp(var, "newmoveddimmed"))
 +		return DIFF_FILE_NEW_MOVED_DIM;
 +	if (!strcasecmp(var, "newmovedalternativedimmed"))
 +		return DIFF_FILE_NEW_MOVED_ALT_DIM;
  	return -1;
  }
  
@@@ -256,44 -229,12 +256,44 @@@ int git_diff_heuristic_config(const cha
  	return 0;
  }
  
 +static int parse_color_moved(const char *arg)
 +{
 +	switch (git_parse_maybe_bool(arg)) {
 +	case 0:
 +		return COLOR_MOVED_NO;
 +	case 1:
 +		return COLOR_MOVED_DEFAULT;
 +	default:
 +		break;
 +	}
 +
 +	if (!strcmp(arg, "no"))
 +		return COLOR_MOVED_NO;
 +	else if (!strcmp(arg, "plain"))
 +		return COLOR_MOVED_PLAIN;
 +	else if (!strcmp(arg, "zebra"))
 +		return COLOR_MOVED_ZEBRA;
 +	else if (!strcmp(arg, "default"))
 +		return COLOR_MOVED_DEFAULT;
 +	else if (!strcmp(arg, "dimmed_zebra"))
 +		return COLOR_MOVED_ZEBRA_DIM;
 +	else
 +		return error(_("color moved setting must be one of 'no', 'default', 'zebra', 'dimmed_zebra', 'plain'"));
 +}
 +
  int git_diff_ui_config(const char *var, const char *value, void *cb)
  {
  	if (!strcmp(var, "diff.color") || !strcmp(var, "color.diff")) {
  		diff_use_color_default = git_config_colorbool(var, value);
  		return 0;
  	}
 +	if (!strcmp(var, "diff.colormoved")) {
 +		int cm = parse_color_moved(value);
 +		if (cm < 0)
 +			return -1;
 +		diff_color_moved_default = cm;
 +		return 0;
 +	}
  	if (!strcmp(var, "diff.context")) {
  		diff_context_default = git_config_int(var, value);
  		if (diff_context_default < 0)
@@@ -402,6 -343,9 +402,6 @@@ int git_diff_basic_config(const char *v
  		return 0;
  	}
  
 -	if (starts_with(var, "submodule."))
 -		return parse_submodule_config_option(var, value);
 -
  	if (git_diff_heuristic_config(var, value, cb) < 0)
  		return -1;
  
@@@ -459,9 -403,11 +459,9 @@@ static struct diff_tempfile 
  	 * If this diff_tempfile instance refers to a temporary file,
  	 * this tempfile object is used to manage its lifetime.
  	 */
 -	struct tempfile tempfile;
 +	struct tempfile *tempfile;
  } diff_temp[2];
  
 -typedef unsigned long (*sane_truncate_fn)(char *line, unsigned long len);
 -
  struct emit_callback {
  	int color_diff;
  	unsigned ws_rule;
@@@ -469,6 -415,7 +469,6 @@@
  	int blank_at_eof_in_postimage;
  	int lno_in_preimage;
  	int lno_in_postimage;
 -	sane_truncate_fn truncate;
  	const char **label_path;
  	struct diff_words_data *diff_words;
  	struct diff_options *opt;
@@@ -610,735 -557,68 +610,735 @@@ static void emit_line(struct diff_optio
  	emit_line_0(o, set, reset, line[0], line+1, len-1);
  }
  
 -static int new_blank_line_at_eof(struct emit_callback *ecbdata, const char *line, int len)
 +enum diff_symbol {
 +	DIFF_SYMBOL_BINARY_DIFF_HEADER,
 +	DIFF_SYMBOL_BINARY_DIFF_HEADER_DELTA,
 +	DIFF_SYMBOL_BINARY_DIFF_HEADER_LITERAL,
 +	DIFF_SYMBOL_BINARY_DIFF_BODY,
 +	DIFF_SYMBOL_BINARY_DIFF_FOOTER,
 +	DIFF_SYMBOL_STATS_SUMMARY_NO_FILES,
 +	DIFF_SYMBOL_STATS_SUMMARY_ABBREV,
 +	DIFF_SYMBOL_STATS_SUMMARY_INSERTS_DELETES,
 +	DIFF_SYMBOL_STATS_LINE,
 +	DIFF_SYMBOL_WORD_DIFF,
 +	DIFF_SYMBOL_STAT_SEP,
 +	DIFF_SYMBOL_SUMMARY,
 +	DIFF_SYMBOL_SUBMODULE_ADD,
 +	DIFF_SYMBOL_SUBMODULE_DEL,
 +	DIFF_SYMBOL_SUBMODULE_UNTRACKED,
 +	DIFF_SYMBOL_SUBMODULE_MODIFIED,
 +	DIFF_SYMBOL_SUBMODULE_HEADER,
 +	DIFF_SYMBOL_SUBMODULE_ERROR,
 +	DIFF_SYMBOL_SUBMODULE_PIPETHROUGH,
 +	DIFF_SYMBOL_REWRITE_DIFF,
 +	DIFF_SYMBOL_BINARY_FILES,
 +	DIFF_SYMBOL_HEADER,
 +	DIFF_SYMBOL_FILEPAIR_PLUS,
 +	DIFF_SYMBOL_FILEPAIR_MINUS,
 +	DIFF_SYMBOL_WORDS_PORCELAIN,
 +	DIFF_SYMBOL_WORDS,
 +	DIFF_SYMBOL_CONTEXT,
 +	DIFF_SYMBOL_CONTEXT_INCOMPLETE,
 +	DIFF_SYMBOL_PLUS,
 +	DIFF_SYMBOL_MINUS,
 +	DIFF_SYMBOL_NO_LF_EOF,
 +	DIFF_SYMBOL_CONTEXT_FRAGINFO,
 +	DIFF_SYMBOL_CONTEXT_MARKER,
 +	DIFF_SYMBOL_SEPARATOR
 +};
 +/*
 + * Flags for content lines:
 + * 0..12 are whitespace rules
 + * 13-15 are WSEH_NEW | WSEH_OLD | WSEH_CONTEXT
 + * 16 is marking if the line is blank at EOF
 + */
 +#define DIFF_SYMBOL_CONTENT_BLANK_LINE_EOF	(1<<16)
 +#define DIFF_SYMBOL_MOVED_LINE			(1<<17)
 +#define DIFF_SYMBOL_MOVED_LINE_ALT		(1<<18)
 +#define DIFF_SYMBOL_MOVED_LINE_UNINTERESTING	(1<<19)
 +#define DIFF_SYMBOL_CONTENT_WS_MASK (WSEH_NEW | WSEH_OLD | WSEH_CONTEXT | WS_RULE_MASK)
 +
 +/*
 + * This struct is used when we need to buffer the output of the diff output.
 + *
 + * NEEDSWORK: Instead of storing a copy of the line, add an offset pointer
 + * into the pre/post image file. This pointer could be a union with the
 + * line pointer. By storing an offset into the file instead of the literal line,
 + * we can decrease the memory footprint for the buffered output. At first we
 + * may want to only have indirection for the content lines, but we could also
 + * enhance the state for emitting prefabricated lines, e.g. the similarity
 + * score line or hunk/file headers would only need to store a number or path
 + * and then the output can be constructed later on depending on state.
 + */
 +struct emitted_diff_symbol {
 +	const char *line;
 +	int len;
 +	int flags;
 +	enum diff_symbol s;
 +};
 +#define EMITTED_DIFF_SYMBOL_INIT {NULL}
 +
 +struct emitted_diff_symbols {
 +	struct emitted_diff_symbol *buf;
 +	int nr, alloc;
 +};
 +#define EMITTED_DIFF_SYMBOLS_INIT {NULL, 0, 0}
 +
 +static void append_emitted_diff_symbol(struct diff_options *o,
 +				       struct emitted_diff_symbol *e)
  {
 -	if (!((ecbdata->ws_rule & WS_BLANK_AT_EOF) &&
 -	      ecbdata->blank_at_eof_in_preimage &&
 -	      ecbdata->blank_at_eof_in_postimage &&
 -	      ecbdata->blank_at_eof_in_preimage <= ecbdata->lno_in_preimage &&
 -	      ecbdata->blank_at_eof_in_postimage <= ecbdata->lno_in_postimage))
 -		return 0;
 -	return ws_blank_line(line, len, ecbdata->ws_rule);
 +	struct emitted_diff_symbol *f;
 +
 +	ALLOC_GROW(o->emitted_symbols->buf,
 +		   o->emitted_symbols->nr + 1,
 +		   o->emitted_symbols->alloc);
 +	f = &o->emitted_symbols->buf[o->emitted_symbols->nr++];
 +
 +	memcpy(f, e, sizeof(struct emitted_diff_symbol));
 +	f->line = e->line ? xmemdupz(e->line, e->len) : NULL;
  }
  
 -static void emit_line_checked(const char *reset,
 -			      struct emit_callback *ecbdata,
 -			      const char *line, int len,
 -			      enum color_diff color,
 -			      unsigned ws_error_highlight,
 -			      char sign)
 +struct moved_entry {
 +	struct hashmap_entry ent;
 +	const struct emitted_diff_symbol *es;
 +	struct moved_entry *next_line;
 +};
 +
 +static int next_byte(const char **cp, const char **endp,
 +		     const struct diff_options *diffopt)
 +{
 +	int retval;
 +
 +	if (*cp > *endp)
 +		return -1;
 +
 +	if (DIFF_XDL_TST(diffopt, IGNORE_WHITESPACE_CHANGE)) {
 +		while (*cp < *endp && isspace(**cp))
 +			(*cp)++;
 +		/*
 +		 * After skipping a couple of whitespaces, we still have to
 +		 * account for one space.
 +		 */
 +		return (int)' ';
 +	}
 +
 +	if (DIFF_XDL_TST(diffopt, IGNORE_WHITESPACE)) {
 +		while (*cp < *endp && isspace(**cp))
 +			(*cp)++;
 +		/* return the first non-ws character via the usual below */
 +	}
 +
 +	retval = (unsigned char)(**cp);
 +	(*cp)++;
 +	return retval;
 +}
 +
 +static int moved_entry_cmp(const struct diff_options *diffopt,
 +			   const struct moved_entry *a,
 +			   const struct moved_entry *b,
 +			   const void *keydata)
 +{
 +	const char *ap = a->es->line, *ae = a->es->line + a->es->len;
 +	const char *bp = b->es->line, *be = b->es->line + b->es->len;
 +
 +	if (!(diffopt->xdl_opts & XDF_WHITESPACE_FLAGS))
 +		return a->es->len != b->es->len  || memcmp(ap, bp, a->es->len);
 +
 +	if (DIFF_XDL_TST(diffopt, IGNORE_WHITESPACE_AT_EOL)) {
 +		while (ae > ap && isspace(*ae))
 +			ae--;
 +		while (be > bp && isspace(*be))
 +			be--;
 +	}
 +
 +	while (1) {
 +		int ca, cb;
 +		ca = next_byte(&ap, &ae, diffopt);
 +		cb = next_byte(&bp, &be, diffopt);
 +		if (ca != cb)
 +			return 1;
 +		if (ca < 0)
 +			return 0;
 +	}
 +}
 +
 +static unsigned get_string_hash(struct emitted_diff_symbol *es, struct diff_options *o)
 +{
 +	if (o->xdl_opts & XDF_WHITESPACE_FLAGS) {
 +		static struct strbuf sb = STRBUF_INIT;
 +		const char *ap = es->line, *ae = es->line + es->len;
 +		int c;
 +
 +		strbuf_reset(&sb);
 +		while (ae > ap && isspace(*ae))
 +			ae--;
 +		while ((c = next_byte(&ap, &ae, o)) > 0)
 +			strbuf_addch(&sb, c);
 +
 +		return memhash(sb.buf, sb.len);
 +	} else {
 +		return memhash(es->line, es->len);
 +	}
 +}
 +
 +static struct moved_entry *prepare_entry(struct diff_options *o,
 +					 int line_no)
 +{
 +	struct moved_entry *ret = xmalloc(sizeof(*ret));
 +	struct emitted_diff_symbol *l = &o->emitted_symbols->buf[line_no];
 +
 +	ret->ent.hash = get_string_hash(l, o);
 +	ret->es = l;
 +	ret->next_line = NULL;
 +
 +	return ret;
 +}
 +
 +static void add_lines_to_move_detection(struct diff_options *o,
 +					struct hashmap *add_lines,
 +					struct hashmap *del_lines)
 +{
 +	struct moved_entry *prev_line = NULL;
 +
 +	int n;
 +	for (n = 0; n < o->emitted_symbols->nr; n++) {
 +		struct hashmap *hm;
 +		struct moved_entry *key;
 +
 +		switch (o->emitted_symbols->buf[n].s) {
 +		case DIFF_SYMBOL_PLUS:
 +			hm = add_lines;
 +			break;
 +		case DIFF_SYMBOL_MINUS:
 +			hm = del_lines;
 +			break;
 +		default:
 +			prev_line = NULL;
 +			continue;
 +		}
 +
 +		key = prepare_entry(o, n);
 +		if (prev_line && prev_line->es->s == o->emitted_symbols->buf[n].s)
 +			prev_line->next_line = key;
 +
 +		hashmap_add(hm, key);
 +		prev_line = key;
 +	}
 +}
 +
 +static int shrink_potential_moved_blocks(struct moved_entry **pmb,
 +					 int pmb_nr)
 +{
 +	int lp, rp;
 +
 +	/* Shrink the set of potential block to the remaining running */
 +	for (lp = 0, rp = pmb_nr - 1; lp <= rp;) {
 +		while (lp < pmb_nr && pmb[lp])
 +			lp++;
 +		/* lp points at the first NULL now */
 +
 +		while (rp > -1 && !pmb[rp])
 +			rp--;
 +		/* rp points at the last non-NULL */
 +
 +		if (lp < pmb_nr && rp > -1 && lp < rp) {
 +			pmb[lp] = pmb[rp];
 +			pmb[rp] = NULL;
 +			rp--;
 +			lp++;
 +		}
 +	}
 +
 +	/* Remember the number of running sets */
 +	return rp + 1;
 +}
 +
 +/*
 + * If o->color_moved is COLOR_MOVED_PLAIN, this function does nothing.
 + *
 + * Otherwise, if the last block has fewer alphanumeric characters than
 + * COLOR_MOVED_MIN_ALNUM_COUNT, unset DIFF_SYMBOL_MOVED_LINE on all lines in
 + * that block.
 + *
 + * The last block consists of the (n - block_length)'th line up to but not
 + * including the nth line.
 + *
 + * NEEDSWORK: This uses the same heuristic as blame_entry_score() in blame.c.
 + * Think of a way to unify them.
 + */
 +static void adjust_last_block(struct diff_options *o, int n, int block_length)
 +{
 +	int i, alnum_count = 0;
 +	if (o->color_moved == COLOR_MOVED_PLAIN)
 +		return;
 +	for (i = 1; i < block_length + 1; i++) {
 +		const char *c = o->emitted_symbols->buf[n - i].line;
 +		for (; *c; c++) {
 +			if (!isalnum(*c))
 +				continue;
 +			alnum_count++;
 +			if (alnum_count >= COLOR_MOVED_MIN_ALNUM_COUNT)
 +				return;
 +		}
 +	}
 +	for (i = 1; i < block_length + 1; i++)
 +		o->emitted_symbols->buf[n - i].flags &= ~DIFF_SYMBOL_MOVED_LINE;
 +}
 +
 +/* Find blocks of moved code, delegate actual coloring decision to helper */
 +static void mark_color_as_moved(struct diff_options *o,
 +				struct hashmap *add_lines,
 +				struct hashmap *del_lines)
 +{
 +	struct moved_entry **pmb = NULL; /* potentially moved blocks */
 +	int pmb_nr = 0, pmb_alloc = 0;
 +	int n, flipped_block = 1, block_length = 0;
 +
 +
 +	for (n = 0; n < o->emitted_symbols->nr; n++) {
 +		struct hashmap *hm = NULL;
 +		struct moved_entry *key;
 +		struct moved_entry *match = NULL;
 +		struct emitted_diff_symbol *l = &o->emitted_symbols->buf[n];
 +		int i;
 +
 +		switch (l->s) {
 +		case DIFF_SYMBOL_PLUS:
 +			hm = del_lines;
 +			key = prepare_entry(o, n);
 +			match = hashmap_get(hm, key, o);
 +			free(key);
 +			break;
 +		case DIFF_SYMBOL_MINUS:
 +			hm = add_lines;
 +			key = prepare_entry(o, n);
 +			match = hashmap_get(hm, key, o);
 +			free(key);
 +			break;
 +		default:
 +			flipped_block = 1;
 +		}
 +
 +		if (!match) {
 +			adjust_last_block(o, n, block_length);
 +			pmb_nr = 0;
 +			block_length = 0;
 +			continue;
 +		}
 +
 +		l->flags |= DIFF_SYMBOL_MOVED_LINE;
 +
 +		if (o->color_moved == COLOR_MOVED_PLAIN)
 +			continue;
 +
 +		/* Check any potential block runs, advance each or nullify */
 +		for (i = 0; i < pmb_nr; i++) {
 +			struct moved_entry *p = pmb[i];
 +			struct moved_entry *pnext = (p && p->next_line) ?
 +					p->next_line : NULL;
 +			if (pnext && !hm->cmpfn(o, pnext, match, NULL)) {
 +				pmb[i] = p->next_line;
 +			} else {
 +				pmb[i] = NULL;
 +			}
 +		}
 +
 +		pmb_nr = shrink_potential_moved_blocks(pmb, pmb_nr);
 +
 +		if (pmb_nr == 0) {
 +			/*
 +			 * The current line is the start of a new block.
 +			 * Setup the set of potential blocks.
 +			 */
 +			for (; match; match = hashmap_get_next(hm, match)) {
 +				ALLOC_GROW(pmb, pmb_nr + 1, pmb_alloc);
 +				pmb[pmb_nr++] = match;
 +			}
 +
 +			flipped_block = (flipped_block + 1) % 2;
 +
 +			adjust_last_block(o, n, block_length);
 +			block_length = 0;
 +		}
 +
 +		block_length++;
 +
 +		if (flipped_block)
 +			l->flags |= DIFF_SYMBOL_MOVED_LINE_ALT;
 +	}
 +	adjust_last_block(o, n, block_length);
 +
 +	free(pmb);
 +}
 +
 +#define DIFF_SYMBOL_MOVED_LINE_ZEBRA_MASK \
 +  (DIFF_SYMBOL_MOVED_LINE | DIFF_SYMBOL_MOVED_LINE_ALT)
 +static void dim_moved_lines(struct diff_options *o)
 +{
 +	int n;
 +	for (n = 0; n < o->emitted_symbols->nr; n++) {
 +		struct emitted_diff_symbol *prev = (n != 0) ?
 +				&o->emitted_symbols->buf[n - 1] : NULL;
 +		struct emitted_diff_symbol *l = &o->emitted_symbols->buf[n];
 +		struct emitted_diff_symbol *next =
 +				(n < o->emitted_symbols->nr - 1) ?
 +				&o->emitted_symbols->buf[n + 1] : NULL;
 +
 +		/* Not a plus or minus line? */
 +		if (l->s != DIFF_SYMBOL_PLUS && l->s != DIFF_SYMBOL_MINUS)
 +			continue;
 +
 +		/* Not a moved line? */
 +		if (!(l->flags & DIFF_SYMBOL_MOVED_LINE))
 +			continue;
 +
 +		/*
 +		 * If prev or next are not a plus or minus line,
 +		 * pretend they don't exist
 +		 */
 +		if (prev && prev->s != DIFF_SYMBOL_PLUS &&
 +			    prev->s != DIFF_SYMBOL_MINUS)
 +			prev = NULL;
 +		if (next && next->s != DIFF_SYMBOL_PLUS &&
 +			    next->s != DIFF_SYMBOL_MINUS)
 +			next = NULL;
 +
 +		/* Inside a block? */
 +		if ((prev &&
 +		    (prev->flags & DIFF_SYMBOL_MOVED_LINE_ZEBRA_MASK) ==
 +		    (l->flags & DIFF_SYMBOL_MOVED_LINE_ZEBRA_MASK)) &&
 +		    (next &&
 +		    (next->flags & DIFF_SYMBOL_MOVED_LINE_ZEBRA_MASK) ==
 +		    (l->flags & DIFF_SYMBOL_MOVED_LINE_ZEBRA_MASK))) {
 +			l->flags |= DIFF_SYMBOL_MOVED_LINE_UNINTERESTING;
 +			continue;
 +		}
 +
 +		/* Check if we are at an interesting bound: */
 +		if (prev && (prev->flags & DIFF_SYMBOL_MOVED_LINE) &&
 +		    (prev->flags & DIFF_SYMBOL_MOVED_LINE_ALT) !=
 +		       (l->flags & DIFF_SYMBOL_MOVED_LINE_ALT))
 +			continue;
 +		if (next && (next->flags & DIFF_SYMBOL_MOVED_LINE) &&
 +		    (next->flags & DIFF_SYMBOL_MOVED_LINE_ALT) !=
 +		       (l->flags & DIFF_SYMBOL_MOVED_LINE_ALT))
 +			continue;
 +
 +		/*
 +		 * The boundary to prev and next are not interesting,
 +		 * so this line is not interesting as a whole
 +		 */
 +		l->flags |= DIFF_SYMBOL_MOVED_LINE_UNINTERESTING;
 +	}
 +}
 +
 +static void emit_line_ws_markup(struct diff_options *o,
 +				const char *set, const char *reset,
 +				const char *line, int len, char sign,
 +				unsigned ws_rule, int blank_at_eof)
  {
 -	const char *set = diff_get_color(ecbdata->color_diff, color);
  	const char *ws = NULL;
  
 -	if (ecbdata->opt->ws_error_highlight & ws_error_highlight) {
 -		ws = diff_get_color(ecbdata->color_diff, DIFF_WHITESPACE);
 +	if (o->ws_error_highlight & ws_rule) {
 +		ws = diff_get_color_opt(o, DIFF_WHITESPACE);
  		if (!*ws)
  			ws = NULL;
  	}
  
  	if (!ws)
 -		emit_line_0(ecbdata->opt, set, reset, sign, line, len);
 -	else if (sign == '+' && new_blank_line_at_eof(ecbdata, line, len))
 +		emit_line_0(o, set, reset, sign, line, len);
 +	else if (blank_at_eof)
  		/* Blank line at EOF - paint '+' as well */
 -		emit_line_0(ecbdata->opt, ws, reset, sign, line, len);
 +		emit_line_0(o, ws, reset, sign, line, len);
  	else {
  		/* Emit just the prefix, then the rest. */
 -		emit_line_0(ecbdata->opt, set, reset, sign, "", 0);
 -		ws_check_emit(line, len, ecbdata->ws_rule,
 -			      ecbdata->opt->file, set, reset, ws);
 +		emit_line_0(o, set, reset, sign, "", 0);
 +		ws_check_emit(line, len, ws_rule,
 +			      o->file, set, reset, ws);
  	}
  }
  
 +static void emit_diff_symbol_from_struct(struct diff_options *o,
 +					 struct emitted_diff_symbol *eds)
 +{
 +	static const char *nneof = " No newline at end of file\n";
 +	const char *context, *reset, *set, *meta, *fraginfo;
 +	struct strbuf sb = STRBUF_INIT;
 +
 +	enum diff_symbol s = eds->s;
 +	const char *line = eds->line;
 +	int len = eds->len;
 +	unsigned flags = eds->flags;
 +
 +	switch (s) {
 +	case DIFF_SYMBOL_NO_LF_EOF:
 +		context = diff_get_color_opt(o, DIFF_CONTEXT);
 +		reset = diff_get_color_opt(o, DIFF_RESET);
 +		putc('\n', o->file);
 +		emit_line_0(o, context, reset, '\\',
 +			    nneof, strlen(nneof));
 +		break;
 +	case DIFF_SYMBOL_SUBMODULE_HEADER:
 +	case DIFF_SYMBOL_SUBMODULE_ERROR:
 +	case DIFF_SYMBOL_SUBMODULE_PIPETHROUGH:
 +	case DIFF_SYMBOL_STATS_SUMMARY_INSERTS_DELETES:
 +	case DIFF_SYMBOL_SUMMARY:
 +	case DIFF_SYMBOL_STATS_LINE:
 +	case DIFF_SYMBOL_BINARY_DIFF_BODY:
 +	case DIFF_SYMBOL_CONTEXT_FRAGINFO:
 +		emit_line(o, "", "", line, len);
 +		break;
 +	case DIFF_SYMBOL_CONTEXT_INCOMPLETE:
 +	case DIFF_SYMBOL_CONTEXT_MARKER:
 +		context = diff_get_color_opt(o, DIFF_CONTEXT);
 +		reset = diff_get_color_opt(o, DIFF_RESET);
 +		emit_line(o, context, reset, line, len);
 +		break;
 +	case DIFF_SYMBOL_SEPARATOR:
 +		fprintf(o->file, "%s%c",
 +			diff_line_prefix(o),
 +			o->line_termination);
 +		break;
 +	case DIFF_SYMBOL_CONTEXT:
 +		set = diff_get_color_opt(o, DIFF_CONTEXT);
 +		reset = diff_get_color_opt(o, DIFF_RESET);
 +		emit_line_ws_markup(o, set, reset, line, len, ' ',
 +				    flags & (DIFF_SYMBOL_CONTENT_WS_MASK), 0);
 +		break;
 +	case DIFF_SYMBOL_PLUS:
 +		switch (flags & (DIFF_SYMBOL_MOVED_LINE |
 +				 DIFF_SYMBOL_MOVED_LINE_ALT |
 +				 DIFF_SYMBOL_MOVED_LINE_UNINTERESTING)) {
 +		case DIFF_SYMBOL_MOVED_LINE |
 +		     DIFF_SYMBOL_MOVED_LINE_ALT |
 +		     DIFF_SYMBOL_MOVED_LINE_UNINTERESTING:
 +			set = diff_get_color_opt(o, DIFF_FILE_NEW_MOVED_ALT_DIM);
 +			break;
 +		case DIFF_SYMBOL_MOVED_LINE |
 +		     DIFF_SYMBOL_MOVED_LINE_ALT:
 +			set = diff_get_color_opt(o, DIFF_FILE_NEW_MOVED_ALT);
 +			break;
 +		case DIFF_SYMBOL_MOVED_LINE |
 +		     DIFF_SYMBOL_MOVED_LINE_UNINTERESTING:
 +			set = diff_get_color_opt(o, DIFF_FILE_NEW_MOVED_DIM);
 +			break;
 +		case DIFF_SYMBOL_MOVED_LINE:
 +			set = diff_get_color_opt(o, DIFF_FILE_NEW_MOVED);
 +			break;
 +		default:
 +			set = diff_get_color_opt(o, DIFF_FILE_NEW);
 +		}
 +		reset = diff_get_color_opt(o, DIFF_RESET);
 +		emit_line_ws_markup(o, set, reset, line, len, '+',
 +				    flags & DIFF_SYMBOL_CONTENT_WS_MASK,
 +				    flags & DIFF_SYMBOL_CONTENT_BLANK_LINE_EOF);
 +		break;
 +	case DIFF_SYMBOL_MINUS:
 +		switch (flags & (DIFF_SYMBOL_MOVED_LINE |
 +				 DIFF_SYMBOL_MOVED_LINE_ALT |
 +				 DIFF_SYMBOL_MOVED_LINE_UNINTERESTING)) {
 +		case DIFF_SYMBOL_MOVED_LINE |
 +		     DIFF_SYMBOL_MOVED_LINE_ALT |
 +		     DIFF_SYMBOL_MOVED_LINE_UNINTERESTING:
 +			set = diff_get_color_opt(o, DIFF_FILE_OLD_MOVED_ALT_DIM);
 +			break;
 +		case DIFF_SYMBOL_MOVED_LINE |
 +		     DIFF_SYMBOL_MOVED_LINE_ALT:
 +			set = diff_get_color_opt(o, DIFF_FILE_OLD_MOVED_ALT);
 +			break;
 +		case DIFF_SYMBOL_MOVED_LINE |
 +		     DIFF_SYMBOL_MOVED_LINE_UNINTERESTING:
 +			set = diff_get_color_opt(o, DIFF_FILE_OLD_MOVED_DIM);
 +			break;
 +		case DIFF_SYMBOL_MOVED_LINE:
 +			set = diff_get_color_opt(o, DIFF_FILE_OLD_MOVED);
 +			break;
 +		default:
 +			set = diff_get_color_opt(o, DIFF_FILE_OLD);
 +		}
 +		reset = diff_get_color_opt(o, DIFF_RESET);
 +		emit_line_ws_markup(o, set, reset, line, len, '-',
 +				    flags & DIFF_SYMBOL_CONTENT_WS_MASK, 0);
 +		break;
 +	case DIFF_SYMBOL_WORDS_PORCELAIN:
 +		context = diff_get_color_opt(o, DIFF_CONTEXT);
 +		reset = diff_get_color_opt(o, DIFF_RESET);
 +		emit_line(o, context, reset, line, len);
 +		fputs("~\n", o->file);
 +		break;
 +	case DIFF_SYMBOL_WORDS:
 +		context = diff_get_color_opt(o, DIFF_CONTEXT);
 +		reset = diff_get_color_opt(o, DIFF_RESET);
 +		/*
 +		 * Skip the prefix character, if any.  With
 +		 * diff_suppress_blank_empty, there may be
 +		 * none.
 +		 */
 +		if (line[0] != '\n') {
 +			line++;
 +			len--;
 +		}
 +		emit_line(o, context, reset, line, len);
 +		break;
 +	case DIFF_SYMBOL_FILEPAIR_PLUS:
 +		meta = diff_get_color_opt(o, DIFF_METAINFO);
 +		reset = diff_get_color_opt(o, DIFF_RESET);
 +		fprintf(o->file, "%s%s+++ %s%s%s\n", diff_line_prefix(o), meta,
 +			line, reset,
 +			strchr(line, ' ') ? "\t" : "");
 +		break;
 +	case DIFF_SYMBOL_FILEPAIR_MINUS:
 +		meta = diff_get_color_opt(o, DIFF_METAINFO);
 +		reset = diff_get_color_opt(o, DIFF_RESET);
 +		fprintf(o->file, "%s%s--- %s%s%s\n", diff_line_prefix(o), meta,
 +			line, reset,
 +			strchr(line, ' ') ? "\t" : "");
 +		break;
 +	case DIFF_SYMBOL_BINARY_FILES:
 +	case DIFF_SYMBOL_HEADER:
 +		fprintf(o->file, "%s", line);
 +		break;
 +	case DIFF_SYMBOL_BINARY_DIFF_HEADER:
 +		fprintf(o->file, "%sGIT binary patch\n", diff_line_prefix(o));
 +		break;
 +	case DIFF_SYMBOL_BINARY_DIFF_HEADER_DELTA:
 +		fprintf(o->file, "%sdelta %s\n", diff_line_prefix(o), line);
 +		break;
 +	case DIFF_SYMBOL_BINARY_DIFF_HEADER_LITERAL:
 +		fprintf(o->file, "%sliteral %s\n", diff_line_prefix(o), line);
 +		break;
 +	case DIFF_SYMBOL_BINARY_DIFF_FOOTER:
 +		fputs(diff_line_prefix(o), o->file);
 +		fputc('\n', o->file);
 +		break;
 +	case DIFF_SYMBOL_REWRITE_DIFF:
 +		fraginfo = diff_get_color(o->use_color, DIFF_FRAGINFO);
 +		reset = diff_get_color_opt(o, DIFF_RESET);
 +		emit_line(o, fraginfo, reset, line, len);
 +		break;
 +	case DIFF_SYMBOL_SUBMODULE_ADD:
 +		set = diff_get_color_opt(o, DIFF_FILE_NEW);
 +		reset = diff_get_color_opt(o, DIFF_RESET);
 +		emit_line(o, set, reset, line, len);
 +		break;
 +	case DIFF_SYMBOL_SUBMODULE_DEL:
 +		set = diff_get_color_opt(o, DIFF_FILE_OLD);
 +		reset = diff_get_color_opt(o, DIFF_RESET);
 +		emit_line(o, set, reset, line, len);
 +		break;
 +	case DIFF_SYMBOL_SUBMODULE_UNTRACKED:
 +		fprintf(o->file, "%sSubmodule %s contains untracked content\n",
 +			diff_line_prefix(o), line);
 +		break;
 +	case DIFF_SYMBOL_SUBMODULE_MODIFIED:
 +		fprintf(o->file, "%sSubmodule %s contains modified content\n",
 +			diff_line_prefix(o), line);
 +		break;
 +	case DIFF_SYMBOL_STATS_SUMMARY_NO_FILES:
 +		emit_line(o, "", "", " 0 files changed\n",
 +			  strlen(" 0 files changed\n"));
 +		break;
 +	case DIFF_SYMBOL_STATS_SUMMARY_ABBREV:
 +		emit_line(o, "", "", " ...\n", strlen(" ...\n"));
 +		break;
 +	case DIFF_SYMBOL_WORD_DIFF:
 +		fprintf(o->file, "%.*s", len, line);
 +		break;
 +	case DIFF_SYMBOL_STAT_SEP:
 +		fputs(o->stat_sep, o->file);
 +		break;
 +	default:
 +		die("BUG: unknown diff symbol");
 +	}
 +	strbuf_release(&sb);
 +}
 +
 +static void emit_diff_symbol(struct diff_options *o, enum diff_symbol s,
 +			     const char *line, int len, unsigned flags)
 +{
 +	struct emitted_diff_symbol e = {line, len, flags, s};
 +
 +	if (o->emitted_symbols)
 +		append_emitted_diff_symbol(o, &e);
 +	else
 +		emit_diff_symbol_from_struct(o, &e);
 +}
 +
 +void diff_emit_submodule_del(struct diff_options *o, const char *line)
 +{
 +	emit_diff_symbol(o, DIFF_SYMBOL_SUBMODULE_DEL, line, strlen(line), 0);
 +}
 +
 +void diff_emit_submodule_add(struct diff_options *o, const char *line)
 +{
 +	emit_diff_symbol(o, DIFF_SYMBOL_SUBMODULE_ADD, line, strlen(line), 0);
 +}
 +
 +void diff_emit_submodule_untracked(struct diff_options *o, const char *path)
 +{
 +	emit_diff_symbol(o, DIFF_SYMBOL_SUBMODULE_UNTRACKED,
 +			 path, strlen(path), 0);
 +}
 +
 +void diff_emit_submodule_modified(struct diff_options *o, const char *path)
 +{
 +	emit_diff_symbol(o, DIFF_SYMBOL_SUBMODULE_MODIFIED,
 +			 path, strlen(path), 0);
 +}
 +
 +void diff_emit_submodule_header(struct diff_options *o, const char *header)
 +{
 +	emit_diff_symbol(o, DIFF_SYMBOL_SUBMODULE_HEADER,
 +			 header, strlen(header), 0);
 +}
 +
 +void diff_emit_submodule_error(struct diff_options *o, const char *err)
 +{
 +	emit_diff_symbol(o, DIFF_SYMBOL_SUBMODULE_ERROR, err, strlen(err), 0);
 +}
 +
 +void diff_emit_submodule_pipethrough(struct diff_options *o,
 +				     const char *line, int len)
 +{
 +	emit_diff_symbol(o, DIFF_SYMBOL_SUBMODULE_PIPETHROUGH, line, len, 0);
 +}
 +
 +static int new_blank_line_at_eof(struct emit_callback *ecbdata, const char *line, int len)
 +{
 +	if (!((ecbdata->ws_rule & WS_BLANK_AT_EOF) &&
 +	      ecbdata->blank_at_eof_in_preimage &&
 +	      ecbdata->blank_at_eof_in_postimage &&
 +	      ecbdata->blank_at_eof_in_preimage <= ecbdata->lno_in_preimage &&
 +	      ecbdata->blank_at_eof_in_postimage <= ecbdata->lno_in_postimage))
 +		return 0;
 +	return ws_blank_line(line, len, ecbdata->ws_rule);
 +}
 +
  static void emit_add_line(const char *reset,
  			  struct emit_callback *ecbdata,
  			  const char *line, int len)
  {
 -	emit_line_checked(reset, ecbdata, line, len,
 -			  DIFF_FILE_NEW, WSEH_NEW, '+');
 +	unsigned flags = WSEH_NEW | ecbdata->ws_rule;
 +	if (new_blank_line_at_eof(ecbdata, line, len))
 +		flags |= DIFF_SYMBOL_CONTENT_BLANK_LINE_EOF;
 +
 +	emit_diff_symbol(ecbdata->opt, DIFF_SYMBOL_PLUS, line, len, flags);
  }
  
  static void emit_del_line(const char *reset,
  			  struct emit_callback *ecbdata,
  			  const char *line, int len)
  {
 -	emit_line_checked(reset, ecbdata, line, len,
 -			  DIFF_FILE_OLD, WSEH_OLD, '-');
 +	unsigned flags = WSEH_OLD | ecbdata->ws_rule;
 +	emit_diff_symbol(ecbdata->opt, DIFF_SYMBOL_MINUS, line, len, flags);
  }
  
  static void emit_context_line(const char *reset,
  			      struct emit_callback *ecbdata,
  			      const char *line, int len)
  {
 -	emit_line_checked(reset, ecbdata, line, len,
 -			  DIFF_CONTEXT, WSEH_CONTEXT, ' ');
 +	unsigned flags = WSEH_CONTEXT | ecbdata->ws_rule;
 +	emit_diff_symbol(ecbdata->opt, DIFF_SYMBOL_CONTEXT, line, len, flags);
  }
  
  static void emit_hunk_header(struct emit_callback *ecbdata,
@@@ -1361,8 -641,7 +1361,8 @@@
  	if (len < 10 ||
  	    memcmp(line, atat, 2) ||
  	    !(ep = memmem(line + 2, len - 2, atat, 2))) {
 -		emit_line(ecbdata->opt, context, reset, line, len);
 +		emit_diff_symbol(ecbdata->opt,
 +				 DIFF_SYMBOL_CONTEXT_MARKER, line, len, 0);
  		return;
  	}
  	ep += 2; /* skip over @@ */
@@@ -1396,9 -675,7 +1396,9 @@@
  	}
  
  	strbuf_add(&msgbuf, line + len, org_len - len);
 -	emit_line(ecbdata->opt, "", "", msgbuf.buf, msgbuf.len);
 +	strbuf_complete_line(&msgbuf);
 +	emit_diff_symbol(ecbdata->opt,
 +			 DIFF_SYMBOL_CONTEXT_FRAGINFO, msgbuf.buf, msgbuf.len, 0);
  	strbuf_release(&msgbuf);
  }
  
@@@ -1414,23 -691,23 +1414,23 @@@ static void remove_tempfile(void
  {
  	int i;
  	for (i = 0; i < ARRAY_SIZE(diff_temp); i++) {
 -		if (is_tempfile_active(&diff_temp[i].tempfile))
 +		if (is_tempfile_active(diff_temp[i].tempfile))
  			delete_tempfile(&diff_temp[i].tempfile);
  		diff_temp[i].name = NULL;
  	}
  }
  
 -static void print_line_count(FILE *file, int count)
 +static void add_line_count(struct strbuf *out, int count)
  {
  	switch (count) {
  	case 0:
 -		fprintf(file, "0,0");
 +		strbuf_addstr(out, "0,0");
  		break;
  	case 1:
 -		fprintf(file, "1");
 +		strbuf_addstr(out, "1");
  		break;
  	default:
 -		fprintf(file, "1,%d", count);
 +		strbuf_addf(out, "1,%d", count);
  		break;
  	}
  }
@@@ -1439,6 -716,7 +1439,6 @@@ static void emit_rewrite_lines(struct e
  			       int prefix, const char *data, int size)
  {
  	const char *endp = NULL;
 -	static const char *nneof = " No newline at end of file\n";
  	const char *reset = diff_get_color(ecb->color_diff, DIFF_RESET);
  
  	while (0 < size) {
@@@ -1456,8 -734,13 +1456,8 @@@
  		size -= len;
  		data += len;
  	}
 -	if (!endp) {
 -		const char *context = diff_get_color(ecb->color_diff,
 -						     DIFF_CONTEXT);
 -		putc('\n', ecb->opt->file);
 -		emit_line_0(ecb->opt, context, reset, '\\',
 -			    nneof, strlen(nneof));
 -	}
 +	if (!endp)
 +		emit_diff_symbol(ecb->opt, DIFF_SYMBOL_NO_LF_EOF, NULL, 0, 0);
  }
  
  static void emit_rewrite_diff(const char *name_a,
@@@ -1469,12 -752,16 +1469,12 @@@
  			      struct diff_options *o)
  {
  	int lc_a, lc_b;
 -	const char *name_a_tab, *name_b_tab;
 -	const char *metainfo = diff_get_color(o->use_color, DIFF_METAINFO);
 -	const char *fraginfo = diff_get_color(o->use_color, DIFF_FRAGINFO);
 -	const char *reset = diff_get_color(o->use_color, DIFF_RESET);
  	static struct strbuf a_name = STRBUF_INIT, b_name = STRBUF_INIT;
  	const char *a_prefix, *b_prefix;
  	char *data_one, *data_two;
  	size_t size_one, size_two;
  	struct emit_callback ecbdata;
 -	const char *line_prefix = diff_line_prefix(o);
 +	struct strbuf out = STRBUF_INIT;
  
  	if (diff_mnemonic_prefix && DIFF_OPT_TST(o, REVERSE_DIFF)) {
  		a_prefix = o->b_prefix;
@@@ -1486,6 -773,8 +1486,6 @@@
  
  	name_a += (*name_a == '/');
  	name_b += (*name_b == '/');
 -	name_a_tab = strchr(name_a, ' ') ? "\t" : "";
 -	name_b_tab = strchr(name_b, ' ') ? "\t" : "";
  
  	strbuf_reset(&a_name);
  	strbuf_reset(&b_name);
@@@ -1512,23 -801,18 +1512,23 @@@
  
  	lc_a = count_lines(data_one, size_one);
  	lc_b = count_lines(data_two, size_two);
 -	fprintf(o->file,
 -		"%s%s--- %s%s%s\n%s%s+++ %s%s%s\n%s%s@@ -",
 -		line_prefix, metainfo, a_name.buf, name_a_tab, reset,
 -		line_prefix, metainfo, b_name.buf, name_b_tab, reset,
 -		line_prefix, fraginfo);
 +
 +	emit_diff_symbol(o, DIFF_SYMBOL_FILEPAIR_MINUS,
 +			 a_name.buf, a_name.len, 0);
 +	emit_diff_symbol(o, DIFF_SYMBOL_FILEPAIR_PLUS,
 +			 b_name.buf, b_name.len, 0);
 +
 +	strbuf_addstr(&out, "@@ -");
  	if (!o->irreversible_delete)
 -		print_line_count(o->file, lc_a);
 +		add_line_count(&out, lc_a);
  	else
 -		fprintf(o->file, "?,?");
 -	fprintf(o->file, " +");
 -	print_line_count(o->file, lc_b);
 -	fprintf(o->file, " @@%s\n", reset);
 +		strbuf_addstr(&out, "?,?");
 +	strbuf_addstr(&out, " +");
 +	add_line_count(&out, lc_b);
 +	strbuf_addstr(&out, " @@\n");
 +	emit_diff_symbol(o, DIFF_SYMBOL_REWRITE_DIFF, out.buf, out.len, 0);
 +	strbuf_release(&out);
 +
  	if (lc_a && !o->irreversible_delete)
  		emit_rewrite_lines(&ecbdata, '-', data_one, size_one);
  	if (lc_b)
@@@ -1541,7 -825,7 +1541,7 @@@
  
  struct diff_words_buffer {
  	mmfile_t text;
- 	long alloc;
+ 	unsigned long alloc;
  	struct diff_words_orig {
  		const char *begin, *end;
  	} *orig;
@@@ -1588,49 -872,37 +1588,49 @@@ struct diff_words_data 
  	struct diff_words_style *style;
  };
  
 -static int fn_out_diff_words_write_helper(FILE *fp,
 +static int fn_out_diff_words_write_helper(struct diff_options *o,
  					  struct diff_words_style_elem *st_el,
  					  const char *newline,
 -					  size_t count, const char *buf,
 -					  const char *line_prefix)
 +					  size_t count, const char *buf)
  {
  	int print = 0;
 +	struct strbuf sb = STRBUF_INIT;
  
  	while (count) {
  		char *p = memchr(buf, '\n', count);
  		if (print)
 -			fputs(line_prefix, fp);
 +			strbuf_addstr(&sb, diff_line_prefix(o));
 +
  		if (p != buf) {
 -			if (st_el->color && fputs(st_el->color, fp) < 0)
 -				return -1;
 -			if (fputs(st_el->prefix, fp) < 0 ||
 -			    fwrite(buf, p ? p - buf : count, 1, fp) != 1 ||
 -			    fputs(st_el->suffix, fp) < 0)
 -				return -1;
 -			if (st_el->color && *st_el->color
 -			    && fputs(GIT_COLOR_RESET, fp) < 0)
 -				return -1;
 +			const char *reset = st_el->color && *st_el->color ?
 +					    GIT_COLOR_RESET : NULL;
 +			if (st_el->color && *st_el->color)
 +				strbuf_addstr(&sb, st_el->color);
 +			strbuf_addstr(&sb, st_el->prefix);
 +			strbuf_add(&sb, buf, p ? p - buf : count);
 +			strbuf_addstr(&sb, st_el->suffix);
 +			if (reset)
 +				strbuf_addstr(&sb, reset);
  		}
  		if (!p)
 -			return 0;
 -		if (fputs(newline, fp) < 0)
 -			return -1;
 +			goto out;
 +
 +		strbuf_addstr(&sb, newline);
  		count -= p + 1 - buf;
  		buf = p + 1;
  		print = 1;
 +		if (count) {
 +			emit_diff_symbol(o, DIFF_SYMBOL_WORD_DIFF,
 +					 sb.buf, sb.len, 0);
 +			strbuf_reset(&sb);
 +		}
  	}
 +
 +out:
 +	if (sb.len)
 +		emit_diff_symbol(o, DIFF_SYMBOL_WORD_DIFF,
 +				 sb.buf, sb.len, 0);
 +	strbuf_release(&sb);
  	return 0;
  }
  
@@@ -1712,20 -984,24 +1712,20 @@@ static void fn_out_diff_words_aux(void 
  		fputs(line_prefix, diff_words->opt->file);
  	}
  	if (diff_words->current_plus != plus_begin) {
 -		fn_out_diff_words_write_helper(diff_words->opt->file,
 +		fn_out_diff_words_write_helper(diff_words->opt,
  				&style->ctx, style->newline,
  				plus_begin - diff_words->current_plus,
 -				diff_words->current_plus, line_prefix);
 -		if (*(plus_begin - 1) == '\n')
 -			fputs(line_prefix, diff_words->opt->file);
 +				diff_words->current_plus);
  	}
  	if (minus_begin != minus_end) {
 -		fn_out_diff_words_write_helper(diff_words->opt->file,
 +		fn_out_diff_words_write_helper(diff_words->opt,
  				&style->old, style->newline,
 -				minus_end - minus_begin, minus_begin,
 -				line_prefix);
 +				minus_end - minus_begin, minus_begin);
  	}
  	if (plus_begin != plus_end) {
 -		fn_out_diff_words_write_helper(diff_words->opt->file,
 +		fn_out_diff_words_write_helper(diff_words->opt,
  				&style->new, style->newline,
 -				plus_end - plus_begin, plus_begin,
 -				line_prefix);
 +				plus_end - plus_begin, plus_begin);
  	}
  
  	diff_words->current_plus = plus_end;
@@@ -1819,12 -1095,11 +1819,12 @@@ static void diff_words_show(struct diff
  
  	/* special case: only removal */
  	if (!diff_words->plus.text.size) {
 -		fputs(line_prefix, diff_words->opt->file);
 -		fn_out_diff_words_write_helper(diff_words->opt->file,
 +		emit_diff_symbol(diff_words->opt, DIFF_SYMBOL_WORD_DIFF,
 +				 line_prefix, strlen(line_prefix), 0);
 +		fn_out_diff_words_write_helper(diff_words->opt,
  			&style->old, style->newline,
  			diff_words->minus.text.size,
 -			diff_words->minus.text.ptr, line_prefix);
 +			diff_words->minus.text.ptr);
  		diff_words->minus.text.size = 0;
  		return;
  	}
@@@ -1847,12 -1122,12 +1847,12 @@@
  	if (diff_words->current_plus != diff_words->plus.text.ptr +
  			diff_words->plus.text.size) {
  		if (color_words_output_graph_prefix(diff_words))
 -			fputs(line_prefix, diff_words->opt->file);
 -		fn_out_diff_words_write_helper(diff_words->opt->file,
 +			emit_diff_symbol(diff_words->opt, DIFF_SYMBOL_WORD_DIFF,
 +					 line_prefix, strlen(line_prefix), 0);
 +		fn_out_diff_words_write_helper(diff_words->opt,
  			&style->ctx, style->newline,
  			diff_words->plus.text.ptr + diff_words->plus.text.size
 -			- diff_words->current_plus, diff_words->current_plus,
 -			line_prefix);
 +			- diff_words->current_plus, diff_words->current_plus);
  	}
  	diff_words->minus.text.size = diff_words->plus.text.size = 0;
  }
@@@ -1860,29 -1135,9 +1860,29 @@@
  /* In "color-words" mode, show word-diff of words accumulated in the buffer */
  static void diff_words_flush(struct emit_callback *ecbdata)
  {
 +	struct diff_options *wo = ecbdata->diff_words->opt;
 +
  	if (ecbdata->diff_words->minus.text.size ||
  	    ecbdata->diff_words->plus.text.size)
  		diff_words_show(ecbdata->diff_words);
 +
 +	if (wo->emitted_symbols) {
 +		struct diff_options *o = ecbdata->opt;
 +		struct emitted_diff_symbols *wol = wo->emitted_symbols;
 +		int i;
 +
 +		/*
 +		 * NEEDSWORK:
 +		 * Instead of appending each, concat all words to a line?
 +		 */
 +		for (i = 0; i < wol->nr; i++)
 +			append_emitted_diff_symbol(o, &wol->buf[i]);
 +
 +		for (i = 0; i < wol->nr; i++)
 +			free((void *)wol->buf[i].line);
 +
 +		wol->nr = 0;
 +	}
  }
  
  static void diff_filespec_load_driver(struct diff_filespec *one)
@@@ -1918,11 -1173,6 +1918,11 @@@ static void init_diff_words_data(struc
  		xcalloc(1, sizeof(struct diff_words_data));
  	ecbdata->diff_words->type = o->word_diff;
  	ecbdata->diff_words->opt = o;
 +
 +	if (orig_opts->emitted_symbols)
 +		o->emitted_symbols =
 +			xcalloc(1, sizeof(struct emitted_diff_symbols));
 +
  	if (!o->word_regex)
  		o->word_regex = userdiff_word_regex(one);
  	if (!o->word_regex)
@@@ -1957,7 -1207,6 +1957,7 @@@ static void free_diff_words_data(struc
  {
  	if (ecbdata->diff_words) {
  		diff_words_flush(ecbdata);
 +		free (ecbdata->diff_words->opt->emitted_symbols);
  		free (ecbdata->diff_words->opt);
  		free (ecbdata->diff_words->minus.text.ptr);
  		free (ecbdata->diff_words->minus.orig);
@@@ -1994,6 -1243,8 +1994,6 @@@ static unsigned long sane_truncate_line
  	unsigned long allot;
  	size_t l = len;
  
 -	if (ecb->truncate)
 -		return ecb->truncate(line, len);
  	cp = line;
  	allot = l;
  	while (0 < l) {
@@@ -2022,25 -1273,30 +2022,25 @@@ static void find_lno(const char *line, 
  static void fn_out_consume(void *priv, char *line, unsigned long len)
  {
  	struct emit_callback *ecbdata = priv;
 -	const char *meta = diff_get_color(ecbdata->color_diff, DIFF_METAINFO);
 -	const char *context = diff_get_color(ecbdata->color_diff, DIFF_CONTEXT);
  	const char *reset = diff_get_color(ecbdata->color_diff, DIFF_RESET);
  	struct diff_options *o = ecbdata->opt;
 -	const char *line_prefix = diff_line_prefix(o);
  
  	o->found_changes = 1;
  
  	if (ecbdata->header) {
 -		fprintf(o->file, "%s", ecbdata->header->buf);
 +		emit_diff_symbol(o, DIFF_SYMBOL_HEADER,
 +				 ecbdata->header->buf, ecbdata->header->len, 0);
  		strbuf_reset(ecbdata->header);
  		ecbdata->header = NULL;
  	}
  
  	if (ecbdata->label_path[0]) {
 -		const char *name_a_tab, *name_b_tab;
 -
 -		name_a_tab = strchr(ecbdata->label_path[0], ' ') ? "\t" : "";
 -		name_b_tab = strchr(ecbdata->label_path[1], ' ') ? "\t" : "";
 -
 -		fprintf(o->file, "%s%s--- %s%s%s\n",
 -			line_prefix, meta, ecbdata->label_path[0], reset, name_a_tab);
 -		fprintf(o->file, "%s%s+++ %s%s%s\n",
 -			line_prefix, meta, ecbdata->label_path[1], reset, name_b_tab);
 +		emit_diff_symbol(o, DIFF_SYMBOL_FILEPAIR_MINUS,
 +				 ecbdata->label_path[0],
 +				 strlen(ecbdata->label_path[0]), 0);
 +		emit_diff_symbol(o, DIFF_SYMBOL_FILEPAIR_PLUS,
 +				 ecbdata->label_path[1],
 +				 strlen(ecbdata->label_path[1]), 0);
  		ecbdata->label_path[0] = ecbdata->label_path[1] = NULL;
  	}
  
@@@ -2056,13 -1312,12 +2056,13 @@@
  		len = sane_truncate_line(ecbdata, line, len);
  		find_lno(line, ecbdata);
  		emit_hunk_header(ecbdata, line, len);
 -		if (line[len-1] != '\n')
 -			putc('\n', o->file);
  		return;
  	}
  
  	if (ecbdata->diff_words) {
 +		enum diff_symbol s =
 +			ecbdata->diff_words->type == DIFF_WORDS_PORCELAIN ?
 +			DIFF_SYMBOL_WORDS_PORCELAIN : DIFF_SYMBOL_WORDS;
  		if (line[0] == '-') {
  			diff_words_append(line, len,
  					  &ecbdata->diff_words->minus);
@@@ -2082,7 -1337,21 +2082,7 @@@
  			return;
  		}
  		diff_words_flush(ecbdata);
 -		if (ecbdata->diff_words->type == DIFF_WORDS_PORCELAIN) {
 -			emit_line(o, context, reset, line, len);
 -			fputs("~\n", o->file);
 -		} else {
 -			/*
 -			 * Skip the prefix character, if any.  With
 -			 * diff_suppress_blank_empty, there may be
 -			 * none.
 -			 */
 -			if (line[0] != '\n') {
 -			      line++;
 -			      len--;
 -			}
 -			emit_line(o, context, reset, line, len);
 -		}
 +		emit_diff_symbol(o, s, line, len, 0);
  		return;
  	}
  
@@@ -2103,8 -1372,8 +2103,8 @@@
  	default:
  		/* incomplete line at the end */
  		ecbdata->lno_in_preimage++;
 -		emit_line(o, diff_get_color(ecbdata->color_diff, DIFF_CONTEXT),
 -			  reset, line, len);
 +		emit_diff_symbol(o, DIFF_SYMBOL_CONTEXT_INCOMPLETE,
 +				 line, len, 0);
  		break;
  	}
  }
@@@ -2249,14 -1518,20 +2249,14 @@@ static int scale_linear(int it, int wid
  	return 1 + (it * (width - 1) / max_change);
  }
  
 -static void show_name(FILE *file,
 -		      const char *prefix, const char *name, int len)
 -{
 -	fprintf(file, " %s%-*s |", prefix, len, name);
 -}
 -
 -static void show_graph(FILE *file, char ch, int cnt, const char *set, const char *reset)
 +static void show_graph(struct strbuf *out, char ch, int cnt,
 +		       const char *set, const char *reset)
  {
  	if (cnt <= 0)
  		return;
 -	fprintf(file, "%s", set);
 -	while (cnt--)
 -		putc(ch, file);
 -	fprintf(file, "%s", reset);
 +	strbuf_addstr(out, set);
 +	strbuf_addchars(out, ch, cnt);
 +	strbuf_addstr(out, reset);
  }
  
  static void fill_print_name(struct diffstat_file *file)
@@@ -2280,16 -1555,14 +2280,16 @@@
  	file->print_name = pname;
  }
  
 -int print_stat_summary(FILE *fp, int files, int insertions, int deletions)
 +static void print_stat_summary_inserts_deletes(struct diff_options *options,
 +		int files, int insertions, int deletions)
  {
  	struct strbuf sb = STRBUF_INIT;
 -	int ret;
  
  	if (!files) {
  		assert(insertions == 0 && deletions == 0);
 -		return fprintf(fp, "%s\n", " 0 files changed");
 +		emit_diff_symbol(options, DIFF_SYMBOL_STATS_SUMMARY_NO_FILES,
 +				 NULL, 0, 0);
 +		return;
  	}
  
  	strbuf_addf(&sb,
@@@ -2316,19 -1589,9 +2316,19 @@@
  			    deletions);
  	}
  	strbuf_addch(&sb, '\n');
 -	ret = fputs(sb.buf, fp);
 +	emit_diff_symbol(options, DIFF_SYMBOL_STATS_SUMMARY_INSERTS_DELETES,
 +			 sb.buf, sb.len, 0);
  	strbuf_release(&sb);
 -	return ret;
 +}
 +
 +void print_stat_summary(FILE *fp, int files,
 +			int insertions, int deletions)
 +{
 +	struct diff_options o;
 +	memset(&o, 0, sizeof(o));
 +	o.file = fp;
 +
 +	print_stat_summary_inserts_deletes(&o, files, insertions, deletions);
  }
  
  static void show_stats(struct diffstat_t *data, struct diff_options *options)
@@@ -2338,13 -1601,13 +2338,13 @@@
  	int total_files = data->nr, count;
  	int width, name_width, graph_width, number_width = 0, bin_width = 0;
  	const char *reset, *add_c, *del_c;
 -	const char *line_prefix = "";
  	int extra_shown = 0;
 +	const char *line_prefix = diff_line_prefix(options);
 +	struct strbuf out = STRBUF_INIT;
  
  	if (data->nr == 0)
  		return;
  
 -	line_prefix = diff_line_prefix(options);
  	count = options->stat_count ? options->stat_count : data->nr;
  
  	reset = diff_get_color_opt(options, DIFF_RESET);
@@@ -2498,32 -1761,26 +2498,32 @@@
  		}
  
  		if (file->is_binary) {
 -			fprintf(options->file, "%s", line_prefix);
 -			show_name(options->file, prefix, name, len);
 -			fprintf(options->file, " %*s", number_width, "Bin");
 +			strbuf_addf(&out, " %s%-*s |", prefix, len, name);
 +			strbuf_addf(&out, " %*s", number_width, "Bin");
  			if (!added && !deleted) {
 -				putc('\n', options->file);
 +				strbuf_addch(&out, '\n');
 +				emit_diff_symbol(options, DIFF_SYMBOL_STATS_LINE,
 +						 out.buf, out.len, 0);
 +				strbuf_reset(&out);
  				continue;
  			}
 -			fprintf(options->file, " %s%"PRIuMAX"%s",
 +			strbuf_addf(&out, " %s%"PRIuMAX"%s",
  				del_c, deleted, reset);
 -			fprintf(options->file, " -> ");
 -			fprintf(options->file, "%s%"PRIuMAX"%s",
 +			strbuf_addstr(&out, " -> ");
 +			strbuf_addf(&out, "%s%"PRIuMAX"%s",
  				add_c, added, reset);
 -			fprintf(options->file, " bytes");
 -			fprintf(options->file, "\n");
 +			strbuf_addstr(&out, " bytes\n");
 +			emit_diff_symbol(options, DIFF_SYMBOL_STATS_LINE,
 +					 out.buf, out.len, 0);
 +			strbuf_reset(&out);
  			continue;
  		}
  		else if (file->is_unmerged) {
 -			fprintf(options->file, "%s", line_prefix);
 -			show_name(options->file, prefix, name, len);
 -			fprintf(options->file, " Unmerged\n");
 +			strbuf_addf(&out, " %s%-*s |", prefix, len, name);
 +			strbuf_addstr(&out, " Unmerged\n");
 +			emit_diff_symbol(options, DIFF_SYMBOL_STATS_LINE,
 +					 out.buf, out.len, 0);
 +			strbuf_reset(&out);
  			continue;
  		}
  
@@@ -2546,16 -1803,14 +2546,16 @@@
  				add = total - del;
  			}
  		}
 -		fprintf(options->file, "%s", line_prefix);
 -		show_name(options->file, prefix, name, len);
 -		fprintf(options->file, " %*"PRIuMAX"%s",
 +		strbuf_addf(&out, " %s%-*s |", prefix, len, name);
 +		strbuf_addf(&out, " %*"PRIuMAX"%s",
  			number_width, added + deleted,
  			added + deleted ? " " : "");
 -		show_graph(options->file, '+', add, add_c, reset);
 -		show_graph(options->file, '-', del, del_c, reset);
 -		fprintf(options->file, "\n");
 +		show_graph(&out, '+', add, add_c, reset);
 +		show_graph(&out, '-', del, del_c, reset);
 +		strbuf_addch(&out, '\n');
 +		emit_diff_symbol(options, DIFF_SYMBOL_STATS_LINE,
 +				 out.buf, out.len, 0);
 +		strbuf_reset(&out);
  	}
  
  	for (i = 0; i < data->nr; i++) {
@@@ -2576,14 -1831,11 +2576,14 @@@
  		if (i < count)
  			continue;
  		if (!extra_shown)
 -			fprintf(options->file, "%s ...\n", line_prefix);
 +			emit_diff_symbol(options,
 +					 DIFF_SYMBOL_STATS_SUMMARY_ABBREV,
 +					 NULL, 0, 0);
  		extra_shown = 1;
  	}
 -	fprintf(options->file, "%s", line_prefix);
 -	print_stat_summary(options->file, total_files, adds, dels);
 +
 +	print_stat_summary_inserts_deletes(options, total_files, adds, dels);
 +	strbuf_release(&out);
  }
  
  static void show_shortstats(struct diffstat_t *data, struct diff_options *options)
@@@ -2595,7 -1847,7 +2595,7 @@@
  
  	for (i = 0; i < data->nr; i++) {
  		int added = data->files[i]->added;
 -		int deleted= data->files[i]->deleted;
 +		int deleted = data->files[i]->deleted;
  
  		if (data->files[i]->is_unmerged ||
  		    (!data->files[i]->is_interesting && (added + deleted == 0))) {
@@@ -2605,7 -1857,8 +2605,7 @@@
  			dels += deleted;
  		}
  	}
 -	fprintf(options->file, "%s", diff_line_prefix(options));
 -	print_stat_summary(options->file, total_files, adds, dels);
 +	print_stat_summary_inserts_deletes(options, total_files, adds, dels);
  }
  
  static void show_numstat(struct diffstat_t *data, struct diff_options *options)
@@@ -2969,8 -2222,8 +2969,8 @@@ static unsigned char *deflate_it(char *
  	return deflated;
  }
  
 -static void emit_binary_diff_body(FILE *file, mmfile_t *one, mmfile_t *two,
 -				  const char *prefix)
 +static void emit_binary_diff_body(struct diff_options *o,
 +				  mmfile_t *one, mmfile_t *two)
  {
  	void *cp;
  	void *delta;
@@@ -2999,18 -2252,13 +2999,18 @@@
  	}
  
  	if (delta && delta_size < deflate_size) {
 -		fprintf(file, "%sdelta %lu\n", prefix, orig_size);
 +		char *s = xstrfmt("%lu", orig_size);
 +		emit_diff_symbol(o, DIFF_SYMBOL_BINARY_DIFF_HEADER_DELTA,
 +				 s, strlen(s), 0);
 +		free(s);
  		free(deflated);
  		data = delta;
  		data_size = delta_size;
 -	}
 -	else {
 -		fprintf(file, "%sliteral %lu\n", prefix, two->size);
 +	} else {
 +		char *s = xstrfmt("%lu", two->size);
 +		emit_diff_symbol(o, DIFF_SYMBOL_BINARY_DIFF_HEADER_LITERAL,
 +				 s, strlen(s), 0);
 +		free(s);
  		free(delta);
  		data = deflated;
  		data_size = deflate_size;
@@@ -3019,9 -2267,8 +3019,9 @@@
  	/* emit data encoded in base85 */
  	cp = data;
  	while (data_size) {
 +		int len;
  		int bytes = (52 < data_size) ? 52 : data_size;
 -		char line[70];
 +		char line[71];
  		data_size -= bytes;
  		if (bytes <= 26)
  			line[0] = bytes + 'A' - 1;
@@@ -3029,24 -2276,20 +3029,24 @@@
  			line[0] = bytes - 26 + 'a' - 1;
  		encode_85(line + 1, cp, bytes);
  		cp = (char *) cp + bytes;
 -		fprintf(file, "%s", prefix);
 -		fputs(line, file);
 -		fputc('\n', file);
 +
 +		len = strlen(line);
 +		line[len++] = '\n';
 +		line[len] = '\0';
 +
 +		emit_diff_symbol(o, DIFF_SYMBOL_BINARY_DIFF_BODY,
 +				 line, len, 0);
  	}
 -	fprintf(file, "%s\n", prefix);
 +	emit_diff_symbol(o, DIFF_SYMBOL_BINARY_DIFF_FOOTER, NULL, 0, 0);
  	free(data);
  }
  
 -static void emit_binary_diff(FILE *file, mmfile_t *one, mmfile_t *two,
 -			     const char *prefix)
 +static void emit_binary_diff(struct diff_options *o,
 +			     mmfile_t *one, mmfile_t *two)
  {
 -	fprintf(file, "%sGIT binary patch\n", prefix);
 -	emit_binary_diff_body(file, one, two, prefix);
 -	emit_binary_diff_body(file, two, one, prefix);
 +	emit_diff_symbol(o, DIFF_SYMBOL_BINARY_DIFF_HEADER, NULL, 0, 0);
 +	emit_binary_diff_body(o, one, two);
 +	emit_binary_diff_body(o, two, one);
  }
  
  int diff_filespec_is_binary(struct diff_filespec *one)
@@@ -3123,16 -2366,24 +3123,16 @@@ static void builtin_diff(const char *na
  	if (o->submodule_format == DIFF_SUBMODULE_LOG &&
  	    (!one->mode || S_ISGITLINK(one->mode)) &&
  	    (!two->mode || S_ISGITLINK(two->mode))) {
 -		const char *del = diff_get_color_opt(o, DIFF_FILE_OLD);
 -		const char *add = diff_get_color_opt(o, DIFF_FILE_NEW);
 -		show_submodule_summary(o->file, one->path ? one->path : two->path,
 -				line_prefix,
 +		show_submodule_summary(o, one->path ? one->path : two->path,
  				&one->oid, &two->oid,
 -				two->dirty_submodule,
 -				meta, del, add, reset);
 +				two->dirty_submodule);
  		return;
  	} else if (o->submodule_format == DIFF_SUBMODULE_INLINE_DIFF &&
  		   (!one->mode || S_ISGITLINK(one->mode)) &&
  		   (!two->mode || S_ISGITLINK(two->mode))) {
 -		const char *del = diff_get_color_opt(o, DIFF_FILE_OLD);
 -		const char *add = diff_get_color_opt(o, DIFF_FILE_NEW);
 -		show_submodule_inline_diff(o->file, one->path ? one->path : two->path,
 -				line_prefix,
 +		show_submodule_inline_diff(o, one->path ? one->path : two->path,
  				&one->oid, &two->oid,
 -				two->dirty_submodule,
 -				meta, del, add, reset, o);
 +				two->dirty_submodule);
  		return;
  	}
  
@@@ -3181,8 -2432,7 +3181,8 @@@
  		if (complete_rewrite &&
  		    (textconv_one || !diff_filespec_is_binary(one)) &&
  		    (textconv_two || !diff_filespec_is_binary(two))) {
 -			fprintf(o->file, "%s", header.buf);
 +			emit_diff_symbol(o, DIFF_SYMBOL_HEADER,
 +					 header.buf, header.len, 0);
  			strbuf_reset(&header);
  			emit_rewrite_diff(name_a, name_b, one, two,
  						textconv_one, textconv_two, o);
@@@ -3192,31 -2442,23 +3192,31 @@@
  	}
  
  	if (o->irreversible_delete && lbl[1][0] == '/') {
 -		fprintf(o->file, "%s", header.buf);
 +		emit_diff_symbol(o, DIFF_SYMBOL_HEADER, header.buf,
 +				 header.len, 0);
  		strbuf_reset(&header);
  		goto free_ab_and_return;
  	} else if (!DIFF_OPT_TST(o, TEXT) &&
  	    ( (!textconv_one && diff_filespec_is_binary(one)) ||
  	      (!textconv_two && diff_filespec_is_binary(two)) )) {
 +		struct strbuf sb = STRBUF_INIT;
  		if (!one->data && !two->data &&
  		    S_ISREG(one->mode) && S_ISREG(two->mode) &&
  		    !DIFF_OPT_TST(o, BINARY)) {
  			if (!oidcmp(&one->oid, &two->oid)) {
  				if (must_show_header)
 -					fprintf(o->file, "%s", header.buf);
 +					emit_diff_symbol(o, DIFF_SYMBOL_HEADER,
 +							 header.buf, header.len,
 +							 0);
  				goto free_ab_and_return;
  			}
 -			fprintf(o->file, "%s", header.buf);
 -			fprintf(o->file, "%sBinary files %s and %s differ\n",
 -				line_prefix, lbl[0], lbl[1]);
 +			emit_diff_symbol(o, DIFF_SYMBOL_HEADER,
 +					 header.buf, header.len, 0);
 +			strbuf_addf(&sb, "%sBinary files %s and %s differ\n",
 +				    diff_line_prefix(o), lbl[0], lbl[1]);
 +			emit_diff_symbol(o, DIFF_SYMBOL_BINARY_FILES,
 +					 sb.buf, sb.len, 0);
 +			strbuf_release(&sb);
  			goto free_ab_and_return;
  		}
  		if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
@@@ -3225,21 -2467,16 +3225,21 @@@
  		if (mf1.size == mf2.size &&
  		    !memcmp(mf1.ptr, mf2.ptr, mf1.size)) {
  			if (must_show_header)
 -				fprintf(o->file, "%s", header.buf);
 +				emit_diff_symbol(o, DIFF_SYMBOL_HEADER,
 +						 header.buf, header.len, 0);
  			goto free_ab_and_return;
  		}
 -		fprintf(o->file, "%s", header.buf);
 +		emit_diff_symbol(o, DIFF_SYMBOL_HEADER, header.buf, header.len, 0);
  		strbuf_reset(&header);
  		if (DIFF_OPT_TST(o, BINARY))
 -			emit_binary_diff(o->file, &mf1, &mf2, line_prefix);
 -		else
 -			fprintf(o->file, "%sBinary files %s and %s differ\n",
 -				line_prefix, lbl[0], lbl[1]);
 +			emit_binary_diff(o, &mf1, &mf2);
 +		else {
 +			strbuf_addf(&sb, "%sBinary files %s and %s differ\n",
 +				    diff_line_prefix(o), lbl[0], lbl[1]);
 +			emit_diff_symbol(o, DIFF_SYMBOL_BINARY_FILES,
 +					 sb.buf, sb.len, 0);
 +			strbuf_release(&sb);
 +		}
  		o->found_changes = 1;
  	} else {
  		/* Crazy xdl interfaces.. */
@@@ -3251,8 -2488,7 +3251,8 @@@
  		const struct userdiff_funcname *pe;
  
  		if (must_show_header) {
 -			fprintf(o->file, "%s", header.buf);
 +			emit_diff_symbol(o, DIFF_SYMBOL_HEADER,
 +					 header.buf, header.len, 0);
  			strbuf_reset(&header);
  		}
  
@@@ -3721,6 -2957,7 +3721,6 @@@ static void prep_temp_blob(const char *
  			   const struct object_id *oid,
  			   int mode)
  {
 -	int fd;
  	struct strbuf buf = STRBUF_INIT;
  	struct strbuf template = STRBUF_INIT;
  	char *path_dup = xstrdup(path);
@@@ -3730,18 -2967,18 +3730,18 @@@
  	strbuf_addstr(&template, "XXXXXX_");
  	strbuf_addstr(&template, base);
  
 -	fd = mks_tempfile_ts(&temp->tempfile, template.buf, strlen(base) + 1);
 -	if (fd < 0)
 +	temp->tempfile = mks_tempfile_ts(template.buf, strlen(base) + 1);
 +	if (!temp->tempfile)
  		die_errno("unable to create temp-file");
  	if (convert_to_working_tree(path,
  			(const char *)blob, (size_t)size, &buf)) {
  		blob = buf.buf;
  		size = buf.len;
  	}
 -	if (write_in_full(fd, blob, size) != size)
 +	if (write_in_full(temp->tempfile->fd, blob, size) < 0 ||
 +	    close_tempfile_gently(temp->tempfile))
  		die_errno("unable to write temp-file");
 -	close_tempfile(&temp->tempfile);
 -	temp->name = get_tempfile_path(&temp->tempfile);
 +	temp->name = get_tempfile_path(temp->tempfile);
  	oid_to_hex_r(temp->hex, oid);
  	xsnprintf(temp->mode, sizeof(temp->mode), "%06o", mode);
  	strbuf_release(&buf);
@@@ -4009,7 -3246,7 +4009,7 @@@ static void diff_fill_oid_info(struct d
  			}
  			if (lstat(one->path, &st) < 0)
  				die_errno("stat '%s'", one->path);
 -			if (index_path(one->oid.hash, one->path, &st, 0))
 +			if (index_path(&one->oid, one->path, &st, 0))
  				die("cannot hash %s", one->path);
  		}
  	}
@@@ -4042,8 -3279,8 +4042,8 @@@ static void run_diff(struct diff_filepa
  	const char *other;
  	const char *attr_path;
  
 -	name  = p->one->path;
 -	other = (strcmp(name, p->two->path) ? p->two->path : NULL);
 +	name  = one->path;
 +	other = (strcmp(name, two->path) ? two->path : NULL);
  	attr_path = name;
  	if (o->prefix_length)
  		strip_prefix(o->prefix_length, &name, &other);
@@@ -4166,8 -3403,6 +4166,8 @@@ void diff_setup(struct diff_options *op
  		options->a_prefix = "a/";
  		options->b_prefix = "b/";
  	}
 +
 +	options->color_moved = diff_color_moved_default;
  }
  
  void diff_setup_done(struct diff_options *options)
@@@ -4277,9 -3512,6 +4277,9 @@@
  
  	if (DIFF_OPT_TST(options, FOLLOW_RENAMES) && options->pathspec.nr != 1)
  		die(_("--follow requires exactly one pathspec"));
 +
 +	if (!options->use_color || external_diff())
 +		options->color_moved = 0;
  }
  
  static int opt_arg(const char *arg, int arg_short, const char *arg_long, int *val)
@@@ -4704,19 -3936,7 +4704,19 @@@ int diff_opt_parse(struct diff_options 
  	}
  	else if (!strcmp(arg, "--no-color"))
  		options->use_color = 0;
 -	else if (!strcmp(arg, "--color-words")) {
 +	else if (!strcmp(arg, "--color-moved")) {
 +		if (diff_color_moved_default)
 +			options->color_moved = diff_color_moved_default;
 +		if (options->color_moved == COLOR_MOVED_NO)
 +			options->color_moved = COLOR_MOVED_DEFAULT;
 +	} else if (!strcmp(arg, "--no-color-moved"))
 +		options->color_moved = COLOR_MOVED_NO;
 +	else if (skip_prefix(arg, "--color-moved=", &arg)) {
 +		int cm = parse_color_moved(arg);
 +		if (cm < 0)
 +			die("bad --color-moved argument: %s", arg);
 +		options->color_moved = cm;
 +	} else if (!strcmp(arg, "--color-words")) {
  		options->use_color = 1;
  		options->word_diff = DIFF_WORDS_COLOR;
  	}
@@@ -5246,78 -4466,67 +5246,78 @@@ static void flush_one_pair(struct diff_
  	}
  }
  
 -static void show_file_mode_name(FILE *file, const char *newdelete, struct diff_filespec *fs)
 +static void show_file_mode_name(struct diff_options *opt, const char *newdelete, struct diff_filespec *fs)
  {
 +	struct strbuf sb = STRBUF_INIT;
  	if (fs->mode)
 -		fprintf(file, " %s mode %06o ", newdelete, fs->mode);
 +		strbuf_addf(&sb, " %s mode %06o ", newdelete, fs->mode);
  	else
 -		fprintf(file, " %s ", newdelete);
 -	write_name_quoted(fs->path, file, '\n');
 -}
 +		strbuf_addf(&sb, " %s ", newdelete);
  
 +	quote_c_style(fs->path, &sb, NULL, 0);
 +	strbuf_addch(&sb, '\n');
 +	emit_diff_symbol(opt, DIFF_SYMBOL_SUMMARY,
 +			 sb.buf, sb.len, 0);
 +	strbuf_release(&sb);
 +}
  
 -static void show_mode_change(FILE *file, struct diff_filepair *p, int show_name,
 -		const char *line_prefix)
 +static void show_mode_change(struct diff_options *opt, struct diff_filepair *p,
 +		int show_name)
  {
  	if (p->one->mode && p->two->mode && p->one->mode != p->two->mode) {
 -		fprintf(file, "%s mode change %06o => %06o%c", line_prefix, p->one->mode,
 -			p->two->mode, show_name ? ' ' : '\n');
 +		struct strbuf sb = STRBUF_INIT;
 +		strbuf_addf(&sb, " mode change %06o => %06o",
 +			    p->one->mode, p->two->mode);
  		if (show_name) {
 -			write_name_quoted(p->two->path, file, '\n');
 +			strbuf_addch(&sb, ' ');
 +			quote_c_style(p->two->path, &sb, NULL, 0);
  		}
 +		emit_diff_symbol(opt, DIFF_SYMBOL_SUMMARY,
 +				 sb.buf, sb.len, 0);
 +		strbuf_release(&sb);
  	}
  }
  
 -static void show_rename_copy(FILE *file, const char *renamecopy, struct diff_filepair *p,
 -			const char *line_prefix)
 +static void show_rename_copy(struct diff_options *opt, const char *renamecopy,
 +		struct diff_filepair *p)
  {
 +	struct strbuf sb = STRBUF_INIT;
  	char *names = pprint_rename(p->one->path, p->two->path);
 -
 -	fprintf(file, " %s %s (%d%%)\n", renamecopy, names, similarity_index(p));
 +	strbuf_addf(&sb, " %s %s (%d%%)\n",
 +			renamecopy, names, similarity_index(p));
  	free(names);
 -	show_mode_change(file, p, 0, line_prefix);
 +	emit_diff_symbol(opt, DIFF_SYMBOL_SUMMARY,
 +				 sb.buf, sb.len, 0);
 +	show_mode_change(opt, p, 0);
 +	strbuf_release(&sb);
  }
  
  static void diff_summary(struct diff_options *opt, struct diff_filepair *p)
  {
 -	FILE *file = opt->file;
 -	const char *line_prefix = diff_line_prefix(opt);
 -
  	switch(p->status) {
  	case DIFF_STATUS_DELETED:
 -		fputs(line_prefix, file);
 -		show_file_mode_name(file, "delete", p->one);
 +		show_file_mode_name(opt, "delete", p->one);
  		break;
  	case DIFF_STATUS_ADDED:
 -		fputs(line_prefix, file);
 -		show_file_mode_name(file, "create", p->two);
 +		show_file_mode_name(opt, "create", p->two);
  		break;
  	case DIFF_STATUS_COPIED:
 -		fputs(line_prefix, file);
 -		show_rename_copy(file, "copy", p, line_prefix);
 +		show_rename_copy(opt, "copy", p);
  		break;
  	case DIFF_STATUS_RENAMED:
 -		fputs(line_prefix, file);
 -		show_rename_copy(file, "rename", p, line_prefix);
 +		show_rename_copy(opt, "rename", p);
  		break;
  	default:
  		if (p->score) {
 -			fprintf(file, "%s rewrite ", line_prefix);
 -			write_name_quoted(p->two->path, file, ' ');
 -			fprintf(file, "(%d%%)\n", similarity_index(p));
 +			struct strbuf sb = STRBUF_INIT;
 +			strbuf_addstr(&sb, " rewrite ");
 +			quote_c_style(p->two->path, &sb, NULL, 0);
 +			strbuf_addf(&sb, " (%d%%)\n", similarity_index(p));
 +			emit_diff_symbol(opt, DIFF_SYMBOL_SUMMARY,
 +					 sb.buf, sb.len, 0);
 +			strbuf_release(&sb);
  		}
 -		show_mode_change(file, p, !p->score, line_prefix);
 +		show_mode_change(opt, p, !p->score);
  		break;
  	}
  }
@@@ -5522,51 -4731,6 +5522,51 @@@ void diff_warn_rename_limit(const char 
  		warning(_(rename_limit_advice), varname, needed);
  }
  
 +static void diff_flush_patch_all_file_pairs(struct diff_options *o)
 +{
 +	int i;
 +	static struct emitted_diff_symbols esm = EMITTED_DIFF_SYMBOLS_INIT;
 +	struct diff_queue_struct *q = &diff_queued_diff;
 +
 +	if (WSEH_NEW & WS_RULE_MASK)
 +		die("BUG: WS rules bit mask overlaps with diff symbol flags");
 +
 +	if (o->color_moved)
 +		o->emitted_symbols = &esm;
 +
 +	for (i = 0; i < q->nr; i++) {
 +		struct diff_filepair *p = q->queue[i];
 +		if (check_pair_status(p))
 +			diff_flush_patch(p, o);
 +	}
 +
 +	if (o->emitted_symbols) {
 +		if (o->color_moved) {
 +			struct hashmap add_lines, del_lines;
 +
 +			hashmap_init(&del_lines,
 +				     (hashmap_cmp_fn)moved_entry_cmp, o, 0);
 +			hashmap_init(&add_lines,
 +				     (hashmap_cmp_fn)moved_entry_cmp, o, 0);
 +
 +			add_lines_to_move_detection(o, &add_lines, &del_lines);
 +			mark_color_as_moved(o, &add_lines, &del_lines);
 +			if (o->color_moved == COLOR_MOVED_ZEBRA_DIM)
 +				dim_moved_lines(o);
 +
 +			hashmap_free(&add_lines, 0);
 +			hashmap_free(&del_lines, 0);
 +		}
 +
 +		for (i = 0; i < esm.nr; i++)
 +			emit_diff_symbol_from_struct(o, &esm.buf[i]);
 +
 +		for (i = 0; i < esm.nr; i++)
 +			free((void *)esm.buf[i].line);
 +	}
 +	esm.nr = 0;
 +}
 +
  void diff_flush(struct diff_options *options)
  {
  	struct diff_queue_struct *q = &diff_queued_diff;
@@@ -5639,7 -4803,6 +5639,7 @@@
  			fclose(options->file);
  		options->file = xfopen("/dev/null", "w");
  		options->close_file = 1;
 +		options->color_moved = 0;
  		for (i = 0; i < q->nr; i++) {
  			struct diff_filepair *p = q->queue[i];
  			if (check_pair_status(p))
@@@ -5651,14 -4814,20 +5651,14 @@@
  
  	if (output_format & DIFF_FORMAT_PATCH) {
  		if (separator) {
 -			fprintf(options->file, "%s%c",
 -				diff_line_prefix(options),
 -				options->line_termination);
 -			if (options->stat_sep) {
 +			emit_diff_symbol(options, DIFF_SYMBOL_SEPARATOR, NULL, 0, 0);
 +			if (options->stat_sep)
  				/* attach patch instead of inline */
 -				fputs(options->stat_sep, options->file);
 -			}
 +				emit_diff_symbol(options, DIFF_SYMBOL_STAT_SEP,
 +						 NULL, 0, 0);
  		}
  
 -		for (i = 0; i < q->nr; i++) {
 -			struct diff_filepair *p = q->queue[i];
 -			if (check_pair_status(p))
 -				diff_flush_patch(p, options);
 -		}
 +		diff_flush_patch_all_file_pairs(options);
  	}
  
  	if (output_format & DIFF_FORMAT_CALLBACK)
diff --combined git-compat-util.h
index 9bc15b0363,bf4869dcef..cedad4d581
--- a/git-compat-util.h
+++ b/git-compat-util.h
@@@ -749,6 -749,8 +749,6 @@@ const char *inet_ntop(int af, const voi
  extern int git_atexit(void (*handler)(void));
  #endif
  
 -extern void release_pack_memory(size_t);
 -
  typedef void (*try_to_free_t)(size_t);
  extern try_to_free_t set_try_to_free_routine(try_to_free_t);
  
@@@ -898,9 -900,11 +898,11 @@@ static inline char *xstrdup_or_null(con
  
  static inline size_t xsize_t(off_t len)
  {
- 	if (len > (size_t) len)
+ 	size_t size = (size_t) len;
+ 
+ 	if (len != (off_t) size)
  		die("Cannot handle files this big");
- 	return (size_t)len;
+ 	return size;
  }
  
  __attribute__((format (printf, 3, 4)))
@@@ -1169,24 -1173,4 +1171,24 @@@ static inline int is_missing_file_error
  
  extern int cmd_main(int, const char **);
  
 +/*
 + * You can mark a stack variable with UNLEAK(var) to avoid it being
 + * reported as a leak by tools like LSAN or valgrind. The argument
 + * should generally be the variable itself (not its address and not what
 + * it points to). It's safe to use this on pointers which may already
 + * have been freed, or on pointers which may still be in use.
 + *
 + * Use this _only_ for a variable that leaks by going out of scope at
 + * program exit (so only from cmd_* functions or their direct helpers).
 + * Normal functions, especially those which may be called multiple
 + * times, should actually free their memory. This is only meant as
 + * an annotation, and does nothing in non-leak-checking builds.
 + */
 +#ifdef SUPPRESS_ANNOTATED_LEAKS
 +extern void unleak_memory(const void *ptr, size_t len);
 +#define UNLEAK(var) unleak_memory(&(var), sizeof(var))
 +#else
 +#define UNLEAK(var) do {} while (0)
 +#endif
 +
  #endif
diff --combined revision.c
index 613168d397,7da0907c85..d167223e69
--- a/revision.c
+++ b/revision.c
@@@ -19,9 -19,6 +19,9 @@@
  #include "dir.h"
  #include "cache-tree.h"
  #include "bisect.h"
 +#include "packfile.h"
 +#include "worktree.h"
 +#include "argv-array.h"
  
  volatile show_early_output_fn_t show_early_output;
  
@@@ -1106,7 -1103,7 +1106,7 @@@ static void add_rev_cmdline(struct rev_
  			    unsigned flags)
  {
  	struct rev_cmdline_info *info = &revs->cmdline;
- 	int nr = info->nr;
+ 	unsigned int nr = info->nr;
  
  	ALLOC_GROW(info->rev, nr + 1, info->alloc);
  	info->rev[nr].item = item;
@@@ -1134,7 -1131,6 +1134,7 @@@ struct all_refs_cb 
  	int warned_bad_reflog;
  	struct rev_info *all_revs;
  	const char *name_for_errormsg;
 +	struct ref_store *refs;
  };
  
  int ref_excluded(struct string_list *ref_excludes, const char *path)
@@@ -1171,7 -1167,6 +1171,7 @@@ static void init_all_refs_cb(struct all
  	cb->all_revs = revs;
  	cb->all_flags = flags;
  	revs->rev_input_given = 1;
 +	cb->refs = NULL;
  }
  
  void clear_ref_exclusion(struct string_list **ref_excludes_p)
@@@ -1192,19 -1187,12 +1192,19 @@@ void add_ref_exclusion(struct string_li
  	string_list_append(*ref_excludes_p, exclude);
  }
  
 -static void handle_refs(const char *submodule, struct rev_info *revs, unsigned flags,
 -		int (*for_each)(const char *, each_ref_fn, void *))
 +static void handle_refs(struct ref_store *refs,
 +			struct rev_info *revs, unsigned flags,
 +			int (*for_each)(struct ref_store *, each_ref_fn, void *))
  {
  	struct all_refs_cb cb;
 +
 +	if (!refs) {
 +		/* this could happen with uninitialized submodules */
 +		return;
 +	}
 +
  	init_all_refs_cb(&cb, revs, flags);
 -	for_each(submodule, handle_one_ref, &cb);
 +	for_each(refs, handle_one_ref, &cb);
  }
  
  static void handle_one_reflog_commit(struct object_id *oid, void *cb_data)
@@@ -1240,41 -1228,17 +1240,41 @@@ static int handle_one_reflog(const cha
  	struct all_refs_cb *cb = cb_data;
  	cb->warned_bad_reflog = 0;
  	cb->name_for_errormsg = path;
 -	for_each_reflog_ent(path, handle_one_reflog_ent, cb_data);
 +	refs_for_each_reflog_ent(cb->refs, path,
 +				 handle_one_reflog_ent, cb_data);
  	return 0;
  }
  
 +static void add_other_reflogs_to_pending(struct all_refs_cb *cb)
 +{
 +	struct worktree **worktrees, **p;
 +
 +	worktrees = get_worktrees(0);
 +	for (p = worktrees; *p; p++) {
 +		struct worktree *wt = *p;
 +
 +		if (wt->is_current)
 +			continue;
 +
 +		cb->refs = get_worktree_ref_store(wt);
 +		refs_for_each_reflog(cb->refs,
 +				     handle_one_reflog,
 +				     cb);
 +	}
 +	free_worktrees(worktrees);
 +}
 +
  void add_reflogs_to_pending(struct rev_info *revs, unsigned flags)
  {
  	struct all_refs_cb cb;
  
  	cb.all_revs = revs;
  	cb.all_flags = flags;
 +	cb.refs = get_main_ref_store();
  	for_each_reflog(handle_one_reflog, &cb);
 +
 +	if (!revs->single_worktree)
 +		add_other_reflogs_to_pending(&cb);
  }
  
  static void add_cache_tree(struct cache_tree *it, struct rev_info *revs,
@@@ -1298,13 -1262,13 +1298,13 @@@
  
  }
  
 -void add_index_objects_to_pending(struct rev_info *revs, unsigned flags)
 +static void do_add_index_objects_to_pending(struct rev_info *revs,
 +					    struct index_state *istate)
  {
  	int i;
  
 -	read_cache();
 -	for (i = 0; i < active_nr; i++) {
 -		struct cache_entry *ce = active_cache[i];
 +	for (i = 0; i < istate->cache_nr; i++) {
 +		struct cache_entry *ce = istate->cache[i];
  		struct blob *blob;
  
  		if (S_ISGITLINK(ce->ce_mode))
@@@ -1317,39 -1281,13 +1317,39 @@@
  					     ce->ce_mode, ce->name);
  	}
  
 -	if (active_cache_tree) {
 +	if (istate->cache_tree) {
  		struct strbuf path = STRBUF_INIT;
 -		add_cache_tree(active_cache_tree, revs, &path);
 +		add_cache_tree(istate->cache_tree, revs, &path);
  		strbuf_release(&path);
  	}
  }
  
 +void add_index_objects_to_pending(struct rev_info *revs, unsigned int flags)
 +{
 +	struct worktree **worktrees, **p;
 +
 +	read_cache();
 +	do_add_index_objects_to_pending(revs, &the_index);
 +
 +	if (revs->single_worktree)
 +		return;
 +
 +	worktrees = get_worktrees(0);
 +	for (p = worktrees; *p; p++) {
 +		struct worktree *wt = *p;
 +		struct index_state istate = { NULL };
 +
 +		if (wt->is_current)
 +			continue; /* current index already taken care of */
 +
 +		if (read_index_from(&istate,
 +				    worktree_git_path(wt, "index")) > 0)
 +			do_add_index_objects_to_pending(revs, &istate);
 +		discard_index(&istate);
 +	}
 +	free_worktrees(worktrees);
 +}
 +
  static int add_parents_only(struct rev_info *revs, const char *arg_, int flags,
  			    int exclude_parent)
  {
@@@ -1364,7 -1302,7 +1364,7 @@@
  		flags ^= UNINTERESTING | BOTTOM;
  		arg++;
  	}
 -	if (get_sha1_committish(arg, oid.hash))
 +	if (get_oid_committish(arg, &oid))
  		return 0;
  	while (1) {
  		it = get_reference(revs, arg, &oid, 0);
@@@ -1513,7 -1451,7 +1513,7 @@@ static int handle_dotdot_1(const char *
  	unsigned int a_flags, b_flags;
  	int symmetric = 0;
  	unsigned int flags_exclude = flags ^ (UNINTERESTING | BOTTOM);
 -	unsigned int oc_flags = GET_SHA1_COMMITTISH | GET_SHA1_RECORD_PATH;
 +	unsigned int oc_flags = GET_OID_COMMITTISH | GET_OID_RECORD_PATH;
  
  	a_name = arg;
  	if (!*a_name)
@@@ -1527,8 -1465,8 +1527,8 @@@
  	if (!*b_name)
  		b_name = "HEAD";
  
 -	if (get_sha1_with_context(a_name, oc_flags, a_oid.hash, a_oc) ||
 -	    get_sha1_with_context(b_name, oc_flags, b_oid.hash, b_oc))
 +	if (get_oid_with_context(a_name, oc_flags, &a_oid, a_oc) ||
 +	    get_oid_with_context(b_name, oc_flags, &b_oid, b_oc))
  		return -1;
  
  	if (!cant_be_filename) {
@@@ -1609,7 -1547,7 +1609,7 @@@ int handle_revision_arg(const char *arg
  	int local_flags;
  	const char *arg = arg_;
  	int cant_be_filename = revarg_opt & REVARG_CANNOT_BE_FILENAME;
 -	unsigned get_sha1_flags = GET_SHA1_RECORD_PATH;
 +	unsigned get_sha1_flags = GET_OID_RECORD_PATH;
  
  	flags = flags & UNINTERESTING ? flags | BOTTOM : flags & ~BOTTOM;
  
@@@ -1660,9 -1598,9 +1660,9 @@@
  	}
  
  	if (revarg_opt & REVARG_COMMITTISH)
 -		get_sha1_flags |= GET_SHA1_COMMITTISH;
 +		get_sha1_flags |= GET_OID_COMMITTISH;
  
 -	if (get_sha1_with_context(arg, get_sha1_flags, oid.hash, &oc))
 +	if (get_oid_with_context(arg, get_sha1_flags, &oid, &oc))
  		return revs->ignore_missing ? 0 : -1;
  	if (!cant_be_filename)
  		verify_non_filename(revs->prefix, arg);
@@@ -1673,15 -1611,31 +1673,15 @@@
  	return 0;
  }
  
 -struct cmdline_pathspec {
 -	int alloc;
 -	int nr;
 -	const char **path;
 -};
 -
 -static void append_prune_data(struct cmdline_pathspec *prune, const char **av)
 -{
 -	while (*av) {
 -		ALLOC_GROW(prune->path, prune->nr + 1, prune->alloc);
 -		prune->path[prune->nr++] = *(av++);
 -	}
 -}
 -
  static void read_pathspec_from_stdin(struct rev_info *revs, struct strbuf *sb,
 -				     struct cmdline_pathspec *prune)
 +				     struct argv_array *prune)
  {
 -	while (strbuf_getline(sb, stdin) != EOF) {
 -		ALLOC_GROW(prune->path, prune->nr + 1, prune->alloc);
 -		prune->path[prune->nr++] = xstrdup(sb->buf);
 -	}
 +	while (strbuf_getline(sb, stdin) != EOF)
 +		argv_array_push(prune, sb->buf);
  }
  
  static void read_revisions_from_stdin(struct rev_info *revs,
 -				      struct cmdline_pathspec *prune)
 +				      struct argv_array *prune)
  {
  	struct strbuf sb;
  	int seen_dashdash = 0;
@@@ -2114,25 -2068,23 +2114,25 @@@ void parse_revision_opt(struct rev_inf
  	ctx->argc -= n;
  }
  
 -static int for_each_bisect_ref(const char *submodule, each_ref_fn fn, void *cb_data, const char *term) {
 +static int for_each_bisect_ref(struct ref_store *refs, each_ref_fn fn,
 +			       void *cb_data, const char *term)
 +{
  	struct strbuf bisect_refs = STRBUF_INIT;
  	int status;
  	strbuf_addf(&bisect_refs, "refs/bisect/%s", term);
 -	status = for_each_fullref_in_submodule(submodule, bisect_refs.buf, fn, cb_data, 0);
 +	status = refs_for_each_fullref_in(refs, bisect_refs.buf, fn, cb_data, 0);
  	strbuf_release(&bisect_refs);
  	return status;
  }
  
 -static int for_each_bad_bisect_ref(const char *submodule, each_ref_fn fn, void *cb_data)
 +static int for_each_bad_bisect_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
  {
 -	return for_each_bisect_ref(submodule, fn, cb_data, term_bad);
 +	return for_each_bisect_ref(refs, fn, cb_data, term_bad);
  }
  
 -static int for_each_good_bisect_ref(const char *submodule, each_ref_fn fn, void *cb_data)
 +static int for_each_good_bisect_ref(struct ref_store *refs, each_ref_fn fn, void *cb_data)
  {
 -	return for_each_bisect_ref(submodule, fn, cb_data, term_good);
 +	return for_each_bisect_ref(refs, fn, cb_data, term_good);
  }
  
  static int handle_revision_pseudo_opt(const char *submodule,
@@@ -2141,22 -2093,8 +2141,22 @@@
  {
  	const char *arg = argv[0];
  	const char *optarg;
 +	struct ref_store *refs;
  	int argcount;
  
 +	if (submodule) {
 +		/*
 +		 * We need some something like get_submodule_worktrees()
 +		 * before we can go through all worktrees of a submodule,
 +		 * .e.g with adding all HEADs from --all, which is not
 +		 * supported right now, so stick to single worktree.
 +		 */
 +		if (!revs->single_worktree)
 +			die("BUG: --single-worktree cannot be used together with submodule");
 +		refs = get_submodule_ref_store(submodule);
 +	} else
 +		refs = get_main_ref_store();
 +
  	/*
  	 * NOTE!
  	 *
@@@ -2168,29 -2106,22 +2168,29 @@@
  	 * register it in the list at the top of handle_revision_opt.
  	 */
  	if (!strcmp(arg, "--all")) {
 -		handle_refs(submodule, revs, *flags, for_each_ref_submodule);
 -		handle_refs(submodule, revs, *flags, head_ref_submodule);
 +		handle_refs(refs, revs, *flags, refs_for_each_ref);
 +		handle_refs(refs, revs, *flags, refs_head_ref);
 +		if (!revs->single_worktree) {
 +			struct all_refs_cb cb;
 +
 +			init_all_refs_cb(&cb, revs, *flags);
 +			other_head_refs(handle_one_ref, &cb);
 +		}
  		clear_ref_exclusion(&revs->ref_excludes);
  	} else if (!strcmp(arg, "--branches")) {
 -		handle_refs(submodule, revs, *flags, for_each_branch_ref_submodule);
 +		handle_refs(refs, revs, *flags, refs_for_each_branch_ref);
  		clear_ref_exclusion(&revs->ref_excludes);
  	} else if (!strcmp(arg, "--bisect")) {
  		read_bisect_terms(&term_bad, &term_good);
 -		handle_refs(submodule, revs, *flags, for_each_bad_bisect_ref);
 -		handle_refs(submodule, revs, *flags ^ (UNINTERESTING | BOTTOM), for_each_good_bisect_ref);
 +		handle_refs(refs, revs, *flags, for_each_bad_bisect_ref);
 +		handle_refs(refs, revs, *flags ^ (UNINTERESTING | BOTTOM),
 +			    for_each_good_bisect_ref);
  		revs->bisect = 1;
  	} else if (!strcmp(arg, "--tags")) {
 -		handle_refs(submodule, revs, *flags, for_each_tag_ref_submodule);
 +		handle_refs(refs, revs, *flags, refs_for_each_tag_ref);
  		clear_ref_exclusion(&revs->ref_excludes);
  	} else if (!strcmp(arg, "--remotes")) {
 -		handle_refs(submodule, revs, *flags, for_each_remote_ref_submodule);
 +		handle_refs(refs, revs, *flags, refs_for_each_remote_ref);
  		clear_ref_exclusion(&revs->ref_excludes);
  	} else if ((argcount = parse_long_opt("glob", argv, &optarg))) {
  		struct all_refs_cb cb;
@@@ -2237,8 -2168,6 +2237,8 @@@
  			return error("invalid argument to --no-walk");
  	} else if (!strcmp(arg, "--do-walk")) {
  		revs->no_walk = 0;
 +	} else if (!strcmp(arg, "--single-worktree")) {
 +		revs->single_worktree = 1;
  	} else {
  		return 0;
  	}
@@@ -2248,10 -2177,11 +2248,10 @@@
  
  static void NORETURN diagnose_missing_default(const char *def)
  {
 -	unsigned char sha1[20];
  	int flags;
  	const char *refname;
  
 -	refname = resolve_ref_unsafe(def, 0, sha1, &flags);
 +	refname = resolve_ref_unsafe(def, 0, NULL, &flags);
  	if (!refname || !(flags & REF_ISSYMREF) || (flags & REF_ISBROKEN))
  		die(_("your current branch appears to be broken"));
  
@@@ -2270,9 -2200,10 +2270,9 @@@
  int setup_revisions(int argc, const char **argv, struct rev_info *revs, struct setup_revision_opt *opt)
  {
  	int i, flags, left, seen_dashdash, read_from_stdin, got_rev_arg = 0, revarg_opt;
 -	struct cmdline_pathspec prune_data;
 +	struct argv_array prune_data = ARGV_ARRAY_INIT;
  	const char *submodule = NULL;
  
 -	memset(&prune_data, 0, sizeof(prune_data));
  	if (opt)
  		submodule = opt->submodule;
  
@@@ -2288,7 -2219,7 +2288,7 @@@
  			argv[i] = NULL;
  			argc = i;
  			if (argv[i + 1])
 -				append_prune_data(&prune_data, argv + i + 1);
 +				argv_array_pushv(&prune_data, argv + i + 1);
  			seen_dashdash = 1;
  			break;
  		}
@@@ -2349,14 -2280,14 +2349,14 @@@
  			for (j = i; j < argc; j++)
  				verify_filename(revs->prefix, argv[j], j == i);
  
 -			append_prune_data(&prune_data, argv + i);
 +			argv_array_pushv(&prune_data, argv + i);
  			break;
  		}
  		else
  			got_rev_arg = 1;
  	}
  
 -	if (prune_data.nr) {
 +	if (prune_data.argc) {
  		/*
  		 * If we need to introduce the magic "a lone ':' means no
  		 * pathspec whatsoever", here is the place to do so.
@@@ -2371,10 -2302,11 +2371,10 @@@
  		 *	call init_pathspec() to set revs->prune_data here.
  		 * }
  		 */
 -		ALLOC_GROW(prune_data.path, prune_data.nr + 1, prune_data.alloc);
 -		prune_data.path[prune_data.nr++] = NULL;
  		parse_pathspec(&revs->prune_data, 0, 0,
 -			       revs->prefix, prune_data.path);
 +			       revs->prefix, prune_data.argv);
  	}
 +	argv_array_clear(&prune_data);
  
  	if (revs->def == NULL)
  		revs->def = opt ? opt->def : NULL;
@@@ -2386,7 -2318,7 +2386,7 @@@
  		struct object_id oid;
  		struct object *object;
  		struct object_context oc;
 -		if (get_sha1_with_context(revs->def, 0, oid.hash, &oc))
 +		if (get_oid_with_context(revs->def, 0, &oid, &oc))
  			diagnose_missing_default(revs->def);
  		object = get_reference(revs, revs->def, &oid, 0);
  		add_pending_object_with_mode(revs, object, revs->def, oc.mode);
diff --combined tree-walk.c
index c99309069a,d459feda23..684f0e3373
--- a/tree-walk.c
+++ b/tree-walk.c
@@@ -78,16 -78,15 +78,16 @@@ int init_tree_desc_gently(struct tree_d
  	return result;
  }
  
 -void *fill_tree_descriptor(struct tree_desc *desc, const unsigned char *sha1)
 +void *fill_tree_descriptor(struct tree_desc *desc, const struct object_id *oid)
  {
  	unsigned long size = 0;
  	void *buf = NULL;
  
 -	if (sha1) {
 -		buf = read_object_with_reference(sha1, tree_type, &size, NULL);
 +	if (oid) {
 +		buf = read_object_with_reference(oid->hash, tree_type, &size,
 +						 NULL);
  		if (!buf)
 -			die("unable to read tree %s", sha1_to_hex(sha1));
 +			die("unable to read tree %s", oid_to_hex(oid));
  	}
  	init_tree_desc(desc, buf, size);
  	return buf;
@@@ -582,12 -581,11 +582,11 @@@ enum follow_symlinks_result get_tree_en
  	int retval = MISSING_OBJECT;
  	struct dir_state *parents = NULL;
  	size_t parents_alloc = 0;
- 	ssize_t parents_nr = 0;
+ 	size_t i, parents_nr = 0;
  	unsigned char current_tree_sha1[20];
  	struct strbuf namebuf = STRBUF_INIT;
  	struct tree_desc t;
  	int follows_remaining = GET_TREE_ENTRY_FOLLOW_SYMLINKS_MAX_LINKS;
- 	int i;
  
  	init_tree_desc(&t, NULL, 0UL);
  	strbuf_addstr(&namebuf, name);