From: Junio C Hamano <gitster@pobox.com>
Date: Mon, 25 Jul 2016 21:13:47 +0000 (-0700)
Subject: Merge branch 'rs/use-strbuf-addbuf'
X-Git-Tag: v2.10.0-rc0~82
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/b4e8a847ba4e775fb7d422b2daf18356db50eec8?ds=inline;hp=-c

Merge branch 'rs/use-strbuf-addbuf'

Code cleanup.

* rs/use-strbuf-addbuf:
strbuf: avoid calling strbuf_grow() twice in strbuf_addbuf()
use strbuf_addbuf() for appending a strbuf to another
---

b4e8a847ba4e775fb7d422b2daf18356db50eec8
diff --combined dir.c
index 6172b3438d,05b98843ee..0ea235f3d6
--- a/dir.c
+++ b/dir.c
@@@ -53,16 -53,24 +53,16 @@@ static enum path_treatment read_directo
  	int check_only, const struct path_simplify *simplify);
  static int get_dtype(struct dirent *de, const char *path, int len);
  
 -/* helper string functions with support for the ignore_case flag */
 -int strcmp_icase(const char *a, const char *b)
 +int fspathcmp(const char *a, const char *b)
  {
  	return ignore_case ? strcasecmp(a, b) : strcmp(a, b);
  }
  
 -int strncmp_icase(const char *a, const char *b, size_t count)
 +int fspathncmp(const char *a, const char *b, size_t count)
  {
  	return ignore_case ? strncasecmp(a, b, count) : strncmp(a, b, count);
  }
  
 -int fnmatch_icase(const char *pattern, const char *string, int flags)
 -{
 -	return wildmatch(pattern, string,
 -			 flags | (ignore_case ? WM_CASEFOLD : 0),
 -			 NULL);
 -}
 -
  int git_fnmatch(const struct pathspec_item *item,
  		const char *pattern, const char *string,
  		int prefix)
@@@ -449,7 -457,7 +449,7 @@@ int no_wildcard(const char *string
  
  void parse_exclude_pattern(const char **pattern,
  			   int *patternlen,
 -			   int *flags,
 +			   unsigned *flags,
  			   int *nowildcardlen)
  {
  	const char *p = *pattern;
@@@ -490,12 -498,17 +490,12 @@@ void add_exclude(const char *string, co
  {
  	struct exclude *x;
  	int patternlen;
 -	int flags;
 +	unsigned flags;
  	int nowildcardlen;
  
  	parse_exclude_pattern(&string, &patternlen, &flags, &nowildcardlen);
  	if (flags & EXC_FLAG_MUSTBEDIR) {
 -		char *s;
 -		x = xmalloc(sizeof(*x) + patternlen + 1);
 -		s = (char *)(x+1);
 -		memcpy(s, string, patternlen);
 -		s[patternlen] = '\0';
 -		x->pattern = s;
 +		FLEXPTR_ALLOC_MEM(x, pattern, string, patternlen);
  	} else {
  		x = xmalloc(sizeof(*x));
  		x->pattern = string;
@@@ -551,7 -564,9 +551,7 @@@ void clear_exclude_list(struct exclude_
  	free(el->excludes);
  	free(el->filebuf);
  
 -	el->nr = 0;
 -	el->excludes = NULL;
 -	el->filebuf = NULL;
 +	memset(el, 0, sizeof(*el));
  }
  
  static void trim_trailing_spaces(char *buf)
@@@ -612,7 -627,10 +612,7 @@@ static struct untracked_cache_dir *look
  	}
  
  	uc->dir_created++;
 -	d = xmalloc(sizeof(*d) + len + 1);
 -	memset(d, 0, sizeof(*d));
 -	memcpy(d->name, name, len);
 -	d->name[len] = '\0';
 +	FLEX_ALLOC_MEM(d, name, name, len);
  
  	ALLOC_GROW(dir->dirs, dir->dirs_nr + 1, dir->dirs_alloc);
  	memmove(dir->dirs + first + 1, dir->dirs + first,
@@@ -681,7 -699,7 +681,7 @@@ static int add_excludes(const char *fna
  			return 0;
  		}
  		if (buf[size-1] != '\n') {
 -			buf = xrealloc(buf, size+1);
 +			buf = xrealloc(buf, st_add(size, 1));
  			buf[size++] = '\n';
  		}
  	} else {
@@@ -695,7 -713,7 +695,7 @@@
  			close(fd);
  			return 0;
  		}
 -		buf = xmalloc(size+1);
 +		buf = xmallocz(size);
  		if (read_in_full(fd, buf, size) != size) {
  			free(buf);
  			close(fd);
@@@ -790,16 -808,16 +790,16 @@@ void add_excludes_from_file(struct dir_
  
  int match_basename(const char *basename, int basenamelen,
  		   const char *pattern, int prefix, int patternlen,
 -		   int flags)
 +		   unsigned flags)
  {
  	if (prefix == patternlen) {
  		if (patternlen == basenamelen &&
 -		    !strncmp_icase(pattern, basename, basenamelen))
 +		    !fspathncmp(pattern, basename, basenamelen))
  			return 1;
  	} else if (flags & EXC_FLAG_ENDSWITH) {
  		/* "*literal" matching against "fooliteral" */
  		if (patternlen - 1 <= basenamelen &&
 -		    !strncmp_icase(pattern + 1,
 +		    !fspathncmp(pattern + 1,
  				   basename + basenamelen - (patternlen - 1),
  				   patternlen - 1))
  			return 1;
@@@ -815,7 -833,7 +815,7 @@@
  int match_pathname(const char *pathname, int pathlen,
  		   const char *base, int baselen,
  		   const char *pattern, int prefix, int patternlen,
 -		   int flags)
 +		   unsigned flags)
  {
  	const char *name;
  	int namelen;
@@@ -836,7 -854,7 +836,7 @@@
  	 */
  	if (pathlen < baselen + 1 ||
  	    (baselen && pathname[baselen] != '/') ||
 -	    strncmp_icase(pathname, base, baselen))
 +	    fspathncmp(pathname, base, baselen))
  		return 0;
  
  	namelen = baselen ? pathlen - baselen - 1 : pathlen;
@@@ -850,7 -868,7 +850,7 @@@
  		if (prefix > namelen)
  			return 0;
  
 -		if (strncmp_icase(pattern, name, prefix))
 +		if (fspathncmp(pattern, name, prefix))
  			return 0;
  		pattern += prefix;
  		patternlen -= prefix;
@@@ -883,7 -901,6 +883,7 @@@ static struct exclude *last_exclude_mat
  						       int *dtype,
  						       struct exclude_list *el)
  {
 +	struct exclude *exc = NULL; /* undecided */
  	int i;
  
  	if (!el->nr)
@@@ -905,22 -922,18 +905,22 @@@
  			if (match_basename(basename,
  					   pathlen - (basename - pathname),
  					   exclude, prefix, x->patternlen,
 -					   x->flags))
 -				return x;
 +					   x->flags)) {
 +				exc = x;
 +				break;
 +			}
  			continue;
  		}
  
  		assert(x->baselen == 0 || x->base[x->baselen - 1] == '/');
  		if (match_pathname(pathname, pathlen,
  				   x->base, x->baselen ? x->baselen - 1 : 0,
 -				   exclude, prefix, x->patternlen, x->flags))
 -			return x;
 +				   exclude, prefix, x->patternlen, x->flags)) {
 +			exc = x;
 +			break;
 +		}
  	}
 -	return NULL; /* undecided */
 +	return exc;
  }
  
  /*
@@@ -1151,8 -1164,10 +1151,8 @@@ static struct dir_entry *dir_entry_new(
  {
  	struct dir_entry *ent;
  
 -	ent = xmalloc(sizeof(*ent) + len + 1);
 +	FLEX_ALLOC_MEM(ent, name, pathname, len);
  	ent->len = len;
 -	memcpy(ent->name, pathname, len);
 -	ent->name[len] = 0;
  	return ent;
  }
  
@@@ -1490,7 -1505,8 +1490,7 @@@ static enum path_treatment treat_path_f
  	}
  	strbuf_addstr(path, cdir->ucd->name);
  	/* treat_one_path() does this before it calls treat_directory() */
 -	if (path->buf[path->len - 1] != '/')
 -		strbuf_addch(path, '/');
 +	strbuf_complete(path, '/');
  	if (cdir->ucd->check_only)
  		/*
  		 * check_only is set as a result of treat_directory() getting
@@@ -1821,67 -1837,31 +1821,67 @@@ static const char *get_ident_string(voi
  		return sb.buf;
  	if (uname(&uts) < 0)
  		die_errno(_("failed to get kernel name and information"));
 -	strbuf_addf(&sb, "Location %s, system %s %s %s", get_git_work_tree(),
 -		    uts.sysname, uts.release, uts.version);
 +	strbuf_addf(&sb, "Location %s, system %s", get_git_work_tree(),
 +		    uts.sysname);
  	return sb.buf;
  }
  
  static int ident_in_untracked(const struct untracked_cache *uc)
  {
 -	const char *end = uc->ident.buf + uc->ident.len;
 -	const char *p   = uc->ident.buf;
 +	/*
 +	 * Previous git versions may have saved many NUL separated
 +	 * strings in the "ident" field, but it is insane to manage
 +	 * many locations, so just take care of the first one.
 +	 */
  
 -	for (p = uc->ident.buf; p < end; p += strlen(p) + 1)
 -		if (!strcmp(p, get_ident_string()))
 -			return 1;
 -	return 0;
 +	return !strcmp(uc->ident.buf, get_ident_string());
  }
  
 -void add_untracked_ident(struct untracked_cache *uc)
 +static void set_untracked_ident(struct untracked_cache *uc)
  {
 -	if (ident_in_untracked(uc))
 -		return;
 +	strbuf_reset(&uc->ident);
  	strbuf_addstr(&uc->ident, get_ident_string());
 -	/* this strbuf contains a list of strings, save NUL too */
 +
 +	/*
 +	 * This strbuf used to contain a list of NUL separated
 +	 * strings, so save NUL too for backward compatibility.
 +	 */
  	strbuf_addch(&uc->ident, 0);
  }
  
 +static void new_untracked_cache(struct index_state *istate)
 +{
 +	struct untracked_cache *uc = xcalloc(1, sizeof(*uc));
 +	strbuf_init(&uc->ident, 100);
 +	uc->exclude_per_dir = ".gitignore";
 +	/* should be the same flags used by git-status */
 +	uc->dir_flags = DIR_SHOW_OTHER_DIRECTORIES | DIR_HIDE_EMPTY_DIRECTORIES;
 +	set_untracked_ident(uc);
 +	istate->untracked = uc;
 +	istate->cache_changed |= UNTRACKED_CHANGED;
 +}
 +
 +void add_untracked_cache(struct index_state *istate)
 +{
 +	if (!istate->untracked) {
 +		new_untracked_cache(istate);
 +	} else {
 +		if (!ident_in_untracked(istate->untracked)) {
 +			free_untracked_cache(istate->untracked);
 +			new_untracked_cache(istate);
 +		}
 +	}
 +}
 +
 +void remove_untracked_cache(struct index_state *istate)
 +{
 +	if (istate->untracked) {
 +		free_untracked_cache(istate->untracked);
 +		istate->untracked = NULL;
 +		istate->cache_changed |= UNTRACKED_CHANGED;
 +	}
 +}
 +
  static struct untracked_cache_dir *validate_untracked_cache(struct dir_struct *dir,
  						      int base_len,
  						      const struct pathspec *pathspec)
@@@ -1939,7 -1919,7 +1939,7 @@@
  		return NULL;
  
  	if (!ident_in_untracked(dir->untracked)) {
 -		warning(_("Untracked cache is disabled on this system."));
 +		warning(_("Untracked cache is disabled on this system or location."));
  		return NULL;
  	}
  
@@@ -2141,7 -2121,8 +2141,7 @@@ static int remove_dir_recurse(struct st
  		else
  			return -1;
  	}
 -	if (path->buf[original_len - 1] != '/')
 -		strbuf_addch(path, '/');
 +	strbuf_complete(path, '/');
  
  	len = path->len;
  	while ((e = readdir(dir)) != NULL) {
@@@ -2352,19 -2333,20 +2352,19 @@@ void write_untracked_extension(struct s
  	struct ondisk_untracked_cache *ouc;
  	struct write_data wd;
  	unsigned char varbuf[16];
 -	int len = 0, varint_len;
 -	if (untracked->exclude_per_dir)
 -		len = strlen(untracked->exclude_per_dir);
 -	ouc = xmalloc(sizeof(*ouc) + len + 1);
 +	int varint_len;
 +	size_t len = strlen(untracked->exclude_per_dir);
 +
 +	FLEX_ALLOC_MEM(ouc, exclude_per_dir, untracked->exclude_per_dir, len);
  	stat_data_to_disk(&ouc->info_exclude_stat, &untracked->ss_info_exclude.stat);
  	stat_data_to_disk(&ouc->excludes_file_stat, &untracked->ss_excludes_file.stat);
  	hashcpy(ouc->info_exclude_sha1, untracked->ss_info_exclude.sha1);
  	hashcpy(ouc->excludes_file_sha1, untracked->ss_excludes_file.sha1);
  	ouc->dir_flags = htonl(untracked->dir_flags);
 -	memcpy(ouc->exclude_per_dir, untracked->exclude_per_dir, len + 1);
  
  	varint_len = encode_varint(untracked->ident.len, varbuf);
  	strbuf_add(out, varbuf, varint_len);
- 	strbuf_add(out, untracked->ident.buf, untracked->ident.len);
+ 	strbuf_addbuf(out, &untracked->ident);
  
  	strbuf_add(out, ouc, ouc_size(len));
  	free(ouc);
@@@ -2465,21 -2447,21 +2465,21 @@@ static int read_one_dir(struct untracke
  	ud.untracked_alloc = value;
  	ud.untracked_nr	   = value;
  	if (ud.untracked_nr)
 -		ud.untracked = xmalloc(sizeof(*ud.untracked) * ud.untracked_nr);
 +		ALLOC_ARRAY(ud.untracked, ud.untracked_nr);
  	data = next;
  
  	next = data;
  	ud.dirs_alloc = ud.dirs_nr = decode_varint(&next);
  	if (next > end)
  		return -1;
 -	ud.dirs = xmalloc(sizeof(*ud.dirs) * ud.dirs_nr);
 +	ALLOC_ARRAY(ud.dirs, ud.dirs_nr);
  	data = next;
  
  	len = strlen((const char *)data);
  	next = data + len + 1;
  	if (next > rd->end)
  		return -1;
 -	*untracked_ = untracked = xmalloc(sizeof(*untracked) + len);
 +	*untracked_ = untracked = xmalloc(st_add(sizeof(*untracked), len));
  	memcpy(untracked, &ud, sizeof(ud));
  	memcpy(untracked->name, data, len + 1);
  	data = next;
@@@ -2592,7 -2574,7 +2592,7 @@@ struct untracked_cache *read_untracked_
  	rd.data	      = next;
  	rd.end	      = end;
  	rd.index      = 0;
 -	rd.ucd        = xmalloc(sizeof(*rd.ucd) * len);
 +	ALLOC_ARRAY(rd.ucd, len);
  
  	if (read_one_dir(&uc->root, &rd) || rd.index != len)
  		goto done;
diff --combined path.c
index 259aeed846,e1bc8f04fe..17551c4834
--- a/path.c
+++ b/path.c
@@@ -5,7 -5,6 +5,7 @@@
  #include "strbuf.h"
  #include "string-list.h"
  #include "dir.h"
 +#include "worktree.h"
  
  static int get_st_mode_bits(const char *path, int *mode)
  {
@@@ -92,274 -91,58 +92,274 @@@ static void replace_dir(struct strbuf *
  		buf->buf[newlen] = '/';
  }
  
 -static const char *common_list[] = {
 -	"/branches", "/hooks", "/info", "!/logs", "/lost-found",
 -	"/objects", "/refs", "/remotes", "/worktrees", "/rr-cache", "/svn",
 -	"config", "!gc.pid", "packed-refs", "shallow",
 -	NULL
 +struct common_dir {
 +	/* Not considered garbage for report_linked_checkout_garbage */
 +	unsigned ignore_garbage:1;
 +	unsigned is_dir:1;
 +	/* Not common even though its parent is */
 +	unsigned exclude:1;
 +	const char *dirname;
  };
  
 -static void update_common_dir(struct strbuf *buf, int git_dir_len, const char *common_dir)
 +static struct common_dir common_list[] = {
 +	{ 0, 1, 0, "branches" },
 +	{ 0, 1, 0, "hooks" },
 +	{ 0, 1, 0, "info" },
 +	{ 0, 0, 1, "info/sparse-checkout" },
 +	{ 1, 1, 0, "logs" },
 +	{ 1, 1, 1, "logs/HEAD" },
 +	{ 0, 1, 1, "logs/refs/bisect" },
 +	{ 0, 1, 0, "lost-found" },
 +	{ 0, 1, 0, "objects" },
 +	{ 0, 1, 0, "refs" },
 +	{ 0, 1, 1, "refs/bisect" },
 +	{ 0, 1, 0, "remotes" },
 +	{ 0, 1, 0, "worktrees" },
 +	{ 0, 1, 0, "rr-cache" },
 +	{ 0, 1, 0, "svn" },
 +	{ 0, 0, 0, "config" },
 +	{ 1, 0, 0, "gc.pid" },
 +	{ 0, 0, 0, "packed-refs" },
 +	{ 0, 0, 0, "shallow" },
 +	{ 0, 0, 0, NULL }
 +};
 +
 +/*
 + * A compressed trie.  A trie node consists of zero or more characters that
 + * are common to all elements with this prefix, optionally followed by some
 + * children.  If value is not NULL, the trie node is a terminal node.
 + *
 + * For example, consider the following set of strings:
 + * abc
 + * def
 + * definite
 + * definition
 + *
 + * The trie would look like:
 + * root: len = 0, children a and d non-NULL, value = NULL.
 + *    a: len = 2, contents = bc, value = (data for "abc")
 + *    d: len = 2, contents = ef, children i non-NULL, value = (data for "def")
 + *       i: len = 3, contents = nit, children e and i non-NULL, value = NULL
 + *           e: len = 0, children all NULL, value = (data for "definite")
 + *           i: len = 2, contents = on, children all NULL,
 + *              value = (data for "definition")
 + */
 +struct trie {
 +	struct trie *children[256];
 +	int len;
 +	char *contents;
 +	void *value;
 +};
 +
 +static struct trie *make_trie_node(const char *key, void *value)
  {
 -	char *base = buf->buf + git_dir_len;
 -	const char **p;
 -
 -	if (is_dir_file(base, "logs", "HEAD") ||
 -	    is_dir_file(base, "info", "sparse-checkout"))
 -		return;	/* keep this in $GIT_DIR */
 -	for (p = common_list; *p; p++) {
 -		const char *path = *p;
 -		int is_dir = 0;
 -		if (*path == '!')
 -			path++;
 -		if (*path == '/') {
 -			path++;
 -			is_dir = 1;
 +	struct trie *new_node = xcalloc(1, sizeof(*new_node));
 +	new_node->len = strlen(key);
 +	if (new_node->len) {
 +		new_node->contents = xmalloc(new_node->len);
 +		memcpy(new_node->contents, key, new_node->len);
 +	}
 +	new_node->value = value;
 +	return new_node;
 +}
 +
 +/*
 + * Add a key/value pair to a trie.  The key is assumed to be \0-terminated.
 + * If there was an existing value for this key, return it.
 + */
 +static void *add_to_trie(struct trie *root, const char *key, void *value)
 +{
 +	struct trie *child;
 +	void *old;
 +	int i;
 +
 +	if (!*key) {
 +		/* we have reached the end of the key */
 +		old = root->value;
 +		root->value = value;
 +		return old;
 +	}
 +
 +	for (i = 0; i < root->len; i++) {
 +		if (root->contents[i] == key[i])
 +			continue;
 +
 +		/*
 +		 * Split this node: child will contain this node's
 +		 * existing children.
 +		 */
 +		child = malloc(sizeof(*child));
 +		memcpy(child->children, root->children, sizeof(root->children));
 +
 +		child->len = root->len - i - 1;
 +		if (child->len) {
 +			child->contents = xstrndup(root->contents + i + 1,
 +						   child->len);
  		}
 +		child->value = root->value;
 +		root->value = NULL;
 +		root->len = i;
  
 -		if (!common_dir)
 -			common_dir = get_git_common_dir();
 +		memset(root->children, 0, sizeof(root->children));
 +		root->children[(unsigned char)root->contents[i]] = child;
  
 -		if (is_dir && dir_prefix(base, path)) {
 -			replace_dir(buf, git_dir_len, common_dir);
 -			return;
 +		/* This is the newly-added child. */
 +		root->children[(unsigned char)key[i]] =
 +			make_trie_node(key + i + 1, value);
 +		return NULL;
 +	}
 +
 +	/* We have matched the entire compressed section */
 +	if (key[i]) {
 +		child = root->children[(unsigned char)key[root->len]];
 +		if (child) {
 +			return add_to_trie(child, key + root->len + 1, value);
 +		} else {
 +			child = make_trie_node(key + root->len + 1, value);
 +			root->children[(unsigned char)key[root->len]] = child;
 +			return NULL;
  		}
 -		if (!is_dir && !strcmp(base, path)) {
 -			replace_dir(buf, git_dir_len, common_dir);
 -			return;
 +	}
 +
 +	old = root->value;
 +	root->value = value;
 +	return old;
 +}
 +
 +typedef int (*match_fn)(const char *unmatched, void *data, void *baton);
 +
 +/*
 + * Search a trie for some key.  Find the longest /-or-\0-terminated
 + * prefix of the key for which the trie contains a value.  Call fn
 + * with the unmatched portion of the key and the found value, and
 + * return its return value.  If there is no such prefix, return -1.
 + *
 + * The key is partially normalized: consecutive slashes are skipped.
 + *
 + * For example, consider the trie containing only [refs,
 + * refs/worktree] (both with values).
 + *
 + * | key             | unmatched  | val from node | return value |
 + * |-----------------|------------|---------------|--------------|
 + * | a               | not called | n/a           | -1           |
 + * | refs            | \0         | refs          | as per fn    |
 + * | refs/           | /          | refs          | as per fn    |
 + * | refs/w          | /w         | refs          | as per fn    |
 + * | refs/worktree   | \0         | refs/worktree | as per fn    |
 + * | refs/worktree/  | /          | refs/worktree | as per fn    |
 + * | refs/worktree/a | /a         | refs/worktree | as per fn    |
 + * |-----------------|------------|---------------|--------------|
 + *
 + */
 +static int trie_find(struct trie *root, const char *key, match_fn fn,
 +		     void *baton)
 +{
 +	int i;
 +	int result;
 +	struct trie *child;
 +
 +	if (!*key) {
 +		/* we have reached the end of the key */
 +		if (root->value && !root->len)
 +			return fn(key, root->value, baton);
 +		else
 +			return -1;
 +	}
 +
 +	for (i = 0; i < root->len; i++) {
 +		/* Partial path normalization: skip consecutive slashes. */
 +		if (key[i] == '/' && key[i+1] == '/') {
 +			key++;
 +			continue;
  		}
 +		if (root->contents[i] != key[i])
 +			return -1;
  	}
 +
 +	/* Matched the entire compressed section */
 +	key += i;
 +	if (!*key)
 +		/* End of key */
 +		return fn(key, root->value, baton);
 +
 +	/* Partial path normalization: skip consecutive slashes */
 +	while (key[0] == '/' && key[1] == '/')
 +		key++;
 +
 +	child = root->children[(unsigned char)*key];
 +	if (child)
 +		result = trie_find(child, key + 1, fn, baton);
 +	else
 +		result = -1;
 +
 +	if (result >= 0 || (*key != '/' && *key != 0))
 +		return result;
 +	if (root->value)
 +		return fn(key, root->value, baton);
 +	else
 +		return -1;
 +}
 +
 +static struct trie common_trie;
 +static int common_trie_done_setup;
 +
 +static void init_common_trie(void)
 +{
 +	struct common_dir *p;
 +
 +	if (common_trie_done_setup)
 +		return;
 +
 +	for (p = common_list; p->dirname; p++)
 +		add_to_trie(&common_trie, p->dirname, p);
 +
 +	common_trie_done_setup = 1;
 +}
 +
 +/*
 + * Helper function for update_common_dir: returns 1 if the dir
 + * prefix is common.
 + */
 +static int check_common(const char *unmatched, void *value, void *baton)
 +{
 +	struct common_dir *dir = value;
 +
 +	if (!dir)
 +		return 0;
 +
 +	if (dir->is_dir && (unmatched[0] == 0 || unmatched[0] == '/'))
 +		return !dir->exclude;
 +
 +	if (!dir->is_dir && unmatched[0] == 0)
 +		return !dir->exclude;
 +
 +	return 0;
 +}
 +
 +static void update_common_dir(struct strbuf *buf, int git_dir_len,
 +			      const char *common_dir)
 +{
 +	char *base = buf->buf + git_dir_len;
 +	init_common_trie();
 +	if (!common_dir)
 +		common_dir = get_git_common_dir();
 +	if (trie_find(&common_trie, base, check_common, NULL) > 0)
 +		replace_dir(buf, git_dir_len, common_dir);
  }
  
  void report_linked_checkout_garbage(void)
  {
  	struct strbuf sb = STRBUF_INIT;
 -	const char **p;
 +	const struct common_dir *p;
  	int len;
  
  	if (!git_common_dir_env)
  		return;
  	strbuf_addf(&sb, "%s/", get_git_dir());
  	len = sb.len;
 -	for (p = common_list; *p; p++) {
 -		const char *path = *p;
 -		if (*path == '!')
 +	for (p = common_list; p->dirname; p++) {
 +		const char *path = p->dirname;
 +		if (p->ignore_garbage)
  			continue;
  		strbuf_setlen(&sb, len);
  		strbuf_addstr(&sb, path);
@@@ -384,11 -167,10 +384,11 @@@ static void adjust_git_path(struct strb
  		update_common_dir(buf, git_dir_len, NULL);
  }
  
 -static void do_git_path(struct strbuf *buf, const char *fmt, va_list args)
 +static void do_git_path(const struct worktree *wt, struct strbuf *buf,
 +			const char *fmt, va_list args)
  {
  	int gitdir_len;
 -	strbuf_addstr(buf, get_git_dir());
 +	strbuf_addstr(buf, get_worktree_git_dir(wt));
  	if (buf->len && !is_dir_sep(buf->buf[buf->len - 1]))
  		strbuf_addch(buf, '/');
  	gitdir_len = buf->len;
@@@ -397,21 -179,11 +397,21 @@@
  	strbuf_cleanup_path(buf);
  }
  
 +char *git_path_buf(struct strbuf *buf, const char *fmt, ...)
 +{
 +	va_list args;
 +	strbuf_reset(buf);
 +	va_start(args, fmt);
 +	do_git_path(NULL, buf, fmt, args);
 +	va_end(args);
 +	return buf->buf;
 +}
 +
  void strbuf_git_path(struct strbuf *sb, const char *fmt, ...)
  {
  	va_list args;
  	va_start(args, fmt);
 -	do_git_path(sb, fmt, args);
 +	do_git_path(NULL, sb, fmt, args);
  	va_end(args);
  }
  
@@@ -420,7 -192,7 +420,7 @@@ const char *git_path(const char *fmt, .
  	struct strbuf *pathname = get_pathname();
  	va_list args;
  	va_start(args, fmt);
 -	do_git_path(pathname, fmt, args);
 +	do_git_path(NULL, pathname, fmt, args);
  	va_end(args);
  	return pathname->buf;
  }
@@@ -430,7 -202,7 +430,7 @@@ char *git_pathdup(const char *fmt, ...
  	struct strbuf path = STRBUF_INIT;
  	va_list args;
  	va_start(args, fmt);
 -	do_git_path(&path, fmt, args);
 +	do_git_path(NULL, &path, fmt, args);
  	va_end(args);
  	return strbuf_detach(&path, NULL);
  }
@@@ -456,16 -228,6 +456,16 @@@ const char *mkpath(const char *fmt, ...
  	return cleanup_path(pathname->buf);
  }
  
 +const char *worktree_git_path(const struct worktree *wt, const char *fmt, ...)
 +{
 +	struct strbuf *pathname = get_pathname();
 +	va_list args;
 +	va_start(args, fmt);
 +	do_git_path(wt, pathname, fmt, args);
 +	va_end(args);
 +	return pathname->buf;
 +}
 +
  static void do_submodule_path(struct strbuf *buf, const char *path,
  			      const char *fmt, va_list args)
  {
@@@ -474,7 -236,8 +474,7 @@@
  	struct strbuf git_submodule_dir = STRBUF_INIT;
  
  	strbuf_addstr(buf, path);
 -	if (buf->len && buf->buf[buf->len - 1] != '/')
 -		strbuf_addch(buf, '/');
 +	strbuf_complete(buf, '/');
  	strbuf_addstr(buf, ".git");
  
  	git_dir = read_gitfile(buf->buf);
@@@ -483,7 -246,7 +483,7 @@@
  		strbuf_addstr(buf, git_dir);
  	}
  	strbuf_addch(buf, '/');
- 	strbuf_addstr(&git_submodule_dir, buf->buf);
+ 	strbuf_addbuf(&git_submodule_dir, buf);
  
  	strbuf_vaddf(buf, fmt, args);
  
@@@ -515,35 -278,6 +515,35 @@@ void strbuf_git_path_submodule(struct s
  	va_end(args);
  }
  
 +static void do_git_common_path(struct strbuf *buf,
 +			       const char *fmt,
 +			       va_list args)
 +{
 +	strbuf_addstr(buf, get_git_common_dir());
 +	if (buf->len && !is_dir_sep(buf->buf[buf->len - 1]))
 +		strbuf_addch(buf, '/');
 +	strbuf_vaddf(buf, fmt, args);
 +	strbuf_cleanup_path(buf);
 +}
 +
 +const char *git_common_path(const char *fmt, ...)
 +{
 +	struct strbuf *pathname = get_pathname();
 +	va_list args;
 +	va_start(args, fmt);
 +	do_git_common_path(pathname, fmt, args);
 +	va_end(args);
 +	return pathname->buf;
 +}
 +
 +void strbuf_git_common_path(struct strbuf *sb, const char *fmt, ...)
 +{
 +	va_list args;
 +	va_start(args, fmt);
 +	do_git_common_path(sb, fmt, args);
 +	va_end(args);
 +}
 +
  int validate_headref(const char *path)
  {
  	struct stat st;
@@@ -625,9 -359,6 +625,9 @@@ char *expand_user_path(const char *path
  			if (!home)
  				goto return_null;
  			strbuf_addstr(&user_path, home);
 +#ifdef GIT_WINDOWS_NATIVE
 +			convert_slashes(user_path.buf);
 +#endif
  		} else {
  			struct passwd *pw = getpw_str(username, username_len);
  			if (!pw)
@@@ -664,8 -395,8 +664,8 @@@ return_null
   */
  const char *enter_repo(const char *path, int strict)
  {
 -	static char used_path[PATH_MAX];
 -	static char validated_path[PATH_MAX];
 +	static struct strbuf validated_path = STRBUF_INIT;
 +	static struct strbuf used_path = STRBUF_INIT;
  
  	if (!path)
  		return NULL;
@@@ -680,47 -411,46 +680,47 @@@
  		while ((1 < len) && (path[len-1] == '/'))
  			len--;
  
 +		/*
 +		 * We can handle arbitrary-sized buffers, but this remains as a
 +		 * sanity check on untrusted input.
 +		 */
  		if (PATH_MAX <= len)
  			return NULL;
 -		strncpy(used_path, path, len); used_path[len] = 0 ;
 -		strcpy(validated_path, used_path);
  
 -		if (used_path[0] == '~') {
 -			char *newpath = expand_user_path(used_path);
 -			if (!newpath || (PATH_MAX - 10 < strlen(newpath))) {
 -				free(newpath);
 +		strbuf_reset(&used_path);
 +		strbuf_reset(&validated_path);
 +		strbuf_add(&used_path, path, len);
 +		strbuf_add(&validated_path, path, len);
 +
 +		if (used_path.buf[0] == '~') {
 +			char *newpath = expand_user_path(used_path.buf);
 +			if (!newpath)
  				return NULL;
 -			}
 -			/*
 -			 * Copy back into the static buffer. A pity
 -			 * since newpath was not bounded, but other
 -			 * branches of the if are limited by PATH_MAX
 -			 * anyway.
 -			 */
 -			strcpy(used_path, newpath); free(newpath);
 +			strbuf_attach(&used_path, newpath, strlen(newpath),
 +				      strlen(newpath));
  		}
 -		else if (PATH_MAX - 10 < len)
 -			return NULL;
 -		len = strlen(used_path);
  		for (i = 0; suffix[i]; i++) {
  			struct stat st;
 -			strcpy(used_path + len, suffix[i]);
 -			if (!stat(used_path, &st) &&
 +			size_t baselen = used_path.len;
 +			strbuf_addstr(&used_path, suffix[i]);
 +			if (!stat(used_path.buf, &st) &&
  			    (S_ISREG(st.st_mode) ||
 -			    (S_ISDIR(st.st_mode) && is_git_directory(used_path)))) {
 -				strcat(validated_path, suffix[i]);
 +			    (S_ISDIR(st.st_mode) && is_git_directory(used_path.buf)))) {
 +				strbuf_addstr(&validated_path, suffix[i]);
  				break;
  			}
 +			strbuf_setlen(&used_path, baselen);
  		}
  		if (!suffix[i])
  			return NULL;
 -		gitfile = read_gitfile(used_path);
 -		if (gitfile)
 -			strcpy(used_path, gitfile);
 -		if (chdir(used_path))
 +		gitfile = read_gitfile(used_path.buf);
 +		if (gitfile) {
 +			strbuf_reset(&used_path);
 +			strbuf_addstr(&used_path, gitfile);
 +		}
 +		if (chdir(used_path.buf))
  			return NULL;
 -		path = validated_path;
 +		path = validated_path.buf;
  	}
  	else {
  		const char *gitfile = read_gitfile(path);
@@@ -743,17 -473,17 +743,17 @@@ static int calc_shared_perm(int mode
  {
  	int tweak;
  
 -	if (shared_repository < 0)
 -		tweak = -shared_repository;
 +	if (get_shared_repository() < 0)
 +		tweak = -get_shared_repository();
  	else
 -		tweak = shared_repository;
 +		tweak = get_shared_repository();
  
  	if (!(mode & S_IWUSR))
  		tweak &= ~0222;
  	if (mode & S_IXUSR)
  		/* Copy read bits to execute bits */
  		tweak |= (tweak & 0444) >> 2;
 -	if (shared_repository < 0)
 +	if (get_shared_repository() < 0)
  		mode = (mode & ~0777) | tweak;
  	else
  		mode |= tweak;
@@@ -766,7 -496,7 +766,7 @@@ int adjust_shared_perm(const char *path
  {
  	int old_mode, new_mode;
  
 -	if (!shared_repository)
 +	if (!get_shared_repository())
  		return 0;
  	if (get_st_mode_bits(path, &old_mode) < 0)
  		return -1;
@@@ -784,18 -514,6 +784,18 @@@
  	return 0;
  }
  
 +void safe_create_dir(const char *dir, int share)
 +{
 +	if (mkdir(dir, 0777) < 0) {
 +		if (errno != EEXIST) {
 +			perror(dir);
 +			exit(1);
 +		}
 +	}
 +	else if (share && adjust_shared_perm(dir))
 +		die(_("Could not make %s writable by group"), dir);
 +}
 +
  static int have_same_root(const char *path1, const char *path2)
  {
  	int is_abs1, is_abs2;
@@@ -826,10 -544,13 +826,10 @@@ const char *relative_path(const char *i
  	else if (!prefix_len)
  		return in;
  
 -	if (have_same_root(in, prefix)) {
 +	if (have_same_root(in, prefix))
  		/* bypass dos_drive, for "c:" is identical to "C:" */
 -		if (has_dos_drive_prefix(in)) {
 -			i = 2;
 -			j = 2;
 -		}
 -	} else {
 +		i = j = has_dos_drive_prefix(in);
 +	else {
  		return in;
  	}
  
@@@ -918,7 -639,7 +918,7 @@@
   */
  const char *remove_leading_path(const char *in, const char *prefix)
  {
 -	static char buf[PATH_MAX + 1];
 +	static struct strbuf buf = STRBUF_INIT;
  	int i = 0, j = 0;
  
  	if (!prefix || !prefix[0])
@@@ -947,13 -668,11 +947,13 @@@
  		return in;
  	while (is_dir_sep(in[j]))
  		j++;
 +
 +	strbuf_reset(&buf);
  	if (!in[j])
 -		strcpy(buf, ".");
 +		strbuf_addstr(&buf, ".");
  	else
 -		strcpy(buf, in + j);
 -	return buf;
 +		strbuf_addstr(&buf, in + j);
 +	return buf.buf;
  }
  
  /*
@@@ -984,10 -703,11 +984,10 @@@
  int normalize_path_copy_len(char *dst, const char *src, int *prefix_len)
  {
  	char *dst0;
 +	int i;
  
 -	if (has_dos_drive_prefix(src)) {
 +	for (i = has_dos_drive_prefix(src); i > 0; i--)
  		*dst++ = *src++;
 -		*dst++ = *src++;
 -	}
  	dst0 = dst;
  
  	if (is_dir_sep(*src)) {
diff --combined strbuf.c
index 1ba600bd78,600e27ea4a..f3bd5719c6
--- a/strbuf.c
+++ b/strbuf.c
@@@ -197,6 -197,13 +197,13 @@@ void strbuf_add(struct strbuf *sb, cons
  	strbuf_setlen(sb, sb->len + len);
  }
  
+ void strbuf_addbuf(struct strbuf *sb, const struct strbuf *sb2)
+ {
+ 	strbuf_grow(sb, sb2->len);
+ 	memcpy(sb->buf + sb->len, sb2->buf, sb2->len);
+ 	strbuf_setlen(sb, sb->len + sb2->len);
+ }
+ 
  void strbuf_adddup(struct strbuf *sb, size_t pos, size_t len)
  {
  	strbuf_grow(sb, len);
@@@ -245,8 -252,8 +252,8 @@@ void strbuf_add_commented_lines(struct 
  	static char prefix2[2];
  
  	if (prefix1[0] != comment_line_char) {
 -		sprintf(prefix1, "%c ", comment_line_char);
 -		sprintf(prefix2, "%c", comment_line_char);
 +		xsnprintf(prefix1, sizeof(prefix1), "%c ", comment_line_char);
 +		xsnprintf(prefix2, sizeof(prefix2), "%c", comment_line_char);
  	}
  	add_lines(out, prefix1, prefix2, buf, size);
  }
@@@ -384,23 -391,6 +391,23 @@@ ssize_t strbuf_read(struct strbuf *sb, 
  	return sb->len - oldlen;
  }
  
 +ssize_t strbuf_read_once(struct strbuf *sb, int fd, size_t hint)
 +{
 +	ssize_t cnt;
 +
 +	strbuf_grow(sb, hint ? hint : 8192);
 +	cnt = xread(fd, sb->buf + sb->len, sb->alloc - sb->len - 1);
 +	if (cnt > 0)
 +		strbuf_setlen(sb, sb->len + cnt);
 +	return cnt;
 +}
 +
 +ssize_t strbuf_write(struct strbuf *sb, FILE *f)
 +{
 +	return sb->len ? fwrite(sb->buf, 1, sb->len, f) : 0;
 +}
 +
 +
  #define STRBUF_MAXLINK (2*PATH_MAX)
  
  int strbuf_readlink(struct strbuf *sb, const char *path, size_t hint)
@@@ -487,15 -477,9 +494,15 @@@ int strbuf_getwholeline(struct strbuf *
  	if (errno == ENOMEM)
  		die("Out of memory, getdelim failed");
  
 -	/* Restore slopbuf that we moved out of the way before */
 +	/*
 +	 * Restore strbuf invariants; if getdelim left us with a NULL pointer,
 +	 * we can just re-init, but otherwise we should make sure that our
 +	 * length is empty, and that the result is NUL-terminated.
 +	 */
  	if (!sb->buf)
  		strbuf_init(sb, 0);
 +	else
 +		strbuf_reset(sb);
  	return EOF;
  }
  #else
@@@ -524,37 -508,15 +531,37 @@@ int strbuf_getwholeline(struct strbuf *
  }
  #endif
  
 -int strbuf_getline(struct strbuf *sb, FILE *fp, int term)
 +static int strbuf_getdelim(struct strbuf *sb, FILE *fp, int term)
  {
  	if (strbuf_getwholeline(sb, fp, term))
  		return EOF;
 -	if (sb->buf[sb->len-1] == term)
 -		strbuf_setlen(sb, sb->len-1);
 +	if (sb->buf[sb->len - 1] == term)
 +		strbuf_setlen(sb, sb->len - 1);
 +	return 0;
 +}
 +
 +int strbuf_getline(struct strbuf *sb, FILE *fp)
 +{
 +	if (strbuf_getwholeline(sb, fp, '\n'))
 +		return EOF;
 +	if (sb->buf[sb->len - 1] == '\n') {
 +		strbuf_setlen(sb, sb->len - 1);
 +		if (sb->len && sb->buf[sb->len - 1] == '\r')
 +			strbuf_setlen(sb, sb->len - 1);
 +	}
  	return 0;
  }
  
 +int strbuf_getline_lf(struct strbuf *sb, FILE *fp)
 +{
 +	return strbuf_getdelim(sb, fp, '\n');
 +}
 +
 +int strbuf_getline_nul(struct strbuf *sb, FILE *fp)
 +{
 +	return strbuf_getdelim(sb, fp, '\0');
 +}
 +
  int strbuf_getwholeline_fd(struct strbuf *sb, int fd, int term)
  {
  	strbuf_reset(sb);
@@@ -730,7 -692,7 +737,7 @@@ char *xstrdup_tolower(const char *strin
  	size_t len, i;
  
  	len = strlen(string);
 -	result = xmalloc(len + 1);
 +	result = xmallocz(len);
  	for (i = 0; i < len; i++)
  		result[i] = tolower(string[i]);
  	result[i] = '\0';
@@@ -789,15 -751,6 +796,15 @@@ void strbuf_addftime(struct strbuf *sb
  	strbuf_setlen(sb, sb->len + len);
  }
  
 +void strbuf_add_unique_abbrev(struct strbuf *sb, const unsigned char *sha1,
 +			      int abbrev_len)
 +{
 +	int r;
 +	strbuf_grow(sb, GIT_SHA1_HEXSZ + 1);
 +	r = find_unique_abbrev_r(sb->buf + sb->len, sha1, abbrev_len);
 +	strbuf_setlen(sb, sb->len + r);
 +}
 +
  /*
   * Returns the length of a line, without trailing spaces.
   *
diff --combined strbuf.h
index 83c5c98530,45d25d7c4b..ba8d5f1d46
--- a/strbuf.h
+++ b/strbuf.h
@@@ -263,11 -263,7 +263,7 @@@ static inline void strbuf_addstr(struc
  /**
   * Copy the contents of another buffer at the end of the current one.
   */
- static inline void strbuf_addbuf(struct strbuf *sb, const struct strbuf *sb2)
- {
- 	strbuf_grow(sb, sb2->len);
- 	strbuf_add(sb, sb2->buf, sb2->len);
- }
+ extern void strbuf_addbuf(struct strbuf *sb, const struct strbuf *sb2);
  
  /**
   * Copy part of the buffer from a given position till a given length to the
@@@ -354,8 -350,8 +350,8 @@@ extern void strbuf_addftime(struct strb
   *
   * NOTE: The buffer is rewound if the read fails. If -1 is returned,
   * `errno` must be consulted, like you would do for `read(3)`.
 - * `strbuf_read()`, `strbuf_read_file()` and `strbuf_getline()` has the
 - * same behaviour as well.
 + * `strbuf_read()`, `strbuf_read_file()` and `strbuf_getline_*()`
 + * family of functions have the same behaviour as well.
   */
  extern size_t strbuf_fread(struct strbuf *, size_t, FILE *);
  
@@@ -366,19 -362,9 +362,19 @@@
   */
  extern ssize_t strbuf_read(struct strbuf *, int fd, size_t hint);
  
 +/**
 + * Read the contents of a given file descriptor partially by using only one
 + * attempt of xread. The third argument can be used to give a hint about the
 + * file size, to avoid reallocs. Returns the number of new bytes appended to
 + * the sb.
 + */
 +extern ssize_t strbuf_read_once(struct strbuf *, int fd, size_t hint);
 +
  /**
   * Read the contents of a file, specified by its path. The third argument
   * can be used to give a hint about the file size, to avoid reallocs.
 + * Return the number of bytes read or a negative value if some error
 + * occurred while opening or reading the file.
   */
  extern ssize_t strbuf_read_file(struct strbuf *sb, const char *path, size_t hint);
  
@@@ -389,37 -375,14 +385,37 @@@
  extern int strbuf_readlink(struct strbuf *sb, const char *path, size_t hint);
  
  /**
 - * Read a line from a FILE *, overwriting the existing contents
 - * of the strbuf. The second argument specifies the line
 - * terminator character, typically `'\n'`.
 + * Write the whole content of the strbuf to the stream not stopping at
 + * NUL bytes.
 + */
 +extern ssize_t strbuf_write(struct strbuf *sb, FILE *stream);
 +
 +/**
 + * Read a line from a FILE *, overwriting the existing contents of
 + * the strbuf.  The strbuf_getline*() family of functions share
 + * this signature, but have different line termination conventions.
 + *
   * Reading stops after the terminator or at EOF.  The terminator
   * is removed from the buffer before returning.  Returns 0 unless
   * there was nothing left before EOF, in which case it returns `EOF`.
   */
 -extern int strbuf_getline(struct strbuf *, FILE *, int);
 +typedef int (*strbuf_getline_fn)(struct strbuf *, FILE *);
 +
 +/* Uses LF as the line terminator */
 +extern int strbuf_getline_lf(struct strbuf *sb, FILE *fp);
 +
 +/* Uses NUL as the line terminator */
 +extern int strbuf_getline_nul(struct strbuf *sb, FILE *fp);
 +
 +/*
 + * Similar to strbuf_getline_lf(), but additionally treats a CR that
 + * comes immediately before the LF as part of the terminator.
 + * This is the most friendly version to be used to read "text" files
 + * that can come from platforms whose native text format is CRLF
 + * terminated.
 + */
 +extern int strbuf_getline(struct strbuf *, FILE *);
 +
  
  /**
   * Like `strbuf_getline`, but keeps the trailing terminator (if
@@@ -516,14 -479,6 +512,14 @@@ static inline struct strbuf **strbuf_sp
   */
  extern void strbuf_list_free(struct strbuf **);
  
 +/**
 + * Add the abbreviation, as generated by find_unique_abbrev, of `sha1` to
 + * the strbuf `sb`.
 + */
 +extern void strbuf_add_unique_abbrev(struct strbuf *sb,
 +				     const unsigned char *sha1,
 +				     int abbrev_len);
 +
  /**
   * Launch the user preferred editor to edit a file and fill the buffer
   * with the file's contents upon the user completing their editing. The
@@@ -541,21 -496,10 +537,21 @@@ extern void strbuf_add_lines(struct str
   */
  extern void strbuf_addstr_xml_quoted(struct strbuf *sb, const char *s);
  
 +/**
 + * "Complete" the contents of `sb` by ensuring that either it ends with the
 + * character `term`, or it is empty.  This can be used, for example,
 + * to ensure that text ends with a newline, but without creating an empty
 + * blank line if there is no content in the first place.
 + */
 +static inline void strbuf_complete(struct strbuf *sb, char term)
 +{
 +	if (sb->len && sb->buf[sb->len - 1] != term)
 +		strbuf_addch(sb, term);
 +}
 +
  static inline void strbuf_complete_line(struct strbuf *sb)
  {
 -	if (sb->len && sb->buf[sb->len - 1] != '\n')
 -		strbuf_addch(sb, '\n');
 +	strbuf_complete(sb, '\n');
  }
  
  extern int strbuf_branchname(struct strbuf *sb, const char *name);
diff --combined wt-status.c
index de62ab2149,51c0d7fea7..19cbc3939c
--- a/wt-status.c
+++ b/wt-status.c
@@@ -15,7 -15,6 +15,7 @@@
  #include "column.h"
  #include "strbuf.h"
  #include "utf8.h"
 +#include "worktree.h"
  
  static const char cut_line[] =
  "------------------------ >8 ------------------------\n";
@@@ -263,7 -262,7 +263,7 @@@ static const char *wt_status_unmerged_s
  	case 7:
  		return _("both modified:");
  	default:
 -		die(_("bug: unhandled unmerged status %x"), stagemask);
 +		die("bug: unhandled unmerged status %x", stagemask);
  	}
  }
  
@@@ -388,7 -387,7 +388,7 @@@ static void wt_status_print_change_data
  	status_printf(s, color(WT_STATUS_HEADER, s), "\t");
  	what = wt_status_diff_status_string(status);
  	if (!what)
 -		die(_("bug: unhandled diff status %c"), status);
 +		die("bug: unhandled diff status %c", status);
  	len = label_width - utf8_strwidth(what);
  	assert(len >= 0);
  	if (status == DIFF_STATUS_COPIED || status == DIFF_STATUS_RENAMED)
@@@ -432,8 -431,7 +432,8 @@@ static void wt_status_collect_changed_c
  			d->worktree_status = p->status;
  		d->dirty_submodule = p->two->dirty_submodule;
  		if (S_ISGITLINK(p->two->mode))
 -			d->new_submodule_commits = !!hashcmp(p->one->sha1, p->two->sha1);
 +			d->new_submodule_commits = !!oidcmp(&p->one->oid,
 +							    &p->two->oid);
  	}
  }
  
@@@ -952,7 -950,6 +952,7 @@@ static void show_merge_in_progress(stru
  			status_printf_ln(s, color,
  				_("  (fix conflicts and run \"git commit\")"));
  	} else {
 +		s-> commitable = 1;
  		status_printf_ln(s, color,
  			_("All conflicts fixed but you are still merging."));
  		if (s->hints)
@@@ -991,7 -988,7 +991,7 @@@ static char *read_line_from_git_path(co
  		strbuf_release(&buf);
  		return NULL;
  	}
 -	strbuf_getline(&buf, fp, '\n');
 +	strbuf_getline_lf(&buf, fp);
  	if (!fclose(fp)) {
  		return strbuf_detach(&buf, NULL);
  	} else {
@@@ -1063,10 -1060,12 +1063,10 @@@ static void abbrev_sha1_in_line(struct 
  			strbuf_addf(split[1], "%s ", abbrev);
  			strbuf_reset(line);
  			for (i = 0; split[i]; i++)
- 				strbuf_addf(line, "%s", split[i]->buf);
+ 				strbuf_addbuf(line, split[i]);
  		}
  	}
 -	for (i = 0; split[i]; i++)
 -		strbuf_release(split[i]);
 -
 +	strbuf_list_free(split);
  }
  
  static void read_rebase_todolist(const char *fname, struct string_list *lines)
@@@ -1077,7 -1076,7 +1077,7 @@@
  	if (!f)
  		die_errno("Could not open file %s for reading",
  			  git_path("%s", fname));
 -	while (!strbuf_getline(&line, f, '\n')) {
 +	while (!strbuf_getline_lf(&line, f)) {
  		if (line.len && line.buf[0] == comment_line_char)
  			continue;
  		strbuf_trim(&line);
@@@ -1265,13 -1264,13 +1265,13 @@@ static void show_bisect_in_progress(str
  /*
   * Extract branch information from rebase/bisect
   */
 -static char *read_and_strip_branch(const char *path)
 +static char *get_branch(const struct worktree *wt, const char *path)
  {
  	struct strbuf sb = STRBUF_INIT;
  	unsigned char sha1[20];
  	const char *branch_name;
  
 -	if (strbuf_read_file(&sb, git_path("%s", path), 0) <= 0)
 +	if (strbuf_read_file(&sb, worktree_git_path(wt, "%s", path), 0) <= 0)
  		goto got_nothing;
  
  	while (sb.len && sb.buf[sb.len - 1] == '\n')
@@@ -1347,7 -1346,7 +1347,7 @@@ static void wt_status_get_detached_from
  	    (!hashcmp(cb.nsha1, sha1) ||
  	     /* perhaps sha1 is a tag, try to dereference to a commit */
  	     ((commit = lookup_commit_reference_gently(sha1, 1)) != NULL &&
 -	      !hashcmp(cb.nsha1, commit->object.sha1)))) {
 +	      !hashcmp(cb.nsha1, commit->object.oid.hash)))) {
  		const char *from = ref;
  		if (!skip_prefix(from, "refs/tags/", &from))
  			skip_prefix(from, "refs/remotes/", &from);
@@@ -1363,62 -1362,40 +1363,62 @@@
  	strbuf_release(&cb.buf);
  }
  
 -void wt_status_get_state(struct wt_status_state *state,
 -			 int get_detached_from)
 +int wt_status_check_rebase(const struct worktree *wt,
 +			   struct wt_status_state *state)
  {
  	struct stat st;
 -	unsigned char sha1[20];
  
 -	if (!stat(git_path_merge_head(), &st)) {
 -		state->merge_in_progress = 1;
 -	} else if (!stat(git_path("rebase-apply"), &st)) {
 -		if (!stat(git_path("rebase-apply/applying"), &st)) {
 +	if (!stat(worktree_git_path(wt, "rebase-apply"), &st)) {
 +		if (!stat(worktree_git_path(wt, "rebase-apply/applying"), &st)) {
  			state->am_in_progress = 1;
 -			if (!stat(git_path("rebase-apply/patch"), &st) && !st.st_size)
 +			if (!stat(worktree_git_path(wt, "rebase-apply/patch"), &st) && !st.st_size)
  				state->am_empty_patch = 1;
  		} else {
  			state->rebase_in_progress = 1;
 -			state->branch = read_and_strip_branch("rebase-apply/head-name");
 -			state->onto = read_and_strip_branch("rebase-apply/onto");
 +			state->branch = get_branch(wt, "rebase-apply/head-name");
 +			state->onto = get_branch(wt, "rebase-apply/onto");
  		}
 -	} else if (!stat(git_path("rebase-merge"), &st)) {
 -		if (!stat(git_path("rebase-merge/interactive"), &st))
 +	} else if (!stat(worktree_git_path(wt, "rebase-merge"), &st)) {
 +		if (!stat(worktree_git_path(wt, "rebase-merge/interactive"), &st))
  			state->rebase_interactive_in_progress = 1;
  		else
  			state->rebase_in_progress = 1;
 -		state->branch = read_and_strip_branch("rebase-merge/head-name");
 -		state->onto = read_and_strip_branch("rebase-merge/onto");
 +		state->branch = get_branch(wt, "rebase-merge/head-name");
 +		state->onto = get_branch(wt, "rebase-merge/onto");
 +	} else
 +		return 0;
 +	return 1;
 +}
 +
 +int wt_status_check_bisect(const struct worktree *wt,
 +			   struct wt_status_state *state)
 +{
 +	struct stat st;
 +
 +	if (!stat(worktree_git_path(wt, "BISECT_LOG"), &st)) {
 +		state->bisect_in_progress = 1;
 +		state->branch = get_branch(wt, "BISECT_START");
 +		return 1;
 +	}
 +	return 0;
 +}
 +
 +void wt_status_get_state(struct wt_status_state *state,
 +			 int get_detached_from)
 +{
 +	struct stat st;
 +	unsigned char sha1[20];
 +
 +	if (!stat(git_path_merge_head(), &st)) {
 +		state->merge_in_progress = 1;
 +	} else if (wt_status_check_rebase(NULL, state)) {
 +		;		/* all set */
  	} else if (!stat(git_path_cherry_pick_head(), &st) &&
  			!get_sha1("CHERRY_PICK_HEAD", sha1)) {
  		state->cherry_pick_in_progress = 1;
  		hashcpy(state->cherry_pick_head_sha1, sha1);
  	}
 -	if (!stat(git_path("BISECT_LOG"), &st)) {
 -		state->bisect_in_progress = 1;
 -		state->branch = read_and_strip_branch("BISECT_START");
 -	}
 +	wt_status_check_bisect(NULL, state);
  	if (!stat(git_path_revert_head(), &st) &&
  	    !get_sha1("REVERT_HEAD", sha1)) {
  		state->revert_in_progress = 1;
@@@ -1555,7 -1532,7 +1555,7 @@@ void wt_status_print(struct wt_status *
  			else
  				printf(_("nothing to commit\n"));
  		} else
 -			printf(_("nothing to commit, working directory clean\n"));
 +			printf(_("nothing to commit, working tree clean\n"));
  	}
  }
  
@@@ -1700,10 -1677,10 +1700,10 @@@ static void wt_shortstatus_print_tracki
  		color_fprintf(s->fp, header_color, LABEL(N_("behind ")));
  		color_fprintf(s->fp, branch_color_remote, "%d", num_theirs);
  	} else if (!num_theirs) {
 -		color_fprintf(s->fp, header_color, LABEL(N_(("ahead "))));
 +		color_fprintf(s->fp, header_color, LABEL(N_("ahead ")));
  		color_fprintf(s->fp, branch_color_local, "%d", num_ours);
  	} else {
 -		color_fprintf(s->fp, header_color, LABEL(N_(("ahead "))));
 +		color_fprintf(s->fp, header_color, LABEL(N_("ahead ")));
  		color_fprintf(s->fp, branch_color_local, "%d", num_ours);
  		color_fprintf(s->fp, header_color, ", %s", LABEL(N_("behind ")));
  		color_fprintf(s->fp, branch_color_remote, "%d", num_theirs);