autoc 1.4 → 2.0.0

data/lib/autoc/cstring.rb

@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+
+require 'autoc/ranges'
+require 'autoc/sequential'
+require 'autoc/association'
+
+
+module AutoC
+
+
+  # Value type string wrapper of the plain C string
+  class CString < Association
+
+    include STD
+
+    include Sequential
+
+    def default_constructible? = false
+
+    def range = @range ||= Range.new(self, visibility: visibility, parallel: @parallel)
+
+    def initialize(type = :CString, char = :char, parallel: nil, **kws)
+      super(type, char, :size_t, **kws)
+      dependencies << STRING_H
+      @parallel = parallel
+    end
+
+    def rvalue = @rv ||= Value.new(self)
+  
+    def lvalue = @lv ||= Value.new(self, reference: true)
+  
+    def const_rvalue = @crv ||= Value.new(self, constant: true)
+  
+    def const_lvalue = @clv ||= Value.new(self, reference: true, constant: true)
+
+    def render_interface(stream)
+      if public?
+        stream << %{
+          /**
+            #{defgroup}
+
+            @brief Value type wrapper of the plain C string
+
+            This type represents a (paper thin) wrapper around the plain C string (char *) with proper value semantics.
+
+            @since 2.0
+          */
+        }
+      else
+        stream << PRIVATE
+      end
+      stream << %{
+        typedef #{element.lvalue} #{signature};
+      }
+    end
+
+    def storage(target) = target # Return C pointer to contiguous storage
+
+    def render_forward_declarations(stream)
+      stream << %{
+        #include <stdio.h>
+        #include <malloc.h>
+        #include <stdarg.h>
+        /* overridable internal buffer size (in chars, not bytes) for *sprintf() operations */
+        #ifndef AUTOC_BUFFER_SIZE
+          #define AUTOC_BUFFER_SIZE 1024
+        #endif
+      }
+      super
+    end
+
+    def type_tag = "#{signature}<#{element}>"
+
+  private
+
+    def configure
+      super
+      method(:void, :create, { target: lvalue, source: const_rvalue }, instance: :custom_create).configure do
+        header %{
+          @brief Create string
+
+          @param[out] target string to be created
+          @param[in]  source string to be copied
+
+          This function creates & initializes a new string by making an independent of the source string.
+          This specifically means that the supplied source string may be any C string, either const or mutable, including string literal.
+
+          Previous contents of `*target` is overwritten.
+
+          Once constructed, the string is to be destroyed with @ref #{destroy}.
+
+          @since 2.0
+        }
+        inline_code %{
+          size_t size;
+          assert(target);
+          assert(source);
+          size = strlen(source);
+          *target = #{memory.allocate(element, 'size+1', atomic: true)}; assert(*target);
+          memcpy(*target, source, size*sizeof(#{element}));
+          (*target)[size] = '\\0';
+        }
+      end
+      method(:int, :create_format, { target: lvalue, format: const_rvalue }, variadic: true ).configure do
+        code %{
+          int r;
+          va_list args;
+          #if defined(HAVE_VSNPRINTF) || __STDC_VERSION__ >= 199901L || __cplusplus > 199711L || (defined(_MSC_VER) && _MSC_VER >= 1900) || defined(__POCC__)
+            va_start(args, format);
+            r = vsnprintf(NULL, 0, format, args);
+            va_end(args);
+            if(r < 0) return 0;
+            *target = #{memory.allocate(element, 'r+1', atomic: true)}; assert(*target);
+            va_start(args, format);
+            r = vsnprintf(*target, r+1, format, args);
+            va_end(args);
+            return r >= 0;
+          #else
+            #if defined(_MSC_VER)
+              #pragma message("WARNING: this code employs bare sprintf() with preallocated temporary buffer of AUTOC_BUFFER_SIZE chars; expect execution bail outs upon exceeding this limit")
+            #else
+              #warning("this code employs bare sprintf() with preallocated temporary buffer of AUTOC_BUFFER_SIZE chars; expect execution bail outs upon exceeding this limit")
+            #endif
+            va_start(args, format);
+            #{element.lvalue} t = #{memory.allocate(element, :AUTOC_BUFFER_SIZE, atomic: true)}; assert(t);
+            r = vsprintf(t, format, args);
+            if(r >= 0) {
+              if(r > AUTOC_BUFFER_SIZE-1) {
+                /*
+                  the output spilled out of the preallocated buffer -
+                  perfer to bail out right away rather than to get likely heap corruption
+                */
+                abort();
+              }
+              /* prefer precision over performance and make a copy instead of returning a (possibly excessive) buffer */
+              #{default_create.(target, :t)};
+            }
+            /* FIXME handle the case of simultaneous (r < 0 && buffer overrun) */
+            #{memory.free(:t)};
+            va_end(args);
+            return r >= 0;
+          #endif
+        }
+        header %{
+          @brief Create formatted string
+
+          @param[out] target string to be created
+          @param[in] format format template
+          @param[in] ... format parameters
+
+          @result non-zero value on successful construction and zero value otherwise
+
+          This function employs a standard C function from the s*printf() family to create new formatted string.
+
+          @note No `*target` is modified on function failure.
+
+          @since 2.0
+        }
+      end
+      destroy.configure do
+        inline_code %{
+          assert(target);
+          #{memory.free('*target')};
+        }
+      end
+      copy.configure do
+        dependencies << custom_create
+        inline_code %{
+          #{custom_create.(*parameters)};
+        }
+      end
+      get.configure do
+        dependencies << check
+        inline_code %{
+          assert(target);
+          assert(#{check.(target, index)});
+          return target[index];
+        }
+      end
+      set.configure do
+        dependencies << check
+        inline_code %{
+          assert(target);
+          assert(#{check.(target, index)});
+          target[index] = value;
+        }
+      end
+      view.configure do
+        dependencies << check
+        inline_code %{
+          assert(target);
+          assert(#{check.(target, index)});
+          return &target[index];
+        }
+      end
+      equal.configure do
+        inline_code %{
+          assert(left);
+          assert(right);
+          return strcmp(left, right) == 0;
+        }
+      end
+      compare.configure do
+        inline_code %{
+          assert(left);
+          assert(right);
+          return strcmp(left, right);
+        }
+      end
+      hash_code.configure do
+        code %{
+          /* djb2 algorithm: http://www.cse.yorku.ca/~oz/hash.html */
+          size_t c;
+          size_t hash;
+          #{element.lvalue} s;
+          assert(target);
+          hash = 5381;
+          s = target;
+          while((c = *s++)) hash = hash*33 ^ c;
+          return hash;
+        }
+      end
+      contains.configure do
+        inline_code %{
+          assert(target);
+          return strchr(target, value) != NULL;
+        }
+      end
+      find_first.configure do
+        inline_code %{
+          assert(target);
+          return strchr(target, value);
+        }
+      end
+      check.configure do
+        dependencies << size
+        inline_code %{
+          assert(target);
+          return index < #{size.(target)};
+        }
+      end
+      empty.configure do
+        inline_code %{
+          assert(target);
+          return *target == '\\0';
+        }
+      end
+      size.configure do
+        inline_code %{
+          assert(target);
+          return strlen(target);
+        }
+      end
+    end
+
+  end # CString
+
+
+  CString::Range = ContiguousRange # Range
+
+
+end

data/lib/autoc/function.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+
+require 'autoc/type'
+require 'autoc/module'
+require 'autoc/primitive'
+
+
+module AutoC
+
+
+  # @private
+  class Value
+
+    attr_reader :type
+  
+    def to_type = type
+  
+    def to_value = self
+  
+    def constant? = @constant == true
+  
+    def reference? = @reference == true
+  
+    def initialize(type, constant: false, reference: false)
+      @type = type
+      @constant = constant
+      @reference = reference
+    end
+  
+    def to_s = signature
+
+    def signature
+      _ = reference? ? "#{type.signature}*" : type.signature
+      constant? ? "const #{_}" : _
+    end
+  
+    def call(value)
+      value = value.to_s
+      if reference?
+        # Manually collapse references &*xyz -> xyz for the sake of source code readability
+        value[0] =='*' ? value[1..-1] : "&#{value}"
+      else
+        value
+      end
+    end
+  end # Value
+  
+  
+  # @private
+  # Function parameter
+  class Parameter
+  
+    attr_reader :value
+  
+    attr_reader :name
+  
+    def initialize(value, name)
+      @value = value.to_value
+      @name = name.to_sym
+    end
+  
+    def to_s = name.to_s
+
+    def to_value_argument = value.reference? ? "*#{name}" : name
+  
+    def signature = value.signature
+  
+    def declaration = '%s %s' % [signature, name]
+  
+  end # Parameter
+  
+  
+  # Standalone C side function
+  # The generated function is meant to be the C89-compliant
+  # NOTE: This function does not track parameter and result types as its dependencies
+  # This can be done manually by appending to #dependencies property with <<
+  class Function
+  
+    include Entity
+    
+    attr_reader :name
+  
+    attr_reader :result
+  
+    attr_reader :parameters
+  
+    attr_reader :visibility
+
+    attr_writer :inline
+
+    def initialize(result, name, parameters, inline: false, visibility: :public, constraint: true, variadic: false, abstract: false)
+      @name = name.to_s
+      @result = result
+      @inline = inline
+      @visibility = visibility
+      @constraint = constraint
+      @abstract = abstract
+      @variadic = variadic
+      @parameters = Parameters.new(self)
+      if parameters.is_a?(Hash)
+        parameters.each do |name, descriptor|
+          x = Parameter.new(descriptor, name)
+          @parameters[x.name] = x
+        end
+      else
+        i = -1
+        parameters.each do |descriptor|
+          x = Parameter.new(descriptor, "_#{i+=1}")
+          @parameters[x.name] = x
+        end
+      end
+    end
+  
+    def inline_code(code)
+      @inline = true
+      code(code)
+    end
+  
+    def external_code(code)
+      @inline = false
+      code(code)
+    end
+  
+    def to_s = name
+
+    def header(header) = @header = header
+  
+    def code(code) = @code = code
+  
+    def inspect = "#{prototype} <#{self.class}>"
+  
+    def inline? = @inline == true
+  
+    def public? = @visibility == :public
+
+    def abstract? = @abstract == true
+  
+    def variadic? = @variadic == true
+
+    def live? = (@constraint.is_a?(Proc) ? @constraint.() : @constraint) == true
+    
+    def signature = '%s(%s)' % [result.signature, (parameters.to_a.collect(&:signature) << (variadic? ? '...' : nil)).compact.join(',')]
+  
+    def prototype = '%s %s(%s)' % [result.signature, name, (parameters.to_a.collect(&:declaration) << (variadic? ? '...' : nil)).compact.join(',')]
+  
+    def definition = '%s {%s}' % [prototype, @code]
+  
+    def parameter(name) = @values[name]
+
+    def call(*arguments)
+      xs = []
+      ps = parameters.to_a
+      (0...arguments.size).each do |i|
+        a = arguments[i]
+        v = a.is_a?(Parameter) ? a.to_value_argument : a
+        xs << (i < ps.size ? ps[i].value.(v) : v)
+      end
+      '%s(%s)' % [name, xs.join(',')]
+    end
+  
+    def configure(&block)
+      instance_eval(&block)
+      self
+    end
+    
+    # This allows to call other functions with this function's individual parameters as arguments
+    # A call to unknown method results in the method's name being emitted
+    def method_missing(meth, *args) = parameters.has_key?(meth) ? parameters[meth] : meth
+
+  private
+
+    # On function inlining in C: http://www.greenend.org.uk/rjk/tech/inline.html
+
+    # static inline seems to be THE most portable way without resorting to preprocessor
+    # but consider the possible code bloat it incurs
+
+    def render_declaration_specifier(stream)
+      # The inline specifier is not a part of C89 yet descent compilers do inlining at will
+      # given the function definition is available at the function call
+      stream << 'static ' if inline?
+    end
+
+    # Render the commentary block preceding the function declaration, both inline or external
+    def render_function_header(stream)
+      stream << %{
+        /* #{@header} */
+      } unless @header.nil?
+    end
+
+    # Render full function declaration statement including the commentary block
+    # For inline functions this also renders a function body effectively making this also a function definition
+    # The declaration comes into either public interface of forward declaration block depending on the function's visibility status
+    def render_function_declaration(stream)
+      render_function_header(stream)
+      render_declaration_specifier(stream)
+      if inline?
+        render_function_definition(stream)
+      else
+        stream << prototype << ';'
+      end
+    end
+
+    # Render function definition, both inline or extern
+    # This code never gets into public interface
+    def render_function_definition(stream)
+      unless abstract?
+        raise("missing function definition for #{name}()") if @code.nil?
+        stream << definition
+      end
+    end
+
+    # Render function's public interface
+    # Only public functions are rendered
+    def render_interface(stream)
+      render_function_declaration(stream) if live? && public?
+    end
+
+    # Render function's interface for non-public functions which should not appear in the public interface
+    def render_forward_declarations(stream)
+      render_function_declaration(stream) if live? && !public?
+    end
+
+    # Render non-inline function definition regardless of function's visibility status
+    def render_implementation(stream)
+      render_function_definition(stream) if live? && !inline?
+    end
+
+  end # Function
+
+
+  # @private
+  # Named parameter list for the function
+  class Function::Parameters < ::Hash
+    def initialize(function)
+      @function = function
+      super()
+    end
+    def to_a = values
+    def [](name)
+      raise "unknown parameter #{name} in function #{@function}()" unless has_key?(name)
+      super
+    end
+  end # Parameters
+
+
+end