projects / babeltrace.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
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 66e2a321eaf4bf6b12cbc37f3d5a1d091b3d8f27..c024530058a1a67ab811ebbbdf24c715cfb1b01b 100644 (file)
--- a/formats/ctf/types/integer.c
+++ b/formats/ctf/types/integer.c
@@ -23,20 +23,21 @@
 #include <endian.h>
 
 static
-uint64_t _aligned_uint_read(struct stream_pos *pos,
-                      const struct type_integer *integer_type)
+uint64_t _aligned_uint_read(struct stream_pos *ppos,
+                           const struct declaration_integer *integer_declaration)
 {
-       int rbo = (integer_type->byte_order != BYTE_ORDER);     /* reverse byte order */
+       struct ctf_stream_pos *pos = ctf_pos(ppos);
+       int rbo = (integer_declaration->byte_order != BYTE_ORDER);      /* reverse byte order */
 
-       align_pos(pos, integer_type->p.alignment);
+       ctf_align_pos(pos, integer_declaration->p.alignment);
        assert(!(pos->offset % CHAR_BIT));
-       switch (integer_type->len) {
+       switch (integer_declaration->len) {
        case 8:
        {
                uint8_t v;
 
                v = *(const uint8_t *)pos->base;
-               move_pos(pos, integer_type->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_type->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_type->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_type->len);
+               ctf_move_pos(pos, integer_declaration->len);
                return rbo ? GUINT64_SWAP_LE_BE(v) : v;
        }
        default:
@@ -69,20 +70,21 @@ uint64_t _aligned_uint_read(struct stream_pos *pos,
 }
 
 static
-int64_t _aligned_int_read(struct stream_pos *pos,
-                    const struct type_integer *integer_type)
+int64_t _aligned_int_read(struct stream_pos *ppos,
+                         const struct declaration_integer *integer_declaration)
 {
-       int rbo = (integer_type->byte_order != BYTE_ORDER);     /* reverse byte order */
+       struct ctf_stream_pos *pos = ctf_pos(ppos);
+       int rbo = (integer_declaration->byte_order != BYTE_ORDER);      /* reverse byte order */
 
-       align_pos(pos, integer_type->p.alignment);
+       ctf_align_pos(pos, integer_declaration->p.alignment);
        assert(!(pos->offset % CHAR_BIT));
-       switch (integer_type->len) {
+       switch (integer_declaration->len) {
        case 8:
        {
                int8_t v;
 
                v = *(const int8_t *)pos->base;
-               move_pos(pos, integer_type->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_type->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_type->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_type->len);
+               ctf_move_pos(pos, integer_declaration->len);
                return rbo ? GUINT64_SWAP_LE_BE(v) : v;
        }
        default:
@@ -115,140 +117,148 @@ int64_t _aligned_int_read(struct stream_pos *pos,
 }
 
 static
-void _aligned_uint_write(struct stream_pos *pos,
-                   const struct type_integer *integer_type,
-                   uint64_t v)
+void _aligned_uint_write(struct stream_pos *ppos,
+                        const struct declaration_integer *integer_declaration,
+                        uint64_t v)
 {
-       int rbo = (integer_type->byte_order != BYTE_ORDER);     /* reverse byte order */
+       struct ctf_stream_pos *pos = ctf_pos(ppos);
+       int rbo = (integer_declaration->byte_order != BYTE_ORDER);      /* reverse byte order */
 
-       align_pos(pos, integer_type->p.alignment);
+       ctf_align_pos(pos, integer_declaration->p.alignment);
        assert(!(pos->offset % CHAR_BIT));
        if (pos->dummy)
                goto end;
 
-       switch (integer_type->len) {
-       case 8: *(uint8_t *) get_pos_addr(pos) = (uint8_t) v;
+       switch (integer_declaration->len) {
+       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_type->len);
+       ctf_move_pos(pos, integer_declaration->len);
 }
 
 static
-void _aligned_int_write(struct stream_pos *pos,
-                  const struct type_integer *integer_type,
-                  int64_t v)
+void _aligned_int_write(struct stream_pos *ppos,
+                       const struct declaration_integer *integer_declaration,
+                       int64_t v)
 {
-       int rbo = (integer_type->byte_order != BYTE_ORDER);     /* reverse byte order */
+       struct ctf_stream_pos *pos = ctf_pos(ppos);
+       int rbo = (integer_declaration->byte_order != BYTE_ORDER);      /* reverse byte order */
 
-       align_pos(pos, integer_type->p.alignment);
+       ctf_align_pos(pos, integer_declaration->p.alignment);
        assert(!(pos->offset % CHAR_BIT));
        if (pos->dummy)
                goto end;
 
-       switch (integer_type->len) {
-       case 8: *(int8_t *) get_pos_addr(pos) = (int8_t) v;
+       switch (integer_declaration->len) {
+       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_type->len);
+       ctf_move_pos(pos, integer_declaration->len);
        return;
 }
 
-uint64_t ctf_uint_read(struct stream_pos *pos,
-                       const struct type_integer *integer_type)
+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_type->p.alignment);
-       if (integer_type->byte_order == LITTLE_ENDIAN)
+       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_type->len, &v);
+                                   integer_declaration->len, &v);
        else
                bt_bitfield_read_be(pos->base, unsigned long, pos->offset,
-                                   integer_type->len, &v);
-       move_pos(pos, integer_type->len);
+                                   integer_declaration->len, &v);
+       ctf_move_pos(pos, integer_declaration->len);
        return v;
 }
 
-int64_t ctf_int_read(struct stream_pos *pos,
-                       const struct type_integer *integer_type)
+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_type->p.alignment);
-       if (integer_type->byte_order == LITTLE_ENDIAN)
+       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_type->len, &v);
+                                   integer_declaration->len, &v);
        else
                bt_bitfield_read_be(pos->base, unsigned long, pos->offset,
-                                   integer_type->len, &v);
-       move_pos(pos, integer_type->len);
+                                   integer_declaration->len, &v);
+       ctf_move_pos(pos, integer_declaration->len);
        return v;
 }
 
-void ctf_uint_write(struct stream_pos *pos,
-                       const struct type_integer *integer_type,
-                       uint64_t v)
+void ctf_uint_write(struct stream_pos *ppos,
+                   const struct declaration_integer *integer_declaration,
+                   uint64_t v)
 {
-       align_pos(pos, integer_type->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_type->byte_order == LITTLE_ENDIAN)
+       if (integer_declaration->byte_order == LITTLE_ENDIAN)
                bt_bitfield_write_le(pos->base, unsigned long, pos->offset,
-                                    integer_type->len, v);
+                                    integer_declaration->len, v);
        else
                bt_bitfield_write_be(pos->base, unsigned long, pos->offset,
-                                    integer_type->len, v);
+                                    integer_declaration->len, v);
 end:
-       move_pos(pos, integer_type->len);
+       ctf_move_pos(pos, integer_declaration->len);
 }
 
-void ctf_int_write(struct stream_pos *pos,
-                       const struct type_integer *integer_type,
-                       int64_t v)
+void ctf_int_write(struct stream_pos *ppos,
+                  const struct declaration_integer *integer_declaration,
+                  int64_t v)
 {
-       align_pos(pos, integer_type->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_type->byte_order == LITTLE_ENDIAN)
+       if (integer_declaration->byte_order == LITTLE_ENDIAN)
                bt_bitfield_write_le(pos->base, unsigned long, pos->offset,
-                                    integer_type->len, v);
+                                    integer_declaration->len, v);
        else
                bt_bitfield_write_be(pos->base, unsigned long, pos->offset,
-                                    integer_type->len, v);
+                                    integer_declaration->len, v);
 end:
-       move_pos(pos, integer_type->len);
+       ctf_move_pos(pos, integer_declaration->len);
 }
BabelTrace - Trace Format Babel Tower
This page took 0.030799 seconds and 4 git commands to generate.