Use inheritance for trace descriptor and positions

[babeltrace.git] / formats / ctf / types / integer.c

diff --git a/formats/ctf/types/integer.c b/formats/ctf/types/integer.c
index fb6e0d425d2c7cbf420b11595aeff664ff1516a6..c024530058a1a67ab811ebbbdf24c715cfb1b01b 100644 (file)
--- a/formats/ctf/types/integer.c
+++ b/formats/ctf/types/integer.c
@@ -23,12 +23,13 @@
 #include <endian.h>
 
 static
-uint64_t _aligned_uint_read(struct stream_pos *pos,
-                      const struct declaration_integer *integer_declaration)
+uint64_t _aligned_uint_read(struct stream_pos *ppos,
+                           const struct declaration_integer *integer_declaration)
 {
+       struct ctf_stream_pos *pos = ctf_pos(ppos);
        int rbo = (integer_declaration->byte_order != BYTE_ORDER);      /* reverse byte order */
 
-       align_pos(pos, integer_declaration->p.alignment);
+       ctf_align_pos(pos, integer_declaration->p.alignment);
        assert(!(pos->offset % CHAR_BIT));
        switch (integer_declaration->len) {
        case 8:
@@ -36,7 +37,7 @@ uint64_t _aligned_uint_read(struct stream_pos *pos,
                uint8_t v;
 
                v = *(const uint8_t *)pos->base;
-               move_pos(pos, integer_declaration->len);
+               ctf_move_pos(pos, integer_declaration->len);
                return v;
        }
        case 16:
@@ -44,7 +45,7 @@ uint64_t _aligned_uint_read(struct stream_pos *pos,
                uint16_t v;
 
                v = *(const uint16_t *)pos->base;
-               move_pos(pos, integer_declaration->len);
+               ctf_move_pos(pos, integer_declaration->len);
                return rbo ? GUINT16_SWAP_LE_BE(v) : v;
        }
        case 32:
@@ -52,7 +53,7 @@ uint64_t _aligned_uint_read(struct stream_pos *pos,
                uint32_t v;
 
                v = *(const uint32_t *)pos->base;
-               move_pos(pos, integer_declaration->len);
+               ctf_move_pos(pos, integer_declaration->len);
                return rbo ? GUINT32_SWAP_LE_BE(v) : v;
        }
        case 64:
@@ -60,7 +61,7 @@ uint64_t _aligned_uint_read(struct stream_pos *pos,
                uint64_t v;
 
                v = *(const uint64_t *)pos->base;
-               move_pos(pos, integer_declaration->len);
+               ctf_move_pos(pos, integer_declaration->len);
                return rbo ? GUINT64_SWAP_LE_BE(v) : v;
        }
        default:
@@ -69,12 +70,13 @@ uint64_t _aligned_uint_read(struct stream_pos *pos,
 }
 
 static
-int64_t _aligned_int_read(struct stream_pos *pos,
-                    const struct declaration_integer *integer_declaration)
+int64_t _aligned_int_read(struct stream_pos *ppos,
+                         const struct declaration_integer *integer_declaration)
 {
+       struct ctf_stream_pos *pos = ctf_pos(ppos);
        int rbo = (integer_declaration->byte_order != BYTE_ORDER);      /* reverse byte order */
 
-       align_pos(pos, integer_declaration->p.alignment);
+       ctf_align_pos(pos, integer_declaration->p.alignment);
        assert(!(pos->offset % CHAR_BIT));
        switch (integer_declaration->len) {
        case 8:
@@ -82,7 +84,7 @@ int64_t _aligned_int_read(struct stream_pos *pos,
                int8_t v;
 
                v = *(const int8_t *)pos->base;
-               move_pos(pos, integer_declaration->len);
+               ctf_move_pos(pos, integer_declaration->len);
                return v;
        }
        case 16:
@@ -90,7 +92,7 @@ int64_t _aligned_int_read(struct stream_pos *pos,
                int16_t v;
 
                v = *(const int16_t *)pos->base;
-               move_pos(pos, integer_declaration->len);
+               ctf_move_pos(pos, integer_declaration->len);
                return rbo ? GUINT16_SWAP_LE_BE(v) : v;
        }
        case 32:
@@ -98,7 +100,7 @@ int64_t _aligned_int_read(struct stream_pos *pos,
                int32_t v;
 
                v = *(const int32_t *)pos->base;
-               move_pos(pos, integer_declaration->len);
+               ctf_move_pos(pos, integer_declaration->len);
                return rbo ? GUINT32_SWAP_LE_BE(v) : v;
        }
        case 64:
@@ -106,7 +108,7 @@ int64_t _aligned_int_read(struct stream_pos *pos,
                int64_t v;
 
                v = *(const int64_t *)pos->base;
-               move_pos(pos, integer_declaration->len);
+               ctf_move_pos(pos, integer_declaration->len);
                return rbo ? GUINT64_SWAP_LE_BE(v) : v;
        }
        default:
@@ -115,115 +117,121 @@ int64_t _aligned_int_read(struct stream_pos *pos,
 }
 
 static
-void _aligned_uint_write(struct stream_pos *pos,
-                   const struct declaration_integer *integer_declaration,
-                   uint64_t v)
+void _aligned_uint_write(struct stream_pos *ppos,
+                        const struct declaration_integer *integer_declaration,
+                        uint64_t v)
 {
+       struct ctf_stream_pos *pos = ctf_pos(ppos);
        int rbo = (integer_declaration->byte_order != BYTE_ORDER);      /* reverse byte order */
 
-       align_pos(pos, integer_declaration->p.alignment);
+       ctf_align_pos(pos, integer_declaration->p.alignment);
        assert(!(pos->offset % CHAR_BIT));
        if (pos->dummy)
                goto end;
 
        switch (integer_declaration->len) {
-       case 8: *(uint8_t *) get_pos_addr(pos) = (uint8_t) v;
+       case 8: *(uint8_t *) ctf_get_pos_addr(pos) = (uint8_t) v;
                break;
        case 16:
-               *(uint16_t *) get_pos_addr(pos) = rbo ?
+               *(uint16_t *) ctf_get_pos_addr(pos) = rbo ?
                                         GUINT16_SWAP_LE_BE((uint16_t) v) :
                                         (uint16_t) v;
                break;
        case 32:
-               *(uint32_t *) get_pos_addr(pos) = rbo ?
+               *(uint32_t *) ctf_get_pos_addr(pos) = rbo ?
                                         GUINT32_SWAP_LE_BE((uint32_t) v) :
                                         (uint32_t) v;
                break;
        case 64:
-               *(uint64_t *) get_pos_addr(pos) = rbo ?
+               *(uint64_t *) ctf_get_pos_addr(pos) = rbo ?
                                         GUINT64_SWAP_LE_BE(v) : v;
                break;
        default:
                assert(0);
        }
 end:
-       move_pos(pos, integer_declaration->len);
+       ctf_move_pos(pos, integer_declaration->len);
 }
 
 static
-void _aligned_int_write(struct stream_pos *pos,
-                  const struct declaration_integer *integer_declaration,
-                  int64_t v)
+void _aligned_int_write(struct stream_pos *ppos,
+                       const struct declaration_integer *integer_declaration,
+                       int64_t v)
 {
+       struct ctf_stream_pos *pos = ctf_pos(ppos);
        int rbo = (integer_declaration->byte_order != BYTE_ORDER);      /* reverse byte order */
 
-       align_pos(pos, integer_declaration->p.alignment);
+       ctf_align_pos(pos, integer_declaration->p.alignment);
        assert(!(pos->offset % CHAR_BIT));
        if (pos->dummy)
                goto end;
 
        switch (integer_declaration->len) {
-       case 8: *(int8_t *) get_pos_addr(pos) = (int8_t) v;
+       case 8: *(int8_t *) ctf_get_pos_addr(pos) = (int8_t) v;
                break;
        case 16:
-               *(int16_t *) get_pos_addr(pos) = rbo ?
+               *(int16_t *) ctf_get_pos_addr(pos) = rbo ?
                                         GUINT16_SWAP_LE_BE((int16_t) v) :
                                         (int16_t) v;
                break;
        case 32:
-               *(int32_t *) get_pos_addr(pos) = rbo ?
+               *(int32_t *) ctf_get_pos_addr(pos) = rbo ?
                                         GUINT32_SWAP_LE_BE((int32_t) v) :
                                         (int32_t) v;
                break;
        case 64:
-               *(int64_t *) get_pos_addr(pos) = rbo ?
+               *(int64_t *) ctf_get_pos_addr(pos) = rbo ?
                                         GUINT64_SWAP_LE_BE(v) : v;
                break;
        default:
                assert(0);
        }
 end:
-       move_pos(pos, integer_declaration->len);
+       ctf_move_pos(pos, integer_declaration->len);
        return;
 }
 
-uint64_t ctf_uint_read(struct stream_pos *pos,
+uint64_t ctf_uint_read(struct stream_pos *ppos,
                        const struct declaration_integer *integer_declaration)
 {
+       struct ctf_stream_pos *pos = ctf_pos(ppos);
        uint64_t v = 0;
 
-       align_pos(pos, integer_declaration->p.alignment);
+       ctf_align_pos(pos, integer_declaration->p.alignment);
        if (integer_declaration->byte_order == LITTLE_ENDIAN)
                bt_bitfield_read_le(pos->base, unsigned long, pos->offset,
                                    integer_declaration->len, &v);
        else
                bt_bitfield_read_be(pos->base, unsigned long, pos->offset,
                                    integer_declaration->len, &v);
-       move_pos(pos, integer_declaration->len);
+       ctf_move_pos(pos, integer_declaration->len);
        return v;
 }
 
-int64_t ctf_int_read(struct stream_pos *pos,
+int64_t ctf_int_read(struct stream_pos *ppos,
                        const struct declaration_integer *integer_declaration)
 {
+       struct ctf_stream_pos *pos = ctf_pos(ppos);
        int64_t v = 0;
 
-       align_pos(pos, integer_declaration->p.alignment);
+       ctf_align_pos(pos, integer_declaration->p.alignment);
        if (integer_declaration->byte_order == LITTLE_ENDIAN)
                bt_bitfield_read_le(pos->base, unsigned long, pos->offset,
                                    integer_declaration->len, &v);
        else
                bt_bitfield_read_be(pos->base, unsigned long, pos->offset,
                                    integer_declaration->len, &v);
-       move_pos(pos, integer_declaration->len);
+       ctf_move_pos(pos, integer_declaration->len);
        return v;
 }
 
-void ctf_uint_write(struct stream_pos *pos,
-                       const struct declaration_integer *integer_declaration,
-                       uint64_t v)
+void ctf_uint_write(struct stream_pos *ppos,
+                   const struct declaration_integer *integer_declaration,
+                   uint64_t v)
 {
-       align_pos(pos, integer_declaration->p.alignment);
+       struct ctf_stream_pos *pos = ctf_pos(ppos);
+
+       ctf_align_pos(pos, integer_declaration->p.alignment);
        if (pos->dummy)
                goto end;
        if (integer_declaration->byte_order == LITTLE_ENDIAN)
@@ -233,14 +241,16 @@ void ctf_uint_write(struct stream_pos *pos,
                bt_bitfield_write_be(pos->base, unsigned long, pos->offset,
                                     integer_declaration->len, v);
 end:
-       move_pos(pos, integer_declaration->len);
+       ctf_move_pos(pos, integer_declaration->len);
 }
 
-void ctf_int_write(struct stream_pos *pos,
-                       const struct declaration_integer *integer_declaration,
-                       int64_t v)
+void ctf_int_write(struct stream_pos *ppos,
+                  const struct declaration_integer *integer_declaration,
+                  int64_t v)
 {
-       align_pos(pos, integer_declaration->p.alignment);
+       struct ctf_stream_pos *pos = ctf_pos(ppos);
+
+       ctf_align_pos(pos, integer_declaration->p.alignment);
        if (pos->dummy)
                goto end;
        if (integer_declaration->byte_order == LITTLE_ENDIAN)
@@ -250,5 +260,5 @@ void ctf_int_write(struct stream_pos *pos,
                bt_bitfield_write_be(pos->base, unsigned long, pos->offset,
                                     integer_declaration->len, v);
 end:
-       move_pos(pos, integer_declaration->len);
+       ctf_move_pos(pos, integer_declaration->len);
 }