Merge branch 'ff/c99'
* ff/c99: Remove all void-pointer arithmetic. Change types used in bitfields to be `int's. Don't use empty structure initializers. Cast pointers to `void *' when used in a format. Don't instantiate structures with FAMs. Initialize FAMs using `FLEX_ARRAY'. Remove ranges from switch statements.
This commit is contained in:
commit
e94528a0e9
4
blame.c
4
blame.c
@ -301,9 +301,9 @@ static void fill_line_map(struct commit *commit, struct commit *other,
|
||||
if (DEBUG)
|
||||
printf("map: i1: %d %d %p i2: %d %d %p\n",
|
||||
i1, map[i1],
|
||||
i1 != -1 ? blame_lines[map[i1]] : NULL,
|
||||
(void *) (i1 != -1 ? blame_lines[map[i1]] : NULL),
|
||||
i2, map2[i2],
|
||||
i2 != -1 ? blame_lines[map2[i2]] : NULL);
|
||||
(void *) (i2 != -1 ? blame_lines[map2[i2]] : NULL));
|
||||
if (map2[i2] != -1 &&
|
||||
blame_lines[map[i1]] &&
|
||||
!blame_lines[map2[i2]])
|
||||
|
@ -148,7 +148,7 @@ static void *read_patch_file(int fd, unsigned long *sizep)
|
||||
buffer = xrealloc(buffer, alloc);
|
||||
nr = alloc - size;
|
||||
}
|
||||
nr = xread(fd, buffer + size, nr);
|
||||
nr = xread(fd, (char *) buffer + size, nr);
|
||||
if (!nr)
|
||||
break;
|
||||
if (nr < 0)
|
||||
@ -164,7 +164,7 @@ static void *read_patch_file(int fd, unsigned long *sizep)
|
||||
*/
|
||||
if (alloc < size + SLOP)
|
||||
buffer = xrealloc(buffer, size + SLOP);
|
||||
memset(buffer + size, 0, SLOP);
|
||||
memset((char *) buffer + size, 0, SLOP);
|
||||
return buffer;
|
||||
}
|
||||
|
||||
@ -1194,7 +1194,7 @@ static int read_old_data(struct stat *st, const char *path, void *buf, unsigned
|
||||
return error("unable to open %s", path);
|
||||
got = 0;
|
||||
for (;;) {
|
||||
int ret = xread(fd, buf + got, size - got);
|
||||
int ret = xread(fd, (char *) buf + got, size - got);
|
||||
if (ret <= 0)
|
||||
break;
|
||||
got += ret;
|
||||
|
@ -31,8 +31,7 @@ static int merge_size = 0;
|
||||
|
||||
static struct object_list *trees = NULL;
|
||||
|
||||
static struct cache_entry df_conflict_entry = {
|
||||
};
|
||||
static struct cache_entry df_conflict_entry;
|
||||
|
||||
struct tree_entry_list {
|
||||
struct tree_entry_list *next;
|
||||
|
@ -103,12 +103,12 @@ 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, buffer + len - 20, 20);
|
||||
memcpy(new + newlen, (char *) buffer + len - 20, 20);
|
||||
newlen += 20;
|
||||
|
||||
used += len;
|
||||
size -= len;
|
||||
buffer += len;
|
||||
buffer = (char *) buffer + len;
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -121,7 +121,7 @@ static int write_subdirectory(void *buffer, unsigned long size, const char *base
|
||||
|
||||
used += len;
|
||||
size -= len;
|
||||
buffer += len;
|
||||
buffer = (char *) buffer + len;
|
||||
}
|
||||
|
||||
write_sha1_file(new, newlen, tree_type, result_sha1);
|
||||
@ -137,13 +137,13 @@ static void convert_tree(void *buffer, unsigned long size, unsigned char *result
|
||||
while (size) {
|
||||
int len = 1+strlen(buffer);
|
||||
|
||||
convert_binary_sha1(buffer + len);
|
||||
convert_binary_sha1((char *) buffer + len);
|
||||
|
||||
len += 20;
|
||||
if (len > size)
|
||||
die("corrupt tree object");
|
||||
size -= len;
|
||||
buffer += len;
|
||||
buffer = (char *) buffer + len;
|
||||
}
|
||||
|
||||
write_subdirectory(orig_buffer, orig_size, "", 0, result_sha1);
|
||||
@ -244,14 +244,14 @@ static void convert_date(void *buffer, unsigned long size, unsigned char *result
|
||||
// "tree <sha1>\n"
|
||||
memcpy(new + newlen, buffer, 46);
|
||||
newlen += 46;
|
||||
buffer += 46;
|
||||
buffer = (char *) buffer + 46;
|
||||
size -= 46;
|
||||
|
||||
// "parent <sha1>\n"
|
||||
while (!memcmp(buffer, "parent ", 7)) {
|
||||
memcpy(new + newlen, buffer, 48);
|
||||
newlen += 48;
|
||||
buffer += 48;
|
||||
buffer = (char *) buffer + 48;
|
||||
size -= 48;
|
||||
}
|
||||
|
||||
@ -275,11 +275,11 @@ static void convert_commit(void *buffer, unsigned long size, unsigned char *resu
|
||||
|
||||
if (memcmp(buffer, "tree ", 5))
|
||||
die("Bad commit '%s'", (char*) buffer);
|
||||
convert_ascii_sha1(buffer+5);
|
||||
buffer += 46; /* "tree " + "hex sha1" + "\n" */
|
||||
convert_ascii_sha1((char *) buffer + 5);
|
||||
buffer = (char *) buffer + 46; /* "tree " + "hex sha1" + "\n" */
|
||||
while (!memcmp(buffer, "parent ", 7)) {
|
||||
convert_ascii_sha1(buffer+7);
|
||||
buffer += 48;
|
||||
convert_ascii_sha1((char *) buffer + 7);
|
||||
buffer = (char *) buffer + 48;
|
||||
}
|
||||
convert_date(orig_buffer, orig_size, result_sha1);
|
||||
}
|
||||
|
@ -17,7 +17,7 @@ static int sha1flush(struct sha1file *f, unsigned int count)
|
||||
for (;;) {
|
||||
int ret = xwrite(f->fd, buf, count);
|
||||
if (ret > 0) {
|
||||
buf += ret;
|
||||
buf = (char *) buf + ret;
|
||||
count -= ret;
|
||||
if (count)
|
||||
continue;
|
||||
@ -57,7 +57,7 @@ int sha1write(struct sha1file *f, void *buf, unsigned int count)
|
||||
memcpy(f->buffer + offset, buf, nr);
|
||||
count -= nr;
|
||||
offset += nr;
|
||||
buf += nr;
|
||||
buf = (char *) buf + nr;
|
||||
left -= nr;
|
||||
if (!left) {
|
||||
SHA1_Update(&f->ctx, f->buffer, offset);
|
||||
|
@ -22,6 +22,7 @@
|
||||
#include <string.h>
|
||||
#include "delta.h"
|
||||
|
||||
#include "git-compat-util.h"
|
||||
|
||||
/* maximum hash entry list for the same hash bucket */
|
||||
#define HASH_LIMIT 64
|
||||
@ -131,7 +132,7 @@ struct delta_index {
|
||||
const void *src_buf;
|
||||
unsigned long src_size;
|
||||
unsigned int hash_mask;
|
||||
struct index_entry *hash[0];
|
||||
struct index_entry *hash[FLEX_ARRAY];
|
||||
};
|
||||
|
||||
struct delta_index * create_delta_index(const void *buf, unsigned long bufsize)
|
||||
@ -283,7 +284,7 @@ create_delta(const struct delta_index *index,
|
||||
ref_data = index->src_buf;
|
||||
ref_top = ref_data + index->src_size;
|
||||
data = trg_buf;
|
||||
top = trg_buf + trg_size;
|
||||
top = (const unsigned char *) trg_buf + trg_size;
|
||||
|
||||
outpos++;
|
||||
val = 0;
|
||||
|
41
diff-lib.c
41
diff-lib.c
@ -34,21 +34,23 @@ int run_diff_files(struct rev_info *revs, int silent_on_removed)
|
||||
continue;
|
||||
|
||||
if (ce_stage(ce)) {
|
||||
struct {
|
||||
struct combine_diff_path p;
|
||||
struct combine_diff_parent filler[5];
|
||||
} combine;
|
||||
struct combine_diff_path *dpath;
|
||||
int num_compare_stages = 0;
|
||||
size_t path_len;
|
||||
|
||||
combine.p.next = NULL;
|
||||
combine.p.len = ce_namelen(ce);
|
||||
combine.p.path = xmalloc(combine.p.len + 1);
|
||||
memcpy(combine.p.path, ce->name, combine.p.len);
|
||||
combine.p.path[combine.p.len] = 0;
|
||||
combine.p.mode = 0;
|
||||
memset(combine.p.sha1, 0, 20);
|
||||
memset(&combine.p.parent[0], 0,
|
||||
sizeof(combine.filler));
|
||||
path_len = ce_namelen(ce);
|
||||
|
||||
dpath = xmalloc (combine_diff_path_size (5, path_len));
|
||||
dpath->path = (char *) &(dpath->parent[5]);
|
||||
|
||||
dpath->next = NULL;
|
||||
dpath->len = path_len;
|
||||
memcpy(dpath->path, ce->name, path_len);
|
||||
dpath->path[path_len] = '\0';
|
||||
dpath->mode = 0;
|
||||
memset(dpath->sha1, 0, 20);
|
||||
memset(&(dpath->parent[0]), 0,
|
||||
sizeof(struct combine_diff_parent)*5);
|
||||
|
||||
while (i < entries) {
|
||||
struct cache_entry *nce = active_cache[i];
|
||||
@ -64,11 +66,11 @@ 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(combine.p.parent[stage-2].sha1,
|
||||
memcpy(dpath->parent[stage-2].sha1,
|
||||
nce->sha1, 20);
|
||||
combine.p.parent[stage-2].mode =
|
||||
dpath->parent[stage-2].mode =
|
||||
canon_mode(mode);
|
||||
combine.p.parent[stage-2].status =
|
||||
dpath->parent[stage-2].status =
|
||||
DIFF_STATUS_MODIFIED;
|
||||
}
|
||||
|
||||
@ -83,13 +85,14 @@ int run_diff_files(struct rev_info *revs, int silent_on_removed)
|
||||
i--;
|
||||
|
||||
if (revs->combine_merges && num_compare_stages == 2) {
|
||||
show_combined_diff(&combine.p, 2,
|
||||
show_combined_diff(dpath, 2,
|
||||
revs->dense_combined_merges,
|
||||
revs);
|
||||
free(combine.p.path);
|
||||
free(dpath);
|
||||
continue;
|
||||
}
|
||||
free(combine.p.path);
|
||||
free(dpath);
|
||||
dpath = NULL;
|
||||
|
||||
/*
|
||||
* Show the diff for the 'ce' if we found the one
|
||||
|
2
diff.c
2
diff.c
@ -515,7 +515,7 @@ static void emit_binary_diff(mmfile_t *one, mmfile_t *two)
|
||||
else
|
||||
line[0] = bytes - 26 + 'a' - 1;
|
||||
encode_85(line + 1, cp, bytes);
|
||||
cp += bytes;
|
||||
cp = (char *) cp + bytes;
|
||||
puts(line);
|
||||
}
|
||||
printf("\n");
|
||||
|
@ -30,7 +30,7 @@ static void prepare_order(const char *orderfile)
|
||||
close(fd);
|
||||
if (map == MAP_FAILED)
|
||||
return;
|
||||
endp = map + st.st_size;
|
||||
endp = (char *) map + st.st_size;
|
||||
for (pass = 0; pass < 2; pass++) {
|
||||
cnt = 0;
|
||||
cp = map;
|
||||
|
15
http-fetch.c
15
http-fetch.c
@ -123,7 +123,7 @@ static size_t fwrite_sha1_file(void *ptr, size_t eltsize, size_t nmemb,
|
||||
struct object_request *obj_req = (struct object_request *)data;
|
||||
do {
|
||||
ssize_t retval = write(obj_req->local,
|
||||
ptr + posn, size - posn);
|
||||
(char *) ptr + posn, size - posn);
|
||||
if (retval < 0)
|
||||
return posn;
|
||||
posn += retval;
|
||||
@ -1136,13 +1136,14 @@ int fetch(unsigned char *sha1)
|
||||
|
||||
static inline int needs_quote(int ch)
|
||||
{
|
||||
switch (ch) {
|
||||
case '/': case '-': case '.':
|
||||
case 'A'...'Z': case 'a'...'z': case '0'...'9':
|
||||
if (((ch >= 'A') && (ch <= 'Z'))
|
||||
|| ((ch >= 'a') && (ch <= 'z'))
|
||||
|| ((ch >= '0') && (ch <= '9'))
|
||||
|| (ch == '/')
|
||||
|| (ch == '-')
|
||||
|| (ch == '.'))
|
||||
return 0;
|
||||
default:
|
||||
return 1;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static inline int hex(int v)
|
||||
|
15
http-push.c
15
http-push.c
@ -196,7 +196,7 @@ static size_t fwrite_sha1_file(void *ptr, size_t eltsize, size_t nmemb,
|
||||
struct transfer_request *request = (struct transfer_request *)data;
|
||||
do {
|
||||
ssize_t retval = write(request->local_fileno,
|
||||
ptr + posn, size - posn);
|
||||
(char *) ptr + posn, size - posn);
|
||||
if (retval < 0)
|
||||
return posn;
|
||||
posn += retval;
|
||||
@ -1077,13 +1077,14 @@ static int fetch_indices(void)
|
||||
|
||||
static inline int needs_quote(int ch)
|
||||
{
|
||||
switch (ch) {
|
||||
case '/': case '-': case '.':
|
||||
case 'A'...'Z': case 'a'...'z': case '0'...'9':
|
||||
if (((ch >= 'A') && (ch <= 'Z'))
|
||||
|| ((ch >= 'a') && (ch <= 'z'))
|
||||
|| ((ch >= '0') && (ch <= '9'))
|
||||
|| (ch == '/')
|
||||
|| (ch == '-')
|
||||
|| (ch == '.'))
|
||||
return 0;
|
||||
default:
|
||||
return 1;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static inline int hex(int v)
|
||||
|
4
http.c
4
http.c
@ -34,7 +34,7 @@ size_t fread_buffer(void *ptr, size_t eltsize, size_t nmemb,
|
||||
size_t size = eltsize * nmemb;
|
||||
if (size > buffer->size - buffer->posn)
|
||||
size = buffer->size - buffer->posn;
|
||||
memcpy(ptr, buffer->buffer + buffer->posn, size);
|
||||
memcpy(ptr, (char *) buffer->buffer + buffer->posn, size);
|
||||
buffer->posn += size;
|
||||
return size;
|
||||
}
|
||||
@ -49,7 +49,7 @@ size_t fwrite_buffer(const void *ptr, size_t eltsize,
|
||||
buffer->size = buffer->posn + size;
|
||||
buffer->buffer = xrealloc(buffer->buffer, buffer->size);
|
||||
}
|
||||
memcpy(buffer->buffer + buffer->posn, ptr, size);
|
||||
memcpy((char *) buffer->buffer + buffer->posn, ptr, size);
|
||||
buffer->posn += size;
|
||||
data_received++;
|
||||
return size;
|
||||
|
@ -93,7 +93,7 @@ typedef struct {
|
||||
char *data;
|
||||
int len;
|
||||
unsigned char flags;
|
||||
unsigned char crlf:1;
|
||||
unsigned int crlf:1;
|
||||
} msg_data_t;
|
||||
|
||||
#define DRV_OK 0
|
||||
|
@ -29,10 +29,10 @@ static int verify_packfile(struct packed_git *p)
|
||||
pack_base = p->pack_base;
|
||||
SHA1_Update(&ctx, pack_base, pack_size - 20);
|
||||
SHA1_Final(sha1, &ctx);
|
||||
if (memcmp(sha1, pack_base + pack_size - 20, 20))
|
||||
if (memcmp(sha1, (char *) pack_base + pack_size - 20, 20))
|
||||
return error("Packfile %s SHA1 mismatch with itself",
|
||||
p->pack_name);
|
||||
if (memcmp(sha1, index_base + index_size - 40, 20))
|
||||
if (memcmp(sha1, (char *) index_base + index_size - 40, 20))
|
||||
return error("Packfile %s SHA1 mismatch with idx",
|
||||
p->pack_name);
|
||||
|
||||
@ -135,7 +135,7 @@ int verify_pack(struct packed_git *p, int verbose)
|
||||
SHA1_Init(&ctx);
|
||||
SHA1_Update(&ctx, index_base, index_size - 20);
|
||||
SHA1_Final(sha1, &ctx);
|
||||
if (memcmp(sha1, index_base + index_size - 20, 20))
|
||||
if (memcmp(sha1, (char *) index_base + index_size - 20, 20))
|
||||
ret = error("Packfile index for %s SHA1 mismatch",
|
||||
p->pack_name);
|
||||
|
||||
|
@ -156,7 +156,7 @@ static void prepare_pack_revindex(struct pack_revindex *rix)
|
||||
|
||||
rix->revindex = xmalloc(sizeof(unsigned long) * (num_ent + 1));
|
||||
for (i = 0; i < num_ent; i++) {
|
||||
unsigned int hl = *((unsigned int *)(index + 24 * i));
|
||||
unsigned int hl = *((unsigned int *)((char *) index + 24*i));
|
||||
rix->revindex[i] = ntohl(hl);
|
||||
}
|
||||
/* This knows the pack format -- the 20-byte trailer
|
||||
@ -300,7 +300,7 @@ static unsigned long write_object(struct sha1file *f,
|
||||
use_packed_git(p);
|
||||
|
||||
datalen = find_packed_object_size(p, entry->in_pack_offset);
|
||||
buf = p->pack_base + entry->in_pack_offset;
|
||||
buf = (char *) p->pack_base + entry->in_pack_offset;
|
||||
sha1write(f, buf, datalen);
|
||||
unuse_packed_git(p);
|
||||
hdrlen = 0; /* not really */
|
||||
|
@ -246,12 +246,12 @@ static struct pack_list * pack_list_difference(const struct pack_list *A,
|
||||
static void cmp_two_packs(struct pack_list *p1, struct pack_list *p2)
|
||||
{
|
||||
int p1_off, p2_off;
|
||||
void *p1_base, *p2_base;
|
||||
unsigned char *p1_base, *p2_base;
|
||||
struct llist_item *p1_hint = NULL, *p2_hint = NULL;
|
||||
|
||||
|
||||
p1_off = p2_off = 256 * 4 + 4;
|
||||
p1_base = (void *)p1->pack->index_base;
|
||||
p2_base = (void *)p2->pack->index_base;
|
||||
p1_base = (unsigned char *) p1->pack->index_base;
|
||||
p2_base = (unsigned char *) p2->pack->index_base;
|
||||
|
||||
while (p1_off <= p1->pack->index_size - 3 * 20 &&
|
||||
p2_off <= p2->pack->index_size - 3 * 20)
|
||||
@ -351,11 +351,11 @@ static size_t sizeof_union(struct packed_git *p1, struct packed_git *p2)
|
||||
{
|
||||
size_t ret = 0;
|
||||
int p1_off, p2_off;
|
||||
void *p1_base, *p2_base;
|
||||
char *p1_base, *p2_base;
|
||||
|
||||
p1_off = p2_off = 256 * 4 + 4;
|
||||
p1_base = (void *)p1->index_base;
|
||||
p2_base = (void *)p2->index_base;
|
||||
p1_base = (char *)p1->index_base;
|
||||
p2_base = (char *)p2->index_base;
|
||||
|
||||
while (p1_off <= p1->index_size - 3 * 20 &&
|
||||
p2_off <= p2->index_size - 3 * 20)
|
||||
@ -534,7 +534,7 @@ static struct pack_list * add_pack(struct packed_git *p)
|
||||
{
|
||||
struct pack_list l;
|
||||
size_t off;
|
||||
void *base;
|
||||
unsigned char *base;
|
||||
|
||||
if (!p->pack_local && !(alt_odb || verbose))
|
||||
return NULL;
|
||||
@ -543,7 +543,7 @@ static struct pack_list * add_pack(struct packed_git *p)
|
||||
llist_init(&l.all_objects);
|
||||
|
||||
off = 256 * 4 + 4;
|
||||
base = (void *)p->index_base;
|
||||
base = (unsigned char *)p->index_base;
|
||||
while (off <= p->index_size - 3 * 20) {
|
||||
llist_insert_back(l.all_objects, base + off);
|
||||
off += 24;
|
||||
|
@ -25,7 +25,7 @@ void *patch_delta(const void *src_buf, unsigned long src_size,
|
||||
return NULL;
|
||||
|
||||
data = delta_buf;
|
||||
top = delta_buf + delta_size;
|
||||
top = (const unsigned char *) delta_buf + delta_size;
|
||||
|
||||
/* make sure the orig file size matches what we expect */
|
||||
size = get_delta_hdr_size(&data, top);
|
||||
@ -56,7 +56,7 @@ void *patch_delta(const void *src_buf, unsigned long src_size,
|
||||
cp_off + cp_size > src_size ||
|
||||
cp_size > size)
|
||||
goto bad;
|
||||
memcpy(out, src_buf + cp_off, cp_size);
|
||||
memcpy(out, (char *) src_buf + cp_off, cp_size);
|
||||
out += cp_size;
|
||||
size -= cp_size;
|
||||
} else if (cmd) {
|
||||
|
@ -21,7 +21,7 @@ static void safe_write(int fd, const void *buf, unsigned n)
|
||||
while (n) {
|
||||
int ret = xwrite(fd, buf, n);
|
||||
if (ret > 0) {
|
||||
buf += ret;
|
||||
buf = (char *) buf + ret;
|
||||
n -= ret;
|
||||
continue;
|
||||
}
|
||||
@ -66,7 +66,7 @@ static void safe_read(int fd, void *buffer, unsigned size)
|
||||
int n = 0;
|
||||
|
||||
while (n < size) {
|
||||
int ret = xread(fd, buffer + n, size - n);
|
||||
int ret = xread(fd, (char *) buffer + n, size - n);
|
||||
if (ret < 0)
|
||||
die("read error (%s)", strerror(errno));
|
||||
if (!ret)
|
||||
|
9
quote.c
9
quote.c
@ -206,7 +206,14 @@ char *unquote_c_style(const char *quoted, const char **endp)
|
||||
case '\\': case '"':
|
||||
break; /* verbatim */
|
||||
|
||||
case '0'...'7':
|
||||
case '0':
|
||||
case '1':
|
||||
case '2':
|
||||
case '3':
|
||||
case '4':
|
||||
case '5':
|
||||
case '6':
|
||||
case '7':
|
||||
/* octal */
|
||||
ac = ((ch - '0') << 6);
|
||||
if ((ch = *sp++) < '0' || '7' < ch)
|
||||
|
13
read-cache.c
13
read-cache.c
@ -706,7 +706,7 @@ static int verify_hdr(struct cache_header *hdr, unsigned long size)
|
||||
SHA1_Init(&c);
|
||||
SHA1_Update(&c, hdr, size - 20);
|
||||
SHA1_Final(sha1, &c);
|
||||
if (memcmp(sha1, (void *)hdr + size - 20, 20))
|
||||
if (memcmp(sha1, (char *) hdr + size - 20, 20))
|
||||
return error("bad index file sha1 signature");
|
||||
return 0;
|
||||
}
|
||||
@ -770,7 +770,7 @@ int read_cache(void)
|
||||
|
||||
offset = sizeof(*hdr);
|
||||
for (i = 0; i < active_nr; i++) {
|
||||
struct cache_entry *ce = map + offset;
|
||||
struct cache_entry *ce = (struct cache_entry *) ((char *) map + offset);
|
||||
offset = offset + ce_size(ce);
|
||||
active_cache[i] = ce;
|
||||
}
|
||||
@ -783,10 +783,11 @@ int read_cache(void)
|
||||
* in 4-byte network byte order.
|
||||
*/
|
||||
unsigned long extsize;
|
||||
memcpy(&extsize, map + offset + 4, 4);
|
||||
memcpy(&extsize, (char *) map + offset + 4, 4);
|
||||
extsize = ntohl(extsize);
|
||||
if (read_index_extension(map + offset,
|
||||
map + offset + 8, extsize) < 0)
|
||||
if (read_index_extension(((const char *) map) + offset,
|
||||
(char *) map + offset + 8,
|
||||
extsize) < 0)
|
||||
goto unmap;
|
||||
offset += 8;
|
||||
offset += extsize;
|
||||
@ -820,7 +821,7 @@ static int ce_write(SHA_CTX *context, int fd, void *data, unsigned int len)
|
||||
}
|
||||
write_buffer_len = buffered;
|
||||
len -= partial;
|
||||
data += partial;
|
||||
data = (char *) data + partial;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
29
sha1_file.c
29
sha1_file.c
@ -486,8 +486,9 @@ int use_packed_git(struct packed_git *p)
|
||||
* this is cheap.
|
||||
*/
|
||||
if (memcmp((char*)(p->index_base) + p->index_size - 40,
|
||||
p->pack_base + p->pack_size - 20, 20)) {
|
||||
|
||||
(char *) p->pack_base + p->pack_size - 20,
|
||||
20)) {
|
||||
|
||||
die("packfile %s does not match index.", p->pack_name);
|
||||
}
|
||||
}
|
||||
@ -701,7 +702,7 @@ static void *unpack_sha1_rest(z_stream *stream, void *buffer, unsigned long size
|
||||
int bytes = strlen(buffer) + 1;
|
||||
unsigned char *buf = xmalloc(1+size);
|
||||
|
||||
memcpy(buf, buffer + bytes, stream->total_out - bytes);
|
||||
memcpy(buf, (char *) buffer + bytes, stream->total_out - bytes);
|
||||
bytes = stream->total_out - bytes;
|
||||
if (bytes < size) {
|
||||
stream->next_out = buf + bytes;
|
||||
@ -853,7 +854,7 @@ static unsigned long unpack_object_header(struct packed_git *p, unsigned long of
|
||||
if (offset >= p->pack_size)
|
||||
die("object offset outside of pack file");
|
||||
|
||||
pack = p->pack_base + offset;
|
||||
pack = (unsigned char *) p->pack_base + offset;
|
||||
c = *pack++;
|
||||
offset++;
|
||||
*type = (c >> 4) & 7;
|
||||
@ -883,7 +884,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, p->pack_base + ptr, 20);
|
||||
memcpy(base, (char *) p->pack_base + ptr, 20);
|
||||
status = 0;
|
||||
done:
|
||||
unuse_packed_git(p);
|
||||
@ -903,7 +904,7 @@ void packed_object_info_detail(struct pack_entry *e,
|
||||
enum object_type kind;
|
||||
|
||||
offset = unpack_object_header(p, e->offset, &kind, size);
|
||||
pack = p->pack_base + offset;
|
||||
pack = (unsigned char *) p->pack_base + offset;
|
||||
if (kind != OBJ_DELTA)
|
||||
*delta_chain_length = 0;
|
||||
else {
|
||||
@ -919,7 +920,7 @@ void packed_object_info_detail(struct pack_entry *e,
|
||||
find_pack_entry_one(pack, &base_ent, p);
|
||||
offset = unpack_object_header(p, base_ent.offset,
|
||||
&kind, &junk);
|
||||
pack = p->pack_base + offset;
|
||||
pack = (unsigned char *) p->pack_base + offset;
|
||||
chain_length++;
|
||||
} while (kind == OBJ_DELTA);
|
||||
*delta_chain_length = chain_length;
|
||||
@ -957,7 +958,7 @@ static int packed_object_info(struct pack_entry *entry,
|
||||
die("cannot map packed file");
|
||||
|
||||
offset = unpack_object_header(p, entry->offset, &kind, &size);
|
||||
pack = p->pack_base + offset;
|
||||
pack = (unsigned char *) p->pack_base + offset;
|
||||
left = p->pack_size - offset;
|
||||
|
||||
switch (kind) {
|
||||
@ -1096,7 +1097,7 @@ void *unpack_entry_gently(struct pack_entry *entry,
|
||||
void *retval;
|
||||
|
||||
offset = unpack_object_header(p, entry->offset, &kind, &size);
|
||||
pack = p->pack_base + offset;
|
||||
pack = (unsigned char *) p->pack_base + offset;
|
||||
left = p->pack_size - offset;
|
||||
switch (kind) {
|
||||
case OBJ_DELTA:
|
||||
@ -1134,7 +1135,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, (index + 24 * n + 4), 20);
|
||||
memcpy(sha1, (char *) index + (24 * n) + 4, 20);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1148,9 +1149,9 @@ int find_pack_entry_one(const unsigned char *sha1,
|
||||
|
||||
do {
|
||||
int mi = (lo + hi) / 2;
|
||||
int cmp = memcmp(index + 24 * mi + 4, sha1, 20);
|
||||
int cmp = memcmp((char *) index + (24 * mi) + 4, sha1, 20);
|
||||
if (!cmp) {
|
||||
e->offset = ntohl(*((unsigned int *)(index + 24 * mi)));
|
||||
e->offset = ntohl(*((unsigned int *) ((char *) index + (24 * mi))));
|
||||
memcpy(e->sha1, sha1, 20);
|
||||
e->p = p;
|
||||
return 1;
|
||||
@ -1290,7 +1291,7 @@ void *read_object_with_reference(const unsigned char *sha1,
|
||||
ref_length = strlen(ref_type);
|
||||
|
||||
if (memcmp(buffer, ref_type, ref_length) ||
|
||||
get_sha1_hex(buffer + ref_length, actual_sha1)) {
|
||||
get_sha1_hex((char *) buffer + ref_length, actual_sha1)) {
|
||||
free(buffer);
|
||||
return NULL;
|
||||
}
|
||||
@ -1408,7 +1409,7 @@ static int write_buffer(int fd, const void *buf, size_t len)
|
||||
return error("file write error (%s)", strerror(errno));
|
||||
}
|
||||
len -= size;
|
||||
buf += size;
|
||||
buf = (char *) buf + size;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
@ -24,7 +24,7 @@ static ssize_t force_write(int fd, void *buffer, size_t length)
|
||||
{
|
||||
ssize_t ret = 0;
|
||||
while (ret < length) {
|
||||
ssize_t size = write(fd, buffer + ret, length - ret);
|
||||
ssize_t size = write(fd, (char *) buffer + ret, length - ret);
|
||||
if (size < 0) {
|
||||
return size;
|
||||
}
|
||||
|
4
tag.c
4
tag.c
@ -47,10 +47,10 @@ int parse_tag_buffer(struct tag *item, void *data, unsigned long size)
|
||||
|
||||
if (size < 64)
|
||||
return -1;
|
||||
if (memcmp("object ", data, 7) || get_sha1_hex(data + 7, object))
|
||||
if (memcmp("object ", data, 7) || get_sha1_hex((char *) data + 7, object))
|
||||
return -1;
|
||||
|
||||
type_line = data + 48;
|
||||
type_line = (char *) data + 48;
|
||||
if (memcmp("\ntype ", type_line-1, 6))
|
||||
return -1;
|
||||
|
||||
|
11
tree-walk.c
11
tree-walk.c
@ -43,7 +43,7 @@ void update_tree_entry(struct tree_desc *desc)
|
||||
|
||||
if (size < len)
|
||||
die("corrupt tree file");
|
||||
desc->buf = buf + len;
|
||||
desc->buf = (char *) buf + len;
|
||||
desc->size = size - len;
|
||||
}
|
||||
|
||||
@ -66,7 +66,7 @@ const unsigned char *tree_entry_extract(struct tree_desc *desc, const char **pat
|
||||
const void *tree = desc->buf;
|
||||
unsigned long size = desc->size;
|
||||
int len = strlen(tree)+1;
|
||||
const unsigned char *sha1 = tree + len;
|
||||
const unsigned char *sha1 = (unsigned char *) tree + len;
|
||||
const char *path;
|
||||
unsigned int mode;
|
||||
|
||||
@ -80,7 +80,8 @@ const unsigned char *tree_entry_extract(struct tree_desc *desc, const char **pat
|
||||
|
||||
int tree_entry(struct tree_desc *desc, struct name_entry *entry)
|
||||
{
|
||||
const void *tree = desc->buf, *path;
|
||||
const void *tree = desc->buf;
|
||||
const char *path;
|
||||
unsigned long len, size = desc->size;
|
||||
|
||||
if (!size)
|
||||
@ -95,10 +96,10 @@ int tree_entry(struct tree_desc *desc, struct name_entry *entry)
|
||||
entry->pathlen = len;
|
||||
|
||||
path += len + 1;
|
||||
entry->sha1 = path;
|
||||
entry->sha1 = (const unsigned char *) path;
|
||||
|
||||
path += 20;
|
||||
len = path - tree;
|
||||
len = path - (char *) tree;
|
||||
if (len > size)
|
||||
die("corrupt tree file");
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user