[PATCH v9 0/2] MR8635: oleaut32: Add VarNumFromStr to convert VT_BSTR to numeric or boolean

diff --git a/dlls/oleaut32/tests/vartest.c b/dlls/oleaut32/tests/vartest.c index eb1639e3990..41e9539917e 100644 --- a/dlls/oleaut32/tests/vartest.c +++ b/dlls/oleaut32/tests/vartest.c @@ -6783,18 +6783,25 @@ static void test_VarCat(void)

static HRESULT (WINAPI *pVarAnd)(LPVARIANT,LPVARIANT,LPVARIANT);

+ #define VARAND(vt1,val1,vt2,val2,rvt,rval) \ V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \ V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \ V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \ test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )

-#define VARANDCY(vt1,val1,val2,rvt,rval) \ +#define VARANDRCY(vt1,val1,val2,rvt,rval) \ V_VT(&left) = VT_##vt1; V_##vt1(&left) = val1; \ V_VT(&right) = VT_CY; V_CY(&right).int64 = val2; \ V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \ test_var_call2( __LINE__, pVarAnd, &left, &right, &exp )

+#define VARANDLCY(val1,vt2,val2,rvt,rval) \ + V_VT(&left) = VT_CY; V_CY(&left) .int64 = val1; \ + V_VT(&right) = VT_##vt2; V_##vt2(&right) = val2; \ + V_VT(&exp) = VT_##rvt; V_##rvt(&exp) = rval; \ + test_var_call2( __LINE__, pVarAnd, &left, &right, &exp ) + /* Skip any type that is not defined or produces an error for every case */ #define SKIPTESTAND(a) \ if (a == VT_ERROR || a == VT_VARIANT || \ @@ -6804,18 +6811,33 @@ static HRESULT (WINAPI *pVarAnd)(LPVARIANT,LPVARIANT,LPVARIANT);

static void test_VarAnd(void) { - static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' }; - static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' }; VARIANT left, right, exp, result; - BSTR false_str, true_str; VARTYPE i; HRESULT hres; + BSTR bstrtrue, bstrfalse, bstrmaxi2, bstrmini2, bstrmaxi4, bstrmini4, bstrmaxi8, bstrmini8, bstr1, bstr0; + BSTR bstrminus1, bstrminus42, bstrspaced1, bstrleading0, bstrfloat1p99, bstrfloatminus1p99, bstrsci1e2, bstrvbhex16; + + bstrtrue = SysAllocString(L"#TRUE#"); + bstrfalse = SysAllocString(L"#FALSE#"); + bstrmaxi2 = SysAllocString(L"32767"); + bstrmini2 = SysAllocString(L"-32768"); + bstrmaxi4 = SysAllocString(L"2147483647"); + bstrmini4 = SysAllocString(L"-2147483648"); + bstrmaxi8 = SysAllocString(L"9223372036854775807"); + bstrmini8 = SysAllocString(L"-9223372036854775807"); + bstr1 = SysAllocString(L"1"); + bstr0 = SysAllocString(L"0"); + bstrminus1 = SysAllocString(L"-1"); + bstrminus42 = SysAllocString(L"-42"); + bstrspaced1 = SysAllocString(L" 1 "); + bstrleading0 = SysAllocString(L"0000123"); + bstrfloat1p99 = SysAllocString(L"1.99"); + bstrfloatminus1p99 = SysAllocString(L"-1.99"); + bstrsci1e2 = SysAllocString(L"1e2"); + bstrvbhex16 = SysAllocString(L"&H10");

CHECKPTR(VarAnd);

- true_str = SysAllocString(szTrue); - false_str = SysAllocString(szFalse); - /* Test all possible flag/vt combinations & the resulting vt type */ for (i = 0; i < ARRAY_SIZE(ExtraFlags); i++) { @@ -6845,9 +6867,9 @@ static void test_VarAnd(void) V_VT(&result) = VT_EMPTY; resvt = VT_EMPTY; if ((leftvt | ExtraFlags[i]) == VT_BSTR) - V_BSTR(&left) = true_str; + V_BSTR(&left) = bstrtrue; if ((rightvt | ExtraFlags[i]) == VT_BSTR) - V_BSTR(&right) = true_str; + V_BSTR(&right) = bstrtrue;

/* Native VarAnd always returns an error when using extra * flags or if the variant combination is I8 and INT. @@ -6962,9 +6984,9 @@ static void test_VarAnd(void) VARAND(EMPTY,0,R8,0,I4,0); VARAND(EMPTY,0,R8,1,I4,0); VARAND(EMPTY,1,R8,1,I4,0); - VARAND(EMPTY,0,BSTR,false_str,I2,0); - VARAND(EMPTY,0,BSTR,true_str,I2,0); - VARANDCY(EMPTY,0,10000,I4,0); + VARAND(EMPTY,0,BSTR,bstrfalse,I2,0); + VARAND(EMPTY,0,BSTR,bstrtrue,I2,0); + VARANDRCY(EMPTY,0,10000,I4,0);

/* NULL OR 0 = NULL. NULL OR n = n */ VARAND(NULL,0,NULL,0,NULL,0); @@ -6998,10 +7020,10 @@ static void test_VarAnd(void) VARAND(NULL,0,R4,1,NULL,0); VARAND(NULL,0,R8,0,I4,0); VARAND(NULL,0,R8,1,NULL,0); - VARAND(NULL,0,BSTR,false_str,BOOL,0); - VARAND(NULL,0,BSTR,true_str,NULL,VARIANT_FALSE); - VARANDCY(NULL,0,10000,NULL,0); - VARANDCY(NULL,0,0,I4,0); + VARAND(NULL,0,BSTR,bstrfalse,BOOL,0); + VARAND(NULL,0,BSTR,bstrtrue,NULL,VARIANT_FALSE); + VARANDRCY(NULL,0,10000,NULL,0); + VARANDRCY(NULL,0,0,I4,0); VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE,BOOL,VARIANT_TRUE); VARAND(BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE,BOOL,VARIANT_FALSE); VARAND(BOOL,VARIANT_FALSE,BOOL,VARIANT_TRUE,BOOL,VARIANT_FALSE); @@ -7049,13 +7071,13 @@ static void test_VarAnd(void) VARAND(BOOL,VARIANT_TRUE,UINT,0xffffffff,I4,-1); VARAND(BOOL,VARIANT_TRUE,UINT,0,I4,0); VARAND(BOOL,VARIANT_FALSE,UINT,0,I4,0); - VARAND(BOOL,VARIANT_FALSE,BSTR,false_str,BOOL,VARIANT_FALSE); - VARAND(BOOL,VARIANT_TRUE,BSTR,false_str,BOOL,VARIANT_FALSE); - VARAND(BOOL,VARIANT_FALSE,BSTR,true_str,BOOL,VARIANT_FALSE); - VARAND(BOOL,VARIANT_TRUE,BSTR,true_str,BOOL,VARIANT_TRUE); - VARANDCY(BOOL,VARIANT_TRUE,10000,I4,1); - VARANDCY(BOOL,VARIANT_TRUE,0,I4,0); - VARANDCY(BOOL,VARIANT_FALSE,0,I4,0); + VARAND(BOOL,VARIANT_FALSE,BSTR,bstrfalse,BOOL,VARIANT_FALSE); + VARAND(BOOL,VARIANT_TRUE,BSTR,bstrfalse,BOOL,VARIANT_FALSE); + VARAND(BOOL,VARIANT_FALSE,BSTR,bstrtrue,BOOL,VARIANT_FALSE); + VARAND(BOOL,VARIANT_TRUE,BSTR,bstrtrue,BOOL,VARIANT_TRUE); + VARANDRCY(BOOL,VARIANT_TRUE,10000,I4,1); + VARANDRCY(BOOL,VARIANT_TRUE,0,I4,0); + VARANDRCY(BOOL,VARIANT_FALSE,0,I4,0); VARAND(I1,-1,I1,-1,I4,-1); VARAND(I1,-1,I1,0,I4,0); VARAND(I1,0,I1,0,I4,0); @@ -7097,13 +7119,13 @@ static void test_VarAnd(void) VARAND(I1,-1,UINT,0xffffffff,I4,-1); VARAND(I1,-1,UINT,0,I4,0); VARAND(I1,0,UINT,0,I4,0); - VARAND(I1,0,BSTR,false_str,I4,0); - VARAND(I1,-1,BSTR,false_str,I4,0); - VARAND(I1,0,BSTR,true_str,I4,0); - VARAND(I1,-1,BSTR,true_str,I4,-1); - VARANDCY(I1,-1,10000,I4,1); - VARANDCY(I1,-1,0,I4,0); - VARANDCY(I1,0,0,I4,0); + VARAND(I1,0,BSTR,bstrfalse,I4,0); + VARAND(I1,-1,BSTR,bstrfalse,I4,0); + VARAND(I1,0,BSTR,bstrtrue,I4,0); + VARAND(I1,-1,BSTR,bstrtrue,I4,-1); + VARANDRCY(I1,-1,10000,I4,1); + VARANDRCY(I1,-1,0,I4,0); + VARANDRCY(I1,0,0,I4,0);

VARAND(UI1,255,UI1,255,UI1,255); VARAND(UI1,255,UI1,0,UI1,0); @@ -7143,13 +7165,13 @@ static void test_VarAnd(void) VARAND(UI1,255,UINT,0xffffffff,I4,255); VARAND(UI1,255,UINT,0,I4,0); VARAND(UI1,0,UINT,0,I4,0); - VARAND(UI1,0,BSTR,false_str,I2,0); - VARAND(UI1,255,BSTR,false_str,I2,0); - VARAND(UI1,0,BSTR,true_str,I2,0); - VARAND(UI1,255,BSTR,true_str,I2,255); - VARANDCY(UI1,255,10000,I4,1); - VARANDCY(UI1,255,0,I4,0); - VARANDCY(UI1,0,0,I4,0); + VARAND(UI1,0,BSTR,bstrfalse,I2,0); + VARAND(UI1,255,BSTR,bstrfalse,I2,0); + VARAND(UI1,0,BSTR,bstrtrue,I2,0); + VARAND(UI1,255,BSTR,bstrtrue,I2,255); + VARANDRCY(UI1,255,10000,I4,1); + VARANDRCY(UI1,255,0,I4,0); + VARANDRCY(UI1,0,0,I4,0);

VARAND(I2,-1,I2,-1,I2,-1); VARAND(I2,-1,I2,0,I2,0); @@ -7186,13 +7208,14 @@ static void test_VarAnd(void) VARAND(I2,-1,UINT,0xffffffff,I4,-1); VARAND(I2,-1,UINT,0,I4,0); VARAND(I2,0,UINT,0,I4,0); - VARAND(I2,0,BSTR,false_str,I2,0); - VARAND(I2,-1,BSTR,false_str,I2,0); - VARAND(I2,0,BSTR,true_str,I2,0); - VARAND(I2,-1,BSTR,true_str,I2,-1); - VARANDCY(I2,-1,10000,I4,1); - VARANDCY(I2,-1,0,I4,0); - VARANDCY(I2,0,0,I4,0); + VARAND(I2,0,BSTR,bstrfalse,I2,0); + VARAND(I2,-1,BSTR,bstrfalse,I2,0); + VARAND(I2,0,BSTR,bstrtrue,I2,0); + VARAND(I2,-1,BSTR,bstrtrue,I2,-1); + VARANDRCY(I2,-1,10000,I4,1); + VARANDRCY(I2,-1,0,I4,0); + VARANDRCY(I2,0,0,I4,0); +

VARAND(UI2,65535,UI2,65535,I4,65535); VARAND(UI2,65535,UI2,0,I4,0); @@ -7226,13 +7249,13 @@ static void test_VarAnd(void) VARAND(UI2,65535,UINT,0xffffffff,I4,65535); VARAND(UI2,65535,UINT,0,I4,0); VARAND(UI2,0,UINT,0,I4,0); - VARAND(UI2,0,BSTR,false_str,I4,0); - VARAND(UI2,65535,BSTR,false_str,I4,0); - VARAND(UI2,0,BSTR,true_str,I4,0); - VARAND(UI2,65535,BSTR,true_str,I4,65535); - VARANDCY(UI2,65535,10000,I4,1); - VARANDCY(UI2,65535,0,I4,0); - VARANDCY(UI2,0,0,I4,0); + VARAND(UI2,0,BSTR,bstrfalse,I4,0); + VARAND(UI2,65535,BSTR,bstrfalse,I4,0); + VARAND(UI2,0,BSTR,bstrtrue,I4,0); + VARAND(UI2,65535,BSTR,bstrtrue,I4,65535); + VARANDRCY(UI2,65535,10000,I4,1); + VARANDRCY(UI2,65535,0,I4,0); + VARANDRCY(UI2,0,0,I4,0);

VARAND(I4,-1,I4,-1,I4,-1); VARAND(I4,-1,I4,0,I4,0); @@ -7263,13 +7286,23 @@ static void test_VarAnd(void) VARAND(I4,-1,UINT,0xffffffff,I4,-1); VARAND(I4,-1,UINT,0,I4,0); VARAND(I4,0,UINT,0,I4,0); - VARAND(I4,0,BSTR,false_str,I4,0); - VARAND(I4,-1,BSTR,false_str,I4,0); - VARAND(I4,0,BSTR,true_str,I4,0); - VARAND(I4,-1,BSTR,true_str,I4,-1); - VARANDCY(I4,-1,10000,I4,1); - VARANDCY(I4,-1,0,I4,0); - VARANDCY(I4,0,0,I4,0); + VARAND(I4,0,BSTR,bstrfalse,I4,0); + VARAND(I4,-1,BSTR,bstrfalse,I4,0); + VARAND(I4,0,BSTR,bstrtrue,I4,0); + VARAND(I4,-1,BSTR,bstrtrue,I4,-1); + VARAND(I4, 1, BSTR, bstrmaxi4, I4, (1 & 2147483647)); + VARAND(I4, 1, BSTR, bstrmini4, I4, (-2147483648 & 1)); + VARAND(I4, 1, BSTR, bstrleading0, I4, (1 &123)); + VARAND(I4, 1, BSTR, bstrspaced1, I4, (1 & 1)); + VARAND(I4, 1, BSTR, bstrminus1, I4, (1 & -1)); + VARAND(I4, 1, BSTR, bstr0, I4, (1 & 0)); + VARAND(I4, 1, BSTR, bstrminus42, I4, ( 1 & -42)); + VARAND(I4, 1, BSTR, bstrsci1e2, I4, (1 & 100)); + VARAND(I4, 1, BSTR, bstrfloat1p99, I4, 0); + VARAND(I4, 1, BSTR, bstrvbhex16, I4, (1 & 0x10)); + VARANDRCY(I4,-1,10000,I4,1); + VARANDRCY(I4,-1,0,I4,0); + VARANDRCY(I4,0,0,I4,0);

VARAND(UI4,0xffffffff,UI4,0xffffffff,I4,-1); VARAND(UI4,0xffffffff,UI4,0,I4,0); @@ -7296,13 +7329,13 @@ static void test_VarAnd(void) VARAND(UI4,0xffffffff,UINT,0xffffffff,I4,-1); VARAND(UI4,0xffffffff,UINT,0,I4,0); VARAND(UI4,0,UINT,0,I4,0); - VARAND(UI4,0,BSTR,false_str,I4,0); - VARAND(UI4,0xffffffff,BSTR,false_str,I4,0); - VARAND(UI4,0,BSTR,true_str,I4,0); - VARAND(UI4,0xffffffff,BSTR,true_str,I4,-1); - VARANDCY(UI4,0xffffffff,10000,I4,1); - VARANDCY(UI4,0xffffffff,0,I4,0); - VARANDCY(UI4,0,0,I4,0); + VARAND(UI4,0,BSTR,bstrfalse,I4,0); + VARAND(UI4,0xffffffff,BSTR,bstrfalse,I4,0); + VARAND(UI4,0,BSTR,bstrtrue,I4,0); + VARAND(UI4,0xffffffff,BSTR,bstrtrue,I4,-1); + VARANDRCY(UI4,0xffffffff,10000,I4,1); + VARANDRCY(UI4,0xffffffff,0,I4,0); + VARANDRCY(UI4,0,0,I4,0);

VARAND(R4,-1,R4,-1,I4,-1); VARAND(R4,-1,R4,0,I4,0); @@ -7327,13 +7360,13 @@ static void test_VarAnd(void) VARAND(R4,-1,UINT,0xffffffff,I4,-1); VARAND(R4,-1,UINT,0,I4,0); VARAND(R4,0,UINT,0,I4,0); - VARAND(R4,0,BSTR,false_str,I4,0); - VARAND(R4,-1,BSTR,false_str,I4,0); - VARAND(R4,0,BSTR,true_str,I4,0); - VARAND(R4,-1,BSTR,true_str,I4,-1); - VARANDCY(R4,-1,10000,I4,1); - VARANDCY(R4,-1,0,I4,0); - VARANDCY(R4,0,0,I4,0); + VARAND(R4,0,BSTR,bstrfalse,I4,0); + VARAND(R4,-1,BSTR,bstrfalse,I4,0); + VARAND(R4,0,BSTR,bstrtrue,I4,0); + VARAND(R4,-1,BSTR,bstrtrue,I4,-1); + VARANDRCY(R4,-1,10000,I4,1); + VARANDRCY(R4,-1,0,I4,0); + VARANDRCY(R4,0,0,I4,0);

VARAND(R8,-1,R8,-1,I4,-1); VARAND(R8,-1,R8,0,I4,0); @@ -7355,13 +7388,13 @@ static void test_VarAnd(void) VARAND(R8,-1,UINT,0xffffffff,I4,-1); VARAND(R8,-1,UINT,0,I4,0); VARAND(R8,0,UINT,0,I4,0); - VARAND(R8,0,BSTR,false_str,I4,0); - VARAND(R8,-1,BSTR,false_str,I4,0); - VARAND(R8,0,BSTR,true_str,I4,0); - VARAND(R8,-1,BSTR,true_str,I4,-1); - VARANDCY(R8,-1,10000,I4,1); - VARANDCY(R8,-1,0,I4,0); - VARANDCY(R8,0,0,I4,0); + VARAND(R8,0,BSTR,bstrfalse,I4,0); + VARAND(R8,-1,BSTR,bstrfalse,I4,0); + VARAND(R8,0,BSTR,bstrtrue,I4,0); + VARAND(R8,-1,BSTR,bstrtrue,I4,-1); + VARANDRCY(R8,-1,10000,I4,1); + VARANDRCY(R8,-1,0,I4,0); + VARANDRCY(R8,0,0,I4,0);

VARAND(DATE,-1,DATE,-1,I4,-1); VARAND(DATE,-1,DATE,0,I4,0); @@ -7380,13 +7413,13 @@ static void test_VarAnd(void) VARAND(DATE,-1,UINT,0xffffffff,I4,-1); VARAND(DATE,-1,UINT,0,I4,0); VARAND(DATE,0,UINT,0,I4,0); - VARAND(DATE,0,BSTR,false_str,I4,0); - VARAND(DATE,-1,BSTR,false_str,I4,0); - VARAND(DATE,0,BSTR,true_str,I4,0); - VARAND(DATE,-1,BSTR,true_str,I4,-1); - VARANDCY(DATE,-1,10000,I4,1); - VARANDCY(DATE,-1,0,I4,0); - VARANDCY(DATE,0,0,I4,0); + VARAND(DATE,0,BSTR,bstrfalse,I4,0); + VARAND(DATE,-1,BSTR,bstrfalse,I4,0); + VARAND(DATE,0,BSTR,bstrtrue,I4,0); + VARAND(DATE,-1,BSTR,bstrtrue,I4,-1); + VARANDRCY(DATE,-1,10000,I4,1); + VARANDRCY(DATE,-1,0,I4,0); + VARANDRCY(DATE,0,0,I4,0);

if (has_i8) { @@ -7397,13 +7430,15 @@ static void test_VarAnd(void) VARAND(I8,0,UI8,0,I8,0); VARAND(I8,-1,UINT,0,I8,0); VARAND(I8,0,UINT,0,I8,0); - VARAND(I8,0,BSTR,false_str,I8,0); - VARAND(I8,-1,BSTR,false_str,I8,0); - VARAND(I8,0,BSTR,true_str,I8,0); - VARAND(I8,-1,BSTR,true_str,I8,-1); - VARANDCY(I8,-1,10000,I8,1); - VARANDCY(I8,-1,0,I8,0); - VARANDCY(I8,0,0,I8,0); + VARAND(I8,0,BSTR,bstrfalse,I8,0); + VARAND(I8,-1,BSTR,bstrfalse,I8,0); + VARAND(I8,0,BSTR,bstrtrue,I8,0); + VARAND(I8,-1,BSTR,bstrtrue,I8,-1); + VARAND(I8, 1, BSTR, bstrmaxi8, I8, 1); + VARAND(I8, 1, BSTR, bstrmini8, I8, 1); + VARANDRCY(I8,-1,10000,I8,1); + VARANDRCY(I8,-1,0,I8,0); + VARANDRCY(I8,0,0,I8,0);

VARAND(UI8,0xffff,UI8,0xffff,I4,0xffff); VARAND(UI8,0xffff,UI8,0,I4,0); @@ -7414,13 +7449,13 @@ static void test_VarAnd(void) VARAND(UI8,0xffff,UINT,0xffff,I4,0xffff); VARAND(UI8,0xffff,UINT,0,I4,0); VARAND(UI8,0,UINT,0,I4,0); - VARAND(UI8,0,BSTR,false_str,I4,0); - VARAND(UI8,0xffff,BSTR,false_str,I4,0); - VARAND(UI8,0,BSTR,true_str,I4,0); - VARAND(UI8,0xffff,BSTR,true_str,I4,65535); - VARANDCY(UI8,0xffff,10000,I4,1); - VARANDCY(UI8,0xffff,0,I4,0); - VARANDCY(UI8,0,0,I4,0); + VARAND(UI8,0,BSTR,bstrfalse,I4,0); + VARAND(UI8,0xffff,BSTR,bstrfalse,I4,0); + VARAND(UI8,0,BSTR,bstrtrue,I4,0); + VARAND(UI8,0xffff,BSTR,bstrtrue,I4,65535); + VARANDRCY(UI8,0xffff,10000,I4,1); + VARANDRCY(UI8,0xffff,0,I4,0); + VARANDRCY(UI8,0,0,I4,0); }

VARAND(INT,-1,INT,-1,I4,-1); @@ -7429,33 +7464,92 @@ static void test_VarAnd(void) VARAND(INT,-1,UINT,0xffff,I4,65535); VARAND(INT,-1,UINT,0,I4,0); VARAND(INT,0,UINT,0,I4,0); - VARAND(INT,0,BSTR,false_str,I4,0); - VARAND(INT,-1,BSTR,false_str,I4,0); - VARAND(INT,0,BSTR,true_str,I4,0); - VARAND(INT,-1,BSTR,true_str,I4,-1); - VARANDCY(INT,-1,10000,I4,1); - VARANDCY(INT,-1,0,I4,0); - VARANDCY(INT,0,0,I4,0); + VARAND(INT,0,BSTR,bstrfalse,I4,0); + VARAND(INT,-1,BSTR,bstrfalse,I4,0); + VARAND(INT,0,BSTR,bstrtrue,I4,0); + VARAND(INT,-1,BSTR,bstrtrue,I4,-1); + VARANDRCY(INT,-1,10000,I4,1); + VARANDRCY(INT,-1,0,I4,0); + VARANDRCY(INT,0,0,I4,0);

VARAND(UINT,0xffff,UINT,0xffff,I4,0xffff); VARAND(UINT,0xffff,UINT,0,I4,0); VARAND(UINT,0,UINT,0,I4,0); - VARAND(UINT,0,BSTR,false_str,I4,0); - VARAND(UINT,0xffff,BSTR, false_str,I4,0); - VARAND(UINT,0,BSTR,true_str,I4,0); - VARAND(UINT,0xffff,BSTR,true_str,I4,65535); - VARANDCY(UINT,0xffff,10000,I4,1); - VARANDCY(UINT,0xffff,0,I4,0); - VARANDCY(UINT,0,0,I4,0); - - VARAND(BSTR,false_str,BSTR,false_str,BOOL,0); - VARAND(BSTR,true_str,BSTR,false_str,BOOL,VARIANT_FALSE); - VARAND(BSTR,true_str,BSTR,true_str,BOOL,VARIANT_TRUE); - VARANDCY(BSTR,true_str,10000,I4,1); - VARANDCY(BSTR,false_str,10000,I4,0); + VARAND(UINT,0,BSTR,bstrfalse,I4,0); + VARAND(UINT,0xffff,BSTR, bstrfalse,I4,0); + VARAND(UINT,0,BSTR,bstrtrue,I4,0); + VARAND(UINT,0xffff,BSTR,bstrtrue,I4,65535); + VARANDRCY(UINT,0xffff,10000,I4,1); + VARANDRCY(UINT,0xffff,0,I4,0); + VARANDRCY(UINT,0,0,I4,0); + + VARAND(BSTR,bstrfalse,BSTR,bstrfalse,BOOL,0); + VARAND(BSTR,bstrtrue,BSTR,bstrfalse,BOOL,VARIANT_FALSE); + VARAND(BSTR,bstrtrue,BSTR,bstrtrue,BOOL,VARIANT_TRUE); + VARAND(BSTR, bstrmaxi4, I4, 1, I4, (2147483647 & 1)); + VARAND(BSTR, bstrmini4, I4, 1, I4, (-2147483648 & 1));

- SysFreeString(true_str); - SysFreeString(false_str); + if (has_i8) + { + VARAND(BSTR, bstrmaxi8, I8, 1, I8, 1); + VARAND(BSTR, bstrmini8, I8, 1, I8, 1); + } + + VARAND(BSTR, bstrleading0, I4, 1, I4, (123 & 1)); + VARAND(BSTR, bstrspaced1, I4, 1, I4, (1 & 1)); + VARAND(BSTR, bstrminus1, I4, 1, I4, (-1 & 1)); + VARAND(BSTR, bstr0, I4, 1, I4, (0 & 1)); + VARAND(BSTR, bstrminus42, I4, 1, I4, (-42 & 1)); + VARAND(BSTR, bstrsci1e2, I4, 1, I4, (100 & 1)); + VARAND(BSTR, bstrfloat1p99, I4, 1, I4, 0); + VARAND(BSTR, bstrvbhex16, I4, 1, I4, (0x10 & 1)); + + VARANDRCY(BSTR, bstrtrue, 10000, I4, 1); + VARANDRCY(BSTR, bstrfalse, 10000, I4, 0); + VARANDRCY(BSTR, bstr1, 10000, I4, 1); + VARANDRCY(BSTR, bstr0, 10000, I4, 0); + VARANDRCY(BSTR, bstrminus1, 10000, I4, 1); + VARANDRCY(BSTR, bstrmaxi2, 10000, I4, 1); + VARANDRCY(BSTR, bstrmaxi4, 10000, I4, 1); + VARANDRCY(BSTR, bstrmini2, 10000, I4, 0); + VARANDRCY(BSTR, bstrspaced1, 10000, I4, 1); + VARANDRCY(BSTR, bstrfloat1p99, 10000, I4, 0); + VARANDRCY(BSTR, bstrfloatminus1p99, 10000, I4, 0); + VARANDRCY(BSTR, bstrsci1e2, 10000, I4, 0); + VARANDRCY(BSTR, bstrmaxi2, 0, I4, 0); + + VARANDLCY(10000, BSTR, bstrtrue, I4, 1); + VARANDLCY(10000, BSTR, bstrfalse, I4, 0); + VARANDLCY(10000, BSTR, bstr1, I4, 1); + VARANDLCY(10000, BSTR, bstr0, I4, 0); + VARANDLCY(10000, BSTR, bstrminus1, I4, 1); + VARANDLCY(10000, BSTR, bstrmaxi2, I4, 1); + VARANDLCY(10000, BSTR, bstrmaxi4, I4, 1); + VARANDLCY(10000, BSTR, bstrmini2, I4, 0); + VARANDLCY(10000, BSTR, bstrspaced1, I4, 1); + VARANDLCY(10000, BSTR, bstrfloat1p99, I4, 0); + VARANDLCY(10000, BSTR, bstrfloatminus1p99, I4, 0); + VARANDLCY(10000, BSTR, bstrsci1e2, I4, 0); + VARANDLCY(0, BSTR,bstrmaxi2, I4, 0); + + SysFreeString(bstrtrue); + SysFreeString(bstrfalse); + SysFreeString(bstrmaxi2); + SysFreeString(bstrmini2); + SysFreeString(bstrmaxi4); + SysFreeString(bstrmini4); + SysFreeString(bstrmaxi8); + SysFreeString(bstrmini8); + SysFreeString(bstr1); + SysFreeString(bstr0); + SysFreeString(bstrminus1); + SysFreeString(bstrminus42); + SysFreeString(bstrspaced1); + SysFreeString(bstrleading0); + SysFreeString(bstrfloat1p99); + SysFreeString(bstrfloatminus1p99); + SysFreeString(bstrsci1e2); + SysFreeString(bstrvbhex16); }

static void test_cmp( int line, LCID lcid, UINT flags, VARIANT *left, VARIANT *right, HRESULT result )

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8635

Maotong Zhang

12:20 p.m.

New subject: [PATCH v9 2/2] oleaut32: Add VarNumFromStr to convert VT_BSTR to numeric or boolean

From: Maotong Zhang zmtong1988@gmail.com

Use VarNumFromStr for VT_BSTR conversion in VarAnd、VarOr、VarImp --- dlls/oleaut32/variant.c | 118 ++++++++++++++++++++++++---------------- 1 file changed, 71 insertions(+), 47 deletions(-)

diff --git a/dlls/oleaut32/variant.c b/dlls/oleaut32/variant.c index fbe035a5576..2251cc4bfe1 100644 --- a/dlls/oleaut32/variant.c +++ b/dlls/oleaut32/variant.c @@ -2563,6 +2563,69 @@ VarNumFromParseNum_DecOverflow: return DISP_E_OVERFLOW; /* No more output choices */ }

+/********************************************************************** + * VarNumFromStr + * + * Converts a BSTR VARIANT to a numeric or boolean VARIANT. + * + * PARAMETERS + * pVar [I] VARIANT to convert in place. + * presvt [I] Receives the resulting VARTYPE. + * + * RETURNS + * S_OK on success, or an HRESULT error code on failure. + */ +static inline HRESULT VarNumFromStr(VARIANT *pVar, VARTYPE *presvt) +{ + HRESULT hres = S_OK; + if (V_VT(pVar) == VT_BSTR) + { + LONGLONG val64; + HRESULT tmpres = VarI8FromStr(V_BSTR(pVar), LOCALE_USER_DEFAULT, 0, &val64); + if (SUCCEEDED(tmpres)) + { + VARIANT tmpvar; + VariantInit(&tmpvar); + + if (val64 >= LONG_MIN && val64 <= LONG_MAX) + { + V_VT(&tmpvar) = VT_I4; + V_I4(&tmpvar) = (LONG)val64; + *presvt = VT_I4; + } + else + { + V_VT(&tmpvar) = VT_I8; + V_I8(&tmpvar) = val64; + *presvt = VT_I8; + } + + VariantClear(pVar); + hres = VariantCopy(pVar, &tmpvar); + VariantClear(&tmpvar); + } + else + { + double d; + if (FAILED(VarR8FromStr(V_BSTR(pVar), LOCALE_USER_DEFAULT, 0, &d))) + { + hres = VariantChangeType(pVar, pVar, VARIANT_LOCALBOOL, VT_BOOL); + } + else + { + if (V_VT(pVar) != *presvt) + hres = VariantChangeType(pVar, pVar, 0, *presvt); + } + } + if (FAILED(hres)) return hres; + } + + if (SUCCEEDED(hres) && V_VT(pVar) != *presvt) + hres = VariantChangeType(pVar, pVar, 0, *presvt); + + return hres; +} + /********************************************************************** * VarCat [OLEAUT32.318] * @@ -3106,15 +3169,7 @@ HRESULT WINAPI VarAnd(LPVARIANT left, LPVARIANT right, LPVARIANT result) V_VT(&varLeft) = VT_I4; /* Don't overflow */ else { - DOUBLE d; - - if (V_VT(&varLeft) == VT_BSTR && - FAILED(VarR8FromStr(V_BSTR(&varLeft), - LOCALE_USER_DEFAULT, 0, &d))) - hres = VariantChangeType(&varLeft,&varLeft, - VARIANT_LOCALBOOL, VT_BOOL); - if (SUCCEEDED(hres) && V_VT(&varLeft) != resvt) - hres = VariantChangeType(&varLeft,&varLeft,0,resvt); + hres = VarNumFromStr(&varLeft, &resvt); if (FAILED(hres)) goto VarAnd_Exit; }

@@ -3122,15 +3177,7 @@ HRESULT WINAPI VarAnd(LPVARIANT left, LPVARIANT right, LPVARIANT result) V_VT(&varRight) = VT_I4; /* Don't overflow */ else { - DOUBLE d; - - if (V_VT(&varRight) == VT_BSTR && - FAILED(VarR8FromStr(V_BSTR(&varRight), - LOCALE_USER_DEFAULT, 0, &d))) - hres = VariantChangeType(&varRight, &varRight, - VARIANT_LOCALBOOL, VT_BOOL); - if (SUCCEEDED(hres) && V_VT(&varRight) != resvt) - hres = VariantChangeType(&varRight, &varRight, 0, resvt); + hres = VarNumFromStr(&varRight, &resvt); if (FAILED(hres)) goto VarAnd_Exit; }

@@ -4252,30 +4299,16 @@ VarOr_AsEmpty: V_VT(&varLeft) = VT_I4; /* Don't overflow */ else { - DOUBLE d; - - if (V_VT(&varLeft) == VT_BSTR && - FAILED(VarR8FromStr(V_BSTR(&varLeft), LOCALE_USER_DEFAULT, 0, &d))) - hRet = VariantChangeType(&varLeft, &varLeft, VARIANT_LOCALBOOL, VT_BOOL); - if (SUCCEEDED(hRet) && V_VT(&varLeft) != vt) - hRet = VariantChangeType(&varLeft, &varLeft, 0, vt); - if (FAILED(hRet)) - goto VarOr_Exit; + hRet = VarNumFromStr(&varLeft, &vt); + if (FAILED(hRet)) goto VarOr_Exit; }

if (vt == VT_I4 && V_VT(&varRight) == VT_UI4) V_VT(&varRight) = VT_I4; /* Don't overflow */ else { - DOUBLE d; - - if (V_VT(&varRight) == VT_BSTR && - FAILED(VarR8FromStr(V_BSTR(&varRight), LOCALE_USER_DEFAULT, 0, &d))) - hRet = VariantChangeType(&varRight, &varRight, VARIANT_LOCALBOOL, VT_BOOL); - if (SUCCEEDED(hRet) && V_VT(&varRight) != vt) - hRet = VariantChangeType(&varRight, &varRight, 0, vt); - if (FAILED(hRet)) - goto VarOr_Exit; + hRet = VarNumFromStr(&varRight, &vt); + if (FAILED(hRet)) goto VarOr_Exit; }

V_VT(pVarOut) = vt; @@ -5757,7 +5790,6 @@ HRESULT WINAPI VarImp(LPVARIANT left, LPVARIANT right, LPVARIANT result) VARTYPE leftvt,rightvt; VARTYPE rightExtraFlags,leftExtraFlags,ExtraFlags; VARIANT lv,rv; - DOUBLE d; VARIANT tempLeft, tempRight;

VariantInit(&lv); @@ -5943,18 +5975,10 @@ HRESULT WINAPI VarImp(LPVARIANT left, LPVARIANT right, LPVARIANT result) if (FAILED(hres)) goto VarImp_Exit; }

- if (V_VT(&lv) == VT_BSTR && - FAILED(VarR8FromStr(V_BSTR(&lv),LOCALE_USER_DEFAULT, 0, &d))) - hres = VariantChangeType(&lv,&lv,VARIANT_LOCALBOOL, VT_BOOL); - if (SUCCEEDED(hres) && V_VT(&lv) != resvt) - hres = VariantChangeType(&lv,&lv,0,resvt); + hres = VarNumFromStr(&lv, &resvt); if (FAILED(hres)) goto VarImp_Exit;

- if (V_VT(&rv) == VT_BSTR && - FAILED(VarR8FromStr(V_BSTR(&rv),LOCALE_USER_DEFAULT, 0, &d))) - hres = VariantChangeType(&rv, &rv,VARIANT_LOCALBOOL, VT_BOOL); - if (SUCCEEDED(hres) && V_VT(&rv) != resvt) - hres = VariantChangeType(&rv, &rv, 0, resvt); + hres = VarNumFromStr(&rv, &resvt); if (FAILED(hres)) goto VarImp_Exit;

/* do the math */

-- GitLab https://gitlab.winehq.org/wine/wine/-/merge_requests/8635

Maotong Zhang (＠xiaotong)

1:09 p.m.

v3:Add VarNumFromStr to convert VT_BSTR to numeric or boolean

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/8635#note_113892

Nikolay Sivov (＠nsivov)

30 Aug 30 Aug

4 p.m.

We already have code for this, see VARIANT_NumberFromBstr(). The difference is that we don't want particular output type, instead using what VarNumFromParseNum() produced.

This needs more tests for every function you change. We can start with more tests for VarAnd() to trigger different numeric types, to confirm that we can actually use VarNumFromParseNum().

-- https://gitlab.winehq.org/wine/wine/-/merge_requests/8635#note_114311

Age (days ago)

Last active (days ago)

wine-gitlab@winehq.org

4 comments

3 participants

tags (0)

participants (3)

Maotong Zhang
Maotong Zhang (＠xiaotong)
Nikolay Sivov (＠nsivov)