TLIBATTR *attr;
res = ITypeLib_GetLibAttr(*ppTLib, &attr);
- if (res == S_OK && (attr->wMajorVerNum != wVerMajor || attr->wMinorVerNum < wVerMinor))
+ if (res == S_OK)
{
+ BOOL mismatch = attr->wMajorVerNum != wVerMajor || attr->wMinorVerNum < wVerMinor;
ITypeLib_ReleaseTLibAttr(*ppTLib, attr);
- ITypeLib_Release(*ppTLib);
- *ppTLib = NULL;
- res = TYPE_E_LIBNOTREGISTERED;
+
+ if (mismatch)
+ {
+ ITypeLib_Release(*ppTLib);
+ *ppTLib = NULL;
+ res = TYPE_E_LIBNOTREGISTERED;
+ }
}
}
}
return res;
}
+static void TLB_unregister_interface(GUID *guid, REGSAM flag)
+{
+ WCHAR subKeyName[50];
+ HKEY subKey;
+
+ /* the path to the type */
+ get_interface_key( guid, subKeyName );
+
+ /* Delete its bits */
+ if (RegOpenKeyExW(HKEY_CLASSES_ROOT, subKeyName, 0, KEY_WRITE | flag, &subKey) != ERROR_SUCCESS)
+ return;
+
+ RegDeleteKeyW(subKey, ProxyStubClsidW);
+ RegDeleteKeyW(subKey, ProxyStubClsid32W);
+ RegDeleteKeyW(subKey, TypeLibW);
+ RegCloseKey(subKey);
+ RegDeleteKeyExW(HKEY_CLASSES_ROOT, subKeyName, flag, 0);
+}
/******************************************************************************
* UnRegisterTypeLib [OLEAUT32.186]
DWORD i = 0;
BOOL deleteOtherStuff;
HKEY key = NULL;
- HKEY subKey = NULL;
TYPEATTR* typeAttr = NULL;
TYPEKIND kind;
ITypeInfo* typeInfo = NULL;
if ((kind == TKIND_INTERFACE && (typeAttr->wTypeFlags & TYPEFLAG_FOLEAUTOMATION)) ||
kind == TKIND_DISPATCH)
{
- /* the path to the type */
- get_interface_key( &typeAttr->guid, subKeyName );
+ BOOL is_wow64;
+ REGSAM opposite = (sizeof(void*) == 8 ? KEY_WOW64_32KEY : KEY_WOW64_64KEY);
- /* Delete its bits */
- if (RegOpenKeyExW(HKEY_CLASSES_ROOT, subKeyName, 0, KEY_WRITE, &subKey) != ERROR_SUCCESS)
- goto enddeleteloop;
+ TLB_unregister_interface(&typeAttr->guid, 0);
- RegDeleteKeyW(subKey, ProxyStubClsidW);
- RegDeleteKeyW(subKey, ProxyStubClsid32W);
- RegDeleteKeyW(subKey, TypeLibW);
- RegCloseKey(subKey);
- subKey = NULL;
- RegDeleteKeyW(HKEY_CLASSES_ROOT, subKeyName);
+ /* unregister TLBs into the opposite registry view, too */
+ if(opposite == KEY_WOW64_32KEY ||
+ (IsWow64Process(GetCurrentProcess(), &is_wow64) && is_wow64)) {
+ TLB_unregister_interface(&typeAttr->guid, opposite);
+ }
}
enddeleteloop:
end:
SysFreeString(tlibPath);
if (typeLib) ITypeLib_Release(typeLib);
- if (subKey) RegCloseKey(subKey);
if (key) RegCloseKey(key);
return result;
}
}
}
-static void dump_Variant(const VARIANT * pvar)
-{
- SYSTEMTIME st;
-
- TRACE("%p->{%s%s", pvar, debugstr_VT(pvar), debugstr_VF(pvar));
-
- if (pvar)
- {
- if (V_ISBYREF(pvar) || V_TYPE(pvar) == VT_UNKNOWN ||
- V_TYPE(pvar) == VT_DISPATCH || V_TYPE(pvar) == VT_RECORD)
- {
- TRACE(",%p", V_BYREF(pvar));
- }
- else if (V_ISARRAY(pvar) || V_ISVECTOR(pvar))
- {
- TRACE(",%p", V_ARRAY(pvar));
- }
- else switch (V_TYPE(pvar))
- {
- case VT_I1: TRACE(",%d", V_I1(pvar)); break;
- case VT_UI1: TRACE(",%d", V_UI1(pvar)); break;
- case VT_I2: TRACE(",%d", V_I2(pvar)); break;
- case VT_UI2: TRACE(",%d", V_UI2(pvar)); break;
- case VT_INT:
- case VT_I4: TRACE(",%d", V_I4(pvar)); break;
- case VT_UINT:
- case VT_UI4: TRACE(",%d", V_UI4(pvar)); break;
- case VT_I8: TRACE(",0x%08x,0x%08x", (ULONG)(V_I8(pvar) >> 32),
- (ULONG)(V_I8(pvar) & 0xffffffff)); break;
- case VT_UI8: TRACE(",0x%08x,0x%08x", (ULONG)(V_UI8(pvar) >> 32),
- (ULONG)(V_UI8(pvar) & 0xffffffff)); break;
- case VT_R4: TRACE(",%3.3e", V_R4(pvar)); break;
- case VT_R8: TRACE(",%3.3e", V_R8(pvar)); break;
- case VT_BOOL: TRACE(",%s", V_BOOL(pvar) ? "TRUE" : "FALSE"); break;
- case VT_BSTR: TRACE(",%s", debugstr_w(V_BSTR(pvar))); break;
- case VT_CY: TRACE(",0x%08x,0x%08x", V_CY(pvar).s.Hi,
- V_CY(pvar).s.Lo); break;
- case VT_DATE:
- if(!VariantTimeToSystemTime(V_DATE(pvar), &st))
- TRACE(",<invalid>");
- else
- TRACE(",%04d/%02d/%02d %02d:%02d:%02d", st.wYear, st.wMonth, st.wDay,
- st.wHour, st.wMinute, st.wSecond);
- break;
- case VT_ERROR:
- case VT_VOID:
- case VT_USERDEFINED:
- case VT_EMPTY:
- case VT_NULL: break;
- default: TRACE(",?"); break;
- }
- }
- TRACE("}\n");
-}
-
static void dump_DispParms(const DISPPARAMS * pdp)
{
unsigned int index;
{
TRACE("args:\n");
for (index = 0; index < pdp->cArgs; index++)
- dump_Variant( &pdp->rgvarg[index] );
+ TRACE(" [%d] %s\n", index, debugstr_variant(pdp->rgvarg+index));
}
}
args[argspos++] = V_UI4(arg);
break;
}
- TRACE("arg %u: type %d\n",i,prgvt[i]);
- dump_Variant(arg);
+ TRACE("arg %u: type %s %s\n", i, debugstr_vt(prgvt[i]), debugstr_variant(arg));
}
switch (vtReturn)
return DISP_E_BADCALLEE;
}
if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn;
- TRACE("retval: "); dump_Variant(pvargResult);
+ TRACE("retval: %s\n", debugstr_variant(pvargResult));
return S_OK;
#elif defined(__x86_64__)
args[argspos++] = V_UI8(arg);
break;
}
- TRACE("arg %u: type %d\n",i,prgvt[i]);
- dump_Variant(arg);
+ TRACE("arg %u: type %s %s\n", i, debugstr_vt(prgvt[i]), debugstr_variant(arg));
}
switch (vtReturn)
}
heap_free( args );
if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn;
- TRACE("retval: "); dump_Variant(pvargResult);
+ TRACE("retval: %s\n", debugstr_variant(pvargResult));
return S_OK;
#else
}
else if (src_arg)
{
- dump_Variant(src_arg);
+ TRACE("%s\n", debugstr_variant(src_arg));
if(rgvt[i]!=V_VT(src_arg))
{
if (FAILED(hres))
{
- ERR("failed to convert param %d to %s%s from %s%s\n", i,
- debugstr_vt(rgvt[i]), debugstr_vf(rgvt[i]),
- debugstr_VT(src_arg), debugstr_VF(src_arg));
+ ERR("failed to convert param %d to %s from %s\n", i,
+ debugstr_vt(rgvt[i]), debugstr_variant(src_arg));
break;
}
prgpvarg[i] = &rgvarg[i];
continue;
else if (wParamFlags & PARAMFLAG_FRETVAL)
{
- if (TRACE_ON(ole))
- {
- TRACE("[retval] value: ");
- dump_Variant(prgpvarg[i]);
- }
+ TRACE("[retval] value: %s\n", debugstr_variant(prgpvarg[i]));
if (pVarResult)
{
}
if (V_VT(&varresult) != VT_ERROR)
{
- TRACE("varresult value: ");
- dump_Variant(&varresult);
+ TRACE("varresult value: %s\n", debugstr_variant(&varresult));
if (pVarResult)
{
const BYTE* pToken = NULL;
HRESULT hRes = S_OK;
- TRACE("(%p->(%s%s),%s,%p,0x%08x,%p,0x%08x)\n", pVarIn, debugstr_VT(pVarIn),
- debugstr_VF(pVarIn), debugstr_w(lpszFormat), rgbTok, dwFlags, pbstrOut,
- lcid);
+ TRACE("(%s,%s,%p,0x%08x,%p,0x%08x)\n", debugstr_variant(pVarIn), debugstr_w(lpszFormat),
+ rgbTok, dwFlags, pbstrOut, lcid);
V_VT(&vString) = VT_EMPTY;
V_VT(&vBool) = VT_BOOL;
const BYTE* pToken = NULL;
HRESULT hRes;
- TRACE("(%p->(%s%s),%s,%p,0x%08x,%p,0x%08x)\n", pVarIn, debugstr_VT(pVarIn),
- debugstr_VF(pVarIn), debugstr_w(lpszFormat), rgbTok, dwFlags, pbstrOut,
- lcid);
+ TRACE("(%s,%s,%p,0x%08x,%p,0x%08x)\n", debugstr_variant(pVarIn),
+ debugstr_w(lpszFormat), rgbTok, dwFlags, pbstrOut, lcid);
V_VT(&vDate) = VT_EMPTY;
BOOL bUpper = FALSE;
HRESULT hRes = S_OK;
- TRACE("(%p->(%s%s),%s,%p,0x%08x,%p,0x%08x)\n", pVarIn, debugstr_VT(pVarIn),
- debugstr_VF(pVarIn), debugstr_w(lpszFormat), rgbTok, dwFlags, pbstrOut,
- lcid);
+ TRACE("%s,%s,%p,0x%08x,%p,0x%08x)\n", debugstr_variant(pVarIn), debugstr_w(lpszFormat),
+ rgbTok, dwFlags, pbstrOut, lcid);
V_VT(&vStr) = VT_EMPTY;
BYTE buff[256];
HRESULT hres;
- TRACE("(%p->(%s%s),%s,%d,%d,0x%08x,%p)\n", pVarIn, debugstr_VT(pVarIn),
- debugstr_VF(pVarIn), debugstr_w(lpszFormat), nFirstDay, nFirstWeek,
- dwFlags, pbstrOut);
+ TRACE("(%s,%s,%d,%d,0x%08x,%p)\n", debugstr_variant(pVarIn), debugstr_w(lpszFormat),
+ nFirstDay, nFirstWeek, dwFlags, pbstrOut);
if (!pbstrOut)
return E_INVALIDARG;
static WCHAR szEmpty[] = { '\0' };
const BYTE* lpFmt = NULL;
- TRACE("(%p->(%s%s),%d,0x%08x,%p)\n", pVarIn, debugstr_VT(pVarIn),
- debugstr_VF(pVarIn), nFormat, dwFlags, pbstrOut);
+ TRACE("%s,%d,0x%08x,%p)\n", debugstr_variant(pVarIn), nFormat, dwFlags, pbstrOut);
if (!pVarIn || !pbstrOut || nFormat < 0 || nFormat > 4)
return E_INVALIDARG;
HRESULT hRet;
VARIANT vStr;
- TRACE("(%p->(%s%s),%d,%d,%d,%d,0x%08x,%p)\n", pVarIn, debugstr_VT(pVarIn),
- debugstr_VF(pVarIn), nDigits, nLeading, nParens, nGrouping, dwFlags, pbstrOut);
+ TRACE("(%s,%d,%d,%d,%d,0x%08x,%p)\n", debugstr_variant(pVarIn), nDigits, nLeading,
+ nParens, nGrouping, dwFlags, pbstrOut);
if (!pVarIn || !pbstrOut || nDigits > 9)
return E_INVALIDARG;
HRESULT hRet;
VARIANT vDbl;
- TRACE("(%p->(%s%s),%d,%d,%d,%d,0x%08x,%p)\n", pVarIn, debugstr_VT(pVarIn),
- debugstr_VF(pVarIn), nDigits, nLeading, nParens, nGrouping,
- dwFlags, pbstrOut);
+ TRACE("(%s,%d,%d,%d,%d,0x%08x,%p)\n", debugstr_variant(pVarIn), nDigits, nLeading,
+ nParens, nGrouping, dwFlags, pbstrOut);
if (!pVarIn || !pbstrOut || nDigits > 9)
return E_INVALIDARG;
HRESULT hRet;
VARIANT vStr;
- TRACE("(%p->(%s%s),%d,%d,%d,%d,0x%08x,%p)\n", pVarIn, debugstr_VT(pVarIn),
- debugstr_VF(pVarIn), nDigits, nLeading, nParens, nGrouping, dwFlags, pbstrOut);
+ TRACE("(%s,%d,%d,%d,%d,0x%08x,%p)\n", debugstr_variant(pVarIn), nDigits, nLeading,
+ nParens, nGrouping, dwFlags, pbstrOut);
if (!pVarIn || !pbstrOut || nDigits > 9)
return E_INVALIDARG;
WINE_DEFAULT_DEBUG_CHANNEL(variant);
-const char * const wine_vtypes[VT_CLSID+1] =
+static const char * const variant_types[] =
{
"VT_EMPTY","VT_NULL","VT_I2","VT_I4","VT_R4","VT_R8","VT_CY","VT_DATE",
"VT_BSTR","VT_DISPATCH","VT_ERROR","VT_BOOL","VT_VARIANT","VT_UNKNOWN",
"VT_RECORD","VT_INT_PTR","VT_UINT_PTR","39","40","41","42","43","44","45",
"46","47","48","49","50","51","52","53","54","55","56","57","58","59","60",
"61","62","63","VT_FILETIME","VT_BLOB","VT_STREAM","VT_STORAGE",
- "VT_STREAMED_OBJECT","VT_STORED_OBJECT","VT_BLOB_OBJECT","VT_CF","VT_CLSID"
+ "VT_STREAMED_OBJECT","VT_STORED_OBJECT","VT_BLOB_OBJECT","VT_CF","VT_CLSID",
+ "VT_VERSIONED_STREAM"
};
-const char * const wine_vflags[16] =
+static const char * const variant_flags[16] =
{
"",
"|VT_VECTOR",
"|VT_VECTOR|VT_ARRAY",
"|VT_ARRAY|VT_BYREF",
"|VT_VECTOR|VT_ARRAY|VT_BYREF",
- "|VT_HARDTYPE",
- "|VT_VECTOR|VT_HARDTYPE",
- "|VT_ARRAY|VT_HARDTYPE",
- "|VT_VECTOR|VT_ARRAY|VT_HARDTYPE",
- "|VT_BYREF|VT_HARDTYPE",
- "|VT_VECTOR|VT_ARRAY|VT_HARDTYPE",
- "|VT_ARRAY|VT_BYREF|VT_HARDTYPE",
- "|VT_VECTOR|VT_ARRAY|VT_BYREF|VT_HARDTYPE",
+ "|VT_RESERVED",
+ "|VT_VECTOR|VT_RESERVED",
+ "|VT_ARRAY|VT_RESERVED",
+ "|VT_VECTOR|VT_ARRAY|VT_RESERVED",
+ "|VT_BYREF|VT_RESERVED",
+ "|VT_VECTOR|VT_ARRAY|VT_RESERVED",
+ "|VT_ARRAY|VT_BYREF|VT_RESERVED",
+ "|VT_VECTOR|VT_ARRAY|VT_BYREF|VT_RESERVED",
};
/* Convert a variant from one type to another */
VARTYPE vtFrom = V_TYPE(ps);
DWORD dwFlags = 0;
- TRACE("(%p->(%s%s),0x%08x,0x%04x,%p->(%s%s),%s%s)\n", pd, debugstr_VT(pd),
- debugstr_VF(pd), lcid, wFlags, ps, debugstr_VT(ps), debugstr_VF(ps),
- debugstr_vt(vt), debugstr_vf(vt));
+ TRACE("(%s,0x%08x,0x%04x,%s,%s)\n", debugstr_variant(pd), lcid, wFlags,
+ debugstr_variant(ps), debugstr_vt(vt));
if (vt == VT_BSTR || vtFrom == VT_BSTR)
{
{
HRESULT hres;
- TRACE("(%p->(%s%s))\n", pVarg, debugstr_VT(pVarg), debugstr_VF(pVarg));
+ TRACE("(%s)\n", debugstr_variant(pVarg));
hres = VARIANT_ValidateType(V_VT(pVarg));
if (FAILED(hres))
{
HRESULT hres;
- TRACE("(%p->(%s%s))\n", pVarg, debugstr_VT(pVarg), debugstr_VF(pVarg));
+ TRACE("(%s)\n", debugstr_variant(pVarg));
hres = VARIANT_ValidateType(V_VT(pVarg));
{
HRESULT hres = S_OK;
- TRACE("(%p->(%s%s),%p->(%s%s))\n", pvargDest, debugstr_VT(pvargDest),
- debugstr_VF(pvargDest), pvargSrc, debugstr_VT(pvargSrc),
- debugstr_VF(pvargSrc));
+ TRACE("(%s,%s)\n", debugstr_variant(pvargDest), debugstr_variant(pvargSrc));
if (V_TYPE(pvargSrc) == VT_CLSID || /* VT_CLSID is a special case */
FAILED(VARIANT_ValidateType(V_VT(pvargSrc))))
case VT_CY: return sizeof(CY);
case VT_ERROR: return sizeof(SCODE);
}
- TRACE("Shouldn't be called for vt %s%s!\n", debugstr_VT(pv), debugstr_VF(pv));
+ TRACE("Shouldn't be called for variant %s!\n", debugstr_variant(pv));
return 0;
}
VARTYPE vt;
HRESULT hres = S_OK;
- TRACE("(%p->(%s%s),%p->(%s%s))\n", pvargDest, debugstr_VT(pvargDest),
- debugstr_VF(pvargDest), pvargSrc, debugstr_VT(pvargSrc),
- debugstr_VF(pvargSrc));
+ TRACE("(%s,%s)\n", debugstr_variant(pvargDest), debugstr_variant(pvargSrc));
if (!V_ISBYREF(pvargSrc))
return VariantCopy(pvargDest, pvargSrc);
if (pSrc != pvargSrc)
VariantClear(pSrc);
- TRACE("returning 0x%08x, %p->(%s%s)\n", hres, pvargDest,
- debugstr_VT(pvargDest), debugstr_VF(pvargDest));
+ TRACE("returning 0x%08x, %s\n", hres, debugstr_variant(pvargDest));
return hres;
}
{
HRESULT res = S_OK;
- TRACE("(%p->(%s%s),%p->(%s%s),0x%08x,0x%04x,%s%s)\n", pvargDest,
- debugstr_VT(pvargDest), debugstr_VF(pvargDest), pvargSrc,
- debugstr_VT(pvargSrc), debugstr_VF(pvargSrc), lcid, wFlags,
- debugstr_vt(vt), debugstr_vf(vt));
+ TRACE("(%s,%s,0x%08x,0x%04x,%s)\n", debugstr_variant(pvargDest),
+ debugstr_variant(pvargSrc), lcid, wFlags, debugstr_vt(vt));
if (vt == VT_CLSID)
res = DISP_E_BADVARTYPE;
if (SUCCEEDED(res)) {
V_VT(&vTmp) = vt;
- VariantCopy(pvargDest, &vTmp);
+ res = VariantCopy(pvargDest, &vTmp);
}
VariantClear(&vTmp);
VariantClear(&vSrcDeref);
}
}
- TRACE("returning 0x%08x, %p->(%s%s)\n", res, pvargDest,
- debugstr_VT(pvargDest), debugstr_VF(pvargDest));
+ TRACE("returning 0x%08x, %s\n", res, debugstr_variant(pvargDest));
return res;
}
HRESULT WINAPI VarDateFromUdateEx(UDATE *pUdateIn, LCID lcid, ULONG dwFlags, DATE *pDateOut)
{
UDATE ud;
- double dateVal, dateSign;
+ double dateVal = 0;
TRACE("(%p->%d/%d/%d %d:%d:%d:%d %d %d,0x%08x,0x%08x,%p)\n", pUdateIn,
pUdateIn->st.wMonth, pUdateIn->st.wDay, pUdateIn->st.wYear,
if (lcid != MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT))
FIXME("lcid possibly not handled, treating as en-us\n");
+ if (dwFlags & ~(VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY))
+ FIXME("unsupported flags: %x\n", dwFlags);
ud = *pUdateIn;
return E_INVALIDARG;
/* Date */
- dateVal = VARIANT_DateFromJulian(VARIANT_JulianFromDMY(ud.st.wYear, ud.st.wMonth, ud.st.wDay));
+ if (!(dwFlags & VAR_TIMEVALUEONLY))
+ dateVal = VARIANT_DateFromJulian(VARIANT_JulianFromDMY(ud.st.wYear, ud.st.wMonth, ud.st.wDay));
- /* Sign */
- dateSign = (dateVal < 0.0) ? -1.0 : 1.0;
+ if ((dwFlags & VAR_TIMEVALUEONLY) || !(dwFlags & VAR_DATEVALUEONLY))
+ {
+ double dateSign = (dateVal < 0.0) ? -1.0 : 1.0;
- /* Time */
- dateVal += ud.st.wHour / 24.0 * dateSign;
- dateVal += ud.st.wMinute / 1440.0 * dateSign;
- dateVal += ud.st.wSecond / 86400.0 * dateSign;
+ /* Time */
+ dateVal += ud.st.wHour / 24.0 * dateSign;
+ dateVal += ud.st.wMinute / 1440.0 * dateSign;
+ dateVal += ud.st.wSecond / 86400.0 * dateSign;
+ }
TRACE("Returning %g\n", dateVal);
*pDateOut = dateVal;
leftvt = V_VT(left);
rightvt = V_VT(right);
- TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
- debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), out);
+ TRACE("%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), out);
if (!str_true[0]) {
VARIANT_GetLocalisedText(LOCALE_USER_DEFAULT, IDS_FALSE, str_false);
DWORD xmask;
HRESULT rc;
- TRACE("(%p->(%s%s),%p->(%s%s),0x%08x,0x%08x)\n", left, debugstr_VT(left),
- debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), lcid, flags);
+ TRACE("(%s,%s,0x%08x,0x%08x)\n", debugstr_variant(left), debugstr_variant(right), lcid, flags);
lvt = V_VT(left) & VT_TYPEMASK;
rvt = V_VT(right) & VT_TYPEMASK;
VariantInit(&tempLeft);
VariantInit(&tempRight);
- TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
- debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result);
+ TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
/* Handle VT_DISPATCH by storing and taking address of returned value */
if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH)
else if (leftvt == VT_I4 || rightvt == VT_I4 ||
leftvt == VT_UINT || rightvt == VT_UINT ||
leftvt == VT_INT || rightvt == VT_INT ||
- leftvt == VT_UINT || rightvt == VT_UINT ||
leftvt == VT_R4 || rightvt == VT_R4 ||
leftvt == VT_R8 || rightvt == VT_R8 ||
leftvt == VT_CY || rightvt == VT_CY ||
vt_ERROR, vt_ERROR, vt_UI1, vt_ERROR, vt_ERROR, vt_I8
};
- TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
- debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right),
- result);
+ TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
VariantInit(&lv);
VariantInit(&rv);
VariantClear(&tv);
VariantClear(&tempLeft);
VariantClear(&tempRight);
- TRACE("returning 0x%8x (variant type %s)\n", hres, debugstr_VT(result));
+ TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
return hres;
}
vt_ERROR, vt_ERROR, vt_UI1, vt_ERROR, vt_ERROR, vt_I8
};
- TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
- debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right),
- result);
+ TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
VariantInit(&lv);
VariantInit(&rv);
VariantClear(&tv);
VariantClear(&tempLeft);
VariantClear(&tempRight);
- TRACE("returning 0x%8x (variant type %s)\n", hres, debugstr_VT(result));
+ TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
return hres;
}
VariantInit(&lv);
VariantInit(&rv);
- TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
- debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result);
+ TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
/* Handle VT_DISPATCH by storing and taking address of returned value */
if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH)
VariantClear(&rv);
VariantClear(&tempLeft);
VariantClear(&tempRight);
- TRACE("returning 0x%8x (variant type %s)\n", hres, debugstr_VT(result));
+ TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
return hres;
}
VariantInit(&tempLeft);
VariantInit(&tempRight);
- TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
- debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result);
+ TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH &&
(V_VT(left)&(~VT_TYPEMASK)) == 0 &&
VariantClear(&rv);
VariantClear(&tempLeft);
VariantClear(&tempRight);
- TRACE("returning 0x%8x (variant type %s)\n", hres, debugstr_VT(result));
+ TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
return hres;
}
VariantInit(&varRight);
VariantInit(&varStr);
- TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", pVarLeft, debugstr_VT(pVarLeft),
- debugstr_VF(pVarLeft), pVarRight, debugstr_VT(pVarRight),
- debugstr_VF(pVarRight), pVarOut);
+ TRACE("(%s,%s,%p)\n", debugstr_variant(pVarLeft), debugstr_variant(pVarRight), pVarOut);
/* Handle VT_DISPATCH by storing and taking address of returned value */
if ((V_VT(pVarLeft) & VT_TYPEMASK) == VT_DISPATCH)
VariantInit(&temp);
- TRACE("(%p->(%s%s),%p)\n", pVarIn, debugstr_VT(pVarIn),
- debugstr_VF(pVarIn), pVarOut);
+ TRACE("(%s,%p)\n", debugstr_variant(pVarIn), pVarOut);
/* Handle VT_DISPATCH by storing and taking address of returned value */
if ((V_VT(pVarIn) & VT_TYPEMASK) == VT_DISPATCH && ((V_VT(pVarIn) & ~VT_TYPEMASK) == 0))
VariantInit(&temp);
- TRACE("(%p->(%s%s),%p)\n", pVarIn, debugstr_VT(pVarIn),
- debugstr_VF(pVarIn), pVarOut);
+ TRACE("(%s,%p)\n", debugstr_variant(pVarIn), pVarOut);
/* Handle VT_DISPATCH by storing and taking address of returned value */
if ((V_VT(pVarIn) & VT_TYPEMASK) == VT_DISPATCH && ((V_VT(pVarIn) & ~VT_TYPEMASK) == 0))
VariantInit(&temp);
- TRACE("(%p->(%s%s),%p)\n", pVarIn, debugstr_VT(pVarIn),
- debugstr_VF(pVarIn), pVarOut);
+ TRACE("(%s,%p)\n", debugstr_variant(pVarIn), pVarOut);
/* Handle VT_DISPATCH by storing and taking address of returned value */
if ((V_VT(pVarIn) & VT_TYPEMASK) == VT_DISPATCH && ((V_VT(pVarIn) & ~VT_TYPEMASK) == 0))
double d;
HRESULT hRet;
- TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", pVarLeft, debugstr_VT(pVarLeft),
- debugstr_VF(pVarLeft), pVarRight, debugstr_VT(pVarRight),
- debugstr_VF(pVarRight), pVarOut);
+ TRACE("(%s,%s,%p)\n", debugstr_variant(pVarLeft), debugstr_variant(pVarRight), pVarOut);
if (V_EXTRA_TYPE(pVarLeft) || V_EXTRA_TYPE(pVarRight) ||
V_VT(pVarLeft) > VT_UINT || V_VT(pVarRight) > VT_UINT ||
{
HRESULT hRet;
- TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", pVarLeft, debugstr_VT(pVarLeft),
- debugstr_VF(pVarLeft), pVarRight, debugstr_VT(pVarRight),
- debugstr_VF(pVarRight), pVarOut);
+ TRACE("(%s,%s,%p)\n", debugstr_variant(pVarLeft), debugstr_variant(pVarRight), pVarOut);
hRet = VarXor(pVarLeft, pVarRight, pVarOut);
if (SUCCEEDED(hRet))
VariantInit(&temp);
- TRACE("(%p->(%s%s),%p)\n", pVarIn, debugstr_VT(pVarIn),
- debugstr_VF(pVarIn), pVarOut);
+ TRACE("(%s,%p)\n", debugstr_variant(pVarIn), pVarOut);
/* Handle VT_DISPATCH by storing and taking address of returned value */
if ((V_VT(pVarIn) & VT_TYPEMASK) == VT_DISPATCH && ((V_VT(pVarIn) & ~VT_TYPEMASK) == 0))
VariantInit(&temp);
- TRACE("(%p->(%s%s),%p)\n", pVarIn, debugstr_VT(pVarIn),
- debugstr_VF(pVarIn), pVarOut);
+ TRACE("(%s,%p)\n", debugstr_variant(pVarIn), pVarOut);
/* Handle VT_DISPATCH by storing and taking address of returned value */
if ((V_VT(pVarIn) & VT_TYPEMASK) == VT_DISPATCH && ((V_VT(pVarIn) & ~VT_TYPEMASK) == 0))
VariantInit(&temp);
- TRACE("(%p->(%s%s),%d)\n", pVarIn, debugstr_VT(pVarIn), debugstr_VF(pVarIn), deci);
+ TRACE("(%s,%d)\n", debugstr_variant(pVarIn), deci);
/* Handle VT_DISPATCH by storing and taking address of returned value */
if ((V_VT(pVarIn) & VT_TYPEMASK) == VT_DISPATCH && ((V_VT(pVarIn) & ~VT_TYPEMASK) == 0))
V_VT(pVarOut) = VT_EMPTY;
VariantClear(&temp);
- TRACE("returning 0x%08x (%s%s),%f\n", hRet, debugstr_VT(pVarOut),
- debugstr_VF(pVarOut), (V_VT(pVarOut) == VT_R4) ? V_R4(pVarOut) :
- (V_VT(pVarOut) == VT_R8) ? V_R8(pVarOut) : 0);
-
+ TRACE("returning 0x%08x %s\n", hRet, debugstr_variant(pVarOut));
return hRet;
}
VARIANT lv,rv;
VARIANT tempLeft, tempRight;
- TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
- debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result);
+ TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
VariantInit(&lv);
VariantInit(&rv);
VariantInit(&lv);
VariantInit(&rv);
- TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
- debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result);
+ TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
/* Handle VT_DISPATCH by storing and taking address of returned value */
if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH)
VARTYPE rightExtraFlags,leftExtraFlags,ExtraFlags;
VARIANT tempLeft, tempRight;
- TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left), debugstr_VF(left),
- right, debugstr_VT(right), debugstr_VF(right), result);
+ TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
VariantInit(&dl);
VariantInit(&dr);
VariantInit(&tempLeft);
VariantInit(&tempRight);
- TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
- debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result);
+ TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
/* Handle VT_DISPATCH by storing and taking address of returned value */
if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH)