win32ole-ffi 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d256a4fde6e3b23e2eaa63e19f294a07ce0f50af3b8afc24dda7a9c0a67dad17
+  data.tar.gz: 250e8e558565e7857d04f906cdc24433e1747c092a24860a8ea0bbfe5dd48f96
+SHA512:
+  metadata.gz: bedcff11b9a0a5a8fa0f31b90b94de0b683ef2b608f3859e3375845f2a0fab02096a0589caaf4c441b9c9d5acf73f54ef99ca7fb7d1c1785b5b2c76dad4b8ebf
+  data.tar.gz: ffea99b91f339f2d534c5abc24aca19a74a9bbb324cb0bdb4476c9cef7296d71c8264b2c73176383d306df7d5b3ec235afa5b2bdf8d2fa6ad653c220063e83c8

data/BSDL

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 0.1.0
+
+- Initial release: WIN32OLE and WIN32OLE::Type, TypeLib, Method, Param,
+  Variable, Variant, Record and Event in pure Ruby with Fiddle, tested on
+  Windows with CRuby 2.6+ (mswin/mingw) and JRuby 9.4+.
+- The deprecated toplevel names (WIN32OLE_TYPE, WIN32OLERuntimeError, ...)
+  as aliases, as in ruby/win32ole.
+- RBS signatures under `sig/`.

data/COPYING

@@ -0,0 +1,56 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+1. You may make and give away verbatim copies of the source form of the
+   software without restriction, provided that you duplicate all of the
+   original copyright notices and associated disclaimers.
+
+2. You may modify your copy of the software in any way, provided that
+   you do at least ONE of the following:
+
+   a. place your modifications in the Public Domain or otherwise
+      make them Freely Available, such as by posting said
+      modifications to Usenet or an equivalent medium, or by allowing
+      the author to include your modifications in the software.
+
+   b. use the modified software only within your corporation or
+      organization.
+
+   c. give non-standard binaries non-standard names, with
+      instructions on where to get the original software distribution.
+
+   d. make other distribution arrangements with the author.
+
+3. You may distribute the software in object code or binary form,
+   provided that you do at least ONE of the following:
+
+   a. distribute the binaries and library files of the software,
+      together with instructions (in the manual page or equivalent)
+      on where to get the original distribution.
+
+   b. accompany the distribution with the machine-readable source of
+      the software.
+
+   c. give non-standard binaries non-standard names, with
+      instructions on where to get the original software distribution.
+
+   d. make other distribution arrangements with the author.
+
+4. You may modify and include the part of the software into any other
+   software (possibly commercial).  But some files in the distribution
+   are not written by the author, so that they are not under these terms.
+
+   For the list of those files and their copying conditions, see the
+   file LEGAL.
+
+5. The scripts and library files supplied as input to or produced as
+   output from the software do not automatically fall under the
+   copyright of the software, but belong to whomever generated them,
+   and may be sold commercially, and may be aggregated with this
+   software.
+
+6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+   IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+   PURPOSE.

data/README.md

@@ -0,0 +1,49 @@
+# win32ole-ffi
+
+WIN32OLE implemented in pure Ruby with Fiddle, without a C extension, so
+that it also runs on JRuby. It works on Windows only, and is tested with
+CRuby 2.6+ (mswin and mingw) and JRuby 9.4+.
+
+It provides the same API as [ruby/win32ole](https://github.com/ruby/win32ole)
+(`WIN32OLE`, `WIN32OLE::Type`, `WIN32OLE::Event`, ...) and runs that gem's
+test suite. Use one or the other: both define the `WIN32OLE` class, so do
+not load `win32ole` and `win32ole/ffi` in the same process.
+
+## Installation
+
+```ruby
+gem 'win32ole-ffi'
+```
+
+The gem depends on the `fiddle` gem on CRuby and on the `ffi` gem (which
+JRuby's Fiddle runs on) on JRuby.
+
+## Usage
+
+Require `win32ole/ffi` where you would require `win32ole`:
+
+```ruby
+require 'win32ole/ffi'
+
+dict = WIN32OLE.new('Scripting.Dictionary')
+dict.add('ruby', 'Ruby')
+dict.item('ruby') #=> "Ruby"
+```
+
+`WIN32OLE::Property`, the helper that ruby/win32ole's `olegen.rb`-generated
+code uses, is not included.
+
+## Development
+
+    $ git clone --recurse-submodules https://github.com/eitoball/win32ole-ffi
+    $ bundle install
+    $ bundle exec rake test
+
+`rake test` also runs ruby/win32ole's tests from the `vendor/win32ole`
+submodule. Before that it applies `patches/*.patch` to the submodule's
+working tree; `rake test:unpatch` reverts them.
+
+## License
+
+The same as ruby/win32ole: Ruby's license or BSD-2-Clause (see `COPYING`
+and `BSDL`).

data/lib/win32ole/ffi/array.rb

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+require 'fiddle'
+require 'win32ole/ffi/win32'
+
+class WIN32OLE
+  module SafeArray
+    W = Win32
+    private_constant :W
+
+    module_function
+
+    def oleaut32
+      W.oleaut32
+    end
+
+    def safe_array_create
+      @safe_array_create ||= Fiddle::Function.new(
+        oleaut32['SafeArrayCreate'], [W::WORD, W::DWORD, W::VOIDP], W::VOIDP, W::STDCALL
+      )
+    end
+
+    def safe_array_create_vector
+      @safe_array_create_vector ||= Fiddle::Function.new(
+        oleaut32['SafeArrayCreateVector'], [W::WORD, W::LONG, W::DWORD], W::VOIDP, W::STDCALL
+      )
+    end
+
+    def safe_array_destroy
+      @safe_array_destroy ||= Fiddle::Function.new(oleaut32['SafeArrayDestroy'], [W::VOIDP], W::LONG, W::STDCALL)
+    end
+
+    def safe_array_lock
+      @safe_array_lock ||= Fiddle::Function.new(oleaut32['SafeArrayLock'], [W::VOIDP], W::LONG, W::STDCALL)
+    end
+
+    def safe_array_unlock
+      @safe_array_unlock ||= Fiddle::Function.new(oleaut32['SafeArrayUnlock'], [W::VOIDP], W::LONG, W::STDCALL)
+    end
+
+    def safe_array_get_dim
+      @safe_array_get_dim ||= Fiddle::Function.new(oleaut32['SafeArrayGetDim'], [W::VOIDP], W::DWORD, W::STDCALL)
+    end
+
+    def safe_array_get_lbound
+      @safe_array_get_lbound ||= Fiddle::Function.new(
+        oleaut32['SafeArrayGetLBound'], [W::VOIDP, W::DWORD, W::VOIDP], W::LONG, W::STDCALL
+      )
+    end
+
+    def safe_array_get_ubound
+      @safe_array_get_ubound ||= Fiddle::Function.new(
+        oleaut32['SafeArrayGetUBound'], [W::VOIDP, W::DWORD, W::VOIDP], W::LONG, W::STDCALL
+      )
+    end
+
+    def safe_array_ptr_of_index
+      @safe_array_ptr_of_index ||= Fiddle::Function.new(
+        oleaut32['SafeArrayPtrOfIndex'], [W::VOIDP, W::VOIDP, W::VOIDP], W::LONG, W::STDCALL
+      )
+    end
+
+    def safe_array_put_element
+      @safe_array_put_element ||= Fiddle::Function.new(
+        oleaut32['SafeArrayPutElement'], [W::VOIDP, W::VOIDP, W::VOIDP], W::LONG, W::STDCALL
+      )
+    end
+
+    def safe_array_access_data
+      @safe_array_access_data ||= Fiddle::Function.new(
+        oleaut32['SafeArrayAccessData'], [W::VOIDP, W::VOIDP], W::LONG, W::STDCALL
+      )
+    end
+
+    def safe_array_unaccess_data
+      @safe_array_unaccess_data ||= Fiddle::Function.new(
+        oleaut32['SafeArrayUnaccessData'], [W::VOIDP], W::LONG, W::STDCALL
+      )
+    end
+
+    # Port of ext/win32ole/win32ole.c's dimension() (line 1148) -- the
+    # nesting depth is the MAX depth found across every branch, not just
+    # the first element, so a ragged/mixed input still gets a well-defined
+    # depth.
+    def dimension_count(val)
+      return 0 unless val.is_a?(::Array)
+
+      val.reduce(0) { |max, v| [max, dimension_count(v)].max } + 1
+    end
+
+    # Port of ary_len_of_dim() (line 1167) -- the size at nesting level
+    # `dim` (0-indexed, 0 == outermost) is the MAX size found across every
+    # branch at that depth.
+    def dimension_size(val, dim)
+      return 0 unless val.is_a?(::Array)
+      return val.size if dim.zero?
+
+      val.reduce(0) { |max, v| [max, dimension_size(v, dim - 1)].max }
+    end
+
+    def dimension_sizes(val)
+      dims = dimension_count(val)
+      Array.new(dims) { |d| dimension_size(val, d) }
+    end
+
+    # Port of ole_ary_m_entry() (line 963) -- pid[0] indexes the outermost
+    # Array, pid[1] the next level in, etc. Returns nil past a shorter
+    # (ragged) branch, matching Ruby's own Array#[] out-of-range behavior.
+    def nested_entry(val, pid)
+      obj = val
+      pid.each { |i| obj = obj.is_a?(::Array) ? obj[i] : nil }
+      obj
+    end
+
+    # Port of ole_set_safe_array()'s pid increment loop (line 1116): the
+    # LAST index (the innermost Ruby nesting level) varies fastest,
+    # carrying left on overflow. This is the order ruby_array_to_safearray
+    # writes elements in.
+    def each_fill_index(sizes)
+      return enum_for(:each_fill_index, sizes) unless block_given?
+
+      return if sizes.any?(&:zero?)
+
+      pid = Array.new(sizes.size, 0)
+      loop do
+        yield pid.dup
+        i = sizes.size - 1
+        loop do
+          pid[i] += 1
+          break if pid[i] < sizes[i]
+
+          pid[i] = 0
+          i -= 1
+          return if i.negative?
+        end
+      end
+    end
+
+    # Port of ole_variant2val()'s pid increment loop (line 1476): the
+    # FIRST index (SAFEARRAY's own dimension 0) varies fastest --
+    # deliberately the opposite order of each_fill_index above (see this
+    # task's own note on why). lbounds/ubounds are inclusive, one entry
+    # per dimension, as SafeArrayGetLBound/GetUBound return them.
+    def each_read_index(lbounds, ubounds)
+      return enum_for(:each_read_index, lbounds, ubounds) unless block_given?
+
+      return if lbounds.zip(ubounds).any? { |lb, ub| ub < lb }
+
+      pid = lbounds.dup
+      loop do
+        yield pid.dup
+        i = 0
+        loop do
+          pid[i] += 1
+          break if pid[i] <= ubounds[i]
+
+          pid[i] = lbounds[i]
+          i += 1
+          return if i == pid.size
+        end
+      end
+    end
+
+    POINTER_ELEMENT_TYPES = [W::VT_BSTR, W::VT_DISPATCH, W::VT_UNKNOWN].freeze
+
+    # One element's value, read the way ole_variant2val reads a SAFEARRAY:
+    # through a VT_BYREF VARIANT pointing at it, without taking ownership
+    # of anything the array still holds.
+    def read_element(elem_addr, base_vt)
+      byref = W.pack_variant(base_vt | W::VT_BYREF, W.pack_pointer(elem_addr))
+      WIN32OLE.variant_bytes_to_ruby_value(byref, owned: false)
+    end
+
+    # ole_set_safe_array's val2variant_ptr + SafeArrayPutElement: the
+    # value's natural VARIANT, coerced to the element type; a VT_VARIANT
+    # element takes the VARIANT itself, a BSTR/IDispatch/IUnknown element
+    # the pointer (SafeArrayPutElement copies or AddRefs it), any other the
+    # address of the value.
+    def write_element(psa, index_buf, base_vt, val, to_free)
+      if base_vt == W::VT_VARIANT
+        var = WIN32OLE.ruby_value_to_variant_bytes(val, to_free)
+        return put_element(psa, index_buf, W.native_pointer_for(var))
+      end
+
+      var = val.nil? ? W.pack_variant(base_vt, W.pack_empty) : WIN32OLE.ruby_value_to_variant_bytes(val, to_free)
+      natural_vt, = W.unpack_variant(var)
+      if natural_vt != base_vt
+        var = W.change_variant_type(var, base_vt)
+        converted_bstr = base_vt == W::VT_BSTR
+      end
+      _vt, payload = W.unpack_variant(var)
+      if POINTER_ELEMENT_TYPES.include?(base_vt)
+        ptr = W.unpack_pointer(payload)
+        if ptr.zero? && base_vt != W::VT_BSTR
+          raise WIN32OLE::RuntimeError, 'element of array does not have IDispatch or IUnknown Interface'
+        end
+
+        put_element(psa, index_buf, ptr)
+        W.sys_free_string.call(ptr) if converted_bstr && !ptr.zero?
+      else
+        put_element(psa, index_buf, W.native_pointer_for(payload))
+      end
+    end
+
+    def put_element(psa, index_buf, pv)
+      hr = safe_array_put_element.call(psa, index_buf, pv)
+      raise WIN32OLE::RuntimeError, "failed to SafeArrayPutElement: #{W.hr_hex(hr)}" if W.failed?(hr)
+    end
+
+    def ruby_array_to_safearray(ary, elem_vt, to_free = [])
+      base_vt = elem_vt & W::VT_TYPEMASK
+      base_vt = W::VT_VARIANT if base_vt.zero? # ole_val_ary2variant_ary: plain VT_ARRAY means VT_VARIANT elements
+      return ui1_safearray_from_bytes(ary) if base_vt == W::VT_UI1 && ary.is_a?(::String)
+      raise TypeError, "wrong argument type #{ary.class} (expected Array)" unless ary.is_a?(::Array)
+
+      sizes = dimension_sizes(ary)
+      dims = sizes.size
+      bounds = sizes.flat_map { |n| [n, 0] }.pack('L2' * dims)
+      psa = safe_array_create.call(base_vt, dims, bounds)
+      raise ::RuntimeError, 'memory allocation error' if psa.nil? || psa.to_i.zero?
+
+      hr = safe_array_lock.call(psa)
+      raise WIN32OLE::RuntimeError, "failed to SafeArrayLock: #{W.hr_hex(hr)}" if W.failed?(hr)
+
+      begin
+        each_fill_index(sizes) do |pid|
+          write_element(psa, pid.pack('l' * dims), base_vt, nested_entry(ary, pid), to_free)
+        end
+      ensure
+        safe_array_unlock.call(psa)
+      end
+      psa
+    end
+
+    def safearray_to_ruby_array(psa, elem_vt)
+      base_vt = elem_vt & W::VT_TYPEMASK
+
+      dim = safe_array_get_dim.call(psa)
+      lbounds = Array.new(dim) { |d| out = ("\x00" * 4).b; safe_array_get_lbound.call(psa, d + 1, out); out.unpack1('l') }
+      ubounds = Array.new(dim) { |d| out = ("\x00" * 4).b; safe_array_get_ubound.call(psa, d + 1, out); out.unpack1('l') }
+
+      hr = safe_array_lock.call(psa)
+      raise WIN32OLE::RuntimeError, "failed to SafeArrayLock: #{W.hr_hex(hr)}" if W.failed?(hr)
+
+      result = nested_array_skeleton(ubounds.zip(lbounds).map { |u, l| u - l + 1 })
+      begin
+        each_read_index(lbounds, ubounds) do |pid|
+          index_buf = pid.pack('l' * dim)
+          elem_ptr_out = ("\x00" * W::PTR_SIZE).b
+          hr = safe_array_ptr_of_index.call(psa, index_buf, elem_ptr_out)
+          raise WIN32OLE::RuntimeError, "failed to SafeArrayPtrOfIndex: #{W.hr_hex(hr)}" if W.failed?(hr)
+
+          val = read_element(elem_ptr_out.unpack1(W::PACK_PTR), base_vt)
+          zero_based_pid = pid.each_with_index.map { |v, d| v - lbounds[d] }
+          store_nested(result, zero_based_pid, val)
+        end
+      ensure
+        safe_array_unlock.call(psa)
+      end
+      result
+    end
+
+    def nested_array_skeleton(sizes)
+      return Array.new(sizes.first) if sizes.size == 1
+
+      Array.new(sizes.first) { nested_array_skeleton(sizes[1..]) }
+    end
+
+    def store_nested(ary, pid, val)
+      obj = ary
+      pid[0..-2].each { |i| obj = obj[i] }
+      obj[pid.last] = val
+    end
+
+    # VT_UI1|VT_ARRAY <-> String fast path: bulk-copy via
+    # SafeArrayAccessData instead of the generic per-element path above --
+    # a real, separate MRI code path (ole_val2olevariantdata's first
+    # branch / folevariant_value's dim==1 reverse path), not an
+    # optimization detail this design can skip: without it, a binary blob
+    # argument would round-trip through an Array of small Integers instead
+    # of staying a String.
+    def ui1_safearray_from_bytes(bytes)
+      bytes = bytes.b
+      bounds = [bytes.bytesize, 0].pack('L2')
+      psa = safe_array_create.call(W::VT_UI1, 1, bounds)
+      raise ::RuntimeError, 'memory allocation error' if psa.nil? || psa.to_i.zero?
+
+      data_out = ("\x00" * W::PTR_SIZE).b
+      hr = safe_array_access_data.call(psa, data_out)
+      raise WIN32OLE::RuntimeError, "failed to SafeArrayAccessData: #{W.hr_hex(hr)}" if W.failed?(hr)
+
+      Fiddle::Pointer.new(data_out.unpack1(W::PACK_PTR))[0, bytes.bytesize] = bytes
+      safe_array_unaccess_data.call(psa)
+      psa
+    end
+
+    def ui1_safearray_to_bytes(psa)
+      data_out = ("\x00" * W::PTR_SIZE).b
+      hr = safe_array_access_data.call(psa, data_out)
+      raise WIN32OLE::RuntimeError, "failed to SafeArrayAccessData: #{W.hr_hex(hr)}" if W.failed?(hr)
+
+      lb_out = ("\x00" * 4).b
+      ub_out = ("\x00" * 4).b
+      safe_array_get_lbound.call(psa, 1, lb_out)
+      safe_array_get_ubound.call(psa, 1, ub_out)
+      len = ub_out.unpack1('l') - lb_out.unpack1('l') + 1
+      bytes = Fiddle::Pointer.new(data_out.unpack1(W::PACK_PTR))[0, len].dup.b
+      safe_array_unaccess_data.call(psa)
+      bytes
+    end
+  end
+end

data/lib/win32ole/ffi/dispatch.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'win32ole/ffi/win32'
+
+class WIN32OLE
+  module Dispatch
+    W = WIN32OLE::Win32
+
+    def dispid_for(name)
+      ids = dispids_for([name])
+      ids && ids.first
+    end
+
+    # One GetIDsOfNames call for several names. Given a method name followed
+    # by parameter names, the parameters are resolved in that method's
+    # scope (what named arguments need). nil if the call fails.
+    def dispids_for(names)
+      raise WIN32OLE::RuntimeError, 'this WIN32OLE object has already been released' if @ptr.nil? || @ptr.zero?
+
+      name_bufs = names.map { |name| W.wstr(name) }
+      name_ptrs = name_bufs.map { |buf| W.native_pointer_for(buf) }
+      names_blob = name_ptrs.map(&:to_i).pack("#{W::PACK_PTR}*")
+      dispids = ("\x00" * (4 * names.size)).b
+      hr = get_ids_of_names_fn.call(@ptr, W::IID_NULL, names_blob, names.size, 0, dispids)
+      return nil if W.failed?(hr)
+
+      dispids.unpack('l*')
+    end
+
+    # ole_invoke's treatment of a trailing Hash: its entries become named
+    # arguments, their DISPIDs looked up together with the method name.
+    # Returns [positional_args, named_args], named_args being
+    # [[dispid, value], ...] or nil when there is no trailing Hash.
+    def split_named_args(name, args)
+      hash = args.last
+      return [args, nil] unless hash.is_a?(::Hash)
+
+      keys = hash.keys.map do |key|
+        case key
+        when ::String then key
+        when ::Symbol then key.to_s
+        else raise TypeError, 'wrong argument type (expected String or Symbol)'
+        end
+      end
+      ids = dispids_for([name, *keys])
+      raise WIN32OLE::RuntimeError, "failed to get named argument info: `#{name}'" if ids.nil?
+
+      [args[0...-1], ids.drop(1).zip(hash.values)]
+    end
+
+    # Returns [hr, result_variant_bytes, excepinfo_bytes]. Never raises —
+    # callers build the user-facing error message (they know whether this
+    # was a method call or a property-put, which changes the message).
+    # named_args ([[dispid, value], ...]) occupy the front of rgvarg, in
+    # order, ahead of the reversed positional arguments -- the layout
+    # ole_invoke builds; named_put marks the value as DISPID_PROPERTYPUT.
+    def ole_invoke(dispid, arg_values, wflags, named_put: false, named_args: nil)
+      raise WIN32OLE::RuntimeError, 'this WIN32OLE object has already been released' if @ptr.nil? || @ptr.zero?
+
+      keep_alive = []
+      to_free = []
+
+      named_args ||= []
+      values = named_args.map(&:last) + arg_values.reverse
+      arg_variants = values.map { |v| WIN32OLE.ruby_value_to_variant_bytes(v, to_free) }
+      args_blob = arg_variants.join
+      args_ptr = args_blob.empty? ? nil : W.native_pointer_for(args_blob)
+      keep_alive << args_ptr if args_ptr
+
+      named_ids = named_put ? [W::DISPID_PROPERTYPUT] : named_args.map(&:first)
+      named_blob = named_ids.pack('l*')
+      named_ptr = named_blob.empty? ? nil : W.native_pointer_for(named_blob)
+      keep_alive << named_ptr if named_ptr
+
+      # DISPPARAMS is a real native struct (VARIANTARG *rgvarg; DISPID
+      # *rgdispidNamedArgs; UINT cArgs; UINT cNamedArgs;) read positionally
+      # by the callee, so — unlike a VARIANT's self-designed padding — the
+      # two pointer fields MUST be packed at native pointer width (PACK_PTR),
+      # not a hardcoded 8 bytes, or this silently misaligns cArgs/cNamedArgs
+      # on x86.
+      dispparams = [
+        args_ptr ? args_ptr.to_i : 0,
+        named_ptr ? named_ptr.to_i : 0,
+        arg_variants.size,
+        named_ids.size
+      ].pack("#{W::PACK_PTR}#{W::PACK_PTR}LL")
+      keep_alive << dispparams
+
+      excepinfo = ("\x00" * W::EXCEPINFO_SIZE).b
+      result = ("\x00" * W::VARIANT_SIZE).b
+
+      hr = invoke_fn.call(@ptr, dispid, W::IID_NULL, 0, wflags, dispparams, result, excepinfo, nil)
+      to_free.each(&:call)
+      [hr, result, excepinfo]
+    end
+
+    def release
+      return unless @ptr && !@ptr.zero?
+
+      release_fn.call(@ptr)
+      @ptr = nil
+      ObjectSpace.undefine_finalizer(self)
+    end
+
+    private
+
+    def get_ids_of_names_fn
+      @get_ids_of_names_fn ||= W.vtable_function(
+        @ptr, 5, [W::VOIDP, W::VOIDP, W::VOIDP, W::DWORD, W::DWORD, W::VOIDP], W::LONG
+      )
+    end
+
+    def invoke_fn
+      @invoke_fn ||= W.vtable_function(
+        @ptr, 6,
+        [W::VOIDP, W::LONG, W::VOIDP, W::DWORD, W::WORD, W::VOIDP, W::VOIDP, W::VOIDP, W::VOIDP],
+        W::LONG
+      )
+    end
+
+    def release_fn
+      @release_fn ||= W.vtable_function(@ptr, 2, [W::VOIDP], W::DWORD)
+    end
+  end
+end