#include "git-compat-util.h"

#include "config.h"

#include "environment.h"

#include "bisect.h"

#include "packfile.h"

#include "worktree.h"

#include "read-cache.h"

#include "setup.h"

#include "sparse-index.h"

return tree_difference;

}

{

struct tree *t1 = repo_get_commit_tree(the_repository, commit);

if (!t1)

return 0;

tree_difference = REV_TREE_SAME;

revs->pruning.flags.has_changes = 0;

diff_tree_oid(NULL, &t1->object.oid, "", &revs->pruning);

return tree_difference == REV_TREE_SAME;

}

if (nth_parent != 0)

die("compact_treesame %u", nth_parent);

old_same = !!(commit->object.flags & TREESAME);

commit->object.flags |= TREESAME;

else

commit->object.flags &= ~TREESAME;

return;

if (!commit->parents) {

commit->object.flags |= TREESAME;

return;

}

case REV_TREE_NEW:

if (revs->remove_empty_trees &&

/* We are adding all the specified

* paths from this parent, so the

* history beyond this parent is not

cb.all_revs = revs;

cb.all_flags = flags;

cb.wt = NULL;

if (!revs->single_worktree)

add_other_reflogs_to_pending(&cb);

};

for (i = 0; i < ARRAY_SIZE(other_head); i++)

if (is_null_oid(oid))

die(_("%s exists but is a symbolic ref"), other_head[i]);

return other_head[i];

struct rev_info *revs, int flags,

int cant_be_filename)

{

char *dotdot = strstr(arg, "..");

int ret;

if (!dotdot)

return -1;

*dotdot = '\0';

ret = handle_dotdot_1(arg, dotdot, revs, flags, cant_be_filename,

&a_oc, &b_oc);

*dotdot = '.';

return ret;

}

static int handle_revision_arg_1(const char *arg_, struct rev_info *revs, int flags, unsigned revarg_opt)

{

char *mark;

struct object *object;

struct object_id oid;

const char *arg = arg_;

int cant_be_filename = revarg_opt & REVARG_CANNOT_BE_FILENAME;

unsigned get_sha1_flags = GET_OID_RECORD_PATH;

flags = flags & UNINTERESTING ? flags | BOTTOM : flags & ~BOTTOM;

* Just ".."? That is not a range but the

* pathspec for the parent directory.

*/

}

mark = strstr(arg, "^@");

if (mark && !mark[2]) {

*mark = 0;

*mark = '^';

}

mark = strstr(arg, "^!");

if (mark[2]) {

if (strtol_i(mark + 2, 10, &exclude_parent) ||

}

*mark = 0;

* should error out if we can't even get an oid, as

* `--missing=print` should be able to report missing oids.

*/

if (!cant_be_filename)

verify_non_filename(revs->prefix, arg);

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_path(revs, object, arg, oc.mode, oc.path);

}

int handle_revision_arg(const char *arg, struct rev_info *revs, int flags, unsigned revarg_opt)

} else if (!strcmp(arg, "--invert-grep")) {

revs->grep_filter.no_body_match = 1;

} else if ((argcount = parse_long_opt("encoding", argv, &optarg))) {

if (strcmp(optarg, "none"))

git_log_output_encoding = xstrdup(optarg);

else

return argcount;

} else if (!strcmp(arg, "--reverse")) {

revs->reverse ^= 1;

} else if ((argcount = parse_long_opt("glob", argv, &optarg))) {

struct all_refs_cb cb;

init_all_refs_cb(&cb, revs, *flags);

clear_ref_exclusions(&revs->ref_excludes);

return argcount;

} else if ((argcount = parse_long_opt("exclude", argv, &optarg))) {

return error(_("options '%s' and '%s' cannot be used together"),

"--exclude-hidden", "--branches");

init_all_refs_cb(&cb, revs, *flags);

clear_ref_exclusions(&revs->ref_excludes);

} else if (skip_prefix(arg, "--tags=", &optarg)) {

struct all_refs_cb cb;

return error(_("options '%s' and '%s' cannot be used together"),

"--exclude-hidden", "--tags");

init_all_refs_cb(&cb, revs, *flags);

clear_ref_exclusions(&revs->ref_excludes);

} else if (skip_prefix(arg, "--remotes=", &optarg)) {

struct all_refs_cb cb;

return error(_("options '%s' and '%s' cannot be used together"),

"--exclude-hidden", "--remotes");

init_all_refs_cb(&cb, revs, *flags);

clear_ref_exclusions(&revs->ref_excludes);

} else if (!strcmp(arg, "--reflog")) {

add_reflogs_to_pending(revs, *flags);

int flags;

const char *refname;

if (!refname || !(flags & REF_ISSYMREF) || (flags & REF_ISBROKEN))

die(_("your current branch appears to be broken"));

diagnose_missing_default(revs->def);

object = get_reference(revs, revs->def, &oid, 0);

add_pending_object_with_mode(revs, object, revs->def, oc.mode);

}

/* Did the user ask for any diff output? Run the diff! */

{

free_commit_list(revs->commits);

free_commit_list(revs->ancestry_path_bottoms);

object_array_clear(&revs->pending);

object_array_clear(&revs->boundary_commits);

release_revisions_cmdline(&revs->cmdline);

release_revisions_mailmap(revs->mailmap);

free_grep_patterns(&revs->grep_filter);

graph_clear(revs->graph);

diff_free(&revs->pruning);

reflog_walk_info_release(revs->reflog_info);

release_revisions_topo_walk_info(revs->topo_walk_info);

reversed = NULL;

while ((c = get_revision_internal(revs)))

commit_list_insert(c, &reversed);

revs->commits = reversed;

revs->reverse = 0;

revs->reverse_output_stage = 1;