metababel 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e44583997647f4d7d9e241dd5e066abc80586445283bd2846fa9fa453542de7
-  data.tar.gz: a89855eeb46c35a71325937679b30bc0ef3fe46317cc1239419980b13f43a1b5
+  metadata.gz: 34978d200c5c83d859b981dd4213dbb580b45bd1df2168ecf3ca6c14c357d8cf
+  data.tar.gz: 57627a9fe43e8264867521661168fea50e9f46b2911dade65cbae364d737469e
 SHA512:
-  metadata.gz: 8ece21929325026051ef4897d8f9871c19e5af621d963d1fcd8e57e8e481feb460e6fe3a02675eefb0bd44dc64505af329231ea22b52c54acbbfc7d9efcdaf2a
-  data.tar.gz: 62fd169ca6e45a414b71228c2b6fc763bd0d18dd83fcbc6266d1663bb7303a8aa608f56863b3bbea0154d5862e4b80f26adbdbd6401b11541a658e200c278704
+  metadata.gz: 3cb392b168b06ca0745d6807479a2cec8d63c10e9d7ecf69fa12908ac97d8edfb65388ecd13bb6557263162956546e88d32ea7bdb8d48066c4c41f91b9701681
+  data.tar.gz: 8fe12ff2a6fcb7ade72c57cfa492915cf6ac156fb1437dcb5504c61f7c7bc71bddac0fbda057c3304f50c2f157ab51def0c9847ad34d6c934830144d5c2e73c4

data/bin/metababel

@@ -7,11 +7,22 @@ require 'metababel'
 require 'fileutils'
 
 def validate_model(yaml)
-  raise "Invalid Model #{yaml}" unless yaml[:stream_classes].all? do |d|
-                                         d.key?(:event_common_context_field_class) || d[:event_classes].all? do |d2|
-                                           d2.key?(:payload_field_class)
-                                         end
-                                       end
+  # Stream and event classes must have a 'name' as minimum requirement.
+  raise "Missing 'name' attr in model #{yaml}" unless yaml[:stream_classes].all? do |d|
+                                                        d.key?(:name) && d[:event_classes].all? do |d2|
+                                                          d2.key?(:name)
+                                                        end
+                                                      end
+
+  # Event class name must be unique
+  events = yaml[:stream_classes].flat_map { |sc|  sc[:event_classes] }.map { |e| e[:name] }
+  raise "Duplicated 'event' in model #{yaml}" unless events.length == events.uniq.length
+end
+
+class Array
+  def join_with_prefix(sep)
+    empty? ? '' : "#{sep}#{join(sep)}"
+  end
 end
 
 class Hash
@@ -33,7 +44,14 @@ class Hash
   end
 end
 
-EventInfo = Struct.new(:name, :args, :body, :index_stream_class, :index_event_class, :default_clock_class) do
+EventClassInfo = Struct.new(:name, :args, :body, :index_stream_class, :index_event_class, :default_clock_class,
+                            :args_to_free) do
+  def name_sanitized
+    name.gsub(/[^0-9A-Za-z-]/, '_')
+  end
+end
+
+StreamClassInfo = Struct.new(:name, :args, :body, :default_clock_class) do
   def name_sanitized
     name.gsub(/[^0-9A-Za-z-]/, '_')
   end
@@ -71,17 +89,28 @@ end
 # But we clean the white space empty line afterward \o/
 def wrote_event_dispatchers(folder, t)
   event_name = 'event'
-  event_dispatchers = t.map_event_classes_with_index do |e, index_stream_class, index_event_class, default_clock_class|
-    arg_variables = []
-    arg_variables << GeneratedArg.new("uint64_t", "timestamp") if default_clock_class
-
+  event_class_dispatchers = t.map_event_classes_with_index do |e, index_stream_class, index_event_class, default_clock_class|
+    arg_variables = {}
     body = Babeltrace2Gen.context(indent: 1) do
       e.get_getter(event: event_name, arg_variables: arg_variables)
     end
-    EventInfo.new(e.name, arg_variables, "\n" + body, index_stream_class, index_event_class)
+    EventClassInfo.new(e.name, arg_variables.fetch('outputs', []), body, index_stream_class, index_event_class, default_clock_class,
+                       arg_variables.fetch('outputs_allocated', []))
   end
 
-  d = { event_dispatchers: event_dispatchers,
+  stream_classes_matching_dispatchers = t.stream_classes.map do |s|
+    arg_variables = {}
+    body = ''
+    if s.event_common_context_field_class
+      body = Babeltrace2Gen.context(indent: 1) do
+        s.get_getter(event: event_name, arg_variables: arg_variables)
+      end
+    end
+    StreamClassInfo.new(s.name, arg_variables.fetch('outputs', []), body, s.default_clock_class)
+  end
+
+  d = { event_class_dispatchers: event_class_dispatchers,
+        stream_classes_matching_dispatchers: stream_classes_matching_dispatchers,
         event_name: event_name }
 
   erb_render_and_save(d, 'upstream.h', folder)
@@ -91,13 +120,12 @@ end
 def wrote_creates(folder, t)
   event_name = 'event'
   downstream_events = t.map_event_classes_with_index do |e, index_stream_class, index_event_class, default_clock_class|
-    arg_variables = []
+    arg_variables = {}
     body = Babeltrace2Gen.context(indent: 1) do
       e.get_setter(event: event_name, arg_variables: arg_variables)
     end
-    arg_variables.insert(0,GeneratedArg.new("uint64_t", "timestamp")) if default_clock_class
-
-    EventInfo.new(e.name, arg_variables, "\n" + body, index_stream_class, index_event_class, default_clock_class)
+    EventClassInfo.new(e.name, arg_variables.fetch('outputs', []), "\n" + body, index_stream_class, index_event_class,
+                       default_clock_class)
   end
 
   body_declarator_classes = "\n" + Babeltrace2Gen.context(indent: 1) do
@@ -114,18 +142,18 @@ def wrote_creates(folder, t)
 end
 
 def wrote_component(options, d, folder)
-  component_dispatchers = [EventInfo.new('initialize_usr_data',
-                                         [GeneratedArg.new('void **', 'usr_data_p')]),
-                           EventInfo.new('finalize_usr_data',
-                                         [GeneratedArg.new('void *', 'usr_data')]),
-                           EventInfo.new('read_params',
-                                         [GeneratedArg.new('void *', 'usr_data'),
-                                          GeneratedArg.new('btx_params_t *', 'usr_params')])]
+  component_dispatchers = [EventClassInfo.new('initialize_usr_data',
+                                              [GeneratedArg.new('void **', 'usr_data_p')]),
+                           EventClassInfo.new('finalize_usr_data',
+                                              [GeneratedArg.new('void *', 'usr_data')]),
+                           EventClassInfo.new('read_params',
+                                              [GeneratedArg.new('void *', 'usr_data'),
+                                               GeneratedArg.new('btx_params_t *', 'usr_params')])]
 
   if options[:component_type] == 'SOURCE'
-    component_dispatchers << EventInfo.new('push_usr_messages',
-                                           [GeneratedArg.new('void *', 'usr_data'),
-                                            GeneratedArg.new('btx_source_status_t*', 'status')])
+    component_dispatchers << EventClassInfo.new('push_usr_messages',
+                                                [GeneratedArg.new('void *', 'usr_data'),
+                                                 GeneratedArg.new('btx_source_status_t*', 'status')])
   end
 
   d2 = { component_dispatchers: component_dispatchers,
@@ -187,8 +215,9 @@ OptionParser.new do |opts|
 end.parse!
 
 raise OptionParser::MissingArgument if options[:component_type].nil?
+
 options[:plugin_name] ||= "metababel_#{options[:component_type].downcase}"
-options[:component_name] ||= "btx"
+options[:component_name] ||= 'btx'
 
 # Babeltrace can be extended by plugins, which provide one or more component classes.
 base_folder = options[:folder] || "#{options[:component_type]}.#{options[:plugin_name]}.#{options[:component_name]}"
@@ -208,10 +237,10 @@ if options.key?(:params)
   d[:params_declaration] = c.get_struct_definition('params')
   d[:params_definition] = body
 else
-  d[:params_declaration] = "char _dummy;"
+  d[:params_declaration] = 'char _dummy;'
 end
 
-erb_render_and_save(d, "#{options[:component_type].downcase}.c", base_folder, out_name: "main.c")
+erb_render_and_save(d, "#{options[:component_type].downcase}.c", base_folder, out_name: 'main.c')
 erb_render_and_save({ options: options }, 'metababel.h', folder, prefix: '')
 
 wrote_component(options, d, folder)

data/lib/metababel/bt2_stream_classes_generator.rb

@@ -1,5 +1,14 @@
 require_relative 'bt2_generator_utils'
 
+module HashRefinements
+  refine Hash do
+    def fetch_append(key, item)
+      self[key] = fetch(key, []) << item
+      item
+    end
+  end
+end
+
 module Babeltrace2Gen
   class GeneratedArg < Struct.new(:type, :name)
   end
@@ -31,32 +40,22 @@ module Babeltrace2Gen
       is_a?(Babeltrace2Gen::BTMemberClass) ? self : @parent.rec_menber_class
     end
 
-    def find_field_class_path(path, variable)
-      path.scan(/\["(\w+)"\]|\[(\d+)\]/).each do |m|
-        # String
-        if m.first
-          pr "#{variable} = bt_field_class_structure_borrow_member_by_name(#{variable}, \"#{m.first}\");"
+    def resolve_path(path)
+      root, id = path.match(/^(PACKET_CONTEXT|EVENT_COMMON_CONTEXT|EVENT_SPECIFIC_CONTEXT|EVENT_PAYLOAD)\["?(.+)?"\]/).captures
+      field_class =
+        case root
+        when 'PACKET_CONTEXT'
+          rec_stream_class.packet_context_field_class
+        when 'EVENT_COMMON_CONTEXT'
+          rec_stream_class.event_common_context_field_class
+        when 'EVENT_SPECIFIC_CONTEXT'
+          rec_event_class.specific_context_field_class
+        when 'EVENT_PAYLOAD'
+          rec_event_class.payload_field_class
         else
-          pr "#{variable} = bt_field_class_structure_borrow_member_by_index(#{variable}, #{m.last});"
+          raise "invalid path #{path}"
         end
-      end
-    end
-
-    def find_field_class(path, variable)
-      m = path.match(/\A(PACKET_CONTEXT|EVENT_COMMON_CONTEXT|EVENT_SPECIFIC_CONTEXT|EVENT_PAYLOAD)(.*)/)
-      case m[1]
-      when 'PACKET_CONTEXT'
-        pr "#{variable} = #{rec_stream_class.packet_context_field_class.variable};"
-      when 'EVENT_COMMON_CONTEXT'
-        pr "#{variable} = #{rec_stream_class.event_common_context_field_class.variable};"
-      when 'EVENT_SPECIFIC_CONTEXT'
-        pr "#{variable} = #{rec_event_class.specific_context_field_class.varible};"
-      when 'EVENT_PAYLOAD'
-        pr "#{variable} = #{rec_event_class.payload_field_class.variable};"
-      else
-        raise "invalid path #{path}"
-      end
-      find_field_class_path(m[2], variable)
+      [field_class, id]
     end
   end
 
@@ -110,7 +109,8 @@ module Babeltrace2Gen
     include BTPrinter
     include BTLocator
     extend BTFromH
-    attr_reader :packet_context_field_class, :event_common_context_field_class, :event_classes, :default_clock_class, :id, :name
+    attr_reader :packet_context_field_class, :event_common_context_field_class, :event_classes, :default_clock_class,
+                :id, :name, :get_getter
 
     def initialize(parent:, name: nil, packet_context_field_class: nil, event_common_context_field_class: nil,
                    event_classes: [], id: nil, assigns_automatic_event_class_id: nil, assigns_automatic_stream_id: nil,
@@ -202,6 +202,21 @@ module Babeltrace2Gen
 
       pr "bt_stream_class_put_ref(#{variable});"
     end
+
+    # The getters code generated from event_common_context_field_class do not include
+    # the event variable name used by the getters. As we do not know the variable
+    # name that should be generated, we can not put it directly in the template,
+    # since, if the code generation generates another name we must update the
+    # template in addition.
+    def get_getter(event:, arg_variables:)
+      return unless event_common_context_field_class
+
+      field = "#{event}_cc_f"
+      scope do
+        pr "const bt_field *#{field} = bt_event_borrow_common_context_field_const(#{event});"
+        event_common_context_field_class.get_getter(variable: field, arg_variables: arg_variables)
+      end
+    end
   end
 
   class BTEventClass
@@ -223,7 +238,7 @@ module Babeltrace2Gen
     end
 
     def get_declarator(trace_class:, variable:, stream_class:)
-      # Store the variable name for instrocption purpose for LOCATION_PATH
+      # Store the variable name for instrospection purpose (PATH)
       @variable = variable
       if @id
         pr "#{variable} = bt_event_class_create_with_id(#{stream_class}, #{@id});"
@@ -243,14 +258,14 @@ module Babeltrace2Gen
         end
       end
 
-      if @payload_field_class
-        var_name = "#{variable}_p_fc"
-        scope do
-          pr "bt_field_class *#{var_name};"
-          @payload_field_class.get_declarator(trace_class: trace_class, variable: var_name)
-          pr "bt_event_class_set_payload_field_class(#{variable}, #{var_name});"
-          pr "bt_field_class_put_ref(#{var_name});"
-        end
+      return unless @payload_field_class
+
+      var_name = "#{variable}_p_fc"
+      scope do
+        pr "bt_field_class *#{var_name};"
+        @payload_field_class.get_declarator(trace_class: trace_class, variable: var_name)
+        pr "bt_event_class_set_payload_field_class(#{variable}, #{var_name});"
+        pr "bt_field_class_put_ref(#{var_name});"
       end
     end
 
@@ -271,12 +286,12 @@ module Babeltrace2Gen
         end
       end
 
-      if @payload_field_class
-        field = "#{event}_p_f"
-        scope do
-          pr "bt_field *#{field} = bt_event_borrow_payload_field(#{event});"
-          @payload_field_class.get_setter(variable: field, arg_variables: arg_variables)
-        end
+      return unless @payload_field_class
+
+      field = "#{event}_p_f"
+      scope do
+        pr "bt_field *#{field} = bt_event_borrow_payload_field(#{event});"
+        @payload_field_class.get_setter(variable: field, arg_variables: arg_variables)
       end
     end
 
@@ -297,12 +312,12 @@ module Babeltrace2Gen
         end
       end
 
-      if @payload_field_class
-        field = "#{event}_p_f"
-        scope do
-          pr "const bt_field *#{field} = bt_event_borrow_payload_field_const(#{event});"
-          @payload_field_class.get_getter(variable: field, arg_variables: arg_variables)
-        end
+      return unless @payload_field_class
+
+      field = "#{event}_p_f"
+      scope do
+        pr "const bt_field *#{field} = bt_event_borrow_payload_field_const(#{event});"
+        @payload_field_class.get_getter(variable: field, arg_variables: arg_variables)
       end
     end
   end
@@ -310,6 +325,7 @@ module Babeltrace2Gen
   class BTFieldClass
     include BTLocator
     include BTPrinter
+    using HashRefinements
 
     attr_accessor :cast_type
 
@@ -353,27 +369,32 @@ module Babeltrace2Gen
       raise NotImplementedError, self.class
     end
 
-    def bt_get_variable(_field, arg_variables)
-      if arg_variables.empty? || arg_variables.first.is_a?(GeneratedArg)
-        variable = rec_menber_class.name
-        type = @cast_type || self.class.instance_variable_get(:@bt_type)
-        arg_variables << GeneratedArg.new(type, variable)
-        variable
-      else
-        arg_variables.shift
-      end
+    def bt_get_variable(arg_variables, is_array: false)
+      internal = arg_variables.fetch('internal', [])
+      return internal.shift unless internal.empty?
+
+      type =
+        if is_array
+          "#{element_field_class.class.instance_variable_get(:@bt_type)}*"
+        else
+          self.class.instance_variable_get(:@bt_type)
+        end
+      var = GeneratedArg.new(@cast_type || type, rec_menber_class.name)
+
+      arg_variables.fetch_append('outputs_allocated', var) if is_array
+      arg_variables.fetch_append('outputs', var)
     end
 
     def get_getter(field:, arg_variables:)
       bt_func_get = self.class.instance_variable_get(:@bt_func) % 'get'
-      variable = bt_get_variable(field, arg_variables)
+      variable = bt_get_variable(arg_variables).name
       cast_func = @cast_type ? "(#{@cast_type})" : ''
       pr "#{variable} = #{cast_func}#{bt_func_get}(#{field});"
     end
 
     def get_setter(field:, arg_variables:)
       bt_func_get = self.class.instance_variable_get(:@bt_func) % 'set'
-      variable = bt_get_variable(field, arg_variables)
+      variable = bt_get_variable(arg_variables).name
       cast_func = @cast_type ? "(#{self.class.instance_variable_get(:@bt_type)})" : ''
       pr "#{bt_func_get}(#{field}, #{variable});"
     end
@@ -418,9 +439,9 @@ module Babeltrace2Gen
 
     def get_declarator(variable:)
       pr "bt_field_class_integer_set_field_value_range(#{variable}, #{@field_value_range});" if @field_value_range
-      if @preferred_display_base
-        pr "bt_field_class_integer_set_preferred_display_base(#{variable}, #{@preferred_display_base});"
-      end
+      return unless @preferred_display_base
+
+      pr "bt_field_class_integer_set_preferred_display_base(#{variable}, #{@preferred_display_base});"
     end
   end
 
@@ -546,13 +567,14 @@ module Babeltrace2Gen
     module WithLengthField
       attr_reader :length_field_path
     end
+    using HashRefinements
 
     def initialize(parent:, element_field_class:, length_field_path: nil)
       super(parent: parent, element_field_class: element_field_class)
-      if length_field_path
-        extend(WithLengthField)
-        @length_field_path = length_field_path
-      end
+      return unless length_field_path
+
+      extend(WithLengthField)
+      @length_field_path = length_field_path
     end
 
     def get_declarator(trace_class:, variable:)
@@ -563,13 +585,55 @@ module Babeltrace2Gen
         if @length_field_path
           element_field_class_variable_length = "#{element_field_class_variable}_length"
           pr "bt_field_class *#{element_field_class_variable_length};"
-          find_field_class(@length_field_path, element_field_class_variable_length)
+          scope do
+            element_field_class_variable_length_sm = "#{element_field_class_variable_length}_sm"
+            pr "bt_field_class_structure_member *#{element_field_class_variable_length_sm};"
+            field_class, id = resolve_path(@length_field_path)
+            id.scan(/(\w+)|(\d+)/).each do |name, index|
+              # String
+              if name
+                pr "#{element_field_class_variable_length_sm} = bt_field_class_structure_borrow_member_by_name(#{field_class.variable}, \"#{name}\");"
+              else
+                pr "#{element_field_class_variable_length_sm} = bt_field_class_structure_borrow_member_by_index(#{field_class.variable}, #{index});"
+              end
+            end
+            pr "#{element_field_class_variable_length} = bt_field_class_structure_member_borrow_field_class(#{element_field_class_variable_length_sm});"
+          end
           pr "#{variable} = bt_field_class_array_dynamic_create(#{trace_class}, #{element_field_class_variable}, #{element_field_class_variable_length});"
+          pr "bt_field_class_put_ref(#{element_field_class_variable});"
         else
           pr "#{variable} = bt_field_class_array_dynamic_create(#{trace_class}, #{element_field_class_variable}, NULL);"
         end
       end
     end
+
+    def get_setter(field:, arg_variables:)
+      field_class, id = resolve_path(@length_field_path)
+      length_field = field_class[id]
+      pr "bt_field_array_dynamic_set_length(#{field}, #{length_field.name});"
+      usr_var = bt_get_variable(arg_variables, is_array: true)
+      pr "for(uint64_t _i=0; _i < #{length_field.name} ; _i++)"
+      scope do
+        v = "#{field}_e"
+        pr "bt_field* #{v} = bt_field_array_borrow_element_field_by_index(#{field}, _i);"
+        arg_variables.fetch_append('internal', GeneratedArg.new('', "#{usr_var.name}[_i]"))
+        @element_field_class.get_setter(field: v, arg_variables: arg_variables)
+      end
+    end
+
+    def get_getter(field:, arg_variables:)
+      length = "#{field}_length"
+      pr "uint64_t #{length} = bt_field_array_get_length(#{field});"
+      usr_var = bt_get_variable(arg_variables, is_array: true)
+      pr "#{usr_var.name} = (#{usr_var.type}) malloc(#{length} * sizeof(#{usr_var.name}));"
+      pr "for(uint64_t _i=0; _i < #{length} ; _i++)"
+      scope do
+        v = "#{field}_e"
+        pr "const bt_field* #{v} = bt_field_array_borrow_element_field_by_index_const(#{field}, _i);"
+        arg_variables.fetch_append('internal', GeneratedArg.new('', "#{usr_var.name}[_i]"))
+        @element_field_class.get_getter(field: v, arg_variables: arg_variables)
+      end
+    end
   end
 
   class BTMemberClass
@@ -595,10 +659,12 @@ module Babeltrace2Gen
 
     def [](index)
       case index
-      when Integer
+      when ::Integer
         @members[index]
-      when String
+      when ::String
         @members.find { |m| m.name == index }
+      else
+        raise("Unknow Type (#{index.class}) for index: #{index}")
       end
     end
 

data/lib/metababel/bt2_values_generator.rb

@@ -28,10 +28,10 @@ module Babeltrace2Gen
 
     # Scalars are leafs, avoid recursion
     def self.from_h(model)
-      new(model[:name],model.fetch(:default_value,nil))
+      new(model[:name], model.fetch(:default_value, nil))
     end
 
-    def initialize(name,usr_default_value)
+    def initialize(name, usr_default_value)
       @name = name
       @usr_default_value = usr_default_value
     end
@@ -47,12 +47,12 @@ module Babeltrace2Gen
       pr "if (#{val} != NULL) {"
       pr "  if (!#{bt_type_is}(#{val})) {"
       pr "    fprintf(stderr,\"Bad value for command line argument '%s' the value must be '%s'. \\n\",\"#{@name}\",\"#{bt_type}\");"
-      pr "    exit(1);"
-      pr "  }"
+      pr '    exit(1);'
+      pr '  }'
       pr "  #{name} = #{cast_func}bt_value_#{bt_type}_get(#{val});"
-      pr "} else {"
+      pr '} else {'
       pr "  #{name} = #{cast_func}#{default_value};"
-      pr "}"
+      pr '}'
     end
   end
 
@@ -90,12 +90,13 @@ module Babeltrace2Gen
     @bt_return_type = 'bt_bool'
     @bt_default_value = 'BT_FALSE'
 
-    def initialize(name,usr_default_value)
+    def initialize(name, usr_default_value)
       bt_type = self.class.instance_variable_get(:@bt_type)
-      if !usr_default_value.nil? and !['BT_TRUE', 'BT_FALSE'].include? usr_default_value
+      if !usr_default_value.nil? and !%w[BT_TRUE BT_FALSE].include? usr_default_value
         raise "Bad default_value for '#{name}' in params.yaml, it must be #{bt_type} (BT_TRUE or BT_FALSE) but provided '#{usr_default_value}'."
       end
-      super(name,usr_default_value)
+
+      super(name, usr_default_value)
     end
   end
 
@@ -105,13 +106,14 @@ module Babeltrace2Gen
     @bt_return_type = 'const char*'
     @bt_default_value = 'NULL'
 
-    def initialize(name,usr_default_value)
+    def initialize(name, usr_default_value)
       bt_type = self.class.instance_variable_get(:@bt_type)
       # Every object that can be converted to string is being supported.
       if !usr_default_value.nil? and !usr_default_value.respond_to?(:to_s)
-          raise "Bad default_value for '#{name}' in params.yaml, it must be #{bt_type} but provided '#{usr_default_value}'." 
+        raise "Bad default_value for '#{name}' in params.yaml, it must be #{bt_type} but provided '#{usr_default_value}'."
       end
-      super(name,usr_default_value.to_s.inspect)
+
+      super(name, usr_default_value.to_s.inspect)
     end
   end
 
@@ -121,12 +123,13 @@ module Babeltrace2Gen
     @bt_return_type = 'uint64_t'
     @bt_default_value = '0'
 
-    def initialize(name,usr_default_value)
+    def initialize(name, usr_default_value)
       bt_type = self.class.instance_variable_get(:@bt_type)
-      if !usr_default_value.nil? and (!usr_default_value.kind_of? Integer or !usr_default_value.between?(0,2**64-1))
-          raise "Bad default_value for '#{name}' in params.yaml, it must be #{bt_type} and must be in [0,2^64-1], but provided '#{usr_default_value}'." 
+      if !usr_default_value.nil? and (!usr_default_value.is_a? Integer or !usr_default_value.between?(0, 2**64 - 1))
+        raise "Bad default_value for '#{name}' in params.yaml, it must be #{bt_type} and must be in [0,2^64-1], but provided '#{usr_default_value}'."
       end
-      super(name,usr_default_value)
+
+      super(name, usr_default_value)
     end
   end
 end

data/lib/metababel/version.rb

@@ -1,3 +1,3 @@
 module Metababel
-  VERSION = '0.0.3'
+  VERSION = '0.0.5'
 end

data/template/component.c.erb

@@ -3,7 +3,6 @@
 #include <assert.h>
 #include <babeltrace2/babeltrace.h>
 #include <metababel/btx_component.h>
-#include <stdbool.h>
 // stdio needed because `params_definition` contain fprintf
 #include <stdio.h>
 

data/template/component.h.erb

@@ -3,6 +3,7 @@
 #include "utarray.h"
 #include "uthash.h"
 #include <babeltrace2/babeltrace.h>
+#include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -83,6 +84,7 @@ typedef enum btx_source_status_e btx_source_status_t;
 <% elsif options[:component_type] == 'FILTER' %>
 struct common_data_s {
   name_to_dispatcher_t *name_to_dispatcher;
+  name_to_dispatcher_t *name_to_matching_dispatcher;
   void *usr_data;
   const bt_value *params;
   btx_params_t *btx_params;
@@ -132,6 +134,7 @@ typedef struct btx_message_iterator_s btx_message_iterator_t;
 <% elsif options[:component_type] == 'SINK' %>
 struct common_data_s {
   name_to_dispatcher_t *name_to_dispatcher;
+  name_to_dispatcher_t *name_to_matching_dispatcher;
   void *usr_data;
   const bt_value *params;
   btx_params_t *btx_params;

data/template/downstream.c.erb

@@ -108,14 +108,14 @@ void btx_push_messages_stream_end(
 
 <% downstream_events.each do |e| %>
 static void btx_set_message_<%= e.name_sanitized %>(
-    bt_event *<%= event_name %>,
-    <%= e.args.map{ |s| "#{s.type} #{s.name}" }.join(", ") %>) {
+    bt_event *
+        <%= event_name %><%= e.args.map{ |s| "#{s.type} #{s.name}" }.join_with_prefix(", ") %>) {
   <%= e.body %>
 }
 
 void btx_push_message_<%= e.name_sanitized %>(
-    void *btx_handle,
-    <%= e.args.map{ |s| "#{s.type} #{s.name}" }.join(", ") %>) {
+    void *
+        btx_handle<%= ', int64_t _timestamp' if e.default_clock_class %><%= e.args.map{ |s| "#{s.type} #{s.name}" }.join_with_prefix(", ") %>) {
 
   common_data_t *common_data = (common_data_t *)btx_handle;
 
@@ -129,13 +129,13 @@ void btx_push_message_<%= e.name_sanitized %>(
       common_data->self_message_iterator, event_class, stream);
   <% else %>
   bt_message *message = bt_message_event_create_with_default_clock_snapshot(
-      common_data->self_message_iterator, event_class, stream, timestamp);
+      common_data->self_message_iterator, event_class, stream, _timestamp);
   <% end %>
 
   bt_event *downstream_event = bt_message_event_borrow_event(message);
 
   btx_set_message_<%= e.name_sanitized %>(
-      downstream_event, <%= e.args.map{ |s| s.name }.join(", ") %>);
+      downstream_event<%= e.args.map{ |s| s.name }.join_with_prefix(", ") %>);
 
   btx_message_iterator_t *message_iterator_private_data =
       bt_self_message_iterator_get_data(common_data->self_message_iterator);

data/template/downstream.h.erb

@@ -29,8 +29,8 @@ void btx_push_messages_stream_end(
 
 <% downstream_events.each do |e| %>
 void btx_push_message_<%= e.name_sanitized %>(
-    void *btx_handle,
-    <%= e.args.map{ |s| "#{s.type} #{s.name}" }.join(", ") %>);
+    void *
+        btx_handle<%= ', int64_t _timestamp' if e.default_clock_class %><%= e.args.map{ |s| "#{s.type} #{s.name}" }.join_with_prefix(", ") %>);
 <% end %>
 #ifdef __cplusplus
 }