*
* 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
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
*/
#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>
{
GQuark nq;
GString *str;
+ char *quark_str;
str = g_string_new(prefix);
g_string_append(str, g_quark_to_string(quark));
- nq = g_quark_from_string(g_string_free(str, FALSE));
+ quark_str = g_string_free(str, FALSE);
+ nq = g_quark_from_string(quark_str);
+ g_free(quark_str);
return nq;
}
g_hash_table_insert(scope->typedef_declarations,
(gpointer) (unsigned long) name,
declaration);
- declaration_ref(declaration);
+ bt_declaration_ref(declaration);
return 0;
}
static int is_path_child_of(GArray *path, GArray *maybe_parent)
{
- int i, ret;
+ int ret;
if (babeltrace_debug) {
- int need_dot = 0;
+ int i, need_dot = 0;
printf_debug("Is path \"");
for (i = 0; i < path->len; need_dot = 1, i++)
}
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;
}
/*
* 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;
return 0;
}
-void declaration_ref(struct declaration *declaration)
+void bt_declaration_ref(struct declaration *declaration)
{
declaration->ref++;
}
-void declaration_unref(struct declaration *declaration)
+void bt_declaration_unref(struct declaration *declaration)
{
if (!declaration)
return;
declaration->declaration_free(declaration);
}
-void definition_ref(struct definition *definition)
+void bt_definition_ref(struct definition *definition)
{
definition->ref++;
}
-void definition_unref(struct definition *definition)
+void bt_definition_unref(struct definition *definition)
{
if (!definition)
return;
scope->typedef_declarations = g_hash_table_new_full(g_direct_hash,
g_direct_equal, NULL,
- (GDestroyNotify) definition_unref);
+ (GDestroyNotify) bt_declaration_unref);
scope->struct_declarations = g_hash_table_new_full(g_direct_hash,
g_direct_equal, NULL,
- (GDestroyNotify) declaration_unref);
+ (GDestroyNotify) bt_declaration_unref);
scope->variant_declarations = g_hash_table_new_full(g_direct_hash,
g_direct_equal, NULL,
- (GDestroyNotify) declaration_unref);
+ (GDestroyNotify) bt_declaration_unref);
scope->enum_declarations = g_hash_table_new_full(g_direct_hash,
g_direct_equal, NULL,
- (GDestroyNotify) declaration_unref);
+ (GDestroyNotify) bt_declaration_unref);
scope->parent_scope = parent_scope;
return scope;
}
g_hash_table_insert(scope->struct_declarations,
(gpointer) (unsigned long) struct_name,
struct_declaration);
- declaration_ref(&struct_declaration->p);
+ bt_declaration_ref(&struct_declaration->p);
/* Also add in typedef/typealias scopes */
prefix_name = prefix_quark("struct ", struct_name);
g_hash_table_insert(scope->variant_declarations,
(gpointer) (unsigned long) variant_name,
untagged_variant_declaration);
- declaration_ref(&untagged_variant_declaration->p);
+ bt_declaration_ref(&untagged_variant_declaration->p);
/* Also add in typedef/typealias scopes */
prefix_name = prefix_quark("variant ", variant_name);
g_hash_table_insert(scope->enum_declarations,
(gpointer) (unsigned long) enum_name,
enum_declaration);
- declaration_ref(&enum_declaration->p);
+ bt_declaration_ref(&enum_declaration->p);
/* Also add in typedef/typealias scopes */
prefix_name = prefix_quark("enum ", enum_name);
GQuark path;
GString *str;
gchar *c_str;
- int i;
int need_dot = 0;
str = g_string_new("");
g_string_append(str, root_name);
need_dot = 1;
} else if (parent_scope) {
+ int i;
+
for (i = 0; i < parent_scope->scope_path->len; i++) {
GQuark q = g_array_index(parent_scope->scope_path,
GQuark, i);
if (root_name) {
scope = _new_definition_scope(parent_scope, 0);
- append_scope_path(root_name, scope->scope_path);
+ bt_append_scope_path(root_name, scope->scope_path);
} else {
int scope_path_len = 1;
/*
* in: path (dot separated), out: q (GArray of GQuark)
*/
-void append_scope_path(const char *path, GArray *q)
+void bt_append_scope_path(const char *path, GArray *q)
{
const char *ptrbegin, *ptrend = path;
GQuark quark;
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 *bt_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;
+}