virtualbox-com 0.9.9 → 0.10.0

data/scripts/spec.rb

@@ -0,0 +1,56 @@
+require_relative 'sig'
+
+module VirtualBox
+module COM
+
+class Spec
+    attr_reader :name
+
+    def hide?
+        @opts[:hide]
+    end
+
+    class Function < Spec
+        def initialize(name, type, args, opts)
+            @name, @type, @args, @opts = name, type, args, opts
+        end
+
+        def signatures
+            { name => to_call }
+        end
+
+        def to_call
+            Sig.new( if @type.nil?
+                     then @args
+                     else @args + [ [ :out, @type ] ]
+                     end)
+        end
+    end
+    
+    class Property < Spec
+        attr_reader :getter, :setter
+
+        def initialize(name, type, opts) 
+            @name, @type, @opts = name, type, opts
+        end
+
+        def signatures
+            r = {}
+            r[getter] = to_read 
+            r[setter] = to_write unless self.readonly?
+            r
+        end
+
+        def readonly?
+            @opts[:readonly]
+        end
+
+        def getter	; :"get_#{@name}" 		; end
+        def setter	; :"set_#{@name}" 		; end
+        def to_read	; Sig.new([[:out, @type]]) 	; end
+        def to_write	; Sig.new([ @type ]) 		; end
+    end
+end
+
+end
+end

data/scripts/to_c.rb

@@ -0,0 +1,157 @@
+require 'bundler/setup'
+require 'getoptlong'
+
+module VirtualBox
+    module COM
+        WSTRING = 'wstring_t'
+        BOOL    = 'bool_t'
+        OCTET   = 'char'
+        PTR     = 'void *'
+        INT8    = 'int8_t'
+        INT16   = 'int16_t'
+        INT32   = 'int32_t'
+        INT64   = 'int64_t'
+        UINT8   = 'uint8_t'
+        UINT16  = 'uint16_t'
+        UINT32  = 'uint32_t'
+        UINT64  = 'uint64_t'
+        
+        module Model
+            def self.get(name)
+                self.const_get(name, false)
+            rescue NameError
+                raise ModelNotFoundException, name
+            end
+            
+            def self.fetch(name)
+                self.const_get(name, false)
+            rescue NameError
+                nil
+            end
+        end
+        
+        class ModelNotFoundException < Exception
+        end
+    end
+end
+
+require 'virtualbox/com/abstracts'
+require_relative 'abstracts'
+require_relative 'sig'
+require_relative 'spec'
+
+
+
+opts = GetoptLong.new(
+	[ "--api",		GetoptLong::REQUIRED_ARGUMENT ],
+	[ "--file",		GetoptLong::REQUIRED_ARGUMENT ],
+	[ "--help",		GetoptLong::NO_ARGUMENT ] )
+
+api  = nil
+file = nil
+
+begin
+    opts.each do |opt, arg|
+	case opt
+	when "--api"  then api  = arg
+	when "--file" then file = arg
+        when "--help" then raise
+	end
+    end
+    raise if api.nil?
+rescue
+    $stderr.print <<EOT
+usage: xidl-conv.rb: --api version [--file output]
+    --api         Model description 
+    --file        path to generated output
+    --help        Show this message.
+
+EOT
+    exit 0
+end
+
+
+require "virtualbox/com/model/#{api}-generated"
+OUT = file.nil? ? $stdout : File.open(file, 'w')
+
+
+
+
+
+M  = VirtualBox::COM::Model
+
+
+M.constants.each {|name| model = VirtualBox::COM::Model.get(name)
+    next unless model <= VirtualBox::COM::AbstractInterface
+    OUT << "struct #{name} {\n"
+    if (s = model.superclass) < VirtualBox::COM::AbstractInterface
+        OUT << "  struct #{s.nickname} #{s.nickname};\n"
+    end
+    model.members.each {|spec|
+        spec.signatures.each {|n, sig|
+            OUT << "  uint32_t (*#{n})(#{sig.to_c.join(', ')});\n"
+        }    
+    }
+    OUT << "};\n"
+}
+
+
+
+M.constants.each {|name| model = VirtualBox::COM::Model.get(name)
+    OUT << "static VALUE c#{name} = Qundef;\n"
+}
+
+
+M.constants.each {|name| model = VirtualBox::COM::Model.get(name)
+    next unless model <= VirtualBox::COM::AbstractInterface
+
+    model.functions.each {|spec|
+        spec.to_call.to_c_func("#{name}__#{spec.name}", name, spec.name);
+    }
+
+    model.properties.each {|spec|
+        spec.to_read.to_c_func("#{name}__#{spec.getter}", name, spec.getter);
+        next if spec.readonly?
+        spec.to_write.to_c_func("#{name}__#{spec.setter}", name, spec.setter);
+
+    }
+}
+
+
+OUT << "static void comclass_init(VALUE under) {\n"
+M.constants.each {|name| model = VirtualBox::COM::Model.get(name)
+    kAbstract = 'c' + model.superclass.name.split('::')[-1]
+    
+    OUT << "  {\n"
+    OUT << "    iid_t iid  = #{model::IID.to_struct};\n"
+    OUT << "    VALUE c    = c#{name}\n"
+    OUT << "      = rb_define_class_under(under, \"#{name}\", #{kAbstract});\n"
+    OUT << "    no_instantiation(c);\n"
+    OUT << "    rb_const_set(c, _IID, iid__new(&iid));\n"
+    
+    if model <= VirtualBox::COM::AbstractEnum
+        OUT << "    VALUE h    = rb_hash_new();\n"
+        model.map.each {|sym, val|
+            OUT << "    rb_funcall(h, _bracketseq, 2, SYM(\"#{sym}\"), ULL2NUM(#{val}));\n"
+        }
+        OUT << "    rb_funcall(c, _map, 1, h);\n"
+    elsif model <= VirtualBox::COM::AbstractInterface
+        model.members.each {|spec|
+            next if spec.hide?
+            case spec
+            when VirtualBox::COM::Spec::Function
+                if spec.to_call.size > 15
+                    warn "Binding for #{model.nickname}\##{spec.name} need to be handcrafted"
+                    next
+                end
+                OUT << "    rb_define_method(c, \"#{spec.name}\", #{model.nickname}__#{spec.name}, #{spec.to_call.in.size});\n"                
+            when VirtualBox::COM::Spec::Property
+                OUT << "    rb_define_method(c, \"#{spec.name}\", #{model.nickname}__#{spec.getter}, 0);\n"
+                
+                OUT << "    rb_define_method(c, \"#{spec.name}=\", #{model.nickname}__#{spec.setter}, 1);\n" if !spec.readonly?
+            end
+        }
+    end
+    OUT << "  }\n"
+}
+OUT << "}\n"

data/scripts/xidl-conv.rb

@@ -1,47 +1,102 @@
 require 'bundler/setup'
+require 'getoptlong'
 require 'nokogiri'
 require 'virtualbox/com/util'
 
-XIDL = Nokogiri::XML(File.new("../VirtualBox.xidl"))
-LIB  = XIDL.root.xpath('library')
 
+# Parse command line
+opts = GetoptLong.new(
+	[ "--xidl",		GetoptLong::REQUIRED_ARGUMENT ],
+	[ "--file",		GetoptLong::REQUIRED_ARGUMENT ],
+	[ "--help",		GetoptLong::NO_ARGUMENT ] )
 
+xidl = nil
+file = nil
 
-io = $stdout
+begin
+    opts.each do |opt, arg|
+	case opt
+	when "--xidl" then xidl = arg
+	when "--file" then file = arg
+        when "--help" then raise
+	end
+    end
+    raise if xidl.nil?
+rescue
+    $stderr.print <<EOT
+usage: xidl-conv.rb: --xidl file [--file output]
+    --xidl        VirtualBox XIDL file
+    --file        path to generated output
+    --help        Show this message.
+
+EOT
+    exit 0
+end
 
-io << <<-EOT
+
+XIDL    = Nokogiri::XML(File.new(xidl))
+LIB     = XIDL.root.xpath('library')
+OUT      = file.nil? ? $stdout : File.open(file, 'w')
+
+OUT << <<-EOT
 #
 # This file has been automatically generated from the VirtualBox.xidl
+# NOTE: it is not always loaded.
 #
 
 EOT
 
-io << "module VirtualBox\n"
-io << "module COM\n"
-io << "\n"
-io << "MODEL_VERSION = \"4.2\"\n"
-io << "\n"
-io << "module Model\n"
-io << "\n"
+OUT << "module VirtualBox\n"
+OUT << "module COM\n"
+OUT << "module Model\n"
+OUT << "\n"
 
 
-io << <<-EOT
+OUT << <<-EOT
 class NSISupports < AbstractInterface
   iid      "00000000-0000-0000-c000-000000000046"
-  function :QueryInterface, :pointer, [ :pointer ], :hide => true
-  function :AddRef,  nil, [],                       :hide => true
-  function :Release, nil, [],                       :hide => true
+  function :QueryInterface, PTR, [ PTR ], :hide => true
+  function :AddRef,  nil, [],             :hide => true
+  function :Release, nil, [],             :hide => true
+end
+
+class NSIException < NSISupports
+  iid      "f3a8d3b4-c424-4edc-8bf6-8974c983ba78"
+  property :message,       WSTRING,        :readonly => true
+  property :result,        UINT32,         :readonly => true
+  property :name,          WSTRING,        :readonly => true
+  property :filename,      WSTRING,        :readonly => true
+  property :line_number,   UINT32,         :readonly => true
+  property :column_number, UINT32,         :readonly => true
+  property :location,      PTR,            :readonly => true
+  property :inner,         :NSIException,  :readonly => true
+  property :data,          :NSISupports,   :readonly => true
+  function :to_string,     nil, [WSTRING]
 end
 
 EOT
 
 
-def uncamelize(string)
-    VirtualBox::COM::Util.uncamelize(string)
+class String
+    def uncamelize
+        VirtualBox::COM::Util.uncamelize(self)
+    end
+
+    def up1case
+        self[0].upcase + self[1..-1]
+    end
+end
+
+def origin_of(type)
+    if    !LIB.xpath("interface[@name = '#{type}']").empty?
+        :interface
+    elsif !LIB.xpath("enum     [@name = '#{type}']").empty?
+        :enum
+    end
 end
 
 def cnv_type(name, array=nil, ptr=nil) 
-    return ':pointer' if ptr
+    return 'PTR' if ptr
     t = case name
         when 'boolean'            then 'BOOL'
         when 'octet'              then 'OCTET'
@@ -54,7 +109,13 @@ def cnv_type(name, array=nil, ptr=nil)
         when 'uuid'               then 'WSTRING'
         when 'wstring'            then 'WSTRING'
         when '$unknown'           then ':NSISupports'
-        else ':'+ name.gsub(/^I/, '')
+        when '$errorinfo'         then ':NSIException'
+        else 
+            case origin_of(name)
+            when :interface then ':' + name.gsub(/^I/, '')
+            when :enum      then ':' + name
+            else raise "Unknown type #{name}"
+            end
         end
     t = '[' + t + ']' if array
     t
@@ -63,42 +124,42 @@ end
 
 # Enumeration
 for enum in LIB.xpath('enum')
-    io << "class #{enum[:name]} < AbstractEnum\n"
-    io << "  iid \"#{enum[:uuid]}\"\n"
-    io << "  map({\n"    
+    OUT << "class #{enum[:name]} < AbstractEnum\n"
+    OUT << "  iid \"#{enum[:uuid]}\"\n"
+    OUT << "  map({\n"    
     enum.xpath('const').each {|c|
-        io << "    :%-40s => %s,\n" % [ uncamelize(c[:name]), c[:value] ] }
-    io << "  })\n"
-    io << "  setup\n"
-    io << "end\n"
-    io << "\n"
+        OUT << "    :%-40s => %s,\n" % [ c[:name].uncamelize, c[:value] ] }
+    OUT << "  })\n"
+    OUT << "end\n"
+    OUT << "\n"
 end
 
 # Interface
 for interface in LIB.xpath('interface')
-    io << "class #{interface[:name][1..-1]} < AbstractInterface\n"
-    io << "  iid      \"#{interface[:uuid]}\"\n"
-
-    case e=interface[:extends]
-    when nil
-    when '$errorinfo'
-    when '$unknown'   then io << "  extends  :NSISupports\n"
-    when /^I/         then io << "  extends  :#{e[1..-1]}\n"
-    else raise "Unkown extension"
-    end
+    klass = case e=interface[:extends]
+            when 'AbstractInterface'
+            when '$errorinfo' then 'NSIException'
+            when '$unknown'   then 'NSISupports'
+            when /^I/         then e[1..-1]
+            else raise "Unknown extension"
+            end
 
+    OUT << "class #{interface[:name][1..-1]} < #{klass}\n"
+    OUT << "  iid      \"#{interface[:uuid]}\"\n"
 
     interface.xpath('attribute').each {|a|
-        name = ':' + uncamelize(a[:name])
-        type = cnv_type(a[:type], a[:safearray])
-        opts = [ ':readonly => true' ] if a[:readonly]
+        name = ':' + a[:name].uncamelize
+        type = cnv_type(a[:type], a[:safearray], a[:mod] == 'ptr')
+        opts = if a[:readonly] 
+               then [ ':readonly => true' ] 
+               end
         args = [ name, type ]
         args << opts if opts && !opts.empty?
 
-        io << "  property " << args.join(', ') << "\n"
+        OUT << "  property " << args.join(', ') << "\n"
     }
     interface.xpath('method').each {|m|
-        name = ':' + uncamelize(m[:name])
+        name = ':' + m[:name].uncamelize
         ret  = if ret = m.xpath("param[@dir = 'return']")[0]
                    cnv_type(ret[:type], ret[:safearray], ret[:mod] == 'ptr')
                else 'nil'
@@ -109,17 +170,16 @@ for interface in LIB.xpath('interface')
             t
         }.join(', ') + ']'
 
-        io << "  function " << [name, ret, param].join(', ') << "\n"
+        OUT << "  function " << [name, ret, param].join(', ') << "\n"
     }
 
-    io << "  setup\n"
-    io << "end\n"
-    io << "\n"
+    OUT << "end\n"
+    OUT << "\n"
 end
 
 
-io << "end\n"
-io << "end\n"
-io << "end\n"
+OUT << "end\n"
+OUT << "end\n"
+OUT << "end\n"
 
-io.flush
+OUT.flush

data/virtualbox-com.gemspec

@@ -5,23 +5,30 @@ require "virtualbox/com/version"
 Gem::Specification.new do |s|
   s.name          = "virtualbox-com"
   s.version       = VirtualBox::COM::VERSION
-  s.platform      = Gem::Platform::RUBY
-  s.authors       = ["Stephane D'Alu", "Mitchell Hashimoto"]
-  s.email         = ["stephane.dalu@gmail.com", "mitchell.hashimoto@gmail.com"]
+  s.authors       = [ "Stephane D'Alu" ]
+  s.email         = [ "stephane.dalu@gmail.com" ]
   s.homepage      = "http://github.com/sdalu/virtualbox-com"
-  s.summary       = "Low level VirtualBox interraction using pure ruby"
-  s.description   = "Low level VirtualBox interraction using pure ruby"
+  s.summary       = "Low level VirtualBox binding"
+  s.description   = "Low level VirtualBox binding using native code"
+  s.extensions    = [ "ext/virtualbox-com/loader/extconf.rb",
+  		      "ext/virtualbox-com/4.2/extconf.rb",
+                      "ext/virtualbox-com/4.1/extconf.rb",
+  		       ]	
 
-  s.required_rubygems_version = ">= 1.3.6"
-  s.rubyforge_project         = "virtualbox-com"
-
-  s.add_dependency "ffi"
+# s.add_dependency "ffi"
   s.add_development_dependency "rake"
   s.add_development_dependency "nokogiri"
+
+  s.has_rdoc      = false
+
+  s.license       = 'GPL-2'
   
 
-  s.files         = `git ls-files`.split("\n")
-  s.executables   = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.files         = %w[ LICENSE Gemfile virtualbox-com.gemspec ] 	+ 
+  		     Dir['scripts/*.rb']		  		+ 
+		     Dir['examples/*.rb'] 				+
+		     Dir['ext/**/*.{c,h,rb,inc}'] 			+
+		     Dir['lib/**/*.rb'] 
   s.require_path  = 'lib'
 end