metababel 0.0.5 → 1.0.1

data/template/upstream.c.erb

@@ -7,151 +7,102 @@
 #include <stdbool.h>
 #include <stdlib.h>
 
-<% event_class_dispatchers.each do |e| %>
-static void btx_dispatch_<%= e.name_sanitized %>(
-    UT_array *callbacks, common_data_t *common_data,
-    const bt_message *upstream_message, bool *is_callback_called) {
+<% dispatchers.each do |dispatcher| %>
+static void btx_dispatch_<%= dispatcher.name_sanitized %>(
+    callbacks_t *callbacks, common_data_t *common_data,
+    const bt_message *upstream_message) {
 
-  <% e.args.each do |s| %>
+  <% dispatcher.args.each do |s| %>
   <%= s.type %> <%= s.name %>;
   <% end %>
 
   <%# Since now event is a variable, we need to check if the body will render variables that accesses it.  %>
-  <% if not e.body.empty? %>
-  const bt_event *<%= event_name %> = bt_message_event_borrow_event_const(upstream_message);
-  <%= "\n" + e.body %>
+  <% if not dispatcher.body.strip.empty? %>
+  const bt_event *<%= event_name %> =
+      bt_message_event_borrow_event_const(upstream_message);
+  <%= dispatcher.body %>
   <% end %>
-
-  <% if e.default_clock_class %>
-  int64_t _timestamp;
-  const bt_clock_snapshot *clock_snapshot = bt_message_event_borrow_default_clock_snapshot_const(upstream_message);
+  <% if dispatcher.default_clock_class %>
+  const bt_clock_snapshot *clock_snapshot =
+      bt_message_event_borrow_default_clock_snapshot_const(upstream_message);
   bt_clock_snapshot_get_ns_from_origin(clock_snapshot, &_timestamp);
   <% end %>
-  // Call all the callbacks who where registered
-  // Their type are declared in 'upstream.h'
-  <%= e.name_sanitized %>_callback_f **p = NULL;
-  while ((p = utarray_next(callbacks, p))) {
-    (*p)((void *)common_data,
-         common_data
-             ->usr_data<%= ', _timestamp' if e.default_clock_class %><%= e.args.map{ |s| s.name }.join_with_prefix(", ") %>);
+  <%# event_class_name, only required when there is at least one matching callback for this event.  %>
+  <% if dispatcher.dispatch_types.map(&:args).flatten.any? { |arg| arg.name == '_event_class_name' } %>
+  const char *_event_class_name = "<%= dispatcher.name %>";
+  <% end %>
+
+  // Call registered matching callbacks
+  <% dispatcher.dispatch_types.each do |dispatch_type| %>
+  {
+    if (callbacks-><%= dispatch_type.id %>) {
+      void **_p = NULL;
+      while ((_p = utarray_next(callbacks-><%= dispatch_type.id %>, _p))) {
+        (*((<%= dispatch_type.name_sanitized %>_callback_f **)(_p)))(
+            (void *)common_data,
+            common_data
+                ->usr_data<%= dispatch_type.args.map{ |a| a.name }.join_with_prefix(", ") %>);
+      }
+    }
   }
 
-  <% e.args_to_free.each do |s| %>
+  <% end %>
+  <% dispatcher.args_to_free.each do |s| %>
   <%= "free(#{s.name});" %>
   <% end %>
-
-  if (callbacks)
-    *is_callback_called = true;
 }
 
-void btx_register_callbacks_<%= e.name_sanitized %>(
-    void *btx_handle, <%= e.name_sanitized %>_callback_f *callback) {
+<% end %>
+<% dispatchers.each do |dispatcher| %>
+void btx_generic_register_callback_<%= dispatcher.name_sanitized %>(
+    void *btx_handle, const char *id, void *callback) {
   // Look-up our dispatcher
   name_to_dispatcher_t *s = NULL;
   name_to_dispatcher_t **name_to_dispatcher =
       &((common_data_t *)btx_handle)->name_to_dispatcher;
-  HASH_FIND_STR(*name_to_dispatcher, "<%= e.name %>", s);
+  HASH_FIND_STR(*name_to_dispatcher, "<%= dispatcher.name %>", s);
   if (!s) {
-    // We didn't find the dispatcher, so we need to:
-    // 1. Create it
+    // We didn't find the dispatcher, so we need to create it.
     s = (name_to_dispatcher_t *)malloc(sizeof(name_to_dispatcher_t));
-    s->name = "<%= e.name %>";
-    s->dispatcher = (void *)&btx_dispatch_<%= e.name_sanitized %>;
-    utarray_new(s->callbacks, &ut_ptr_icd);
+    s->name = "<%= dispatcher.name %>";
+    s->dispatcher = (void *)&btx_dispatch_<%= dispatcher.name_sanitized %>;
+    s->callbacks = calloc(1, sizeof(callbacks_t));
     // 2. Register it
     HASH_ADD_KEYPTR(hh, *name_to_dispatcher, s->name, strlen(s->name), s);
   }
-  // Add the callbacks to the array
-  utarray_push_back(s->callbacks, &callback);
-}
-<% end %>
 
-<% stream_classes_matching_dispatchers.each do |s| %>
-void btx_matching_dispatch_<%= s.name_sanitized %>(UT_array *callbacks,
-                                                   common_data_t *common_data,
-                                                   const bt_message *upstream_message,
-                                                   bool *is_callback_called) {
+  <% dispatcher.dispatch_types.each do |dispatch_type| %>
+  if (strcmp("<%= dispatch_type.id %>", id) == 0) {
+    // Add the callbacks to the array
+    if (!s->callbacks-><%= dispatch_type.id %>)
+      utarray_new(s->callbacks-><%= dispatch_type.id %>, &ut_ptr_icd);
+    utarray_push_back(s->callbacks-><%= dispatch_type.id %>, &callback);
+  }
 
-  <% s.args.each do |a| %>
-  <%= a.type %> <%= a.name %>;
   <% end %>
-  const bt_event *<%= event_name %> = bt_message_event_borrow_event_const(upstream_message);
-  <%= s.body %>
-  const bt_event_class *event_class = bt_event_borrow_class_const(<%= event_name %>);
-  const char *event_class_name = bt_event_class_get_name(event_class);
-
-  condition_to_callback_t **p = NULL;
-  while ((p = utarray_next(callbacks, p))) {
-    <%= s.name_sanitized %>_callback_condition_f *condition =
-        (<%= s.name_sanitized %>_callback_condition_f *)((*p)->condition);
-    <%= s.name_sanitized %>_conditioned_callback_f *callback =
-        (<%= s.name_sanitized %>_conditioned_callback_f *)((*p)->callback);
-    <% if s.default_clock_class %>
-    int64_t _timestamp;
-    const bt_clock_snapshot *clock_snapshot = bt_message_event_borrow_default_clock_snapshot_const(upstream_message);
-    bt_clock_snapshot_get_ns_from_origin(clock_snapshot, &_timestamp);
-    <% end %>
-    bool is_condition_met = false;
-    condition(
-        (void *)common_data, common_data->usr_data, event_class_name,
-        &is_condition_met<%= ', _timestamp' if s.default_clock_class %><%= s.args.map{ |a| a.name }.join_with_prefix(", ") %>);
-    if (is_condition_met) {
-      callback(
-          (void *)common_data, common_data->usr_data,
-          event_class_name<%= ', _timestamp' if s.default_clock_class %><%= s.args.map{ |a| a.name }.join_with_prefix(", ") %>);
-      *is_callback_called = true;
-    }
-  }
 }
 
-void btx_register_matching_callback_<%= s.name_sanitized %>(
-    void *btx_handle, <%= s.name_sanitized %>_callback_condition_f *condition,
-    <%= s.name_sanitized %>_conditioned_callback_f *callback) {
-  // Look-up our dispatcher
-  name_to_dispatcher_t *s = NULL;
-  name_to_dispatcher_t **name_to_matching_dispatcher =
-      &((common_data_t *)btx_handle)->name_to_matching_dispatcher;
-  HASH_FIND_STR(*name_to_matching_dispatcher, "<%= s.name_sanitized %>", s);
-  if (!s) {
-    // We didn't find the dispatcher, so we need to:
-    // 1. Create it
-    s = (name_to_dispatcher_t *)malloc(sizeof(name_to_dispatcher_t));
-    s->name = "<%= s.name_sanitized %>";
-    s->dispatcher = (void *)&btx_matching_dispatch_<%= s.name_sanitized %>;
-    utarray_new(s->callbacks, &ut_ptr_icd);
-    // 2. Register it
-    HASH_ADD_KEYPTR(hh, *name_to_matching_dispatcher, s->name, strlen(s->name),
-                    s);
-  }
-  // Add the callbacks to the array
-  condition_to_callback_t *m =
-      (condition_to_callback_t *)malloc(sizeof(condition_to_callback_t));
-  m->condition = (void *)condition;
-  m->callback = (void *)callback;
-  utarray_push_back(s->callbacks, &m);
-}
 <% end %>
+<% dispatch_types.each do |dispatch_type| %>
+void btx_register_callbacks_<%= dispatch_type.name_sanitized %>(
+    void *btx_handle,
+    <%= dispatch_type.name_sanitized %>_callback_f *callback) {
+  <% dispatch_type.matched_dispatchers.each do |dispatcher| %>
+  btx_generic_register_callback_<%= dispatcher.name_sanitized %>(
+      btx_handle, "<%= dispatch_type.id %>", (void *)callback);
+  <% end %>
+}
 
+<% end %>
 void btx_delete_dispatchers(common_data_t *common_data) {
   name_to_dispatcher_t *current, *tmp;
   HASH_ITER(hh, common_data->name_to_dispatcher, current, tmp) {
     HASH_DEL(common_data->name_to_dispatcher, current);
-    utarray_free(current->callbacks);
-    free(current);
-  }
-}
-
-void btx_delete_matching_dispatchers(common_data_t *common_data) {
-  name_to_dispatcher_t *current, *tmp;
-  HASH_ITER(hh, common_data->name_to_matching_dispatcher, current, tmp) {
-    // Removes the item from the hash table.
-    HASH_DEL(common_data->name_to_matching_dispatcher, current);
-    // Deletes every condition, callback pair.
-    condition_to_callback_t **p = NULL;
-    while ((p = utarray_next(current->callbacks, p))) {
-      free(*p);
-    }
-    utarray_free(current->callbacks);
+    <% dispatch_types.map(&:id).uniq.each do |name| %>
+    if (current->callbacks-><%= name %>)
+      utarray_free(current->callbacks-><%= name %>);
+    <% end %>
+    free(current->callbacks);
     free(current);
   }
 }

data/template/upstream.h.erb

@@ -5,47 +5,21 @@ extern "C" {
 #endif
 
 // Dispatcher
-typedef void(dispatcher_t)(UT_array *callbacks, common_data_t *common_data,
-                           const bt_message *upstream_message, bool *is_callback_called);
+typedef void(dispatcher_t)(callbacks_t *callbacks, common_data_t *common_data,
+                           const bt_message *upstream_message);
 
-<% event_class_dispatchers.each do |e| %>
-<%# The signature type of callbacks %>
-typedef void <%= e.name_sanitized %>_callback_f(
-    void *btx_handle,
-    void *usr_data<%= ', int64_t _timestamp' if e.default_clock_class %><%= e.args.map{ |s| s.type }.join_with_prefix(", ") %>);
 <%# The Function who register the callbacks to the dispatcher %>
-void btx_register_callbacks_<%= e.name_sanitized %>(
-    void *btx_handle, <%= e.name_sanitized %>_callback_f *callback);
-<% end %>
-
-void btx_delete_dispatchers(common_data_t *common_data);
-
-// Matching dispatcher
-
-struct condition_to_callback_s {
-  void *condition;
-  void *callback;
-};
-typedef struct condition_to_callback_s condition_to_callback_t;
-
-<% stream_classes_matching_dispatchers.each do |s| %>
-<%# The signature type of condition callbacks %>
-typedef void <%= s.name_sanitized %>_callback_condition_f(
-    void *btx_handle, void *usr_data, const char *event_class_name,
-    bool *matched<%= ', int64_t _timestamp' if s.default_clock_class %><%= s.args.map{ |a| a.type }.join_with_prefix(", ") %>);
+<% dispatch_types.each do |dispatch_type| %>
+typedef void <%= dispatch_type.name_sanitized %>_callback_f(
+    void *btx_handle,
+    void *
+        usr_data<%= dispatch_type.args.map{ |s| s.type }.join_with_prefix(', ') %>);
 
-<%# The signature type of callbacks to be called if the condition is met %>
-typedef void <%= s.name_sanitized %>_conditioned_callback_f(
-    void *btx_handle, void *usr_data,
-    const char *
-        event_class_name<%= ', int64_t _timestamp' if s.default_clock_class %><%= s.args.map{ |a| a.type }.join_with_prefix(", ") %>);
+void btx_register_callbacks_<%= dispatch_type.name_sanitized %>(
+    void *btx_handle, <%= dispatch_type.name_sanitized %>_callback_f *callback);
 
-void btx_register_matching_callback_<%= s.name_sanitized %>(
-    void *btx_handle, <%= s.name_sanitized %>_callback_condition_f *condition,
-    <%= s.name_sanitized %>_conditioned_callback_f *callback);
 <% end %>
-
-void btx_delete_matching_dispatchers(common_data_t *common_data);
+void btx_delete_dispatchers(common_data_t *common_data);
 
 #ifdef __cplusplus
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: metababel
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 1.0.1
 platform: ruby
 authors:
 - Thomas Applencourt
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-05 00:00:00.000000000 Z
+date: 2023-10-31 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: 
@@ -23,7 +23,8 @@ files:
 - bin/metababel
 - lib/metababel.rb
 - lib/metababel/bt2_generator_utils.rb
-- lib/metababel/bt2_stream_classes_generator.rb
+- lib/metababel/bt2_matching_utils.rb
+- lib/metababel/bt2_trace_class_generator.rb
 - lib/metababel/bt2_values_generator.rb
 - lib/metababel/version.rb
 - template/component.c.erb
@@ -39,7 +40,8 @@ files:
 homepage: 
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -55,7 +57,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubyforge_project: 
+rubygems_version: 2.7.6.3
 signing_key: 
 specification_version: 4
 summary: Helper for creation Babeltrace plugins