GQuark callsite_name)
{
return g_hash_table_lookup(trace->callsites,
- (gpointer) (unsigned long) callsite_name);
+ GUINT_TO_POINTER(callsite_name));
}
void bt_ctf_text_hook(void)
if (event) {
/* find the event id */
event_id_ptr = g_hash_table_lookup(stream->event_quark_to_id,
- (gconstpointer) (unsigned long) event);
+ (gconstpointer) GUINT_TO_POINTER(event));
/* event not found in this stream class */
if (!event_id_ptr) {
fprintf(stderr, "[error] Event ID not found in stream class\n");
continue;
}
- event_id = (uint64_t)(unsigned long) *event_id_ptr;
+ event_id = GPOINTER_TO_UINT(*event_id_ptr);
/* find or create the bt_callback_chain for this event */
if (event_id >= bt_stream_cb->per_id_callbacks->len) {
goto error;
handle = g_hash_table_lookup(ctx->trace_handles,
- (gpointer) (unsigned long) handle_id);
+ GUINT_TO_POINTER(handle_id));
if (!handle)
goto error;
field->name = name_quark;
field->type = field_type;
g_hash_table_insert(field_name_to_index,
- (gpointer) (unsigned long) name_quark,
- (gpointer) (unsigned long) fields->len);
+ GUINT_TO_POINTER(name_quark),
+ GUINT_TO_POINTER(fields->len));
g_ptr_array_add(fields, field);
end:
return ret;
{
int ret;
- ret = (int) (long) g_hash_table_lookup(s->types, id);
+ ret = GPOINTER_TO_INT(g_hash_table_lookup(s->types, id));
printf_debug("lookup %p %s %d\n", s, id, ret);
return ret;
}
static
struct ctf_clock *trace_clock_lookup(struct ctf_trace *trace, GQuark clock_name)
{
- return g_hash_table_lookup(trace->parent.clocks, (gpointer) (unsigned long) clock_name);
+ return g_hash_table_lookup(trace->parent.clocks, GUINT_TO_POINTER(clock_name));
}
static
g_ptr_array_set_size(event->stream->events_by_id, event->id + 1);
g_ptr_array_index(event->stream->events_by_id, event->id) = event;
g_hash_table_insert(event->stream->event_quark_to_id,
- (gpointer) (unsigned long) event->name,
+ GUINT_TO_POINTER(event->name),
&event->id);
g_ptr_array_add(trace->event_declarations, event_decl);
return 0;
goto error;
}
trace->parent.single_clock = clock;
- g_hash_table_insert(trace->parent.clocks, (gpointer) (unsigned long) clock->name, clock);
+ g_hash_table_insert(trace->parent.clocks, GUINT_TO_POINTER(clock->name), clock);
return 0;
error:
}
trace->parent.single_clock = clock;
- g_hash_table_insert(trace->parent.clocks, (gpointer) (unsigned long) clock->name, clock);
+ g_hash_table_insert(trace->parent.clocks, GUINT_TO_POINTER(clock->name), clock);
}
static
}
cs_dups = g_hash_table_lookup(trace->callsites,
- (gpointer) (unsigned long) callsite->name);
+ GUINT_TO_POINTER(callsite->name));
if (!cs_dups) {
cs_dups = g_new0(struct ctf_callsite_dups, 1);
BT_INIT_LIST_HEAD(&cs_dups->head);
g_hash_table_insert(trace->callsites,
- (gpointer) (unsigned long) callsite->name, cs_dups);
+ GUINT_TO_POINTER(callsite->name), cs_dups);
}
bt_list_add_tail(&callsite->node, &cs_dups->head);
return 0;
/* Add new handle to container */
g_hash_table_insert(ctx->trace_handles,
- (gpointer) (unsigned long) handle->id,
+ GUINT_TO_POINTER(handle->id),
handle);
return handle->id;
* automatically.
*/
if (!g_hash_table_remove(ctx->trace_handles,
- (gpointer) (unsigned long) handle_id)) {
+ GUINT_TO_POINTER(handle_id))) {
ret = -ENOENT;
goto end;
}
return NULL;
return g_hash_table_lookup(format_registry,
- (gconstpointer) (unsigned long) name);
+ (gconstpointer) GUINT_TO_POINTER(name));
}
static void show_format(gpointer key, gpointer value, gpointer user_data)
struct walk_data *data = user_data;
fprintf(data->fp, "%s%s", data->iter ? ", " : "",
- g_quark_to_string((GQuark) (unsigned long) key));
+ g_quark_to_string((GQuark) GPOINTER_TO_UINT(key)));
data->iter++;
}
format_refcount_inc();
g_hash_table_insert(format_registry,
- (gpointer) (unsigned long) format->name,
+ GUINT_TO_POINTER(format->name),
format);
return 0;
}
{
assert(bt_lookup_format(format->name));
g_hash_table_remove(format_registry,
- (gpointer) (unsigned long) format->name);
+ GUINT_TO_POINTER(format->name));
format_refcount_dec();
}
* by clock name.
*/
clock_b = g_hash_table_lookup(match->clocks,
- (gpointer) (unsigned long) clock_a->name);
+ GUINT_TO_POINTER(clock_a->name));
if (clock_b) {
match->clock_match = clock_b;
return;
* clocks.
*/
clock_b = g_hash_table_lookup(match->clocks,
- (gpointer) (unsigned long) clock_a->uuid);
+ GUINT_TO_POINTER(clock_a->uuid));
if (clock_b) {
match->clock_match = clock_b;
return;
struct ctf_clock *tc_clock;
tc_clock = g_hash_table_lookup(tc_clocks,
- (gpointer) (unsigned long) v);
+ GUINT_TO_POINTER(v));
if (!tc_clock) {
/*
* For now we only support CTF that has one
clock_match->tc->offset_first;
}
g_hash_table_insert(tc_clocks,
- (gpointer) (unsigned long) v,
+ GUINT_TO_POINTER(v),
value);
} else if (!t_clock->absolute) {
int64_t diff_ns;
return NULL;
handle = g_hash_table_lookup(ctx->trace_handles,
- (gpointer) (unsigned long) handle_id);
+ GUINT_TO_POINTER(handle_id));
if (!handle)
return NULL;
return handle->path;
return -1;
handle = g_hash_table_lookup(ctx->trace_handles,
- (gpointer) (unsigned long) handle_id);
+ GUINT_TO_POINTER(handle_id));
if (!handle) {
ret = -1;
goto end;
return -1;
handle = g_hash_table_lookup(ctx->trace_handles,
- (gpointer) (unsigned long) handle_id);
+ GUINT_TO_POINTER(handle_id));
if (!handle) {
ret = -1;
goto end;
g_hash_table_iter_init(&iter, typed_map_obj->ght);
while (g_hash_table_iter_next(&iter, &key, &element_obj)) {
- const char *key_str = g_quark_to_string((unsigned long) key);
+ const char *key_str = g_quark_to_string(GPOINTER_TO_UINT(key));
element_obj_copy = bt_value_copy(element_obj);
while (g_hash_table_iter_next(&iter, &key, &element_obj_a)) {
struct bt_value *element_obj_b;
- const char *key_str = g_quark_to_string((unsigned long) key);
+ const char *key_str = g_quark_to_string(GPOINTER_TO_UINT(key));
element_obj_b = bt_value_map_get(object_b, key_str);
g_hash_table_iter_init(&iter, typed_map_obj->ght);
while (g_hash_table_iter_next(&iter, &key, &element_obj)) {
- const char *key_str = g_quark_to_string((unsigned long) key);
+ const char *key_str = g_quark_to_string(GPOINTER_TO_UINT(key));
if (!cb(key_str, element_obj, data)) {
ret = BT_VALUE_STATUS_CANCELLED;
GQuark q)
{
return g_hash_table_lookup(enum_declaration->table.quark_to_range_set,
- (gconstpointer) (unsigned long) q);
+ (gconstpointer) GUINT_TO_POINTER(q));
}
static
}
array = g_hash_table_lookup(enum_declaration->table.quark_to_range_set,
- (gconstpointer) (unsigned long) q);
+ (gconstpointer) GUINT_TO_POINTER(q));
if (!array) {
array = g_array_sized_new(FALSE, TRUE,
sizeof(struct enum_range), 1);
g_hash_table_insert(enum_declaration->table.quark_to_range_set,
- (gpointer) (unsigned long) q,
+ GUINT_TO_POINTER(q),
array);
}
g_array_set_size(array, array->len + 1);
}
array = g_hash_table_lookup(enum_declaration->table.quark_to_range_set,
- (gconstpointer) (unsigned long) q);
+ (gconstpointer) GUINT_TO_POINTER(q));
if (!array) {
array = g_array_sized_new(FALSE, TRUE,
sizeof(struct enum_range), 1);
g_hash_table_insert(enum_declaration->table.quark_to_range_set,
- (gpointer) (unsigned long) q,
+ GUINT_TO_POINTER(q),
array);
}
g_array_set_size(array, array->len + 1);
field->declaration = field_declaration;
/* Keep index in hash rather than pointer, because array can relocate */
g_hash_table_insert(struct_declaration->fields_by_name,
- (gpointer) (unsigned long) field->name,
- (gpointer) index);
+ GUINT_TO_POINTER(field->name),
+ GUINT_TO_POINTER(index));
/*
* Alignment of structure is the max alignment of declarations contained
* therein.
gboolean found;
found = g_hash_table_lookup_extended(struct_declaration->fields_by_name,
- (gconstpointer) (unsigned long) field_name,
+ (gconstpointer) GUINT_TO_POINTER(field_name),
NULL, &index);
if (!found)
return -1;
- return (int) (unsigned long) index;
+ return GPOINTER_TO_INT(index);
}
/*
struct declaration_scope *scope)
{
return g_hash_table_lookup(scope->typedef_declarations,
- (gconstpointer) (unsigned long) declaration_name);
+ (gconstpointer) GUINT_TO_POINTER(declaration_name));
}
struct bt_declaration *bt_lookup_declaration(GQuark declaration_name,
return -EEXIST;
g_hash_table_insert(scope->typedef_declarations,
- (gpointer) (unsigned long) name,
+ GUINT_TO_POINTER(name),
declaration);
bt_declaration_ref(declaration);
return 0;
struct definition_scope *scope)
{
return g_hash_table_lookup(scope->definitions,
- (gconstpointer) (unsigned long) field_name);
+ (gconstpointer) GUINT_TO_POINTER(field_name));
}
/*
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;
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,
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);
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 *
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);
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 *
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);
field->declaration = field_declaration;
/* Keep index in hash rather than pointer, because array can relocate */
g_hash_table_insert(untagged_variant_declaration->fields_by_tag,
- (gpointer) (unsigned long) field->name,
- (gpointer) index);
+ GUINT_TO_POINTER(field->name),
+ GUINT_TO_POINTER(index));
/*
* Alignment of variant is based on the alignment of its currently
* selected choice, so we leave variant alignment as-is (statically
found = g_hash_table_lookup_extended(
untagged_variant_declaration->fields_by_tag,
- (gconstpointer) (unsigned long) tag, NULL, &index);
+ (gconstpointer) GUINT_TO_POINTER(tag), NULL, &index);
if (!found) {
return NULL;
}
- return &g_array_index(untagged_variant_declaration->fields, struct declaration_field, (unsigned long)index);
+ return &g_array_index(untagged_variant_declaration->fields, struct declaration_field, GPOINTER_TO_UINT(index));
}
/*
assert(tag_array->len == 1);
tag = g_array_index(tag_array, GQuark, 0);
if (!g_hash_table_lookup_extended(variant_declaration->untagged_variant->fields_by_tag,
- (gconstpointer) (unsigned long) tag,
+ (gconstpointer) GUINT_TO_POINTER(tag),
&orig_key,
&value)) {
/* Cannot find matching field. */
g_quark_to_string(tag));
return NULL;
}
- index = (unsigned long) value;
+ index = GPOINTER_TO_UINT(value);
variant->current_field = g_ptr_array_index(variant->fields, index);
return variant->current_field;
}