autoc 1.1 → 1.2

data/doc/top-level-namespace.html

@@ -6,7 +6,7 @@
 <title>
   Top Level Namespace
   
-    &mdash; Documentation by YARD 0.8.7.4
+    &mdash; Documentation by YARD 0.8.7.6
   
 </title>
 
@@ -103,9 +103,9 @@
 </div>
 
     <div id="footer">
-  Generated on Mon Jun  9 18:28:02 2014 by
+  Generated on Sat Nov 22 16:58:03 2014 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.8.7.4 (ruby-2.0.0).
+  0.8.7.6 (ruby-2.1.5).
 </div>
 
   </body>

data/lib/autoc.rb

@@ -2,8 +2,8 @@
 
 *AutoC* is a host of Ruby modules related to automatic C source code generation.
 
-. {AutoC::Code} - generic C multi-source module generator.
-. {AutoC::Collection} - strongly-typed data structure generators similar
+. {AutoC::Code} generic C multi-source module generator.
+. {AutoC::Collection} strongly-typed data structure generators similar
 to the C++ STL container classes.
 
 == Versioning scheme
@@ -21,7 +21,7 @@ Should the major incompatible changes be made, the new release 2.0 will be intro
 
 =end
 module AutoC
-  VERSION = "1.1"
+  VERSION = "1.2"
 end # AutoC
 
 

data/lib/autoc/code.rb

@@ -17,6 +17,15 @@ module AutoC
 # end
 
 
+# Convert obj to string and return it.
+# Throw NameError is resulting string is not a valid C identifier.
+def self.c_id(obj)
+  obj = obj.to_s
+  #raise NameError.new("#{obj} is not a valid C identifier", obj) if (/^[_a-zA-Z]\w*$/ =~ obj).nil?
+  obj
+end
+
+
 # TODO min/max Fixnums
 module Priority
   DEFAULT = 0
@@ -70,10 +79,7 @@ class Module
   end
   
   def <<(obj)
-    unless @entities.include?(obj)
-      @entities << obj
-      obj.entities.each {|e| self << e}
-    end
+    obj.entities.each {|e| self << e} unless @entities.add?(obj).nil?
     self
   end
 
@@ -95,7 +101,7 @@ class Module
     (1..source_count).each {|i| @sources << new_source(i)}
     @main_source = @sources.first
     @smallest_source = @main_source
-    # It appears that computing the size of a source might be a fairly expensive operation so do it only when neccessary
+    # It appears that computing the size of a source might be a fairly expensive operation so do it only when necessary
     refresh_smallest_source = source_count > 1
     @entities.each do |e|
       @header << e

data/lib/autoc/collection.rb

@@ -7,17 +7,23 @@ module AutoC
 
 =begin
 
+== Implemented types
+
+- {AutoC::UserDefinedType} user-defined custom type
+
+- {AutoC::Reference} counted reference type
+
 == Implemented collections
 
-- {AutoC::Vector} a fixed-sized array
+- {AutoC::Vector} resizable array
 
-- {AutoC::List} a single linked list
+- {AutoC::List} single linked list
 
-- {AutoC::Queue} a double linked list
+- {AutoC::Queue} double linked list
 
-- {AutoC::HashSet} a hash-based set
+- {AutoC::HashSet} hash-based set
 
-- {AutoC::HashMap} a hash-based map
+- {AutoC::HashMap} hash-based map
 
 == Ruby side operation
 
@@ -29,13 +35,15 @@ AutoC::Module.generate!(:Test) do |c|
   c << AutoC::List.new(:IntList, :int)
 end
 ----
-In the above example a C module Test represented by the C header +test_auto.h+ and the C source +test_auto.c+ are generated.
+In the above example a C module Test represented by the C header +test_auto.h+ and the C source +test_auto.c+ is generated.
 The C++ counterpart of the generated collection is +std::forward_list<int>+.
 
 == C interface
 
 === Element types: values, references
 
+Collections may contain both value and reference types, including other collections.
+
 === Thread safety
 
 WARNING: In its current state the implemented collections are *not* thread-safe.
@@ -63,72 +71,70 @@ while(MyVectorItMove(&it)) {
 WARNING: the collection being iterated *must not* be modified in any way otherwise the iterator behavior is undefined.
 =end
 class Collection < Type
+
+  attr_reader :element, :it_ref
   
-  def self.coerce(type)
-    type.is_a?(Type) ? type : UserDefinedType.new(type)
-  end
+  def hash; super ^ element.hash end
   
-  attr_reader :element
+  def ==(other) super && element == other.element end
   
-  def entities; super + [element] end
+  alias :eql? :==
+
+  def entities; super << element end
   
   def initialize(type_name, element_type, visibility = :public)
     super(type_name, visibility)
-    @element = Collection.coerce(element_type)
+    @it_ref = "#{it}*"
+    @element = Type.coerce(element_type)
+    @ctor = define_function(:ctor, Function::Signature.new([type_ref^:self]))
+    @dtor = define_function(:dtor, Function::Signature.new([type_ref^:self]))
+    @copy = define_function(:copy, Function::Signature.new([type_ref^:dst, type_ref^:src]))
+    @equal = define_function(:equal, Function::Signature.new([type_ref^:lt, type_ref^:rt], :int))
+    @identify = define_function(:identify, Function::Signature.new([type_ref^:self], :size_t))
+    @less = define_function(:less, Function::Signature.new([type_ref^:lt, type_ref^:rt], :int))
+    element_type_check(element)
   end
   
-  def ctor(*args)
-    if args.empty?
-      super()
-    else
-      check_args(args, 1)
-      obj = args.first
-      super() + "(&#{obj})"
-    end
-  end
-  
-  def dtor(*args)
-    if args.empty?
-      super()
-    else
-      check_args(args, 1)
-      obj = args.first
-      super() + "(&#{obj})"
-    end
+  def write_intf_decls(stream, declare, define)
+    # Emit default redirection macros
+    # Unlike other special methods the constructors may have extra arguments
+    # Assume the constructor's first parameter is always a target
+    ctor_ex = ctor.parameters.names[1..-1]
+    ctor_lt = ["self"].concat(ctor_ex).join(',')
+    ctor_rt = ["&self"].concat(ctor_ex).join(',')
+    stream << %$
+      #define _#{ctor}(#{ctor_lt}) #{ctor}(#{ctor_rt})
+      #define _#{dtor}(self) #{dtor}(&self)
+      #define _#{identify}(self) #{identify}(&self)
+      #define _#{copy}(dst,src) #{copy}(&dst,&src)
+      #define _#{equal}(lt,rt) #{equal}(&lt,&rt)
+      #define _#{less}(lt,rt) #{less}(&lt,&rt)
+    $
   end
+
+  def copyable?; super && element.copyable? end
   
-  def copy(*args)
-    if args.empty?
-      super()
-    else
-      check_args(args, 2)
-      dst, src = args
-      super() + "(&#{dst}, &#{src})"
-    end
-  end
+  def comparable?; super && element.comparable? end
   
-  def equal(*args)
-    if args.empty?
-      super()
-    else
-      check_args(args, 2)
-      lt, rt = args
-      super() + "(&#{lt}, &#{rt})"
-    end
-  end
+  def hashable?; super && element.hashable? end
   
-  def less(*args)
-    args.empty? ? super() : raise("#{self.class} provides no ordering functionality")
-  end
+  private
   
-  def identify(*args)
-    args.empty? ? super() : raise("#{self.class} provides no hashing functionality")
+  def element_type_check(obj)
+    raise "type #{obj.type} (#{obj}) must be destructible" unless obj.destructible?
+    raise "type #{obj.type} (#{obj}) must be copyable" unless obj.copyable?
+    raise "type #{obj.type} (#{obj}) must be comparable" unless obj.comparable?
+    raise "type #{obj.type} (#{obj}) must be hashable" unless obj.hashable?
   end
   
-  private
+  # @private
+  class Redirector < Function
+    # Redirect call to the specific macro
+    def call(*params) "_#{name}(" + params.join(',') + ')' end
+  end # Redirector
   
-  def check_args(args, nargs)
-    raise "expected exactly #{nargs} argument(s)" unless args.size == nargs
+  def define_function(name, signature)
+    Redirector.new(method_missing(name), signature)
   end
   
 end # Collection

data/lib/autoc/collection/hash_map.rb

@@ -133,16 +133,35 @@ class HashMap < Collection
 
   alias :value :element
   
-  def entities; super + [key] end
+  def hash; super ^ key.hash end
+  
+  def ==(other) super && key == other.key end
+  
+  alias :eql? :==
+
+  def entities; super << key end
   
   def initialize(type, key_type, value_type, visibility = :public)
     super(type, value_type, visibility)
-    @key = Collection.coerce(key_type)
+    @key = Type.coerce(key_type)
     @entry = UserDefinedType.new(:type => entry, :identify => entryIdentify, :equal => entryEqual, :copy => entryCopy, :dtor => entryDtor)
     @set = HashSet.new(set, @entry, :static)
+    @capability.subtract [:orderable]
+    element_type_check(value)
+    key_type_check(key)
   end
   
-  def write_exported_types(stream)
+  def copyable?; super && key.copyable? end
+  
+  def comparable?; super && key.comparable? end
+  
+  def hashable?
+    # NOTE : must be in sync with Type#hashable?
+    # No super call here because the map's element need not to be hashable,- only the key must be
+    @capability.include?(:hashable) && comparable? && key.hashable?
+  end
+  
+  def write_intf_types(stream)
     stream << %$
       /***
       **** #{type}<#{key.type},#{value.type}> (#{self.class})
@@ -156,7 +175,7 @@ class HashMap < Collection
         unsigned flags;
       };
     $
-    @set.write_exported_types(stream)
+    @set.write_intf_types(stream)
     stream << %$
       typedef struct #{type} #{type};
       typedef struct #{it} #{it};
@@ -169,42 +188,43 @@ class HashMap < Collection
     $
   end
 
-  def write_exported_declarations(stream, declare, define)
+  def write_intf_decls(stream, declare, define)
+    super
     stream << %$
-      #{declare} void #{ctor}(#{type}*);
-      #{declare} void #{dtor}(#{type}*);
-      #{declare} void #{copy}(#{type}*, #{type}*);
-      #{declare} int #{equal}(#{type}*, #{type}*);
-      #{declare} size_t #{identify}(#{type}*);
-      #{declare} void #{purge}(#{type}*);
-      #{declare} size_t #{size}(#{type}*);
+      #{declare} #{ctor.declaration};
+      #{declare} #{dtor.declaration};
+      #{declare} #{copy.declaration};
+      #{declare} #{equal.declaration};
+      #{declare} #{identify.declaration};
+      #{declare} void #{purge}(#{type_ref});
+      #{declare} size_t #{size}(#{type_ref});
       #define #{empty}(self) (#{size}(self) == 0)
-      #{declare} int #{containsKey}(#{type}*, #{key.type});
-      #{declare} #{value.type} #{get}(#{type}*, #{key.type});
-      #{declare} int #{put}(#{type}*, #{key.type}, #{value.type});
-      #{declare} int #{replace}(#{type}*, #{key.type}, #{value.type});
-      #{declare} int #{remove}(#{type}*, #{key.type});
-      #{declare} void #{itCtor}(#{it}*, #{type}*);
-      #{declare} int #{itMove}(#{it}*);
-      #{declare} #{key.type} #{itGetKey}(#{it}*);
-      #{declare} #{value.type} #{itGetElement}(#{it}*);
+      #{declare} int #{containsKey}(#{type_ref}, #{key.type});
+      #{declare} #{value.type} #{get}(#{type_ref}, #{key.type});
+      #{declare} int #{put}(#{type_ref}, #{key.type}, #{value.type});
+      #{declare} int #{replace}(#{type_ref}, #{key.type}, #{value.type});
+      #{declare} int #{remove}(#{type_ref}, #{key.type});
+      #{declare} void #{itCtor}(#{it_ref}, #{type_ref});
+      #{declare} int #{itMove}(#{it_ref});
+      #{declare} #{key.type} #{itGetKey}(#{it_ref});
+      #{declare} #{value.type} #{itGetElement}(#{it_ref});
       #define #{itGet}(it) #{itGetElement}(it)
     $
   end
 
-  def write_implementations(stream, define)
+  def write_impls(stream, define)
     stream << %$
       #define AUTOC_VALID_VALUE 1
       #define AUTOC_VALID_KEY 2
       #define AUTOC_OWNED_VALUE 4
       #define AUTOC_OWNED_KEY 8
-      static #{@entry.type} #{entryKeyOnlyRef}(#{key.type}* key) {
+      static #{@entry.type} #{entryKeyOnlyRef}(#{key.type_ref} key) {
         #{@entry.type} entry;
         entry.key = *key;
         entry.flags = AUTOC_VALID_KEY;
         return entry;
       }
-      static #{@entry.type} #{entryKeyValueRef}(#{key.type}* key, #{value.type}* value) {
+      static #{@entry.type} #{entryKeyValueRef}(#{key.type_ref} key, #{value.type_ref} value) {
         #{@entry.type} entry;
         entry.key = *key;
         entry.value = *value;
@@ -220,7 +240,7 @@ class HashMap < Collection
         return #{key.equal("lt->key", "rt->key")};
       }
       #define #{entryCopy}(dst, src) #{entryCopyRef}(&dst, &src)
-      static void #{entryCopyRef}(#{@entry.type}* dst, #{@entry.type}* src) {
+      static void #{entryCopyRef}(#{@entry.type_ref} dst, #{@entry.type_ref} src) {
         #{assert}(src->flags & AUTOC_VALID_KEY);
         dst->flags = (AUTOC_VALID_KEY | AUTOC_OWNED_KEY);
         #{key.copy("dst->key", "src->key")};
@@ -235,20 +255,35 @@ class HashMap < Collection
         if(entry->flags & AUTOC_OWNED_KEY) #{key.dtor("entry->key")};
         if(entry->flags & AUTOC_VALID_VALUE && entry->flags & AUTOC_OWNED_VALUE) #{value.dtor("entry->value")};
       }
+      static #{@entry.type_ref} #{itGetEntryRef}(#{it_ref});
+      static int #{containsAllOf}(#{type_ref} self, #{type_ref} other) {
+        #{it} it;
+        #{itCtor}(&it, self);
+        while(#{itMove}(&it)) {
+          int found = 0;
+          #{@entry.type}* e = #{itGetEntryRef}(&it);
+          if(#{containsKey}(other, e->key)) {
+            #{value.type} other_value = #{get}(other, e->key);
+            found = #{value.equal("e->value", "other_value")};
+            #{value.dtor("other_value")};
+          }
+          if(!found) return 0;
+        }
+        return 1;
+      }
     $
-    @set.write_exported_declarations(stream, static, inline)
-    @set.write_implementations(stream, static)
+    @set.write_intf_decls(stream, static, inline)
+    @set.write_impls(stream, static)
     stream << %$
-      static #{@entry.type}* #{itGetEntryRef}(#{it}*);
-      #{define} void #{ctor}(#{type}* self) {
+      #{define} #{ctor.definition} {
         #{assert}(self);
         #{@set.ctor}(&self->entries);
       }
-      #{define} void #{dtor}(#{type}* self) {
+      #{define} #{dtor.definition} {
         #{assert}(self);
         #{@set.dtor}(&self->entries);
       }
-      static int #{putEntryRef}(#{type}* self, #{@entry.type}* entry) {
+      static int #{putEntryRef}(#{type_ref} self, #{@entry.type_ref} entry) {
         int absent;
         #{assert}(self);
         #{assert}(entry);
@@ -257,7 +292,7 @@ class HashMap < Collection
         }
         return absent;
       }
-      #{define} void #{copy}(#{type}* dst, #{type}* src) {
+      #{define} #{copy.definition} {
         #{it} it;
         #{assert}(src);
         #{assert}(dst);
@@ -268,39 +303,24 @@ class HashMap < Collection
           #{putEntryRef}(dst, e);
         }
       }
-      static int #{containsAllOf}(#{type}* self, #{type}* other) {
-        #{it} it;
-        #{itCtor}(&it, self);
-        while(#{itMove}(&it)) {
-          int found = 0;
-          #{@entry.type}* e = #{itGetEntryRef}(&it);
-          if(#{containsKey}(other, e->key)) {
-            #{value.type} other_value = #{get}(other, e->key);
-            found = #{value.equal("e->value", "other_value")};
-            #{value.dtor("other_value")};
-          }
-          if(!found) return 0;
-        }
-        return 1;
-      }
-      #{define} int #{equal}(#{type}* lt, #{type}* rt) {
+      #{define} #{equal.definition} {
         #{assert}(lt);
         #{assert}(rt);
         return #{size}(lt) == #{size}(rt) && #{containsAllOf}(lt, rt) && #{containsAllOf}(rt, lt);
       }
-      #{define} size_t #{identify}(#{type}* self) {
+      #{define} #{identify.definition} {
         #{assert}(self);
         return #{@set.identify}(&self->entries); /* TODO : make use of the values' hashes */
       }
-      #{define} void #{purge}(#{type}* self) {
+      #{define} void #{purge}(#{type_ref} self) {
         #{assert}(self);
         #{@set.purge}(&self->entries);
       }
-      #{define} size_t #{size}(#{type}* self) {
+      #{define} size_t #{size}(#{type_ref} self) {
         #{assert}(self);
         return #{@set.size}(&self->entries);
       }
-      #{define} int #{containsKey}(#{type}* self, #{key.type} key) {
+      #{define} int #{containsKey}(#{type_ref} self, #{key.type} key) {
         int result;
         #{@entry.type} entry;
         #{assert}(self);
@@ -308,7 +328,7 @@ class HashMap < Collection
         #{@entry.dtor("entry")};
         return result;
       }
-      #{define} #{value.type} #{get}(#{type}* self, #{key.type} key) {
+      #{define} #{value.type} #{get}(#{type_ref} self, #{key.type} key) {
         #{value.type} result;
         #{@entry.type} entry, existing_entry;
         #{assert}(self);
@@ -319,7 +339,7 @@ class HashMap < Collection
         #{@entry.dtor("entry")};
         return result;
       }
-      #{define} int #{put}(#{type}* self, #{key.type} key, #{value.type} value) {
+      #{define} int #{put}(#{type_ref} self, #{key.type} key, #{value.type} value) {
         int result;
         #{@entry.type} entry;
         #{assert}(self);
@@ -328,7 +348,7 @@ class HashMap < Collection
         #{@entry.dtor("entry")};
         return result;
       }
-      #{define} int #{replace}(#{type}* self, #{key.type} key, #{value.type} value) {
+      #{define} int #{replace}(#{type_ref} self, #{key.type} key, #{value.type} value) {
         int result;
         #{@entry.type} entry;
         #{assert}(self);
@@ -337,7 +357,7 @@ class HashMap < Collection
         #{@entry.dtor("entry")};
         return result;
       }
-      #{define} int #{remove}(#{type}* self, #{key.type} key) {
+      #{define} int #{remove}(#{type_ref} self, #{key.type} key) {
         int result;
         #{@entry.type} entry;
         #{assert}(self);
@@ -345,25 +365,25 @@ class HashMap < Collection
         #{@entry.dtor("entry")};
         return result;
       }
-      #{define} void #{itCtor}(#{it}* self, #{type}* map) {
+      #{define} void #{itCtor}(#{it_ref} self, #{type_ref} map) {
         #{assert}(self);
         #{assert}(map);
         #{@set.itCtor}(&self->it, &map->entries);
       }
-      #{define} int #{itMove}(#{it}* self) {
+      #{define} int #{itMove}(#{it_ref} self) {
         #{assert}(self);
         return #{@set.itMove}(&self->it);
       }
-      #{define} #{key.type} #{itGetKey}(#{it}* self) {
-        #{@entry.type}* e;
+      #{define} #{key.type} #{itGetKey}(#{it_ref} self) {
+        #{@entry.type_ref} e;
         #{key.type} key;
         #{assert}(self);
         e = #{itGetEntryRef}(self);
         #{key.copy("key", "e->key")};
         return key;
       }
-      #{define} #{value.type} #{itGetElement}(#{it}* self) {
-        #{@entry.type}* e;
+      #{define} #{value.type} #{itGetElement}(#{it_ref} self) {
+        #{@entry.type_ref} e;
         #{value.type} value;
         #{assert}(self);
         e = #{itGetEntryRef}(self);
@@ -371,7 +391,7 @@ class HashMap < Collection
         #{value.copy("value", "e->value")};
         return value;
       }
-      static #{@entry.type}* #{itGetEntryRef}(#{it}* self) {
+      static #{@entry.type_ref} #{itGetEntryRef}(#{it_ref} self) {
         #{assert}(self);
         return #{@set.itGetRef}(&self->it);
       }