metababel 0.0.5 → 1.0.1

data/lib/metababel/bt2_generator_utils.rb

@@ -5,7 +5,7 @@ module Babeltrace2Gen
     INDENT_INCREMENT = '  '.freeze
 
     def pr(str)
-      @@output << INDENT_INCREMENT * @@indent << str << "\n"
+      @@output << (INDENT_INCREMENT * @@indent) << str << "\n"
     end
     module_function :pr
 
@@ -28,7 +28,7 @@ module Babeltrace2Gen
     def name_sanitized
       raise unless @name
 
-      @name.gsub(/[^0-9A-Za-z\-]/, '_')
+      @name.gsub(/[^0-9A-Za-z-]/, '_')
     end
   end
 

data/lib/metababel/bt2_matching_utils.rb

@@ -0,0 +1,72 @@
+module HashRefinements
+  refine Hash do
+    # Special case for hash, default value of
+    # ':default_clock_class: {}'.
+    def match?(obj)
+      self == obj
+    end
+  end
+end
+
+module Babeltrace2Gen
+  using HashRefinements
+
+  module BTMatch
+    def match?(match_obj)
+      attrs_syms = self.class::BT_MATCH_ATTRS
+      attrs = attrs_syms.map do |attr_sym|
+        match_attr = match_obj.send(attr_sym)
+        # In the model, but not in the match, assuming True
+        next true if match_attr.nil?
+
+        self_attr = send(attr_sym)
+
+        # Not matching because in the match but not in the model
+        next false if self_attr.nil?
+
+        # Continue the recursion
+        self_attr.match?(match_attr)
+      end.flatten
+      return false unless attrs.all?
+
+      attrs.filter { |a| a.is_a?(Babeltrace2Gen::GeneratedArg) }
+    end
+  end
+
+  module BTMatchMembers
+    def match?(match_obj)
+      # Object here have only one symbol, who cannot be nil
+      attr_sym = self.class::BT_MATCH_ATTRS[0]
+
+      self_members = send(attr_sym)
+      match_members = match_obj.send(attr_sym)
+
+      # Do the product of menbers to get the matching one
+      # We keep only the matching one.
+      args_matched = match_members.filter_map do |match_obj|
+        # Find all machings members
+        matches = self_members.filter { |member| member.match?(match_obj) }
+        # Check that one match_obj only match zero or one member.
+        unless matches.length < 2
+          raise "Match expression '#{match_obj.name}' must match only one member, '#{matches.length}' matched #{matches.map(&:name)}."
+        end
+
+        # If not argument matched, then nil; otherwise, return the matched member.
+        matches.pop.bt_get_variable unless matches.empty?
+      end
+
+      # We didn't match anything
+      if args_matched.empty? || args_matched.uniq.length != match_members.length
+        false
+      # Same arguments in the model have been matched twice
+      elsif args_matched.uniq.length != args_matched.length
+        raise "Members '#{args_matched.uniq.map(&:name)}' matched multiple times in '#{match_members.map(&:name)}'. "
+      # Not all match mernbers found a matchings
+      elsif args_matched.uniq.length != match_members.length
+        false
+      else
+        args_matched
+      end
+    end
+  end
+end

data/lib/metababel/{bt2_stream_classes_generator.rb → bt2_trace_class_generator.rb}

@@ -1,4 +1,5 @@
 require_relative 'bt2_generator_utils'
+require_relative 'bt2_matching_utils'
 
 module HashRefinements
   refine Hash do
@@ -28,6 +29,10 @@ module Babeltrace2Gen
   module BTLocator
     attr_reader :parent, :variable
 
+    def rec_trace_class
+      is_a?(Babeltrace2Gen::BTTraceClass) ? self : @parent.rec_trace_class
+    end
+
     def rec_stream_class
       is_a?(Babeltrace2Gen::BTStreamClass) ? self : @parent.rec_stream_class
     end
@@ -70,15 +75,21 @@ module Babeltrace2Gen
     include BTLocator
     include BTPrinter
     include BTUtils
+    include BTMatch
     extend BTFromH
 
-    attr_reader :stream_classes, :assigns_automatic_stream_class_id
+    BT_MATCH_ATTRS = [:environment]
+
+    attr_reader :stream_classes, :environment, :assigns_automatic_stream_class_id, :match
 
-    def initialize(parent:, stream_classes:, assigns_automatic_stream_class_id: nil)
+    def initialize(parent:, stream_classes:, environment: nil, assigns_automatic_stream_class_id: nil, match: false)
       raise if parent
 
+      # match indicate if this model will be used to match another.
+      @match = match
       @parent = nil
       @assigns_automatic_stream_class_id = assigns_automatic_stream_class_id
+      @environment = BTEnvironmentClass.from_h(self, environment) if environment
       @stream_classes = stream_classes.collect.with_index do |m, i|
         if m[:id].nil? != (@assigns_automatic_stream_class_id.nil? || @assigns_automatic_stream_class_id)
           raise "Incoherence between trace::assigns_automatic_stream_class_id and stream_class[#{i}]::id"
@@ -89,6 +100,8 @@ module Babeltrace2Gen
     end
 
     def get_declarator(variable:, self_component:)
+      raise NotImplementedError, "':environment' keyword not supported in downstream model" if environment
+
       pr "#{variable} = bt_trace_class_create(#{self_component});"
       bt_set_conditionally(@assigns_automatic_stream_class_id) do |v|
         pr "bt_trace_class_set_assigns_automatic_stream_class_id(#{variable}, #{v});"
@@ -108,7 +121,12 @@ module Babeltrace2Gen
     include BTUtils
     include BTPrinter
     include BTLocator
+    include BTMatch
     extend BTFromH
+
+    BT_MATCH_ATTRS = %i[parent name packet_context_field_class event_common_context_field_class
+                        default_clock_class]
+
     attr_reader :packet_context_field_class, :event_common_context_field_class, :event_classes, :default_clock_class,
                 :id, :name, :get_getter
 
@@ -121,8 +139,6 @@ module Babeltrace2Gen
       @parent = parent
       @name = name
 
-      raise 'Two packet_context' if packet_context_field_class && packet_context
-
       # Should put assert to check for struct
       @packet_context_field_class = BTFieldClass.from_h(self, packet_context_field_class) if packet_context_field_class
 
@@ -135,7 +151,7 @@ module Babeltrace2Gen
       @assigns_automatic_event_class_id = assigns_automatic_event_class_id
       @event_classes = event_classes.collect do |ec|
         if ec[:id].nil? != (@assigns_automatic_event_class_id.nil? || @assigns_automatic_event_class_id.nil)
-          raise 'Incorect id scheme'
+          raise 'Incorrect id scheme'
         end
 
         BTEventClass.from_h(self, ec)
@@ -164,6 +180,10 @@ module Babeltrace2Gen
       end
 
       if @packet_context_field_class
+        # Support for packets required for packet_context_field_class
+        # We do not support create_packet neither packet_beginning_default_clock_snapshot (BT_FALSE) nor packet_end_default_clock_snapshot (BT_FALSE)
+        pr "bt_stream_class_set_supports_packets(#{variable}, BT_TRUE, BT_FALSE, BT_FALSE);"
+
         var_pc = "#{variable}_pc_fc"
         scope do
           pr "bt_field_class *#{var_pc};"
@@ -182,7 +202,7 @@ module Babeltrace2Gen
           pr "bt_field_class_put_ref(#{var_ecc});"
         end
       end
-      # Need to do is afert packet an devent_common_context because it can refer members to those
+      # Need to do is after common_context because it can refer members to those
       bt_set_conditionally(@assigns_automatic_event_class_id) do |v|
         pr "bt_stream_class_set_assigns_automatic_event_class_id(#{variable}, #{v});"
       end
@@ -203,7 +223,7 @@ module Babeltrace2Gen
       pr "bt_stream_class_put_ref(#{variable});"
     end
 
-    # The getters code generated from event_common_context_field_class do not include
+    # The getters code generated from event_common_context_field_class does 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
@@ -222,12 +242,24 @@ module Babeltrace2Gen
   class BTEventClass
     include BTPrinter
     include BTLocator
+    include BTMatch
     extend BTFromH
-    attr_reader :name, :specific_context_field_class, :payload_field_class
 
-    def initialize(parent:, name: nil, specific_context_field_class: nil, payload_field_class: nil, id: nil)
+    BT_MATCH_ATTRS = %i[parent name specific_context_field_class payload_field_class]
+
+    attr_reader :name, :specific_context_field_class, :payload_field_class, :set_id, :domain, :register
+
+    def initialize(parent:, name: nil, specific_context_field_class: nil, payload_field_class: nil, id: nil,
+                   set_id: nil, domain: nil, register: true)
+
+      @set_id = set_id
+      @domain = domain
+      @register = register
+
       @parent = parent
       @name = name
+      raise 'Name is mandatory for BTEventClass' if name.nil? && !rec_trace_class.match
+
       if specific_context_field_class
         @specific_context_field_class = BTFieldClass.from_h(self,
                                                             specific_context_field_class)
@@ -238,7 +270,7 @@ module Babeltrace2Gen
     end
 
     def get_declarator(trace_class:, variable:, stream_class:)
-      # Store the variable name for instrospection purpose (PATH)
+      # Store the variable name for introspection purposes (PATH)
       @variable = variable
       if @id
         pr "#{variable} = bt_event_class_create_with_id(#{stream_class}, #{@id});"
@@ -296,6 +328,15 @@ module Babeltrace2Gen
     end
 
     def get_getter(event:, arg_variables:)
+      if rec_trace_class.environment
+        trace = 'trace'
+        scope do
+          pr "const bt_stream *stream = bt_event_borrow_stream_const(#{event});"
+          pr "const bt_trace *#{trace} = bt_stream_borrow_trace_const(stream);"
+          rec_trace_class.environment.get_getter(trace: trace, arg_variables: arg_variables)
+        end
+      end
+
       if rec_stream_class.event_common_context_field_class
         field = "#{event}_cc_f"
         scope do
@@ -325,9 +366,12 @@ module Babeltrace2Gen
   class BTFieldClass
     include BTLocator
     include BTPrinter
+    include BTMatch
     using HashRefinements
 
-    attr_accessor :cast_type
+    BT_MATCH_ATTRS = %i[type cast_type cast_type_is_struct]
+
+    attr_accessor :cast_type_is_struct, :cast_type, :type
 
     def initialize(parent:)
       @parent = parent
@@ -335,7 +379,10 @@ module Babeltrace2Gen
 
     def self.from_h(parent, model)
       key = model.delete(:type)
-      raise "No type in #{model}" unless key
+      # /!\ Recursion
+      is_match_model = parent.rec_trace_class.match
+
+      raise "No type in #{model}" unless key || is_match_model
 
       h = {
         'bool' => BTFieldClass::Bool,
@@ -354,14 +401,22 @@ module Babeltrace2Gen
         'option_with_selector_field_bool' => BTFieldClass::Option::WithSelectorField::Bool,
         'option_with_selector_field_unsigned' => BTFieldClass::Option::WithSelectorField::IntegerUnsigned,
         'option_with_selector_field_signed' => BTFieldClass::Option::WithSelectorField::IntegerSigned,
-        'variant' => BTFieldClass::Variant
+        'variant' => BTFieldClass::Variant,
       }.freeze
 
-      raise "No #{key} in FIELD_CLASS_NAME_MAP" unless h.include?(key)
+      raise "No #{key} in FIELD_CLASS_NAME_MAP" unless h.include?(key) || is_match_model
 
       cast_type = model.delete(:cast_type)
-      fc = h[key].from_h(parent, model)
+      cast_type_is_struct = model.delete(:cast_type_is_struct)
+
+      fc = h.include?(key) ? h[key].from_h(parent, model) : BTFieldClass::Default.new(parent: parent)
+
+      # Since key (:type) can be a string or a regex, we store
+      # the type into the field to apply string.match?(regex)
+      # in place of comparing field objects.
+      fc.type = key
       fc.cast_type = cast_type if cast_type
+      fc.cast_type_is_struct = cast_type_is_struct if cast_type_is_struct
       fc
     end
 
@@ -395,11 +450,15 @@ 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
-      cast_func = @cast_type ? "(#{self.class.instance_variable_get(:@bt_type)})" : ''
-      pr "#{bt_func_get}(#{field}, #{variable});"
+      # We always explicitly cast to the proper bebeltrace type when sending messsages.
+      pr "#{bt_func_get}(#{field}, (#{self.class.instance_variable_get(:@bt_type)})#{variable});"
     end
   end
 
+  class BTFieldClass::Default < BTFieldClass
+    extend BTFromH
+  end
+
   class BTFieldClass::Bool < BTFieldClass
     extend BTFromH
 
@@ -525,6 +584,7 @@ module Babeltrace2Gen
 
   class BTFieldClass::String < BTFieldClass
     extend BTFromH
+    include BTUtils
 
     @bt_type = 'const char*'
     @bt_func = 'bt_field_string_%s_value'
@@ -532,6 +592,33 @@ module Babeltrace2Gen
     def get_declarator(trace_class:, variable:)
       pr "#{variable} = bt_field_class_string_create(#{trace_class});"
     end
+
+    def get_getter(field:, arg_variables:)
+      return super(field: field, arg_variables: arg_variables) unless @cast_type_is_struct
+
+      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 "memcpy(&#{variable}, #{bt_func_get}(#{field}), sizeof(#{variable}));"
+    end
+
+    def get_setter(field:, arg_variables:)
+      return super(field: field, arg_variables: arg_variables) unless @cast_type_is_struct
+
+      variable = bt_get_variable(arg_variables).name
+
+      pr "// Dump data to a temporal string."
+      pr "char *#{field}_temp = 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 "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\");"
+      pr "free(#{field}_temp);"
+    end
   end
 
   class BTFieldClass::Array < BTFieldClass
@@ -637,21 +724,32 @@ module Babeltrace2Gen
   end
 
   class BTMemberClass
+    include BTMatch
     include BTLocator
+
+    BT_MATCH_ATTRS = %i[name field_class]
+
     attr_reader :parent, :name, :field_class
 
-    def initialize(parent:, name:, field_class:)
+    def initialize(parent:, field_class:, name: nil)
       @parent = parent
-      @name = name
+      @name = name # Name can be nil in the matching callbacks
       @field_class = BTFieldClass.from_h(self, field_class)
     end
+
+    def bt_get_variable()
+      @field_class.bt_get_variable({})
+    end
   end
 
   class BTFieldClass::Structure < BTFieldClass
+    include BTMatchMembers
     extend BTFromH
 
     attr_reader :members
 
+    BT_MATCH_ATTRS = [:members]
+
     def initialize(parent:, members: [])
       @parent = parent
       @members = members.collect { |m| BTMemberClass.new(parent: self, **m) }
@@ -803,4 +901,87 @@ module Babeltrace2Gen
       end
     end
   end
+
+  class BTEnvironmentClass
+    include BTPrinter
+    include BTLocator
+    include BTMatchMembers
+    extend BTFromH
+    attr_reader :parent, :entries
+
+    BT_MATCH_ATTRS = [:entries]
+
+    def initialize(parent:, entries: [])
+      @parent = parent
+      @entries = entries.map { |entry| BTEntryClass.from_h(self, entry) }
+    end
+
+    def get_getter(trace:, arg_variables:)
+      scope do
+        @entries.each do |entry|
+          entry.get_getter(trace: trace, arg_variables: arg_variables)
+        end
+      end
+    end
+  end
+
+  class BTEntryClass
+    include BTPrinter
+    include BTMatch
+    using HashRefinements
+
+    BT_MATCH_ATTRS = %i[name type]
+
+    attr_accessor :name, :type
+
+    def initialize(parent:, name:, type:)
+      @parent = parent
+      @name = name
+      @type = type
+    end
+
+    def self.from_h(parent, model)
+      type = model.fetch(:type, nil)
+      is_match_model = parent.rec_trace_class.match
+
+      raise "No type in #{model}" unless type || is_match_model
+
+      h = { 'string' => BTEntryClass::String,
+            'integer_signed' => BTEntryClass::IntegerSigned }.freeze
+
+      raise "Type #{type} not supported" unless h.include?(type) || is_match_model
+
+      h.include?(type) ? h[type].from_h(parent, model) : BTEntryClass::Default.from_h(parent, model)
+    end
+
+    def get_getter(trace:, arg_variables:)
+      var_name = @name
+      arg_variables.fetch_append('outputs', bt_get_variable)
+      bt_func_get = self.class.instance_variable_get(:@bt_func)
+      pr "const bt_value *#{var_name}_value = bt_trace_borrow_environment_entry_value_by_name_const(#{trace}, \"#{var_name}\");"
+      pr "#{var_name} = #{bt_func_get}(#{var_name}_value);"
+    end
+
+    def bt_get_variable()
+      GeneratedArg.new(self.class.instance_variable_get(:@bt_type), @name)
+    end
+  end
+
+  class BTEntryClass::Default < BTEntryClass
+    extend BTFromH
+  end
+
+  class BTEntryClass::String < BTEntryClass
+    extend BTFromH
+
+    @bt_type = 'const char*'
+    @bt_func = 'bt_value_string_get'
+  end
+
+  class BTEntryClass::IntegerSigned < BTEntryClass
+    extend BTFromH
+
+    @bt_type = 'int64_t'
+    @bt_func = 'bt_value_integer_signed_get'
+  end
 end

data/lib/metababel/bt2_values_generator.rb

@@ -92,7 +92,7 @@ module Babeltrace2Gen
 
     def initialize(name, usr_default_value)
       bt_type = self.class.instance_variable_get(:@bt_type)
-      if !usr_default_value.nil? and !%w[BT_TRUE BT_FALSE].include? usr_default_value
+      if !usr_default_value.nil? && !%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
 
@@ -109,7 +109,7 @@ module Babeltrace2Gen
     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)
+      if !usr_default_value.nil? && !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}'."
       end
 
@@ -125,7 +125,7 @@ module Babeltrace2Gen
 
     def initialize(name, usr_default_value)
       bt_type = self.class.instance_variable_get(:@bt_type)
-      if !usr_default_value.nil? and (!usr_default_value.is_a? Integer or !usr_default_value.between?(0, 2**64 - 1))
+      if !usr_default_value.nil? && (!usr_default_value.is_a?(Integer) || !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
 

data/lib/metababel/version.rb

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

data/lib/metababel.rb

@@ -1,4 +1,4 @@
 require 'metababel/bt2_generator_utils'
-require 'metababel/bt2_stream_classes_generator'
+require 'metababel/bt2_trace_class_generator'
 require 'metababel/bt2_values_generator'
 require 'metababel/version'

data/template/component.c.erb

@@ -1,68 +1,34 @@
-#include "utarray.h"
-#include "uthash.h"
-#include <assert.h>
 #include <babeltrace2/babeltrace.h>
 #include <metababel/btx_component.h>
 // stdio needed because `params_definition` contain fprintf
+<% if params_definition %>
 #include <stdio.h>
+<% end %>
 
 void btx_populate_params(common_data_t *common_data) {
-  const bt_value *params = common_data->params;
-  btx_params_t *usr_params = common_data->btx_params;
-  (void)params;
-  (void)usr_params;
+  <% if params_definition %>
+  const bt_value *_params = common_data->params;
+  btx_params_t *_usr_params = common_data->btx_params;
   <%= params_definition %>
+  <% end %>
 }
 
-<% component_dispatchers.each do |e| %>
-
-typedef void btx_dispatch_<%= e.name_sanitized %>_f(
-    UT_array *callbacks, common_data_t *common_data,
-    <%= e.args.map{ |s| s.type }.join(", ") %>);
-
-static void btx_dispatch_<%= e.name_sanitized %>(
-    UT_array *callbacks, common_data_t *common_data,
-    <%= e.args.map{ |s| "#{s.type} #{s.name}" }.join(", ") %>) {
-
-  // 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, <%= e.args.map{ |s| s.name }.join(", ") %>);
-  }
-}
+<% static_callback_types.each do |e| %>
 
 void btx_register_callbacks_<%= e.name_sanitized %>(
-    void *btx_handle, <%= e.name_sanitized %>_callback_f *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);
-  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 = "<%= e.name %>";
-    s->dispatcher = (void *)&btx_dispatch_<%= e.name_sanitized %>;
-    utarray_new(s->callbacks, &ut_ptr_icd);
-    // 2. Register it
-    HASH_ADD_KEYPTR(hh, *name_to_dispatcher, s->name, strlen(s->name), s);
-    // 3. Add the callbacks to the array
-    utarray_push_back(s->callbacks, &callback);
-  } else {
-    assert(false && "Only one callbacks for <%= e.name_sanitized %>");
-  }
+    void *btx_handle, <%= e.name_sanitized %>_static_callback_f *callback) {
+  ((common_data_t *)btx_handle)->static_callbacks-><%= e.name_sanitized %> =
+      callback;
 }
 
 void btx_call_callbacks_<%= e.name_sanitized %>(
     common_data_t *common_data,
     <%= e.args.map{ |s| "#{s.type} #{s.name}" }.join(", ") %>) {
-  name_to_dispatcher_t *s = NULL;
-  HASH_FIND_STR(common_data->name_to_dispatcher, "<%= e.name %>", s);
 
-  if (s)
-    (*((btx_dispatch_<%= e.name_sanitized %>_f(*))(s->dispatcher)))(
-        s->callbacks, common_data, <%= e.args.map{ |s| s.name }.join(", ") %>);
+  <%= 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(", ") %>);
 }
 <% end %>