22 #define GNUC_OLDER_3_4_4 \
24 ((__GNUC__ <= 3) && (__GNUC_MINOR__ < 4)) || \
25 ((__GNUC__ <= 3) && (__GNUC_MINOR__ <= 4) && (__GNUC_PATCHLEVEL__ <= 4)))
27 #if (defined(__GNUC__)) && (GNUC_OLDER_3_4_4)
28 #ifndef NONAMELESSUNION
29 #define NONAMELESSUNION 1
39 #if defined(HAVE_TYPE_IMULTILANGUAGE2) || defined(HAVE_TYPE_IMULTILANGUAGE)
44 #ifdef HAVE_STDARG_PROTOTYPES
46 #define va_init_list(a,b) va_start(a,b)
49 #define va_init_list(a,b) va_start(a)
53 #define DOUT fprintf(stderr,"[%d]\n",__LINE__)
54 #define DOUTS(x) fprintf(stderr,"[%d]:" #x "=%s\n",__LINE__,x)
55 #define DOUTMSG(x) fprintf(stderr, "[%d]:" #x "\n",__LINE__)
56 #define DOUTI(x) fprintf(stderr, "[%ld]:" #x "=%d\n",__LINE__,x)
57 #define DOUTD(x) fprintf(stderr, "[%d]:" #x "=%f\n",__LINE__,x)
59 #if (defined(__GNUC__)) && (GNUC_OLDER_3_4_4)
60 #define V_UNION1(X, Y) ((X)->u.Y)
62 #define V_UNION1(X, Y) ((X)->Y)
65 #if (defined(__GNUC__)) && (GNUC_OLDER_3_4_4)
67 #define V_UNION(X,Y) ((X)->n1.n2.n3.Y)
70 #define V_VT(X) ((X)->n1.n2.vt)
73 #define V_BOOL(X) V_UNION(X,boolVal)
77 #define V_I1REF(X) V_UNION(X, pcVal)
81 #define V_UI2REF(X) V_UNION(X, puiVal)
85 #define V_INT(X) V_UNION(X, intVal)
89 #define V_INTREF(X) V_UNION(X, pintVal)
93 #define V_UINT(X) V_UNION(X, uintVal)
97 #define V_UINTREF(X) V_UNION(X, puintVal)
104 #if defined(__CYGWIN__) || defined(__MINGW32__)
105 #undef IID_IMultiLanguage2
106 const IID IID_IMultiLanguage2 = {0xDCCFC164, 0x2B38, 0x11d2, {0xB7, 0xEC, 0x00, 0xC0, 0x4F, 0x8F, 0x5D, 0x9A}};
109 #define OLE_RELEASE(X) (X) ? ((X)->lpVtbl->Release(X)) : 0
111 #define OLE_ADDREF(X) (X) ? ((X)->lpVtbl->AddRef(X)) : 0
113 #define OLE_GET_TYPEATTR(X, Y) ((X)->lpVtbl->GetTypeAttr((X), (Y)))
114 #define OLE_RELEASE_TYPEATTR(X, Y) ((X)->lpVtbl->ReleaseTypeAttr((X), (Y)))
116 #define OLE_FREE(x) {\
117 if(g_ole_initialized == TRUE) {\
125 #define OLEData_Get_Struct(obj, pole) {\
126 Data_Get_Struct(obj, struct oledata, pole);\
127 if(!pole->pDispatch) {\
128 rb_raise(rb_eRuntimeError, "failed to get Dispatch Interface");\
132 #ifdef HAVE_LONG_LONG
133 #define I8_2_NUM LL2NUM
134 #define UI8_2_NUM ULL2NUM
135 #define NUM2I8 NUM2LL
136 #define NUM2UI8 NUM2ULL
138 #define I8_2_NUM INT2NUM
139 #define UI8_2_NUM UINT2NUM
140 #define NUM2I8 NUM2INT
141 #define NUM2UI8 NUM2UINT
144 #define WC2VSTR(x) ole_wc2vstr((x), TRUE)
146 #define WIN32OLE_VERSION "1.5.3"
148 typedef HRESULT (STDAPICALLTYPE FNCOCREATEINSTANCEEX)
149 (REFCLSID, IUnknown*,
DWORD, COSERVERINFO*,
DWORD, MULTI_QI*);
168 STDMETHOD(GetTypeInfoCount)(
171 STDMETHOD(GetTypeInfo)(
176 STDMETHOD(GetIDsOfNames)(
236 #if defined(HAVE_TYPE_IMULTILANGUAGE2)
238 #elif defined(HAVE_TYPE_IMULTILANGUAGE)
241 #define pIMultiLanguage NULL
290 static HRESULT ( STDMETHODCALLTYPE QueryInterface )(IDispatch __RPC_FAR *, REFIID
riid,
void __RPC_FAR *__RPC_FAR *
ppvObject);
291 static ULONG ( STDMETHODCALLTYPE AddRef )(IDispatch __RPC_FAR * This);
292 static ULONG ( STDMETHODCALLTYPE Release )(IDispatch __RPC_FAR * This);
293 static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(IDispatch __RPC_FAR * This, UINT __RPC_FAR *
pctinfo);
294 static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(IDispatch __RPC_FAR * This, UINT
iTInfo, LCID
lcid, ITypeInfo __RPC_FAR *__RPC_FAR *
ppTInfo);
303 #ifndef pIMultiLanguage
333 static void ole_set_byref(VARIANT *realvar, VARIANT *var, VARTYPE vt);
379 static VALUE set_argv(VARIANTARG* realargs,
unsigned int beg,
unsigned int end);
556 static HRESULT find_coclass(ITypeInfo *pTypeInfo, TYPEATTR *pTypeAttr, ITypeInfo **pTypeInfo2, TYPEATTR **pTypeAttr2);
592 static HRESULT (STDMETHODCALLTYPE mf_QueryInterface)(
593 IMessageFilter __RPC_FAR * This,
597 if (
MEMCMP(riid, &IID_IUnknown, GUID, 1) == 0
598 ||
MEMCMP(riid, &IID_IMessageFilter, GUID, 1) == 0)
603 return E_NOINTERFACE;
606 static ULONG (STDMETHODCALLTYPE mf_AddRef)(
607 IMessageFilter __RPC_FAR * This)
612 static ULONG (STDMETHODCALLTYPE mf_Release)(
613 IMessageFilter __RPC_FAR * This)
618 static DWORD (STDMETHODCALLTYPE mf_HandleInComingCall)(
619 IMessageFilter __RPC_FAR * pThis,
626 #ifdef DEBUG_MESSAGEFILTER
627 printf(
"incoming %08X, %08X, %d\n", dwCallType, threadIDCaller, dwTickCount);
633 case CALLTYPE_TOPLEVEL_CALLPENDING:
634 case CALLTYPE_ASYNC_CALLPENDING:
636 return SERVERCALL_RETRYLATER;
649 return SERVERCALL_ISHANDLED;
652 static DWORD (STDMETHODCALLTYPE mf_RetryRejectedCall)(
653 IMessageFilter* pThis,
668 static DWORD (STDMETHODCALLTYPE mf_MessagePending)(
669 IMessageFilter* pThis,
676 return PENDINGMSG_WAITNOPROCESS;
684 return PENDINGMSG_WAITNOPROCESS;
694 static HRESULT ( STDMETHODCALLTYPE QueryInterface )(
695 IDispatch __RPC_FAR * This,
699 if (
MEMCMP(riid, &IID_IUnknown, GUID, 1) == 0
700 ||
MEMCMP(riid, &IID_IDispatch, GUID, 1) == 0)
707 return E_NOINTERFACE;
710 static ULONG ( STDMETHODCALLTYPE AddRef )(
711 IDispatch __RPC_FAR * This)
717 static ULONG ( STDMETHODCALLTYPE Release )(
718 IDispatch __RPC_FAR * This)
730 static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(
731 IDispatch __RPC_FAR * This,
737 static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(
738 IDispatch __RPC_FAR * This,
741 ITypeInfo __RPC_FAR *__RPC_FAR *
ppTInfo)
747 static HRESULT ( STDMETHODCALLTYPE GetIDsOfNames )(
748 IDispatch __RPC_FAR * This,
764 static HRESULT ( STDMETHODCALLTYPE Invoke )(
765 IDispatch __RPC_FAR * This,
783 if (dispIdMember == DISPID_VALUE) {
784 if (wFlags == DISPATCH_METHOD) {
786 }
else if (wFlags & DISPATCH_PROPERTYGET) {
821 memset(&st, 0,
sizeof(SYSTEMTIME));
829 SystemTimeToVariantTime(&st, &t);
838 VariantTimeToSystemTime(date, &st);
847 if (st.wMilliseconds > 0) {
853 #define ENC_MACHING_CP(enc,encname,cp) if(strcasecmp(rb_enc_name((enc)),(encname)) == 0) return cp
926 #ifndef pIMultiLanguage
933 #if defined(HAVE_TYPE_IMULTILANGUAGE2)
934 hr = CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER,
935 &IID_IMultiLanguage2, &p);
936 #elif defined(HAVE_TYPE_IMULTILANGUAGE)
937 hr = CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER,
938 &IID_IMultiLanguage, &p);
947 #define load_conv_function51932() failed_load_conv51932()
950 #define conv_51932(cp) ((cp) == 51932 && (load_conv_function51932(), 1))
973 rb_raise(
eWIN32OLERuntimeError,
"codepage should be WIN32OLE::CP_ACP, WIN32OLE::CP_OEMCP, WIN32OLE::CP_MACCP, WIN32OLE::CP_THREAD_ACP, WIN32OLE::CP_SYMBOL, WIN32OLE::CP_UTF7, WIN32OLE::CP_UTF8, or installed codepage.");
1023 if (!pGetCPInfoEx) {
1025 GetProcAddress(GetModuleHandle(
"kernel32"),
"GetCPInfoEx");
1026 if (!pGetCPInfoEx) {
1027 pGetCPInfoEx = (
void*)-1;
1032 if (pGetCPInfoEx == (
void*)-1 || !pGetCPInfoEx(cp, 0, buf)) {
1046 rb_raise(
eWIN32OLERuntimeError,
"codepage should be WIN32OLE::CP_ACP, WIN32OLE::CP_OEMCP, WIN32OLE::CP_MACCP, WIN32OLE::CP_THREAD_ACP, WIN32OLE::CP_SYMBOL, WIN32OLE::CP_UTF7, WIN32OLE::CP_UTF8, or installed codepage.");
1064 #ifndef pIMultiLanguage
1103 sprintf(strhr,
" HRESULT error code:0x%08x\n ", (
unsigned)hr);
1105 dwCount = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
1106 FORMAT_MESSAGE_FROM_SYSTEM |
1107 FORMAT_MESSAGE_IGNORE_INSERTS,
1109 MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
1110 (LPTSTR)&p_msg, 0,
NULL);
1112 dwCount = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
1113 FORMAT_MESSAGE_FROM_SYSTEM |
1114 FORMAT_MESSAGE_IGNORE_INSERTS,
1116 (LPTSTR)&p_msg, 0,
NULL);
1119 term = p_msg +
strlen(p_msg);
1120 while (p_msg < term) {
1122 if (*term ==
'\r' || *term ==
'\n')
1126 if (p_msg[0] !=
'\0') {
1137 SysFreeString(pExInfo->bstrDescription);
1138 SysFreeString(pExInfo->bstrSource);
1139 SysFreeString(pExInfo->bstrHelpFile);
1145 char error_code[40];
1146 char *pSource =
NULL;
1147 char *pDescription =
NULL;
1149 if(pExInfo->pfnDeferredFillIn !=
NULL) {
1150 (*pExInfo->pfnDeferredFillIn)(pExInfo);
1152 if (pExInfo->bstrSource !=
NULL) {
1153 pSource =
ole_wc2mb(pExInfo->bstrSource);
1155 if (pExInfo->bstrDescription !=
NULL) {
1156 pDescription =
ole_wc2mb(pExInfo->bstrDescription);
1158 if(pExInfo->wCode == 0) {
1159 sprintf(error_code,
"\n OLE error code:%lX in ", pExInfo->scode);
1162 sprintf(error_code,
"\n OLE error code:%u in ", pExInfo->wCode);
1165 if(pSource !=
NULL) {
1172 if(pDescription !=
NULL) {
1178 if(pSource)
free(pSource);
1179 if(pDescription)
free(pDescription);
1195 if(err_msg !=
Qnil) {
1215 hr = OleInitialize(
NULL);
1237 while(PeekMessage(&msg,
NULL,0,0,PM_REMOVE)) {
1238 TranslateMessage(&msg);
1239 DispatchMessage(&msg);
1305 cp == CP_THREAD_ACP ||
1316 #ifndef pIMultiLanguage
1324 pw = SysAllocStringLen(
NULL, size);
1335 pw = SysAllocStringLen(
NULL, size);
1347 #ifndef pIMultiLanguage
1355 pw = SysAllocStringLen(
NULL, size);
1365 pw = SysAllocStringLen(
NULL, size - 1);
1366 MultiByteToWideChar(
cWIN32OLE_cp, 0, pm, len, pw, size);
1397 switch(V_VT(pvar)) {
1399 return &V_UI1(pvar);
1405 return &V_UI2(pvar);
1411 return &V_UI4(pvar);
1419 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1424 return &V_UI8(pvar);
1428 return &
V_INT(pvar);
1437 return &V_DATE(pvar);
1440 return V_BSTR(pvar);
1443 return V_DISPATCH(pvar);
1446 return &V_ERROR(pvar);
1449 return &V_BOOL(pvar);
1452 return V_UNKNOWN(pvar);
1455 return &V_ARRAY(pvar);
1467 for (i = 0; i < dim; i++) {
1468 if (pid[i] > pub[i]) {
1488 if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) ==
NULL) ||
1489 (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) ==
NULL)) {
1492 hr = SafeArrayPutElement(psa, pid, p);
1498 if (pid[i] > pub[i]) {
1515 for (i = 0; i <
len; i++) {
1540 for (i = 0; i <
len; i++) {
1543 if (ary_len < ary_len1) {
1559 SAFEARRAYBOUND *psab =
NULL;
1560 SAFEARRAY *psa =
NULL;
1567 psab =
ALLOC_N(SAFEARRAYBOUND, dim);
1571 if(!psab || !pub || !pid) {
1573 if(psab)
free(psab);
1578 for (i = 0; i < dim; i++) {
1580 psab[
i].lLbound = 0;
1581 pub[
i] = psab[
i].cElements - 1;
1585 if ((vt & ~VT_BYREF) == VT_ARRAY) {
1586 vt = (vt | VT_VARIANT);
1588 psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
1592 hr = SafeArrayLock(psa);
1593 if (SUCCEEDED(hr)) {
1595 hr = SafeArrayUnlock(psa);
1599 if(psab)
free(psab);
1602 if (SUCCEEDED(hr)) {
1608 SafeArrayDestroy(psa);
1621 V_VT(var) = VT_DISPATCH;
1627 VariantCopy(var, &(pvar->
var));
1632 V_VT(var) = VT_DATE;
1636 switch (
TYPE(val)) {
1641 V_VT(var) = VT_BSTR;
1657 V_VT(var) = VT_BOOL;
1658 V_BOOL(var) = VARIANT_TRUE;
1661 V_VT(var) = VT_BOOL;
1662 V_BOOL(var) = VARIANT_FALSE;
1666 V_VT(var) = VT_ERROR;
1667 V_ERROR(var) = DISP_E_PARAMNOTFOUND;
1669 V_VT(var) = VT_EMPTY;
1673 V_VT(var) = VT_DISPATCH;
1683 if (vt == VT_VARIANT) {
1686 V_VT(var) = (vt & ~VT_BYREF);
1687 if (V_VT(var) == VT_DISPATCH) {
1688 V_DISPATCH(var) =
NULL;
1689 }
else if (V_VT(var) == VT_UNKNOWN) {
1690 V_UNKNOWN(var) =
NULL;
1695 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1696 switch(vt & ~VT_BYREF) {
1699 V_I8(var) =
NUM2I8 (val);
1717 switch (
TYPE(val)) {
1719 if (V_VT(var) == (VT_BSTR | VT_BYREF)) {
1725 case (VT_UI1 | VT_BYREF) :
1726 *V_UI1REF(var) =
NUM2CHR(val);
1728 case (VT_I2 | VT_BYREF) :
1729 *V_I2REF(var) = (short)
NUM2INT(val);
1731 case (VT_I4 | VT_BYREF) :
1734 case (VT_R4 | VT_BYREF) :
1735 *V_R4REF(var) = (float)
NUM2INT(val);
1737 case (VT_R8 | VT_BYREF) :
1746 case (VT_I2 | VT_BYREF) :
1747 *V_I2REF(var) = (short)
NUM2INT(val);
1749 case (VT_I4 | VT_BYREF) :
1752 case (VT_R4 | VT_BYREF) :
1753 *V_R4REF(var) = (float)
NUM2DBL(val);
1755 case (VT_R8 | VT_BYREF) :
1763 if (V_VT(var) == (VT_R8 | VT_BYREF)) {
1768 if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
1769 *V_BOOLREF(var) = VARIANT_TRUE;
1773 if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
1774 *V_BOOLREF(var) = VARIANT_FALSE;
1786 if (vt == (VT_VARIANT|VT_BYREF)) {
1789 if (V_VT(realvar) != (vt & ~VT_BYREF)) {
1792 switch(vt & ~VT_BYREF) {
1794 V_I1REF(var) = &V_I1(realvar);
1797 V_UI1REF(var) = &V_UI1(realvar);
1800 V_I2REF(var) = &V_I2(realvar);
1806 V_I4REF(var) = &V_I4(realvar);
1809 V_UI4REF(var) = &V_UI4(realvar);
1812 V_R4REF(var) = &V_R4(realvar);
1815 V_R8REF(var) = &V_R8(realvar);
1818 #if (_MSC_VER >= 1300)
1820 V_I8REF(var) = &V_I8(realvar);
1823 V_UI8REF(var) = &V_UI8(realvar);
1835 V_CYREF(var) = &V_CY(realvar);
1838 V_DATEREF(var) = &V_DATE(realvar);
1841 V_BSTRREF(var) = &V_BSTR(realvar);
1844 V_DISPATCHREF(var) = &V_DISPATCH(realvar);
1847 V_ERRORREF(var) = &V_ERROR(realvar);
1850 V_BOOLREF(var) = &V_BOOL(realvar);
1853 V_UNKNOWNREF(var) = &V_UNKNOWN(realvar);
1856 V_ARRAYREF(var) = &V_ARRAY(realvar);
1870 if (((vt & ~VT_BYREF) == (VT_ARRAY | VT_UI1)) &&
TYPE(val) ==
T_STRING) {
1873 SAFEARRAY *p =
NULL;
1874 SAFEARRAY *psa = SafeArrayCreateVector(VT_UI1, 0, len);
1878 hr = SafeArrayAccessData(psa, &pdest);
1879 if (SUCCEEDED(hr)) {
1881 SafeArrayUnaccessData(psa);
1882 V_VT(&(pvar->
realvar)) = (vt & ~VT_BYREF);
1883 p = V_ARRAY(&(pvar->
realvar));
1885 SafeArrayDestroy(p);
1887 V_ARRAY(&(pvar->
realvar)) = psa;
1888 if (vt & VT_BYREF) {
1889 V_VT(&(pvar->
var)) = vt;
1890 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1892 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1896 SafeArrayDestroy(psa);
1898 }
else if (vt & VT_ARRAY) {
1900 V_VT(&(pvar->
var)) = vt;
1901 if (vt & VT_BYREF) {
1902 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1906 if (SUCCEEDED(hr)) {
1907 if (vt & VT_BYREF) {
1908 V_VT(&(pvar->
var)) = vt;
1909 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1911 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1915 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1916 }
else if ( (vt & ~VT_BYREF) == VT_I8 || (vt & ~VT_BYREF) == VT_UI8) {
1919 V_VT(&(pvar->
var)) = vt;
1920 if (vt & VT_BYREF) {
1926 V_VT(&(pvar->
var)) = vt;
1927 if (vt == (VT_BYREF | VT_VARIANT)) {
1930 V_VT(&(pvar->
realvar)) = vt & ~VT_BYREF;
1931 if (vt & VT_BYREF) {
1937 if (vt == (VT_BYREF | VT_VARIANT)) {
1939 }
else if (vt & VT_BYREF) {
1940 if ( (vt & ~VT_BYREF) != V_VT(&(pvar->
realvar))) {
1944 if (SUCCEEDED(hr)) {
1948 if (vt == V_VT(&(pvar->
realvar))) {
1949 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1951 hr = VariantChangeTypeEx(&(pvar->
var), &(pvar->
realvar),
2027 long *ids =
ALLOC_N(
long, dim);
2031 for(i = 0; i < dim; i++) {
2032 ids[
i] = pid[
i] - plb[
i];
2036 for(i = 0; i < dim-1; i++) {
2050 long id = pid[dim - 1] - plb[dim - 1];
2060 while ( V_VT(pvar) == (VT_BYREF | VT_VARIANT) )
2061 pvar = V_VARIANTREF(pvar);
2063 if(V_ISARRAY(pvar)) {
2064 SAFEARRAY *psa = V_ISBYREF(pvar) ? *V_ARRAYREF(pvar) : V_ARRAY(pvar);
2066 long *pid, *plb, *pub;
2073 dim = SafeArrayGetDim(psa);
2074 VariantInit(&variant);
2075 V_VT(&variant) = (V_VT(pvar) & ~VT_ARRAY) | VT_BYREF;
2081 if(!pid || !plb || !pub) {
2088 for(i = 0; i < dim; ++
i) {
2089 SafeArrayGetLBound(psa, i+1, &plb[i]);
2090 SafeArrayGetLBound(psa, i+1, &pid[i]);
2091 SafeArrayGetUBound(psa, i+1, &pub[i]);
2093 hr = SafeArrayLock(psa);
2094 if (SUCCEEDED(hr)) {
2099 hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
2100 if (SUCCEEDED(hr)) {
2104 for (i = 0; i < dim; ++
i) {
2105 if (++pid[i] <= pub[i])
2110 SafeArrayUnlock(psa);
2117 switch(V_VT(pvar) & ~VT_BYREF){
2126 obj =
INT2NUM((
long)V_I1(pvar));
2131 obj =
INT2NUM((
long)*V_UI1REF(pvar));
2133 obj =
INT2NUM((
long)V_UI1(pvar));
2138 obj =
INT2NUM((
long)*V_I2REF(pvar));
2140 obj =
INT2NUM((
long)V_I2(pvar));
2147 obj =
INT2NUM((
long)V_UI2(pvar));
2152 obj =
INT2NUM((
long)*V_I4REF(pvar));
2154 obj =
INT2NUM((
long)V_I4(pvar));
2159 obj =
INT2NUM((
long)*V_UI4REF(pvar));
2161 obj =
INT2NUM((
long)V_UI4(pvar));
2178 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
2181 #if (_MSC_VER >= 1300)
2191 #if (_MSC_VER >= 1300)
2226 obj =
INT2NUM(*V_ERRORREF(pvar));
2232 if (V_ISBYREF(pvar))
2242 if (V_ISBYREF(pvar))
2243 pDispatch = *V_DISPATCHREF(pvar);
2245 pDispatch = V_DISPATCH(pvar);
2247 if (pDispatch !=
NULL ) {
2262 if (V_ISBYREF(pvar))
2263 punk = *V_UNKNOWNREF(pvar);
2265 punk = V_UNKNOWN(pvar);
2268 hr = punk->lpVtbl->QueryInterface(punk, &IID_IDispatch, &p);
2281 date = *V_DATEREF(pvar);
2283 date = V_DATE(pvar);
2293 VariantInit(&variant);
2294 hr = VariantChangeTypeEx(&variant, pvar,
2296 if (SUCCEEDED(hr) && V_VT(&variant) == VT_BSTR) {
2299 VariantClear(&variant);
2309 return RegOpenKeyEx(hkey, name, 0, KEY_READ, phkey);
2321 char buf[BUFSIZ + 1];
2324 LONG
err = RegEnumKeyEx(hkey, i, buf, &size_buf,
2326 if(err == ERROR_SUCCESS) {
2340 LONG
err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype,
NULL, &size);
2342 if (err == ERROR_SUCCESS) {
2343 pbuf =
ALLOC_N(
char, size + 1);
2344 err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype, (BYTE *)pbuf, &size);
2345 if (err == ERROR_SUCCESS) {
2347 if (dwtype == REG_EXPAND_SZ) {
2348 char* pbuf2 = (
char *)pbuf;
2350 pbuf =
ALLOC_N(
char, len + 1);
2351 ExpandEnvironmentStrings(pbuf2, pbuf, len + 1);
2367 err = RegOpenKeyEx(hkey, subkey, 0, KEY_READ, &hsubkey);
2368 if (err == ERROR_SUCCESS) {
2370 RegCloseKey(hsubkey);
2400 char path[MAX_PATH + 1];
2402 err =
reg_open_key(HKEY_CLASSES_ROOT,
"CLSID", &hroot);
2403 if (err != ERROR_SUCCESS) {
2407 if (err != ERROR_SUCCESS) {
2413 RegCloseKey(hclsid);
2414 if (typelib !=
Qnil) {
2415 ExpandEnvironmentStrings(
StringValuePtr(typelib), path,
sizeof(path));
2416 path[MAX_PATH] =
'\0';
2425 HKEY htypelib, hclsid, hversion, hlang;
2436 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
2437 if(err != ERROR_SUCCESS) {
2440 for(i = 0; !found; i++) {
2445 if (err != ERROR_SUCCESS)
2448 for(j = 0; !found; j++) {
2457 if (typelib ==
Qnil)
2460 for(k = 0; !found; k++) {
2465 if (err == ERROR_SUCCESS) {
2472 RegCloseKey(hversion);
2474 RegCloseKey(hclsid);
2476 RegCloseKey(htypelib);
2496 ITypeInfo *pTypeInfo;
2497 TYPEATTR *pTypeAttr;
2507 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
2508 for (index = 0; index <
count; index++) {
2509 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, index, &pTypeInfo);
2517 for(iVar = 0; iVar < pTypeAttr->cVars; iVar++) {
2518 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, iVar, &pVarDesc);
2521 if(pVarDesc->varkind == VAR_CONST &&
2522 !(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
2523 VARFLAG_FRESTRICTED |
2524 VARFLAG_FNONBROWSABLE))) {
2525 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
2527 if(FAILED(hr) || len == 0 || !bstr)
2531 *pName = toupper((
int)*pName);
2539 SysFreeString(bstr);
2545 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
2547 pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
2565 err = RegConnectRegistry(
StringValuePtr(host), HKEY_LOCAL_MACHINE, &hlm);
2566 if (err != ERROR_SUCCESS)
2567 return HRESULT_FROM_WIN32(err);
2571 err = RegOpenKeyEx(hlm,
StringValuePtr(subkey), 0, KEY_READ, &hpid);
2572 if (err != ERROR_SUCCESS)
2573 hr = HRESULT_FROM_WIN32(err);
2575 len =
sizeof(clsid);
2576 err = RegQueryValueEx(hpid,
"",
NULL, &dwtype, (BYTE *)clsid, &len);
2577 if (err == ERROR_SUCCESS && dwtype == REG_SZ) {
2579 hr = CLSIDFromString(pbuf, pclsid);
2580 SysFreeString(pbuf);
2583 hr = HRESULT_FROM_WIN32(err);
2594 VALUE ole, host, others;
2599 COSERVERINFO serverinfo;
2601 DWORD clsctx = CLSCTX_REMOTE_SERVER;
2604 gole32 = LoadLibrary(
"OLE32");
2609 GetProcAddress(
gole32,
"CoCreateInstanceEx");
2615 hr = CLSIDFromProgID(pbuf, &clsid);
2619 hr = CLSIDFromString(pbuf, &clsid);
2620 SysFreeString(pbuf);
2623 "unknown OLE server: `%s'",
2625 memset(&serverinfo, 0,
sizeof(COSERVERINFO));
2627 memset(&multi_qi, 0,
sizeof(MULTI_QI));
2628 multi_qi.pIID = &IID_IDispatch;
2630 SysFreeString(serverinfo.pwszName);
2633 "failed to create DCOM server `%s' in `%s'",
2654 hr = CreateBindCtx(0, &pBindCtx);
2657 "failed to create bind context");
2661 hr = MkParseDisplayName(pBindCtx, pbuf, &eaten, &pMoniker);
2662 SysFreeString(pbuf);
2666 "failed to parse display name of moniker `%s'",
2669 hr = pMoniker->lpVtbl->BindToObject(pMoniker, pBindCtx,
NULL,
2670 &IID_IDispatch, &p);
2677 "failed to bind moniker `%s'",
2717 hr = CLSIDFromProgID(pBuf, &clsid);
2719 hr = CLSIDFromString(pBuf, &clsid);
2721 SysFreeString(pBuf);
2726 hr = GetActiveObject(&clsid, 0, &pUnknown);
2731 hr = pUnknown->lpVtbl->QueryInterface(pUnknown, &IID_IDispatch, &p);
2736 "failed to create WIN32OLE server `%s'",
2780 ITypeInfo *pTypeInfo;
2798 0, lcid, &pTypeInfo);
2802 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
2822 hr = LoadTypeLibEx(pBuf, REGKIND_NONE, &pTypeLib);
2823 SysFreeString(pBuf);
2848 ITypeInfo *pTypeInfo;
2852 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
2853 for (i = 0; i <
count; i++) {
2854 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
2859 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
2925 FNHTMLHELP *pfnHtmlHelp;
2929 ghhctrl = LoadLibrary(
"HHCTRL.OCX");
2932 pfnHtmlHelp = (FNHTMLHELP*)GetProcAddress(
ghhctrl,
"HtmlHelpA");
2999 static BOOL CALLBACK
3093 case LOCALE_SYSTEM_DEFAULT:
3094 case LOCALE_USER_DEFAULT:
3118 hr = CoCreateGuid(&guid);
3122 len = StringFromGUID2(&guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
3138 hr = OleInitialize(
NULL);
3231 rb_scan_args(argc, argv,
"11*", &svr_name, &host, &others);
3249 hr = CLSIDFromProgID(pBuf, &clsid);
3251 hr = CLSIDFromString(pBuf, &clsid);
3253 SysFreeString(pBuf);
3256 "unknown OLE server: `%s'",
3261 hr = CoCreateInstance(&clsid,
NULL, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
3262 &IID_IDispatch, &p);
3266 "failed to create WIN32OLE object from `%s'",
3277 unsigned int index,
i;
3279 index = pOp->
dp.cNamedArgs;
3287 for(i = 1; i < index + 1; i++) {
3291 for(i = 0; i < index; i++ ) {
3292 VariantClear(&(pOp->
dp.rgvarg[i]));
3305 VariantInit(&(pOp->
dp.rgvarg[index]));
3308 pOp->
dp.cNamedArgs += 1;
3313 set_argv(VARIANTARG* realargs,
unsigned int beg,
unsigned int end)
3319 while (end-- > beg) {
3321 VariantClear(&realargs[end]);
3342 EXCEPINFO excepinfo;
3344 VARIANTARG* realargs =
NULL;
3345 unsigned int argErr = 0;
3347 unsigned int cNamedArgs;
3351 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3353 VariantInit(&result);
3356 op.
dp.rgdispidNamedArgs =
NULL;
3357 op.
dp.cNamedArgs = 0;
3372 DispID = DISPID_VALUE;
3378 &wcmdname, 1, lcid, &DispID);
3379 SysFreeString(wcmdname);
3382 "unknown property or method: `%s'",
3390 op.
dp.cNamedArgs = 0;
3398 op.
dp.cArgs = cNamedArgs + argc - 2;
3403 pDispID =
ALLOCA_N(DISPID, cNamedArgs + 1);
3408 op.dp.cNamedArgs + 1,
3410 for(i = 0; i < op.dp.cNamedArgs + 1; i++) {
3411 SysFreeString(op.pNamedArgs[i]);
3412 op.pNamedArgs[
i] =
NULL;
3416 for(i = 0; i < op.dp.cArgs; i++ ) {
3417 VariantClear(&op.dp.rgvarg[i]);
3420 "failed to get named argument info: `%s'",
3423 op.dp.rgdispidNamedArgs = &(pDispID[1]);
3427 op.
dp.cArgs = argc - 1;
3429 if (op.
dp.cArgs > 0) {
3436 if(op.
dp.cArgs > cNamedArgs) {
3437 realargs =
ALLOCA_N(VARIANTARG, op.
dp.cArgs-cNamedArgs+1);
3438 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3439 n = op.
dp.cArgs - i + cNamedArgs - 1;
3440 VariantInit(&realargs[n]);
3441 VariantInit(&op.
dp.rgvarg[n]);
3445 VariantCopy(&op.
dp.rgvarg[n], &(pvar->
var));
3448 V_VT(&op.
dp.rgvarg[n]) = VT_VARIANT | VT_BYREF;
3449 V_VARIANTREF(&op.
dp.rgvarg[n]) = &realargs[n];
3454 if (wFlags & DISPATCH_PROPERTYPUT) {
3455 if (op.
dp.cArgs == 0)
3458 op.
dp.cNamedArgs = 1;
3459 op.
dp.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
3460 op.
dp.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
3464 &IID_NULL, lcid, wFlags, &op.
dp,
3465 &result, &excepinfo, &argErr);
3469 if(op.
dp.cArgs >= cNamedArgs) {
3470 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3471 n = op.
dp.cArgs - i + cNamedArgs - 1;
3475 if (hr == DISP_E_EXCEPTION) {
3478 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3479 VariantInit(&result);
3481 &IID_NULL, lcid, wFlags,
3483 &excepinfo, &argErr);
3489 if ((hr == DISP_E_EXCEPTION || hr == DISP_E_MEMBERNOTFOUND) && DispID > 0x8000) {
3490 if (hr == DISP_E_EXCEPTION) {
3493 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3495 &IID_NULL, lcid, wFlags,
3497 &excepinfo, &argErr);
3500 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3501 n = op.
dp.cArgs - i + cNamedArgs - 1;
3502 VariantClear(&op.
dp.rgvarg[n]);
3508 if (op.
dp.cArgs > cNamedArgs) {
3509 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3510 n = op.
dp.cArgs - i + cNamedArgs - 1;
3514 if (hr == DISP_E_EXCEPTION) {
3517 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3518 VariantInit(&result);
3520 &IID_NULL, lcid, wFlags,
3522 &excepinfo, &argErr);
3523 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3524 n = op.
dp.cArgs - i + cNamedArgs - 1;
3525 VariantClear(&op.
dp.rgvarg[n]);
3532 if(op.
dp.cArgs > cNamedArgs) {
3533 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3534 n = op.
dp.cArgs - i + cNamedArgs - 1;
3543 for(i = 0; i < op.
dp.cArgs; i++) {
3544 VariantClear(&op.
dp.rgvarg[i]);
3555 VariantClear(&result);
3575 return ole_invoke(argc, argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
3583 unsigned int argErr = 0;
3584 EXCEPINFO excepinfo;
3586 DISPPARAMS dispParams;
3587 VARIANTARG* realargs =
NULL;
3597 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3598 memset(&dispParams, 0,
sizeof(DISPPARAMS));
3599 VariantInit(&result);
3603 dispParams.rgvarg =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
3604 realargs =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
3605 for (i = 0, j = dispParams.cArgs - 1; i < (
int)dispParams.cArgs; i++, j--)
3607 VariantInit(&realargs[i]);
3608 VariantInit(&dispParams.rgvarg[i]);
3611 V_VT(&dispParams.rgvarg[i]) = vt;
3616 V_VT(&dispParams.rgvarg[i]) = V_VT(&realargs[i]) = VT_ERROR;
3617 V_ERROR(&dispParams.rgvarg[i]) = V_ERROR(&realargs[i]) = DISP_E_PARAMNOTFOUND;
3630 SAFEARRAYBOUND rgsabound[1];
3632 rgsabound[0].lLbound = 0;
3634 v = vt & ~(VT_ARRAY | VT_BYREF);
3635 V_ARRAY(&realargs[i]) = SafeArrayCreate(v, 1, rgsabound);
3636 V_VT(&realargs[i]) = VT_ARRAY |
v;
3637 SafeArrayLock(V_ARRAY(&realargs[i]));
3638 pb = V_ARRAY(&realargs[i])->pvData;
3639 ps = V_ARRAY(&realargs[i])->pvData;
3640 pl = V_ARRAY(&realargs[i])->pvData;
3641 py = V_ARRAY(&realargs[i])->pvData;
3642 pv = V_ARRAY(&realargs[i])->pvData;
3643 for (ent = 0; ent < (int)rgsabound[0].cElements; ent++)
3648 if (v != VT_VARIANT)
3650 VariantChangeTypeEx(&velem, &velem,
3663 *py++ = V_CY(&velem);
3669 *ps++ = V_I2(&velem);
3674 *pb++ = V_UI1(&velem);
3678 *pl++ = V_I4(&velem);
3682 SafeArrayUnlock(V_ARRAY(&realargs[i]));
3687 if ((vt & (~VT_BYREF)) != VT_VARIANT)
3689 hr = VariantChangeTypeEx(&realargs[i], &realargs[i],
3691 (VARTYPE)(vt & (~VT_BYREF)));
3698 if ((vt & VT_BYREF) || vt == VT_VARIANT)
3700 if (vt == VT_VARIANT)
3701 V_VT(&dispParams.rgvarg[i]) = VT_VARIANT | VT_BYREF;
3702 switch (vt & (~VT_BYREF))
3706 V_VARIANTREF(&dispParams.rgvarg[i]) = &realargs[
i];
3712 V_CYREF(&dispParams.rgvarg[i]) = &V_CY(&realargs[i]);
3718 V_I2REF(&dispParams.rgvarg[i]) = &V_I2(&realargs[i]);
3723 V_UI1REF(&dispParams.rgvarg[i]) = &V_UI1(&realargs[i]);
3727 V_I4REF(&dispParams.rgvarg[i]) = &V_I4(&realargs[i]);
3734 V_CY(&dispParams.rgvarg[i]) = V_CY(&realargs[i]);
3739 if (dispkind & DISPATCH_PROPERTYPUT) {
3740 dispParams.cNamedArgs = 1;
3741 dispParams.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
3742 dispParams.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
3748 &dispParams, &result,
3749 &excepinfo, &argErr);
3759 if(dispParams.cArgs > 0) {
3760 set_argv(realargs, 0, dispParams.cArgs);
3764 VariantClear(&result);
3783 return ole_invoke2(
self, dispid, args, types, DISPATCH_METHOD);
3801 return ole_invoke2(
self, dispid, args, types, DISPATCH_PROPERTYGET);
3819 return ole_invoke2(
self, dispid, args, types, DISPATCH_PROPERTYPUT);
3894 EXCEPINFO excepinfo;
3895 DISPID dispID = DISPID_VALUE;
3896 DISPID dispIDParam = DISPID_PROPERTYPUT;
3897 USHORT wFlags = DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF;
3898 DISPPARAMS dispParams;
3899 VARIANTARG propertyValue[2];
3903 dispParams.rgdispidNamedArgs = &dispIDParam;
3904 dispParams.rgvarg = propertyValue;
3905 dispParams.cNamedArgs = 1;
3906 dispParams.cArgs = 1;
3908 VariantInit(&propertyValue[0]);
3909 VariantInit(&propertyValue[1]);
3910 memset(&excepinfo, 0,
sizeof(excepinfo));
3917 pBuf, 1, lcid, &dispID);
3918 SysFreeString(pBuf[0]);
3923 "unknown property or method: `%s'",
3929 lcid, wFlags, &dispParams,
3930 NULL, &excepinfo, &argErr);
3932 for(index = 0; index < dispParams.cArgs; ++index) {
3933 VariantClear(&propertyValue[index]);
3969 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
3970 VariantInit(&variant);
3971 while(pEnum->lpVtbl->Next(pEnum, 1, &variant,
NULL) ==
S_OK) {
3973 VariantClear(&variant);
3974 VariantInit(&variant);
3983 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
4009 unsigned int argErr;
4010 EXCEPINFO excepinfo;
4011 DISPPARAMS dispParams;
4014 IEnumVARIANT *pEnum =
NULL;
4019 VariantInit(&result);
4020 dispParams.rgvarg =
NULL;
4021 dispParams.rgdispidNamedArgs =
NULL;
4022 dispParams.cNamedArgs = 0;
4023 dispParams.cArgs = 0;
4024 memset(&excepinfo, 0,
sizeof(excepinfo));
4029 DISPATCH_METHOD | DISPATCH_PROPERTYGET,
4030 &dispParams, &result,
4031 &excepinfo, &argErr);
4034 VariantClear(&result);
4038 if (V_VT(&result) == VT_UNKNOWN) {
4039 hr = V_UNKNOWN(&result)->lpVtbl->QueryInterface(V_UNKNOWN(&result),
4043 }
else if (V_VT(&result) == VT_DISPATCH) {
4044 hr = V_DISPATCH(&result)->lpVtbl->QueryInterface(V_DISPATCH(&result),
4049 if (FAILED(hr) || !pEnum) {
4050 VariantClear(&result);
4054 VariantClear(&result);
4077 if(mname[n-1] ==
'=') {
4084 return ole_invoke(argc, argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
4092 TYPEATTR *pTypeAttr;
4094 FUNCDESC *pFuncDesc;
4102 for(i = 0; i < pTypeAttr->cFuncs && method ==
Qnil; i++) {
4103 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
4107 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
4110 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4118 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4129 TYPEATTR *pTypeAttr;
4132 ITypeInfo *pRefTypeInfo;
4139 if (method !=
Qnil) {
4142 for(i=0; i < pTypeAttr->cImplTypes && method ==
Qnil; i++){
4143 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
4146 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
4160 TYPEATTR *pTypeAttr;
4163 FUNCDESC *pFuncDesc;
4170 for(i = 0; i < pTypeAttr->cFuncs; i++) {
4172 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
4176 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
4179 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4182 if(pFuncDesc->invkind & mask) {
4188 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4200 TYPEATTR *pTypeAttr;
4203 ITypeInfo *pRefTypeInfo;
4211 for(i=0; i < pTypeAttr->cImplTypes; i++){
4212 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
4215 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
4228 ITypeInfo *pTypeInfo;
4236 0, lcid, &pTypeInfo);
4240 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo,
4245 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
4250 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
4251 for (i = 0; i <
count; i++) {
4252 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4255 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
4256 if (SUCCEEDED(hr)) {
4269 ITypeInfo *pTypeInfo;
4299 return ole_methods(
self, INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF);
4331 return ole_methods(
self, INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF);
4360 hr = pTypeInfo->lpVtbl->GetContainingTypeLib( pTypeInfo, &pTypeLib, &index );
4364 hr = pTypeLib->lpVtbl->GetDocumentation( pTypeLib, index,
4387 ITypeInfo *pTypeInfo;
4415 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
4440 ITypeInfo *pTypeInfo;
4446 0, lcid, &pTypeInfo);
4452 if (vtlib ==
Qnil) {
4479 hr = CLSIDFromString(pBuf, &iid);
4480 SysFreeString(pBuf);
4483 "invalid iid: `%s'",
4496 "failed to get interface `%s'",
4531 SysFreeString(wcmdname);
4542 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
4547 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4549 helpcontext, helpfile);
4563 ITypeInfo *pRefTypeInfo;
4566 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
4578 if(typedetails !=
Qnil)
4586 TYPEDESC *p = pTypeDesc;
4589 if (p->vt == VT_PTR || p->vt == VT_SAFEARRAY) {
4601 switch(pTypeDesc->vt) {
4644 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
4666 if(typedetails !=
Qnil)
4671 if(typedetails !=
Qnil)
4677 case VT_USERDEFINED:
4679 if (typedetails !=
Qnil)
4706 if (typedetails !=
Qnil)
4725 ITypeInfo *pTypeInfo;
4768 IPersistMemory *pPersistMemory;
4775 hr = pole->
pDispatch->lpVtbl->QueryInterface(pole->
pDispatch, &IID_IPersistMemory, &p);
4777 if (SUCCEEDED(hr)) {
4778 hr = pPersistMemory->lpVtbl->InitNew(pPersistMemory);
4780 if (SUCCEEDED(hr)) {
4829 return rb_eval_string(
"WIN32OLE_TYPELIB.typelibs.collect{|t|t.name}");
4841 HKEY hclsids, hclsid;
4848 err =
reg_open_key(HKEY_CLASSES_ROOT,
"CLSID", &hclsids);
4849 if(err != ERROR_SUCCESS) {
4857 if (err != ERROR_SUCCESS)
4863 RegCloseKey(hclsid);
4865 RegCloseKey(hclsids);
4904 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
4905 for (i = 0; i < count && found ==
Qfalse; i++) {
4906 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
4909 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4950 hr = pTypeLib->lpVtbl->GetLibAttr(pTypeLib, ppTLibAttr);
4953 "failed to get library attribute(TLIBATTR) from ITypeLib");
4970 HKEY htypelib, hguid;
4981 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
4982 if(err != ERROR_SUCCESS) {
4990 if (err != ERROR_SUCCESS)
4994 if (version ==
Qnil)
4998 if (SUCCEEDED(hr)) {
5007 RegCloseKey(htypelib);
5016 if (major ==
Qnil) {
5020 if (minor !=
Qnil) {
5031 HKEY htypelib, hguid, hversion;
5047 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
5048 if(err != ERROR_SUCCESS) {
5052 if (err != ERROR_SUCCESS) {
5053 RegCloseKey(htypelib);
5056 if (version_str !=
Qnil) {
5058 if (err == ERROR_SUCCESS) {
5062 version = version_str;
5065 RegCloseKey(hversion);
5073 if (err != ERROR_SUCCESS)
5077 RegCloseKey(hversion);
5085 RegCloseKey(hversion);
5089 RegCloseKey(htypelib);
5090 if (typelib !=
Qnil) {
5092 if (SUCCEEDED(hr)) {
5103 HKEY htypelib, hguid, hversion;
5113 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
5114 if(err != ERROR_SUCCESS) {
5117 for(i = 0; !found; i++) {
5122 if (err != ERROR_SUCCESS)
5124 for(j = 0; found ==
Qfalse; j++) {
5129 if (err != ERROR_SUCCESS)
5133 RegCloseKey(hversion);
5138 if (SUCCEEDED(hr)) {
5143 RegCloseKey(hversion);
5147 RegCloseKey(htypelib);
5199 if (len < 1 || len > 3) {
5213 hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
5214 SysFreeString(pbuf);
5215 if (SUCCEEDED(hr)) {
5244 TLIBATTR *pTLibAttr;
5248 len = StringFromGUID2(&pTLibAttr->guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
5252 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5273 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
5295 TLIBATTR *pTLibAttr;
5302 major =
INT2NUM(pTLibAttr->wMajorVerNum);
5303 minor =
INT2NUM(pTLibAttr->wMinorVerNum);
5304 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5320 TLIBATTR *pTLibAttr;
5326 major =
INT2NUM(pTLibAttr->wMajorVerNum);
5327 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5343 TLIBATTR *pTLibAttr;
5348 minor =
INT2NUM(pTLibAttr->wMinorVerNum);
5349 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5369 if (err != ERROR_SUCCESS) {
5372 for(k = 0; path ==
Qnil; k++) {
5377 if (err == ERROR_SUCCESS) {
5394 return E_UNEXPECTED;
5397 hr = LoadTypeLibEx(pBuf, REGKIND_NONE, ppTypeLib);
5398 SysFreeString(pBuf);
5414 TLIBATTR *pTLibAttr;
5423 hr = QueryPathOfRegTypeLib(&pTLibAttr->guid,
5424 pTLibAttr->wMajorVerNum,
5425 pTLibAttr->wMinorVerNum,
5429 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5433 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5456 TLIBATTR *pTLibAttr;
5461 if ((pTLibAttr->wLibFlags == 0) ||
5462 (pTLibAttr->wLibFlags & LIBFLAG_FRESTRICTED) ||
5463 (pTLibAttr->wLibFlags & LIBFLAG_FHIDDEN)) {
5466 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5489 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
5565 hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
5568 SysFreeString(pbuf);
5596 TYPEATTR *pTypeAttr;
5602 switch(pTypeAttr->typekind) {
5612 case TKIND_INTERFACE:
5615 case TKIND_DISPATCH:
5658 TYPEATTR *pTypeAttr;
5665 len = StringFromGUID2(&pTypeAttr->guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
5693 TYPEATTR *pTypeAttr;
5699 hr = ProgIDFromCLSID(&pTypeAttr->guid, &pbuf);
5700 if (SUCCEEDED(hr)) {
5702 CoTaskMemFree(pbuf);
5729 TYPEATTR *pTypeAttr;
5734 if (pTypeAttr->wTypeFlags & (TYPEFLAG_FHIDDEN | TYPEFLAG_FRESTRICTED)) {
5763 TYPEATTR *pTypeAttr;
5768 ver =
INT2FIX(pTypeAttr->wMajorVerNum);
5793 TYPEATTR *pTypeAttr;
5798 ver =
INT2FIX(pTypeAttr->wMinorVerNum);
5823 TYPEATTR *pTypeAttr;
5828 typekind =
INT2FIX(pTypeAttr->typekind);
5882 TYPEATTR *pTypeAttr;
5887 if(pTypeAttr->typekind != TKIND_ALIAS) {
5948 &helpcontext,
NULL);
5991 ITypeInfo *pRefTypeInfo;
5995 TYPEATTR *pTypeAttr;
6003 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
6004 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
6008 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
6011 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
6015 if ((flags & implflags) == implflags) {
6117 TYPEATTR *pTypeAttr;
6131 for(i = 0; i < pTypeAttr->cVars; i++) {
6132 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, i, &pVarDesc);
6137 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
6139 if(FAILED(hr) || len == 0 || !bstr)
6150 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6243 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6247 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6285 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6289 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6319 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6322 if(pVarDesc->varkind == VAR_CONST)
6324 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6363 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6366 if (!(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
6367 VARFLAG_FRESTRICTED |
6368 VARFLAG_FNONBROWSABLE))) {
6371 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6409 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6412 switch(pVarDesc->varkind) {
6413 case VAR_PERINSTANCE:
6428 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6465 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6468 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6469 kind =
INT2FIX(pVarDesc->varkind);
6529 if(pOwnerTypeInfo)
OLE_ADDREF(pOwnerTypeInfo);
6602 FUNCDESC *pFuncDesc;
6606 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6611 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6636 FUNCDESC *pFuncDesc;
6640 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6644 vvt =
INT2FIX(pFuncDesc->elemdescFunc.tdesc.vt);
6645 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6670 FUNCDESC *pFuncDesc;
6674 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6679 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6704 FUNCDESC *pFuncDesc;
6707 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6710 invkind =
INT2FIX(pFuncDesc->invkind);
6711 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6720 if((
FIX2INT(invkind) & INVOKE_PROPERTYGET) &&
6721 (
FIX2INT(invkind) & INVOKE_PROPERTYPUT) ) {
6723 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYGET) {
6725 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYPUT) {
6727 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYPUTREF) {
6729 }
else if(
FIX2INT(invkind) & INVOKE_FUNC) {
6775 FUNCDESC *pFuncDesc;
6778 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6781 if (pFuncDesc->wFuncFlags & (FUNCFLAG_FRESTRICTED |
6783 FUNCFLAG_FNONBROWSABLE)) {
6788 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6812 TYPEATTR *pTypeAttr;
6817 ITypeInfo *pRefTypeInfo;
6818 FUNCDESC *pFuncDesc;
6826 if(pTypeAttr->typekind != TKIND_COCLASS) {
6827 pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
6830 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
6831 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
6835 if (flags & IMPLTYPEFLAG_FSOURCE) {
6836 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
6840 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
6841 href, &pRefTypeInfo);
6844 hr = pRefTypeInfo->lpVtbl->GetFuncDesc(pRefTypeInfo, method_index,
6851 hr = pRefTypeInfo->lpVtbl->GetDocumentation(pRefTypeInfo,
6855 pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
6861 pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
6929 FUNCDESC *pFuncDesc;
6931 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6934 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
6936 helpcontext, helpfile);
6937 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7007 DWORD helpcontext = 0;
7009 &helpcontext,
NULL);
7035 FUNCDESC *pFuncDesc;
7038 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7041 dispid =
INT2NUM(pFuncDesc->memid);
7042 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7066 FUNCDESC *pFuncDesc;
7069 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7072 offset_vtbl =
INT2FIX(pFuncDesc->oVft);
7073 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7097 FUNCDESC *pFuncDesc;
7100 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7103 size_params =
INT2FIX(pFuncDesc->cParams);
7104 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7129 FUNCDESC *pFuncDesc;
7132 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7134 return size_opt_params;
7135 size_opt_params =
INT2FIX(pFuncDesc->cParamsOpt);
7136 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7137 return size_opt_params;
7160 FUNCDESC *pFuncDesc;
7167 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7172 bstrs =
ALLOCA_N(BSTR, pFuncDesc->cParams + 1);
7173 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pFuncDesc->memid,
7174 bstrs, pFuncDesc->cParams + 1,
7177 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7180 SysFreeString(bstrs[0]);
7181 if (pFuncDesc->cParams > 0) {
7182 for(i = 1; i <
len; i++) {
7188 pparam->
index = i - 1;
7193 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7253 FUNCDESC *pFuncDesc;
7258 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7263 bstrs =
ALLOCA_N(BSTR, pFuncDesc->cParams + 1);
7264 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pFuncDesc->memid,
7265 bstrs, pFuncDesc->cParams + 1,
7268 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7271 SysFreeString(bstrs[0]);
7272 if (param_index < 1 || len <= (UINT)param_index)
7274 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7282 pparam->
index = param_index - 1;
7285 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7325 FUNCDESC *pFuncDesc;
7328 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7332 &(pFuncDesc->lprgelemdescParam[index].tdesc),
Qnil);
7333 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7359 FUNCDESC *pFuncDesc;
7362 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7366 &(pFuncDesc->lprgelemdescParam[index].tdesc), typedetail);
7367 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7393 FUNCDESC *pFuncDesc;
7396 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7399 if (
V_UNION1((&(pFuncDesc->lprgelemdescParam[index])), paramdesc).wParamFlags &mask)
7401 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7420 pparam->
index, PARAMFLAG_FIN);
7447 pparam->
index, PARAMFLAG_FOUT);
7465 pparam->
index, PARAMFLAG_FOPT);
7484 pparam->
index, PARAMFLAG_FRETVAL);
7490 FUNCDESC *pFuncDesc;
7491 ELEMDESC *pElemDesc;
7492 PARAMDESCEX * pParamDescEx;
7495 USHORT mask = PARAMFLAG_FOPT|PARAMFLAG_FHASDEFAULT;
7497 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7500 pElemDesc = &pFuncDesc->lprgelemdescParam[
index];
7501 wParamFlags =
V_UNION1(pElemDesc, paramdesc).wParamFlags;
7502 if ((wParamFlags & mask) == mask) {
7503 pParamDescEx =
V_UNION1(pElemDesc, paramdesc).pparamdescex;
7506 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7560 if (defval !=
Qnil) {
7584 if (IsEqualIID(iid, &IID_IUnknown) ||
7585 IsEqualIID(iid, &IID_IDispatch) ||
7586 IsEqualIID(iid, &((PIEVENTSINKOBJ)pEV)->m_iid)) {
7591 return E_NOINTERFACE;
7593 ((LPUNKNOWN)*ppv)->lpVtbl->AddRef((LPUNKNOWN)*ppv);
7631 return DISP_E_BADINDEX;
7635 PEVENTSINK pEventSink,
7646 return pTypeInfo->lpVtbl->GetIDsOfNames(pTypeInfo, szNames, cNames, pDispID);
7648 return DISP_E_UNKNOWNNAME;
7661 for(i = 0; i <
len; i++) {
7685 *is_default =
FALSE;
7688 for(i = 0; i <
len; i++) {
7691 if(
NIL_P(event_name)) {
7696 *is_default =
FALSE;
7707 *is_default_handler =
FALSE;
7714 *is_default_handler =
TRUE;
7740 bstrs =
ALLOCA_N(BSTR, pdispparams->cArgs + 1);
7741 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, dispid,
7742 bstrs, pdispparams->cArgs + 1,
7747 for (i = 0; i < len - 1; i++) {
7754 pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
7775 for(i = 0; i <
RARRAY_LEN(ary) && (
unsigned int) i < pdispparams->cArgs; i++) {
7777 pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
7786 VALUE handler = parg[0];
7787 VALUE mid = parg[1];
7788 VALUE args = parg[2];
7789 return rb_apply(handler, mid, args);
7811 PEVENTSINK pEventSink,
7816 DISPPARAMS *pdispparams,
7817 VARIANT *pvarResult,
7818 EXCEPINFO *pexcepinfo,
7833 BOOL is_default_handler =
FALSE;
7847 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, dispid,
7860 if (handler ==
Qnil) {
7865 if (handler ==
Qnil || mid ==
Qnil) {
7870 if (is_default_handler) {
7875 for (i = 0; i < pdispparams->cArgs; ++
i) {
7876 pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
7880 if (is_outarg ==
Qtrue) {
7907 VariantInit(pvarResult);
7917 if (!g_IsEventSinkVtblInitialized) {
7920 vtEventSink.Release = EVENTSINK_Release;
7926 g_IsEventSinkVtblInitialized =
TRUE;
7938 PIEVENTSINKOBJ pEVObj
7940 if(pEVObj !=
NULL) {
7951 IDispatch *pDispatch;
7954 TYPEATTR *pTypeAttr;
7956 ITypeInfo *pImplTypeInfo;
7957 TYPEATTR *pImplTypeAttr;
7966 BOOL is_found =
FALSE;
7973 hr = pDispatch->lpVtbl->GetTypeInfo(pDispatch, 0, lcid, &pTypeInfo);
7977 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo,
7985 hr = pTypeLib->lpVtbl->GetTypeInfoOfGuid(pTypeLib,
7991 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
7992 for (index = 0; index <
count; index++) {
7993 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib,
8004 if(pTypeAttr->typekind == TKIND_COCLASS) {
8005 for (type = 0; type < pTypeAttr->cImplTypes; type++) {
8006 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
8011 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
8017 hr = pImplTypeInfo->lpVtbl->GetDocumentation(pImplTypeInfo,
8026 if (strcmp(pitf, pstr) == 0) {
8027 hr = pImplTypeInfo->lpVtbl->GetTypeAttr(pImplTypeInfo,
8029 if (SUCCEEDED(hr)) {
8031 *piid = pImplTypeAttr->guid;
8033 *ppTypeInfo = pImplTypeInfo;
8034 (*ppTypeInfo)->lpVtbl->AddRef((*ppTypeInfo));
8036 pImplTypeInfo->lpVtbl->ReleaseTypeAttr(pImplTypeInfo,
8042 if (is_found || FAILED(hr))
8049 if (is_found || FAILED(hr))
8054 return E_NOINTERFACE;
8060 ITypeInfo *pTypeInfo,
8061 TYPEATTR *pTypeAttr,
8062 ITypeInfo **pCOTypeInfo,
8063 TYPEATTR **pCOTypeAttr)
8069 ITypeInfo *pTypeInfo2;
8070 TYPEATTR *pTypeAttr2;
8074 ITypeInfo *pRefTypeInfo;
8075 TYPEATTR *pRefTypeAttr;
8077 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib,
NULL);
8081 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
8082 for (i = 0; i < count && !found; i++) {
8083 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo2);
8091 if (pTypeAttr2->typekind != TKIND_COCLASS) {
8096 for (j = 0; j < pTypeAttr2->cImplTypes && !found; j++) {
8097 hr = pTypeInfo2->lpVtbl->GetImplTypeFlags(pTypeInfo2, j, &flags);
8100 if (!(flags & IMPLTYPEFLAG_FDEFAULT))
8102 hr = pTypeInfo2->lpVtbl->GetRefTypeOfImplType(pTypeInfo2, j, &href);
8105 hr = pTypeInfo2->lpVtbl->GetRefTypeInfo(pTypeInfo2, href, &pRefTypeInfo);
8113 if (IsEqualGUID(&(pTypeAttr->guid), &(pRefTypeAttr->guid))) {
8124 *pCOTypeInfo = pTypeInfo2;
8125 *pCOTypeAttr = pTypeAttr2;
8135 ITypeInfo *pTypeInfo,
8136 TYPEATTR *pTypeAttr,
8137 ITypeInfo **ppTypeInfo)
8144 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
8145 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
8153 if ((flags & IMPLTYPEFLAG_FDEFAULT) &&
8154 (flags & IMPLTYPEFLAG_FSOURCE)) {
8156 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
8160 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
8161 hRefType, ppTypeInfo);
8173 IProvideClassInfo2 *pProvideClassInfo2;
8174 IProvideClassInfo *pProvideClassInfo;
8178 ITypeInfo *pTypeInfo;
8179 ITypeInfo *pTypeInfo2 =
NULL;
8180 TYPEATTR *pTypeAttr;
8181 TYPEATTR *pTypeAttr2 =
NULL;
8187 hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
8188 &IID_IProvideClassInfo2,
8190 if (SUCCEEDED(hr)) {
8191 pProvideClassInfo2 =
p;
8192 hr = pProvideClassInfo2->lpVtbl->GetGUID(pProvideClassInfo2,
8193 GUIDKIND_DEFAULT_SOURCE_DISP_IID,
8196 if (SUCCEEDED(hr)) {
8200 if (SUCCEEDED(hr)) {
8203 hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
8204 &IID_IProvideClassInfo,
8206 if (SUCCEEDED(hr)) {
8207 pProvideClassInfo =
p;
8208 hr = pProvideClassInfo->lpVtbl->GetClassInfo(pProvideClassInfo,
8213 hr = pDispatch->lpVtbl->GetTypeInfo(pDispatch, 0,
cWIN32OLE_lcid, &pTypeInfo );
8226 hr =
find_coclass(pTypeInfo, pTypeAttr, &pTypeInfo2, &pTypeAttr2);
8227 if (SUCCEEDED(hr)) {
8243 hr = (*ppTypeInfo)->lpVtbl->GetTypeAttr(*ppTypeInfo, &pTypeAttr);
8244 if (SUCCEEDED(hr)) {
8245 *piid = pTypeAttr->guid;
8246 (*ppTypeInfo)->lpVtbl->ReleaseTypeAttr(*ppTypeInfo, pTypeAttr);
8287 ITypeInfo *pTypeInfo = 0;
8289 IConnectionPointContainer *pContainer;
8290 IConnectionPoint *pConnectionPoint;
8310 hr =
find_iid(ole, pitf, &iid, &pTypeInfo);
8321 hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
8322 &IID_IConnectionPointContainer,
8327 "failed to query IConnectionPointContainer");
8331 hr = pContainer->lpVtbl->FindConnectionPoint(pContainer,
8341 hr = pConnectionPoint->lpVtbl->Advise(pConnectionPoint,
8515 if (
NIL_P(events)) {
8638 VariantClear(&(pvar->
realvar));
8639 VariantClear(&(pvar->
var));
8650 VariantInit(&(pvar->
var));
8651 VariantInit(&(pvar->
realvar));
8677 SAFEARRAYBOUND *psab =
NULL;
8678 SAFEARRAY *psa =
NULL;
8685 vt = (vt | VT_ARRAY);
8692 psab =
ALLOC_N(SAFEARRAYBOUND, dim);
8698 for (i = 0; i < dim; i++) {
8700 psab[
i].lLbound = 0;
8703 psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
8705 if (psab)
free(psab);
8709 V_VT(&(pvar->
var)) = vt;
8710 if (vt & VT_BYREF) {
8711 V_VT(&(pvar->
realvar)) = (vt & ~VT_BYREF);
8712 V_ARRAY(&(pvar->
realvar)) = psa;
8713 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
8715 V_ARRAY(&(pvar->
var)) = psa;
8717 if (psab)
free(psab);
8750 if (len < 1 || len > 3) {
8759 switch (
TYPE(val)) {
8783 vt = V_VT(&pvar->
var);
8791 SAFEARRAY *psa =
NULL;
8794 if (!(V_VT(&(pvar->
var)) & VT_ARRAY)) {
8797 psa = V_ISBYREF(&(pvar->
var)) ? *V_ARRAYREF(&(pvar->
var)) : V_ARRAY(&(pvar->
var));
8801 hr = SafeArrayLock(psa);
8814 dim = SafeArrayGetDim(psa);
8815 if (dim != ary_size) {
8822 for (i = 0; i < dim; i++) {
8832 hr = SafeArrayUnlock(psa);
8869 if (!V_ISARRAY(&(pvar->
var))) {
8871 "`[]' is not available for this variant type object");
8880 VariantInit(&variant);
8881 V_VT(&variant) = (V_VT(&(pvar->
var)) & ~VT_ARRAY) | VT_BYREF;
8882 hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
8899 if ((vt & ~VT_BYREF) == VT_VARIANT) {
8902 if ( (vt & ~VT_BYREF) != V_VT(var)) {
8903 hr = VariantChangeTypeEx(var, var,
8950 if (!V_ISARRAY(&(pvar->
var))) {
8952 "`[]' is not available for this variant type object");
8962 vt = (V_VT(&(pvar->
var)) & ~VT_ARRAY);
8964 if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) ==
NULL) ||
8965 (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) ==
NULL)) {
8968 hr = SafeArrayPutElement(psa, pid, p);
8975 return argv[argc-1];
8998 vt = V_VT(&(pvar->
var));
9000 if ((vt & ~VT_BYREF) == (VT_UI1|VT_ARRAY)) {
9001 if (vt & VT_BYREF) {
9002 psa = *V_ARRAYREF(&(pvar->
var));
9004 psa = V_ARRAY(&(pvar->
var));
9009 dim = SafeArrayGetDim(psa);
9054 vt = V_VT(&(pvar->
var));
9055 if (V_ISARRAY(&(pvar->
var)) && ((vt & ~VT_BYREF) != (VT_UI1|VT_ARRAY) ||
TYPE(val) !=
T_STRING)) {
9057 "`value=' is not available for this variant type object");
9082 com_vtbl.QueryInterface = QueryInterface;
9085 com_vtbl.GetTypeInfoCount = GetTypeInfoCount;
9086 com_vtbl.GetTypeInfo = GetTypeInfo;
9087 com_vtbl.GetIDsOfNames = GetIDsOfNames;
9186 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)