1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

add IDispatch wrapper in val2variant

Browse Source 
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@5710 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
suke 2004-02-15 06:53:15 +00:00
parent 30fd29a174
commit d780328362
2 changed files with 389 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
ChangeLog
View File

@ -1,3 +1,8 @@
Sun Feb 15 15:48:57 2004 Masaki Suketa <masaki.suketa@nifty.ne.jp>
* ext/win32ole/win32ole.c: add IDispatch wrapper in val2variant.
Thanks, arton.
Sun Feb 15 15:23:29 2004 Hirokazu Yamamoto <ocean@m2.ccsnet.ne.jp> Sun Feb 15 15:23:29 2004 Hirokazu Yamamoto <ocean@m2.ccsnet.ne.jp>
* ruby.h, dir.c (rb_glob): add const. * ruby.h, dir.c (rb_glob): add const.

624
ext/win32ole/win32ole.c
View File

@ -78,13 +78,13 @@
#define WC2VSTR(x) ole_wc2vstr((x), TRUE) #define WC2VSTR(x) ole_wc2vstr((x), TRUE)
#define WIN32OLE_VERSION "0.5.5" #define WIN32OLE_VERSION "0.5.6"
typedef HRESULT (STDAPICALLTYPE FNCOCREATEINSTANCEEX) typedef HRESULT (STDAPICALLTYPE FNCOCREATEINSTANCEEX)
(REFCLSID, IUnknown*, DWORD, COSERVERINFO*, DWORD, MULTI_QI*); (REFCLSID, IUnknown*, DWORD, COSERVERINFO*, DWORD, MULTI_QI*);
typedef HWND (WINAPI FNHTMLHELP)(HWND hwndCaller, LPCSTR pszFile, typedef HWND (WINAPI FNHTMLHELP)(HWND hwndCaller, LPCSTR pszFile,
UINT uCommand, DWORD dwData); UINT uCommand, DWORD dwData);
typedef struct { typedef struct {
struct IEventSinkVtbl * lpVtbl; struct IEventSinkVtbl * lpVtbl;
} IEventSink, *PEVENTSINK; } IEventSink, *PEVENTSINK;
@ -151,6 +151,8 @@ static BOOL gOLEInitialized = Qfalse;
static HINSTANCE ghhctrl = NULL; static HINSTANCE ghhctrl = NULL;
static HINSTANCE gole32 = NULL; static HINSTANCE gole32 = NULL;
static FNCOCREATEINSTANCEEX *gCoCreateInstanceEx = NULL; static FNCOCREATEINSTANCEEX *gCoCreateInstanceEx = NULL;
static VALUE com_hash;
static IDispatchVtbl com_vtbl;
struct oledata { struct oledata {
IDispatch *pDispatch; IDispatch *pDispatch;
@ -192,6 +194,137 @@ static VALUE foletype_s_allocate _((VALUE));
static VALUE oletype_set_member _((VALUE, ITypeInfo *, VALUE)); static VALUE oletype_set_member _((VALUE, ITypeInfo *, VALUE));
static VALUE olemethod_from_typeinfo _((VALUE, ITypeInfo *, VALUE)); static VALUE olemethod_from_typeinfo _((VALUE, ITypeInfo *, VALUE));
static HRESULT ole_docinfo_from_type _((ITypeInfo *, BSTR *, BSTR *, DWORD *, BSTR *)); static HRESULT ole_docinfo_from_type _((ITypeInfo *, BSTR *, BSTR *, DWORD *, BSTR *));
static char *ole_wc2mb(LPWSTR);
static VALUE ole_variant2val(VARIANT*);
static void ole_val2variant(VALUE, VARIANT*);
typedef struct _Win32OLEIDispatch
{
IDispatch dispatch;
ULONG refcount;
VALUE obj;
} Win32OLEIDispatch;
static HRESULT ( STDMETHODCALLTYPE QueryInterface )(
IDispatch __RPC_FAR * This,
/* [in] */ REFIID riid,
/* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
{
if (MEMCMP(riid, &IID_IUnknown, GUID, 1) == 0
|| MEMCMP(riid, &IID_IDispatch, GUID, 1) == 0)
{
Win32OLEIDispatch* p = (Win32OLEIDispatch*)This;
p->refcount++;
*ppvObject = This;
return S_OK;
}
return E_NOINTERFACE;
}
static ULONG ( STDMETHODCALLTYPE AddRef )(
IDispatch __RPC_FAR * This)
{
Win32OLEIDispatch* p = (Win32OLEIDispatch*)This;
return ++(p->refcount);
}
static ULONG ( STDMETHODCALLTYPE Release )(
IDispatch __RPC_FAR * This)
{
Win32OLEIDispatch* p = (Win32OLEIDispatch*)This;
ULONG u = --(p->refcount);
if (u == 0) {
st_data_t key = p->obj;
st_delete(DATA_PTR(com_hash), &key, 0);
free(p);
}
return u;
}
static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(
IDispatch __RPC_FAR * This,
/* [out] */ UINT __RPC_FAR *pctinfo)
{
return E_NOTIMPL;
}
static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(
IDispatch __RPC_FAR * This,
/* [in] */ UINT iTInfo,
/* [in] */ LCID lcid,
/* [out] */ ITypeInfo __RPC_FAR *__RPC_FAR *ppTInfo)
{
return E_NOTIMPL;
}
static HRESULT ( STDMETHODCALLTYPE GetIDsOfNames )(
IDispatch __RPC_FAR * This,
/* [in] */ REFIID riid,
/* [size_is][in] */ LPOLESTR __RPC_FAR *rgszNames,
/* [in] */ UINT cNames,
/* [in] */ LCID lcid,
/* [size_is][out] */ DISPID __RPC_FAR *rgDispId)
{
Win32OLEIDispatch* p = (Win32OLEIDispatch*)This;
char* psz = ole_wc2mb(*rgszNames); // support only one method
*rgDispId = rb_intern(psz);
free(psz);
return S_OK;
}
static /* [local] */ HRESULT ( STDMETHODCALLTYPE Invoke )(
IDispatch __RPC_FAR * This,
/* [in] */ DISPID dispIdMember,
/* [in] */ REFIID riid,
/* [in] */ LCID lcid,
/* [in] */ WORD wFlags,
/* [out][in] */ DISPPARAMS __RPC_FAR *pDispParams,
/* [out] */ VARIANT __RPC_FAR *pVarResult,
/* [out] */ EXCEPINFO __RPC_FAR *pExcepInfo,
/* [out] */ UINT __RPC_FAR *puArgErr)
{
VALUE v;
int i;
int args = pDispParams->cArgs;
Win32OLEIDispatch* p = (Win32OLEIDispatch*)This;
VALUE* parg = ALLOCA_N(VALUE, args);
for (i = 0; i < args; i++) {
*(parg + i) = ole_variant2val(&pDispParams->rgvarg[args - i - 1]);
}
if (dispIdMember == DISPID_VALUE) {
if (wFlags == DISPATCH_METHOD) {
dispIdMember = rb_intern("call");
} else if (wFlags & DISPATCH_PROPERTYGET) {
dispIdMember = rb_intern("value");
}
}
v = rb_funcall2(p->obj, dispIdMember, args, parg);
ole_val2variant(v, pVarResult);
return S_OK;
}
static IDispatch*
val2dispatch(val)
VALUE val;
{
struct st_table *tbl = DATA_PTR(com_hash);
Win32OLEIDispatch* pdisp;
st_data_t data;
if (st_lookup(tbl, val, &data)) {
pdisp = (Win32OLEIDispatch *)(data & ~FIXNUM_FLAG);
pdisp->refcount++;
}
else {
pdisp = ALLOC(Win32OLEIDispatch);
pdisp->dispatch.lpVtbl = &com_vtbl;
pdisp->refcount = 1;
pdisp->obj = val;
st_insert(tbl, val, (VALUE)pdisp | FIXNUM_FLAG);
}
return &pdisp->dispatch;
}
static void static void
time2d(hh, mm, ss, pv) time2d(hh, mm, ss, pv)
@ -469,12 +602,12 @@ ole_initialize()
ole_raise(hr, rb_eRuntimeError, "Fail : OLE initialize"); ole_raise(hr, rb_eRuntimeError, "Fail : OLE initialize");
} }
gOLEInitialized = Qtrue; gOLEInitialized = Qtrue;
/* /*
* In some situation, OleUninitialize does not work fine. ;-< * In some situation, OleUninitialize does not work fine. ;-<
*/ */
/* /*
atexit((void (*)(void))ole_uninitialize); atexit((void (*)(void))ole_uninitialize);
*/ */
} }
} }
@ -600,7 +733,7 @@ ole_val2variant(val, var)
struct oledata *pole; struct oledata *pole;
if(rb_obj_is_kind_of(val, cWIN32OLE)) { if(rb_obj_is_kind_of(val, cWIN32OLE)) {
Data_Get_Struct(val, struct oledata, pole); Data_Get_Struct(val, struct oledata, pole);
OLE_ADDREF(pole->pDispatch); OLE_ADDREF(pole->pDispatch);
V_VT(var) = VT_DISPATCH; V_VT(var) = VT_DISPATCH;
V_DISPATCH(var) = pole->pDispatch; V_DISPATCH(var) = pole->pDispatch;
return; return;
@ -678,9 +811,9 @@ ole_val2variant(val, var)
V_I4(var) = NUM2INT(val); V_I4(var) = NUM2INT(val);
break; break;
case T_BIGNUM: case T_BIGNUM:
V_VT(var) = VT_R8; V_VT(var) = VT_R8;
V_R8(var) = rb_big2dbl(val); V_R8(var) = rb_big2dbl(val);
break; break;
case T_FLOAT: case T_FLOAT:
V_VT(var) = VT_R8; V_VT(var) = VT_R8;
V_R8(var) = NUM2DBL(val); V_R8(var) = NUM2DBL(val);
@ -698,7 +831,8 @@ ole_val2variant(val, var)
V_ERROR(var) = DISP_E_PARAMNOTFOUND; V_ERROR(var) = DISP_E_PARAMNOTFOUND;
break; break;
default: default:
rb_raise(rb_eTypeError, "not valid value"); V_VT(var) = VT_DISPATCH;
V_DISPATCH(var) = val2dispatch(val);
break; break;
} }
} }
@ -889,7 +1023,7 @@ ole_variant2val(pvar)
pDispatch = V_DISPATCH(pvar); pDispatch = V_DISPATCH(pvar);
if (pDispatch != NULL ) { if (pDispatch != NULL ) {
OLE_ADDREF(pDispatch); OLE_ADDREF(pDispatch);
obj = create_win32ole_object(cWIN32OLE, pDispatch, 0, 0); obj = create_win32ole_object(cWIN32OLE, pDispatch, 0, 0);
} }
break; break;
@ -1012,7 +1146,7 @@ typelib_file_from_clsid(ole)
hr = CLSIDFromProgID(pbuf, &clsid); hr = CLSIDFromProgID(pbuf, &clsid);
SysFreeString(pbuf); SysFreeString(pbuf);
if (FAILED(hr)) { if (FAILED(hr)) {
return Qnil; return Qnil;
} }
StringFromCLSID(&clsid, &pbuf); StringFromCLSID(&clsid, &pbuf);
vclsid = WC2VSTR(pbuf); vclsid = WC2VSTR(pbuf);
@ -1070,7 +1204,7 @@ typelib_file_from_typelib(ole)
if (typelib == Qnil) if (typelib == Qnil)
continue; continue;
if (rb_str_cmp(typelib, ole) == 0) { if (rb_str_cmp(typelib, ole) == 0) {
for(k = 0; !found; k++) { for(k = 0; !found; k++) {
lang = reg_enum_key(hversion, k); lang = reg_enum_key(hversion, k);
if (lang == Qnil) if (lang == Qnil)
break; break;
@ -1096,7 +1230,7 @@ typelib_file(ole)
{ {
VALUE file = typelib_file_from_clsid(ole); VALUE file = typelib_file_from_clsid(ole);
if (file != Qnil) { if (file != Qnil) {
return file; return file;
} }
return typelib_file_from_typelib(ole); return typelib_file_from_typelib(ole);
} }
@ -1198,8 +1332,8 @@ clsid_from_remote(host, com, pclsid)
pbuf = ole_mb2wc(clsid, -1); pbuf = ole_mb2wc(clsid, -1);
hr = CLSIDFromString(pbuf, pclsid); hr = CLSIDFromString(pbuf, pclsid);
SysFreeString(pbuf); SysFreeString(pbuf);
} }
else { else {
hr = HRESULT_FROM_WIN32(err); hr = HRESULT_FROM_WIN32(err);
} }
RegCloseKey(hpid); RegCloseKey(hpid);
@ -1294,7 +1428,7 @@ ole_bind_obj(moniker, argc, argv, self)
} }
hr = pMoniker->lpVtbl->BindToObject(pMoniker, pBindCtx, NULL, hr = pMoniker->lpVtbl->BindToObject(pMoniker, pBindCtx, NULL,
&IID_IDispatch, &IID_IDispatch,
(void**)&pDispatch); (void**)&pDispatch);
OLE_RELEASE(pMoniker); OLE_RELEASE(pMoniker);
OLE_RELEASE(pBindCtx); OLE_RELEASE(pBindCtx);
@ -1332,8 +1466,8 @@ fole_s_connect(argc, argv, self)
rb_scan_args(argc, argv, "1*", &svr_name, &others); rb_scan_args(argc, argv, "1*", &svr_name, &others);
if (ruby_safe_level > 0 && OBJ_TAINTED(svr_name)) { if (ruby_safe_level > 0 && OBJ_TAINTED(svr_name)) {
rb_raise(rb_eSecurityError, "Insecure Object Connection - %s", rb_raise(rb_eSecurityError, "Insecure Object Connection - %s",
StringValuePtr(svr_name)); StringValuePtr(svr_name));
} }
/* get CLSID from OLE server name */ /* get CLSID from OLE server name */
@ -1420,12 +1554,12 @@ fole_s_const_load(argc, argv, self)
else if(TYPE(ole) == T_STRING) { else if(TYPE(ole) == T_STRING) {
file = typelib_file(ole); file = typelib_file(ole);
if (file == Qnil) { if (file == Qnil) {
file = ole; file = ole;
} }
pBuf = ole_mb2wc(StringValuePtr(file), -1); pBuf = ole_mb2wc(StringValuePtr(file), -1);
hr = LoadTypeLibEx(pBuf, REGKIND_NONE, &pTypeLib); hr = LoadTypeLibEx(pBuf, REGKIND_NONE, &pTypeLib);
SysFreeString(pBuf); SysFreeString(pBuf);
if (FAILED(hr)) if (FAILED(hr))
ole_raise(hr, eWIN32OLE_RUNTIME_ERROR, "Fail to LoadTypeLibEx"); ole_raise(hr, eWIN32OLE_RUNTIME_ERROR, "Fail to LoadTypeLibEx");
if(TYPE(klass) != T_NIL) { if(TYPE(klass) != T_NIL) {
ole_const_load(pTypeLib, klass, self); ole_const_load(pTypeLib, klass, self);
@ -1460,17 +1594,17 @@ ole_classes_from_typelib(pTypeLib, classes)
hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i, hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
&bstr, NULL, NULL, NULL); &bstr, NULL, NULL, NULL);
if (FAILED(hr)) if (FAILED(hr))
continue; continue;
hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo); hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
if (FAILED(hr)) if (FAILED(hr))
continue; continue;
type = foletype_s_allocate(cWIN32OLE_TYPE); type = foletype_s_allocate(cWIN32OLE_TYPE);
oletype_set_member(type, pTypeInfo, WC2VSTR(bstr)); oletype_set_member(type, pTypeInfo, WC2VSTR(bstr));
rb_ary_push(classes, type); rb_ary_push(classes, type);
OLE_RELEASE(pTypeInfo); OLE_RELEASE(pTypeInfo);
} }
return classes; return classes;
} }
@ -1481,7 +1615,7 @@ reference_count(pole)
{ {
ULONG n = 0; ULONG n = 0;
if(pole->pDispatch) { if(pole->pDispatch) {
OLE_ADDREF(pole->pDispatch); OLE_ADDREF(pole->pDispatch);
n = OLE_RELEASE(pole->pDispatch); n = OLE_RELEASE(pole->pDispatch);
} }
return n; return n;
@ -1546,7 +1680,7 @@ ole_show_help(helpfile, helpcontext)
hwnd = pfnHtmlHelp(GetDesktopWindow(), StringValuePtr(helpfile), hwnd = pfnHtmlHelp(GetDesktopWindow(), StringValuePtr(helpfile),
0x0f, NUM2INT(helpcontext)); 0x0f, NUM2INT(helpcontext));
if (hwnd == 0) if (hwnd == 0)
hwnd = pfnHtmlHelp(GetDesktopWindow(), StringValuePtr(helpfile), hwnd = pfnHtmlHelp(GetDesktopWindow(), StringValuePtr(helpfile),
0, NUM2INT(helpcontext)); 0, NUM2INT(helpcontext));
return hwnd; return hwnd;
} }
@ -1611,14 +1745,14 @@ fole_initialize(argc, argv, self)
rb_scan_args(argc, argv, "11*", &svr_name, &host, &others); rb_scan_args(argc, argv, "11*", &svr_name, &host, &others);
if (ruby_safe_level > 0 && OBJ_TAINTED(svr_name)) { if (ruby_safe_level > 0 && OBJ_TAINTED(svr_name)) {
rb_raise(rb_eSecurityError, "Insecure Object Creation - %s", rb_raise(rb_eSecurityError, "Insecure Object Creation - %s",
StringValuePtr(svr_name)); StringValuePtr(svr_name));
} }
if (!NIL_P(host)) { if (!NIL_P(host)) {
if (ruby_safe_level > 0 && OBJ_TAINTED(host)) { if (ruby_safe_level > 0 && OBJ_TAINTED(host)) {
rb_raise(rb_eSecurityError, "Insecure Object Creation - %s", rb_raise(rb_eSecurityError, "Insecure Object Creation - %s",
StringValuePtr(svr_name)); StringValuePtr(svr_name));
} }
return ole_create_dcom(argc, argv, self); return ole_create_dcom(argc, argv, self);
} }
@ -1695,8 +1829,8 @@ set_argv(realargs, beg, end)
Check_Type(argv, T_ARRAY); Check_Type(argv, T_ARRAY);
rb_ary_clear(argv); rb_ary_clear(argv);
while (end-- > beg) { while (end-- > beg) {
rb_ary_push(argv, ole_variant2val(&realargs[end])); rb_ary_push(argv, ole_variant2val(&realargs[end]));
VariantClear(&realargs[end]); VariantClear(&realargs[end]);
} }
return argv; return argv;
} }
@ -1741,7 +1875,7 @@ ole_invoke(argc, argv, self, wFlags)
rb_scan_args(argc, argv, "1*", &cmd, &paramS); rb_scan_args(argc, argv, "1*", &cmd, &paramS);
OLEData_Get_Struct(self, pole); OLEData_Get_Struct(self, pole);
if(!pole->pDispatch) { if(!pole->pDispatch) {
rb_raise(rb_eRuntimeError, "Fail to get dispatch interface."); rb_raise(rb_eRuntimeError, "Fail to get dispatch interface.");
} }
wcmdname = ole_mb2wc(StringValuePtr(cmd), -1); wcmdname = ole_mb2wc(StringValuePtr(cmd), -1);
hr = pole->pDispatch->lpVtbl->GetIDsOfNames( pole->pDispatch, &IID_NULL, hr = pole->pDispatch->lpVtbl->GetIDsOfNames( pole->pDispatch, &IID_NULL,
@ -1810,9 +1944,9 @@ ole_invoke(argc, argv, self, wFlags)
VariantInit(&op.dp.rgvarg[n]); VariantInit(&op.dp.rgvarg[n]);
param = rb_ary_entry(paramS, i-cNamedArgs); param = rb_ary_entry(paramS, i-cNamedArgs);
ole_val2variant(param, &realargs[n]); ole_val2variant(param, &realargs[n]);
V_VT(&op.dp.rgvarg[n]) = VT_VARIANT | VT_BYREF; V_VT(&op.dp.rgvarg[n]) = VT_VARIANT | VT_BYREF;
V_VARIANTREF(&op.dp.rgvarg[n]) = &realargs[n]; V_VARIANTREF(&op.dp.rgvarg[n]) = &realargs[n];
} }
} }
@ -1862,7 +1996,7 @@ ole_invoke(argc, argv, self, wFlags)
} }
/* clear dispatch parameter */ /* clear dispatch parameter */
if(op.dp.cArgs > cNamedArgs) { if(op.dp.cArgs > cNamedArgs) {
set_argv(realargs, cNamedArgs, op.dp.cArgs); set_argv(realargs, cNamedArgs, op.dp.cArgs);
} }
else { else {
for(i = 0; i < op.dp.cArgs; i++) { for(i = 0; i < op.dp.cArgs; i++) {
@ -1923,136 +2057,136 @@ ole_invoke2(self, dispid, args, types, dispkind)
realargs = ALLOCA_N(VARIANTARG, dispParams.cArgs); realargs = ALLOCA_N(VARIANTARG, dispParams.cArgs);
for (i = 0, j = dispParams.cArgs - 1; i < (int)dispParams.cArgs; i++, j--) for (i = 0, j = dispParams.cArgs - 1; i < (int)dispParams.cArgs; i++, j--)
{ {
VariantInit(&realargs[i]); VariantInit(&realargs[i]);
VariantInit(&dispParams.rgvarg[i]); VariantInit(&dispParams.rgvarg[i]);
tp = rb_ary_entry(types, j); tp = rb_ary_entry(types, j);
vt = (VARTYPE)FIX2INT(tp); vt = (VARTYPE)FIX2INT(tp);
V_VT(&dispParams.rgvarg[i]) = vt; V_VT(&dispParams.rgvarg[i]) = vt;
param = rb_ary_entry(args, j); param = rb_ary_entry(args, j);
if (param == Qnil) if (param == Qnil)
{ {
V_VT(&dispParams.rgvarg[i]) = V_VT(&realargs[i]) = VT_ERROR; V_VT(&dispParams.rgvarg[i]) = V_VT(&realargs[i]) = VT_ERROR;
V_ERROR(&dispParams.rgvarg[i]) = V_ERROR(&realargs[i]) = DISP_E_PARAMNOTFOUND; V_ERROR(&dispParams.rgvarg[i]) = V_ERROR(&realargs[i]) = DISP_E_PARAMNOTFOUND;
} }
else else
{ {
if (vt & VT_ARRAY) if (vt & VT_ARRAY)
{ {
int ent; int ent;
LPBYTE pb; LPBYTE pb;
short* ps; short* ps;
LPLONG pl; LPLONG pl;
VARIANT* pv; VARIANT* pv;
CY *py; CY *py;
VARTYPE v; VARTYPE v;
SAFEARRAYBOUND rgsabound[1]; SAFEARRAYBOUND rgsabound[1];
Check_Type(param, T_ARRAY); Check_Type(param, T_ARRAY);
rgsabound[0].lLbound = 0; rgsabound[0].lLbound = 0;
rgsabound[0].cElements = RARRAY(param)->len; rgsabound[0].cElements = RARRAY(param)->len;
v = vt & ~(VT_ARRAY | VT_BYREF); v = vt & ~(VT_ARRAY | VT_BYREF);
V_ARRAY(&realargs[i]) = SafeArrayCreate(v, 1, rgsabound); V_ARRAY(&realargs[i]) = SafeArrayCreate(v, 1, rgsabound);
V_VT(&realargs[i]) = VT_ARRAY | v; V_VT(&realargs[i]) = VT_ARRAY | v;
SafeArrayLock(V_ARRAY(&realargs[i])); SafeArrayLock(V_ARRAY(&realargs[i]));
pb = V_ARRAY(&realargs[i])->pvData; pb = V_ARRAY(&realargs[i])->pvData;
ps = V_ARRAY(&realargs[i])->pvData; ps = V_ARRAY(&realargs[i])->pvData;
pl = V_ARRAY(&realargs[i])->pvData; pl = V_ARRAY(&realargs[i])->pvData;
py = V_ARRAY(&realargs[i])->pvData; py = V_ARRAY(&realargs[i])->pvData;
pv = V_ARRAY(&realargs[i])->pvData; pv = V_ARRAY(&realargs[i])->pvData;
for (ent = 0; ent < (int)rgsabound[0].cElements; ent++) for (ent = 0; ent < (int)rgsabound[0].cElements; ent++)
{ {
VARIANT velem; VARIANT velem;
VALUE elem = rb_ary_entry(param, ent); VALUE elem = rb_ary_entry(param, ent);
ole_val2variant(elem, &velem); ole_val2variant(elem, &velem);
if (v != VT_VARIANT) if (v != VT_VARIANT)
{ {
VariantChangeTypeEx(&velem, &velem, VariantChangeTypeEx(&velem, &velem,
LOCALE_SYSTEM_DEFAULT, 0, v); LOCALE_SYSTEM_DEFAULT, 0, v);
} }
switch (v) switch (v)
{ {
/* 128 bits */ /* 128 bits */
case VT_VARIANT: case VT_VARIANT:
*pv++ = velem; *pv++ = velem;
break; break;
/* 64 bits */ /* 64 bits */
case VT_R8: case VT_R8:
case VT_CY: case VT_CY:
case VT_DATE: case VT_DATE:
*py++ = V_CY(&velem); *py++ = V_CY(&velem);
break; break;
/* 16 bits */ /* 16 bits */
case VT_BOOL: case VT_BOOL:
case VT_I2: case VT_I2:
case VT_UI2: case VT_UI2:
*ps++ = V_I2(&velem); *ps++ = V_I2(&velem);
break; break;
/* 8 bites */ /* 8 bites */
case VT_UI1: case VT_UI1:
case VT_I1: case VT_I1:
*pb++ = V_UI1(&velem); *pb++ = V_UI1(&velem);
break; break;
/* 32 bits */ /* 32 bits */
default: default:
*pl++ = V_I4(&velem); *pl++ = V_I4(&velem);
break; break;
} }
} }
SafeArrayUnlock(V_ARRAY(&realargs[i])); SafeArrayUnlock(V_ARRAY(&realargs[i]));
} }
else else
{ {
ole_val2variant(param, &realargs[i]); ole_val2variant(param, &realargs[i]);
if ((vt & (~VT_BYREF)) != VT_VARIANT) if ((vt & (~VT_BYREF)) != VT_VARIANT)
{ {
hr = VariantChangeTypeEx(&realargs[i], &realargs[i], hr = VariantChangeTypeEx(&realargs[i], &realargs[i],
LOCALE_SYSTEM_DEFAULT, 0, LOCALE_SYSTEM_DEFAULT, 0,
(VARTYPE)(vt & (~VT_BYREF))); (VARTYPE)(vt & (~VT_BYREF)));
if (hr != S_OK) if (hr != S_OK)
{ {
rb_raise(rb_eTypeError, "not valid value"); rb_raise(rb_eTypeError, "not valid value");
} }
} }
} }
if ((vt & VT_BYREF) || vt == VT_VARIANT) if ((vt & VT_BYREF) || vt == VT_VARIANT)
{ {
if (vt == VT_VARIANT) if (vt == VT_VARIANT)
V_VT(&dispParams.rgvarg[i]) = VT_VARIANT | VT_BYREF; V_VT(&dispParams.rgvarg[i]) = VT_VARIANT | VT_BYREF;
switch (vt & (~VT_BYREF)) switch (vt & (~VT_BYREF))
{ {
/* 128 bits */ /* 128 bits */
case VT_VARIANT: case VT_VARIANT:
V_VARIANTREF(&dispParams.rgvarg[i]) = &realargs[i]; V_VARIANTREF(&dispParams.rgvarg[i]) = &realargs[i];
break; break;
/* 64 bits */ /* 64 bits */
case VT_R8: case VT_R8:
case VT_CY: case VT_CY:
case VT_DATE: case VT_DATE:
V_CYREF(&dispParams.rgvarg[i]) = &V_CY(&realargs[i]); V_CYREF(&dispParams.rgvarg[i]) = &V_CY(&realargs[i]);
break; break;
/* 16 bits */ /* 16 bits */
case VT_BOOL: case VT_BOOL:
case VT_I2: case VT_I2:
case VT_UI2: case VT_UI2:
V_I2REF(&dispParams.rgvarg[i]) = &V_I2(&realargs[i]); V_I2REF(&dispParams.rgvarg[i]) = &V_I2(&realargs[i]);
break; break;
/* 8 bites */ /* 8 bites */
case VT_UI1: case VT_UI1:
case VT_I1: case VT_I1:
V_UI1REF(&dispParams.rgvarg[i]) = &V_UI1(&realargs[i]); V_UI1REF(&dispParams.rgvarg[i]) = &V_UI1(&realargs[i]);
break; break;
/* 32 bits */ /* 32 bits */
default: default:
V_I4REF(&dispParams.rgvarg[i]) = &V_I4(&realargs[i]); V_I4REF(&dispParams.rgvarg[i]) = &V_I4(&realargs[i]);
break; break;
} }
} }
else else
{ {
/* copy 64 bits of data */ /* copy 64 bits of data */
V_CY(&dispParams.rgvarg[i]) = V_CY(&realargs[i]); V_CY(&dispParams.rgvarg[i]) = V_CY(&realargs[i]);
} }
} }
} }
if (dispkind & DISPATCH_PROPERTYPUT) { if (dispkind & DISPATCH_PROPERTYPUT) {
@ -2075,7 +2209,7 @@ ole_invoke2(self, dispid, args, types, dispkind)
/* clear dispatch parameter */ /* clear dispatch parameter */
if(dispParams.cArgs > 0) { if(dispParams.cArgs > 0) {
set_argv(realargs, 0, dispParams.cArgs); set_argv(realargs, 0, dispParams.cArgs);
} }
obj = ole_variant2val(&result); obj = ole_variant2val(&result);
@ -2246,7 +2380,7 @@ ole_each_sub(pEnumV)
obj = ole_variant2val(&variant); obj = ole_variant2val(&variant);
VariantClear(&variant); VariantClear(&variant);
VariantInit(&variant); VariantInit(&variant);
rb_yield(obj); rb_yield(obj);
} }
return Qnil; return Qnil;
} }
@ -2368,8 +2502,8 @@ ole_method_sub(self, pOwnerTypeInfo, pTypeInfo, name)
} }
for(i = 0; i < pTypeAttr->cFuncs && method == Qnil; i++) { for(i = 0; i < pTypeAttr->cFuncs && method == Qnil; i++) {
hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc); hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
if (FAILED(hr)) if (FAILED(hr))
continue; continue;
hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid, hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
&bstr, NULL, NULL, NULL); &bstr, NULL, NULL, NULL);
@ -2377,13 +2511,13 @@ ole_method_sub(self, pOwnerTypeInfo, pTypeInfo, name)
pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc); pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
continue; continue;
} }
fname = WC2VSTR(bstr); fname = WC2VSTR(bstr);
if (strcasecmp(StringValuePtr(name), StringValuePtr(fname)) == 0) { if (strcasecmp(StringValuePtr(name), StringValuePtr(fname)) == 0) {
olemethod_set_member(self, pTypeInfo, pOwnerTypeInfo, i, fname); olemethod_set_member(self, pTypeInfo, pOwnerTypeInfo, i, fname);
method = self; method = self;
} }
pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc); pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
pFuncDesc=NULL; pFuncDesc=NULL;
} }
OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr); OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
return method; return method;
@ -2444,8 +2578,8 @@ ole_methods_sub(pOwnerTypeInfo, pTypeInfo, methods, mask)
for(i = 0; i < pTypeAttr->cFuncs; i++) { for(i = 0; i < pTypeAttr->cFuncs; i++) {
pstr = NULL; pstr = NULL;
hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc); hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
if (FAILED(hr)) if (FAILED(hr))
continue; continue;
hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid, hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
&bstr, NULL, NULL, NULL); &bstr, NULL, NULL, NULL);
@ -2453,14 +2587,14 @@ ole_methods_sub(pOwnerTypeInfo, pTypeInfo, methods, mask)
pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc); pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
continue; continue;
} }
if(pFuncDesc->invkind & mask) { if(pFuncDesc->invkind & mask) {
method = folemethod_s_allocate(cWIN32OLE_METHOD); method = folemethod_s_allocate(cWIN32OLE_METHOD);
olemethod_set_member(method, pTypeInfo, pOwnerTypeInfo, olemethod_set_member(method, pTypeInfo, pOwnerTypeInfo,
i, WC2VSTR(bstr)); i, WC2VSTR(bstr));
rb_ary_push(methods, method); rb_ary_push(methods, method);
} }
pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc); pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
pFuncDesc=NULL; pFuncDesc=NULL;
} }
OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr); OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
@ -2649,7 +2783,7 @@ fole_obj_help( self )
&bstr, NULL, NULL, NULL); &bstr, NULL, NULL, NULL);
if (SUCCEEDED(hr)) { if (SUCCEEDED(hr)) {
type = foletype_s_allocate(cWIN32OLE_TYPE); type = foletype_s_allocate(cWIN32OLE_TYPE);
oletype_set_member(type, pTypeInfo, WC2VSTR(bstr)); oletype_set_member(type, pTypeInfo, WC2VSTR(bstr));
} }
OLE_RELEASE(pTypeLib); OLE_RELEASE(pTypeLib);
OLE_RELEASE(pTypeInfo); OLE_RELEASE(pTypeInfo);
@ -2698,7 +2832,7 @@ ole_usertype2val(pTypeInfo, pTypeDesc, typedetails)
hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
V_UNION1(pTypeDesc, hreftype), V_UNION1(pTypeDesc, hreftype),
&pRefTypeInfo); &pRefTypeInfo);
if(FAILED(hr)) if(FAILED(hr))
return Qnil; return Qnil;
hr = ole_docinfo_from_type(pRefTypeInfo, &bstr, NULL, NULL, NULL); hr = ole_docinfo_from_type(pRefTypeInfo, &bstr, NULL, NULL, NULL);
@ -2723,13 +2857,13 @@ ole_ptrtype2val(pTypeInfo, pTypeDesc, typedetails)
TYPEDESC *p = pTypeDesc; TYPEDESC *p = pTypeDesc;
VALUE type = rb_str_new2(""); VALUE type = rb_str_new2("");
while(p->vt == VT_PTR || p->vt == VT_SAFEARRAY) { while(p->vt == VT_PTR || p->vt == VT_SAFEARRAY) {
p = V_UNION1(p, lptdesc); p = V_UNION1(p, lptdesc);
if(strlen(StringValuePtr(type)) == 0) { if(strlen(StringValuePtr(type)) == 0) {
type = ole_typedesc2val(pTypeInfo, p, typedetails); type = ole_typedesc2val(pTypeInfo, p, typedetails);
} else { } else {
rb_str_cat(type, ",", 1); rb_str_cat(type, ",", 1);
rb_str_concat(type, ole_typedesc2val(pTypeInfo, p, typedetails)); rb_str_concat(type, ole_typedesc2val(pTypeInfo, p, typedetails));
} }
} }
return type; return type;
} }
@ -2838,16 +2972,16 @@ ole_typedesc2val(pTypeInfo, pTypeDesc, typedetails)
if(typedetails != Qnil) if(typedetails != Qnil)
rb_ary_push(typedetails, rb_str_new2("USERDEFINED")); rb_ary_push(typedetails, rb_str_new2("USERDEFINED"));
str = ole_usertype2val(pTypeInfo, pTypeDesc, typedetails); str = ole_usertype2val(pTypeInfo, pTypeDesc, typedetails);
if (str != Qnil) { if (str != Qnil) {
return str; return str;
} }
return rb_str_new2("USERDEFINED"); return rb_str_new2("USERDEFINED");
case VT_UNKNOWN: case VT_UNKNOWN:
return rb_str_new2("UNKNOWN"); return rb_str_new2("UNKNOWN");
case VT_DISPATCH: case VT_DISPATCH:
if(typedetails != Qnil) if(typedetails != Qnil)
rb_ary_push(typedetails, rb_str_new2("DISPATCH")); rb_ary_push(typedetails, rb_str_new2("DISPATCH"));
return rb_str_new2("DISPATCH"); return rb_str_new2("DISPATCH");
default: default:
str = rb_str_new2("Unknown Type "); str = rb_str_new2("Unknown Type ");
rb_str_concat(str, rb_fix2str(INT2FIX(pTypeDesc->vt), 10)); rb_str_concat(str, rb_fix2str(INT2FIX(pTypeDesc->vt), 10));
@ -2882,7 +3016,7 @@ fole_method_help( self, cmdname )
OLE_RELEASE(pTypeInfo); OLE_RELEASE(pTypeInfo);
if (obj == Qnil) if (obj == Qnil)
rb_raise(eWIN32OLE_RUNTIME_ERROR, "Not found %s", rb_raise(eWIN32OLE_RUNTIME_ERROR, "Not found %s",
StringValuePtr(cmdname)); StringValuePtr(cmdname));
return obj; return obj;
} }
@ -2906,17 +3040,17 @@ foletype_s_ole_classes(self, typelib)
if(TYPE(typelib) == T_STRING) { if(TYPE(typelib) == T_STRING) {
file = typelib_file(typelib); file = typelib_file(typelib);
if (file == Qnil) { if (file == Qnil) {
file = typelib; file = typelib;
} }
pbuf = ole_mb2wc(StringValuePtr(file), -1); pbuf = ole_mb2wc(StringValuePtr(file), -1);
hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib); hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
if (FAILED(hr)) if (FAILED(hr))
ole_raise(hr, eWIN32OLE_RUNTIME_ERROR, "Fail to LoadTypeLibEx"); ole_raise(hr, eWIN32OLE_RUNTIME_ERROR, "Fail to LoadTypeLibEx");
SysFreeString(pbuf); SysFreeString(pbuf);
ole_classes_from_typelib(pTypeLib, classes); ole_classes_from_typelib(pTypeLib, classes);
OLE_RELEASE(pTypeLib); OLE_RELEASE(pTypeLib);
} else { } else {
rb_raise(rb_eTypeError, "1st argument should be TypeLib string"); rb_raise(rb_eTypeError, "1st argument should be TypeLib string");
} }
return classes; return classes;
} }
@ -3055,13 +3189,13 @@ oleclass_from_typelib(self, pTypeLib, oleclass)
hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i, hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
&bstr, NULL, NULL, NULL); &bstr, NULL, NULL, NULL);
if (FAILED(hr)) if (FAILED(hr))
continue; continue;
typelib = WC2VSTR(bstr); typelib = WC2VSTR(bstr);
if (rb_str_cmp(oleclass, typelib) == 0) { if (rb_str_cmp(oleclass, typelib) == 0) {
oletype_set_member(self, pTypeInfo, typelib); oletype_set_member(self, pTypeInfo, typelib);
found = Qtrue; found = Qtrue;
} }
OLE_RELEASE(pTypeInfo); OLE_RELEASE(pTypeInfo);
} }
return found; return found;
} }
@ -3091,7 +3225,7 @@ foletype_initialize(self, typelib, oleclass)
if (oleclass_from_typelib(self, pTypeLib, oleclass) == Qfalse) { if (oleclass_from_typelib(self, pTypeLib, oleclass) == Qfalse) {
OLE_RELEASE(pTypeLib); OLE_RELEASE(pTypeLib);
rb_raise(eWIN32OLE_RUNTIME_ERROR, "Not found `%s` in `%s`", rb_raise(eWIN32OLE_RUNTIME_ERROR, "Not found `%s` in `%s`",
StringValuePtr(oleclass), StringValuePtr(typelib)); StringValuePtr(oleclass), StringValuePtr(typelib));
} }
OLE_RELEASE(pTypeLib); OLE_RELEASE(pTypeLib);
return self; return self;
@ -3396,7 +3530,7 @@ ole_type_src_type(pTypeInfo)
return alias; return alias;
if(pTypeAttr->typekind != TKIND_ALIAS) { if(pTypeAttr->typekind != TKIND_ALIAS) {
OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr); OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
return alias; return alias;
} }
alias = ole_typedesc2val(pTypeInfo, &(pTypeAttr->tdescAlias), Qnil); alias = ole_typedesc2val(pTypeInfo, &(pTypeAttr->tdescAlias), Qnil);
OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr); OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
@ -3495,22 +3629,22 @@ ole_variables(pTypeInfo)
if(FAILED(hr)) if(FAILED(hr))
continue; continue;
len = 0; len = 0;
pstr = NULL; pstr = NULL;
hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr, hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
1, &len); 1, &len);
if(FAILED(hr) || len == 0 || !bstr) if(FAILED(hr) || len == 0 || !bstr)
continue; continue;
var = Data_Make_Struct(cWIN32OLE_VARIABLE, struct olevariabledata, var = Data_Make_Struct(cWIN32OLE_VARIABLE, struct olevariabledata,
0,olevariable_free,pvar); 0,olevariable_free,pvar);
pvar->pTypeInfo = pTypeInfo; pvar->pTypeInfo = pTypeInfo;
OLE_ADDREF(pTypeInfo); OLE_ADDREF(pTypeInfo);
pvar->index = i; pvar->index = i;
rb_ivar_set(var, rb_intern("name"), WC2VSTR(bstr)); rb_ivar_set(var, rb_intern("name"), WC2VSTR(bstr));
rb_ary_push(variables, var); rb_ary_push(variables, var);
pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc); pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
pVarDesc = NULL; pVarDesc = NULL;
} }
OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr); OLE_RELEASE_TYPEATTR(pTypeInfo, pTypeAttr);
return variables; return variables;
@ -3800,10 +3934,10 @@ folemethod_initialize(self, oletype, method)
if (rb_obj_is_kind_of(oletype, cWIN32OLE_TYPE)) { if (rb_obj_is_kind_of(oletype, cWIN32OLE_TYPE)) {
Check_SafeStr(method); Check_SafeStr(method);
Data_Get_Struct(oletype, struct oletypedata, ptype); Data_Get_Struct(oletype, struct oletypedata, ptype);
obj = olemethod_from_typeinfo(self, ptype->pTypeInfo, method); obj = olemethod_from_typeinfo(self, ptype->pTypeInfo, method);
if (obj == Qnil) { if (obj == Qnil) {
rb_raise(eWIN32OLE_RUNTIME_ERROR, "Not found %s", rb_raise(eWIN32OLE_RUNTIME_ERROR, "Not found %s",
StringValuePtr(method)); StringValuePtr(method));
} }
} }
else { else {
@ -4000,7 +4134,7 @@ ole_method_visible(pTypeInfo, method_index)
return Qfalse; return Qfalse;
if (pFuncDesc->wFuncFlags & (FUNCFLAG_FRESTRICTED | if (pFuncDesc->wFuncFlags & (FUNCFLAG_FRESTRICTED |
FUNCFLAG_FHIDDEN | FUNCFLAG_FHIDDEN |
FUNCFLAG_FNONBROWSABLE)) { FUNCFLAG_FNONBROWSABLE)) {
visible = Qfalse; visible = Qfalse;
} else { } else {
visible = Qtrue; visible = Qtrue;
@ -4059,29 +4193,29 @@ static ole_method_event(pTypeInfo, method_index, method_name)
hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
href, &pRefTypeInfo); href, &pRefTypeInfo);
if (FAILED(hr)) if (FAILED(hr))
continue; continue;
hr = pRefTypeInfo->lpVtbl->GetFuncDesc(pRefTypeInfo, method_index, hr = pRefTypeInfo->lpVtbl->GetFuncDesc(pRefTypeInfo, method_index,
&pFuncDesc); &pFuncDesc);
if (FAILED(hr)) { if (FAILED(hr)) {
OLE_RELEASE(pRefTypeInfo); OLE_RELEASE(pRefTypeInfo);
continue; continue;
} }
hr = pRefTypeInfo->lpVtbl->GetDocumentation(pRefTypeInfo, hr = pRefTypeInfo->lpVtbl->GetDocumentation(pRefTypeInfo,
pFuncDesc->memid, pFuncDesc->memid,
&bstr, NULL, NULL, NULL); &bstr, NULL, NULL, NULL);
if (FAILED(hr)) { if (FAILED(hr)) {
pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc); pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
OLE_RELEASE(pRefTypeInfo); OLE_RELEASE(pRefTypeInfo);
continue; continue;
} }
name = WC2VSTR(bstr); name = WC2VSTR(bstr);
pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc); pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
OLE_RELEASE(pRefTypeInfo); OLE_RELEASE(pRefTypeInfo);
if (rb_str_cmp(method_name, name) == 0) { if (rb_str_cmp(method_name, name) == 0) {
event = Qtrue; event = Qtrue;
break; break;
} }
} }
} }
@ -4117,8 +4251,8 @@ folemethod_event_interface(self)
Data_Get_Struct(self, struct olemethoddata, pmethod); Data_Get_Struct(self, struct olemethoddata, pmethod);
if(folemethod_event(self) == Qtrue) { if(folemethod_event(self) == Qtrue) {
hr = ole_docinfo_from_type(pmethod->pTypeInfo, &name, NULL, NULL, NULL); hr = ole_docinfo_from_type(pmethod->pTypeInfo, &name, NULL, NULL, NULL);
if(SUCCEEDED(hr)) if(SUCCEEDED(hr))
return WC2VSTR(name); return WC2VSTR(name);
} }
return Qnil; return Qnil;
} }
@ -4822,7 +4956,7 @@ STDMETHODIMP EVENTSINK_Invoke(
if (rb_ary_entry(event, 3) == Qtrue) { if (rb_ary_entry(event, 3) == Qtrue) {
argv = rb_ary_new(); argv = rb_ary_new();
rb_ary_push(args, argv); rb_ary_push(args, argv);
result = rb_apply(handler, rb_intern("call"), args); result = rb_apply(handler, rb_intern("call"), args);
ary2ptr_dispparams(argv, pdispparams); ary2ptr_dispparams(argv, pdispparams);
} }
@ -5089,9 +5223,9 @@ ole_event_free(poleev)
if(poleev->pEvent) { if(poleev->pEvent) {
pti = poleev->pEvent->pTypeInfo; pti = poleev->pEvent->pTypeInfo;
if(pti) OLE_RELEASE(pti); if(pti) OLE_RELEASE(pti);
pcp = poleev->pEvent->pConnectionPoint; pcp = poleev->pEvent->pConnectionPoint;
if(pcp) { if(pcp) {
pcp->lpVtbl->Unadvise(pcp, poleev->pEvent->m_dwCookie); pcp->lpVtbl->Unadvise(pcp, poleev->pEvent->m_dwCookie);
OLE_RELEASE(pcp); OLE_RELEASE(pcp);
} }
@ -5138,10 +5272,10 @@ fev_initialize(argc, argv, self)
} }
if(TYPE(itf) != T_NIL) { if(TYPE(itf) != T_NIL) {
if (ruby_safe_level > 0 && OBJ_TAINTED(itf)) { if (ruby_safe_level > 0 && OBJ_TAINTED(itf)) {
rb_raise(rb_eSecurityError, "Insecure Event Creation - %s", rb_raise(rb_eSecurityError, "Insecure Event Creation - %s",
StringValuePtr(itf)); StringValuePtr(itf));
} }
Check_SafeStr(itf); Check_SafeStr(itf);
pitf = StringValuePtr(itf); pitf = StringValuePtr(itf);
hr = find_iid(ole, pitf, &iid, &pTypeInfo); hr = find_iid(ole, pitf, &iid, &pTypeInfo);
@ -5276,6 +5410,16 @@ Init_win32ole()
rb_global_variable(&ary_ole_event); rb_global_variable(&ary_ole_event);
id_events = rb_intern("events"); id_events = rb_intern("events");
com_vtbl.QueryInterface = QueryInterface;
com_vtbl.AddRef = AddRef;
com_vtbl.Release = Release;
com_vtbl.GetTypeInfoCount = GetTypeInfoCount;
com_vtbl.GetTypeInfo = GetTypeInfo;
com_vtbl.GetIDsOfNames = GetIDsOfNames;
com_vtbl.Invoke = Invoke;
com_hash = Data_Wrap_Struct(rb_cData, rb_mark_hash, st_free_table, st_init_numtable());
rb_global_variable(&com_hash);
cWIN32OLE = rb_define_class("WIN32OLE", rb_cObject); cWIN32OLE = rb_define_class("WIN32OLE", rb_cObject);
rb_define_alloc_func(cWIN32OLE, fole_s_allocate); rb_define_alloc_func(cWIN32OLE, fole_s_allocate);