Convert memcpy(a,b,20) to hashcpy(a,b).
This abstracts away the size of the hash values when copying them from memory location to memory location, much as the introduction of hashcmp abstracted away hash value comparsion. A few call sites were using char* rather than unsigned char* so I added the cast rather than open hashcpy to be void*. This is a reasonable tradeoff as most call sites already use unsigned char* and the existing hashcmp is also declared to be unsigned char*. [jc: Splitted the patch to "master" part, to be followed by a patch for merge-recursive.c which is not in "master" yet. Fixed the cast in the latter hunk to combine-diff.c which was wrong in the original. Also converted ones left-over in combine-diff.c, diff-lib.c and upload-pack.c ] Signed-off-by: Shawn O. Pearce <spearce@spearce.org> Signed-off-by: Junio C Hamano <junkio@cox.net>
This commit is contained in:
parent
b05faa2da9
commit
e702496e43
4
blame.c
4
blame.c
@ -176,7 +176,7 @@ static int get_blob_sha1(struct tree *t, const char *pathname,
|
||||
if (i == 20)
|
||||
return -1;
|
||||
|
||||
memcpy(sha1, blob_sha1, 20);
|
||||
hashcpy(sha1, blob_sha1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -191,7 +191,7 @@ static int get_blob_sha1_internal(const unsigned char *sha1, const char *base,
|
||||
strcmp(blame_file + baselen, pathname))
|
||||
return -1;
|
||||
|
||||
memcpy(blob_sha1, sha1, 20);
|
||||
hashcpy(blob_sha1, sha1);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
@ -192,7 +192,7 @@ static int builtin_diff_combined(struct rev_info *revs,
|
||||
parent = xmalloc(ents * sizeof(*parent));
|
||||
/* Again, the revs are all reverse */
|
||||
for (i = 0; i < ents; i++)
|
||||
memcpy(parent + i, ent[ents - 1 - i].item->sha1, 20);
|
||||
hashcpy((unsigned char*)parent + i, ent[ents - 1 - i].item->sha1);
|
||||
diff_tree_combined(parent[0], parent + 1, ents - 1,
|
||||
revs->dense_combined_merges, revs);
|
||||
return 0;
|
||||
@ -290,7 +290,7 @@ int cmd_diff(int argc, const char **argv, const char *prefix)
|
||||
if (obj->type == OBJ_BLOB) {
|
||||
if (2 <= blobs)
|
||||
die("more than two blobs given: '%s'", name);
|
||||
memcpy(blob[blobs].sha1, obj->sha1, 20);
|
||||
hashcpy(blob[blobs].sha1, obj->sha1);
|
||||
blob[blobs].name = name;
|
||||
blobs++;
|
||||
continue;
|
||||
|
@ -534,7 +534,7 @@ static int add_object_entry(const unsigned char *sha1, unsigned hash, int exclud
|
||||
entry = objects + idx;
|
||||
nr_objects = idx + 1;
|
||||
memset(entry, 0, sizeof(*entry));
|
||||
memcpy(entry->sha1, sha1, 20);
|
||||
hashcpy(entry->sha1, sha1);
|
||||
entry->hash = hash;
|
||||
|
||||
if (object_ix_hashsz * 3 <= nr_objects * 4)
|
||||
@ -649,7 +649,7 @@ static struct pbase_tree_cache *pbase_tree_get(const unsigned char *sha1)
|
||||
free(ent->tree_data);
|
||||
nent = ent;
|
||||
}
|
||||
memcpy(nent->sha1, sha1, 20);
|
||||
hashcpy(nent->sha1, sha1);
|
||||
nent->tree_data = data;
|
||||
nent->tree_size = size;
|
||||
nent->ref = 1;
|
||||
@ -799,7 +799,7 @@ static void add_preferred_base(unsigned char *sha1)
|
||||
it->next = pbase_tree;
|
||||
pbase_tree = it;
|
||||
|
||||
memcpy(it->pcache.sha1, tree_sha1, 20);
|
||||
hashcpy(it->pcache.sha1, tree_sha1);
|
||||
it->pcache.tree_data = data;
|
||||
it->pcache.tree_size = size;
|
||||
}
|
||||
|
@ -53,7 +53,7 @@ static void prime_cache_tree_rec(struct cache_tree *it, struct tree *tree)
|
||||
struct name_entry entry;
|
||||
int cnt;
|
||||
|
||||
memcpy(it->sha1, tree->object.sha1, 20);
|
||||
hashcpy(it->sha1, tree->object.sha1);
|
||||
desc.buf = tree->buffer;
|
||||
desc.size = tree->size;
|
||||
cnt = 0;
|
||||
|
@ -95,7 +95,7 @@ static void add_delta_to_list(unsigned char *base_sha1, void *delta, unsigned lo
|
||||
{
|
||||
struct delta_info *info = xmalloc(sizeof(*info));
|
||||
|
||||
memcpy(info->base_sha1, base_sha1, 20);
|
||||
hashcpy(info->base_sha1, base_sha1);
|
||||
info->size = size;
|
||||
info->delta = delta;
|
||||
info->next = delta_list;
|
||||
@ -173,7 +173,7 @@ static int unpack_delta_entry(unsigned long delta_size)
|
||||
unsigned char base_sha1[20];
|
||||
int result;
|
||||
|
||||
memcpy(base_sha1, fill(20), 20);
|
||||
hashcpy(base_sha1, fill(20));
|
||||
use(20);
|
||||
|
||||
delta_data = get_data(delta_size);
|
||||
|
@ -142,7 +142,7 @@ static int add_cacheinfo(unsigned int mode, const unsigned char *sha1,
|
||||
size = cache_entry_size(len);
|
||||
ce = xcalloc(1, size);
|
||||
|
||||
memcpy(ce->sha1, sha1, 20);
|
||||
hashcpy(ce->sha1, sha1);
|
||||
memcpy(ce->name, path, len);
|
||||
ce->ce_flags = create_ce_flags(len, stage);
|
||||
ce->ce_mode = create_ce_mode(mode);
|
||||
@ -333,7 +333,7 @@ static struct cache_entry *read_one_ent(const char *which,
|
||||
size = cache_entry_size(namelen);
|
||||
ce = xcalloc(1, size);
|
||||
|
||||
memcpy(ce->sha1, sha1, 20);
|
||||
hashcpy(ce->sha1, sha1);
|
||||
memcpy(ce->name, path, namelen);
|
||||
ce->ce_flags = create_ce_flags(namelen, stage);
|
||||
ce->ce_mode = create_ce_mode(mode);
|
||||
|
@ -50,10 +50,10 @@ int write_tree(unsigned char *sha1, int missing_ok, const char *prefix)
|
||||
if (prefix) {
|
||||
struct cache_tree *subtree =
|
||||
cache_tree_find(active_cache_tree, prefix);
|
||||
memcpy(sha1, subtree->sha1, 20);
|
||||
hashcpy(sha1, subtree->sha1);
|
||||
}
|
||||
else
|
||||
memcpy(sha1, active_cache_tree->sha1, 20);
|
||||
hashcpy(sha1, active_cache_tree->sha1);
|
||||
|
||||
rollback_lock_file(lock_file);
|
||||
|
||||
|
@ -335,7 +335,7 @@ static int update_one(struct cache_tree *it,
|
||||
offset += sprintf(buffer + offset,
|
||||
"%o %.*s", mode, entlen, path + baselen);
|
||||
buffer[offset++] = 0;
|
||||
memcpy(buffer + offset, sha1, 20);
|
||||
hashcpy((unsigned char*)buffer + offset, sha1);
|
||||
offset += 20;
|
||||
|
||||
#if DEBUG
|
||||
@ -412,7 +412,7 @@ static void *write_one(struct cache_tree *it,
|
||||
#endif
|
||||
|
||||
if (0 <= it->entry_count) {
|
||||
memcpy(buffer + *offset, it->sha1, 20);
|
||||
hashcpy((unsigned char*)buffer + *offset, it->sha1);
|
||||
*offset += 20;
|
||||
}
|
||||
for (i = 0; i < it->subtree_nr; i++) {
|
||||
@ -478,7 +478,7 @@ static struct cache_tree *read_one(const char **buffer, unsigned long *size_p)
|
||||
if (0 <= it->entry_count) {
|
||||
if (size < 20)
|
||||
goto free_return;
|
||||
memcpy(it->sha1, buf, 20);
|
||||
hashcpy(it->sha1, (unsigned char*)buf);
|
||||
buf += 20;
|
||||
size -= 20;
|
||||
}
|
||||
|
4
cache.h
4
cache.h
@ -218,6 +218,10 @@ static inline int hashcmp(const unsigned char *sha1, const unsigned char *sha2)
|
||||
{
|
||||
return memcmp(sha1, sha2, 20);
|
||||
}
|
||||
static inline void hashcpy(unsigned char *sha_dst, const unsigned char *sha_src)
|
||||
{
|
||||
memcpy(sha_dst, sha_src, 20);
|
||||
}
|
||||
|
||||
int git_mkstemp(char *path, size_t n, const char *template);
|
||||
|
||||
|
@ -31,9 +31,9 @@ static struct combine_diff_path *intersect_paths(struct combine_diff_path *curr,
|
||||
memset(p->parent, 0,
|
||||
sizeof(p->parent[0]) * num_parent);
|
||||
|
||||
memcpy(p->sha1, q->queue[i]->two->sha1, 20);
|
||||
hashcpy(p->sha1, q->queue[i]->two->sha1);
|
||||
p->mode = q->queue[i]->two->mode;
|
||||
memcpy(p->parent[n].sha1, q->queue[i]->one->sha1, 20);
|
||||
hashcpy(p->parent[n].sha1, q->queue[i]->one->sha1);
|
||||
p->parent[n].mode = q->queue[i]->one->mode;
|
||||
p->parent[n].status = q->queue[i]->status;
|
||||
*tail = p;
|
||||
@ -56,8 +56,7 @@ static struct combine_diff_path *intersect_paths(struct combine_diff_path *curr,
|
||||
len = strlen(path);
|
||||
if (len == p->len && !memcmp(path, p->path, len)) {
|
||||
found = 1;
|
||||
memcpy(p->parent[n].sha1,
|
||||
q->queue[i]->one->sha1, 20);
|
||||
hashcpy(p->parent[n].sha1, q->queue[i]->one->sha1);
|
||||
p->parent[n].mode = q->queue[i]->one->mode;
|
||||
p->parent[n].status = q->queue[i]->status;
|
||||
break;
|
||||
@ -927,6 +926,7 @@ void diff_tree_combined_merge(const unsigned char *sha1,
|
||||
for (parents = commit->parents, num_parent = 0;
|
||||
parents;
|
||||
parents = parents->next, num_parent++)
|
||||
memcpy(parent + num_parent, parents->item->object.sha1, 20);
|
||||
hashcpy((unsigned char*)(parent + num_parent),
|
||||
parents->item->object.sha1);
|
||||
diff_tree_combined(sha1, parent, num_parent, dense, rev);
|
||||
}
|
||||
|
@ -77,7 +77,7 @@ struct ref **get_remote_heads(int in, struct ref **list,
|
||||
if (nr_match && !path_match(name, nr_match, match))
|
||||
continue;
|
||||
ref = xcalloc(1, sizeof(*ref) + len - 40);
|
||||
memcpy(ref->old_sha1, old_sha1, 20);
|
||||
hashcpy(ref->old_sha1, old_sha1);
|
||||
memcpy(ref->name, buffer + 41, len - 40);
|
||||
*list = ref;
|
||||
list = &ref->next;
|
||||
@ -208,7 +208,7 @@ static struct ref *try_explicit_object_name(const char *name)
|
||||
len = strlen(name) + 1;
|
||||
ref = xcalloc(1, sizeof(*ref) + len);
|
||||
memcpy(ref->name, name, len);
|
||||
memcpy(ref->new_sha1, sha1, 20);
|
||||
hashcpy(ref->new_sha1, sha1);
|
||||
return ref;
|
||||
}
|
||||
|
||||
@ -318,7 +318,7 @@ int match_refs(struct ref *src, struct ref *dst, struct ref ***dst_tail,
|
||||
int len = strlen(src->name) + 1;
|
||||
dst_peer = xcalloc(1, sizeof(*dst_peer) + len);
|
||||
memcpy(dst_peer->name, src->name, len);
|
||||
memcpy(dst_peer->new_sha1, src->new_sha1, 20);
|
||||
hashcpy(dst_peer->new_sha1, src->new_sha1);
|
||||
link_dst_tail(dst_peer, dst_tail);
|
||||
}
|
||||
dst_peer->peer_ref = src;
|
||||
|
@ -23,7 +23,7 @@ static struct entry * convert_entry(unsigned char *sha1);
|
||||
static struct entry *insert_new(unsigned char *sha1, int pos)
|
||||
{
|
||||
struct entry *new = xcalloc(1, sizeof(struct entry));
|
||||
memcpy(new->old_sha1, sha1, 20);
|
||||
hashcpy(new->old_sha1, sha1);
|
||||
memmove(convert + pos + 1, convert + pos, (nr_convert - pos) * sizeof(struct entry *));
|
||||
convert[pos] = new;
|
||||
nr_convert++;
|
||||
@ -54,7 +54,7 @@ static struct entry *lookup_entry(unsigned char *sha1)
|
||||
static void convert_binary_sha1(void *buffer)
|
||||
{
|
||||
struct entry *entry = convert_entry(buffer);
|
||||
memcpy(buffer, entry->new_sha1, 20);
|
||||
hashcpy(buffer, entry->new_sha1);
|
||||
}
|
||||
|
||||
static void convert_ascii_sha1(void *buffer)
|
||||
@ -104,7 +104,7 @@ static int write_subdirectory(void *buffer, unsigned long size, const char *base
|
||||
if (!slash) {
|
||||
newlen += sprintf(new + newlen, "%o %s", mode, path);
|
||||
new[newlen++] = '\0';
|
||||
memcpy(new + newlen, (char *) buffer + len - 20, 20);
|
||||
hashcpy((unsigned char*)new + newlen, (unsigned char *) buffer + len - 20);
|
||||
newlen += 20;
|
||||
|
||||
used += len;
|
||||
|
@ -38,7 +38,7 @@ int sha1close(struct sha1file *f, unsigned char *result, int update)
|
||||
}
|
||||
SHA1_Final(f->buffer, &f->ctx);
|
||||
if (result)
|
||||
memcpy(result, f->buffer, 20);
|
||||
hashcpy(result, f->buffer);
|
||||
if (update)
|
||||
sha1flush(f, 20);
|
||||
if (close(f->fd))
|
||||
|
@ -66,8 +66,7 @@ int run_diff_files(struct rev_info *revs, int silent_on_removed)
|
||||
if (2 <= stage) {
|
||||
int mode = ntohl(nce->ce_mode);
|
||||
num_compare_stages++;
|
||||
memcpy(dpath->parent[stage-2].sha1,
|
||||
nce->sha1, 20);
|
||||
hashcpy(dpath->parent[stage-2].sha1, nce->sha1);
|
||||
dpath->parent[stage-2].mode =
|
||||
canon_mode(mode);
|
||||
dpath->parent[stage-2].status =
|
||||
|
6
diff.c
6
diff.c
@ -1101,7 +1101,7 @@ void fill_filespec(struct diff_filespec *spec, const unsigned char *sha1,
|
||||
{
|
||||
if (mode) {
|
||||
spec->mode = canon_mode(mode);
|
||||
memcpy(spec->sha1, sha1, 20);
|
||||
hashcpy(spec->sha1, sha1);
|
||||
spec->sha1_valid = !is_null_sha1(sha1);
|
||||
}
|
||||
}
|
||||
@ -1194,7 +1194,7 @@ static struct sha1_size_cache *locate_size_cache(unsigned char *sha1,
|
||||
sizeof(*sha1_size_cache));
|
||||
e = xmalloc(sizeof(struct sha1_size_cache));
|
||||
sha1_size_cache[first] = e;
|
||||
memcpy(e->sha1, sha1, 20);
|
||||
hashcpy(e->sha1, sha1);
|
||||
e->size = size;
|
||||
return e;
|
||||
}
|
||||
@ -1516,7 +1516,7 @@ static void diff_fill_sha1_info(struct diff_filespec *one)
|
||||
}
|
||||
}
|
||||
else
|
||||
memset(one->sha1, 0, 20);
|
||||
hashclr(one->sha1);
|
||||
}
|
||||
|
||||
static void run_diff(struct diff_filepair *p, struct diff_options *o)
|
||||
|
@ -404,7 +404,7 @@ static int everything_local(struct ref **refs, int nr_match, char **match)
|
||||
continue;
|
||||
}
|
||||
|
||||
memcpy(ref->new_sha1, local, 20);
|
||||
hashcpy(ref->new_sha1, local);
|
||||
if (!verbose)
|
||||
continue;
|
||||
fprintf(stderr,
|
||||
|
2
fetch.c
2
fetch.c
@ -84,7 +84,7 @@ static int process_commit(struct commit *commit)
|
||||
if (commit->object.flags & COMPLETE)
|
||||
return 0;
|
||||
|
||||
memcpy(current_commit_sha1, commit->object.sha1, 20);
|
||||
hashcpy(current_commit_sha1, commit->object.sha1);
|
||||
|
||||
pull_say("walk %s\n", sha1_to_hex(commit->object.sha1));
|
||||
|
||||
|
@ -356,7 +356,7 @@ static void add_sha1_list(unsigned char *sha1, unsigned long ino)
|
||||
int nr;
|
||||
|
||||
entry->ino = ino;
|
||||
memcpy(entry->sha1, sha1, 20);
|
||||
hashcpy(entry->sha1, sha1);
|
||||
nr = sha1_list.nr;
|
||||
if (nr == MAX_SHA1_ENTRIES) {
|
||||
fsck_sha1_list();
|
||||
|
@ -393,7 +393,7 @@ void prefetch(unsigned char *sha1)
|
||||
char *filename = sha1_file_name(sha1);
|
||||
|
||||
newreq = xmalloc(sizeof(*newreq));
|
||||
memcpy(newreq->sha1, sha1, 20);
|
||||
hashcpy(newreq->sha1, sha1);
|
||||
newreq->repo = alt;
|
||||
newreq->url = NULL;
|
||||
newreq->local = -1;
|
||||
|
@ -1874,7 +1874,7 @@ static int one_local_ref(const char *refname, const unsigned char *sha1)
|
||||
struct ref *ref;
|
||||
int len = strlen(refname) + 1;
|
||||
ref = xcalloc(1, sizeof(*ref) + len);
|
||||
memcpy(ref->new_sha1, sha1, 20);
|
||||
hashcpy(ref->new_sha1, sha1);
|
||||
memcpy(ref->name, refname, len);
|
||||
*local_tail = ref;
|
||||
local_tail = &ref->next;
|
||||
@ -1909,7 +1909,7 @@ static void one_remote_ref(char *refname)
|
||||
}
|
||||
|
||||
ref = xcalloc(1, sizeof(*ref) + len);
|
||||
memcpy(ref->old_sha1, remote_sha1, 20);
|
||||
hashcpy(ref->old_sha1, remote_sha1);
|
||||
memcpy(ref->name, refname, len);
|
||||
*remote_tail = ref;
|
||||
remote_tail = &ref->next;
|
||||
@ -2445,7 +2445,7 @@ int main(int argc, char **argv)
|
||||
continue;
|
||||
}
|
||||
}
|
||||
memcpy(ref->new_sha1, ref->peer_ref->new_sha1, 20);
|
||||
hashcpy(ref->new_sha1, ref->peer_ref->new_sha1);
|
||||
if (is_zero_sha1(ref->new_sha1)) {
|
||||
error("cannot happen anymore");
|
||||
rc = -3;
|
||||
|
@ -161,7 +161,7 @@ static void *unpack_raw_entry(unsigned long offset,
|
||||
case OBJ_DELTA:
|
||||
if (pos + 20 >= pack_limit)
|
||||
bad_object(offset, "object extends past end of pack");
|
||||
memcpy(delta_base, pack_base + pos, 20);
|
||||
hashcpy(delta_base, pack_base + pos);
|
||||
pos += 20;
|
||||
/* fallthru */
|
||||
case OBJ_COMMIT:
|
||||
@ -304,7 +304,7 @@ static void parse_pack_objects(void)
|
||||
if (obj->type == OBJ_DELTA) {
|
||||
struct delta_entry *delta = &deltas[nr_deltas++];
|
||||
delta->obj = obj;
|
||||
memcpy(delta->base_sha1, base_sha1, 20);
|
||||
hashcpy(delta->base_sha1, base_sha1);
|
||||
} else
|
||||
sha1_object(data, data_size, obj->type, obj->sha1);
|
||||
free(data);
|
||||
|
4
mktree.c
4
mktree.c
@ -30,7 +30,7 @@ static void append_to_tree(unsigned mode, unsigned char *sha1, char *path)
|
||||
ent = entries[used++] = xmalloc(sizeof(**entries) + len + 1);
|
||||
ent->mode = mode;
|
||||
ent->len = len;
|
||||
memcpy(ent->sha1, sha1, 20);
|
||||
hashcpy(ent->sha1, sha1);
|
||||
memcpy(ent->name, path, len+1);
|
||||
}
|
||||
|
||||
@ -64,7 +64,7 @@ static void write_tree(unsigned char *sha1)
|
||||
offset += sprintf(buffer + offset, "%o ", ent->mode);
|
||||
offset += sprintf(buffer + offset, "%s", ent->name);
|
||||
buffer[offset++] = 0;
|
||||
memcpy(buffer + offset, ent->sha1, 20);
|
||||
hashcpy((unsigned char*)buffer + offset, ent->sha1);
|
||||
offset += 20;
|
||||
}
|
||||
write_sha1_file(buffer, offset, tree_type, sha1);
|
||||
|
2
object.c
2
object.c
@ -91,7 +91,7 @@ void created_object(const unsigned char *sha1, struct object *obj)
|
||||
obj->used = 0;
|
||||
obj->type = OBJ_NONE;
|
||||
obj->flags = 0;
|
||||
memcpy(obj->sha1, sha1, 20);
|
||||
hashcpy(obj->sha1, sha1);
|
||||
|
||||
if (obj_hash_size - 1 <= nr_objs * 2)
|
||||
grow_object_hash();
|
||||
|
@ -47,7 +47,7 @@ static void generate_id_list(void)
|
||||
|
||||
if (!get_sha1_hex(p, n)) {
|
||||
flush_current_id(patchlen, sha1, &ctx);
|
||||
memcpy(sha1, n, 20);
|
||||
hashcpy(sha1, n);
|
||||
patchlen = 0;
|
||||
continue;
|
||||
}
|
||||
|
@ -247,8 +247,8 @@ static void read_head_info(void)
|
||||
report_status = 1;
|
||||
}
|
||||
cmd = xmalloc(sizeof(struct command) + len - 80);
|
||||
memcpy(cmd->old_sha1, old_sha1, 20);
|
||||
memcpy(cmd->new_sha1, new_sha1, 20);
|
||||
hashcpy(cmd->old_sha1, old_sha1);
|
||||
hashcpy(cmd->new_sha1, new_sha1);
|
||||
memcpy(cmd->ref_name, line + 82, len - 81);
|
||||
cmd->error_string = "n/a (unpacker error)";
|
||||
cmd->next = NULL;
|
||||
|
2
refs.c
2
refs.c
@ -29,7 +29,7 @@ const char *resolve_ref(const char *path, unsigned char *sha1, int reading)
|
||||
if (lstat(path, &st) < 0) {
|
||||
if (reading || errno != ENOENT)
|
||||
return NULL;
|
||||
memset(sha1, 0, 20);
|
||||
hashclr(sha1);
|
||||
return path;
|
||||
}
|
||||
|
||||
|
@ -496,7 +496,7 @@ static int add_parents_only(struct rev_info *revs, const char *arg, int flags)
|
||||
it = get_reference(revs, arg, sha1, 0);
|
||||
if (it->type != OBJ_TAG)
|
||||
break;
|
||||
memcpy(sha1, ((struct tag*)it)->tagged->sha1, 20);
|
||||
hashcpy(sha1, ((struct tag*)it)->tagged->sha1);
|
||||
}
|
||||
if (it->type != OBJ_COMMIT)
|
||||
return 0;
|
||||
|
@ -185,7 +185,7 @@ static int one_local_ref(const char *refname, const unsigned char *sha1)
|
||||
struct ref *ref;
|
||||
int len = strlen(refname) + 1;
|
||||
ref = xcalloc(1, sizeof(*ref) + len);
|
||||
memcpy(ref->new_sha1, sha1, 20);
|
||||
hashcpy(ref->new_sha1, sha1);
|
||||
memcpy(ref->name, refname, len);
|
||||
*local_tail = ref;
|
||||
local_tail = &ref->next;
|
||||
@ -310,7 +310,7 @@ static int send_pack(int in, int out, int nr_refspec, char **refspec)
|
||||
continue;
|
||||
}
|
||||
}
|
||||
memcpy(ref->new_sha1, ref->peer_ref->new_sha1, 20);
|
||||
hashcpy(ref->new_sha1, ref->peer_ref->new_sha1);
|
||||
if (is_zero_sha1(ref->new_sha1)) {
|
||||
error("cannot happen anymore");
|
||||
ret = -3;
|
||||
|
18
sha1_file.c
18
sha1_file.c
@ -540,7 +540,7 @@ struct packed_git *add_packed_git(char *path, int path_len, int local)
|
||||
p->pack_use_cnt = 0;
|
||||
p->pack_local = local;
|
||||
if ((path_len > 44) && !get_sha1_hex(path + path_len - 44, sha1))
|
||||
memcpy(p->sha1, sha1, 20);
|
||||
hashcpy(p->sha1, sha1);
|
||||
return p;
|
||||
}
|
||||
|
||||
@ -571,7 +571,7 @@ struct packed_git *parse_pack_index_file(const unsigned char *sha1, char *idx_pa
|
||||
p->pack_base = NULL;
|
||||
p->pack_last_used = 0;
|
||||
p->pack_use_cnt = 0;
|
||||
memcpy(p->sha1, sha1, 20);
|
||||
hashcpy(p->sha1, sha1);
|
||||
return p;
|
||||
}
|
||||
|
||||
@ -953,7 +953,7 @@ int check_reuse_pack_delta(struct packed_git *p, unsigned long offset,
|
||||
ptr = unpack_object_header(p, ptr, kindp, sizep);
|
||||
if (*kindp != OBJ_DELTA)
|
||||
goto done;
|
||||
memcpy(base, (unsigned char *) p->pack_base + ptr, 20);
|
||||
hashcpy(base, (unsigned char *) p->pack_base + ptr);
|
||||
status = 0;
|
||||
done:
|
||||
unuse_packed_git(p);
|
||||
@ -981,7 +981,7 @@ void packed_object_info_detail(struct pack_entry *e,
|
||||
if (p->pack_size <= offset + 20)
|
||||
die("pack file %s records an incomplete delta base",
|
||||
p->pack_name);
|
||||
memcpy(base_sha1, pack, 20);
|
||||
hashcpy(base_sha1, pack);
|
||||
do {
|
||||
struct pack_entry base_ent;
|
||||
unsigned long junk;
|
||||
@ -1201,7 +1201,7 @@ int nth_packed_object_sha1(const struct packed_git *p, int n,
|
||||
void *index = p->index_base + 256;
|
||||
if (n < 0 || num_packed_objects(p) <= n)
|
||||
return -1;
|
||||
memcpy(sha1, (char *) index + (24 * n) + 4, 20);
|
||||
hashcpy(sha1, (unsigned char *) index + (24 * n) + 4);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1218,7 +1218,7 @@ int find_pack_entry_one(const unsigned char *sha1,
|
||||
int cmp = hashcmp((unsigned char *)index + (24 * mi) + 4, sha1);
|
||||
if (!cmp) {
|
||||
e->offset = ntohl(*((unsigned int *) ((char *) index + (24 * mi))));
|
||||
memcpy(e->sha1, sha1, 20);
|
||||
hashcpy(e->sha1, sha1);
|
||||
e->p = p;
|
||||
return 1;
|
||||
}
|
||||
@ -1331,7 +1331,7 @@ void *read_object_with_reference(const unsigned char *sha1,
|
||||
unsigned long isize;
|
||||
unsigned char actual_sha1[20];
|
||||
|
||||
memcpy(actual_sha1, sha1, 20);
|
||||
hashcpy(actual_sha1, sha1);
|
||||
while (1) {
|
||||
int ref_length = -1;
|
||||
const char *ref_type = NULL;
|
||||
@ -1342,7 +1342,7 @@ void *read_object_with_reference(const unsigned char *sha1,
|
||||
if (!strcmp(type, required_type)) {
|
||||
*size = isize;
|
||||
if (actual_sha1_return)
|
||||
memcpy(actual_sha1_return, actual_sha1, 20);
|
||||
hashcpy(actual_sha1_return, actual_sha1);
|
||||
return buffer;
|
||||
}
|
||||
/* Handle references */
|
||||
@ -1537,7 +1537,7 @@ int write_sha1_file(void *buf, unsigned long len, const char *type, unsigned cha
|
||||
*/
|
||||
filename = write_sha1_file_prepare(buf, len, type, sha1, hdr, &hdrlen);
|
||||
if (returnsha1)
|
||||
memcpy(returnsha1, sha1, 20);
|
||||
hashcpy(returnsha1, sha1);
|
||||
if (has_sha1_file(sha1))
|
||||
return 0;
|
||||
fd = open(filename, O_RDONLY);
|
||||
|
22
sha1_name.c
22
sha1_name.c
@ -103,7 +103,7 @@ static int find_short_packed_object(int len, const unsigned char *match, unsigne
|
||||
!match_sha(len, match, next)) {
|
||||
/* unique within this pack */
|
||||
if (!found) {
|
||||
memcpy(found_sha1, now, 20);
|
||||
hashcpy(found_sha1, now);
|
||||
found++;
|
||||
}
|
||||
else if (hashcmp(found_sha1, now)) {
|
||||
@ -120,7 +120,7 @@ static int find_short_packed_object(int len, const unsigned char *match, unsigne
|
||||
}
|
||||
}
|
||||
if (found == 1)
|
||||
memcpy(sha1, found_sha1, 20);
|
||||
hashcpy(sha1, found_sha1);
|
||||
return found;
|
||||
}
|
||||
|
||||
@ -140,13 +140,13 @@ static int find_unique_short_object(int len, char *canonical,
|
||||
if (1 < has_unpacked || 1 < has_packed)
|
||||
return SHORT_NAME_AMBIGUOUS;
|
||||
if (has_unpacked != has_packed) {
|
||||
memcpy(sha1, (has_packed ? packed_sha1 : unpacked_sha1), 20);
|
||||
hashcpy(sha1, (has_packed ? packed_sha1 : unpacked_sha1));
|
||||
return 0;
|
||||
}
|
||||
/* Both have unique ones -- do they match? */
|
||||
if (hashcmp(packed_sha1, unpacked_sha1))
|
||||
return SHORT_NAME_AMBIGUOUS;
|
||||
memcpy(sha1, packed_sha1, 20);
|
||||
hashcpy(sha1, packed_sha1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -320,13 +320,13 @@ static int get_parent(const char *name, int len,
|
||||
if (parse_commit(commit))
|
||||
return -1;
|
||||
if (!idx) {
|
||||
memcpy(result, commit->object.sha1, 20);
|
||||
hashcpy(result, commit->object.sha1);
|
||||
return 0;
|
||||
}
|
||||
p = commit->parents;
|
||||
while (p) {
|
||||
if (!--idx) {
|
||||
memcpy(result, p->item->object.sha1, 20);
|
||||
hashcpy(result, p->item->object.sha1);
|
||||
return 0;
|
||||
}
|
||||
p = p->next;
|
||||
@ -347,9 +347,9 @@ static int get_nth_ancestor(const char *name, int len,
|
||||
|
||||
if (!commit || parse_commit(commit) || !commit->parents)
|
||||
return -1;
|
||||
memcpy(sha1, commit->parents->item->object.sha1, 20);
|
||||
hashcpy(sha1, commit->parents->item->object.sha1);
|
||||
}
|
||||
memcpy(result, sha1, 20);
|
||||
hashcpy(result, sha1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -401,7 +401,7 @@ static int peel_onion(const char *name, int len, unsigned char *sha1)
|
||||
o = deref_tag(o, name, sp - name - 2);
|
||||
if (!o || (!o->parsed && !parse_object(o->sha1)))
|
||||
return -1;
|
||||
memcpy(sha1, o->sha1, 20);
|
||||
hashcpy(sha1, o->sha1);
|
||||
}
|
||||
else {
|
||||
/* At this point, the syntax look correct, so
|
||||
@ -413,7 +413,7 @@ static int peel_onion(const char *name, int len, unsigned char *sha1)
|
||||
if (!o || (!o->parsed && !parse_object(o->sha1)))
|
||||
return -1;
|
||||
if (o->type == expected_type) {
|
||||
memcpy(sha1, o->sha1, 20);
|
||||
hashcpy(sha1, o->sha1);
|
||||
return 0;
|
||||
}
|
||||
if (o->type == OBJ_TAG)
|
||||
@ -520,7 +520,7 @@ int get_sha1(const char *name, unsigned char *sha1)
|
||||
memcmp(ce->name, cp, namelen))
|
||||
break;
|
||||
if (ce_stage(ce) == stage) {
|
||||
memcpy(sha1, ce->sha1, 20);
|
||||
hashcpy(sha1, ce->sha1);
|
||||
return 0;
|
||||
}
|
||||
pos++;
|
||||
|
@ -179,7 +179,7 @@ static int find_tree_entry(struct tree_desc *t, const char *name, unsigned char
|
||||
if (cmp < 0)
|
||||
break;
|
||||
if (entrylen == namelen) {
|
||||
memcpy(result, sha1, 20);
|
||||
hashcpy(result, sha1);
|
||||
return 0;
|
||||
}
|
||||
if (name[entrylen] != '/')
|
||||
@ -187,7 +187,7 @@ static int find_tree_entry(struct tree_desc *t, const char *name, unsigned char
|
||||
if (!S_ISDIR(*mode))
|
||||
break;
|
||||
if (++entrylen == namelen) {
|
||||
memcpy(result, sha1, 20);
|
||||
hashcpy(result, sha1);
|
||||
return 0;
|
||||
}
|
||||
return get_tree_entry(sha1, name + entrylen, result, mode);
|
||||
|
2
tree.c
2
tree.c
@ -25,7 +25,7 @@ static int read_one_entry(const unsigned char *sha1, const char *base, int basel
|
||||
ce->ce_flags = create_ce_flags(baselen + len, stage);
|
||||
memcpy(ce->name, base, baselen);
|
||||
memcpy(ce->name + baselen, pathname, len+1);
|
||||
memcpy(ce->sha1, sha1, 20);
|
||||
hashcpy(ce->sha1, sha1);
|
||||
return add_cache_entry(ce, ADD_CACHE_OK_TO_ADD|ADD_CACHE_SKIP_DFCHECK);
|
||||
}
|
||||
|
||||
|
@ -200,7 +200,7 @@ static int unpack_trees_rec(struct tree_entry_list **posns, int len,
|
||||
|
||||
any_files = 1;
|
||||
|
||||
memcpy(ce->sha1, posns[i]->sha1, 20);
|
||||
hashcpy(ce->sha1, posns[i]->sha1);
|
||||
src[i + o->merge] = ce;
|
||||
subposns[i] = df_conflict_list;
|
||||
posns[i] = posns[i]->next;
|
||||
|
@ -374,7 +374,7 @@ static int get_common_commits(void)
|
||||
sha1_to_hex(sha1),
|
||||
multi_ack ? " continue" : "");
|
||||
if (multi_ack)
|
||||
memcpy(last_sha1, sha1, 20);
|
||||
hashcpy(last_sha1, sha1);
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user