wine/dlls/oleaut32/variant.c

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

Version: ~ [ wine-1.1.38 ] ~ [ wine-1.1.37 ] ~ [ wine-1.1.36 ] ~ [ wine-1.1.35 ] ~ [ wine-1.1.34 ] ~ [ wine-1.1.33 ] ~ [ wine-1.1.32 ] ~ [ wine-1.1.31 ] ~ [ wine-1.1.30 ] ~ [ wine-1.1.29 ] ~ [ wine-1.1.28 ] ~ [ wine-1.1.27 ] ~ [ wine-1.1.26 ] ~ [ wine-1.1.25 ] ~ [ wine-1.1.24 ] ~ [ wine-1.1.23 ] ~ [ wine-1.1.22 ] ~ [ wine-1.1.21 ] ~ [ wine-1.1.20 ] ~ [ wine-1.1.19 ] ~ [ wine-1.1.18 ] ~ [ wine-1.1.17 ] ~ [ wine-1.1.16 ] ~ [ wine-1.1.15 ] ~ [ wine-1.1.14 ] ~ [ wine-1.1.13 ] ~ [ wine-1.1.12 ] ~ [ wine-1.1.11 ] ~ [ wine-1.1.10 ] ~ [ wine-1.1.9 ] ~ [ wine-1.1.8 ] ~ [ wine-1.1.7 ] ~ [ wine-1.0.1 ] ~ [ wine-1.1.6 ] ~ [ wine-1.1.5 ] ~ [ wine-1.1.4 ] ~ [ wine-1.1.3 ] ~ [ wine-1.1.2 ] ~ [ wine-1.1.1 ] ~ [ wine-1.1.0 ] ~ [ wine-1.0 ] ~

1 /* 2 * VARIANT 3 * 4 * Copyright 1998 Jean-Claude Cote 5 * Copyright 2003 Jon Griffiths 6 * Copyright 2005 Daniel Remenak 7 * Copyright 2006 Google (Benjamin Arai) 8 * 9 * The algorithm for conversion from Julian days to day/month/year is based on 10 * that devised by Henry Fliegel, as implemented in PostgreSQL, which is 11 * Copyright 1994-7 Regents of the University of California 12 * 13 * This library is free software; you can redistribute it and/or 14 * modify it under the terms of the GNU Lesser General Public 15 * License as published by the Free Software Foundation; either 16 * version 2.1 of the License, or (at your option) any later version. 17 * 18 * This library is distributed in the hope that it will be useful, 19 * but WITHOUT ANY WARRANTY; without even the implied warranty of 20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 21 * Lesser General Public License for more details. 22 * 23 * You should have received a copy of the GNU Lesser General Public 24 * License along with this library; if not, write to the Free Software 25 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 26 */ 27 28 #include "config.h" 29 30 #include <string.h> 31 #include <stdlib.h> 32 #include <stdarg.h> 33 34 #define COBJMACROS 35 #define NONAMELESSUNION 36 #define NONAMELESSSTRUCT 37 38 #include "windef.h" 39 #include "winbase.h" 40 #include "wine/unicode.h" 41 #include "winerror.h" 42 #include "variant.h" 43 #include "resource.h" 44 #include "wine/debug.h" 45 46 WINE_DEFAULT_DEBUG_CHANNEL(variant); 47 48 const char * const wine_vtypes[VT_CLSID+1] = 49 { 50 "VT_EMPTY","VT_NULL","VT_I2","VT_I4","VT_R4","VT_R8","VT_CY","VT_DATE", 51 "VT_BSTR","VT_DISPATCH","VT_ERROR","VT_BOOL","VT_VARIANT","VT_UNKNOWN", 52 "VT_DECIMAL","15","VT_I1","VT_UI1","VT_UI2","VT_UI4","VT_I8","VT_UI8", 53 "VT_INT","VT_UINT","VT_VOID","VT_HRESULT","VT_PTR","VT_SAFEARRAY", 54 "VT_CARRAY","VT_USERDEFINED","VT_LPSTR","VT_LPWSTR","32","33","34","35", 55 "VT_RECORD","VT_INT_PTR","VT_UINT_PTR","39","40","41","42","43","44","45", 56 "46","47","48","49","50","51","52","53","54","55","56","57","58","59","60", 57 "61","62","63","VT_FILETIME","VT_BLOB","VT_STREAM","VT_STORAGE", 58 "VT_STREAMED_OBJECT","VT_STORED_OBJECT","VT_BLOB_OBJECT","VT_CF","VT_CLSID" 59 }; 60 61 const char * const wine_vflags[16] = 62 { 63 "", 64 "|VT_VECTOR", 65 "|VT_ARRAY", 66 "|VT_VECTOR|VT_ARRAY", 67 "|VT_BYREF", 68 "|VT_VECTOR|VT_ARRAY", 69 "|VT_ARRAY|VT_BYREF", 70 "|VT_VECTOR|VT_ARRAY|VT_BYREF", 71 "|VT_HARDTYPE", 72 "|VT_VECTOR|VT_HARDTYPE", 73 "|VT_ARRAY|VT_HARDTYPE", 74 "|VT_VECTOR|VT_ARRAY|VT_HARDTYPE", 75 "|VT_BYREF|VT_HARDTYPE", 76 "|VT_VECTOR|VT_ARRAY|VT_HARDTYPE", 77 "|VT_ARRAY|VT_BYREF|VT_HARDTYPE", 78 "|VT_VECTOR|VT_ARRAY|VT_BYREF|VT_HARDTYPE", 79 }; 80 81 /* Convert a variant from one type to another */ 82 static inline HRESULT VARIANT_Coerce(VARIANTARG* pd, LCID lcid, USHORT wFlags, 83 VARIANTARG* ps, VARTYPE vt) 84 { 85 HRESULT res = DISP_E_TYPEMISMATCH; 86 VARTYPE vtFrom = V_TYPE(ps); 87 DWORD dwFlags = 0; 88 89 TRACE("(%p->(%s%s),0x%08x,0x%04x,%p->(%s%s),%s%s)\n", pd, debugstr_VT(pd), 90 debugstr_VF(pd), lcid, wFlags, ps, debugstr_VT(ps), debugstr_VF(ps), 91 debugstr_vt(vt), debugstr_vf(vt)); 92 93 if (vt == VT_BSTR || vtFrom == VT_BSTR) 94 { 95 /* All flags passed to low level function are only used for 96 * changing to or from strings. Map these here. 97 */ 98 if (wFlags & VARIANT_LOCALBOOL) 99 dwFlags |= VAR_LOCALBOOL; 100 if (wFlags & VARIANT_CALENDAR_HIJRI) 101 dwFlags |= VAR_CALENDAR_HIJRI; 102 if (wFlags & VARIANT_CALENDAR_THAI) 103 dwFlags |= VAR_CALENDAR_THAI; 104 if (wFlags & VARIANT_CALENDAR_GREGORIAN) 105 dwFlags |= VAR_CALENDAR_GREGORIAN; 106 if (wFlags & VARIANT_NOUSEROVERRIDE) 107 dwFlags |= LOCALE_NOUSEROVERRIDE; 108 if (wFlags & VARIANT_USE_NLS) 109 dwFlags |= LOCALE_USE_NLS; 110 } 111 112 /* Map int/uint to i4/ui4 */ 113 if (vt == VT_INT) 114 vt = VT_I4; 115 else if (vt == VT_UINT) 116 vt = VT_UI4; 117 118 if (vtFrom == VT_INT) 119 vtFrom = VT_I4; 120 else if (vtFrom == VT_UINT) 121 vtFrom = VT_UI4; 122 123 if (vt == vtFrom) 124 return VariantCopy(pd, ps); 125 126 if (wFlags & VARIANT_NOVALUEPROP && vtFrom == VT_DISPATCH && vt != VT_UNKNOWN) 127 { 128 /* VARIANT_NOVALUEPROP prevents IDispatch objects from being coerced by 129 * accessing the default object property. 130 */ 131 return DISP_E_TYPEMISMATCH; 132 } 133 134 switch (vt) 135 { 136 case VT_EMPTY: 137 if (vtFrom == VT_NULL) 138 return DISP_E_TYPEMISMATCH; 139 /* ... Fall through */ 140 case VT_NULL: 141 if (vtFrom <= VT_UINT && vtFrom != (VARTYPE)15 && vtFrom != VT_ERROR) 142 { 143 res = VariantClear( pd ); 144 if (vt == VT_NULL && SUCCEEDED(res)) 145 V_VT(pd) = VT_NULL; 146 } 147 return res; 148 149 case VT_I1: 150 switch (vtFrom) 151 { 152 case VT_EMPTY: V_I1(pd) = 0; return S_OK; 153 case VT_I2: return VarI1FromI2(V_I2(ps), &V_I1(pd)); 154 case VT_I4: return VarI1FromI4(V_I4(ps), &V_I1(pd)); 155 case VT_UI1: V_I1(pd) = V_UI1(ps); return S_OK; 156 case VT_UI2: return VarI1FromUI2(V_UI2(ps), &V_I1(pd)); 157 case VT_UI4: return VarI1FromUI4(V_UI4(ps), &V_I1(pd)); 158 case VT_I8: return VarI1FromI8(V_I8(ps), &V_I1(pd)); 159 case VT_UI8: return VarI1FromUI8(V_UI8(ps), &V_I1(pd)); 160 case VT_R4: return VarI1FromR4(V_R4(ps), &V_I1(pd)); 161 case VT_R8: return VarI1FromR8(V_R8(ps), &V_I1(pd)); 162 case VT_DATE: return VarI1FromDate(V_DATE(ps), &V_I1(pd)); 163 case VT_BOOL: return VarI1FromBool(V_BOOL(ps), &V_I1(pd)); 164 case VT_CY: return VarI1FromCy(V_CY(ps), &V_I1(pd)); 165 case VT_DECIMAL: return VarI1FromDec(&V_DECIMAL(ps), &V_I1(pd) ); 166 case VT_DISPATCH: return VarI1FromDisp(V_DISPATCH(ps), lcid, &V_I1(pd) ); 167 case VT_BSTR: return VarI1FromStr(V_BSTR(ps), lcid, dwFlags, &V_I1(pd) ); 168 } 169 break; 170 171 case VT_I2: 172 switch (vtFrom) 173 { 174 case VT_EMPTY: V_I2(pd) = 0; return S_OK; 175 case VT_I1: return VarI2FromI1(V_I1(ps), &V_I2(pd)); 176 case VT_I4: return VarI2FromI4(V_I4(ps), &V_I2(pd)); 177 case VT_UI1: return VarI2FromUI1(V_UI1(ps), &V_I2(pd)); 178 case VT_UI2: V_I2(pd) = V_UI2(ps); return S_OK; 179 case VT_UI4: return VarI2FromUI4(V_UI4(ps), &V_I2(pd)); 180 case VT_I8: return VarI2FromI8(V_I8(ps), &V_I2(pd)); 181 case VT_UI8: return VarI2FromUI8(V_UI8(ps), &V_I2(pd)); 182 case VT_R4: return VarI2FromR4(V_R4(ps), &V_I2(pd)); 183 case VT_R8: return VarI2FromR8(V_R8(ps), &V_I2(pd)); 184 case VT_DATE: return VarI2FromDate(V_DATE(ps), &V_I2(pd)); 185 case VT_BOOL: return VarI2FromBool(V_BOOL(ps), &V_I2(pd)); 186 case VT_CY: return VarI2FromCy(V_CY(ps), &V_I2(pd)); 187 case VT_DECIMAL: return VarI2FromDec(&V_DECIMAL(ps), &V_I2(pd)); 188 case VT_DISPATCH: return VarI2FromDisp(V_DISPATCH(ps), lcid, &V_I2(pd)); 189 case VT_BSTR: return VarI2FromStr(V_BSTR(ps), lcid, dwFlags, &V_I2(pd)); 190 } 191 break; 192 193 case VT_I4: 194 switch (vtFrom) 195 { 196 case VT_EMPTY: V_I4(pd) = 0; return S_OK; 197 case VT_I1: return VarI4FromI1(V_I1(ps), &V_I4(pd)); 198 case VT_I2: return VarI4FromI2(V_I2(ps), &V_I4(pd)); 199 case VT_UI1: return VarI4FromUI1(V_UI1(ps), &V_I4(pd)); 200 case VT_UI2: return VarI4FromUI2(V_UI2(ps), &V_I4(pd)); 201 case VT_UI4: V_I4(pd) = V_UI4(ps); return S_OK; 202 case VT_I8: return VarI4FromI8(V_I8(ps), &V_I4(pd)); 203 case VT_UI8: return VarI4FromUI8(V_UI8(ps), &V_I4(pd)); 204 case VT_R4: return VarI4FromR4(V_R4(ps), &V_I4(pd)); 205 case VT_R8: return VarI4FromR8(V_R8(ps), &V_I4(pd)); 206 case VT_DATE: return VarI4FromDate(V_DATE(ps), &V_I4(pd)); 207 case VT_BOOL: return VarI4FromBool(V_BOOL(ps), &V_I4(pd)); 208 case VT_CY: return VarI4FromCy(V_CY(ps), &V_I4(pd)); 209 case VT_DECIMAL: return VarI4FromDec(&V_DECIMAL(ps), &V_I4(pd)); 210 case VT_DISPATCH: return VarI4FromDisp(V_DISPATCH(ps), lcid, &V_I4(pd)); 211 case VT_BSTR: return VarI4FromStr(V_BSTR(ps), lcid, dwFlags, &V_I4(pd)); 212 } 213 break; 214 215 case VT_UI1: 216 switch (vtFrom) 217 { 218 case VT_EMPTY: V_UI1(pd) = 0; return S_OK; 219 case VT_I1: V_UI1(pd) = V_I1(ps); return S_OK; 220 case VT_I2: return VarUI1FromI2(V_I2(ps), &V_UI1(pd)); 221 case VT_I4: return VarUI1FromI4(V_I4(ps), &V_UI1(pd)); 222 case VT_UI2: return VarUI1FromUI2(V_UI2(ps), &V_UI1(pd)); 223 case VT_UI4: return VarUI1FromUI4(V_UI4(ps), &V_UI1(pd)); 224 case VT_I8: return VarUI1FromI8(V_I8(ps), &V_UI1(pd)); 225 case VT_UI8: return VarUI1FromUI8(V_UI8(ps), &V_UI1(pd)); 226 case VT_R4: return VarUI1FromR4(V_R4(ps), &V_UI1(pd)); 227 case VT_R8: return VarUI1FromR8(V_R8(ps), &V_UI1(pd)); 228 case VT_DATE: return VarUI1FromDate(V_DATE(ps), &V_UI1(pd)); 229 case VT_BOOL: return VarUI1FromBool(V_BOOL(ps), &V_UI1(pd)); 230 case VT_CY: return VarUI1FromCy(V_CY(ps), &V_UI1(pd)); 231 case VT_DECIMAL: return VarUI1FromDec(&V_DECIMAL(ps), &V_UI1(pd)); 232 case VT_DISPATCH: return VarUI1FromDisp(V_DISPATCH(ps), lcid, &V_UI1(pd)); 233 case VT_BSTR: return VarUI1FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI1(pd)); 234 } 235 break; 236 237 case VT_UI2: 238 switch (vtFrom) 239 { 240 case VT_EMPTY: V_UI2(pd) = 0; return S_OK; 241 case VT_I1: return VarUI2FromI1(V_I1(ps), &V_UI2(pd)); 242 case VT_I2: V_UI2(pd) = V_I2(ps); return S_OK; 243 case VT_I4: return VarUI2FromI4(V_I4(ps), &V_UI2(pd)); 244 case VT_UI1: return VarUI2FromUI1(V_UI1(ps), &V_UI2(pd)); 245 case VT_UI4: return VarUI2FromUI4(V_UI4(ps), &V_UI2(pd)); 246 case VT_I8: return VarUI4FromI8(V_I8(ps), &V_UI4(pd)); 247 case VT_UI8: return VarUI4FromUI8(V_UI8(ps), &V_UI4(pd)); 248 case VT_R4: return VarUI2FromR4(V_R4(ps), &V_UI2(pd)); 249 case VT_R8: return VarUI2FromR8(V_R8(ps), &V_UI2(pd)); 250 case VT_DATE: return VarUI2FromDate(V_DATE(ps), &V_UI2(pd)); 251 case VT_BOOL: return VarUI2FromBool(V_BOOL(ps), &V_UI2(pd)); 252 case VT_CY: return VarUI2FromCy(V_CY(ps), &V_UI2(pd)); 253 case VT_DECIMAL: return VarUI2FromDec(&V_DECIMAL(ps), &V_UI2(pd)); 254 case VT_DISPATCH: return VarUI2FromDisp(V_DISPATCH(ps), lcid, &V_UI2(pd)); 255 case VT_BSTR: return VarUI2FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI2(pd)); 256 } 257 break; 258 259 case VT_UI4: 260 switch (vtFrom) 261 { 262 case VT_EMPTY: V_UI4(pd) = 0; return S_OK; 263 case VT_I1: return VarUI4FromI1(V_I1(ps), &V_UI4(pd)); 264 case VT_I2: return VarUI4FromI2(V_I2(ps), &V_UI4(pd)); 265 case VT_I4: V_UI4(pd) = V_I4(ps); return S_OK; 266 case VT_UI1: return VarUI4FromUI1(V_UI1(ps), &V_UI4(pd)); 267 case VT_UI2: return VarUI4FromUI2(V_UI2(ps), &V_UI4(pd)); 268 case VT_I8: return VarUI4FromI8(V_I8(ps), &V_UI4(pd)); 269 case VT_UI8: return VarUI4FromUI8(V_UI8(ps), &V_UI4(pd)); 270 case VT_R4: return VarUI4FromR4(V_R4(ps), &V_UI4(pd)); 271 case VT_R8: return VarUI4FromR8(V_R8(ps), &V_UI4(pd)); 272 case VT_DATE: return VarUI4FromDate(V_DATE(ps), &V_UI4(pd)); 273 case VT_BOOL: return VarUI4FromBool(V_BOOL(ps), &V_UI4(pd)); 274 case VT_CY: return VarUI4FromCy(V_CY(ps), &V_UI4(pd)); 275 case VT_DECIMAL: return VarUI4FromDec(&V_DECIMAL(ps), &V_UI4(pd)); 276 case VT_DISPATCH: return VarUI4FromDisp(V_DISPATCH(ps), lcid, &V_UI4(pd)); 277 case VT_BSTR: return VarUI4FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI4(pd)); 278 } 279 break; 280 281 case VT_UI8: 282 switch (vtFrom) 283 { 284 case VT_EMPTY: V_UI8(pd) = 0; return S_OK; 285 case VT_I4: if (V_I4(ps) < 0) return DISP_E_OVERFLOW; V_UI8(pd) = V_I4(ps); return S_OK; 286 case VT_I1: return VarUI8FromI1(V_I1(ps), &V_UI8(pd)); 287 case VT_I2: return VarUI8FromI2(V_I2(ps), &V_UI8(pd)); 288 case VT_UI1: return VarUI8FromUI1(V_UI1(ps), &V_UI8(pd)); 289 case VT_UI2: return VarUI8FromUI2(V_UI2(ps), &V_UI8(pd)); 290 case VT_UI4: return VarUI8FromUI4(V_UI4(ps), &V_UI8(pd)); 291 case VT_I8: V_UI8(pd) = V_I8(ps); return S_OK; 292 case VT_R4: return VarUI8FromR4(V_R4(ps), &V_UI8(pd)); 293 case VT_R8: return VarUI8FromR8(V_R8(ps), &V_UI8(pd)); 294 case VT_DATE: return VarUI8FromDate(V_DATE(ps), &V_UI8(pd)); 295 case VT_BOOL: return VarUI8FromBool(V_BOOL(ps), &V_UI8(pd)); 296 case VT_CY: return VarUI8FromCy(V_CY(ps), &V_UI8(pd)); 297 case VT_DECIMAL: return VarUI8FromDec(&V_DECIMAL(ps), &V_UI8(pd)); 298 case VT_DISPATCH: return VarUI8FromDisp(V_DISPATCH(ps), lcid, &V_UI8(pd)); 299 case VT_BSTR: return VarUI8FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI8(pd)); 300 } 301 break; 302 303 case VT_I8: 304 switch (vtFrom) 305 { 306 case VT_EMPTY: V_I8(pd) = 0; return S_OK; 307 case VT_I4: V_I8(pd) = V_I4(ps); return S_OK; 308 case VT_I1: return VarI8FromI1(V_I1(ps), &V_I8(pd)); 309 case VT_I2: return VarI8FromI2(V_I2(ps), &V_I8(pd)); 310 case VT_UI1: return VarI8FromUI1(V_UI1(ps), &V_I8(pd)); 311 case VT_UI2: return VarI8FromUI2(V_UI2(ps), &V_I8(pd)); 312 case VT_UI4: return VarI8FromUI4(V_UI4(ps), &V_I8(pd)); 313 case VT_UI8: V_I8(pd) = V_UI8(ps); return S_OK; 314 case VT_R4: return VarI8FromR4(V_R4(ps), &V_I8(pd)); 315 case VT_R8: return VarI8FromR8(V_R8(ps), &V_I8(pd)); 316 case VT_DATE: return VarI8FromDate(V_DATE(ps), &V_I8(pd)); 317 case VT_BOOL: return VarI8FromBool(V_BOOL(ps), &V_I8(pd)); 318 case VT_CY: return VarI8FromCy(V_CY(ps), &V_I8(pd)); 319 case VT_DECIMAL: return VarI8FromDec(&V_DECIMAL(ps), &V_I8(pd)); 320 case VT_DISPATCH: return VarI8FromDisp(V_DISPATCH(ps), lcid, &V_I8(pd)); 321 case VT_BSTR: return VarI8FromStr(V_BSTR(ps), lcid, dwFlags, &V_I8(pd)); 322 } 323 break; 324 325 case VT_R4: 326 switch (vtFrom) 327 { 328 case VT_EMPTY: V_R4(pd) = 0.0f; return S_OK; 329 case VT_I1: return VarR4FromI1(V_I1(ps), &V_R4(pd)); 330 case VT_I2: return VarR4FromI2(V_I2(ps), &V_R4(pd)); 331 case VT_I4: return VarR4FromI4(V_I4(ps), &V_R4(pd)); 332 case VT_UI1: return VarR4FromUI1(V_UI1(ps), &V_R4(pd)); 333 case VT_UI2: return VarR4FromUI2(V_UI2(ps), &V_R4(pd)); 334 case VT_UI4: return VarR4FromUI4(V_UI4(ps), &V_R4(pd)); 335 case VT_I8: return VarR4FromI8(V_I8(ps), &V_R4(pd)); 336 case VT_UI8: return VarR4FromUI8(V_UI8(ps), &V_R4(pd)); 337 case VT_R8: return VarR4FromR8(V_R8(ps), &V_R4(pd)); 338 case VT_DATE: return VarR4FromDate(V_DATE(ps), &V_R4(pd)); 339 case VT_BOOL: return VarR4FromBool(V_BOOL(ps), &V_R4(pd)); 340 case VT_CY: return VarR4FromCy(V_CY(ps), &V_R4(pd)); 341 case VT_DECIMAL: return VarR4FromDec(&V_DECIMAL(ps), &V_R4(pd)); 342 case VT_DISPATCH: return VarR4FromDisp(V_DISPATCH(ps), lcid, &V_R4(pd)); 343 case VT_BSTR: return VarR4FromStr(V_BSTR(ps), lcid, dwFlags, &V_R4(pd)); 344 } 345 break; 346 347 case VT_R8: 348 switch (vtFrom) 349 { 350 case VT_EMPTY: V_R8(pd) = 0.0; return S_OK; 351 case VT_I1: return VarR8FromI1(V_I1(ps), &V_R8(pd)); 352 case VT_I2: return VarR8FromI2(V_I2(ps), &V_R8(pd)); 353 case VT_I4: return VarR8FromI4(V_I4(ps), &V_R8(pd)); 354 case VT_UI1: return VarR8FromUI1(V_UI1(ps), &V_R8(pd)); 355 case VT_UI2: return VarR8FromUI2(V_UI2(ps), &V_R8(pd)); 356 case VT_UI4: return VarR8FromUI4(V_UI4(ps), &V_R8(pd)); 357 case VT_I8: return VarR8FromI8(V_I8(ps), &V_R8(pd)); 358 case VT_UI8: return VarR8FromUI8(V_UI8(ps), &V_R8(pd)); 359 case VT_R4: return VarR8FromR4(V_R4(ps), &V_R8(pd)); 360 case VT_DATE: return VarR8FromDate(V_DATE(ps), &V_R8(pd)); 361 case VT_BOOL: return VarR8FromBool(V_BOOL(ps), &V_R8(pd)); 362 case VT_CY: return VarR8FromCy(V_CY(ps), &V_R8(pd)); 363 case VT_DECIMAL: return VarR8FromDec(&V_DECIMAL(ps), &V_R8(pd)); 364 case VT_DISPATCH: return VarR8FromDisp(V_DISPATCH(ps), lcid, &V_R8(pd)); 365 case VT_BSTR: return VarR8FromStr(V_BSTR(ps), lcid, dwFlags, &V_R8(pd)); 366 } 367 break; 368 369 case VT_DATE: 370 switch (vtFrom) 371 { 372 case VT_EMPTY: V_DATE(pd) = 0.0; return S_OK; 373 case VT_I1: return VarDateFromI1(V_I1(ps), &V_DATE(pd)); 374 case VT_I2: return VarDateFromI2(V_I2(ps), &V_DATE(pd)); 375 case VT_I4: return VarDateFromI4(V_I4(ps), &V_DATE(pd)); 376 case VT_UI1: return VarDateFromUI1(V_UI1(ps), &V_DATE(pd)); 377 case VT_UI2: return VarDateFromUI2(V_UI2(ps), &V_DATE(pd)); 378 case VT_UI4: return VarDateFromUI4(V_UI4(ps), &V_DATE(pd)); 379 case VT_I8: return VarDateFromI8(V_I8(ps), &V_DATE(pd)); 380 case VT_UI8: return VarDateFromUI8(V_UI8(ps), &V_DATE(pd)); 381 case VT_R4: return VarDateFromR4(V_R4(ps), &V_DATE(pd)); 382 case VT_R8: return VarDateFromR8(V_R8(ps), &V_DATE(pd)); 383 case VT_BOOL: return VarDateFromBool(V_BOOL(ps), &V_DATE(pd)); 384 case VT_CY: return VarDateFromCy(V_CY(ps), &V_DATE(pd)); 385 case VT_DECIMAL: return VarDateFromDec(&V_DECIMAL(ps), &V_DATE(pd)); 386 case VT_DISPATCH: return VarDateFromDisp(V_DISPATCH(ps), lcid, &V_DATE(pd)); 387 case VT_BSTR: return VarDateFromStr(V_BSTR(ps), lcid, dwFlags, &V_DATE(pd)); 388 } 389 break; 390 391 case VT_BOOL: 392 switch (vtFrom) 393 { 394 case VT_EMPTY: V_BOOL(pd) = 0; return S_OK; 395 case VT_I1: return VarBoolFromI1(V_I1(ps), &V_BOOL(pd)); 396 case VT_I2: return VarBoolFromI2(V_I2(ps), &V_BOOL(pd)); 397 case VT_I4: return VarBoolFromI4(V_I4(ps), &V_BOOL(pd)); 398 case VT_UI1: return VarBoolFromUI1(V_UI1(ps), &V_BOOL(pd)); 399 case VT_UI2: return VarBoolFromUI2(V_UI2(ps), &V_BOOL(pd)); 400 case VT_UI4: return VarBoolFromUI4(V_UI4(ps), &V_BOOL(pd)); 401 case VT_I8: return VarBoolFromI8(V_I8(ps), &V_BOOL(pd)); 402 case VT_UI8: return VarBoolFromUI8(V_UI8(ps), &V_BOOL(pd)); 403 case VT_R4: return VarBoolFromR4(V_R4(ps), &V_BOOL(pd)); 404 case VT_R8: return VarBoolFromR8(V_R8(ps), &V_BOOL(pd)); 405 case VT_DATE: return VarBoolFromDate(V_DATE(ps), &V_BOOL(pd)); 406 case VT_CY: return VarBoolFromCy(V_CY(ps), &V_BOOL(pd)); 407 case VT_DECIMAL: return VarBoolFromDec(&V_DECIMAL(ps), &V_BOOL(pd)); 408 case VT_DISPATCH: return VarBoolFromDisp(V_DISPATCH(ps), lcid, &V_BOOL(pd)); 409 case VT_BSTR: return VarBoolFromStr(V_BSTR(ps), lcid, dwFlags, &V_BOOL(pd)); 410 } 411 break; 412 413 case VT_BSTR: 414 switch (vtFrom) 415 { 416 case VT_EMPTY: 417 V_BSTR(pd) = SysAllocStringLen(NULL, 0); 418 return V_BSTR(pd) ? S_OK : E_OUTOFMEMORY; 419 case VT_BOOL: 420 if (wFlags & (VARIANT_ALPHABOOL|VARIANT_LOCALBOOL)) 421 return VarBstrFromBool(V_BOOL(ps), lcid, dwFlags, &V_BSTR(pd)); 422 return VarBstrFromI2(V_BOOL(ps), lcid, dwFlags, &V_BSTR(pd)); 423 case VT_I1: return VarBstrFromI1(V_I1(ps), lcid, dwFlags, &V_BSTR(pd)); 424 case VT_I2: return VarBstrFromI2(V_I2(ps), lcid, dwFlags, &V_BSTR(pd)); 425 case VT_I4: return VarBstrFromI4(V_I4(ps), lcid, dwFlags, &V_BSTR(pd)); 426 case VT_UI1: return VarBstrFromUI1(V_UI1(ps), lcid, dwFlags, &V_BSTR(pd)); 427 case VT_UI2: return VarBstrFromUI2(V_UI2(ps), lcid, dwFlags, &V_BSTR(pd)); 428 case VT_UI4: return VarBstrFromUI4(V_UI4(ps), lcid, dwFlags, &V_BSTR(pd)); 429 case VT_I8: return VarBstrFromI8(V_I8(ps), lcid, dwFlags, &V_BSTR(pd)); 430 case VT_UI8: return VarBstrFromUI8(V_UI8(ps), lcid, dwFlags, &V_BSTR(pd)); 431 case VT_R4: return VarBstrFromR4(V_R4(ps), lcid, dwFlags, &V_BSTR(pd)); 432 case VT_R8: return VarBstrFromR8(V_R8(ps), lcid, dwFlags, &V_BSTR(pd)); 433 case VT_DATE: return VarBstrFromDate(V_DATE(ps), lcid, dwFlags, &V_BSTR(pd)); 434 case VT_CY: return VarBstrFromCy(V_CY(ps), lcid, dwFlags, &V_BSTR(pd)); 435 case VT_DECIMAL: return VarBstrFromDec(&V_DECIMAL(ps), lcid, dwFlags, &V_BSTR(pd)); 436 case VT_DISPATCH: return VarBstrFromDisp(V_DISPATCH(ps), lcid, dwFlags, &V_BSTR(pd)); 437 } 438 break; 439 440 case VT_CY: 441 switch (vtFrom) 442 { 443 case VT_EMPTY: V_CY(pd).int64 = 0; return S_OK; 444 case VT_I1: return VarCyFromI1(V_I1(ps), &V_CY(pd)); 445 case VT_I2: return VarCyFromI2(V_I2(ps), &V_CY(pd)); 446 case VT_I4: return VarCyFromI4(V_I4(ps), &V_CY(pd)); 447 case VT_UI1: return VarCyFromUI1(V_UI1(ps), &V_CY(pd)); 448 case VT_UI2: return VarCyFromUI2(V_UI2(ps), &V_CY(pd)); 449 case VT_UI4: return VarCyFromUI4(V_UI4(ps), &V_CY(pd)); 450 case VT_I8: return VarCyFromI8(V_I8(ps), &V_CY(pd)); 451 case VT_UI8: return VarCyFromUI8(V_UI8(ps), &V_CY(pd)); 452 case VT_R4: return VarCyFromR4(V_R4(ps), &V_CY(pd)); 453 case VT_R8: return VarCyFromR8(V_R8(ps), &V_CY(pd)); 454 case VT_DATE: return VarCyFromDate(V_DATE(ps), &V_CY(pd)); 455 case VT_BOOL: return VarCyFromBool(V_BOOL(ps), &V_CY(pd)); 456 case VT_DECIMAL: return VarCyFromDec(&V_DECIMAL(ps), &V_CY(pd)); 457 case VT_DISPATCH: return VarCyFromDisp(V_DISPATCH(ps), lcid, &V_CY(pd)); 458 case VT_BSTR: return VarCyFromStr(V_BSTR(ps), lcid, dwFlags, &V_CY(pd)); 459 } 460 break; 461 462 case VT_DECIMAL: 463 switch (vtFrom) 464 { 465 case VT_EMPTY: 466 case VT_BOOL: 467 DEC_SIGNSCALE(&V_DECIMAL(pd)) = SIGNSCALE(DECIMAL_POS,0); 468 DEC_HI32(&V_DECIMAL(pd)) = 0; 469 DEC_MID32(&V_DECIMAL(pd)) = 0; 470 /* VarDecFromBool() coerces to -1/0, ChangeTypeEx() coerces to 1/0. 471 * VT_NULL and VT_EMPTY always give a 0 value. 472 */ 473 DEC_LO32(&V_DECIMAL(pd)) = vtFrom == VT_BOOL && V_BOOL(ps) ? 1 : 0; 474 return S_OK; 475 case VT_I1: return VarDecFromI1(V_I1(ps), &V_DECIMAL(pd)); 476 case VT_I2: return VarDecFromI2(V_I2(ps), &V_DECIMAL(pd)); 477 case VT_I4: return VarDecFromI4(V_I4(ps), &V_DECIMAL(pd)); 478 case VT_UI1: return VarDecFromUI1(V_UI1(ps), &V_DECIMAL(pd)); 479 case VT_UI2: return VarDecFromUI2(V_UI2(ps), &V_DECIMAL(pd)); 480 case VT_UI4: return VarDecFromUI4(V_UI4(ps), &V_DECIMAL(pd)); 481 case VT_I8: return VarDecFromI8(V_I8(ps), &V_DECIMAL(pd)); 482 case VT_UI8: return VarDecFromUI8(V_UI8(ps), &V_DECIMAL(pd)); 483 case VT_R4: return VarDecFromR4(V_R4(ps), &V_DECIMAL(pd)); 484 case VT_R8: return VarDecFromR8(V_R8(ps), &V_DECIMAL(pd)); 485 case VT_DATE: return VarDecFromDate(V_DATE(ps), &V_DECIMAL(pd)); 486 case VT_CY: return VarDecFromCy(V_CY(ps), &V_DECIMAL(pd)); 487 case VT_DISPATCH: return VarDecFromDisp(V_DISPATCH(ps), lcid, &V_DECIMAL(pd)); 488 case VT_BSTR: return VarDecFromStr(V_BSTR(ps), lcid, dwFlags, &V_DECIMAL(pd)); 489 } 490 break; 491 492 case VT_UNKNOWN: 493 switch (vtFrom) 494 { 495 case VT_DISPATCH: 496 if (V_DISPATCH(ps) == NULL) 497 V_UNKNOWN(pd) = NULL; 498 else 499 res = IDispatch_QueryInterface(V_DISPATCH(ps), &IID_IUnknown, (LPVOID*)&V_UNKNOWN(pd)); 500 break; 501 } 502 break; 503 504 case VT_DISPATCH: 505 switch (vtFrom) 506 { 507 case VT_UNKNOWN: 508 if (V_UNKNOWN(ps) == NULL) 509 V_DISPATCH(pd) = NULL; 510 else 511 res = IUnknown_QueryInterface(V_UNKNOWN(ps), &IID_IDispatch, (LPVOID*)&V_DISPATCH(pd)); 512 break; 513 } 514 break; 515 516 case VT_RECORD: 517 break; 518 } 519 return res; 520 } 521 522 /* Coerce to/from an array */ 523 static inline HRESULT VARIANT_CoerceArray(VARIANTARG* pd, VARIANTARG* ps, VARTYPE vt) 524 { 525 if (vt == VT_BSTR && V_VT(ps) == (VT_ARRAY|VT_UI1)) 526 return BstrFromVector(V_ARRAY(ps), &V_BSTR(pd)); 527 528 if (V_VT(ps) == VT_BSTR && vt == (VT_ARRAY|VT_UI1)) 529 return VectorFromBstr(V_BSTR(ps), &V_ARRAY(ps)); 530 531 if (V_VT(ps) == vt) 532 return SafeArrayCopy(V_ARRAY(ps), &V_ARRAY(pd)); 533 534 return DISP_E_TYPEMISMATCH; 535 } 536 537 /****************************************************************************** 538 * Check if a variants type is valid. 539 */ 540 static inline HRESULT VARIANT_ValidateType(VARTYPE vt) 541 { 542 VARTYPE vtExtra = vt & VT_EXTRA_TYPE; 543 544 vt &= VT_TYPEMASK; 545 546 if (!(vtExtra & (VT_VECTOR|VT_RESERVED))) 547 { 548 if (vt < VT_VOID || vt == VT_RECORD || vt == VT_CLSID) 549 { 550 if ((vtExtra & (VT_BYREF|VT_ARRAY)) && vt <= VT_NULL) 551 return DISP_E_BADVARTYPE; 552 if (vt != (VARTYPE)15) 553 return S_OK; 554 } 555 } 556 return DISP_E_BADVARTYPE; 557 } 558 559 /****************************************************************************** 560 * VariantInit [OLEAUT32.8] 561 * 562 * Initialise a variant. 563 * 564 * PARAMS 565 * pVarg [O] Variant to initialise 566 * 567 * RETURNS 568 * Nothing. 569 * 570 * NOTES 571 * This function simply sets the type of the variant to VT_EMPTY. It does not 572 * free any existing value, use VariantClear() for that. 573 */ 574 void WINAPI VariantInit(VARIANTARG* pVarg) 575 { 576 TRACE("(%p)\n", pVarg); 577 578 V_VT(pVarg) = VT_EMPTY; /* Native doesn't set any other fields */ 579 } 580 581 HRESULT VARIANT_ClearInd(VARIANTARG *pVarg) 582 { 583 HRESULT hres; 584 585 TRACE("(%p->(%s%s))\n", pVarg, debugstr_VT(pVarg), debugstr_VF(pVarg)); 586 587 hres = VARIANT_ValidateType(V_VT(pVarg)); 588 if (FAILED(hres)) 589 return hres; 590 591 switch (V_VT(pVarg)) 592 { 593 case VT_DISPATCH: 594 case VT_UNKNOWN: 595 if (V_UNKNOWN(pVarg)) 596 IUnknown_Release(V_UNKNOWN(pVarg)); 597 break; 598 case VT_UNKNOWN | VT_BYREF: 599 case VT_DISPATCH | VT_BYREF: 600 if(*V_UNKNOWNREF(pVarg)) 601 IUnknown_Release(*V_UNKNOWNREF(pVarg)); 602 break; 603 case VT_BSTR: 604 SysFreeString(V_BSTR(pVarg)); 605 break; 606 case VT_BSTR | VT_BYREF: 607 SysFreeString(*V_BSTRREF(pVarg)); 608 break; 609 case VT_VARIANT | VT_BYREF: 610 VariantClear(V_VARIANTREF(pVarg)); 611 break; 612 case VT_RECORD: 613 case VT_RECORD | VT_BYREF: 614 { 615 struct __tagBRECORD* pBr = &V_UNION(pVarg,brecVal); 616 if (pBr->pRecInfo) 617 { 618 IRecordInfo_RecordClear(pBr->pRecInfo, pBr->pvRecord); 619 IRecordInfo_Release(pBr->pRecInfo); 620 } 621 break; 622 } 623 default: 624 if (V_ISARRAY(pVarg) || (V_VT(pVarg) & ~VT_BYREF) == VT_SAFEARRAY) 625 { 626 if (V_ISBYREF(pVarg)) 627 { 628 if (*V_ARRAYREF(pVarg)) 629 hres = SafeArrayDestroy(*V_ARRAYREF(pVarg)); 630 } 631 else if (V_ARRAY(pVarg)) 632 hres = SafeArrayDestroy(V_ARRAY(pVarg)); 633 } 634 break; 635 } 636 637 V_VT(pVarg) = VT_EMPTY; 638 return hres; 639 } 640 641 /****************************************************************************** 642 * VariantClear [OLEAUT32.9] 643 * 644 * Clear a variant. 645 * 646 * PARAMS 647 * pVarg [I/O] Variant to clear 648 * 649 * RETURNS 650 * Success: S_OK. Any previous value in pVarg is freed and its type is set to VT_EMPTY. 651 * Failure: DISP_E_BADVARTYPE, if the variant is not a valid variant type. 652 */ 653 HRESULT WINAPI VariantClear(VARIANTARG* pVarg) 654 { 655 HRESULT hres = S_OK; 656 657 TRACE("(%p->(%s%s))\n", pVarg, debugstr_VT(pVarg), debugstr_VF(pVarg)); 658 659 hres = VARIANT_ValidateType(V_VT(pVarg)); 660 661 if (SUCCEEDED(hres)) 662 { 663 if (!V_ISBYREF(pVarg)) 664 { 665 if (V_ISARRAY(pVarg) || V_VT(pVarg) == VT_SAFEARRAY) 666 { 667 if (V_ARRAY(pVarg)) 668 hres = SafeArrayDestroy(V_ARRAY(pVarg)); 669 } 670 else if (V_VT(pVarg) == VT_BSTR) 671 { 672 SysFreeString(V_BSTR(pVarg)); 673 } 674 else if (V_VT(pVarg) == VT_RECORD) 675 { 676 struct __tagBRECORD* pBr = &V_UNION(pVarg,brecVal); 677 if (pBr->pRecInfo) 678 { 679 IRecordInfo_RecordClear(pBr->pRecInfo, pBr->pvRecord); 680 IRecordInfo_Release(pBr->pRecInfo); 681 } 682 } 683 else if (V_VT(pVarg) == VT_DISPATCH || 684 V_VT(pVarg) == VT_UNKNOWN) 685 { 686 if (V_UNKNOWN(pVarg)) 687 IUnknown_Release(V_UNKNOWN(pVarg)); 688 } 689 } 690 V_VT(pVarg) = VT_EMPTY; 691 } 692 return hres; 693 } 694 695 /****************************************************************************** 696 * Copy an IRecordInfo object contained in a variant. 697 */ 698 static HRESULT VARIANT_CopyIRecordInfo(struct __tagBRECORD* pBr) 699 { 700 HRESULT hres = S_OK; 701 702 if (pBr->pRecInfo) 703 { 704 ULONG ulSize; 705 706 hres = IRecordInfo_GetSize(pBr->pRecInfo, &ulSize); 707 if (SUCCEEDED(hres)) 708 { 709 PVOID pvRecord = HeapAlloc(GetProcessHeap(), 0, ulSize); 710 if (!pvRecord) 711 hres = E_OUTOFMEMORY; 712 else 713 { 714 memcpy(pvRecord, pBr->pvRecord, ulSize); 715 pBr->pvRecord = pvRecord; 716 717 hres = IRecordInfo_RecordCopy(pBr->pRecInfo, pvRecord, pvRecord); 718 if (SUCCEEDED(hres)) 719 IRecordInfo_AddRef(pBr->pRecInfo); 720 } 721 } 722 } 723 else if (pBr->pvRecord) 724 hres = E_INVALIDARG; 725 return hres; 726 } 727 728 /****************************************************************************** 729 * VariantCopy [OLEAUT32.10] 730 * 731 * Copy a variant. 732 * 733 * PARAMS 734 * pvargDest [O] Destination for copy 735 * pvargSrc [I] Source variant to copy 736 * 737 * RETURNS 738 * Success: S_OK. pvargDest contains a copy of pvargSrc. 739 * Failure: DISP_E_BADVARTYPE, if either variant has an invalid type. 740 * E_OUTOFMEMORY, if memory cannot be allocated. Otherwise an 741 * HRESULT error code from SafeArrayCopy(), IRecordInfo_GetSize(), 742 * or IRecordInfo_RecordCopy(), depending on the type of pvargSrc. 743 * 744 * NOTES 745 * - If pvargSrc == pvargDest, this function does nothing, and succeeds if 746 * pvargSrc is valid. Otherwise, pvargDest is always cleared using 747 * VariantClear() before pvargSrc is copied to it. If clearing pvargDest 748 * fails, so does this function. 749 * - VT_CLSID is a valid type type for pvargSrc, but not for pvargDest. 750 * - For by-value non-intrinsic types, a deep copy is made, i.e. The whole value 751 * is copied rather than just any pointers to it. 752 * - For by-value object types the object pointer is copied and the objects 753 * reference count increased using IUnknown_AddRef(). 754 * - For all by-reference types, only the referencing pointer is copied. 755 */ 756 HRESULT WINAPI VariantCopy(VARIANTARG* pvargDest, VARIANTARG* pvargSrc) 757 { 758 HRESULT hres = S_OK; 759 760 TRACE("(%p->(%s%s),%p->(%s%s))\n", pvargDest, debugstr_VT(pvargDest), 761 debugstr_VF(pvargDest), pvargSrc, debugstr_VT(pvargSrc), 762 debugstr_VF(pvargSrc)); 763 764 if (V_TYPE(pvargSrc) == VT_CLSID || /* VT_CLSID is a special case */ 765 FAILED(VARIANT_ValidateType(V_VT(pvargSrc)))) 766 return DISP_E_BADVARTYPE; 767 768 if (pvargSrc != pvargDest && 769 SUCCEEDED(hres = VariantClear(pvargDest))) 770 { 771 *pvargDest = *pvargSrc; /* Shallow copy the value */ 772 773 if (!V_ISBYREF(pvargSrc)) 774 { 775 if (V_ISARRAY(pvargSrc)) 776 { 777 if (V_ARRAY(pvargSrc)) 778 hres = SafeArrayCopy(V_ARRAY(pvargSrc), &V_ARRAY(pvargDest)); 779 } 780 else if (V_VT(pvargSrc) == VT_BSTR) 781 { 782 V_BSTR(pvargDest) = SysAllocStringByteLen((char*)V_BSTR(pvargSrc), SysStringByteLen(V_BSTR(pvargSrc))); 783 if (!V_BSTR(pvargDest)) 784 { 785 TRACE("!V_BSTR(pvargDest), SysAllocStringByteLen() failed to allocate %d bytes\n", SysStringByteLen(V_BSTR(pvargSrc))); 786 hres = E_OUTOFMEMORY; 787 } 788 } 789 else if (V_VT(pvargSrc) == VT_RECORD) 790 { 791 hres = VARIANT_CopyIRecordInfo(&V_UNION(pvargDest,brecVal)); 792 } 793 else if (V_VT(pvargSrc) == VT_DISPATCH || 794 V_VT(pvargSrc) == VT_UNKNOWN) 795 { 796 if (V_UNKNOWN(pvargSrc)) 797 IUnknown_AddRef(V_UNKNOWN(pvargSrc)); 798 } 799 } 800 } 801 return hres; 802 } 803 804 /* Return the byte size of a variants data */ 805 static inline size_t VARIANT_DataSize(const VARIANT* pv) 806 { 807 switch (V_TYPE(pv)) 808 { 809 case VT_I1: 810 case VT_UI1: return sizeof(BYTE); 811 case VT_I2: 812 case VT_UI2: return sizeof(SHORT); 813 case VT_INT: 814 case VT_UINT: 815 case VT_I4: 816 case VT_UI4: return sizeof(LONG); 817 case VT_I8: 818 case VT_UI8: return sizeof(LONGLONG); 819 case VT_R4: return sizeof(float); 820 case VT_R8: return sizeof(double); 821 case VT_DATE: return sizeof(DATE); 822 case VT_BOOL: return sizeof(VARIANT_BOOL); 823 case VT_DISPATCH: 824 case VT_UNKNOWN: 825 case VT_BSTR: return sizeof(void*); 826 case VT_CY: return sizeof(CY); 827 case VT_ERROR: return sizeof(SCODE); 828 } 829 TRACE("Shouldn't be called for vt %s%s!\n", debugstr_VT(pv), debugstr_VF(pv)); 830 return 0; 831 } 832 833 /****************************************************************************** 834 * VariantCopyInd [OLEAUT32.11] 835 * 836 * Copy a variant, dereferencing it if it is by-reference. 837 * 838 * PARAMS 839 * pvargDest [O] Destination for copy 840 * pvargSrc [I] Source variant to copy 841 * 842 * RETURNS 843 * Success: S_OK. pvargDest contains a copy of pvargSrc. 844 * Failure: An HRESULT error code indicating the error. 845 * 846 * NOTES 847 * Failure: DISP_E_BADVARTYPE, if either variant has an invalid by-value type. 848 * E_INVALIDARG, if pvargSrc is an invalid by-reference type. 849 * E_OUTOFMEMORY, if memory cannot be allocated. Otherwise an 850 * HRESULT error code from SafeArrayCopy(), IRecordInfo_GetSize(), 851 * or IRecordInfo_RecordCopy(), depending on the type of pvargSrc. 852 * 853 * NOTES 854 * - If pvargSrc is by-value, this function behaves exactly as VariantCopy(). 855 * - If pvargSrc is by-reference, the value copied to pvargDest is the pointed-to 856 * value. 857 * - if pvargSrc == pvargDest, this function dereferences in place. Otherwise, 858 * pvargDest is always cleared using VariantClear() before pvargSrc is copied 859 * to it. If clearing pvargDest fails, so does this function. 860 */ 861 HRESULT WINAPI VariantCopyInd(VARIANT* pvargDest, VARIANTARG* pvargSrc) 862 { 863 VARIANTARG vTmp, *pSrc = pvargSrc; 864 VARTYPE vt; 865 HRESULT hres = S_OK; 866 867 TRACE("(%p->(%s%s),%p->(%s%s))\n", pvargDest, debugstr_VT(pvargDest), 868 debugstr_VF(pvargDest), pvargSrc, debugstr_VT(pvargSrc), 869 debugstr_VF(pvargSrc)); 870 871 if (!V_ISBYREF(pvargSrc)) 872 return VariantCopy(pvargDest, pvargSrc); 873 874 /* Argument checking is more lax than VariantCopy()... */ 875 vt = V_TYPE(pvargSrc); 876 if (V_ISARRAY(pvargSrc) || 877 (vt > VT_NULL && vt != (VARTYPE)15 && vt < VT_VOID && 878 !(V_VT(pvargSrc) & (VT_VECTOR|VT_RESERVED)))) 879 { 880 /* OK */ 881 } 882 else 883 return E_INVALIDARG; /* ...And the return value for invalid types differs too */ 884 885 if (pvargSrc == pvargDest) 886 { 887 /* In place copy. Use a shallow copy of pvargSrc & init pvargDest. 888 * This avoids an expensive VariantCopy() call - e.g. SafeArrayCopy(). 889 */ 890 vTmp = *pvargSrc; 891 pSrc = &vTmp; 892 V_VT(pvargDest) = VT_EMPTY; 893 } 894 else 895 { 896 /* Copy into another variant. Free the variant in pvargDest */ 897 if (FAILED(hres = VariantClear(pvargDest))) 898 { 899 TRACE("VariantClear() of destination failed\n"); 900 return hres; 901 } 902 } 903 904 if (V_ISARRAY(pSrc)) 905 { 906 /* Native doesn't check that *V_ARRAYREF(pSrc) is valid */ 907 hres = SafeArrayCopy(*V_ARRAYREF(pSrc), &V_ARRAY(pvargDest)); 908 } 909 else if (V_VT(pSrc) == (VT_BSTR|VT_BYREF)) 910 { 911 /* Native doesn't check that *V_BSTRREF(pSrc) is valid */ 912 V_BSTR(pvargDest) = SysAllocStringByteLen((char*)*V_BSTRREF(pSrc), SysStringByteLen(*V_BSTRREF(pSrc))); 913 } 914 else if (V_VT(pSrc) == (VT_RECORD|VT_BYREF)) 915 { 916 V_UNION(pvargDest,brecVal) = V_UNION(pvargSrc,brecVal); 917 hres = VARIANT_CopyIRecordInfo(&V_UNION(pvargDest,brecVal)); 918 } 919 else if (V_VT(pSrc) == (VT_DISPATCH|VT_BYREF) || 920 V_VT(pSrc) == (VT_UNKNOWN|VT_BYREF)) 921 { 922 /* Native doesn't check that *V_UNKNOWNREF(pSrc) is valid */ 923 V_UNKNOWN(pvargDest) = *V_UNKNOWNREF(pSrc); 924 if (*V_UNKNOWNREF(pSrc)) 925 IUnknown_AddRef(*V_UNKNOWNREF(pSrc)); 926 } 927 else if (V_VT(pSrc) == (VT_VARIANT|VT_BYREF)) 928 { 929 /* Native doesn't check that *V_VARIANTREF(pSrc) is valid */ 930 if (V_VT(V_VARIANTREF(pSrc)) == (VT_VARIANT|VT_BYREF)) 931 hres = E_INVALIDARG; /* Don't dereference more than one level */ 932 else 933 hres = VariantCopyInd(pvargDest, V_VARIANTREF(pSrc)); 934 935 /* Use the dereferenced variants type value, not VT_VARIANT */ 936 goto VariantCopyInd_Return; 937 } 938 else if (V_VT(pSrc) == (VT_DECIMAL|VT_BYREF)) 939 { 940 memcpy(&DEC_SCALE(&V_DECIMAL(pvargDest)), &DEC_SCALE(V_DECIMALREF(pSrc)), 941 sizeof(DECIMAL) - sizeof(USHORT)); 942 } 943 else 944 { 945 /* Copy the pointed to data into this variant */ 946 memcpy(&V_BYREF(pvargDest), V_BYREF(pSrc), VARIANT_DataSize(pSrc)); 947 } 948 949 V_VT(pvargDest) = V_VT(pSrc) & ~VT_BYREF; 950 951 VariantCopyInd_Return: 952 953 if (pSrc != pvargSrc) 954 VariantClear(pSrc); 955 956 TRACE("returning 0x%08x, %p->(%s%s)\n", hres, pvargDest, 957 debugstr_VT(pvargDest), debugstr_VF(pvargDest)); 958 return hres; 959 } 960 961 /****************************************************************************** 962 * VariantChangeType [OLEAUT32.12] 963 * 964 * Change the type of a variant. 965 * 966 * PARAMS 967 * pvargDest [O] Destination for the converted variant 968 * pvargSrc [O] Source variant to change the type of 969 * wFlags [I] VARIANT_ flags from "oleauto.h" 970 * vt [I] Variant type to change pvargSrc into 971 * 972 * RETURNS 973 * Success: S_OK. pvargDest contains the converted value. 974 * Failure: An HRESULT error code describing the failure. 975 * 976 * NOTES 977 * The LCID used for the conversion is LOCALE_USER_DEFAULT. 978 * See VariantChangeTypeEx. 979 */ 980 HRESULT WINAPI VariantChangeType(VARIANTARG* pvargDest, VARIANTARG* pvargSrc, 981 USHORT wFlags, VARTYPE vt) 982 { 983 return VariantChangeTypeEx( pvargDest, pvargSrc, LOCALE_USER_DEFAULT, wFlags, vt ); 984 } 985 986 /****************************************************************************** 987 * VariantChangeTypeEx [OLEAUT32.147] 988 * 989 * Change the type of a variant. 990 * 991 * PARAMS 992 * pvargDest [O] Destination for the converted variant 993 * pvargSrc [O] Source variant to change the type of 994 * lcid [I] LCID for the conversion 995 * wFlags [I] VARIANT_ flags from "oleauto.h" 996 * vt [I] Variant type to change pvargSrc into 997 * 998 * RETURNS 999 * Success: S_OK. pvargDest contains the converted value. 1000 * Failure: An HRESULT error code describing the failure. 1001 * 1002 * NOTES 1003 * pvargDest and pvargSrc can point to the same variant to perform an in-place 1004 * conversion. If the conversion is successful, pvargSrc will be freed. 1005 */ 1006 HRESULT WINAPI VariantChangeTypeEx(VARIANTARG* pvargDest, VARIANTARG* pvargSrc, 1007 LCID lcid, USHORT wFlags, VARTYPE vt) 1008 { 1009 HRESULT res = S_OK; 1010 1011 TRACE("(%p->(%s%s),%p->(%s%s),0x%08x,0x%04x,%s%s)\n", pvargDest, 1012 debugstr_VT(pvargDest), debugstr_VF(pvargDest), pvargSrc, 1013 debugstr_VT(pvargSrc), debugstr_VF(pvargSrc), lcid, wFlags, 1014 debugstr_vt(vt), debugstr_vf(vt)); 1015 1016 if (vt == VT_CLSID) 1017 res = DISP_E_BADVARTYPE; 1018 else 1019 { 1020 res = VARIANT_ValidateType(V_VT(pvargSrc)); 1021 1022 if (SUCCEEDED(res)) 1023 { 1024 res = VARIANT_ValidateType(vt); 1025 1026 if (SUCCEEDED(res)) 1027 { 1028 VARIANTARG vTmp, vSrcDeref; 1029 1030 if(V_ISBYREF(pvargSrc) && !V_BYREF(pvargSrc)) 1031 res = DISP_E_TYPEMISMATCH; 1032 else 1033 { 1034 V_VT(&vTmp) = VT_EMPTY; 1035 V_VT(&vSrcDeref) = VT_EMPTY; 1036 VariantClear(&vTmp); 1037 VariantClear(&vSrcDeref); 1038 } 1039 1040 if (SUCCEEDED(res)) 1041 { 1042 res = VariantCopyInd(&vSrcDeref, pvargSrc); 1043 if (SUCCEEDED(res)) 1044 { 1045 if (V_ISARRAY(&vSrcDeref) || (vt & VT_ARRAY)) 1046 res = VARIANT_CoerceArray(&vTmp, &vSrcDeref, vt); 1047 else 1048 res = VARIANT_Coerce(&vTmp, lcid, wFlags, &vSrcDeref, vt); 1049 1050 if (SUCCEEDED(res)) { 1051 V_VT(&vTmp) = vt; 1052 VariantCopy(pvargDest, &vTmp); 1053 } 1054 VariantClear(&vTmp); 1055 VariantClear(&vSrcDeref); 1056 } 1057 } 1058 } 1059 } 1060 } 1061 1062 TRACE("returning 0x%08x, %p->(%s%s)\n", res, pvargDest, 1063 debugstr_VT(pvargDest), debugstr_VF(pvargDest)); 1064 return res; 1065 } 1066 1067 /* Date Conversions */ 1068 1069 #define IsLeapYear(y) (((y % 4) == 0) && (((y % 100) != 0) || ((y % 400) == 0))) 1070 1071 /* Convert a VT_DATE value to a Julian Date */ 1072 static inline int VARIANT_JulianFromDate(int dateIn) 1073 { 1074 int julianDays = dateIn; 1075 1076 julianDays -= DATE_MIN; /* Convert to + days from 1 Jan 100 AD */ 1077 julianDays += 1757585; /* Convert to + days from 23 Nov 4713 BC (Julian) */ 1078 return julianDays; 1079 } 1080 1081 /* Convert a Julian Date to a VT_DATE value */ 1082 static inline int VARIANT_DateFromJulian(int dateIn) 1083 { 1084 int julianDays = dateIn; 1085 1086 julianDays -= 1757585; /* Convert to + days from 1 Jan 100 AD */ 1087 julianDays += DATE_MIN; /* Convert to +/- days from 1 Jan 1899 AD */ 1088 return julianDays; 1089 } 1090 1091 /* Convert a Julian date to Day/Month/Year - from PostgreSQL */ 1092 static inline void VARIANT_DMYFromJulian(int jd, USHORT *year, USHORT *month, USHORT *day) 1093 { 1094 int j, i, l, n; 1095 1096 l = jd + 68569; 1097 n = l * 4 / 146097; 1098 l -= (n * 146097 + 3) / 4; 1099 i = (4000 * (l + 1)) / 1461001; 1100 l += 31 - (i * 1461) / 4; 1101 j = (l * 80) / 2447; 1102 *day = l - (j * 2447) / 80; 1103 l = j / 11; 1104 *month = (j + 2) - (12 * l); 1105 *year = 100 * (n - 49) + i + l; 1106 } 1107 1108 /* Convert Day/Month/Year to a Julian date - from PostgreSQL */ 1109 static inline double VARIANT_JulianFromDMY(USHORT year, USHORT month, USHORT day) 1110 { 1111 int m12 = (month - 14) / 12; 1112 1113 return ((1461 * (year + 4800 + m12)) / 4 + (367 * (month - 2 - 12 * m12)) / 12 - 1114 (3 * ((year + 4900 + m12) / 100)) / 4 + day - 32075); 1115 } 1116 1117 /* Macros for accessing DOS format date/time fields */ 1118 #define DOS_YEAR(x) (1980 + (x >> 9)) 1119 #define DOS_MONTH(x) ((x >> 5) & 0xf) 1120 #define DOS_DAY(x) (x & 0x1f) 1121 #define DOS_HOUR(x) (x >> 11) 1122 #define DOS_MINUTE(x) ((x >> 5) & 0x3f) 1123 #define DOS_SECOND(x) ((x & 0x1f) << 1) 1124 /* Create a DOS format date/time */ 1125 #define DOS_DATE(d,m,y) (d | (m << 5) | ((y-1980) << 9)) 1126 #define DOS_TIME(h,m,s) ((s >> 1) | (m << 5) | (h << 11)) 1127 1128 /* Roll a date forwards or backwards to correct it */ 1129 static HRESULT VARIANT_RollUdate(UDATE *lpUd) 1130 { 1131 static const BYTE days[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; 1132 short iYear, iMonth, iDay, iHour, iMinute, iSecond; 1133 1134 /* interpret values signed */ 1135 iYear = lpUd->st.wYear; 1136 iMonth = lpUd->st.wMonth; 1137 iDay = lpUd->st.wDay; 1138 iHour = lpUd->st.wHour; 1139 iMinute = lpUd->st.wMinute; 1140 iSecond = lpUd->st.wSecond; 1141 1142 TRACE("Raw date: %d/%d/%d %d:%d:%d\n", iDay, iMonth, 1143 iYear, iHour, iMinute, iSecond); 1144 1145 if (iYear > 9999 || iYear < -9999) 1146 return E_INVALIDARG; /* Invalid value */ 1147 /* Years < 100 are treated as 1900 + year */ 1148 if (iYear > 0 && iYear < 100) 1149 iYear += 1900; 1150 1151 iMinute += (iSecond - (iSecond % 60)) / 60; 1152 iSecond = iSecond % 60; 1153 iHour += (iMinute - (iMinute % 60)) / 60; 1154 iMinute = iMinute % 60; 1155 iDay += (iHour - (iHour % 24)) / 24; 1156 iHour = iHour % 24; 1157 iYear += (iMonth - (iMonth % 12)) / 12; 1158 iMonth = iMonth % 12; 1159 if (iMonth<=0) {iMonth+=12; iYear--;} 1160 while (iDay > days[iMonth]) 1161 { 1162 if (iMonth == 2 && IsLeapYear(iYear)) 1163 iDay -= 29; 1164 else 1165 iDay -= days[iMonth]; 1166 iMonth++; 1167 iYear += (iMonth - (iMonth % 12)) / 12; 1168 iMonth = iMonth % 12; 1169 } 1170 while (iDay <= 0) 1171 { 1172 iMonth--; 1173 if (iMonth<=0) {iMonth+=12; iYear--;} 1174 if (iMonth == 2 && IsLeapYear(iYear)) 1175 iDay += 29; 1176 else 1177 iDay += days[iMonth]; 1178 } 1179 1180 if (iSecond<0){iSecond+=60; iMinute--;} 1181 if (iMinute<0){iMinute+=60; iHour--;} 1182 if (iHour<0) {iHour+=24; iDay--;} 1183 if (iYear<=0) iYear+=2000; 1184 1185 lpUd->st.wYear = iYear; 1186 lpUd->st.wMonth = iMonth; 1187 lpUd->st.wDay = iDay; 1188 lpUd->st.wHour = iHour; 1189 lpUd->st.wMinute = iMinute; 1190 lpUd->st.wSecond = iSecond; 1191 1192 TRACE("Rolled date: %d/%d/%d %d:%d:%d\n", lpUd->st.wDay, lpUd->st.wMonth, 1193 lpUd->st.wYear, lpUd->st.wHour, lpUd->st.wMinute, lpUd->st.wSecond); 1194 return S_OK; 1195 } 1196 1197 /********************************************************************** 1198 * DosDateTimeToVariantTime [OLEAUT32.14] 1199 * 1200 * Convert a Dos format date and time into variant VT_DATE format. 1201 * 1202 * PARAMS 1203 * wDosDate [I] Dos format date 1204 * wDosTime [I] Dos format time 1205 * pDateOut [O] Destination for VT_DATE format 1206 * 1207 * RETURNS 1208 * Success: TRUE. pDateOut contains the converted time. 1209 * Failure: FALSE, if wDosDate or wDosTime are invalid (see notes). 1210 * 1211 * NOTES 1212 * - Dos format dates can only hold dates from 1-Jan-1980 to 31-Dec-2099. 1213 * - Dos format times are accurate to only 2 second precision. 1214 * - The format of a Dos Date is: 1215 *| Bits Values Meaning 1216 *| ---- ------ ------- 1217 *| 0-4 1-31 Day of the week. 0 rolls back one day. A value greater than 1218 *| the days in the month rolls forward the extra days. 1219 *| 5-8 1-12 Month of the year. 0 rolls back to December of the previous 1220 *| year. 13-15 are invalid. 1221 *| 9-15 0-119 Year based from 1980 (Max 2099). 120-127 are invalid. 1222 * - The format of a Dos Time is: 1223 *| Bits Values Meaning 1224 *| ---- ------ ------- 1225 *| 0-4 0-29 Seconds/2. 30 and 31 are invalid. 1226 *| 5-10 0-59 Minutes. 60-63 are invalid. 1227 *| 11-15 0-23 Hours (24 hour clock). 24-32 are invalid. 1228 */ 1229 INT WINAPI DosDateTimeToVariantTime(USHORT wDosDate, USHORT wDosTime, 1230 double *pDateOut) 1231 { 1232 UDATE ud; 1233 1234 TRACE("(0x%x(%d/%d/%d),0x%x(%d:%d:%d),%p)\n", 1235 wDosDate, DOS_YEAR(wDosDate), DOS_MONTH(wDosDate), DOS_DAY(wDosDate), 1236 wDosTime, DOS_HOUR(wDosTime), DOS_MINUTE(wDosTime), DOS_SECOND(wDosTime), 1237 pDateOut); 1238 1239 ud.st.wYear = DOS_YEAR(wDosDate); 1240 ud.st.wMonth = DOS_MONTH(wDosDate); 1241 if (ud.st.wYear > 2099 || ud.st.wMonth > 12) 1242 return FALSE; 1243 ud.st.wDay = DOS_DAY(wDosDate); 1244 ud.st.wHour = DOS_HOUR(wDosTime); 1245 ud.st.wMinute = DOS_MINUTE(wDosTime); 1246 ud.st.wSecond = DOS_SECOND(wDosTime); 1247 ud.st.wDayOfWeek = ud.st.wMilliseconds = 0; 1248 if (ud.st.wHour > 23 || ud.st.wMinute > 59 || ud.st.wSecond > 59) 1249 return FALSE; /* Invalid values in Dos*/ 1250 1251 return VarDateFromUdate(&ud, 0, pDateOut) == S_OK; 1252 } 1253 1254 /********************************************************************** 1255 * VariantTimeToDosDateTime [OLEAUT32.13] 1256 * 1257 * Convert a variant format date into a Dos format date and time. 1258 * 1259 * dateIn [I] VT_DATE time format 1260 * pwDosDate [O] Destination for Dos format date 1261 * pwDosTime [O] Destination for Dos format time 1262 * 1263 * RETURNS 1264 * Success: TRUE. pwDosDate and pwDosTime contains the converted values. 1265 * Failure: FALSE, if dateIn cannot be represented in Dos format. 1266 * 1267 * NOTES 1268 * See DosDateTimeToVariantTime() for Dos format details and bugs. 1269 */ 1270 INT WINAPI VariantTimeToDosDateTime(double dateIn, USHORT *pwDosDate, USHORT *pwDosTime) 1271 { 1272 UDATE ud; 1273 1274 TRACE("(%g,%p,%p)\n", dateIn, pwDosDate, pwDosTime); 1275 1276 if (FAILED(VarUdateFromDate(dateIn, 0, &ud))) 1277 return FALSE; 1278 1279 if (ud.st.wYear < 1980 || ud.st.wYear > 2099) 1280 return FALSE; 1281 1282 *pwDosDate = DOS_DATE(ud.st.wDay, ud.st.wMonth, ud.st.wYear); 1283 *pwDosTime = DOS_TIME(ud.st.wHour, ud.st.wMinute, ud.st.wSecond); 1284 1285 TRACE("Returning 0x%x(%d/%d/%d), 0x%x(%d:%d:%d)\n", 1286 *pwDosDate, DOS_YEAR(*pwDosDate), DOS_MONTH(*pwDosDate), DOS_DAY(*pwDosDate), 1287 *pwDosTime, DOS_HOUR(*pwDosTime), DOS_MINUTE(*pwDosTime), DOS_SECOND(*pwDosTime)); 1288 return TRUE; 1289 } 1290 1291 /*********************************************************************** 1292 * SystemTimeToVariantTime [OLEAUT32.184] 1293 * 1294 * Convert a System format date and time into variant VT_DATE format. 1295 * 1296 * PARAMS 1297 * lpSt [I] System format date and time 1298 * pDateOut [O] Destination for VT_DATE format date 1299 * 1300 * RETURNS 1301 * Success: TRUE. *pDateOut contains the converted value. 1302 * Failure: FALSE, if lpSt cannot be represented in VT_DATE format. 1303 */ 1304 INT WINAPI SystemTimeToVariantTime(LPSYSTEMTIME lpSt, double *pDateOut) 1305 { 1306 UDATE ud; 1307 1308 TRACE("(%p->%d/%d/%d %d:%d:%d,%p)\n", lpSt, lpSt->wDay, lpSt->wMonth, 1309 lpSt->wYear, lpSt->wHour, lpSt->wMinute, lpSt->wSecond, pDateOut); 1310 1311 if (lpSt->wMonth > 12) 1312 return FALSE; 1313 1314 ud.st = *lpSt; 1315 return VarDateFromUdate(&ud, 0, pDateOut) == S_OK; 1316 } 1317 1318 /*********************************************************************** 1319 * VariantTimeToSystemTime [OLEAUT32.185] 1320 * 1321 * Convert a variant VT_DATE into a System format date and time. 1322 * 1323 * PARAMS 1324 * datein [I] Variant VT_DATE format date 1325 * lpSt [O] Destination for System format date and time 1326 * 1327 * RETURNS 1328 * Success: TRUE. *lpSt contains the converted value. 1329 * Failure: FALSE, if dateIn is too large or small. 1330 */ 1331 INT WINAPI VariantTimeToSystemTime(double dateIn, LPSYSTEMTIME lpSt) 1332 { 1333 UDATE ud; 1334 1335 TRACE("(%g,%p)\n", dateIn, lpSt); 1336 1337 if (FAILED(VarUdateFromDate(dateIn, 0, &ud))) 1338 return FALSE; 1339 1340 *lpSt = ud.st; 1341 return TRUE; 1342 } 1343 1344 /*********************************************************************** 1345 * VarDateFromUdateEx [OLEAUT32.319] 1346 * 1347 * Convert an unpacked format date and time to a variant VT_DATE. 1348 * 1349 * PARAMS 1350 * pUdateIn [I] Unpacked format date and time to convert 1351 * lcid [I] Locale identifier for the conversion 1352 * dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h") 1353 * pDateOut [O] Destination for variant VT_DATE. 1354 * 1355 * RETURNS 1356 * Success: S_OK. *pDateOut contains the converted value. 1357 * Failure: E_INVALIDARG, if pUdateIn cannot be represented in VT_DATE format. 1358 */ 1359 HRESULT WINAPI VarDateFromUdateEx(UDATE *pUdateIn, LCID lcid, ULONG dwFlags, DATE *pDateOut) 1360 { 1361 UDATE ud; 1362 double dateVal; 1363 1364 TRACE("(%p->%d/%d/%d %d:%d:%d:%d %d %d,0x%08x,0x%08x,%p)\n", pUdateIn, 1365 pUdateIn->st.wMonth, pUdateIn->st.wDay, pUdateIn->st.wYear, 1366 pUdateIn->st.wHour, pUdateIn->st.wMinute, pUdateIn->st.wSecond, 1367 pUdateIn->st.wMilliseconds, pUdateIn->st.wDayOfWeek, 1368 pUdateIn->wDayOfYear, lcid, dwFlags, pDateOut); 1369 1370 if (lcid != MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT)) 1371 FIXME("lcid possibly not handled, treating as en-us\n"); 1372 1373 ud = *pUdateIn; 1374 1375 if (dwFlags & VAR_VALIDDATE) 1376 WARN("Ignoring VAR_VALIDDATE\n"); 1377 1378 if (FAILED(VARIANT_RollUdate(&ud))) 1379 return E_INVALIDARG; 1380 1381 /* Date */ 1382 dateVal = VARIANT_DateFromJulian(VARIANT_JulianFromDMY(ud.st.wYear, ud.st.wMonth, ud.st.wDay)); 1383 1384 /* Time */ 1385 dateVal += ud.st.wHour / 24.0; 1386 dateVal += ud.st.wMinute / 1440.0; 1387 dateVal += ud.st.wSecond / 86400.0; 1388 1389 TRACE("Returning %g\n", dateVal); 1390 *pDateOut = dateVal; 1391 return S_OK; 1392 } 1393 1394 /*********************************************************************** 1395 * VarDateFromUdate [OLEAUT32.330] 1396 * 1397 * Convert an unpacked format date and time to a variant VT_DATE. 1398 * 1399 * PARAMS 1400 * pUdateIn [I] Unpacked format date and time to convert 1401 * dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h") 1402 * pDateOut [O] Destination for variant VT_DATE. 1403 * 1404 * RETURNS 1405 * Success: S_OK. *pDateOut contains the converted value. 1406 * Failure: E_INVALIDARG, if pUdateIn cannot be represented in VT_DATE format. 1407 * 1408 * NOTES 1409 * This function uses the United States English locale for the conversion. Use 1410 * VarDateFromUdateEx() for alternate locales. 1411 */ 1412 HRESULT WINAPI VarDateFromUdate(UDATE *pUdateIn, ULONG dwFlags, DATE *pDateOut) 1413 { 1414 LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT); 1415 1416 return VarDateFromUdateEx(pUdateIn, lcid, dwFlags, pDateOut); 1417 } 1418 1419 /*********************************************************************** 1420 * VarUdateFromDate [OLEAUT32.331] 1421 * 1422 * Convert a variant VT_DATE into an unpacked format date and time. 1423 * 1424 * PARAMS 1425 * datein [I] Variant VT_DATE format date 1426 * dwFlags [I] Flags controlling the conversion (VAR_ flags from "oleauto.h") 1427 * lpUdate [O] Destination for unpacked format date and time 1428 * 1429 * RETURNS 1430 * Success: S_OK. *lpUdate contains the converted value. 1431 * Failure: E_INVALIDARG, if dateIn is too large or small. 1432 */ 1433 HRESULT WINAPI VarUdateFromDate(DATE dateIn, ULONG dwFlags, UDATE *lpUdate) 1434 { 1435 /* Cumulative totals of days per month */ 1436 static const USHORT cumulativeDays[] = 1437 { 1438 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 1439 }; 1440 double datePart, timePart; 1441 int julianDays; 1442 1443 TRACE("(%g,0x%08x,%p)\n", dateIn, dwFlags, lpUdate); 1444 1445 if (dateIn <= (DATE_MIN - 1.0) || dateIn >= (DATE_MAX + 1.0)) 1446 return E_INVALIDARG; 1447 1448 datePart = dateIn < 0.0 ? ceil(dateIn) : floor(dateIn); 1449 /* Compensate for int truncation (always downwards) */ 1450 timePart = dateIn - datePart + 0.00000000001; 1451 if (timePart >= 1.0) 1452 timePart -= 0.00000000001; 1453 1454 /* Date */ 1455 julianDays = VARIANT_JulianFromDate(dateIn); 1456 VARIANT_DMYFromJulian(julianDays, &lpUdate->st.wYear, &lpUdate->st.wMonth, 1457 &lpUdate->st.wDay); 1458 1459 datePart = (datePart + 1.5) / 7.0; 1460 lpUdate->st.wDayOfWeek = (datePart - floor(datePart)) * 7; 1461 if (lpUdate->st.wDayOfWeek == 0) 1462 lpUdate->st.wDayOfWeek = 5; 1463 else if (lpUdate->st.wDayOfWeek == 1) 1464 lpUdate->st.wDayOfWeek = 6; 1465 else 1466 lpUdate->st.wDayOfWeek -= 2; 1467 1468 if (lpUdate->st.wMonth > 2 && IsLeapYear(lpUdate->st.wYear)) 1469 lpUdate->wDayOfYear = 1; /* After February, in a leap year */ 1470 else 1471 lpUdate->wDayOfYear = 0; 1472 1473 lpUdate->wDayOfYear += cumulativeDays[lpUdate->st.wMonth]; 1474 lpUdate->wDayOfYear += lpUdate->st.wDay; 1475 1476 /* Time */ 1477 timePart *= 24.0; 1478 lpUdate->st.wHour = timePart; 1479 timePart -= lpUdate->st.wHour; 1480 timePart *= 60.0; 1481 lpUdate->st.wMinute = timePart; 1482 timePart -= lpUdate->st.wMinute; 1483 timePart *= 60.0; 1484 lpUdate->st.wSecond = timePart; 1485 timePart -= lpUdate->st.wSecond; 1486 lpUdate->st.wMilliseconds = 0; 1487 if (timePart > 0.5) 1488 { 1489 /* Round the milliseconds, adjusting the time/date forward if needed */ 1490 if (lpUdate->st.wSecond < 59) 1491 lpUdate->st.wSecond++; 1492 else 1493 { 1494 lpUdate->st.wSecond = 0; 1495 if (lpUdate->st.wMinute < 59) 1496 lpUdate->st.wMinute++; 1497 else 1498 { 1499 lpUdate->st.wMinute = 0; 1500 if (lpUdate->st.wHour < 23) 1501 lpUdate->st.wHour++; 1502 else 1503 { 1504 lpUdate->st.wHour = 0; 1505 /* Roll over a whole day */ 1506 if (++lpUdate->st.wDay > 28) 1507 VARIANT_RollUdate(lpUdate); 1508 } 1509 } 1510 } 1511 } 1512 return S_OK; 1513 } 1514 1515 #define GET_NUMBER_TEXT(fld,name) \ 1516 buff[0] = 0; \ 1517 if (!GetLocaleInfoW(lcid, lctype|fld, buff, 2)) \ 1518 WARN("buffer too small for " #fld "\n"); \ 1519 else \ 1520 if (buff[0]) lpChars->name = buff[0]; \ 1521 TRACE("lcid 0x%x, " #name "=%d '%c'\n", lcid, lpChars->name, lpChars->name) 1522 1523 /* Get the valid number characters for an lcid */ 1524 static void VARIANT_GetLocalisedNumberChars(VARIANT_NUMBER_CHARS *lpChars, LCID lcid, DWORD dwFlags) 1525 { 1526 static const VARIANT_NUMBER_CHARS defaultChars = { '-','+','.',',','$',0,'.',',' }; 1527 static CRITICAL_SECTION csLastChars = { NULL, -1, 0, 0, 0, 0 }; 1528 static VARIANT_NUMBER_CHARS lastChars; 1529 static LCID lastLcid = -1; 1530 static DWORD lastFlags = 0; 1531 LCTYPE lctype = dwFlags & LOCALE_NOUSEROVERRIDE; 1532 WCHAR buff[4]; 1533 1534 /* To make caching thread-safe, a critical section is needed */ 1535 EnterCriticalSection(&csLastChars); 1536 1537 /* Asking for default locale entries is very expensive: It is a registry 1538 server call. So cache one locally, as Microsoft does it too */ 1539 if(lcid == lastLcid && dwFlags == lastFlags) 1540 { 1541 memcpy(lpChars, &lastChars, sizeof(defaultChars)); 1542 LeaveCriticalSection(&csLastChars); 1543 return; 1544 } 1545 1546 memcpy(lpChars, &defaultChars, sizeof(defaultChars)); 1547 GET_NUMBER_TEXT(LOCALE_SNEGATIVESIGN, cNegativeSymbol); 1548 GET_NUMBER_TEXT(LOCALE_SPOSITIVESIGN, cPositiveSymbol); 1549 GET_NUMBER_TEXT(LOCALE_SDECIMAL, cDecimalPoint); 1550 GET_NUMBER_TEXT(LOCALE_STHOUSAND, cDigitSeparator); 1551 GET_NUMBER_TEXT(LOCALE_SMONDECIMALSEP, cCurrencyDecimalPoint); 1552 GET_NUMBER_TEXT(LOCALE_SMONTHOUSANDSEP, cCurrencyDigitSeparator); 1553 1554 /* Local currency symbols are often 2 characters */ 1555 lpChars->cCurrencyLocal2 = '\0'; 1556 switch(GetLocaleInfoW(lcid, lctype|LOCALE_SCURRENCY, buff, sizeof(buff)/sizeof(WCHAR))) 1557 { 1558 case 3: lpChars->cCurrencyLocal2 = buff[1]; /* Fall through */ 1559 case 2: lpChars->cCurrencyLocal = buff[0]; 1560 break; 1561 default: WARN("buffer too small for LOCALE_SCURRENCY\n"); 1562 } 1563 TRACE("lcid 0x%x, cCurrencyLocal =%d,%d '%c','%c'\n", lcid, lpChars->cCurrencyLocal, 1564 lpChars->cCurrencyLocal2, lpChars->cCurrencyLocal, lpChars->cCurrencyLocal2); 1565 1566 memcpy(&lastChars, lpChars, sizeof(defaultChars)); 1567 lastLcid = lcid; 1568 lastFlags = dwFlags; 1569 LeaveCriticalSection(&csLastChars); 1570 } 1571 1572 /* Number Parsing States */ 1573 #define B_PROCESSING_EXPONENT 0x1 1574 #define B_NEGATIVE_EXPONENT 0x2 1575 #define B_EXPONENT_START 0x4 1576 #define B_INEXACT_ZEROS 0x8 1577 #define B_LEADING_ZERO 0x10 1578 #define B_PROCESSING_HEX 0x20 1579 #define B_PROCESSING_OCT 0x40 1580 1581 /********************************************************************** 1582 * VarParseNumFromStr [OLEAUT32.46] 1583 * 1584 * Parse a string containing a number into a NUMPARSE structure. 1585 * 1586 * PARAMS 1587 * lpszStr [I] String to parse number from 1588 * lcid [I] Locale Id for the conversion 1589 * dwFlags [I] 0, or LOCALE_NOUSEROVERRIDE to use system default number chars 1590 * pNumprs [I/O] Destination for parsed number 1591 * rgbDig [O] Destination for digits read in 1592 * 1593 * RETURNS 1594 * Success: S_OK. pNumprs and rgbDig contain the parsed representation of 1595 * the number. 1596 * Failure: E_INVALIDARG, if any parameter is invalid. 1597 * DISP_E_TYPEMISMATCH, if the string is not a number or is formatted 1598 * incorrectly. 1599 * DISP_E_OVERFLOW, if rgbDig is too small to hold the number. 1600 * 1601 * NOTES 1602 * pNumprs must have the following fields set: 1603 * cDig: Set to the size of rgbDig. 1604 * dwInFlags: Set to the allowable syntax of the number using NUMPRS_ flags 1605 * from "oleauto.h". 1606 * 1607 * FIXME 1608 * - I am unsure if this function should parse non-arabic (e.g. Thai) 1609 * numerals, so this has not been implemented. 1610 */ 1611 HRESULT WINAPI VarParseNumFromStr(OLECHAR *lpszStr, LCID lcid, ULONG dwFlags, 1612 NUMPARSE *pNumprs, BYTE *rgbDig) 1613 { 1614 VARIANT_NUMBER_CHARS chars; 1615 BYTE rgbTmp[1024]; 1616 DWORD dwState = B_EXPONENT_START|B_INEXACT_ZEROS; 1617 int iMaxDigits = sizeof(rgbTmp) / sizeof(BYTE); 1618 int cchUsed = 0; 1619 1620 TRACE("(%s,%d,0x%08x,%p,%p)\n", debugstr_w(lpszStr), lcid, dwFlags, pNumprs, rgbDig); 1621 1622 if (!pNumprs || !rgbDig) 1623 return E_INVALIDARG; 1624 1625 if (pNumprs->cDig < iMaxDigits) 1626 iMaxDigits = pNumprs->cDig; 1627 1628 pNumprs->cDig = 0; 1629 pNumprs->dwOutFlags = 0; 1630 pNumprs->cchUsed = 0; 1631 pNumprs->nBaseShift = 0; 1632 pNumprs->nPwr10 = 0; 1633 1634 if (!lpszStr) 1635 return DISP_E_TYPEMISMATCH; 1636 1637 VARIANT_GetLocalisedNumberChars(&chars, lcid, dwFlags); 1638 1639 /* First consume all the leading symbols and space from the string */ 1640 while (1) 1641 { 1642 if (pNumprs->dwInFlags & NUMPRS_LEADING_WHITE && isspaceW(*lpszStr)) 1643 { 1644 pNumprs->dwOutFlags |= NUMPRS_LEADING_WHITE; 1645 do 1646 { 1647 cchUsed++; 1648 lpszStr++; 1649 } while (isspaceW(*lpszStr)); 1650 } 1651 else if (pNumprs->dwInFlags & NUMPRS_LEADING_PLUS && 1652 *lpszStr == chars.cPositiveSymbol && 1653 !(pNumprs->dwOutFlags & NUMPRS_LEADING_PLUS)) 1654 { 1655 pNumprs->dwOutFlags |= NUMPRS_LEADING_PLUS; 1656 cchUsed++; 1657 lpszStr++; 1658 } 1659 else if (pNumprs->dwInFlags & NUMPRS_LEADING_MINUS && 1660 *lpszStr == chars.cNegativeSymbol && 1661 !(pNumprs->dwOutFlags & NUMPRS_LEADING_MINUS)) 1662 { 1663 pNumprs->dwOutFlags |= (NUMPRS_LEADING_MINUS|NUMPRS_NEG); 1664 cchUsed++; 1665 lpszStr++; 1666 } 1667 else if (pNumprs->dwInFlags & NUMPRS_CURRENCY && 1668 !(pNumprs->dwOutFlags & NUMPRS_CURRENCY) && 1669 *lpszStr == chars.cCurrencyLocal && 1670 (!chars.cCurrencyLocal2 || lpszStr[1] == chars.cCurrencyLocal2)) 1671 { 1672 pNumprs->dwOutFlags |= NUMPRS_CURRENCY; 1673 cchUsed++; 1674 lpszStr++; 1675 /* Only accept currency characters */ 1676 chars.cDecimalPoint = chars.cCurrencyDecimalPoint; 1677 chars.cDigitSeparator = chars.cCurrencyDigitSeparator; 1678 } 1679 else if (pNumprs->dwInFlags & NUMPRS_PARENS && *lpszStr == '(' && 1680 !(pNumprs->dwOutFlags & NUMPRS_PARENS)) 1681 { 1682 pNumprs->dwOutFlags |= NUMPRS_PARENS; 1683 cchUsed++; 1684 lpszStr++; 1685 } 1686 else 1687 break; 1688 } 1689 1690 if (!(pNumprs->dwOutFlags & NUMPRS_CURRENCY)) 1691 { 1692 /* Only accept non-currency characters */ 1693 chars.cCurrencyDecimalPoint = chars.cDecimalPoint; 1694 chars.cCurrencyDigitSeparator = chars.cDigitSeparator; 1695 } 1696 1697 if ((*lpszStr == '&' && (*(lpszStr+1) == 'H' || *(lpszStr+1) == 'h')) && 1698 pNumprs->dwInFlags & NUMPRS_HEX_OCT) 1699 { 1700 dwState |= B_PROCESSING_HEX; 1701 pNumprs->dwOutFlags |= NUMPRS_HEX_OCT; 1702 cchUsed=cchUsed+2; 1703 lpszStr=lpszStr+2; 1704 } 1705 else if ((*lpszStr == '&' && (*(lpszStr+1) == 'O' || *(lpszStr+1) == 'o')) && 1706 pNumprs->dwInFlags & NUMPRS_HEX_OCT) 1707 { 1708 dwState |= B_PROCESSING_OCT; 1709 pNumprs->dwOutFlags |= NUMPRS_HEX_OCT; 1710 cchUsed=cchUsed+2; 1711 lpszStr=lpszStr+2; 1712 } 1713 1714 /* Strip Leading zeros */ 1715 while (*lpszStr == '') 1716 { 1717 dwState |= B_LEADING_ZERO; 1718 cchUsed++; 1719 lpszStr++; 1720 } 1721 1722 while (*lpszStr) 1723 { 1724 if (isdigitW(*lpszStr)) 1725 { 1726 if (dwState & B_PROCESSING_EXPONENT) 1727 { 1728 int exponentSize = 0; 1729 if (dwState & B_EXPONENT_START) 1730 { 1731 if (!isdigitW(*lpszStr)) 1732 break; /* No exponent digits - invalid */ 1733 while (*lpszStr == '') 1734 { 1735 /* Skip leading zero's in the exponent */ 1736 cchUsed++; 1737 lpszStr++; 1738 } 1739 } 1740 1741 while (isdigitW(*lpszStr)) 1742 { 1743 exponentSize *= 10; 1744 exponentSize += *lpszStr - ''; 1745 cchUsed++; 1746 lpszStr++; 1747 } 1748 if (dwState & B_NEGATIVE_EXPONENT) 1749 exponentSize = -exponentSize; 1750 /* Add the exponent into the powers of 10 */ 1751 pNumprs->nPwr10 += exponentSize; 1752 dwState &= ~(B_PROCESSING_EXPONENT|B_EXPONENT_START); 1753 lpszStr--; /* back up to allow processing of next char */ 1754 } 1755 else 1756 { 1757 if ((pNumprs->cDig >= iMaxDigits) && !(dwState & B_PROCESSING_HEX) 1758 && !(dwState & B_PROCESSING_OCT)) 1759 { 1760 pNumprs->dwOutFlags |= NUMPRS_INEXACT; 1761 1762 if (*lpszStr != '') 1763 dwState &= ~B_INEXACT_ZEROS; /* Inexact number with non-trailing zeros */ 1764 1765 /* This digit can't be represented, but count it in nPwr10 */ 1766 if (pNumprs->dwOutFlags & NUMPRS_DECIMAL) 1767 pNumprs->nPwr10--; 1768 else 1769 pNumprs->nPwr10++; 1770 } 1771 else 1772 { 1773 if ((dwState & B_PROCESSING_OCT) && ((*lpszStr == '8') || (*lpszStr == '9'))) { 1774 return DISP_E_TYPEMISMATCH; 1775 } 1776 1777 if (pNumprs->dwOutFlags & NUMPRS_DECIMAL) 1778 pNumprs->nPwr10--; /* Count decimal points in nPwr10 */ 1779 1780 rgbTmp[pNumprs->cDig] = *lpszStr - ''; 1781 } 1782 pNumprs->cDig++; 1783 cchUsed++; 1784 } 1785 } 1786 else if (*lpszStr == chars.cDigitSeparator && pNumprs->dwInFlags & NUMPRS_THOUSANDS) 1787 { 1788 pNumprs->dwOutFlags |= NUMPRS_THOUSANDS; 1789 cchUsed++; 1790 } 1791 else if (*lpszStr == chars.cDecimalPoint && 1792 pNumprs->dwInFlags & NUMPRS_DECIMAL && 1793 !(pNumprs->dwOutFlags & (NUMPRS_DECIMAL|NUMPRS_EXPONENT))) 1794 { 1795 pNumprs->dwOutFlags |= NUMPRS_DECIMAL; 1796 cchUsed++; 1797 1798 /* If we have no digits so far, skip leading zeros */ 1799 if (!pNumprs->cDig) 1800 { 1801 while (lpszStr[1] == '') 1802 { 1803 dwState |= B_LEADING_ZERO; 1804 cchUsed++; 1805 lpszStr++; 1806 pNumprs->nPwr10--; 1807 } 1808 } 1809 } 1810 else if (((*lpszStr >= 'a' && *lpszStr <= 'f') || 1811 (*lpszStr >= 'A' && *lpszStr <= 'F')) && 1812 dwState & B_PROCESSING_HEX) 1813 { 1814 if (pNumprs->cDig >= iMaxDigits) 1815 { 1816 return DISP_E_OVERFLOW; 1817 } 1818 else 1819 { 1820 if (*lpszStr >= 'a') 1821 rgbTmp[pNumprs->cDig] = *lpszStr - 'a' + 10; 1822 else 1823 rgbTmp[pNumprs->cDig] = *lpszStr - 'A' + 10; 1824 } 1825 pNumprs->cDig++; 1826 cchUsed++; 1827 } 1828 else if ((*lpszStr == 'e' || *lpszStr == 'E') && 1829 pNumprs->dwInFlags & NUMPRS_EXPONENT && 1830 !(pNumprs->dwOutFlags & NUMPRS_EXPONENT)) 1831 { 1832 dwState |= B_PROCESSING_EXPONENT; 1833 pNumprs->dwOutFlags |= NUMPRS_EXPONENT; 1834 cchUsed++; 1835 } 1836 else if (dwState & B_PROCESSING_EXPONENT && *lpszStr == chars.cPositiveSymbol) 1837 { 1838 cchUsed++; /* Ignore positive exponent */ 1839 } 1840 else if (dwState & B_PROCESSING_EXPONENT && *lpszStr == chars.cNegativeSymbol) 1841 { 1842 dwState |= B_NEGATIVE_EXPONENT; 1843 cchUsed++; 1844 } 1845 else 1846 break; /* Stop at an unrecognised character */ 1847 1848 lpszStr++; 1849 } 1850 1851 if (!pNumprs->cDig && dwState & B_LEADING_ZERO) 1852 { 1853 /* Ensure a 0 on its own gets stored */ 1854 pNumprs->cDig = 1; 1855 rgbTmp[0] = 0; 1856 } 1857 1858 if (pNumprs->dwOutFlags & NUMPRS_EXPONENT && dwState & B_PROCESSING_EXPONENT) 1859 { 1860 pNumprs->cchUsed = cchUsed; 1861 WARN("didn't completely parse exponent\n"); 1862 return DISP_E_TYPEMISMATCH; /* Failed to completely parse the exponent */ 1863 } 1864 1865 if (pNumprs->dwOutFlags & NUMPRS_INEXACT) 1866 { 1867 if (dwState & B_INEXACT_ZEROS) 1868 pNumprs->dwOutFlags &= ~NUMPRS_INEXACT; /* All zeros doesn't set NUMPRS_INEXACT */ 1869 } else if(pNumprs->dwInFlags & NUMPRS_HEX_OCT) 1870 { 1871 /* copy all of the digits into the output digit buffer */ 1872 /* this is exactly what windows does although it also returns */ 1873 /* cDig of X and writes X+Y where Y>=0 number of digits to rgbDig */ 1874 memcpy(rgbDig, rgbTmp, pNumprs->cDig * sizeof(BYTE)); 1875 1876 if (dwState & B_PROCESSING_HEX) { 1877 /* hex numbers have always the same format */ 1878 pNumprs->nPwr10=0; 1879 pNumprs->nBaseShift=4; 1880 } else { 1881 if (dwState & B_PROCESSING_OCT) { 1882 /* oct numbers have always the same format */ 1883 pNumprs->nPwr10=0; 1884 pNumprs->nBaseShift=3; 1885 } else { 1886 while (pNumprs->cDig > 1 && !rgbTmp[pNumprs->cDig - 1]) 1887 { 1888 pNumprs->nPwr10++; 1889 pNumprs->cDig--; 1890 } 1891 } 1892 } 1893 } else 1894 { 1895 /* Remove trailing zeros from the last (whole number or decimal) part */ 1896 while (pNumprs->cDig > 1 && !rgbTmp[pNumprs->cDig - 1]) 1897 { 1898 pNumprs->nPwr10++; 1899 pNumprs->cDig--; 1900 } 1901 } 1902 1903 if (pNumprs->cDig <= iMaxDigits) 1904 pNumprs->dwOutFlags &= ~NUMPRS_INEXACT; /* Ignore stripped zeros for NUMPRS_INEXACT */ 1905 else 1906 pNumprs->cDig = iMaxDigits; /* Only return iMaxDigits worth of digits */ 1907 1908 /* Copy the digits we processed into rgbDig */ 1909 memcpy(rgbDig, rgbTmp, pNumprs->cDig * sizeof(BYTE)); 1910 1911 /* Consume any trailing symbols and space */ 1912 while (1) 1913 { 1914 if ((pNumprs->dwInFlags & NUMPRS_TRAILING_WHITE) && isspaceW(*lpszStr)) 1915 { 1916 pNumprs->dwOutFlags |= NUMPRS_TRAILING_WHITE; 1917 do 1918 { 1919 cchUsed++; 1920 lpszStr++; 1921 } while (isspaceW(*lpszStr)); 1922 } 1923 else if (pNumprs->dwInFlags & NUMPRS_TRAILING_PLUS && 1924 !(pNumprs->dwOutFlags & NUMPRS_LEADING_PLUS) && 1925 *lpszStr == chars.cPositiveSymbol) 1926 { 1927 pNumprs->dwOutFlags |= NUMPRS_TRAILING_PLUS; 1928 cchUsed++; 1929 lpszStr++; 1930 } 1931 else if (pNumprs->dwInFlags & NUMPRS_TRAILING_MINUS && 1932 !(pNumprs->dwOutFlags & NUMPRS_LEADING_MINUS) && 1933 *lpszStr == chars.cNegativeSymbol) 1934 { 1935 pNumprs->dwOutFlags |= (NUMPRS_TRAILING_MINUS|NUMPRS_NEG); 1936 cchUsed++; 1937 lpszStr++; 1938 } 1939 else if (pNumprs->dwInFlags & NUMPRS_PARENS && *lpszStr == ')' && 1940 pNumprs->dwOutFlags & NUMPRS_PARENS) 1941 { 1942 cchUsed++; 1943 lpszStr++; 1944 pNumprs->dwOutFlags |= NUMPRS_NEG; 1945 } 1946 else 1947 break; 1948 } 1949 1950 if (pNumprs->dwOutFlags & NUMPRS_PARENS && !(pNumprs->dwOutFlags & NUMPRS_NEG)) 1951 { 1952 pNumprs->cchUsed = cchUsed; 1953 return DISP_E_TYPEMISMATCH; /* Opening parenthesis not matched */ 1954 } 1955 1956 if (pNumprs->dwInFlags & NUMPRS_USE_ALL && *lpszStr != '\0') 1957 return DISP_E_TYPEMISMATCH; /* Not all chars were consumed */ 1958 1959 if (!pNumprs->cDig) 1960 return DISP_E_TYPEMISMATCH; /* No Number found */ 1961 1962 pNumprs->cchUsed = cchUsed; 1963 return S_OK; 1964 } 1965 1966 /* VTBIT flags indicating an integer value */ 1967 #define INTEGER_VTBITS (VTBIT_I1|VTBIT_UI1|VTBIT_I2|VTBIT_UI2|VTBIT_I4|VTBIT_UI4|VTBIT_I8|VTBIT_UI8) 1968 /* VTBIT flags indicating a real number value */ 1969 #define REAL_VTBITS (VTBIT_R4|VTBIT_R8|VTBIT_CY) 1970 1971 /* Helper macros to check whether bit pattern fits in VARIANT (x is a ULONG64 ) */ 1972 #define FITS_AS_I1(x) ((x) >> 8 == 0) 1973 #define FITS_AS_I2(x) ((x) >> 16 == 0) 1974 #define FITS_AS_I4(x) ((x) >> 32 == 0) 1975 1976 /********************************************************************** 1977 * VarNumFromParseNum [OLEAUT32.47] 1978 * 1979 * Convert a NUMPARSE structure into a numeric Variant type. 1980 * 1981 * PARAMS 1982 * pNumprs [I] Source for parsed number. cDig must be set to the size of rgbDig 1983 * rgbDig [I] Source for the numbers digits 1984 * dwVtBits [I] VTBIT_ flags from "oleauto.h" indicating the acceptable dest types 1985 * pVarDst [O] Destination for the converted Variant value. 1986 * 1987 * RETURNS 1988 * Success: S_OK. pVarDst contains the converted value. 1989 * Failure: E_INVALIDARG, if any parameter is invalid. 1990 * DISP_E_OVERFLOW, if the number is too big for the types set in dwVtBits. 1991 * 1992 * NOTES 1993 * - The smallest favoured type present in dwVtBits that can represent the 1994 * number in pNumprs without losing precision is used. 1995 * - Signed types are preferred over unsigned types of the same size. 1996 * - Preferred types in order are: integer, float, double, currency then decimal. 1997 * - Rounding (dropping of decimal points) occurs without error. See VarI8FromR8() 1998 * for details of the rounding method. 1999 * - pVarDst is not cleared before the result is stored in it. 2000 * - WinXP and Win2003 support VTBIT_I8, VTBIT_UI8 but that's buggy (by 2001 * design?): If some other VTBIT's for integers are specified together 2002 * with VTBIT_I8 and the number will fit only in a VT_I8 Windows will "cast" 2003 * the number to the smallest requested integer truncating this way the 2004 * number. Wine doesn't implement this "feature" (yet?). 2005 */ 2006 HRESULT WINAPI VarNumFromParseNum(NUMPARSE *pNumprs, BYTE *rgbDig, 2007 ULONG dwVtBits, VARIANT *pVarDst) 2008 { 2009 /* Scale factors and limits for double arithmetic */ 2010 static const double dblMultipliers[11] = { 2011 1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 2012 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000.0 2013 }; 2014 static const double dblMinimums[11] = { 2015 R8_MIN, R8_MIN*10.0, R8_MIN*100.0, R8_MIN*1000.0, R8_MIN*10000.0, 2016 R8_MIN*100000.0, R8_MIN*1000000.0, R8_MIN*10000000.0, 2017 R8_MIN*100000000.0, R8_MIN*1000000000.0, R8_MIN*10000000000.0 2018 }; 2019 static const double dblMaximums[11] = { 2020 R8_MAX, R8_MAX/10.0, R8_MAX/100.0, R8_MAX/1000.0, R8_MAX/10000.0, 2021 R8_MAX/100000.0, R8_MAX/1000000.0, R8_MAX/10000000.0, 2022 R8_MAX/100000000.0, R8_MAX/1000000000.0, R8_MAX/10000000000.0 2023 }; 2024 2025 int wholeNumberDigits, fractionalDigits, divisor10 = 0, multiplier10 = 0; 2026 2027 TRACE("(%p,%p,0x%x,%p)\n", pNumprs, rgbDig, dwVtBits, pVarDst); 2028 2029 if (pNumprs->nBaseShift) 2030 { 2031 /* nBaseShift indicates a hex or octal number */ 2032 ULONG64 ul64 = 0; 2033 LONG64 l64; 2034 int i; 2035 2036 /* Convert the hex or octal number string into a UI64 */ 2037 for (i = 0; i < pNumprs->cDig; i++) 2038 { 2039 if (ul64 > ((UI8_MAX>>pNumprs->nBaseShift) - rgbDig[i])) 2040 { 2041 TRACE("Overflow multiplying digits\n"); 2042 return DISP_E_OVERFLOW; 2043 } 2044 ul64 = (ul64<<pNumprs->nBaseShift) + rgbDig[i]; 2045 } 2046 2047 /* also make a negative representation */ 2048 l64=-ul64; 2049 2050 /* Try signed and unsigned types in size order */ 2051 if (dwVtBits & VTBIT_I1 && FITS_AS_I1(ul64)) 2052 { 2053 V_VT(pVarDst) = VT_I1; 2054 V_I1(pVarDst) = ul64; 2055 return S_OK; 2056 } 2057 else if (dwVtBits & VTBIT_UI1 && FITS_AS_I1(ul64)) 2058 { 2059 V_VT(pVarDst) = VT_UI1; 2060 V_UI1(pVarDst) = ul64; 2061 return S_OK; 2062 } 2063 else if (dwVtBits & VTBIT_I2 && FITS_AS_I2(ul64)) 2064 { 2065 V_VT(pVarDst) = VT_I2; 2066 V_I2(pVarDst) = ul64; 2067 return S_OK; 2068 } 2069 else if (dwVtBits & VTBIT_UI2 && FITS_AS_I2(ul64)) 2070 { 2071 V_VT(pVarDst) = VT_UI2; 2072 V_UI2(pVarDst) = ul64; 2073 return S_OK; 2074 } 2075 else if (dwVtBits & VTBIT_I4 && FITS_AS_I4(ul64)) 2076 { 2077 V_VT(pVarDst) = VT_I4; 2078 V_I4(pVarDst) = ul64; 2079 return S_OK; 2080 } 2081 else if (dwVtBits & VTBIT_UI4 && FITS_AS_I4(ul64)) 2082 { 2083 V_VT(pVarDst) = VT_UI4; 2084 V_UI4(pVarDst) = ul64; 2085 return S_OK; 2086 } 2087 else if (dwVtBits & VTBIT_I8 && ((ul64 <= I8_MAX)||(l64>=I8_MIN))) 2088 { 2089 V_VT(pVarDst) = VT_I8; 2090 V_I8(pVarDst) = ul64; 2091 return S_OK; 2092 } 2093 else if (dwVtBits & VTBIT_UI8) 2094 { 2095 V_VT(pVarDst) = VT_UI8; 2096 V_UI8(pVarDst) = ul64; 2097 return S_OK; 2098 } 2099 else if ((dwVtBits & VTBIT_DECIMAL) == VTBIT_DECIMAL) 2100 { 2101 V_VT(pVarDst) = VT_DECIMAL; 2102 DEC_SIGNSCALE(&V_DECIMAL(pVarDst)) = SIGNSCALE(DECIMAL_POS,0); 2103 DEC_HI32(&V_DECIMAL(pVarDst)) = 0; 2104 DEC_LO64(&V_DECIMAL(pVarDst)) = ul64; 2105 return S_OK; 2106 } 2107 else if (dwVtBits & VTBIT_R4 && ((ul64 <= I4_MAX)||(l64 >= I4_MIN))) 2108 { 2109 V_VT(pVarDst) = VT_R4; 2110 if (ul64 <= I4_MAX) 2111 V_R4(pVarDst) = ul64; 2112 else 2113 V_R4(pVarDst) = l64; 2114 return S_OK; 2115 } 2116 else if (dwVtBits & VTBIT_R8 && ((ul64 <= I4_MAX)||(l64 >= I4_MIN))) 2117 { 2118 V_VT(pVarDst) = VT_R8; 2119 if (ul64 <= I4_MAX) 2120 V_R8(pVarDst) = ul64; 2121 else 2122 V_R8(pVarDst) = l64; 2123 return S_OK; 2124 } 2125 2126 TRACE("Overflow: possible return types: 0x%x, value: %s\n", dwVtBits, wine_dbgstr_longlong(ul64)); 2127 return DISP_E_OVERFLOW; 2128 } 2129 2130 /* Count the number of relevant fractional and whole digits stored, 2131 * And compute the divisor/multiplier to scale the number by. 2132 */ 2133 if (pNumprs->nPwr10 < 0) 2134 { 2135 if (-pNumprs->nPwr10 >= pNumprs->cDig) 2136 { 2137 /* A real number < +/- 1.0 e.g. 0.1024 or 0.01024 */ 2138 wholeNumberDigits = 0; 2139 fractionalDigits = pNumprs->cDig; 2140 divisor10 = -pNumprs->nPwr10; 2141 } 2142 else 2143 { 2144 /* An exactly represented real number e.g. 1.024 */ 2145 wholeNumberDigits = pNumprs->cDig + pNumprs->nPwr10; 2146 fractionalDigits = pNumprs->cDig - wholeNumberDigits; 2147 divisor10 = pNumprs->cDig - wholeNumberDigits; 2148 } 2149 } 2150 else if (pNumprs->nPwr10 == 0) 2151 { 2152 /* An exactly represented whole number e.g. 1024 */ 2153 wholeNumberDigits = pNumprs->cDig; 2154 fractionalDigits = 0; 2155 } 2156 else /* pNumprs->nPwr10 > 0 */ 2157 { 2158 /* A whole number followed by nPwr10 0's e.g. 102400 */ 2159 wholeNumberDigits = pNumprs->cDig; 2160 fractionalDigits = 0; 2161 multiplier10 = pNumprs->nPwr10; 2162 } 2163 2164 TRACE("cDig %d; nPwr10 %d, whole %d, frac %d mult %d; div %d\n", 2165 pNumprs->cDig, pNumprs->nPwr10, wholeNumberDigits, fractionalDigits, 2166 multiplier10, divisor10); 2167 2168 if (dwVtBits & (INTEGER_VTBITS|VTBIT_DECIMAL) && 2169 (!fractionalDigits || !(dwVtBits & (REAL_VTBITS|VTBIT_CY|VTBIT_DECIMAL)))) 2170 { 2171 /* We have one or more integer output choices, and either: 2172 * 1) An integer input value, or 2173 * 2) A real number input value but no floating output choices. 2174 * Alternately, we have a DECIMAL output available and an integer input. 2175 * 2176 * So, place the integer value into pVarDst, using the smallest type 2177 * possible and preferring signed over unsigned types. 2178 */ 2179 BOOL bOverflow = FALSE, bNegative; 2180 ULONG64 ul64 = 0; 2181 int i; 2182 2183 /* Convert the integer part of the number into a UI8 */ 2184 for (i = 0; i < wholeNumberDigits; i++) 2185 { 2186 if (ul64 > (UI8_MAX / 10 - rgbDig[i])) 2187 { 2188 TRACE("Overflow multiplying digits\n"); 2189 bOverflow = TRUE; 2190 break; 2191 } 2192 ul64 = ul64 * 10 + rgbDig[i]; 2193 } 2194 2195 /* Account for the scale of the number */ 2196 if (!bOverflow && multiplier10) 2197 { 2198 for (i = 0; i < multiplier10; i++) 2199 { 2200 if (ul64 > (UI8_MAX / 10)) 2201 { 2202 TRACE("Overflow scaling number\n"); 2203 bOverflow = TRUE; 2204 break; 2205 } 2206 ul64 = ul64 * 10; 2207 } 2208 } 2209 2210 /* If we have any fractional digits, round the value. 2211 * Note we don't have to do this if divisor10 is < 1, 2212 * because this means the fractional part must be < 0.5 2213 */ 2214 if (!bOverflow && fractionalDigits && divisor10 > 0) 2215 { 2216 const BYTE* fracDig = rgbDig + wholeNumberDigits; 2217 BOOL bAdjust = FALSE; 2218 2219 TRACE("first decimal value is %d\n", *fracDig); 2220 2221 if (*fracDig > 5) 2222 bAdjust = TRUE; /* > 0.5 */ 2223 else if (*fracDig == 5) 2224 { 2225 for (i = 1; i < fractionalDigits; i++) 2226 { 2227 if (fracDig[i]) 2228 { 2229 bAdjust = TRUE; /* > 0.5 */ 2230 break; 2231 } 2232 } 2233 /* If exactly 0.5, round only odd values */ 2234 if (i == fractionalDigits && (ul64 & 1)) 2235 bAdjust = TRUE; 2236 } 2237 2238 if (bAdjust) 2239 { 2240 if (ul64 == UI8_MAX) 2241 { 2242 TRACE("Overflow after rounding\n"); 2243 bOverflow = TRUE; 2244 } 2245 ul64++; 2246 } 2247 } 2248 2249 /* Zero is not a negative number */ 2250 bNegative = pNumprs->dwOutFlags & NUMPRS_NEG && ul64 ? TRUE : FALSE; 2251 2252 TRACE("Integer value is 0x%s, bNeg %d\n", wine_dbgstr_longlong(ul64), bNegative); 2253 2254 /* For negative integers, try the signed types in size order */ 2255 if (!bOverflow && bNegative) 2256 { 2257 if (dwVtBits & (VTBIT_I1|VTBIT_I2|VTBIT_I4|VTBIT_I8)) 2258 { 2259 if (dwVtBits & VTBIT_I1 && ul64 <= -I1_MIN) 2260 { 2261 V_VT(pVarDst) = VT_I1; 2262 V_I1(pVarDst) = -ul64; 2263 return S_OK; 2264 } 2265 else if (dwVtBits & VTBIT_I2 && ul64 <= -I2_MIN) 2266 { 2267 V_VT(pVarDst) = VT_I2; 2268 V_I2(pVarDst) = -ul64; 2269 return S_OK; 2270 } 2271 else if (dwVtBits & VTBIT_I4 && ul64 <= -((LONGLONG)I4_MIN)) 2272 { 2273 V_VT(pVarDst) = VT_I4; 2274 V_I4(pVarDst) = -ul64; 2275 return S_OK; 2276 } 2277 else if (dwVtBits & VTBIT_I8 && ul64 <= (ULONGLONG)I8_MAX + 1) 2278 { 2279 V_VT(pVarDst) = VT_I8; 2280 V_I8(pVarDst) = -ul64; 2281 return S_OK; 2282 } 2283 else if ((dwVtBits & REAL_VTBITS) == VTBIT_DECIMAL) 2284 { 2285 /* Decimal is only output choice left - fast path */ 2286 V_VT(pVarDst) = VT_DECIMAL; 2287 DEC_SIGNSCALE(&V_DECIMAL(pVarDst)) = SIGNSCALE(DECIMAL_NEG,0); 2288 DEC_HI32(&V_DECIMAL(pVarDst)) = 0; 2289 DEC_LO64(&V_DECIMAL(pVarDst)) = -ul64; 2290 return S_OK; 2291 } 2292 } 2293 } 2294 else if (!bOverflow) 2295 { 2296 /* For positive integers, try signed then unsigned types in size order */ 2297 if (dwVtBits & VTBIT_I1 && ul64 <= I1_MAX) 2298 { 2299 V_VT(pVarDst) = VT_I1; 2300 V_I1(pVarDst) = ul64; 2301 return S_OK; 2302 } 2303 else if (dwVtBits & VTBIT_UI1 && ul64 <= UI1_MAX) 2304 { 2305 V_VT(pVarDst) = VT_UI1; 2306 V_UI1(pVarDst) = ul64; 2307 return S_OK; 2308 } 2309 else if (dwVtBits & VTBIT_I2 && ul64 <= I2_MAX) 2310 { 2311 V_VT(pVarDst) = VT_I2; 2312 V_I2(pVarDst) = ul64; 2313 return S_OK; 2314 } 2315 else if (dwVtBits & VTBIT_UI2 && ul64 <= UI2_MAX) 2316 { 2317 V_VT(pVarDst) = VT_UI2; 2318 V_UI2(pVarDst) = ul64; 2319 return S_OK; 2320 } 2321 else if (dwVtBits & VTBIT_I4 && ul64 <= I4_MAX) 2322 { 2323 V_VT(pVarDst) = VT_I4; 2324 V_I4(pVarDst) = ul64; 2325 return S_OK; 2326 } 2327 else if (dwVtBits & VTBIT_UI4 && ul64 <= UI4_MAX) 2328 { 2329 V_VT(pVarDst) = VT_UI4; 2330 V_UI4(pVarDst) = ul64; 2331 return S_OK; 2332 } 2333 else if (dwVtBits & VTBIT_I8 && ul64 <= I8_MAX) 2334 { 2335 V_VT(pVarDst) = VT_I8; 2336 V_I8(pVarDst) = ul64; 2337 return S_OK; 2338 } 2339 else if (dwVtBits & VTBIT_UI8) 2340 { 2341 V_VT(pVarDst) = VT_UI8; 2342 V_UI8(pVarDst) = ul64; 2343 return S_OK; 2344 } 2345 else if ((dwVtBits & REAL_VTBITS) == VTBIT_DECIMAL) 2346 { 2347 /* Decimal is only output choice left - fast path */ 2348 V_VT(pVarDst) = VT_DECIMAL; 2349 DEC_SIGNSCALE(&V_DECIMAL(pVarDst)) = SIGNSCALE(DECIMAL_POS,0); 2350 DEC_HI32(&V_DECIMAL(pVarDst)) = 0; 2351 DEC_LO64(&V_DECIMAL(pVarDst)) = ul64; 2352 return S_OK; 2353 } 2354 } 2355 } 2356 2357 if (dwVtBits & REAL_VTBITS) 2358 { 2359 /* Try to put the number into a float or real */ 2360 BOOL bOverflow = FALSE, bNegative = pNumprs->dwOutFlags & NUMPRS_NEG; 2361 double whole = 0.0; 2362 int i; 2363 2364 /* Convert the number into a double */ 2365 for (i = 0; i < pNumprs->cDig; i++) 2366 whole = whole * 10.0 + rgbDig[i]; 2367 2368 TRACE("Whole double value is %16.16g\n", whole); 2369 2370 /* Account for the scale */ 2371 while (multiplier10 > 10) 2372 { 2373 if (whole > dblMaximums[10]) 2374 { 2375 dwVtBits &= ~(VTBIT_R4|VTBIT_R8|VTBIT_CY); 2376 bOverflow = TRUE; 2377 break; 2378 } 2379 whole = whole * dblMultipliers[10]; 2380 multiplier10 -= 10; 2381 } 2382 if (multiplier10 && !bOverflow) 2383 { 2384 if (whole > dblMaximums[multiplier10]) 2385 { 2386 dwVtBits &= ~(VTBIT_R4|VTBIT_R8|VTBIT_CY); 2387 bOverflow = TRUE; 2388 } 2389 else 2390 whole = whole * dblMultipliers[multiplier10]; 2391 } 2392 2393 if (!bOverflow) 2394 TRACE("Scaled double value is %16.16g\n", whole); 2395 2396 while (divisor10 > 10 && !bOverflow) 2397 { 2398 if (whole < dblMinimums[10] && whole != 0) 2399 { 2400 dwVtBits &= ~(VTBIT_R4|VTBIT_R8|VTBIT_CY); /* Underflow */ 2401 bOverflow = TRUE; 2402 break; 2403 } 2404 whole = whole / dblMultipliers[10]; 2405 divisor10 -= 10; 2406 } 2407 if (divisor10 && !bOverflow) 2408 { 2409 if (whole < dblMinimums[divisor10] && whole != 0) 2410 { 2411 dwVtBits &= ~(VTBIT_R4|VTBIT_R8|VTBIT_CY); /* Underflow */ 2412 bOverflow = TRUE; 2413 } 2414 else 2415 whole = whole / dblMultipliers[divisor10]; 2416 } 2417 if (!bOverflow) 2418 TRACE("Final double value is %16.16g\n", whole); 2419 2420 if (dwVtBits & VTBIT_R4 && 2421 ((whole <= R4_MAX && whole >= R4_MIN) || whole == 0.0)) 2422 { 2423 TRACE("Set R4 to final value\n"); 2424 V_VT(pVarDst) = VT_R4; /* Fits into a float */ 2425 V_R4(pVarDst) = pNumprs->dwOutFlags & NUMPRS_NEG ? -whole : whole; 2426 return S_OK; 2427 } 2428 2429 if (dwVtBits & VTBIT_R8) 2430 { 2431 TRACE("Set R8 to final value\n"); 2432 V_VT(pVarDst) = VT_R8; /* Fits into a double */ 2433 V_R8(pVarDst) = pNumprs->dwOutFlags & NUMPRS_NEG ? -whole : whole; 2434 return S_OK; 2435 } 2436 2437 if (dwVtBits & VTBIT_CY) 2438 { 2439 if (SUCCEEDED(VarCyFromR8(bNegative ? -whole : whole, &V_CY(pVarDst)))) 2440 { 2441 V_VT(pVarDst) = VT_CY; /* Fits into a currency */ 2442 TRACE("Set CY to final value\n"); 2443 return S_OK; 2444 } 2445 TRACE("Value Overflows CY\n"); 2446 } 2447 } 2448 2449 if (dwVtBits & VTBIT_DECIMAL) 2450 { 2451 int i; 2452 ULONG carry; 2453 ULONG64 tmp; 2454 DECIMAL* pDec = &V_DECIMAL(pVarDst); 2455 2456 DECIMAL_SETZERO(*pDec); 2457 DEC_LO32(pDec) = 0; 2458 2459 if (pNumprs->dwOutFlags & NUMPRS_NEG) 2460 DEC_SIGN(pDec) = DECIMAL_NEG; 2461 else 2462 DEC_SIGN(pDec) = DECIMAL_POS; 2463 2464 /* Factor the significant digits */ 2465 for (i = 0; i < pNumprs->cDig; i++) 2466 { 2467 tmp = (ULONG64)DEC_LO32(pDec) * 10 + rgbDig[i]; 2468 carry = (ULONG)(tmp >> 32); 2469 DEC_LO32(pDec) = (ULONG)(tmp & UI4_MAX); 2470 tmp = (ULONG64)DEC_MID32(pDec) * 10 + carry; 2471 carry = (ULONG)(tmp >> 32); 2472 DEC_MID32(pDec) = (ULONG)(tmp & UI4_MAX); 2473 tmp = (ULONG64)DEC_HI32(pDec) * 10 + carry; 2474 DEC_HI32(pDec) = (ULONG)(tmp & UI4_MAX); 2475 2476 if (tmp >> 32 & UI4_MAX) 2477 { 2478 VarNumFromParseNum_DecOverflow: 2479 TRACE("Overflow\n"); 2480 DEC_LO32(pDec) = DEC_MID32(pDec) = DEC_HI32(pDec) = UI4_MAX; 2481 return DISP_E_OVERFLOW; 2482 } 2483 } 2484 2485 /* Account for the scale of the number */ 2486 while (multiplier10 > 0) 2487 { 2488 tmp = (ULONG64)DEC_LO32(pDec) * 10; 2489 carry = (ULONG)(tmp >> 32); 2490 DEC_LO32(pDec) = (ULONG)(tmp & UI4_MAX); 2491 tmp = (ULONG64)DEC_MID32(pDec) * 10 + carry; 2492 carry = (ULONG)(tmp >> 32); 2493 DEC_MID32(pDec) = (ULONG)(tmp & UI4_MAX); 2494 tmp = (ULONG64)DEC_HI32(pDec) * 10 + carry; 2495 DEC_HI32(pDec) = (ULONG)(tmp & UI4_MAX); 2496 2497 if (tmp >> 32 & UI4_MAX) 2498 goto VarNumFromParseNum_DecOverflow; 2499 multiplier10--; 2500 } 2501 DEC_SCALE(pDec) = divisor10; 2502 2503 V_VT(pVarDst) = VT_DECIMAL; 2504 return S_OK; 2505 } 2506 return DISP_E_OVERFLOW; /* No more output choices */ 2507 } 2508 2509 /********************************************************************** 2510 * VarCat [OLEAUT32.318] 2511 * 2512 * Concatenates one variant onto another. 2513 * 2514 * PARAMS 2515 * left [I] First variant 2516 * right [I] Second variant 2517 * result [O] Result variant 2518 * 2519 * RETURNS 2520 * Success: S_OK. 2521 * Failure: An HRESULT error code indicating the error. 2522 */ 2523 HRESULT WINAPI VarCat(LPVARIANT left, LPVARIANT right, LPVARIANT out) 2524 { 2525 VARTYPE leftvt,rightvt,resultvt; 2526 HRESULT hres; 2527 static WCHAR str_true[32]; 2528 static WCHAR str_false[32]; 2529 static const WCHAR sz_empty[] = {'\0'}; 2530 leftvt = V_VT(left); 2531 rightvt = V_VT(right); 2532 2533 TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left), 2534 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), out); 2535 2536 if (!str_true[0]) { 2537 VARIANT_GetLocalisedText(LOCALE_USER_DEFAULT, IDS_FALSE, str_false); 2538 VARIANT_GetLocalisedText(LOCALE_USER_DEFAULT, IDS_TRUE, str_true); 2539 } 2540 2541 /* when both left and right are NULL the result is NULL */ 2542 if (leftvt == VT_NULL && rightvt == VT_NULL) 2543 { 2544 V_VT(out) = VT_NULL; 2545 return S_OK; 2546 } 2547 2548 hres = S_OK; 2549 resultvt = VT_EMPTY; 2550 2551 /* There are many special case for errors and return types */ 2552 if (leftvt == VT_VARIANT && (rightvt == VT_ERROR || 2553 rightvt == VT_DATE || rightvt == VT_DECIMAL)) 2554 hres = DISP_E_TYPEMISMATCH; 2555 else if ((leftvt == VT_I2 || leftvt == VT_I4 || 2556 leftvt == VT_R4 || leftvt == VT_R8 || 2557 leftvt == VT_CY || leftvt == VT_BOOL || 2558 leftvt == VT_BSTR || leftvt == VT_I1 || 2559 leftvt == VT_UI1 || leftvt == VT_UI2 || 2560 leftvt == VT_UI4 || leftvt == VT_I8 || 2561 leftvt == VT_UI8 || leftvt == VT_INT || 2562 leftvt == VT_UINT || leftvt == VT_EMPTY || 2563 leftvt == VT_NULL || leftvt == VT_DATE || 2564 leftvt == VT_DECIMAL || leftvt == VT_DISPATCH) 2565 && 2566 (rightvt == VT_I2 || rightvt == VT_I4 || 2567 rightvt == VT_R4 || rightvt == VT_R8 || 2568 rightvt == VT_CY || rightvt == VT_BOOL || 2569 rightvt == VT_BSTR || rightvt == VT_I1 || 2570 rightvt == VT_UI1 || rightvt == VT_UI2 || 2571 rightvt == VT_UI4 || rightvt == VT_I8 || 2572 rightvt == VT_UI8 || rightvt == VT_INT || 2573 rightvt == VT_UINT || rightvt == VT_EMPTY || 2574 rightvt == VT_NULL || rightvt == VT_DATE || 2575 rightvt == VT_DECIMAL || rightvt == VT_DISPATCH)) 2576 resultvt = VT_BSTR; 2577 else if (rightvt == VT_ERROR && leftvt < VT_VOID) 2578 hres = DISP_E_TYPEMISMATCH; 2579 else if (leftvt == VT_ERROR && (rightvt == VT_DATE || 2580 rightvt == VT_ERROR || rightvt == VT_DECIMAL)) 2581 hres = DISP_E_TYPEMISMATCH; 2582 else if (rightvt == VT_DATE || rightvt == VT_ERROR || 2583 rightvt == VT_DECIMAL) 2584 hres = DISP_E_BADVARTYPE; 2585 else if (leftvt == VT_ERROR || rightvt == VT_ERROR) 2586 hres = DISP_E_TYPEMISMATCH; 2587 else if (leftvt == VT_VARIANT) 2588 hres = DISP_E_TYPEMISMATCH; 2589 else if (rightvt == VT_VARIANT && (leftvt == VT_EMPTY || 2590 leftvt == VT_NULL || leftvt == VT_I2 || 2591 leftvt == VT_I4 || leftvt == VT_R4 || 2592 leftvt == VT_R8 || leftvt == VT_CY || 2593 leftvt == VT_DATE || leftvt == VT_BSTR || 2594 leftvt == VT_BOOL || leftvt == VT_DECIMAL || 2595 leftvt == VT_I1 || leftvt == VT_UI1 || 2596 leftvt == VT_UI2 || leftvt == VT_UI4 || 2597 leftvt == VT_I8 || leftvt == VT_UI8 || 2598 leftvt == VT_INT || leftvt == VT_UINT)) 2599 hres = DISP_E_TYPEMISMATCH; 2600 else 2601 hres = DISP_E_BADVARTYPE; 2602 2603 /* if result type is not S_OK, then no need to go further */ 2604 if (hres != S_OK) 2605 { 2606 V_VT(out) = resultvt; 2607 return hres; 2608 } 2609 /* Else proceed with formatting inputs to strings */ 2610 else 2611 { 2612 VARIANT bstrvar_left, bstrvar_right; 2613 V_VT(out) = VT_BSTR; 2614 2615 VariantInit(&bstrvar_left); 2616 VariantInit(&bstrvar_right); 2617 2618 /* Convert left side variant to string */ 2619 if (leftvt != VT_BSTR) 2620 { 2621 if (leftvt == VT_BOOL) 2622 { 2623 /* Bools are handled as localized True/False strings instead of 0/-1 as in MSDN */ 2624 V_VT(&bstrvar_left) = VT_BSTR; 2625 if (V_BOOL(left) == TRUE) 2626 V_BSTR(&bstrvar_left) = SysAllocString(str_true); 2627 else 2628 V_BSTR(&bstrvar_left) = SysAllocString(str_false); 2629 } 2630 /* Fill with empty string for later concat with right side */ 2631 else if (leftvt == VT_NULL) 2632 { 2633 V_VT(&bstrvar_left) = VT_BSTR; 2634 V_BSTR(&bstrvar_left) = SysAllocString(sz_empty); 2635 } 2636 else 2637 { 2638 hres = VariantChangeTypeEx(&bstrvar_left,left,0,0,VT_BSTR); 2639 if (hres != S_OK) { 2640 VariantClear(&bstrvar_left); 2641 VariantClear(&bstrvar_right); 2642 if (leftvt == VT_NULL && (rightvt == VT_EMPTY || 2643 rightvt == VT_NULL || rightvt == VT_I2 || 2644 rightvt == VT_I4 || rightvt == VT_R4 || 2645 rightvt == VT_R8 || rightvt == VT_CY || 2646 rightvt == VT_DATE || rightvt == VT_BSTR || 2647 rightvt == VT_BOOL || rightvt == VT_DECIMAL || 2648 rightvt == VT_I1 || rightvt == VT_UI1 || 2649 rightvt == VT_UI2 || rightvt == VT_UI4 || 2650 rightvt == VT_I8 || rightvt == VT_UI8 || 2651 rightvt == VT_INT || rightvt == VT_UINT)) 2652 return DISP_E_BADVARTYPE; 2653 return hres; 2654 } 2655 } 2656 } 2657 2658 /* convert right side variant to string */ 2659 if (rightvt != VT_BSTR) 2660 { 2661 if (rightvt == VT_BOOL) 2662 { 2663 /* Bools are handled as localized True/False strings instead of 0/-1 as in MSDN */ 2664 V_VT(&bstrvar_right) = VT_BSTR; 2665 if (V_BOOL(right) == TRUE) 2666 V_BSTR(&bstrvar_right) = SysAllocString(str_true); 2667 else 2668 V_BSTR(&bstrvar_right) = SysAllocString(str_false); 2669 } 2670 /* Fill with empty string for later concat with right side */ 2671 else if (rightvt == VT_NULL) 2672 { 2673 V_VT(&bstrvar_right) = VT_BSTR; 2674 V_BSTR(&bstrvar_right) = SysAllocString(sz_empty); 2675 } 2676 else 2677 { 2678 hres = VariantChangeTypeEx(&bstrvar_right,right,0,0,VT_BSTR); 2679 if (hres != S_OK) { 2680 VariantClear(&bstrvar_left); 2681 VariantClear(&bstrvar_right); 2682 if (rightvt == VT_NULL && (leftvt == VT_EMPTY || 2683 leftvt == VT_NULL || leftvt == VT_I2 || 2684 leftvt == VT_I4 || leftvt == VT_R4 || 2685 leftvt == VT_R8 || leftvt == VT_CY || 2686 leftvt == VT_DATE || leftvt == VT_BSTR || 2687 leftvt == VT_BOOL || leftvt == VT_DECIMAL || 2688 leftvt == VT_I1 || leftvt == VT_UI1 || 2689 leftvt == VT_UI2 || leftvt == VT_UI4 || 2690 leftvt == VT_I8 || leftvt == VT_UI8 || 2691 leftvt == VT_INT || leftvt == VT_UINT)) 2692 return DISP_E_BADVARTYPE; 2693 return hres; 2694 } 2695 } 2696 } 2697 2698 /* Concat the resulting strings together */ 2699 if (leftvt == VT_BSTR && rightvt == VT_BSTR) 2700 VarBstrCat (V_BSTR(left), V_BSTR(right), &V_BSTR(out)); 2701 else if (leftvt != VT_BSTR && rightvt != VT_BSTR) 2702 VarBstrCat (V_BSTR(&bstrvar_left), V_BSTR(&bstrvar_right), &V_BSTR(out)); 2703 else if (leftvt != VT_BSTR && rightvt == VT_BSTR) 2704 VarBstrCat (V_BSTR(&bstrvar_left), V_BSTR(right), &V_BSTR(out)); 2705 else if (leftvt == VT_BSTR && rightvt != VT_BSTR) 2706 VarBstrCat (V_BSTR(left), V_BSTR(&bstrvar_right), &V_BSTR(out)); 2707 2708 VariantClear(&bstrvar_left); 2709 VariantClear(&bstrvar_right); 2710 return S_OK; 2711 } 2712 } 2713 2714 2715 /* Wrapper around VariantChangeTypeEx() which permits changing a 2716 variant with VT_RESERVED flag set. Needed by VarCmp. */ 2717 static HRESULT _VarChangeTypeExWrap (VARIANTARG* pvargDest, 2718 VARIANTARG* pvargSrc, LCID lcid, USHORT wFlags, VARTYPE vt) 2719 { 2720 HRESULT res; 2721 VARTYPE flags; 2722 2723 flags = V_VT(pvargSrc) & ~VT_TYPEMASK; 2724 V_VT(pvargSrc) &= ~VT_RESERVED; 2725 res = VariantChangeTypeEx(pvargDest,pvargSrc,lcid,wFlags,vt); 2726 V_VT(pvargSrc) |= flags; 2727 2728 return res; 2729 } 2730 2731 /********************************************************************** 2732 * VarCmp [OLEAUT32.176] 2733 * 2734 * Compare two variants. 2735 * 2736 * PARAMS 2737 * left [I] First variant 2738 * right [I] Second variant 2739 * lcid [I] LCID (locale identifier) for the comparison 2740 * flags [I] Flags to be used in the comparison: 2741 * NORM_IGNORECASE, NORM_IGNORENONSPACE, NORM_IGNORESYMBOLS, 2742 * NORM_IGNOREWIDTH, NORM_IGNOREKANATYPE, NORM_IGNOREKASHIDA 2743 * 2744 * RETURNS 2745 * VARCMP_LT: left variant is less than right variant. 2746 * VARCMP_EQ: input variants are equal. 2747 * VARCMP_GT: left variant is greater than right variant. 2748 * VARCMP_NULL: either one of the input variants is NULL. 2749 * Failure: An HRESULT error code indicating the error. 2750 * 2751 * NOTES 2752 * Native VarCmp up to and including WinXP doesn't like I1, UI2, VT_UI4, 2753 * UI8 and UINT as input variants. INT is accepted only as left variant. 2754 * 2755 * If both input variants are ERROR then VARCMP_EQ will be returned, else 2756 * an ERROR variant will trigger an error. 2757 * 2758 * Both input variants can have VT_RESERVED flag set which is ignored 2759 * unless one and only one of the variants is a BSTR and the other one 2760 * is not an EMPTY variant. All four VT_RESERVED combinations have a 2761 * different meaning: 2762 * - BSTR and other: BSTR is always greater than the other variant. 2763 * - BSTR|VT_RESERVED and other: a string comparison is performed. 2764 * - BSTR and other|VT_RESERVED: If the BSTR is a number a numeric 2765 * comparison will take place else the BSTR is always greater. 2766 * - BSTR|VT_RESERVED and other|VT_RESERVED: It seems that the other 2767 * variant is ignored and the return value depends only on the sign 2768 * of the BSTR if it is a number else the BSTR is always greater. A 2769 * positive BSTR is greater, a negative one is smaller than the other 2770 * variant. 2771 * 2772 * SEE 2773 * VarBstrCmp for the lcid and flags usage. 2774 */ 2775 HRESULT WINAPI VarCmp(LPVARIANT left, LPVARIANT right, LCID lcid, DWORD flags) 2776 { 2777 VARTYPE lvt, rvt, vt; 2778 VARIANT rv,lv; 2779 DWORD xmask; 2780 HRESULT rc; 2781 2782 TRACE("(%p->(%s%s),%p->(%s%s),0x%08x,0x%08x)\n", left, debugstr_VT(left), 2783 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), lcid, flags); 2784 2785 lvt = V_VT(left) & VT_TYPEMASK; 2786 rvt = V_VT(right) & VT_TYPEMASK; 2787 xmask = (1 << lvt) | (1 << rvt); 2788 2789 /* If we have any flag set except VT_RESERVED bail out. 2790 Same for the left input variant type > VT_INT and for the 2791 right input variant type > VT_I8. Yes, VT_INT is only supported 2792 as left variant. Go figure */ 2793 if (((V_VT(left) | V_VT(right)) & ~VT_TYPEMASK & ~VT_RESERVED) || 2794 lvt > VT_INT || rvt > VT_I8) { 2795 return DISP_E_BADVARTYPE; 2796 } 2797 2798 /* Don't ask me why but native VarCmp cannot handle: VT_I1, VT_UI2, VT_UI4, 2799 VT_UINT and VT_UI8. Tested with DCOM98, Win2k, WinXP */ 2800 if (rvt == VT_INT || xmask & (VTBIT_I1 | VTBIT_UI2 | VTBIT_UI4 | VTBIT_UI8 | 2801 VTBIT_DISPATCH | VTBIT_VARIANT | VTBIT_UNKNOWN | VTBIT_15)) 2802 return DISP_E_TYPEMISMATCH; 2803 2804 /* If both variants are VT_ERROR return VARCMP_EQ */ 2805 if (xmask == VTBIT_ERROR) 2806 return VARCMP_EQ; 2807 else if (xmask & VTBIT_ERROR) 2808 return DISP_E_TYPEMISMATCH; 2809 2810 if (xmask & VTBIT_NULL) 2811 return VARCMP_NULL; 2812 2813 VariantInit(&lv); 2814 VariantInit(&rv); 2815 2816 /* Two BSTRs, ignore VT_RESERVED */ 2817 if (xmask == VTBIT_BSTR) 2818 return VarBstrCmp(V_BSTR(left), V_BSTR(right), lcid, flags); 2819 2820 /* A BSTR and an other variant; we have to take care of VT_RESERVED */ 2821 if (xmask & VTBIT_BSTR) { 2822 VARIANT *bstrv, *nonbv; 2823 VARTYPE nonbvt; 2824 int swap = 0; 2825 2826 /* Swap the variants so the BSTR is always on the left */ 2827 if (lvt == VT_BSTR) { 2828 bstrv = left; 2829 nonbv = right; 2830 nonbvt = rvt; 2831 } else { 2832 swap = 1; 2833 bstrv = right; 2834 nonbv = left; 2835 nonbvt = lvt; 2836 } 2837 2838 /* BSTR and EMPTY: ignore VT_RESERVED */ 2839 if (nonbvt == VT_EMPTY) 2840 rc = (!V_BSTR(bstrv) || !*V_BSTR(bstrv)) ? VARCMP_EQ : VARCMP_GT; 2841 else { 2842 VARTYPE breserv = V_VT(bstrv) & ~VT_TYPEMASK; 2843 VARTYPE nreserv = V_VT(nonbv) & ~VT_TYPEMASK; 2844 2845 if (!breserv && !nreserv) 2846 /* No VT_RESERVED set ==> BSTR always greater */ 2847 rc = VARCMP_GT; 2848 else if (breserv && !nreserv) { 2849 /* BSTR has VT_RESERVED set. Do a string comparison */ 2850 rc = VariantChangeTypeEx(&rv,nonbv,lcid,0,VT_BSTR); 2851 if (FAILED(rc)) 2852 return rc; 2853 rc = VarBstrCmp(V_BSTR(bstrv), V_BSTR(&rv), lcid, flags); 2854 VariantClear(&rv); 2855 } else if (V_BSTR(bstrv) && *V_BSTR(bstrv)) { 2856 /* Non NULL nor empty BSTR */ 2857 /* If the BSTR is not a number the BSTR is greater */ 2858 rc = _VarChangeTypeExWrap(&lv,bstrv,lcid,0,VT_R8); 2859 if (FAILED(rc)) 2860 rc = VARCMP_GT; 2861 else if (breserv && nreserv) 2862 /* FIXME: This is strange: with both VT_RESERVED set it 2863 looks like the result depends only on the sign of 2864 the BSTR number */ 2865 rc = (V_R8(&lv) >= 0) ? VARCMP_GT : VARCMP_LT; 2866 else 2867 /* Numeric comparison, will be handled below. 2868 VARCMP_NULL used only to break out. */ 2869 rc = VARCMP_NULL; 2870 VariantClear(&lv); 2871 VariantClear(&rv); 2872 } else 2873 /* Empty or NULL BSTR */ 2874 rc = VARCMP_GT; 2875 } 2876 /* Fixup the return code if we swapped left and right */ 2877 if (swap) { 2878 if (rc == VARCMP_GT) 2879 rc = VARCMP_LT; 2880 else if (rc == VARCMP_LT) 2881 rc = VARCMP_GT; 2882 } 2883 if (rc != VARCMP_NULL) 2884 return rc; 2885 } 2886 2887 if (xmask & VTBIT_DECIMAL) 2888 vt = VT_DECIMAL; 2889 else if (xmask & VTBIT_BSTR) 2890 vt = VT_R8; 2891 else if (xmask & VTBIT_R4) 2892 vt = VT_R4; 2893 else if (xmask & (VTBIT_R8 | VTBIT_DATE)) 2894 vt = VT_R8; 2895 else if (xmask & VTBIT_CY) 2896 vt = VT_CY; 2897 else 2898 /* default to I8 */ 2899 vt = VT_I8; 2900 2901 /* Coerce the variants */ 2902 rc = _VarChangeTypeExWrap(&lv,left,lcid,0,vt); 2903 if (rc == DISP_E_OVERFLOW && vt != VT_R8) { 2904 /* Overflow, change to R8 */ 2905 vt = VT_R8; 2906 rc = _VarChangeTypeExWrap(&lv,left,lcid,0,vt); 2907 } 2908 if (FAILED(rc)) 2909 return rc; 2910 rc = _VarChangeTypeExWrap(&rv,right,lcid,0,vt); 2911 if (rc == DISP_E_OVERFLOW && vt != VT_R8) { 2912 /* Overflow, change to R8 */ 2913 vt = VT_R8; 2914 rc = _VarChangeTypeExWrap(&lv,left,lcid,0,vt); 2915 if (FAILED(rc)) 2916 return rc; 2917 rc = _VarChangeTypeExWrap(&rv,right,lcid,0,vt); 2918 } 2919 if (FAILED(rc)) 2920 return rc; 2921 2922 #define _VARCMP(a,b) \ 2923 (((a) == (b)) ? VARCMP_EQ : (((a) < (b)) ? VARCMP_LT : VARCMP_GT)) 2924 2925 switch (vt) { 2926 case VT_CY: 2927 return VarCyCmp(V_CY(&lv), V_CY(&rv)); 2928 case VT_DECIMAL: 2929 return VarDecCmp(&V_DECIMAL(&lv), &V_DECIMAL(&rv)); 2930 case VT_I8: 2931 return _VARCMP(V_I8(&lv), V_I8(&rv)); 2932 case VT_R4: 2933 return _VARCMP(V_R4(&lv), V_R4(&rv)); 2934 case VT_R8: 2935 return _VARCMP(V_R8(&lv), V_R8(&rv)); 2936 default: 2937 /* We should never get here */ 2938 return E_FAIL; 2939 } 2940 #undef _VARCMP 2941 } 2942 2943 static HRESULT VARIANT_FetchDispatchValue(LPVARIANT pvDispatch, LPVARIANT pValue) 2944 { 2945 HRESULT hres; 2946 static DISPPARAMS emptyParams = { NULL, NULL, 0, 0 }; 2947 2948 if ((V_VT(pvDispatch) & VT_TYPEMASK) == VT_DISPATCH) { 2949 if (NULL == V_DISPATCH(pvDispatch)) return DISP_E_TYPEMISMATCH; 2950 hres = IDispatch_Invoke(V_DISPATCH(pvDispatch), DISPID_VALUE, &IID_NULL, 2951 LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &emptyParams, pValue, 2952 NULL, NULL); 2953 } else { 2954 hres = DISP_E_TYPEMISMATCH; 2955 } 2956 return hres; 2957 } 2958 2959 /********************************************************************** 2960 * VarAnd [OLEAUT32.142] 2961 * 2962 * Computes the logical AND of two variants. 2963 * 2964 * PARAMS 2965 * left [I] First variant 2966 * right [I] Second variant 2967 * result [O] Result variant 2968 * 2969 * RETURNS 2970 * Success: S_OK. 2971 * Failure: An HRESULT error code indicating the error. 2972 */ 2973 HRESULT WINAPI VarAnd(LPVARIANT left, LPVARIANT right, LPVARIANT result) 2974 { 2975 HRESULT hres = S_OK; 2976 VARTYPE resvt = VT_EMPTY; 2977 VARTYPE leftvt,rightvt; 2978 VARTYPE rightExtraFlags,leftExtraFlags,ExtraFlags; 2979 VARIANT varLeft, varRight; 2980 VARIANT tempLeft, tempRight; 2981 2982 VariantInit(&varLeft); 2983 VariantInit(&varRight); 2984 VariantInit(&tempLeft); 2985 VariantInit(&tempRight); 2986 2987 TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left), 2988 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result); 2989 2990 /* Handle VT_DISPATCH by storing and taking address of returned value */ 2991 if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH) 2992 { 2993 hres = VARIANT_FetchDispatchValue(left, &tempLeft); 2994 if (FAILED(hres)) goto VarAnd_Exit; 2995 left = &tempLeft; 2996 } 2997 if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH) 2998 { 2999 hres = VARIANT_FetchDispatchValue(right, &tempRight); 3000 if (FAILED(hres)) goto VarAnd_Exit; 3001 right = &tempRight; 3002 } 3003 3004 leftvt = V_VT(left)&VT_TYPEMASK; 3005 rightvt = V_VT(right)&VT_TYPEMASK; 3006 leftExtraFlags = V_VT(left)&(~VT_TYPEMASK); 3007 rightExtraFlags = V_VT(right)&(~VT_TYPEMASK); 3008 3009 if (leftExtraFlags != rightExtraFlags) 3010 { 3011 hres = DISP_E_BADVARTYPE; 3012 goto VarAnd_Exit; 3013 } 3014 ExtraFlags = leftExtraFlags; 3015 3016 /* Native VarAnd always returns an error when using extra 3017 * flags or if the variant combination is I8 and INT. 3018 */ 3019 if ((leftvt == VT_I8 && rightvt == VT_INT) || 3020 (leftvt == VT_INT && rightvt == VT_I8) || 3021 ExtraFlags != 0) 3022 { 3023 hres = DISP_E_BADVARTYPE; 3024 goto VarAnd_Exit; 3025 } 3026 3027 /* Determine return type */ 3028 else if (leftvt == VT_I8 || rightvt == VT_I8) 3029 resvt = VT_I8; 3030 else if (leftvt == VT_I4 || rightvt == VT_I4 || 3031 leftvt == VT_UINT || rightvt == VT_UINT || 3032 leftvt == VT_INT || rightvt == VT_INT || 3033 leftvt == VT_UINT || rightvt == VT_UINT || 3034 leftvt == VT_R4 || rightvt == VT_R4 || 3035 leftvt == VT_R8 || rightvt == VT_R8 || 3036 leftvt == VT_CY || rightvt == VT_CY || 3037 leftvt == VT_DATE || rightvt == VT_DATE || 3038 leftvt == VT_I1 || rightvt == VT_I1 || 3039 leftvt == VT_UI2 || rightvt == VT_UI2 || 3040 leftvt == VT_UI4 || rightvt == VT_UI4 || 3041 leftvt == VT_UI8 || rightvt == VT_UI8 || 3042 leftvt == VT_DECIMAL || rightvt == VT_DECIMAL) 3043 resvt = VT_I4; 3044 else if (leftvt == VT_UI1 || rightvt == VT_UI1 || 3045 leftvt == VT_I2 || rightvt == VT_I2 || 3046 leftvt == VT_EMPTY || rightvt == VT_EMPTY) 3047 if ((leftvt == VT_NULL && rightvt == VT_UI1) || 3048 (leftvt == VT_UI1 && rightvt == VT_NULL) || 3049 (leftvt == VT_UI1 && rightvt == VT_UI1)) 3050 resvt = VT_UI1; 3051 else 3052 resvt = VT_I2; 3053 else if (leftvt == VT_BOOL || rightvt == VT_BOOL || 3054 (leftvt == VT_BSTR && rightvt == VT_BSTR)) 3055 resvt = VT_BOOL; 3056 else if (leftvt == VT_NULL || rightvt == VT_NULL || 3057 leftvt == VT_BSTR || rightvt == VT_BSTR) 3058 resvt = VT_NULL; 3059 else 3060 { 3061 hres = DISP_E_BADVARTYPE; 3062 goto VarAnd_Exit; 3063 } 3064 3065 if (leftvt == VT_NULL || rightvt == VT_NULL) 3066 { 3067 /* 3068 * Special cases for when left variant is VT_NULL 3069 * (VT_NULL & 0 = VT_NULL, VT_NULL & value = value) 3070 */ 3071 if (leftvt == VT_NULL) 3072 { 3073 VARIANT_BOOL b; 3074 switch(rightvt) 3075 { 3076 case VT_I1: if (V_I1(right)) resvt = VT_NULL; break; 3077 case VT_UI1: if (V_UI1(right)) resvt = VT_NULL; break; 3078 case VT_I2: if (V_I2(right)) resvt = VT_NULL; break; 3079 case VT_UI2: if (V_UI2(right)) resvt = VT_NULL; break; 3080 case VT_I4: if (V_I4(right)) resvt = VT_NULL; break; 3081 case VT_UI4: if (V_UI4(right)) resvt = VT_NULL; break; 3082 case VT_I8: if (V_I8(right)) resvt = VT_NULL; break; 3083 case VT_UI8: if (V_UI8(right)) resvt = VT_NULL; break; 3084 case VT_INT: if (V_INT(right)) resvt = VT_NULL; break; 3085 case VT_UINT: if (V_UINT(right)) resvt = VT_NULL; break; 3086 case VT_BOOL: if (V_BOOL(right)) resvt = VT_NULL; break; 3087 case VT_R4: if (V_R4(right)) resvt = VT_NULL; break; 3088 case VT_R8: if (V_R8(right)) resvt = VT_NULL; break; 3089 case VT_CY: 3090 if(V_CY(right).int64) 3091 resvt = VT_NULL; 3092 break; 3093 case VT_DECIMAL: 3094 if (DEC_HI32(&V_DECIMAL(right)) || 3095 DEC_LO64(&V_DECIMAL(right))) 3096 resvt = VT_NULL; 3097 break; 3098 case VT_BSTR: 3099 hres = VarBoolFromStr(V_BSTR(right), 3100 LOCALE_USER_DEFAULT, VAR_LOCALBOOL, &b); 3101 if (FAILED(hres)) 3102 return hres; 3103 else if (b) 3104 V_VT(result) = VT_NULL; 3105 else 3106 { 3107 V_VT(result) = VT_BOOL; 3108 V_BOOL(result) = b; 3109 } 3110 goto VarAnd_Exit; 3111 } 3112 } 3113 V_VT(result) = resvt; 3114 goto VarAnd_Exit; 3115 } 3116 3117 hres = VariantCopy(&varLeft, left); 3118 if (FAILED(hres)) goto VarAnd_Exit; 3119 3120 hres = VariantCopy(&varRight, right); 3121 if (FAILED(hres)) goto VarAnd_Exit; 3122 3123 if (resvt == VT_I4 && V_VT(&varLeft) == VT_UI4) 3124 V_VT(&varLeft) = VT_I4; /* Don't overflow */ 3125 else 3126 { 3127 double d; 3128 3129 if (V_VT(&varLeft) == VT_BSTR && 3130 FAILED(VarR8FromStr(V_BSTR(&varLeft), 3131 LOCALE_USER_DEFAULT, 0, &d))) 3132 hres = VariantChangeType(&varLeft,&varLeft, 3133 VARIANT_LOCALBOOL, VT_BOOL); 3134 if (SUCCEEDED(hres) && V_VT(&varLeft) != resvt) 3135 hres = VariantChangeType(&varLeft,&varLeft,0,resvt); 3136 if (FAILED(hres)) goto VarAnd_Exit; 3137 } 3138 3139 if (resvt == VT_I4 && V_VT(&varRight) == VT_UI4) 3140 V_VT(&varRight) = VT_I4; /* Don't overflow */ 3141 else 3142 { 3143 double d; 3144 3145 if (V_VT(&varRight) == VT_BSTR && 3146 FAILED(VarR8FromStr(V_BSTR(&varRight), 3147 LOCALE_USER_DEFAULT, 0, &d))) 3148 hres = VariantChangeType(&varRight, &varRight, 3149 VARIANT_LOCALBOOL, VT_BOOL); 3150 if (SUCCEEDED(hres) && V_VT(&varRight) != resvt) 3151 hres = VariantChangeType(&varRight, &varRight, 0, resvt); 3152 if (FAILED(hres)) goto VarAnd_Exit; 3153 } 3154 3155 V_VT(result) = resvt; 3156 switch(resvt) 3157 { 3158 case VT_I8: 3159 V_I8(result) = V_I8(&varLeft) & V_I8(&varRight); 3160 break; 3161 case VT_I4: 3162 V_I4(result) = V_I4(&varLeft) & V_I4(&varRight); 3163 break; 3164 case VT_I2: 3165 V_I2(result) = V_I2(&varLeft) & V_I2(&varRight); 3166 break; 3167 case VT_UI1: 3168 V_UI1(result) = V_UI1(&varLeft) & V_UI1(&varRight); 3169 break; 3170 case VT_BOOL: 3171 V_BOOL(result) = V_BOOL(&varLeft) & V_BOOL(&varRight); 3172 break; 3173 default: 3174 FIXME("Couldn't bitwise AND variant types %d,%d\n", 3175 leftvt,rightvt); 3176 } 3177 3178 VarAnd_Exit: 3179 VariantClear(&varLeft); 3180 VariantClear(&varRight); 3181 VariantClear(&tempLeft); 3182 VariantClear(&tempRight); 3183 3184 return hres; 3185 } 3186 3187 /********************************************************************** 3188 * VarAdd [OLEAUT32.141] 3189 * 3190 * Add two variants. 3191 * 3192 * PARAMS 3193 * left [I] First variant 3194 * right [I] Second variant 3195 * result [O] Result variant 3196 * 3197 * RETURNS 3198 * Success: S_OK. 3199 * Failure: An HRESULT error code indicating the error. 3200 * 3201 * NOTES 3202 * Native VarAdd up to and including WinXP doesn't like I1, UI2, UI4, 3203 * UI8, INT and UINT as input variants. 3204 * 3205 * Native VarAdd doesn't check for NULL in/out pointers and crashes. We do the 3206 * same here. 3207 * 3208 * FIXME 3209 * Overflow checking for R8 (double) overflow. Return DISP_E_OVERFLOW in that 3210 * case. 3211 */ 3212 HRESULT WINAPI VarAdd(LPVARIANT left, LPVARIANT right, LPVARIANT result) 3213 { 3214 HRESULT hres; 3215 VARTYPE lvt, rvt, resvt, tvt; 3216 VARIANT lv, rv, tv; 3217 VARIANT tempLeft, tempRight; 3218 double r8res; 3219 3220 /* Variant priority for coercion. Sorted from lowest to highest. 3221 VT_ERROR shows an invalid input variant type. */ 3222 enum coerceprio { vt_EMPTY, vt_UI1, vt_I2, vt_I4, vt_I8, vt_BSTR,vt_R4, 3223 vt_R8, vt_CY, vt_DATE, vt_DECIMAL, vt_DISPATCH, vt_NULL, 3224 vt_ERROR }; 3225 /* Mapping from priority to variant type. Keep in sync with coerceprio! */ 3226 static const VARTYPE prio2vt[] = { VT_EMPTY, VT_UI1, VT_I2, VT_I4, VT_I8, VT_BSTR, VT_R4, 3227 VT_R8, VT_CY, VT_DATE, VT_DECIMAL, VT_DISPATCH, 3228 VT_NULL, VT_ERROR }; 3229 3230 /* Mapping for coercion from input variant to priority of result variant. */ 3231 static const VARTYPE coerce[] = { 3232 /* VT_EMPTY, VT_NULL, VT_I2, VT_I4, VT_R4 */ 3233 vt_EMPTY, vt_NULL, vt_I2, vt_I4, vt_R4, 3234 /* VT_R8, VT_CY, VT_DATE, VT_BSTR, VT_DISPATCH */ 3235 vt_R8, vt_CY, vt_DATE, vt_BSTR, vt_DISPATCH, 3236 /* VT_ERROR, VT_BOOL, VT_VARIANT, VT_UNKNOWN, VT_DECIMAL */ 3237 vt_ERROR, vt_I2, vt_ERROR, vt_ERROR, vt_DECIMAL, 3238 /* 15, VT_I1, VT_UI1, VT_UI2, VT_UI4 VT_I8 */ 3239 vt_ERROR, vt_ERROR, vt_UI1, vt_ERROR, vt_ERROR, vt_I8 3240 }; 3241 3242 TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left), 3243 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), 3244 result); 3245 3246 VariantInit(&lv); 3247 VariantInit(&rv); 3248 VariantInit(&tv); 3249 VariantInit(&tempLeft); 3250 VariantInit(&tempRight); 3251 3252 /* Handle VT_DISPATCH by storing and taking address of returned value */ 3253 if ((V_VT(left) & VT_TYPEMASK) != VT_NULL && (V_VT(right) & VT_TYPEMASK) != VT_NULL) 3254 { 3255 if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH) 3256 { 3257 hres = VARIANT_FetchDispatchValue(left, &tempLeft); 3258 if (FAILED(hres)) goto end; 3259 left = &tempLeft; 3260 } 3261 if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH) 3262 { 3263 hres = VARIANT_FetchDispatchValue(right, &tempRight); 3264 if (FAILED(hres)) goto end; 3265 right = &tempRight; 3266 } 3267 } 3268 3269 lvt = V_VT(left)&VT_TYPEMASK; 3270 rvt = V_VT(right)&VT_TYPEMASK; 3271 3272 /* If we have any flag set (VT_ARRAY, VT_VECTOR, etc.) bail out. 3273 Same for any input variant type > VT_I8 */ 3274 if (V_VT(left) & ~VT_TYPEMASK || V_VT(right) & ~VT_TYPEMASK || 3275 lvt > VT_I8 || rvt > VT_I8) { 3276 hres = DISP_E_BADVARTYPE; 3277 goto end; 3278 } 3279 3280 /* Determine the variant type to coerce to. */ 3281 if (coerce[lvt] > coerce[rvt]) { 3282 resvt = prio2vt[coerce[lvt]]; 3283 tvt = prio2vt[coerce[rvt]]; 3284 } else { 3285 resvt = prio2vt[coerce[rvt]]; 3286 tvt = prio2vt[coerce[lvt]]; 3287 } 3288 3289 /* Special cases where the result variant type is defined by both 3290 input variants and not only that with the highest priority */ 3291 if (resvt == VT_BSTR) { 3292 if (tvt == VT_EMPTY || tvt == VT_BSTR) 3293 resvt = VT_BSTR; 3294 else 3295 resvt = VT_R8; 3296 } 3297 if (resvt == VT_R4 && (tvt == VT_BSTR || tvt == VT_I8 || tvt == VT_I4)) 3298 resvt = VT_R8; 3299 3300 /* For overflow detection use the biggest compatible type for the 3301 addition */ 3302 switch (resvt) { 3303 case VT_ERROR: 3304 hres = DISP_E_BADVARTYPE; 3305 goto end; 3306 case VT_NULL: 3307 hres = S_OK; 3308 V_VT(result) = VT_NULL; 3309 goto end; 3310 case VT_DISPATCH: 3311 FIXME("cannot handle variant type VT_DISPATCH\n"); 3312 hres = DISP_E_TYPEMISMATCH; 3313 goto end; 3314 case VT_EMPTY: 3315 resvt = VT_I2; 3316 /* Fall through */ 3317 case VT_UI1: 3318 case VT_I2: 3319 case VT_I4: 3320 case VT_I8: 3321 tvt = VT_I8; 3322 break; 3323 case VT_DATE: 3324 case VT_R4: 3325 tvt = VT_R8; 3326 break; 3327 default: 3328 tvt = resvt; 3329 } 3330 3331 /* Now coerce the variants */ 3332 hres = VariantChangeType(&lv, left, 0, tvt); 3333 if (FAILED(hres)) 3334 goto end; 3335 hres = VariantChangeType(&rv, right, 0, tvt); 3336 if (FAILED(hres)) 3337 goto end; 3338 3339 /* Do the math */ 3340 hres = S_OK; 3341 V_VT(result) = resvt; 3342 switch (tvt) { 3343 case VT_DECIMAL: 3344 hres = VarDecAdd(&V_DECIMAL(&lv), &V_DECIMAL(&rv), 3345 &V_DECIMAL(result)); 3346 goto end; 3347 case VT_CY: 3348 hres = VarCyAdd(V_CY(&lv), V_CY(&rv), &V_CY(result)); 3349 goto end; 3350 case VT_BSTR: 3351 /* We do not add those, we concatenate them. */ 3352 hres = VarBstrCat(V_BSTR(&lv), V_BSTR(&rv), &V_BSTR(result)); 3353 goto end; 3354 case VT_I8: 3355 /* Overflow detection */ 3356 r8res = (double)V_I8(&lv) + (double)V_I8(&rv); 3357 if (r8res > (double)I8_MAX || r8res < (double)I8_MIN) { 3358 V_VT(result) = VT_R8; 3359 V_R8(result) = r8res; 3360 goto end; 3361 } else { 3362 V_VT(&tv) = tvt; 3363 V_I8(&tv) = V_I8(&lv) + V_I8(&rv); 3364 } 3365 break; 3366 case VT_R8: 3367 V_VT(&tv) = tvt; 3368 /* FIXME: overflow detection */ 3369 V_R8(&tv) = V_R8(&lv) + V_R8(&rv); 3370 break; 3371 default: 3372 ERR("We shouldn't get here! tvt = %d!\n", tvt); 3373 break; 3374 } 3375 if (resvt != tvt) { 3376 if ((hres = VariantChangeType(result, &tv, 0, resvt)) != S_OK) { 3377 /* Overflow! Change to the vartype with the next higher priority. 3378 With one exception: I4 ==> R8 even if it would fit in I8 */ 3379 if (resvt == VT_I4) 3380 resvt = VT_R8; 3381 else 3382 resvt = prio2vt[coerce[resvt] + 1]; 3383 hres = VariantChangeType(result, &tv, 0, resvt); 3384 } 3385 } else 3386 hres = VariantCopy(result, &tv); 3387 3388 end: 3389 if (hres != S_OK) { 3390 V_VT(result) = VT_EMPTY; 3391 V_I4(result) = 0; /* No V_EMPTY */ 3392 } 3393 VariantClear(&lv); 3394 VariantClear(&rv); 3395 VariantClear(&tv); 3396 VariantClear(&tempLeft); 3397 VariantClear(&tempRight); 3398 TRACE("returning 0x%8x (variant type %s)\n", hres, debugstr_VT(result)); 3399 return hres; 3400 } 3401 3402 /********************************************************************** 3403 * VarMul [OLEAUT32.156] 3404 * 3405 * Multiply two variants. 3406 * 3407 * PARAMS 3408 * left [I] First variant 3409 * right [I] Second variant 3410 * result [O] Result variant 3411 * 3412 * RETURNS 3413 * Success: S_OK. 3414 * Failure: An HRESULT error code indicating the error. 3415 * 3416 * NOTES 3417 * Native VarMul up to and including WinXP doesn't like I1, UI2, UI4, 3418 * UI8, INT and UINT as input variants. But it can multiply apples with oranges. 3419 * 3420 * Native VarMul doesn't check for NULL in/out pointers and crashes. We do the 3421 * same here. 3422 * 3423 * FIXME 3424 * Overflow checking for R8 (double) overflow. Return DISP_E_OVERFLOW in that 3425 * case. 3426 */ 3427 HRESULT WINAPI VarMul(LPVARIANT left, LPVARIANT right, LPVARIANT result) 3428 { 3429 HRESULT hres; 3430 VARTYPE lvt, rvt, resvt, tvt; 3431 VARIANT lv, rv, tv; 3432 VARIANT tempLeft, tempRight; 3433 double r8res; 3434 3435 /* Variant priority for coercion. Sorted from lowest to highest. 3436 VT_ERROR shows an invalid input variant type. */ 3437 enum coerceprio { vt_UI1 = 0, vt_I2, vt_I4, vt_I8, vt_CY, vt_R4, vt_R8, 3438 vt_DECIMAL, vt_NULL, vt_ERROR }; 3439 /* Mapping from priority to variant type. Keep in sync with coerceprio! */ 3440 static const VARTYPE prio2vt[] = { VT_UI1, VT_I2, VT_I4, VT_I8, VT_CY, VT_R4, VT_R8, 3441 VT_DECIMAL, VT_NULL, VT_ERROR }; 3442 3443 /* Mapping for coercion from input variant to priority of result variant. */ 3444 static const VARTYPE coerce[] = { 3445 /* VT_EMPTY, VT_NULL, VT_I2, VT_I4, VT_R4 */ 3446 vt_UI1, vt_NULL, vt_I2, vt_I4, vt_R4, 3447 /* VT_R8, VT_CY, VT_DATE, VT_BSTR, VT_DISPATCH */ 3448 vt_R8, vt_CY, vt_R8, vt_R8, vt_ERROR, 3449 /* VT_ERROR, VT_BOOL, VT_VARIANT, VT_UNKNOWN, VT_DECIMAL */ 3450 vt_ERROR, vt_I2, vt_ERROR, vt_ERROR, vt_DECIMAL, 3451 /* 15, VT_I1, VT_UI1, VT_UI2, VT_UI4 VT_I8 */ 3452 vt_ERROR, vt_ERROR, vt_UI1, vt_ERROR, vt_ERROR, vt_I8 3453 }; 3454 3455 TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left), 3456 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), 3457 result); 3458 3459 VariantInit(&lv); 3460 VariantInit(&rv); 3461 VariantInit(&tv); 3462 VariantInit(&tempLeft); 3463 VariantInit(&tempRight); 3464 3465 /* Handle VT_DISPATCH by storing and taking address of returned value */ 3466 if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH) 3467 { 3468 hres = VARIANT_FetchDispatchValue(left, &tempLeft); 3469 if (FAILED(hres)) goto end; 3470 left = &tempLeft; 3471 } 3472 if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH) 3473 { 3474 hres = VARIANT_FetchDispatchValue(right, &tempRight); 3475 if (FAILED(hres)) goto end; 3476 right = &tempRight; 3477 } 3478 3479 lvt = V_VT(left)&VT_TYPEMASK; 3480 rvt = V_VT(right)&VT_TYPEMASK; 3481 3482 /* If we have any flag set (VT_ARRAY, VT_VECTOR, etc.) bail out. 3483 Same for any input variant type > VT_I8 */ 3484 if (V_VT(left) & ~VT_TYPEMASK || V_VT(right) & ~VT_TYPEMASK || 3485 lvt > VT_I8 || rvt > VT_I8) { 3486 hres = DISP_E_BADVARTYPE; 3487 goto end; 3488 } 3489 3490 /* Determine the variant type to coerce to. */ 3491 if (coerce[lvt] > coerce[rvt]) { 3492 resvt = prio2vt[coerce[lvt]]; 3493 tvt = prio2vt[coerce[rvt]]; 3494 } else { 3495 resvt = prio2vt[coerce[rvt]]; 3496 tvt = prio2vt[coerce[lvt]]; 3497 } 3498 3499 /* Special cases where the result variant type is defined by both 3500 input variants and not only that with the highest priority */ 3501 if (resvt == VT_R4 && (tvt == VT_CY || tvt == VT_I8 || tvt == VT_I4)) 3502 resvt = VT_R8; 3503 if (lvt == VT_EMPTY && rvt == VT_EMPTY) 3504 resvt = VT_I2; 3505 3506 /* For overflow detection use the biggest compatible type for the 3507 multiplication */ 3508 switch (resvt) { 3509 case VT_ERROR: 3510 hres = DISP_E_BADVARTYPE; 3511 goto end; 3512 case VT_NULL: 3513 hres = S_OK; 3514 V_VT(result) = VT_NULL; 3515 goto end; 3516 case VT_UI1: 3517 case VT_I2: 3518 case VT_I4: 3519 case VT_I8: 3520 tvt = VT_I8; 3521 break; 3522 case VT_R4: 3523 tvt = VT_R8; 3524 break; 3525 default: 3526 tvt = resvt; 3527 } 3528 3529 /* Now coerce the variants */ 3530 hres = VariantChangeType(&lv, left, 0, tvt); 3531 if (FAILED(hres)) 3532 goto end; 3533 hres = VariantChangeType(&rv, right, 0, tvt); 3534 if (FAILED(hres)) 3535 goto end; 3536 3537 /* Do the math */ 3538 hres = S_OK; 3539 V_VT(&tv) = tvt; 3540 V_VT(result) = resvt; 3541 switch (tvt) { 3542 case VT_DECIMAL: 3543 hres = VarDecMul(&V_DECIMAL(&lv), &V_DECIMAL(&rv), 3544 &V_DECIMAL(result)); 3545 goto end; 3546 case VT_CY: 3547 hres = VarCyMul(V_CY(&lv), V_CY(&rv), &V_CY(result)); 3548 goto end; 3549 case VT_I8: 3550 /* Overflow detection */ 3551 r8res = (double)V_I8(&lv) * (double)V_I8(&rv); 3552 if (r8res > (double)I8_MAX || r8res < (double)I8_MIN) { 3553 V_VT(result) = VT_R8; 3554 V_R8(result) = r8res; 3555 goto end; 3556 } else 3557 V_I8(&tv) = V_I8(&lv) * V_I8(&rv); 3558 break; 3559 case VT_R8: 3560 /* FIXME: overflow detection */ 3561 V_R8(&tv) = V_R8(&lv) * V_R8(&rv); 3562 break; 3563 default: 3564 ERR("We shouldn't get here! tvt = %d!\n", tvt); 3565 break; 3566 } 3567 if (resvt != tvt) { 3568 while ((hres = VariantChangeType(result, &tv, 0, resvt)) != S_OK) { 3569 /* Overflow! Change to the vartype with the next higher priority. 3570 With one exception: I4 ==> R8 even if it would fit in I8 */ 3571 if (resvt == VT_I4) 3572 resvt = VT_R8; 3573 else 3574 resvt = prio2vt[coerce[resvt] + 1]; 3575 } 3576 } else 3577 hres = VariantCopy(result, &tv); 3578 3579 end: 3580 if (hres != S_OK) { 3581 V_VT(result) = VT_EMPTY; 3582 V_I4(result) = 0; /* No V_EMPTY */ 3583 } 3584 VariantClear(&lv); 3585 VariantClear(&rv); 3586 VariantClear(&tv); 3587 VariantClear(&tempLeft); 3588 VariantClear(&tempRight); 3589 TRACE("returning 0x%8x (variant type %s)\n", hres, debugstr_VT(result)); 3590 return hres; 3591 } 3592 3593 /********************************************************************** 3594 * VarDiv [OLEAUT32.143] 3595 * 3596 * Divides one variant with another. 3597 * 3598 * PARAMS 3599 * left [I] First variant 3600 * right [I] Second variant 3601 * result [O] Result variant 3602 * 3603 * RETURNS 3604 * Success: S_OK. 3605 * Failure: An HRESULT error code indicating the error. 3606 */ 3607 HRESULT WINAPI VarDiv(LPVARIANT left, LPVARIANT right, LPVARIANT result) 3608 { 3609 HRESULT hres = S_OK; 3610 VARTYPE resvt = VT_EMPTY; 3611 VARTYPE leftvt,rightvt; 3612 VARTYPE rightExtraFlags,leftExtraFlags,ExtraFlags; 3613 VARIANT lv,rv; 3614 VARIANT tempLeft, tempRight; 3615 3616 VariantInit(&tempLeft); 3617 VariantInit(&tempRight); 3618 VariantInit(&lv); 3619 VariantInit(&rv); 3620 3621 TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left), 3622 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result); 3623 3624 /* Handle VT_DISPATCH by storing and taking address of returned value */ 3625 if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH) 3626 { 3627 hres = VARIANT_FetchDispatchValue(left, &tempLeft); 3628 if (FAILED(hres)) goto end; 3629 left = &tempLeft; 3630 } 3631 if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH) 3632 { 3633 hres = VARIANT_FetchDispatchValue(right, &tempRight); 3634 if (FAILED(hres)) goto end; 3635 right = &tempRight; 3636 } 3637 3638 leftvt = V_VT(left)&VT_TYPEMASK; 3639 rightvt = V_VT(right)&VT_TYPEMASK; 3640 leftExtraFlags = V_VT(left)&(~VT_TYPEMASK); 3641 rightExtraFlags = V_VT(right)&(~VT_TYPEMASK); 3642 3643 if (leftExtraFlags != rightExtraFlags) 3644 { 3645 hres = DISP_E_BADVARTYPE; 3646 goto end; 3647 } 3648 ExtraFlags = leftExtraFlags; 3649 3650 /* Native VarDiv always returns an error when using extra flags */ 3651 if (ExtraFlags != 0) 3652 { 3653 hres = DISP_E_BADVARTYPE; 3654 goto end; 3655 } 3656 3657 /* Determine return type */ 3658 if (!(rightvt == VT_EMPTY)) 3659 { 3660 if (leftvt == VT_NULL || rightvt == VT_NULL) 3661 { 3662 V_VT(result) = VT_NULL; 3663 hres = S_OK; 3664 goto end; 3665 } 3666 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL) 3667 resvt = VT_DECIMAL; 3668 else if (leftvt == VT_I8 || rightvt == VT_I8 || 3669 leftvt == VT_CY || rightvt == VT_CY || 3670 leftvt == VT_DATE || rightvt == VT_DATE || 3671 leftvt == VT_I4 || rightvt == VT_I4 || 3672 leftvt == VT_BSTR || rightvt == VT_BSTR || 3673 leftvt == VT_I2 || rightvt == VT_I2 || 3674 leftvt == VT_BOOL || rightvt == VT_BOOL || 3675 leftvt == VT_R8 || rightvt == VT_R8 || 3676 leftvt == VT_UI1 || rightvt == VT_UI1) 3677 { 3678 if ((leftvt == VT_UI1 && rightvt == VT_R4) || 3679 (leftvt == VT_R4 && rightvt == VT_UI1)) 3680 resvt = VT_R4; 3681 else if ((leftvt == VT_R4 && (rightvt == VT_BOOL || 3682 rightvt == VT_I2)) || (rightvt == VT_R4 && 3683 (leftvt == VT_BOOL || leftvt == VT_I2))) 3684 resvt = VT_R4; 3685 else 3686 resvt = VT_R8; 3687 } 3688 else if (leftvt == VT_R4 || rightvt == VT_R4) 3689 resvt = VT_R4; 3690 } 3691 else if (leftvt == VT_NULL && rightvt == VT_EMPTY) 3692 { 3693 V_VT(result) = VT_NULL; 3694 hres = S_OK; 3695 goto end; 3696 } 3697 else 3698 { 3699 hres = DISP_E_BADVARTYPE; 3700 goto end; 3701 } 3702 3703 /* coerce to the result type */ 3704 hres = VariantChangeType(&lv, left, 0, resvt); 3705 if (hres != S_OK) goto end; 3706 3707 hres = VariantChangeType(&rv, right, 0, resvt); 3708 if (hres != S_OK) goto end; 3709 3710 /* do the math */ 3711 V_VT(result) = resvt; 3712 switch (resvt) 3713 { 3714 case VT_R4: 3715 if (V_R4(&lv) == 0.0 && V_R4(&rv) == 0.0) 3716 { 3717 hres = DISP_E_OVERFLOW; 3718 V_VT(result) = VT_EMPTY; 3719 } 3720 else if (V_R4(&rv) == 0.0) 3721 { 3722 hres = DISP_E_DIVBYZERO; 3723 V_VT(result) = VT_EMPTY; 3724 } 3725 else 3726 V_R4(result) = V_R4(&lv) / V_R4(&rv); 3727 break; 3728 case VT_R8: 3729 if (V_R8(&lv) == 0.0 && V_R8(&rv) == 0.0) 3730 { 3731 hres = DISP_E_OVERFLOW; 3732 V_VT(result) = VT_EMPTY; 3733 } 3734 else if (V_R8(&rv) == 0.0) 3735 { 3736 hres = DISP_E_DIVBYZERO; 3737 V_VT(result) = VT_EMPTY; 3738 } 3739 else 3740 V_R8(result) = V_R8(&lv) / V_R8(&rv); 3741 break; 3742 case VT_DECIMAL: 3743 hres = VarDecDiv(&(V_DECIMAL(&lv)), &(V_DECIMAL(&rv)), &(V_DECIMAL(result))); 3744 break; 3745 } 3746 3747 end: 3748 VariantClear(&lv); 3749 VariantClear(&rv); 3750 VariantClear(&tempLeft); 3751 VariantClear(&tempRight); 3752 TRACE("returning 0x%8x (variant type %s)\n", hres, debugstr_VT(result)); 3753 return hres; 3754 } 3755 3756 /********************************************************************** 3757 * VarSub [OLEAUT32.159] 3758 * 3759 * Subtract two variants. 3760 * 3761 * PARAMS 3762 * left [I] First variant 3763 * right [I] Second variant 3764 * result [O] Result variant 3765 * 3766 * RETURNS 3767 * Success: S_OK. 3768 * Failure: An HRESULT error code indicating the error. 3769 */ 3770 HRESULT WINAPI VarSub(LPVARIANT left, LPVARIANT right, LPVARIANT result) 3771 { 3772 HRESULT hres = S_OK; 3773 VARTYPE resvt = VT_EMPTY; 3774 VARTYPE leftvt,rightvt; 3775 VARTYPE rightExtraFlags,leftExtraFlags,ExtraFlags; 3776 VARIANT lv,rv; 3777 VARIANT tempLeft, tempRight; 3778 3779 VariantInit(&lv); 3780 VariantInit(&rv); 3781 VariantInit(&tempLeft); 3782 VariantInit(&tempRight); 3783 3784 TRACE("(%p->(%s%s),%p->(%s%s),%p)\n", left, debugstr_VT(left), 3785 debugstr_VF(left), right, debugstr_VT(right), debugstr_VF(right), result); 3786 3787 if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH && 3788 (V_VT(left)&(~VT_TYPEMASK)) == 0 && 3789 (V_VT(right) & VT_TYPEMASK) != VT_NULL) 3790 { 3791 if (NULL == V_DISPATCH(left)) { 3792 if ((V_VT(right) & VT_TYPEMASK) >= VT_INT_PTR) 3793 hres = DISP_E_BADVARTYPE; 3794 else if ((V_VT(right) & VT_TYPEMASK) >= VT_UI8 && 3795 (V_VT(right) & VT_TYPEMASK) < VT_RECORD) 3796 hres = DISP_E_BADVARTYPE; 3797 else switch (V_VT(right) & VT_TYPEMASK) 3798 { 3799 case VT_VARIANT: 3800 case VT_UNKNOWN: 3801 case 15: 3802 case VT_I1: 3803 case VT_UI2: 3804 case VT_UI4: 3805 hres = DISP_E_BADVARTYPE; 3806 } 3807 if (FAILED(hres)) goto end; 3808 } 3809 hres = VARIANT_FetchDispatchValue(left, &tempLeft); 3810 if (FAILED(hres)) goto end; 3811 left = &tempLeft; 3812 } 3813 if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH && 3814 (V_VT(right)&(~VT_TYPEMASK)) == 0 && 3815 (V_VT(left) & VT_TYPEMASK) != VT_NULL) 3816 { 3817 if (NULL == V_DISPATCH(right)) 3818 { 3819 if ((V_VT(left) & VT_TYPEMASK) >= VT_INT_PTR) 3820 hres = DISP_E_BADVARTYPE; 3821 else if ((V_VT(left) & VT_TYPEMASK) >= VT_UI8 && 3822 (V_VT(left) & VT_TYPEMASK) < VT_RECORD) 3823 hres = DISP_E_BADVARTYPE; 3824 else switch (V_VT(left) & VT_TYPEMASK) 3825 { 3826 case VT_VARIANT: 3827 case VT_UNKNOWN: 3828 case 15: 3829 case VT_I1: 3830 case VT_UI2: 3831 case VT_UI4: 3832 hres = DISP_E_BADVARTYPE; 3833 } 3834 if (FAILED(hres)) goto end; 3835 } 3836 hres = VARIANT_FetchDispatchValue(right, &tempRight); 3837 if (FAILED(hres)) goto end; 3838 right = &tempRight; 3839 } 3840 3841 leftvt = V_VT(left)&VT_TYPEMASK; 3842 rightvt = V_VT(right)&VT_TYPEMASK; 3843 leftExtraFlags = V_VT(left)&(~VT_TYPEMASK); 3844 rightExtraFlags = V_VT(right)&(~VT_TYPEMASK); 3845 3846 if (leftExtraFlags != rightExtraFlags) 3847 { 3848 hres = DISP_E_BADVARTYPE; 3849 goto end; 3850 } 3851 ExtraFlags = leftExtraFlags; 3852 3853 /* determine return type and return code */ 3854 /* All extra flags produce errors */ 3855 if (ExtraFlags == (VT_VECTOR|VT_BYREF|VT_RESERVED) || 3856 ExtraFlags == (VT_VECTOR|VT_RESERVED) || 3857 ExtraFlags == (VT_VECTOR|VT_BYREF) || 3858 ExtraFlags == (VT_BYREF|VT_RESERVED) || 3859 ExtraFlags == VT_VECTOR || 3860 ExtraFlags == VT_BYREF || 3861 ExtraFlags == VT_RESERVED) 3862 { 3863 hres = DISP_E_BADVARTYPE; 3864 goto end; 3865 } 3866 else if (ExtraFlags >= VT_ARRAY) 3867 { 3868 hres = DISP_E_TYPEMISMATCH; 3869 goto end; 3870 } 3871 /* Native VarSub cannot handle: VT_I1, VT_UI2, VT_UI4, 3872 VT_INT, VT_UINT and VT_UI8. Tested with WinXP */ 3873 else if (leftvt == VT_CLSID || rightvt == VT_CLSID || 3874 leftvt == VT_VARIANT || rightvt == VT_VARIANT || 3875 leftvt == VT_I1 || rightvt == VT_I1 || 3876 leftvt == VT_UI2 || rightvt == VT_UI2 || 3877 leftvt == VT_UI4 || rightvt == VT_UI4 || 3878 leftvt == VT_UI8 || rightvt == VT_UI8 || 3879 leftvt == VT_INT || rightvt == VT_INT || 3880 leftvt == VT_UINT || rightvt == VT_UINT || 3881 leftvt == VT_UNKNOWN || rightvt == VT_UNKNOWN || 3882 leftvt == VT_RECORD || rightvt == VT_RECORD) 3883 { 3884 if (leftvt == VT_RECORD && rightvt == VT_I8) 3885 hres = DISP_E_TYPEMISMATCH; 3886 else if (leftvt < VT_UI1 && rightvt == VT_RECORD) 3887 hres = DISP_E_TYPEMISMATCH; 3888 else if (leftvt >= VT_UI1 && rightvt == VT_RECORD) 3889 hres = DISP_E_TYPEMISMATCH; 3890 else if (leftvt == VT_RECORD && rightvt <= VT_UI1) 3891 hres = DISP_E_TYPEMISMATCH; 3892 else if (leftvt == VT_RECORD && rightvt > VT_UI1) 3893 hres = DISP_E_BADVARTYPE; 3894 else 3895 hres = DISP_E_BADVARTYPE; 3896 goto end; 3897 } 3898 /* The following flags/types are invalid for left variant */ 3899 else if (!((leftvt <= VT_LPWSTR || leftvt == VT_RECORD || 3900 leftvt == VT_CLSID) && leftvt != (VARTYPE)15 /* undefined vt */ && 3901 (leftvt < VT_VOID || leftvt > VT_LPWSTR))) 3902 { 3903 hres = DISP_E_BADVARTYPE; 3904 goto end; 3905 } 3906 /* The following flags/types are invalid for right variant */ 3907 else if (!((rightvt <= VT_LPWSTR || rightvt == VT_RECORD || 3908 rightvt == VT_CLSID) && rightvt != (VARTYPE)15 /* undefined vt */ && 3909 (rightvt < VT_VOID || rightvt > VT_LPWSTR))) 3910 { 3911 hres = DISP_E_BADVARTYPE; 3912 goto end; 3913 } 3914 else if ((leftvt == VT_NULL && rightvt == VT_DISPATCH) || 3915 (leftvt == VT_DISPATCH && rightvt == VT_NULL)) 3916 resvt = VT_NULL; 3917 else if (leftvt == VT_DISPATCH || rightvt == VT_DISPATCH || 3918 leftvt == VT_ERROR || rightvt == VT_ERROR) 3919 { 3920 hres = DISP_E_TYPEMISMATCH; 3921 goto end; 3922 } 3923 else if (leftvt == VT_NULL || rightvt == VT_NULL) 3924 resvt = VT_NULL; 3925 else if ((leftvt == VT_EMPTY && rightvt == VT_BSTR) || 3926 (leftvt == VT_DATE && rightvt == VT_DATE) || 3927 (leftvt == VT_BSTR && rightvt == VT_EMPTY) || 3928 (leftvt == VT_BSTR && rightvt == VT_BSTR)) 3929 resvt = VT_R8; 3930 else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL) 3931 resvt = VT_DECIMAL; 3932 else if (leftvt == VT_DATE || rightvt == VT_DATE) 3933 resvt = VT_DATE; 3934 else if (leftvt == VT_CY || rightvt == VT_CY) 3935 resvt = VT_CY; 3936 else if (leftvt == VT_R8 || rightvt == VT_R8) 3937 resvt = VT_R8; 3938 else if (leftvt == VT_BSTR || rightvt == VT_BSTR) 3939 resvt = VT_R8; 3940 else if (leftvt == VT_R4 || rightvt == VT_R4) 3941 { 3942 if (leftvt == VT_I4 || rightvt == VT_I4 || 3943 leftvt == VT_I8 || rightvt == VT_I8) 3944 resvt = VT_R8; 3945 else 3946 resvt = VT_R4; 3947 } 3948 else if (leftvt == VT_I8 || rightvt == VT_I8) 3949 resvt = VT_I8; 3950 else if (leftvt == VT_I4 || rightvt == VT_I4) 3951 resvt = VT_I4; 3952 else if (leftvt == VT_I2 || rightvt == VT_I2 || 3953 leftvt == VT_BOOL || rightvt == VT_BOOL || 3954 (leftvt == VT_EMPTY && rightvt == VT_EMPTY)) 3955 resvt = VT_I2; 3956 else if (leftvt == VT_UI1 || rightvt == VT_UI1) 3957 resvt = VT_UI1; 3958 else 3959 { 3960 hres = DISP_E_TYPEMISMATCH; 3961 goto end; 3962 } 3963 3964 /* coerce to the result type */ 3965 if (leftvt == VT_BSTR && rightvt == VT_DATE) 3966 hres = VariantChangeType(&lv, left, 0, VT_R8); 3967 else 3968 hres = VariantChangeType(&lv, left, 0, resvt); 3969 if (hres != S_OK) goto end; 3970 if (leftvt == VT_DATE && rightvt == VT_BSTR) 3971 hres = VariantChangeType(&rv, right, 0, VT_R8); 3972 else 3973 hres = VariantChangeType(&rv, right, 0, resvt); 3974 if (hres != S_OK) goto end; 3975 3976 /* do the math */ 3977 V_VT(result) = resvt; 3978 switch (resvt) 3979 { 3980 case VT_NULL: 3981 break; 3982 case VT_DATE: 3983 V_DATE(result) = V_DATE(&lv) - V_DATE(&rv); 3984 break; 3985 case VT_CY: 3986 hres = VarCySub(V_CY(&lv), V_CY(&rv), &(V_CY(result))); 3987 break; 3988 case VT_R4: 3989 V_R4(result) = V_R4(&lv) - V_R4(&rv); 3990 break; 3991 case VT_I8: 3992 V_I8(result) = V_I8(&lv) - V_I8(&rv); 3993 break; 3994 case VT_I4: 3995 V_I4(result) = V_I4(&lv) - V_I4(&rv); 3996 break; 3997 case VT_I2: 3998 V_I2(result) = V_I2(&lv) - V_I2(&rv); 3999 break; 4000 case VT_I1: 4001 V_I1(result) = V_I1(&lv) - V_I1(&rv); 4002 break; 4003 case VT_UI1: 4004 V_UI1(result) = V_UI2(&lv) - V_UI1(&rv); 4005 break; 4006 case VT_R8: 4007 V_R8(result) = V_R8(&lv) - V_R8(&rv); 4008 break; 4009 case VT_DECIMAL: 4010 hres = VarDecSub(&(V_DECIMAL(&lv)), &(V_DECIMAL(&rv)), &(V_DECIMAL(result))); 4011 break; 4012 } 4013 4014 end: 4015 VariantClear(&lv); 4016 VariantClear(&rv); 4017 VariantClear(&tempLeft); 4018 VariantClear(&tempRight); 4019 TRACE("returning 0x%8x (variant type %s)\n", hres, debugstr_VT(result)); 4020 return hres; 4021 } 4022 4023 4024 /********************************************************************** 4025 * VarOr [OLEAUT32.157] 4026 * 4027 * Perform a logical or (OR) operation on two variants.

Wine Cross Reference wine/dlls/oleaut32/variant.c

Wine Cross Reference
wine/dlls/oleaut32/variant.c