oleaut32 1/2: [RESEND] Fixes for function variant:VarDiv
Benjamin Arai
me at benjaminarai.com
Thu Aug 31 19:34:49 CDT 2006
Hi,
I just sent the same patches but James Hawkins said I should send
these in the reverse order because the fixes need to be applied first
to avoid crashes from the conformance test.
The two patches add a conformance test and fixes to the variant
function VarDiv. The original implementation crashed the conformance
test due to improper handling of certain variant types. The
conformance test (2/2) exposes the issues and the fix (1/2) addresses
all of them.
---
dlls/oleaut32/variant.c | 202 ++++++++++++++++++++++++++++++++++++-----------
1 files changed, 154 insertions(+), 48 deletions(-)
Copyright: Google
License: LGPL
--
Benjamin Arai
http://www.benjaminarai.com
-------------- next part --------------
diff --git a/dlls/oleaut32/variant.c b/dlls/oleaut32/variant.c
index b7114c9..c51533d 100644
--- a/dlls/oleaut32/variant.c
+++ b/dlls/oleaut32/variant.c
@@ -3534,65 +3534,171 @@ end:
*/
HRESULT WINAPI VarDiv(LPVARIANT left, LPVARIANT right, LPVARIANT result)
{
- HRESULT rc = E_FAIL;
- VARTYPE lvt,rvt,resvt;
+ HRESULT hres = S_OK;
+ VARTYPE resvt = VT_EMPTY;
+ VARTYPE leftvt,rightvt;
+ VARTYPE rightExtraFlags,leftExtraFlags,ExtraFlags;
VARIANT lv,rv;
- BOOL found;
+
+ leftvt = V_VT(left)&VT_TYPEMASK;
+ rightvt = V_VT(right)&VT_TYPEMASK;
+ leftExtraFlags = V_VT(left)&(~VT_TYPEMASK);
+ rightExtraFlags = V_VT(right)&(~VT_TYPEMASK);
+
+ if (leftExtraFlags != rightExtraFlags)
+ return DISP_E_BADVARTYPE;
+ ExtraFlags = leftExtraFlags;
TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left),
debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result);
- VariantInit(&lv);VariantInit(&rv);
- lvt = V_VT(left)&VT_TYPEMASK;
- rvt = V_VT(right)&VT_TYPEMASK;
- found = FALSE;resvt = VT_VOID;
- if (((1<<lvt) | (1<<rvt)) & (VTBIT_R4|VTBIT_R8|VTBIT_CY)) {
- found = TRUE;
- resvt = VT_R8;
- }
- if (!found && (((1<<lvt) | (1<<rvt)) & (VTBIT_DECIMAL))) {
- found = TRUE;
- resvt = VT_DECIMAL;
- }
- if (!found && (((1<<lvt) | (1<<rvt)) & (VTBIT_I1|VTBIT_I2|VTBIT_UI1|VTBIT_UI2|VTBIT_I4|VTBIT_UI4|VTBIT_INT|VTBIT_UINT))) {
- found = TRUE;
- resvt = VT_I4;
- }
- if (!found) {
- FIXME("can't expand vt %d vs %d to a target type.\n",lvt,rvt);
- return E_FAIL;
+ /* All extra flags produce errors */
+ if (ExtraFlags == (VT_RESERVED|VT_ARRAY|VT_VECTOR|VT_BYREF) ||
+ ExtraFlags == (VT_RESERVED|VT_ARRAY|VT_VECTOR) ||
+ ExtraFlags == (VT_ARRAY|VT_RESERVED|VT_BYREF) ||
+ ExtraFlags == (VT_ARRAY|VT_VECTOR|VT_BYREF) ||
+ ExtraFlags == (VT_ARRAY|VT_RESERVED) ||
+ ExtraFlags == (VT_ARRAY|VT_VECTOR) ||
+ ExtraFlags == (VT_ARRAY|VT_BYREF) ||
+ ExtraFlags == (VT_ARRAY))
+ return DISP_E_TYPEMISMATCH;
+ else if (ExtraFlags)
+ return DISP_E_BADVARTYPE;
+ /* Handling for all remaining errors and return types */
+ /* The following flags/types are invalid for left variant */
+ else if (!((leftvt <= VT_LPWSTR) && leftvt != (VARTYPE)15 &&
+ (leftvt < VT_VOID || leftvt > VT_LPWSTR)))
+ return DISP_E_BADVARTYPE;
+ /* The following flags/types are invalid for right variant */
+ else if (!((rightvt <= VT_LPWSTR) && rightvt != (VARTYPE)15 &&
+ (rightvt < VT_VOID || rightvt > VT_LPWSTR)))
+ return DISP_E_BADVARTYPE;
+ else if (rightvt == VT_EMPTY)
+ if (leftvt == VT_I1 || leftvt == VT_VARIANT ||
+ leftvt == VT_UI2 || leftvt == VT_UI2 ||
+ leftvt == VT_UI4 || leftvt == VT_UI8 ||
+ leftvt == VT_INT || leftvt == VT_UINT)
+ return DISP_E_BADVARTYPE;
+ else if (leftvt == VT_NULL)
+ {
+ V_VT(result) = VT_NULL;
+ return S_OK;
+ }
+ else if (leftvt == VT_DECIMAL || leftvt == VT_BSTR)
+ return DISP_E_DIVBYZERO;
+ else if (leftvt == VT_ERROR)
+ return DISP_E_TYPEMISMATCH;
+ else
+ return DISP_E_OVERFLOW;
+ else if (rightvt == VT_NULL && leftvt != VT_ERROR)
+ if (leftvt == VT_I1 || leftvt == VT_UI2 ||
+ leftvt == VT_UI2 || leftvt == VT_UI4 ||
+ leftvt == VT_VARIANT || leftvt == VT_UI8 ||
+ leftvt == VT_INT || leftvt == VT_UINT)
+ return DISP_E_BADVARTYPE;
+ else
+ {
+ V_VT(result) = VT_NULL;
+ return S_OK;
+ }
+ else if (leftvt == VT_ERROR || rightvt == VT_ERROR)
+ if (leftvt != rightvt &&(rightvt == VT_I1 ||
+ leftvt == VT_I1 || leftvt == VT_UI2 ||
+ leftvt == VT_UI4 || leftvt == VT_UI8 ||
+ leftvt == VT_INT || leftvt == VT_UINT ||
+ rightvt == VT_UI2 || rightvt == VT_UI4 ||
+ rightvt == VT_UI8 || rightvt == VT_INT ||
+ rightvt == VT_UINT || rightvt == VT_VARIANT ||
+ leftvt == VT_VARIANT))
+ return DISP_E_BADVARTYPE;
+ else
+ return DISP_E_TYPEMISMATCH;
+ else if (leftvt == VT_CLSID || rightvt == VT_CLSID ||
+ leftvt == VT_VARIANT || rightvt == VT_VARIANT ||
+ leftvt == VT_I1 || rightvt == VT_VARIANT ||
+ leftvt == VT_UI2 || leftvt == VT_UI4 ||
+ leftvt == VT_UI8 || leftvt == VT_INT ||
+ leftvt == VT_UINT)
+ return DISP_E_BADVARTYPE;
+ else if (leftvt == VT_BSTR && rightvt == VT_EMPTY)
+ return DISP_E_DIVBYZERO;
+ else if (leftvt == VT_I2 || rightvt == VT_I2 ||
+ leftvt == VT_I4 || rightvt == VT_I4 ||
+ leftvt == VT_R4 || rightvt == VT_R4 ||
+ leftvt == VT_R8 || rightvt == VT_R8 ||
+ leftvt == VT_CY || rightvt == VT_CY ||
+ leftvt == VT_DATE || rightvt == VT_DATE ||
+ leftvt == VT_BSTR || rightvt == VT_BSTR ||
+ leftvt == VT_BOOL || rightvt == VT_BOOL ||
+ leftvt == VT_UI1 || rightvt == VT_UI1 ||
+ leftvt == VT_I8 || rightvt == VT_I8 ||
+ leftvt == VT_NULL || leftvt == VT_DECIMAL ||
+ leftvt == VT_EMPTY)
+ {
+ if (rightvt == VT_UI2 || rightvt == VT_UI4 ||
+ rightvt == VT_UI8 || rightvt == VT_INT ||
+ rightvt == VT_UINT || rightvt == VT_I1)
+ return DISP_E_BADVARTYPE;
+ else
+ {
+ if (leftvt == VT_NULL)
+ {
+ V_VT(result) = VT_NULL;
+ return S_OK;
+ }
+ else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
+ resvt = VT_DECIMAL;
+ else if (leftvt == VT_R4 && (rightvt == VT_I2 ||
+ rightvt == VT_R4 || rightvt == VT_BOOL ||
+ rightvt == VT_UI1))
+ resvt = VT_R4;
+ else if (rightvt == VT_R4 && (leftvt == VT_I2 ||
+ leftvt == VT_BOOL || leftvt == VT_UI1 ||
+ leftvt == VT_EMPTY))
+ resvt = VT_R4;
+ else
+ resvt = VT_R8;
+ }
}
- rc = VariantChangeType(&lv, left, 0, resvt);
- if (FAILED(rc)) {
- FIXME("Could not convert 0x%x to %d?\n",V_VT(left),resvt);
- return rc;
+
+ VariantInit(&lv);
+ VariantInit(&rv);
+
+ /* coerce to the result type */
+ hres = VariantChangeType(&lv, left, 0, resvt);
+ if (hres != S_OK)
+ {
+ VariantClear(&lv);
+ VariantClear(&rv);
+ return hres;
}
- rc = VariantChangeType(&rv, right, 0, resvt);
- if (FAILED(rc)) {
- FIXME("Could not convert 0x%x to %d?\n",V_VT(right),resvt);
- return rc;
+ hres = VariantChangeType(&rv, right, 0, resvt);
+ if (hres != S_OK)
+ {
+ VariantClear(&lv);
+ VariantClear(&rv);
+ return hres;
}
- switch (resvt) {
+
+ /* do the math */
+ V_VT(result) = resvt;
+ switch (resvt)
+ {
+ case VT_R4:
+ V_R4(result) = V_R4(&lv) / V_R4(&rv);
+ break;
case VT_R8:
- if (V_R8(&rv) == 0) return DISP_E_DIVBYZERO;
- V_VT(result) = resvt;
- V_R8(result) = V_R8(&lv) / V_R8(&rv);
- rc = S_OK;
- break;
+ V_R8(result) = V_R8(&lv) / V_R8(&rv);
+ break;
case VT_DECIMAL:
- rc = VarDecDiv(&(V_DECIMAL(&lv)), &(V_DECIMAL(&rv)), &(V_DECIMAL(result)));
- V_VT(result) = resvt;
- break;
- case VT_I4:
- if (V_I4(&rv) == 0) return DISP_E_DIVBYZERO;
- V_VT(result) = resvt;
- V_I4(result) = V_I4(&lv) / V_I4(&rv);
- rc = S_OK;
- break;
+ hres = VarDecDiv(&(V_DECIMAL(&lv)), &(V_DECIMAL(&rv)), &(V_DECIMAL(result)));
+ break;
}
- TRACE("returning 0x%8lx (%s%s),%g\n", rc, debugstr_VT(result),
- debugstr_VF(result), V_VT(result) == VT_R8 ? V_R8(result) : (double)V_I4(result));
- return rc;
+
+ VariantClear(&lv);
+ VariantClear(&rv);
+
+ return hres;
}
/**********************************************************************
--
1.4.0
More information about the wine-patches
mailing list