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.5"
148 typedef HRESULT (STDAPICALLTYPE FNCOCREATEINSTANCEEX)
149 (REFCLSID, IUnknown*,
DWORD, COSERVERINFO*,
DWORD, MULTI_QI*);
168 STDMETHOD(GetTypeInfoCount)(
171 STDMETHOD(GetTypeInfo)(
176 STDMETHOD(GetIDsOfNames)(
217 #if defined(RB_THREAD_SPECIFIC) && (defined(__CYGWIN__) || defined(__MINGW32__))
219 # define g_ole_initialized_init() ((void)0)
220 # define g_ole_initialized_set(val) (g_ole_initialized = (val))
223 # define g_ole_initialized (BOOL)TlsGetValue(g_ole_initialized_key)
224 # define g_ole_initialized_init() (g_ole_initialized_key = TlsAlloc())
225 # define g_ole_initialized_set(val) TlsSetValue(g_ole_initialized_key, (void*)(val))
246 #if defined(HAVE_TYPE_IMULTILANGUAGE2)
248 #elif defined(HAVE_TYPE_IMULTILANGUAGE)
251 #define pIMultiLanguage NULL
300 static HRESULT ( STDMETHODCALLTYPE QueryInterface )(IDispatch __RPC_FAR *, REFIID
riid,
void __RPC_FAR *__RPC_FAR *
ppvObject);
301 static ULONG ( STDMETHODCALLTYPE AddRef )(IDispatch __RPC_FAR * This);
302 static ULONG ( STDMETHODCALLTYPE Release )(IDispatch __RPC_FAR * This);
303 static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(IDispatch __RPC_FAR * This, UINT __RPC_FAR *
pctinfo);
304 static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(IDispatch __RPC_FAR * This, UINT
iTInfo, LCID
lcid, ITypeInfo __RPC_FAR *__RPC_FAR *
ppTInfo);
313 #ifndef pIMultiLanguage
387 static VALUE set_argv(VARIANTARG* realargs,
unsigned int beg,
unsigned int end);
564 static HRESULT find_coclass(ITypeInfo *pTypeInfo, TYPEATTR *pTypeAttr, ITypeInfo **pTypeInfo2, TYPEATTR **pTypeAttr2);
601 static HRESULT (STDMETHODCALLTYPE mf_QueryInterface)(
602 IMessageFilter __RPC_FAR * This,
606 if (
MEMCMP(riid, &IID_IUnknown, GUID, 1) == 0
607 ||
MEMCMP(riid, &IID_IMessageFilter, GUID, 1) == 0)
612 return E_NOINTERFACE;
615 static ULONG (STDMETHODCALLTYPE mf_AddRef)(
616 IMessageFilter __RPC_FAR * This)
621 static ULONG (STDMETHODCALLTYPE mf_Release)(
622 IMessageFilter __RPC_FAR * This)
627 static DWORD (STDMETHODCALLTYPE mf_HandleInComingCall)(
628 IMessageFilter __RPC_FAR * pThis,
635 #ifdef DEBUG_MESSAGEFILTER
636 printf(
"incoming %08X, %08X, %d\n", dwCallType, threadIDCaller, dwTickCount);
642 case CALLTYPE_TOPLEVEL_CALLPENDING:
643 case CALLTYPE_ASYNC_CALLPENDING:
645 return SERVERCALL_RETRYLATER;
658 return SERVERCALL_ISHANDLED;
661 static DWORD (STDMETHODCALLTYPE mf_RetryRejectedCall)(
662 IMessageFilter* pThis,
677 static DWORD (STDMETHODCALLTYPE mf_MessagePending)(
678 IMessageFilter* pThis,
685 return PENDINGMSG_WAITNOPROCESS;
693 return PENDINGMSG_WAITNOPROCESS;
703 static HRESULT ( STDMETHODCALLTYPE QueryInterface )(
704 IDispatch __RPC_FAR * This,
708 if (
MEMCMP(riid, &IID_IUnknown, GUID, 1) == 0
709 ||
MEMCMP(riid, &IID_IDispatch, GUID, 1) == 0)
716 return E_NOINTERFACE;
719 static ULONG ( STDMETHODCALLTYPE AddRef )(
720 IDispatch __RPC_FAR * This)
726 static ULONG ( STDMETHODCALLTYPE Release )(
727 IDispatch __RPC_FAR * This)
739 static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(
740 IDispatch __RPC_FAR * This,
746 static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(
747 IDispatch __RPC_FAR * This,
750 ITypeInfo __RPC_FAR *__RPC_FAR *
ppTInfo)
756 static HRESULT ( STDMETHODCALLTYPE GetIDsOfNames )(
757 IDispatch __RPC_FAR * This,
770 if ((
ID)(DISPID)nameid != nameid)
return E_NOINTERFACE;
775 static HRESULT ( STDMETHODCALLTYPE Invoke )(
776 IDispatch __RPC_FAR * This,
788 int args = pDispParams->cArgs;
791 ID mid = (
ID)dispIdMember;
792 for (i = 0; i <
args; i++) {
795 if (dispIdMember == DISPID_VALUE) {
796 if (wFlags == DISPATCH_METHOD) {
798 }
else if (wFlags & DISPATCH_PROPERTYGET) {
833 memset(&st, 0,
sizeof(SYSTEMTIME));
841 SystemTimeToVariantTime(&st, &t);
850 VariantTimeToSystemTime(date, &st);
859 if (st.wMilliseconds > 0) {
865 #define ENC_MACHING_CP(enc,encname,cp) if(strcasecmp(rb_enc_name((enc)),(encname)) == 0) return cp
938 #ifndef pIMultiLanguage
945 #if defined(HAVE_TYPE_IMULTILANGUAGE2)
946 hr = CoCreateInstance(&CLSID_CMultiLanguage,
NULL, CLSCTX_INPROC_SERVER,
947 &IID_IMultiLanguage2, &p);
948 #elif defined(HAVE_TYPE_IMULTILANGUAGE)
949 hr = CoCreateInstance(&CLSID_CMultiLanguage,
NULL, CLSCTX_INPROC_SERVER,
950 &IID_IMultiLanguage, &p);
959 #define load_conv_function51932() failed_load_conv51932()
962 #define conv_51932(cp) ((cp) == 51932 && (load_conv_function51932(), 1))
985 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.");
1035 if (!pGetCPInfoEx) {
1037 GetProcAddress(GetModuleHandle(
"kernel32"),
"GetCPInfoEx");
1038 if (!pGetCPInfoEx) {
1039 pGetCPInfoEx = (
void*)-1;
1044 if (pGetCPInfoEx == (
void*)-1 || !pGetCPInfoEx(cp, 0, buf)) {
1058 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.");
1076 #ifndef pIMultiLanguage
1083 pm = alloc(size, arg);
1095 pm = alloc(size, arg);
1109 return ALLOC_N(
char, size + 1);
1127 sprintf(strhr,
" HRESULT error code:0x%08x\n ", (
unsigned)hr);
1129 dwCount = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
1130 FORMAT_MESSAGE_FROM_SYSTEM |
1131 FORMAT_MESSAGE_IGNORE_INSERTS,
1133 MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
1134 (LPTSTR)&p_msg, 0,
NULL);
1136 dwCount = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
1137 FORMAT_MESSAGE_FROM_SYSTEM |
1138 FORMAT_MESSAGE_IGNORE_INSERTS,
1140 (LPTSTR)&p_msg, 0,
NULL);
1143 term = p_msg +
strlen(p_msg);
1144 while (p_msg < term) {
1146 if (*term ==
'\r' || *term ==
'\n')
1150 if (p_msg[0] !=
'\0') {
1161 SysFreeString(pExInfo->bstrDescription);
1162 SysFreeString(pExInfo->bstrSource);
1163 SysFreeString(pExInfo->bstrHelpFile);
1169 char error_code[40];
1170 char *pSource =
NULL;
1171 char *pDescription =
NULL;
1173 if(pExInfo->pfnDeferredFillIn !=
NULL) {
1174 (*pExInfo->pfnDeferredFillIn)(pExInfo);
1176 if (pExInfo->bstrSource !=
NULL) {
1177 pSource =
ole_wc2mb(pExInfo->bstrSource);
1179 if (pExInfo->bstrDescription !=
NULL) {
1180 pDescription =
ole_wc2mb(pExInfo->bstrDescription);
1182 if(pExInfo->wCode == 0) {
1183 sprintf(error_code,
"\n OLE error code:%lX in ", pExInfo->scode);
1186 sprintf(error_code,
"\n OLE error code:%u in ", pExInfo->wCode);
1189 if(pSource !=
NULL) {
1196 if(pDescription !=
NULL) {
1202 if(pSource)
free(pSource);
1203 if(pDescription)
free(pDescription);
1219 if(err_msg !=
Qnil) {
1251 hr = OleInitialize(
NULL);
1268 while(PeekMessage(&msg,
NULL,0,0,PM_REMOVE)) {
1269 TranslateMessage(&msg);
1270 DispatchMessage(&msg);
1336 cp == CP_THREAD_ACP ||
1347 #ifndef pIMultiLanguage
1355 pw = SysAllocStringLen(
NULL, size);
1366 pw = SysAllocStringLen(
NULL, size);
1378 #ifndef pIMultiLanguage
1386 pw = SysAllocStringLen(
NULL, size);
1396 pw = SysAllocStringLen(
NULL, size - 1);
1397 MultiByteToWideChar(
cWIN32OLE_cp, 0, pm, len, pw, size);
1405 *(
VALUE *)arg = str;
1436 switch(V_VT(pvar)) {
1438 return &V_UI1(pvar);
1444 return &V_UI2(pvar);
1450 return &V_UI4(pvar);
1458 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1463 return &V_UI8(pvar);
1467 return &
V_INT(pvar);
1476 return &V_DATE(pvar);
1479 return V_BSTR(pvar);
1482 return V_DISPATCH(pvar);
1485 return &V_ERROR(pvar);
1488 return &V_BOOL(pvar);
1491 return V_UNKNOWN(pvar);
1494 return &V_ARRAY(pvar);
1506 for (i = 0; i < dim; i++) {
1507 if (pid[i] > pub[i]) {
1527 if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) ==
NULL) ||
1528 (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) ==
NULL)) {
1531 hr = SafeArrayPutElement(psa, pid, p);
1537 if (pid[i] > pub[i]) {
1554 for (i = 0; i <
len; i++) {
1579 for (i = 0; i <
len; i++) {
1582 if (ary_len < ary_len1) {
1598 SAFEARRAYBOUND *psab =
NULL;
1599 SAFEARRAY *psa =
NULL;
1606 psab =
ALLOC_N(SAFEARRAYBOUND, dim);
1610 if(!psab || !pub || !pid) {
1612 if(psab)
free(psab);
1617 for (i = 0; i < dim; i++) {
1619 psab[
i].lLbound = 0;
1620 pub[
i] = psab[
i].cElements - 1;
1624 if ((vt & ~VT_BYREF) == VT_ARRAY) {
1625 vt = (vt | VT_VARIANT);
1627 psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
1631 hr = SafeArrayLock(psa);
1632 if (SUCCEEDED(hr)) {
1634 hr = SafeArrayUnlock(psa);
1638 if(psab)
free(psab);
1641 if (SUCCEEDED(hr)) {
1647 SafeArrayDestroy(psa);
1660 V_VT(var) = VT_DISPATCH;
1666 VariantCopy(var, &(pvar->
var));
1671 V_VT(var) = VT_DATE;
1675 switch (
TYPE(val)) {
1680 V_VT(var) = VT_BSTR;
1696 V_VT(var) = VT_BOOL;
1697 V_BOOL(var) = VARIANT_TRUE;
1700 V_VT(var) = VT_BOOL;
1701 V_BOOL(var) = VARIANT_FALSE;
1705 V_VT(var) = VT_ERROR;
1706 V_ERROR(var) = DISP_E_PARAMNOTFOUND;
1708 V_VT(var) = VT_EMPTY;
1712 V_VT(var) = VT_DISPATCH;
1722 if (vt == VT_VARIANT) {
1725 V_VT(var) = (vt & ~VT_BYREF);
1726 if (V_VT(var) == VT_DISPATCH) {
1727 V_DISPATCH(var) =
NULL;
1728 }
else if (V_VT(var) == VT_UNKNOWN) {
1729 V_UNKNOWN(var) =
NULL;
1734 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1735 switch(vt & ~VT_BYREF) {
1738 V_I8(var) =
NUM2I8 (val);
1756 switch (
TYPE(val)) {
1758 if (V_VT(var) == (VT_BSTR | VT_BYREF)) {
1764 case (VT_UI1 | VT_BYREF) :
1765 *V_UI1REF(var) =
NUM2CHR(val);
1767 case (VT_I2 | VT_BYREF) :
1768 *V_I2REF(var) = (short)
NUM2INT(val);
1770 case (VT_I4 | VT_BYREF) :
1773 case (VT_R4 | VT_BYREF) :
1774 *V_R4REF(var) = (float)
NUM2INT(val);
1776 case (VT_R8 | VT_BYREF) :
1785 case (VT_I2 | VT_BYREF) :
1786 *V_I2REF(var) = (short)
NUM2INT(val);
1788 case (VT_I4 | VT_BYREF) :
1791 case (VT_R4 | VT_BYREF) :
1792 *V_R4REF(var) = (float)
NUM2DBL(val);
1794 case (VT_R8 | VT_BYREF) :
1802 if (V_VT(var) == (VT_R8 | VT_BYREF)) {
1807 if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
1808 *V_BOOLREF(var) = VARIANT_TRUE;
1812 if (V_VT(var) == (VT_BOOL | VT_BYREF)) {
1813 *V_BOOLREF(var) = VARIANT_FALSE;
1825 if (vt == (VT_VARIANT|VT_BYREF)) {
1828 if (V_VT(realvar) != (vt & ~VT_BYREF)) {
1831 switch(vt & ~VT_BYREF) {
1833 V_I1REF(var) = &V_I1(realvar);
1836 V_UI1REF(var) = &V_UI1(realvar);
1839 V_I2REF(var) = &V_I2(realvar);
1845 V_I4REF(var) = &V_I4(realvar);
1848 V_UI4REF(var) = &V_UI4(realvar);
1851 V_R4REF(var) = &V_R4(realvar);
1854 V_R8REF(var) = &V_R8(realvar);
1857 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1860 V_I8REF(var) = &V_I8(realvar);
1865 V_UI8REF(var) = &V_UI8(realvar);
1878 V_CYREF(var) = &V_CY(realvar);
1881 V_DATEREF(var) = &V_DATE(realvar);
1884 V_BSTRREF(var) = &V_BSTR(realvar);
1887 V_DISPATCHREF(var) = &V_DISPATCH(realvar);
1890 V_ERRORREF(var) = &V_ERROR(realvar);
1893 V_BOOLREF(var) = &V_BOOL(realvar);
1896 V_UNKNOWNREF(var) = &V_UNKNOWN(realvar);
1899 V_ARRAYREF(var) = &V_ARRAY(realvar);
1913 if (((vt & ~VT_BYREF) == (VT_ARRAY | VT_UI1)) &&
TYPE(val) ==
T_STRING) {
1916 SAFEARRAY *p =
NULL;
1917 SAFEARRAY *psa = SafeArrayCreateVector(VT_UI1, 0, len);
1921 hr = SafeArrayAccessData(psa, &pdest);
1922 if (SUCCEEDED(hr)) {
1924 SafeArrayUnaccessData(psa);
1925 V_VT(&(pvar->
realvar)) = (vt & ~VT_BYREF);
1926 p = V_ARRAY(&(pvar->
realvar));
1928 SafeArrayDestroy(p);
1930 V_ARRAY(&(pvar->
realvar)) = psa;
1931 if (vt & VT_BYREF) {
1932 V_VT(&(pvar->
var)) = vt;
1933 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1935 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1939 SafeArrayDestroy(psa);
1941 }
else if (vt & VT_ARRAY) {
1943 V_VT(&(pvar->
var)) = vt;
1944 if (vt & VT_BYREF) {
1945 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1949 if (SUCCEEDED(hr)) {
1950 if (vt & VT_BYREF) {
1951 V_VT(&(pvar->
var)) = vt;
1952 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
1954 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1958 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1959 }
else if ( (vt & ~VT_BYREF) == VT_I8 || (vt & ~VT_BYREF) == VT_UI8) {
1962 V_VT(&(pvar->
var)) = vt;
1963 if (vt & VT_BYREF) {
1969 V_VT(&(pvar->
var)) = vt;
1970 if (vt == (VT_BYREF | VT_VARIANT)) {
1973 V_VT(&(pvar->
realvar)) = vt & ~VT_BYREF;
1974 if (vt & VT_BYREF) {
1980 if (vt == (VT_BYREF | VT_VARIANT)) {
1982 }
else if (vt & VT_BYREF) {
1983 if ( (vt & ~VT_BYREF) != V_VT(&(pvar->
realvar))) {
1987 if (SUCCEEDED(hr)) {
1991 if (vt == V_VT(&(pvar->
realvar))) {
1992 hr = VariantCopy(&(pvar->
var), &(pvar->
realvar));
1994 hr = VariantChangeTypeEx(&(pvar->
var), &(pvar->
realvar),
2070 long *ids =
ALLOC_N(
long, dim);
2074 for(i = 0; i < dim; i++) {
2075 ids[
i] = pid[
i] - plb[
i];
2079 for(i = 0; i < dim-1; i++) {
2093 long id = pid[dim - 1] - plb[dim - 1];
2103 while ( V_VT(pvar) == (VT_BYREF | VT_VARIANT) )
2104 pvar = V_VARIANTREF(pvar);
2106 if(V_ISARRAY(pvar)) {
2107 SAFEARRAY *psa = V_ISBYREF(pvar) ? *V_ARRAYREF(pvar) : V_ARRAY(pvar);
2109 long *pid, *plb, *pub;
2116 dim = SafeArrayGetDim(psa);
2117 VariantInit(&variant);
2118 V_VT(&variant) = (V_VT(pvar) & ~VT_ARRAY) | VT_BYREF;
2124 if(!pid || !plb || !pub) {
2131 for(i = 0; i < dim; ++
i) {
2132 SafeArrayGetLBound(psa, i+1, &plb[i]);
2133 SafeArrayGetLBound(psa, i+1, &pid[i]);
2134 SafeArrayGetUBound(psa, i+1, &pub[i]);
2136 hr = SafeArrayLock(psa);
2137 if (SUCCEEDED(hr)) {
2142 hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
2143 if (SUCCEEDED(hr)) {
2147 for (i = 0; i < dim; ++
i) {
2148 if (++pid[i] <= pub[i])
2153 SafeArrayUnlock(psa);
2160 switch(V_VT(pvar) & ~VT_BYREF){
2169 obj =
INT2NUM((
long)V_I1(pvar));
2174 obj =
INT2NUM((
long)*V_UI1REF(pvar));
2176 obj =
INT2NUM((
long)V_UI1(pvar));
2181 obj =
INT2NUM((
long)*V_I2REF(pvar));
2183 obj =
INT2NUM((
long)V_I2(pvar));
2190 obj =
INT2NUM((
long)V_UI2(pvar));
2195 obj =
INT2NUM((
long)*V_I4REF(pvar));
2197 obj =
INT2NUM((
long)V_I4(pvar));
2202 obj =
INT2NUM((
long)*V_UI4REF(pvar));
2204 obj =
INT2NUM((
long)V_UI4(pvar));
2221 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
2224 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
2236 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
2273 obj =
INT2NUM(*V_ERRORREF(pvar));
2279 if (V_ISBYREF(pvar))
2289 if (V_ISBYREF(pvar))
2290 pDispatch = *V_DISPATCHREF(pvar);
2292 pDispatch = V_DISPATCH(pvar);
2294 if (pDispatch !=
NULL ) {
2309 if (V_ISBYREF(pvar))
2310 punk = *V_UNKNOWNREF(pvar);
2312 punk = V_UNKNOWN(pvar);
2315 hr = punk->lpVtbl->QueryInterface(punk, &IID_IDispatch, &p);
2328 date = *V_DATEREF(pvar);
2330 date = V_DATE(pvar);
2340 VariantInit(&variant);
2341 hr = VariantChangeTypeEx(&variant, pvar,
2343 if (SUCCEEDED(hr) && V_VT(&variant) == VT_BSTR) {
2346 VariantClear(&variant);
2356 return RegOpenKeyEx(hkey, name, 0, KEY_READ, phkey);
2368 char buf[BUFSIZ + 1];
2371 LONG
err = RegEnumKeyEx(hkey, i, buf, &size_buf,
2373 if(err == ERROR_SUCCESS) {
2387 LONG
err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype,
NULL, &size);
2389 if (err == ERROR_SUCCESS) {
2390 pbuf =
ALLOC_N(
char, size + 1);
2391 err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype, (BYTE *)pbuf, &size);
2392 if (err == ERROR_SUCCESS) {
2394 if (dwtype == REG_EXPAND_SZ) {
2395 char* pbuf2 = (
char *)pbuf;
2397 pbuf =
ALLOC_N(
char, len + 1);
2398 ExpandEnvironmentStrings(pbuf2, pbuf, len + 1);
2414 err = RegOpenKeyEx(hkey, subkey, 0, KEY_READ, &hsubkey);
2415 if (err == ERROR_SUCCESS) {
2417 RegCloseKey(hsubkey);
2447 char path[MAX_PATH + 1];
2449 err =
reg_open_key(HKEY_CLASSES_ROOT,
"CLSID", &hroot);
2450 if (err != ERROR_SUCCESS) {
2454 if (err != ERROR_SUCCESS) {
2460 RegCloseKey(hclsid);
2461 if (typelib !=
Qnil) {
2462 ExpandEnvironmentStrings(
StringValuePtr(typelib), path,
sizeof(path));
2463 path[MAX_PATH] =
'\0';
2472 HKEY htypelib, hclsid, hversion, hlang;
2483 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
2484 if(err != ERROR_SUCCESS) {
2487 for(i = 0; !found; i++) {
2492 if (err != ERROR_SUCCESS)
2495 for(j = 0; !found; j++) {
2504 if (typelib ==
Qnil)
2507 for(k = 0; !found; k++) {
2512 if (err == ERROR_SUCCESS) {
2519 RegCloseKey(hversion);
2521 RegCloseKey(hclsid);
2523 RegCloseKey(htypelib);
2543 ITypeInfo *pTypeInfo;
2544 TYPEATTR *pTypeAttr;
2554 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
2555 for (index = 0; index <
count; index++) {
2556 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, index, &pTypeInfo);
2564 for(iVar = 0; iVar < pTypeAttr->cVars; iVar++) {
2565 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, iVar, &pVarDesc);
2568 if(pVarDesc->varkind == VAR_CONST &&
2569 !(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
2570 VARFLAG_FRESTRICTED |
2571 VARFLAG_FNONBROWSABLE))) {
2572 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
2574 if(FAILED(hr) || len == 0 || !bstr)
2578 *pName = toupper((
int)*pName);
2586 SysFreeString(bstr);
2592 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
2594 pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
2612 err = RegConnectRegistry(
StringValuePtr(host), HKEY_LOCAL_MACHINE, &hlm);
2613 if (err != ERROR_SUCCESS)
2614 return HRESULT_FROM_WIN32(err);
2618 err = RegOpenKeyEx(hlm,
StringValuePtr(subkey), 0, KEY_READ, &hpid);
2619 if (err != ERROR_SUCCESS)
2620 hr = HRESULT_FROM_WIN32(err);
2622 len =
sizeof(clsid);
2623 err = RegQueryValueEx(hpid,
"",
NULL, &dwtype, (BYTE *)clsid, &len);
2624 if (err == ERROR_SUCCESS && dwtype == REG_SZ) {
2626 hr = CLSIDFromString(pbuf, pclsid);
2627 SysFreeString(pbuf);
2630 hr = HRESULT_FROM_WIN32(err);
2645 COSERVERINFO serverinfo;
2647 DWORD clsctx = CLSCTX_REMOTE_SERVER;
2650 gole32 = LoadLibrary(
"OLE32");
2655 GetProcAddress(
gole32,
"CoCreateInstanceEx");
2660 hr = CLSIDFromProgID(pbuf, &clsid);
2664 hr = CLSIDFromString(pbuf, &clsid);
2665 SysFreeString(pbuf);
2668 "unknown OLE server: `%s'",
2670 memset(&serverinfo, 0,
sizeof(COSERVERINFO));
2672 memset(&multi_qi, 0,
sizeof(MULTI_QI));
2673 multi_qi.pIID = &IID_IDispatch;
2675 SysFreeString(serverinfo.pwszName);
2678 "failed to create DCOM server `%s' in `%s'",
2699 hr = CreateBindCtx(0, &pBindCtx);
2702 "failed to create bind context");
2706 hr = MkParseDisplayName(pBindCtx, pbuf, &eaten, &pMoniker);
2707 SysFreeString(pbuf);
2711 "failed to parse display name of moniker `%s'",
2714 hr = pMoniker->lpVtbl->BindToObject(pMoniker, pBindCtx,
NULL,
2715 &IID_IDispatch, &p);
2722 "failed to bind moniker `%s'",
2761 hr = CLSIDFromProgID(pBuf, &clsid);
2763 hr = CLSIDFromString(pBuf, &clsid);
2765 SysFreeString(pBuf);
2770 hr = GetActiveObject(&clsid, 0, &pUnknown);
2775 hr = pUnknown->lpVtbl->QueryInterface(pUnknown, &IID_IDispatch, &p);
2780 "failed to create WIN32OLE server `%s'",
2824 ITypeInfo *pTypeInfo;
2841 0, lcid, &pTypeInfo);
2845 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
2865 hr = LoadTypeLibEx(pBuf, REGKIND_NONE, &pTypeLib);
2866 SysFreeString(pBuf);
2891 ITypeInfo *pTypeInfo;
2894 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
2895 for (i = 0; i <
count; i++) {
2896 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
2901 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
2967 FNHTMLHELP *pfnHtmlHelp;
2971 ghhctrl = LoadLibrary(
"HHCTRL.OCX");
2974 pfnHtmlHelp = (FNHTMLHELP*)GetProcAddress(
ghhctrl,
"HtmlHelpA");
3041 static BOOL CALLBACK
3135 case LOCALE_SYSTEM_DEFAULT:
3136 case LOCALE_USER_DEFAULT:
3160 hr = CoCreateGuid(&guid);
3164 len = StringFromGUID2(&guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
3258 rb_scan_args(argc, argv,
"11*", &svr_name, &host, &others);
3276 hr = CLSIDFromProgID(pBuf, &clsid);
3278 hr = CLSIDFromString(pBuf, &clsid);
3280 SysFreeString(pBuf);
3283 "unknown OLE server: `%s'",
3288 hr = CoCreateInstance(&clsid,
NULL, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
3289 &IID_IDispatch, &p);
3293 "failed to create WIN32OLE object from `%s'",
3307 index = pOp->
dp.cNamedArgs;
3315 for(i = 1; i < index + 1; i++) {
3319 for(i = 0; i <
index; i++ ) {
3320 VariantClear(&(pOp->
dp.rgvarg[i]));
3333 VariantInit(&(pOp->
dp.rgvarg[index]));
3347 while (end-- > beg) {
3349 VariantClear(&realargs[end]);
3370 EXCEPINFO excepinfo;
3372 VARIANTARG* realargs =
NULL;
3373 unsigned int argErr = 0;
3379 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3381 VariantInit(&result);
3384 op.
dp.rgdispidNamedArgs =
NULL;
3385 op.
dp.cNamedArgs = 0;
3400 DispID = DISPID_VALUE;
3406 &wcmdname, 1, lcid, &DispID);
3407 SysFreeString(wcmdname);
3410 "unknown property or method: `%s'",
3418 op.
dp.cNamedArgs = 0;
3426 op.
dp.cArgs = cNamedArgs + argc - 2;
3431 pDispID =
ALLOCA_N(DISPID, cNamedArgs + 1);
3436 op.dp.cNamedArgs + 1,
3438 for(i = 0; i < op.dp.cNamedArgs + 1; i++) {
3439 SysFreeString(op.pNamedArgs[i]);
3440 op.pNamedArgs[
i] =
NULL;
3444 for(i = 0; i < op.dp.cArgs; i++ ) {
3445 VariantClear(&op.dp.rgvarg[i]);
3448 "failed to get named argument info: `%s'",
3451 op.dp.rgdispidNamedArgs = &(pDispID[1]);
3455 op.
dp.cArgs = argc - 1;
3457 if (op.
dp.cArgs > 0) {
3464 if(op.
dp.cArgs > cNamedArgs) {
3465 realargs =
ALLOCA_N(VARIANTARG, op.
dp.cArgs-cNamedArgs+1);
3466 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3467 n = op.
dp.cArgs - i + cNamedArgs - 1;
3468 VariantInit(&realargs[n]);
3469 VariantInit(&op.
dp.rgvarg[n]);
3473 VariantCopy(&op.
dp.rgvarg[n], &(pvar->
var));
3476 V_VT(&op.
dp.rgvarg[n]) = VT_VARIANT | VT_BYREF;
3477 V_VARIANTREF(&op.
dp.rgvarg[n]) = &realargs[
n];
3482 if (wFlags & DISPATCH_PROPERTYPUT) {
3483 if (op.
dp.cArgs == 0)
3486 op.
dp.cNamedArgs = 1;
3487 op.
dp.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
3488 op.
dp.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
3492 &IID_NULL, lcid, wFlags, &op.
dp,
3493 &result, &excepinfo, &argErr);
3497 if(op.
dp.cArgs >= cNamedArgs) {
3498 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3499 n = op.
dp.cArgs - i + cNamedArgs - 1;
3503 if (hr == DISP_E_EXCEPTION) {
3506 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3507 VariantInit(&result);
3509 &IID_NULL, lcid, wFlags,
3511 &excepinfo, &argErr);
3517 if ((hr == DISP_E_EXCEPTION || hr == DISP_E_MEMBERNOTFOUND) && DispID > 0x8000) {
3518 if (hr == DISP_E_EXCEPTION) {
3521 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3523 &IID_NULL, lcid, wFlags,
3525 &excepinfo, &argErr);
3528 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3529 n = op.
dp.cArgs - i + cNamedArgs - 1;
3530 VariantClear(&op.
dp.rgvarg[n]);
3536 if (op.
dp.cArgs > cNamedArgs) {
3537 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3538 n = op.
dp.cArgs - i + cNamedArgs - 1;
3542 if (hr == DISP_E_EXCEPTION) {
3545 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3546 VariantInit(&result);
3548 &IID_NULL, lcid, wFlags,
3550 &excepinfo, &argErr);
3551 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3552 n = op.
dp.cArgs - i + cNamedArgs - 1;
3553 VariantClear(&op.
dp.rgvarg[n]);
3560 if(op.
dp.cArgs > cNamedArgs) {
3561 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
3562 n = op.
dp.cArgs - i + cNamedArgs - 1;
3571 for(i = 0; i < op.
dp.cArgs; i++) {
3572 VariantClear(&op.
dp.rgvarg[i]);
3583 VariantClear(&result);
3603 return ole_invoke(argc, argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
3611 unsigned int argErr = 0;
3612 EXCEPINFO excepinfo;
3614 DISPPARAMS dispParams;
3615 VARIANTARG* realargs =
NULL;
3625 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
3626 memset(&dispParams, 0,
sizeof(DISPPARAMS));
3627 VariantInit(&result);
3631 dispParams.rgvarg =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
3632 realargs =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
3633 for (i = 0, j = dispParams.cArgs - 1; i < (
int)dispParams.cArgs; i++, j--)
3635 VariantInit(&realargs[i]);
3636 VariantInit(&dispParams.rgvarg[i]);
3639 V_VT(&dispParams.rgvarg[i]) = vt;
3644 V_VT(&dispParams.rgvarg[i]) = V_VT(&realargs[i]) = VT_ERROR;
3645 V_ERROR(&dispParams.rgvarg[i]) = V_ERROR(&realargs[i]) = DISP_E_PARAMNOTFOUND;
3658 SAFEARRAYBOUND rgsabound[1];
3660 rgsabound[0].lLbound = 0;
3662 v = vt & ~(VT_ARRAY | VT_BYREF);
3663 V_ARRAY(&realargs[i]) = SafeArrayCreate(v, 1, rgsabound);
3664 V_VT(&realargs[i]) = VT_ARRAY |
v;
3665 SafeArrayLock(V_ARRAY(&realargs[i]));
3666 pb = V_ARRAY(&realargs[i])->pvData;
3667 ps = V_ARRAY(&realargs[i])->pvData;
3668 pl = V_ARRAY(&realargs[i])->pvData;
3669 py = V_ARRAY(&realargs[i])->pvData;
3670 pv = V_ARRAY(&realargs[i])->pvData;
3671 for (ent = 0; ent < (
int)rgsabound[0].cElements; ent++)
3676 if (v != VT_VARIANT)
3678 VariantChangeTypeEx(&velem, &velem,
3691 *py++ = V_CY(&velem);
3697 *ps++ = V_I2(&velem);
3702 *pb++ = V_UI1(&velem);
3706 *pl++ = V_I4(&velem);
3710 SafeArrayUnlock(V_ARRAY(&realargs[i]));
3715 if ((vt & (~VT_BYREF)) != VT_VARIANT)
3717 hr = VariantChangeTypeEx(&realargs[i], &realargs[i],
3719 (VARTYPE)(vt & (~VT_BYREF)));
3726 if ((vt & VT_BYREF) || vt == VT_VARIANT)
3728 if (vt == VT_VARIANT)
3729 V_VT(&dispParams.rgvarg[i]) = VT_VARIANT | VT_BYREF;
3730 switch (vt & (~VT_BYREF))
3734 V_VARIANTREF(&dispParams.rgvarg[i]) = &realargs[
i];
3740 V_CYREF(&dispParams.rgvarg[i]) = &V_CY(&realargs[i]);
3746 V_I2REF(&dispParams.rgvarg[i]) = &V_I2(&realargs[i]);
3751 V_UI1REF(&dispParams.rgvarg[i]) = &V_UI1(&realargs[i]);
3755 V_I4REF(&dispParams.rgvarg[i]) = &V_I4(&realargs[i]);
3762 V_CY(&dispParams.rgvarg[i]) = V_CY(&realargs[i]);
3767 if (dispkind & DISPATCH_PROPERTYPUT) {
3768 dispParams.cNamedArgs = 1;
3769 dispParams.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
3770 dispParams.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
3776 &dispParams, &result,
3777 &excepinfo, &argErr);
3787 if(dispParams.cArgs > 0) {
3788 set_argv(realargs, 0, dispParams.cArgs);
3792 VariantClear(&result);
3811 return ole_invoke2(
self, dispid, args, types, DISPATCH_METHOD);
3829 return ole_invoke2(
self, dispid, args, types, DISPATCH_PROPERTYGET);
3847 return ole_invoke2(
self, dispid, args, types, DISPATCH_PROPERTYPUT);
3922 EXCEPINFO excepinfo;
3923 DISPID dispID = DISPID_VALUE;
3924 DISPID dispIDParam = DISPID_PROPERTYPUT;
3925 USHORT wFlags = DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF;
3926 DISPPARAMS dispParams;
3927 VARIANTARG propertyValue[2];
3931 dispParams.rgdispidNamedArgs = &dispIDParam;
3932 dispParams.rgvarg = propertyValue;
3933 dispParams.cNamedArgs = 1;
3934 dispParams.cArgs = 1;
3936 VariantInit(&propertyValue[0]);
3937 VariantInit(&propertyValue[1]);
3938 memset(&excepinfo, 0,
sizeof(excepinfo));
3945 pBuf, 1, lcid, &dispID);
3946 SysFreeString(pBuf[0]);
3951 "unknown property or method: `%s'",
3957 lcid, wFlags, &dispParams,
3958 NULL, &excepinfo, &argErr);
3960 for(index = 0; index < dispParams.cArgs; ++
index) {
3961 VariantClear(&propertyValue[index]);
3996 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
3997 VariantInit(&variant);
3998 while(pEnum->lpVtbl->Next(pEnum, 1, &variant,
NULL) == S_OK) {
4000 VariantClear(&variant);
4001 VariantInit(&variant);
4010 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
4036 unsigned int argErr;
4037 EXCEPINFO excepinfo;
4038 DISPPARAMS dispParams;
4041 IEnumVARIANT *pEnum =
NULL;
4046 VariantInit(&result);
4047 dispParams.rgvarg =
NULL;
4048 dispParams.rgdispidNamedArgs =
NULL;
4049 dispParams.cNamedArgs = 0;
4050 dispParams.cArgs = 0;
4051 memset(&excepinfo, 0,
sizeof(excepinfo));
4056 DISPATCH_METHOD | DISPATCH_PROPERTYGET,
4057 &dispParams, &result,
4058 &excepinfo, &argErr);
4061 VariantClear(&result);
4065 if (V_VT(&result) == VT_UNKNOWN) {
4066 hr = V_UNKNOWN(&result)->lpVtbl->QueryInterface(V_UNKNOWN(&result),
4070 }
else if (V_VT(&result) == VT_DISPATCH) {
4071 hr = V_DISPATCH(&result)->lpVtbl->QueryInterface(V_DISPATCH(&result),
4076 if (FAILED(hr) || !pEnum) {
4077 VariantClear(&result);
4081 VariantClear(&result);
4105 #if SIZEOF_SIZE_T > SIZEOF_LONG
4110 if(mname[n-1] ==
'=') {
4118 return ole_invoke(argc, argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
4126 TYPEATTR *pTypeAttr;
4128 FUNCDESC *pFuncDesc;
4136 for(i = 0; i < pTypeAttr->cFuncs && method ==
Qnil; i++) {
4137 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
4141 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
4144 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4152 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4163 TYPEATTR *pTypeAttr;
4166 ITypeInfo *pRefTypeInfo;
4173 if (method !=
Qnil) {
4176 for(i=0; i < pTypeAttr->cImplTypes && method ==
Qnil; i++){
4177 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
4180 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
4194 TYPEATTR *pTypeAttr;
4196 FUNCDESC *pFuncDesc;
4203 for(i = 0; i < pTypeAttr->cFuncs; i++) {
4204 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, i, &pFuncDesc);
4208 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
4211 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4214 if(pFuncDesc->invkind & mask) {
4220 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
4232 TYPEATTR *pTypeAttr;
4235 ITypeInfo *pRefTypeInfo;
4243 for(i=0; i < pTypeAttr->cImplTypes; i++){
4244 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
4247 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
4260 ITypeInfo *pTypeInfo;
4268 0, lcid, &pTypeInfo);
4272 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo,
4277 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
4282 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
4283 for (i = 0; i <
count; i++) {
4284 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4287 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
4288 if (SUCCEEDED(hr)) {
4301 ITypeInfo *pTypeInfo;
4331 return ole_methods(
self, INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF);
4363 return ole_methods(
self, INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF);
4392 hr = pTypeInfo->lpVtbl->GetContainingTypeLib( pTypeInfo, &pTypeLib, &index );
4396 hr = pTypeLib->lpVtbl->GetDocumentation( pTypeLib, index,
4419 ITypeInfo *pTypeInfo;
4447 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
4472 ITypeInfo *pTypeInfo;
4478 0, lcid, &pTypeInfo);
4484 if (vtlib ==
Qnil) {
4511 hr = CLSIDFromString(pBuf, &iid);
4512 SysFreeString(pBuf);
4515 "invalid iid: `%s'",
4528 "failed to get interface `%s'",
4562 SysFreeString(wcmdname);
4573 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
4578 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4580 helpcontext, helpfile);
4594 ITypeInfo *pRefTypeInfo;
4597 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
4609 if(typedetails !=
Qnil)
4617 TYPEDESC *p = pTypeDesc;
4620 if (p->vt == VT_PTR || p->vt == VT_SAFEARRAY) {
4632 switch(pTypeDesc->vt) {
4675 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
4697 if(typedetails !=
Qnil)
4702 if(typedetails !=
Qnil)
4708 case VT_USERDEFINED:
4710 if (typedetails !=
Qnil)
4737 if (typedetails !=
Qnil)
4756 ITypeInfo *pTypeInfo;
4799 IPersistMemory *pPersistMemory;
4806 hr = pole->
pDispatch->lpVtbl->QueryInterface(pole->
pDispatch, &IID_IPersistMemory, &p);
4808 if (SUCCEEDED(hr)) {
4809 hr = pPersistMemory->lpVtbl->InitNew(pPersistMemory);
4811 if (SUCCEEDED(hr)) {
4860 return rb_eval_string(
"WIN32OLE_TYPELIB.typelibs.collect{|t|t.name}");
4872 HKEY hclsids, hclsid;
4879 err =
reg_open_key(HKEY_CLASSES_ROOT,
"CLSID", &hclsids);
4880 if(err != ERROR_SUCCESS) {
4888 if (err != ERROR_SUCCESS)
4894 RegCloseKey(hclsid);
4896 RegCloseKey(hclsids);
4935 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
4936 for (i = 0; i < count && found ==
Qfalse; i++) {
4937 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
4940 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
4981 hr = pTypeLib->lpVtbl->GetLibAttr(pTypeLib, ppTLibAttr);
4984 "failed to get library attribute(TLIBATTR) from ITypeLib");
5001 HKEY htypelib, hguid;
5012 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
5013 if(err != ERROR_SUCCESS) {
5021 if (err != ERROR_SUCCESS)
5025 if (version ==
Qnil)
5029 if (SUCCEEDED(hr)) {
5038 RegCloseKey(htypelib);
5047 if (major ==
Qnil) {
5051 if (minor !=
Qnil) {
5062 HKEY htypelib, hguid, hversion;
5078 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
5079 if(err != ERROR_SUCCESS) {
5083 if (err != ERROR_SUCCESS) {
5084 RegCloseKey(htypelib);
5087 if (version_str !=
Qnil) {
5089 if (err == ERROR_SUCCESS) {
5093 version = version_str;
5096 RegCloseKey(hversion);
5104 if (err != ERROR_SUCCESS)
5108 RegCloseKey(hversion);
5116 RegCloseKey(hversion);
5120 RegCloseKey(htypelib);
5121 if (typelib !=
Qnil) {
5123 if (SUCCEEDED(hr)) {
5134 HKEY htypelib, hguid, hversion;
5144 err =
reg_open_key(HKEY_CLASSES_ROOT,
"TypeLib", &htypelib);
5145 if(err != ERROR_SUCCESS) {
5148 for(i = 0; !found; i++) {
5153 if (err != ERROR_SUCCESS)
5155 for(j = 0; found ==
Qfalse; j++) {
5160 if (err != ERROR_SUCCESS)
5164 RegCloseKey(hversion);
5169 if (SUCCEEDED(hr)) {
5174 RegCloseKey(hversion);
5178 RegCloseKey(htypelib);
5230 if (len < 1 || len > 3) {
5244 hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
5245 SysFreeString(pbuf);
5246 if (SUCCEEDED(hr)) {
5275 TLIBATTR *pTLibAttr;
5279 len = StringFromGUID2(&pTLibAttr->guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
5283 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5304 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
5326 TLIBATTR *pTLibAttr;
5333 major =
INT2NUM(pTLibAttr->wMajorVerNum);
5334 minor =
INT2NUM(pTLibAttr->wMinorVerNum);
5335 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5351 TLIBATTR *pTLibAttr;
5357 major =
INT2NUM(pTLibAttr->wMajorVerNum);
5358 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5374 TLIBATTR *pTLibAttr;
5379 minor =
INT2NUM(pTLibAttr->wMinorVerNum);
5380 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5400 if (err != ERROR_SUCCESS) {
5403 for(k = 0; path ==
Qnil; k++) {
5408 if (err == ERROR_SUCCESS) {
5425 return E_UNEXPECTED;
5428 hr = LoadTypeLibEx(pBuf, REGKIND_NONE, ppTypeLib);
5429 SysFreeString(pBuf);
5445 TLIBATTR *pTLibAttr;
5454 hr = QueryPathOfRegTypeLib(&pTLibAttr->guid,
5455 pTLibAttr->wMajorVerNum,
5456 pTLibAttr->wMinorVerNum,
5460 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5464 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5487 TLIBATTR *pTLibAttr;
5492 if ((pTLibAttr->wLibFlags == 0) ||
5493 (pTLibAttr->wLibFlags & LIBFLAG_FRESTRICTED) ||
5494 (pTLibAttr->wLibFlags & LIBFLAG_FHIDDEN)) {
5497 pTypeLib->lpVtbl->ReleaseTLibAttr(pTypeLib, pTLibAttr);
5520 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, -1,
5596 hr = LoadTypeLibEx(pbuf, REGKIND_NONE, &pTypeLib);
5599 SysFreeString(pbuf);
5627 TYPEATTR *pTypeAttr;
5633 switch(pTypeAttr->typekind) {
5643 case TKIND_INTERFACE:
5646 case TKIND_DISPATCH:
5689 TYPEATTR *pTypeAttr;
5696 len = StringFromGUID2(&pTypeAttr->guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
5724 TYPEATTR *pTypeAttr;
5730 hr = ProgIDFromCLSID(&pTypeAttr->guid, &pbuf);
5731 if (SUCCEEDED(hr)) {
5733 CoTaskMemFree(pbuf);
5760 TYPEATTR *pTypeAttr;
5765 if (pTypeAttr->wTypeFlags & (TYPEFLAG_FHIDDEN | TYPEFLAG_FRESTRICTED)) {
5794 TYPEATTR *pTypeAttr;
5799 ver =
INT2FIX(pTypeAttr->wMajorVerNum);
5824 TYPEATTR *pTypeAttr;
5829 ver =
INT2FIX(pTypeAttr->wMinorVerNum);
5854 TYPEATTR *pTypeAttr;
5859 typekind =
INT2FIX(pTypeAttr->typekind);
5913 TYPEATTR *pTypeAttr;
5918 if(pTypeAttr->typekind != TKIND_ALIAS) {
5979 &helpcontext,
NULL);
6022 ITypeInfo *pRefTypeInfo;
6026 TYPEATTR *pTypeAttr;
6034 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
6035 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
6039 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo, i, &href);
6042 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo, href, &pRefTypeInfo);
6046 if ((flags & implflags) == implflags) {
6148 TYPEATTR *pTypeAttr;
6161 for(i = 0; i < pTypeAttr->cVars; i++) {
6162 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, i, &pVarDesc);
6166 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
6168 if(FAILED(hr) || len == 0 || !bstr)
6179 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6272 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6276 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6314 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6318 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6348 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6351 if(pVarDesc->varkind == VAR_CONST)
6353 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6392 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6395 if (!(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
6396 VARFLAG_FRESTRICTED |
6397 VARFLAG_FNONBROWSABLE))) {
6400 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6438 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6441 switch(pVarDesc->varkind) {
6442 case VAR_PERINSTANCE:
6457 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6494 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, var_index, &pVarDesc);
6497 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
6498 kind =
INT2FIX(pVarDesc->varkind);
6558 if(pOwnerTypeInfo)
OLE_ADDREF(pOwnerTypeInfo);
6631 FUNCDESC *pFuncDesc;
6635 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6640 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6665 FUNCDESC *pFuncDesc;
6669 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6673 vvt =
INT2FIX(pFuncDesc->elemdescFunc.tdesc.vt);
6674 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6699 FUNCDESC *pFuncDesc;
6703 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6708 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6733 FUNCDESC *pFuncDesc;
6736 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6739 invkind =
INT2FIX(pFuncDesc->invkind);
6740 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6749 if((
FIX2INT(invkind) & INVOKE_PROPERTYGET) &&
6750 (
FIX2INT(invkind) & INVOKE_PROPERTYPUT) ) {
6752 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYGET) {
6754 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYPUT) {
6756 }
else if(
FIX2INT(invkind) & INVOKE_PROPERTYPUTREF) {
6758 }
else if(
FIX2INT(invkind) & INVOKE_FUNC) {
6804 FUNCDESC *pFuncDesc;
6807 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6810 if (pFuncDesc->wFuncFlags & (FUNCFLAG_FRESTRICTED |
6812 FUNCFLAG_FNONBROWSABLE)) {
6817 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
6841 TYPEATTR *pTypeAttr;
6846 ITypeInfo *pRefTypeInfo;
6847 FUNCDESC *pFuncDesc;
6855 if(pTypeAttr->typekind != TKIND_COCLASS) {
6856 pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
6859 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
6860 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
6864 if (flags & IMPLTYPEFLAG_FSOURCE) {
6865 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
6869 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
6870 href, &pRefTypeInfo);
6873 hr = pRefTypeInfo->lpVtbl->GetFuncDesc(pRefTypeInfo, method_index,
6880 hr = pRefTypeInfo->lpVtbl->GetDocumentation(pRefTypeInfo,
6884 pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
6890 pRefTypeInfo->lpVtbl->ReleaseFuncDesc(pRefTypeInfo, pFuncDesc);
6958 FUNCDESC *pFuncDesc;
6960 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
6963 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo, pFuncDesc->memid,
6965 helpcontext, helpfile);
6966 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7036 DWORD helpcontext = 0;
7038 &helpcontext,
NULL);
7064 FUNCDESC *pFuncDesc;
7067 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7070 dispid =
INT2NUM(pFuncDesc->memid);
7071 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7095 FUNCDESC *pFuncDesc;
7098 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7101 offset_vtbl =
INT2FIX(pFuncDesc->oVft);
7102 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7126 FUNCDESC *pFuncDesc;
7129 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7132 size_params =
INT2FIX(pFuncDesc->cParams);
7133 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7158 FUNCDESC *pFuncDesc;
7161 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7163 return size_opt_params;
7164 size_opt_params =
INT2FIX(pFuncDesc->cParamsOpt);
7165 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7166 return size_opt_params;
7189 FUNCDESC *pFuncDesc;
7196 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7201 bstrs =
ALLOCA_N(BSTR, pFuncDesc->cParams + 1);
7202 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pFuncDesc->memid,
7203 bstrs, pFuncDesc->cParams + 1,
7206 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7209 SysFreeString(bstrs[0]);
7210 if (pFuncDesc->cParams > 0) {
7211 for(i = 1; i <
len; i++) {
7217 pparam->
index = i - 1;
7222 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7282 FUNCDESC *pFuncDesc;
7287 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7292 bstrs =
ALLOCA_N(BSTR, pFuncDesc->cParams + 1);
7293 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pFuncDesc->memid,
7294 bstrs, pFuncDesc->cParams + 1,
7297 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7300 SysFreeString(bstrs[0]);
7301 if (param_index < 1 || len <= (UINT)param_index)
7303 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7311 pparam->
index = param_index - 1;
7314 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7354 FUNCDESC *pFuncDesc;
7357 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7361 &(pFuncDesc->lprgelemdescParam[index].tdesc),
Qnil);
7362 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7388 FUNCDESC *pFuncDesc;
7391 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7395 &(pFuncDesc->lprgelemdescParam[index].tdesc), typedetail);
7396 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7422 FUNCDESC *pFuncDesc;
7425 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7428 if (
V_UNION1((&(pFuncDesc->lprgelemdescParam[index])), paramdesc).wParamFlags &mask)
7430 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7449 pparam->
index, PARAMFLAG_FIN);
7476 pparam->
index, PARAMFLAG_FOUT);
7494 pparam->
index, PARAMFLAG_FOPT);
7513 pparam->
index, PARAMFLAG_FRETVAL);
7519 FUNCDESC *pFuncDesc;
7520 ELEMDESC *pElemDesc;
7521 PARAMDESCEX * pParamDescEx;
7524 USHORT mask = PARAMFLAG_FOPT|PARAMFLAG_FHASDEFAULT;
7526 hr = pTypeInfo->lpVtbl->GetFuncDesc(pTypeInfo, method_index, &pFuncDesc);
7529 pElemDesc = &pFuncDesc->lprgelemdescParam[
index];
7530 wParamFlags =
V_UNION1(pElemDesc, paramdesc).wParamFlags;
7531 if ((wParamFlags & mask) == mask) {
7532 pParamDescEx =
V_UNION1(pElemDesc, paramdesc).pparamdescex;
7535 pTypeInfo->lpVtbl->ReleaseFuncDesc(pTypeInfo, pFuncDesc);
7589 if (defval !=
Qnil) {
7613 if (IsEqualIID(iid, &IID_IUnknown) ||
7614 IsEqualIID(iid, &IID_IDispatch) ||
7615 IsEqualIID(iid, &((PIEVENTSINKOBJ)pEV)->m_iid)) {
7620 return E_NOINTERFACE;
7622 ((LPUNKNOWN)*ppv)->lpVtbl->AddRef((LPUNKNOWN)*ppv);
7660 return DISP_E_BADINDEX;
7664 PEVENTSINK pEventSink,
7675 return pTypeInfo->lpVtbl->GetIDsOfNames(pTypeInfo, szNames, cNames, pDispID);
7677 return DISP_E_UNKNOWNNAME;
7688 for(i = 0; i <
len; i++) {
7712 *is_default =
FALSE;
7715 for(i = 0; i <
len; i++) {
7718 if(
NIL_P(event_name)) {
7723 *is_default =
FALSE;
7734 *is_default_handler =
FALSE;
7741 *is_default_handler =
TRUE;
7767 bstrs =
ALLOCA_N(BSTR, pdispparams->cArgs + 1);
7768 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, dispid,
7769 bstrs, pdispparams->cArgs + 1,
7774 for (i = 0; i < len - 1; i++) {
7781 pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
7802 for(i = 0; i <
RARRAY_LEN(ary) && (
unsigned int) i < pdispparams->cArgs; i++) {
7804 pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
7813 VALUE handler = parg[0];
7814 VALUE mid = parg[1];
7815 VALUE args = parg[2];
7816 return rb_apply(handler, mid, args);
7838 PEVENTSINK pEventSink,
7843 DISPPARAMS *pdispparams,
7844 VARIANT *pvarResult,
7845 EXCEPINFO *pexcepinfo,
7860 BOOL is_default_handler =
FALSE;
7874 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, dispid,
7887 if (handler ==
Qnil) {
7892 if (handler ==
Qnil || mid ==
Qnil) {
7897 if (is_default_handler) {
7902 for (i = 0; i < pdispparams->cArgs; ++
i) {
7903 pvar = &pdispparams->rgvarg[pdispparams->cArgs-i-1];
7907 if (is_outarg ==
Qtrue) {
7934 VariantInit(pvarResult);
7944 if (!g_IsEventSinkVtblInitialized) {
7947 vtEventSink.Release = EVENTSINK_Release;
7953 g_IsEventSinkVtblInitialized =
TRUE;
7965 PIEVENTSINKOBJ pEVObj
7967 if(pEVObj !=
NULL) {
7978 IDispatch *pDispatch;
7981 TYPEATTR *pTypeAttr;
7983 ITypeInfo *pImplTypeInfo;
7984 TYPEATTR *pImplTypeAttr;
7993 BOOL is_found =
FALSE;
8000 hr = pDispatch->lpVtbl->GetTypeInfo(pDispatch, 0, lcid, &pTypeInfo);
8004 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo,
8012 hr = pTypeLib->lpVtbl->GetTypeInfoOfGuid(pTypeLib,
8018 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
8019 for (index = 0; index <
count; index++) {
8020 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib,
8031 if(pTypeAttr->typekind == TKIND_COCLASS) {
8032 for (type = 0; type < pTypeAttr->cImplTypes; type++) {
8033 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
8038 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
8044 hr = pImplTypeInfo->lpVtbl->GetDocumentation(pImplTypeInfo,
8053 if (strcmp(pitf, pstr) == 0) {
8054 hr = pImplTypeInfo->lpVtbl->GetTypeAttr(pImplTypeInfo,
8056 if (SUCCEEDED(hr)) {
8058 *piid = pImplTypeAttr->guid;
8060 *ppTypeInfo = pImplTypeInfo;
8061 (*ppTypeInfo)->lpVtbl->AddRef((*ppTypeInfo));
8063 pImplTypeInfo->lpVtbl->ReleaseTypeAttr(pImplTypeInfo,
8069 if (is_found || FAILED(hr))
8076 if (is_found || FAILED(hr))
8081 return E_NOINTERFACE;
8087 ITypeInfo *pTypeInfo,
8088 TYPEATTR *pTypeAttr,
8089 ITypeInfo **pCOTypeInfo,
8090 TYPEATTR **pCOTypeAttr)
8096 ITypeInfo *pTypeInfo2;
8097 TYPEATTR *pTypeAttr2;
8101 ITypeInfo *pRefTypeInfo;
8102 TYPEATTR *pRefTypeAttr;
8104 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib,
NULL);
8108 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
8109 for (i = 0; i < count && !found; i++) {
8110 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo2);
8118 if (pTypeAttr2->typekind != TKIND_COCLASS) {
8123 for (j = 0; j < pTypeAttr2->cImplTypes && !found; j++) {
8124 hr = pTypeInfo2->lpVtbl->GetImplTypeFlags(pTypeInfo2, j, &flags);
8127 if (!(flags & IMPLTYPEFLAG_FDEFAULT))
8129 hr = pTypeInfo2->lpVtbl->GetRefTypeOfImplType(pTypeInfo2, j, &href);
8132 hr = pTypeInfo2->lpVtbl->GetRefTypeInfo(pTypeInfo2, href, &pRefTypeInfo);
8140 if (IsEqualGUID(&(pTypeAttr->guid), &(pRefTypeAttr->guid))) {
8151 *pCOTypeInfo = pTypeInfo2;
8152 *pCOTypeAttr = pTypeAttr2;
8162 ITypeInfo *pTypeInfo,
8163 TYPEATTR *pTypeAttr,
8164 ITypeInfo **ppTypeInfo)
8171 for (i = 0; i < pTypeAttr->cImplTypes; i++) {
8172 hr = pTypeInfo->lpVtbl->GetImplTypeFlags(pTypeInfo, i, &flags);
8180 if ((flags & IMPLTYPEFLAG_FDEFAULT) &&
8181 (flags & IMPLTYPEFLAG_FSOURCE)) {
8183 hr = pTypeInfo->lpVtbl->GetRefTypeOfImplType(pTypeInfo,
8187 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
8188 hRefType, ppTypeInfo);
8200 IProvideClassInfo2 *pProvideClassInfo2;
8201 IProvideClassInfo *pProvideClassInfo;
8205 ITypeInfo *pTypeInfo;
8206 ITypeInfo *pTypeInfo2 =
NULL;
8207 TYPEATTR *pTypeAttr;
8208 TYPEATTR *pTypeAttr2 =
NULL;
8214 hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
8215 &IID_IProvideClassInfo2,
8217 if (SUCCEEDED(hr)) {
8218 pProvideClassInfo2 =
p;
8219 hr = pProvideClassInfo2->lpVtbl->GetGUID(pProvideClassInfo2,
8220 GUIDKIND_DEFAULT_SOURCE_DISP_IID,
8223 if (SUCCEEDED(hr)) {
8227 if (SUCCEEDED(hr)) {
8230 hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
8231 &IID_IProvideClassInfo,
8233 if (SUCCEEDED(hr)) {
8234 pProvideClassInfo =
p;
8235 hr = pProvideClassInfo->lpVtbl->GetClassInfo(pProvideClassInfo,
8240 hr = pDispatch->lpVtbl->GetTypeInfo(pDispatch, 0,
cWIN32OLE_lcid, &pTypeInfo );
8253 hr =
find_coclass(pTypeInfo, pTypeAttr, &pTypeInfo2, &pTypeAttr2);
8254 if (SUCCEEDED(hr)) {
8270 hr = (*ppTypeInfo)->lpVtbl->GetTypeAttr(*ppTypeInfo, &pTypeAttr);
8271 if (SUCCEEDED(hr)) {
8272 *piid = pTypeAttr->guid;
8273 (*ppTypeInfo)->lpVtbl->ReleaseTypeAttr(*ppTypeInfo, pTypeAttr);
8314 ITypeInfo *pTypeInfo = 0;
8316 IConnectionPointContainer *pContainer;
8317 IConnectionPoint *pConnectionPoint;
8336 hr =
find_iid(ole, pitf, &iid, &pTypeInfo);
8347 hr = pDispatch->lpVtbl->QueryInterface(pDispatch,
8348 &IID_IConnectionPointContainer,
8353 "failed to query IConnectionPointContainer");
8357 hr = pContainer->lpVtbl->FindConnectionPoint(pContainer,
8367 hr = pConnectionPoint->lpVtbl->Advise(pConnectionPoint,
8540 if (
NIL_P(events)) {
8663 VariantClear(&(pvar->
realvar));
8664 VariantClear(&(pvar->
var));
8675 VariantInit(&(pvar->
var));
8676 VariantInit(&(pvar->
realvar));
8702 SAFEARRAYBOUND *psab =
NULL;
8703 SAFEARRAY *psa =
NULL;
8710 vt = (vt | VT_ARRAY);
8717 psab =
ALLOC_N(SAFEARRAYBOUND, dim);
8723 for (i = 0; i < dim; i++) {
8725 psab[
i].lLbound = 0;
8728 psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
8730 if (psab)
free(psab);
8734 V_VT(&(pvar->
var)) = vt;
8735 if (vt & VT_BYREF) {
8736 V_VT(&(pvar->
realvar)) = (vt & ~VT_BYREF);
8737 V_ARRAY(&(pvar->
realvar)) = psa;
8738 V_ARRAYREF(&(pvar->
var)) = &(V_ARRAY(&(pvar->
realvar)));
8740 V_ARRAY(&(pvar->
var)) = psa;
8742 if (psab)
free(psab);
8755 switch (
TYPE(val)) {
8758 for(i = 0; i <
len; i++) {
8807 if (len < 1 || len > 3) {
8823 vt = V_VT(&pvar->
var);
8831 SAFEARRAY *psa =
NULL;
8834 if (!(V_VT(&(pvar->
var)) & VT_ARRAY)) {
8837 psa = V_ISBYREF(&(pvar->
var)) ? *V_ARRAYREF(&(pvar->
var)) : V_ARRAY(&(pvar->
var));
8841 hr = SafeArrayLock(psa);
8854 dim = SafeArrayGetDim(psa);
8855 if (dim != ary_size) {
8862 for (i = 0; i < dim; i++) {
8872 hr = SafeArrayUnlock(psa);
8909 if (!V_ISARRAY(&(pvar->
var))) {
8911 "`[]' is not available for this variant type object");
8920 VariantInit(&variant);
8921 V_VT(&variant) = (V_VT(&(pvar->
var)) & ~VT_ARRAY) | VT_BYREF;
8922 hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
8939 if ((vt & ~VT_BYREF) == VT_VARIANT) {
8942 if ( (vt & ~VT_BYREF) != V_VT(var)) {
8943 hr = VariantChangeTypeEx(var, var,
8990 if (!V_ISARRAY(&(pvar->
var))) {
8992 "`[]' is not available for this variant type object");
9002 vt = (V_VT(&(pvar->
var)) & ~VT_ARRAY);
9004 if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) ==
NULL) ||
9005 (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) ==
NULL)) {
9008 hr = SafeArrayPutElement(psa, pid, p);
9015 return argv[argc-1];
9038 vt = V_VT(&(pvar->
var));
9040 if ((vt & ~VT_BYREF) == (VT_UI1|VT_ARRAY)) {
9041 if (vt & VT_BYREF) {
9042 psa = *V_ARRAYREF(&(pvar->
var));
9044 psa = V_ARRAY(&(pvar->
var));
9049 dim = SafeArrayGetDim(psa);
9094 vt = V_VT(&(pvar->
var));
9095 if (V_ISARRAY(&(pvar->
var)) && ((vt & ~VT_BYREF) != (VT_UI1|VT_ARRAY) ||
TYPE(val) !=
T_STRING)) {
9097 "`value=' is not available for this variant type object");
9123 com_vtbl.QueryInterface = QueryInterface;
9126 com_vtbl.GetTypeInfoCount = GetTypeInfoCount;
9127 com_vtbl.GetTypeInfo = GetTypeInfo;
9128 com_vtbl.GetIDsOfNames = GetIDsOfNames;
9227 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
static void olevariant_free(struct olevariantdata *pvar)
static VALUE fole_invoke2(VALUE self, VALUE dispid, VALUE args, VALUE types)
static VALUE foletype_helpfile(VALUE self)
static HRESULT typeinfo_from_ole(struct oledata *pole, ITypeInfo **ppti)
RUBY_SYMBOL_EXPORT_BEGIN typedef unsigned long st_data_t
static VALUE fole_s_set_locale(VALUE self, VALUE vlcid)
static DWORD HTASK DWORD LPINTERFACEINFO lpInterfaceInfo
static VALUE method_name(VALUE obj)
static VALUE foletype_minor_version(VALUE self)
static BOOL lcid_installed(LCID lcid)
#define load_conv_function51932()
static VALUE foletype_visible(VALUE self)
static IDispatchVtbl com_vtbl
static VALUE ole_create_dcom(VALUE self, VALUE ole, VALUE host, VALUE others)
VALUE rb_ary_unshift(VALUE ary, VALUE item)
static char * ole_wc2mb_alloc(LPWSTR pw, char *(alloc)(UINT size, void *arg), void *arg)
#define RUBY_EVENT_THREAD_END
static VALUE foletypelib_ole_types(VALUE self)
static VALUE fev_on_event_with_outargs(int argc, VALUE *argv, VALUE self)
static VALUE folemethod_return_type_detail(VALUE self)
static VALUE ole_variable_ole_type(ITypeInfo *pTypeInfo, UINT var_index)
STDMETHODIMP EVENTSINK_Invoke(PEVENTSINK pEventSink, DISPID dispid, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pdispparams, VARIANT *pvarResult, EXCEPINFO *pexcepinfo, UINT *puArgErr)
static VALUE foletype_impl_ole_types(VALUE self)
static VALUE ev_on_event(int argc, VALUE *argv, VALUE self, VALUE is_ary_arg)
static VALUE ole_methods_sub(ITypeInfo *pOwnerTypeInfo, ITypeInfo *pTypeInfo, VALUE methods, int mask)
rb_funcall2(argv[0], id_yield, argc-1, argv+1)
static HRESULT find_default_source(VALUE ole, IID *piid, ITypeInfo **ppTypeInfo)
VALUE rb_ary_entry(VALUE ary, long offset)
static VALUE ole_method_return_type_detail(ITypeInfo *pTypeInfo, UINT method_index)
static VALUE ole_invoke2(VALUE self, VALUE dispid, VALUE args, VALUE types, USHORT dispkind)
static VALUE foletype_guid(VALUE self)
static VALUE ole_usertype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails)
static VALUE folemethod_dispid(VALUE self)
static HWND ole_show_help(VALUE helpfile, VALUE helpcontext)
static VALUE foletype_s_allocate(VALUE klass)
static char g_lcid_to_check[8+1]
size_t strlen(const char *)
static VALUE fev_unadvise(VALUE self)
static VALUE folemethod_size_opt_params(VALUE self)
static VALUE foleparam_input(VALUE self)
static VALUE evs_entry(long i)
const char * rb_obj_classname(VALUE)
static VALUE fole_setproperty_with_bracket(int argc, VALUE *argv, VALUE self)
static HRESULT clsid_from_remote(VALUE host, VALUE com, CLSID *pclsid)
static VALUE fole_s_ole_uninitialize(VALUE self)
void ruby_finalize(void)
Runs the VM finalization processes.
#define UNLIMITED_ARGUMENTS
static DWORD HTASK threadIDCaller
static char * ole_alloc_vstr(UINT size, void *arg)
int st_lookup(st_table *, st_data_t, st_data_t *)
static VALUE foletypelib_minor_version(VALUE self)
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
PIEVENTSINKOBJ EVENTSINK_Constructor()
EVENTSINK_AddRef(PEVENTSINK pEV)
static VALUE ev_advise(int argc, VALUE *argv, VALUE self)
static VALUE fole_setproperty2(VALUE self, VALUE dispid, VALUE args, VALUE types)
static VALUE folemethod_event_interface(VALUE self)
static long ole_search_event_at(VALUE ary, VALUE ev)
STDMETHODIMP EVENTSINK_QueryInterface(PEVENTSINK pEV, REFIID iid, LPVOID *ppv)
static void ole_val2olevariantdata(VALUE val, VARTYPE vt, struct olevariantdata *pvar)
static VALUE oletype_set_member(VALUE self, ITypeInfo *pTypeInfo, VALUE name)
static VALUE foletype_default_event_sources(VALUE self)
st_table * st_init_numtable(void)
static VALUE ole_search_event(VALUE ary, VALUE ev, BOOL *is_default)
#define Data_Make_Struct(klass, type, mark, free, sval)
static VALUE ole_methods(VALUE self, int mask)
static VALUE ole_method_params(ITypeInfo *pTypeInfo, UINT method_index)
STDMETHODIMP EVENTSINK_GetIDsOfNames(PEVENTSINK pEventSink, REFIID riid, OLECHAR **szNames, UINT cNames, LCID lcid, DISPID *pDispID)
static void hash2ptr_dispparams(VALUE hash, ITypeInfo *pTypeInfo, DISPID dispid, DISPPARAMS *pdispparams)
VALUE rb_ary_delete_at(VALUE ary, long pos)
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR VARIANT __RPC_FAR EXCEPINFO __RPC_FAR * pExcepInfo
rb_funcall(memo->yielder, id_lshift, 1, rb_assoc_new(memo->prev_value, memo->prev_elts))
static REFIID LPOLESTR __RPC_FAR * rgszNames
static VALUE reg_get_typelib_file_path(HKEY hkey)
static VALUE evs_delete(long i)
static VALUE ole_param_ole_type_detail(ITypeInfo *pTypeInfo, UINT method_index, UINT index)
static VALUE foleparam_output(VALUE self)
static volatile DWORD g_ole_initialized_key
VALUE rb_const_get(VALUE, ID)
static VALUE fole_func_methods(VALUE self)
int rb_str_cmp(VALUE, VALUE)
static LCID cWIN32OLE_lcid
#define g_ole_initialized_set(val)
static DWORD HTASK DWORD dwTickCount
static VALUE ole_type_helpfile(ITypeInfo *pTypeInfo)
static VALUE ary_new_dim(VALUE myary, long *pid, long *plb, long dim)
RUBY_EXTERN VALUE rb_cTime
static VALUE fev_on_event(int argc, VALUE *argv, VALUE self)
static VALUE folevariable_varkind(VALUE self)
static VALUE foletype_inspect(VALUE self)
VALUE rb_exc_new_str(VALUE etype, VALUE str)
static VALUE reg_enum_key(HKEY hkey, DWORD i)
static REFIID LPOLESTR __RPC_FAR UINT cNames
static VALUE ole_method_invoke_kind(ITypeInfo *pTypeInfo, UINT method_index)
BOOL( FNENUMSYSEMCODEPAGES)(CODEPAGE_ENUMPROC, DWORD)
static VALUE typelib_file_from_typelib(VALUE ole)
static VALUE foletype_s_progids(VALUE self)
static IEventSinkVtbl vtEventSink
static VALUE foletype_helpcontext(VALUE self)
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
static VALUE fole_free(VALUE self)
static rb_encoding * cWIN32OLE_enc
rb_encoding * rb_default_internal_encoding(void)
static BOOL CALLBACK installed_lcid_proc(LPTSTR str)
VALUE rb_ary_push(VALUE ary, VALUE item)
static VALUE ole_typelib_from_itypeinfo(ITypeInfo *pTypeInfo)
static VALUE make_inspect(const char *class_name, VALUE detail)
static void init_enc2cp(void)
static VALUE ole_variant2val(VARIANT *pvar)
static VALUE fole_type(VALUE self)
static void ole_const_load(ITypeLib *pTypeLib, VALUE klass, VALUE self)
static VALUE folevariant_initialize(VALUE self, VALUE args)
static IDispatch * val2dispatch(VALUE val)
static LPWSTR ole_mb2wc(char *pm, int len)
static VALUE ole_param_flag_mask(ITypeInfo *pTypeInfo, UINT method_index, UINT index, USHORT mask)
static void olevariable_free(struct olevariabledata *polevar)
struct tagIEVENTSINKOBJ IEVENTSINKOBJ
static VALUE ole_method_offset_vtbl(ITypeInfo *pTypeInfo, UINT method_index)
struct _Win32OLEIDispatch Win32OLEIDispatch
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
VALUE rb_protect(VALUE(*proc)(VALUE), VALUE data, int *state)
void rb_raise(VALUE exc, const char *fmt,...)
static VALUE folemethod_helpfile(VALUE self)
static VALUE foleparam_inspect(VALUE self)
void EVENTSINK_Destructor(PIEVENTSINKOBJ)
#define MEMCMP(p1, p2, type, n)
static VALUE ole_method_dispid(ITypeInfo *pTypeInfo, UINT method_index)
#define RETURN_ENUMERATOR(obj, argc, argv)
VALUE rb_ary_clear(VALUE ary)
static VALUE fole_methods(VALUE self)
#define OLEData_Get_Struct(obj, pole)
static VALUE ole_method_visible(ITypeInfo *pTypeInfo, UINT method_index)
static void ole_val2variant_ex(VALUE val, VARIANT *var, VARTYPE vt)
static VALUE is_all_index_under(long *pid, long *pub, long dim)
#define SafeStringValue(v)
static VALUE foletype_major_version(VALUE self)
static ITypeLib * oletypelib_get_typelib(VALUE self)
char CodePageName[MAX_PATH]
static VALUE fole_s_reference_count(VALUE self, VALUE obj)
double rb_big2dbl(VALUE x)
VALUE eWIN32OLERuntimeError
#define OLE_GET_TYPEATTR(X, Y)
IConnectionPoint * pConnectionPoint
static VALUE fole_method_help(VALUE self, VALUE cmdname)
static VALUE folemethod_inspect(VALUE self)
static VALUE ole_set_member(VALUE self, IDispatch *dispatch)
static VALUE ole_method_event(ITypeInfo *pTypeInfo, UINT method_index, VALUE method_name)
IUnknown COSERVERINFO MULTI_QI *typedef LPCSTR UINT DWORD dwData
static VALUE folemethod_return_type(VALUE self)
static HTASK threadIDCallee
static VALUE foletype_s_typelibs(VALUE self)
static void * get_ptr_of_variant(VARIANT *pvar)
static VALUE oleclass_from_typelib(VALUE self, ITypeLib *pTypeLib, VALUE oleclass)
static void ary_store_dim(VALUE myary, long *pid, long *plb, long dim, VALUE val)
static VALUE fole_s_get_code_page(VALUE self)
VALUE rb_ivar_get(VALUE, ID)
VALUE rb_str_concat(VALUE, VALUE)
static void olemethod_free(struct olemethoddata *polemethod)
static void ole_delete_event(VALUE ary, VALUE ev)
static void ole_val2ptr_variant(VALUE val, VARIANT *var)
static VALUE ole_ary_m_entry(VALUE val, long *pid)
static VALUE ole_type_visible(ITypeInfo *pTypeInfo)
static VALUE ole_type_impl_ole_types(ITypeInfo *pTypeInfo, int implflags)
unsigned long rb_event_flag_t
static HRESULT find_default_source_from_typeinfo(ITypeInfo *pTypeInfo, TYPEATTR *pTypeAttr, ITypeInfo **ppTypeInfo)
static VALUE set_argv(VARIANTARG *realargs, unsigned int beg, unsigned int end)
static VALUE folevariant_ary_aref(int argc, VALUE *argv, VALUE self)
static VALUE ole_ole_type(ITypeInfo *pTypeInfo)
static VALUE foleparam_ole_type_detail(VALUE self)
static void oleparam_free(struct oleparamdata *pole)
static VALUE ole_method_helpfile(ITypeInfo *pTypeInfo, UINT method_index)
static VALUE folemethod_invkind(VALUE self)
static void ole_val2variant(VALUE val, VARIANT *var)
void rb_exc_raise(VALUE mesg)
static VALUE foletypelib_guid(VALUE self)
IUnknown COSERVERINFO MULTI_QI *typedef LPCSTR UINT uCommand
static BOOL g_uninitialize_hooked
static VALUE foletype_ole_type(VALUE self)
static UINT g_cp_to_check
#define g_ole_initialized_init()
int st_delete(st_table *, st_data_t *, st_data_t *)
int rb_is_const_id(ID id)
static VALUE folevariable_ole_type_detail(VALUE self)
static VALUE foletype_default_ole_types(VALUE self)
struct tagIEVENTSINKOBJ * PIEVENTSINKOBJ
STDMETHODIMP EVENTSINK_GetTypeInfoCount(PEVENTSINK pEV, UINT *pct)
static HRESULT ole_docinfo_from_type(ITypeInfo *pTypeInfo, BSTR *name, BSTR *helpstr, DWORD *helpcontext, BSTR *helpfile)
struct IEventSink * PEVENTSINK
static VALUE folevariable_value(VALUE self)
static DISPID REFIID LCID WORD wFlags
static VALUE folemethod_invoke_kind(VALUE self)
static VALUE ole_search_handler_method(VALUE handler, VALUE ev, BOOL *is_default_handler)
static VALUE ole_typedesc2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails)
static VALUE fev_initialize(int argc, VALUE *argv, VALUE self)
static VALUE oleparam_ole_param(VALUE self, VALUE olemethod, int n)
static void ole_val2variant2(VALUE val, VARIANT *var)
static VALUE create_win32ole_object(VALUE klass, IDispatch *pDispatch, int argc, VALUE *argv)
rb_encoding * rb_default_external_encoding(void)
static VALUE ole_types_from_typelib(ITypeLib *pTypeLib, VALUE classes)
memset(y->frac+ix+1, 0,(y->Prec-(ix+1))*sizeof(BDIGIT))
static void unlock_safe_array(SAFEARRAY *psa)
VALUE rb_block_proc(void)
static VALUE ole_wc2vstr(LPWSTR pw, BOOL isfree)
return Data_Wrap_Struct(CLASS_OF(interp), 0, ip_free, slave)
static VALUE folemethod_event(VALUE self)
static VALUE ole_hresult2msg(HRESULT hr)
static VALUE foleparam_default(VALUE self)
static VALUE ole_variable_varkind(ITypeInfo *pTypeInfo, UINT var_index)
static VALUE ole_method_return_vtype(ITypeInfo *pTypeInfo, UINT method_index)
static VALUE ole_variable_kind(ITypeInfo *pTypeInfo, UINT var_index)
static UINT ole_encoding2cp(rb_encoding *enc)
ITypeInfo * pOwnerTypeInfo
static char * ole_alloc_str(UINT size, void *arg)
static VALUE olemethod_set_member(VALUE self, ITypeInfo *pTypeInfo, ITypeInfo *pOwnerTypeInfo, int index, VALUE name)
static VALUE ole_variable_visible(ITypeInfo *pTypeInfo, UINT var_index)
static void ole_initialize(void)
static BOOL g_lcid_installed
STDMETHOD() QueryInterface(PEVENTSINK, REFIID, LPVOID *)
#define StringValuePtr(v)
static VALUE ole_variable_value(ITypeInfo *pTypeInfo, UINT var_index)
static VALUE foletype_src_type(VALUE self)
static LPWSTR ole_vstr2wc(VALUE vstr)
static double rbtime2vtdate(VALUE tmobj)
static VALUE ole_type_helpcontext(ITypeInfo *pTypeInfo)
static void ole_uninitialize_hook(rb_event_flag_t evflag, VALUE data, VALUE self, ID mid, VALUE klass)
static VALUE ole_ptrtype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails)
static VALUE foletype_s_ole_classes(VALUE self, VALUE typelib)
static void ole_set_byref(VARIANT *realvar, VARIANT *var, VARTYPE vt)
static VALUE typelib_file(VALUE ole)
#define g_ole_initialized
static VALUE oletypelib_search_registry(VALUE self, VALUE typelib)
#define StringValueCStr(v)
static VALUE folemethod_helpcontext(VALUE self)
static void oletypelib_get_libattr(ITypeLib *pTypeLib, TLIBATTR **ppTLibAttr)
void rb_define_const(VALUE, const char *, VALUE)
static UINT __RPC_FAR * pctinfo
static VALUE ole_type_from_itypeinfo(ITypeInfo *pTypeInfo)
VALUE rb_str_cat2(VALUE, const char *)
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
static IMessageFilter imessage_filter
void rb_ary_store(VALUE ary, long idx, VALUE val)
static IMessageFilterVtbl message_filter
static VALUE reg_get_val(HKEY hkey, const char *subkey)
static VALUE fole_s_allocate(VALUE klass)
static VALUE fole_getproperty2(VALUE self, VALUE dispid, VALUE args, VALUE types)
static void oletypelib_free(struct oletypelibdata *poletypelib)
static VALUE ole_method_invkind(ITypeInfo *pTypeInfo, UINT method_index)
static VALUE fole_invoke(int argc, VALUE *argv, VALUE self)
static SAFEARRAY * get_locked_safe_array(VALUE val)
static VALUE ole_type_progid(ITypeInfo *pTypeInfo)
static BOOL code_page_installed(UINT cp)
static VALUE foletypelib_path(VALUE self)
static VALUE fole_typelib(VALUE self)
VALUE rb_call_super(int, const VALUE *)
static void ole_set_safe_array(long n, SAFEARRAY *psa, long *pid, long *pub, VALUE val, long dim, VARTYPE vt)
static VALUE foletype_name(VALUE self)
static VALUE folevariant_set_value(VALUE self, VALUE val)
static char * ole_wc2mb(LPWSTR pw)
static VALUE foletypelib_name(VALUE self)
static VALUE foletypelib_visible(VALUE self)
static VALUE folemethod_initialize(VALUE self, VALUE oletype, VALUE method)
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR * pDispParams
unsigned char buf[MIME_BUF_SIZE]
static VALUE folevariable_inspect(VALUE self)
static VALUE ole_methods_from_typeinfo(ITypeInfo *pTypeInfo, int mask)
sprintf(psz,"E%"PRIdSIZE, ex)
static VALUE ole_type_guid(ITypeInfo *pTypeInfo)
#define ALLOCA_N(type, n)
static VALUE fole_activex_initialize(VALUE self)
static void add_event_call_back(VALUE obj, VALUE event, VALUE data)
static VALUE folevariant_ary_aset(int argc, VALUE *argv, VALUE self)
static VALUE folemethod_name(VALUE self)
static void ole_raise(HRESULT hr, VALUE ecs, const char *fmt,...)
VALUE rb_eval_string(const char *)
Evaluates the given string in an isolated binding.
static void set_ole_codepage(UINT cp)
static long dimension(VALUE val)
static VALUE folevariable_variable_kind(VALUE self)
static rb_encoding * ole_cp2encoding(UINT cp)
static VALUE fole_put_methods(VALUE self)
static VALUE fole_s_set_code_page(VALUE self, VALUE vcp)
static VALUE fev_set_handler(VALUE self, VALUE val)
static REFIID LPOLESTR __RPC_FAR UINT LCID DISPID __RPC_FAR * rgDispId
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
static long ary_len_of_dim(VALUE ary, long dim)
static DISPID dispIdMember
static VALUE folevariant_value(VALUE self)
static VALUE fev_s_msg_loop(VALUE klass)
static VALUE folevariant_s_allocate(VALUE klass)
static VALUE foletypelib_major_version(VALUE self)
static VALUE foletype_helpstring(VALUE self)
VALUE rb_sprintf(const char *format,...)
static VALUE evs_length(void)
rb_block_call(enumerable, id_each, 0, 0, chunk_ii, arg)
static st_table * enc2cp_table
static VALUE foleparam_retval(VALUE self)
static HRESULT ole_val_ary2variant_ary(VALUE val, VARIANT *var, VARTYPE vt)
static VALUE foletype_progid(VALUE self)
static VALUE reg_get_val2(HKEY hkey, const char *subkey)
void rb_gc_register_mark_object(VALUE)
static VALUE ole_type_major_version(ITypeInfo *pTypeInfo)
#define OLE_RELEASE_TYPEATTR(X, Y)
static VALUE ole_propertyput(VALUE self, VALUE property, VALUE value)
static VALUE fole_get_methods(VALUE self)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
static VALUE typelib_file_from_clsid(VALUE ole)
static VALUE hash2named_arg(RB_BLOCK_CALL_FUNC_ARGLIST(pair, op))
static VALUE foleparam_initialize(VALUE self, VALUE olemethod, VALUE n)
static VALUE oletypelib_search_registry2(VALUE self, VALUE args)
static VALUE ole_invoke(int argc, VALUE *argv, VALUE self, USHORT wFlags, BOOL is_bracket)
static VALUE ole_method_size_params(ITypeInfo *pTypeInfo, UINT method_index)
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR VARIANT __RPC_FAR EXCEPINFO __RPC_FAR UINT __RPC_FAR * puArgErr
int rb_define_dummy_encoding(const char *name)
static HTASK DWORD DWORD dwPendingType
static VALUE ole_method_size_opt_params(ITypeInfo *pTypeInfo, UINT method_index)
static void failed_load_conv51932(void)
static VALUE ole_method_sub(VALUE self, ITypeInfo *pOwnerTypeInfo, ITypeInfo *pTypeInfo, VALUE name)
struct IEventSinkVtbl * lpVtbl
static VALUE vtdate2rbtime(double date)
static void free_enc2cp(void)
static VALUE folemethod_size_params(VALUE self)
void ole_uninitialize(void)
#define ENC_MACHING_CP(enc, encname, cp)
rb_hash_aset(hash, RARRAY_AREF(key_value_pair, 0), RARRAY_AREF(key_value_pair, 1))
static VALUE fev_get_handler(VALUE self)
static VALUE foletypelib_s_allocate(VALUE klass)
static VALUE oletypelib_set_member(VALUE self, ITypeLib *pTypeLib)
static HTASK DWORD DWORD dwRejectType
static VALUE fole_s_get_locale(VALUE self)
static VALUE ole_param_default(ITypeInfo *pTypeInfo, UINT method_index, UINT index)
static VALUE folemethod_return_vtype(VALUE self)
static VALUE ole_variable_ole_type_detail(ITypeInfo *pTypeInfo, UINT var_index)
static VALUE fole_setproperty(int argc, VALUE *argv, VALUE self)
VALUE rb_ensure(VALUE(*b_proc)(ANYARGS), VALUE data1, VALUE(*e_proc)(ANYARGS), VALUE data2)
static VALUE foleparam_name(VALUE self)
static VALUE ole_method_helpcontext(ITypeInfo *pTypeInfo, UINT method_index)
static VALUE ole_type_helpstring(ITypeInfo *pTypeInfo)
static VALUE ole_variables(ITypeInfo *pTypeInfo)
static VALUE foletypelib_s_typelibs(VALUE self)
static VALUE fev_s_allocate(VALUE klass)
static BOOL g_IsEventSinkVtblInitialized
static VALUE oleparam_ole_param_from_index(VALUE self, ITypeInfo *pTypeInfo, UINT method_index, int param_index)
static VALUE foletypelib_initialize(VALUE self, VALUE args)
static VALUE fole_getproperty_with_bracket(int argc, VALUE *argv, VALUE self)
static VALUE foletypelib_library_name(VALUE self)
static void check_type_val2variant(VALUE val)
VALUE rb_vsprintf(const char *, va_list)
static void oletype_free(struct oletypedata *poletype)
static VALUE ole_each_sub(VALUE pEnumV)
VALUE rb_define_module_under(VALUE outer, const char *name)
static VALUE folemethod_offset_vtbl(VALUE self)
static VALUE folemethod_s_allocate(VALUE klass)
#define va_init_list(a, b)
static HRESULT find_coclass(ITypeInfo *pTypeInfo, TYPEATTR *pTypeAttr, ITypeInfo **pTypeInfo2, TYPEATTR **pTypeAttr2)
static VALUE foletype_initialize(VALUE self, VALUE typelib, VALUE oleclass)
static VALUE fole_each(VALUE self)
VALUE rb_str_cat(VALUE, const char *, long)
static VALUE ary_ole_event
rb_encoding * rb_enc_get(VALUE obj)
static REFIID void __RPC_FAR *__RPC_FAR * ppvObject
static VALUE folemethod_params(VALUE self)
static VALUE fole_respond_to(VALUE self, VALUE method)
VALUE rb_obj_is_kind_of(VALUE, VALUE)
IUnknown COSERVERINFO MULTI_QI *typedef HWND(WINAPI FNHTMLHELP)(HWND hwndCaller
static VALUE fole_s_free(VALUE self, VALUE obj)
typedef HRESULT(STDAPICALLTYPE FNCOCREATEINSTANCEEX)(REFCLSID
static FNCOCREATEINSTANCEEX * gCoCreateInstanceEx
static VALUE folevariant_s_array(VALUE klass, VALUE dims, VALUE vvt)
RUBY_EXTERN VALUE rb_cObject
STDMETHODIMP EVENTSINK_GetTypeInfo(PEVENTSINK pEV, UINT info, LCID lcid, ITypeInfo **pInfo)
static void ary2ptr_dispparams(VALUE ary, DISPPARAMS *pdispparams)
static const unsigned char ev[]
static VALUE exec_callback(VALUE arg)
static HRESULT find_iid(VALUE ole, char *pitf, IID *piid, ITypeInfo **ppTypeInfo)
static HRESULT ole_method_docinfo_from_type(ITypeInfo *pTypeInfo, UINT method_index, BSTR *name, BSTR *helpstr, DWORD *helpcontext, BSTR *helpfile)
static VALUE folevariable_name(VALUE self)
static VALUE ole_bind_obj(VALUE moniker, int argc, VALUE *argv, VALUE self)
#define Data_Get_Struct(obj, type, sval)
static VALUE foletypelib_inspect(VALUE self)
static VALUE fole_query_interface(VALUE self, VALUE str_iid)
int rb_respond_to(VALUE, ID)
static ULONG reference_count(struct oledata *pole)
static void ole_event_free(struct oleeventdata *poleev)
static VALUE foletype_ole_typelib(VALUE self)
static VALUE hash2result(VALUE hash)
static VALUE ole_method_helpstring(ITypeInfo *pTypeInfo, UINT method_index)
static VALUE rescue_callback(VALUE arg)
static VALUE folemethod_helpstring(VALUE self)
int st_insert(st_table *, st_data_t, st_data_t)
VALUE rb_apply(VALUE, ID, VALUE)
Calls a method.
static VALUE ole_method_return_type(ITypeInfo *pTypeInfo, UINT method_index)
VALUE rb_ary_concat(VALUE x, VALUE y)
static VALUE ole_type_src_type(ITypeInfo *pTypeInfo)
#define RSTRING_LENINT(str)
rb_ivar_set(yielder, id_memo, LONG2NUM(++count))
static VALUE ole_ienum_free(VALUE pEnumV)
void rb_write_error(const char *)
static VALUE foletypelib_version(VALUE self)
static void ole_freeexceptinfo(EXCEPINFO *pExInfo)
const char * rb_id2name(ID id)
VALUE rb_str_intern(VALUE)
static BOOL g_cp_installed
static VALUE folevariable_visible(VALUE self)
IUnknown COSERVERINFO MULTI_QI *typedef LPCSTR pszFile
static VALUE make_version_str(VALUE major, VALUE minor)
static UINT LCID ITypeInfo __RPC_FAR *__RPC_FAR * ppTInfo
static VALUE ole_type_minor_version(ITypeInfo *pTypeInfo)
static VALUE fole_initialize(int argc, VALUE *argv, VALUE self)
static HRESULT oletypelib_from_guid(VALUE guid, VALUE version, ITypeLib **ppTypeLib)
void rb_mark_hash(struct st_table *)
static VALUE foletype_typekind(VALUE self)
VALUE rb_hash_aref(VALUE, VALUE)
VALUE rb_fix2str(VALUE, int)
int rb_enc_find_index(const char *name)
static void ole_free(struct oledata *pole)
static VALUE folevariant_vartype(VALUE self)
static VALUE fole_s_create_guid(VALUE self)
static VALUE foletype_variables(VALUE self)
static void version(void)
static VALUE ole_param_ole_type(ITypeInfo *pTypeInfo, UINT method_index, UINT index)
static UINT ole_init_cp(void)
static VALUE foleparam_optional(VALUE self)
static long * ary2safe_array_index(int ary_size, VALUE *ary, SAFEARRAY *psa)
static VALUE folemethod_visible(VALUE self)
static IMessageFilter * previous_filter
#define RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)
static VOID * val2variant_ptr(VALUE val, VARIANT *var, VARTYPE vt)
static VALUE oletypelib_path(VALUE guid, VALUE version)
RUBY_EXTERN VALUE rb_cData
void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, VALUE data)
static void ole_msg_loop(void)
static VALUE foleparam_s_allocate(VALUE klass)
static VALUE fole_s_show_help(int argc, VALUE *argv, VALUE self)
static VALUE ole_type_typekind(ITypeInfo *pTypeInfo)
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR VARIANT __RPC_FAR * pVarResult
static ULONG(STDMETHODCALLTYPE AddRef)(IDispatch __RPC_FAR *This)
static VALUE olemethod_from_typeinfo(VALUE self, ITypeInfo *pTypeInfo, VALUE name)
static BOOL CALLBACK installed_code_page_proc(LPTSTR str)
static VALUE ole_excepinfo2msg(EXCEPINFO *pExInfo)
static VALUE default_inspect(VALUE self, const char *class_name)
static VALUE fev_off_event(int argc, VALUE *argv, VALUE self)
static VALUE folevariable_ole_type(VALUE self)
static VALUE foleparam_ole_type(VALUE self)
static VALUE foletype_source_ole_types(VALUE self)
void st_free_table(st_table *)
static VALUE fole_s_ole_initialize(VALUE self)
static VALUE fole_missing(int argc, VALUE *argv, VALUE self)
STATIC void unsigned char * cp
static LONG reg_open_vkey(HKEY hkey, VALUE key, HKEY *phkey)
rb_encoding * rb_enc_from_index(int index)
static VALUE fole_s_const_load(int argc, VALUE *argv, VALUE self)
static LONG reg_open_key(HKEY hkey, const char *name, HKEY *phkey)
static VALUE foletype_methods(VALUE self)
static VALUE evs_push(VALUE ev)
void rb_str_set_len(VALUE, long)
static VALUE fole_s_connect(int argc, VALUE *argv, VALUE self)