undef/git-commit-vandalism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'mh/reflife'

Browse Source 
Define memory ownership and lifetime rules for what for-each-ref
feeds to its callbacks (in short, "you do not own it, so make a
copy if you want to keep it").

* mh/reflife: (25 commits)
  refs: document the lifetime of the args passed to each_ref_fn
  register_ref(): make a copy of the bad reference SHA-1
  exclude_existing(): set existing_refs.strdup_strings
  string_list_add_refs_by_glob(): add a comment about memory management
  string_list_add_one_ref(): rename first parameter to "refname"
  show_head_ref(): rename first parameter to "refname"
  show_head_ref(): do not shadow name of argument
  add_existing(): do not retain a reference to sha1
  do_fetch(): clean up existing_refs before exiting
  do_fetch(): reduce scope of peer_item
  object_array_entry: fix memory handling of the name field
  find_first_merges(): remove unnecessary code
  find_first_merges(): initialize merges variable using initializer
  fsck: don't put a void*-shaped peg in a char*-shaped hole
  object_array_remove_duplicates(): rewrite to reduce copying
  revision: use object_array_filter() in implementation of gc_boundary()
  object_array: add function object_array_filter()
  revision: split some overly-long lines
  cmd_diff(): make it obvious which cases are exclusive of each other
  cmd_diff(): rename local variable "list" -> "entry"
  ...
This commit is contained in:
Junio C Hamano 2013-06-14 08:46:13 -07:00
commit ede63a195c
15 changed files with 231 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
bisect.c
View File

@ -15,7 +15,7 @@
static struct sha1_array good_revs;
static struct sha1_array skipped_revs;
static const unsigned char *current_bad_sha1;
static unsigned char *current_bad_sha1;
static const char *argv_checkout[] = {"checkout", "-q", NULL, "--", NULL};
static const char *argv_show_branch[] = {"show-branch", NULL, NULL};
@ -404,7 +404,8 @@ static int register_ref(const char *refname, const unsigned char *sha1,
int flags, void *cb_data)
{
if (!strcmp(refname, "bad")) {
current_bad_sha1 = sha1;
current_bad_sha1 = xmalloc(20);
hashcpy(current_bad_sha1, sha1);
} else if (!prefixcmp(refname, "good-")) {
sha1_array_append(&good_revs, sha1);
} else if (!prefixcmp(refname, "skip-")) {

6
builtin/describe.c
View File

@ -43,7 +43,7 @@ struct commit_name {
unsigned prio:2; /* annotated tag = 2, tag = 1, head = 0 */
unsigned name_checked:1;
unsigned char sha1[20];
const char *path;
char *path;
};
static const char *prio_names[] = {
"head", "lightweight", "annotated",
@ -127,12 +127,14 @@ static void add_to_known_names(const char *path,
} else {
e->next = NULL;
}
e->path = NULL;
}
e->tag = tag;
e->prio = prio;
e->name_checked = 0;
hashcpy(e->sha1, sha1);
e->path = path;
free(e->path);
e->path = xstrdup(path);
}
}

69
builtin/diff.c
View File

@ -153,7 +153,8 @@ static int builtin_diff_index(struct rev_info *revs,
static int builtin_diff_tree(struct rev_info *revs,
int argc, const char **argv,
struct object_array_entry *ent)
struct object_array_entry *ent0,
struct object_array_entry *ent1)
{
const unsigned char *(sha1[2]);
int swap = 0;
@ -161,13 +162,14 @@ static int builtin_diff_tree(struct rev_info *revs,
if (argc > 1)
usage(builtin_diff_usage);
/* We saw two trees, ent[0] and ent[1].
* if ent[1] is uninteresting, they are swapped
/*
* We saw two trees, ent0 and ent1. If ent1 is uninteresting,
* swap them.
*/
if (ent[1].item->flags & UNINTERESTING)
if (ent1->item->flags & UNINTERESTING)
swap = 1;
sha1[swap] = ent[0].item->sha1;
sha1[1-swap] = ent[1].item->sha1;
sha1[swap] = ent0->item->sha1;
sha1[1-swap] = ent1->item->sha1;
diff_tree_sha1(sha1[0], sha1[1], "", &revs->diffopt);
log_tree_diff_flush(revs);
return 0;
@ -251,8 +253,8 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
{
int i;
struct rev_info rev;
struct object_array_entry ent[100];
int ents = 0, blobs = 0, paths = 0;
struct object_array ent = OBJECT_ARRAY_INIT;
int blobs = 0, paths = 0;
const char *path = NULL;
struct blobinfo blob[2];
int nongit;
@ -337,9 +339,9 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
}
for (i = 0; i < rev.pending.nr; i++) {
struct object_array_entry *list = rev.pending.objects+i;
struct object *obj = list->item;
const char *name = list->name;
struct object_array_entry *entry = &rev.pending.objects[i];
struct object *obj = entry->item;
const char *name = entry->name;
int flags = (obj->flags & UNINTERESTING);
if (!obj->parsed)
obj = parse_object(obj->sha1);
@ -348,28 +350,22 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
die(_("invalid object '%s' given."), name);
if (obj->type == OBJ_COMMIT)
obj = &((struct commit *)obj)->tree->object;
if (obj->type == OBJ_TREE) {
if (ARRAY_SIZE(ent) <= ents)
die(_("more than %d trees given: '%s'"),
(int) ARRAY_SIZE(ent), name);
obj->flags |= flags;
ent[ents].item = obj;
ent[ents].name = name;
ents++;
continue;
}
if (obj->type == OBJ_BLOB) {
add_object_array(obj, name, &ent);
} else if (obj->type == OBJ_BLOB) {
if (2 <= blobs)
die(_("more than two blobs given: '%s'"), name);
hashcpy(blob[blobs].sha1, obj->sha1);
blob[blobs].name = name;
blob[blobs].mode = list->mode;
blob[blobs].mode = entry->mode;
blobs++;
continue;
}
} else {
die(_("unhandled object '%s' given."), name);
}
}
if (rev.prune_data.nr) {
if (!path)
path = rev.prune_data.items[0].match;
@ -379,7 +375,7 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
/*
* Now, do the arguments look reasonable?
*/
if (!ents) {
if (!ent.nr) {
switch (blobs) {
case 0:
result = builtin_diff_files(&rev, argc, argv);
@ -400,23 +396,26 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
}
else if (blobs)
usage(builtin_diff_usage);
else if (ents == 1)
else if (ent.nr == 1)
result = builtin_diff_index(&rev, argc, argv);
else if (ents == 2)
result = builtin_diff_tree(&rev, argc, argv, ent);
else if (ent[0].item->flags & UNINTERESTING) {
else if (ent.nr == 2)
result = builtin_diff_tree(&rev, argc, argv,
&ent.objects[0], &ent.objects[1]);
else if (ent.objects[0].item->flags & UNINTERESTING) {
/*
* diff A...B where there is at least one merge base
* between A and B. We have ent[0] == merge-base,
* ent[ents-2] == A, and ent[ents-1] == B. Show diff
* between the base and B. Note that we pick one
* merge base at random if there are more than one.
* between A and B. We have ent.objects[0] ==
* merge-base, ent.objects[ents-2] == A, and
* ent.objects[ents-1] == B. Show diff between the
* base and B. Note that we pick one merge base at
* random if there are more than one.
*/
ent[1] = ent[ents-1];
result = builtin_diff_tree(&rev, argc, argv, ent);
result = builtin_diff_tree(&rev, argc, argv,
&ent.objects[0],
&ent.objects[ent.nr-1]);
} else
result = builtin_diff_combined(&rev, argc, argv,
ent, ents);
ent.objects, ent.nr);
result = diff_result_code(&rev.diffopt, result);
if (1 < rev.diffopt.skip_stat_unmatch)
refresh_index_quietly();

27
builtin/fetch.c
View File

@ -600,7 +600,8 @@ static int add_existing(const char *refname, const unsigned char *sha1,
{
struct string_list *list = (struct string_list *)cbdata;
struct string_list_item *item = string_list_insert(list, refname);
item->util = (void *)sha1;
item->util = xmalloc(20);
hashcpy(item->util, sha1);
return 0;
}
@ -619,7 +620,7 @@ static void find_non_local_tags(struct transport *transport,
struct ref **head,
struct ref ***tail)
{
struct string_list existing_refs = STRING_LIST_INIT_NODUP;
struct string_list existing_refs = STRING_LIST_INIT_DUP;
struct string_list remote_refs = STRING_LIST_INIT_NODUP;
const struct ref *ref;
struct string_list_item *item = NULL;
@ -665,7 +666,7 @@ static void find_non_local_tags(struct transport *transport,
item = string_list_insert(&remote_refs, ref->name);
item->util = (void *)ref->old_sha1;
}
string_list_clear(&existing_refs, 0);
string_list_clear(&existing_refs, 1);
/*
* We may have a final lightweight tag that needs to be
@ -722,11 +723,11 @@ static int truncate_fetch_head(void)
static int do_fetch(struct transport *transport,
struct refspec *refs, int ref_count)
{
struct string_list existing_refs = STRING_LIST_INIT_NODUP;
struct string_list_item *peer_item = NULL;
struct string_list existing_refs = STRING_LIST_INIT_DUP;
struct ref *ref_map;
struct ref *rm;
int autotags = (transport->remote->fetch_tags == 1);
int retcode = 0;
for_each_ref(add_existing, &existing_refs);
@ -742,9 +743,9 @@ static int do_fetch(struct transport *transport,
/* if not appending, truncate FETCH_HEAD */
if (!append && !dry_run) {
int errcode = truncate_fetch_head();
if (errcode)
return errcode;
retcode = truncate_fetch_head();
if (retcode)
goto cleanup;
}
ref_map = get_ref_map(transport, refs, ref_count, tags, &autotags);
@ -753,7 +754,8 @@ static int do_fetch(struct transport *transport,
for (rm = ref_map; rm; rm = rm->next) {
if (rm->peer_ref) {
peer_item = string_list_lookup(&existing_refs,
struct string_list_item *peer_item =
string_list_lookup(&existing_refs,
rm->peer_ref->name);
if (peer_item)
hashcpy(rm->peer_ref->old_sha1,
@ -765,7 +767,8 @@ static int do_fetch(struct transport *transport,
transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, "1");
if (fetch_refs(transport, ref_map)) {
free_refs(ref_map);
return 1;
retcode = 1;
goto cleanup;
}
if (prune) {
/* If --tags was specified, pretend the user gave us the canonical tags refspec */
@ -808,7 +811,9 @@ static int do_fetch(struct transport *transport,
free_refs(ref_map);
}
return 0;
cleanup:
string_list_clear(&existing_refs, 1);
return retcode;
}
static void set_option(const char *name, const char *value)

2
builtin/fsck.c
View File

@ -112,7 +112,7 @@ static int mark_object(struct object *obj, int type, void *data)
return 1;
}
add_object_array(obj, (void *) parent, &pending);
add_object_array(obj, NULL, &pending);
return 0;
}

2
builtin/show-ref.c
View File

@ -103,7 +103,7 @@ static int add_existing(const char *refname, const unsigned char *sha1, int flag
*/
static int exclude_existing(const char *match)
{
static struct string_list existing_refs = STRING_LIST_INIT_NODUP;
static struct string_list existing_refs = STRING_LIST_INIT_DUP;
char buf[1024];
int matchlen = match ? strlen(match) : 0;

2
bundle.c
View File

@ -281,7 +281,7 @@ int create_bundle(struct bundle_header *header, const char *path,
if (!get_sha1_hex(buf.buf + 1, sha1)) {
struct object *object = parse_object_or_die(sha1, buf.buf);
object->flags |= UNINTERESTING;
add_pending_object(&revs, object, xstrdup(buf.buf));
add_pending_object(&revs, object, buf.buf);
}
} else if (!get_sha1_hex(buf.buf, sha1)) {
struct object *object = parse_object_or_die(sha1, buf.buf);

6
http-backend.c
View File

@ -410,14 +410,14 @@ static void get_info_refs(char *arg)
strbuf_release(&buf);
}
static int show_head_ref(const char *name, const unsigned char *sha1,
static int show_head_ref(const char *refname, const unsigned char *sha1,
int flag, void *cb_data)
{
struct strbuf *buf = cb_data;
if (flag & REF_ISSYMREF) {
unsigned char sha1[20];
const char *target = resolve_ref_unsafe(name, sha1, 1, NULL);
unsigned char unused[20];
const char *target = resolve_ref_unsafe(refname, unused, 1, NULL);
const char *target_nons = strip_namespace(target);
strbuf_addf(buf, "ref: %s\n", target_nons);

10
notes.c
View File

@ -918,17 +918,21 @@ out:
return ret;
}
static int string_list_add_one_ref(const char *path, const unsigned char *sha1,
static int string_list_add_one_ref(const char *refname, const unsigned char *sha1,
int flag, void *cb)
{
struct string_list *refs = cb;
if (!unsorted_string_list_has_string(refs, path))
string_list_append(refs, path);
if (!unsorted_string_list_has_string(refs, refname))
string_list_append(refs, refname);
return 0;
}
/*
* The list argument must have strdup_strings set on it.
*/
void string_list_add_refs_by_glob(struct string_list *list, const char *glob)
{
assert(list->strdup_strings);
if (has_glob_specials(glob)) {
for_each_glob_ref(string_list_add_one_ref, glob, list);
} else {

74
object.c
View File

@ -270,11 +270,18 @@ void add_object_array(struct object *obj, const char *name, struct object_array
add_object_array_with_mode(obj, name, array, S_IFINVALID);
}
/*
* A zero-length string to which object_array_entry::name can be
* initialized without requiring a malloc/free.
*/
static char object_array_slopbuf[1];
void add_object_array_with_mode(struct object *obj, const char *name, struct object_array *array, unsigned mode)
{
unsigned nr = array->nr;
unsigned alloc = array->alloc;
struct object_array_entry *objects = array->objects;
struct object_array_entry *entry;
if (nr >= alloc) {
alloc = (alloc + 32) * 2;
@ -282,28 +289,67 @@ void add_object_array_with_mode(struct object *obj, const char *name, struct obj
array->alloc = alloc;
array->objects = objects;
}
objects[nr].item = obj;
objects[nr].name = name;
objects[nr].mode = mode;
entry = &objects[nr];
entry->item = obj;
if (!name)
entry->name = NULL;
else if (!*name)
/* Use our own empty string instead of allocating one: */
entry->name = object_array_slopbuf;
else
entry->name = xstrdup(name);
entry->mode = mode;
array->nr = ++nr;
}
void object_array_filter(struct object_array *array,
object_array_each_func_t want, void *cb_data)
{
unsigned nr = array->nr, src, dst;
struct object_array_entry *objects = array->objects;
for (src = dst = 0; src < nr; src++) {
if (want(&objects[src], cb_data)) {
if (src != dst)
objects[dst] = objects[src];
dst++;
} else {
if (objects[src].name != object_array_slopbuf)
free(objects[src].name);
}
}
array->nr = dst;
}
/*
* Return true iff array already contains an entry with name.
*/
static int contains_name(struct object_array *array, const char *name)
{
unsigned nr = array->nr, i;
struct object_array_entry *object = array->objects;
for (i = 0; i < nr; i++, object++)
if (!strcmp(object->name, name))
return 1;
return 0;
}
void object_array_remove_duplicates(struct object_array *array)
{
unsigned int ref, src, dst;
unsigned nr = array->nr, src;
struct object_array_entry *objects = array->objects;
for (ref = 0; ref + 1 < array->nr; ref++) {
for (src = ref + 1, dst = src;
src < array->nr;
src++) {
if (!strcmp(objects[ref].name, objects[src].name))
continue;
if (src != dst)
objects[dst] = objects[src];
dst++;
array->nr = 0;
for (src = 0; src < nr; src++) {
if (!contains_name(array, objects[src].name)) {
if (src != array->nr)
objects[array->nr] = objects[src];
array->nr++;
} else {
if (objects[src].name != object_array_slopbuf)
free(objects[src].name);
}
array->nr = dst;
}
}

25
object.h
View File

@ -11,7 +11,13 @@ struct object_array {
unsigned int alloc;
struct object_array_entry {
struct object *item;
const char *name;
/*
* name or NULL. If non-NULL, the memory pointed to
* is owned by this object *except* if it points at
* object_array_slopbuf, which is a static copy of the
* empty string.
*/
char *name;
unsigned mode;
} *objects;
};
@ -85,7 +91,22 @@ int object_list_contains(struct object_list *list, struct object *obj);
/* Object array handling .. */
void add_object_array(struct object *obj, const char *name, struct object_array *array);
void add_object_array_with_mode(struct object *obj, const char *name, struct object_array *array, unsigned mode);
void object_array_remove_duplicates(struct object_array *);
typedef int (*object_array_each_func_t)(struct object_array_entry *, void *);
/*
* Apply want to each entry in array, retaining only the entries for
* which the function returns true. Preserve the order of the entries
* that are retained.
*/
void object_array_filter(struct object_array *array,
object_array_each_func_t want, void *cb_data);
/*
* Remove from array all but the first entry with a given name.
* Warning: this function uses an O(N^2) algorithm.
*/
void object_array_remove_duplicates(struct object_array *array);
void clear_object_flags(unsigned flags);

22
refs.h
View File

@ -28,13 +28,23 @@ struct ref_lock {
#define REF_ISBROKEN 0x04
/*
* Calls the specified function for each ref file until it returns
* nonzero, and returns the value. Please note that it is not safe to
* modify references while an iteration is in progress, unless the
* same callback function invocation that modifies the reference also
* returns a nonzero value to immediately stop the iteration.
* The signature for the callback function for the for_each_*()
* functions below. The memory pointed to by the refname and sha1
* arguments is only guaranteed to be valid for the duration of a
* single callback invocation.
*/
typedef int each_ref_fn(const char *refname,
const unsigned char *sha1, int flags, void *cb_data);
/*
* The following functions invoke the specified callback function for
* each reference indicated. If the function ever returns a nonzero
* value, stop the iteration and return that value. Please note that
* it is not safe to modify references while an iteration is in
* progress, unless the same callback function invocation that
* modifies the reference also returns a nonzero value to immediately
* stop the iteration.
*/
typedef int each_ref_fn(const char *refname, const unsigned char *sha1, int flags, void *cb_data);
extern int head_ref(each_ref_fn, void *);
extern int for_each_ref(each_ref_fn, void *);
extern int for_each_ref_in(const char *, each_ref_fn, void *);

64
revision.c
View File

@ -71,7 +71,8 @@ static int show_path_truncated(FILE *out, const struct name_path *path)
return ours || emitted;
}
void show_object_with_name(FILE *out, struct object *obj, const struct name_path *path, const char *component)
void show_object_with_name(FILE *out, struct object *obj,
const struct name_path *path, const char *component)
{
struct name_path leaf;
leaf.up = (struct name_path *)path;
@ -88,7 +89,9 @@ void add_object(struct object *obj,
struct name_path *path,
const char *name)
{
add_object_array(obj, path_name(path, name), p);
char *pn = path_name(path, name);
add_object_array(obj, pn, p);
free(pn);
}
static void mark_blob_uninteresting(struct blob *blob)
@ -187,7 +190,9 @@ void mark_parents_uninteresting(struct commit *commit)
}
}
static void add_pending_object_with_mode(struct rev_info *revs, struct object *obj, const char *name, unsigned mode)
static void add_pending_object_with_mode(struct rev_info *revs,
struct object *obj,
const char *name, unsigned mode)
{
if (!obj)
return;
@ -210,7 +215,8 @@ static void add_pending_object_with_mode(struct rev_info *revs, struct object *o
add_object_array_with_mode(obj, name, &revs->pending, mode);
}
void add_pending_object(struct rev_info *revs, struct object *obj, const char *name)
void add_pending_object(struct rev_info *revs,
struct object *obj, const char *name)
{
add_pending_object_with_mode(revs, obj, name, S_IFINVALID);
}
@ -227,7 +233,9 @@ void add_head_to_pending(struct rev_info *revs)
add_pending_object(revs, obj, "HEAD");
}
static struct object *get_reference(struct rev_info *revs, const char *name, const unsigned char *sha1, unsigned int flags)
static struct object *get_reference(struct rev_info *revs, const char *name,
const unsigned char *sha1,
unsigned int flags)
{
struct object *object;
@ -248,7 +256,8 @@ void add_pending_sha1(struct rev_info *revs, const char *name,
add_pending_object(revs, object, name);
}
static struct commit *handle_commit(struct rev_info *revs, struct object *object, const char *name)
static struct commit *handle_commit(struct rev_info *revs,
struct object *object, const char *name)
{
unsigned long flags = object->flags;
@ -443,7 +452,8 @@ static void file_change(struct diff_options *options,
DIFF_OPT_SET(options, HAS_CHANGES);
}
static int rev_compare_tree(struct rev_info *revs, struct commit *parent, struct commit *commit)
static int rev_compare_tree(struct rev_info *revs,
struct commit *parent, struct commit *commit)
{
struct tree *t1 = parent->tree;
struct tree *t2 = commit->tree;
@ -1129,6 +1139,10 @@ static int limit_list(struct rev_info *revs)
return 0;
}
/*
* Add an entry to refs->cmdline with the specified information.
* *name is copied.
*/
static void add_rev_cmdline(struct rev_info *revs,
struct object *item,
const char *name,
@ -1140,7 +1154,7 @@ static void add_rev_cmdline(struct rev_info *revs,
ALLOC_GROW(info->rev, nr + 1, info->alloc);
info->rev[nr].item = item;
info->rev[nr].name = name;
info->rev[nr].name = xstrdup(name);
info->rev[nr].whence = whence;
info->rev[nr].flags = flags;
info->nr++;
@ -1526,7 +1540,7 @@ static void read_revisions_from_stdin(struct rev_info *revs,
}
die("options not supported in --stdin mode");
}
if (handle_revision_arg(xstrdup(sb.buf), revs, 0,
if (handle_revision_arg(sb.buf, revs, 0,
REVARG_CANNOT_BE_FILENAME))
die("bad revision '%s'", sb.buf);
}
@ -2853,25 +2867,23 @@ static struct commit *get_revision_1(struct rev_info *revs)
return NULL;
}
/*
* Return true for entries that have not yet been shown. (This is an
* object_array_each_func_t.)
*/
static int entry_unshown(struct object_array_entry *entry, void *cb_data_unused)
{
return !(entry->item->flags & SHOWN);
}
/*
* If array is on the verge of a realloc, garbage-collect any entries
* that have already been shown to try to free up some space.
*/
static void gc_boundary(struct object_array *array)
{
unsigned nr = array->nr;
unsigned alloc = array->alloc;
struct object_array_entry *objects = array->objects;
if (alloc <= nr) {
unsigned i, j;
for (i = j = 0; i < nr; i++) {
if (objects[i].item->flags & SHOWN)
continue;
if (i != j)
objects[j] = objects[i];
j++;
}
for (i = j; i < nr; i++)
objects[i].item = NULL;
array->nr = j;
}
if (array->nr == array->alloc)
object_array_filter(array, entry_unshown, NULL);
}
static void create_boundary_commit_list(struct rev_info *revs)

28
revision.h
View File

@ -202,19 +202,23 @@ struct setup_revision_opt {
};
extern void init_revisions(struct rev_info *revs, const char *prefix);
extern int setup_revisions(int argc, const char **argv, struct rev_info *revs, struct setup_revision_opt *);
extern int setup_revisions(int argc, const char **argv, struct rev_info *revs,
struct setup_revision_opt *);
extern void parse_revision_opt(struct rev_info *revs, struct parse_opt_ctx_t *ctx,
const struct option *options,
const char * const usagestr[]);
#define REVARG_CANNOT_BE_FILENAME 01
#define REVARG_COMMITTISH 02
extern int handle_revision_arg(const char *arg, struct rev_info *revs, int flags, unsigned revarg_opt);
extern int handle_revision_arg(const char *arg, struct rev_info *revs,
int flags, unsigned revarg_opt);
extern void reset_revision_walk(void);
extern int prepare_revision_walk(struct rev_info *revs);
extern struct commit *get_revision(struct rev_info *revs);
extern char *get_revision_mark(const struct rev_info *revs, const struct commit *commit);
extern void put_revision_mark(const struct rev_info *revs, const struct commit *commit);
extern char *get_revision_mark(const struct rev_info *revs,
const struct commit *commit);
extern void put_revision_mark(const struct rev_info *revs,
const struct commit *commit);
extern void mark_parents_uninteresting(struct commit *commit);
extern void mark_tree_uninteresting(struct tree *tree);
@ -227,15 +231,19 @@ struct name_path {
char *path_name(const struct name_path *path, const char *name);
extern void show_object_with_name(FILE *, struct object *, const struct name_path *, const char *);
extern void show_object_with_name(FILE *, struct object *,
const struct name_path *, const char *);
extern void add_object(struct object *obj,
struct object_array *p,
struct name_path *path,
const char *name);
extern void add_pending_object(struct rev_info *revs, struct object *obj, const char *name);
extern void add_pending_sha1(struct rev_info *revs, const char *name, const unsigned char *sha1, unsigned int flags);
extern void add_pending_object(struct rev_info *revs,
struct object *obj, const char *name);
extern void add_pending_sha1(struct rev_info *revs,
const char *name, const unsigned char *sha1,
unsigned int flags);
extern void add_head_to_pending(struct rev_info *);
@ -245,8 +253,10 @@ enum commit_action {
commit_error
};
extern enum commit_action get_commit_action(struct rev_info *revs, struct commit *commit);
extern enum commit_action simplify_commit(struct rev_info *revs, struct commit *commit);
extern enum commit_action get_commit_action(struct rev_info *revs,
struct commit *commit);
extern enum commit_action simplify_commit(struct rev_info *revs,
struct commit *commit);
enum rewrite_result {
rewrite_one_ok,

6
submodule.c
View File

@ -845,7 +845,7 @@ static int find_first_merges(struct object_array *result, const char *path,
struct commit *a, struct commit *b)
{
int i, j;
struct object_array merges;
struct object_array merges = OBJECT_ARRAY_INIT;
struct commit *commit;
int contains_another;
@ -855,7 +855,6 @@ static int find_first_merges(struct object_array *result, const char *path,
struct rev_info revs;
struct setup_revision_opt rev_opts;
memset(&merges, 0, sizeof(merges));
memset(result, 0, sizeof(struct object_array));
memset(&rev_opts, 0, sizeof(rev_opts));
@ -893,8 +892,7 @@ static int find_first_merges(struct object_array *result, const char *path,
}
if (!contains_another)
add_object_array(merges.objects[i].item,
merges.objects[i].name, result);
add_object_array(merges.objects[i].item, NULL, result);
}
free(merges.objects);