rubber-generate 0.0.5

data/lib/rubber/struct.rb

@@ -0,0 +1,52 @@
+class Class
+def define_member(name, value=nil)
+    raise "Not a symbol - #{name}" unless name.kind_of?(Symbol)
+    if value.nil?
+	 module_eval("attr_accessor #{name.inspect}")
+    else
+	module_eval("attr_writer #{name.inspect};def #{name}(); def self.#{name}(); @#{name}; end; if instance_variables.include?(#{('@'+name.to_s).inspect}) then @#{name} else @#{name} = #{value.inspect}; end; end")
+    end
+end
+def define_members(*ids)
+    members = []
+    ids.each do |id|
+	if id.kind_of?(Hash)
+	    STDERR.puts("WARNING: Hash passed to define_members has size > 1 in #{caller.join("\n")}\n`#{to_s}.new(...)' will not work as expected (non-predictable member order)") if id.size > 1
+	    id.each do |name,value|
+		define_member(name,value)
+                raise "Duplicate definition of member `#{name}'" if members.include?(name.to_s)
+		members.push(name.to_s)
+	    end
+	elsif id.kind_of?(Symbol)
+	    define_member(id)
+            raise "Duplicate definition of member `#{id}'" if members.include?(id.to_s)
+	    members.push(id.to_s)
+	else
+	    raise "Neither a Hash nor a Symbol - `#{id}'"
+	end
+    end
+    module_eval <<-EOS
+      def initialize(*ids); 
+        members.each_index { |i| __send__((members[i]+'=').intern, i < ids.size ? ids[i] : __send__(members[i].intern)) }; 
+          if respond_to?(:init)
+            case method(:init).arity
+            when 0
+              __send__(:init) # Avoid errors if init doesn't need args...
+            else
+              __send__(:init,*ids)
+            end
+          end
+      end
+      def self.new_from_hash(hash,*args); obj=new(*args); hash.each { |n,v| fn = (n.to_s+'=').intern; if obj.members.include?(n.to_s); obj.__send__(fn, v); else raise ArgumentError, 'Unknown member - '+n.to_s; end  }; obj; end
+      def self.members(); #{members.inspect}; end
+      def members(); #{members.inspect}; end
+      def kind_of?(klass); return true if klass == Struct; super(klass); end
+      def to_a(); [#{members.join(', ')}]; end
+      def [](id); id=id.intern if id.kind_of?(String); case id; #{i=-1;members.collect{|name| "when :#{name},#{i+=1}; @#{name};"}} else raise 'Unknown member - '+id.to_s; end; end
+      def []=(id,value); id=id.intern if id.kind_of?(String); case id; #{i=-1;members.collect{|name| "when :#{name},#{i+=1}; @#{name}=value;"}} else raise 'Unknown member - '+id.to_s; end; end
+      def length; #{members.size}; end
+      alias_method(:size, :length)
+      alias_method(:values, :to_a)
+    EOS
+  end
+end

data/lib/rubber/types.rb

@@ -0,0 +1,222 @@
+
+$custom_maps = {}
+$custom_frees = {}
+$equivalents = {}
+module Rubber
+# Map most GLib types to normal C style ones
+CMAP = { 
+  'ruby'=>'VALUE',
+  'gboolean'=>'bool', 
+  'gint'=>'int', 
+  'glong'=>'long', 
+  'guint'=>'uint', 
+  'gchar'=>'char',
+  'gfloat'=>'double', # Ruby only uses doubles?
+  'float'=>'double', # Ruby only uses doubles?
+  'gdouble'=>'double'
+}
+class << self
+  def auto_class_map()
+  hsh = {}
+  %w[rb_cObject
+rb_cArray
+rb_cBignum
+rb_cClass
+rb_cDir
+rb_cData
+rb_cFalseClass
+rb_cFile
+rb_cFixnum
+rb_cFloat
+rb_cHash
+rb_cInteger
+rb_cIO
+rb_cModule
+rb_cNilClass
+rb_cNumeric
+rb_cProc
+rb_cRange
+rb_cRegexp
+rb_cString
+rb_cSymbol
+rb_cThread
+rb_cTime
+rb_cTrueClass
+rb_cStruct
+rb_eException
+rb_eStandardError
+rb_eSystemExit
+rb_eInterrupt
+rb_eSignal
+rb_eFatal
+rb_eArgError
+rb_eEOFError
+rb_eIndexError
+rb_eRangeError
+rb_eIOError
+rb_eRuntimeError
+rb_eSecurityError
+rb_eSystemCallError
+rb_eTypeError
+rb_eZeroDivError
+rb_eNotImpError
+rb_eNoMemError
+rb_eNoMethodError
+rb_eFloatDomainError
+rb_eScriptError
+rb_eNameError
+rb_eSyntaxError
+rb_eLoadError].each { |n|
+    hsh[$1]= n.strip if n =~ /rb_[ce]([A-Za-z]+)/
+  }
+  hsh
+  end
+end
+RUBY_CLASS_MAP = auto_class_map()
+
+
+def self.find_class(classname)
+  return nil if classname.nil?
+  return RUBY_CLASS_MAP[classname] if RUBY_CLASS_MAP.has_key?(classname)
+  # Should this be rb_c or just c?
+  # c{NAME} works better... I think...
+  return 'c'+classname
+end
+
+	RUBY_NATIVE_TYPES = %w|T_NIL T_OBJECT T_CLASS T_MODULE T_FLOAT T_STRING T_REGEXP T_ARRAY T_FIXNUM T_HASH T_STRUCT T_BIGNUM T_FILE T_TRUE T_FALSE T_DATA T_SYMBOL|
+	RUBY_NATIVE_NAMES = %w|Nil Object Class Module Float String Regexp Array Fixnum Hash Struct Bignum File True False Data Symbol|
+
+def self.native_type?(name)
+  return true if name.nil? or RUBY_NATIVE_TYPES.include?(equivalent_type(name))
+  false
+end
+
+def self.count_arr_access(str,name)
+  if name.include?(?[)
+    sc = StringIO.new(name)
+    brac, lev = 0, 0
+    until sc.eof?
+      c = sc.getc
+      if lev == 0 and c == ?[
+        brac += 1
+      end
+      case c
+      when ?[
+        lev += 1
+      when ?]
+        lev -= 1
+      end 
+    end
+    brac
+  else
+    0
+  end
+end
+
+def self.equivalent_type(ctype,name=nil)
+    ctype.gsub!(/ /,'')
+    ctype.strip!
+    ctype.gsub!(/(const|static)/,'')
+    if name
+      brackets = count_arr_access(ctype,name)
+      until brackets == 0
+        ctype = ctype[0..-2] if ctype[-1] == ?*
+        brackets -= 1
+      end
+    end
+    return 'VALUE' if RUBY_NATIVE_TYPES.include?(ctype)
+    ctype= $equivalents[ctype] if $equivalents.has_key?(ctype)
+    return 'VALUE' if RUBY_NATIVE_TYPES.include?(ctype)
+    ctype= CMAP[ctype] if CMAP.has_key?(ctype)
+    ctype
+end
+
+def self.explicit_cast(name, ctype, rule)
+    ctype = equivalent_type(ctype, name)
+    rule = equivalent_type(rule)
+    #puts "#{name}:#{ctype}->#{rule}"
+    return name if ctype == rule
+    if $custom_maps.has_key?(ctype)
+      if $custom_maps[ctype].has_key?(rule)
+        return $custom_maps[ctype][rule].gsub(/%%/,"#{name}")
+      end
+    end
+    case ctype
+    when 'VALUE'
+      case rule
+        when 'char*', 'string'
+          "( NIL_P(#{name}) ? NULL : StringValuePtr(#{name}) )"
+        when 'bool'
+          "RTEST(#{name})"
+        when 'int'
+          "NUM2INT(#{name})"
+        when 'uint'
+          "NUM2UINT(#{name})"
+        when 'long'
+          "NUM2LONG(#{name})"
+        when 'double'
+          "NUM2DBL(#{name})"
+        when 'gobject', 'GObject*'
+          "RVAL2GOBJ(#{name})"
+        else
+        raise "Unable to convert #{ctype} to #{rule}"
+      #"#{ctype.gsub(/[* ]/,'_').upcase}_TO_#{rule.upcase}(#{name})"
+      end
+    when 'bool'
+      case rule
+        when 'char*', 'string'
+          "#{name} ? #{"true".inspect} : #{"false".inspect}"
+        when 'VALUE', 'ruby'
+          " ((#{name}) ? Qtrue : Qfalse)"
+        else
+        raise "Unable to convert #{ctype} to #{rule}"
+      #"#{ctype.gsub(/[* ]/,'_').upcase}_TO_#{rule.upcase}(#{name})"
+      end
+    when 'uint'
+      case rule
+        when 'VALUE', 'ruby'
+          " UINT2NUM(#{name})"
+        else
+        raise "Unable to convert #{ctype} to #{rule}"
+      end
+    when 'char*', 'string'
+      case rule
+        when 'VALUE', 'ruby'
+          " rb_str_new2(#{name})"
+        else
+        raise "Unable to convert #{ctype} to #{rule}"
+      end
+    when 'GObject*', 'gobject'
+      case rule
+        when 'VALUE', 'ruby'
+          " GOBJ2RVAL(#{name})"
+        else
+        raise "Unable to convert #{ctype} to #{rule}"
+      end
+    when 'int'
+      case rule
+        when 'VALUE', 'ruby'
+          " INT2NUM(#{name})"
+        else
+        raise "Unable to convert #{ctype} to #{rule}"
+      end
+    when 'long'
+      case rule
+        when 'VALUE', 'ruby'
+          " LONG2NUM(#{name})"
+        else
+        raise "Unable to convert #{ctype} to #{rule}"
+      end
+    when 'double'
+      case rule
+        when 'VALUE', 'ruby'
+          " rb_float_new(#{name})"
+        else
+        raise "Unable to convert #{ctype} to #{rule}"
+      end
+    else
+      raise "Unable to convert #{ctype} to #{rule}"
+      #"#{ctype.gsub(/[* ]/,'_').upcase}_TO_#{rule.upcase}(#{name})"
+    end
+end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: rubber-generate
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 5
+  version: 0.0.5
+platform: ruby
+authors: 
+- Geoff Youngs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-05 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: "    rubber-c-binder allows a rubyish means of generating bindings for C libraries,\n    including (but not limited to) GObject based libraries.\n\n    It allows C code to be written in the context of a ruby style class/method layout\n    and eases type checking and conversion between Ruby & C datatypes.\n"
+email: g@intersect-uk.co.uk
+executables: 
+- rubber-generate
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- bin/rubber-generate
+- lib/rubber/autord.rb
+- lib/rubber/codegen/class.rb
+- lib/rubber/codegen/enum.rb
+- lib/rubber/codegen/flags.rb
+- lib/rubber/codegen/float.rb
+- lib/rubber/codegen/function.rb
+- lib/rubber/codegen/gboxed.rb
+- lib/rubber/codegen/gcrefpool.rb
+- lib/rubber/codegen/genum.rb
+- lib/rubber/codegen/gflags.rb
+- lib/rubber/codegen/ginterface.rb
+- lib/rubber/codegen/gobject.rb
+- lib/rubber/codegen/integer.rb
+- lib/rubber/codegen/module.rb
+- lib/rubber/codegen/param.rb
+- lib/rubber/codegen/string.rb
+- lib/rubber/codegen/struct.rb
+- lib/rubber/codegen.rb
+- lib/rubber/mkextconf.rb
+- lib/rubber/scanner.rb
+- lib/rubber/struct.rb
+- lib/rubber/types.rb
+- README.md
+has_rdoc: true
+homepage: http://github.com/geoffyoungs/rubber-generate
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Template language for generating Ruby bindings for C libraries
+test_files: []
+