autoc 1.2 → 1.3

data/lib/autoc/type.rb

@@ -1,4 +1,3 @@
-require "set"
 require "forwardable"
 require "autoc/code"
 
@@ -24,9 +23,10 @@ class Dispatcher
     def ===(other) other.is_a?(ParameterArray) && types == other.types end
     def types; collect {|x| x.first} end
     def names; collect {|x| x.last} end
-    def pass; names.join(',') end
-    def declaration; types.join(',') end
-    def definition; collect {|x| "#{x.first} #{x.last}"}.join(',') end
+    def pass; names.join(",") end
+    # ANSI C instructs the empty parameter list to be marked as `void`
+    def declaration; empty? ? :void : types.join(",") end
+    def definition; empty? ? :void : collect {|x| "#{x.first} #{x.last}"}.join(",") end
   end # ParameterArray
 
   # def call(*params)
@@ -106,10 +106,12 @@ class Type < Code
     def write_intf(stream)
       stream << %$
         #ifndef AUTOC_INLINE
-          #ifdef _MSC_VER
-            #define AUTOC_INLINE __inline
+          #if defined(_MSC_VER) || defined(__DMC__)
+            #define AUTOC_INLINE AUTOC_STATIC __inline
+          #elif defined(__LCC__)
+            #define AUTOC_INLINE AUTOC_STATIC /* LCC rejects static __inline */
           #elif __STDC_VERSION__ >= 199901L
-            #define AUTOC_INLINE inline AUTOC_STATIC
+            #define AUTOC_INLINE  AUTOC_STATIC inline
           #else
             #define AUTOC_INLINE AUTOC_STATIC
           #endif
@@ -122,7 +124,7 @@ class Type < Code
           #endif
         #endif
         #ifndef AUTOC_STATIC
-          #ifdef _MSC_VER
+          #if defined(_MSC_VER)
             #define AUTOC_STATIC __pragma(warning(suppress:4100)) static
           #elif defined(__GNUC__)
             #define AUTOC_STATIC __attribute__((__used__)) static
@@ -161,7 +163,7 @@ class Type < Code
   
   def prefix
     # Lazy evaluator for simple types like char* which do not actually use
-    # this method and hence do not require the prefix to be valid C identifier
+    # this method and hence do not require the prefix to be a valid C identifier
     AutoC.c_id(type)
   end
   
@@ -169,20 +171,27 @@ class Type < Code
     @type = type.to_s
     @type_ref = "#{self.type}*"
     @visibility = [:public, :private, :static].include?(visibility) ? visibility : raise("unsupported visibility")
-    @capability = Set[:constructible, :destructible, :copyable, :comparable, :hashable, :orderable] # Can be used to disable specific capabilities for a type
     # Canonic special method signatures
-    @ctor_signature = Function::Signature.new([type^:self])
-    @dtor_signature = Function::Signature.new([type^:self])
-    @copy_signature = Function::Signature.new([type^:dst, type^:src])
-    @equal_signature = Function::Signature.new([type^:lt, type^:rt], :int)
-    @identify_signature = Function::Signature.new([type^:self], :size_t)
-    @less_signature = Function::Signature.new([type^:lt, type^:rt], :int)
+    @signature = {
+      :ctor => Function::Signature.new([type^:self]),
+      :dtor => Function::Signature.new([type^:self]),
+      :copy => Function::Signature.new([type^:dst, type^:src]),
+      :equal => Function::Signature.new([type^:lt, type^:rt], :int),
+      :identify => Function::Signature.new([type^:self], :size_t),
+      :less => Function::Signature.new([type^:lt, type^:rt], :int),
+    }
   end
   
   def method_missing(method, *args)
     str = method.to_s
     str = str.sub(/[\!\?]$/, '') # Strip trailing ? or !
+    x = false # Have leading underscore
+    if /_(.*)/ =~ str
+      str = $1
+      x = true
+    end
     fn = prefix + str[0,1].capitalize + str[1..-1] # Ruby 1.8 compatible
+    fn = "_" << fn if x # Carry over the leading underscore
     if args.empty?
       fn # Emit bare function name
     elsif args.size == 1 && args.first == nil
@@ -217,27 +226,29 @@ class Type < Code
     end
   end
   
+  # Abstract methods which must be defined in descendant classes
+  
   # def write_intf_types(stream)
   
   # def write_intf_decls(stream, declare, define)
   
   # def write_impls(stream, define)
   
-  def extern; "AUTOC_EXTERN" end
+  def extern; :AUTOC_EXTERN end
   
-  def inline; "AUTOC_INLINE" end
+  def inline; :AUTOC_INLINE end
   
-  def static; "AUTOC_STATIC" end
+  def static; :AUTOC_STATIC end
   
-  def assert; "assert" end
+  def assert; :assert end
   
-  def malloc; "malloc" end
+  def malloc; :malloc end
   
-  def calloc; "calloc" end
+  def calloc; :calloc end
   
-  def free; "free" end
+  def free; :free end
   
-  def abort; "abort" end
+  def abort; :abort end
   
   def public?; @visibility == :public end
     
@@ -245,17 +256,29 @@ class Type < Code
   
   def static?; @visibility == :static end
 
-  def constructible?; @capability.include?(:constructible) end
+  # A generic type is not required to provide any special functions therefore all the
+  # availability methods below return false
+    
+  # Returns *true* if the type provides a well-defined parameterless default type constructor
+  def constructible?; false end
 
-  def destructible?; @capability.include?(:destructible) end
+  # Returns *true* if the type provides a well-defined type constructor which can have extra arguments
+  def initializable?; false end
 
-  def copyable?; @capability.include?(:copyable) end
+  # Returns *true* if the type provides a well-defined type destructor
+  def destructible?; false end
 
-  def comparable?; @capability.include?(:comparable) end
+  # Returns *true* if the type provides a well-defined copy constructor to create a clone of an instance
+  def copyable?; false end
+
+  # Returns *true* if the type provides a well-defined equality test function
+  def comparable?; false end
   
-  def orderable?; @capability.include?(:orderable) && comparable? end
+  # Returns *true* if the type provides a well-defined 'less than' test function
+  def orderable?; false end
 
-  def hashable?; @capability.include?(:hashable) && comparable? end
+  # Returns *true* if the type provides a well-defined hash calculation function
+  def hashable?; false end
 
   # Create forwarding readers which take arbitrary number of arguments
   [:ctor, :dtor, :copy, :equal, :identify, :less].each do |name|
@@ -266,12 +289,6 @@ class Type < Code
     $
   end
   
-  private
-
-  def define_function(name, signature)
-    Function.new(method_missing(name), signature)
-  end
-  
 end # Type
 
 
@@ -299,7 +316,7 @@ class UserDefinedType < Type
   def prefix; @prefix.nil? ? super : @prefix end
   
   def initialize(opt)
-    opt = {:type => opt} if opt.is_a?(Symbol) || opt.is_a?(String)
+    opt = {:type => opt} if opt.is_a?(::Symbol) || opt.is_a?(::String)
     if opt.is_a?(Hash)
       t = opt[:type].nil? ? raise("type is not specified") : opt[:type].to_s
     else
@@ -308,33 +325,55 @@ class UserDefinedType < Type
     super(t)
     @prefix = AutoC.c_id(opt[:prefix]) unless opt[:prefix].nil?
     @deps = []; @deps << PublicDeclaration.new(opt[:forward]) unless opt[:forward].nil?
-    opt.default = :unset # This allows to use nil as a value to indicate that the specific method is not avaliable
-    opt[:ctor].nil? ? @capability.subtract([:constructible]) : define_callable(:ctor, opt) {def call(obj) "((#{obj}) = 0)" end}
-    opt[:dtor].nil? ? @capability.subtract([:destructible]) : define_callable(:dtor, opt) {def call(obj) end}
-    opt[:copy].nil? ? @capability.subtract([:copyable]) : define_callable(:copy, opt) {def call(dst, src) "((#{dst}) = (#{src}))" end}
-    opt[:equal].nil? ? @capability.subtract([:comparable]) : define_callable(:equal, opt) {def call(lt, rt) "((#{lt}) == (#{rt}))" end}
-    opt[:less].nil? ? @capability.subtract([:orderable]) : define_callable(:less, opt) {def call(lt, rt) "((#{lt}) < (#{rt}))" end}
-    opt[:identify].nil? ? @capability.subtract([:hashable]) : define_callable(:identify, opt) {def call(obj) "((size_t)(#{obj}))" end}
-    # Handle specific requirements
-    @capability.subtract([:constructible]) if @ctor.parameters.size > 1 # Constructible type must not have extra parameters besides self
+    define_callable(:ctor, opt) {def call(obj) "((#{obj}) = 0)" end}
+    define_callable(:dtor, opt) {def call(obj) end}
+    define_callable(:copy, opt) {def call(dst, src) "((#{dst}) = (#{src}))" end}
+    define_callable(:equal, opt) {def call(lt, rt) "((#{lt}) == (#{rt}))" end}
+    define_callable(:less, opt) {def call(lt, rt) "((#{lt}) < (#{rt}))" end}
+    define_callable(:identify, opt) {def call(obj) "((size_t)(#{obj}))" end}
   end
   
+  def constructible?; !@ctor.nil? && @ctor.parameters.size == 1 end
+
+  def initializable?; !@ctor.nil? end
+
+  def destructible?; !@dtor.nil? end
+
+  def copyable?; !@copy.nil? end
+
+  def comparable?; !@equal.nil? end
+
+  def orderable?; !@less.nil? end
+
+  def hashable?; !@identify.nil? end
+    
+  # The methods below are left empty as the user-defined types have no implementation on their own
+
+  def write_intf_types(stream) end
+
+  def write_intf_decls(stream, declare, define) end
+
+  def write_impls(stream, define) end
+
   private
   
   # Default methods creator
   def define_callable(name, opt, &code)
-    iv = "@#{name}"
-    ivs = "@#{name}_signature"
-    c = if opt[name] == :unset
-      # Synthesize statement block with default (canonic) parameter list
-      Class.new(Statement, &code).new(instance_variable_get(ivs).parameters)
-    elsif opt[name].is_a?(Function)
-      opt[name] # If a Function instance is given, pass it through
+    c = if opt.has_key?(name) && opt[name].nil?
+      nil # Disable specific capability by explicitly setting the key to nil
     else
-      # If only a name is specified, assume it is the function name with default signature
-      Function.new(opt[name], instance_variable_get(ivs))
+      signature = @signature[name]
+      c = if opt[name].nil?
+        # Implicit nil as returned by Hash#default method does synthesize statement block with default (canonic) parameter list
+        Class.new(Statement, &code).new(signature.parameters)
+      elsif opt[name].is_a?(Function)
+        opt[name] # If a Function instance is given, pass it through
+      else
+        # If only a name is specified, assume it is the function name with default signature
+        Function.new(opt[name], signature)
+      end
     end
-    instance_variable_set(iv, c)
+    instance_variable_set("@#{name}", c)
   end
   
 end # UserDefinedType
@@ -376,13 +415,18 @@ class Reference < Type
   def_delegators :@target,
     :prefix,
     :public?, :private?, :static?,
-    :constructible?, :destructible?, :copyable?, :comparable?, :orderable?, :hashable?
-  
+    :constructible?, :initializable?, :destructible?, :comparable?, :orderable?, :hashable?
+
+  # Return *true* since reference copying involves no call to the underlying type's copy constructor  
+  def copyable?; true end
+    
+  attr_reader :target
+    
   def initialize(target)
     @target = Type.coerce(target)
     super(@target.type_ref) # NOTE : the type of the Reference instance itself is actually a pointer type
-    @ctor_params = Dispatcher::ParameterArray.new(@target.ctor.parameters[1..-1]) # Capture extra parameters from the target type constructor
-    define_callable(:ctor, @ctor_params) {def call(obj, *params) "((#{obj}) = #{@ref.new?}(#{params.join(',')}))" end}
+    @init = Dispatcher::ParameterArray.new(@target.ctor.parameters[1..-1]) # Capture extra parameters from the target type constructor
+    define_callable(:ctor, @init) {def call(obj, *params) "((#{obj}) = #{@ref.new?}(#{params.join(',')}))" end}
     define_callable(:dtor, [type]) {def call(obj) "#{@ref.free?}(#{obj})" end}
     define_callable(:copy, [type, type]) {def call(dst, src) "((#{dst}) = #{@ref.ref?}(#{src}))" end}
     define_callable(:equal, [type, type]) {def call(lt, rt) @target.equal("*#{lt}", "*#{rt}") end}
@@ -401,7 +445,7 @@ class Reference < Type
       /***
       ****  <#{type}> (#{self.class})
       ***/
-      #{declare} #{type} #{new?}(#{@ctor_params.declaration});
+      #{declare} #{type} #{new?}(#{@init.declaration});
       #{declare} #{type} #{ref?}(#{type});
       #{declare} void #{free?}(#{type});
     $
@@ -410,9 +454,9 @@ class Reference < Type
   def write_impls(stream, define)
     stream << %$
     #define AUTOC_COUNTER(p) (*(size_t*)((char*)(p) + sizeof(#{@target.type})))
-      #{define} #{type} #{new?}(#{@ctor_params.definition}) {
+      #{define} #{type} #{new?}(#{@init.definition}) {
         #{type} self = (#{type})#{malloc}(sizeof(#{@target.type}) + sizeof(size_t)); #{assert}(self);
-        #{@target.ctor("*self", *@ctor_params.names)};
+        #{@target.ctor("*self", *@init.names)};
         AUTOC_COUNTER(self) = 1;
         return self;
       }
@@ -443,15 +487,60 @@ class Reference < Type
     end
   end # BoundStatement
   
-  def define_callable(name, params, &code)
-    instance_variable_set("@#{name}", Class.new(BoundStatement, &code).new(self, @target, params))
+  def define_callable(name, param_types, &code)
+    instance_variable_set("@#{name}", Class.new(BoundStatement, &code).new(self, @target, param_types))
   end
   
 end # Reference
 
 
+# @private
+module Type::Redirecting
+
+  # Setup special methods which receive types by reference instead of by value
+  def initialize_redirectors
+    define_redirector(:ctor, Function::Signature.new([type_ref^:self]))
+    define_redirector(:dtor, Function::Signature.new([type_ref^:self]))
+    define_redirector(:copy, Function::Signature.new([type_ref^:dst, type_ref^:src]))
+    define_redirector(:equal, Function::Signature.new([type_ref^:lt, type_ref^:rt], :int))
+    define_redirector(:identify, Function::Signature.new([type_ref^:self], :size_t))
+    define_redirector(:less, Function::Signature.new([type_ref^:lt, type_ref^:rt], :int))
+  end
+  
+  def write_redirectors(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
+  
+private
+      
+  # @private
+  class Redirector < Function
+    # Redirect call to the specific macro
+    def call(*params) "_#{name}(" + params.join(',') + ')' end
+  end # Redirector
+  
+  def define_redirector(name, signature)
+    instance_variable_set("@#{name}", Redirector.new(method_missing(name), signature))
+  end
+      
+end # Redirecting
+
+
 # Class adjustments for the function signature definition DSL
-[Symbol, String, Type].each do |type|
+[::Symbol, ::String, Type].each do |type|
   type.class_eval do 
     def ^(name)
       [self, name]

data/test/test.rb

@@ -1,36 +1,158 @@
-require "autoc"
-
-ValueType = {
-  :type => :ValueType,
-  :ctor => :ValueTypeCtor,
-  :dtor => :ValueTypeDtor,
-  :copy => :ValueTypeCopy,
-  :equal => :ValueTypeEqual,
-  :less => :ValueTypeLess,
-  :identify => :ValueTypeIdentify,
-  :forward => %$#include "test.h"$,
-}
-
-PInt = AutoC::Reference.new(:type => "int", :prefix => "Int")
-
-PValueType = AutoC::Reference.new(ValueType)
-
-IntVector = AutoC::Vector.new(:IntVector, :int)
-
-IntSet = AutoC::HashSet.new(:IntSet, :int)
-
-ListIntSet = AutoC::List.new(:ListIntSet, IntSet)
-
-AutoC::Module.generate!(:Test) do |c|
-  c << AutoC::Vector.new(:ValueTypeVector, ValueType)
-  c << AutoC::List.new(:ValueTypeList, ValueType)
-  c << AutoC::Queue.new(:ValueTypeQueue, ValueType)
-  c << AutoC::HashSet.new(:ValueTypeSet, ValueType)
-  c << AutoC::HashMap.new(:ValueTypeMap, ValueType, ValueType)
-  c << AutoC::HashMap.new(:IntStrMap, "int", "const char *")
-  c << ListIntSet
-  c << IntSet
-  c << AutoC::Vector.new(:PIntVector, PInt)
-  c << PInt << PValueType
-  c << AutoC::List.new(:ListPVectorValue, AutoC::Reference.new(AutoC::Vector.new(:PVectorValue, PValueType)))
+=begin
+
+This is the AutoC automatic unit test generator.
+Usage instruction:
+
+1. Generate get test's source code (test_auto.c and test_auto.h):
+> ruby -I . -I ../lib test.rb
+
+2. Compile the generated code:
+> cc test_auto.c
+  
+3. Run the tests:
+> ./a.out
+
+The code is intended to finish succesfully,
+the process' exit code is zero when all tests are passed
+ano non-zero if there were failed tests.
+
+The compile-time warnings are possible and may be ignored.
+
+The compiled code should also pass the memory leakage tests
+(with Valgrind, Dr.Memory etc.)
+
+=end
+
+require "autoc"
+
+Prologue = Class.new(AutoC::Code) do
+  def write_defs(stream)
+    stream << %~
+      #include <stdio.h>
+      struct {
+        int total, processed, failed;
+      } tests;
+      int failure;
+      typedef void (*test_func)(void);
+      void run_test(const char* name, test_func func) {
+        fprintf(stdout, "+   %s\\n", name);
+        fflush(stdout);
+        failure = 0;
+        func();
+        if(failure) tests.failed++;
+        tests.processed++;
+      }
+      void print_condition_failure(const char* message, const char* condition, const char* file, int line) {
+        fprintf(stderr, "*** %s : %s (%s:%d)\\n", condition, message, file, line);
+        fflush(stderr);
+        failure = 1;
+      }
+      void print_equality_failure(const char* message, const char* x, const char* y, const char* file, int line) {
+        fprintf(stderr, "*** %s == %s : %s (%s:%d)\\n", x, y, message, file, line);
+        fflush(stderr);
+        failure = 1;
+      }
+      void print_summary(void) {
+        if(tests.failed)
+          fprintf(stdout, "*** Failed %d of %d tests\\n", tests.failed, tests.processed);
+        else
+          fprintf(stdout, "+++ All %d tests passed successfully\\n", tests.processed);
+        fflush(stdout);
+      }
+      #define TEST_MESSAGE(s) fprintf(stderr, "*** %s\\n", s); fflush(stderr);
+      #define TEST_ASSERT(x) if(x) {} else print_condition_failure("evaluated to FALSE", #x, __FILE__, __LINE__) 
+      #define TEST_TRUE(x) if(x) {} else print_condition_failure("expected TRUE but got FALSE", #x, __FILE__, __LINE__) 
+      #define TEST_FALSE(x) if(x) print_condition_failure("expected FALSE but got TRUE", #x, __FILE__, __LINE__)
+      #define TEST_NULL(x) if((x) == NULL) {} else print_condition_failure("expected NULL", #x, __FILE__, __LINE__) 
+      #define TEST_NOT_NULL(x) if((x) == NULL) print_condition_failure("expected not NULL", #x, __FILE__, __LINE__)
+      #define TEST_EQUAL(x, y) if((x) == (y)) {} else print_equality_failure("expected equality", #x, #y, __FILE__, __LINE__)
+      #define TEST_NOT_EQUAL(x, y) if((x) == (y)) print_equality_failure("expected non-equality", #x, #y, __FILE__, __LINE__)
+      #define TEST_EQUAL_CHARS(x, y) if(strcmp(x, y) == 0) {} else print_equality_failure("expected strings equality", #x, #y, __FILE__, __LINE__)
+      #define TEST_NOT_EQUAL_CHARS(x, y) if(strcmp(x, y) == 0) print_equality_failure("expected strings non-equality", #x, #y, __FILE__, __LINE__)
+    ~
+  end
+end.new
+
+
+Epilogue = Class.new(AutoC::Code) do
+  def priority; AutoC::Priority::MIN end
+  def write_defs(stream)
+    total = 0
+    $tests.each {|t| total += t.tests.size}
+    stream << %~int main(int argc, char** argv) {~
+    stream << %~
+      tests.total = #{total};
+      tests.processed = tests.failed = 0;
+    ~
+    $tests.each {|t| t.write_test_calls(stream)}
+    stream << %~print_summary();~
+    stream << %~return tests.failed > 0;}~
+  end
+end.new
+
+
+$tests = []
+
+
+def type_test(cls, *opts, &code)
+  t = Class.new(cls) do
+    def entities; super << Prologue end
+    attr_reader :tests
+    def initialize(*args)
+      super
+      @tests = []
+      @test_names = []
+    end
+    def setup(code = nil)
+      @setup_code = code
+    end
+    def cleanup(code = nil)
+      @cleanup_code = code
+    end
+    def test(name, code)
+      s = name.to_s
+      @test_names << [name, func_name = eval("test#{s[0,1].upcase}#{s[1..-1]}")]
+      @tests << %~
+        void #{func_name}(void) {
+          #{@setup_code}
+          #{code}
+          #{@cleanup_code}
+        }
+      ~
+    end
+    def write_defs(stream)
+      super
+      @tests.each {|f| stream << f}
+      stream << %~void #{runTests}(void) {~
+        stream << %~
+          fprintf(stdout, "+ %s\\n", "#{type}");
+          fflush(stdout);
+        ~
+        @test_names.each do |name, func_name|
+          stream << %~
+            run_test("#{name}", #{func_name});
+          ~
+        end
+      stream << %~
+        fputs("\\n", stdout); fflush(stdout);}
+      ~
+    end
+    def write_test_calls(stream)
+      stream << %$
+        #{runTests}();
+      $
+    end
+  end.new(*opts)
+  $tests << t
+  t.instance_eval(&code)
+end
+
+
+Dir["**/test_*.rb"].each {|t| load t}
+  
+  
+AutoC::Module.generate!(:Test) do |c|
+  c << Prologue
+  $tests.each {|t| c << t}
+  c << Epilogue
 end