Fix: split ctf/event.c

[babeltrace.git] / formats / ctf / events.c

diff --git a/formats/ctf/events.c b/formats/ctf/events.c
index 5ac74e6e1617cff6961713498d7cb21cff282033..0e32d21e3542b72bee804c6eba37a39527e0c9ea 100644 (file)
--- a/formats/ctf/events.c
+++ b/formats/ctf/events.c
@@ -23,8 +23,14 @@
 #include <babeltrace/format.h>
 #include <babeltrace/ctf/events.h>
 #include <babeltrace/ctf-ir/metadata.h>
 #include <babeltrace/format.h>
 #include <babeltrace/ctf/events.h>
 #include <babeltrace/ctf-ir/metadata.h>

+#include <babeltrace/prio_heap.h>
+#include <babeltrace/iterator-internal.h>
+#include <babeltrace/ctf/events-internal.h>
+#include <babeltrace/ctf/metadata.h>

 #include <glib.h>
 
 #include <glib.h>
 

+#include "events-private.h"
+

 /*
  * thread local storage to store the last error that occured
  * while reading a field, this variable must be accessed by
 /*
  * thread local storage to store the last error that occured
  * while reading a field, this variable must be accessed by


@@ -86,9 +92,21 @@ struct definition *bt_ctf_get_field(struct bt_ctf_event *event,
                const char *field)
 {
        struct definition *def;
                const char *field)
 {
        struct definition *def;

+       char *field_underscore;

 
        if (scope) {
                def = lookup_definition(scope, field);
 
        if (scope) {
                def = lookup_definition(scope, field);

+               /*
+                * optionally a field can have an underscore prefix, try
+                * to lookup the field with this prefix if it failed
+                */
+               if (!def) {
+                       field_underscore = g_new(char, strlen(field) + 2);
+                       field_underscore[0] = '_';
+                       strcpy(&field_underscore[1], field);
+                       def = lookup_definition(scope, field_underscore);
+                       g_free(field_underscore);
+               }

                if (bt_ctf_field_type(def) == CTF_TYPE_VARIANT) {
                        struct definition_variant *variant_definition;
                        variant_definition = container_of(def,
                if (bt_ctf_field_type(def) == CTF_TYPE_VARIANT) {
                        struct definition_variant *variant_definition;
                        variant_definition = container_of(def,


@@ -136,11 +154,11 @@ const char *bt_ctf_event_name(struct bt_ctf_event *event)
 const char *bt_ctf_field_name(const struct definition *def)
 {
        if (def)
 const char *bt_ctf_field_name(const struct definition *def)
 {
        if (def)

-               return g_quark_to_string(def->name);
+               return rem_(g_quark_to_string(def->name));

        return NULL;
 }
 
        return NULL;
 }
 

-enum ctf_type_id bt_ctf_field_type(struct definition *def)
+enum ctf_type_id bt_ctf_field_type(const struct definition *def)

 {
        if (def)
                return def->declaration->id;
 {
        if (def)
                return def->declaration->id;


@@ -233,12 +251,22 @@ error:
        return -1;
 }
 
        return -1;
 }
 

+uint64_t bt_ctf_get_timestamp_raw(struct bt_ctf_event *event)
+{
+       if (event && event->stream->has_timestamp)
+               return ctf_get_timestamp_raw(event->stream,
+                               event->stream->timestamp);
+       else
+               return -1ULL;
+}
+

 uint64_t bt_ctf_get_timestamp(struct bt_ctf_event *event)
 {
        if (event && event->stream->has_timestamp)
 uint64_t bt_ctf_get_timestamp(struct bt_ctf_event *event)
 {
        if (event && event->stream->has_timestamp)

-               return event->stream->timestamp;
+               return ctf_get_timestamp(event->stream,
+                               event->stream->timestamp);

        else
        else

-               return 0;
+               return -1ULL;

 }
 
 static void bt_ctf_field_set_error(int error)
 }
 
 static void bt_ctf_field_set_error(int error)


@@ -255,7 +283,85 @@ int bt_ctf_field_get_error(void)
        return ret;
 }
 
        return ret;
 }
 

-uint64_t bt_ctf_get_uint64(struct definition *field)
+int bt_ctf_get_int_signedness(const struct definition *field)
+{
+       int ret;
+
+       if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER) {
+               ret = get_int_signedness(field);
+       } else {
+               ret = -1;
+               bt_ctf_field_set_error(-EINVAL);
+       }
+
+       return ret;
+}
+
+int bt_ctf_get_int_base(const struct definition *field)
+{
+       int ret;
+
+       if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER) {
+               ret = get_int_base(field);
+       } else {
+               ret = -1;
+               bt_ctf_field_set_error(-EINVAL);
+       }
+
+       return ret;
+}
+
+int bt_ctf_get_int_byte_order(const struct definition *field)
+{
+       int ret;
+
+       if (field && bt_ctf_field_type(field) == CTF_TYPE_INTEGER) {
+               ret = get_int_byte_order(field);
+       } else {
+               ret = -1;
+               bt_ctf_field_set_error(-EINVAL);
+       }
+
+       return ret;
+}
+
+enum ctf_string_encoding bt_ctf_get_encoding(const struct definition *field)
+{
+       enum ctf_string_encoding ret = 0;
+
+       if (!field)
+               goto end;
+
+       if (bt_ctf_field_type(field) == CTF_TYPE_INTEGER)
+               ret = get_int_encoding(field);
+       else if (bt_ctf_field_type(field) == CTF_TYPE_STRING)
+               ret = get_string_encoding(field);
+       else
+               goto error;
+
+end:
+       return ret;
+
+error:
+       bt_ctf_field_set_error(-EINVAL);
+       return -1;
+}
+
+int bt_ctf_get_array_len(const struct definition *field)
+{
+       int ret;
+
+       if (field && bt_ctf_field_type(field) == CTF_TYPE_ARRAY) {
+               ret = get_array_len(field);
+       } else {
+               ret = -1;
+               bt_ctf_field_set_error(-EINVAL);
+       }
+
+       return ret;
+}
+
+uint64_t bt_ctf_get_uint64(const struct definition *field)

 {
        unsigned int ret = 0;
 
 {
        unsigned int ret = 0;
 


@@ -267,7 +373,7 @@ uint64_t bt_ctf_get_uint64(struct definition *field)
        return ret;
 }
 
        return ret;
 }
 

-int64_t bt_ctf_get_int64(struct definition *field)
+int64_t bt_ctf_get_int64(const struct definition *field)

 {
        int ret = 0;
 
 {
        int ret = 0;
 


@@ -280,7 +386,7 @@ int64_t bt_ctf_get_int64(struct definition *field)
 
 }
 
 
 }
 

-char *bt_ctf_get_char_array(struct definition *field)
+char *bt_ctf_get_char_array(const struct definition *field)

 {
        char *ret = NULL;
 
 {
        char *ret = NULL;
 


@@ -292,7 +398,7 @@ char *bt_ctf_get_char_array(struct definition *field)
        return ret;
 }
 
        return ret;
 }
 

-char *bt_ctf_get_string(struct definition *field)
+char *bt_ctf_get_string(const struct definition *field)

 {
        char *ret = NULL;
 
 {
        char *ret = NULL;