autoc 0.8 → 1.0

data/lib/autoc/collection/vector.rb

@@ -0,0 +1,295 @@
+require "autoc/collection"
+
+
+module AutoC
+  
+  
+=begin
+
+Vector is an ordered random access sequence container.
+
+The collection's C++ counterpart is +std::vector<>+ template class.
+
+== Generated C interface
+
+=== Collection management
+
+[cols="2*"]
+|===
+|*_void_* ~type~Copy(*_Type_* * +dst+, *_Type_* * +src+)
+|
+Create a new vector +dst+ filled with the contents of +src+.
+A copy operation is performed on every element in +src+.
+
+NOTE: Previous contents of +dst+ is overwritten.
+
+|*_void_* ~type~Ctor(*_Type_* * +self+, *_size_t_* +size+)
+|
+Create a new vector +self+ of size +size+.
+The elements are initialized with either supplied or generated default parameterless constructor.
+
+WARNING: +size+ must be greater than zero.
+
+NOTE: Previous contents of +self+ is overwritten.
+
+|*_void_* ~type~Dtor(*_Type_* * +self+)
+|
+Destroy vector +self+.
+Stored elements are destroyed as well by calling the respective destructors.
+
+|*_int_* ~type~Equal(*_Type_* * +lt+, *_Type_* * +rt+)
+|
+Return non-zero value if vectors +lt+ and +rt+ are considered equal by contents and zero value otherwise.
+
+|*_size_t_* ~type~Identify(*_Type_* * +self+)
+|
+Return hash code for vector +self+.
+|===
+
+=== Basic operations
+
+[cols=2*]
+|===
+|*_E_* ~type~Get(*_Type_* * +self+, *_size_t_* +index+)
+|
+Return a _copy_ of the element stored in +self+ at position +index+.
+
+WARNING: +index+ *must* be a valid index otherwise the behavior is undefined. See ~type~Within().
+
+|*_void_* ~type~Resize(*_Type_* * +self+, *_size_t_* +size+)
+|
+Set new size of vector +self+ to +size+.
+
+If new size is greater than the old one, extra elements are created with default parameterless constructors.
+If new size is smaller the the old one, excessive elements are destroyed.
+
+WARNING: +size+ *must* be greater than zero.
+
+|*_void_* ~type~Set(*_Type_* * +self+, *_size_t_* +index+, *_E_* +what+)
+|
+
+Store a _copy_ of the element +what+ in vector +self+ at position +index+ destroying previous contents.
+
+WARNING: +index+ *must* be a valid index otherwise the behavior is undefined. See ~type~Within().
+
+|*_size_t_* ~type~Size(*_Type_* * +self+)
+|
+Return number of elements stored in vector +self+.
+
+|*_void_* ~type~Sort(*_Type_* * +self+)
+|
+Perform a sorting operation on the contents of vector +self+ utilizing either generated of user supplied ordering functions.
+
+|*_int_* ~type~Within(*_Type_* * +self+, *_size_t_* +index+)
+|
+Return non-zero value if +index+ is a valid index and zero value otherwise.
+Valid index belongs to the range 0 ... ~type~Size()-1.
+|===
+
+=== Iteration
+
+[cols=2*]
+|===
+|*_void_* ~it~Ctor(*_IteratorType_* * +it+, *_Type_* * +self+)
+|
+Create a new forward iterator +it+ on vector +self+.
+
+NOTE: Previous contents of +it+ is overwritten.
+
+|*_void_* ~it~CtorEx(*_IteratorType_* * +it+, *_Type_* * +self+, *_int_* +forward+)
+|
+Create a new iterator +it+ on vector +self+.
+Non-zero value of +forward+ specifies a forward iterator, zero value specifies a backward iterator.
+
+NOTE: Previous contents of +it+ is overwritten.
+
+|*_int_* ~it~Move(*_IteratorType_* * +it+)
+|
+Advance iterator position of +it+ *and* return non-zero value if new position is valid and zero value otherwise.
+
+|*_E_* ~it~Get(*_IteratorType_* * +it+)
+|
+Return a _copy_ of current element pointed to by the iterator +it+.
+
+WARNING: current position *must* be valid otherwise the behavior is undefined. See ~it~Move().
+|===
+
+=end
+class Vector < Collection
+
+  def ctor(*args)
+    args.empty? ? super() : raise("#{self.class} provides no default constructor")
+  end
+  
+  def write_exported_types(stream)
+    stream << %$
+      /***
+      **** #{type}<#{element.type}> (#{self.class})
+      ***/
+    $ if public?
+    stream << %$
+      typedef struct #{type} #{type};
+      typedef struct #{it} #{it};
+      struct #{type} {
+        #{element.type}* values;
+        size_t element_count;
+      };
+      struct #{it} {
+        #{type}* vector;
+        int index;
+        int forward;
+      };
+    $
+  end
+  
+  def write_exported_declarations(stream, declare, define)
+    stream << %$
+      #{declare} void #{ctor}(#{type}*, size_t);
+      #{declare} void #{dtor}(#{type}*);
+      #{declare} void #{copy}(#{type}*, #{type}*);
+      #{declare} int #{equal}(#{type}*, #{type}*);
+      #{declare} void #{resize}(#{type}*, size_t);
+      #{declare} size_t #{identify}(#{type}*);
+      #{define} size_t #{size}(#{type}* self) {
+        #{assert}(self);
+        return self->element_count;
+      }
+      #{define} int #{within}(#{type}* self, size_t index) {
+        #{assert}(self);
+        return index < #{size}(self);
+      }
+      #{define} #{element.type} #{get}(#{type}* self, size_t index) {
+        #{element.type} result;
+        #{assert}(self);
+        #{assert}(#{within}(self, index));
+        #{element.copy("result", "self->values[index]")};
+        return result;
+      }
+      #{define} void #{set}(#{type}* self, size_t index, #{element.type} value) {
+        #{assert}(self);
+        #{assert}(#{within}(self, index));
+        #{element.dtor("self->values[index]")};
+        #{element.copy("self->values[index]", "value")};
+      }
+      #{declare} void #{sort}(#{type}*);
+      #define #{itCtor}(self, type) #{itCtorEx}(self, type, 1)
+      #{define} void #{itCtorEx}(#{it}* self, #{type}* vector, int forward) {
+        #{assert}(self);
+        #{assert}(vector);
+        self->vector = vector;
+        self->forward = forward;
+        self->index = forward ? -1 : #{size}(vector);
+      }
+      #{define} int #{itMove}(#{it}* self) {
+        #{assert}(self);
+        if(self->forward) ++self->index; else --self->index;
+        return #{within}(self->vector, self->index);
+      }
+      #{define} #{element.type} #{itGet}(#{it}* self) {
+        #{assert}(self);
+        return #{get}(self->vector, self->index);
+      }
+    $
+  end
+  
+  def write_implementations(stream, define)
+    stream << %$
+      static void #{allocate}(#{type}* self, size_t element_count) {
+        #{assert}(self);
+        #{assert}(element_count > 0);
+        self->element_count = element_count;
+        self->values = (#{element.type}*)#{malloc}(element_count*sizeof(#{element.type})); #{assert}(self->values);
+      }
+      #{define} void #{ctor}(#{type}* self, size_t element_count) {
+        size_t index;
+        #{assert}(self);
+        #{allocate}(self, element_count);
+        for(index = 0; index < #{size}(self); ++index) {
+          #{element.ctor("self->values[index]")};
+        }
+      }
+      #{define} void #{dtor}(#{type}* self) {
+        size_t index;
+        #{assert}(self);
+        for(index = 0; index < #{size}(self); ++index) {
+          #{element.dtor("self->values[index]")};
+        }
+        #{free}(self->values);
+      }
+      #{define} void #{copy}(#{type}* dst, #{type}* src) {
+        size_t index, size;
+        #{assert}(src);
+        #{assert}(dst);
+        #{allocate}(dst, size = #{size}(src));
+        for(index = 0; index < size; ++index) {
+          #{element.copy("dst->values[index]", "src->values[index]")};
+        }
+      }
+      #{define} int #{equal}(#{type}* lt, #{type}* rt) {
+        size_t index, size;
+        #{assert}(lt);
+        #{assert}(rt);
+        if(#{size}(lt) == (size = #{size}(rt))) {
+          for(index = 0; index < size; ++index) {
+            if(!#{element.equal("lt->values[index]", "rt->values[index]")}) return 0;
+          }
+          return 1;
+        } else
+          return 0;
+      }
+      #{define} void #{resize}(#{type}* self, size_t new_element_count) {
+        size_t index, element_count, from, to;
+        #{assert}(self);
+        if((element_count = #{size}(self)) != new_element_count) {
+          #{element.type}* values = (#{element.type}*)#{malloc}(new_element_count*sizeof(#{element.type})); #{assert}(values);
+          from = AUTOC_MIN(element_count, new_element_count);
+          to = AUTOC_MAX(element_count, new_element_count);
+          for(index = 0; index < from; ++index) {
+            values[index] = self->values[index];
+          }
+          if(element_count > new_element_count) {
+            for(index = from; index < to; ++index) {
+              #{element.dtor("self->values[index]")};
+            }
+          } else {
+            for(index = from; index < to; ++index) {
+              #{element.ctor("values[index]")};
+            }
+          }
+          #{free}(self->values);
+          self->values = values;
+          self->element_count = new_element_count;
+        }
+      }
+      #{define} size_t #{identify}(#{type}* self) {
+        size_t index, result = 0;
+        #{assert}(self);
+        for(index = 0; index < self->element_count; ++index) {
+          result ^= #{element.identify("self->values[index]")};
+          result = AUTOC_RCYCLE(result);
+        }
+        return result;
+      }
+      static int #{comparator}(void* lp_, void* rp_) {
+        #{element.type}* lp = (#{element.type}*)lp_;
+        #{element.type}* rp = (#{element.type}*)rp_;
+        if(#{element.equal("*lp", "*rp")}) {
+          return 0;
+        } else if(#{element.less("*lp", "*rp")}) {
+          return -1;
+        } else {
+          return +1;
+        }
+      }
+      #{define} void #{sort}(#{type}* self) {
+        typedef int (*F)(const void*, const void*);
+        #{assert}(self);
+        qsort(self->values, #{size}(self), sizeof(#{element.type}), (F)#{comparator});
+      }
+    $
+  end
+  
+end # Vector
+
+
+end # AutoC

data/lib/autoc/type.rb

@@ -0,0 +1,198 @@
+require "autoc/code"
+
+
+module AutoC
+  
+
+class Type < Code
+  
+  # @private
+  CommonCode = Class.new(Code) do
+    def write_intf(stream)
+      stream << %$
+        #ifndef AUTOC_INLINE
+          #ifdef _MSC_VER
+            #define AUTOC_INLINE __inline
+          #elif __STDC_VERSION__ >= 199901L
+            #define AUTOC_INLINE inline AUTOC_STATIC
+          #else
+            #define AUTOC_INLINE AUTOC_STATIC
+          #endif
+        #endif
+        #ifndef AUTOC_EXTERN
+          #ifdef __cplusplus
+            #define AUTOC_EXTERN extern "C"
+          #else
+            #define AUTOC_EXTERN extern
+          #endif
+        #endif
+        #ifndef AUTOC_STATIC
+          #ifdef _MSC_VER
+            #define AUTOC_STATIC __pragma(warning(suppress:4100)) static
+          #elif defined(__GNUC__)
+            #define AUTOC_STATIC __attribute__((__used__)) static
+          #else
+            #define AUTOC_STATIC static
+          #endif
+        #endif
+        #include <stddef.h>
+        #include <stdlib.h>
+        #include <assert.h>
+      $
+    end
+    def write_decls(stream)
+      stream << %$
+        #include <limits.h>
+        #define AUTOC_MIN(a,b) ((a) > (b) ? (b) : (a))
+        #define AUTOC_MAX(a,b) ((a) > (b) ? (a) : (b))
+        #define AUTOC_RCYCLE(x) (((x) << 1) | ((x) >> (sizeof(x)*CHAR_BIT - 1))) /* NOTE : valid for unsigned types only */
+      $
+    end
+  end.new
+
+  attr_reader :type
+  
+  def entities; [CommonCode] end
+
+  def initialize(type, visibility = :public)
+    @type = type.to_s
+    @visibility = [:public, :private, :static].include?(visibility) ? visibility : raise("unsupported visibility")
+  end
+  
+  def method_missing(method, *args)
+    str = method.to_s
+    func = @type + str[0,1].capitalize + str[1..-1] # Ruby 1.8 compatible
+    if args.empty?
+      func # Emit bare function name
+    elsif args.size == 1 && args.first == nil
+      func + "()" # Use sole nil argument to emit function call with no arguments
+    else
+      func + "(" + args.join(", ") + ")" # Emit normal function call with supplied arguments
+    end
+  end
+  
+  def write_intf(stream)
+    case @visibility
+      when :public
+        write_exported_types(stream)
+        write_exported_declarations(stream, extern, inline)
+    end
+  end
+  
+  def write_decls(stream)
+    case @visibility
+      when :private
+        write_exported_types(stream)
+        write_exported_declarations(stream, extern, inline)
+      when :static
+        write_exported_types(stream)
+        write_exported_declarations(stream, static, inline)
+    end
+  end
+  
+  def write_defs(stream)
+    case @visibility
+      when :public, :private
+        write_implementations(stream, nil)
+      when :static
+        write_implementations(stream, static)
+    end
+  end
+  
+  def write_exported_types(stream) end
+  
+  def write_exported_declarations(stream, declare, define) end
+  
+  def write_implementations(stream, define) end
+  
+  def extern; "AUTOC_EXTERN" end
+  
+  def inline; "AUTOC_INLINE" end
+  
+  def static; "AUTOC_STATIC" end
+  
+  def assert; "assert" end
+  
+  def malloc; "malloc" end
+  
+  def calloc; "calloc" end
+  
+  def free; "free" end
+  
+  def abort; "abort" end
+  
+  protected
+  
+  def public?; @visibility == :public end
+    
+  def private?; @visibility == :private end
+  
+  def static?; @visibility == :static end
+
+end # Type
+
+
+class UserDefinedType < Type
+  
+  # @private  
+  class PublicDeclaration < Code
+    def entities; super + [Type::CommonCode] end
+    def initialize(forward) @forward = forward.to_s end
+    def hash; @forward.hash end
+    def eql?(other) self.class == other.class && @forward == other.instance_variable_get(:@forward) end
+    def write_intf(stream)
+      stream << "\n"
+      stream << @forward
+      stream << "\n"
+    end
+  end # PublicDeclaration
+
+  def entities; super + @deps end
+  
+  def initialize(opt)
+    @deps = []
+    v = :public
+    if [Symbol, String].include?(opt.class)
+      t = opt
+    elsif opt.is_a?(Hash)
+      t = opt[:type].nil? ? raise("type is not specified") : opt[:type]
+      [:ctor, :dtor, :copy, :equal, :less, :identify].each do |key|
+        instance_variable_set("@#{key}".to_sym, opt[key].to_s) unless opt[key].nil?
+      end
+      @deps << PublicDeclaration.new(opt[:forward]) unless opt[:forward].nil?
+      optv = opt[:visibility]
+      v = optv.nil? ? :public : optv
+    else
+      raise "failed to decode the argument"
+    end
+    super(t, v)
+  end
+  
+  def ctor(obj)
+    @ctor.nil? ? "(#{obj} = 0)" : "#{@ctor}(#{obj})"
+  end
+  
+  def dtor(obj)
+    @dtor.nil? ? nil : "#{@dtor}(#{obj})"
+  end
+  
+  def copy(dst, src)
+    @copy.nil? ? "(#{dst} = #{src})" : "#{@copy}(#{dst}, #{src})"
+  end
+  
+  def equal(lt, rt)
+    @equal.nil? ? "(#{lt} == #{rt})" : "#{@equal}(#{lt}, #{rt})"
+  end
+  
+  def less(lt, rt)
+    @less.nil? ? "(#{lt} < #{rt})" : "#{@less}(#{lt}, #{rt})"
+  end
+  
+  def identify(obj)
+    @identify.nil? ? "(size_t)(#{obj})" : "#{@identify}(#{obj})"
+  end
+  
+end # UserDefinedType
+
+
+end # AutoC