static void test_change_type(IVariantChangeType *change_type, VARIANT *src, const conv_results_t *ex)
{
VARIANT v;
call_change_type(change_type, &v, src, VT_I4);
ok(V_I4(&v) == ex->int_result, "V_I4(v) = %d, expected %d\n", V_I4(&v), ex->int_result);
call_change_type(change_type, &v, src, VT_BSTR);
ok(!strcmp_wa(V_BSTR(&v), ex->str_result), "V_BSTR(v) = %s, expected %s\n", wine_dbgstr_w(V_BSTR(&v)), ex->str_result);
VariantClear(&v);
call_change_type(change_type, &v, src, VT_BOOL);
ok(V_BOOL(&v) == ex->bool_result, "V_BOOL(v) = %x, expected %x\n", V_BOOL(&v), ex->bool_result);
if(ex->test_double) {
call_change_type(change_type, &v, src, VT_R8);
ok(V_R8(&v) == ex->double_result, "V_R8(v) = %lf, expected %lf\n", V_R8(&v), ex->double_result);
call_change_type(change_type, &v, src, VT_R4);
ok(V_R4(&v) == (float)ex->double_result, "V_R4(v) = %f, expected %f\n", V_R4(&v), (float)ex->double_result);
}
if(V_VT(src) == VT_NULL)
call_change_type(change_type, &v, src, VT_NULL);
else
change_type_fail(change_type, src, VT_NULL, E_NOTIMPL);
if(V_VT(src) == VT_EMPTY)
call_change_type(change_type, &v, src, VT_EMPTY);
else
change_type_fail(change_type, src, VT_EMPTY, E_NOTIMPL);
call_change_type(change_type, &v, src, VT_I2);
ok(V_I2(&v) == (INT16)ex->int_result, "V_I2(v) = %d, expected %d\n", V_I2(&v), ex->int_result);
}
static void test_invoke_versioning(IActiveScript *script)
{
VARIANT v;
HRESULT hres;
V_VT(&v) = VT_NULL;
hres = set_script_prop(script, SCRIPTPROP_INVOKEVERSIONING, &v);
if(hres == E_NOTIMPL) {
win_skip("SCRIPTPROP_INVOKESTRING not supported\n");
return;
}
ok(hres == E_INVALIDARG, "SetProperty(SCRIPTPROP_INVOKEVERSIONING) failed: %08x\n", hres);
V_VT(&v) = VT_I2;
V_I2(&v) = 0;
hres = set_script_prop(script, SCRIPTPROP_INVOKEVERSIONING, &v);
ok(hres == E_INVALIDARG, "SetProperty(SCRIPTPROP_INVOKEVERSIONING) failed: %08x\n", hres);
V_VT(&v) = VT_I4;
V_I4(&v) = 16;
hres = set_script_prop(script, SCRIPTPROP_INVOKEVERSIONING, &v);
ok(hres == E_INVALIDARG, "SetProperty(SCRIPTPROP_INVOKEVERSIONING) failed: %08x\n", hres);
V_VT(&v) = VT_I4;
V_I4(&v) = 2;
hres = set_script_prop(script, SCRIPTPROP_INVOKEVERSIONING, &v);
ok(hres == S_OK, "SetProperty(SCRIPTPROP_INVOKEVERSIONING) failed: %08x\n", hres);
}
const char *debugstr_variant(const VARIANT *v)
{
if (!v) return "(null)";
switch (V_VT(v))
{
case VT_EMPTY:
return "{VT_EMPTY}";
case VT_NULL:
return "{VT_NULL}";
case VT_I2:
return wine_dbg_sprintf("{VT_I2: %d}", V_I2(v));
case VT_I4:
return wine_dbg_sprintf("{VT_I4: %d}", V_I4(v));
case VT_R8:
return wine_dbg_sprintf("{VT_R8: %lf}", V_R8(v));
case VT_BSTR:
return wine_dbg_sprintf("{VT_BSTR: %s}", debugstr_w(V_BSTR(v)));
case VT_DISPATCH:
return wine_dbg_sprintf("{VT_DISPATCH: %p}", V_DISPATCH(v));
case VT_ERROR:
return wine_dbg_sprintf("{VT_ERROR: %08x}", V_ERROR(v));
case VT_BOOL:
return wine_dbg_sprintf("{VT_BOOL: %x}", V_BOOL(v));
case VT_UINT:
return wine_dbg_sprintf("{VT_UINT: %u}", V_UINT(v));
default:
return wine_dbg_sprintf("{vt %d}", V_VT(v));
}
}
wchar_t *Variant2CWString(VARIANT *result){
switch(V_VT(result)){
case VT_EMPTY:
return L"empty";
break;
case VT_NULL:
return L"null";
break;
case VT_I2: // short
return Number2String((long)V_I2(result));
break;
case VT_I4: // long
return Number2String((long)V_I4(result));
break;
case VT_R4: // float
return Double2String(V_R4(result));
break;
case VT_R8: // double
return Double2String(V_R8(result));
break;
case VT_BOOL: //(True -1,False 0)
return (V_BOOL(result) ? L"True" : L"False");
break;
case VT_BSTR:
return (wchar_t*)(V_BSTR(result));
break;
case VT_DATE:
return Date2String( V_DATE(result));
break;
}
}
//+---------------------------------------------------------------------------
//
// Function: CVarToVARIANTARG
//
// Synopsis: Converts a C-language variable to a VARIANT.
//
// Arguments: [pv] -- Pointer to C-language variable.
// [vt] -- Type of C-language variable.
// [pvarg] -- Resulting VARIANT. Must be initialized by caller.
// Any contents will be freed.
//
// Modifies: [pvarg]
//
// History: 2-23-94 adams Created
//
// Notes: Supports all variant pointer types, VT_UI2, VT_I2, VT_UI4,
// VT_I4, VT_R4, VT_R8, VT_ERROR.
//
//----------------------------------------------------------------------------
void CVarToVARIANTARG(void* pv, VARTYPE vt, VARIANTARG* pvarg)
{
Assert(pv);
Assert(pvarg);
VariantClear(pvarg);
V_VT(pvarg) = vt;
if(V_ISBYREF(pvarg))
{
// Use a supported pointer type for derefencing.
vt = VT_UNKNOWN;
}
switch(vt)
{
case VT_BOOL:
// convert TRUE to VT_TRUE
Assert(*(BOOL*)pv==1 || *(BOOL*)pv==0);
V_BOOL(pvarg) = VARIANT_BOOL(-*(BOOL*)pv);
break;
case VT_I2:
V_I2(pvarg) = *(short*)pv;
break;
case VT_ERROR:
case VT_I4:
V_I4(pvarg) = *(long*)pv;
break;
case VT_R4:
V_R4(pvarg) = *(float*)pv;
break;
case VT_R8:
V_R8(pvarg) = *(double*)pv;
break;
case VT_CY:
V_CY(pvarg) = *(CY*)pv;
break;
// All Pointer types.
case VT_PTR:
case VT_BSTR:
case VT_LPSTR:
case VT_LPWSTR:
case VT_DISPATCH:
case VT_UNKNOWN:
V_BYREF(pvarg) = *(void**)pv;
break;
default:
Assert(FALSE && "Unknown type.");
break;
}
}
HRESULT variant_to_jsval(VARIANT *var, jsval_t *r)
{
switch(V_VT(var)) {
case VT_EMPTY:
*r = jsval_undefined();
return S_OK;
case VT_NULL:
*r = jsval_null();
return S_OK;
case VT_BOOL:
*r = jsval_bool(V_BOOL(var));
return S_OK;
case VT_I4:
*r = jsval_number(V_I4(var));
return S_OK;
case VT_R8:
*r = jsval_number(V_R8(var));
return S_OK;
case VT_BSTR: {
jsstr_t *str;
str = jsstr_alloc_len(V_BSTR(var), SysStringLen(V_BSTR(var)));
if(!str)
return E_OUTOFMEMORY;
if(!V_BSTR(var))
str->length_flags |= JSSTR_FLAG_NULLBSTR;
*r = jsval_string(str);
return S_OK;
}
case VT_DISPATCH: {
if(V_DISPATCH(var))
IDispatch_AddRef(V_DISPATCH(var));
*r = jsval_disp(V_DISPATCH(var));
return S_OK;
}
case VT_I2:
*r = jsval_number(V_I2(var));
return S_OK;
case VT_INT:
*r = jsval_number(V_INT(var));
return S_OK;
case VT_UNKNOWN:
if(V_UNKNOWN(var)) {
IDispatch *disp;
HRESULT hres;
hres = IUnknown_QueryInterface(V_UNKNOWN(var), &IID_IDispatch, (void**)&disp);
if(SUCCEEDED(hres)) {
*r = jsval_disp(disp);
return S_OK;
}
}
/* fall through */
default:
return jsval_variant(r, var);
}
}
JNIEXPORT void JNICALL Java_com_tangram_Variant_putVariantShort(JNIEnv *env, jobject _this, jshort s)
{
VARIANT *v = extractVariant(env, _this);
if (v) {
VariantClear(v); // whatever was there before
V_VT(v) = VT_I2;
V_I2(v) = (short)s;
}
}
static HRESULT return_short(VARIANT *res, short val)
{
if(res) {
V_VT(res) = VT_I2;
V_I2(res) = val;
}
return S_OK;
}
static void test_service(void)
{
static const WCHAR spooler[] = {'S','p','o','o','l','e','r',0};
static const WCHAR dummyW[] = {'d','u','m','m','y',0};
SERVICE_STATUS_PROCESS status;
SC_HANDLE scm, service;
IShellDispatch2 *sd;
DWORD dummy;
HRESULT hr;
BSTR name;
VARIANT v;
hr = CoCreateInstance(&CLSID_Shell, NULL, CLSCTX_INPROC_SERVER,
&IID_IShellDispatch2, (void**)&sd);
if (hr != S_OK)
{
win_skip("IShellDispatch2 not supported\n");
return;
}
V_VT(&v) = VT_I2;
V_I2(&v) = 10;
hr = IShellDispatch2_IsServiceRunning(sd, NULL, &v);
ok(V_VT(&v) == VT_BOOL, "got %d\n", V_VT(&v));
ok(V_BOOL(&v) == VARIANT_FALSE, "got %d\n", V_BOOL(&v));
EXPECT_HR(hr, S_OK);
scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
service = OpenServiceW(scm, spooler, SERVICE_QUERY_STATUS);
QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (BYTE *)&status, sizeof(SERVICE_STATUS_PROCESS), &dummy);
CloseServiceHandle(service);
CloseServiceHandle(scm);
/* service should exist */
name = SysAllocString(spooler);
V_VT(&v) = VT_I2;
hr = IShellDispatch2_IsServiceRunning(sd, name, &v);
EXPECT_HR(hr, S_OK);
ok(V_VT(&v) == VT_BOOL, "got %d\n", V_VT(&v));
if (status.dwCurrentState == SERVICE_RUNNING)
ok(V_BOOL(&v) == VARIANT_TRUE, "got %d\n", V_BOOL(&v));
else
ok(V_BOOL(&v) == VARIANT_FALSE, "got %d\n", V_BOOL(&v));
SysFreeString(name);
/* service doesn't exist */
name = SysAllocString(dummyW);
V_VT(&v) = VT_I2;
hr = IShellDispatch2_IsServiceRunning(sd, name, &v);
EXPECT_HR(hr, S_OK);
ok(V_VT(&v) == VT_BOOL, "got %d\n", V_VT(&v));
ok(V_BOOL(&v) == VARIANT_FALSE, "got %d\n", V_BOOL(&v));
SysFreeString(name);
IShellDispatch2_Release(sd);
}
void wxWebViewIE::Reload(wxWebViewReloadFlags flags)
{
VARIANTARG level;
VariantInit(&level);
V_VT(&level) = VT_I2;
switch(flags)
{
case wxWEB_VIEW_RELOAD_DEFAULT:
V_I2(&level) = REFRESH_NORMAL;
break;
case wxWEB_VIEW_RELOAD_NO_CACHE:
V_I2(&level) = REFRESH_COMPLETELY;
break;
default:
wxFAIL_MSG("Unexpected reload type");
}
m_webBrowser->Refresh2(&level);
}
JNIEXPORT jshort JNICALL Java_com_tangram_Variant_getVariantShort(JNIEnv *env, jobject _this)
{
VARIANT *v = extractVariant(env, _this);
if (v) {
if (V_VT(v) != VT_I2) {
return NULL;
}
return (jshort)V_I2(v);
}
return NULL;
}
static HRESULT WINAPI testObj_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
{
switch(id) {
case DISPID_TESTOBJ_PROPGET:
CHECK_EXPECT(testobj_propget_i);
ok(wFlags == (DISPATCH_PROPERTYGET|DISPATCH_METHOD), "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(!pdp->rgvarg, "rgvarg == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(!pdp->cArgs, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(pvarRes != NULL, "pvarRes == NULL\n");
ok(pei != NULL, "pei == NULL\n");
V_VT(pvarRes) = VT_I2;
V_I2(pvarRes) = 10;
return S_OK;
case DISPID_TESTOBJ_PROPPUT:
CHECK_EXPECT(testobj_propput_i);
ok(wFlags == DISPATCH_PROPERTYPUT, "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
ok(pdp->rgdispidNamedArgs != NULL, "rgdispidNamedArgs == NULL\n");
ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
ok(pdp->cNamedArgs == 1, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(pdp->rgdispidNamedArgs[0] == DISPID_PROPERTYPUT, "pdp->rgdispidNamedArgs[0] = %d\n", pdp->rgdispidNamedArgs[0]);
ok(!pvarRes, "pvarRes != NULL\n");
ok(pei != NULL, "pei == NULL\n");
ok(V_VT(pdp->rgvarg) == VT_I2, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
ok(V_I2(pdp->rgvarg) == 1, "V_I2(psp->rgvargs) = %d\n", V_I2(pdp->rgvarg));
return S_OK;
}
ok(0, "unexpected call %d\n", id);
return E_FAIL;
}
DWORD COcsWmi::dwCimValue(VARIANT &pVal, CIMTYPE &pType)
{
if ((pVal.vt == VT_NULL) || (pVal.vt == VT_EMPTY))
return 0;
else
switch (pType)
{
case CIM_SINT8:
return V_I1(&pVal);
case CIM_UINT8:
return V_UI1(&pVal);
case CIM_SINT16:
return V_I2(&pVal);
case CIM_UINT16:
return V_UI2(&pVal);
case CIM_SINT32:
return V_I4(&pVal);
case CIM_UINT32:
return V_UI4(&pVal);
case CIM_BOOLEAN:
return (V_BOOL(&pVal) ? 1 : 0);
default:
return 0;
}
}
static HRESULT WINAPI HTMLSelectElement_add(IHTMLSelectElement *iface, IHTMLElement *element,
VARIANT before)
{
HTMLSelectElement *This = impl_from_IHTMLSelectElement(iface);
nsIWritableVariant *nsvariant;
HTMLElement *element_obj;
nsresult nsres;
TRACE("(%p)->(%p %s)\n", This, element, debugstr_variant(&before));
element_obj = unsafe_impl_from_IHTMLElement(element);
if(!element_obj) {
FIXME("External IHTMLElement implementation?\n");
return E_INVALIDARG;
}
nsvariant = create_nsvariant();
if(!nsvariant)
return E_FAIL;
switch(V_VT(&before)) {
case VT_EMPTY:
case VT_ERROR:
nsres = nsIWritableVariant_SetAsEmpty(nsvariant);
break;
case VT_I2:
nsres = nsIWritableVariant_SetAsInt16(nsvariant, V_I2(&before));
break;
default:
FIXME("unhandled before %s\n", debugstr_variant(&before));
nsIWritableVariant_Release(nsvariant);
return E_NOTIMPL;
}
if(NS_SUCCEEDED(nsres))
nsres = nsIDOMHTMLSelectElement_Add(This->nsselect, element_obj->nselem, (nsIVariant*)nsvariant);
nsIWritableVariant_Release(nsvariant);
if(NS_FAILED(nsres)) {
ERR("Add failed: %08x\n", nsres);
return E_FAIL;
}
return S_OK;
}
const char *debugstr_variant(const VARIANT *v)
{
if(!v)
return "(null)";
switch(V_VT(v)) {
case VT_EMPTY:
return "{VT_EMPTY}";
case VT_NULL:
return "{VT_NULL}";
case VT_I1:
return wine_dbg_sprintf("{VT_I1: %d}", V_I1(v));
case VT_I2:
return wine_dbg_sprintf("{VT_I2: %d}", V_I2(v));
case VT_I4:
return wine_dbg_sprintf("{VT_I4: %d}", V_I4(v));
case VT_INT:
return wine_dbg_sprintf("{VT_INT: %d}", V_INT(v));
case VT_R8:
return wine_dbg_sprintf("{VT_R8: %lf}", V_R8(v));
case VT_BSTR:
return wine_dbg_sprintf("{VT_BSTR: %s}", debugstr_w(V_BSTR(v)));
case VT_DISPATCH:
return wine_dbg_sprintf("{VT_DISPATCH: %p}", V_DISPATCH(v));
case VT_BOOL:
return wine_dbg_sprintf("{VT_BOOL: %x}", V_BOOL(v));
case VT_UNKNOWN:
return wine_dbg_sprintf("{VT_UNKNOWN: %p}", V_UNKNOWN(v));
case VT_UINT:
return wine_dbg_sprintf("{VT_UINT: %u}", V_UINT(v));
case VT_BSTR|VT_BYREF:
return wine_dbg_sprintf("{VT_BSTR|VT_BYREF: ptr %p, data %s}",
V_BSTRREF(v), debugstr_w(V_BSTRREF(v) ? *V_BSTRREF(v) : NULL));
case VT_ERROR:
return wine_dbg_sprintf("{VT_ERROR: 0x%08x}", V_ERROR(v));
case VT_VARIANT|VT_BYREF:
return wine_dbg_sprintf("{VT_VARIANT|VT_BYREF: %s}", debugstr_variant(V_VARIANTREF(v)));
case VT_UI1|VT_ARRAY:
return "{VT_UI1|VT_ARRAY}";
default:
return wine_dbg_sprintf("{vt %d}", V_VT(v));
}
}
static HRESULT Global_Hex(vbdisp_t *This, VARIANT *arg, unsigned args_cnt, VARIANT *res)
{
WCHAR buf[17], *ptr;
DWORD n;
TRACE("%s\n", debugstr_variant(arg));
switch(V_VT(arg)) {
case VT_I2:
n = (WORD)V_I2(arg);
break;
case VT_I4:
n = V_I4(arg);
break;
case VT_EMPTY:
n = 0;
break;
case VT_NULL:
if(res)
V_VT(res) = VT_NULL;
return S_OK;
default:
FIXME("unsupported type %s\n", debugstr_variant(arg));
return E_NOTIMPL;
}
buf[16] = 0;
ptr = buf+15;
if(n) {
do {
*ptr-- = hex_char(n & 0xf);
n >>= 4;
}while(n);
ptr++;
}else {
bool
variant_as_string( DEBUGHELPER *pH, const VARIANT &var, std::string *ret )
{
if (var.vt & VT_VECTOR) return false;
if (var.vt & VT_RESERVED) return false;
if (var.vt & VT_ARRAY)
return safearray_as_string( pH, reinterpret_cast<DWORDLONG>(var.parray), ret);
if (var.vt & VT_BYREF)
{
// Construct a fake variant with the byref-value in it.
VARTYPE vt = var.vt & ~VT_BYREF;
long size = vartype_len(vt);
VARIANT var2;
var2.vt = vt;
long source=reinterpret_cast<long>(var.byref);
void *dest;
if( vt == VT_VARIANT)
dest = &var2;
else
{
var2.vt=vt;
dest = &(var2.bVal);
}
if(!ReadMem(pH,source, size, dest)) return false;
std::string retval;
if( ! variant_as_string( pH, var2, &retval)) return false;
retval += "]";
*ret = "[" + retval;
return true;
}
std::ostringstream os;
switch (var.vt & VT_TYPEMASK )
{
case VT_I2: os << V_I2(&var); break;
case VT_I4: os << V_I4(&var); break;
//case VT_I8: os << V_I8(&var); break;
case VT_R4: os << V_R4(&var); break;
case VT_R8: os << V_R8(&var); break;
case VT_UNKNOWN:
case VT_DISPATCH: os << "0x" << std::hex << (long )V_DISPATCH(&var); break;
case VT_BOOL: os << (V_BOOL(&var)==VARIANT_FALSE?"False":"True"); break;
case VT_I1: os << "'" << V_I1(&var) << "'" ; break;
case VT_UI1: os << "'" << V_UI1(&var) << "'" ; break;
case VT_UI2: os << V_UI2(&var); break;
case VT_UI4: os << V_UI4(&var); break;
case VT_INT: os << V_INT(&var); break;
case VT_UINT: os << V_UINT(&var); break;
case VT_ERROR: os << "error"; break;
case VT_CY: os << (((double)(V_CY(&var).int64))/10000.); break;
case VT_DATE: return date_as_string(V_DATE(&var), ret); break;
case VT_BSTR:
{
long pBSTR = reinterpret_cast<long>( V_BSTR(&var) );
// if (!ReadMem(pH, reinterpret_cast<DWORDLONG>( V_BSTR(&var) ), &pBSTR)) return false;
std::string ret;
if (!bstr_as_string( pH, pBSTR , &ret )) return false;
os << ret;
}break;
case VT_EMPTY: os << '@'; break;
case VT_NULL: os << "null"; break;
break;
default:
return false;
}
*ret = os.str();
return true;
}
static HRESULT WINAPI convert_DataConvert(IDataConvert* iface,
DBTYPE src_type, DBTYPE dst_type,
DBLENGTH src_len, DBLENGTH *dst_len,
void *src, void *dst,
DBLENGTH dst_max_len,
DBSTATUS src_status, DBSTATUS *dst_status,
BYTE precision, BYTE scale,
DBDATACONVERT flags)
{
convert *This = impl_from_IDataConvert(iface);
HRESULT hr;
TRACE("(%p)->(%d, %d, %ld, %p, %p, %p, %ld, %d, %p, %d, %d, %x)\n", This,
src_type, dst_type, src_len, dst_len, src, dst, dst_max_len,
src_status, dst_status, precision, scale, flags);
*dst_status = DBSTATUS_E_BADACCESSOR;
if(IDataConvert_CanConvert(iface, src_type, dst_type) != S_OK)
{
return DB_E_UNSUPPORTEDCONVERSION;
}
if(src_type == DBTYPE_STR)
{
BSTR b;
DWORD len;
if(flags & DBDATACONVERT_LENGTHFROMNTS)
len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0) - 1;
else
len = MultiByteToWideChar(CP_ACP, 0, src, src_len, NULL, 0);
b = SysAllocStringLen(NULL, len);
if(!b) return E_OUTOFMEMORY;
if(flags & DBDATACONVERT_LENGTHFROMNTS)
MultiByteToWideChar(CP_ACP, 0, src, -1, b, len + 1);
else
MultiByteToWideChar(CP_ACP, 0, src, src_len, b, len);
hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
&b, dst, dst_max_len, src_status, dst_status,
precision, scale, flags);
SysFreeString(b);
return hr;
}
if(src_type == DBTYPE_WSTR)
{
BSTR b;
if(flags & DBDATACONVERT_LENGTHFROMNTS)
b = SysAllocString(src);
else
b = SysAllocStringLen(src, src_len / 2);
if(!b) return E_OUTOFMEMORY;
hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
&b, dst, dst_max_len, src_status, dst_status,
precision, scale, flags);
SysFreeString(b);
return hr;
}
switch(dst_type)
{
case DBTYPE_I2:
{
signed short *d = dst;
VARIANT tmp;
switch(src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I2: *d = *(signed short*)src; hr = S_OK; break;
case DBTYPE_I4: hr = VarI2FromI4(*(signed int*)src, d); break;
case DBTYPE_R4: hr = VarI2FromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarI2FromR8(*(double*)src, d); break;
case DBTYPE_CY: hr = VarI2FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarI2FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarI2FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarI2FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarI2FromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarI2FromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: hr = VarI2FromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarI2FromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarI2FromUI4(*(DWORD*)src, d); break;
case DBTYPE_I8: hr = VarI2FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: hr = VarI2FromUI8(*(ULONGLONG*)src, d); break;
case DBTYPE_VARIANT:
VariantInit(&tmp);
if ((hr = VariantChangeType(&tmp, (VARIANT*)src, 0, VT_I2)) == S_OK)
*d = V_I2(&tmp);
break;
default: FIXME("Unimplemented conversion %04x -> I2\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_I4:
{
signed int *d = dst;
VARIANT tmp;
switch(src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I2: hr = VarI4FromI2(*(signed short*)src, d); break;
case DBTYPE_I4: *d = *(signed int*)src; hr = S_OK; break;
case DBTYPE_R4: hr = VarI4FromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarI4FromR8(*(double*)src, d); break;
case DBTYPE_CY: hr = VarI4FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarI4FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarI4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarI4FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarI4FromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarI4FromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: hr = VarI4FromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarI4FromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarI4FromUI4(*(DWORD*)src, d); break;
case DBTYPE_I8: hr = VarI4FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: hr = VarI4FromUI8(*(ULONGLONG*)src, d); break;
case DBTYPE_VARIANT:
VariantInit(&tmp);
if ((hr = VariantChangeType(&tmp, (VARIANT*)src, 0, VT_I4)) == S_OK)
*d = V_I4(&tmp);
break;
default: FIXME("Unimplemented conversion %04x -> I4\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_R4:
{
FLOAT *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I2: hr = VarR4FromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarR4FromI4(*(signed int*)src, d); break;
case DBTYPE_R4: *d = *(FLOAT*)src; hr = S_OK; break;
case DBTYPE_R8: hr = VarR4FromR8(*(double*)src, d); break;
case DBTYPE_CY: hr = VarR4FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarR4FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarR4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarR4FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarR4FromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarR4FromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: hr = VarR4FromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarR4FromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarR4FromUI4(*(DWORD*)src, d); break;
case DBTYPE_I8: hr = VarR4FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: hr = VarR4FromUI8(*(ULONGLONG*)src, d); break;
default: FIXME("Unimplemented conversion %04x -> R4\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_R8:
{
DOUBLE *d=dst;
switch (src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I1: hr = VarR8FromI1(*(signed char*)src, d); break;
case DBTYPE_I2: hr = VarR8FromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarR8FromI4(*(signed int*)src, d); break;
case DBTYPE_I8: hr = VarR8FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI1: hr = VarR8FromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarR8FromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarR8FromUI4(*(DWORD*)src, d); break;
case DBTYPE_UI8: hr = VarR8FromUI8(*(ULONGLONG*)src, d); break;
case DBTYPE_R4: hr = VarR8FromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: *d = *(DOUBLE*)src; hr = S_OK; break;
case DBTYPE_CY: hr = VarR8FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarR8FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarR8FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarR8FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarR8FromDec((DECIMAL*)src, d); break;
default: FIXME("Unimplemented conversion %04x -> R8\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_BOOL:
{
VARIANT_BOOL *d=dst;
switch (src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I1: hr = VarBoolFromI1(*(signed char*)src, d); break;
case DBTYPE_I2: hr = VarBoolFromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarBoolFromI4(*(signed int*)src, d); break;
case DBTYPE_I8: hr = VarBoolFromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI1: hr = VarBoolFromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarBoolFromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarBoolFromUI4(*(DWORD*)src, d); break;
case DBTYPE_UI8: hr = VarBoolFromUI8(*(ULONGLONG*)src, d); break;
case DBTYPE_R4: hr = VarBoolFromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarBoolFromR8(*(DOUBLE*)src, d); break;
case DBTYPE_CY: hr = VarBoolFromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarBoolFromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarBoolFromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: *d = *(VARIANT_BOOL*)src; hr = S_OK; break;
case DBTYPE_DECIMAL: hr = VarBoolFromDec((DECIMAL*)src, d); break;
default: FIXME("Unimplemented conversion %04x -> BOOL\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_DATE:
{
DATE *d=dst;
switch (src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I1: hr = VarDateFromI1(*(signed char*)src, d); break;
case DBTYPE_I2: hr = VarDateFromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarDateFromI4(*(signed int*)src, d); break;
case DBTYPE_I8: hr = VarDateFromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI1: hr = VarDateFromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarDateFromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarDateFromUI4(*(DWORD*)src, d); break;
case DBTYPE_UI8: hr = VarDateFromUI8(*(ULONGLONG*)src, d); break;
case DBTYPE_R4: hr = VarDateFromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarDateFromR8(*(DOUBLE*)src, d); break;
case DBTYPE_CY: hr = VarDateFromCy(*(CY*)src, d); break;
case DBTYPE_DATE: *d = *(DATE*)src; hr = S_OK; break;
case DBTYPE_BSTR: hr = VarDateFromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarDateFromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarDateFromDec((DECIMAL*)src, d); break;
case DBTYPE_DBTIMESTAMP:
{
SYSTEMTIME st;
DBTIMESTAMP *ts=(DBTIMESTAMP*)src;
st.wYear = ts->year;
st.wMonth = ts->month;
st.wDay = ts->day;
st.wHour = ts->hour;
st.wMinute = ts->minute;
st.wSecond = ts->second;
st.wMilliseconds = ts->fraction/1000000;
hr = (SystemTimeToVariantTime(&st, d) ? S_OK : E_FAIL);
break;
}
default: FIXME("Unimplemented conversion %04x -> DATE\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_DBTIMESTAMP:
{
DBTIMESTAMP *d=dst;
switch (src_type)
{
case DBTYPE_EMPTY: memset(d, 0, sizeof(DBTIMESTAMP)); hr = S_OK; break;
case DBTYPE_DBTIMESTAMP: memcpy(d, src, sizeof(DBTIMESTAMP)); hr = S_OK; break;
case DBTYPE_DATE:
{
SYSTEMTIME st;
hr = (VariantTimeToSystemTime(*(double*)src, &st) ? S_OK : E_FAIL);
d->year = st.wYear;
d->month = st.wMonth;
d->day = st.wDay;
d->hour = st.wHour;
d->minute = st.wMinute;
d->second = st.wSecond;
d->fraction = st.wMilliseconds * 1000000;
break;
}
default: FIXME("Unimplemented conversion %04x -> DBTIMESTAMP\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_CY:
{
CY *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: d->int64 = 0; hr = S_OK; break;
case DBTYPE_I2: hr = VarCyFromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarCyFromI4(*(signed int*)src, d); break;
case DBTYPE_R4: hr = VarCyFromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarCyFromR8(*(double*)src, d); break;
case DBTYPE_CY: *d = *(CY*)src; hr = S_OK; break;
case DBTYPE_DATE: hr = VarCyFromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarCyFromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarCyFromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarCyFromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarCyFromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: hr = VarCyFromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarCyFromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarCyFromUI4(*(DWORD*)src, d); break;
case DBTYPE_I8: hr = VarCyFromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: hr = VarCyFromUI8(*(ULONGLONG*)src, d); break;
default: FIXME("Unimplemented conversion %04x -> CY\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_BSTR:
{
BSTR *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: *d = SysAllocStringLen(NULL, 0); hr = *d ? S_OK : E_OUTOFMEMORY; break;
case DBTYPE_I2: hr = VarBstrFromI2(*(signed short*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_I4: hr = VarBstrFromI4(*(signed int*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_R4: hr = VarBstrFromR4(*(FLOAT*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_R8: hr = VarBstrFromR8(*(double*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_CY: hr = VarBstrFromCy(*(CY*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_DATE: hr = VarBstrFromDate(*(DATE*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BSTR: *d = SysAllocStringLen(*(BSTR*)src, SysStringLen(*(BSTR*)src)); hr = *d ? S_OK : E_OUTOFMEMORY; break;
case DBTYPE_BOOL: hr = VarBstrFromBool(*(VARIANT_BOOL*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_DECIMAL: hr = VarBstrFromDec((DECIMAL*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_I1: hr = VarBstrFromI1(*(signed char*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_UI1: hr = VarBstrFromUI1(*(BYTE*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_UI2: hr = VarBstrFromUI2(*(WORD*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_UI4: hr = VarBstrFromUI4(*(DWORD*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_I8: hr = VarBstrFromI8(*(LONGLONG*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_UI8: hr = VarBstrFromUI8(*(ULONGLONG*)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_GUID:
{
WCHAR szBuff[39];
const GUID *id = (const GUID *)src;
WCHAR format[] = {
'{','%','0','8','X','-','%','0','4','X','-','%','0','4','X','-',
'%','0','2','X','%','0','2','X','-',
'%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','}',0};
wsprintfW(szBuff, format,
id->Data1, id->Data2, id->Data3,
id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7] );
*d = SysAllocString(szBuff);
hr = *d ? S_OK : E_OUTOFMEMORY;
}
break;
case DBTYPE_BYTES:
{
*d = SysAllocStringLen(NULL, 2 * src_len);
if (*d == NULL)
hr = E_OUTOFMEMORY;
else
{
const char hexchars[] = "0123456789ABCDEF";
WCHAR *s = *d;
unsigned char *p = src;
while (src_len > 0)
{
*s++ = hexchars[(*p >> 4) & 0x0F];
*s++ = hexchars[(*p) & 0x0F];
src_len--; p++;
}
hr = S_OK;
}
}
break;
default: FIXME("Unimplemented conversion %04x -> BSTR\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_UI1:
{
BYTE *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I2: hr = VarUI1FromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarUI1FromI4(*(signed int*)src, d); break;
case DBTYPE_R4: hr = VarUI1FromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarUI1FromR8(*(double*)src, d); break;
case DBTYPE_CY: hr = VarUI1FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarUI1FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarUI1FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarUI1FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarUI1FromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarUI1FromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: *d = *(BYTE*)src; hr = S_OK; break;
case DBTYPE_UI2: hr = VarUI1FromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarUI1FromUI4(*(DWORD*)src, d); break;
case DBTYPE_I8: hr = VarUI1FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: hr = VarUI1FromUI8(*(ULONGLONG*)src, d); break;
default: FIXME("Unimplemented conversion %04x -> UI1\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_UI2:
{
WORD *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I2: hr = VarUI2FromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarUI2FromI4(*(signed int*)src, d); break;
case DBTYPE_R4: hr = VarUI2FromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarUI2FromR8(*(double*)src, d); break;
case DBTYPE_CY: hr = VarUI2FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarUI2FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarUI2FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarUI2FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarUI2FromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarUI2FromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: hr = VarUI2FromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: *d = *(WORD*)src; hr = S_OK; break;
case DBTYPE_UI4: hr = VarUI2FromUI4(*(DWORD*)src, d); break;
case DBTYPE_I8: hr = VarUI2FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: hr = VarUI2FromUI8(*(ULONGLONG*)src, d); break;
default: FIXME("Unimplemented conversion %04x -> UI2\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_UI4:
{
DWORD *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I2: hr = VarUI4FromI2(*(signed short*)src, d); break;
case DBTYPE_I4: hr = VarUI4FromI4(*(signed int*)src, d); break;
case DBTYPE_R4: hr = VarUI4FromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarUI4FromR8(*(double*)src, d); break;
case DBTYPE_CY: hr = VarUI4FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarUI4FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarUI4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarUI4FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarUI4FromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarUI4FromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: hr = VarUI4FromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarUI4FromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: *d = *(DWORD*)src; hr = S_OK; break;
case DBTYPE_I8: hr = VarUI4FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: hr = VarUI4FromUI8(*(ULONGLONG*)src, d); break;
default: FIXME("Unimplemented conversion %04x -> UI4\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_UI8:
{
ULONGLONG *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
case DBTYPE_I2: hr = VarUI8FromI2(*(signed short*)src, d); break;
case DBTYPE_I4: {LONGLONG s = *(signed int*)src; hr = VarUI8FromI8(s, d); break;}
case DBTYPE_R4: hr = VarUI8FromR4(*(FLOAT*)src, d); break;
case DBTYPE_R8: hr = VarUI8FromR8(*(double*)src, d); break;
case DBTYPE_CY: hr = VarUI8FromCy(*(CY*)src, d); break;
case DBTYPE_DATE: hr = VarUI8FromDate(*(DATE*)src, d); break;
case DBTYPE_BSTR: hr = VarUI8FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
case DBTYPE_BOOL: hr = VarUI8FromBool(*(VARIANT_BOOL*)src, d); break;
case DBTYPE_DECIMAL: hr = VarUI8FromDec((DECIMAL*)src, d); break;
case DBTYPE_I1: hr = VarUI8FromI1(*(signed char*)src, d); break;
case DBTYPE_UI1: hr = VarUI8FromUI1(*(BYTE*)src, d); break;
case DBTYPE_UI2: hr = VarUI8FromUI2(*(WORD*)src, d); break;
case DBTYPE_UI4: hr = VarUI8FromUI4(*(DWORD*)src, d); break;
case DBTYPE_I8: hr = VarUI8FromI8(*(LONGLONG*)src, d); break;
case DBTYPE_UI8: *d = *(ULONGLONG*)src; hr = S_OK; break;
default: FIXME("Unimplemented conversion %04x -> UI8\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_FILETIME:
{
FILETIME *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: d->dwLowDateTime = d->dwHighDateTime = 0; hr = S_OK; break;
case DBTYPE_FILETIME: *d = *(FILETIME*)src; hr = S_OK; break;
default: FIXME("Unimplemented conversion %04x -> FILETIME\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_GUID:
{
GUID *d = dst;
switch(src_type)
{
case DBTYPE_EMPTY: *d = GUID_NULL; hr = S_OK; break;
case DBTYPE_GUID: *d = *(GUID*)src; hr = S_OK; break;
default: FIXME("Unimplemented conversion %04x -> GUID\n", src_type); return E_NOTIMPL;
}
break;
}
case DBTYPE_WSTR:
{
BSTR b;
DBLENGTH bstr_len;
INT bytes_to_copy;
hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
src, &b, sizeof(BSTR), src_status, dst_status,
precision, scale, flags);
if(hr != S_OK) return hr;
bstr_len = SysStringLen(b);
*dst_len = bstr_len * sizeof(WCHAR); /* Doesn't include size for '\0' */
*dst_status = DBSTATUS_S_OK;
bytes_to_copy = min(*dst_len + sizeof(WCHAR), dst_max_len);
if(dst)
{
if(bytes_to_copy >= sizeof(WCHAR))
{
memcpy(dst, b, bytes_to_copy - sizeof(WCHAR));
*((WCHAR*)dst + bytes_to_copy / sizeof(WCHAR) - 1) = 0;
if(bytes_to_copy < *dst_len + sizeof(WCHAR))
*dst_status = DBSTATUS_S_TRUNCATED;
}
else
{
*dst_status = DBSTATUS_E_DATAOVERFLOW;
hr = DB_E_ERRORSOCCURRED;
}
}
SysFreeString(b);
return hr;
}
case DBTYPE_STR:
{
BSTR b;
DBLENGTH bstr_len;
INT bytes_to_copy;
hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
src, &b, sizeof(BSTR), src_status, dst_status,
precision, scale, flags);
if(hr != S_OK) return hr;
bstr_len = SysStringLen(b);
*dst_len = bstr_len * sizeof(char); /* Doesn't include size for '\0' */
*dst_status = DBSTATUS_S_OK;
bytes_to_copy = min(*dst_len + sizeof(char), dst_max_len);
if(dst)
{
if(bytes_to_copy >= sizeof(char))
{
WideCharToMultiByte(CP_ACP, 0, b, bytes_to_copy - sizeof(char), dst, dst_max_len, NULL, NULL);
*((char *)dst + bytes_to_copy / sizeof(char) - 1) = 0;
if(bytes_to_copy < *dst_len + sizeof(char))
*dst_status = DBSTATUS_S_TRUNCATED;
}
else
{
*dst_status = DBSTATUS_E_DATAOVERFLOW;
hr = DB_E_ERRORSOCCURRED;
}
}
SysFreeString(b);
return hr;
}
case DBTYPE_BYREF | DBTYPE_WSTR:
{
BSTR b;
WCHAR **d = dst;
DBLENGTH bstr_len;
hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
src, &b, sizeof(BSTR), src_status, dst_status,
precision, scale, flags);
if(hr != S_OK) return hr;
bstr_len = SysStringLen(b) * sizeof(WCHAR);
*dst_len = bstr_len; /* Doesn't include size for '\0' */
*d = CoTaskMemAlloc(bstr_len + sizeof(WCHAR));
if(*d) memcpy(*d, b, bstr_len + sizeof(WCHAR));
else hr = E_OUTOFMEMORY;
SysFreeString(b);
return hr;
}
default:
FIXME("Unimplemented conversion %04x -> %04x\n", src_type, dst_type);
return E_NOTIMPL;
}
if(hr == DISP_E_OVERFLOW)
{
*dst_status = DBSTATUS_E_DATAOVERFLOW;
*dst_len = get_length(dst_type);
hr = DB_E_ERRORSOCCURRED;
}
else if(hr == S_OK)
{
*dst_status = DBSTATUS_S_OK;
*dst_len = get_length(dst_type);
}
return hr;
}
static HRESULT invoke_builtin(vbdisp_t *This, const builtin_prop_t *prop, WORD flags, DISPPARAMS *dp, VARIANT *res)
{
VARIANT args[8];
unsigned argn, i;
switch(flags) {
case DISPATCH_PROPERTYGET:
if(!(prop->flags & (BP_GET|BP_GETPUT))) {
FIXME("property does not support DISPATCH_PROPERTYGET\n");
return E_FAIL;
}
break;
case DISPATCH_PROPERTYGET|DISPATCH_METHOD:
if(!prop->proc && prop->flags == BP_GET) {
const int vt = prop->min_args, val = prop->max_args;
switch(vt) {
case VT_I2:
V_VT(res) = VT_I2;
V_I2(res) = val;
break;
case VT_I4:
V_VT(res) = VT_I4;
V_I4(res) = val;
break;
case VT_BSTR: {
const string_constant_t *str = (const string_constant_t*)prop->max_args;
BSTR ret;
ret = SysAllocStringLen(str->buf, str->len);
if(!ret)
return E_OUTOFMEMORY;
V_VT(res) = VT_BSTR;
V_BSTR(res) = ret;
break;
}
DEFAULT_UNREACHABLE;
}
return S_OK;
}
break;
case DISPATCH_METHOD:
if(prop->flags & (BP_GET|BP_GETPUT)) {
FIXME("Call on property\n");
return E_FAIL;
}
break;
case DISPATCH_PROPERTYPUT:
if(!(prop->flags & BP_GETPUT)) {
FIXME("property does not support DISPATCH_PROPERTYPUT\n");
return E_FAIL;
}
FIXME("call put\n");
return E_NOTIMPL;
default:
FIXME("unsupported flags %x\n", flags);
return E_NOTIMPL;
}
argn = arg_cnt(dp);
if(argn < prop->min_args || argn > (prop->max_args ? prop->max_args : prop->min_args)) {
FIXME("invalid number of arguments\n");
return E_FAIL;
}
assert(argn < sizeof(args)/sizeof(*args));
for(i=0; i < argn; i++) {
if(V_VT(dp->rgvarg+dp->cArgs-i-1) == (VT_BYREF|VT_VARIANT))
args[i] = *V_VARIANTREF(dp->rgvarg+dp->cArgs-i-1);
else
args[i] = dp->rgvarg[dp->cArgs-i-1];
}
return prop->proc(This, args, dp->cArgs, res);
}
static void test_font_events_disp(void)
{
static const WCHAR nameW[] = {'N','a','m','e',0};
static const WCHAR sizeW[] = {'S','i','z','e',0};
static const WCHAR boldW[] = {'B','o','l','d',0};
static const WCHAR italicW[] = {'I','t','a','l','i','c',0};
static const WCHAR underlineW[] = {'U','n','d','e','r','l','i','n','e',0};
static const WCHAR strikeW[] = {'S','t','r','i','k','e','t','h','r','o','u','g','h',0};
static const WCHAR weightW[] = {'W','e','i','g','h','t',0};
static const WCHAR charsetW[] = {'C','h','a','r','s','e','t',0};
static const struct font_dispid font_dispids[] =
{
{ DISPID_FONT_NAME, nameW },
{ DISPID_FONT_SIZE, sizeW },
{ DISPID_FONT_BOLD, boldW },
{ DISPID_FONT_ITALIC, italicW },
{ DISPID_FONT_UNDER, underlineW },
{ DISPID_FONT_STRIKE, strikeW },
{ DISPID_FONT_WEIGHT, weightW },
{ DISPID_FONT_CHARSET, charsetW }
};
IFont *pFont;
IFont *pFont2;
IConnectionPointContainer *pCPC;
IConnectionPoint *pCP;
FONTDESC fontdesc;
HRESULT hr;
DWORD dwCookie;
IFontDisp *pFontDisp;
DISPPARAMS dispparams;
VARIANTARG vararg;
INT i;
fontdesc.cbSizeofstruct = sizeof(fontdesc);
fontdesc.lpstrName = MSSansSerif_font;
fontdesc.cySize.int64 = 12 * 10000; /* 12 pt */
fontdesc.sWeight = FW_NORMAL;
fontdesc.sCharset = 0;
fontdesc.fItalic = FALSE;
fontdesc.fUnderline = FALSE;
fontdesc.fStrikethrough = FALSE;
hr = pOleCreateFontIndirect(&fontdesc, &IID_IFont, (void **)&pFont);
EXPECT_HR(hr, S_OK);
hr = IFont_QueryInterface(pFont, &IID_IConnectionPointContainer, (void **)&pCPC);
EXPECT_HR(hr, S_OK);
hr = IConnectionPointContainer_FindConnectionPoint(pCPC, &IID_IFontEventsDisp, &pCP);
EXPECT_HR(hr, S_OK);
IConnectionPointContainer_Release(pCPC);
hr = IConnectionPoint_Advise(pCP, (IUnknown *)&FontEventsDisp, &dwCookie);
EXPECT_HR(hr, S_OK);
IConnectionPoint_Release(pCP);
fonteventsdisp_invoke_called = 0;
fonteventsdisp_invoke_arg0 = NULL;
hr = IFont_put_Bold(pFont, TRUE);
EXPECT_HR(hr, S_OK);
ok(fonteventsdisp_invoke_called == 1, "IFontEventDisp::Invoke wasn't called once\n");
SysFreeString(fonteventsdisp_invoke_arg0);
hr = IFont_QueryInterface(pFont, &IID_IFontDisp, (void **)&pFontDisp);
EXPECT_HR(hr, S_OK);
for (i = 0; i < sizeof(font_dispids)/sizeof(font_dispids[0]); i++)
{
switch (font_dispids[i].dispid)
{
case DISPID_FONT_NAME:
{
static const WCHAR arialW[] = {'A','r','i','a','l',0};
V_VT(&vararg) = VT_BSTR;
V_BSTR(&vararg) = SysAllocString(arialW);
break;
}
case DISPID_FONT_SIZE:
V_VT(&vararg) = VT_CY;
S(V_CY(&vararg)).Lo = 25;
S(V_CY(&vararg)).Hi = 0;
break;
case DISPID_FONT_BOLD:
V_VT(&vararg) = VT_BOOL;
V_BOOL(&vararg) = VARIANT_FALSE;
break;
case DISPID_FONT_ITALIC:
case DISPID_FONT_UNDER:
case DISPID_FONT_STRIKE:
V_VT(&vararg) = VT_BOOL;
V_BOOL(&vararg) = VARIANT_TRUE;
break;
case DISPID_FONT_WEIGHT:
V_VT(&vararg) = VT_I2;
V_I2(&vararg) = FW_BLACK;
break;
case DISPID_FONT_CHARSET:
V_VT(&vararg) = VT_I2;
V_I2(&vararg) = 1;
break;
default:
;
}
dispparams.cNamedArgs = 0;
dispparams.rgdispidNamedArgs = NULL;
dispparams.cArgs = 1;
dispparams.rgvarg = &vararg;
fonteventsdisp_invoke_called = 0;
hr = IFontDisp_Invoke(pFontDisp, font_dispids[i].dispid, &IID_NULL, 0, DISPATCH_PROPERTYPUT, &dispparams, NULL, NULL, NULL);
ok(hr == S_OK, "dispid=%d, got 0x%08x\n", font_dispids[i].dispid, hr);
ok(fonteventsdisp_invoke_called == 1, "dispid=%d, DISPID_FONT_CHANGED not called, got %d\n", font_dispids[i].dispid,
fonteventsdisp_invoke_called);
if (hr == S_OK)
{
ok(!lstrcmpW(font_dispids[i].name, fonteventsdisp_invoke_arg0), "dispid=%d, got %s, expected %s\n",
font_dispids[i].dispid, wine_dbgstr_w(fonteventsdisp_invoke_arg0), wine_dbgstr_w(font_dispids[i].name));
SysFreeString(fonteventsdisp_invoke_arg0);
}
VariantClear(&vararg);
}
IFontDisp_Release(pFontDisp);
hr = IFont_Clone(pFont, &pFont2);
EXPECT_HR(hr, S_OK);
IFont_Release(pFont);
/* this test shows that the notification routine isn't called again */
fonteventsdisp_invoke_called = 0;
hr = IFont_put_Bold(pFont2, FALSE);
EXPECT_HR(hr, S_OK);
ok(fonteventsdisp_invoke_called == 0, "got %d\n", fonteventsdisp_invoke_called);
IFont_Release(pFont2);
}
static void test_wshshell(void)
{
static const WCHAR notepadW[] = {'n','o','t','e','p','a','d','.','e','x','e',0};
static const WCHAR desktopW[] = {'D','e','s','k','t','o','p',0};
static const WCHAR lnk1W[] = {'f','i','l','e','.','l','n','k',0};
static const WCHAR pathW[] = {'%','P','A','T','H','%',0};
static const WCHAR sysW[] = {'S','Y','S','T','E','M',0};
static const WCHAR path2W[] = {'P','A','T','H',0};
static const WCHAR dummydirW[] = {'d','e','a','d','p','a','r','r','o','t',0};
static const WCHAR emptyW[] = {'e','m','p','t','y',0};
IWshEnvironment *env;
IWshExec *shexec;
IWshShell3 *sh3;
IDispatchEx *dispex;
IWshCollection *coll;
IDispatch *disp, *shortcut;
IUnknown *shell, *unk;
IFolderCollection *folders;
IWshShortcut *shcut;
ITypeInfo *ti;
HRESULT hr;
TYPEATTR *tattr;
DISPPARAMS dp;
EXCEPINFO ei;
VARIANT arg, res, arg2;
BSTR str, ret;
DWORD retval;
UINT err;
hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
&IID_IDispatch, (void**)&disp);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IDispatch_QueryInterface(disp, &IID_IWshShell3, (void**)&shell);
EXPECT_HR(hr, S_OK);
IDispatch_Release(disp);
hr = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
EXPECT_HR(hr, E_NOINTERFACE);
hr = IUnknown_QueryInterface(shell, &IID_IWshShell3, (void**)&sh3);
EXPECT_HR(hr, S_OK);
hr = IWshShell3_QueryInterface(sh3, &IID_IObjectWithSite, (void**)&unk);
ok(hr == E_NOINTERFACE, "got 0x%08x\n", hr);
hr = IWshShell3_QueryInterface(sh3, &IID_IWshShell, (void**)&unk);
ok(hr == S_OK, "got 0x%08x\n", hr);
IUnknown_Release(unk);
hr = IWshShell3_QueryInterface(sh3, &IID_IWshShell2, (void**)&unk);
ok(hr == S_OK, "got 0x%08x\n", hr);
IUnknown_Release(unk);
hr = IWshShell3_get_SpecialFolders(sh3, &coll);
EXPECT_HR(hr, S_OK);
hr = IWshCollection_QueryInterface(coll, &IID_IFolderCollection, (void**)&folders);
EXPECT_HR(hr, E_NOINTERFACE);
hr = IWshCollection_QueryInterface(coll, &IID_IDispatch, (void**)&disp);
EXPECT_HR(hr, S_OK);
hr = IDispatch_GetTypeInfo(disp, 0, 0, &ti);
EXPECT_HR(hr, S_OK);
hr = ITypeInfo_GetTypeAttr(ti, &tattr);
EXPECT_HR(hr, S_OK);
ok(IsEqualIID(&tattr->guid, &IID_IWshCollection), "got wrong type guid\n");
ITypeInfo_ReleaseTypeAttr(ti, tattr);
/* try to call Item() with normal IDispatch procedure */
str = SysAllocString(desktopW);
V_VT(&arg) = VT_BSTR;
V_BSTR(&arg) = str;
dp.rgvarg = &arg;
dp.rgdispidNamedArgs = NULL;
dp.cArgs = 1;
dp.cNamedArgs = 0;
hr = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, 1033, DISPATCH_PROPERTYGET, &dp, &res, &ei, &err);
EXPECT_HR(hr, DISP_E_MEMBERNOTFOUND);
/* try Item() directly, it returns directory path apparently */
V_VT(&res) = VT_EMPTY;
hr = IWshCollection_Item(coll, &arg, &res);
EXPECT_HR(hr, S_OK);
ok(V_VT(&res) == VT_BSTR, "got res type %d\n", V_VT(&res));
SysFreeString(str);
VariantClear(&res);
/* CreateShortcut() */
str = SysAllocString(lnk1W);
hr = IWshShell3_CreateShortcut(sh3, str, &shortcut);
EXPECT_HR(hr, S_OK);
SysFreeString(str);
hr = IDispatch_QueryInterface(shortcut, &IID_IWshShortcut, (void**)&shcut);
EXPECT_HR(hr, S_OK);
hr = IWshShortcut_get_Arguments(shcut, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
hr = IWshShortcut_get_IconLocation(shcut, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
IWshShortcut_Release(shcut);
IDispatch_Release(shortcut);
/* ExpandEnvironmentStrings */
hr = IWshShell3_ExpandEnvironmentStrings(sh3, NULL, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
str = SysAllocString(pathW);
hr = IWshShell3_ExpandEnvironmentStrings(sh3, str, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
SysFreeString(str);
V_VT(&arg) = VT_BSTR;
V_BSTR(&arg) = SysAllocString(sysW);
hr = IWshShell3_get_Environment(sh3, &arg, &env);
ok(hr == S_OK, "got 0x%08x\n", hr);
VariantClear(&arg);
hr = IWshEnvironment_get_Item(env, NULL, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
ret = (BSTR)0x1;
hr = IWshEnvironment_get_Item(env, NULL, &ret);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(ret && !*ret, "got %p\n", ret);
SysFreeString(ret);
/* invalid var name */
str = SysAllocString(lnk1W);
hr = IWshEnvironment_get_Item(env, str, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
ret = NULL;
hr = IWshEnvironment_get_Item(env, str, &ret);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(ret && *ret == 0, "got %s\n", wine_dbgstr_w(ret));
SysFreeString(ret);
SysFreeString(str);
/* valid name */
str = SysAllocString(path2W);
hr = IWshEnvironment_get_Item(env, str, &ret);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(ret && *ret != 0, "got %s\n", wine_dbgstr_w(ret));
SysFreeString(ret);
SysFreeString(str);
IWshEnvironment_Release(env);
V_VT(&arg) = VT_I2;
V_I2(&arg) = 0;
V_VT(&arg2) = VT_ERROR;
V_ERROR(&arg2) = DISP_E_PARAMNOTFOUND;
str = SysAllocString(notepadW);
hr = IWshShell3_Run(sh3, str, &arg, &arg2, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
retval = 10;
hr = IWshShell3_Run(sh3, str, NULL, &arg2, &retval);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
ok(retval == 10, "got %u\n", retval);
retval = 10;
hr = IWshShell3_Run(sh3, str, &arg, NULL, &retval);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
ok(retval == 10, "got %u\n", retval);
retval = 10;
V_VT(&arg2) = VT_ERROR;
V_ERROR(&arg2) = 0;
hr = IWshShell3_Run(sh3, str, &arg, &arg2, &retval);
ok(hr == DISP_E_TYPEMISMATCH, "got 0x%08x\n", hr);
ok(retval == 10, "got %u\n", retval);
SysFreeString(str);
/* current directory */
if (0) /* crashes on native */
hr = IWshShell3_get_CurrentDirectory(sh3, NULL);
str = NULL;
hr = IWshShell3_get_CurrentDirectory(sh3, &str);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(str && str[0] != 0, "got empty string\n");
SysFreeString(str);
hr = IWshShell3_put_CurrentDirectory(sh3, NULL);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
str = SysAllocString(emptyW);
hr = IWshShell3_put_CurrentDirectory(sh3, str);
ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
SysFreeString(str);
str = SysAllocString(dummydirW);
hr = IWshShell3_put_CurrentDirectory(sh3, str);
ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
SysFreeString(str);
/* Exec */
hr = IWshShell3_Exec(sh3, NULL, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
hr = IWshShell3_Exec(sh3, NULL, &shexec);
ok(hr == DISP_E_EXCEPTION, "got 0x%08x\n", hr);
str = SysAllocString(emptyW);
hr = IWshShell3_Exec(sh3, str, &shexec);
ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
SysFreeString(str);
IWshCollection_Release(coll);
IDispatch_Release(disp);
IWshShell3_Release(sh3);
IUnknown_Release(shell);
}
//+---------------------------------------------------------------------------
//
// Function: VARIANTARGToCVar
//
// Synopsis: Converts a VARIANT to a C-language variable.
//
// Arguments: [pvarg] -- Variant to convert.
// [pfAlloc] -- BSTR allocated during conversion caller is
// now owner of this BSTR or IUnknown or IDispatch
// object allocated needs to be released.
// [vt] -- Type to convert to.
// [pv] -- Location to place C-language variable.
//
// Modifies: [pv].
//
// Returns: HRESULT.
//
// History: 2-23-94 adams Created
//
// Notes: Supports all variant pointer types, VT_I2, VT_I4, VT_R4,
// VT_R8, VT_ERROR.
//----------------------------------------------------------------------------
HRESULT VARIANTARGToCVar(VARIANT* pvarg, BOOL* pfAlloc, VARTYPE vt, void* pv, IServiceProvider* pSrvProvider, WORD wMaxstrlen)
{
HRESULT hr = S_OK;
VARIANTARG* pVArgCopy = pvarg;
VARIANTARG vargNew; // variant of new type
BOOL fAlloc;
Assert(pvarg);
Assert(pv);
if(!pfAlloc)
{
pfAlloc = &fAlloc;
}
Assert((vt&~VT_TYPEMASK) == 0 || (vt&~VT_TYPEMASK)==VT_BYREF);
// Assume no allocations yet.
*pfAlloc = FALSE;
if(vt & VT_BYREF)
{
// If the parameter is a variant pointer then everything is acceptable.
if((vt&VT_TYPEMASK) == VT_VARIANT)
{
switch(V_VT(pvarg))
{
case VT_VARIANT|VT_BYREF:
hr = ClipVarString(pvarg->pvarVal, *(VARIANT**)pv, pfAlloc, wMaxstrlen);
break;
default:
hr = ClipVarString(pvarg, *(VARIANT**)pv, pfAlloc, wMaxstrlen);
break;
}
if(hr == S_FALSE)
{
hr = S_OK;
*(PVOID*)pv = (PVOID)pvarg;
}
goto Cleanup;
}
if((V_VT(pvarg)&VT_TYPEMASK) != (vt&VT_TYPEMASK))
{
hr = DISP_E_TYPEMISMATCH;
goto Cleanup;
}
// Type of both original and destination or same type (however, original
// may not be a byref only the original.
if(V_ISBYREF(pvarg))
{
// Destination and original are byref and same type just copy pointer.
*(PVOID*)pv = V_BYREF(pvarg);
}
else
{
// Convert original to byref.
switch(vt & VT_TYPEMASK)
{
case VT_BOOL:
*(PVOID*)pv = (PVOID)&V_BOOL(pvarg);
break;
case VT_I2:
*(PVOID*)pv = (PVOID)&V_I2(pvarg);
break;
case VT_ERROR:
case VT_I4:
*(PVOID*)pv = (PVOID)&V_I4(pvarg);
break;
case VT_R4:
*(PVOID*)pv = (PVOID)&V_R4(pvarg);
break;
case VT_R8:
*(PVOID*)pv = (PVOID)&V_R8(pvarg);
break;
case VT_CY:
*(PVOID*)pv = (PVOID)&V_CY(pvarg);
break;
// All pointer types.
case VT_PTR:
case VT_BSTR:
case VT_LPSTR:
case VT_LPWSTR:
case VT_DISPATCH:
case VT_UNKNOWN:
*(PVOID*)pv = (PVOID)&V_UNKNOWN(pvarg);
break;
case VT_VARIANT:
Assert("Dead code: shudn't have gotten here!");
*(PVOID*)pv = (PVOID)pvarg;
break;
default:
Assert(!"Unknown type in BYREF VARIANTARGToCVar().\n");
hr = DISP_E_TYPEMISMATCH;
goto Cleanup;
}
}
goto Cleanup;
}
// If the c style parameter is the same type as the VARIANT then we'll just
// move the data. Also if the c style type is a VARIANT then there's
// nothing to convert just copy the variant to the C parameter.
else if((V_VT(pvarg)&(VT_TYPEMASK|VT_BYREF))!=vt && (vt!=VT_VARIANT))
{
// If the request type isn't the same as the variant passed in then we
// need to convert.
VariantInit(&vargNew);
pVArgCopy = &vargNew;
hr = VariantChangeTypeSpecial(pVArgCopy, pvarg, vt,pSrvProvider);
if(hr)
{
goto Cleanup;
}
*pfAlloc = (vt==VT_BSTR) || (vt==VT_UNKNOWN) || (vt==VT_DISPATCH);
}
// Move the variant data to C style data.
switch(vt)
{
case VT_BOOL:
// convert VT_TRUE and any other non-zero values to TRUE
*(VARIANT_BOOL*)pv = V_BOOL(pVArgCopy);
break;
case VT_I2:
*(short*)pv = V_I2(pVArgCopy);
break;
case VT_ERROR:
case VT_I4:
*(long*)pv = V_I4(pVArgCopy);
break;
case VT_R4:
*(float*)pv = V_R4(pVArgCopy);
break;
case VT_R8:
*(double*)pv = V_R8(pVArgCopy);
break;
case VT_CY:
*(CY*)pv = V_CY(pVArgCopy);
break;
// All Pointer types.
case VT_BSTR:
if(wMaxstrlen && FormsStringLen(V_BSTR(pVArgCopy))>wMaxstrlen)
{
hr = FormsAllocStringLen(V_BSTR(pVArgCopy), wMaxstrlen, (BSTR*)pv);
if(hr)
{
goto Cleanup;
}
if(*pfAlloc)
{
VariantClear(&vargNew);
}
else
{
*pfAlloc = TRUE;
}
goto Cleanup;
}
case VT_PTR:
case VT_LPSTR:
case VT_LPWSTR:
case VT_DISPATCH:
case VT_UNKNOWN:
*(void**)pv = V_BYREF(pVArgCopy);
break;
case VT_VARIANT:
hr = ClipVarString(pVArgCopy, (VARIANT*)pv, pfAlloc, wMaxstrlen);
if(hr == S_FALSE)
{
hr = S_OK;
// Copy entire variant to output parameter.
*(VARIANT*)pv = *pVArgCopy;
}
break;
default:
Assert(FALSE && "Unknown type in VARIANTARGToCVar().\n");
hr = DISP_E_TYPEMISMATCH;
break;
}
Cleanup:
RRETURN(hr);
}
static void test_XMLHTTP(void)
{
static const char bodyA[] = "mode=Test";
static const char urlA[] = "http://crossover.codeweavers.com/posttest.php";
static const char xmltestA[] = "http://crossover.codeweavers.com/xmltest.xml";
static const char referertesturl[] = "http://test.winehq.org/tests/referer.php";
static const WCHAR wszExpectedResponse[] = {'F','A','I','L','E','D',0};
static const CHAR xmltestbodyA[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<a>TEST</a>\n";
static const WCHAR norefererW[] = {'n','o',' ','r','e','f','e','r','e','r',' ','s','e','t',0};
IXMLHttpRequest *xhr;
IObjectWithSite *obj_site, *obj_site2;
BSTR bstrResponse, str, str1;
VARIANT varbody, varbody_ref;
VARIANT dummy;
LONG state, status, bound;
IDispatch *event;
void *ptr;
HRESULT hr;
HGLOBAL g;
xhr = create_xhr();
VariantInit(&dummy);
V_VT(&dummy) = VT_ERROR;
V_ERROR(&dummy) = DISP_E_MEMBERNOTFOUND;
hr = IXMLHttpRequest_put_onreadystatechange(xhr, NULL);
EXPECT_HR(hr, S_OK);
hr = IXMLHttpRequest_abort(xhr);
EXPECT_HR(hr, S_OK);
V_VT(&varbody) = VT_I2;
V_I2(&varbody) = 1;
hr = IXMLHttpRequest_get_responseBody(xhr, &varbody);
EXPECT_HR(hr, E_PENDING);
ok(V_VT(&varbody) == VT_EMPTY, "got type %d\n", V_VT(&varbody));
ok(V_I2(&varbody) == 1, "got %d\n", V_I2(&varbody));
V_VT(&varbody) = VT_I2;
V_I2(&varbody) = 1;
hr = IXMLHttpRequest_get_responseStream(xhr, &varbody);
EXPECT_HR(hr, E_PENDING);
ok(V_VT(&varbody) == VT_EMPTY, "got type %d\n", V_VT(&varbody));
ok(V_I2(&varbody) == 1, "got %d\n", V_I2(&varbody));
/* send before open */
hr = IXMLHttpRequest_send(xhr, dummy);
ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
/* initial status code */
hr = IXMLHttpRequest_get_status(xhr, NULL);
ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr);
status = 0xdeadbeef;
hr = IXMLHttpRequest_get_status(xhr, &status);
ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
ok(status == READYSTATE_UNINITIALIZED || broken(status == 0xdeadbeef) /* <win8 */, "got %d\n", status);
hr = IXMLHttpRequest_get_statusText(xhr, &str);
ok(hr == E_FAIL, "got 0x%08x\n", hr);
/* invalid parameters */
test_open(xhr, NULL, NULL, E_INVALIDARG);
test_open(xhr, "POST", NULL, E_INVALIDARG);
test_open(xhr, NULL, urlA, E_INVALIDARG);
hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, NULL);
EXPECT_HR(hr, E_INVALIDARG);
hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), NULL);
ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, _bstr_("value1"));
EXPECT_HR(hr, E_INVALIDARG);
hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), _bstr_("value1"));
ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_get_readyState(xhr, NULL);
ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr);
state = -1;
hr = IXMLHttpRequest_get_readyState(xhr, &state);
EXPECT_HR(hr, S_OK);
ok(state == READYSTATE_UNINITIALIZED, "got %d, expected READYSTATE_UNINITIALIZED\n", state);
httpreq = xhr;
event = create_dispevent();
EXPECT_REF(event, 1);
hr = IXMLHttpRequest_put_onreadystatechange(xhr, event);
EXPECT_HR(hr, S_OK);
EXPECT_REF(event, 2);
g_unexpectedcall = g_expectedcall = 0;
test_open(xhr, "POST", urlA, S_OK);
ok(g_unexpectedcall == 0, "unexpected disp event call\n");
ok(g_expectedcall == 1 || broken(g_expectedcall == 0) /* win2k */, "no expected disp event call\n");
/* status code after ::open() */
status = 0xdeadbeef;
hr = IXMLHttpRequest_get_status(xhr, &status);
ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
ok(status == READYSTATE_UNINITIALIZED || broken(status == 0xdeadbeef) /* <win8 */, "got %d\n", status);
state = -1;
hr = IXMLHttpRequest_get_readyState(xhr, &state);
EXPECT_HR(hr, S_OK);
ok(state == READYSTATE_LOADING, "got %d, expected READYSTATE_LOADING\n", state);
hr = IXMLHttpRequest_abort(xhr);
EXPECT_HR(hr, S_OK);
state = -1;
hr = IXMLHttpRequest_get_readyState(xhr, &state);
EXPECT_HR(hr, S_OK);
ok(state == READYSTATE_UNINITIALIZED || broken(state == READYSTATE_LOADING) /* win2k */,
"got %d, expected READYSTATE_UNINITIALIZED\n", state);
test_open(xhr, "POST", urlA, S_OK);
hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_("header1"), _bstr_("value1"));
EXPECT_HR(hr, S_OK);
hr = IXMLHttpRequest_setRequestHeader(xhr, NULL, _bstr_("value1"));
EXPECT_HR(hr, E_INVALIDARG);
hr = IXMLHttpRequest_setRequestHeader(xhr, _bstr_(""), _bstr_("value1"));
EXPECT_HR(hr, E_INVALIDARG);
V_VT(&varbody) = VT_BSTR;
V_BSTR(&varbody) = _bstr_(bodyA);
hr = IXMLHttpRequest_send(xhr, varbody);
if (hr == INET_E_RESOURCE_NOT_FOUND)
{
skip("No connection could be made with crossover.codeweavers.com\n");
IXMLHttpRequest_Release(xhr);
return;
}
EXPECT_HR(hr, S_OK);
/* response headers */
hr = IXMLHttpRequest_getAllResponseHeaders(xhr, NULL);
ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_getAllResponseHeaders(xhr, &str);
EXPECT_HR(hr, S_OK);
/* status line is stripped already */
ok(memcmp(str, _bstr_("HTTP"), 4*sizeof(WCHAR)), "got response headers %s\n", wine_dbgstr_w(str));
ok(*str, "got empty headers\n");
hr = IXMLHttpRequest_getAllResponseHeaders(xhr, &str1);
EXPECT_HR(hr, S_OK);
ok(str1 != str, "got %p\n", str1);
SysFreeString(str1);
SysFreeString(str);
hr = IXMLHttpRequest_getResponseHeader(xhr, NULL, NULL);
EXPECT_HR(hr, E_INVALIDARG);
hr = IXMLHttpRequest_getResponseHeader(xhr, _bstr_("Date"), NULL);
ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_getResponseHeader(xhr, _bstr_("Date"), &str);
EXPECT_HR(hr, S_OK);
ok(*str != ' ', "got leading space in header %s\n", wine_dbgstr_w(str));
SysFreeString(str);
/* status code after ::send() */
status = 0xdeadbeef;
hr = IXMLHttpRequest_get_status(xhr, &status);
EXPECT_HR(hr, S_OK);
ok(status == 200, "got %d\n", status);
hr = IXMLHttpRequest_get_statusText(xhr, NULL);
ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_get_statusText(xhr, &str);
EXPECT_HR(hr, S_OK);
ok(!lstrcmpW(str, _bstr_("OK")), "got status %s\n", wine_dbgstr_w(str));
SysFreeString(str);
/* another ::send() after completed request */
V_VT(&varbody) = VT_BSTR;
V_BSTR(&varbody) = _bstr_(bodyA);
hr = IXMLHttpRequest_send(xhr, varbody);
ok(hr == E_FAIL || broken(hr == E_UNEXPECTED) /* win2k */, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_get_responseText(xhr, &bstrResponse);
EXPECT_HR(hr, S_OK);
/* the server currently returns "FAILED" because the Content-Type header is
* not what the server expects */
if(hr == S_OK)
{
ok(!memcmp(bstrResponse, wszExpectedResponse, sizeof(wszExpectedResponse)),
"expected %s, got %s\n", wine_dbgstr_w(wszExpectedResponse), wine_dbgstr_w(bstrResponse));
SysFreeString(bstrResponse);
}
/* POST: VT_VARIANT|VT_BYREF body */
test_open(xhr, "POST", urlA, S_OK);
V_VT(&varbody_ref) = VT_VARIANT|VT_BYREF;
V_VARIANTREF(&varbody_ref) = &varbody;
hr = IXMLHttpRequest_send(xhr, varbody_ref);
EXPECT_HR(hr, S_OK);
/* GET request */
test_open(xhr, "GET", xmltestA, S_OK);
V_VT(&varbody) = VT_EMPTY;
hr = IXMLHttpRequest_send(xhr, varbody);
if (hr == INET_E_RESOURCE_NOT_FOUND)
{
skip("No connection could be made with crossover.codeweavers.com\n");
IXMLHttpRequest_Release(xhr);
return;
}
EXPECT_HR(hr, S_OK);
hr = IXMLHttpRequest_get_responseText(xhr, NULL);
ok(hr == E_POINTER || broken(hr == E_INVALIDARG) /* <win8 */, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_get_responseText(xhr, &bstrResponse);
EXPECT_HR(hr, S_OK);
ok(!memcmp(bstrResponse, _bstr_(xmltestbodyA), sizeof(xmltestbodyA)*sizeof(WCHAR)),
"expected %s, got %s\n", xmltestbodyA, wine_dbgstr_w(bstrResponse));
SysFreeString(bstrResponse);
hr = IXMLHttpRequest_get_responseBody(xhr, NULL);
EXPECT_HR(hr, E_INVALIDARG);
V_VT(&varbody) = VT_EMPTY;
hr = IXMLHttpRequest_get_responseBody(xhr, &varbody);
EXPECT_HR(hr, S_OK);
ok(V_VT(&varbody) == (VT_ARRAY|VT_UI1), "got type %d, expected %d\n", V_VT(&varbody), VT_ARRAY|VT_UI1);
ok(SafeArrayGetDim(V_ARRAY(&varbody)) == 1, "got %d, expected one dimension\n", SafeArrayGetDim(V_ARRAY(&varbody)));
bound = -1;
hr = SafeArrayGetLBound(V_ARRAY(&varbody), 1, &bound);
EXPECT_HR(hr, S_OK);
ok(bound == 0, "got %d, expected zero bound\n", bound);
hr = SafeArrayAccessData(V_ARRAY(&varbody), &ptr);
EXPECT_HR(hr, S_OK);
ok(memcmp(ptr, xmltestbodyA, sizeof(xmltestbodyA)-1) == 0, "got wrong body data\n");
SafeArrayUnaccessData(V_ARRAY(&varbody));
VariantClear(&varbody);
/* get_responseStream */
hr = IXMLHttpRequest_get_responseStream(xhr, NULL);
EXPECT_HR(hr, E_INVALIDARG);
V_VT(&varbody) = VT_EMPTY;
hr = IXMLHttpRequest_get_responseStream(xhr, &varbody);
ok(V_VT(&varbody) == VT_UNKNOWN, "got type %d\n", V_VT(&varbody));
EXPECT_HR(hr, S_OK);
EXPECT_REF(V_UNKNOWN(&varbody), 1);
g = NULL;
hr = GetHGlobalFromStream((IStream*)V_UNKNOWN(&varbody), &g);
EXPECT_HR(hr, S_OK);
ok(g != NULL, "got %p\n", g);
IDispatch_Release(event);
/* test if referrer header is sent */
test_open(xhr, "GET", referertesturl, S_OK);
V_VT(&varbody) = VT_EMPTY;
hr = IXMLHttpRequest_send(xhr, varbody);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_get_responseText(xhr, &str);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(!lstrcmpW(str, norefererW), "got response text %s\n", wine_dbgstr_w(str));
SysFreeString(str);
/* interaction with object site */
hr = IXMLHttpRequest_QueryInterface(xhr, &IID_IObjectWithSite, (void**)&obj_site);
EXPECT_HR(hr, S_OK);
hr = IObjectWithSite_SetSite(obj_site, NULL);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_QueryInterface(xhr, &IID_IObjectWithSite, (void**)&obj_site2);
EXPECT_HR(hr, S_OK);
ok(obj_site == obj_site2 || broken(obj_site != obj_site2), "got new instance\n");
IObjectWithSite_Release(obj_site2);
set_xhr_site(xhr);
test_open(xhr, "GET", "tests/referer.php", S_OK);
str1 = a2bstr("http://test.winehq.org/");
V_VT(&varbody) = VT_EMPTY;
hr = IXMLHttpRequest_send(xhr, varbody);
ok(hr == S_OK, "got 0x%08x\n", hr);
hr = IXMLHttpRequest_get_responseText(xhr, &str);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(!lstrcmpW(str, str1), "got response text %s, expected %s\n", wine_dbgstr_w(str), wine_dbgstr_w(str1));
SysFreeString(str);
SysFreeString(str1);
/* try to set site another time */
hr = IObjectWithSite_SetSite(obj_site, &testsite);
EXPECT_HR(hr, S_OK);
IObjectWithSite_Release(obj_site);
IXMLHttpRequest_Release(xhr);
free_bstrs();
}
static void test_registry(void)
{
static const WCHAR keypathW[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\',
'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','T','e','s','t','\\',0};
static const WCHAR regsz2W[] = {'r','e','g','s','z','2',0};
static const WCHAR regszW[] = {'r','e','g','s','z',0};
static const WCHAR regdwordW[] = {'r','e','g','d','w','o','r','d',0};
static const WCHAR regbinaryW[] = {'r','e','g','b','i','n','a','r','y',0};
static const WCHAR regmultiszW[] = {'r','e','g','m','u','l','t','i','s','z',0};
static const WCHAR regsz1W[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\',
'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','T','e','s','t','\\','r','e','g','s','z','1',0};
static const WCHAR foobarW[] = {'f','o','o','b','a','r',0};
static const WCHAR fooW[] = {'f','o','o',0};
static const WCHAR brokenW[] = {'H','K','E','Y','_','b','r','o','k','e','n','_','k','e','y',0};
static const WCHAR broken2W[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','a',0};
WCHAR pathW[MAX_PATH];
DWORD dwvalue, type;
VARIANT value, v;
IWshShell3 *sh3;
VARTYPE vartype;
LONG bound;
HRESULT hr;
BSTR name;
HKEY root;
LONG ret;
UINT dim;
hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
&IID_IWshShell3, (void**)&sh3);
ok(hr == S_OK, "got 0x%08x\n", hr);
/* RegRead() */
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, NULL, &value);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
name = SysAllocString(brokenW);
hr = IWshShell3_RegRead(sh3, name, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
SysFreeString(name);
name = SysAllocString(broken2W);
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
SysFreeString(name);
ret = RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &root);
ok(ret == 0, "got %d\n", ret);
ret = RegSetValueExA(root, "regsz", 0, REG_SZ, (const BYTE*)"foobar", 7);
ok(ret == 0, "got %d\n", ret);
ret = RegSetValueExA(root, "regsz2", 0, REG_SZ, (const BYTE*)"foobar\0f", 9);
ok(ret == 0, "got %d\n", ret);
ret = RegSetValueExA(root, "regmultisz", 0, REG_MULTI_SZ, (const BYTE*)"foo\0bar\0", 9);
ok(ret == 0, "got %d\n", ret);
dwvalue = 10;
ret = RegSetValueExA(root, "regdword", 0, REG_DWORD, (const BYTE*)&dwvalue, sizeof(dwvalue));
ok(ret == 0, "got %d\n", ret);
dwvalue = 11;
ret = RegSetValueExA(root, "regbinary", 0, REG_BINARY, (const BYTE*)&dwvalue, sizeof(dwvalue));
ok(ret == 0, "got %d\n", ret);
/* REG_SZ */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regszW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
ok(!lstrcmpW(V_BSTR(&value), foobarW), "got %s\n", wine_dbgstr_w(V_BSTR(&value)));
VariantClear(&value);
SysFreeString(name);
/* REG_SZ with embedded NULL */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regsz2W);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
ok(SysStringLen(V_BSTR(&value)) == 6, "len %d\n", SysStringLen(V_BSTR(&value)));
VariantClear(&value);
SysFreeString(name);
/* REG_DWORD */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regdwordW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I4, "got %d\n", V_VT(&value));
ok(V_I4(&value) == 10, "got %d\n", V_I4(&value));
SysFreeString(name);
/* REG_BINARY */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regbinaryW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == (VT_ARRAY|VT_VARIANT), "got 0x%x\n", V_VT(&value));
dim = SafeArrayGetDim(V_ARRAY(&value));
ok(dim == 1, "got %u\n", dim);
hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 0, "got %u\n", bound);
hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 3, "got %u\n", bound);
hr = SafeArrayGetVartype(V_ARRAY(&value), &vartype);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(vartype == VT_VARIANT, "got %d\n", vartype);
bound = 0;
hr = SafeArrayGetElement(V_ARRAY(&value), &bound, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&v) == VT_UI1, "got %d\n", V_VT(&v));
ok(V_UI1(&v) == 11, "got %u\n", V_UI1(&v));
VariantClear(&v);
VariantClear(&value);
SysFreeString(name);
/* REG_MULTI_SZ */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regmultiszW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == (VT_ARRAY|VT_VARIANT), "got 0x%x\n", V_VT(&value));
SysFreeString(name);
dim = SafeArrayGetDim(V_ARRAY(&value));
ok(dim == 1, "got %u\n", dim);
hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 0, "got %u\n", bound);
hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 1, "got %u\n", bound);
hr = SafeArrayGetVartype(V_ARRAY(&value), &vartype);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(vartype == VT_VARIANT, "got %d\n", vartype);
bound = 0;
hr = SafeArrayGetElement(V_ARRAY(&value), &bound, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
ok(!lstrcmpW(V_BSTR(&v), fooW), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
VariantClear(&v);
VariantClear(&value);
name = SysAllocString(regsz1W);
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
VariantClear(&value);
SysFreeString(name);
delete_key(root);
/* RegWrite() */
ret = RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &root);
ok(ret == 0, "got %d\n", ret);
hr = IWshShell3_RegWrite(sh3, NULL, NULL, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regszW);
name = SysAllocString(pathW);
hr = IWshShell3_RegWrite(sh3, name, NULL, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
VariantInit(&value);
hr = IWshShell3_RegWrite(sh3, name, &value, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
hr = IWshShell3_RegWrite(sh3, name, &value, &value);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
/* type is optional */
V_VT(&v) = VT_ERROR;
V_ERROR(&v) = DISP_E_PARAMNOTFOUND;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
/* default type is REG_SZ */
V_VT(&value) = VT_I4;
V_I4(&value) = 12;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
type = REG_NONE;
ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL);
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
ok(type == REG_SZ, "got %d\n", type);
ret = RegDeleteValueA(root, "regsz");
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
V_VT(&value) = VT_BSTR;
V_BSTR(&value) = SysAllocString(regszW);
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
VariantClear(&value);
type = REG_NONE;
ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL);
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
ok(type == REG_SZ, "got %d\n", type);
ret = RegDeleteValueA(root, "regsz");
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
V_VT(&value) = VT_R4;
V_R4(&value) = 1.2;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
VariantClear(&value);
type = REG_NONE;
ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL);
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
ok(type == REG_SZ, "got %d\n", type);
ret = RegDeleteValueA(root, "regsz");
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
V_VT(&value) = VT_R4;
V_R4(&value) = 1.2;
V_VT(&v) = VT_I2;
V_I2(&v) = 1;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
VariantClear(&value);
SysFreeString(name);
delete_key(root);
IWshShell3_Release(sh3);
}
static void test_scriptdisp(void)
{
IActiveScriptParse *parser;
IDispatchEx *script_disp;
IActiveScript *vbscript;
DISPID id, id2;
DISPPARAMS dp;
EXCEPINFO ei;
VARIANT v;
ULONG ref;
HRESULT hres;
vbscript = create_vbscript();
hres = IActiveScript_QueryInterface(vbscript, &IID_IActiveScriptParse, (void**)&parser);
ok(hres == S_OK, "Could not get IActiveScriptParse iface: %08x\n", hres);
test_state(vbscript, SCRIPTSTATE_UNINITIALIZED);
test_safety(vbscript);
SET_EXPECT(GetLCID);
hres = IActiveScript_SetScriptSite(vbscript, &ActiveScriptSite);
ok(hres == S_OK, "SetScriptSite failed: %08x\n", hres);
CHECK_CALLED(GetLCID);
test_state(vbscript, SCRIPTSTATE_UNINITIALIZED);
SET_EXPECT(OnStateChange_INITIALIZED);
hres = IActiveScriptParse_InitNew(parser);
ok(hres == S_OK, "InitNew failed: %08x\n", hres);
CHECK_CALLED(OnStateChange_INITIALIZED);
test_state(vbscript, SCRIPTSTATE_INITIALIZED);
SET_EXPECT(OnStateChange_CONNECTED);
hres = IActiveScript_SetScriptState(vbscript, SCRIPTSTATE_CONNECTED);
ok(hres == S_OK, "SetScriptState(SCRIPTSTATE_CONNECTED) failed: %08x\n", hres);
CHECK_CALLED(OnStateChange_CONNECTED);
test_state(vbscript, SCRIPTSTATE_CONNECTED);
script_disp = get_script_dispatch(vbscript);
id = 100;
get_disp_id(script_disp, "LCase", DISP_E_UNKNOWNNAME, &id);
ok(id == -1, "id = %d, expected -1\n", id);
get_disp_id(script_disp, "globalVariable", DISP_E_UNKNOWNNAME, &id);
parse_script(parser, "dim globalVariable\nglobalVariable = 3");
get_disp_id(script_disp, "globalVariable", S_OK, &id);
memset(&dp, 0, sizeof(dp));
memset(&ei, 0, sizeof(ei));
V_VT(&v) = VT_EMPTY;
hres = IDispatchEx_InvokeEx(script_disp, id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
ok(V_VT(&v) == VT_I2, "V_VT(v) = %d\n", V_VT(&v));
ok(V_I2(&v) == 3, "V_I2(v) = %d\n", V_I2(&v));
get_disp_id(script_disp, "globalVariable2", DISP_E_UNKNOWNNAME, &id);
parse_script(parser, "globalVariable2 = 4");
get_disp_id(script_disp, "globalVariable2", S_OK, &id);
get_disp_id(script_disp, "globalFunction", DISP_E_UNKNOWNNAME, &id);
parse_script(parser, "function globalFunction()\nglobalFunction=5\nend function");
get_disp_id(script_disp, "globalFunction", S_OK, &id);
SET_EXPECT(OnEnterScript);
SET_EXPECT(OnLeaveScript);
memset(&dp, 0, sizeof(dp));
memset(&ei, 0, sizeof(ei));
V_VT(&v) = VT_EMPTY;
hres = IDispatchEx_InvokeEx(script_disp, id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
ok(V_VT(&v) == VT_I2, "V_VT(v) = %d\n", V_VT(&v));
ok(V_I2(&v) == 5, "V_I2(v) = %d\n", V_I2(&v));
CHECK_CALLED(OnEnterScript);
CHECK_CALLED(OnLeaveScript);
SET_EXPECT(OnEnterScript);
SET_EXPECT(OnLeaveScript);
memset(&dp, 0, sizeof(dp));
memset(&ei, 0, sizeof(ei));
V_VT(&v) = VT_EMPTY;
hres = IDispatchEx_Invoke(script_disp, id, &IID_NULL, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
ok(V_VT(&v) == VT_I2, "V_VT(v) = %d\n", V_VT(&v));
ok(V_I2(&v) == 5, "V_I2(v) = %d\n", V_I2(&v));
CHECK_CALLED(OnEnterScript);
CHECK_CALLED(OnLeaveScript);
get_disp_id(script_disp, "globalSub", DISP_E_UNKNOWNNAME, &id);
parse_script(parser, "sub globalSub()\nend sub");
get_disp_id(script_disp, "globalSub", S_OK, &id);
get_disp_id(script_disp, "globalSub", S_OK, &id2);
ok(id == id2, "id != id2\n");
get_disp_id(script_disp, "constVariable", DISP_E_UNKNOWNNAME, &id);
parse_script(parser, "const constVariable = 6");
get_disp_id(script_disp, "ConstVariable", S_OK, &id);
get_disp_id(script_disp, "Constvariable", S_OK, &id2);
ok(id == id2, "id != id2\n");
IDispatchEx_Release(script_disp);
IActiveScriptParse_Release(parser);
SET_EXPECT(OnStateChange_DISCONNECTED);
SET_EXPECT(OnStateChange_INITIALIZED);
SET_EXPECT(OnStateChange_CLOSED);
hres = IActiveScript_Close(vbscript);
ok(hres == S_OK, "Close failed: %08x\n", hres);
CHECK_CALLED(OnStateChange_DISCONNECTED);
CHECK_CALLED(OnStateChange_INITIALIZED);
CHECK_CALLED(OnStateChange_CLOSED);
ref = IActiveScript_Release(vbscript);
ok(!ref, "ref = %d\n", ref);
}
void EventProxy::convertJavaVariant(VARIANT *java, VARIANT *com) {
switch (com->vt)
{
case VT_DISPATCH:
{
switch (java->vt)
{
case VT_DISPATCH:
{
V_DISPATCH(com) = V_DISPATCH(java);
break;
}
case VT_DISPATCH | VT_BYREF:
{
V_DISPATCH(com) = *V_DISPATCHREF(java);
break;
}
}
break;
}
case VT_DISPATCH | VT_BYREF:
{
switch (java->vt)
{
case VT_DISPATCH:
{
*V_DISPATCHREF(com) = V_DISPATCH(java);
break;
}
case VT_DISPATCH | VT_BYREF:
{
*V_DISPATCHREF(com) = *V_DISPATCHREF(java);
break;
}
}
break;
}
case VT_BOOL:
{
switch (java->vt)
{
case VT_BOOL:
{
V_BOOL(com) = V_BOOL(java);
break;
}
case VT_BOOL | VT_BYREF:
{
V_BOOL(com) = *V_BOOLREF(java);
break;
}
}
break;
}
case VT_BOOL | VT_BYREF:
{
switch (java->vt)
{
case VT_BOOL:
{
*V_BOOLREF(com) = V_BOOL(java);
break;
}
case VT_BOOL | VT_BYREF:
{
*V_BOOLREF(com) = *V_BOOLREF(java);
break;
}
}
break;
}
case VT_UI1:
{
switch (java->vt)
{
case VT_UI1:
{
V_UI1(com) = V_UI1(java);
break;
}
case VT_UI1 | VT_BYREF:
{
V_UI1(com) = *V_UI1REF(java);
break;
}
}
break;
}
case VT_UI1 | VT_BYREF:
{
switch (java->vt)
{
case VT_UI1:
{
*V_UI1REF(com) = V_UI1(java);
break;
}
case VT_UI1 | VT_BYREF:
{
*V_UI1REF(com) = *V_UI1REF(java);
break;
}
}
break;
}
case VT_I2:
{
switch (java->vt)
{
case VT_I2:
{
V_I2(com) = V_I2(java);
break;
}
case VT_I2 | VT_BYREF:
{
V_I2(com) = *V_I2REF(java);
break;
}
}
break;
}
case VT_I2 | VT_BYREF:
{
switch (java->vt)
{
case VT_I2:
{
*V_I2REF(com) = V_I2(java);
break;
}
case VT_I2 | VT_BYREF:
{
*V_I2REF(com) = *V_I2REF(java);
break;
}
}
break;
}
case VT_I4:
{
switch (java->vt)
{
case VT_I4:
{
V_I4(com) = V_I4(java);
break;
}
case VT_I4 | VT_BYREF:
{
V_I4(com) = *V_I4REF(java);
break;
}
}
break;
}
case VT_I4 | VT_BYREF:
{
switch (java->vt)
{
case VT_I4:
{
*V_I4REF(com) = V_I4(java);
break;
}
case VT_I4 | VT_BYREF:
{
*V_I4REF(com) = *V_I4REF(java);
break;
}
}
break;
}
case VT_R4:
{
switch (java->vt)
{
case VT_R4:
{
V_R4(com) = V_R4(java);
break;
}
case VT_R4 | VT_BYREF:
{
V_R4(com) = *V_R4REF(java);
break;
}
}
break;
}
case VT_R4 | VT_BYREF:
{
switch (java->vt)
{
case VT_R4:
{
*V_R4REF(com) = V_R4(java);
break;
}
case VT_R4 | VT_BYREF:
{
*V_R4REF(com) = *V_R4REF(java);
break;
}
}
break;
}
case VT_R8:
{
switch (java->vt)
{
case VT_R8:
{
V_R8(com) = V_R8(java);
break;
}
case VT_R8 | VT_BYREF:
{
V_R8(com) = *V_R8REF(java);
break;
}
}
break;
}
case VT_R8 | VT_BYREF:
{
switch (java->vt)
{
case VT_R8:
{
*V_R8REF(com) = V_R8(java);
break;
}
case VT_R8 | VT_BYREF:
{
*V_R8REF(com) = *V_R8REF(java);
break;
}
}
break;
}
case VT_I1:
{
switch (java->vt)
{
case VT_I1:
{
V_I1(com) = V_I1(java);
break;
}
case VT_I1 | VT_BYREF:
{
V_I1(com) = *V_I1REF(java);
break;
}
}
break;
}
case VT_I1 | VT_BYREF:
{
switch (java->vt)
{
case VT_I1:
{
*V_I1REF(com) = V_I1(java);
break;
}
case VT_I1 | VT_BYREF:
{
*V_I1REF(com) = *V_I1REF(java);
break;
}
}
break;
}
case VT_UI2:
{
switch (java->vt)
{
case VT_UI2:
{
V_UI2(com) = V_UI2(java);
break;
}
case VT_UI2 | VT_BYREF:
{
V_UI2(com) = *V_UI2REF(java);
break;
}
}
break;
}
case VT_UI2 | VT_BYREF:
{
switch (java->vt)
{
case VT_UI2:
{
*V_UI2REF(com) = V_UI2(java);
break;
}
case VT_UI2 | VT_BYREF:
{
*V_UI2REF(com) = *V_UI2REF(java);
break;
}
}
break;
}
case VT_UI4:
{
switch (java->vt)
{
case VT_UI4:
{
V_UI4(com) = V_UI4(java);
break;
}
case VT_UI4 | VT_BYREF:
{
V_UI4(com) = *V_UI4REF(java);
break;
}
}
break;
}
case VT_UI4 | VT_BYREF:
{
switch (java->vt)
{
case VT_UI4:
{
*V_UI4REF(com) = V_UI4(java);
break;
}
case VT_UI4 | VT_BYREF:
{
*V_UI4REF(com) = *V_UI4REF(java);
break;
}
}
break;
}
case VT_INT:
{
switch (java->vt)
{
case VT_INT:
{
V_INT(com) = V_INT(java);
break;
}
case VT_INT | VT_BYREF:
{
V_INT(com) = *V_INTREF(java);
break;
}
}
break;
}
case VT_INT | VT_BYREF:
{
switch (java->vt)
{
case VT_INT:
{
*V_INTREF(com) = V_INT(java);
break;
}
case VT_INT | VT_BYREF:
{
*V_INTREF(com) = *V_INTREF(java);
break;
}
}
break;
}
case VT_UINT:
{
switch (java->vt)
{
case VT_UINT:
{
V_UINT(com) = V_UINT(java);
break;
}
case VT_UINT | VT_BYREF:
{
V_UINT(com) = *V_UINTREF(java);
break;
}
}
break;
}
case VT_UINT | VT_BYREF:
{
switch (java->vt)
{
case VT_UINT:
{
*V_UINTREF(com) = V_UINT(java);
break;
}
case VT_UINT | VT_BYREF:
{
*V_UINTREF(com) = *V_UINTREF(java);
break;
}
}
break;
}
case VT_CY:
{
switch (java->vt)
{
case VT_CY:
{
V_CY(com) = V_CY(java);
break;
}
case VT_CY | VT_BYREF:
{
V_CY(com) = *V_CYREF(java);
break;
}
}
break;
}
case VT_CY | VT_BYREF:
{
switch (java->vt)
{
case VT_CY:
{
*V_CYREF(com) = V_CY(java);
break;
}
case VT_CY | VT_BYREF:
{
*V_CYREF(com) = *V_CYREF(java);
break;
}
}
break;
}
case VT_DATE:
{
switch (java->vt)
{
case VT_DATE:
{
V_DATE(com) = V_DATE(java);
break;
}
case VT_DATE | VT_BYREF:
{
V_DATE(com) = *V_DATEREF(java);
break;
}
}
break;
}
case VT_DATE | VT_BYREF:
{
switch (java->vt)
{
case VT_DATE:
{
*V_DATEREF(com) = V_DATE(java);
break;
}
case VT_DATE | VT_BYREF:
{
*V_DATEREF(com) = *V_DATEREF(java);
break;
}
}
break;
}
case VT_BSTR:
{
switch (java->vt)
{
case VT_BSTR:
{
V_BSTR(com) = V_BSTR(java);
break;
}
case VT_BSTR | VT_BYREF:
{
V_BSTR(com) = *V_BSTRREF(java);
break;
}
}
break;
}
case VT_BSTR | VT_BYREF:
{
switch (java->vt)
{
case VT_BSTR:
{
*V_BSTRREF(com) = V_BSTR(java);
break;
}
case VT_BSTR | VT_BYREF:
{
*V_BSTRREF(com) = *V_BSTRREF(java);
break;
}
}
break;
}
case VT_DECIMAL:
{
switch (java->vt)
{
case VT_DECIMAL:
{
V_DECIMAL(com) = V_DECIMAL(java);
break;
}
case VT_DECIMAL | VT_BYREF:
{
V_DECIMAL(com) = *V_DECIMALREF(java);
break;
}
}
break;
}
case VT_DECIMAL | VT_BYREF:
{
switch (java->vt)
{
case VT_DECIMAL:
{
*V_DECIMALREF(com) = V_DECIMAL(java);
break;
}
case VT_DECIMAL | VT_BYREF:
{
*V_DECIMALREF(com) = *V_DECIMALREF(java);
break;
}
}
break;
}
}
}
static void test_disp(IDispatch *disp)
{
DISPID id, public_prop_id, public_prop2_id, public_func_id, public_sub_id, defvalget_id;
DISPID named_args[5] = {DISPID_PROPERTYPUT};
VARIANT v, args[5];
DISPPARAMS dp = {args, named_args};
IDispatchEx *dispex;
EXCEPINFO ei = {0};
BSTR str;
HRESULT hres;
hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
ok(hres == S_OK, "Could not get IDispatchEx iface: %08x\n", hres);
str = a2bstr("publicProp");
hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &public_prop_id);
SysFreeString(str);
ok(hres == S_OK, "GetDispID(publicProp) failed: %08x\n", hres);
str = a2bstr("PUBLICPROP");
hres = IDispatchEx_GetDispID(dispex, str, 0, &id);
SysFreeString(str);
ok(hres == S_OK, "GetDispID(PUBLICPROP) failed: %08x\n", hres);
ok(public_prop_id == id, "id = %d\n", public_prop_id);
str = a2bstr("publicPROP2");
hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &public_prop2_id);
SysFreeString(str);
ok(hres == S_OK, "GetDispID(publicProp2) failed: %08x\n", hres);
str = a2bstr("defValGet");
hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &defvalget_id);
SysFreeString(str);
ok(hres == S_OK, "GetDispID(defValGet) failed: %08x\n", hres);
ok(defvalget_id == DISPID_VALUE, "id = %d\n", defvalget_id);
str = a2bstr("privateProp");
hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &id);
SysFreeString(str);
ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(privateProp) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
ok(id == -1, "id = %d\n", id);
str = a2bstr("class_initialize");
hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &id);
SysFreeString(str);
ok(hres == S_OK, "GetDispID(publicProp2) failed: %08x\n", hres);
hres = IDispatchEx_InvokeEx(dispex, public_prop_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
V_VT(args) = VT_BOOL;
V_BOOL(args) = VARIANT_TRUE;
dp.cArgs = dp.cNamedArgs = 1;
V_VT(&v) = VT_BOOL;
hres = IDispatchEx_InvokeEx(dispex, public_prop_id, 0, DISPATCH_PROPERTYPUT, &dp, &v, &ei, NULL);
ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
dp.cArgs = dp.cNamedArgs = 0;
hres = IDispatchEx_InvokeEx(dispex, public_prop_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
ok(V_VT(&v) == VT_BOOL, "V_VT(v) = %d\n", V_VT(&v));
ok(V_BOOL(&v), "V_BOOL(v) = %x\n", V_BOOL(&v));
dp.cArgs = 1;
hres = IDispatchEx_InvokeEx(dispex, public_prop_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
ok(hres == DISP_E_MEMBERNOTFOUND, "InvokeEx failed: %08x, expected DISP_E_MEMBERNOTFOUND\n", hres);
ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
V_VT(args) = VT_BOOL;
V_BOOL(args) = VARIANT_FALSE;
dp.cArgs = 1;
V_VT(&v) = VT_BOOL;
hres = IDispatchEx_InvokeEx(dispex, public_prop_id, 0, DISPATCH_PROPERTYPUT, &dp, NULL, &ei, NULL);
ok(hres == DISP_E_PARAMNOTOPTIONAL, "InvokeEx failed: %08x, expected DISP_E_PARAMNOTOPTIONAL\n", hres);
str = a2bstr("publicFunction");
hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &public_func_id);
SysFreeString(str);
ok(hres == S_OK, "GetDispID(publicFunction) failed: %08x\n", hres);
ok(public_func_id != -1, "public_func_id = -1\n");
str = a2bstr("publicSub");
hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &public_sub_id);
SysFreeString(str);
ok(hres == S_OK, "GetDispID(publicSub) failed: %08x\n", hres);
ok(public_sub_id != -1, "public_func_id = -1\n");
dp.cArgs = dp.cNamedArgs = 0;
hres = IDispatchEx_InvokeEx(dispex, public_func_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
ok(V_VT(&v) == VT_I2, "V_VT(v) = %d\n", V_VT(&v));
ok(V_I2(&v) == 4, "V_I2(v) = %d\n", V_I2(&v));
dp.cArgs = dp.cNamedArgs = 0;
hres = IDispatchEx_InvokeEx(dispex, public_func_id, 0, DISPATCH_PROPERTYGET, &dp, &v, &ei, NULL);
ok(hres == DISP_E_MEMBERNOTFOUND, "InvokeEx failed: %08x, expected DISP_E_MEMBERNOTFOUND\n", hres);
ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
dp.cArgs = dp.cNamedArgs = 0;
hres = IDispatchEx_InvokeEx(dispex, public_func_id, 0, DISPATCH_METHOD, &dp, &v, &ei, NULL);
ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
ok(V_VT(&v) == VT_I2, "V_VT(v) = %d\n", V_VT(&v));
ok(V_I2(&v) == 4, "V_I2(v) = %d\n", V_I2(&v));
dp.cArgs = dp.cNamedArgs = 0;
hres = IDispatchEx_InvokeEx(dispex, public_sub_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
dp.cArgs = dp.cNamedArgs = 0;
hres = IDispatchEx_InvokeEx(dispex, public_sub_id, 0, DISPATCH_PROPERTYGET, &dp, &v, &ei, NULL);
ok(hres == DISP_E_MEMBERNOTFOUND, "InvokeEx failed: %08x, expected DISP_E_MEMBERNOTFOUND\n", hres);
ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
dp.cArgs = dp.cNamedArgs = 0;
hres = IDispatchEx_InvokeEx(dispex, public_sub_id, 0, DISPATCH_METHOD, &dp, &v, &ei, NULL);
ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
V_VT(args) = VT_BOOL;
V_BOOL(args) = VARIANT_TRUE;
dp.cArgs = dp.cNamedArgs = 1;
hres = IDispatchEx_InvokeEx(dispex, public_sub_id, 0, DISPATCH_PROPERTYPUT, &dp, NULL, &ei, NULL);
ok(FAILED(hres), "InvokeEx succeeded: %08x\n", hres);
dp.cArgs = dp.cNamedArgs = 0;
hres = IDispatchEx_InvokeEx(dispex, public_func_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
ok(V_VT(&v) == VT_I2, "V_VT(v) = %d\n", V_VT(&v));
ok(V_I2(&v) == 4, "V_I2(v) = %d\n", V_I2(&v));
dp.cArgs = dp.cNamedArgs = 0;
hres = IDispatchEx_InvokeEx(dispex, public_func_id, 0, DISPATCH_METHOD, &dp, &v, &ei, NULL);
ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
ok(V_VT(&v) == VT_I2, "V_VT(v) = %d\n", V_VT(&v));
ok(V_I2(&v) == 4, "V_I2(v) = %d\n", V_I2(&v));
dp.cArgs = dp.cNamedArgs = 0;
hres = IDispatchEx_InvokeEx(dispex, public_sub_id, 0, DISPATCH_PROPERTYGET|DISPATCH_METHOD, &dp, &v, &ei, NULL);
ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
dp.cArgs = dp.cNamedArgs = 0;
hres = IDispatchEx_InvokeEx(dispex, public_sub_id, 0, DISPATCH_METHOD, &dp, &v, &ei, NULL);
ok(hres == S_OK, "InvokeEx failed: %08x\n", hres);
ok(V_VT(&v) == VT_EMPTY, "V_VT(v) = %d\n", V_VT(&v));
str = a2bstr("privateSub");
hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive, &id);
SysFreeString(str);
ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(privateSub) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
ok(id == -1, "id = %d\n", id);
str = a2bstr("dynprop");
hres = IDispatchEx_GetDispID(dispex, str, fdexNameCaseInsensitive|fdexNameEnsure, &id);
ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(privateProp) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
ok(id == -1, "id = %d\n", id);
hres = IDispatchEx_GetDispID(dispex, str, fdexNameEnsure, &id);
ok(hres == DISP_E_UNKNOWNNAME, "GetDispID(privateProp) failed: %08x, expected DISP_E_UNKNOWNNAME\n", hres);
ok(id == -1, "id = %d\n", id);
SysFreeString(str);
IDispatchEx_Release(dispex);
}
static void
ole_set_byref(VARIANT *realvar, VARIANT *var, VARTYPE vt)
{
V_VT(var) = vt;
if (vt == (VT_VARIANT|VT_BYREF)) {
V_VARIANTREF(var) = realvar;
} else {
if (V_VT(realvar) != (vt & ~VT_BYREF)) {
rb_raise(eWIN32OLERuntimeError, "variant type mismatch");
}
switch(vt & ~VT_BYREF) {
case VT_I1:
V_I1REF(var) = &V_I1(realvar);
break;
case VT_UI1:
V_UI1REF(var) = &V_UI1(realvar);
break;
case VT_I2:
V_I2REF(var) = &V_I2(realvar);
break;
case VT_UI2:
V_UI2REF(var) = &V_UI2(realvar);
break;
case VT_I4:
V_I4REF(var) = &V_I4(realvar);
break;
case VT_UI4:
V_UI4REF(var) = &V_UI4(realvar);
break;
case VT_R4:
V_R4REF(var) = &V_R4(realvar);
break;
case VT_R8:
V_R8REF(var) = &V_R8(realvar);
break;
#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
#ifdef V_I8REF
case VT_I8:
V_I8REF(var) = &V_I8(realvar);
break;
#endif
#ifdef V_UI8REF
case VT_UI8:
V_UI8REF(var) = &V_UI8(realvar);
break;
#endif
#endif
case VT_INT:
V_INTREF(var) = &V_INT(realvar);
break;
case VT_UINT:
V_UINTREF(var) = &V_UINT(realvar);
break;
case VT_CY:
V_CYREF(var) = &V_CY(realvar);
break;
case VT_DATE:
V_DATEREF(var) = &V_DATE(realvar);
break;
case VT_BSTR:
V_BSTRREF(var) = &V_BSTR(realvar);
break;
case VT_DISPATCH:
V_DISPATCHREF(var) = &V_DISPATCH(realvar);
break;
case VT_ERROR:
V_ERRORREF(var) = &V_ERROR(realvar);
break;
case VT_BOOL:
V_BOOLREF(var) = &V_BOOL(realvar);
break;
case VT_UNKNOWN:
V_UNKNOWNREF(var) = &V_UNKNOWN(realvar);
break;
case VT_ARRAY:
V_ARRAYREF(var) = &V_ARRAY(realvar);
break;
default:
rb_raise(eWIN32OLERuntimeError, "unknown type specified(setting BYREF):%d", vt);
break;
}
}
}
static HRESULT WINAPI Global_InvokeEx(IDispatchEx *iface, DISPID id, LCID lcid, WORD wFlags, DISPPARAMS *pdp,
VARIANT *pvarRes, EXCEPINFO *pei, IServiceProvider *pspCaller)
{
switch(id) {
case DISPID_GLOBAL_OK: {
VARIANT *b;
ok(wFlags == INVOKE_FUNC || wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(pdp->cArgs == 2, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
if(wFlags & INVOKE_PROPERTYGET)
ok(pvarRes != NULL, "pvarRes == NULL\n");
else
ok(!pvarRes, "pvarRes != NULL\n");
ok(pei != NULL, "pei == NULL\n");
ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
b = pdp->rgvarg+1;
if(V_VT(b) == (VT_BYREF|VT_VARIANT))
b = V_BYREF(b);
ok(V_VT(b) == VT_BOOL, "V_VT(b) = %d\n", V_VT(b));
ok(V_BOOL(b), "%s: %s\n", test_name, wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
return S_OK;
}
case DISPID_GLOBAL_TRACE:
ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(!pvarRes, "pvarRes != NULL\n");
ok(pei != NULL, "pei == NULL\n");
ok(V_VT(pdp->rgvarg) == VT_BSTR, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
if(V_VT(pdp->rgvarg) == VT_BSTR)
trace("%s: %s\n", test_name, wine_dbgstr_w(V_BSTR(pdp->rgvarg)));
return S_OK;
case DISPID_GLOBAL_REPORTSUCCESS:
CHECK_EXPECT(global_success_i);
ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(!pvarRes, "pvarRes != NULL\n");
ok(pei != NULL, "pei == NULL\n");
return S_OK;
case DISPID_GLOBAL_GETVT:
ok(pdp != NULL, "pdp == NULL\n");
ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(pvarRes != NULL, "pvarRes == NULL\n");
ok(V_VT(pvarRes) == VT_EMPTY, "V_VT(pvarRes) = %d\n", V_VT(pvarRes));
ok(pei != NULL, "pei == NULL\n");
V_VT(pvarRes) = VT_BSTR;
V_BSTR(pvarRes) = a2bstr(vt2a(pdp->rgvarg));
return S_OK;
case DISPID_GLOBAL_ISENGLANG:
ok(wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(pdp->cArgs == 0, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(pvarRes != NULL, "pvarRes == NULL\n");
ok(pei != NULL, "pei == NULL\n");
V_VT(pvarRes) = VT_BOOL;
if(is_lang_english()) {
V_BOOL(pvarRes) = VARIANT_TRUE;
}else {
skip("Skipping some tests in non-English UIs\n");
V_BOOL(pvarRes) = VARIANT_FALSE;
}
return S_OK;
case DISPID_GLOBAL_VBVAR:
CHECK_EXPECT(global_vbvar_i);
ok(wFlags == DISPATCH_PROPERTYPUT, "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
ok(pdp->rgdispidNamedArgs != NULL, "rgdispidNamedArgs == NULL\n");
ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
ok(pdp->cNamedArgs == 1, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(pdp->rgdispidNamedArgs[0] == DISPID_PROPERTYPUT, "pdp->rgdispidNamedArgs[0] = %d\n", pdp->rgdispidNamedArgs[0]);
ok(!pvarRes, "pvarRes != NULL\n");
ok(pei != NULL, "pei == NULL\n");
ok(V_VT(pdp->rgvarg) == VT_I2, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
ok(V_I2(pdp->rgvarg) == 3, "V_I2(psp->rgvargs) = %d\n", V_I2(pdp->rgvarg));
return S_OK;
case DISPID_GLOBAL_TESTOBJ:
ok(wFlags == (DISPATCH_PROPERTYGET|DISPATCH_METHOD), "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(!pdp->rgvarg, "rgvarg == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(!pdp->cArgs, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(pvarRes != NULL, "pvarRes == NULL\n");
ok(pei != NULL, "pei == NULL\n");
V_VT(pvarRes) = VT_DISPATCH;
V_DISPATCH(pvarRes) = (IDispatch*)&testObj;
return S_OK;
case DISPID_GLOBAL_ISNULLDISP: {
VARIANT *v;
ok(wFlags == (INVOKE_FUNC|INVOKE_PROPERTYGET), "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(pvarRes != NULL, "pvarRes == NULL\n");
ok(pei != NULL, "pei == NULL\n");
v = pdp->rgvarg;
if(V_VT(v) == (VT_VARIANT|VT_BYREF))
v = V_VARIANTREF(v);
ok(V_VT(v) == VT_DISPATCH, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
V_VT(pvarRes) = VT_BOOL;
V_BOOL(pvarRes) = V_DISPATCH(v) ? VARIANT_FALSE : VARIANT_TRUE;
return S_OK;
}
case DISPID_GLOBAL_TESTDISP:
ok(wFlags == INVOKE_FUNC, "wFlags = %x\n", wFlags);
ok(pdp != NULL, "pdp == NULL\n");
ok(pdp->rgvarg != NULL, "rgvarg == NULL\n");
ok(!pdp->rgdispidNamedArgs, "rgdispidNamedArgs != NULL\n");
ok(pdp->cArgs == 1, "cArgs = %d\n", pdp->cArgs);
ok(!pdp->cNamedArgs, "cNamedArgs = %d\n", pdp->cNamedArgs);
ok(!pvarRes, "pvarRes != NULL\n");
ok(pei != NULL, "pei == NULL\n");
ok(V_VT(pdp->rgvarg) == VT_DISPATCH, "V_VT(psp->rgvargs) = %d\n", V_VT(pdp->rgvarg));
test_disp(V_DISPATCH(pdp->rgvarg));
return S_OK;
}
ok(0, "unexpected call %d\n", id);
return DISP_E_MEMBERNOTFOUND;
}
STDAPI
VariantChangeType(
VARIANTARG FAR* pvargDest,
VARIANTARG FAR* pvargSrc,
unsigned short wFlags,
VARTYPE vt)
{
VARIANT varTmp;
HRESULT hresult;
VARTYPE vtSrc;
if (pvargDest == NULL || pvargSrc == NULL)
return(E_INVALIDARG);
vtSrc = V_VT(pvargSrc); // get src vartype
hresult = NOERROR; // assume success
// NOTE: all code after this point must go to LError0 upon Error.
// should have validated the destination type at this point (to ensure
// that the below optimized switch statement will work properly).
switch ( VTSW(vtSrc, vt) )
{
case VTSW(VT_BOOL, VT_BOOL):
case VTSW(VT_I2, VT_I2):
case VTSW(VT_I4, VT_I4):
case VTSW(VT_INT, VT_INT):
case VTSW(VT_I8, VT_I8):
case VTSW(VT_R4, VT_R4):
case VTSW(VT_R8, VT_R8):
case VTSW(VT_CY, VT_CY):
case VTSW(VT_DECIMAL, VT_DECIMAL):
case VTSW(VT_I1, VT_I1):
case VTSW(VT_UI1, VT_UI1):
case VTSW(VT_UI2, VT_UI2):
case VTSW(VT_UI4, VT_UI4):
case VTSW(VT_UINT, VT_UINT):
case VTSW(VT_UI8, VT_UI8):
varTmp = *pvargSrc;
break;
case VTSW(VT_EMPTY, VT_BSTR):
hresult = ErrSysAllocString(OASTR(""), &V_BSTR(&varTmp));
break;
case VTSW(VT_BOOL, VT_BSTR):
//fall through to return "0" or "-1"
case VTSW(VT_I2, VT_BSTR):
hresult = VarBstrFromI2(V_I2(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_I4, VT_BSTR):
case VTSW(VT_INT, VT_BSTR):
hresult = VarBstrFromI4(V_I4(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_I8, VT_BSTR):
hresult = VarBstrFromI8(V_I8(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_R4, VT_BSTR):
hresult = VarBstrFromR4(V_R4(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_R8, VT_BSTR):
hresult = VarBstrFromR8(V_R8(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_CY, VT_BSTR):
hresult = VarBstrFromCy(V_CY(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_DECIMAL, VT_BSTR):
hresult = VarBstrFromDec(&pvargSrc->n1.decVal, LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_I1, VT_BSTR):
hresult = VarBstrFromI1(V_I1(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_UI1, VT_BSTR):
hresult = VarBstrFromUI1(V_UI1(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_UI2, VT_BSTR):
hresult = VarBstrFromUI2(V_UI2(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_UI4, VT_BSTR):
case VTSW(VT_UINT, VT_BSTR):
hresult = VarBstrFromUI4(V_UI4(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_UI8, VT_BSTR):
hresult = VarBstrFromUI8(V_UI8(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_BSTR, VT_BSTR):
hresult = ErrSysAllocString(V_BSTR(pvargSrc), &V_BSTR(&varTmp));
break;
case VTSW(VT_DATE, VT_BSTR):
_ASSERTE(false);
hresult = RESULT(DISP_E_TYPEMISMATCH);
break;
default:
if (vtSrc >= VT_VARIANT) {
IfFailGo(IsLegalVartype(vtSrc), LError0);
}
// everybody else gets a type mis-match error
_ASSERTE(false);
hresult = RESULT(DISP_E_TYPEMISMATCH);
break;
}
if (FAILED(hresult))
{
goto LError0;
}
// now set the tag in temp variant. Errors after this point have to
// goto LError1 to potentially clear this variant.
V_VT(&varTmp) = vt;
// now that we have succeeded, we can go ahead and destroy our
// destination variant.
if (V_VT(pvargDest) >= VT_BSTR) {
IfFailGo(VariantClear(pvargDest), LError1);
}
// copy in the variant we just created
memcpy(pvargDest, &varTmp, sizeof(VARIANT));
return NOERROR;
LError1:;
VariantClear(&varTmp);
// fall through
LError0:;
return hresult;
}
