#include "cache.h"

#include "tag.h"

#include "blob.h"

#include "tree.h"

#include "diff.h"

#include "refs.h"

#include "revision.h"

#include "graph.h"

#include "grep.h"

#include "reflog-walk.h"

#include "packfile.h"

#include "worktree.h"

#include "argv-array.h"

volatile show_early_output_fn_t show_early_output;

static const char *term_bad;

static const char *term_good;

void show_object_with_name(FILE *out, struct object *obj, const char *name)

{

const char *p;

blob->object.flags |= UNINTERESTING;

}

{

struct tree_desc desc;

struct name_entry entry;

return;

init_tree_desc(&desc, tree->buffer, tree->size);

while (tree_entry(&desc, &entry)) {

switch (object_type(entry.mode)) {

case OBJ_TREE:

break;

case OBJ_BLOB:

break;

default:

/* Subproject commit - not in this repository */

free_tree_buffer(tree);

}

{

struct object *obj;

if (obj->flags & UNINTERESTING)

return;

obj->flags |= UNINTERESTING;

}

{

}

static void add_pending_object_with_path(struct rev_info *revs,

struct object *obj;

if (get_oid("HEAD", &oid))

return;

if (!obj)

return;

add_pending_object(revs, obj, "HEAD");

{

struct object *object;

if (!object) {

if (revs->ignore_missing)

return object;

add_pending_object(revs, object, tag->tag);

if (!tag->tagged)

die("bad tag");

if (!object) {

if (revs->ignore_missing_links || (flags & UNINTERESTING))

return NULL;

die("bad object %s", oid_to_hex(&tag->tagged->oid));

}

object->flags |= flags;

*/

if (object->type == OBJ_COMMIT) {

struct commit *commit = (struct commit *)object;

if (parse_commit(commit) < 0)

die("unable to parse commit %s", name);

if (flags & UNINTERESTING) {

mark_parents_uninteresting(commit);

revs->limited = 1;

}

return commit;

}

if (!revs->tree_objects)

return NULL;

if (flags & UNINTERESTING) {

return NULL;

}

add_pending_object_with_path(revs, object, name, mode, path);

static int rev_compare_tree(struct rev_info *revs,

struct commit *parent, struct commit *commit)

{

if (!t1)

return REV_TREE_NEW;

static int rev_same_tree_as_empty(struct rev_info *revs, struct commit *commit)

{

int retval;

if (!t1)

return 0;

if (!revs->prune)

return;

return;

if (!commit->parents) {

}

return -1;

}

p->object.flags |= left_flag;

if (!(p->object.flags & SEEN)) {

p->object.flags |= SEEN;

return;

left_first = left_count < right_count;

ids.diffopts.pathspec = revs->diffopt.pathspec;

/* Compute patch-ids for one side */

{

struct all_refs_cb *cb = cb_data;

if (!is_null_oid(oid)) {

if (o) {

o->flags |= cb->all_flags;

/* ??? CMDLINEFLAGS ??? */

cb.all_revs = revs;

cb.all_flags = flags;

for_each_reflog(handle_one_reflog, &cb);

if (!revs->single_worktree)

int i;

if (it->entry_count >= 0) {

add_pending_object_with_path(revs, &tree->object, "",

040000, path->buf);

}

if (S_ISGITLINK(ce->ce_mode))

continue;

if (!blob)

die("unable to add index blob to traversal");

add_pending_object_with_path(revs, &blob->object, "",

{

struct worktree **worktrees, **p;

if (revs->single_worktree)

return;

return 1;

}

{

memset(revs, 0, sizeof(*revs));

revs->abbrev = DEFAULT_ABBREV;

revs->ignore_merges = 1;

revs->simplify_history = 1;

revs->commit_format = CMIT_FMT_DEFAULT;

revs->expand_tabs_in_log_default = 8;

revs->grep_filter.status_only = 1;

if (prefix && !revs->diffopt.prefix) {

revs->diffopt.prefix = prefix;

revs->diffopt.prefix_length = strlen(prefix);

struct object_id oid;

const char **prune = NULL;

int i, prune_num = 1; /* counting terminating NULL */

if (get_oid("HEAD", &oid))

die("--merge without HEAD?");

free_commit_list(bases);

head->object.flags |= SYMMETRIC_LEFT;

if (!ce_stage(ce))

continue;

prune_num++;

REALLOC_ARRAY(prune, prune_num);

prune[prune_num-2] = ce->name;

prune[prune_num-1] = NULL;

}

i++;

}

clear_pathspec(&revs->prune_data);

*dotdot = '\0';

}

if (!a_obj || !b_obj)

return dotdot_missing(arg, dotdot, revs, symmetric);

struct commit *a, *b;

struct commit_list *exclude;

if (!a || !b)

return dotdot_missing(arg, dotdot, revs, symmetric);

const char *arg = argv[0];

const char *optarg;

int argcount;

/* pseudo revision arguments */

if (!strcmp(arg, "--all") || !strcmp(arg, "--branches") ||

revs->abbrev = strtoul(optarg, NULL, 10);

if (revs->abbrev < MINIMUM_ABBREV)

revs->abbrev = MINIMUM_ABBREV;

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

revs->abbrev_commit = 1;

revs->abbrev_commit_given = 1;

} else if (revs->allow_exclude_promisor_objects_opt &&

!strcmp(arg, "--exclude-promisor-objects")) {

if (fetch_if_missing)

revs->exclude_promisor_objects = 1;

} else {

int opts = diff_opt_parse(&revs->diffopt, argv, argc, revs->prefix);

* supported right now, so stick to single worktree.

*/

if (!revs->single_worktree)

refs = get_submodule_ref_store(submodule);

} else

/*

* NOTE!

*/

int setup_revisions(int argc, const char **argv, struct rev_info *revs, struct setup_revision_opt *opt)

{

struct argv_array prune_data = ARGV_ARRAY_INIT;

const char *submodule = NULL;

revarg_opt = opt ? opt->revarg_opt : 0;

if (seen_dashdash)

revarg_opt |= REVARG_CANNOT_BE_FILENAME;

for (left = i = 1; i < argc; i++) {

const char *arg = argv[i];

if (*arg == '-') {

argv[left++] = arg;

continue;

}

die("--stdin given twice?");

read_revisions_from_stdin(revs, &prune_data);

continue;

static int mark_uninteresting(const struct object_id *oid,

struct packed_git *pack,

uint32_t pos,

{

o->flags |= UNINTERESTING | SEEN;

return 0;

}

revs->treesame.name = "treesame";

if (revs->exclude_promisor_objects) {

FOR_EACH_OBJECT_PROMISOR_ONLY);

}

{

if (commit->object.flags & SHOWN)

return commit_ignore;

return commit_ignore;

if (commit->object.flags & UNINTERESTING)

return commit_ignore;

struct commit_list *p;

for (p = revs->previous_parents; p; p = p->next)

if (p->item == NULL || /* first commit */

break;

revs->linear = p != NULL;

}