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

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.
maint
Junio C Hamano 19 years ago
parent
c0a2e1c0ba 1d7f171c3a
commit
e94528a0e9
24 changed files with 122 additions and 107 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      blame.c
  2. 6
      builtin-apply.c
  3. 3
      builtin-read-tree.c
  4. 22
      convert-objects.c
  5. 4
      csum-file.c
  6. 5
      diff-delta.c
  7. 41
      diff-lib.c
  8. 2
      diff.c
  9. 2
      diffcore-order.c
  10. 13
      http-fetch.c
  11. 13
      http-push.c
  12. 4
      http.c
  13. 2
      imap-send.c
  14. 6
      pack-check.c
  15. 4
      pack-objects.c
  16. 16
      pack-redundant.c
  17. 4
      patch-delta.c
  18. 4
      pkt-line.c
  19. 9
      quote.c
  20. 13
      read-cache.c
  21. 27
      sha1_file.c
  22. 2
      ssh-fetch.c
  23. 4
      tag.c
  24. 11
      tree-walk.c

4
blame.c
Unescape View File

@ -301,9 +301,9 @@ static void fill_line_map(struct commit *commit, struct commit *other,
if (DEBUG) if (DEBUG)
printf("map: i1: %d %d %p i2: %d %d %p\n", printf("map: i1: %d %d %p i2: %d %d %p\n",
i1, map[i1], i1, map[i1],
i1 != -1 ? blame_lines[map[i1]] : NULL, (void *) (i1 != -1 ? blame_lines[map[i1]] : NULL),
i2, map2[i2], i2, map2[i2],
i2 != -1 ? blame_lines[map2[i2]] : NULL); (void *) (i2 != -1 ? blame_lines[map2[i2]] : NULL));
if (map2[i2] != -1 && if (map2[i2] != -1 &&
blame_lines[map[i1]] && blame_lines[map[i1]] &&
!blame_lines[map2[i2]]) !blame_lines[map2[i2]])

6
builtin-apply.c
Unescape View File

@ -148,7 +148,7 @@ static void *read_patch_file(int fd, unsigned long *sizep)
buffer = xrealloc(buffer, alloc); buffer = xrealloc(buffer, alloc);
nr = alloc - size; nr = alloc - size;
} }
nr = xread(fd, buffer + size, nr); nr = xread(fd, (char *) buffer + size, nr);
if (!nr) if (!nr)
break; break;
if (nr < 0) if (nr < 0)
@ -164,7 +164,7 @@ static void *read_patch_file(int fd, unsigned long *sizep)
*/ */
if (alloc < size + SLOP) if (alloc < size + SLOP)
buffer = xrealloc(buffer, size + SLOP); buffer = xrealloc(buffer, size + SLOP);
memset(buffer + size, 0, SLOP); memset((char *) buffer + size, 0, SLOP);
return buffer; 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); return error("unable to open %s", path);
got = 0; got = 0;
for (;;) { for (;;) {
int ret = xread(fd, buf + got, size - got); int ret = xread(fd, (char *) buf + got, size - got);
if (ret <= 0) if (ret <= 0)
break; break;
got += ret; got += ret;

3
builtin-read-tree.c
Unescape View File

@ -31,8 +31,7 @@ static int merge_size = 0;


static struct object_list *trees = NULL; 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 {
struct tree_entry_list *next; struct tree_entry_list *next;

22
convert-objects.c
Unescape View File

@ -103,12 +103,12 @@ static int write_subdirectory(void *buffer, unsigned long size, const char *base
if (!slash) { if (!slash) {
newlen += sprintf(new + newlen, "%o %s", mode, path); newlen += sprintf(new + newlen, "%o %s", mode, path);
new[newlen++] = '\0'; new[newlen++] = '\0';
memcpy(new + newlen, buffer + len - 20, 20); memcpy(new + newlen, (char *) buffer + len - 20, 20);
newlen += 20; newlen += 20;


used += len; used += len;
size -= len; size -= len;
buffer += len; buffer = (char *) buffer + len;
continue; continue;
} }


@ -121,7 +121,7 @@ static int write_subdirectory(void *buffer, unsigned long size, const char *base


used += len; used += len;
size -= len; size -= len;
buffer += len; buffer = (char *) buffer + len;
} }


write_sha1_file(new, newlen, tree_type, result_sha1); 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) { while (size) {
int len = 1+strlen(buffer); int len = 1+strlen(buffer);


convert_binary_sha1(buffer + len); convert_binary_sha1((char *) buffer + len);


len += 20; len += 20;
if (len > size) if (len > size)
die("corrupt tree object"); die("corrupt tree object");
size -= len; size -= len;
buffer += len; buffer = (char *) buffer + len;
} }


write_subdirectory(orig_buffer, orig_size, "", 0, result_sha1); 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" // "tree <sha1>\n"
memcpy(new + newlen, buffer, 46); memcpy(new + newlen, buffer, 46);
newlen += 46; newlen += 46;
buffer += 46; buffer = (char *) buffer + 46;
size -= 46; size -= 46;


// "parent <sha1>\n" // "parent <sha1>\n"
while (!memcmp(buffer, "parent ", 7)) { while (!memcmp(buffer, "parent ", 7)) {
memcpy(new + newlen, buffer, 48); memcpy(new + newlen, buffer, 48);
newlen += 48; newlen += 48;
buffer += 48; buffer = (char *) buffer + 48;
size -= 48; size -= 48;
} }


@ -275,11 +275,11 @@ static void convert_commit(void *buffer, unsigned long size, unsigned char *resu


if (memcmp(buffer, "tree ", 5)) if (memcmp(buffer, "tree ", 5))
die("Bad commit '%s'", (char*) buffer); die("Bad commit '%s'", (char*) buffer);
convert_ascii_sha1(buffer+5); convert_ascii_sha1((char *) buffer + 5);
buffer += 46; /* "tree " + "hex sha1" + "\n" */ buffer = (char *) buffer + 46; /* "tree " + "hex sha1" + "\n" */
while (!memcmp(buffer, "parent ", 7)) { while (!memcmp(buffer, "parent ", 7)) {
convert_ascii_sha1(buffer+7); convert_ascii_sha1((char *) buffer + 7);
buffer += 48; buffer = (char *) buffer + 48;
} }
convert_date(orig_buffer, orig_size, result_sha1); convert_date(orig_buffer, orig_size, result_sha1);
} }

4
csum-file.c
Unescape View File

@ -17,7 +17,7 @@ static int sha1flush(struct sha1file *f, unsigned int count)
for (;;) { for (;;) {
int ret = xwrite(f->fd, buf, count); int ret = xwrite(f->fd, buf, count);
if (ret > 0) { if (ret > 0) {
buf += ret; buf = (char *) buf + ret;
count -= ret; count -= ret;
if (count) if (count)
continue; continue;
@ -57,7 +57,7 @@ int sha1write(struct sha1file *f, void *buf, unsigned int count)
memcpy(f->buffer + offset, buf, nr); memcpy(f->buffer + offset, buf, nr);
count -= nr; count -= nr;
offset += nr; offset += nr;
buf += nr; buf = (char *) buf + nr;
left -= nr; left -= nr;
if (!left) { if (!left) {
SHA1_Update(&f->ctx, f->buffer, offset); SHA1_Update(&f->ctx, f->buffer, offset);

5
diff-delta.c
Unescape View File

@ -22,6 +22,7 @@
#include <string.h> #include <string.h>
#include "delta.h" #include "delta.h"


#include "git-compat-util.h"


/* maximum hash entry list for the same hash bucket */ /* maximum hash entry list for the same hash bucket */
#define HASH_LIMIT 64 #define HASH_LIMIT 64
@ -131,7 +132,7 @@ struct delta_index {
const void *src_buf; const void *src_buf;
unsigned long src_size; unsigned long src_size;
unsigned int hash_mask; 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) 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_data = index->src_buf;
ref_top = ref_data + index->src_size; ref_top = ref_data + index->src_size;
data = trg_buf; data = trg_buf;
top = trg_buf + trg_size; top = (const unsigned char *) trg_buf + trg_size;


outpos++; outpos++;
val = 0; val = 0;

41
diff-lib.c
Unescape View File

@ -34,21 +34,23 @@ int run_diff_files(struct rev_info *revs, int silent_on_removed)
continue; continue;


if (ce_stage(ce)) { if (ce_stage(ce)) {
struct { struct combine_diff_path *dpath;
struct combine_diff_path p;
struct combine_diff_parent filler[5];
} combine;
int num_compare_stages = 0; int num_compare_stages = 0;
size_t path_len;


combine.p.next = NULL; path_len = ce_namelen(ce);
combine.p.len = ce_namelen(ce);
combine.p.path = xmalloc(combine.p.len + 1); dpath = xmalloc (combine_diff_path_size (5, path_len));
memcpy(combine.p.path, ce->name, combine.p.len); dpath->path = (char *) &(dpath->parent[5]);
combine.p.path[combine.p.len] = 0;
combine.p.mode = 0; dpath->next = NULL;
memset(combine.p.sha1, 0, 20); dpath->len = path_len;
memset(&combine.p.parent[0], 0, memcpy(dpath->path, ce->name, path_len);
sizeof(combine.filler)); 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) { while (i < entries) {
struct cache_entry *nce = active_cache[i]; 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) { if (2 <= stage) {
int mode = ntohl(nce->ce_mode); int mode = ntohl(nce->ce_mode);
num_compare_stages++; num_compare_stages++;
memcpy(combine.p.parent[stage-2].sha1, memcpy(dpath->parent[stage-2].sha1,
nce->sha1, 20); nce->sha1, 20);
combine.p.parent[stage-2].mode = dpath->parent[stage-2].mode =
canon_mode(mode); canon_mode(mode);
combine.p.parent[stage-2].status = dpath->parent[stage-2].status =
DIFF_STATUS_MODIFIED; DIFF_STATUS_MODIFIED;
} }


@ -83,13 +85,14 @@ int run_diff_files(struct rev_info *revs, int silent_on_removed)
i--; i--;


if (revs->combine_merges && num_compare_stages == 2) { if (revs->combine_merges && num_compare_stages == 2) {
show_combined_diff(&combine.p, 2, show_combined_diff(dpath, 2,
revs->dense_combined_merges, revs->dense_combined_merges,
revs); revs);
free(combine.p.path); free(dpath);
continue; continue;
} }
free(combine.p.path); free(dpath);
dpath = NULL;


/* /*
* Show the diff for the 'ce' if we found the one * Show the diff for the 'ce' if we found the one

2
diff.c
Unescape View File

@ -515,7 +515,7 @@ static void emit_binary_diff(mmfile_t *one, mmfile_t *two)
else else
line[0] = bytes - 26 + 'a' - 1; line[0] = bytes - 26 + 'a' - 1;
encode_85(line + 1, cp, bytes); encode_85(line + 1, cp, bytes);
cp += bytes; cp = (char *) cp + bytes;
puts(line); puts(line);
} }
printf("\n"); printf("\n");

2
diffcore-order.c
Unescape View File

@ -30,7 +30,7 @@ static void prepare_order(const char *orderfile)
close(fd); close(fd);
if (map == MAP_FAILED) if (map == MAP_FAILED)
return; return;
endp = map + st.st_size; endp = (char *) map + st.st_size;
for (pass = 0; pass < 2; pass++) { for (pass = 0; pass < 2; pass++) {
cnt = 0; cnt = 0;
cp = map; cp = map;

13
http-fetch.c
Unescape View File

@ -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; struct object_request *obj_req = (struct object_request *)data;
do { do {
ssize_t retval = write(obj_req->local, ssize_t retval = write(obj_req->local,
ptr + posn, size - posn); (char *) ptr + posn, size - posn);
if (retval < 0) if (retval < 0)
return posn; return posn;
posn += retval; posn += retval;
@ -1136,14 +1136,15 @@ int fetch(unsigned char *sha1)


static inline int needs_quote(int ch) static inline int needs_quote(int ch)
{ {
switch (ch) { if (((ch >= 'A') && (ch <= 'Z'))
case '/': case '-': case '.': || ((ch >= 'a') && (ch <= 'z'))
case 'A'...'Z': case 'a'...'z': case '0'...'9': || ((ch >= '0') && (ch <= '9'))
|| (ch == '/')
|| (ch == '-')
|| (ch == '.'))
return 0; return 0;
default:
return 1; return 1;
} }
}


static inline int hex(int v) static inline int hex(int v)
{ {

13
http-push.c
Unescape View File

@ -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; struct transfer_request *request = (struct transfer_request *)data;
do { do {
ssize_t retval = write(request->local_fileno, ssize_t retval = write(request->local_fileno,
ptr + posn, size - posn); (char *) ptr + posn, size - posn);
if (retval < 0) if (retval < 0)
return posn; return posn;
posn += retval; posn += retval;
@ -1077,14 +1077,15 @@ static int fetch_indices(void)


static inline int needs_quote(int ch) static inline int needs_quote(int ch)
{ {
switch (ch) { if (((ch >= 'A') && (ch <= 'Z'))
case '/': case '-': case '.': || ((ch >= 'a') && (ch <= 'z'))
case 'A'...'Z': case 'a'...'z': case '0'...'9': || ((ch >= '0') && (ch <= '9'))
|| (ch == '/')
|| (ch == '-')
|| (ch == '.'))
return 0; return 0;
default:
return 1; return 1;
} }
}


static inline int hex(int v) static inline int hex(int v)
{ {

4
http.c
Unescape View File

@ -34,7 +34,7 @@ size_t fread_buffer(void *ptr, size_t eltsize, size_t nmemb,
size_t size = eltsize * nmemb; size_t size = eltsize * nmemb;
if (size > buffer->size - buffer->posn) if (size > buffer->size - buffer->posn)
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; buffer->posn += size;
return size; return size;
} }
@ -49,7 +49,7 @@ size_t fwrite_buffer(const void *ptr, size_t eltsize,
buffer->size = buffer->posn + size; buffer->size = buffer->posn + size;
buffer->buffer = xrealloc(buffer->buffer, buffer->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; buffer->posn += size;
data_received++; data_received++;
return size; return size;

2
imap-send.c
Unescape View File

@ -93,7 +93,7 @@ typedef struct {
char *data; char *data;
int len; int len;
unsigned char flags; unsigned char flags;
unsigned char crlf:1; unsigned int crlf:1;
} msg_data_t; } msg_data_t;


#define DRV_OK 0 #define DRV_OK 0

6
pack-check.c
Unescape View File

@ -29,10 +29,10 @@ static int verify_packfile(struct packed_git *p)
pack_base = p->pack_base; pack_base = p->pack_base;
SHA1_Update(&ctx, pack_base, pack_size - 20); SHA1_Update(&ctx, pack_base, pack_size - 20);
SHA1_Final(sha1, &ctx); 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", return error("Packfile %s SHA1 mismatch with itself",
p->pack_name); 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", return error("Packfile %s SHA1 mismatch with idx",
p->pack_name); p->pack_name);


@ -135,7 +135,7 @@ int verify_pack(struct packed_git *p, int verbose)
SHA1_Init(&ctx); SHA1_Init(&ctx);
SHA1_Update(&ctx, index_base, index_size - 20); SHA1_Update(&ctx, index_base, index_size - 20);
SHA1_Final(sha1, &ctx); 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", ret = error("Packfile index for %s SHA1 mismatch",
p->pack_name); p->pack_name);



4
pack-objects.c
Unescape View File

@ -156,7 +156,7 @@ static void prepare_pack_revindex(struct pack_revindex *rix)


rix->revindex = xmalloc(sizeof(unsigned long) * (num_ent + 1)); rix->revindex = xmalloc(sizeof(unsigned long) * (num_ent + 1));
for (i = 0; i < num_ent; i++) { 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); rix->revindex[i] = ntohl(hl);
} }
/* This knows the pack format -- the 20-byte trailer /* 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); use_packed_git(p);


datalen = find_packed_object_size(p, entry->in_pack_offset); 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); sha1write(f, buf, datalen);
unuse_packed_git(p); unuse_packed_git(p);
hdrlen = 0; /* not really */ hdrlen = 0; /* not really */

16
pack-redundant.c
Unescape View File

@ -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) static void cmp_two_packs(struct pack_list *p1, struct pack_list *p2)
{ {
int p1_off, p2_off; 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; struct llist_item *p1_hint = NULL, *p2_hint = NULL;


p1_off = p2_off = 256 * 4 + 4; p1_off = p2_off = 256 * 4 + 4;
p1_base = (void *)p1->pack->index_base; p1_base = (unsigned char *) p1->pack->index_base;
p2_base = (void *)p2->pack->index_base; p2_base = (unsigned char *) p2->pack->index_base;


while (p1_off <= p1->pack->index_size - 3 * 20 && while (p1_off <= p1->pack->index_size - 3 * 20 &&
p2_off <= p2->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; size_t ret = 0;
int p1_off, p2_off; int p1_off, p2_off;
void *p1_base, *p2_base; char *p1_base, *p2_base;


p1_off = p2_off = 256 * 4 + 4; p1_off = p2_off = 256 * 4 + 4;
p1_base = (void *)p1->index_base; p1_base = (char *)p1->index_base;
p2_base = (void *)p2->index_base; p2_base = (char *)p2->index_base;


while (p1_off <= p1->index_size - 3 * 20 && while (p1_off <= p1->index_size - 3 * 20 &&
p2_off <= p2->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; struct pack_list l;
size_t off; size_t off;
void *base; unsigned char *base;


if (!p->pack_local && !(alt_odb || verbose)) if (!p->pack_local && !(alt_odb || verbose))
return NULL; return NULL;
@ -543,7 +543,7 @@ static struct pack_list * add_pack(struct packed_git *p)
llist_init(&l.all_objects); llist_init(&l.all_objects);


off = 256 * 4 + 4; off = 256 * 4 + 4;
base = (void *)p->index_base; base = (unsigned char *)p->index_base;
while (off <= p->index_size - 3 * 20) { while (off <= p->index_size - 3 * 20) {
llist_insert_back(l.all_objects, base + off); llist_insert_back(l.all_objects, base + off);
off += 24; off += 24;

4
patch-delta.c
Unescape View File

@ -25,7 +25,7 @@ void *patch_delta(const void *src_buf, unsigned long src_size,
return NULL; return NULL;


data = delta_buf; 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 */ /* make sure the orig file size matches what we expect */
size = get_delta_hdr_size(&data, top); 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_off + cp_size > src_size ||
cp_size > size) cp_size > size)
goto bad; goto bad;
memcpy(out, src_buf + cp_off, cp_size); memcpy(out, (char *) src_buf + cp_off, cp_size);
out += cp_size; out += cp_size;
size -= cp_size; size -= cp_size;
} else if (cmd) { } else if (cmd) {

4
pkt-line.c
Unescape View File

@ -21,7 +21,7 @@ static void safe_write(int fd, const void *buf, unsigned n)
while (n) { while (n) {
int ret = xwrite(fd, buf, n); int ret = xwrite(fd, buf, n);
if (ret > 0) { if (ret > 0) {
buf += ret; buf = (char *) buf + ret;
n -= ret; n -= ret;
continue; continue;
} }
@ -66,7 +66,7 @@ static void safe_read(int fd, void *buffer, unsigned size)
int n = 0; int n = 0;


while (n < size) { while (n < size) {
int ret = xread(fd, buffer + n, size - n); int ret = xread(fd, (char *) buffer + n, size - n);
if (ret < 0) if (ret < 0)
die("read error (%s)", strerror(errno)); die("read error (%s)", strerror(errno));
if (!ret) if (!ret)

9
quote.c
Unescape View File

@ -206,7 +206,14 @@ char *unquote_c_style(const char *quoted, const char **endp)
case '\\': case '"': case '\\': case '"':
break; /* verbatim */ break; /* verbatim */


case '0'...'7': case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
/* octal */ /* octal */
ac = ((ch - '0') << 6); ac = ((ch - '0') << 6);
if ((ch = *sp++) < '0' || '7' < ch) if ((ch = *sp++) < '0' || '7' < ch)

13
read-cache.c
Unescape View File

@ -706,7 +706,7 @@ static int verify_hdr(struct cache_header *hdr, unsigned long size)
SHA1_Init(&c); SHA1_Init(&c);
SHA1_Update(&c, hdr, size - 20); SHA1_Update(&c, hdr, size - 20);
SHA1_Final(sha1, &c); 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 error("bad index file sha1 signature");
return 0; return 0;
} }
@ -770,7 +770,7 @@ int read_cache(void)


offset = sizeof(*hdr); offset = sizeof(*hdr);
for (i = 0; i < active_nr; i++) { 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); offset = offset + ce_size(ce);
active_cache[i] = ce; active_cache[i] = ce;
} }
@ -783,10 +783,11 @@ int read_cache(void)
* in 4-byte network byte order. * in 4-byte network byte order.
*/ */
unsigned long extsize; unsigned long extsize;
memcpy(&extsize, map + offset + 4, 4); memcpy(&extsize, (char *) map + offset + 4, 4);
extsize = ntohl(extsize); extsize = ntohl(extsize);
if (read_index_extension(map + offset, if (read_index_extension(((const char *) map) + offset,
map + offset + 8, extsize) < 0) (char *) map + offset + 8,
extsize) < 0)
goto unmap; goto unmap;
offset += 8; offset += 8;
offset += extsize; offset += extsize;
@ -820,7 +821,7 @@ static int ce_write(SHA_CTX *context, int fd, void *data, unsigned int len)
} }
write_buffer_len = buffered; write_buffer_len = buffered;
len -= partial; len -= partial;
data += partial; data = (char *) data + partial;
} }
return 0; return 0;
} }

27
sha1_file.c
Unescape View File

@ -486,7 +486,8 @@ int use_packed_git(struct packed_git *p)
* this is cheap. * this is cheap.
*/ */
if (memcmp((char*)(p->index_base) + p->index_size - 40, 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); 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; int bytes = strlen(buffer) + 1;
unsigned char *buf = xmalloc(1+size); 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; bytes = stream->total_out - bytes;
if (bytes < size) { if (bytes < size) {
stream->next_out = buf + bytes; 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) if (offset >= p->pack_size)
die("object offset outside of pack file"); die("object offset outside of pack file");


pack = p->pack_base + offset; pack = (unsigned char *) p->pack_base + offset;
c = *pack++; c = *pack++;
offset++; offset++;
*type = (c >> 4) & 7; *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); ptr = unpack_object_header(p, ptr, kindp, sizep);
if (*kindp != OBJ_DELTA) if (*kindp != OBJ_DELTA)
goto done; goto done;
memcpy(base, p->pack_base + ptr, 20); memcpy(base, (char *) p->pack_base + ptr, 20);
status = 0; status = 0;
done: done:
unuse_packed_git(p); unuse_packed_git(p);
@ -903,7 +904,7 @@ void packed_object_info_detail(struct pack_entry *e,
enum object_type kind; enum object_type kind;


offset = unpack_object_header(p, e->offset, &kind, size); 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) if (kind != OBJ_DELTA)
*delta_chain_length = 0; *delta_chain_length = 0;
else { else {
@ -919,7 +920,7 @@ void packed_object_info_detail(struct pack_entry *e,
find_pack_entry_one(pack, &base_ent, p); find_pack_entry_one(pack, &base_ent, p);
offset = unpack_object_header(p, base_ent.offset, offset = unpack_object_header(p, base_ent.offset,
&kind, &junk); &kind, &junk);
pack = p->pack_base + offset; pack = (unsigned char *) p->pack_base + offset;
chain_length++; chain_length++;
} while (kind == OBJ_DELTA); } while (kind == OBJ_DELTA);
*delta_chain_length = chain_length; *delta_chain_length = chain_length;
@ -957,7 +958,7 @@ static int packed_object_info(struct pack_entry *entry,
die("cannot map packed file"); die("cannot map packed file");


offset = unpack_object_header(p, entry->offset, &kind, &size); 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; left = p->pack_size - offset;


switch (kind) { switch (kind) {
@ -1096,7 +1097,7 @@ void *unpack_entry_gently(struct pack_entry *entry,
void *retval; void *retval;


offset = unpack_object_header(p, entry->offset, &kind, &size); 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; left = p->pack_size - offset;
switch (kind) { switch (kind) {
case OBJ_DELTA: 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; void *index = p->index_base + 256;
if (n < 0 || num_packed_objects(p) <= n) if (n < 0 || num_packed_objects(p) <= n)
return -1; return -1;
memcpy(sha1, (index + 24 * n + 4), 20); memcpy(sha1, (char *) index + (24 * n) + 4, 20);
return 0; return 0;
} }


@ -1148,9 +1149,9 @@ int find_pack_entry_one(const unsigned char *sha1,


do { do {
int mi = (lo + hi) / 2; 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) { if (!cmp) {
e->offset = ntohl(*((unsigned int *)(index + 24 * mi))); e->offset = ntohl(*((unsigned int *) ((char *) index + (24 * mi))));
memcpy(e->sha1, sha1, 20); memcpy(e->sha1, sha1, 20);
e->p = p; e->p = p;
return 1; return 1;
@ -1290,7 +1291,7 @@ void *read_object_with_reference(const unsigned char *sha1,
ref_length = strlen(ref_type); ref_length = strlen(ref_type);


if (memcmp(buffer, ref_type, ref_length) || 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); free(buffer);
return NULL; 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)); return error("file write error (%s)", strerror(errno));
} }
len -= size; len -= size;
buf += size; buf = (char *) buf + size;
} }
return 0; return 0;
} }

2
ssh-fetch.c
Unescape View File

@ -24,7 +24,7 @@ static ssize_t force_write(int fd, void *buffer, size_t length)
{ {
ssize_t ret = 0; ssize_t ret = 0;
while (ret < length) { 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) { if (size < 0) {
return size; return size;
} }

4
tag.c
Unescape View File

@ -47,10 +47,10 @@ int parse_tag_buffer(struct tag *item, void *data, unsigned long size)


if (size < 64) if (size < 64)
return -1; 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; return -1;


type_line = data + 48; type_line = (char *) data + 48;
if (memcmp("\ntype ", type_line-1, 6)) if (memcmp("\ntype ", type_line-1, 6))
return -1; return -1;



11
tree-walk.c
Unescape View File

@ -43,7 +43,7 @@ void update_tree_entry(struct tree_desc *desc)


if (size < len) if (size < len)
die("corrupt tree file"); die("corrupt tree file");
desc->buf = buf + len; desc->buf = (char *) buf + len;
desc->size = size - 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; const void *tree = desc->buf;
unsigned long size = desc->size; unsigned long size = desc->size;
int len = strlen(tree)+1; int len = strlen(tree)+1;
const unsigned char *sha1 = tree + len; const unsigned char *sha1 = (unsigned char *) tree + len;
const char *path; const char *path;
unsigned int mode; 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) 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; unsigned long len, size = desc->size;


if (!size) if (!size)
@ -95,10 +96,10 @@ int tree_entry(struct tree_desc *desc, struct name_entry *entry)
entry->pathlen = len; entry->pathlen = len;


path += len + 1; path += len + 1;
entry->sha1 = path; entry->sha1 = (const unsigned char *) path;


path += 20; path += 20;
len = path - tree; len = path - (char *) tree;
if (len > size) if (len > size)
die("corrupt tree file"); die("corrupt tree file");



Write Preview
Loading…
Cancel
Save