25#if defined(__CYGWIN__) || defined(__MINGW32__)
26#undef IID_IMultiLanguage2
27const IID IID_IMultiLanguage2 = {0xDCCFC164, 0x2B38, 0x11d2, {0xB7, 0xEC, 0x00, 0xC0, 0x4F, 0x8F, 0x5D, 0x9A}};
30#define WIN32OLE_VERSION "1.8.8"
32typedef HRESULT (STDAPICALLTYPE FNCOCREATEINSTANCEEX)
33 (REFCLSID, IUnknown*,
DWORD, COSERVERINFO*,
DWORD, MULTI_QI*);
40#if defined(RB_THREAD_SPECIFIC) && (defined(__CYGWIN__))
42# define g_ole_initialized_init() ((void)0)
43# define g_ole_initialized_set(val) (g_ole_initialized = (val))
45static volatile DWORD g_ole_initialized_key = TLS_OUT_OF_INDEXES;
46# define g_ole_initialized (TlsGetValue(g_ole_initialized_key)!=0)
47# define g_ole_initialized_init() (g_ole_initialized_key = TlsAlloc())
48# define g_ole_initialized_set(val) TlsSetValue(g_ole_initialized_key, (void*)(val))
51static BOOL g_uninitialize_hooked =
FALSE;
52static BOOL g_cp_installed =
FALSE;
53static BOOL g_lcid_installed =
FALSE;
54static BOOL g_running_nano =
FALSE;
55static HINSTANCE ghhctrl =
NULL;
56static HINSTANCE gole32 =
NULL;
57static FNCOCREATEINSTANCEEX *gCoCreateInstanceEx =
NULL;
59static VALUE enc2cp_hash;
60static IDispatchVtbl com_vtbl;
61static UINT cWIN32OLE_cp = CP_ACP;
63static UINT g_cp_to_check = CP_ACP;
64static char g_lcid_to_check[8 + 1];
65static VARTYPE g_nil_to = VT_ERROR;
66static IMessageFilterVtbl message_filter;
67static IMessageFilter imessage_filter = { &message_filter };
68static IMessageFilter* previous_filter;
70#if defined(HAVE_TYPE_IMULTILANGUAGE2)
72#elif defined(HAVE_TYPE_IMULTILANGUAGE)
75#define pIMultiLanguage NULL
83static HRESULT ( STDMETHODCALLTYPE QueryInterface )(IDispatch __RPC_FAR *, REFIID
riid,
void __RPC_FAR *__RPC_FAR *
ppvObject);
84static ULONG ( STDMETHODCALLTYPE AddRef )(IDispatch __RPC_FAR * This);
85static ULONG ( STDMETHODCALLTYPE Release )(IDispatch __RPC_FAR * This);
86static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(IDispatch __RPC_FAR * This, UINT __RPC_FAR *
pctinfo);
87static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(IDispatch __RPC_FAR * This, UINT
iTInfo, LCID
lcid, ITypeInfo __RPC_FAR *__RPC_FAR *
ppTInfo);
90static IDispatch* val2dispatch(
VALUE val);
91static double rbtime2vtdate(
VALUE tmobj);
92static VALUE vtdate2rbtime(
double date);
95NORETURN(
static void failed_load_conv51932(
void));
96#ifndef pIMultiLanguage
99static UINT ole_init_cp(
void);
100static void ole_freeexceptinfo(EXCEPINFO *pExInfo);
101static VALUE ole_excepinfo2msg(EXCEPINFO *pExInfo);
102static void ole_free(
void *
ptr);
103static size_t ole_size(
const void *
ptr);
104static LPWSTR ole_mb2wc(
char *pm,
int len, UINT cp);
105static VALUE ole_ary_m_entry(
VALUE val, LONG *pid);
106static VALUE is_all_index_under(LONG *pid,
long *pub,
long dim);
107static void * get_ptr_of_variant(VARIANT *pvar);
108static void ole_set_safe_array(
long n, SAFEARRAY *psa, LONG *pid,
long *pub,
VALUE val,
long dim, VARTYPE vt);
109static long dimension(
VALUE val);
110static long ary_len_of_dim(
VALUE ary,
long dim);
111static VALUE ole_set_member(
VALUE self, IDispatch *dispatch);
114static VALUE ary_new_dim(
VALUE myary, LONG *pid, LONG *plb, LONG dim);
115static void ary_store_dim(
VALUE myary, LONG *pid, LONG *plb, LONG dim,
VALUE val);
116static void ole_const_load(ITypeLib *pTypeLib,
VALUE klass,
VALUE self);
122static ULONG reference_count(
struct oledata * pole);
128static BOOL CALLBACK installed_code_page_proc(LPTSTR
str);
129static BOOL code_page_installed(UINT cp);
132static BOOL CALLBACK installed_lcid_proc(LPTSTR
str);
133static BOOL lcid_installed(LCID
lcid);
136static VALUE fole_s_ole_initialize(
VALUE self);
137static VALUE fole_s_ole_uninitialize(
VALUE self);
140static VALUE set_argv(VARIANTARG* realargs,
unsigned int beg,
unsigned int end);
156static HRESULT typeinfo_from_ole(
struct oledata *pole, ITypeInfo **ppti);
166static VALUE ole_usertype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc,
VALUE typedetails);
167static VALUE ole_ptrtype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc,
VALUE typedetails);
169static VALUE fole_activex_initialize(
VALUE self);
171static void com_hash_free(
void *
ptr);
172static void com_hash_mark(
void *
ptr);
173static size_t com_hash_size(
const void *
ptr);
174static void check_nano_server(
void);
178 {
NULL, ole_free, ole_size,},
184 {com_hash_mark, com_hash_free, com_hash_size,},
188static HRESULT (STDMETHODCALLTYPE mf_QueryInterface)(
189 IMessageFilter __RPC_FAR * This,
194 ||
MEMCMP(
riid, &IID_IMessageFilter, GUID, 1) == 0)
199 return E_NOINTERFACE;
202static ULONG (STDMETHODCALLTYPE mf_AddRef)(
203 IMessageFilter __RPC_FAR * This)
208static ULONG (STDMETHODCALLTYPE mf_Release)(
209 IMessageFilter __RPC_FAR * This)
214static DWORD (STDMETHODCALLTYPE mf_HandleInComingCall)(
215 IMessageFilter __RPC_FAR * pThis,
222#ifdef DEBUG_MESSAGEFILTER
229 case CALLTYPE_TOPLEVEL_CALLPENDING:
230 case CALLTYPE_ASYNC_CALLPENDING:
232 return SERVERCALL_RETRYLATER;
238 if (previous_filter) {
239 return previous_filter->lpVtbl->HandleInComingCall(previous_filter,
245 return SERVERCALL_ISHANDLED;
248static DWORD (STDMETHODCALLTYPE mf_RetryRejectedCall)(
249 IMessageFilter* pThis,
255 if (previous_filter) {
256 return previous_filter->lpVtbl->RetryRejectedCall(previous_filter,
264static DWORD (STDMETHODCALLTYPE mf_MessagePending)(
265 IMessageFilter* pThis,
272 return PENDINGMSG_WAITNOPROCESS;
274 if (previous_filter) {
275 return previous_filter->lpVtbl->MessagePending(previous_filter,
280 return PENDINGMSG_WAITNOPROCESS;
290static HRESULT ( STDMETHODCALLTYPE QueryInterface )(
291 IDispatch __RPC_FAR * This,
296 ||
MEMCMP(
riid, &IID_IDispatch, GUID, 1) == 0)
303 return E_NOINTERFACE;
306static ULONG ( STDMETHODCALLTYPE AddRef )(
307 IDispatch __RPC_FAR * This)
313static ULONG ( STDMETHODCALLTYPE Release )(
314 IDispatch __RPC_FAR * This)
326static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(
327 IDispatch __RPC_FAR * This,
333static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(
334 IDispatch __RPC_FAR * This,
337 ITypeInfo __RPC_FAR *__RPC_FAR *
ppTInfo)
343static HRESULT ( STDMETHODCALLTYPE GetIDsOfNames )(
344 IDispatch __RPC_FAR * This,
362static HRESULT ( STDMETHODCALLTYPE Invoke )(
363 IDispatch __RPC_FAR * This,
379 for (
i = 0;
i < args;
i++) {
383 if (
wFlags == DISPATCH_METHOD) {
385 }
else if (
wFlags & DISPATCH_PROPERTYGET) {
401val2dispatch(
VALUE val)
421rbtime2vtdate(
VALUE tmobj)
433 st.wMilliseconds = 0;
434 SystemTimeToVariantTime(&
st, &t);
443 nsec /= (24.0 * 3600.0);
449vtdate2rbtime(
double date)
455 VariantTimeToSystemTime(date, &
st);
469 st.wMilliseconds = 0;
470 SystemTimeToVariantTime(&
st, &sec);
489#define ENC_MACHING_CP(enc,encname,cp) if(strcasecmp(rb_enc_name((enc)),(encname)) == 0) return cp
557failed_load_conv51932(
void)
562#ifndef pIMultiLanguage
569#if defined(HAVE_TYPE_IMULTILANGUAGE2)
570 hr = CoCreateInstance(&CLSID_CMultiLanguage,
NULL, CLSCTX_INPROC_SERVER,
571 &IID_IMultiLanguage2, &p);
572#elif defined(HAVE_TYPE_IMULTILANGUAGE)
573 hr = CoCreateInstance(&CLSID_CMultiLanguage,
NULL, CLSCTX_INPROC_SERVER,
574 &IID_IMultiLanguage, &p);
577 failed_load_conv51932();
582#define need_conv_function51932() (load_conv_function51932(), 1)
584#define load_conv_function51932() failed_load_conv51932()
585#define need_conv_function51932() (failed_load_conv51932(), 0)
588#define conv_51932(cp) ((cp) == 51932 && need_conv_function51932())
591set_ole_codepage(UINT cp)
593 if (code_page_installed(cp)) {
611 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.");
615 cWIN32OLE_enc = ole_cp2encoding(cWIN32OLE_cp);
628 cp = ole_encoding2cp(encdef);
629 set_ole_codepage(cp);
643ole_cp2encoding(UINT cp)
651 if (!code_page_installed(cp)) {
663 GetProcAddress(GetModuleHandle(
"kernel32"),
"GetCPInfoEx");
665 pGetCPInfoEx = (
void*)-1;
670 if (pGetCPInfoEx == (
void*)-1 || !pGetCPInfoEx(cp, 0,
buf)) {
684 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.");
696#ifndef pIMultiLanguage
698ole_ml_wc2mb_conv0(LPWSTR pw, LPSTR pm, UINT *
size)
702 &dw, cWIN32OLE_cp, pw,
NULL, pm,
size);
704#define ole_ml_wc2mb_conv(pw, pm, size, onfailure) do { \
705 HRESULT hr = ole_ml_wc2mb_conv0(pw, pm, &size); \
708 ole_raise(hr, eWIN32OLERuntimeError, "fail to convert Unicode to CP%d", cWIN32OLE_cp); \
713#define ole_wc2mb_conv(pw, pm, size) WideCharToMultiByte(cWIN32OLE_cp, 0, (pw), -1, (pm), (size), NULL, NULL)
716ole_wc2mb_alloc(LPWSTR pw,
char *(alloc)(UINT
size,
void *
arg),
void *
arg)
721#ifndef pIMultiLanguage
722 ole_ml_wc2mb_conv(pw,
NULL,
size, {});
737ole_alloc_str(UINT
size,
void *
arg)
745 return ole_wc2mb_alloc(pw, ole_alloc_str,
NULL);
749ole_freeexceptinfo(EXCEPINFO *pExInfo)
751 SysFreeString(pExInfo->bstrDescription);
752 SysFreeString(pExInfo->bstrSource);
753 SysFreeString(pExInfo->bstrHelpFile);
757ole_excepinfo2msg(EXCEPINFO *pExInfo)
760 char *pSource =
NULL;
761 char *pDescription =
NULL;
763 if(pExInfo->pfnDeferredFillIn !=
NULL) {
764 (*pExInfo->pfnDeferredFillIn)(pExInfo);
766 if (pExInfo->bstrSource !=
NULL) {
767 pSource =
ole_wc2mb(pExInfo->bstrSource);
769 if (pExInfo->bstrDescription !=
NULL) {
770 pDescription =
ole_wc2mb(pExInfo->bstrDescription);
772 if(pExInfo->wCode == 0) {
773 sprintf(error_code,
"\n OLE error code:%lX in ", (
unsigned long)pExInfo->scode);
776 sprintf(error_code,
"\n OLE error code:%u in ", pExInfo->wCode);
779 if(pSource !=
NULL) {
786 if(pDescription !=
NULL) {
792 if(pSource)
free(pSource);
793 if(pDescription)
free(pDescription);
794 ole_freeexceptinfo(pExInfo);
817 if(!g_uninitialize_hooked) {
819 g_uninitialize_hooked =
TRUE;
824 hr = CoInitializeEx(
NULL, COINIT_MULTITHREADED);
826 hr = OleInitialize(
NULL);
833 if (g_running_nano ==
FALSE) {
834 hr = CoRegisterMessageFilter(&imessage_filter, &previous_filter);
836 previous_filter =
NULL;
851static size_t ole_size(
const void *
ptr)
885 cp = ole_encoding2cp(enc);
886 if (code_page_installed(cp) ||
890 cp == CP_THREAD_ACP ||
906ole_mb2wc(
char *pm,
int len, UINT cp)
912#ifndef pIMultiLanguage
923 &dw, cp, pm, &
n, pw, &
size);
930 size = MultiByteToWideChar(cp, 0, pm,
len,
NULL, 0);
933 MultiByteToWideChar(cp, 0, pm,
len, pw,
size);
938ole_alloc_vstr(UINT
size,
void *
arg)
949 ole_wc2mb_alloc(pw, ole_alloc_vstr, &vstr);
957ole_ary_m_entry(
VALUE val, LONG *pid)
970is_all_index_under(LONG *pid,
long *pub,
long dim)
973 for (
i = 0;
i < dim;
i++) {
974 if (pid[
i] > pub[
i]) {
985 if (vt == VT_VARIANT) {
988 V_VT(var) = (vt & ~VT_BYREF);
989 if (V_VT(var) == VT_DISPATCH) {
990 V_DISPATCH(var) =
NULL;
991 }
else if (V_VT(var) == VT_UNKNOWN) {
992 V_UNKNOWN(var) =
NULL;
997#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
998 switch(vt & ~VT_BYREF) {
1001 V_I8(var) =
NUM2I8 (val);
1022 if ((vt & ~VT_BYREF) == VT_VARIANT) {
1025 if ( (vt & ~VT_BYREF) != V_VT(var)) {
1026 hr = VariantChangeTypeEx(var, var,
1032 p = get_ptr_of_variant(var);
1041get_ptr_of_variant(VARIANT *pvar)
1043 switch(V_VT(pvar)) {
1045 return &V_UI1(pvar);
1051 return &V_UI2(pvar);
1057 return &V_UI4(pvar);
1065#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1070 return &V_UI8(pvar);
1074 return &
V_INT(pvar);
1083 return &V_DATE(pvar);
1086 return V_BSTR(pvar);
1089 return V_DISPATCH(pvar);
1092 return &V_ERROR(pvar);
1095 return &V_BOOL(pvar);
1098 return V_UNKNOWN(pvar);
1101 return &V_ARRAY(pvar);
1110ole_set_safe_array(
long n, SAFEARRAY *psa, LONG *pid,
long *pub,
VALUE val,
long dim, VARTYPE vt)
1118 val1 = ole_ary_m_entry(val, pid);
1121 if (is_all_index_under(pid, pub, dim) ==
Qtrue) {
1122 if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) ==
NULL) ||
1123 (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) ==
NULL)) {
1126 hr = SafeArrayPutElement(psa, pid, p);
1132 if (pid[
i] > pub[
i]) {
1142dimension(
VALUE val) {
1149 for (
i = 0;
i <
len;
i++) {
1161ary_len_of_dim(
VALUE ary,
long dim) {
1174 for (
i = 0;
i <
len;
i++) {
1176 ary_len1 = ary_len_of_dim(val, dim-1);
1177 if (ary_len < ary_len1) {
1193 SAFEARRAYBOUND *psab =
NULL;
1194 SAFEARRAY *psa =
NULL;
1200 dim = dimension(val);
1202 psab =
ALLOC_N(SAFEARRAYBOUND, dim);
1206 if(!psab || !pub || !pid) {
1208 if(psab)
free(psab);
1213 for (
i = 0;
i < dim;
i++) {
1214 psab[
i].cElements = ary_len_of_dim(val,
i);
1215 psab[
i].lLbound = 0;
1216 pub[
i] = psab[
i].cElements - 1;
1220 if ((vt & ~VT_BYREF) == VT_ARRAY) {
1221 vt = (vt | VT_VARIANT);
1223 psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
1227 hr = SafeArrayLock(psa);
1228 if (SUCCEEDED(hr)) {
1229 ole_set_safe_array(dim-1, psa, pid, pub, val, dim, (VARTYPE)(vt & VT_TYPEMASK));
1230 hr = SafeArrayUnlock(psa);
1234 if(psab)
free(psab);
1237 if (SUCCEEDED(hr)) {
1243 SafeArrayDestroy(psa);
1255 V_VT(var) = VT_DISPATCH;
1268 V_VT(var) = VT_DATE;
1269 V_DATE(var) = rbtime2vtdate(val);
1272 switch (
TYPE(val)) {
1277 V_VT(var) = VT_BSTR;
1284 V_I4(var) = (LONG)
v;
1286 if (V_I4(var) !=
v) {
1302 V_VT(var) = VT_BOOL;
1303 V_BOOL(var) = VARIANT_TRUE;
1306 V_VT(var) = VT_BOOL;
1307 V_BOOL(var) = VARIANT_FALSE;
1310 if (g_nil_to == VT_ERROR) {
1311 V_VT(var) = VT_ERROR;
1312 V_ERROR(var) = DISP_E_PARAMNOTFOUND;
1314 V_VT(var) = VT_EMPTY;
1318 V_VT(var) = VT_DISPATCH;
1319 V_DISPATCH(var) = val2dispatch(val);
1327 g_nil_to = VT_EMPTY;
1329 g_nil_to = VT_ERROR;
1352ole_set_member(
VALUE self, IDispatch *dispatch)
1385ary_new_dim(
VALUE myary, LONG *pid, LONG *plb, LONG dim) {
1389 long *ids =
ALLOC_N(
long, dim);
1393 for(
i = 0;
i < dim;
i++) {
1394 ids[
i] = pid[
i] - plb[
i];
1398 for(
i = 0;
i < dim-1;
i++) {
1411ary_store_dim(
VALUE myary, LONG *pid, LONG *plb, LONG dim,
VALUE val) {
1412 long id = pid[dim - 1] - plb[dim - 1];
1413 VALUE obj = ary_new_dim(myary, pid, plb, dim);
1421 VARTYPE vt = V_VT(pvar);
1423 while ( vt == (VT_BYREF | VT_VARIANT) ) {
1424 pvar = V_VARIANTREF(pvar);
1428 if(V_ISARRAY(pvar)) {
1429 VARTYPE vt_base = vt & VT_TYPEMASK;
1430 SAFEARRAY *psa = V_ISBYREF(pvar) ? *V_ARRAYREF(pvar) : V_ARRAY(pvar);
1432 LONG *pid, *plb, *pub;
1439 dim = SafeArrayGetDim(psa);
1444 if(!pid || !plb || !pub) {
1451 for(
i = 0;
i < dim; ++
i) {
1452 SafeArrayGetLBound(psa,
i+1, &plb[
i]);
1453 SafeArrayGetLBound(psa,
i+1, &pid[
i]);
1454 SafeArrayGetUBound(psa,
i+1, &pub[
i]);
1456 hr = SafeArrayLock(psa);
1457 if (SUCCEEDED(hr)) {
1460 VariantInit(&variant);
1461 V_VT(&variant) = vt_base | VT_BYREF;
1462 if (vt_base == VT_RECORD) {
1463 hr = SafeArrayGetRecordInfo(psa, &V_RECORDINFO(&variant));
1464 if (SUCCEEDED(hr)) {
1465 V_VT(&variant) = VT_RECORD;
1469 ary_new_dim(
obj, pid, plb, dim);
1470 if (vt_base == VT_RECORD)
1471 hr = SafeArrayPtrOfIndex(psa, pid, &V_RECORD(&variant));
1473 hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
1474 if (SUCCEEDED(hr)) {
1476 ary_store_dim(
obj, pid, plb, dim, val);
1478 for (
i = 0;
i < dim; ++
i) {
1479 if (++pid[
i] <= pub[
i])
1484 SafeArrayUnlock(psa);
1491 switch(V_VT(pvar) & ~VT_BYREF){
1552#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1555#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1567#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
1597 bstr = *V_BSTRREF(pvar);
1599 bstr = V_BSTR(pvar);
1600 obj = (SysStringLen(bstr) == 0)
1614 if (V_ISBYREF(pvar))
1624 if (V_ISBYREF(pvar))
1644 if (V_ISBYREF(pvar))
1645 punk = *V_UNKNOWNREF(pvar);
1647 punk = V_UNKNOWN(pvar);
1650 hr = punk->lpVtbl->QueryInterface(punk, &IID_IDispatch, &p);
1663 date = *V_DATEREF(pvar);
1665 date = V_DATE(pvar);
1667 obj = vtdate2rbtime(date);
1673 IRecordInfo *pri = V_RECORDINFO(pvar);
1674 void *prec = V_RECORD(pvar);
1684 VariantInit(&variant);
1685 hr = VariantChangeTypeEx(&variant, pvar,
1687 if (SUCCEEDED(hr) && V_VT(&variant) == VT_BSTR) {
1690 VariantClear(&variant);
1700 return RegOpenKeyEx(hkey,
name, 0, KEY_READ, phkey);
1715 LONG
err = RegEnumKeyEx(hkey,
i,
buf, &size_buf,
1717 if(
err == ERROR_SUCCESS) {
1733 if (
err == ERROR_SUCCESS) {
1735 err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype, (BYTE *)pbuf, &
size);
1736 if (
err == ERROR_SUCCESS) {
1738 if (dwtype == REG_EXPAND_SZ) {
1739 char* pbuf2 = (
char *)pbuf;
1742 ExpandEnvironmentStrings(pbuf2, pbuf,
len + 1);
1758 err = RegOpenKeyEx(hkey, subkey, 0, KEY_READ, &hsubkey);
1759 if (
err == ERROR_SUCCESS) {
1761 RegCloseKey(hsubkey);
1775 ITypeInfo *pTypeInfo;
1776 TYPEATTR *pTypeAttr;
1786 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
1788 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib,
index, &pTypeInfo);
1796 for(iVar = 0; iVar < pTypeAttr->cVars; iVar++) {
1797 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, iVar, &pVarDesc);
1800 if(pVarDesc->varkind == VAR_CONST &&
1801 !(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
1802 VARFLAG_FRESTRICTED |
1803 VARFLAG_FNONBROWSABLE))) {
1804 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
1806 if(FAILED(hr) ||
len == 0 || !bstr)
1810 *pName = toupper((
int)*pName);
1820 SysFreeString(bstr);
1826 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
1828 pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
1835clsid_from_remote(
VALUE host,
VALUE com, CLSID *pclsid)
1847 if (
err != ERROR_SUCCESS)
1848 return HRESULT_FROM_WIN32(
err);
1853 if (
err != ERROR_SUCCESS)
1854 hr = HRESULT_FROM_WIN32(
err);
1856 len =
sizeof(clsid);
1857 err = RegQueryValueEx(hpid,
"",
NULL, &dwtype, (BYTE *)clsid, &
len);
1858 if (
err == ERROR_SUCCESS && dwtype == REG_SZ) {
1859 pbuf = ole_mb2wc(clsid, -1, cWIN32OLE_cp);
1860 hr = CLSIDFromString(pbuf, pclsid);
1861 SysFreeString(pbuf);
1864 hr = HRESULT_FROM_WIN32(
err);
1879 COSERVERINFO serverinfo;
1881 DWORD clsctx = CLSCTX_REMOTE_SERVER;
1884 gole32 = LoadLibrary(
"OLE32");
1887 if (!gCoCreateInstanceEx)
1888 gCoCreateInstanceEx = (FNCOCREATEINSTANCEEX*)
1889 GetProcAddress(gole32,
"CoCreateInstanceEx");
1890 if (!gCoCreateInstanceEx)
1894 hr = CLSIDFromProgID(pbuf, &clsid);
1896 hr = clsid_from_remote(host, ole, &clsid);
1898 hr = CLSIDFromString(pbuf, &clsid);
1899 SysFreeString(pbuf);
1902 "unknown OLE server: `%s'",
1904 memset(&serverinfo, 0,
sizeof(COSERVERINFO));
1906 memset(&multi_qi, 0,
sizeof(MULTI_QI));
1907 multi_qi.pIID = &IID_IDispatch;
1908 hr = gCoCreateInstanceEx(&clsid,
NULL, clsctx, &serverinfo, 1, &multi_qi);
1909 SysFreeString(serverinfo.pwszName);
1912 "failed to create DCOM server `%s' in `%s'",
1916 ole_set_member(
self, (IDispatch*)multi_qi.pItf);
1933 hr = CreateBindCtx(0, &pBindCtx);
1936 "failed to create bind context");
1940 hr = MkParseDisplayName(pBindCtx, pbuf, &eaten, &pMoniker);
1941 SysFreeString(pbuf);
1945 "failed to parse display name of moniker `%s'",
1948 hr = pMoniker->lpVtbl->BindToObject(pMoniker, pBindCtx,
NULL,
1949 &IID_IDispatch, &p);
1956 "failed to bind moniker `%s'",
1991 hr = CLSIDFromProgID(pBuf, &clsid);
1993 hr = CLSIDFromString(pBuf, &clsid);
1995 SysFreeString(pBuf);
1997 return ole_bind_obj(svr_name,
argc,
argv,
self);
2000 hr = GetActiveObject(&clsid, 0, &pUnknown);
2005 hr = pUnknown->lpVtbl->QueryInterface(pUnknown, &IID_IDispatch, &p);
2010 "failed to create WIN32OLE server `%s'",
2054 ITypeInfo *pTypeInfo;
2071 0,
lcid, &pTypeInfo);
2075 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &
index);
2082 ole_const_load(pTypeLib,
klass,
self);
2085 ole_const_load(pTypeLib,
cWIN32OLE,
self);
2095 hr = LoadTypeLibEx(pBuf, REGKIND_NONE, &pTypeLib);
2096 SysFreeString(pBuf);
2100 ole_const_load(pTypeLib,
klass,
self);
2103 ole_const_load(pTypeLib,
cWIN32OLE,
self);
2114reference_count(
struct oledata * pole)
2156 if (reference_count(pole) > 0) {
2164ole_show_help(
VALUE helpfile,
VALUE helpcontext)
2166 FNHTMLHELP *pfnHtmlHelp;
2170 ghhctrl = LoadLibrary(
"HHCTRL.OCX");
2173 pfnHtmlHelp = (FNHTMLHELP*)GetProcAddress(ghhctrl,
"HtmlHelpA");
2219 hwnd = ole_show_help(helpfile, helpcontext);
2235fole_s_get_code_page(
VALUE self)
2241installed_code_page_proc(LPTSTR
str) {
2243 g_cp_installed =
TRUE;
2250code_page_installed(UINT cp)
2252 g_cp_installed =
FALSE;
2254 EnumSystemCodePages(installed_code_page_proc, CP_INSTALLED);
2255 return g_cp_installed;
2275 set_ole_codepage(cp);
2292fole_s_get_locale(
VALUE self)
2298CALLBACK installed_lcid_proc(LPTSTR
str)
2300 if (
strcmp(
str, g_lcid_to_check) == 0) {
2301 g_lcid_installed =
TRUE;
2308lcid_installed(LCID
lcid)
2310 g_lcid_installed =
FALSE;
2311 snprintf(g_lcid_to_check,
sizeof(g_lcid_to_check),
"%08lx", (
unsigned long)
lcid);
2312 EnumSystemLocales(installed_lcid_proc, LCID_INSTALLED);
2313 return g_lcid_installed;
2330 if (lcid_installed(
lcid)) {
2334 case LOCALE_SYSTEM_DEFAULT:
2335 case LOCALE_USER_DEFAULT:
2353fole_s_create_guid(
VALUE self)
2359 hr = CoCreateGuid(&guid);
2363 len = StringFromGUID2(&guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
2378fole_s_ole_initialize(
VALUE self)
2386fole_s_ole_uninitialize(
VALUE self)
2468 IClassFactory2 * pIClassFactory2;
2470 static ID keyword_ids[1];
2479 return ole_create_dcom(
self, svr_name, host, others);
2484 hr = CLSIDFromProgID(pBuf, &clsid);
2486 hr = CLSIDFromString(pBuf, &clsid);
2488 SysFreeString(pBuf);
2491 "unknown OLE server: `%s'",
2495 if (!keyword_ids[0]) {
2500 if (kwargs[0] ==
Qundef) {
2502 hr = CoCreateInstance(
2505 CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
2510 hr = CoGetClassObject(
2512 CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
2514 &IID_IClassFactory2,
2515 (LPVOID)&pIClassFactory2
2519 hr = pIClassFactory2->lpVtbl->CreateInstanceLic(pIClassFactory2,
NULL,
NULL, &IID_IDispatch, key_buf, &p);
2520 SysFreeString(key_buf);
2527 "failed to create WIN32OLE object from `%s'",
2551 VariantClear(&(pOp->
dp.rgvarg[
i]));
2563 VariantInit(&(pOp->
dp.rgvarg[
index]));
2566 pOp->
dp.cNamedArgs += 1;
2571set_argv(VARIANTARG* realargs,
unsigned int beg,
unsigned int end)
2577 while (end-- > beg) {
2579 if (V_VT(&realargs[end]) != VT_RECORD) {
2580 VariantClear(&realargs[end]);
2602 EXCEPINFO excepinfo;
2604 VARIANTARG* realargs =
NULL;
2605 unsigned int argErr = 0;
2607 unsigned int cNamedArgs;
2610 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
2612 VariantInit(&result);
2614 op.dp.rgvarg =
NULL;
2615 op.dp.rgdispidNamedArgs =
NULL;
2616 op.dp.cNamedArgs = 0;
2631 DispID = DISPID_VALUE;
2637 &wcmdname, 1,
lcid, &DispID);
2638 SysFreeString(wcmdname);
2647 op.dp.cNamedArgs = 0;
2655 op.dp.cArgs = cNamedArgs +
argc - 2;
2656 op.pNamedArgs =
ALLOCA_N(OLECHAR*, cNamedArgs + 1);
2657 op.dp.rgvarg =
ALLOCA_N(VARIANTARG, op.dp.cArgs);
2661 pDispID =
ALLOCA_N(DISPID, cNamedArgs + 1);
2666 op.dp.cNamedArgs + 1,
2668 for(
i = 0;
i < op.dp.cNamedArgs + 1;
i++) {
2669 SysFreeString(op.pNamedArgs[
i]);
2670 op.pNamedArgs[
i] =
NULL;
2674 for(
i = 0;
i < op.dp.cArgs;
i++ ) {
2675 VariantClear(&op.dp.rgvarg[
i]);
2678 "failed to get named argument info: `%s'",
2681 op.dp.rgdispidNamedArgs = &(pDispID[1]);
2685 op.dp.cArgs =
argc - 1;
2686 op.pNamedArgs =
ALLOCA_N(OLECHAR*, cNamedArgs + 1);
2687 if (op.dp.cArgs > 0) {
2688 op.dp.rgvarg =
ALLOCA_N(VARIANTARG, op.dp.cArgs);
2694 if(op.dp.cArgs > cNamedArgs) {
2695 realargs =
ALLOCA_N(VARIANTARG, op.dp.cArgs-cNamedArgs+1);
2696 for(
i = cNamedArgs;
i < op.dp.cArgs;
i++) {
2697 n = op.dp.cArgs -
i + cNamedArgs - 1;
2698 VariantInit(&realargs[
n]);
2699 VariantInit(&op.dp.rgvarg[
n]);
2705 op.dp.rgvarg[
n] = realargs[
n];
2706 V_VT(&op.dp.rgvarg[
n]) = VT_RECORD | VT_BYREF;
2709 V_VT(&op.dp.rgvarg[
n]) = VT_VARIANT | VT_BYREF;
2710 V_VARIANTREF(&op.dp.rgvarg[
n]) = &realargs[
n];
2715 if (
wFlags & DISPATCH_PROPERTYPUT) {
2716 if (op.dp.cArgs == 0)
2719 op.dp.cNamedArgs = 1;
2720 op.dp.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
2721 op.dp.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
2725 &result, &excepinfo, &argErr);
2729 if(op.dp.cArgs >= cNamedArgs) {
2730 for(
i = cNamedArgs;
i < op.dp.cArgs;
i++) {
2731 n = op.dp.cArgs -
i + cNamedArgs - 1;
2735 if (hr == DISP_E_EXCEPTION) {
2736 ole_freeexceptinfo(&excepinfo);
2738 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
2739 VariantInit(&result);
2743 &excepinfo, &argErr);
2749 if ((hr == DISP_E_EXCEPTION || hr == DISP_E_MEMBERNOTFOUND) && DispID > 0x8000) {
2750 if (hr == DISP_E_EXCEPTION) {
2751 ole_freeexceptinfo(&excepinfo);
2753 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
2757 &excepinfo, &argErr);
2760 for(
i = cNamedArgs;
i < op.dp.cArgs;
i++) {
2761 n = op.dp.cArgs -
i + cNamedArgs - 1;
2762 if (V_VT(&op.dp.rgvarg[
n]) != VT_RECORD) {
2763 VariantClear(&op.dp.rgvarg[
n]);
2770 if (op.dp.cArgs > cNamedArgs) {
2771 for(
i = cNamedArgs;
i < op.dp.cArgs;
i++) {
2772 n = op.dp.cArgs -
i + cNamedArgs - 1;
2776 if (hr == DISP_E_EXCEPTION) {
2777 ole_freeexceptinfo(&excepinfo);
2779 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
2780 VariantInit(&result);
2784 &excepinfo, &argErr);
2785 for(
i = cNamedArgs;
i < op.dp.cArgs;
i++) {
2786 n = op.dp.cArgs -
i + cNamedArgs - 1;
2787 if (V_VT(&op.dp.rgvarg[
n]) != VT_RECORD) {
2788 VariantClear(&op.dp.rgvarg[
n]);
2796 if(op.dp.cArgs > cNamedArgs) {
2797 for(
i = cNamedArgs;
i < op.dp.cArgs;
i++) {
2798 n = op.dp.cArgs -
i + cNamedArgs - 1;
2803 V_VT(&realargs[
n]) == VT_RECORD ) {
2807 set_argv(realargs, cNamedArgs, op.dp.cArgs);
2810 for(
i = 0;
i < op.dp.cArgs;
i++) {
2811 VariantClear(&op.dp.rgvarg[
i]);
2816 v = ole_excepinfo2msg(&excepinfo);
2822 VariantClear(&result);
2854 unsigned int argErr = 0;
2855 EXCEPINFO excepinfo;
2857 DISPPARAMS dispParams;
2858 VARIANTARG* realargs =
NULL;
2867 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
2868 memset(&dispParams, 0,
sizeof(DISPPARAMS));
2869 VariantInit(&result);
2873 dispParams.rgvarg =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
2874 realargs =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
2875 for (
i = 0, j = dispParams.cArgs - 1;
i < (
int)dispParams.cArgs;
i++, j--)
2877 VariantInit(&realargs[
i]);
2878 VariantInit(&dispParams.rgvarg[
i]);
2881 V_VT(&dispParams.rgvarg[
i]) = vt;
2886 V_VT(&dispParams.rgvarg[
i]) = V_VT(&realargs[
i]) = VT_ERROR;
2887 V_ERROR(&dispParams.rgvarg[
i]) = V_ERROR(&realargs[
i]) = DISP_E_PARAMNOTFOUND;
2900 SAFEARRAYBOUND rgsabound[1];
2902 rgsabound[0].lLbound = 0;
2904 v = vt & ~(VT_ARRAY | VT_BYREF);
2905 V_ARRAY(&realargs[
i]) = SafeArrayCreate(
v, 1, rgsabound);
2906 V_VT(&realargs[
i]) = VT_ARRAY |
v;
2907 SafeArrayLock(V_ARRAY(&realargs[
i]));
2908 pb = V_ARRAY(&realargs[
i])->pvData;
2909 ps = V_ARRAY(&realargs[
i])->pvData;
2910 pl = V_ARRAY(&realargs[
i])->pvData;
2911 py = V_ARRAY(&realargs[
i])->pvData;
2912 pv = V_ARRAY(&realargs[
i])->pvData;
2913 for (ent = 0; ent < (
int)rgsabound[0].cElements; ent++)
2918 if (
v != VT_VARIANT)
2920 VariantChangeTypeEx(&velem, &velem,
2933 *py++ = V_CY(&velem);
2939 *ps++ = V_I2(&velem);
2944 *pb++ = V_UI1(&velem);
2948 *pl++ = V_I4(&velem);
2952 SafeArrayUnlock(V_ARRAY(&realargs[
i]));
2957 if ((vt & (~VT_BYREF)) != VT_VARIANT)
2959 hr = VariantChangeTypeEx(&realargs[
i], &realargs[
i],
2961 (VARTYPE)(vt & (~VT_BYREF)));
2968 if ((vt & VT_BYREF) || vt == VT_VARIANT)
2970 if (vt == VT_VARIANT)
2971 V_VT(&dispParams.rgvarg[
i]) = VT_VARIANT | VT_BYREF;
2972 switch (vt & (~VT_BYREF))
2976 V_VARIANTREF(&dispParams.rgvarg[
i]) = &realargs[
i];
2982 V_CYREF(&dispParams.rgvarg[
i]) = &V_CY(&realargs[
i]);
2988 V_I2REF(&dispParams.rgvarg[
i]) = &V_I2(&realargs[
i]);
2993 V_UI1REF(&dispParams.rgvarg[
i]) = &V_UI1(&realargs[
i]);
2997 V_I4REF(&dispParams.rgvarg[
i]) = &V_I4(&realargs[
i]);
3004 V_CY(&dispParams.rgvarg[
i]) = V_CY(&realargs[
i]);
3009 if (dispkind & DISPATCH_PROPERTYPUT) {
3010 dispParams.cNamedArgs = 1;
3011 dispParams.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
3012 dispParams.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
3018 &dispParams, &result,
3019 &excepinfo, &argErr);
3022 v = ole_excepinfo2msg(&excepinfo);
3029 if(dispParams.cArgs > 0) {
3030 set_argv(realargs, 0, dispParams.cArgs);
3034 VariantClear(&result);
3053 return ole_invoke2(
self, dispid, args,
types, DISPATCH_METHOD);
3071 return ole_invoke2(
self, dispid, args,
types, DISPATCH_PROPERTYGET);
3089 return ole_invoke2(
self, dispid, args,
types, DISPATCH_PROPERTYPUT);
3176 EXCEPINFO excepinfo;
3177 DISPID dispID = DISPID_VALUE;
3178 DISPID dispIDParam = DISPID_PROPERTYPUT;
3179 USHORT
wFlags = DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF;
3180 DISPPARAMS dispParams;
3181 VARIANTARG propertyValue[2];
3185 dispParams.rgdispidNamedArgs = &dispIDParam;
3186 dispParams.rgvarg = propertyValue;
3187 dispParams.cNamedArgs = 1;
3188 dispParams.cArgs = 1;
3190 VariantInit(&propertyValue[0]);
3191 VariantInit(&propertyValue[1]);
3192 memset(&excepinfo, 0,
sizeof(excepinfo));
3199 pBuf, 1,
lcid, &dispID);
3200 SysFreeString(pBuf[0]);
3205 "unknown property or method: `%s'",
3212 NULL, &excepinfo, &argErr);
3215 VariantClear(&propertyValue[
index]);
3218 v = ole_excepinfo2msg(&excepinfo);
3236fole_free(
VALUE self)
3246ole_each_sub(
VALUE pEnumV)
3250 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
3251 VariantInit(&variant);
3252 while(pEnum->lpVtbl->Next(pEnum, 1, &variant,
NULL) == S_OK) {
3254 VariantClear(&variant);
3255 VariantInit(&variant);
3262ole_ienum_free(
VALUE pEnumV)
3264 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
3284fole_each(
VALUE self)
3290 unsigned int argErr;
3291 EXCEPINFO excepinfo;
3292 DISPPARAMS dispParams;
3295 IEnumVARIANT *pEnum =
NULL;
3300 VariantInit(&result);
3301 dispParams.rgvarg =
NULL;
3302 dispParams.rgdispidNamedArgs =
NULL;
3303 dispParams.cNamedArgs = 0;
3304 dispParams.cArgs = 0;
3305 memset(&excepinfo, 0,
sizeof(excepinfo));
3310 DISPATCH_METHOD | DISPATCH_PROPERTYGET,
3311 &dispParams, &result,
3312 &excepinfo, &argErr);
3315 VariantClear(&result);
3319 if (V_VT(&result) == VT_UNKNOWN) {
3320 hr = V_UNKNOWN(&result)->lpVtbl->QueryInterface(V_UNKNOWN(&result),
3324 }
else if (V_VT(&result) == VT_DISPATCH) {
3325 hr = V_DISPATCH(&result)->lpVtbl->QueryInterface(V_DISPATCH(&result),
3330 if (FAILED(hr) || !pEnum) {
3331 VariantClear(&result);
3335 VariantClear(&result);
3353 mid = org_mid =
argv[0];
3361 if(mname[
n-1] ==
'=') {
3365 return ole_propertyput(
self,
argv[0],
argv[1]);
3369 v = ole_invoke(
argc,
argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
3379typeinfo_from_ole(
struct oledata *pole, ITypeInfo **ppti)
3381 ITypeInfo *pTypeInfo;
3389 0,
lcid, &pTypeInfo);
3393 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo,
3398 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &
i);
3403 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
3405 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib,
i,
3408 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib,
i, &pTypeInfo);
3409 if (SUCCEEDED(hr)) {
3422 ITypeInfo *pTypeInfo;
3430 hr = typeinfo_from_ole(pole, &pTypeInfo);
3450fole_methods(
VALUE self)
3452 return ole_methods(
self, INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF);
3466fole_get_methods(
VALUE self)
3468 return ole_methods(
self, INVOKE_PROPERTYGET);
3482fole_put_methods(
VALUE self)
3484 return ole_methods(
self, INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF);
3499fole_func_methods(
VALUE self)
3501 return ole_methods(
self, INVOKE_FUNC);
3514fole_type(
VALUE self)
3516 ITypeInfo *pTypeInfo;
3548fole_typelib(
VALUE self)
3552 ITypeInfo *pTypeInfo;
3558 0,
lcid, &pTypeInfo);
3564 if (vtlib ==
Qnil) {
3581fole_query_interface(
VALUE self,
VALUE str_iid)
3591 hr = CLSIDFromString(pBuf, &iid);
3592 SysFreeString(pBuf);
3595 "invalid iid: `%s'",
3608 "failed to get interface `%s'",
3642 SysFreeString(wcmdname);
3653 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &
i);
3658 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib,
i,
3660 helpcontext, helpfile);
3670ole_usertype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc,
VALUE typedetails)
3674 ITypeInfo *pRefTypeInfo;
3677 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
3689 if(typedetails !=
Qnil)
3695ole_ptrtype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc,
VALUE typedetails)
3697 TYPEDESC *p = pTypeDesc;
3700 if (p->vt == VT_PTR || p->vt == VT_SAFEARRAY) {
3712 switch(pTypeDesc->vt) {
3755#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
3777 if(typedetails !=
Qnil)
3779 return ole_ptrtype2val(pTypeInfo, pTypeDesc, typedetails);
3782 if(typedetails !=
Qnil)
3784 return ole_ptrtype2val(pTypeInfo, pTypeDesc, typedetails);
3788 case VT_USERDEFINED:
3790 if (typedetails !=
Qnil)
3792 str = ole_usertype2val(pTypeInfo, pTypeDesc, typedetails);
3820 if (typedetails !=
Qnil)
3839 ITypeInfo *pTypeInfo;
3846 hr = typeinfo_from_ole(pole, &pTypeInfo);
3880fole_activex_initialize(
VALUE self)
3883 IPersistMemory *pPersistMemory;
3890 hr = pole->
pDispatch->lpVtbl->QueryInterface(pole->
pDispatch, &IID_IPersistMemory, &p);
3892 if (SUCCEEDED(hr)) {
3893 hr = pPersistMemory->lpVtbl->InitNew(pPersistMemory);
3895 if (SUCCEEDED(hr)) {
3914 ITypeInfo *pTypeInfo;
3917 0,
lcid, &pTypeInfo);
3921 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, pTypeLib, &
index);
3927com_hash_free(
void *
ptr)
3934com_hash_mark(
void *
ptr)
3941com_hash_size(
const void *
ptr)
3948check_nano_server(
void)
3952 const char * subkey =
"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Server\\ServerLevels";
3953 const char * regval =
"NanoServer";
3955 err = RegOpenKeyEx(HKEY_LOCAL_MACHINE, subkey, 0, KEY_READ, &hsubkey);
3956 if (
err == ERROR_SUCCESS) {
3958 if (
err == ERROR_SUCCESS) {
3959 g_running_nano =
TRUE;
3961 RegCloseKey(hsubkey);
3972 check_nano_server();
3974 com_vtbl.QueryInterface = QueryInterface;
3975 com_vtbl.AddRef = AddRef;
3976 com_vtbl.Release = Release;
3977 com_vtbl.GetTypeInfoCount = GetTypeInfoCount;
3978 com_vtbl.GetTypeInfo = GetTypeInfo;
3979 com_vtbl.GetIDsOfNames = GetIDsOfNames;
3980 com_vtbl.Invoke = Invoke;
3982 message_filter.QueryInterface = mf_QueryInterface;
3983 message_filter.AddRef = mf_AddRef;
3984 message_filter.Release = mf_Release;
3985 message_filter.HandleInComingCall = mf_HandleInComingCall;
3986 message_filter.RetryRejectedCall = mf_RetryRejectedCall;
3987 message_filter.MessagePending = mf_MessagePending;
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
rb_encoding * rb_enc_from_index(int index)
rb_encoding * rb_default_internal_encoding(void)
rb_encoding * rb_enc_get(VALUE obj)
int rb_define_dummy_encoding(const char *name)
rb_encoding * rb_default_external_encoding(void)
int rb_enc_find_index(const char *name)
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
ID rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
char str[HTML_ESCAPE_MAX_LEN+1]
VALUE rb_define_class(const char *, VALUE)
Defines a top-level class.
void rb_define_alias(VALUE, const char *, const char *)
Defines an alias of a method.
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *)
VALUE rb_cObject
Object class.
void rb_raise(VALUE exc, const char *fmt,...)
VALUE rb_ensure(VALUE(*)(VALUE), VALUE, VALUE(*)(VALUE), VALUE)
An equivalent to ensure clause.
VALUE rb_obj_is_kind_of(VALUE, VALUE)
Determines if obj is a kind of c.
VALUE type(ANYARGS)
ANYARGS-ed function type.
unsigned char buf[MIME_BUF_SIZE]
void st_free_table(st_table *tab)
size_t st_memsize(const st_table *tab)
int st_delete(st_table *tab, st_data_t *key, st_data_t *value)
st_table * st_init_numtable(void)
int st_insert(st_table *tab, st_data_t key, st_data_t value)
int st_lookup(st_table *tab, st_data_t key, st_data_t *value)
char CodePageName[MAX_PATH]
int rb_is_const_id(ID id)
HRESULT ole_docinfo_from_type(ITypeInfo *pTypeInfo, BSTR *name, BSTR *helpstr, DWORD *helpcontext, BSTR *helpfile)
LPWSTR ole_vstr2wc(VALUE vstr)
VALUE ole_typedesc2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails)
VALUE reg_get_val2(HKEY hkey, const char *subkey)
HRESULT ole_val_ary2variant_ary(VALUE val, VARIANT *var, VARTYPE vt)
LONG reg_open_key(HKEY hkey, const char *name, HKEY *phkey)
IUnknown COSERVERINFO MULTI_QI *typedef LPCSTR pszFile
static DISPID dispIdMember
typedef HRESULT(STDAPICALLTYPE FNCOCREATEINSTANCEEX)(REFCLSID
VALUE ole_wc2vstr(LPWSTR pw, BOOL isfree)
void ole_uninitialize(void)
BOOL() FNENUMSYSEMCODEPAGES(CODEPAGE_ENUMPROC, DWORD)
static DWORD HTASK threadIDCaller
void ole_val2variant_ex(VALUE val, VARIANT *var, VARTYPE vt)
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR VARIANT __RPC_FAR * pVarResult
#define load_conv_function51932()
static DISPID REFIID LCID WORD wFlags
VALUE default_inspect(VALUE self, const char *class_name)
#define ENC_MACHING_CP(enc, encname, cp)
VALUE ole_variant2val(VARIANT *pvar)
void ole_val2variant2(VALUE val, VARIANT *var)
IUnknown COSERVERINFO MULTI_QI *typedef LPCSTR UINT uCommand
#define g_ole_initialized
static HTASK threadIDCallee
IUnknown COSERVERINFO MULTI_QI *typedef HWND(WINAPI FNHTMLHELP)(HWND hwndCaller
static HTASK DWORD DWORD dwPendingType
static DWORD HTASK DWORD LPINTERFACEINFO lpInterfaceInfo
static REFIID LPOLESTR __RPC_FAR * rgszNames
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR VARIANT __RPC_FAR EXCEPINFO __RPC_FAR * pExcepInfo
static UINT LCID ITypeInfo __RPC_FAR *__RPC_FAR * ppTInfo
VALUE reg_get_val(HKEY hkey, const char *subkey)
BOOL ole_initialized(void)
#define g_ole_initialized_init()
static REFIID void __RPC_FAR *__RPC_FAR * ppvObject
void ole_initialize(void)
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR VARIANT __RPC_FAR EXCEPINFO __RPC_FAR UINT __RPC_FAR * puArgErr
static REFIID LPOLESTR __RPC_FAR UINT LCID DISPID __RPC_FAR * rgDispId
IUnknown COSERVERINFO MULTI_QI *typedef LPCSTR UINT DWORD dwData
VOID * val2variant_ptr(VALUE val, VARIANT *var, VARTYPE vt)
static HTASK DWORD DWORD dwRejectType
static UINT __RPC_FAR * pctinfo
#define ole_wc2mb_conv(pw, pm, size)
static REFIID LPOLESTR __RPC_FAR UINT cNames
VALUE make_inspect(const char *class_name, VALUE detail)
char * ole_wc2mb(LPWSTR pw)
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR * pDispParams
void ole_val2variant(VALUE val, VARIANT *var)
LONG reg_open_vkey(HKEY hkey, VALUE key, HKEY *phkey)
struct _Win32OLEIDispatch Win32OLEIDispatch
static DWORD HTASK DWORD dwTickCount
VALUE reg_enum_key(HKEY hkey, DWORD i)
HRESULT typelib_from_val(VALUE obj, ITypeLib **pTypeLib)
NORETURN(static void failed_load_conv51932(void))
struct oledata * oledata_get_struct(VALUE ole)
#define g_ole_initialized_set(val)
#define OLE_GET_TYPEATTR(X, Y)
VALUE eWIN32OLERuntimeError
VALUE eWIN32OLEQueryInterfaceError
void Init_win32ole_error(void)
void ole_raise(HRESULT hr, VALUE ecs, const char *fmt,...)
void Init_win32ole_event(void)
VALUE ole_methods_from_typeinfo(ITypeInfo *pTypeInfo, int mask)
VALUE create_win32ole_method(ITypeInfo *pTypeInfo, VALUE name)
void Init_win32ole_method(void)
void Init_win32ole_param(void)
void Init_win32ole_record(void)
void ole_rec2variant(VALUE rec, VARIANT *var)
void olerecord_set_ivar(VALUE obj, IRecordInfo *pri, void *prec)
VALUE create_win32ole_record(IRecordInfo *pri, void *prec)
VALUE ole_type_from_itypeinfo(ITypeInfo *pTypeInfo)
void Init_win32ole_type(void)
VALUE ole_typelib_from_itypeinfo(ITypeInfo *pTypeInfo)
void Init_win32ole_typelib(void)
VALUE typelib_file(VALUE ole)
void Init_win32ole_variable(void)
void ole_variant2variant(VALUE val, VARIANT *var)
void Init_win32ole_variant(void)
void Init_win32ole_variant_m(void)