#include <stdint.h>
#include <glib.h>
-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;
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);
}
}
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;
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);
}
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;
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);
}
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;
}
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;
}
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);
}
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);
}
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);
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;
move_pos(dest, len);
}
-void ctf_string_free_temp(unsigned char *string)
+void ctf_string_free_temp(char *string)
{
g_free(string);
}
* 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" */ \
/* 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; \
} \
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; \
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" */ \
\
/* 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; \
} \
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; \
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)
/*
#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) */
#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" */ \
\
\
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; \
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); \
} \
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); \
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; \
*(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" */ \
\
\
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; \
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); \
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++) { \
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; \
#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) */
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);
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,
* 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;
}
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));
* 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,
#define _GNU_SOURCE
#include <babeltrace/bitfield.h>
+#include <time.h>
+#include <stdlib.h>
#include <stdio.h>
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 */
#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)];
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);
}
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);
}
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);
}
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);
}
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);
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)];
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);
}
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);
}
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);
}
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);
}
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);
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();
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
{
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);
}
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);