kernel
/
git
mirror of https://git.kernel.org/pub/scm/git/git.git
1
0
Fork 0
Code Releases Activity

sha1_file: convert index_path and index_fd to struct object_id 

Convert these two functions and the functions that underlie them to take
pointers to struct object_id.  This is a prerequisite to convert
resolve_gitlink_ref.  Fix a stray tab in the middle of the index_mem
call in index_pipe by converting it to a space.

Signed-off-by: brian m. carlson <sandals@crustytoothpaste.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
maint
brian m. carlson 2017-10-15 22:07:05 +00:00 committed by Junio C Hamano
parent 0155f710b8
commit bcd2986473
1 changed files with 15 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
sha1_file.c
View File

@ -1664,7 +1664,7 @@ static void check_tag(const void *buf, size_t size)
die("corrupt tag"); die("corrupt tag");
} }


static int index_mem(unsigned char *sha1, void *buf, size_t size, static int index_mem(struct object_id *oid, void *buf, size_t size,
enum object_type type, enum object_type type,
const char *path, unsigned flags) const char *path, unsigned flags)
{ {
@ -1695,15 +1695,15 @@ static int index_mem(unsigned char *sha1, void *buf, size_t size,
} }


if (write_object) if (write_object)
ret = write_sha1_file(buf, size, typename(type), sha1); ret = write_sha1_file(buf, size, typename(type), oid->hash);
else else
ret = hash_sha1_file(buf, size, typename(type), sha1); ret = hash_sha1_file(buf, size, typename(type), oid->hash);
if (re_allocated) if (re_allocated)
free(buf); free(buf);
return ret; return ret;
} }


static int index_stream_convert_blob(unsigned char *sha1, int fd, static int index_stream_convert_blob(struct object_id *oid, int fd,
const char *path, unsigned flags) const char *path, unsigned flags)
{ {
int ret; int ret;
@ -1718,22 +1718,22 @@ static int index_stream_convert_blob(unsigned char *sha1, int fd,


if (write_object) if (write_object)
ret = write_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB), ret = write_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB),
sha1); oid->hash);
else else
ret = hash_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB), ret = hash_sha1_file(sbuf.buf, sbuf.len, typename(OBJ_BLOB),
sha1); oid->hash);
strbuf_release(&sbuf); strbuf_release(&sbuf);
return ret; return ret;
} }


static int index_pipe(unsigned char *sha1, int fd, enum object_type type, static int index_pipe(struct object_id *oid, int fd, enum object_type type,
const char *path, unsigned flags) const char *path, unsigned flags)
{ {
struct strbuf sbuf = STRBUF_INIT; struct strbuf sbuf = STRBUF_INIT;
int ret; int ret;


if (strbuf_read(&sbuf, fd, 4096) >= 0) if (strbuf_read(&sbuf, fd, 4096) >= 0)
ret = index_mem(sha1, sbuf.buf, sbuf.len, type, path, flags); ret = index_mem(oid, sbuf.buf, sbuf.len, type, path, flags);
else else
ret = -1; ret = -1;
strbuf_release(&sbuf); strbuf_release(&sbuf);
@ -1742,14 +1742,14 @@ static int index_pipe(unsigned char *sha1, int fd, enum object_type type,


#define SMALL_FILE_SIZE (32*1024) #define SMALL_FILE_SIZE (32*1024)


static int index_core(unsigned char *sha1, int fd, size_t size, static int index_core(struct object_id *oid, int fd, size_t size,
enum object_type type, const char *path, enum object_type type, const char *path,
unsigned flags) unsigned flags)
{ {
int ret; int ret;


if (!size) { if (!size) {
ret = index_mem(sha1, "", size, type, path, flags); ret = index_mem(oid, "", size, type, path, flags);
} else if (size <= SMALL_FILE_SIZE) { } else if (size <= SMALL_FILE_SIZE) {
char *buf = xmalloc(size); char *buf = xmalloc(size);
ssize_t read_result = read_in_full(fd, buf, size); ssize_t read_result = read_in_full(fd, buf, size);
@ -1760,11 +1760,11 @@ static int index_core(unsigned char *sha1, int fd, size_t size,
ret = error("short read while indexing %s", ret = error("short read while indexing %s",
path ? path : "<unknown>"); path ? path : "<unknown>");
else else
ret = index_mem(sha1, buf, size, type, path, flags); ret = index_mem(oid, buf, size, type, path, flags);
free(buf); free(buf);
} else { } else {
void *buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0); void *buf = xmmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
ret = index_mem(sha1, buf, size, type, path, flags); ret = index_mem(oid, buf, size, type, path, flags);
munmap(buf, size); munmap(buf, size);
} }
return ret; return ret;
@ -1802,12 +1802,12 @@ int index_fd(struct object_id *oid, int fd, struct stat *st,
* die() for large files. * die() for large files.
*/ */
if (type == OBJ_BLOB && path && would_convert_to_git_filter_fd(path)) if (type == OBJ_BLOB && path && would_convert_to_git_filter_fd(path))
ret = index_stream_convert_blob(oid->hash, fd, path, flags); ret = index_stream_convert_blob(oid, fd, path, flags);
else if (!S_ISREG(st->st_mode)) else if (!S_ISREG(st->st_mode))
ret = index_pipe(oid->hash, fd, type, path, flags); ret = index_pipe(oid, fd, type, path, flags);
else if (st->st_size <= big_file_threshold || type != OBJ_BLOB || else if (st->st_size <= big_file_threshold || type != OBJ_BLOB ||
(path && would_convert_to_git(&the_index, path))) (path && would_convert_to_git(&the_index, path)))
ret = index_core(oid->hash, fd, xsize_t(st->st_size), type, path, ret = index_core(oid, fd, xsize_t(st->st_size), type, path,
flags); flags);
else else
ret = index_stream(oid, fd, xsize_t(st->st_size), type, path, ret = index_stream(oid, fd, xsize_t(st->st_size), type, path,