virtualbox-com 0.9.9 → 0.10.0

data/lib/virtualbox/com/model/4.2.rb

@@ -1,4 +1,4 @@
-require_relative '4.2-generated'
+
 require 'set'
 
 module VirtualBox
@@ -6,7 +6,7 @@ module COM
 module Model
 
 
-class Machine < AbstractInterface
+class Machine < NSISupports
     ONLINE_STATES = Set.new [ :running, 
                               :paused, 
                               :stuck,
@@ -30,7 +30,7 @@ end
 
 
 
-class Progress < AbstractInterface
+class Progress < NSISupports
     # This method blocks the execution while the operations represented
     # by this {Progress} object execute, but yields a block every `x`
     # percent (interval given in parameters).
@@ -62,7 +62,7 @@ class Progress < AbstractInterface
 end
 
 
-class EventSource < AbstractInterface
+class EventSource < NSISupports
     MODEL_MAP = {
         :machine_event                    => :MachineEvent,
         :snapshot_event                   => :SnapshotEvent,

data/lib/virtualbox/com/util.rb

@@ -60,6 +60,7 @@ module Util
         "bios"          => "BIOS",
         "csam"          => "CSAM",
         "dhcp"          => "DHCP",
+        "ehci"		=> "EHCI",
         "fifo"          => "FIFO",
         "hpet"          => "HPET",
         "ich6"          => "ICH6",
@@ -75,6 +76,7 @@ module Util
         "tftp"          => "TFTP",
         "uuid"          => "UUID",
         "vbox"          => "VBox",
+        "vhwa"          => "VHWA",
         "vpid"          => "VPID",
         "vram"          => "VRAM",
         "vrde"          => "VRDE",
@@ -127,7 +129,6 @@ module Util
         "vm"            => "VM",
         "vd"            => "VD",
     }
-
 end
 
 end

data/lib/virtualbox/com/version.rb

@@ -1,5 +1,5 @@
 module VirtualBox
 module COM
-    VERSION = "0.9.9"
+    VERSION = "0.10.0"
 end
 end

data/lib/virtualbox/com/xpcomc-ffi.rb

@@ -10,31 +10,17 @@ require_relative 'xpcomc-ffi/model-types'
 
 module VirtualBox
 module COM
-class IID
-    class FFIStruct < ::FFI::Struct
-        layout :m0, :uint32,
-               :m1, :uint16,
-               :m2, :uint16,
-               :m3, [:uint8, 8]
-    end
-
-    def to_ffi
-        @ffi ||= begin
-                     data = FFIStruct.new
-                     data[:m0] = to_a[0]
-                     data[:m1] = to_a[1]
-                     data[:m2] = to_a[2]
-                     to_a[3..-1].each_index{|i| data[:m3][i] = to_a[3..-1][i] }
-                     data.freeze
-                 end
+module Model
+    def self.create(name, *args)
+        self.get(name).new(*args)
     end
 end
 end
 end
 
-
-
 # Load FFI implementation
+require_relative 'xpcomc-ffi/iid'
+require_relative 'xpcomc-ffi/abstracts'
 require_relative 'xpcomc-ffi/xpcomc-vbox'
 require_relative 'xpcomc-ffi/binding'
 require_relative 'xpcomc-ffi/implementer'

data/lib/virtualbox/com/xpcomc-ffi/abstracts.rb

@@ -0,0 +1,103 @@
+module VirtualBox
+module COM
+
+class AbstractModel
+    def self.iid(str)
+        const_set(:IID, IID.new(str))
+    end
+end
+
+
+#
+# # Defining an Interface
+#
+# Defining an interface is done by subclassing AbstractInterface and
+# using the provided class methods to define the COM methods and
+# properties. A small example class is shown below:
+#
+#     class Time < AbstractInterface
+#       function :now, [[:out, :uint]]
+#       property :hour, :uint
+#     end
+#
+# # Accessing an Interface
+#
+#
+#     # Assume `time` was retrieved already
+#     puts time.foo.to_s
+#     time.hour = 20
+#     x = time.now
+#
+# The above example shows how the properties and functions can be used
+# with a given interface.
+#
+class AbstractInterface < AbstractModel
+    attr_reader :implementer
+
+    class << self
+        # Adds a function to the interface
+        def function(name, type, args, opts={})
+            h[name] = Spec::Function.new(name, type, args, opts)
+            define_method(name) { |*args| 
+                @implementer.call_function(spec, *args) 
+            } unless spec.hide?
+        end
+
+        # Adds a property to the interface
+        def property(name, type, opts={})
+            h[name] = Spec::Property.new(name, type, opts)
+            define_method(name) {
+                @implementer.read_property(spec)
+            } unless spec.hide?
+            define_method(:"#{name}=") { |value|
+                @implementer.write_property(spec, value)
+            } unless spec.hide? || spec.readonly?
+        end
+
+        # Get a member by name
+        def member(name)
+            h[name]
+        end
+
+        # List of members (Spec::*)
+        def members
+            h.values
+        end
+
+        # List of functions (Spec::Function)
+        def functions
+            members.select {|s| s.kind_of?(Spec::Function) }
+        end
+
+        # List if properties (Spec::Property)
+        def properties
+            members.select {|s| s.kind_of?(Spec::Property) }
+        end
+
+        
+        private
+        def h ; @h ||= {} ; end
+    end
+
+
+    # Initializes the interface with the given implementer
+    def initialize(*args)
+        @args = args
+        @implementer = Implementer.new(self, *args)
+    end
+    
+
+    # Cast to another model
+    def cast(name)
+        @implementer.cast(name, *@args)
+    end
+
+    # Concise inspect
+    def inspect
+        "#<#{self.class.name}>"
+    end
+end
+
+
+end
+end

data/lib/virtualbox/com/{iid.rb → xpcomc-ffi/iid.rb}

@@ -2,6 +2,13 @@ module VirtualBox
 module COM
 
 class IID
+    class FFIStruct < ::FFI::Struct
+        layout :m0, :uint32,
+               :m1, :uint16,
+               :m2, :uint16,
+               :m3, [:uint8, 8]
+    end
+
     def initialize(obj)
         @i = case obj
              when String
@@ -37,6 +44,17 @@ class IID
                   ((@i & 0x000000000000000000000000000000ff) >>  0)]
                  .freeze
     end
+
+    def to_ffi
+        @ffi ||= begin
+                     data = FFIStruct.new
+                     data[:m0] = to_a[0]
+                     data[:m1] = to_a[1]
+                     data[:m2] = to_a[2]
+                     to_a[3..-1].each_index{|i| data[:m3][i] = to_a[3..-1][i] }
+                     data.freeze
+                 end
+    end
 end
 
 end

data/lib/virtualbox/com/xpcomc-ffi/lib.rb

@@ -6,6 +6,11 @@ module XPCOMC
 
 
 module Lib
+    SUPPORTED_VERSIONS = {
+        "4.2" => [ "3b2f08eb-b810-4715-bee0-bb06b9880ad2",
+                   "12F4DCDB-12B2-4EC1-B7CD-DDD9F6C5BF4D" ]
+    }
+
     extend ::FFI::Library
 
     # Constant with default library path and name
@@ -71,6 +76,7 @@ module Lib
             next if virtualbox_ptr.null? || session_ptr.null?
 
             # Load the interface description
+            require "virtualbox/com/model/#{version}-generated"
             require "virtualbox/com/model/#{version}"
 
             #

data/lib/virtualbox/com/xpcomc-ffi/model-types.rb

@@ -11,6 +11,7 @@ module COM
     UINT16  = :uint16
     UINT32  = :uint32
     UINT64  = :uint64
+    PTR     = :pointer
 end
 end
 

data/lib/virtualbox/com/xpcomc-native.rb

@@ -0,0 +1,8 @@
+require_relative 'xpcomc-native/vbox_loader'
+
+module VirtualBox
+module COM
+    def self.virtualbox ; VIRTUALBOX ; end
+    def self.session    ; SESSION    ; end
+end
+end

data/scripts/abstracts.rb

@@ -0,0 +1,84 @@
+module VirtualBox
+module COM
+
+class IID
+    def initialize(iid)
+        @iid = iid
+    end
+
+    def to_s
+        @iid
+    end
+
+    def to_struct
+        hex = @iid.gsub('-', '')
+        '{' + ([ hex[0,8], hex[8,4], hex[12,4] ].map{|e| "0x#{e}" } + 
+               [ '{' + [ hex[16,2], hex[18,2], hex[20,2], hex[22,2],
+                         hex[24,2], hex[26,2], hex[28,2], hex[30,2] ]
+                     .map{|e| "0x#{e}" }.join(', ') + '}' ]).join(', ') + '}'
+    end
+end
+
+class AbstractModel
+    def self.iid(str)
+        const_set(:IID, IID.new(str))
+    end
+        
+
+    def self.nickname
+        self.name.split('::')[-1]
+    end
+end
+
+class AbstractInterface < AbstractModel
+    class << self
+
+        # Extends the current model with another one.
+        # Note that redefining functions or properties is not supported.
+        def extends(model = nil)
+            if model.nil?
+            then @model
+            else @model = Model.get(model) 
+            end
+        rescue ModelNotFoundException
+            raise "trying to extend an unknown model (#{model})"
+        end
+
+
+        # Adds a function to the interface
+        def function(name, type, args, opts={})
+            h[name] = Spec::Function.new(name, type, args, opts)
+        end
+
+        # Adds a property to the interface
+        def property(name, type, opts={})
+            h[name] = Spec::Property.new(name, type, opts)
+        end
+
+        # Get a member by name
+        def member(name)
+            h[name]
+        end
+
+        # List of members (Spec::*)
+        def members
+            h.values
+        end
+
+        # List of functions (Spec::Function)
+        def functions
+            members.select {|s| s.kind_of?(Spec::Function) }
+        end
+
+        # List if properties (Spec::Property)
+        def properties
+            members.select {|s| s.kind_of?(Spec::Property) }
+        end
+
+        private
+        def h ; @h ||= {} ; end
+    end
+end
+
+end
+end

data/scripts/sig.rb

@@ -0,0 +1,201 @@
+module VirtualBox
+module COM
+
+
+class Sig
+    # Store and normalize signatures
+    def initialize(sig)
+        @sig = sig.map {|item|
+            if item.is_a?(Array) && item[0] == :out 
+            then [ item[1], :out ]
+            else [ item,    :in  ]
+            end
+        }.freeze.each{|type, way|
+            # Sanity check: only `[type]` or `type`
+            if type.is_a?(Array) && type.length != 1
+                raise ArgumentError,  "only arrays of simple type are supported"
+            end
+        }
+    end
+
+
+    def size
+        @sig.size
+    end
+
+    def in  ; @sig.select {|type, way| way == :in  } ; end
+    def out ; @sig.select {|type, way| way == :out } ; end
+
+    def to_c
+        @sig.map {|type, way| is_array = type.is_a?(Array)
+            case way
+            when :out
+                if is_array
+                then [PTR, PTR] 
+                else PTR
+                end
+            when :in
+                if is_array then [UINT32,  PTR] 
+                elsif model = Model.fetch(type)
+                    if    model <= COM::AbstractInterface then PTR
+                    elsif model <= COM::AbstractEnum      then UINT32
+                    end
+                else type
+                end
+            end
+        }.unshift(PTR).flatten	# Add `this` element
+    end
+
+
+
+    # Enhance signature by adding variable declarations
+    def with_var_decl
+        i = 0
+        @sig.map {|type, way| is_array = type.is_a?(Array)
+            v = "v#{i+=1}"
+            vdecl = if is_array then [["#{v}_size", UINT32], [v, PTR]]
+                    elsif model = Model.fetch(type)
+                        if    model <= AbstractInterface then [[v, PTR]]
+                        elsif model <= AbstractEnum      then [[v, UINT32]]
+                        end
+                    else [[v, type]]
+                    end
+            [type, way] + vdecl
+        }
+    end
+
+
+
+
+
+
+    def to_c_func(name, vtbl, fun)
+        ins = self.in;
+
+        args= ([ 'self' ] + ins.size.times.map {|i| "i#{i}"})
+            .map {|v| "VALUE #{v}"}.join(', ')
+
+        OUT << "static VALUE #{name}(#{args}) {\n"
+        OUT << "  VALUE  res      = Qundef;\n"
+        OUT << "  struct obj *obj = DATA_PTR(self);\n"
+        OUT << "  struct #{vtbl} *vtbl = obj->vtbl;\n"
+
+        args = self.with_var_decl
+
+        args.each{|type, way, *vdecl|
+            vdecl.each{|var, decl|
+                OUT << "  #{decl} #{var};\n"
+            }
+        }
+
+        ins.each_index{|i| type, = ins[i]
+            OUT << "  i#{i} = " << do_prepare(type, "i#{i}") << ";\n"
+        }
+
+        i = 0;
+        args.each {|type, way, *vdec| is_array = type.is_a?(Array)
+            if way == :in
+                OUT << "  " << get_extract(type, "i#{i}", vdec.map{|var, dec|
+                                       "&#{var}"}) << ";\n"
+            end
+            i += 1
+        }
+
+        a = args.map {|type, way, *vdec| vdec.map{|var, dec|
+                if way == :out then "&#{var}" else var end } }.flatten
+        a.unshift('obj');
+        OUT << "  NS_CHECK(vtbl->#{fun}(" << a.join(', ') << "));\n"
+
+
+
+        OUT << "  res = rb_ary_new();\n"
+        i = 0
+        o = 0
+        args.each {|type, way, *vdec| is_array = type.is_a?(Array)
+            if way == :out
+                OUT << "  rb_ary_push(res, " << get_convert(type, vdec.map{|var, dec|
+                                       "#{var}"}) << ");\n"
+                o += 1
+            end
+            i += 1
+        }
+
+        OUT << "  res = rb_ary_entry(res, 0);\n" if o == 1
+        OUT << "  return res;\n"
+        OUT << "}\n"
+
+    end
+
+
+
+    def get_convert(type, *args)
+        is_array = type.is_a?(Array)
+        type     = type[0] if is_array
+        
+        m, *a = to_converter(type)
+        m = "array_#{m}" if is_array && type != OCTET
+        m = "convert_#{m}"
+        m + '(' + (args + a).join(', ') + ')'
+    end
+    
+    def get_extract(type, src, *args)
+        is_array = type.is_a?(Array)
+        type     = type[0] if is_array
+        a        = []
+
+        if is_array && type == OCTET
+            m = :blob
+        elsif is_array
+            m = :carray
+        else
+            m, *a = to_converter(type)
+        end    
+        m = "extract_#{m}"
+        m + '(' + ([src] + args + a).join(', ') + ')'
+    end
+    
+    def get_in_and_out(prefix, type, src, *args)
+    end
+
+    def do_prepare(type, src)
+        is_array = type.is_a?(Array)
+        type     = type[0] if is_array
+        
+        m, *a = to_converter(type)
+        m = "array_#{m}" if is_array && type != OCTET
+        m = "prepare_#{m}"
+        m + '(' + ([src] + a).join(', ') + ')'
+    end
+
+
+
+    def to_converter(type)
+        is_array = type.is_a?(Array)
+        type     = type[0] if is_array
+        
+        case type
+        when BOOL    then :bool
+        when PTR     then :ptr
+        when OCTET   then :blob
+        when INT16   then :int16
+        when INT32   then :int32
+        when INT64   then :int64
+        when UINT16  then :uint16
+        when UINT32  then :uint32
+        when UINT64  then :uint64
+        when WSTRING then :wstring
+        else
+            if model = Model.fetch(type)
+                kind = if    model <= AbstractInterface then :interface
+                       elsif model <= AbstractEnum      then :enum
+                       else raise "unknown model #{mode.class}"
+                       end 
+                [ kind, "c#{type}" ]
+            else raise "unknown type #{type}"
+            end
+        end
+    end
+end
+
+end
+end