ctf.fs: bt_ctf_notif_iter_create(): assert() that all medops exist

[babeltrace.git] / types / types.c

diff --git a/types/types.c b/types/types.c
index d60e5772a4d8556107a5392f2e96158e7b13e903..f58d2e4ad22e2421dafecedf7f5fea7ee35ba8a4 100644 (file)
--- a/types/types.c
+++ b/types/types.c
@@ -31,7 +31,7 @@
 #include <babeltrace/format.h>
 #include <babeltrace/babeltrace-internal.h>
 #include <babeltrace/types.h>
-#include <limits.h>
+#include <babeltrace/compat/limits.h>
 #include <glib.h>
 #include <errno.h>
 
@@ -51,18 +51,18 @@ GQuark prefix_quark(const char *prefix, GQuark quark)
 }
 
 static
-struct declaration *
+struct bt_declaration *
        bt_lookup_declaration_scope(GQuark declaration_name,
                struct declaration_scope *scope)
 {
        return g_hash_table_lookup(scope->typedef_declarations,
-                                  (gconstpointer) (unsigned long) declaration_name);
+                                  (gconstpointer) GUINT_TO_POINTER(declaration_name));
 }
 
-struct declaration *bt_lookup_declaration(GQuark declaration_name,
+struct bt_declaration *bt_lookup_declaration(GQuark declaration_name,
                struct declaration_scope *scope)
 {
-       struct declaration *declaration;
+       struct bt_declaration *declaration;
 
        while (scope) {
                declaration = bt_lookup_declaration_scope(declaration_name,
@@ -74,7 +74,7 @@ struct declaration *bt_lookup_declaration(GQuark declaration_name,
        return NULL;
 }
 
-int bt_register_declaration(GQuark name, struct declaration *declaration,
+int bt_register_declaration(GQuark name, struct bt_declaration *declaration,
                struct declaration_scope *scope)
 {
        if (!name)
@@ -85,19 +85,19 @@ int bt_register_declaration(GQuark name, struct declaration *declaration,
                return -EEXIST;
 
        g_hash_table_insert(scope->typedef_declarations,
-                           (gpointer) (unsigned long) name,
+                           GUINT_TO_POINTER(name),
                            declaration);
        bt_declaration_ref(declaration);
        return 0;
 }
 
 static
-struct definition *
+struct bt_definition *
        lookup_field_definition_scope(GQuark field_name,
                struct definition_scope *scope)
 {
        return g_hash_table_lookup(scope->definitions,
-                                  (gconstpointer) (unsigned long) field_name);
+                                  (gconstpointer) GUINT_TO_POINTER(field_name));
 }
 
 /*
@@ -158,7 +158,7 @@ end:
 }
 
 static struct definition_scope *
-       get_definition_scope(const struct definition *definition)
+       get_definition_scope(const struct bt_definition *definition)
 {
        return definition->scope;
 }
@@ -183,12 +183,12 @@ static struct definition_scope *
  * lookup_path: the path leading to the enum we want to look for.
  * scope: the definition scope containing the variant definition.
  */
-struct definition *
-       lookup_path_definition(GArray *cur_path,
+struct bt_definition *
+       bt_lookup_path_definition(GArray *cur_path,
                               GArray *lookup_path,
                               struct definition_scope *scope)
 {
-       struct definition *definition, *lookup_definition;
+       struct bt_definition *definition, *lookup_definition;
        GQuark last;
        int index;
 
@@ -262,7 +262,7 @@ lookup:
        return NULL;
 }
 
-int register_field_definition(GQuark field_name, struct definition *definition,
+int bt_register_field_definition(GQuark field_name, struct bt_definition *definition,
                struct definition_scope *scope)
 {
        if (!scope || !field_name)
@@ -273,18 +273,18 @@ int register_field_definition(GQuark field_name, struct definition *definition,
                return -EEXIST;
 
        g_hash_table_insert(scope->definitions,
-                           (gpointer) (unsigned long) field_name,
+                           GUINT_TO_POINTER(field_name),
                            definition);
        /* Don't keep reference on definition */
        return 0;
 }
 
-void bt_declaration_ref(struct declaration *declaration)
+void bt_declaration_ref(struct bt_declaration *declaration)
 {
        declaration->ref++;
 }
 
-void bt_declaration_unref(struct declaration *declaration)
+void bt_declaration_unref(struct bt_declaration *declaration)
 {
        if (!declaration)
                return;
@@ -292,12 +292,12 @@ void bt_declaration_unref(struct declaration *declaration)
                declaration->declaration_free(declaration);
 }
 
-void bt_definition_ref(struct definition *definition)
+void bt_definition_ref(struct bt_definition *definition)
 {
        definition->ref++;
 }
 
-void bt_definition_unref(struct definition *definition)
+void bt_definition_unref(struct bt_definition *definition)
 {
        if (!definition)
                return;
@@ -340,7 +340,7 @@ struct declaration_struct *bt_lookup_struct_declaration_scope(GQuark struct_name
                                             struct declaration_scope *scope)
 {
        return g_hash_table_lookup(scope->struct_declarations,
-                                  (gconstpointer) (unsigned long) struct_name);
+                                  (gconstpointer) GUINT_TO_POINTER(struct_name));
 }
 
 struct declaration_struct *bt_lookup_struct_declaration(GQuark struct_name,
@@ -372,7 +372,7 @@ int bt_register_struct_declaration(GQuark struct_name,
                return -EEXIST;
 
        g_hash_table_insert(scope->struct_declarations,
-                           (gpointer) (unsigned long) struct_name,
+                           GUINT_TO_POINTER(struct_name),
                            struct_declaration);
        bt_declaration_ref(&struct_declaration->p);
 
@@ -389,7 +389,7 @@ struct declaration_untagged_variant *
                struct declaration_scope *scope)
 {
        return g_hash_table_lookup(scope->variant_declarations,
-                                  (gconstpointer) (unsigned long) variant_name);
+                                  (gconstpointer) GUINT_TO_POINTER(variant_name));
 }
 
 struct declaration_untagged_variant *
@@ -422,7 +422,7 @@ int bt_register_variant_declaration(GQuark variant_name,
                return -EEXIST;
 
        g_hash_table_insert(scope->variant_declarations,
-                           (gpointer) (unsigned long) variant_name,
+                           GUINT_TO_POINTER(variant_name),
                            untagged_variant_declaration);
        bt_declaration_ref(&untagged_variant_declaration->p);
 
@@ -440,7 +440,7 @@ struct declaration_enum *
                struct declaration_scope *scope)
 {
        return g_hash_table_lookup(scope->enum_declarations,
-                                  (gconstpointer) (unsigned long) enum_name);
+                                  (gconstpointer) GUINT_TO_POINTER(enum_name));
 }
 
 struct declaration_enum *
@@ -473,7 +473,7 @@ int bt_register_enum_declaration(GQuark enum_name,
                return -EEXIST;
 
        g_hash_table_insert(scope->enum_declarations,
-                           (gpointer) (unsigned long) enum_name,
+                           GUINT_TO_POINTER(enum_name),
                            enum_declaration);
        bt_declaration_ref(&enum_declaration->p);
 
@@ -485,7 +485,7 @@ int bt_register_enum_declaration(GQuark enum_name,
 }
 
 static struct definition_scope *
-       _new_definition_scope(struct definition_scope *parent_scope,
+       _bt_new_definition_scope(struct definition_scope *parent_scope,
                              int scope_path_len)
 {
        struct definition_scope *scope = g_new(struct definition_scope, 1);
@@ -499,7 +499,7 @@ static struct definition_scope *
        return scope;
 }
 
-GQuark new_definition_path(struct definition_scope *parent_scope,
+GQuark bt_new_definition_path(struct definition_scope *parent_scope,
                           GQuark field_name, const char *root_name)
 {
        GQuark path;
@@ -540,20 +540,20 @@ GQuark new_definition_path(struct definition_scope *parent_scope,
 }
 
 struct definition_scope *
-       new_definition_scope(struct definition_scope *parent_scope,
+       bt_new_definition_scope(struct definition_scope *parent_scope,
                             GQuark field_name, const char *root_name)
 {
        struct definition_scope *scope;
 
        if (root_name) {
-               scope = _new_definition_scope(parent_scope, 0);
+               scope = _bt_new_definition_scope(parent_scope, 0);
                bt_append_scope_path(root_name, scope->scope_path);
        } else {
                int scope_path_len = 1;
 
                assert(parent_scope);
                scope_path_len += parent_scope->scope_path->len;
-               scope = _new_definition_scope(parent_scope, scope_path_len);
+               scope = _bt_new_definition_scope(parent_scope, scope_path_len);
                memcpy(scope->scope_path->data, parent_scope->scope_path->data,
                       sizeof(GQuark) * (scope_path_len - 1));
                g_array_index(scope->scope_path, GQuark, scope_path_len - 1) =
@@ -605,14 +605,14 @@ void bt_append_scope_path(const char *path, GArray *q)
        }
 }
 
-void free_definition_scope(struct definition_scope *scope)
+void bt_free_definition_scope(struct definition_scope *scope)
 {
        g_array_free(scope->scope_path, TRUE);
        g_hash_table_destroy(scope->definitions);
        g_free(scope);
 }
 
-struct definition *lookup_definition(const struct definition *definition,
+struct bt_definition *bt_lookup_definition(const struct bt_definition *definition,
                                     const char *field_name)
 {
        struct definition_scope *scope = get_definition_scope(definition);
@@ -624,17 +624,17 @@ struct definition *lookup_definition(const struct definition *definition,
                                             scope);
 }
 
-struct definition_integer *lookup_integer(const struct definition *definition,
+struct definition_integer *bt_lookup_integer(const struct bt_definition *definition,
                                          const char *field_name,
                                          int signedness)
 {
-       struct definition *lookup;
+       struct bt_definition *lookup;
        struct definition_integer *lookup_integer;
 
-       lookup = lookup_definition(definition, field_name);
+       lookup = bt_lookup_definition(definition, field_name);
        if (!lookup)
                return NULL;
-       if (lookup->declaration->id != CTF_TYPE_INTEGER)
+       if (lookup->declaration->id != BT_CTF_TYPE_ID_INTEGER)
                return NULL;
        lookup_integer = container_of(lookup, struct definition_integer, p);
        if (lookup_integer->declaration->signedness != signedness)
@@ -642,17 +642,17 @@ struct definition_integer *lookup_integer(const struct definition *definition,
        return lookup_integer;
 }
 
-struct definition_enum *bt_lookup_enum(const struct definition *definition,
+struct definition_enum *bt_lookup_enum(const struct bt_definition *definition,
                                    const char *field_name,
                                    int signedness)
 {
-       struct definition *lookup;
+       struct bt_definition *lookup;
        struct definition_enum *lookup_enum;
 
-       lookup = lookup_definition(definition, field_name);
+       lookup = bt_lookup_definition(definition, field_name);
        if (!lookup)
                return NULL;
-       if (lookup->declaration->id != CTF_TYPE_ENUM)
+       if (lookup->declaration->id != BT_CTF_TYPE_ID_ENUM)
                return NULL;
        lookup_enum = container_of(lookup, struct definition_enum, p);
        if (lookup_enum->integer->declaration->signedness != signedness)
@@ -660,16 +660,16 @@ struct definition_enum *bt_lookup_enum(const struct definition *definition,
        return lookup_enum;
 }
 
-struct definition *bt_lookup_variant(const struct definition *definition,
+struct bt_definition *bt_lookup_variant(const struct bt_definition *definition,
                                  const char *field_name)
 {
-       struct definition *lookup;
+       struct bt_definition *lookup;
        struct definition_variant *bt_lookup_variant;
 
-       lookup = lookup_definition(definition, field_name);
+       lookup = bt_lookup_definition(definition, field_name);
        if (!lookup)
                return NULL;
-       if (lookup->declaration->id != CTF_TYPE_VARIANT)
+       if (lookup->declaration->id != BT_CTF_TYPE_ID_VARIANT)
                return NULL;
        bt_lookup_variant = container_of(lookup, struct definition_variant, p);
        lookup = bt_variant_get_current_field(bt_lookup_variant);