From: Junio C Hamano <gitster@pobox.com>
Date: Mon, 6 Nov 2017 05:24:26 +0000 (+0900)
Subject: Merge branch 'jk/revision-pruning-optim'
X-Git-Tag: v2.16.0-rc0~164
X-Git-Url: https://git.lorimer.id.au/gitweb.git/diff_plain/f4c214b529336124f8642f1373cd4a549d5e7743?hp=-c

Merge branch 'jk/revision-pruning-optim'

Pathspec-limited revision traversal was taught not to keep finding
unneeded differences once it knows two trees are different inside
given pathspec.

* jk/revision-pruning-optim:
revision: quit pruning diff more quickly when possible
---

f4c214b529336124f8642f1373cd4a549d5e7743
diff --combined diff.h
index aca150ba2e,fe5c287a70..398b87b4cf
--- a/diff.h
+++ b/diff.h
@@@ -14,7 -14,7 +14,7 @@@ struct diff_queue_struct
  struct strbuf;
  struct diff_filespec;
  struct userdiff_driver;
 -struct sha1_array;
 +struct oid_array;
  struct commit;
  struct combine_diff_path;
  
@@@ -23,16 -23,16 +23,16 @@@ typedef int (*pathchange_fn_t)(struct d
  
  typedef void (*change_fn_t)(struct diff_options *options,
  		 unsigned old_mode, unsigned new_mode,
 -		 const unsigned char *old_sha1,
 -		 const unsigned char *new_sha1,
 -		 int old_sha1_valid, int new_sha1_valid,
 +		 const struct object_id *old_oid,
 +		 const struct object_id *new_oid,
 +		 int old_oid_valid, int new_oid_valid,
  		 const char *fullpath,
  		 unsigned old_dirty_submodule, unsigned new_dirty_submodule);
  
  typedef void (*add_remove_fn_t)(struct diff_options *options,
  		    int addremove, unsigned mode,
 -		    const unsigned char *sha1,
 -		    int sha1_valid,
 +		    const struct object_id *oid,
 +		    int oid_valid,
  		    const char *fullpath, unsigned dirty_submodule);
  
  typedef void (*diff_format_fn_t)(struct diff_queue_struct *q,
@@@ -148,9 -148,9 +148,9 @@@ struct diff_options 
  	int abbrev;
  	int ita_invisible_in_index;
  /* white-space error highlighting */
 -#define WSEH_NEW 1
 -#define WSEH_CONTEXT 2
 -#define WSEH_OLD 4
 +#define WSEH_NEW (1<<12)
 +#define WSEH_CONTEXT (1<<13)
 +#define WSEH_OLD (1<<14)
  	unsigned ws_error_highlight;
  	const char *prefix;
  	int prefix_length;
@@@ -180,33 -180,15 +180,34 @@@
  	pathchange_fn_t pathchange;
  	change_fn_t change;
  	add_remove_fn_t add_remove;
+ 	void *change_fn_data;
  	diff_format_fn_t format_callback;
  	void *format_callback_data;
  	diff_prefix_fn_t output_prefix;
  	void *output_prefix_data;
  
  	int diff_path_counter;
 +
 +	struct emitted_diff_symbols *emitted_symbols;
 +	enum {
 +		COLOR_MOVED_NO = 0,
 +		COLOR_MOVED_PLAIN = 1,
 +		COLOR_MOVED_ZEBRA = 2,
 +		COLOR_MOVED_ZEBRA_DIM = 3,
 +	} color_moved;
 +	#define COLOR_MOVED_DEFAULT COLOR_MOVED_ZEBRA
 +	#define COLOR_MOVED_MIN_ALNUM_COUNT 20
  };
  
 +void diff_emit_submodule_del(struct diff_options *o, const char *line);
 +void diff_emit_submodule_add(struct diff_options *o, const char *line);
 +void diff_emit_submodule_untracked(struct diff_options *o, const char *path);
 +void diff_emit_submodule_modified(struct diff_options *o, const char *path);
 +void diff_emit_submodule_header(struct diff_options *o, const char *header);
 +void diff_emit_submodule_error(struct diff_options *o, const char *err);
 +void diff_emit_submodule_pipethrough(struct diff_options *o,
 +				     const char *line, int len);
 +
  enum color_diff {
  	DIFF_RESET = 0,
  	DIFF_CONTEXT = 1,
@@@ -216,15 -198,7 +217,15 @@@
  	DIFF_FILE_NEW = 5,
  	DIFF_COMMIT = 6,
  	DIFF_WHITESPACE = 7,
 -	DIFF_FUNCINFO = 8
 +	DIFF_FUNCINFO = 8,
 +	DIFF_FILE_OLD_MOVED = 9,
 +	DIFF_FILE_OLD_MOVED_ALT = 10,
 +	DIFF_FILE_OLD_MOVED_DIM = 11,
 +	DIFF_FILE_OLD_MOVED_ALT_DIM = 12,
 +	DIFF_FILE_NEW_MOVED = 13,
 +	DIFF_FILE_NEW_MOVED_ALT = 14,
 +	DIFF_FILE_NEW_MOVED_DIM = 15,
 +	DIFF_FILE_NEW_MOVED_ALT_DIM = 16
  };
  const char *diff_get_color(int diff_use_color, enum color_diff ix);
  #define diff_get_color_opt(o, ix) \
@@@ -237,14 -211,13 +238,14 @@@ const char *diff_line_prefix(struct dif
  extern const char mime_boundary_leader[];
  
  extern struct combine_diff_path *diff_tree_paths(
 -	struct combine_diff_path *p, const unsigned char *sha1,
 -	const unsigned char **parent_sha1, int nparent,
 +	struct combine_diff_path *p, const struct object_id *oid,
 +	const struct object_id **parents_oid, int nparent,
  	struct strbuf *base, struct diff_options *opt);
 -extern int diff_tree_sha1(const unsigned char *old, const unsigned char *new,
 -			  const char *base, struct diff_options *opt);
 -extern int diff_root_tree_sha1(const unsigned char *new, const char *base,
 -                               struct diff_options *opt);
 +extern int diff_tree_oid(const struct object_id *old_oid,
 +			 const struct object_id *new_oid,
 +			 const char *base, struct diff_options *opt);
 +extern int diff_root_tree_oid(const struct object_id *new_oid, const char *base,
 +			      struct diff_options *opt);
  
  struct combine_diff_path {
  	struct combine_diff_path *next;
@@@ -264,7 -237,7 +265,7 @@@
  extern void show_combined_diff(struct combine_diff_path *elem, int num_parent,
  			      int dense, struct rev_info *);
  
 -extern void diff_tree_combined(const unsigned char *sha1, const struct sha1_array *parents, int dense, struct rev_info *rev);
 +extern void diff_tree_combined(const struct object_id *oid, const struct oid_array *parents, int dense, struct rev_info *rev);
  
  extern void diff_tree_combined_merge(const struct commit *commit, int dense, struct rev_info *rev);
  
@@@ -275,15 -248,16 +276,15 @@@ extern int diff_can_quit_early(struct d
  extern void diff_addremove(struct diff_options *,
  			   int addremove,
  			   unsigned mode,
 -			   const unsigned char *sha1,
 -			   int sha1_valid,
 +			   const struct object_id *oid,
 +			   int oid_valid,
  			   const char *fullpath, unsigned dirty_submodule);
  
  extern void diff_change(struct diff_options *,
  			unsigned mode1, unsigned mode2,
 -			const unsigned char *sha1,
 -			const unsigned char *sha2,
 -			int sha1_valid,
 -			int sha2_valid,
 +			const struct object_id *old_oid,
 +			const struct object_id *new_oid,
 +			int old_oid_valid, int new_oid_valid,
  			const char *fullpath,
  			unsigned dirty_submodule1, unsigned dirty_submodule2);
  
@@@ -381,8 -355,8 +382,8 @@@ extern const char *diff_aligned_abbrev(
  extern int run_diff_files(struct rev_info *revs, unsigned int option);
  extern int run_diff_index(struct rev_info *revs, int cached);
  
 -extern int do_diff_cache(const unsigned char *, struct diff_options *);
 -extern int diff_flush_patch_id(struct diff_options *, unsigned char *, int);
 +extern int do_diff_cache(const struct object_id *, struct diff_options *);
 +extern int diff_flush_patch_id(struct diff_options *, struct object_id *, int);
  
  extern int diff_result_code(struct diff_options *, int);
  
@@@ -412,19 -386,12 +413,19 @@@ extern size_t fill_textconv(struct user
   */
  extern struct userdiff_driver *get_textconv(struct diff_filespec *one);
  
 +/*
 + * Prepare diff_filespec and convert it using diff textconv API
 + * if the textconv driver exists.
 + * Return 1 if the conversion succeeds, 0 otherwise.
 + */
 +extern int textconv_object(const char *path, unsigned mode, const struct object_id *oid, int oid_valid, char **buf, unsigned long *buf_size);
 +
  extern int parse_rename_score(const char **cp_p);
  
  extern long parse_algorithm_value(const char *value);
  
 -extern int print_stat_summary(FILE *fp, int files,
 -			      int insertions, int deletions);
 +extern void print_stat_summary(FILE *fp, int files,
 +			       int insertions, int deletions);
  extern void setup_diff_pager(struct diff_options *);
  
  #endif /* DIFF_H */
diff --combined revision.c
index d167223e69,7c23ab7afe..99c95c19b0
--- 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;
  
@@@ -62,10 -59,10 +62,10 @@@ static void mark_tree_contents_unintere
  	while (tree_entry(&desc, &entry)) {
  		switch (object_type(entry.mode)) {
  		case OBJ_TREE:
 -			mark_tree_uninteresting(lookup_tree(entry.oid->hash));
 +			mark_tree_uninteresting(lookup_tree(entry.oid));
  			break;
  		case OBJ_BLOB:
 -			mark_blob_uninteresting(lookup_blob(entry.oid->hash));
 +			mark_blob_uninteresting(lookup_blob(entry.oid));
  			break;
  		default:
  			/* Subproject commit - not in this repository */
@@@ -151,14 -148,16 +151,14 @@@ static void add_pending_object_with_pat
  	if (revs->reflog_info && obj->type == OBJ_COMMIT) {
  		struct strbuf buf = STRBUF_INIT;
  		int len = interpret_branch_name(name, 0, &buf, 0);
 -		int st;
  
  		if (0 < len && name[len] && buf.len)
  			strbuf_addstr(&buf, name + len);
 -		st = add_reflog_for_walk(revs->reflog_info,
 -					 (struct commit *)obj,
 -					 buf.buf[0] ? buf.buf: name);
 +		add_reflog_for_walk(revs->reflog_info,
 +				    (struct commit *)obj,
 +				    buf.buf[0] ? buf.buf: name);
  		strbuf_release(&buf);
 -		if (st)
 -			return;
 +		return; /* do not add the commit itself */
  	}
  	add_object_array_with_path(obj, name, &revs->pending, mode, path);
  }
@@@ -178,23 -177,23 +178,23 @@@ void add_pending_object(struct rev_inf
  
  void add_head_to_pending(struct rev_info *revs)
  {
 -	unsigned char sha1[20];
 +	struct object_id oid;
  	struct object *obj;
 -	if (get_sha1("HEAD", sha1))
 +	if (get_oid("HEAD", &oid))
  		return;
 -	obj = parse_object(sha1);
 +	obj = parse_object(&oid);
  	if (!obj)
  		return;
  	add_pending_object(revs, obj, "HEAD");
  }
  
  static struct object *get_reference(struct rev_info *revs, const char *name,
 -				    const unsigned char *sha1,
 +				    const struct object_id *oid,
  				    unsigned int flags)
  {
  	struct object *object;
  
 -	object = parse_object(sha1);
 +	object = parse_object(oid);
  	if (!object) {
  		if (revs->ignore_missing)
  			return object;
@@@ -204,10 -203,10 +204,10 @@@
  	return object;
  }
  
 -void add_pending_sha1(struct rev_info *revs, const char *name,
 -		      const unsigned char *sha1, unsigned int flags)
 +void add_pending_oid(struct rev_info *revs, const char *name,
 +		      const struct object_id *oid, unsigned int flags)
  {
 -	struct object *object = get_reference(revs, name, sha1, flags);
 +	struct object *object = get_reference(revs, name, oid, flags);
  	add_pending_object(revs, object, name);
  }
  
@@@ -229,9 -228,9 +229,9 @@@ static struct commit *handle_commit(str
  			add_pending_object(revs, object, tag->tag);
  		if (!tag->tagged)
  			die("bad tag");
 -		object = parse_object(tag->tagged->oid.hash);
 +		object = parse_object(&tag->tagged->oid);
  		if (!object) {
 -			if (flags & UNINTERESTING)
 +			if (revs->ignore_missing_links || (flags & UNINTERESTING))
  				return NULL;
  			die("bad object %s", oid_to_hex(&tag->tagged->oid));
  		}
@@@ -395,29 -394,38 +395,38 @@@ static struct commit *one_relevant_pare
   * if the whole diff is removal of old data, and otherwise
   * REV_TREE_DIFFERENT (of course if the trees are the same we
   * want REV_TREE_SAME).
-  * That means that once we get to REV_TREE_DIFFERENT, we do not
-  * have to look any further.
+  *
+  * The only time we care about the distinction is when
+  * remove_empty_trees is in effect, in which case we care only about
+  * whether the whole change is REV_TREE_NEW, or if there's another type
+  * of change. Which means we can stop the diff early in either of these
+  * cases:
+  *
+  *   1. We're not using remove_empty_trees at all.
+  *
+  *   2. We saw anything except REV_TREE_NEW.
   */
  static int tree_difference = REV_TREE_SAME;
  
  static void file_add_remove(struct diff_options *options,
  		    int addremove, unsigned mode,
 -		    const unsigned char *sha1,
 -		    int sha1_valid,
 +		    const struct object_id *oid,
 +		    int oid_valid,
  		    const char *fullpath, unsigned dirty_submodule)
  {
  	int diff = addremove == '+' ? REV_TREE_NEW : REV_TREE_OLD;
+ 	struct rev_info *revs = options->change_fn_data;
  
  	tree_difference |= diff;
- 	if (tree_difference == REV_TREE_DIFFERENT)
+ 	if (!revs->remove_empty_trees || tree_difference != REV_TREE_NEW)
  		DIFF_OPT_SET(options, HAS_CHANGES);
  }
  
  static void file_change(struct diff_options *options,
  		 unsigned old_mode, unsigned new_mode,
 -		 const unsigned char *old_sha1,
 -		 const unsigned char *new_sha1,
 -		 int old_sha1_valid, int new_sha1_valid,
 +		 const struct object_id *old_oid,
 +		 const struct object_id *new_oid,
 +		 int old_oid_valid, int new_oid_valid,
  		 const char *fullpath,
  		 unsigned old_dirty_submodule, unsigned new_dirty_submodule)
  {
@@@ -456,7 -464,7 +465,7 @@@ static int rev_compare_tree(struct rev_
  
  	tree_difference = REV_TREE_SAME;
  	DIFF_OPT_CLR(&revs->pruning, HAS_CHANGES);
 -	if (diff_tree_sha1(t1->object.oid.hash, t2->object.oid.hash, "",
 +	if (diff_tree_oid(&t1->object.oid, &t2->object.oid, "",
  			   &revs->pruning) < 0)
  		return REV_TREE_DIFFERENT;
  	return tree_difference;
@@@ -472,7 -480,7 +481,7 @@@ static int rev_same_tree_as_empty(struc
  
  	tree_difference = REV_TREE_SAME;
  	DIFF_OPT_CLR(&revs->pruning, HAS_CHANGES);
 -	retval = diff_tree_sha1(NULL, t1->object.oid.hash, "", &revs->pruning);
 +	retval = diff_tree_oid(NULL, &t1->object.oid, "", &revs->pruning);
  
  	return retval >= 0 && (tree_difference == REV_TREE_SAME);
  }
@@@ -885,7 -893,7 +894,7 @@@ static void cherry_pick_list(struct com
  /* How many extra uninteresting commits we want to see.. */
  #define SLOP 5
  
 -static int still_interesting(struct commit_list *src, unsigned long date, int slop,
 +static int still_interesting(struct commit_list *src, timestamp_t date, int slop,
  			     struct commit **interesting_cache)
  {
  	/*
@@@ -1019,7 -1027,7 +1028,7 @@@ static void limit_left_right(struct com
  static int limit_list(struct rev_info *revs)
  {
  	int slop = SLOP;
 -	unsigned long date = ~0ul;
 +	timestamp_t date = TIME_MAX;
  	struct commit_list *list = revs->commits;
  	struct commit_list *newlist = NULL;
  	struct commit_list **p = &newlist;
@@@ -1106,7 -1114,7 +1115,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 -1142,6 +1143,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)
@@@ -1144,7 -1151,7 +1153,7 @@@
  	if (!ref_excludes)
  		return 0;
  	for_each_string_list_item(item, ref_excludes) {
 -		if (!wildmatch(item->string, path, 0, NULL))
 +		if (!wildmatch(item->string, path, 0))
  			return 1;
  	}
  	return 0;
@@@ -1159,9 -1166,9 +1168,9 @@@ static int handle_one_ref(const char *p
  	if (ref_excluded(cb->all_revs->ref_excludes, path))
  	    return 0;
  
 -	object = get_reference(cb->all_revs, path, oid->hash, cb->all_flags);
 +	object = get_reference(cb->all_revs, path, oid, cb->all_flags);
  	add_rev_cmdline(cb->all_revs, object, path, REV_CMD_REF, cb->all_flags);
 -	add_pending_sha1(cb->all_revs, path, oid->hash, cb->all_flags);
 +	add_pending_oid(cb->all_revs, path, oid, cb->all_flags);
  	return 0;
  }
  
@@@ -1170,8 -1177,6 +1179,8 @@@ 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,26 -1197,19 +1201,26 @@@ 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(unsigned char *sha1, void *cb_data)
 +static void handle_one_reflog_commit(struct object_id *oid, void *cb_data)
  {
  	struct all_refs_cb *cb = cb_data;
 -	if (!is_null_sha1(sha1)) {
 -		struct object *o = parse_object(sha1);
 +	if (!is_null_oid(oid)) {
 +		struct object *o = parse_object(oid);
  		if (o) {
  			o->flags |= cb->all_flags;
  			/* ??? CMDLINEFLAGS ??? */
@@@ -1225,12 -1223,12 +1234,12 @@@
  	}
  }
  
 -static int handle_one_reflog_ent(unsigned char *osha1, unsigned char *nsha1,
 -		const char *email, unsigned long timestamp, int tz,
 +static int handle_one_reflog_ent(struct object_id *ooid, struct object_id *noid,
 +		const char *email, timestamp_t timestamp, int tz,
  		const char *message, void *cb_data)
  {
 -	handle_one_reflog_commit(osha1, cb_data);
 -	handle_one_reflog_commit(nsha1, cb_data);
 +	handle_one_reflog_commit(ooid, cb_data);
 +	handle_one_reflog_commit(noid, cb_data);
  	return 0;
  }
  
@@@ -1240,41 -1238,17 +1249,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,
@@@ -1284,7 -1258,7 +1293,7 @@@
  	int i;
  
  	if (it->entry_count >= 0) {
 -		struct tree *tree = lookup_tree(it->sha1);
 +		struct tree *tree = lookup_tree(&it->oid);
  		add_pending_object_with_path(revs, &tree->object, "",
  					     040000, path->buf);
  	}
@@@ -1298,62 -1272,36 +1307,62 @@@
  
  }
  
 -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))
  			continue;
  
 -		blob = lookup_blob(ce->oid.hash);
 +		blob = lookup_blob(&ce->oid);
  		if (!blob)
  			die("unable to add index blob to traversal");
  		add_pending_object_with_path(revs, &blob->object, "",
  					     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)
  {
 -	unsigned char sha1[20];
 +	struct object_id oid;
  	struct object *it;
  	struct commit *commit;
  	struct commit_list *parents;
@@@ -1364,17 -1312,17 +1373,17 @@@
  		flags ^= UNINTERESTING | BOTTOM;
  		arg++;
  	}
 -	if (get_sha1_committish(arg, sha1))
 +	if (get_oid_committish(arg, &oid))
  		return 0;
  	while (1) {
 -		it = get_reference(revs, arg, sha1, 0);
 +		it = get_reference(revs, arg, &oid, 0);
  		if (!it && revs->ignore_missing)
  			return 0;
  		if (it->type != OBJ_TAG)
  			break;
  		if (!((struct tag*)it)->tagged)
  			return 0;
 -		hashcpy(sha1, ((struct tag*)it)->tagged->oid.hash);
 +		oidcpy(&oid, &((struct tag*)it)->tagged->oid);
  	}
  	if (it->type != OBJ_COMMIT)
  		return 0;
@@@ -1407,6 -1355,7 +1416,7 @@@ void init_revisions(struct rev_info *re
  	DIFF_OPT_SET(&revs->pruning, QUICK);
  	revs->pruning.add_remove = file_add_remove;
  	revs->pruning.change = file_change;
+ 	revs->pruning.change_fn_data = revs;
  	revs->sort_order = REV_SORT_IN_GRAPH_ORDER;
  	revs->dense = 1;
  	revs->prefix = prefix;
@@@ -1423,6 -1372,7 +1433,6 @@@
  	init_grep_defaults();
  	grep_init(&revs->grep_filter, prefix);
  	revs->grep_filter.status_only = 1;
 -	revs->grep_filter.regflags = REG_NEWLINE;
  
  	diff_setup(&revs->diffopt);
  	if (prefix && !revs->diffopt.prefix) {
@@@ -1449,16 -1399,16 +1459,16 @@@ static void prepare_show_merge(struct r
  {
  	struct commit_list *bases;
  	struct commit *head, *other;
 -	unsigned char sha1[20];
 +	struct object_id oid;
  	const char **prune = NULL;
  	int i, prune_num = 1; /* counting terminating NULL */
  
 -	if (get_sha1("HEAD", sha1))
 +	if (get_oid("HEAD", &oid))
  		die("--merge without HEAD?");
 -	head = lookup_commit_or_die(sha1, "HEAD");
 -	if (get_sha1("MERGE_HEAD", sha1))
 +	head = lookup_commit_or_die(&oid, "HEAD");
 +	if (get_oid("MERGE_HEAD", &oid))
  		die("--merge without MERGE_HEAD?");
 -	other = lookup_commit_or_die(sha1, "MERGE_HEAD");
 +	other = lookup_commit_or_die(&oid, "MERGE_HEAD");
  	add_pending_object(revs, &head->object, "HEAD");
  	add_pending_object(revs, &other->object, "MERGE_HEAD");
  	bases = get_merge_bases(head, other);
@@@ -1489,168 -1439,134 +1499,168 @@@
  	revs->limited = 1;
  }
  
 +static int dotdot_missing(const char *arg, char *dotdot,
 +			  struct rev_info *revs, int symmetric)
 +{
 +	if (revs->ignore_missing)
 +		return 0;
 +	/* de-munge so we report the full argument */
 +	*dotdot = '.';
 +	die(symmetric
 +	    ? "Invalid symmetric difference expression %s"
 +	    : "Invalid revision range %s", arg);
 +}
 +
 +static int handle_dotdot_1(const char *arg, char *dotdot,
 +			   struct rev_info *revs, int flags,
 +			   int cant_be_filename,
 +			   struct object_context *a_oc,
 +			   struct object_context *b_oc)
 +{
 +	const char *a_name, *b_name;
 +	struct object_id a_oid, b_oid;
 +	struct object *a_obj, *b_obj;
 +	unsigned int a_flags, b_flags;
 +	int symmetric = 0;
 +	unsigned int flags_exclude = flags ^ (UNINTERESTING | BOTTOM);
 +	unsigned int oc_flags = GET_OID_COMMITTISH | GET_OID_RECORD_PATH;
 +
 +	a_name = arg;
 +	if (!*a_name)
 +		a_name = "HEAD";
 +
 +	b_name = dotdot + 2;
 +	if (*b_name == '.') {
 +		symmetric = 1;
 +		b_name++;
 +	}
 +	if (!*b_name)
 +		b_name = "HEAD";
 +
 +	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) {
 +		*dotdot = '.';
 +		verify_non_filename(revs->prefix, arg);
 +		*dotdot = '\0';
 +	}
 +
 +	a_obj = parse_object(&a_oid);
 +	b_obj = parse_object(&b_oid);
 +	if (!a_obj || !b_obj)
 +		return dotdot_missing(arg, dotdot, revs, symmetric);
 +
 +	if (!symmetric) {
 +		/* just A..B */
 +		b_flags = flags;
 +		a_flags = flags_exclude;
 +	} else {
 +		/* A...B -- find merge bases between the two */
 +		struct commit *a, *b;
 +		struct commit_list *exclude;
 +
 +		a = lookup_commit_reference(&a_obj->oid);
 +		b = lookup_commit_reference(&b_obj->oid);
 +		if (!a || !b)
 +			return dotdot_missing(arg, dotdot, revs, symmetric);
 +
 +		exclude = get_merge_bases(a, b);
 +		add_rev_cmdline_list(revs, exclude, REV_CMD_MERGE_BASE,
 +				     flags_exclude);
 +		add_pending_commit_list(revs, exclude, flags_exclude);
 +		free_commit_list(exclude);
 +
 +		b_flags = flags;
 +		a_flags = flags | SYMMETRIC_LEFT;
 +	}
 +
 +	a_obj->flags |= a_flags;
 +	b_obj->flags |= b_flags;
 +	add_rev_cmdline(revs, a_obj, a_name, REV_CMD_LEFT, a_flags);
 +	add_rev_cmdline(revs, b_obj, b_name, REV_CMD_RIGHT, b_flags);
 +	add_pending_object_with_path(revs, a_obj, a_name, a_oc->mode, a_oc->path);
 +	add_pending_object_with_path(revs, b_obj, b_name, b_oc->mode, b_oc->path);
 +	return 0;
 +}
 +
 +static int handle_dotdot(const char *arg,
 +			 struct rev_info *revs, int flags,
 +			 int cant_be_filename)
 +{
 +	struct object_context a_oc, b_oc;
 +	char *dotdot = strstr(arg, "..");
 +	int ret;
 +
 +	if (!dotdot)
 +		return -1;
 +
 +	memset(&a_oc, 0, sizeof(a_oc));
 +	memset(&b_oc, 0, sizeof(b_oc));
 +
 +	*dotdot = '\0';
 +	ret = handle_dotdot_1(arg, dotdot, revs, flags, cant_be_filename,
 +			      &a_oc, &b_oc);
 +	*dotdot = '.';
 +
 +	free(a_oc.path);
 +	free(b_oc.path);
 +
 +	return ret;
 +}
 +
  int handle_revision_arg(const char *arg_, struct rev_info *revs, int flags, unsigned revarg_opt)
  {
  	struct object_context oc;
 -	char *dotdot;
 +	char *mark;
  	struct object *object;
 -	unsigned char sha1[20];
 +	struct object_id oid;
  	int local_flags;
  	const char *arg = arg_;
  	int cant_be_filename = revarg_opt & REVARG_CANNOT_BE_FILENAME;
 -	unsigned get_sha1_flags = 0;
 +	unsigned get_sha1_flags = GET_OID_RECORD_PATH;
  
  	flags = flags & UNINTERESTING ? flags | BOTTOM : flags & ~BOTTOM;
  
 -	dotdot = strstr(arg, "..");
 -	if (dotdot) {
 -		unsigned char from_sha1[20];
 -		const char *next = dotdot + 2;
 -		const char *this = arg;
 -		int symmetric = *next == '.';
 -		unsigned int flags_exclude = flags ^ (UNINTERESTING | BOTTOM);
 -		static const char head_by_default[] = "HEAD";
 -		unsigned int a_flags;
 -
 -		*dotdot = 0;
 -		next += symmetric;
 -
 -		if (!*next)
 -			next = head_by_default;
 -		if (dotdot == arg)
 -			this = head_by_default;
 -		if (this == head_by_default && next == head_by_default &&
 -		    !symmetric) {
 -			/*
 -			 * Just ".."?  That is not a range but the
 -			 * pathspec for the parent directory.
 -			 */
 -			if (!cant_be_filename) {
 -				*dotdot = '.';
 -				return -1;
 -			}
 -		}
 -		if (!get_sha1_committish(this, from_sha1) &&
 -		    !get_sha1_committish(next, sha1)) {
 -			struct object *a_obj, *b_obj;
 -
 -			if (!cant_be_filename) {
 -				*dotdot = '.';
 -				verify_non_filename(revs->prefix, arg);
 -			}
 -
 -			a_obj = parse_object(from_sha1);
 -			b_obj = parse_object(sha1);
 -			if (!a_obj || !b_obj) {
 -			missing:
 -				if (revs->ignore_missing)
 -					return 0;
 -				die(symmetric
 -				    ? "Invalid symmetric difference expression %s"
 -				    : "Invalid revision range %s", arg);
 -			}
 -
 -			if (!symmetric) {
 -				/* just A..B */
 -				a_flags = flags_exclude;
 -			} else {
 -				/* A...B -- find merge bases between the two */
 -				struct commit *a, *b;
 -				struct commit_list *exclude;
 -
 -				a = (a_obj->type == OBJ_COMMIT
 -				     ? (struct commit *)a_obj
 -				     : lookup_commit_reference(a_obj->oid.hash));
 -				b = (b_obj->type == OBJ_COMMIT
 -				     ? (struct commit *)b_obj
 -				     : lookup_commit_reference(b_obj->oid.hash));
 -				if (!a || !b)
 -					goto missing;
 -				exclude = get_merge_bases(a, b);
 -				add_rev_cmdline_list(revs, exclude,
 -						     REV_CMD_MERGE_BASE,
 -						     flags_exclude);
 -				add_pending_commit_list(revs, exclude,
 -							flags_exclude);
 -				free_commit_list(exclude);
 -
 -				a_flags = flags | SYMMETRIC_LEFT;
 -			}
 -
 -			a_obj->flags |= a_flags;
 -			b_obj->flags |= flags;
 -			add_rev_cmdline(revs, a_obj, this,
 -					REV_CMD_LEFT, a_flags);
 -			add_rev_cmdline(revs, b_obj, next,
 -					REV_CMD_RIGHT, flags);
 -			add_pending_object(revs, a_obj, this);
 -			add_pending_object(revs, b_obj, next);
 -			return 0;
 -		}
 -		*dotdot = '.';
 +	if (!cant_be_filename && !strcmp(arg, "..")) {
 +		/*
 +		 * Just ".."?  That is not a range but the
 +		 * pathspec for the parent directory.
 +		 */
 +		return -1;
  	}
  
 -	dotdot = strstr(arg, "^@");
 -	if (dotdot && !dotdot[2]) {
 -		*dotdot = 0;
 +	if (!handle_dotdot(arg, revs, flags, revarg_opt))
 +		return 0;
 +
 +	mark = strstr(arg, "^@");
 +	if (mark && !mark[2]) {
 +		*mark = 0;
  		if (add_parents_only(revs, arg, flags, 0))
  			return 0;
 -		*dotdot = '^';
 +		*mark = '^';
  	}
 -	dotdot = strstr(arg, "^!");
 -	if (dotdot && !dotdot[2]) {
 -		*dotdot = 0;
 +	mark = strstr(arg, "^!");
 +	if (mark && !mark[2]) {
 +		*mark = 0;
  		if (!add_parents_only(revs, arg, flags ^ (UNINTERESTING | BOTTOM), 0))
 -			*dotdot = '^';
 +			*mark = '^';
  	}
 -	dotdot = strstr(arg, "^-");
 -	if (dotdot) {
 +	mark = strstr(arg, "^-");
 +	if (mark) {
  		int exclude_parent = 1;
  
 -		if (dotdot[2]) {
 +		if (mark[2]) {
  			char *end;
 -			exclude_parent = strtoul(dotdot + 2, &end, 10);
 +			exclude_parent = strtoul(mark + 2, &end, 10);
  			if (*end != '\0' || !exclude_parent)
  				return -1;
  		}
  
 -		*dotdot = 0;
 +		*mark = 0;
  		if (!add_parents_only(revs, arg, flags ^ (UNINTERESTING | BOTTOM), exclude_parent))
 -			*dotdot = '^';
 +			*mark = '^';
  	}
  
  	local_flags = 0;
@@@ -1660,28 -1576,43 +1670,28 @@@
  	}
  
  	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, sha1, &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);
 -	object = get_reference(revs, arg, sha1, flags ^ local_flags);
 +	object = get_reference(revs, arg, &oid, flags ^ local_flags);
  	add_rev_cmdline(revs, object, arg_, REV_CMD_REV, flags ^ local_flags);
 -	add_pending_object_with_mode(revs, object, arg, oc.mode);
 +	add_pending_object_with_path(revs, object, arg, oc.mode, oc.path);
 +	free(oc.path);
  	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;
@@@ -1769,8 -1700,8 +1779,8 @@@ static int handle_revision_opt(struct r
  		revs->max_count = atoi(argv[1]);
  		revs->no_walk = 0;
  		return 2;
 -	} else if (starts_with(arg, "-n")) {
 -		revs->max_count = atoi(arg + 2);
 +	} else if (skip_prefix(arg, "-n", &optarg)) {
 +		revs->max_count = atoi(optarg);
  		revs->no_walk = 0;
  	} else if ((argcount = parse_long_opt("max-age", argv, &optarg))) {
  		revs->max_age = atoi(optarg);
@@@ -1829,13 -1760,16 +1839,13 @@@
  	} else if (!strcmp(arg, "--author-date-order")) {
  		revs->sort_order = REV_SORT_BY_AUTHOR_DATE;
  		revs->topo_order = 1;
 -	} else if (starts_with(arg, "--early-output")) {
 -		int count = 100;
 -		switch (arg[14]) {
 -		case '=':
 -			count = atoi(arg+15);
 -			/* Fallthrough */
 -		case 0:
 -			revs->topo_order = 1;
 -		       revs->early_output = count;
 -		}
 +	} else if (!strcmp(arg, "--early-output")) {
 +		revs->early_output = 100;
 +		revs->topo_order = 1;
 +	} else if (skip_prefix(arg, "--early-output=", &optarg)) {
 +		if (strtoul_ui(optarg, 10, &revs->early_output) < 0)
 +			die("'%s': not a non-negative integer", optarg);
 +		revs->topo_order = 1;
  	} else if (!strcmp(arg, "--parents")) {
  		revs->rewrite_parents = 1;
  		revs->print_parents = 1;
@@@ -1851,13 -1785,13 +1861,13 @@@
  		revs->min_parents = 2;
  	} else if (!strcmp(arg, "--no-merges")) {
  		revs->max_parents = 1;
 -	} else if (starts_with(arg, "--min-parents=")) {
 -		revs->min_parents = atoi(arg+14);
 -	} else if (starts_with(arg, "--no-min-parents")) {
 +	} else if (skip_prefix(arg, "--min-parents=", &optarg)) {
 +		revs->min_parents = atoi(optarg);
 +	} else if (!strcmp(arg, "--no-min-parents")) {
  		revs->min_parents = 0;
 -	} else if (starts_with(arg, "--max-parents=")) {
 -		revs->max_parents = atoi(arg+14);
 -	} else if (starts_with(arg, "--no-max-parents")) {
 +	} else if (skip_prefix(arg, "--max-parents=", &optarg)) {
 +		revs->max_parents = atoi(optarg);
 +	} else if (!strcmp(arg, "--no-max-parents")) {
  		revs->max_parents = -1;
  	} else if (!strcmp(arg, "--boundary")) {
  		revs->boundary = 1;
@@@ -1938,15 -1872,14 +1948,15 @@@
  		revs->verbose_header = 1;
  		revs->pretty_given = 1;
  		get_commit_format(NULL, revs);
 -	} else if (starts_with(arg, "--pretty=") || starts_with(arg, "--format=")) {
 +	} else if (skip_prefix(arg, "--pretty=", &optarg) ||
 +		   skip_prefix(arg, "--format=", &optarg)) {
  		/*
  		 * Detached form ("--pretty X" as opposed to "--pretty=X")
  		 * not allowed, since the argument is optional.
  		 */
  		revs->verbose_header = 1;
  		revs->pretty_given = 1;
 -		get_commit_format(arg+9, revs);
 +		get_commit_format(optarg, revs);
  	} else if (!strcmp(arg, "--expand-tabs")) {
  		revs->expand_tabs_in_log = 8;
  	} else if (!strcmp(arg, "--no-expand-tabs")) {
@@@ -1964,23 -1897,26 +1974,23 @@@
  		revs->show_signature = 1;
  	} else if (!strcmp(arg, "--no-show-signature")) {
  		revs->show_signature = 0;
 -	} else if (!strcmp(arg, "--show-linear-break") ||
 -		   starts_with(arg, "--show-linear-break=")) {
 -		if (starts_with(arg, "--show-linear-break="))
 -			revs->break_bar = xstrdup(arg + 20);
 -		else
 -			revs->break_bar = "                    ..........";
 +	} else if (!strcmp(arg, "--show-linear-break")) {
 +		revs->break_bar = "                    ..........";
 +		revs->track_linear = 1;
 +		revs->track_first_time = 1;
 +	} else if (skip_prefix(arg, "--show-linear-break=", &optarg)) {
 +		revs->break_bar = xstrdup(optarg);
  		revs->track_linear = 1;
  		revs->track_first_time = 1;
 -	} else if (starts_with(arg, "--show-notes=") ||
 -		   starts_with(arg, "--notes=")) {
 +	} else if (skip_prefix(arg, "--show-notes=", &optarg) ||
 +		   skip_prefix(arg, "--notes=", &optarg)) {
  		struct strbuf buf = STRBUF_INIT;
  		revs->show_notes = 1;
  		revs->show_notes_given = 1;
 -		if (starts_with(arg, "--show-notes")) {
 -			if (revs->notes_opt.use_default_notes < 0)
 -				revs->notes_opt.use_default_notes = 1;
 -			strbuf_addstr(&buf, arg+13);
 -		}
 -		else
 -			strbuf_addstr(&buf, arg+8);
 +		if (starts_with(arg, "--show-notes=") &&
 +		    revs->notes_opt.use_default_notes < 0)
 +			revs->notes_opt.use_default_notes = 1;
 +		strbuf_addstr(&buf, optarg);
  		expand_notes_ref(&buf);
  		string_list_append(&revs->notes_opt.extra_notes_refs,
  				   strbuf_detach(&buf, NULL));
@@@ -2017,8 -1953,8 +2027,8 @@@
  		revs->abbrev = 0;
  	} else if (!strcmp(arg, "--abbrev")) {
  		revs->abbrev = DEFAULT_ABBREV;
 -	} else if (starts_with(arg, "--abbrev=")) {
 -		revs->abbrev = strtoul(arg + 9, NULL, 10);
 +	} else if (skip_prefix(arg, "--abbrev=", &optarg)) {
 +		revs->abbrev = strtoul(optarg, NULL, 10);
  		if (revs->abbrev < MINIMUM_ABBREV)
  			revs->abbrev = MINIMUM_ABBREV;
  		else if (revs->abbrev > 40)
@@@ -2065,11 -2001,11 +2075,11 @@@
  	} else if (!strcmp(arg, "--extended-regexp") || !strcmp(arg, "-E")) {
  		revs->grep_filter.pattern_type_option = GREP_PATTERN_TYPE_ERE;
  	} else if (!strcmp(arg, "--regexp-ignore-case") || !strcmp(arg, "-i")) {
 -		revs->grep_filter.regflags |= REG_ICASE;
 +		revs->grep_filter.ignore_case = 1;
  		DIFF_OPT_SET(&revs->diffopt, PICKAXE_IGNORE_CASE);
  	} else if (!strcmp(arg, "--fixed-strings") || !strcmp(arg, "-F")) {
  		revs->grep_filter.pattern_type_option = GREP_PATTERN_TYPE_FIXED;
 -	} else if (!strcmp(arg, "--perl-regexp")) {
 +	} else if (!strcmp(arg, "--perl-regexp") || !strcmp(arg, "-P")) {
  		revs->grep_filter.pattern_type_option = GREP_PATTERN_TYPE_PCRE;
  	} else if (!strcmp(arg, "--all-match")) {
  		revs->grep_filter.all_match = 1;
@@@ -2114,25 -2050,23 +2124,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_ref_in_submodule(submodule, bisect_refs.buf, fn, cb_data);
 +	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 -2075,8 +2151,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 -2088,22 +2178,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;
@@@ -2201,20 -2114,20 +2211,20 @@@
  	} else if ((argcount = parse_long_opt("exclude", argv, &optarg))) {
  		add_ref_exclusion(&revs->ref_excludes, optarg);
  		return argcount;
 -	} else if (starts_with(arg, "--branches=")) {
 +	} else if (skip_prefix(arg, "--branches=", &optarg)) {
  		struct all_refs_cb cb;
  		init_all_refs_cb(&cb, revs, *flags);
 -		for_each_glob_ref_in(handle_one_ref, arg + 11, "refs/heads/", &cb);
 +		for_each_glob_ref_in(handle_one_ref, optarg, "refs/heads/", &cb);
  		clear_ref_exclusion(&revs->ref_excludes);
 -	} else if (starts_with(arg, "--tags=")) {
 +	} else if (skip_prefix(arg, "--tags=", &optarg)) {
  		struct all_refs_cb cb;
  		init_all_refs_cb(&cb, revs, *flags);
 -		for_each_glob_ref_in(handle_one_ref, arg + 7, "refs/tags/", &cb);
 +		for_each_glob_ref_in(handle_one_ref, optarg, "refs/tags/", &cb);
  		clear_ref_exclusion(&revs->ref_excludes);
 -	} else if (starts_with(arg, "--remotes=")) {
 +	} else if (skip_prefix(arg, "--remotes=", &optarg)) {
  		struct all_refs_cb cb;
  		init_all_refs_cb(&cb, revs, *flags);
 -		for_each_glob_ref_in(handle_one_ref, arg + 10, "refs/remotes/", &cb);
 +		for_each_glob_ref_in(handle_one_ref, optarg, "refs/remotes/", &cb);
  		clear_ref_exclusion(&revs->ref_excludes);
  	} else if (!strcmp(arg, "--reflog")) {
  		add_reflogs_to_pending(revs, *flags);
@@@ -2224,21 -2137,19 +2234,21 @@@
  		*flags ^= UNINTERESTING | BOTTOM;
  	} else if (!strcmp(arg, "--no-walk")) {
  		revs->no_walk = REVISION_WALK_NO_WALK_SORTED;
 -	} else if (starts_with(arg, "--no-walk=")) {
 +	} else if (skip_prefix(arg, "--no-walk=", &optarg)) {
  		/*
  		 * Detached form ("--no-walk X" as opposed to "--no-walk=X")
  		 * not allowed, since the argument is optional.
  		 */
 -		if (!strcmp(arg + 10, "sorted"))
 +		if (!strcmp(optarg, "sorted"))
  			revs->no_walk = REVISION_WALK_NO_WALK_SORTED;
 -		else if (!strcmp(arg + 10, "unsorted"))
 +		else if (!strcmp(optarg, "unsorted"))
  			revs->no_walk = REVISION_WALK_NO_WALK_UNSORTED;
  		else
  			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 -2159,11 +2258,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 -2182,10 +2280,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 -2201,7 +2298,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 -2262,14 +2359,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 -2284,11 +2381,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;
@@@ -2382,13 -2296,13 +2392,13 @@@
  		opt->tweak(revs, opt);
  	if (revs->show_merge)
  		prepare_show_merge(revs);
 -	if (revs->def && !revs->pending.nr && !got_rev_arg) {
 -		unsigned char sha1[20];
 +	if (revs->def && !revs->pending.nr && !revs->rev_input_given && !got_rev_arg) {
 +		struct object_id oid;
  		struct object *object;
  		struct object_context oc;
 -		if (get_sha1_with_context(revs->def, 0, sha1, &oc))
 +		if (get_oid_with_context(revs->def, 0, &oid, &oc))
  			diagnose_missing_default(revs->def);
 -		object = get_reference(revs, revs->def, sha1, 0);
 +		object = get_reference(revs, revs->def, &oid, 0);
  		add_pending_object_with_mode(revs, object, revs->def, oc.mode);
  	}
  
@@@ -2431,8 -2345,6 +2441,8 @@@
  
  	if (revs->reverse && revs->reflog_info)
  		die("cannot combine --reverse with --walk-reflogs");
 +	if (revs->reflog_info && revs->limited)
 +		die("cannot combine --walk-reflogs with history-limiting options");
  	if (revs->rewrite_parents && revs->children.name)
  		die("cannot combine --parents and --children");
  
@@@ -3006,7 -2918,7 +3016,7 @@@ static int commit_match(struct commit *
  	if (opt->show_notes) {
  		if (!buf.len)
  			strbuf_addstr(&buf, message);
 -		format_display_notes(commit->object.oid.hash, &buf, encoding, 1);
 +		format_display_notes(&commit->object.oid, &buf, encoding, 1);
  	}
  
  	/*
@@@ -3032,18 -2944,6 +3042,18 @@@ static inline int want_ancestry(const s
  	return (revs->rewrite_parents || revs->children.name);
  }
  
 +/*
 + * Return a timestamp to be used for --since/--until comparisons for this
 + * commit, based on the revision options.
 + */
 +static timestamp_t comparison_date(const struct rev_info *revs,
 +				   struct commit *commit)
 +{
 +	return revs->reflog_info ?
 +		get_reflog_timestamp(revs->reflog_info) :
 +		commit->date;
 +}
 +
  enum commit_action get_commit_action(struct rev_info *revs, struct commit *commit)
  {
  	if (commit->object.flags & SHOWN)
@@@ -3054,9 -2954,8 +3064,9 @@@
  		return commit_show;
  	if (commit->object.flags & UNINTERESTING)
  		return commit_ignore;
 -	if (revs->min_age != -1 && (commit->date > revs->min_age))
 -		return commit_ignore;
 +	if (revs->min_age != -1 &&
 +	    comparison_date(revs, commit) > revs->min_age)
 +			return commit_ignore;
  	if (revs->min_parents || (revs->max_parents >= 0)) {
  		int n = commit_list_count(commit->parents);
  		if ((n < revs->min_parents) ||
@@@ -3189,19 -3088,17 +3199,19 @@@ static void track_linear(struct rev_inf
  
  static struct commit *get_revision_1(struct rev_info *revs)
  {
 -	if (!revs->commits)
 -		return NULL;
 +	while (1) {
 +		struct commit *commit;
  
 -	do {
 -		struct commit *commit = pop_commit(&revs->commits);
 +		if (revs->reflog_info)
 +			commit = next_reflog_entry(revs->reflog_info);
 +		else
 +			commit = pop_commit(&revs->commits);
  
 -		if (revs->reflog_info) {
 -			save_parents(revs, commit);
 -			fake_reflog_parent(revs->reflog_info, commit);
 +		if (!commit)
 +			return NULL;
 +
 +		if (revs->reflog_info)
  			commit->object.flags &= ~(ADDED | SEEN | SHOWN);
 -		}
  
  		/*
  		 * If we haven't done the list limiting, we need to look at
@@@ -3210,12 -3107,9 +3220,12 @@@
  		 */
  		if (!revs->limited) {
  			if (revs->max_age != -1 &&
 -			    (commit->date < revs->max_age))
 +			    comparison_date(revs, commit) < revs->max_age)
  				continue;
 -			if (add_parents_to_list(revs, commit, &revs->commits, NULL) < 0) {
 +
 +			if (revs->reflog_info)
 +				try_to_simplify_commit(revs, commit);
 +			else if (add_parents_to_list(revs, commit, &revs->commits, NULL) < 0) {
  				if (!revs->ignore_missing_links)
  					die("Failed to traverse parents of commit %s",
  						oid_to_hex(&commit->object.oid));
@@@ -3233,7 -3127,8 +3243,7 @@@
  				track_linear(revs, commit);
  			return commit;
  		}
 -	} while (revs->commits);
 -	return NULL;
 +	}
  }
  
  /*