metababel 1.0.4 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94a55badce2025551858542b3ad05ec6f2fadfa18ea7a3d32e43dfc8fa588505
-  data.tar.gz: 861f4853f64c5de23d47f6678e8a369b49b1e5f84cd4ad1944b077a32e5a8a87
+  metadata.gz: fcf5e88ccc5e61854e63063f8bca911bf5ab66b4a73ebc2d19f62d3458e9126b
+  data.tar.gz: 773927d69d8240bdc04611eef6131d6c6e0a0e583ff67bc8982fc0ade6d13e1d
 SHA512:
-  metadata.gz: 10357d19a20bb264699f6f586f49fd2d5229a7da0ea7dd51234d5b5733bee78340c83f564a2084a26a99db9d13073332ad211c67def4b469c6251e2f219b4efa
-  data.tar.gz: 92a55fb2d187388088d13d30a827548b1543bec100f81ff4fa58a7dae41d77ad52f53268b33abd93a1149ea9479c838354b3d1b1773e6dbdf8f2b54a0ae1351b
+  metadata.gz: 7bfccb7ef5b523fee9b91cd078ae3a070506bca1758bf22c10b3304a407513d9f1167718c6aea7b822a7235b13b8773c294e956d04c0cc4af8701d9224320de2
+  data.tar.gz: 2481d7b5db7fc44247c72f6aaeb9dddc5176af852da2fa6706facd0af89b840b2095b5ff96fd86a6b25859325458e5686b2a185a3013e8a69a926e4e2dcd9b1b

data/bin/metababel

@@ -8,6 +8,7 @@ require 'fileutils'
 require 'set'
 require 'ostruct'
 require 'abbrev'
+require 'pathname'
 
 class Array
   def join_with_prefix(sep)
@@ -92,7 +93,7 @@ class DispatchType < BaseDispatch
 end
 
 class Dispatcher < BaseDispatch
-  attr_reader :event_nane, :event, :name,
+  attr_reader :event_name, :event, :name,
               :index_stream_class, :index_event_class,
               :default_clock_class,
               :dispatch_types
@@ -160,75 +161,51 @@ def parse_argv
   # Display help if no arguments.
   ARGV << '-h' if ARGV.empty?
 
-  options = {}
-
-  options[:disable_callbaks] = ['on_downstream'].to_set
-
-  OptionParser.new do |opts|
-    opts.banner = 'Usage: example.rb [options]'
-
-    opts.on('-h', '--help', 'Prints this help') do
-      puts opts
-      exit
-    end
+  parser  = OptionParser.new
+  parser.on('-h', '--help', 'Prints this help') do
+    puts parser.help
+    exit
+  end
 
-    opts.on('-v', '--version', 'Prints this help') do
-      puts "Ruby: #{RUBY_VERSION}"
-      puts "Metababel: #{Metababel::VERSION}"
-      exit
-    end
+  parser.on('-v', '--version', 'Prints this help') do
+    puts "Ruby: #{RUBY_VERSION}"
+    puts "Metababel: #{Metababel::VERSION}"
+    exit
+  end
 
-    opts.on('-t', '--component TYPE',
+  parser.on('-t', '--component-type TYPE',
             '[Mandatory] Node within a trace processing graph [one of: SINK, SOURCE, FILTER].') do |p|
-      l = %w[SOURCE FILTER SINK]
-      h = Abbrev.abbrev(l)
-      raise "Invalid component type, should be #{l} (case insentitive)" unless h.include?(p.upcase)
-
-      options[:component_type] = h[p.upcase]
-    end
-
-    opts.on('-u', '--upstreams PATH', Array, '[Mandatory] Path to the bt2 YAML files for the upstream model.') do |p|
-      options[:upstreams] = p
-    end
-
-    opts.on('-d', '--downstream PATH', '[Optional] Path to the bt2 YAML file for the downstream model.') do |p|
-      options[:downstream] = p
-    end
-
-    opts.on('-p', '--plugin-name PATH', '[Optional] Name of the bt2 plugin created.') do |p|
-      options[:plugin_name] = p
-    end
-
-    opts.on('-c', '--component-name PATH', '[Optional] Name of the bt2 componant created.') do |p|
-      options[:component_name] = p
-    end
+    l = %w[SOURCE FILTER SINK]
+    h = Abbrev.abbrev(l)
+    raise "Invalid component type, should be #{l} (case insensitive)" unless h.include?(p.upcase)
 
-    opts.on('--params PATH', '[Optional] Paht to the bt2 YAML params definition.') do |p|
-      options[:params] = p
-    end
-
-    opts.on('-m', '--matching PATH', '[Optional] Path to bt2 YAML matching-callbacks definitions.') do |p|
-      options[:matching] = p
-    end
-
-    opts.on('-o', '--output FOLDER', '[Optional] Output folder path.') do |p|
-      options[:folder] = p
-    end
-
-    opts.on('-i', '--usr-data-header NAME', '[Optional] User datatypes definitions.') do |p|
-      options[:usr_data_header] = p
-    end
-
-    opts.on('--enable-callbacks NAME', Array, '[Optional] Enable some callbacks type') do |p|
-      options[:disable_callbaks] -= p.to_set
-    end
-  end.parse!
-
-  raise OptionParser::MissingArgument if options[:component_type].nil?
-
-  options[:plugin_name] ||= "metababel_#{options[:component_type].downcase}"
-  options[:component_name] ||= 'btx'
+    h[p.upcase]
+  end
 
+  parser.on('-u', '--upstreams PATHS', Array, '[Mandatory] Path to the bt2 YAML files for the upstream model.')
+  parser.on('-d', '--downstream PATH', '[Optional] Path to the bt2 YAML file for the downstream model.')
+  parser.on('-p', '--plugin-name PATH', '[Optional] Name of the bt2 plugin created.')
+  parser.on('-c', '--component-name PATH', '[Optional] Name of the bt2 component created.')
+  parser.on('--params PATH', '[Optional] Path to the bt2 YAML params definition.')
+  parser.on('-m', '--matching PATH', '[Optional] Path to bt2 YAML matching-callbacks definitions.')
+  parser.on('-o', '--output FOLDER', '[Optional] Output folder path.')
+  parser.on('-i', '--usr-data-header NAME', '[Optional] User datatypes definitions.')
+  parser.on('--enable-callbacks NAME', Array, '[Optional] Enable some callbacks type')
+  parser.on('--display-shared-callback PLUGIN') { |plugin|
+    path = Dir["#{__dir__}/../shared/*#{plugin}*"].first
+    puts File.readlines(path)
+    exit
+  }
+
+
+  options = { 'disable-callbaks': ['on_downstream'].to_set,
+              'component-name': 'btx',
+            }
+  parser.parse!(into: options)
+  raise OptionParser::MissingArgument if options[:'component-type'].nil?
+
+  options[:'plugin-name'] ||= "metababel_#{options[:'component-type'].downcase}"
+  options[:'disable-callbaks'] -= (options[:'enable-callbacks'] || []).to_set
   options
 end
 
@@ -313,7 +290,7 @@ class ContextBuilder
 
   def base_folder
     @base_folder ||= begin
-      f = @cli_options[:folder] || "#{@cli_options[:component_type]}.#{@cli_options[:plugin_name]}.#{@cli_options[:component_name]}"
+      f = @cli_options[:output] || "#{@cli_options[:'component-type']}.#{@cli_options[:'plugin-name']}.#{@cli_options[:'component-name']}"
       FileUtils.mkdir_p(f)
       f
     end
@@ -377,15 +354,15 @@ class ContextBuilder
                                                [GeneratedArg.new('void *', 'usr_data'),
                                                 GeneratedArg.new('btx_params_t *', 'usr_params')],
                                                no_btx_handle: true)]
-      # Usefull to push message
-      if %w[SOURCE FILTER].include?(@cli_options[:component_type])
+
+      if %w[SOURCE FILTER].include?(@cli_options[:'component-type'])
         static_callbacks += [StaticDispatcher.new('initialize_processing',
                                                   [GeneratedArg.new('void *', 'usr_data_p')]),
                              StaticDispatcher.new('finalize_processing',
                                                   [GeneratedArg.new('void *', 'usr_data')])]
       end
 
-      if %w[SOURCE].include?(@cli_options[:component_type])
+      if %w[SOURCE].include?(@cli_options[:'component-type'])
         static_callbacks << StaticDispatcher.new('push_usr_messages',
                                                  [GeneratedArg.new('void *', 'usr_data'),
                                                   GeneratedArg.new('btx_source_status_t*', 'status')])
@@ -398,9 +375,11 @@ class ContextBuilder
 
   def downstream
     @downstream ||= begin
-      raise 'Missing downstream model' unless @cli_options[:downstream]
+      unless @cli_options[:downstream] || !@cli_options[:'disable-callbaks'].include?('on_downstream')
+        raise 'Missing downstream model'
+      end
 
-      y = load_models(@cli_options[:downstream])
+      y = @cli_options[:downstream] ? load_models(@cli_options[:downstream]) : { stream_classes: [] }
       t = Babeltrace2Gen::BTTraceClass.from_h(nil, y)
 
       event_name = '_event'
@@ -434,7 +413,15 @@ class ContextBuilder
 
   def upstream
     @upstream ||= begin
-      raise 'Missing upstreams models' unless @cli_options[:upstreams]
+      unless @cli_options[:upstreams] || !@cli_options[:'disable-callbaks'].include?('on_downstream')
+        raise 'Missing upstreams models'
+      end
+
+      unless @cli_options[:upstreams]
+        return { dispatchers: [],
+                 dispatch_types: [],
+                 event_name: nil }
+      end
 
       y = load_models(@cli_options[:upstreams])
       t = Babeltrace2Gen::BTTraceClass.from_h(nil, y)
@@ -491,7 +478,7 @@ def wrote_component(cb)
 end
 
 def wrote_main(cb)
-  erb_render_and_save(cb.get_context(%w[params options]), "#{cb.cli_options[:component_type].downcase}.c",
+  erb_render_and_save(cb.get_context(%w[params options]), "#{cb.cli_options[:'component-type'].downcase}.c",
                       cb.base_folder, out_name: 'main.c')
 end
 
@@ -505,5 +492,5 @@ context_builder = ContextBuilder.new
 wrote_header(context_builder)
 wrote_main(context_builder)
 wrote_component(context_builder)
-wrote_downstream(context_builder) if %w[SOURCE FILTER].include?(context_builder.cli_options[:component_type])
-wrote_upstream(context_builder) if %w[FILTER SINK].include?(context_builder.cli_options[:component_type])
+wrote_downstream(context_builder) if %w[SOURCE FILTER].include?(context_builder.cli_options[:'component-type'])
+wrote_upstream(context_builder) if %w[FILTER SINK].include?(context_builder.cli_options[:'component-type'])

data/lib/metababel/bt2_trace_class_generator.rb

@@ -41,8 +41,8 @@ module Babeltrace2Gen
       is_a?(Babeltrace2Gen::BTEventClass) ? self : @parent.rec_event_class
     end
 
-    def rec_menber_class
-      is_a?(Babeltrace2Gen::BTMemberClass) ? self : @parent.rec_menber_class
+    def rec_member_class
+      is_a?(Babeltrace2Gen::BTMemberClass) ? self : @parent.rec_member_class
     end
 
     def resolve_path(path)
@@ -432,7 +432,7 @@ module Babeltrace2Gen
         else
           self.class.instance_variable_get(:@bt_type)
         end
-      var = GeneratedArg.new(@cast_type || type, rec_menber_class.name)
+      var = GeneratedArg.new(@cast_type || type, rec_member_class.name)
 
       arg_variables.fetch_append('outputs_allocated', var) if is_array
       arg_variables.fetch_append('outputs', var)
@@ -448,7 +448,7 @@ module Babeltrace2Gen
     def get_setter(field:, arg_variables:)
       bt_func_get = self.class.instance_variable_get(:@bt_func) % 'set'
       variable = bt_get_variable(arg_variables).name
-      # We always explicitly cast to the proper bebeltrace type when sending messsages.
+      # We always explicitly cast to the proper bebeltrace type when sending messages.
       pr "#{bt_func_get}(#{field}, (#{self.class.instance_variable_get(:@bt_type)})#{variable});"
     end
   end
@@ -552,32 +552,69 @@ module Babeltrace2Gen
   end
 
   module BTFieldClass::Enumeration
-    attr_reader :mappings
+    class BTFieldClass::Enumeration::Mapping
+      extend BTFromH
+      include BTUtils
+      include BTPrinter
 
-    class Mapping
+      def initialize(parent:, label:, integer_range_set:)
+        @parent = parent
+        @label = label
+        # Form [ [lower,upper], ...]
+        @ranges = integer_range_set
+      end
+
+      def get_declarator(field_class:)
+        bt_type_internal = self.class.instance_variable_get(:@bt_type_internal)
+        scope do
+          pr "bt_integer_range_set_#{bt_type_internal} *#{field_class}_range;"
+          pr "#{field_class}_range = bt_integer_range_set_#{bt_type_internal}_create();"
+          @ranges.each do |l, u|
+            pr "bt_integer_range_set_#{bt_type_internal}_add_range(#{field_class}_range, #{l}, #{u});"
+          end
+          pr "bt_field_class_enumeration_#{bt_type_internal}_add_mapping(#{field_class}, \"#{@label}\", #{field_class}_range);"
+          pr "bt_integer_range_set_#{bt_type_internal}_put_ref(#{field_class}_range);"
+        end
+      end
+    end
+
+    def initialize(parent:, mappings:)
+      @parent = parent
+      @mappings = mappings.map do |mapping|
+        # Handle inheritence
+        self.class.const_get('Mapping').from_h(self, mapping)
+      end
+    end
+
+    def get_declarator(trace_class:, variable:)
+      bt_type_internal = self.class.instance_variable_get(:@bt_type_internal)
+      pr "#{variable} = bt_field_class_enumeration_#{bt_type_internal}_create(#{trace_class});"
+      @mappings.each do |mapping|
+        mapping.get_declarator(field_class: variable)
+      end
     end
   end
 
   class BTFieldClass::Enumeration::Unsigned < BTFieldClass::Integer::Unsigned
     include BTFieldClass::Enumeration
-    class Mapping < BTFieldClass::Enumeration::Mapping
+    class BTFieldClass::Enumeration::Unsigned::Mapping < BTFieldClass::Enumeration::Mapping
+      @bt_type_internal = 'unsigned'
     end
 
-    def initialize(parent:, field_value_range:, mappings:, preferred_display_base: 10)
-      @mappings = mappings # TODO: init Mapping
-      super(parent: parent, field_value_range: field_value_range, preferred_display_base: preferred_display_base)
-    end
+    @bt_type = 'uint64_t'
+    @bt_type_internal = 'unsigned'
+    @bt_func = 'bt_field_integer_unsigned_%s_value'
   end
 
   class BTFieldClass::Enumeration::Signed < BTFieldClass::Integer::Signed
     include BTFieldClass::Enumeration
-    class Mapping < BTFieldClass::Enumeration::Mapping
+    class BTFieldClass::Enumeration::Signed::Mapping < BTFieldClass::Enumeration::Mapping
+      @bt_type_internal = 'signed'
     end
 
-    def initialize(parent:, field_value_range:, mappings:, preferred_display_base: 10)
-      @mappings = mappings # TODO: init Mapping
-      super(parent: parent, field_value_range: field_value_range, preferred_display_base: preferred_display_base)
-    end
+    @bt_type = 'int64_t'
+    @bt_type_internal = 'signed'
+    @bt_func = 'bt_field_integer_signed_%s_value'
   end
 
   class BTFieldClass::String < BTFieldClass
@@ -597,7 +634,7 @@ module Babeltrace2Gen
       bt_func_get = self.class.instance_variable_get(:@bt_func) % 'get'
       variable = bt_get_variable(arg_variables).name
 
-      pr "// Dump string data to the struct."
+      pr '// Dump string data to the struct.'
       pr "memcpy(&#{variable}, #{bt_func_get}(#{field}), sizeof(#{variable}));"
     end
 
@@ -606,12 +643,12 @@ module Babeltrace2Gen
 
       variable = bt_get_variable(arg_variables).name
 
-      pr "// Dump data to a temporal string."
+      pr '// Dump data to a temporal string.'
       pr "char *#{field}_temp = (char *)malloc(sizeof(#{variable}));"
       pr "assert(#{field}_temp != NULL && \"Out of memory\");"
       pr "memcpy(#{field}_temp, &#{variable}, sizeof(#{variable}));"
-      pr ""
-      pr "// Set string field with dumped data."
+      pr ''
+      pr '// Set string field with dumped data.'
       pr "bt_field_string_clear(#{field});"
       pr "bt_field_string_append_status #{field}_status = bt_field_string_append_with_length(#{field}, #{field}_temp, sizeof(#{variable}));"
       pr "assert(#{field}_status == BT_FIELD_STRING_APPEND_STATUS_OK && \"Out of memory\");"
@@ -671,7 +708,6 @@ module Babeltrace2Gen
         @element_field_class.get_getter(field: v, arg_variables: arg_variables)
       end
     end
-
   end
 
   class BTFieldClass::Array::Dynamic < BTFieldClass::Array
@@ -759,13 +795,14 @@ module Babeltrace2Gen
     def initialize(parent:, field_class: nil, name: nil)
       @parent = parent
       is_match_model = parent.rec_trace_class.match
-      raise ArgumentError.new("missing keyword: :name") unless name || is_match_model
-      raise ArgumentError.new("missing keyword: :field_class") unless field_class || is_match_model
+      raise ArgumentError, 'missing keyword: :name' unless name || is_match_model
+      raise ArgumentError, 'missing keyword: :field_class' unless field_class || is_match_model
+
       @name = name # Name can be nil in the matching callbacks
-      @field_class = BTFieldClass.from_h(self, field_class || {} )
+      @field_class = BTFieldClass.from_h(self, field_class || {})
     end
 
-    def bt_get_variable()
+    def bt_get_variable
       @field_class.bt_get_variable({})
     end
   end
@@ -994,7 +1031,7 @@ module Babeltrace2Gen
       pr "bt_trace_set_environment_entry_#{bt_type_set}(#{trace}, \"#{var_name}\", #{var_name});"
     end
 
-    def bt_get_variable(arg_variables={})
+    def bt_get_variable(arg_variables = {})
       var = GeneratedArg.new(self.class.instance_variable_get(:@bt_type), @name)
       arg_variables.fetch_append('outputs', var)
     end

data/lib/metababel/bt2_values_generator.rb

@@ -26,7 +26,7 @@ module Babeltrace2Gen
 
     include BTPrinter
 
-    # Scalars are leafs, avoid recursion
+    # Scalars are leaves, avoid recursion
     def self.from_h(model)
       new(model[:name], model.fetch(:default_value, nil))
     end

data/lib/metababel/version.rb

@@ -1,3 +1,3 @@
 module Metababel
-  VERSION = '1.0.4'
+  VERSION = '1.1.1'
 end

data/shared/stripper.cpp

@@ -0,0 +1,96 @@
+#include <babeltrace2/babeltrace.h>
+#include <metababel/metababel.h>
+#include <unordered_map>
+
+typedef std::unordered_map<const bt_stream *, const bt_message *> StreamToMessage_t;
+typedef std::unordered_map<const bt_packet *, const bt_message *> PacketToMessage_t;
+
+struct StreamToMessages_s {
+  StreamToMessage_t stream_beginning;
+  PacketToMessage_t packet_beginning;
+};
+typedef struct StreamToMessages_s StreamToMessages_t;
+
+static void btx_initialize_usr_data(void **usr_data) { *usr_data = new StreamToMessages_t{}; }
+
+static void btx_finalize_usr_data(void *usr_data) { delete ((StreamToMessages_t *)(usr_data)); }
+
+static void push_associated_beginnings(void *btx_handle, StreamToMessages_t *h,
+                                       const bt_message *message) {
+
+  const bt_event *event = bt_message_event_borrow_event_const(message);
+  const bt_stream *stream = bt_event_borrow_stream_const(event);
+
+  auto it_stream = h->stream_beginning.find(stream);
+  if (it_stream != h->stream_beginning.end()) {
+    btx_push_message(btx_handle, it_stream->second);
+    h->stream_beginning.erase(it_stream);
+  }
+
+  if (bt_stream_class_supports_packets(bt_stream_borrow_class_const(stream))) {
+    const auto packet = bt_event_borrow_packet_const(event);
+    auto it_packet = h->packet_beginning.find(packet);
+    if (it_packet != h->packet_beginning.end()) {
+      btx_push_message(btx_handle, it_packet->second);
+      h->packet_beginning.erase(it_packet);
+    }
+  }
+}
+
+template <typename T>
+static void push_or_drop_message(void *btx_handle,
+                                 std::unordered_map<const T *, const bt_message *> &stm,
+                                 const T *key, const bt_message *message) {
+  auto it = stm.find(key);
+  if (it == stm.end()) {
+    btx_push_message(btx_handle, message);
+  } else {
+    bt_message_put_ref(message);
+    bt_message_put_ref(it->second);
+    stm.erase(it);
+  }
+}
+
+static void on_downstream_message_callback(void *btx_handle, void *usr_data,
+                                           const bt_message *message) {
+
+  auto *h = (StreamToMessages_t *)usr_data;
+  switch (bt_message_get_type(message)) {
+  // Save begins
+  case (BT_MESSAGE_TYPE_STREAM_BEGINNING): {
+    const bt_stream *stream = bt_message_stream_beginning_borrow_stream_const(message);
+    h->stream_beginning.insert({stream, message});
+    break;
+  }
+  case (BT_MESSAGE_TYPE_PACKET_BEGINNING): {
+    const bt_packet *packet = bt_message_packet_beginning_borrow_packet_const(message);
+    h->packet_beginning.insert({packet, message});
+    break;
+  }
+  // Push event and associated beginnings
+  case (BT_MESSAGE_TYPE_EVENT): {
+    push_associated_beginnings(btx_handle, h, message);
+    btx_push_message(btx_handle, message);
+    break;
+  }
+  // Drop or push ends
+  case (BT_MESSAGE_TYPE_PACKET_END): {
+    const bt_packet *packet = bt_message_packet_end_borrow_packet_const(message);
+    push_or_drop_message(btx_handle, h->packet_beginning, packet, message);
+    break;
+  }
+  case (BT_MESSAGE_TYPE_STREAM_END): {
+    const bt_stream *stream = bt_message_stream_end_borrow_stream_const(message);
+    push_or_drop_message(btx_handle, h->stream_beginning, stream, message);
+    break;
+  }
+  default:
+    btx_push_message(btx_handle, message);
+  }
+}
+
+void btx_register_usr_callbacks(void *btx_handle) {
+  btx_register_callbacks_initialize_component(btx_handle, &btx_initialize_usr_data);
+  btx_register_callbacks_finalize_component(btx_handle, &btx_finalize_usr_data);
+  btx_register_on_downstream_message_callback(btx_handle, &on_downstream_message_callback);
+}

data/template/component.c.erb

@@ -27,8 +27,8 @@ void btx_call_callbacks_<%= e.name_sanitized %>(
   <%= e.name_sanitized %>_static_callback_f *p =
       common_data->static_callbacks-><%= e.name_sanitized %>;
   if (p)
-    p( <%= "(void *)common_data," unless e.no_btx_handle %>
-       <%= e.args.map{ |s| s.name }.join(", ") %>);
+    p(<%= "(void *)common_data," unless e.no_btx_handle %>
+          <%= e.args.map{ |s| s.name }.join(", ") %>);
 }
 <% end %>
 

data/template/component.h.erb

@@ -4,8 +4,8 @@
 #include "uthash.h"
 #include <babeltrace2/babeltrace.h>
 #include <stdbool.h>
-<% if options.key?(:usr_data_header) %>
-#include "<%= options[:usr_data_header] %>"
+<% if options.key?(:'usr-data-header') %>
+#include "<%= options[:'usr-data-header'] %>"
 <% end %>
 
 #ifdef __cplusplus
@@ -50,7 +50,7 @@ struct name_to_dispatcher_s {
 };
 typedef struct name_to_dispatcher_s name_to_dispatcher_t;
 
-<% if ['SOURCE', 'FILTER'].include?(options[:component_type]) %>
+<% if ['SOURCE', 'FILTER'].include?(options[:'component-type']) %>
 // Structure for Downstream Message
 struct el {
   const bt_message *message;
@@ -59,11 +59,11 @@ struct el {
 
 <% end %>
 // Struct stored in the component via `bt_self_component_set_data`
-<% if options[:component_type] == 'SOURCE' %>
+<% if options[:'component-type'] == 'SOURCE' %>
 struct common_data_s {
   name_to_dispatcher_t *name_to_dispatcher;
   static_callbacks_t *static_callbacks;
-  <% unless options[:disable_callbaks].include?('on_downstream') %>
+  <% unless options[:'disable-callbaks'].include?('on_downstream') %>
   void *on_downstream_message_callback;
   <% end %>
   void *usr_data;
@@ -101,11 +101,11 @@ enum btx_source_status_e {
 };
 typedef enum btx_source_status_e btx_source_status_t;
 
-<% elsif options[:component_type] == 'FILTER' %>
+<% elsif options[:'component-type'] == 'FILTER' %>
 struct common_data_s {
   name_to_dispatcher_t *name_to_dispatcher;
   static_callbacks_t *static_callbacks;
-  <% unless options[:disable_callbaks].include?('on_downstream') %>
+  <% unless options[:'disable-callbaks'].include?('on_downstream') %>
   void *on_downstream_message_callback;
   <% end %>
 
@@ -155,7 +155,7 @@ struct btx_message_iterator_s {
 };
 typedef struct btx_message_iterator_s btx_message_iterator_t;
 
-<% elsif options[:component_type] == 'SINK' %>
+<% elsif options[:'component-type'] == 'SINK' %>
 struct common_data_s {
   name_to_dispatcher_t *name_to_dispatcher;
   static_callbacks_t *static_callbacks;
@@ -173,8 +173,8 @@ void btx_unregister_callbacks(common_data_t *common_data);
 
 <% static_callback_types.each do |e| %>
 typedef void <%= e.name_sanitized %>_static_callback_f(
-  <%= "void *btx_handle," unless e.no_btx_handle %>
-  <%= e.args.map{ |s| s.type }.join(", ") %>);
+    <%= "void *btx_handle," unless e.no_btx_handle %>
+        <%= e.args.map{ |s| s.type }.join(", ") %>);
 
 <%# The Function who register the callbacks to the dispatcher %>
 void btx_register_callbacks_<%= e.name_sanitized %>(

data/template/downstream.c.erb

@@ -35,7 +35,7 @@ _btx_push_message(btx_message_iterator_t *message_iterator_private_data,
   DL_APPEND(message_iterator_private_data->queue, elt);
 }
 
-<% unless options[:disable_callbaks].include?('on_downstream') %>
+<% unless options[:'disable-callbaks'].include?('on_downstream') %>
 void btx_push_message(void *btx_handle, const bt_message *message) {
   _btx_push_message((btx_message_iterator_t *)btx_handle, message);
 }
@@ -46,12 +46,12 @@ void btx_register_on_downstream_message_callback(
       (void *)callback;
 }
 <% end %>
-// Used internaly to push messages downstreams
+// Used internally to push messages downstreams
 void btx_downstream_push_message(
     btx_message_iterator_t *message_iterator_private_data,
     const bt_message *message) {
 
-  <% unless options[:disable_callbaks].include?('on_downstream') %>
+  <% unless options[:'disable-callbaks'].include?('on_downstream') %>
   on_downstream_message_callback_f *p =
       (on_downstream_message_callback_f *)message_iterator_private_data
           ->common_data->on_downstream_message_callback;
@@ -84,7 +84,7 @@ bt_trace *btx_downstream_trace_create_rec(bt_trace_class *trace_class) {
   return trace;
 }
 
-// Workarround of a bug where gepping trace alive (and not the stream) provoke
+// Workaround of a bug where gepping trace alive (and not the stream) provoke
 // some segfault
 void btx_streams_get_ref(bt_trace *trace) {
   <% stream_classes.each_with_index do |_,i| %>
@@ -118,6 +118,7 @@ void btx_push_messages_stream_beginning(
     btx_downstream_push_message(message_iterator_private_data, message);
   }
   <% end %>
+  (void)trace;
 }
 
 void btx_push_messages_stream_end(
@@ -134,6 +135,7 @@ void btx_push_messages_stream_end(
     btx_downstream_push_message(message_iterator_private_data, message);
   }
   <% end %>
+  (void)trace;
 }
 
 <% downstream_events.each do |e| %>
@@ -175,8 +177,8 @@ void btx_push_message_<%= e.name_sanitized %>(
 <% end %>
 
 <% downstream_environements.each do |arg, body| %>
-void btx_downstream_set_environment_<%= arg.name%>(void *btx_handle,
-                                                   <%= arg.type%> <%= arg.name%>) {
+void btx_downstream_set_environment_<%= arg.name%>(
+    void *btx_handle, <%= arg.type%> <%= arg.name%>) {
   common_data_t *common_data = (common_data_t *)btx_handle;
   bt_trace *_trace = common_data->downstream_trace;
   <%= body %>

data/template/downstream.h.erb

@@ -33,7 +33,7 @@ void btx_push_message_<%= e.name_sanitized %>(
         btx_handle<%= e.args.map{ |s| "#{s.type} #{s.name}" }.join_with_prefix(", ") %>);
 <% end %>
 
-<% unless options[:disable_callbaks].include?('on_downstream') %>
+<% unless options[:'disable-callbaks'].include?('on_downstream') %>
 void btx_push_message(void *btx_handle, const bt_message *message);
 
 typedef void on_downstream_message_callback_f(void *btx_handle, void *usr_data,
@@ -43,8 +43,8 @@ void btx_register_on_downstream_message_callback(
 <% end %>
 
 <% downstream_environements.each do |arg, body| %>
-void btx_downstream_set_environment_<%= arg.name%>(void *btx_handle,
-                                                   <%= arg.type%> <%= arg.name%>);
+void btx_downstream_set_environment_<%= arg.name%>(
+    void *btx_handle, <%= arg.type%> <%= arg.name%>);
 <% end %>
 
 #ifdef __cplusplus

data/template/filter.c.erb

@@ -264,7 +264,7 @@ filter_message_iterator_next_initializing(
       (btx_message_iterator_t *)bt_self_message_iterator_get_data(
           self_message_iterator);
 
-  /* Begining of Stream */
+  /* Beginning of Stream */
   btx_push_messages_stream_beginning(self_message_iterator,
                                      message_iterator_private_data);
 
@@ -404,7 +404,7 @@ filter_initialize(bt_self_component_filter *self_component_filter,
   btx_call_callbacks_initialize_component(common_data, &common_data->usr_data);
   /* Call read callbacks */
   btx_call_callbacks_read_params(common_data, common_data->usr_data,
-      common_data->btx_params);
+                                 common_data->btx_params);
 
   return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
 }
@@ -519,17 +519,17 @@ static void filter_message_iterator_finalize(
 /* Mandatory */
 BT_PLUGIN_MODULE();
 
-BT_PLUGIN(<%= options[:plugin_name] %>);
-BT_PLUGIN_FILTER_COMPONENT_CLASS(<%= options[:component_name] %>,
+BT_PLUGIN(<%= options[:'plugin-name'] %>);
+BT_PLUGIN_FILTER_COMPONENT_CLASS(<%= options[:'component-name'] %>,
                                  filter_message_iterator_next);
 
 BT_PLUGIN_FILTER_COMPONENT_CLASS_INITIALIZE_METHOD(
-    <%= options[:component_name] %>, filter_initialize);
+    <%= options[:'component-name'] %>, filter_initialize);
 BT_PLUGIN_FILTER_COMPONENT_CLASS_FINALIZE_METHOD(
-    <%= options[:component_name] %>, filter_finalize);
+    <%= options[:'component-name'] %>, filter_finalize);
 BT_PLUGIN_FILTER_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD(
-    <%= options[:component_name] %>, filter_message_iterator_initialize);
+    <%= options[:'component-name'] %>, filter_message_iterator_initialize);
 BT_PLUGIN_FILTER_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_FINALIZE_METHOD(
-    <%= options[:component_name] %>, filter_message_iterator_finalize);
+    <%= options[:'component-name'] %>, filter_message_iterator_finalize);
 BT_PLUGIN_FILTER_COMPONENT_CLASS_INPUT_PORT_CONNECTED_METHOD(
-    <%= options[:component_name] %>, filter_input_port_connected);
+    <%= options[:'component-name'] %>, filter_input_port_connected);

data/template/metababel.h.erb

@@ -1,7 +1,7 @@
 #include <metababel/btx_component.h>
-<% if ['SOURCE', 'FILTER'].include?(options[:component_type]) %>
+<% if ['SOURCE', 'FILTER'].include?(options[:'component-type']) %>
 #include <metababel/btx_downstream.h>
 <% end %>
-<% if ['FILTER', 'SINK'].include?(options[:component_type]) %>
+<% if ['FILTER', 'SINK'].include?(options[:'component-type']) %>
 #include <metababel/btx_upstream.h>
 <% end %>

data/template/sink.c.erb

@@ -18,7 +18,7 @@ sink_consume(bt_self_component_sink *self_component_sink) {
       BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;
 
   /* Retrieve our private data from the component's user data */
-  /* This containt user data and the message iterator */
+  /* This contain user data and the message iterator */
   common_data_t *common_data = (common_data_t *)bt_self_component_get_data(
       bt_self_component_sink_as_self_component(self_component_sink));
 
@@ -153,7 +153,7 @@ sink_graph_is_configured(bt_self_component_sink *self_component_sink) {
   bt_self_component_port_input *in_port =
       bt_self_component_sink_borrow_input_port_by_index(self_component_sink, 0);
 
-  /* Create the uptream message iterator */
+  /* Create the upstream message iterator */
   bt_message_iterator_create_from_sink_component(
       self_component_sink, in_port, &common_data->message_iterator);
 
@@ -163,15 +163,12 @@ sink_graph_is_configured(bt_self_component_sink *self_component_sink) {
 /* Mandatory */
 BT_PLUGIN_MODULE();
 
-BT_PLUGIN(<%= options[:plugin_name] %>);
-// Maybe we should createonly one pluging
-/* Add the output  component class */
-BT_PLUGIN_SINK_COMPONENT_CLASS(<%= options[:component_name] %>, sink_consume);
+BT_PLUGIN(<%= options[:'plugin-name'] %>);
+BT_PLUGIN_SINK_COMPONENT_CLASS(<%= options[:'component-name'] %>, sink_consume);
 
 BT_PLUGIN_SINK_COMPONENT_CLASS_INITIALIZE_METHOD(
-    <%= options[:component_name] %>, sink_initialize);
-BT_PLUGIN_SINK_COMPONENT_CLASS_FINALIZE_METHOD(<%= options[:component_name] %>,
-                                               sink_finalize);
-
+    <%= options[:'component-name'] %>, sink_initialize);
+BT_PLUGIN_SINK_COMPONENT_CLASS_FINALIZE_METHOD(
+    <%= options[:'component-name'] %>, sink_finalize);
 BT_PLUGIN_SINK_COMPONENT_CLASS_GRAPH_IS_CONFIGURED_METHOD(
-    <%= options[:component_name] %>, sink_graph_is_configured);
+    <%= options[:'component-name'] %>, sink_graph_is_configured);

data/template/source.c.erb

@@ -33,7 +33,7 @@ source_message_iterator_next(bt_self_message_iterator *self_message_iterator,
    * not put any message into the message array */
   switch (message_iterator_private_data->state) {
   case BTX_SOURCE_STATE_INITIALIZING:
-    /* Begining of Stream */
+    /* Beginning of Stream */
     btx_push_messages_stream_beginning(self_message_iterator,
                                        message_iterator_private_data);
     /* Call Initialize user callback */
@@ -132,7 +132,7 @@ source_initialize(bt_self_component_source *self_component_source,
   btx_call_callbacks_initialize_component(common_data, &common_data->usr_data);
   /* Call read callbacks */
   btx_call_callbacks_read_params(common_data, common_data->usr_data,
-      common_data->btx_params);
+                                 common_data->btx_params);
 
   return BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
 }
@@ -209,15 +209,15 @@ static void source_message_iterator_finalize(
 /* Mandatory */
 BT_PLUGIN_MODULE();
 
-BT_PLUGIN(<%= options[:plugin_name] %>);
-BT_PLUGIN_SOURCE_COMPONENT_CLASS(<%= options[:component_name] %>,
+BT_PLUGIN(<%= options[:'plugin-name'] %>);
+BT_PLUGIN_SOURCE_COMPONENT_CLASS(<%= options[:'component-name'] %>,
                                  source_message_iterator_next);
 
 BT_PLUGIN_SOURCE_COMPONENT_CLASS_INITIALIZE_METHOD(
-    <%= options[:component_name] %>, source_initialize);
+    <%= options[:'component-name'] %>, source_initialize);
 BT_PLUGIN_SOURCE_COMPONENT_CLASS_FINALIZE_METHOD(
-    <%= options[:component_name] %>, source_finalize);
+    <%= options[:'component-name'] %>, source_finalize);
 BT_PLUGIN_SOURCE_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_INITIALIZE_METHOD(
-    <%= options[:component_name] %>, source_message_iterator_initialize);
+    <%= options[:'component-name'] %>, source_message_iterator_initialize);
 BT_PLUGIN_SOURCE_COMPONENT_CLASS_MESSAGE_ITERATOR_CLASS_FINALIZE_METHOD(
-    <%= options[:component_name] %>, source_message_iterator_finalize);
+    <%= options[:'component-name'] %>, source_message_iterator_finalize);

data/template/upstream.c.erb

@@ -55,9 +55,9 @@ static void btx_dispatch_<%= dispatcher.name_sanitized %>(
 
 <% end %>
 
-static void bt_register_callbacks(void *btx_handle, const char *dispatcher_name,
-                                  void *btx_dispatch_p, const char *id,
-                                  void *callback) {
+static void __attribute__((unused))
+bt_register_callbacks(void *btx_handle, const char *dispatcher_name,
+                      void *btx_dispatch_p, const char *id, void *callback) {
 
   name_to_dispatcher_t *s = NULL;
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: metababel
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.1.1
 platform: ruby
 authors:
 - Thomas Applencourt
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-02-16 00:00:00.000000000 Z
+date: 2024-04-03 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: 
@@ -29,6 +29,7 @@ files:
 - lib/metababel/bt2_trace_class_generator.rb
 - lib/metababel/bt2_values_generator.rb
 - lib/metababel/version.rb
+- shared/stripper.cpp
 - template/component.c.erb
 - template/component.h.erb
 - template/downstream.c.erb