Clean up some gcc4 warnings

src/libmdb/data.c

@@ -88,7 +88,7 @@ mdb_bind_column_by_name(MdbTableDef *table, gchar *col_name, void *bind_ptr, int
  * 
  * Returns: 0 on success.  1 on failure.
  */
-int mdb_find_pg_row(MdbHandle *mdb, int pg_row, char **buf, int *off, int *len)
+int mdb_find_pg_row(MdbHandle *mdb, int pg_row, void **buf, int *off, int *len)
 {
 	unsigned int pg = pg_row >> 8;
 	unsigned int row = pg_row & 0xff;
@@ -441,7 +441,7 @@ int
 mdb_ole_read_next(MdbHandle *mdb, MdbColumn *col, void *ole_ptr)
 {
 	guint32 ole_len;
-	char *buf;
+	void *buf;
 	int row_start;
 	int len;
 
@@ -468,7 +468,7 @@ int
 mdb_ole_read(MdbHandle *mdb, MdbColumn *col, void *ole_ptr, int chunk_size)
 {
 	guint32 ole_len;
-	char *buf;
+	void *buf;
 	int row_start;
 	int len;
 
@@ -529,9 +529,9 @@ mdb_ole_read(MdbHandle *mdb, MdbColumn *col, void *ole_ptr, int chunk_size)
 int mdb_copy_ole(MdbHandle *mdb, char *dest, int start, int size)
 {
 	guint32 ole_len;
-	guint32 row_start, pg_row;
-	guint32 len;
-	char *buf, *pg_buf = mdb->pg_buf;
+	gint32 row_start, pg_row;
+	gint32 len;
+	void *buf, *pg_buf = mdb->pg_buf;
 
 	if (size<MDB_MEMO_OVERHEAD) {
 		return 0;
@@ -592,9 +592,9 @@ int mdb_copy_ole(MdbHandle *mdb, char *dest, int start, int size)
 static char *mdb_memo_to_string(MdbHandle *mdb, int start, int size)
 {
 	guint32 memo_len;
-	guint32 row_start, pg_row;
-	guint32 len;
-	char *buf, *pg_buf = mdb->pg_buf;
+	gint32 row_start, pg_row;
+	gint32 len;
+	void *buf, *pg_buf = mdb->pg_buf;
 	char *text = (char *) g_malloc(MDB_BIND_SIZE);
 
 	if (size<MDB_MEMO_OVERHEAD) {
@@ -797,7 +797,7 @@ int floor_log10(double f, int is_single)
 	}
 }
 
-char *mdb_col_to_string(MdbHandle *mdb, unsigned char *buf, int start, int datatype, int size)
+char *mdb_col_to_string(MdbHandle *mdb, void *buf, int start, int datatype, int size)
 {
 	char *text;
 	float tf;

src/libmdb/dump.c

@@ -6,7 +6,7 @@
 #include "dmalloc.h"
 #endif
 
-void buffer_dump(const unsigned char* buf, int start, int end)
+void buffer_dump(const void* buf, int start, int end)
 {
 	char asc[20];
 	int j, k;
@@ -14,11 +14,12 @@ void buffer_dump(const unsigned char* buf, int start, int end)
 	memset(asc, 0, sizeof(asc));
 	k = 0;
 	for (j=start; j<=end; j++) {
+		int c = ((const unsigned char *)(buf))[j];
 		if (k == 0) {
 			fprintf(stdout, "%04x  ", j);
 		}
-		fprintf(stdout, "%02x ", buf[j]);
-		asc[k] = isprint(buf[j]) ? buf[j] : '.';
+		fprintf(stdout, "%02x ", c);
+		asc[k] = isprint(c) ? c : '.';
 		k++;
 		if (k == 8) {
 			fprintf(stdout, " ");

src/libmdb/file.c

@@ -290,9 +290,9 @@ char tmpbuf[MDB_PGSIZE];
 
 
 /* really stupid, just here for consistancy */
-unsigned char mdb_get_byte(unsigned char *buf, int offset)
+unsigned char mdb_get_byte(void *buf, int offset)
 {
-	return buf[offset];
+	return ((unsigned char *)(buf))[offset];
 }
 unsigned char mdb_pg_get_byte(MdbHandle *mdb, int offset)
 {
@@ -301,9 +301,11 @@ unsigned char mdb_pg_get_byte(MdbHandle *mdb, int offset)
 	return mdb->pg_buf[offset];
 }
 
-int mdb_get_int16(unsigned char *buf, int offset)
+int mdb_get_int16(void *buf, int offset)
 {
-	return buf[offset+1]*256+buf[offset];
+	guint16 l;
+	memcpy(&l, buf + offset, 2);
+	return (int)GUINT16_FROM_LE(l);
 }
 int mdb_pg_get_int16(MdbHandle *mdb, int offset)
 {
@@ -317,13 +319,13 @@ gint32 mdb_pg_get_int24_msb(MdbHandle *mdb, int offset)
 	gint32 l = 0;
 	if (offset <0 || offset+3 > mdb->fmt->pg_size) return -1;
 	mdb->cur_pos+=3;
-	memcpy(&l, &(mdb->pg_buf[offset]), 3);
+	memcpy(&l, mdb->pg_buf + offset, 3);
 	return GINT32_FROM_BE(l);
 }
-gint32 mdb_get_int24(unsigned char *buf, int offset)
+gint32 mdb_get_int24(void *buf, int offset)
 {
 	gint32 l = 0;
-	memcpy(&l, &buf[offset], 3);
+	memcpy(&l, buf + offset, 3);
 	return GINT32_FROM_LE(l);
 }
 gint32 mdb_pg_get_int24(MdbHandle *mdb, int offset)
@@ -333,10 +335,10 @@ gint32 mdb_pg_get_int24(MdbHandle *mdb, int offset)
 	return mdb_get_int24(mdb->pg_buf, offset);
 }
 
-long mdb_get_int32(unsigned char *buf, int offset)
+long mdb_get_int32(void *buf, int offset)
 {
-	guint32 l;
-	memcpy(&l, &buf[offset], 4);
+	gint32 l;
+	memcpy(&l, buf + offset, 4);
 	return (long)GINT32_FROM_LE(l);
 }
 long mdb_pg_get_int32(MdbHandle *mdb, int offset)
@@ -346,10 +348,10 @@ long mdb_pg_get_int32(MdbHandle *mdb, int offset)
 	return mdb_get_int32(mdb->pg_buf, offset);
 }
 
-float mdb_get_single(unsigned char *buf, int offset)
+float mdb_get_single(void *buf, int offset)
 {
 	union {guint32 g; float f;} f;
-	memcpy(&f, &buf[offset], 4);
+	memcpy(&f, buf + offset, 4);
 	f.g = GUINT32_FROM_LE(f.g);
 	return f.f;
 }
@@ -360,10 +362,10 @@ float mdb_pg_get_single(MdbHandle *mdb, int offset)
        return mdb_get_single(mdb->pg_buf, offset);
 }
 
-double mdb_get_double(unsigned char *buf, int offset)
+double mdb_get_double(void *buf, int offset)
 {
 	union {guint64 g; double d;} d;
-	memcpy(&d, &buf[offset], 8);
+	memcpy(&d, buf + offset, 8);
 	d.g = GUINT64_FROM_LE(d.g);
 	return d.d;
 }

src/libmdb/iconv.c

@@ -28,22 +28,23 @@
  * This function is used in reading text data from an MDB table.
  */
 int
-mdb_unicode2ascii(MdbHandle *mdb, unsigned char *src, unsigned int slen, unsigned char *dest, unsigned int dlen)
+mdb_unicode2ascii(MdbHandle *mdb, char *src, unsigned int slen, char *dest, unsigned int dlen)
 {
-	unsigned char *tmp = NULL;
+	char *tmp = NULL;
 	unsigned int tlen = 0;
 	unsigned int len_in, len_out;
 	char *in_ptr, *out_ptr;
 
-	if ((!src) || (!dest))
+	if ((!src) || (!dest) || (!dlen))
 		return 0;
 
 	/* Uncompress 'Unicode Compressed' string into tmp */
-	if (IS_JET4(mdb) && (slen>=2) && (src[0]==0xff) && (src[1]==0xfe)) {
+	if (IS_JET4(mdb) && (slen>=2)
+	 && ((src[0]&0xff)==0xff) && ((src[1]&0xff)==0xfe)) {
 		unsigned int compress=1;
 		src += 2;
 		slen -= 2;
-		tmp = (unsigned char *)g_malloc(slen*2);
+		tmp = (char *)g_malloc(slen*2);
 		while (slen) {
 			if (*src == 0) {
 				compress = (compress) ? 0 : 1;
@@ -61,8 +62,8 @@ mdb_unicode2ascii(MdbHandle *mdb, unsigned char *src, unsigned int slen, unsigne
 		}
 	}
 
-	in_ptr = (char *)((tmp) ? tmp : src);
-	out_ptr = (char *)dest;
+	in_ptr = (tmp) ? tmp : src;
+	out_ptr = dest;
 	len_in = (tmp) ? tlen : slen;
 	len_out = dlen;
 
@@ -103,16 +104,16 @@ mdb_unicode2ascii(MdbHandle *mdb, unsigned char *src, unsigned int slen, unsigne
  * If slen is 0, strlen will be used to calculate src's length.
  */
 int
-mdb_ascii2unicode(MdbHandle *mdb, unsigned char *src, unsigned int slen, unsigned char *dest, unsigned int dlen)
+mdb_ascii2unicode(MdbHandle *mdb, char *src, unsigned int slen, char *dest, unsigned int dlen)
 {
         size_t len_in, len_out;
         char *in_ptr, *out_ptr;
 
-	if ((!src) || (!dest))
+	if ((!src) || (!dest) || (!dlen))
 		return 0;
 
-        in_ptr = (char *)src;
-        out_ptr = (char *)dest;
+        in_ptr = src;
+        out_ptr = dest;
         len_in = (slen) ? slen : strlen(in_ptr);
         len_out = dlen;
 

src/libmdb/index.c

@@ -165,17 +165,17 @@ mdb_read_indices(MdbTableDef *table)
 	return NULL;
 }
 void
-mdb_index_hash_text(guchar *text, guchar *hash)
+mdb_index_hash_text(char *text, char *hash)
 {
 	unsigned int k;
 
 	for (k=0;k<strlen(text);k++) {
-		hash[k] = idx_to_text[text[k]];
+		int c = ((unsigned char *)(text))[k];
+		hash[k] = idx_to_text[c];
 		if (!(hash[k])) fprintf(stderr, 
-				"No translation available for %02x %d\n", 
-				text[k],text[k]);
+				"No translation available for %02x %d\n", c, c);
 	}
-	hash[strlen(text)]=0;
+	hash[strlen(text)]='\0';
 }
 /*
  * reverse the order of the column for hashing
@@ -245,7 +245,7 @@ int lastchar;
 }
 #endif
 int
-mdb_index_test_sargs(MdbHandle *mdb, MdbIndex *idx, unsigned char *buf, int len)
+mdb_index_test_sargs(MdbHandle *mdb, MdbIndex *idx, char *buf, int len)
 {
 	unsigned int i, j;
 	MdbColumn *col;
@@ -617,7 +617,7 @@ mdb_index_find_next(MdbHandle *mdb, MdbIndex *idx, MdbIndexChain *chain, guint32
 		}
 
 		//idx_start = ipg->offset + (ipg->len - 4 - idx_sz);
-		passed = mdb_index_test_sargs(mdb, idx, ipg->cache_value, idx_sz);
+		passed = mdb_index_test_sargs(mdb, idx, (char *)(ipg->cache_value), idx_sz);
 
 		ipg->offset += ipg->len;
 	} while (!passed);

src/libmdb/table.c

@@ -77,10 +77,10 @@ MdbTableDef *mdb_read_table(MdbCatalogEntry *entry)
 	MdbHandle *mdb = entry->mdb;
 	MdbFormatConstants *fmt = mdb->fmt;
 	int len, row_start, pg_row;
-	unsigned char *buf, *pg_buf = mdb->pg_buf;
+	void *buf, *pg_buf = mdb->pg_buf;
 
 	mdb_read_pg(mdb, entry->table_pg);
-	if (pg_buf[0] != 0x02)  /* not a valid table def page */
+	if (mdb_get_byte(pg_buf, 0) != 0x02)  /* not a valid table def page */
 		return NULL;
 	table = mdb_alloc_tabledef(entry);
 
@@ -168,7 +168,7 @@ read_pg_if_16(MdbHandle *mdb, int *cur_pos)
 	return (high_byte * 256 + low_byte);
 }
 guint16 
-read_pg_if_n(MdbHandle *mdb, unsigned char *buf, int *cur_pos, int len)
+read_pg_if_n(MdbHandle *mdb, void *buf, int *cur_pos, int len)
 {
 	if (*cur_pos + len < mdb->fmt->pg_size) {
 		memcpy(buf, &mdb->pg_buf[*cur_pos], len);
@@ -270,7 +270,7 @@ GPtrArray *mdb_read_columns(MdbTableDef *table)
 	** column names - ordered the same as the column attributes table
 	*/
 	for (i=0;i<table->num_cols;i++) {
-		unsigned char *tmp_buf;
+		char *tmp_buf;
 		pcol = g_ptr_array_index(table->columns, i);
 
 		if (IS_JET4(mdb)) {
@@ -284,7 +284,7 @@ GPtrArray *mdb_read_columns(MdbTableDef *table)
 			fprintf(stderr,"Unknown MDB version\n");
 			continue;
 		}
-		tmp_buf = (unsigned char *) g_malloc(name_sz);
+		tmp_buf = (char *) g_malloc(name_sz);
 		read_pg_if_n(mdb, tmp_buf, &cur_pos, name_sz);
 		mdb_unicode2ascii(mdb, tmp_buf, name_sz, pcol->name, MDB_MAX_OBJ_NAME);
 		g_free(tmp_buf);