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) {
1216 hr = OleInitialize(
NULL);
1238 while(PeekMessage(&msg,
NULL,0,0,PM_REMOVE)) {
1239 TranslateMessage(&msg);
1240 DispatchMessage(&msg);
1306 cp == CP_THREAD_ACP ||
1317 #ifndef pIMultiLanguage
1325 pw = SysAllocStringLen(
NULL, size);
1336 pw = SysAllocStringLen(
NULL, size);
1348 #ifndef pIMultiLanguage
1356 pw = SysAllocStringLen(
NULL, size);
1366 pw = SysAllocStringLen(
NULL, size - 1);
1367 MultiByteToWideChar(
cWIN32OLE_cp, 0, pm, len, pw, size);
1398 switch(V_VT(pvar)) {
1400 return &V_UI1(pvar);
1406 return &V_UI2(pvar);
1412 return &V_UI4(pvar);
1420 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1425 return &V_UI8(pvar);
1429 return &
V_INT(pvar);
1438 return &V_DATE(pvar);
1441 return V_BSTR(pvar);
1444 return V_DISPATCH(pvar);
1447 return &V_ERROR(pvar);
1450 return &V_BOOL(pvar);
1453 return V_UNKNOWN(pvar);
1456 return &V_ARRAY(pvar);
1468 for (i = 0; i < dim; i++) {
1469 if (pid[i] > pub[i]) {
1489 if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) ==
NULL) ||
1490 (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) ==
NULL)) {
1493 hr = SafeArrayPutElement(psa, pid, p);
1499 if (pid[i] > pub[i]) {
1516 for (i = 0; i <
len; i++) {
1541 for (i = 0; i <
len; i++) {
1544 if (ary_len < ary_len1) {
1560 SAFEARRAYBOUND *psab =
NULL;
1561 SAFEARRAY *psa =
NULL;
1568 psab =
ALLOC_N(SAFEARRAYBOUND, dim);
1572 if(!psab || !pub || !pid) {
1574 if(psab)
free(psab);
1579 for (i = 0; i < dim; i++) {
1581 psab[
i].lLbound = 0;
1582 pub[
i] = psab[
i].cElements - 1;
1586 if ((vt & ~VT_BYREF) == VT_ARRAY) {
1587 vt = (vt | VT_VARIANT);
1589 psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
1593 hr = SafeArrayLock(psa);
1594 if (SUCCEEDED(hr)) {
1596 hr = SafeArrayUnlock(psa);
1600 if(psab)
free(psab);
1603 if (SUCCEEDED(hr)) {
1609 SafeArrayDestroy(psa);
1622 V_VT(var) = VT_DISPATCH;
1628 VariantCopy(var, &(pvar->
var));
1633 V_VT(var) = VT_DATE;
1637 switch (
TYPE(val)) {
1642 V_VT(var) = VT_BSTR;
1658 V_VT(var) = VT_BOOL;
1659 V_BOOL(var) = VARIANT_TRUE;
1662 V_VT(var) = VT_BOOL;
1663 V_BOOL(var) = VARIANT_FALSE;
1667 V_VT(var) = VT_ERROR;
1668 V_ERROR(var) = DISP_E_PARAMNOTFOUND;
1670 V_VT(var) = VT_EMPTY;
1674 V_VT(var) = VT_DISPATCH;
1684 if (vt == VT_VARIANT) {
1687 V_VT(var) = (vt & ~VT_BYREF);
1688 if (V_VT(var) == VT_DISPATCH) {
1689 V_DISPATCH(var) =
NULL;
1690 }
else if (V_VT(var) == VT_UNKNOWN) {
1691 V_UNKNOWN(var) =
NULL;
1696 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1697 switch(vt & ~VT_BYREF) {
1700 V_I8(var) =
NUM2I8 (val);
1718 switch (
TYPE(val)) {
1720 if (V_VT(var) == (VT_BSTR | VT_BYREF)) {
1726 case (VT_UI1 | VT_BYREF) :
1727 *V_UI1REF(var) =
NUM2CHR(val);
1729 case (VT_I2 | VT_BYREF) :
1730 *V_I2REF(var) = (short)
NUM2INT(val);
1732 case (VT_I4 | VT_BYREF) :
1735 case (VT_R4 | VT_BYREF) :
1736 *V_R4REF(var) = (float)
NUM2INT(val);
1738 case (VT_R8 | VT_BYREF) :
1747 case (VT_I2 | VT_BYREF) :
1748 *V_I2REF(var) = (short)
NUM2INT(val);
1750 case (VT_I4 | VT_BYREF) :
1753 case (VT_R4 | VT_BYREF) :
1754 *V_R4REF(var) = (float)
NUM2DBL(val);
1756 case (VT_R8 | VT_BYREF) :
1764 if (V_VT(var) == (VT_R8 | VT_BYREF)) {
1769 if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
1770 *V_BOOLREF(var) = VARIANT_TRUE;
1774 if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
1775 *V_BOOLREF(var) = VARIANT_FALSE;
1787 if (vt == (VT_VARIANT|VT_BYREF)) {
1790 if (V_VT(realvar) != (vt & ~VT_BYREF)) {
1793 switch(vt & ~VT_BYREF) {
1795 V_I1REF(var) = &V_I1(realvar);
1798 V_UI1REF(var) = &V_UI1(realvar);
1801 V_I2REF(var) = &V_I2(realvar);
1807 V_I4REF(var) = &V_I4(realvar);
1810 V_UI4REF(var) = &V_UI4(realvar);
1813 V_R4REF(var) = &V_R4(realvar);
1816 V_R8REF(var) = &V_R8(realvar);
1819 #if (_MSC_VER >= 1300)
1821 V_I8REF(var) = &V_I8(realvar);
1824 V_UI8REF(var) = &V_UI8(realvar);
1836 V_CYREF(var) = &V_CY(realvar);
1839 V_DATEREF(var) = &V_DATE(realvar);
1842 V_BSTRREF(var) = &V_BSTR(realvar);
1845 V_DISPATCHREF(var) = &V_DISPATCH(realvar);
1848 V_ERRORREF(var) = &V_ERROR(realvar);
1851 V_BOOLREF(var) = &V_BOOL(realvar);
1854 V_UNKNOWNREF(var) = &V_UNKNOWN(realvar);
1857 V_ARRAYREF(var) = &V_ARRAY(realvar);
1871 if (((vt & ~VT_BYREF) == (VT_ARRAY | VT_UI1)) &&
TYPE(val) ==
T_STRING) {
1874 SAFEARRAY *p =
NULL;
1875 SAFEARRAY *psa = SafeArrayCreateVector(VT_UI1, 0, len);
1879 hr = SafeArrayAccessData(psa, &pdest);
1880 if (SUCCEEDED(hr)) {
1882 SafeArrayUnaccessData(psa);
1883 V_VT(&(pvar->
realvar)) = (vt & ~VT_BYREF);
1884 p = V_ARRAY(&(pvar->
realvar));
1886 SafeArrayDestroy(p);
1888 V_ARRAY(&(pvar->
realvar)) = psa;
1889 if (vt & VT_BYREF) {
1890 V_VT(&(pvar->
var)) = vt;
1891 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1893 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1897 SafeArrayDestroy(psa);
1899 }
else if (vt & VT_ARRAY) {
1901 V_VT(&(pvar->
var)) = vt;
1902 if (vt & VT_BYREF) {
1903 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1907 if (SUCCEEDED(hr)) {
1908 if (vt & VT_BYREF) {
1909 V_VT(&(pvar->
var)) = vt;
1910 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1912 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1916 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1917 }
else if ( (vt & ~VT_BYREF) == VT_I8 || (vt & ~VT_BYREF) == VT_UI8) {
1920 V_VT(&(pvar->
var)) = vt;
1921 if (vt & VT_BYREF) {
1927 V_VT(&(pvar->
var)) = vt;
1928 if (vt == (VT_BYREF | VT_VARIANT)) {
1931 V_VT(&(pvar->
realvar)) = vt & ~VT_BYREF;
1932 if (vt & VT_BYREF) {
1938 if (vt == (VT_BYREF | VT_VARIANT)) {
1940 }
else if (vt & VT_BYREF) {
1941 if ( (vt & ~VT_BYREF) != V_VT(&(pvar->
realvar))) {
1945 if (SUCCEEDED(hr)) {
1949 if (vt == V_VT(&(pvar->
realvar))) {
1950 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1952 hr = VariantChangeTypeEx(&(pvar->
var), &(pvar->
realvar),
2028 long *ids =
ALLOC_N(
long, dim);
2032 for(i = 0; i < dim; i++) {
2033 ids[
i] = pid[
i] - plb[
i];
2037 for(i = 0; i < dim-1; i++) {
2051 long id = pid[dim - 1] - plb[dim - 1];
2061 while ( V_VT(pvar) == (VT_BYREF | VT_VARIANT) )
2062 pvar = V_VARIANTREF(pvar);
2064 if(V_ISARRAY(pvar)) {
2065 SAFEARRAY *psa = V_ISBYREF(pvar) ? *V_ARRAYREF(pvar) : V_ARRAY(pvar);
2067 long *pid, *plb, *pub;
2074 dim = SafeArrayGetDim(psa);
2075 VariantInit(&variant);
2076 V_VT(&variant) = (V_VT(pvar) & ~VT_ARRAY) | VT_BYREF;
2082 if(!pid || !plb || !pub) {
2089 for(i = 0; i < dim; ++
i) {
2090 SafeArrayGetLBound(psa, i+1, &plb[i]);
2091 SafeArrayGetLBound(psa, i+1, &pid[i]);
2092 SafeArrayGetUBound(psa, i+1, &pub[i]);
2094 hr = SafeArrayLock(psa);
2095 if (SUCCEEDED(hr)) {
2100 hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
2101 if (SUCCEEDED(hr)) {
2105 for (i = 0; i < dim; ++
i) {
2106 if (++pid[i] <= pub[i])
2111 SafeArrayUnlock(psa);
2118 switch(V_VT(pvar) & ~VT_BYREF){
2127 obj =
INT2NUM((
long)V_I1(pvar));
2132 obj =
INT2NUM((
long)*V_UI1REF(pvar));
2134 obj =
INT2NUM((
long)V_UI1(pvar));
2139 obj =
INT2NUM((
long)*V_I2REF(pvar));
2141 obj =
INT2NUM((
long)V_I2(pvar));
2148 obj =
INT2NUM((
long)V_UI2(pvar));
2153 obj =
INT2NUM((
long)*V_I4REF(pvar));
2155 obj =
INT2NUM((
long)V_I4(pvar));
2160 obj =
INT2NUM((
long)*V_UI4REF(pvar));
2162 obj =
INT2NUM((
long)V_UI4(pvar));
2179 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
2182 #if (_MSC_VER >= 1300)
2192 #if (_MSC_VER >= 1300)
2227 obj =
INT2NUM(*V_ERRORREF(pvar));
2233 if (V_ISBYREF(pvar))
2243 if (V_ISBYREF(pvar))
2244 pDispatch = *V_DISPATCHREF(pvar);
2246 pDispatch = V_DISPATCH(pvar);
2248 if (pDispatch !=
NULL ) {
2263 if (V_ISBYREF(pvar))
2264 punk = *V_UNKNOWNREF(pvar);
2266 punk = V_UNKNOWN(pvar);
2269 hr = punk->lpVtbl->QueryInterface(punk, &IID_IDispatch, &p);
2282 date = *V_DATEREF(pvar);
2284 date = V_DATE(pvar);
2294 VariantInit(&variant);
2295 hr = VariantChangeTypeEx(&variant, pvar,
2297 if (SUCCEEDED(hr) && V_VT(&variant) == VT_BSTR) {
2300 VariantClear(&variant);
2310 return RegOpenKeyEx(hkey, name, 0, KEY_READ, phkey);
2322 char buf[BUFSIZ + 1];
2325 LONG
err = RegEnumKeyEx(hkey, i, buf, &size_buf,
2327 if(err == ERROR_SUCCESS) {
2341 LONG
err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype,
NULL, &size);
2343 if (err == ERROR_SUCCESS) {
2344 pbuf =
ALLOC_N(
char, size + 1);
2345 err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype, (BYTE *)pbuf, &size);
2346 if (err == ERROR_SUCCESS) {
2348 if (dwtype == REG_EXPAND_SZ) {
2349 char* pbuf2 = (
char *)pbuf;
2351 pbuf =
ALLOC_N(
char, len + 1);
2352 ExpandEnvironmentStrings(pbuf2, pbuf, len + 1);
2368 err = RegOpenKeyEx(hkey, subkey, 0, KEY_READ, &hsubkey);
2369 if (err == ERROR_SUCCESS) {
2371 RegCloseKey(hsubkey);
2401 char path[MAX_PATH + 1];
2403 err =
reg_open_key(HKEY_CLASSES_ROOT,
"CLSID", &hroot);
2404 if (err != ERROR_SUCCESS) {
2408 if (err != ERROR_SUCCESS) {
2414 RegCloseKey(hclsid);
2415 if (typelib !=
Qnil) {
2416 ExpandEnvironmentStrings(
StringValuePtr(typelib), path,
sizeof(path));
2417 path[MAX_PATH] =
'\0';
2426 HKEY htypelib, hclsid, hversion, hlang;
2437 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
2438 if(err != ERROR_SUCCESS) {
2441 for(i = 0; !found; i++) {
2446 if (err != ERROR_SUCCESS)
2449 for(j = 0; !found; j++) {
2458 if (typelib ==
Qnil)
2461 for(k = 0; !found; k++) {
2466 if (err == ERROR_SUCCESS) {
2473 RegCloseKey(hversion);
2475 RegCloseKey(hclsid);
2477 RegCloseKey(htypelib);
2497 ITypeInfo *pTypeInfo;
2498 TYPEATTR *pTypeAttr;
2508 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
2509 for (index = 0; index <
count; index++) {
2510 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, index, &pTypeInfo);
2518 for(iVar = 0; iVar < pTypeAttr->cVars; iVar++) {
2519 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, iVar, &pVarDesc);
2522 if(pVarDesc->varkind == VAR_CONST &&
2523 !(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
2524 VARFLAG_FRESTRICTED |
2525 VARFLAG_FNONBROWSABLE))) {
2526 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
2528 if(FAILED(hr) || len == 0 || !bstr)
2532 *pName = toupper((
int)*pName);
2540 SysFreeString(bstr);
2546 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
2548 pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
2566 err = RegConnectRegistry(
StringValuePtr(host), HKEY_LOCAL_MACHINE, &hlm);
2567 if (err != ERROR_SUCCESS)
2568 return HRESULT_FROM_WIN32(err);
2572 err = RegOpenKeyEx(hlm,
StringValuePtr(subkey), 0, KEY_READ, &hpid);
2573 if (err != ERROR_SUCCESS)
2574 hr = HRESULT_FROM_WIN32(err);
2576 len =
sizeof(clsid);
2577 err = RegQueryValueEx(hpid,
"",
NULL, &dwtype, (BYTE *)clsid, &len);
2578 if (err == ERROR_SUCCESS && dwtype == REG_SZ) {
2580 hr = CLSIDFromString(pbuf, pclsid);
2581 SysFreeString(pbuf);
2584 hr = HRESULT_FROM_WIN32(err);
2595 VALUE ole, host, others;
2600 COSERVERINFO serverinfo;
2602 DWORD clsctx = CLSCTX_REMOTE_SERVER;
2605 gole32 = LoadLibrary(
"OLE32");
2610 GetProcAddress(
gole32,
"CoCreateInstanceEx");
2616 hr = CLSIDFromProgID(pbuf, &clsid);
2620 hr = CLSIDFromString(pbuf, &clsid);
2621 SysFreeString(pbuf);
2624 "unknown OLE server: `%s'",
2626 memset(&serverinfo, 0,
sizeof(COSERVERINFO));
2628 memset(&multi_qi, 0,
sizeof(MULTI_QI));
2629 multi_qi.pIID = &IID_IDispatch;
2631 SysFreeString(serverinfo.pwszName);
2634 "failed to create DCOM server `%s' in `%s'",
2655 hr = CreateBindCtx(0, &pBindCtx);
2658 "failed to create bind context");
2662 hr = MkParseDisplayName(pBindCtx, pbuf, &eaten, &pMoniker);
2663 SysFreeString(pbuf);
2667 "failed to parse display name of moniker `%s'",
2670 hr = pMoniker->lpVtbl->BindToObject(pMoniker, pBindCtx,
NULL,
2671 &IID_IDispatch, &p);
2678 "failed to bind moniker `%s'",
2718 hr = CLSIDFromProgID(pBuf, &clsid);
2720 hr = CLSIDFromString(pBuf, &clsid);
2722 SysFreeString(pBuf);
2727 hr = GetActiveObject(&clsid, 0, &pUnknown);
2732 hr = pUnknown->lpVtbl->QueryInterface(pUnknown, &IID_IDispatch, &p);
2737 "failed to create WIN32OLE server `%s'",
2781 ITypeInfo *pTypeInfo;
2799 0, lcid, &pTypeInfo);
2803 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
2823 hr = LoadTypeLibEx(pBuf, REGKIND_NONE, &pTypeLib);
2824 SysFreeString(pBuf);
2849 ITypeInfo *pTypeInfo;
2853 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
2854 for (i = 0; i <
count; i++) {
2855 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
2860 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
2926 FNHTMLHELP *pfnHtmlHelp;
2930 ghhctrl = LoadLibrary(
"HHCTRL.OCX");
2933 pfnHtmlHelp = (FNHTMLHELP*)GetProcAddress(
ghhctrl,
"HtmlHelpA");
3000 static BOOL CALLBACK
3094 case LOCALE_SYSTEM_DEFAULT:
3095 case LOCALE_USER_DEFAULT:
3119 hr = CoCreateGuid(&guid);
3123 len = StringFromGUID2(&guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
3139 hr = OleInitialize(
NULL);
3232 rb_scan_args(argc, argv,
"11*", &svr_name, &host, &others);
3250 hr = CLSIDFromProgID(pBuf, &clsid);
3252 hr = CLSIDFromString(pBuf, &clsid);
3254 SysFreeString(pBuf);
3257 "unknown OLE server: `%s'",
3262 hr = CoCreateInstance(&clsid,
NULL, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
3263 &IID_IDispatch, &p);
3267 "failed to create WIN32OLE object from `%s'",
3278 unsigned int index,
i;
3280 index = pOp->
dp.cNamedArgs;
3288 for(i = 1; i < index + 1; i++) {
3292 for(i = 0; i < index; i++ ) {
3293 VariantClear(&(pOp->
dp.rgvarg[i]));
3306 VariantInit(&(pOp->
dp.rgvarg[index]));
3309 pOp->
dp.cNamedArgs += 1;
3314 set_argv(VARIANTARG* realargs,
unsigned int beg,
unsigned int end)
3320 while (end-- > beg) {
3322 VariantClear(&realargs[end]);
3343 EXCEPINFO excepinfo;
3345 VARIANTARG* realargs =
NULL;
3346 unsigned int argErr = 0;
3348 unsigned int cNamedArgs;
3352 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3354 VariantInit(&result);
3357 op.
dp.rgdispidNamedArgs =
NULL;
3358 op.
dp.cNamedArgs = 0;
3373 DispID = DISPID_VALUE;
3379 &wcmdname, 1, lcid, &DispID);
3380 SysFreeString(wcmdname);
3383 "unknown property or method: `%s'",
3391 op.
dp.cNamedArgs = 0;
3399 op.
dp.cArgs = cNamedArgs + argc - 2;
3404 pDispID =
ALLOCA_N(DISPID, cNamedArgs + 1);
3409 op.dp.cNamedArgs + 1,
3411 for(i = 0; i < op.dp.cNamedArgs + 1; i++) {
3412 SysFreeString(op.pNamedArgs[i]);
3413 op.pNamedArgs[
i] =
NULL;
3417 for(i = 0; i < op.dp.cArgs; i++ ) {
3418 VariantClear(&op.dp.rgvarg[i]);
3421 "failed to get named argument info: `%s'",
3424 op.dp.rgdispidNamedArgs = &(pDispID[1]);
3428 op.
dp.cArgs = argc - 1;
3430 if (op.
dp.cArgs > 0) {
3437 if(op.
dp.cArgs > cNamedArgs) {
3438 realargs =
ALLOCA_N(VARIANTARG, op.
dp.cArgs-cNamedArgs+1);
3439 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3440 n = op.
dp.cArgs - i + cNamedArgs - 1;
3441 VariantInit(&realargs[n]);
3442 VariantInit(&op.
dp.rgvarg[n]);
3446 VariantCopy(&op.
dp.rgvarg[n], &(pvar->
var));
3449 V_VT(&op.
dp.rgvarg[n]) = VT_VARIANT | VT_BYREF;
3450 V_VARIANTREF(&op.
dp.rgvarg[n]) = &realargs[n];
3455 if (wFlags & DISPATCH_PROPERTYPUT) {
3456 if (op.
dp.cArgs == 0)
3459 op.
dp.cNamedArgs = 1;
3460 op.
dp.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
3461 op.
dp.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
3465 &IID_NULL, lcid, wFlags, &op.
dp,
3466 &result, &excepinfo, &argErr);
3470 if(op.
dp.cArgs >= cNamedArgs) {
3471 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3472 n = op.
dp.cArgs - i + cNamedArgs - 1;
3476 if (hr == DISP_E_EXCEPTION) {
3479 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3480 VariantInit(&result);
3482 &IID_NULL, lcid, wFlags,
3484 &excepinfo, &argErr);
3490 if ((hr == DISP_E_EXCEPTION || hr == DISP_E_MEMBERNOTFOUND) && DispID > 0x8000) {
3491 if (hr == DISP_E_EXCEPTION) {
3494 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3496 &IID_NULL, lcid, wFlags,
3498 &excepinfo, &argErr);
3501 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3502 n = op.
dp.cArgs - i + cNamedArgs - 1;
3503 VariantClear(&op.
dp.rgvarg[n]);
3509 if (op.
dp.cArgs > cNamedArgs) {
3510 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3511 n = op.
dp.cArgs - i + cNamedArgs - 1;
3515 if (hr == DISP_E_EXCEPTION) {
3518 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3519 VariantInit(&result);
3521 &IID_NULL, lcid, wFlags,
3523 &excepinfo, &argErr);
3524 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3525 n = op.
dp.cArgs - i + cNamedArgs - 1;
3526 VariantClear(&op.
dp.rgvarg[n]);
3533 if(op.
dp.cArgs > cNamedArgs) {
3534 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3535 n = op.
dp.cArgs - i + cNamedArgs - 1;
3544 for(i = 0; i < op.
dp.cArgs; i++) {
3545 VariantClear(&op.
dp.rgvarg[i]);
3556 VariantClear(&result);
3576 return ole_invoke(argc, argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
3584 unsigned int argErr = 0;
3585 EXCEPINFO excepinfo;
3587 DISPPARAMS dispParams;
3588 VARIANTARG* realargs =
NULL;
3598 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3599 memset(&dispParams, 0,
sizeof(DISPPARAMS));
3600 VariantInit(&result);
3604 dispParams.rgvarg =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
3605 realargs =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
3606 for (i = 0, j = dispParams.cArgs - 1; i < (
int)dispParams.cArgs; i++, j--)
3608 VariantInit(&realargs[i]);
3609 VariantInit(&dispParams.rgvarg[i]);
3612 V_VT(&dispParams.rgvarg[i]) = vt;
3617 V_VT(&dispParams.rgvarg[i]) = V_VT(&realargs[i]) = VT_ERROR;
3618 V_ERROR(&dispParams.rgvarg[i]) = V_ERROR(&realargs[i]) = DISP_E_PARAMNOTFOUND;
3631 SAFEARRAYBOUND rgsabound[1];
3633 rgsabound[0].lLbound = 0;
3635 v = vt & ~(VT_ARRAY | VT_BYREF);
3636 V_ARRAY(&realargs[i]) = SafeArrayCreate(v, 1, rgsabound);
3637 V_VT(&realargs[i]) = VT_ARRAY |
v;
3638 SafeArrayLock(V_ARRAY(&realargs[i]));
3639 pb = V_ARRAY(&realargs[i])->pvData;
3640 ps = V_ARRAY(&realargs[i])->pvData;
3641 pl = V_ARRAY(&realargs[i])->pvData;
3642 py = V_ARRAY(&realargs[i])->pvData;
3643 pv = V_ARRAY(&realargs[i])->pvData;
3644 for (ent = 0; ent < (int)rgsabound[0].cElements; ent++)
3649 if (v != VT_VARIANT)
3651 VariantChangeTypeEx(&velem, &velem,
3664 *py++ = V_CY(&velem);
3670 *ps++ = V_I2(&velem);
3675 *pb++ = V_UI1(&velem);
3679 *pl++ = V_I4(&velem);
3683 SafeArrayUnlock(V_ARRAY(&realargs[i]));
3688 if ((vt & (~VT_BYREF)) != VT_VARIANT)
3690 hr = VariantChangeTypeEx(&realargs[i], &realargs[i],
3692 (VARTYPE)(vt & (~VT_BYREF)));
3699 if ((vt & VT_BYREF) || vt == VT_VARIANT)
3701 if (vt == VT_VARIANT)
3702 V_VT(&dispParams.rgvarg[i]) = VT_VARIANT | VT_BYREF;
3703 switch (vt & (~VT_BYREF))
3707 V_VARIANTREF(&dispParams.rgvarg[i]) = &realargs[
i];
3713 V_CYREF(&dispParams.rgvarg[i]) = &V_CY(&realargs[i]);
3719 V_I2REF(&dispParams.rgvarg[i]) = &V_I2(&realargs[i]);
3724 V_UI1REF(&dispParams.rgvarg[i]) = &V_UI1(&realargs[i]);
3728 V_I4REF(&dispParams.rgvarg[i]) = &V_I4(&realargs[i]);
3735 V_CY(&dispParams.rgvarg[i]) = V_CY(&realargs[i]);
3740 if (dispkind & DISPATCH_PROPERTYPUT) {
3741 dispParams.cNamedArgs = 1;
3742 dispParams.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
3743 dispParams.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
3749 &dispParams, &result,
3750 &excepinfo, &argErr);
3760 if(dispParams.cArgs > 0) {
3761 set_argv(realargs, 0, dispParams.cArgs);
3765 VariantClear(&result);
3784 return ole_invoke2(
self, dispid, args, types, DISPATCH_METHOD);
3802 return ole_invoke2(
self, dispid, args, types, DISPATCH_PROPERTYGET);
3820 return ole_invoke2(
self, dispid, args, types, DISPATCH_PROPERTYPUT);
3895 EXCEPINFO excepinfo;
3896 DISPID dispID = DISPID_VALUE;
3897 DISPID dispIDParam = DISPID_PROPERTYPUT;
3898 USHORT wFlags = DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF;
3899 DISPPARAMS dispParams;
3900 VARIANTARG propertyValue[2];
3904 dispParams.rgdispidNamedArgs = &dispIDParam;
3905 dispParams.rgvarg = propertyValue;
3906 dispParams.cNamedArgs = 1;
3907 dispParams.cArgs = 1;
3909 VariantInit(&propertyValue[0]);
3910 VariantInit(&propertyValue[1]);
3911 memset(&excepinfo, 0,
sizeof(excepinfo));
3918 pBuf, 1, lcid, &dispID);
3919 SysFreeString(pBuf[0]);
3924 "unknown property or method: `%s'",
3930 lcid, wFlags, &dispParams,
3931 NULL, &excepinfo, &argErr);
3933 for(index = 0; index < dispParams.cArgs; ++index) {
3934 VariantClear(&propertyValue[index]);
3970 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
3971 VariantInit(&variant);
3972 while(pEnum->lpVtbl->Next(pEnum, 1, &variant,
NULL) ==
S_OK) {
3974 VariantClear(&variant);
3975 VariantInit(&variant);
3984 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
4010 unsigned int argErr;
4011 EXCEPINFO excepinfo;
4012 DISPPARAMS dispParams;
4015 IEnumVARIANT *pEnum =
NULL;
4020 VariantInit(&result);
4021 dispParams.rgvarg =
NULL;
4022 dispParams.rgdispidNamedArgs =
NULL;
4023 dispParams.cNamedArgs = 0;
4024 dispParams.cArgs = 0;
4025 memset(&excepinfo, 0,
sizeof(excepinfo));
4030 DISPATCH_METHOD | DISPATCH_PROPERTYGET,
4031 &dispParams, &result,
4032 &excepinfo, &argErr);
4035 VariantClear(&result);
4039 if (V_VT(&result) == VT_UNKNOWN) {
4040 hr = V_UNKNOWN(&result)->lpVtbl->QueryInterface(V_UNKNOWN(&result),
4044 }
else if (V_VT(&result) == VT_DISPATCH) {
4045 hr = V_DISPATCH(&result)->lpVtbl->QueryInterface(V_DISPATCH(&result),
4050 if (FAILED(hr) || !pEnum) {
4051 VariantClear(&result);
4055 VariantClear(&result);
4078 if(mname[n-1] ==
'=') {
4085 return ole_invoke(argc, argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
4093 TYPEATTR *pTypeAttr;
4095 FUNCDESC *pFuncDesc;
4103 for(i = 0; i < pTypeAttr->cFuncs && method ==
Qnil; i++) {
4104 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
4108 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
4111 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4119 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4130 TYPEATTR *pTypeAttr;
4133 ITypeInfo *pRefTypeInfo;
4140 if (method !=
Qnil) {
4143 for(i=0; i < pTypeAttr->cImplTypes && method ==
Qnil; i++){
4144 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
4147 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
4161 TYPEATTR *pTypeAttr;
4164 FUNCDESC *pFuncDesc;
4171 for(i = 0; i < pTypeAttr->cFuncs; i++) {
4173 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
4177 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
4180 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4183 if(pFuncDesc->invkind & mask) {
4189 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4201 TYPEATTR *pTypeAttr;
4204 ITypeInfo *pRefTypeInfo;
4212 for(i=0; i < pTypeAttr->cImplTypes; i++){
4213 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
4216 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
4229 ITypeInfo *pTypeInfo;
4237 0, lcid, &pTypeInfo);
4241 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo,
4246 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
4251 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
4252 for (i = 0; i <
count; i++) {
4253 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4256 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
4257 if (SUCCEEDED(hr)) {
4270 ITypeInfo *pTypeInfo;
4300 return ole_methods(
self, INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF);
4332 return ole_methods(
self, INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF);
4361 hr = pTypeInfo->lpVtbl->GetContainingTypeLib( pTypeInfo, &pTypeLib, &index );
4365 hr = pTypeLib->lpVtbl->GetDocumentation( pTypeLib, index,
4388 ITypeInfo *pTypeInfo;
4416 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
4441 ITypeInfo *pTypeInfo;
4447 0, lcid, &pTypeInfo);
4453 if (vtlib ==
Qnil) {
4480 hr = CLSIDFromString(pBuf, &iid);
4481 SysFreeString(pBuf);
4484 "invalid iid: `%s'",
4497 "failed to get interface `%s'",
4532 SysFreeString(wcmdname);
4543 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
4548 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4550 helpcontext, helpfile);
4564 ITypeInfo *pRefTypeInfo;
4567 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
4579 if(typedetails !=
Qnil)
4587 TYPEDESC *p = pTypeDesc;
4590 if (p->vt == VT_PTR || p->vt == VT_SAFEARRAY) {
4602 switch(pTypeDesc->vt) {
4645 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
4667 if(typedetails !=
Qnil)
4672 if(typedetails !=
Qnil)
4678 case VT_USERDEFINED:
4680 if (typedetails !=
Qnil)
4707 if (typedetails !=
Qnil)
4726 ITypeInfo *pTypeInfo;
4769 IPersistMemory *pPersistMemory;
4776 hr = pole->
pDispatch->lpVtbl->QueryInterface(pole->
pDispatch, &IID_IPersistMemory, &p);
4778 if (SUCCEEDED(hr)) {
4779 hr = pPersistMemory->lpVtbl->InitNew(pPersistMemory);
4781 if (SUCCEEDED(hr)) {
4830 return rb_eval_string(
"WIN32OLE_TYPELIB.typelibs.collect{|t|t.name}");
4842 HKEY hclsids, hclsid;
4849 err =
reg_open_key(HKEY_CLASSES_ROOT,
"CLSID", &hclsids);
4850 if(err != ERROR_SUCCESS) {
4858 if (err != ERROR_SUCCESS)
4864 RegCloseKey(hclsid);
4866 RegCloseKey(hclsids);
4905 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
4906 for (i = 0; i < count && found ==
Qfalse; i++) {
4907 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
4910 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4951 hr = pTypeLib->lpVtbl->GetLibAttr(pTypeLib, ppTLibAttr);
4954 "failed to get library attribute(TLIBATTR) from ITypeLib");
4971 HKEY htypelib, hguid;
4982 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
4983 if(err != ERROR_SUCCESS) {
4991 if (err != ERROR_SUCCESS)
4995 if (version ==
Qnil)
4999 if (SUCCEEDED(hr)) {
5008 RegCloseKey(htypelib);
5017 if (major ==
Qnil) {
5021 if (minor !=
Qnil) {
5032 HKEY htypelib, hguid, hversion;
5048 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
5049 if(err != ERROR_SUCCESS) {
5053 if (err != ERROR_SUCCESS) {
5054 RegCloseKey(htypelib);
5057 if (version_str !=
Qnil) {
5059 if (err == ERROR_SUCCESS) {
5063 version = version_str;
5066 RegCloseKey(hversion);
5074 if (err != ERROR_SUCCESS)
5078 RegCloseKey(hversion);
5086 RegCloseKey(hversion);
5090 RegCloseKey(htypelib);
5091 if (typelib !=
Qnil) {
5093 if (SUCCEEDED(hr)) {
5104 HKEY htypelib, hguid, hversion;
5114 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
5115 if(err != ERROR_SUCCESS) {
5118 for(i = 0; !found; i++) {
5123 if (err != ERROR_SUCCESS)
5125 for(j = 0; found ==
Qfalse; j++) {
5130 if (err != ERROR_SUCCESS)
5134 RegCloseKey(hversion);
5139 if (SUCCEEDED(hr)) {
5144 RegCloseKey(hversion);
5148 RegCloseKey(htypelib);
5200 if (len < 1 || len > 3) {
5214 hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
5215 SysFreeString(pbuf);
5216 if (SUCCEEDED(hr)) {
5245 TLIBATTR *pTLibAttr;
5249 len = StringFromGUID2(&pTLibAttr->guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
5253 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5274 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
5296 TLIBATTR *pTLibAttr;
5303 major =
INT2NUM(pTLibAttr->wMajorVerNum);
5304 minor =
INT2NUM(pTLibAttr->wMinorVerNum);
5305 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5321 TLIBATTR *pTLibAttr;
5327 major =
INT2NUM(pTLibAttr->wMajorVerNum);
5328 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5344 TLIBATTR *pTLibAttr;
5349 minor =
INT2NUM(pTLibAttr->wMinorVerNum);
5350 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5370 if (err != ERROR_SUCCESS) {
5373 for(k = 0; path ==
Qnil; k++) {
5378 if (err == ERROR_SUCCESS) {
5395 return E_UNEXPECTED;
5398 hr = LoadTypeLibEx(pBuf, REGKIND_NONE, ppTypeLib);
5399 SysFreeString(pBuf);
5415 TLIBATTR *pTLibAttr;
5424 hr = QueryPathOfRegTypeLib(&pTLibAttr->guid,
5425 pTLibAttr->wMajorVerNum,
5426 pTLibAttr->wMinorVerNum,
5430 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5434 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5457 TLIBATTR *pTLibAttr;
5462 if ((pTLibAttr->wLibFlags == 0) ||
5463 (pTLibAttr->wLibFlags & LIBFLAG_FRESTRICTED) ||
5464 (pTLibAttr->wLibFlags & LIBFLAG_FHIDDEN)) {
5467 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5490 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
5566 hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
5569 SysFreeString(pbuf);
5597 TYPEATTR *pTypeAttr;
5603 switch(pTypeAttr->typekind) {
5613 case TKIND_INTERFACE:
5616 case TKIND_DISPATCH:
5659 TYPEATTR *pTypeAttr;
5666 len = StringFromGUID2(&pTypeAttr->guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
5694 TYPEATTR *pTypeAttr;
5700 hr = ProgIDFromCLSID(&pTypeAttr->guid, &pbuf);
5701 if (SUCCEEDED(hr)) {
5703 CoTaskMemFree(pbuf);
5730 TYPEATTR *pTypeAttr;
5735 if (pTypeAttr->wTypeFlags & (TYPEFLAG_FHIDDEN | TYPEFLAG_FRESTRICTED)) {
5764 TYPEATTR *pTypeAttr;
5769 ver =
INT2FIX(pTypeAttr->wMajorVerNum);
5794 TYPEATTR *pTypeAttr;
5799 ver =
INT2FIX(pTypeAttr->wMinorVerNum);
5824 TYPEATTR *pTypeAttr;
5829 typekind =
INT2FIX(pTypeAttr->typekind);
5883 TYPEATTR *pTypeAttr;
5888 if(pTypeAttr->typekind != TKIND_ALIAS) {
5949 &helpcontext,
NULL);
5992 ITypeInfo *pRefTypeInfo;
5996 TYPEATTR *pTypeAttr;
6004 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
6005 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
6009 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
6012 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
6016 if ((flags & implflags) == implflags) {
6118 TYPEATTR *pTypeAttr;
6132 for(i = 0; i < pTypeAttr->cVars; i++) {
6133 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, i, &pVarDesc);
6138 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
6140 if(FAILED(hr) || len == 0 || !bstr)
6151 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6244 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6248 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6286 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6290 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6320 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6323 if(pVarDesc->varkind == VAR_CONST)
6325 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6364 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6367 if (!(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
6368 VARFLAG_FRESTRICTED |
6369 VARFLAG_FNONBROWSABLE))) {
6372 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6410 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6413 switch(pVarDesc->varkind) {
6414 case VAR_PERINSTANCE:
6429 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6466 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6469 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6470 kind =
INT2FIX(pVarDesc->varkind);
6530 if(pOwnerTypeInfo)
OLE_ADDREF(pOwnerTypeInfo);
6603 FUNCDESC *pFuncDesc;
6607 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6612 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6637 FUNCDESC *pFuncDesc;
6641 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6645 vvt =
INT2FIX(pFuncDesc->elemdescFunc.tdesc.vt);
6646 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6671 FUNCDESC *pFuncDesc;
6675 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6680 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6705 FUNCDESC *pFuncDesc;
6708 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6711 invkind =
INT2FIX(pFuncDesc->invkind);
6712 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6721 if((
FIX2INT(invkind) & INVOKE_PROPERTYGET) &&
6722 (
FIX2INT(invkind) & INVOKE_PROPERTYPUT) ) {
6724 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYGET) {
6726 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYPUT) {
6728 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYPUTREF) {
6730 }
else if(
FIX2INT(invkind) & INVOKE_FUNC) {
6776 FUNCDESC *pFuncDesc;
6779 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6782 if (pFuncDesc->wFuncFlags & (FUNCFLAG_FRESTRICTED |
6784 FUNCFLAG_FNONBROWSABLE)) {
6789 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6813 TYPEATTR *pTypeAttr;
6818 ITypeInfo *pRefTypeInfo;
6819 FUNCDESC *pFuncDesc;
6827 if(pTypeAttr->typekind != TKIND_COCLASS) {
6828 pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
6831 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
6832 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
6836 if (flags & IMPLTYPEFLAG_FSOURCE) {
6837 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
6841 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
6842 href, &pRefTypeInfo);
6845 hr = pRefTypeInfo->lpVtbl->GetFuncDesc(pRefTypeInfo, method_index,
6852 hr = pRefTypeInfo->lpVtbl->GetDocumentation(pRefTypeInfo,
6856 pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
6862 pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
6930 FUNCDESC *pFuncDesc;
6932 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6935 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
6937 helpcontext, helpfile);
6938 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7008 DWORD helpcontext = 0;
7010 &helpcontext,
NULL);
7036 FUNCDESC *pFuncDesc;
7039 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7042 dispid =
INT2NUM(pFuncDesc->memid);
7043 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7067 FUNCDESC *pFuncDesc;
7070 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7073 offset_vtbl =
INT2FIX(pFuncDesc->oVft);
7074 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7098 FUNCDESC *pFuncDesc;
7101 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7104 size_params =
INT2FIX(pFuncDesc->cParams);
7105 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7130 FUNCDESC *pFuncDesc;
7133 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7135 return size_opt_params;
7136 size_opt_params =
INT2FIX(pFuncDesc->cParamsOpt);
7137 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7138 return size_opt_params;
7161 FUNCDESC *pFuncDesc;
7168 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7173 bstrs =
ALLOCA_N(BSTR, pFuncDesc->cParams + 1);
7174 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pFuncDesc->memid,
7175 bstrs, pFuncDesc->cParams + 1,
7178 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7181 SysFreeString(bstrs[0]);
7182 if (pFuncDesc->cParams > 0) {
7183 for(i = 1; i <
len; i++) {
7189 pparam->
index = i - 1;
7194 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7254 FUNCDESC *pFuncDesc;
7259 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7264 bstrs =
ALLOCA_N(BSTR, pFuncDesc->cParams + 1);
7265 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pFuncDesc->memid,
7266 bstrs, pFuncDesc->cParams + 1,
7269 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7272 SysFreeString(bstrs[0]);
7273 if (param_index < 1 || len <= (UINT)param_index)
7275 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7283 pparam->
index = param_index - 1;
7286 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7326 FUNCDESC *pFuncDesc;
7329 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7333 &(pFuncDesc->lprgelemdescParam[index].tdesc),
Qnil);
7334 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7360 FUNCDESC *pFuncDesc;
7363 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7367 &(pFuncDesc->lprgelemdescParam[index].tdesc), typedetail);
7368 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7394 FUNCDESC *pFuncDesc;
7397 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7400 if (
V_UNION1((&(pFuncDesc->lprgelemdescParam[index])), paramdesc).wParamFlags &mask)
7402 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7421 pparam->
index, PARAMFLAG_FIN);
7448 pparam->
index, PARAMFLAG_FOUT);
7466 pparam->
index, PARAMFLAG_FOPT);
7485 pparam->
index, PARAMFLAG_FRETVAL);
7491 FUNCDESC *pFuncDesc;
7492 ELEMDESC *pElemDesc;
7493 PARAMDESCEX * pParamDescEx;
7496 USHORT mask = PARAMFLAG_FOPT|PARAMFLAG_FHASDEFAULT;
7498 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7501 pElemDesc = &pFuncDesc->lprgelemdescParam[
index];
7502 wParamFlags =
V_UNION1(pElemDesc, paramdesc).wParamFlags;
7503 if ((wParamFlags & mask) == mask) {
7504 pParamDescEx =
V_UNION1(pElemDesc, paramdesc).pparamdescex;
7507 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7561 if (defval !=
Qnil) {
7585 if (IsEqualIID(iid, &IID_IUnknown) ||
7586 IsEqualIID(iid, &IID_IDispatch) ||
7587 IsEqualIID(iid, &((PIEVENTSINKOBJ)pEV)->m_iid)) {
7592 return E_NOINTERFACE;
7594 ((LPUNKNOWN)*ppv)->lpVtbl->AddRef((LPUNKNOWN)*ppv);
7632 return DISP_E_BADINDEX;
7636 PEVENTSINK pEventSink,
7647 return pTypeInfo->lpVtbl->GetIDsOfNames(pTypeInfo, szNames, cNames, pDispID);
7649 return DISP_E_UNKNOWNNAME;
7662 for(i = 0; i <
len; i++) {
7686 *is_default =
FALSE;
7689 for(i = 0; i <
len; i++) {
7692 if(
NIL_P(event_name)) {
7697 *is_default =
FALSE;
7708 *is_default_handler =
FALSE;
7715 *is_default_handler =
TRUE;
7741 bstrs =
ALLOCA_N(BSTR, pdispparams->cArgs + 1);
7742 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, dispid,
7743 bstrs, pdispparams->cArgs + 1,
7748 for (i = 0; i < len - 1; i++) {
7755 pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
7776 for(i = 0; i <
RARRAY_LEN(ary) && (
unsigned int) i < pdispparams->cArgs; i++) {
7778 pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
7787 VALUE handler = parg[0];
7788 VALUE mid = parg[1];
7789 VALUE args = parg[2];
7790 return rb_apply(handler, mid, args);
7812 PEVENTSINK pEventSink,
7817 DISPPARAMS *pdispparams,
7818 VARIANT *pvarResult,
7819 EXCEPINFO *pexcepinfo,
7834 BOOL is_default_handler =
FALSE;
7848 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, dispid,
7861 if (handler ==
Qnil) {
7866 if (handler ==
Qnil || mid ==
Qnil) {
7871 if (is_default_handler) {
7876 for (i = 0; i < pdispparams->cArgs; ++
i) {
7877 pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
7881 if (is_outarg ==
Qtrue) {
7908 VariantInit(pvarResult);
7918 if (!g_IsEventSinkVtblInitialized) {
7921 vtEventSink.Release = EVENTSINK_Release;
7927 g_IsEventSinkVtblInitialized =
TRUE;
7939 PIEVENTSINKOBJ pEVObj
7941 if(pEVObj !=
NULL) {
7952 IDispatch *pDispatch;
7955 TYPEATTR *pTypeAttr;
7957 ITypeInfo *pImplTypeInfo;
7958 TYPEATTR *pImplTypeAttr;
7967 BOOL is_found =
FALSE;
7974 hr = pDispatch->lpVtbl->GetTypeInfo(pDispatch, 0, lcid, &pTypeInfo);
7978 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo,
7986 hr = pTypeLib->lpVtbl->GetTypeInfoOfGuid(pTypeLib,
7992 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
7993 for (index = 0; index <
count; index++) {
7994 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib,
8005 if(pTypeAttr->typekind == TKIND_COCLASS) {
8006 for (type = 0; type < pTypeAttr->cImplTypes; type++) {
8007 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
8012 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
8018 hr = pImplTypeInfo->lpVtbl->GetDocumentation(pImplTypeInfo,
8027 if (strcmp(pitf, pstr) == 0) {
8028 hr = pImplTypeInfo->lpVtbl->GetTypeAttr(pImplTypeInfo,
8030 if (SUCCEEDED(hr)) {
8032 *piid = pImplTypeAttr->guid;
8034 *ppTypeInfo = pImplTypeInfo;
8035 (*ppTypeInfo)->lpVtbl->AddRef((*ppTypeInfo));
8037 pImplTypeInfo->lpVtbl->ReleaseTypeAttr(pImplTypeInfo,
8043 if (is_found || FAILED(hr))
8050 if (is_found || FAILED(hr))
8055 return E_NOINTERFACE;
8061 ITypeInfo *pTypeInfo,
8062 TYPEATTR *pTypeAttr,
8063 ITypeInfo **pCOTypeInfo,
8064 TYPEATTR **pCOTypeAttr)
8070 ITypeInfo *pTypeInfo2;
8071 TYPEATTR *pTypeAttr2;
8075 ITypeInfo *pRefTypeInfo;
8076 TYPEATTR *pRefTypeAttr;
8078 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib,
NULL);
8082 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
8083 for (i = 0; i < count && !found; i++) {
8084 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo2);
8092 if (pTypeAttr2->typekind != TKIND_COCLASS) {
8097 for (j = 0; j < pTypeAttr2->cImplTypes && !found; j++) {
8098 hr = pTypeInfo2->lpVtbl->GetImplTypeFlags(pTypeInfo2, j, &flags);
8101 if (!(flags & IMPLTYPEFLAG_FDEFAULT))
8103 hr = pTypeInfo2->lpVtbl->GetRefTypeOfImplType(pTypeInfo2, j, &href);
8106 hr = pTypeInfo2->lpVtbl->GetRefTypeInfo(pTypeInfo2, href, &pRefTypeInfo);
8114 if (IsEqualGUID(&(pTypeAttr->guid), &(pRefTypeAttr->guid))) {
8125 *pCOTypeInfo = pTypeInfo2;
8126 *pCOTypeAttr = pTypeAttr2;
8136 ITypeInfo *pTypeInfo,
8137 TYPEATTR *pTypeAttr,
8138 ITypeInfo **ppTypeInfo)
8145 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
8146 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
8154 if ((flags & IMPLTYPEFLAG_FDEFAULT) &&
8155 (flags & IMPLTYPEFLAG_FSOURCE)) {
8157 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
8161 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
8162 hRefType, ppTypeInfo);
8174 IProvideClassInfo2 *pProvideClassInfo2;
8175 IProvideClassInfo *pProvideClassInfo;
8179 ITypeInfo *pTypeInfo;
8180 ITypeInfo *pTypeInfo2 =
NULL;
8181 TYPEATTR *pTypeAttr;
8182 TYPEATTR *pTypeAttr2 =
NULL;
8188 hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
8189 &IID_IProvideClassInfo2,
8191 if (SUCCEEDED(hr)) {
8192 pProvideClassInfo2 =
p;
8193 hr = pProvideClassInfo2->lpVtbl->GetGUID(pProvideClassInfo2,
8194 GUIDKIND_DEFAULT_SOURCE_DISP_IID,
8197 if (SUCCEEDED(hr)) {
8201 if (SUCCEEDED(hr)) {
8204 hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
8205 &IID_IProvideClassInfo,
8207 if (SUCCEEDED(hr)) {
8208 pProvideClassInfo =
p;
8209 hr = pProvideClassInfo->lpVtbl->GetClassInfo(pProvideClassInfo,
8214 hr = pDispatch->lpVtbl->GetTypeInfo(pDispatch, 0,
cWIN32OLE_lcid, &pTypeInfo );
8227 hr =
find_coclass(pTypeInfo, pTypeAttr, &pTypeInfo2, &pTypeAttr2);
8228 if (SUCCEEDED(hr)) {
8244 hr = (*ppTypeInfo)->lpVtbl->GetTypeAttr(*ppTypeInfo, &pTypeAttr);
8245 if (SUCCEEDED(hr)) {
8246 *piid = pTypeAttr->guid;
8247 (*ppTypeInfo)->lpVtbl->ReleaseTypeAttr(*ppTypeInfo, pTypeAttr);
8288 ITypeInfo *pTypeInfo = 0;
8290 IConnectionPointContainer *pContainer;
8291 IConnectionPoint *pConnectionPoint;
8311 hr =
find_iid(ole, pitf, &iid, &pTypeInfo);
8322 hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
8323 &IID_IConnectionPointContainer,
8328 "failed to query IConnectionPointContainer");
8332 hr = pContainer->lpVtbl->FindConnectionPoint(pContainer,
8342 hr = pConnectionPoint->lpVtbl->Advise(pConnectionPoint,
8516 if (
NIL_P(events)) {
8639 VariantClear(&(pvar->
realvar));
8640 VariantClear(&(pvar->
var));
8651 VariantInit(&(pvar->
var));
8652 VariantInit(&(pvar->
realvar));
8678 SAFEARRAYBOUND *psab =
NULL;
8679 SAFEARRAY *psa =
NULL;
8686 vt = (vt | VT_ARRAY);
8693 psab =
ALLOC_N(SAFEARRAYBOUND, dim);
8699 for (i = 0; i < dim; i++) {
8701 psab[
i].lLbound = 0;
8704 psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
8706 if (psab)
free(psab);
8710 V_VT(&(pvar->
var)) = vt;
8711 if (vt & VT_BYREF) {
8712 V_VT(&(pvar->
realvar)) = (vt & ~VT_BYREF);
8713 V_ARRAY(&(pvar->
realvar)) = psa;
8714 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
8716 V_ARRAY(&(pvar->
var)) = psa;
8718 if (psab)
free(psab);
8751 if (len < 1 || len > 3) {
8760 switch (
TYPE(val)) {
8784 vt = V_VT(&pvar->
var);
8792 SAFEARRAY *psa =
NULL;
8795 if (!(V_VT(&(pvar->
var)) & VT_ARRAY)) {
8798 psa = V_ISBYREF(&(pvar->
var)) ? *V_ARRAYREF(&(pvar->
var)) : V_ARRAY(&(pvar->
var));
8802 hr = SafeArrayLock(psa);
8815 dim = SafeArrayGetDim(psa);
8816 if (dim != ary_size) {
8823 for (i = 0; i < dim; i++) {
8833 hr = SafeArrayUnlock(psa);
8870 if (!V_ISARRAY(&(pvar->
var))) {
8872 "`[]' is not available for this variant type object");
8881 VariantInit(&variant);
8882 V_VT(&variant) = (V_VT(&(pvar->
var)) & ~VT_ARRAY) | VT_BYREF;
8883 hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
8900 if ((vt & ~VT_BYREF) == VT_VARIANT) {
8903 if ( (vt & ~VT_BYREF) != V_VT(var)) {
8904 hr = VariantChangeTypeEx(var, var,
8951 if (!V_ISARRAY(&(pvar->
var))) {
8953 "`[]' is not available for this variant type object");
8963 vt = (V_VT(&(pvar->
var)) & ~VT_ARRAY);
8965 if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) ==
NULL) ||
8966 (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) ==
NULL)) {
8969 hr = SafeArrayPutElement(psa, pid, p);
8976 return argv[argc-1];
8999 vt = V_VT(&(pvar->
var));
9001 if ((vt & ~VT_BYREF) == (VT_UI1|VT_ARRAY)) {
9002 if (vt & VT_BYREF) {
9003 psa = *V_ARRAYREF(&(pvar->
var));
9005 psa = V_ARRAY(&(pvar->
var));
9010 dim = SafeArrayGetDim(psa);
9055 vt = V_VT(&(pvar->
var));
9056 if (V_ISARRAY(&(pvar->
var)) && ((vt & ~VT_BYREF) != (VT_UI1|VT_ARRAY) ||
TYPE(val) !=
T_STRING)) {
9058 "`value=' is not available for this variant type object");
9083 com_vtbl.QueryInterface = QueryInterface;
9086 com_vtbl.GetTypeInfoCount = GetTypeInfoCount;
9087 com_vtbl.GetTypeInfo = GetTypeInfo;
9088 com_vtbl.GetIDsOfNames = GetIDsOfNames;
9187 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)