Fix: add mmap_base_offset to ctf_stream_pos

[babeltrace.git] / types / types.c

diff --git a/types/types.c b/types/types.c
index 17dcffb92576f868e3a212c05d235aed24617bc7..450c93ba6b5206c9edcdd8fb726e92c0b029d73a 100644 (file)
--- a/types/types.c
+++ b/types/types.c
@@ -5,7 +5,9 @@
  *
  * Types registry.
  *
- * Copyright 2010, 2011 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
+ * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
+ *
+ * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -19,7 +21,8 @@
  */
 
 #include <babeltrace/format.h>
-#include <babeltrace/babeltrace.h>
+#include <babeltrace/babeltrace-internal.h>
+#include <babeltrace/types.h>
 #include <limits.h>
 #include <glib.h>
 #include <errno.h>
@@ -144,42 +147,9 @@ end:
 }
 
 static struct definition_scope *
-       get_definition_scope(struct definition *definition)
-{
-       switch (definition->declaration->id) {
-       case CTF_TYPE_STRUCT:
-       {
-               struct definition_struct *def =
-                       container_of(definition, struct definition_struct, p);
-               return def->scope;
-       }
-       case CTF_TYPE_VARIANT:
-       {
-               struct definition_variant *def =
-                       container_of(definition, struct definition_variant, p);
-               return def->scope;
-       }
-       case CTF_TYPE_ARRAY:
-       {
-               struct definition_array *def =
-                       container_of(definition, struct definition_array, p);
-               return def->scope;
-       }
-       case CTF_TYPE_SEQUENCE:
-       {
-               struct definition_sequence *def =
-                       container_of(definition, struct definition_sequence, p);
-               return def->scope;
-       }
-
-       case CTF_TYPE_INTEGER:
-       case CTF_TYPE_FLOAT:
-       case CTF_TYPE_ENUM:
-       case CTF_TYPE_STRING:
-       case CTF_TYPE_UNKNOWN:
-       default:
-               return NULL;
-       }
+       get_definition_scope(const struct definition *definition)
+{
+       return definition->scope;
 }
 
 /*
@@ -203,9 +173,9 @@ static struct definition_scope *
  * scope: the definition scope containing the variant definition.
  */
 struct definition *
-       lookup_definition(GArray *cur_path,
-                         GArray *lookup_path,
-                         struct definition_scope *scope)
+       lookup_path_definition(GArray *cur_path,
+                              GArray *lookup_path,
+                              struct definition_scope *scope)
 {
        struct definition *definition, *lookup_definition;
        GQuark last;
@@ -331,7 +301,7 @@ struct declaration_scope *
 
        scope->typedef_declarations = g_hash_table_new_full(g_direct_hash,
                                        g_direct_equal, NULL,
-                                       (GDestroyNotify) definition_unref);
+                                       (GDestroyNotify) declaration_unref);
        scope->struct_declarations = g_hash_table_new_full(g_direct_hash,
                                        g_direct_equal, NULL,
                                        (GDestroyNotify) declaration_unref);
@@ -629,3 +599,68 @@ void free_definition_scope(struct definition_scope *scope)
        g_hash_table_destroy(scope->definitions);
        g_free(scope);
 }
+
+struct definition *lookup_definition(const struct definition *definition,
+                                    const char *field_name)
+{
+       struct definition_scope *scope = get_definition_scope(definition);
+
+       if (!scope)
+               return NULL;
+
+       return lookup_field_definition_scope(g_quark_from_string(field_name),
+                                            scope);
+}
+
+struct definition_integer *lookup_integer(const struct definition *definition,
+                                         const char *field_name,
+                                         int signedness)
+{
+       struct definition *lookup;
+       struct definition_integer *lookup_integer;
+
+       lookup = lookup_definition(definition, field_name);
+       if (!lookup)
+               return NULL;
+       if (lookup->declaration->id != CTF_TYPE_INTEGER)
+               return NULL;
+       lookup_integer = container_of(lookup, struct definition_integer, p);
+       if (lookup_integer->declaration->signedness != signedness)
+               return NULL;
+       return lookup_integer;
+}
+
+struct definition_enum *lookup_enum(const struct definition *definition,
+                                   const char *field_name,
+                                   int signedness)
+{
+       struct definition *lookup;
+       struct definition_enum *lookup_enum;
+
+       lookup = lookup_definition(definition, field_name);
+       if (!lookup)
+               return NULL;
+       if (lookup->declaration->id != CTF_TYPE_ENUM)
+               return NULL;
+       lookup_enum = container_of(lookup, struct definition_enum, p);
+       if (lookup_enum->integer->declaration->signedness != signedness)
+               return NULL;
+       return lookup_enum;
+}
+
+struct definition *lookup_variant(const struct definition *definition,
+                                 const char *field_name)
+{
+       struct definition *lookup;
+       struct definition_variant *lookup_variant;
+
+       lookup = lookup_definition(definition, field_name);
+       if (!lookup)
+               return NULL;
+       if (lookup->declaration->id != CTF_TYPE_VARIANT)
+               return NULL;
+       lookup_variant = container_of(lookup, struct definition_variant, p);
+       lookup = variant_get_current_field(lookup_variant);
+       assert(lookup);
+       return lookup;
+}