24 #if defined(__CYGWIN__) || defined(__MINGW32__) 25 #undef IID_IMultiLanguage2 26 const IID IID_IMultiLanguage2 = {0xDCCFC164, 0x2B38, 0x11d2, {0xB7, 0xEC, 0x00, 0xC0, 0x4F, 0x8F, 0x5D, 0x9A}};
29 #define WIN32OLE_VERSION "1.8.5" 31 typedef HRESULT (STDAPICALLTYPE FNCOCREATEINSTANCEEX)
32 (REFCLSID, IUnknown*,
DWORD, COSERVERINFO*,
DWORD, MULTI_QI*);
39 #if defined(RB_THREAD_SPECIFIC) && (defined(__CYGWIN__)) 41 # define g_ole_initialized_init() ((void)0) 42 # define g_ole_initialized_set(val) (g_ole_initialized = (val)) 45 # define g_ole_initialized (TlsGetValue(g_ole_initialized_key)!=0) 46 # define g_ole_initialized_init() (g_ole_initialized_key = TlsAlloc()) 47 # define g_ole_initialized_set(val) TlsSetValue(g_ole_initialized_key, (void*)(val)) 68 #if defined(HAVE_TYPE_IMULTILANGUAGE2) 70 #elif defined(HAVE_TYPE_IMULTILANGUAGE) 73 #define pIMultiLanguage NULL 81 static HRESULT ( STDMETHODCALLTYPE QueryInterface )(IDispatch __RPC_FAR *, REFIID
riid,
void __RPC_FAR *__RPC_FAR *
ppvObject);
82 static ULONG ( STDMETHODCALLTYPE AddRef )(IDispatch __RPC_FAR * This);
83 static ULONG ( STDMETHODCALLTYPE Release )(IDispatch __RPC_FAR * This);
84 static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(IDispatch __RPC_FAR * This, UINT __RPC_FAR *
pctinfo);
85 static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(IDispatch __RPC_FAR * This, UINT
iTInfo, LCID
lcid, ITypeInfo __RPC_FAR *__RPC_FAR *
ppTInfo);
94 #ifndef pIMultiLanguage 101 static size_t ole_size(
const void *ptr);
138 static VALUE set_argv(VARIANTARG* realargs,
unsigned int beg,
unsigned int end);
182 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
185 static HRESULT (STDMETHODCALLTYPE mf_QueryInterface)(
186 IMessageFilter __RPC_FAR * This,
190 if (
MEMCMP(riid, &IID_IUnknown, GUID, 1) == 0
191 ||
MEMCMP(riid, &IID_IMessageFilter, GUID, 1) == 0)
196 return E_NOINTERFACE;
199 static ULONG (STDMETHODCALLTYPE mf_AddRef)(
200 IMessageFilter __RPC_FAR * This)
205 static ULONG (STDMETHODCALLTYPE mf_Release)(
206 IMessageFilter __RPC_FAR * This)
211 static DWORD (STDMETHODCALLTYPE mf_HandleInComingCall)(
212 IMessageFilter __RPC_FAR * pThis,
219 #ifdef DEBUG_MESSAGEFILTER 220 printf(
"incoming %08X, %08X, %d\n", dwCallType, threadIDCaller, dwTickCount);
226 case CALLTYPE_TOPLEVEL_CALLPENDING:
227 case CALLTYPE_ASYNC_CALLPENDING:
229 return SERVERCALL_RETRYLATER;
242 return SERVERCALL_ISHANDLED;
245 static DWORD (STDMETHODCALLTYPE mf_RetryRejectedCall)(
246 IMessageFilter* pThis,
261 static DWORD (STDMETHODCALLTYPE mf_MessagePending)(
262 IMessageFilter* pThis,
269 return PENDINGMSG_WAITNOPROCESS;
277 return PENDINGMSG_WAITNOPROCESS;
287 static HRESULT ( STDMETHODCALLTYPE QueryInterface )(
288 IDispatch __RPC_FAR * This,
292 if (
MEMCMP(riid, &IID_IUnknown, GUID, 1) == 0
293 ||
MEMCMP(riid, &IID_IDispatch, GUID, 1) == 0)
300 return E_NOINTERFACE;
303 static ULONG ( STDMETHODCALLTYPE AddRef )(
304 IDispatch __RPC_FAR * This)
310 static ULONG ( STDMETHODCALLTYPE Release )(
311 IDispatch __RPC_FAR * This)
323 static HRESULT ( STDMETHODCALLTYPE GetTypeInfoCount )(
324 IDispatch __RPC_FAR * This,
330 static HRESULT ( STDMETHODCALLTYPE GetTypeInfo )(
331 IDispatch __RPC_FAR * This,
334 ITypeInfo __RPC_FAR *__RPC_FAR *
ppTInfo)
340 static HRESULT ( STDMETHODCALLTYPE GetIDsOfNames )(
341 IDispatch __RPC_FAR * This,
354 if ((
ID)(DISPID)nameid != nameid)
return E_NOINTERFACE;
359 static HRESULT ( STDMETHODCALLTYPE Invoke )(
360 IDispatch __RPC_FAR * This,
372 int args = pDispParams->cArgs;
375 ID mid = (
ID)dispIdMember;
376 for (i = 0; i < args; i++) {
379 if (dispIdMember == DISPID_VALUE) {
380 if (wFlags == DISPATCH_METHOD) {
382 }
else if (wFlags & DISPATCH_PROPERTYGET) {
430 st.wMilliseconds = 0;
431 SystemTimeToVariantTime(&st, &t);
440 nsec /= (24.0 * 3600.0);
452 VariantTimeToSystemTime(date, &st);
466 st.wMilliseconds = 0;
467 SystemTimeToVariantTime(&st, &sec);
486 #define ENC_MACHING_CP(enc,encname,cp) if(strcasecmp(rb_enc_name((enc)),(encname)) == 0) return cp 559 #ifndef pIMultiLanguage 566 #if defined(HAVE_TYPE_IMULTILANGUAGE2) 567 hr = CoCreateInstance(&CLSID_CMultiLanguage,
NULL, CLSCTX_INPROC_SERVER,
568 &IID_IMultiLanguage2, &p);
569 #elif defined(HAVE_TYPE_IMULTILANGUAGE) 570 hr = CoCreateInstance(&CLSID_CMultiLanguage,
NULL, CLSCTX_INPROC_SERVER,
571 &IID_IMultiLanguage, &p);
579 #define need_conv_function51932() (load_conv_function51932(), 1) 581 #define load_conv_function51932() failed_load_conv51932() 582 #define need_conv_function51932() (failed_load_conv51932(), 0) 585 #define conv_51932(cp) ((cp) == 51932 && need_conv_function51932()) 608 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.");
636 char CodePageName[MAX_PATH];
660 GetProcAddress(GetModuleHandle(
"kernel32"),
"GetCPInfoEx");
662 pGetCPInfoEx = (
void*)-1;
667 if (pGetCPInfoEx == (
void*)-1 || !pGetCPInfoEx(cp, 0, buf)) {
681 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.");
693 #ifndef pIMultiLanguage 695 ole_ml_wc2mb_conv0(LPWSTR pw, LPSTR pm, UINT *
size)
701 #define ole_ml_wc2mb_conv(pw, pm, size, onfailure) do { \ 702 HRESULT hr = ole_ml_wc2mb_conv0(pw, pm, &size); \ 705 ole_raise(hr, eWIN32OLERuntimeError, "fail to convert Unicode to CP%d", cWIN32OLE_cp); \ 710 #define ole_wc2mb_conv(pw, pm, size) WideCharToMultiByte(cWIN32OLE_cp, 0, (pw), -1, (pm), (size), NULL, NULL) 718 #ifndef pIMultiLanguage 719 ole_ml_wc2mb_conv(pw,
NULL, size, {});
720 pm = alloc(size, arg);
721 if (size) ole_ml_wc2mb_conv(pw, pm, size,
xfree(pm));
727 pm = alloc(size, arg);
736 return ALLOC_N(
char, size + 1);
748 SysFreeString(pExInfo->bstrDescription);
749 SysFreeString(pExInfo->bstrSource);
750 SysFreeString(pExInfo->bstrHelpFile);
757 char *pSource =
NULL;
758 char *pDescription =
NULL;
760 if(pExInfo->pfnDeferredFillIn !=
NULL) {
761 (*pExInfo->pfnDeferredFillIn)(pExInfo);
763 if (pExInfo->bstrSource !=
NULL) {
764 pSource =
ole_wc2mb(pExInfo->bstrSource);
766 if (pExInfo->bstrDescription !=
NULL) {
767 pDescription =
ole_wc2mb(pExInfo->bstrDescription);
769 if(pExInfo->wCode == 0) {
770 sprintf(error_code,
"\n OLE error code:%lX in ", (
unsigned long)pExInfo->scode);
773 sprintf(error_code,
"\n OLE error code:%u in ", pExInfo->wCode);
776 if(pSource !=
NULL) {
783 if(pDescription !=
NULL) {
789 if(pSource)
free(pSource);
790 if(pDescription)
free(pDescription);
820 hr = OleInitialize(
NULL);
844 return ptr ?
sizeof(
struct oledata) : 0;
881 cp == CP_THREAD_ACP ||
903 #ifndef pIMultiLanguage 907 &dw, cp, pm, &n,
NULL, &size);
911 pw = SysAllocStringLen(
NULL, size);
914 &dw, cp, pm, &n, pw, &size);
921 size = MultiByteToWideChar(cp, 0, pm, len,
NULL, 0);
922 pw = SysAllocStringLen(
NULL, size);
924 MultiByteToWideChar(cp, 0, pm, len, pw, size);
964 for (i = 0; i < dim; i++) {
965 if (pid[i] > pub[i]) {
976 if (vt == VT_VARIANT) {
979 V_VT(var) = (vt & ~VT_BYREF);
980 if (V_VT(var) == VT_DISPATCH) {
981 V_DISPATCH(var) =
NULL;
982 }
else if (V_VT(var) == VT_UNKNOWN) {
983 V_UNKNOWN(var) =
NULL;
988 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__) 989 switch(vt & ~VT_BYREF) {
1013 if ((vt & ~VT_BYREF) == VT_VARIANT) {
1016 if ( (vt & ~VT_BYREF) != V_VT(var)) {
1017 hr = VariantChangeTypeEx(var, var,
1034 switch(V_VT(pvar)) {
1036 return &V_UI1(pvar);
1042 return &V_UI2(pvar);
1048 return &V_UI4(pvar);
1056 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__) 1061 return &V_UI8(pvar);
1065 return &
V_INT(pvar);
1074 return &V_DATE(pvar);
1077 return V_BSTR(pvar);
1080 return V_DISPATCH(pvar);
1083 return &V_ERROR(pvar);
1086 return &V_BOOL(pvar);
1089 return V_UNKNOWN(pvar);
1092 return &V_ARRAY(pvar);
1113 if ((V_VT(&var) == VT_DISPATCH && V_DISPATCH(&var) ==
NULL) ||
1114 (V_VT(&var) == VT_UNKNOWN && V_UNKNOWN(&var) ==
NULL)) {
1117 hr = SafeArrayPutElement(psa, pid, p);
1123 if (pid[i] > pub[i]) {
1140 for (i = 0; i <
len; i++) {
1165 for (i = 0; i <
len; i++) {
1168 if (ary_len < ary_len1) {
1184 SAFEARRAYBOUND *psab =
NULL;
1185 SAFEARRAY *psa =
NULL;
1193 psab =
ALLOC_N(SAFEARRAYBOUND, dim);
1197 if(!psab || !pub || !pid) {
1199 if(psab)
free(psab);
1204 for (i = 0; i < dim; i++) {
1206 psab[i].lLbound = 0;
1207 pub[i] = psab[i].cElements - 1;
1211 if ((vt & ~VT_BYREF) == VT_ARRAY) {
1212 vt = (vt | VT_VARIANT);
1214 psa = SafeArrayCreate((VARTYPE)(vt & VT_TYPEMASK), dim, psab);
1218 hr = SafeArrayLock(psa);
1219 if (SUCCEEDED(hr)) {
1221 hr = SafeArrayUnlock(psa);
1225 if(psab)
free(psab);
1228 if (SUCCEEDED(hr)) {
1234 SafeArrayDestroy(psa);
1246 V_VT(var) = VT_DISPATCH;
1259 V_VT(var) = VT_DATE;
1263 switch (
TYPE(val)) {
1268 V_VT(var) = VT_BSTR;
1275 V_I4(var) = (LONG)v;
1277 if (V_I4(var) != v) {
1293 V_VT(var) = VT_BOOL;
1294 V_BOOL(var) = VARIANT_TRUE;
1297 V_VT(var) = VT_BOOL;
1298 V_BOOL(var) = VARIANT_FALSE;
1302 V_VT(var) = VT_ERROR;
1303 V_ERROR(var) = DISP_E_PARAMNOTFOUND;
1305 V_VT(var) = VT_EMPTY;
1309 V_VT(var) = VT_DISPATCH;
1380 long *ids =
ALLOC_N(
long, dim);
1384 for(i = 0; i < dim; i++) {
1385 ids[i] = pid[i] - plb[i];
1389 for(i = 0; i < dim-1; i++) {
1403 long id = pid[dim - 1] - plb[dim - 1];
1412 VARTYPE vt = V_VT(pvar);
1414 while ( vt == (VT_BYREF | VT_VARIANT) ) {
1415 pvar = V_VARIANTREF(pvar);
1419 if(V_ISARRAY(pvar)) {
1420 VARTYPE vt_base = vt & VT_TYPEMASK;
1421 SAFEARRAY *psa = V_ISBYREF(pvar) ? *V_ARRAYREF(pvar) : V_ARRAY(pvar);
1423 LONG *pid, *plb, *pub;
1430 dim = SafeArrayGetDim(psa);
1435 if(!pid || !plb || !pub) {
1442 for(i = 0; i < dim; ++i) {
1443 SafeArrayGetLBound(psa, i+1, &plb[i]);
1444 SafeArrayGetLBound(psa, i+1, &pid[i]);
1445 SafeArrayGetUBound(psa, i+1, &pub[i]);
1447 hr = SafeArrayLock(psa);
1448 if (SUCCEEDED(hr)) {
1451 VariantInit(&variant);
1452 V_VT(&variant) = vt_base | VT_BYREF;
1453 if (vt_base == VT_RECORD) {
1454 hr = SafeArrayGetRecordInfo(psa, &V_RECORDINFO(&variant));
1455 if (SUCCEEDED(hr)) {
1456 V_VT(&variant) = VT_RECORD;
1461 if (vt_base == VT_RECORD)
1462 hr = SafeArrayPtrOfIndex(psa, pid, &V_RECORD(&variant));
1464 hr = SafeArrayPtrOfIndex(psa, pid, &V_BYREF(&variant));
1465 if (SUCCEEDED(hr)) {
1469 for (i = 0; i < dim; ++i) {
1470 if (++pid[i] <= pub[i])
1475 SafeArrayUnlock(psa);
1482 switch(V_VT(pvar) & ~VT_BYREF){
1543 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__) 1546 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__) 1558 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__) 1588 bstr = *V_BSTRREF(pvar);
1590 bstr = V_BSTR(pvar);
1591 obj = (SysStringLen(bstr) == 0)
1605 if (V_ISBYREF(pvar))
1615 if (V_ISBYREF(pvar))
1616 pDispatch = *V_DISPATCHREF(pvar);
1618 pDispatch = V_DISPATCH(pvar);
1620 if (pDispatch !=
NULL ) {
1635 if (V_ISBYREF(pvar))
1636 punk = *V_UNKNOWNREF(pvar);
1638 punk = V_UNKNOWN(pvar);
1641 hr = punk->lpVtbl->QueryInterface(punk, &IID_IDispatch, &p);
1654 date = *V_DATEREF(pvar);
1656 date = V_DATE(pvar);
1664 IRecordInfo *pri = V_RECORDINFO(pvar);
1665 void *prec = V_RECORD(pvar);
1675 VariantInit(&variant);
1676 hr = VariantChangeTypeEx(&variant, pvar,
1678 if (SUCCEEDED(hr) && V_VT(&variant) == VT_BSTR) {
1681 VariantClear(&variant);
1691 return RegOpenKeyEx(hkey, name, 0, KEY_READ, phkey);
1703 char buf[BUFSIZ + 1];
1706 LONG
err = RegEnumKeyEx(hkey, i, buf, &size_buf,
1708 if(err == ERROR_SUCCESS) {
1722 LONG
err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype,
NULL, &size);
1724 if (err == ERROR_SUCCESS) {
1725 pbuf =
ALLOC_N(
char, size + 1);
1726 err = RegQueryValueEx(hkey, subkey,
NULL, &dwtype, (BYTE *)pbuf, &size);
1727 if (err == ERROR_SUCCESS) {
1729 if (dwtype == REG_EXPAND_SZ) {
1730 char* pbuf2 = (
char *)pbuf;
1732 pbuf =
ALLOC_N(
char, len + 1);
1733 ExpandEnvironmentStrings(pbuf2, pbuf, len + 1);
1749 err = RegOpenKeyEx(hkey, subkey, 0, KEY_READ, &hsubkey);
1750 if (err == ERROR_SUCCESS) {
1752 RegCloseKey(hsubkey);
1766 ITypeInfo *pTypeInfo;
1767 TYPEATTR *pTypeAttr;
1777 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
1778 for (index = 0; index <
count; index++) {
1779 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, index, &pTypeInfo);
1787 for(iVar = 0; iVar < pTypeAttr->cVars; iVar++) {
1788 hr = pTypeInfo->lpVtbl->GetVarDesc(pTypeInfo, iVar, &pVarDesc);
1791 if(pVarDesc->varkind == VAR_CONST &&
1792 !(pVarDesc->wVarFlags & (VARFLAG_FHIDDEN |
1793 VARFLAG_FRESTRICTED |
1794 VARFLAG_FNONBROWSABLE))) {
1795 hr = pTypeInfo->lpVtbl->GetNames(pTypeInfo, pVarDesc->memid, &bstr,
1797 if(FAILED(hr) || len == 0 || !bstr)
1801 *pName = toupper((
int)*pName);
1809 SysFreeString(bstr);
1815 pTypeInfo->lpVtbl->ReleaseVarDesc(pTypeInfo, pVarDesc);
1817 pTypeInfo->lpVtbl->ReleaseTypeAttr(pTypeInfo, pTypeAttr);
1835 err = RegConnectRegistry(
StringValuePtr(host), HKEY_LOCAL_MACHINE, &hlm);
1836 if (err != ERROR_SUCCESS)
1837 return HRESULT_FROM_WIN32(err);
1841 err = RegOpenKeyEx(hlm,
StringValuePtr(subkey), 0, KEY_READ, &hpid);
1842 if (err != ERROR_SUCCESS)
1843 hr = HRESULT_FROM_WIN32(err);
1845 len =
sizeof(clsid);
1846 err = RegQueryValueEx(hpid,
"",
NULL, &dwtype, (BYTE *)clsid, &len);
1847 if (err == ERROR_SUCCESS && dwtype == REG_SZ) {
1849 hr = CLSIDFromString(pbuf, pclsid);
1850 SysFreeString(pbuf);
1853 hr = HRESULT_FROM_WIN32(err);
1868 COSERVERINFO serverinfo;
1870 DWORD clsctx = CLSCTX_REMOTE_SERVER;
1873 gole32 = LoadLibrary(
"OLE32");
1878 GetProcAddress(
gole32,
"CoCreateInstanceEx");
1883 hr = CLSIDFromProgID(pbuf, &clsid);
1887 hr = CLSIDFromString(pbuf, &clsid);
1888 SysFreeString(pbuf);
1891 "unknown OLE server: `%s'",
1893 memset(&serverinfo, 0,
sizeof(COSERVERINFO));
1895 memset(&multi_qi, 0,
sizeof(MULTI_QI));
1896 multi_qi.pIID = &IID_IDispatch;
1898 SysFreeString(serverinfo.pwszName);
1901 "failed to create DCOM server `%s' in `%s'",
1922 hr = CreateBindCtx(0, &pBindCtx);
1925 "failed to create bind context");
1929 hr = MkParseDisplayName(pBindCtx, pbuf, &eaten, &pMoniker);
1930 SysFreeString(pbuf);
1934 "failed to parse display name of moniker `%s'",
1937 hr = pMoniker->lpVtbl->BindToObject(pMoniker, pBindCtx,
NULL,
1938 &IID_IDispatch, &p);
1945 "failed to bind moniker `%s'",
1984 hr = CLSIDFromProgID(pBuf, &clsid);
1986 hr = CLSIDFromString(pBuf, &clsid);
1988 SysFreeString(pBuf);
1993 hr = GetActiveObject(&clsid, 0, &pUnknown);
1998 hr = pUnknown->lpVtbl->QueryInterface(pUnknown, &IID_IDispatch, &p);
2003 "failed to create WIN32OLE server `%s'",
2047 ITypeInfo *pTypeInfo;
2064 0, lcid, &pTypeInfo);
2068 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &index);
2088 hr = LoadTypeLibEx(pBuf, REGKIND_NONE, &pTypeLib);
2089 SysFreeString(pBuf);
2159 FNHTMLHELP *pfnHtmlHelp;
2163 ghhctrl = LoadLibrary(
"HHCTRL.OCX");
2166 pfnHtmlHelp = (FNHTMLHELP*)GetProcAddress(
ghhctrl,
"HtmlHelpA");
2233 static BOOL CALLBACK
2327 case LOCALE_SYSTEM_DEFAULT:
2328 case LOCALE_USER_DEFAULT:
2352 hr = CoCreateGuid(&guid);
2356 len = StringFromGUID2(&guid, bstr,
sizeof(bstr)/
sizeof(OLECHAR));
2457 rb_scan_args(argc, argv,
"11*", &svr_name, &host, &others);
2475 hr = CLSIDFromProgID(pBuf, &clsid);
2477 hr = CLSIDFromString(pBuf, &clsid);
2479 SysFreeString(pBuf);
2482 "unknown OLE server: `%s'",
2487 hr = CoCreateInstance(&clsid,
NULL, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
2488 &IID_IDispatch, &p);
2492 "failed to create WIN32OLE object from `%s'",
2504 unsigned int index, i;
2505 index = pOp->
dp.cNamedArgs;
2511 for(i = 1; i < index + 1; i++) {
2515 for(i = 0; i < index; i++ ) {
2516 VariantClear(&(pOp->
dp.rgvarg[i]));
2528 VariantInit(&(pOp->
dp.rgvarg[index]));
2531 pOp->
dp.cNamedArgs += 1;
2536 set_argv(VARIANTARG* realargs,
unsigned int beg,
unsigned int end)
2542 while (end-- > beg) {
2544 if (V_VT(&realargs[end]) != VT_RECORD) {
2545 VariantClear(&realargs[end]);
2567 EXCEPINFO excepinfo;
2569 VARIANTARG* realargs =
NULL;
2570 unsigned int argErr = 0;
2572 unsigned int cNamedArgs;
2575 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
2577 VariantInit(&result);
2580 op.
dp.rgdispidNamedArgs =
NULL;
2581 op.
dp.cNamedArgs = 0;
2596 DispID = DISPID_VALUE;
2602 &wcmdname, 1, lcid, &DispID);
2603 SysFreeString(wcmdname);
2606 "unknown property or method: `%s'",
2614 op.
dp.cNamedArgs = 0;
2622 op.
dp.cArgs = cNamedArgs + argc - 2;
2628 pDispID =
ALLOCA_N(DISPID, cNamedArgs + 1);
2633 op.dp.cNamedArgs + 1,
2635 for(i = 0; i < op.dp.cNamedArgs + 1; i++) {
2636 SysFreeString(op.pNamedArgs[i]);
2637 op.pNamedArgs[i] =
NULL;
2641 for(i = 0; i < op.dp.cArgs; i++ ) {
2642 VariantClear(&op.dp.rgvarg[i]);
2645 "failed to get named argument info: `%s'",
2648 op.dp.rgdispidNamedArgs = &(pDispID[1]);
2652 op.
dp.cArgs = argc - 1;
2654 if (op.
dp.cArgs > 0) {
2661 if(op.
dp.cArgs > cNamedArgs) {
2662 realargs =
ALLOCA_N(VARIANTARG, op.
dp.cArgs-cNamedArgs+1);
2663 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
2664 n = op.
dp.cArgs - i + cNamedArgs - 1;
2665 VariantInit(&realargs[n]);
2666 VariantInit(&op.
dp.rgvarg[n]);
2672 op.
dp.rgvarg[n] = realargs[n];
2673 V_VT(&op.
dp.rgvarg[n]) = VT_RECORD | VT_BYREF;
2676 V_VT(&op.
dp.rgvarg[n]) = VT_VARIANT | VT_BYREF;
2677 V_VARIANTREF(&op.
dp.rgvarg[n]) = &realargs[n];
2682 if (wFlags & DISPATCH_PROPERTYPUT) {
2683 if (op.
dp.cArgs == 0)
2686 op.
dp.cNamedArgs = 1;
2687 op.
dp.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
2688 op.
dp.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
2691 &IID_NULL, lcid, wFlags, &op.
dp,
2692 &result, &excepinfo, &argErr);
2696 if(op.
dp.cArgs >= cNamedArgs) {
2697 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
2698 n = op.
dp.cArgs - i + cNamedArgs - 1;
2702 if (hr == DISP_E_EXCEPTION) {
2705 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
2706 VariantInit(&result);
2708 &IID_NULL, lcid, wFlags,
2710 &excepinfo, &argErr);
2716 if ((hr == DISP_E_EXCEPTION || hr == DISP_E_MEMBERNOTFOUND) && DispID > 0x8000) {
2717 if (hr == DISP_E_EXCEPTION) {
2720 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
2722 &IID_NULL, lcid, wFlags,
2724 &excepinfo, &argErr);
2727 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
2728 n = op.
dp.cArgs - i + cNamedArgs - 1;
2729 if (V_VT(&op.
dp.rgvarg[n]) != VT_RECORD) {
2730 VariantClear(&op.
dp.rgvarg[n]);
2737 if (op.
dp.cArgs > cNamedArgs) {
2738 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
2739 n = op.
dp.cArgs - i + cNamedArgs - 1;
2743 if (hr == DISP_E_EXCEPTION) {
2746 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
2747 VariantInit(&result);
2749 &IID_NULL, lcid, wFlags,
2751 &excepinfo, &argErr);
2752 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
2753 n = op.
dp.cArgs - i + cNamedArgs - 1;
2754 if (V_VT(&op.
dp.rgvarg[n]) != VT_RECORD) {
2755 VariantClear(&op.
dp.rgvarg[n]);
2763 if(op.
dp.cArgs > cNamedArgs) {
2764 for(i = cNamedArgs; i < op.
dp.cArgs; i++) {
2765 n = op.
dp.cArgs - i + cNamedArgs - 1;
2770 V_VT(&realargs[n]) == VT_RECORD ) {
2777 for(i = 0; i < op.
dp.cArgs; i++) {
2778 VariantClear(&op.
dp.rgvarg[i]);
2789 VariantClear(&result);
2809 return ole_invoke(argc, argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
2817 unsigned int argErr = 0;
2818 EXCEPINFO excepinfo;
2820 DISPPARAMS dispParams;
2821 VARIANTARG* realargs =
NULL;
2831 memset(&excepinfo, 0,
sizeof(EXCEPINFO));
2832 memset(&dispParams, 0,
sizeof(DISPPARAMS));
2833 VariantInit(&result);
2837 dispParams.rgvarg =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
2838 realargs =
ALLOCA_N(VARIANTARG, dispParams.cArgs);
2839 for (i = 0, j = dispParams.cArgs - 1; i < (
int)dispParams.cArgs; i++, j--)
2841 VariantInit(&realargs[i]);
2842 VariantInit(&dispParams.rgvarg[i]);
2845 V_VT(&dispParams.rgvarg[i]) = vt;
2850 V_VT(&dispParams.rgvarg[i]) = V_VT(&realargs[i]) = VT_ERROR;
2851 V_ERROR(&dispParams.rgvarg[i]) = V_ERROR(&realargs[i]) = DISP_E_PARAMNOTFOUND;
2864 SAFEARRAYBOUND rgsabound[1];
2866 rgsabound[0].lLbound = 0;
2868 v = vt & ~(VT_ARRAY | VT_BYREF);
2869 V_ARRAY(&realargs[i]) = SafeArrayCreate(v, 1, rgsabound);
2870 V_VT(&realargs[i]) = VT_ARRAY | v;
2871 SafeArrayLock(V_ARRAY(&realargs[i]));
2872 pb = V_ARRAY(&realargs[i])->pvData;
2873 ps = V_ARRAY(&realargs[i])->pvData;
2874 pl = V_ARRAY(&realargs[i])->pvData;
2875 py = V_ARRAY(&realargs[i])->pvData;
2876 pv = V_ARRAY(&realargs[i])->pvData;
2877 for (ent = 0; ent < (int)rgsabound[0].cElements; ent++)
2882 if (v != VT_VARIANT)
2884 VariantChangeTypeEx(&velem, &velem,
2897 *py++ = V_CY(&velem);
2903 *ps++ = V_I2(&velem);
2908 *pb++ = V_UI1(&velem);
2912 *pl++ = V_I4(&velem);
2916 SafeArrayUnlock(V_ARRAY(&realargs[i]));
2921 if ((vt & (~VT_BYREF)) != VT_VARIANT)
2923 hr = VariantChangeTypeEx(&realargs[i], &realargs[i],
2925 (VARTYPE)(vt & (~VT_BYREF)));
2932 if ((vt & VT_BYREF) || vt == VT_VARIANT)
2934 if (vt == VT_VARIANT)
2935 V_VT(&dispParams.rgvarg[i]) = VT_VARIANT | VT_BYREF;
2936 switch (vt & (~VT_BYREF))
2940 V_VARIANTREF(&dispParams.rgvarg[i]) = &realargs[i];
2946 V_CYREF(&dispParams.rgvarg[i]) = &V_CY(&realargs[i]);
2952 V_I2REF(&dispParams.rgvarg[i]) = &V_I2(&realargs[i]);
2957 V_UI1REF(&dispParams.rgvarg[i]) = &V_UI1(&realargs[i]);
2961 V_I4REF(&dispParams.rgvarg[i]) = &V_I4(&realargs[i]);
2968 V_CY(&dispParams.rgvarg[i]) = V_CY(&realargs[i]);
2973 if (dispkind & DISPATCH_PROPERTYPUT) {
2974 dispParams.cNamedArgs = 1;
2975 dispParams.rgdispidNamedArgs =
ALLOCA_N( DISPID, 1 );
2976 dispParams.rgdispidNamedArgs[0] = DISPID_PROPERTYPUT;
2982 &dispParams, &result,
2983 &excepinfo, &argErr);
2993 if(dispParams.cArgs > 0) {
2994 set_argv(realargs, 0, dispParams.cArgs);
2998 VariantClear(&result);
3017 return ole_invoke2(
self, dispid, args, types, DISPATCH_METHOD);
3035 return ole_invoke2(
self, dispid, args, types, DISPATCH_PROPERTYGET);
3053 return ole_invoke2(
self, dispid, args, types, DISPATCH_PROPERTYPUT);
3128 EXCEPINFO excepinfo;
3129 DISPID dispID = DISPID_VALUE;
3130 DISPID dispIDParam = DISPID_PROPERTYPUT;
3131 USHORT wFlags = DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF;
3132 DISPPARAMS dispParams;
3133 VARIANTARG propertyValue[2];
3137 dispParams.rgdispidNamedArgs = &dispIDParam;
3138 dispParams.rgvarg = propertyValue;
3139 dispParams.cNamedArgs = 1;
3140 dispParams.cArgs = 1;
3142 VariantInit(&propertyValue[0]);
3143 VariantInit(&propertyValue[1]);
3144 memset(&excepinfo, 0,
sizeof(excepinfo));
3151 pBuf, 1, lcid, &dispID);
3152 SysFreeString(pBuf[0]);
3157 "unknown property or method: `%s'",
3163 lcid, wFlags, &dispParams,
3164 NULL, &excepinfo, &argErr);
3166 for(index = 0; index < dispParams.cArgs; ++index) {
3167 VariantClear(&propertyValue[index]);
3202 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
3203 VariantInit(&variant);
3204 while(pEnum->lpVtbl->Next(pEnum, 1, &variant,
NULL) == S_OK) {
3206 VariantClear(&variant);
3207 VariantInit(&variant);
3216 IEnumVARIANT *pEnum = (IEnumVARIANT *)pEnumV;
3242 unsigned int argErr;
3243 EXCEPINFO excepinfo;
3244 DISPPARAMS dispParams;
3247 IEnumVARIANT *pEnum =
NULL;
3252 VariantInit(&result);
3253 dispParams.rgvarg =
NULL;
3254 dispParams.rgdispidNamedArgs =
NULL;
3255 dispParams.cNamedArgs = 0;
3256 dispParams.cArgs = 0;
3257 memset(&excepinfo, 0,
sizeof(excepinfo));
3262 DISPATCH_METHOD | DISPATCH_PROPERTYGET,
3263 &dispParams, &result,
3264 &excepinfo, &argErr);
3267 VariantClear(&result);
3271 if (V_VT(&result) == VT_UNKNOWN) {
3272 hr = V_UNKNOWN(&result)->lpVtbl->QueryInterface(V_UNKNOWN(&result),
3276 }
else if (V_VT(&result) == VT_DISPATCH) {
3277 hr = V_DISPATCH(&result)->lpVtbl->QueryInterface(V_DISPATCH(&result),
3282 if (FAILED(hr) || !pEnum) {
3283 VariantClear(&result);
3287 VariantClear(&result);
3313 if(mname[n-1] ==
'=') {
3321 return ole_invoke(argc, argv,
self, DISPATCH_METHOD|DISPATCH_PROPERTYGET,
FALSE);
3328 ITypeInfo *pTypeInfo;
3336 0, lcid, &pTypeInfo);
3340 hr = pTypeInfo->lpVtbl->GetDocumentation(pTypeInfo,
3345 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
3350 count = pTypeLib->lpVtbl->GetTypeInfoCount(pTypeLib);
3351 for (i = 0; i <
count; i++) {
3352 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
3355 hr = pTypeLib->lpVtbl->GetTypeInfo(pTypeLib, i, &pTypeInfo);
3356 if (SUCCEEDED(hr)) {
3369 ITypeInfo *pTypeInfo;
3399 return ole_methods(
self, INVOKE_FUNC | INVOKE_PROPERTYGET | INVOKE_PROPERTYPUT | INVOKE_PROPERTYPUTREF);
3431 return ole_methods(
self, INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF);
3463 ITypeInfo *pTypeInfo;
3499 ITypeInfo *pTypeInfo;
3505 0, lcid, &pTypeInfo);
3511 if (vtlib ==
Qnil) {
3538 hr = CLSIDFromString(pBuf, &iid);
3539 SysFreeString(pBuf);
3542 "invalid iid: `%s'",
3555 "failed to get interface `%s'",
3589 SysFreeString(wcmdname);
3600 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, &pTypeLib, &i);
3605 hr = pTypeLib->lpVtbl->GetDocumentation(pTypeLib, i,
3607 helpcontext, helpfile);
3621 ITypeInfo *pRefTypeInfo;
3624 hr = pTypeInfo->lpVtbl->GetRefTypeInfo(pTypeInfo,
3636 if(typedetails !=
Qnil)
3644 TYPEDESC *p = pTypeDesc;
3647 if (p->vt == VT_PTR || p->vt == VT_SAFEARRAY) {
3659 switch(pTypeDesc->vt) {
3702 #if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__) 3724 if(typedetails !=
Qnil)
3729 if(typedetails !=
Qnil)
3735 case VT_USERDEFINED:
3737 if (typedetails !=
Qnil)
3767 if (typedetails !=
Qnil)
3786 ITypeInfo *pTypeInfo;
3830 IPersistMemory *pPersistMemory;
3837 hr = pole->
pDispatch->lpVtbl->QueryInterface(pole->
pDispatch, &IID_IPersistMemory, &p);
3839 if (SUCCEEDED(hr)) {
3840 hr = pPersistMemory->lpVtbl->InitNew(pPersistMemory);
3842 if (SUCCEEDED(hr)) {
3861 ITypeInfo *pTypeInfo;
3864 0, lcid, &pTypeInfo);
3868 hr = pTypeInfo->lpVtbl->GetContainingTypeLib(pTypeInfo, pTypeLib, &index);
3900 com_vtbl.QueryInterface = QueryInterface;
3903 com_vtbl.GetTypeInfoCount = GetTypeInfoCount;
3904 com_vtbl.GetTypeInfo = GetTypeInfo;
3905 com_vtbl.GetIDsOfNames = GetIDsOfNames;
static VALUE fole_invoke2(VALUE self, VALUE dispid, VALUE args, VALUE types)
static HRESULT typeinfo_from_ole(struct oledata *pole, ITypeInfo **ppti)
static VALUE fole_s_set_locale(VALUE self, VALUE vlcid)
static DWORD HTASK DWORD LPINTERFACEINFO lpInterfaceInfo
static BOOL lcid_installed(LCID lcid)
#define load_conv_function51932()
static IDispatchVtbl com_vtbl
static VALUE ole_create_dcom(VALUE self, VALUE ole, VALUE host, VALUE others)
#define MEMCMP(p1, p2, type, n)
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
void Init_win32ole_param(void)
#define ole_wc2mb_conv(pw, pm, size)
RUBY_EXTERN VALUE rb_cData
VALUE eWIN32OLERuntimeError
static void ole_free(void *ptr)
VALUE rb_ary_entry(VALUE ary, long offset)
static VALUE ole_invoke2(VALUE self, VALUE dispid, VALUE args, VALUE types, USHORT dispkind)
static VALUE ole_usertype2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails)
#define RUBY_TYPED_FREE_IMMEDIATELY
static HWND ole_show_help(VALUE helpfile, VALUE helpcontext)
static char g_lcid_to_check[8+1]
size_t strlen(const char *)
void Init_win32ole_method(void)
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 * val2variant_ptr(VALUE val, VARIANT *var, VARTYPE vt)
static DWORD HTASK threadIDCaller
static char * ole_alloc_vstr(UINT size, void *arg)
struct oledata * oledata_get_struct(VALUE ole)
void rb_define_singleton_method(VALUE obj, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a singleton method for obj.
static VALUE fole_setproperty2(VALUE self, VALUE dispid, VALUE args, VALUE types)
VALUE create_win32ole_record(IRecordInfo *pri, void *prec)
static VALUE ole_methods(VALUE self, int mask)
VALUE rb_str_cat(VALUE, const char *, long)
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR VARIANT __RPC_FAR EXCEPINFO __RPC_FAR * pExcepInfo
static REFIID LPOLESTR __RPC_FAR * rgszNames
static volatile DWORD g_ole_initialized_key
static VALUE fole_func_methods(VALUE self)
#define g_ole_initialized_set(val)
void ole_variant2variant(VALUE val, VARIANT *var)
static DWORD HTASK DWORD dwTickCount
#define TypedData_Wrap_Struct(klass, data_type, sval)
#define TypedData_Get_Struct(obj, type, data_type, sval)
static const rb_data_type_t win32ole_hash_datatype
static REFIID LPOLESTR __RPC_FAR UINT cNames
ID rb_check_id_cstr(const char *ptr, long len, rb_encoding *enc)
int rb_is_const_id(ID id)
static void ary_store_dim(VALUE myary, LONG *pid, LONG *plb, LONG dim, VALUE val)
static VALUE fole_free(VALUE self)
static VALUE ary_new_dim(VALUE myary, LONG *pid, LONG *plb, LONG dim)
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 fole_type(VALUE self)
VALUE rb_str_concat(VALUE, VALUE)
static void ole_const_load(ITypeLib *pTypeLib, VALUE klass, VALUE self)
static IDispatch * val2dispatch(VALUE val)
LPWSTR ole_vstr2wc(VALUE vstr)
struct _Win32OLEIDispatch Win32OLEIDispatch
VALUE rb_funcall(VALUE, ID, int,...)
Calls a method.
void Init_win32ole_variant_m(void)
void rb_str_set_len(VALUE, long)
void rb_raise(VALUE exc, const char *fmt,...)
#define OLE_GET_TYPEATTR(X, Y)
VALUE rb_ivar_get(VALUE, ID)
VALUE rb_enc_associate(VALUE obj, rb_encoding *enc)
VALUE rb_ary_clear(VALUE ary)
static VALUE fole_methods(VALUE self)
void rb_define_alloc_func(VALUE, rb_alloc_func_t)
VALUE rb_obj_is_kind_of(VALUE, VALUE)
void ole_initialize(void)
VALUE reg_get_val(HKEY hkey, const char *subkey)
void Init_win32ole_type(void)
static size_t com_hash_size(const void *ptr)
static VALUE fole_s_reference_count(VALUE self, VALUE obj)
double rb_big2dbl(VALUE x)
int rb_str_cmp(VALUE, VALUE)
static VALUE fole_method_help(VALUE self, VALUE cmdname)
static VALUE ole_set_member(VALUE self, IDispatch *dispatch)
IUnknown COSERVERINFO MULTI_QI *typedef LPCSTR UINT DWORD dwData
BOOL() FNENUMSYSEMCODEPAGES(CODEPAGE_ENUMPROC, DWORD)
static HTASK threadIDCallee
void ole_rec2variant(VALUE rec, VARIANT *var)
static void * get_ptr_of_variant(VARIANT *pvar)
VALUE rb_fix2str(VALUE, int)
void Init_win32ole_variant(void)
static VALUE fole_s_get_code_page(VALUE self)
HRESULT typelib_from_val(VALUE obj, ITypeLib **pTypeLib)
VALUE make_inspect(const char *class_name, VALUE detail)
static VALUE set_argv(VARIANTARG *realargs, unsigned int beg, unsigned int end)
static size_t ole_size(const void *ptr)
NORETURN(static void failed_load_conv51932(void))
RUBY_SYMBOL_EXPORT_BEGIN typedef unsigned long st_data_t
void ole_val2variant2(VALUE val, VARIANT *var)
void rb_hash_foreach(VALUE hash, int(*func)(ANYARGS), VALUE farg)
static const rb_data_type_t ole_datatype
IUnknown COSERVERINFO MULTI_QI *typedef LPCSTR UINT uCommand
static BOOL g_uninitialize_hooked
static UINT g_cp_to_check
#define g_ole_initialized_init()
#define RB_TYPE_P(obj, type)
static DISPID REFIID LCID WORD wFlags
BOOL ole_initialized(void)
void ole_raise(HRESULT hr, VALUE ecs, const char *fmt,...)
static VALUE create_win32ole_object(VALUE klass, IDispatch *pDispatch, int argc, VALUE *argv)
rb_encoding * rb_default_external_encoding(void)
void Init_win32ole_variable(void)
static UINT ole_encoding2cp(rb_encoding *enc)
static char * ole_alloc_str(UINT size, void *arg)
VALUE default_inspect(VALUE self, const char *class_name)
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
static BOOL g_lcid_installed
static double rbtime2vtdate(VALUE tmobj)
RUBY_EXTERN VALUE rb_cObject
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)
size_t st_memsize(const st_table *tab)
VALUE ole_type_from_itypeinfo(ITypeInfo *pTypeInfo)
#define g_ole_initialized
VALUE reg_get_val2(HKEY hkey, const char *subkey)
VALUE rb_str_cat2(VALUE, const char *)
VALUE typelib_file(VALUE ole)
static UINT __RPC_FAR * pctinfo
LONG reg_open_key(HKEY hkey, const char *name, HKEY *phkey)
static VALUE enc_name(VALUE self)
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
static IMessageFilter imessage_filter
void Init_win32ole_record(void)
void rb_define_const(VALUE, const char *, VALUE)
void rb_ary_store(VALUE ary, long idx, VALUE val)
static IMessageFilterVtbl message_filter
static int hash2named_arg(VALUE key, VALUE val, VALUE pop)
static VALUE fole_s_allocate(VALUE klass)
static VALUE fole_getproperty2(VALUE self, VALUE dispid, VALUE args, VALUE types)
static VALUE fole_invoke(int argc, VALUE *argv, VALUE self)
VALUE ole_methods_from_typeinfo(ITypeInfo *pTypeInfo, int mask)
static BOOL code_page_installed(UINT cp)
static VALUE fole_typelib(VALUE self)
#define ALLOCA_N(type, n)
void rb_gc_register_mark_object(VALUE obj)
static DISPID REFIID LCID WORD DISPPARAMS __RPC_FAR * pDispParams
void ole_val2variant_ex(VALUE val, VARIANT *var, VARTYPE vt)
VALUE ole_variant2val(VARIANT *pvar)
static VALUE fole_activex_initialize(VALUE self)
static VALUE is_all_index_under(LONG *pid, long *pub, long dim)
static void set_ole_codepage(UINT cp)
static long dimension(VALUE val)
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)
VALUE rb_const_get(VALUE, ID)
VALUE rb_str_subseq(VALUE, long, long)
LONG reg_open_vkey(HKEY hkey, VALUE key, HKEY *phkey)
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
VALUE rb_sprintf(const char *format,...)
static VALUE ole_propertyput(VALUE self, VALUE property, VALUE value)
char * ole_wc2mb(LPWSTR pw)
static VALUE fole_get_methods(VALUE self)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
unsigned char buf[MIME_BUF_SIZE]
void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events, VALUE data)
static VALUE ole_invoke(int argc, VALUE *argv, VALUE self, USHORT wFlags, BOOL is_bracket)
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 void failed_load_conv51932(void)
static VALUE vtdate2rbtime(double date)
void olerecord_set_ivar(VALUE obj, IRecordInfo *pri, void *prec)
void ole_uninitialize(void)
#define ENC_MACHING_CP(enc, encname, cp)
static HTASK DWORD DWORD dwRejectType
static VALUE fole_s_get_locale(VALUE self)
VALUE rb_call_super(int, const VALUE *)
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 fole_getproperty_with_bracket(int argc, VALUE *argv, VALUE self)
register unsigned int len
static VALUE ole_each_sub(VALUE pEnumV)
#define StringValueCStr(v)
static void com_hash_free(void *ptr)
static void com_hash_mark(void *ptr)
void Init_win32ole_event(void)
VALUE ole_typedesc2val(ITypeInfo *pTypeInfo, TYPEDESC *pTypeDesc, VALUE typedetails)
static VALUE fole_each(VALUE self)
rb_encoding * rb_enc_get(VALUE obj)
static VALUE ole_ary_m_entry(VALUE val, LONG *pid)
#define UNLIMITED_ARGUMENTS
static REFIID void __RPC_FAR *__RPC_FAR * ppvObject
static VALUE fole_respond_to(VALUE self, VALUE method)
IUnknown COSERVERINFO MULTI_QI *typedef HWND(WINAPI FNHTMLHELP)(HWND hwndCaller
static VALUE fole_s_free(VALUE self, VALUE obj)
void Init_win32ole_typelib(void)
VALUE ole_wc2vstr(LPWSTR pw, BOOL isfree)
typedef HRESULT(STDAPICALLTYPE FNCOCREATEINSTANCEEX)(REFCLSID
VALUE reg_enum_key(HKEY hkey, DWORD i)
static FNCOCREATEINSTANCEEX * gCoCreateInstanceEx
VALUE create_win32ole_method(ITypeInfo *pTypeInfo, VALUE name)
static LPWSTR ole_mb2wc(char *pm, int len, UINT cp)
static VALUE ole_bind_obj(VALUE moniker, int argc, VALUE *argv, VALUE self)
static VALUE fole_query_interface(VALUE self, VALUE str_iid)
static ULONG reference_count(struct oledata *pole)
#define TypedData_Make_Struct(klass, type, data_type, sval)
VALUE ole_typelib_from_itypeinfo(ITypeInfo *pTypeInfo)
VALUE rb_ary_concat(VALUE x, VALUE y)
VALUE rb_check_symbol(volatile VALUE *namep)
#define RETURN_ENUMERATOR(obj, argc, argv)
#define SafeStringValue(v)
static VALUE ole_ienum_free(VALUE pEnumV)
VALUE rb_enc_str_new(const char *, long, rb_encoding *)
static void ole_freeexceptinfo(EXCEPINFO *pExInfo)
static BOOL g_cp_installed
#define StringValuePtr(v)
IUnknown COSERVERINFO MULTI_QI *typedef LPCSTR pszFile
static UINT LCID ITypeInfo __RPC_FAR *__RPC_FAR * ppTInfo
static VALUE fole_initialize(int argc, VALUE *argv, VALUE self)
void Init_win32ole_error(void)
#define RTYPEDDATA_DATA(v)
int rb_enc_find_index(const char *name)
#define RSTRING_LENINT(str)
HRESULT ole_val_ary2variant_ary(VALUE val, VARIANT *var, VARTYPE vt)
static VALUE fole_s_create_guid(VALUE self)
static UINT ole_init_cp(void)
static IMessageFilter * previous_filter
void rb_mark_hash(st_table *tbl)
RUBY_EXTERN VALUE rb_cTime
static VALUE fole_s_show_help(int argc, VALUE *argv, VALUE self)
HRESULT ole_docinfo_from_type(ITypeInfo *pTypeInfo, BSTR *name, BSTR *helpstr, DWORD *helpcontext, BSTR *helpfile)
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 BOOL CALLBACK installed_code_page_proc(LPTSTR str)
static VALUE ole_excepinfo2msg(EXCEPINFO *pExInfo)
static void ole_set_safe_array(long n, SAFEARRAY *psa, LONG *pid, long *pub, VALUE val, long dim, VARTYPE vt)
static VALUE fole_s_ole_initialize(VALUE self)
static VALUE fole_missing(int argc, VALUE *argv, VALUE self)
rb_encoding * rb_enc_from_index(int index)
static VALUE fole_s_const_load(int argc, VALUE *argv, VALUE self)
void ole_val2variant(VALUE val, VARIANT *var)
static VALUE fole_s_connect(int argc, VALUE *argv, VALUE self)