From 47e0f2e23aef98a584bf964754ab1e29c2897cfb Mon Sep 17 00:00:00 2001 From: Mathieu Desnoyers Date: Mon, 21 Feb 2011 17:33:08 -0500 Subject: [PATCH] Babeltrace-wide warning fixes Signed-off-by: Mathieu Desnoyers --- formats/ctf/types/enum.c | 27 ++++--- formats/ctf/types/float.c | 8 +- formats/ctf/types/integer.c | 36 ++++----- formats/ctf/types/string.c | 13 ++-- include/babeltrace/bitfield.h | 135 +++++++++++++++++---------------- include/babeltrace/ctf/types.h | 10 +-- include/babeltrace/format.h | 12 ++- include/babeltrace/types.h | 18 ++++- tests/test-bitfield.c | 102 ++++++++++++------------- types/enum.c | 15 +++- types/string.c | 2 +- 11 files changed, 201 insertions(+), 177 deletions(-) diff --git a/formats/ctf/types/enum.c b/formats/ctf/types/enum.c index a62d84e7..e0bb545b 100644 --- a/formats/ctf/types/enum.c +++ b/formats/ctf/types/enum.c @@ -20,8 +20,8 @@ #include #include -GQuark ctf_enum_read(struct stream_pos *pos, - const struct type_class_enum *src) +GArray *ctf_enum_read(struct stream_pos *pos, + const struct type_class_enum *src) { const struct type_class_integer *int_class = &src->p; @@ -29,30 +29,33 @@ GQuark ctf_enum_read(struct stream_pos *pos, uint64_t v; v = ctf_uint_read(pos, int_class); - return enum_uint_to_quark(src, v); + return enum_uint_to_quark_set(src, v); } else { int64_t v; v = ctf_int_read(pos, int_class); - return enum_int_to_quark(src, v); + return enum_int_to_quark_set(src, v); } } +/* + * Arbitrarily choose the start of the first matching range. + */ void ctf_enum_write(struct stream_pos *pos, - const struct type_class_enum *dest, - GQuark q) + const struct type_class_enum *dest, + GQuark q) { const struct type_class_integer *int_class = &dest->p; + GArray *array; - if (!int_class->signedness) { - uint64_t v; + array = enum_quark_to_range_set(dest, q); + assert(array); - v = enum_quark_to_uint(dest, q); + if (!int_class->signedness) { + uint64_t v = g_array_index(array, struct enum_range, 0).start._unsigned; ctf_uint_write(pos, int_class, v); } else { - int64_t v; - - v = enum_quark_to_int(dest, q); + int64_t v = g_array_index(array, struct enum_range, 0).start._unsigned; ctf_int_write(pos, int_class, v); } } diff --git a/formats/ctf/types/float.c b/formats/ctf/types/float.c index be068316..3651f0c3 100644 --- a/formats/ctf/types/float.c +++ b/formats/ctf/types/float.c @@ -119,7 +119,7 @@ double ctf_double_read(struct stream_pos *srcp, struct stream_pos destp; align_pos(srcp, float_class->p.alignment); - init_pos(&destp, (unsigned char *) u.bits); + init_pos(&destp, (char *) u.bits); _ctf_float_copy(&destp, dest_class, srcp, float_class); float_type_free(dest_class); return u.v; @@ -139,7 +139,7 @@ void ctf_double_write(struct stream_pos *destp, u.v = v; align_pos(destp, float_class->p.alignment); - init_pos(&srcp, (unsigned char *) u.bits); + init_pos(&srcp, (char *) u.bits); _ctf_float_copy(destp, float_class, &srcp, src_class); float_type_free(src_class); } @@ -156,7 +156,7 @@ long double ctf_ldouble_read(struct stream_pos *srcp, struct stream_pos destp; align_pos(srcp, float_class->p.alignment); - init_pos(&destp, (unsigned char *) u.bits); + init_pos(&destp, (char *) u.bits); _ctf_float_copy(&destp, dest_class, srcp, float_class); float_type_free(dest_class); return u.v; @@ -176,7 +176,7 @@ void ctf_ldouble_write(struct stream_pos *destp, u.v = v; align_pos(destp, float_class->p.alignment); - init_pos(&srcp, (unsigned char *) u.bits); + init_pos(&srcp, (char *) u.bits); _ctf_float_copy(destp, float_class, &srcp, src_class); float_type_free(src_class); } diff --git a/formats/ctf/types/integer.c b/formats/ctf/types/integer.c index e0de8052..127b8062 100644 --- a/formats/ctf/types/integer.c +++ b/formats/ctf/types/integer.c @@ -190,15 +190,15 @@ end: uint64_t ctf_uint_read(struct stream_pos *pos, const struct type_class_integer *int_class) { - uint64_t v; + uint64_t v = 0; align_pos(pos, int_class->p.alignment); if (int_class->byte_order == LITTLE_ENDIAN) - ctf_bitfield_read_le(pos->base, pos->offset, - int_class->len, &v); + bt_bitfield_read_le(pos->base, unsigned long, pos->offset, + int_class->len, &v); else - ctf_bitfield_read_be(pos->base, pos->offset, - int_class->len, &v); + bt_bitfield_read_be(pos->base, unsigned long, pos->offset, + int_class->len, &v); move_pos(pos, int_class->len); return v; } @@ -206,15 +206,15 @@ uint64_t ctf_uint_read(struct stream_pos *pos, int64_t ctf_int_read(struct stream_pos *pos, const struct type_class_integer *int_class) { - int64_t v; + int64_t v = 0; align_pos(pos, int_class->p.alignment); if (int_class->byte_order == LITTLE_ENDIAN) - ctf_bitfield_read_le(pos->base, pos->offset, - int_class->len, &v); + bt_bitfield_read_le(pos->base, unsigned long, pos->offset, + int_class->len, &v); else - ctf_bitfield_read_be(pos->base, pos->offset, - int_class->len, &v); + bt_bitfield_read_be(pos->base, unsigned long, pos->offset, + int_class->len, &v); move_pos(pos, int_class->len); return v; } @@ -227,11 +227,11 @@ void ctf_uint_write(struct stream_pos *pos, if (pos->dummy) goto end; if (int_class->byte_order == LITTLE_ENDIAN) - ctf_bitfield_write_le(pos->base, pos->offset, - int_class->len, v); + bt_bitfield_write_le(pos->base, unsigned long, pos->offset, + int_class->len, v); else - ctf_bitfield_write_be(pos->base, pos->offset, - int_class->len, v); + bt_bitfield_write_be(pos->base, unsigned long, pos->offset, + int_class->len, v); end: move_pos(pos, int_class->len); } @@ -244,11 +244,11 @@ void ctf_int_write(struct stream_pos *pos, if (pos->dummy) goto end; if (int_class->byte_order == LITTLE_ENDIAN) - ctf_bitfield_write_le(pos->base, pos->offset, - int_class->len, v); + bt_bitfield_write_le(pos->base, unsigned long, pos->offset, + int_class->len, v); else - ctf_bitfield_write_be(pos->base, pos->offset, - int_class->len, v); + bt_bitfield_write_be(pos->base, unsigned long, pos->offset, + int_class->len, v); end: move_pos(pos, int_class->len); } diff --git a/formats/ctf/types/string.c b/formats/ctf/types/string.c index fab69c4f..95a81a30 100644 --- a/formats/ctf/types/string.c +++ b/formats/ctf/types/string.c @@ -24,7 +24,7 @@ void ctf_string_copy(struct stream_pos *dest, struct stream_pos *src, const struct type_class_string *string_class) { size_t len; - unsigned char *destaddr, *srcaddr; + char *destaddr, *srcaddr; align_pos(src, string_class->p.alignment); srcaddr = get_pos_addr(src); @@ -39,26 +39,25 @@ end: move_pos(src, len); } -void ctf_string_read(unsigned char **dest, struct stream_pos *src, +void ctf_string_read(char **dest, struct stream_pos *src, const struct type_class_string *string_class) { size_t len; - unsigned char *srcaddr; + char *srcaddr; align_pos(src, string_class->p.alignment); srcaddr = get_pos_addr(src); len = strlen(srcaddr) + 1; *dest = g_realloc(*dest, len); strcpy(*dest, srcaddr); -end: move_pos(src, len); } -void ctf_string_write(struct stream_pos *dest, const unsigned char *src, +void ctf_string_write(struct stream_pos *dest, const char *src, const struct type_class_string *string_class) { size_t len; - unsigned char *destaddr; + char *destaddr; align_pos(dest, string_class->p.alignment); len = strlen(src) + 1; @@ -70,7 +69,7 @@ end: move_pos(dest, len); } -void ctf_string_free_temp(unsigned char *string) +void ctf_string_free_temp(char *string) { g_free(string); } diff --git a/include/babeltrace/bitfield.h b/include/babeltrace/bitfield.h index 449923c2..455650ed 100644 --- a/include/babeltrace/bitfield.h +++ b/include/babeltrace/bitfield.h @@ -74,11 +74,11 @@ * Also, consecutive bitfields are placed from higher to lower bits. */ -#define _bt_bitfield_write_le(ptr, _start, _length, _v) \ +#define _bt_bitfield_write_le(ptr, type, _start, _length, _v) \ do { \ typeof(_v) v = (_v); \ - typeof(*(ptr)) mask, cmask; \ - unsigned long ts = sizeof(typeof(*(ptr))) * CHAR_BIT; /* type size */ \ + type mask, cmask; \ + unsigned long ts = sizeof(type) * CHAR_BIT; /* type size */ \ unsigned long start = (_start), length = (_length); \ unsigned long start_unit, end_unit, this_unit; \ unsigned long end, cshift; /* cshift is "complement shift" */ \ @@ -97,10 +97,10 @@ do { \ /* We can now append v with a simple "or", shift it piece-wise */ \ this_unit = start_unit; \ if (start_unit == end_unit - 1) { \ - mask = ~((~(typeof(*(ptr))) 0) << (start % ts)); \ + mask = ~((~(type) 0) << (start % ts)); \ if (end % ts) \ - mask |= (~(typeof(*(ptr))) 0) << (end % ts); \ - cmask = (typeof(*(ptr))) v << (start % ts); \ + mask |= (~(type) 0) << (end % ts); \ + cmask = (type) v << (start % ts); \ cmask &= ~mask; \ (ptr)[this_unit] &= mask; \ (ptr)[this_unit] |= cmask; \ @@ -108,8 +108,8 @@ do { \ } \ if (start % ts) { \ cshift = start % ts; \ - mask = ~((~(typeof(*(ptr))) 0) << cshift); \ - cmask = (typeof(*(ptr))) v << cshift; \ + mask = ~((~(type) 0) << cshift); \ + cmask = (type) v << cshift; \ cmask &= ~mask; \ (ptr)[this_unit] &= mask; \ (ptr)[this_unit] |= cmask; \ @@ -118,26 +118,26 @@ do { \ this_unit++; \ } \ for (; this_unit < end_unit - 1; this_unit++) { \ - (ptr)[this_unit] = (typeof(*(ptr))) v; \ + (ptr)[this_unit] = (type) v; \ v = _bt_piecewise_rshift(v, ts); \ start += ts; \ } \ if (end % ts) { \ - mask = (~(typeof(*(ptr))) 0) << (end % ts); \ - cmask = (typeof(*(ptr))) v; \ + mask = (~(type) 0) << (end % ts); \ + cmask = (type) v; \ cmask &= ~mask; \ (ptr)[this_unit] &= mask; \ (ptr)[this_unit] |= cmask; \ } else \ - (ptr)[this_unit] = (typeof(*(ptr))) v; \ + (ptr)[this_unit] = (type) v; \ } while (0) -#define _bt_bitfield_write_be(ptr, _start, _length, _v) \ +#define _bt_bitfield_write_be(ptr, type, _start, _length, _v) \ do { \ typeof(_v) v = (_v); \ - typeof(*(ptr)) mask, cmask; \ - unsigned long ts = sizeof(typeof(*(ptr))) * CHAR_BIT; /* type size */ \ - unsigned long start = _start, length = _length; \ + type mask, cmask; \ + unsigned long ts = sizeof(type) * CHAR_BIT; /* type size */ \ + unsigned long start = (_start), length = (_length); \ unsigned long start_unit, end_unit, this_unit; \ unsigned long end, cshift; /* cshift is "complement shift" */ \ \ @@ -155,10 +155,10 @@ do { \ /* We can now append v with a simple "or", shift it piece-wise */ \ this_unit = end_unit - 1; \ if (start_unit == end_unit - 1) { \ - mask = ~((~(typeof(*(ptr))) 0) << ((ts - (end % ts)) % ts)); \ + mask = ~((~(type) 0) << ((ts - (end % ts)) % ts)); \ if (start % ts) \ - mask |= (~((typeof(*(ptr))) 0)) << (ts - (start % ts)); \ - cmask = (typeof(*(ptr))) v << ((ts - (end % ts)) % ts); \ + mask |= (~((type) 0)) << (ts - (start % ts)); \ + cmask = (type) v << ((ts - (end % ts)) % ts); \ cmask &= ~mask; \ (ptr)[this_unit] &= mask; \ (ptr)[this_unit] |= cmask; \ @@ -166,8 +166,8 @@ do { \ } \ if (end % ts) { \ cshift = end % ts; \ - mask = ~((~(typeof(*(ptr))) 0) << (ts - cshift)); \ - cmask = (typeof(*(ptr))) v << (ts - cshift); \ + mask = ~((~(type) 0) << (ts - cshift)); \ + cmask = (type) v << (ts - cshift); \ cmask &= ~mask; \ (ptr)[this_unit] &= mask; \ (ptr)[this_unit] |= cmask; \ @@ -176,18 +176,18 @@ do { \ this_unit--; \ } \ for (; (long) this_unit >= (long) start_unit + 1; this_unit--) { \ - (ptr)[this_unit] = (typeof(*(ptr))) v; \ + (ptr)[this_unit] = (type) v; \ v = _bt_piecewise_rshift(v, ts); \ end -= ts; \ } \ if (start % ts) { \ - mask = (~(typeof(*(ptr))) 0) << (ts - (start % ts)); \ - cmask = (typeof(*(ptr))) v; \ + mask = (~(type) 0) << (ts - (start % ts)); \ + cmask = (type) v; \ cmask &= ~mask; \ (ptr)[this_unit] &= mask; \ (ptr)[this_unit] |= cmask; \ } else \ - (ptr)[this_unit] = (typeof(*(ptr))) v; \ + (ptr)[this_unit] = (type) v; \ } while (0) /* @@ -198,25 +198,25 @@ do { \ #if (BYTE_ORDER == LITTLE_ENDIAN) -#define bt_bitfield_write(ptr, _start, _length, _v) \ - _bt_bitfield_write_le(ptr, _start, _length, _v) +#define bt_bitfield_write(ptr, type, _start, _length, _v) \ + _bt_bitfield_write_le(ptr, type, _start, _length, _v) -#define bt_bitfield_write_le(ptr, _start, _length, _v) \ - _bt_bitfield_write_le(ptr, _start, _length, _v) +#define bt_bitfield_write_le(ptr, type, _start, _length, _v) \ + _bt_bitfield_write_le(ptr, type, _start, _length, _v) -#define bt_bitfield_write_be(ptr, _start, _length, _v) \ - _bt_bitfield_write_be((unsigned char *) (ptr), _start, _length, _v) +#define bt_bitfield_write_be(ptr, type, _start, _length, _v) \ + _bt_bitfield_write_be(ptr, unsigned char, _start, _length, _v) #elif (BYTE_ORDER == BIG_ENDIAN) -#define bt_bitfield_write(ptr, _start, _length, _v) \ - _bt_bitfield_write_be(ptr, _start, _length, _v) +#define bt_bitfield_write(ptr, type, _start, _length, _v) \ + _bt_bitfield_write_be(ptr, type, _start, _length, _v) -#define bt_bitfield_write_le(ptr, _start, _length, _v) \ - _bt_bitfield_write_le((unsigned char *) (ptr), _start, _length, _v) +#define bt_bitfield_write_le(ptr, type, _start, _length, _v) \ + _bt_bitfield_write_le(ptr, unsigned char, _start, _length, _v) -#define bt_bitfield_write_be(ptr, _start, _length, _v) \ - _bt_bitfield_write_be(ptr, _start, _length, _v) +#define bt_bitfield_write_be(ptr, type, _start, _length, _v) \ + _bt_bitfield_write_be(ptr, type, _start, _length, _v) #else /* (BYTE_ORDER == PDP_ENDIAN) */ @@ -224,12 +224,12 @@ do { \ #endif -#define _bt_bitfield_read_le(ptr, _start, _length, vptr) \ +#define _bt_bitfield_read_le(ptr, type, _start, _length, vptr) \ do { \ typeof(*(vptr)) v; \ - typeof(*(ptr)) mask, cmask; \ - unsigned long ts = sizeof(typeof(*(ptr))) * CHAR_BIT; /* type size */ \ - unsigned long start = _start, length = _length; \ + type mask, cmask; \ + unsigned long ts = sizeof(type) * CHAR_BIT; /* type size */ \ + unsigned long start = (_start), length = (_length); \ unsigned long start_unit, end_unit, this_unit; \ unsigned long end, cshift; /* cshift is "complement shift" */ \ \ @@ -244,7 +244,7 @@ do { \ \ this_unit = end_unit - 1; \ if (_bt_is_signed_type(typeof(v)) \ - && ((ptr)[this_unit] & ((typeof(*(ptr))) 1 << ((end % ts ? : ts) - 1)))) \ + && ((ptr)[this_unit] & ((type) 1 << ((end % ts ? : ts) - 1)))) \ v = ~(typeof(v)) 0; \ else \ v = 0; \ @@ -252,7 +252,7 @@ do { \ cmask = (ptr)[this_unit]; \ cmask >>= (start % ts); \ if ((end - start) % ts) { \ - mask = ~((~(typeof(*(ptr))) 0) << (end - start)); \ + mask = ~((~(type) 0) << (end - start)); \ cmask &= mask; \ } \ v = _bt_piecewise_lshift(v, end - start); \ @@ -262,7 +262,7 @@ do { \ } \ if (end % ts) { \ cshift = end % ts; \ - mask = ~((~(typeof(*(ptr))) 0) << cshift); \ + mask = ~((~(type) 0) << cshift); \ cmask = (ptr)[this_unit]; \ cmask &= mask; \ v = _bt_piecewise_lshift(v, cshift); \ @@ -276,7 +276,7 @@ do { \ end -= ts; \ } \ if (start % ts) { \ - mask = ~((~(typeof(*(ptr))) 0) << (ts - (start % ts))); \ + mask = ~((~(type) 0) << (ts - (start % ts))); \ cmask = (ptr)[this_unit]; \ cmask >>= (start % ts); \ cmask &= mask; \ @@ -289,12 +289,12 @@ do { \ *(vptr) = v; \ } while (0) -#define _bt_bitfield_read_be(ptr, _start, _length, vptr) \ +#define _bt_bitfield_read_be(ptr, type, _start, _length, vptr) \ do { \ typeof(*(vptr)) v; \ - typeof(*(ptr)) mask, cmask; \ - unsigned long ts = sizeof(typeof(*(ptr))) * CHAR_BIT; /* type size */ \ - unsigned long start = _start, length = _length; \ + type mask, cmask; \ + unsigned long ts = sizeof(type) * CHAR_BIT; /* type size */ \ + unsigned long start = (_start), length = (_length); \ unsigned long start_unit, end_unit, this_unit; \ unsigned long end, cshift; /* cshift is "complement shift" */ \ \ @@ -309,7 +309,7 @@ do { \ \ this_unit = start_unit; \ if (_bt_is_signed_type(typeof(v)) \ - && ((ptr)[this_unit] & ((typeof(*(ptr))) 1 << (ts - (start % ts) - 1)))) \ + && ((ptr)[this_unit] & ((type) 1 << (ts - (start % ts) - 1)))) \ v = ~(typeof(v)) 0; \ else \ v = 0; \ @@ -317,7 +317,7 @@ do { \ cmask = (ptr)[this_unit]; \ cmask >>= (ts - (end % ts)) % ts; \ if ((end - start) % ts) { \ - mask = ~((~(typeof(*(ptr))) 0) << (end - start)); \ + mask = ~((~(type) 0) << (end - start)); \ cmask &= mask; \ } \ v = _bt_piecewise_lshift(v, end - start); \ @@ -326,12 +326,13 @@ do { \ break; \ } \ if (start % ts) { \ - mask = ~((~(typeof(*(ptr))) 0) << (ts - (start % ts))); \ + cshift = start % ts; \ + mask = ~((~(type) 0) << (ts - cshift)); \ cmask = (ptr)[this_unit]; \ cmask &= mask; \ - v = _bt_piecewise_lshift(v, ts - (start % ts)); \ + v = _bt_piecewise_lshift(v, ts - cshift); \ v |= _bt_unsigned_cast(typeof(v), cmask); \ - start += ts - (start % ts); \ + start += ts - cshift; \ this_unit++; \ } \ for (; this_unit < end_unit - 1; this_unit++) { \ @@ -340,7 +341,7 @@ do { \ start += ts; \ } \ if (end % ts) { \ - mask = ~((~(typeof(*(ptr))) 0) << (end % ts)); \ + mask = ~((~(type) 0) << (end % ts)); \ cmask = (ptr)[this_unit]; \ cmask >>= ts - (end % ts); \ cmask &= mask; \ @@ -361,25 +362,25 @@ do { \ #if (BYTE_ORDER == LITTLE_ENDIAN) -#define bt_bitfield_read(ptr, _start, _length, _vptr) \ - _bt_bitfield_read_le(ptr, _start, _length, _vptr) +#define bt_bitfield_read(ptr, type, _start, _length, _vptr) \ + _bt_bitfield_read_le(ptr, type, _start, _length, _vptr) -#define bt_bitfield_read_le(ptr, _start, _length, _vptr) \ - _bt_bitfield_read_le(ptr, _start, _length, _vptr) +#define bt_bitfield_read_le(ptr, type, _start, _length, _vptr) \ + _bt_bitfield_read_le(ptr, type, _start, _length, _vptr) -#define bt_bitfield_read_be(ptr, _start, _length, _vptr) \ - _bt_bitfield_read_be((const unsigned char *) (ptr), _start, _length, _vptr) +#define bt_bitfield_read_be(ptr, type, _start, _length, _vptr) \ + _bt_bitfield_read_be(ptr, unsigned char, _start, _length, _vptr) #elif (BYTE_ORDER == BIG_ENDIAN) -#define bt_bitfield_read(ptr, _start, _length, _vptr) \ - _bt_bitfield_read_be(ptr, _start, _length, _vptr) +#define bt_bitfield_read(ptr, type, _start, _length, _vptr) \ + _bt_bitfield_read_be(ptr, type, _start, _length, _vptr) -#define bt_bitfield_read_le(ptr, _start, _length, _vptr) \ - _bt_bitfield_read_le((const unsigned char *) (ptr), _start, _length, _vptr) +#define bt_bitfield_read_le(ptr, type, _start, _length, _vptr) \ + _bt_bitfield_read_le(ptr, unsigned char, _start, _length, _vptr) -#define bt_bitfield_read_be(ptr, _start, _length, _vptr) \ - _bt_bitfield_read_be(ptr, _start, _length, _vptr) +#define bt_bitfield_read_be(ptr, type, _start, _length, _vptr) \ + _bt_bitfield_read_be(ptr, type, _start, _length, _vptr) #else /* (BYTE_ORDER == PDP_ENDIAN) */ diff --git a/include/babeltrace/ctf/types.h b/include/babeltrace/ctf/types.h index a2ccca68..c5ce9d2b 100644 --- a/include/babeltrace/ctf/types.h +++ b/include/babeltrace/ctf/types.h @@ -59,14 +59,14 @@ void ctf_float_copy(struct stream_pos *destp, void ctf_string_copy(struct stream_pos *dest, struct stream_pos *src, const struct type_class_string *string_class); -void ctf_string_read(unsigned char **dest, struct stream_pos *src, +void ctf_string_read(char **dest, struct stream_pos *src, const struct type_class_string *string_class); -void ctf_string_write(struct stream_pos *dest, const unsigned char *src, +void ctf_string_write(struct stream_pos *dest, const char *src, const struct type_class_string *string_class); -void ctf_string_free_temp(unsigned char *string); +void ctf_string_free_temp(char *string); -GQuark ctf_enum_read(struct stream_pos *pos, - const struct type_class_enum *src); +GArray *ctf_enum_read(struct stream_pos *pos, + const struct type_class_enum *src); void ctf_enum_write(struct stream_pos *pos, const struct type_class_enum *dest, GQuark q); diff --git a/include/babeltrace/format.h b/include/babeltrace/format.h index c6dedc1a..b9c3e9fb 100644 --- a/include/babeltrace/format.h +++ b/include/babeltrace/format.h @@ -48,13 +48,17 @@ struct format { void (*string_copy)(struct stream_pos *dest, struct stream_pos *src, const struct type_class_string *string_class); - void (*string_read)(unsigned char **dest, struct stream_pos *src, + void (*string_read)(char **dest, struct stream_pos *src, const struct type_class_string *string_class); - void (*string_write)(struct stream_pos *dest, const unsigned char *src, + void (*string_write)(struct stream_pos *dest, const char *src, const struct type_class_string *string_class); - void (*string_free_temp)(unsigned char *string); + void (*string_free_temp)(char *string); - GQuark (*enum_read)(struct stream_pos *pos, + /* + * enum_read returns a GArray of GQuark. Must be released with + * g_array_unref(). + */ + GArray *(*enum_read)(struct stream_pos *pos, const struct type_class_enum *src); void (*enum_write)(struct stream_pos *pos, const struct type_class_enum *dest, diff --git a/include/babeltrace/types.h b/include/babeltrace/types.h index 9a425ae2..d6ac7924 100644 --- a/include/babeltrace/types.h +++ b/include/babeltrace/types.h @@ -35,13 +35,13 @@ * Always update stream_pos with move_pos and init_pos. */ struct stream_pos { - unsigned char *base; /* Base address */ + char *base; /* Base address */ size_t offset; /* Offset from base, in bits */ int dummy; /* Dummy position, for length calculation */ }; static inline -void init_pos(struct stream_pos *pos, unsigned char *base) +void init_pos(struct stream_pos *pos, char *base) { pos->base = base; /* initial base, page-aligned */ pos->offset = 0; @@ -77,7 +77,7 @@ void copy_pos(struct stream_pos *dest, struct stream_pos *src) } static inline -unsigned char *get_pos_addr(struct stream_pos *pos) +char *get_pos_addr(struct stream_pos *pos) { /* Only makes sense to get the address after aligning on CHAR_BIT */ assert(!(pos->offset % CHAR_BIT)); @@ -219,15 +219,25 @@ void float_type_free(struct type_class_float *float_class); * A GQuark can be translated to/from strings with g_quark_from_string() and * g_quark_to_string(). */ + +/* + * Returns a GArray of GQuark or NULL. + * Caller must release the GArray with g_array_unref(). + */ GArray *enum_uint_to_quark_set(const struct type_class_enum *enum_class, uint64_t v); /* - * Returns a GArray or NULL. + * Returns a GArray of GQuark or NULL. * Caller must release the GArray with g_array_unref(). */ GArray *enum_int_to_quark_set(const struct type_class_enum *enum_class, uint64_t v); + +/* + * Returns a GArray of struct enum_range or NULL. + * Caller must release the GArray with g_array_unref(). + */ GArray *enum_quark_to_range_set(const struct type_class_enum *enum_class, GQuark q); void enum_signed_insert(struct type_class_enum *enum_class, diff --git a/tests/test-bitfield.c b/tests/test-bitfield.c index f8b63853..045b7d94 100644 --- a/tests/test-bitfield.c +++ b/tests/test-bitfield.c @@ -22,6 +22,8 @@ #define _GNU_SOURCE #include +#include +#include #include unsigned int glob; @@ -32,7 +34,7 @@ unsigned int glob; */ void fct(void) { - bt_bitfield_write(&glob, 12, 15, 0x12345678); + bt_bitfield_write(&glob, unsigned int, 12, 15, 0x12345678); } /* Test array size, in bytes */ @@ -95,31 +97,29 @@ static int fls(unsigned int x) #endif -static void print_byte_array(const unsigned char *c, unsigned long len) -{ - unsigned long i; - - for (i = 0; i < len; i++) { - printf("0x%X", c[i]); - if (i != len - 1) - printf(" "); - } - printf("\n"); -} - -static void init_byte_array(unsigned char *c, - unsigned long len, - unsigned char val) -{ - unsigned long i; - - for (i = 0; i < len; i++) - c[i] = val; -} +#define print_byte_array(c, len) \ +do { \ + unsigned long i; \ + \ + for (i = 0; i < (len); i++) { \ + printf("0x%X", (c)[i]); \ + if (i != (len) - 1) \ + printf(" "); \ + } \ + printf("\n"); \ +} while (0) + +#define init_byte_array(c, len, val) \ +do { \ + unsigned long i; \ + \ + for (i = 0; i < (len); i++) \ + (c)[i] = (val); \ +} while (0) int run_test_unsigned(void) { - unsigned int src, nrbits; + unsigned long src, nrbits; union { unsigned char c[TEST_LEN]; unsigned short s[TEST_LEN/sizeof(unsigned short)]; @@ -139,8 +139,8 @@ int run_test_unsigned(void) for (s = 0; s < CHAR_BIT * TEST_LEN; s++) { for (l = nrbits; l < (CHAR_BIT * TEST_LEN) - s; l++) { init_byte_array(target.c, TEST_LEN, 0xFF); - bt_bitfield_write(target.c, s, l, src); - bt_bitfield_read(target.c, s, l, &readval); + bt_bitfield_write(target.c, unsigned char, s, l, src); + bt_bitfield_read(target.c, unsigned char, s, l, &readval); if (readval != src) { printf("Error (bytewise) src %lX read %llX shift %d len %d\n", src, readval, s, l); @@ -149,8 +149,8 @@ int run_test_unsigned(void) } init_byte_array(target.c, TEST_LEN, 0xFF); - bt_bitfield_write(target.s, s, l, src); - bt_bitfield_read(target.c, s, l, &readval); + bt_bitfield_write(target.s, unsigned short, s, l, src); + bt_bitfield_read(target.c, unsigned char, s, l, &readval); if (readval != src) { printf("Error (shortwise) src %lX read %llX shift %d len %d\n", src, readval, s, l); @@ -159,8 +159,8 @@ int run_test_unsigned(void) } init_byte_array(target.c, TEST_LEN, 0xFF); - bt_bitfield_write(target.i, s, l, src); - bt_bitfield_read(target.c, s, l, &readval); + bt_bitfield_write(target.i, unsigned int, s, l, src); + bt_bitfield_read(target.c, unsigned char, s, l, &readval); if (readval != src) { printf("Error (intwise) src %lX read %llX shift %d len %d\n", src, readval, s, l); @@ -169,8 +169,8 @@ int run_test_unsigned(void) } init_byte_array(target.c, TEST_LEN, 0xFF); - bt_bitfield_write(target.l, s, l, src); - bt_bitfield_read(target.c, s, l, &readval); + bt_bitfield_write(target.l, unsigned long, s, l, src); + bt_bitfield_read(target.c, unsigned char, s, l, &readval); if (readval != src) { printf("Error (longwise) src %lX read %llX shift %d len %d\n", src, readval, s, l); @@ -179,8 +179,8 @@ int run_test_unsigned(void) } init_byte_array(target.c, TEST_LEN, 0xFF); - bt_bitfield_write(target.ll, s, l, src); - bt_bitfield_read(target.c, s, l, &readval); + bt_bitfield_write(target.ll, unsigned long long, s, l, src); + bt_bitfield_read(target.c, unsigned char, s, l, &readval); if (readval != src) { printf("Error (longlongwise) src %lX read %llX shift %d len %d\n", src, readval, s, l); @@ -198,9 +198,9 @@ int run_test_unsigned(void) int run_test_signed(void) { - int src, nrbits; + long src, nrbits; union { - char c[TEST_LEN]; + signed char c[TEST_LEN]; short s[TEST_LEN/sizeof(short)]; int i[TEST_LEN/sizeof(int)]; long l[TEST_LEN/sizeof(long)]; @@ -221,8 +221,8 @@ int run_test_signed(void) for (s = 0; s < 8 * TEST_LEN; s++) { for (l = nrbits; l < (8 * TEST_LEN) - s; l++) { init_byte_array(target.c, TEST_LEN, 0x0); - bt_bitfield_write(target.c, s, l, src); - bt_bitfield_read(target.c, s, l, &readval); + bt_bitfield_write(target.c, signed char, s, l, src); + bt_bitfield_read(target.c, signed char, s, l, &readval); if (readval != src) { printf("Error (bytewise) src %lX read %llX shift %d len %d\n", src, readval, s, l); @@ -231,8 +231,8 @@ int run_test_signed(void) } init_byte_array(target.c, TEST_LEN, 0x0); - bt_bitfield_write(target.s, s, l, src); - bt_bitfield_read(target.c, s, l, &readval); + bt_bitfield_write(target.s, short, s, l, src); + bt_bitfield_read(target.c, signed char, s, l, &readval); if (readval != src) { printf("Error (shortwise) src %lX read %llX shift %d len %d\n", src, readval, s, l); @@ -241,8 +241,8 @@ int run_test_signed(void) } init_byte_array(target.c, TEST_LEN, 0x0); - bt_bitfield_write(target.i, s, l, src); - bt_bitfield_read(target.c, s, l, &readval); + bt_bitfield_write(target.i, int, s, l, src); + bt_bitfield_read(target.c, signed char, s, l, &readval); if (readval != src) { printf("Error (intwise) src %lX read %llX shift %d len %d\n", src, readval, s, l); @@ -251,8 +251,8 @@ int run_test_signed(void) } init_byte_array(target.c, TEST_LEN, 0x0); - bt_bitfield_write(target.l, s, l, src); - bt_bitfield_read(target.c, s, l, &readval); + bt_bitfield_write(target.l, long, s, l, src); + bt_bitfield_read(target.c, signed char, s, l, &readval); if (readval != src) { printf("Error (longwise) src %lX read %llX shift %d len %d\n", src, readval, s, l); @@ -261,8 +261,8 @@ int run_test_signed(void) } init_byte_array(target.c, TEST_LEN, 0x0); - bt_bitfield_write(target.ll, s, l, src); - bt_bitfield_read(target.c, s, l, &readval); + bt_bitfield_write(target.ll, long long, s, l, src); + bt_bitfield_read(target.c, signed char, s, l, &readval); if (readval != src) { printf("Error (longlongwise) src %lX read %llX shift %d len %d\n", src, readval, s, l); @@ -335,35 +335,35 @@ int main(int argc, char **argv) target.i[0] = 0xFFFFFFFF; target.i[1] = 0xFFFFFFFF; - bt_bitfield_write(target.c, shift, len, src); + bt_bitfield_write(target.c, unsigned char, shift, len, src); printf("bytewise\n"); print_byte_array(target.c, 8); target.i[0] = 0xFFFFFFFF; target.i[1] = 0xFFFFFFFF; - bt_bitfield_write(target.s, shift, len, src); + bt_bitfield_write(target.s, unsigned short, shift, len, src); printf("shortwise\n"); print_byte_array(target.c, 8); target.i[0] = 0xFFFFFFFF; target.i[1] = 0xFFFFFFFF; - bt_bitfield_write(target.i, shift, len, src); + bt_bitfield_write(target.i, unsigned int, shift, len, src); printf("intwise\n"); print_byte_array(target.c, 8); target.i[0] = 0xFFFFFFFF; target.i[1] = 0xFFFFFFFF; - bt_bitfield_write(target.l, shift, len, src); + bt_bitfield_write(target.l, unsigned long, shift, len, src); printf("longwise\n"); print_byte_array(target.c, 8); target.i[0] = 0xFFFFFFFF; target.i[1] = 0xFFFFFFFF; - bt_bitfield_write(target.ll, shift, len, src); + bt_bitfield_write(target.ll, unsigned long long, shift, len, src); printf("lluwise\n"); print_byte_array(target.c, 8); - bt_bitfield_read(target.c, shift, len, &readval); + bt_bitfield_read(target.c, unsigned char, shift, len, &readval); printf("read: %llX\n", readval); ret = run_test(); diff --git a/types/enum.c b/types/enum.c index bfed769d..daf13507 100644 --- a/types/enum.c +++ b/types/enum.c @@ -233,9 +233,8 @@ void enum_unsigned_insert_value_to_quark_set(struct type_class_enum *enum_class, GArray *enum_quark_to_range_set(const struct type_class_enum *enum_class, GQuark q) { - gconstpointer v = g_hash_table_lookup(enum_class->table.quark_to_range_set, - (gconstpointer) (unsigned long) q); - return (GArray *) v; + return g_hash_table_lookup(enum_class->table.quark_to_range_set, + (gconstpointer) (unsigned long) q); } static @@ -339,9 +338,17 @@ void enum_copy(struct stream_pos *dest, const struct format *fdest, { struct type_class_enum *enum_class = container_of(type_class, struct type_class_enum, p.p); + GArray *array; GQuark v; - v = fsrc->enum_read(src, enum_class); + array = fsrc->enum_read(src, enum_class); + assert(array); + /* + * Arbitrarily choose the first one. + * TODO: use direct underlying type read/write intead. Not doing it for + * now to test enum read and write code. + */ + v = g_array_index(array, GQuark, 0); return fdest->enum_write(dest, enum_class, v); } diff --git a/types/string.c b/types/string.c index d38d3cf3..ab0ec72c 100644 --- a/types/string.c +++ b/types/string.c @@ -30,7 +30,7 @@ void string_copy(struct stream_pos *dest, const struct format *fdest, if (fsrc->string_copy == fdest->string_copy) { fsrc->string_copy(dest, src, string_class); } else { - unsigned char *tmp = NULL; + char *tmp = NULL; fsrc->string_read(&tmp, src, string_class); fdest->string_write(dest, tmp, string_class); -- 2.34.1