variant.c File Reference

#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "variant.h"
#include "resource.h"
#include "wine/debug.h"

Include dependency graph for variant.c:

Go to the source code of this file.

Macros
#define	COBJMACROS
#define	NONAMELESSUNION
#define	NONAMELESSSTRUCT
#define	IsLeapYear(y)   (((y % 4) == 0) && (((y % 100) != 0) || ((y % 400) == 0)))
#define	DOS_YEAR(x)   (1980 + (x >> 9))
#define	DOS_MONTH(x)   ((x >> 5) & 0xf)
#define	DOS_DAY(x)   (x & 0x1f)
#define	DOS_HOUR(x)   (x >> 11)
#define	DOS_MINUTE(x)   ((x >> 5) & 0x3f)
#define	DOS_SECOND(x)   ((x & 0x1f) << 1)
#define	DOS_DATE(d, m, y)   (d | (m << 5) | ((y-1980) << 9))
#define	DOS_TIME(h, m, s)   ((s >> 1) | (m << 5) | (h << 11))
#define	GET_NUMBER_TEXT(fld, name)
#define	B_PROCESSING_EXPONENT   0x1
#define	B_NEGATIVE_EXPONENT   0x2
#define	B_EXPONENT_START   0x4
#define	B_INEXACT_ZEROS   0x8
#define	B_LEADING_ZERO   0x10
#define	B_PROCESSING_HEX   0x20
#define	B_PROCESSING_OCT   0x40
#define	INTEGER_VTBITS   (VTBIT_I1|VTBIT_UI1|VTBIT_I2|VTBIT_UI2|VTBIT_I4|VTBIT_UI4|VTBIT_I8|VTBIT_UI8)
#define	REAL_VTBITS   (VTBIT_R4|VTBIT_R8|VTBIT_CY)
#define	FITS_AS_I1(x)   ((x) >> 8 == 0)
#define	FITS_AS_I2(x)   ((x) >> 16 == 0)
#define	FITS_AS_I4(x)   ((x) >> 32 == 0)
#define	_VARCMP(a, b)    (((a) == (b)) ? VARCMP_EQ : (((a) < (b)) ? VARCMP_LT : VARCMP_GT))
#define	ABS_CASE(typ, min)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (variant)
static HRESULT	VARIANT_Coerce (VARIANTARG *pd, LCID lcid, USHORT wFlags, VARIANTARG *ps, VARTYPE vt)
static HRESULT	VARIANT_CoerceArray (VARIANTARG *pd, VARIANTARG *ps, VARTYPE vt)
static HRESULT	VARIANT_FetchDispatchValue (LPVARIANT pvDispatch, LPVARIANT pValue)
static HRESULT	VARIANT_ValidateType (VARTYPE vt)
void WINAPI	VariantInit (VARIANTARG *pVarg)
HRESULT	VARIANT_ClearInd (VARIANTARG *pVarg)
HRESULT WINAPI DECLSPEC_HOTPATCH	VariantClear (VARIANTARG *pVarg)
static HRESULT	VARIANT_CopyIRecordInfo (VARIANT *dest, VARIANT *src)
HRESULT WINAPI	VariantCopy (VARIANTARG *pvargDest, VARIANTARG *pvargSrc)
static size_t	VARIANT_DataSize (const VARIANT *pv)
HRESULT WINAPI	VariantCopyInd (VARIANT *pvargDest, VARIANTARG *pvargSrc)
HRESULT WINAPI DECLSPEC_HOTPATCH	VariantChangeType (VARIANTARG *pvargDest, VARIANTARG *pvargSrc, USHORT wFlags, VARTYPE vt)
HRESULT WINAPI	VariantChangeTypeEx (VARIANTARG *pvargDest, VARIANTARG *pvargSrc, LCID lcid, USHORT wFlags, VARTYPE vt)
static int	VARIANT_JulianFromDate (int dateIn)
static int	VARIANT_DateFromJulian (int dateIn)
static void	VARIANT_DMYFromJulian (int jd, USHORT *year, USHORT *month, USHORT *day)
static double	VARIANT_JulianFromDMY (USHORT year, USHORT month, USHORT day)
static HRESULT	VARIANT_RollUdate (UDATE *lpUd)
INT WINAPI	DosDateTimeToVariantTime (USHORT wDosDate, USHORT wDosTime, double *pDateOut)
INT WINAPI	VariantTimeToDosDateTime (double dateIn, USHORT *pwDosDate, USHORT *pwDosTime)
INT WINAPI	SystemTimeToVariantTime (LPSYSTEMTIME lpSt, double *pDateOut)
INT WINAPI	VariantTimeToSystemTime (double dateIn, LPSYSTEMTIME lpSt)
HRESULT WINAPI	VarDateFromUdateEx (UDATE *pUdateIn, LCID lcid, ULONG dwFlags, DATE *pDateOut)
HRESULT WINAPI	VarDateFromUdate (UDATE *pUdateIn, ULONG dwFlags, DATE *pDateOut)
HRESULT WINAPI	VarUdateFromDate (DATE dateIn, ULONG dwFlags, UDATE *lpUdate)
static void	VARIANT_GetLocalisedNumberChars (VARIANT_NUMBER_CHARS *lpChars, LCID lcid, DWORD dwFlags)
HRESULT WINAPI	VarParseNumFromStr (OLECHAR *lpszStr, LCID lcid, ULONG dwFlags, NUMPARSE *pNumprs, BYTE *rgbDig)
HRESULT WINAPI	VarNumFromParseNum (NUMPARSE *pNumprs, BYTE *rgbDig, ULONG dwVtBits, VARIANT *pVarDst)
HRESULT WINAPI	VarCat (LPVARIANT left, LPVARIANT right, LPVARIANT out)
static HRESULT	_VarChangeTypeExWrap (VARIANTARG *pvargDest, VARIANTARG *pvargSrc, LCID lcid, USHORT wFlags, VARTYPE vt)
HRESULT WINAPI	VarCmp (LPVARIANT left, LPVARIANT right, LCID lcid, DWORD flags)
HRESULT WINAPI	VarAnd (LPVARIANT left, LPVARIANT right, LPVARIANT result)
HRESULT WINAPI	VarAdd (LPVARIANT left, LPVARIANT right, LPVARIANT result)
HRESULT WINAPI	VarMul (LPVARIANT left, LPVARIANT right, LPVARIANT result)
HRESULT WINAPI	VarDiv (LPVARIANT left, LPVARIANT right, LPVARIANT result)
HRESULT WINAPI	VarSub (LPVARIANT left, LPVARIANT right, LPVARIANT result)
HRESULT WINAPI	VarOr (LPVARIANT pVarLeft, LPVARIANT pVarRight, LPVARIANT pVarOut)
HRESULT WINAPI	VarAbs (LPVARIANT pVarIn, LPVARIANT pVarOut)
HRESULT WINAPI	VarFix (LPVARIANT pVarIn, LPVARIANT pVarOut)
HRESULT WINAPI	VarInt (LPVARIANT pVarIn, LPVARIANT pVarOut)
HRESULT WINAPI	VarXor (LPVARIANT pVarLeft, LPVARIANT pVarRight, LPVARIANT pVarOut)
HRESULT WINAPI	VarEqv (LPVARIANT pVarLeft, LPVARIANT pVarRight, LPVARIANT pVarOut)
HRESULT WINAPI	VarNeg (LPVARIANT pVarIn, LPVARIANT pVarOut)
HRESULT WINAPI	VarNot (LPVARIANT pVarIn, LPVARIANT pVarOut)
HRESULT WINAPI	VarRound (LPVARIANT pVarIn, int deci, LPVARIANT pVarOut)
HRESULT WINAPI	VarIdiv (LPVARIANT left, LPVARIANT right, LPVARIANT result)
HRESULT WINAPI	VarMod (LPVARIANT left, LPVARIANT right, LPVARIANT result)
HRESULT WINAPI	VarPow (LPVARIANT left, LPVARIANT right, LPVARIANT result)
HRESULT WINAPI	VarImp (LPVARIANT left, LPVARIANT right, LPVARIANT result)

Variables
static CRITICAL_SECTION	cache_cs = { &critsect_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	critsect_debug

Macro Definition Documentation

_VARCMP

#define _VARCMP	(		a,
			b
	)		(((a) == (b)) ? VARCMP_EQ : (((a) < (b)) ? VARCMP_LT : VARCMP_GT))

ABS_CASE

#define ABS_CASE	(		typ,
			min
	)

Value:

    case VT_##typ: if (V_##typ(pVarIn) == min) hRet = DISP_E_OVERFLOW; \
                  else if (V_##typ(pVarIn) < 0) V_##typ(pVarOut) = -V_##typ(pVarIn); \
                  break

B_EXPONENT_START

#define B_EXPONENT_START   0x4

Definition at line 1568 of file variant.c.

B_INEXACT_ZEROS

#define B_INEXACT_ZEROS   0x8

Definition at line 1569 of file variant.c.

B_LEADING_ZERO

#define B_LEADING_ZERO   0x10

Definition at line 1570 of file variant.c.

B_NEGATIVE_EXPONENT

#define B_NEGATIVE_EXPONENT   0x2

Definition at line 1567 of file variant.c.

B_PROCESSING_EXPONENT

#define B_PROCESSING_EXPONENT   0x1

Definition at line 1566 of file variant.c.

B_PROCESSING_HEX

#define B_PROCESSING_HEX   0x20

Definition at line 1571 of file variant.c.

B_PROCESSING_OCT

#define B_PROCESSING_OCT   0x40

Definition at line 1572 of file variant.c.

COBJMACROS

#define COBJMACROS

Definition at line 32 of file variant.c.

DOS_DATE

#define DOS_DATE	(		d,
			m,
			y
	)		(d | (m << 5) | ((y-1980) << 9))

Definition at line 1104 of file variant.c.

DOS_DAY

#define DOS_DAY

(

x

)

(x & 0x1f)

Definition at line 1099 of file variant.c.

DOS_HOUR

#define DOS_HOUR

(

x

)

(x >> 11)

Definition at line 1100 of file variant.c.

DOS_MINUTE

#define DOS_MINUTE

(

x

)

((x >> 5) & 0x3f)

Definition at line 1101 of file variant.c.

DOS_MONTH

#define DOS_MONTH

(

x

)

((x >> 5) & 0xf)

Definition at line 1098 of file variant.c.

DOS_SECOND

#define DOS_SECOND

(

x

)

((x & 0x1f) << 1)

Definition at line 1102 of file variant.c.

DOS_TIME

#define DOS_TIME	(		h,
			m,
			s
	)		((s >> 1) | (m << 5) | (h << 11))

Definition at line 1105 of file variant.c.

DOS_YEAR

#define DOS_YEAR

(

x

)

(1980 + (x >> 9))

Definition at line 1097 of file variant.c.

FITS_AS_I1

#define FITS_AS_I1

(

x

)

((x) >> 8 == 0)

Definition at line 1964 of file variant.c.

FITS_AS_I2

#define FITS_AS_I2

(

x

)

((x) >> 16 == 0)

Definition at line 1965 of file variant.c.

FITS_AS_I4

#define FITS_AS_I4

(

x

)

((x) >> 32 == 0)

Definition at line 1966 of file variant.c.

GET_NUMBER_TEXT

#define GET_NUMBER_TEXT	(		fld,
			name
	)

Value:

  buff[0] = 0; \
  if (!GetLocaleInfoW(lcid, lctype|fld, buff, 2)) \
    WARN("buffer too small for " #fld "\n"); \
  else \
    if (buff[0]) lpChars->name = buff[0]; \
  TRACE("lcid 0x%x, " #name "=%d '%c'\n", lcid, lpChars->name, lpChars->name)

Definition at line 1509 of file variant.c.

INTEGER_VTBITS

#define INTEGER_VTBITS   (VTBIT_I1|VTBIT_UI1|VTBIT_I2|VTBIT_UI2|VTBIT_I4|VTBIT_UI4|VTBIT_I8|VTBIT_UI8)

Definition at line 1959 of file variant.c.

IsLeapYear

#define IsLeapYear

(

y

)

(((y % 4) == 0) && (((y % 100) != 0) || ((y % 400) == 0)))

Definition at line 1048 of file variant.c.

NONAMELESSSTRUCT

#define NONAMELESSSTRUCT

Definition at line 34 of file variant.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 33 of file variant.c.

REAL_VTBITS

#define REAL_VTBITS   (VTBIT_R4|VTBIT_R8|VTBIT_CY)

Definition at line 1961 of file variant.c.

Function Documentation

_VarChangeTypeExWrap()

static HRESULT _VarChangeTypeExWrap ( VARIANTARG *  pvargDest, VARIANTARG *  pvargSrc, LCID  lcid, USHORT  wFlags, VARTYPE  vt  )

static

Definition at line 2659 of file variant.c.

{
    VARIANTARG vtmpsrc = *pvargSrc;
 
    V_VT(&vtmpsrc) &= ~VT_RESERVED;
    return VariantChangeTypeEx(pvargDest,&vtmpsrc,lcid,wFlags,vt);
}

Referenced by VarCmp().

DosDateTimeToVariantTime()

INT WINAPI DosDateTimeToVariantTime	(	USHORT	wDosDate,
		USHORT	wDosTime,
		double *	pDateOut
	)

Definition at line 1211 of file variant.c.

{
  UDATE ud;
 
  TRACE("(0x%x(%d/%d/%d),0x%x(%d:%d:%d),%p)\n",
        wDosDate, DOS_YEAR(wDosDate), DOS_MONTH(wDosDate), DOS_DAY(wDosDate),
        wDosTime, DOS_HOUR(wDosTime), DOS_MINUTE(wDosTime), DOS_SECOND(wDosTime),
        pDateOut);
 
  ud.st.wYear = DOS_YEAR(wDosDate);
  ud.st.wMonth = DOS_MONTH(wDosDate);
  if (ud.st.wYear > 2099 || ud.st.wMonth > 12)
    return FALSE;
  ud.st.wDay = DOS_DAY(wDosDate);
  ud.st.wHour = DOS_HOUR(wDosTime);
  ud.st.wMinute = DOS_MINUTE(wDosTime);
  ud.st.wSecond = DOS_SECOND(wDosTime);
  ud.st.wDayOfWeek = ud.st.wMilliseconds = 0;
  if (ud.st.wHour > 23 || ud.st.wMinute > 59 || ud.st.wSecond > 59)
    return FALSE; /* Invalid values in Dos*/
 
  return VarDateFromUdate(&ud, 0, pDateOut) == S_OK;
}

Referenced by test_DosDateTimeToVariantTime().

SystemTimeToVariantTime()

INT WINAPI SystemTimeToVariantTime	(	LPSYSTEMTIME	lpSt,
		double *	pDateOut
	)

Definition at line 1286 of file variant.c.

{
  UDATE ud;
 
  TRACE("(%p->%d/%d/%d %d:%d:%d,%p)\n", lpSt, lpSt->wDay, lpSt->wMonth,
        lpSt->wYear, lpSt->wHour, lpSt->wMinute, lpSt->wSecond, pDateOut);
 
  if (lpSt->wMonth > 12)
    return FALSE;
  if (lpSt->wDay > 31)
    return FALSE;
  if ((short)lpSt->wYear < 0)
    return FALSE;
 
  ud.st = *lpSt;
  return VarDateFromUdate(&ud, 0, pDateOut) == S_OK;
}

Referenced by get_date_from_filetime(), Global_Now(), summaryinfo_invoke(), test_SummaryInfo(), test_SystemTimeToVariantTime(), and VarDateFromStr().

VarAbs()

HRESULT WINAPI VarAbs	(	LPVARIANT	pVarIn,
		LPVARIANT	pVarOut
	)

Definition at line 4263 of file variant.c.

{
    VARIANT varIn;
    HRESULT hRet = S_OK;
    VARIANT temp;
 
    VariantInit(&temp);
 
    TRACE("(%s,%p)\n", debugstr_variant(pVarIn), pVarOut);
 
    /* Handle VT_DISPATCH by storing and taking address of returned value */
    if ((V_VT(pVarIn) & VT_TYPEMASK) == VT_DISPATCH && ((V_VT(pVarIn) & ~VT_TYPEMASK) == 0))
    {
        hRet = VARIANT_FetchDispatchValue(pVarIn, &temp);
        if (FAILED(hRet)) goto VarAbs_Exit;
        pVarIn = &temp;
    }
 
    if (V_ISARRAY(pVarIn) || V_VT(pVarIn) == VT_UNKNOWN ||
        V_VT(pVarIn) == VT_DISPATCH || V_VT(pVarIn) == VT_RECORD ||
        V_VT(pVarIn) == VT_ERROR)
    {
        hRet = DISP_E_TYPEMISMATCH;
        goto VarAbs_Exit;
    }
    *pVarOut = *pVarIn; /* Shallow copy the value, and invert it if needed */
 
#define ABS_CASE(typ,min) \
    case VT_##typ: if (V_##typ(pVarIn) == min) hRet = DISP_E_OVERFLOW; \
                  else if (V_##typ(pVarIn) < 0) V_##typ(pVarOut) = -V_##typ(pVarIn); \
                  break
 
    switch (V_VT(pVarIn))
    {
    ABS_CASE(I1,I1_MIN);
    case VT_BOOL:
        V_VT(pVarOut) = VT_I2;
        /* BOOL->I2, Fall through ... */
    ABS_CASE(I2,I2_MIN);
    case VT_INT:
    ABS_CASE(I4,I4_MIN);
    ABS_CASE(I8,I8_MIN);
    ABS_CASE(R4,R4_MIN);
    case VT_BSTR:
        hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(&varIn));
        if (FAILED(hRet))
            break;
        V_VT(pVarOut) = VT_R8;
        pVarIn = &varIn;
        /* Fall through ... */
    case VT_DATE:
    ABS_CASE(R8,R8_MIN);
    case VT_CY:
        hRet = VarCyAbs(V_CY(pVarIn), & V_CY(pVarOut));
        break;
    case VT_DECIMAL:
        DEC_SIGN(&V_DECIMAL(pVarOut)) &= ~DECIMAL_NEG;
        break;
    case VT_UI1:
    case VT_UI2:
    case VT_UINT:
    case VT_UI4:
    case VT_UI8:
        /* No-Op */
        break;
    case VT_EMPTY:
        V_VT(pVarOut) = VT_I2;
    case VT_NULL:
        V_I2(pVarOut) = 0;
        break;
    default:
        hRet = DISP_E_BADVARTYPE;
    }
 
VarAbs_Exit:
    VariantClear(&temp);
    return hRet;
}

Referenced by Global_Abs(), and test_VarAbs().

VarAdd()

HRESULT WINAPI VarAdd	(	LPVARIANT	left,
		LPVARIANT	right,
		LPVARIANT	result
	)

Definition at line 3130 of file variant.c.

{
    HRESULT hres;
    VARTYPE lvt, rvt, resvt, tvt;
    VARIANT lv, rv, tv;
    VARIANT tempLeft, tempRight;
    double r8res;
 
    /* Variant priority for coercion. Sorted from lowest to highest.
       VT_ERROR shows an invalid input variant type. */
    enum coerceprio { vt_EMPTY, vt_UI1, vt_I2, vt_I4, vt_I8, vt_BSTR,vt_R4,
                      vt_R8, vt_CY, vt_DATE, vt_DECIMAL, vt_DISPATCH, vt_NULL,
                      vt_ERROR };
    /* Mapping from priority to variant type. Keep in sync with coerceprio! */
    static const VARTYPE prio2vt[] = { VT_EMPTY, VT_UI1, VT_I2, VT_I4, VT_I8, VT_BSTR, VT_R4,
                          VT_R8, VT_CY, VT_DATE, VT_DECIMAL, VT_DISPATCH,
                          VT_NULL, VT_ERROR };
 
    /* Mapping for coercion from input variant to priority of result variant. */
    static const VARTYPE coerce[] = {
        /* VT_EMPTY, VT_NULL, VT_I2, VT_I4, VT_R4 */
        vt_EMPTY, vt_NULL, vt_I2, vt_I4, vt_R4,
        /* VT_R8, VT_CY, VT_DATE, VT_BSTR, VT_DISPATCH */
        vt_R8, vt_CY, vt_DATE, vt_BSTR, vt_DISPATCH,
        /* VT_ERROR, VT_BOOL, VT_VARIANT, VT_UNKNOWN, VT_DECIMAL */
        vt_ERROR, vt_I2, vt_ERROR, vt_ERROR, vt_DECIMAL,
        /* 15, VT_I1, VT_UI1, VT_UI2, VT_UI4 VT_I8 */
        vt_ERROR, vt_ERROR, vt_UI1, vt_ERROR, vt_ERROR, vt_I8
    };
 
    TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
 
    VariantInit(&lv);
    VariantInit(&rv);
    VariantInit(&tv);
    VariantInit(&tempLeft);
    VariantInit(&tempRight);
 
    /* Handle VT_DISPATCH by storing and taking address of returned value */
    if ((V_VT(left) & VT_TYPEMASK) != VT_NULL && (V_VT(right) & VT_TYPEMASK) != VT_NULL)
    {
        if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH)
        {
            hres = VARIANT_FetchDispatchValue(left, &tempLeft);
            if (FAILED(hres)) goto end;
            left = &tempLeft;
        }
        if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH)
        {
            hres = VARIANT_FetchDispatchValue(right, &tempRight);
            if (FAILED(hres)) goto end;
            right = &tempRight;
        }
    }
 
    lvt = V_VT(left)&VT_TYPEMASK;
    rvt = V_VT(right)&VT_TYPEMASK;
 
    /* If we have any flag set (VT_ARRAY, VT_VECTOR, etc.) bail out.
       Same for any input variant type > VT_I8 */
    if (V_VT(left) & ~VT_TYPEMASK || V_VT(right) & ~VT_TYPEMASK ||
        lvt > VT_I8 || rvt > VT_I8) {
        hres = DISP_E_BADVARTYPE;
        goto end;
    }
 
    /* Determine the variant type to coerce to. */
    if (coerce[lvt] > coerce[rvt]) {
        resvt = prio2vt[coerce[lvt]];
        tvt = prio2vt[coerce[rvt]];
    } else {
        resvt = prio2vt[coerce[rvt]];
        tvt = prio2vt[coerce[lvt]];
    }
 
    /* Special cases where the result variant type is defined by both
       input variants and not only that with the highest priority */
    if (resvt == VT_BSTR) {
        if (tvt == VT_EMPTY || tvt == VT_BSTR)
            resvt = VT_BSTR;
        else
            resvt = VT_R8;
    }
    if (resvt == VT_R4 && (tvt == VT_BSTR || tvt == VT_I8 || tvt == VT_I4))
        resvt = VT_R8;
 
    /* For overflow detection use the biggest compatible type for the
       addition */
    switch (resvt) {
        case VT_ERROR:
            hres = DISP_E_BADVARTYPE;
            goto end;
        case VT_NULL:
            hres = S_OK;
            V_VT(result) = VT_NULL;
            goto end;
        case VT_DISPATCH:
            FIXME("cannot handle variant type VT_DISPATCH\n");
            hres = DISP_E_TYPEMISMATCH;
            goto end;
        case VT_EMPTY:
            resvt = VT_I2;
            /* Fall through */
        case VT_UI1:
        case VT_I2:
        case VT_I4:
        case VT_I8:
            tvt = VT_I8;
            break;
        case VT_DATE:
        case VT_R4:
            tvt = VT_R8;
            break;
        default:
            tvt = resvt;
    }
 
    /* Now coerce the variants */
    hres = VariantChangeType(&lv, left, 0, tvt);
    if (FAILED(hres))
        goto end;
    hres = VariantChangeType(&rv, right, 0, tvt);
    if (FAILED(hres))
        goto end;
 
    /* Do the math */
    hres = S_OK;
    V_VT(result) = resvt;
    switch (tvt) {
        case VT_DECIMAL:
            hres = VarDecAdd(&V_DECIMAL(&lv), &V_DECIMAL(&rv),
                             &V_DECIMAL(result));
            goto end;
        case VT_CY:
            hres = VarCyAdd(V_CY(&lv), V_CY(&rv), &V_CY(result));
            goto end;
        case VT_BSTR:
            /* We do not add those, we concatenate them. */
            hres = VarBstrCat(V_BSTR(&lv), V_BSTR(&rv), &V_BSTR(result));
            goto end;
        case VT_I8:
            /* Overflow detection */
            r8res = (double)V_I8(&lv) + (double)V_I8(&rv);
            if (r8res > (double)I8_MAX || r8res < (double)I8_MIN) {
                V_VT(result) = VT_R8;
                V_R8(result) = r8res;
                goto end;
            } else {
                V_VT(&tv) = tvt;
                V_I8(&tv) = V_I8(&lv) + V_I8(&rv);
            }
            break;
        case VT_R8:
            V_VT(&tv) = tvt;
            /* FIXME: overflow detection */
            V_R8(&tv) = V_R8(&lv) + V_R8(&rv);
            break;
        default:
            ERR("We shouldn't get here! tvt = %d!\n", tvt);
            break;
    }
    if (resvt != tvt) {
        if ((hres = VariantChangeType(result, &tv, 0, resvt)) != S_OK) {
            /* Overflow! Change to the vartype with the next higher priority.
               With one exception: I4 ==> R8 even if it would fit in I8 */
            if (resvt == VT_I4)
                resvt = VT_R8;
            else
                resvt = prio2vt[coerce[resvt] + 1];
            hres = VariantChangeType(result, &tv, 0, resvt);
        }
    } else
        hres = VariantCopy(result, &tv);
 
end:
    if (hres != S_OK) {
        V_VT(result) = VT_EMPTY;
        V_I4(result) = 0;       /* No V_EMPTY */
    }
    VariantClear(&lv);
    VariantClear(&rv);
    VariantClear(&tv);
    VariantClear(&tempLeft);
    VariantClear(&tempRight);
    TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
    return hres;
}

Referenced by interp_add(), interp_incc(), and test_VarAdd().

VarAnd()

HRESULT WINAPI VarAnd	(	LPVARIANT	left,
		LPVARIANT	right,
		LPVARIANT	result
	)

Definition at line 2893 of file variant.c.

{
    HRESULT hres = S_OK;
    VARTYPE resvt = VT_EMPTY;
    VARTYPE leftvt,rightvt;
    VARTYPE rightExtraFlags,leftExtraFlags,ExtraFlags;
    VARIANT varLeft, varRight;
    VARIANT tempLeft, tempRight;
 
    VariantInit(&varLeft);
    VariantInit(&varRight);
    VariantInit(&tempLeft);
    VariantInit(&tempRight);
 
    TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
 
    /* Handle VT_DISPATCH by storing and taking address of returned value */
    if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH)
    {
        hres = VARIANT_FetchDispatchValue(left, &tempLeft);
        if (FAILED(hres)) goto VarAnd_Exit;
        left = &tempLeft;
    }
    if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH)
    {
        hres = VARIANT_FetchDispatchValue(right, &tempRight);
        if (FAILED(hres)) goto VarAnd_Exit;
        right = &tempRight;
    }
 
    leftvt = V_VT(left)&VT_TYPEMASK;
    rightvt = V_VT(right)&VT_TYPEMASK;
    leftExtraFlags = V_VT(left)&(~VT_TYPEMASK);
    rightExtraFlags = V_VT(right)&(~VT_TYPEMASK);
 
    if (leftExtraFlags != rightExtraFlags)
    {
        hres = DISP_E_BADVARTYPE;
        goto VarAnd_Exit;
    }
    ExtraFlags = leftExtraFlags;
 
    /* Native VarAnd always returns an error when using extra
     * flags or if the variant combination is I8 and INT.
     */
    if ((leftvt == VT_I8 && rightvt == VT_INT) ||
        (leftvt == VT_INT && rightvt == VT_I8) ||
        ExtraFlags != 0)
    {
        hres = DISP_E_BADVARTYPE;
        goto VarAnd_Exit;
    }
 
    /* Determine return type */
    else if (leftvt == VT_I8 || rightvt == VT_I8)
        resvt = VT_I8;
    else if (leftvt == VT_I4 || rightvt == VT_I4 ||
        leftvt == VT_UINT || rightvt == VT_UINT ||
        leftvt == VT_INT || rightvt == VT_INT ||
        leftvt == VT_R4 || rightvt == VT_R4 ||
        leftvt == VT_R8 || rightvt == VT_R8 ||
        leftvt == VT_CY || rightvt == VT_CY ||
        leftvt == VT_DATE || rightvt == VT_DATE ||
        leftvt == VT_I1 || rightvt == VT_I1 ||
        leftvt == VT_UI2 || rightvt == VT_UI2 ||
        leftvt == VT_UI4 || rightvt == VT_UI4 ||
        leftvt == VT_UI8 || rightvt == VT_UI8 ||
        leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
        resvt = VT_I4;
    else if (leftvt == VT_UI1 || rightvt == VT_UI1 ||
        leftvt == VT_I2 || rightvt == VT_I2 ||
        leftvt == VT_EMPTY || rightvt == VT_EMPTY)
        if ((leftvt == VT_NULL && rightvt == VT_UI1) ||
            (leftvt == VT_UI1 && rightvt == VT_NULL) ||
            (leftvt == VT_UI1 && rightvt == VT_UI1))
            resvt = VT_UI1;
        else
            resvt = VT_I2;
    else if (leftvt == VT_BOOL || rightvt == VT_BOOL ||
        (leftvt == VT_BSTR && rightvt == VT_BSTR))
        resvt = VT_BOOL;
    else if (leftvt == VT_NULL || rightvt == VT_NULL ||
        leftvt == VT_BSTR || rightvt == VT_BSTR)
        resvt = VT_NULL;
    else
    {
        hres = DISP_E_BADVARTYPE;
        goto VarAnd_Exit;
    }
 
    if (leftvt == VT_NULL || rightvt == VT_NULL)
    {
        /*
         * Special cases for when left variant is VT_NULL
         * (VT_NULL & 0 = VT_NULL, VT_NULL & value = value)
         */
        if (leftvt == VT_NULL)
        {
            VARIANT_BOOL b;
            switch(rightvt)
            {
            case VT_I1:   if (V_I1(right)) resvt = VT_NULL; break;
            case VT_UI1:  if (V_UI1(right)) resvt = VT_NULL; break;
            case VT_I2:   if (V_I2(right)) resvt = VT_NULL; break;
            case VT_UI2:  if (V_UI2(right)) resvt = VT_NULL; break;
            case VT_I4:   if (V_I4(right)) resvt = VT_NULL; break;
            case VT_UI4:  if (V_UI4(right)) resvt = VT_NULL; break;
            case VT_I8:   if (V_I8(right)) resvt = VT_NULL; break;
            case VT_UI8:  if (V_UI8(right)) resvt = VT_NULL; break;
            case VT_INT:  if (V_INT(right)) resvt = VT_NULL; break;
            case VT_UINT: if (V_UINT(right)) resvt = VT_NULL; break;
            case VT_BOOL: if (V_BOOL(right)) resvt = VT_NULL; break;
            case VT_R4:   if (V_R4(right)) resvt = VT_NULL; break;
            case VT_R8:   if (V_R8(right)) resvt = VT_NULL; break;
            case VT_CY:
                if(V_CY(right).int64)
                    resvt = VT_NULL;
                break;
            case VT_DECIMAL:
                if (DEC_HI32(&V_DECIMAL(right)) ||
                    DEC_LO64(&V_DECIMAL(right)))
                    resvt = VT_NULL;
                break;
            case VT_BSTR:
                hres = VarBoolFromStr(V_BSTR(right),
                LOCALE_USER_DEFAULT, VAR_LOCALBOOL, &b);
                if (FAILED(hres))
                    return hres;
                else if (b)
                    V_VT(result) = VT_NULL;
                else
                {
                    V_VT(result) = VT_BOOL;
                    V_BOOL(result) = b;
                }
                goto VarAnd_Exit;
            }
        }
        V_VT(result) = resvt;
        goto VarAnd_Exit;
    }
 
    hres = VariantCopy(&varLeft, left);
    if (FAILED(hres)) goto VarAnd_Exit;
 
    hres = VariantCopy(&varRight, right);
    if (FAILED(hres)) goto VarAnd_Exit;
 
    if (resvt == VT_I4 && V_VT(&varLeft) == VT_UI4)
        V_VT(&varLeft) = VT_I4; /* Don't overflow */
    else
    {
        double d;
 
        if (V_VT(&varLeft) == VT_BSTR &&
            FAILED(VarR8FromStr(V_BSTR(&varLeft),
            LOCALE_USER_DEFAULT, 0, &d)))
            hres = VariantChangeType(&varLeft,&varLeft,
            VARIANT_LOCALBOOL, VT_BOOL);
        if (SUCCEEDED(hres) && V_VT(&varLeft) != resvt)
            hres = VariantChangeType(&varLeft,&varLeft,0,resvt);
        if (FAILED(hres)) goto VarAnd_Exit;
    }
 
    if (resvt == VT_I4 && V_VT(&varRight) == VT_UI4)
        V_VT(&varRight) = VT_I4; /* Don't overflow */
    else
    {
        double d;
 
        if (V_VT(&varRight) == VT_BSTR &&
            FAILED(VarR8FromStr(V_BSTR(&varRight),
            LOCALE_USER_DEFAULT, 0, &d)))
            hres = VariantChangeType(&varRight, &varRight,
                VARIANT_LOCALBOOL, VT_BOOL);
        if (SUCCEEDED(hres) && V_VT(&varRight) != resvt)
            hres = VariantChangeType(&varRight, &varRight, 0, resvt);
        if (FAILED(hres)) goto VarAnd_Exit;
    }
 
    V_VT(result) = resvt;
    switch(resvt)
    {
    case VT_I8:
        V_I8(result) = V_I8(&varLeft) & V_I8(&varRight);
        break;
    case VT_I4:
        V_I4(result) = V_I4(&varLeft) & V_I4(&varRight);
        break;
    case VT_I2:
        V_I2(result) = V_I2(&varLeft) & V_I2(&varRight);
        break;
    case VT_UI1:
        V_UI1(result) = V_UI1(&varLeft) & V_UI1(&varRight);
        break;
    case VT_BOOL:
        V_BOOL(result) = V_BOOL(&varLeft) & V_BOOL(&varRight);
        break;
    default:
        FIXME("Couldn't bitwise AND variant types %d,%d\n",
            leftvt,rightvt);
    }
 
VarAnd_Exit:
    VariantClear(&varLeft);
    VariantClear(&varRight);
    VariantClear(&tempLeft);
    VariantClear(&tempRight);
 
    return hres;
}

Referenced by interp_and(), and test_VarAnd().

VarCat()

HRESULT WINAPI VarCat	(	LPVARIANT	left,
		LPVARIANT	right,
		LPVARIANT	out
	)

Definition at line 2515 of file variant.c.

{
    BSTR left_str = NULL, right_str = NULL;
    VARTYPE leftvt, rightvt;
    HRESULT hres;
 
    TRACE("%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), out);
 
    leftvt = V_VT(left);
    rightvt = V_VT(right);
 
    /* when both left and right are NULL the result is NULL */
    if (leftvt == VT_NULL && rightvt == VT_NULL)
    {
        V_VT(out) = VT_NULL;
        return S_OK;
    }
 
    /* There are many special case for errors and return types */
    if (leftvt == VT_VARIANT && (rightvt == VT_ERROR ||
        rightvt == VT_DATE || rightvt == VT_DECIMAL))
        hres = DISP_E_TYPEMISMATCH;
    else if ((leftvt == VT_I2 || leftvt == VT_I4 ||
        leftvt == VT_R4 || leftvt == VT_R8 ||
        leftvt == VT_CY || leftvt == VT_BOOL ||
        leftvt == VT_BSTR || leftvt == VT_I1 ||
        leftvt == VT_UI1 || leftvt == VT_UI2 ||
        leftvt == VT_UI4 || leftvt == VT_I8 ||
        leftvt == VT_UI8 || leftvt == VT_INT ||
        leftvt == VT_UINT || leftvt == VT_EMPTY ||
        leftvt == VT_NULL || leftvt == VT_DATE ||
        leftvt == VT_DECIMAL || leftvt == VT_DISPATCH)
        &&
        (rightvt == VT_I2 || rightvt == VT_I4 ||
        rightvt == VT_R4 || rightvt == VT_R8 ||
        rightvt == VT_CY || rightvt == VT_BOOL ||
        rightvt == VT_BSTR || rightvt == VT_I1 ||
        rightvt == VT_UI1 || rightvt == VT_UI2 ||
        rightvt == VT_UI4 || rightvt == VT_I8 ||
        rightvt == VT_UI8 || rightvt == VT_INT ||
        rightvt == VT_UINT || rightvt == VT_EMPTY ||
        rightvt == VT_NULL || rightvt == VT_DATE ||
        rightvt == VT_DECIMAL || rightvt == VT_DISPATCH))
        hres = S_OK;
    else if (rightvt == VT_ERROR && leftvt < VT_VOID)
        hres = DISP_E_TYPEMISMATCH;
    else if (leftvt == VT_ERROR && (rightvt == VT_DATE ||
        rightvt == VT_ERROR || rightvt == VT_DECIMAL))
        hres = DISP_E_TYPEMISMATCH;
    else if (rightvt == VT_DATE || rightvt == VT_ERROR ||
        rightvt == VT_DECIMAL)
        hres = DISP_E_BADVARTYPE;
    else if (leftvt == VT_ERROR || rightvt == VT_ERROR)
        hres = DISP_E_TYPEMISMATCH;
    else if (leftvt == VT_VARIANT)
        hres = DISP_E_TYPEMISMATCH;
    else if (rightvt == VT_VARIANT && (leftvt == VT_EMPTY ||
        leftvt == VT_NULL || leftvt ==  VT_I2 ||
        leftvt == VT_I4 || leftvt == VT_R4 ||
        leftvt == VT_R8 || leftvt == VT_CY ||
        leftvt == VT_DATE || leftvt == VT_BSTR ||
        leftvt == VT_BOOL ||  leftvt == VT_DECIMAL ||
        leftvt == VT_I1 || leftvt == VT_UI1 ||
        leftvt == VT_UI2 || leftvt == VT_UI4 ||
        leftvt == VT_I8 || leftvt == VT_UI8 ||
        leftvt == VT_INT || leftvt == VT_UINT))
        hres = DISP_E_TYPEMISMATCH;
    else
        hres = DISP_E_BADVARTYPE;
 
    /* if result type is not S_OK, then no need to go further */
    if (hres != S_OK)
    {
        V_VT(out) = VT_EMPTY;
        return hres;
    }
 
    if (leftvt == VT_BSTR)
        left_str = V_BSTR(left);
    else
    {
        VARIANT converted, *tmp = left;
 
        VariantInit(&converted);
        if(leftvt == VT_DISPATCH)
        {
            hres = VARIANT_FetchDispatchValue(left, &converted);
            if(FAILED(hres))
                goto failed;
 
            tmp = &converted;
        }
 
        hres = VariantChangeTypeEx(&converted, tmp, 0, VARIANT_ALPHABOOL|VARIANT_LOCALBOOL, VT_BSTR);
        if (SUCCEEDED(hres))
            left_str = V_BSTR(&converted);
        else if (hres != DISP_E_TYPEMISMATCH)
        {
            VariantClear(&converted);
            goto failed;
        }
    }
 
    if (rightvt == VT_BSTR)
        right_str = V_BSTR(right);
    else
    {
        VARIANT converted, *tmp = right;
 
        VariantInit(&converted);
        if(rightvt == VT_DISPATCH)
        {
            hres = VARIANT_FetchDispatchValue(right, &converted);
            if(FAILED(hres))
                goto failed;
 
            tmp = &converted;
        }
 
        hres = VariantChangeTypeEx(&converted, tmp, 0, VARIANT_ALPHABOOL|VARIANT_LOCALBOOL, VT_BSTR);
        if (SUCCEEDED(hres))
            right_str = V_BSTR(&converted);
        else if (hres != DISP_E_TYPEMISMATCH)
        {
            VariantClear(&converted);
            goto failed;
        }
    }
 
 
    V_VT(out) = VT_BSTR;
    hres = VarBstrCat(left_str, right_str, &V_BSTR(out));
 
failed:
    if(V_VT(left) != VT_BSTR)
        SysFreeString(left_str);
    if(V_VT(right) != VT_BSTR)
        SysFreeString(right_str);
    return hres;
}

Referenced by interp_concat(), and test_VarCat().

VarCmp()

HRESULT WINAPI VarCmp	(	LPVARIANT	left,
		LPVARIANT	right,
		LCID	lcid,
		DWORD	flags
	)

Definition at line 2712 of file variant.c.

{
    VARTYPE     lvt, rvt, vt;
    VARIANT     rv,lv;
    DWORD       xmask;
    HRESULT     rc;
 
    TRACE("(%s,%s,0x%08x,0x%08x)\n", debugstr_variant(left), debugstr_variant(right), lcid, flags);
 
    lvt = V_VT(left) & VT_TYPEMASK;
    rvt = V_VT(right) & VT_TYPEMASK;
    xmask = (1 << lvt) | (1 << rvt);
 
    /* If we have any flag set except VT_RESERVED bail out.
       Same for the left input variant type > VT_INT and for the
       right input variant type > VT_I8. Yes, VT_INT is only supported
       as left variant. Go figure */
    if (((V_VT(left) | V_VT(right)) & ~VT_TYPEMASK & ~VT_RESERVED) ||
            lvt > VT_INT || rvt > VT_I8) {
        return DISP_E_BADVARTYPE;
    }
 
    /* Don't ask me why but native VarCmp cannot handle: VT_I1, VT_UI2, VT_UI4,
       VT_UINT and VT_UI8. Tested with DCOM98, Win2k, WinXP */
    if (rvt == VT_INT || xmask & (VTBIT_I1 | VTBIT_UI2 | VTBIT_UI4 | VTBIT_UI8 |
                VTBIT_DISPATCH | VTBIT_VARIANT | VTBIT_UNKNOWN | VTBIT_15))
        return DISP_E_TYPEMISMATCH;
 
    /* If both variants are VT_ERROR return VARCMP_EQ */
    if (xmask == VTBIT_ERROR)
        return VARCMP_EQ;
    else if (xmask & VTBIT_ERROR)
        return DISP_E_TYPEMISMATCH;
 
    if (xmask & VTBIT_NULL)
        return VARCMP_NULL;
 
    VariantInit(&lv);
    VariantInit(&rv);
 
    /* Two BSTRs, ignore VT_RESERVED */
    if (xmask == VTBIT_BSTR)
        return VarBstrCmp(V_BSTR(left), V_BSTR(right), lcid, flags);
 
    /* A BSTR and another variant; we have to take care of VT_RESERVED */
    if (xmask & VTBIT_BSTR) {
        VARIANT *bstrv, *nonbv;
        VARTYPE nonbvt;
        int swap = 0;
 
        /* Swap the variants so the BSTR is always on the left */
        if (lvt == VT_BSTR) {
            bstrv = left;
            nonbv = right;
            nonbvt = rvt;
        } else {
            swap = 1;
            bstrv = right;
            nonbv = left;
            nonbvt = lvt;
        }
 
        /* BSTR and EMPTY: ignore VT_RESERVED */
        if (nonbvt == VT_EMPTY)
            rc = (!V_BSTR(bstrv) || !*V_BSTR(bstrv)) ? VARCMP_EQ : VARCMP_GT;
        else {
            VARTYPE breserv = V_VT(bstrv) & ~VT_TYPEMASK;
            VARTYPE nreserv = V_VT(nonbv) & ~VT_TYPEMASK;
 
            if (!breserv && !nreserv) 
                /* No VT_RESERVED set ==> BSTR always greater */
                rc = VARCMP_GT;
            else if (breserv && !nreserv) {
                /* BSTR has VT_RESERVED set. Do a string comparison */
                rc = VariantChangeTypeEx(&rv,nonbv,lcid,0,VT_BSTR);
                if (FAILED(rc))
                    return rc;
                rc = VarBstrCmp(V_BSTR(bstrv), V_BSTR(&rv), lcid, flags);
                VariantClear(&rv);
            } else if (V_BSTR(bstrv) && *V_BSTR(bstrv)) {
            /* Non NULL nor empty BSTR */
                /* If the BSTR is not a number the BSTR is greater */
                rc = _VarChangeTypeExWrap(&lv,bstrv,lcid,0,VT_R8);
                if (FAILED(rc))
                    rc = VARCMP_GT;
                else if (breserv && nreserv)
                    /* FIXME: This is strange: with both VT_RESERVED set it
                       looks like the result depends only on the sign of
                       the BSTR number */
                    rc = (V_R8(&lv) >= 0) ? VARCMP_GT : VARCMP_LT;
                else
                    /* Numeric comparison, will be handled below.
                       VARCMP_NULL used only to break out. */
                    rc = VARCMP_NULL;
                VariantClear(&lv);
                VariantClear(&rv);
            } else
                /* Empty or NULL BSTR */
                rc = VARCMP_GT;
        }
        /* Fixup the return code if we swapped left and right */
        if (swap) {
            if (rc == VARCMP_GT)
                rc = VARCMP_LT;
            else if (rc == VARCMP_LT)
                rc = VARCMP_GT;
        }
        if (rc != VARCMP_NULL)
            return rc;
    }
 
    if (xmask & VTBIT_DECIMAL)
        vt = VT_DECIMAL;
    else if (xmask & VTBIT_BSTR)
        vt = VT_R8;
    else if (xmask & VTBIT_R4)
        vt = VT_R4;
    else if (xmask & (VTBIT_R8 | VTBIT_DATE))
        vt = VT_R8;
    else if (xmask & VTBIT_CY)
        vt = VT_CY;
    else
        /* default to I8 */
        vt = VT_I8;
 
    /* Coerce the variants */
    rc = _VarChangeTypeExWrap(&lv,left,lcid,0,vt);
    if (rc == DISP_E_OVERFLOW && vt != VT_R8) {
        /* Overflow, change to R8 */
        vt = VT_R8;
        rc = _VarChangeTypeExWrap(&lv,left,lcid,0,vt);
    }
    if (FAILED(rc))
        return rc;
    rc = _VarChangeTypeExWrap(&rv,right,lcid,0,vt);
    if (rc == DISP_E_OVERFLOW && vt != VT_R8) {
        /* Overflow, change to R8 */
        vt = VT_R8;
        rc = _VarChangeTypeExWrap(&lv,left,lcid,0,vt);
        if (FAILED(rc))
            return rc;
        rc = _VarChangeTypeExWrap(&rv,right,lcid,0,vt);
    }
    if (FAILED(rc))
        return rc;
 
#define _VARCMP(a,b) \
    (((a) == (b)) ? VARCMP_EQ : (((a) < (b)) ? VARCMP_LT : VARCMP_GT))
 
    switch (vt) {
        case VT_CY:
            return VarCyCmp(V_CY(&lv), V_CY(&rv));
        case VT_DECIMAL:
            return VarDecCmp(&V_DECIMAL(&lv), &V_DECIMAL(&rv));
        case VT_I8:
            return _VARCMP(V_I8(&lv), V_I8(&rv));
        case VT_R4:
            return _VARCMP(V_R4(&lv), V_R4(&rv));
        case VT_R8:
            return _VARCMP(V_R8(&lv), V_R8(&rv));
        default:
            /* We should never get here */
            return E_FAIL;
    }
#undef _VARCMP
}

Referenced by interp_step(), submit_onclick_setret(), test_cmp(), test_VarCmp(), and var_cmp().

VarDateFromUdate()

HRESULT WINAPI VarDateFromUdate	(	UDATE *	pUdateIn,
		ULONG	dwFlags,
		DATE *	pDateOut
	)

Definition at line 1406 of file variant.c.

{
  LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
  
  return VarDateFromUdateEx(pUdateIn, lcid, dwFlags, pDateOut);
}

Referenced by DosDateTimeToVariantTime(), SystemTimeToVariantTime(), and test_VarDateFromUdate().

VarDateFromUdateEx()

HRESULT WINAPI VarDateFromUdateEx	(	UDATE *	pUdateIn,
		LCID	lcid,
		ULONG	dwFlags,
		DATE *	pDateOut
	)

Definition at line 1345 of file variant.c.

{
  UDATE ud;
  double dateVal = 0;
 
  TRACE("(%p->%d/%d/%d %d:%d:%d:%d %d %d,0x%08x,0x%08x,%p)\n", pUdateIn,
        pUdateIn->st.wMonth, pUdateIn->st.wDay, pUdateIn->st.wYear,
        pUdateIn->st.wHour, pUdateIn->st.wMinute, pUdateIn->st.wSecond,
        pUdateIn->st.wMilliseconds, pUdateIn->st.wDayOfWeek,
        pUdateIn->wDayOfYear, lcid, dwFlags, pDateOut);
 
  if (lcid != MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT))
    FIXME("lcid possibly not handled, treating as en-us\n");
  if (dwFlags & ~(VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY))
    FIXME("unsupported flags: %x\n", dwFlags);
 
  ud = *pUdateIn;
 
  if (dwFlags & VAR_VALIDDATE)
    WARN("Ignoring VAR_VALIDDATE\n");
 
  if (FAILED(VARIANT_RollUdate(&ud)))
    return E_INVALIDARG;
 
  /* Date */
  if (!(dwFlags & VAR_TIMEVALUEONLY))
    dateVal = VARIANT_DateFromJulian(VARIANT_JulianFromDMY(ud.st.wYear, ud.st.wMonth, ud.st.wDay));
 
  if ((dwFlags & VAR_TIMEVALUEONLY) || !(dwFlags & VAR_DATEVALUEONLY))
  {
    double dateSign = (dateVal < 0.0) ? -1.0 : 1.0;
 
    /* Time */
    dateVal += ud.st.wHour / 24.0 * dateSign;
    dateVal += ud.st.wMinute / 1440.0 * dateSign;
    dateVal += ud.st.wSecond / 86400.0 * dateSign;
  }
 
  TRACE("Returning %g\n", dateVal);
  *pDateOut = dateVal;
  return S_OK;
}

Referenced by Global_Date(), Global_Time(), and VarDateFromUdate().

VarDiv()

HRESULT WINAPI VarDiv	(	LPVARIANT	left,
		LPVARIANT	right,
		LPVARIANT	result
	)

Definition at line 3521 of file variant.c.

{
    HRESULT hres = S_OK;
    VARTYPE resvt = VT_EMPTY;
    VARTYPE leftvt,rightvt;
    VARTYPE rightExtraFlags,leftExtraFlags,ExtraFlags;
    VARIANT lv,rv;
    VARIANT tempLeft, tempRight;
 
    VariantInit(&tempLeft);
    VariantInit(&tempRight);
    VariantInit(&lv);
    VariantInit(&rv);
 
    TRACE("(%s,%s,%p)\n", debugstr_variant(left), debugstr_variant(right), result);
 
    /* Handle VT_DISPATCH by storing and taking address of returned value */
    if ((V_VT(left) & VT_TYPEMASK) == VT_DISPATCH)
    {
        hres = VARIANT_FetchDispatchValue(left, &tempLeft);
        if (FAILED(hres)) goto end;
        left = &tempLeft;
    }
    if ((V_VT(right) & VT_TYPEMASK) == VT_DISPATCH)
    {
        hres = VARIANT_FetchDispatchValue(right, &tempRight);
        if (FAILED(hres)) goto end;
        right = &tempRight;
    }
 
    leftvt = V_VT(left)&VT_TYPEMASK;
    rightvt = V_VT(right)&VT_TYPEMASK;
    leftExtraFlags = V_VT(left)&(~VT_TYPEMASK);
    rightExtraFlags = V_VT(right)&(~VT_TYPEMASK);
 
    if (leftExtraFlags != rightExtraFlags)
    {
        hres = DISP_E_BADVARTYPE;
        goto end;
    }
    ExtraFlags = leftExtraFlags;
 
    /* Native VarDiv always returns an error when using extra flags */
    if (ExtraFlags != 0)
    {
        hres = DISP_E_BADVARTYPE;
        goto end;
    }
 
    /* Determine return type */
    if (rightvt != VT_EMPTY)
    {
        if (leftvt == VT_NULL || rightvt == VT_NULL)
        {
            V_VT(result) = VT_NULL;
            hres = S_OK;
            goto end;
        }
        else if (leftvt == VT_DECIMAL || rightvt == VT_DECIMAL)
            resvt = VT_DECIMAL;
        else if (leftvt == VT_I8 || rightvt == VT_I8 ||
            leftvt == VT_CY || rightvt == VT_CY ||
            leftvt == VT_DATE || rightvt == VT_DATE ||
            leftvt == VT_I4 || rightvt == VT_I4 ||
            leftvt == VT_BSTR || rightvt == VT_BSTR ||
            leftvt == VT_I2 || rightvt == VT_I2 ||
            leftvt == VT_BOOL || rightvt == VT_BOOL ||
            leftvt == VT_R8 || rightvt == VT_R8 ||
            leftvt == VT_UI1 || rightvt == VT_UI1)
        {
            if ((leftvt == VT_UI1 && rightvt == VT_R4) ||
                (leftvt == VT_R4 && rightvt == VT_UI1))
                resvt = VT_R4;
            else if ((leftvt == VT_R4 && (rightvt == VT_BOOL ||
                rightvt == VT_I2)) || (rightvt == VT_R4 &&
                (leftvt == VT_BOOL || leftvt == VT_I2)))
                resvt = VT_R4;
            else
                resvt = VT_R8;
        }
        else if (leftvt == VT_R4 || rightvt == VT_R4)
            resvt = VT_R4;
    }
    else if (leftvt == VT_NULL)
    {
        V_VT(result) = VT_NULL;
        hres = S_OK;
        goto end;
    }
    else
    {
        hres = DISP_E_BADVARTYPE;
        goto end;
    }
 
    /* coerce to the result type */
    hres = VariantChangeType(&lv, left, 0, resvt);
    if (hres != S_OK) goto end;
 
    hres = VariantChangeType(&rv, right, 0, resvt);
    if (hres != S_OK) goto end;
 
    /* do the math */
    V_VT(result) = resvt;
    switch (resvt)
    {
    case VT_R4:
    if (V_R4(&lv) == 0.0 && V_R4(&rv) == 0.0)
    {
        hres = DISP_E_OVERFLOW;
        V_VT(result) = VT_EMPTY;
    }
    else if (V_R4(&rv) == 0.0)
    {
        hres = DISP_E_DIVBYZERO;
        V_VT(result) = VT_EMPTY;
    }
    else
        V_R4(result) = V_R4(&lv) / V_R4(&rv);
    break;
    case VT_R8:
    if (V_R8(&lv) == 0.0 && V_R8(&rv) == 0.0)
    {
        hres = DISP_E_OVERFLOW;
        V_VT(result) = VT_EMPTY;
    }
    else if (V_R8(&rv) == 0.0)
    {
        hres = DISP_E_DIVBYZERO;
        V_VT(result) = VT_EMPTY;
    }
    else
        V_R8(result) = V_R8(&lv) / V_R8(&rv);
    break;
    case VT_DECIMAL:
    hres = VarDecDiv(&(V_DECIMAL(&lv)), &(V_DECIMAL(&rv)), &(V_DECIMAL(result)));
    break;
    }
 
end:
    VariantClear(&lv);
    VariantClear(&rv);
    VariantClear(&tempLeft);
    VariantClear(&tempRight);
    TRACE("returning 0x%8x %s\n", hres, debugstr_variant(result));
    return hres;
}

Referenced by interp_div(), and test_VarDiv().

VarEqv()

HRESULT WINAPI VarEqv	(	LPVARIANT	pVarLeft,
		LPVARIANT	pVarRight,
		LPVARIANT	pVarOut
	)

Definition at line 4727 of file variant.c.

{
    HRESULT hRet;
 
    TRACE("(%s,%s,%p)\n", debugstr_variant(pVarLeft), debugstr_variant(pVarRight), pVarOut);
 
    hRet = VarXor(pVarLeft, pVarRight, pVarOut);
    if (SUCCEEDED(hRet))
    {
        if (V_VT(pVarOut) == VT_I8)
            V_I8(pVarOut) = ~V_I8(pVarOut);
        else
            V_UI4(pVarOut) = ~V_UI4(pVarOut);
    }
    return hRet;
}

Referenced by interp_eqv(), and test_VarEqv().

VarFix()

HRESULT WINAPI VarFix	(	LPVARIANT	pVarIn,
		LPVARIANT	pVarOut
	)

Definition at line 4367 of file variant.c.

{
    HRESULT hRet = S_OK;
    VARIANT temp;
 
    VariantInit(&temp);
 
    TRACE("(%s,%p)\n", debugstr_variant(pVarIn), pVarOut);
 
    /* Handle VT_DISPATCH by storing and taking address of returned value */
    if ((V_VT(pVarIn) & VT_TYPEMASK) == VT_DISPATCH && ((V_VT(pVarIn) & ~VT_TYPEMASK) == 0))
    {
        hRet = VARIANT_FetchDispatchValue(pVarIn, &temp);
        if (FAILED(hRet)) goto VarFix_Exit;
        pVarIn = &temp;
    }
    V_VT(pVarOut) = V_VT(pVarIn);
 
    switch (V_VT(pVarIn))
    {
    case VT_UI1:
        V_UI1(pVarOut) = V_UI1(pVarIn);
        break;
    case VT_BOOL:
        V_VT(pVarOut) = VT_I2;
        /* Fall through */
     case VT_I2:
        V_I2(pVarOut) = V_I2(pVarIn);
        break;
     case VT_I4:
        V_I4(pVarOut) = V_I4(pVarIn);
        break;
     case VT_I8:
        V_I8(pVarOut) = V_I8(pVarIn);
        break;
    case VT_R4:
        if (V_R4(pVarIn) < 0.0f)
            V_R4(pVarOut) = (float)ceil(V_R4(pVarIn));
        else
            V_R4(pVarOut) = (float)floor(V_R4(pVarIn));
        break;
    case VT_BSTR:
        V_VT(pVarOut) = VT_R8;
        hRet = VarR8FromStr(V_BSTR(pVarIn), LOCALE_USER_DEFAULT, 0, &V_R8(pVarOut));
        pVarIn = pVarOut;
        /* Fall through */
    case VT_DATE:
    case VT_R8:
        if (V_R8(pVarIn) < 0.0)
            V_R8(pVarOut) = ceil(V_R8(pVarIn));
        else
            V_R8(pVarOut) = floor(V_R8(pVarIn));
        break;
    case VT_CY:
        hRet = VarCyFix(V_CY(pVarIn), &V_CY(pVarOut));
        break;
    case VT_DECIMAL:
        hRet = VarDecFix(&V_DECIMAL(pVarIn), &V_DECIMAL(pVarOut));
        break;
    case VT_EMPTY:
        V_VT(pVarOut) = VT_I2;
        V_I2(pVarOut) = 0;
        break;
    case VT_NULL:
        /* No-Op */
        break;
    default:
        if (V_TYPE(pVarIn) == VT_CLSID || /* VT_CLSID is a special case */
            FAILED(VARIANT_ValidateType(V_VT(pVarIn))))
            hRet = DISP_E_BADVARTYPE;
        else
            hRet = DISP_E_TYPEMISMATCH;
    }
VarFix_Exit:
    if (FAILED(hRet))
      V_VT(pVarOut) = VT_EMPTY;
    VariantClear(&temp);
 
    return hRet;
}

Referenced by Global_Fix(), test_VarFix(), and VarInt().

VARIANT_ClearInd()

HRESULT VARIANT_ClearInd

(

VARIANTARG *

pVarg

)

Definition at line 576 of file variant.c.

{
    HRESULT hres;
 
    TRACE("(%s)\n", debugstr_variant(pVarg));
 
    hres = VARIANT_ValidateType(V_VT(pVarg));
    if (FAILED(hres))
        return hres;
 
    switch (V_VT(pVarg))
    {
    case VT_DISPATCH:
    case VT_UNKNOWN:
        if (V_UNKNOWN(pVarg))
            IUnknown_Release(V_UNKNOWN(pVarg));
        break;
    case VT_UNKNOWN | VT_BYREF:
    case VT_DISPATCH | VT_BYREF:
        if(*V_UNKNOWNREF(pVarg))
            IUnknown_Release(*V_UNKNOWNREF(pVarg));
        break;
    case VT_BSTR:
        SysFreeString(V_BSTR(pVarg));
        break;
    case VT_BSTR | VT_BYREF:
        SysFreeString(*V_BSTRREF(pVarg));
        break;
    case VT_VARIANT | VT_BYREF:
        VariantClear(V_VARIANTREF(pVarg));
        break;
    case VT_RECORD:
    case VT_RECORD | VT_BYREF:
    {
        struct __tagBRECORD* pBr = &V_UNION(pVarg,brecVal);
        if (pBr->pRecInfo)
        {
            IRecordInfo_RecordClear(pBr->pRecInfo, pBr->pvRecord);
            IRecordInfo_Release(pBr->pRecInfo);
        }
        break;
    }
    default:
        if (V_ISARRAY(pVarg) || (V_VT(pVarg) & ~VT_BYREF) == VT_SAFEARRAY)
        {
            if (V_ISBYREF(pVarg))
            {
                if (*V_ARRAYREF(pVarg))
                    hres = SafeArrayDestroy(*V_ARRAYREF(pVarg));
            }
            else if (V_ARRAY(pVarg))
                hres = SafeArrayDestroy(V_ARRAY(pVarg));
        }
        break;
    }
 
    V_VT(pVarg) = VT_EMPTY;
    return hres;
}

Referenced by ITypeInfo_fnInvoke().

VARIANT_Coerce()

static HRESULT VARIANT_Coerce ( VARIANTARG *  pd, LCID  lcid, USHORT  wFlags, VARIANTARG *  ps, VARTYPE  vt  )

inlinestatic

Definition at line 55 of file variant.c.

{
  HRESULT res = DISP_E_TYPEMISMATCH;
  VARTYPE vtFrom =  V_TYPE(ps);
  DWORD dwFlags = 0;
 
  TRACE("(%s,0x%08x,0x%04x,%s,%s)\n", debugstr_variant(pd), lcid, wFlags,
        debugstr_variant(ps), debugstr_vt(vt));
 
  if (vt == VT_BSTR || vtFrom == VT_BSTR)
  {
    /* All flags passed to low level function are only used for
     * changing to or from strings. Map these here.
     */
    if (wFlags & VARIANT_LOCALBOOL)
      dwFlags |= VAR_LOCALBOOL;
    if (wFlags & VARIANT_CALENDAR_HIJRI)
      dwFlags |= VAR_CALENDAR_HIJRI;
    if (wFlags & VARIANT_CALENDAR_THAI)
      dwFlags |= VAR_CALENDAR_THAI;
    if (wFlags & VARIANT_CALENDAR_GREGORIAN)
      dwFlags |= VAR_CALENDAR_GREGORIAN;
    if (wFlags & VARIANT_NOUSEROVERRIDE)
      dwFlags |= LOCALE_NOUSEROVERRIDE;
    if (wFlags & VARIANT_USE_NLS)
      dwFlags |= LOCALE_USE_NLS;
  }
 
  /* Map int/uint to i4/ui4 */
  if (vt == VT_INT)
    vt = VT_I4;
  else if (vt == VT_UINT)
    vt = VT_UI4;
 
  if (vtFrom == VT_INT)
    vtFrom = VT_I4;
  else if (vtFrom == VT_UINT)
    vtFrom = VT_UI4;
 
  if (vt == vtFrom)
     return VariantCopy(pd, ps);
 
  if (wFlags & VARIANT_NOVALUEPROP && vtFrom == VT_DISPATCH && vt != VT_UNKNOWN)
  {
    /* VARIANT_NOVALUEPROP prevents IDispatch objects from being coerced by
     * accessing the default object property.
     */
    return DISP_E_TYPEMISMATCH;
  }
 
  switch (vt)
  {
  case VT_EMPTY:
    if (vtFrom == VT_NULL)
      return DISP_E_TYPEMISMATCH;
    /* ... Fall through */
  case VT_NULL:
    if (vtFrom <= VT_UINT && vtFrom != (VARTYPE)15 && vtFrom != VT_ERROR)
    {
      res = VariantClear( pd );
      if (vt == VT_NULL && SUCCEEDED(res))
        V_VT(pd) = VT_NULL;
    }
    return res;
 
  case VT_I1:
    switch (vtFrom)
    {
    case VT_EMPTY:    V_I1(pd) = 0; return S_OK;
    case VT_I2:       return VarI1FromI2(V_I2(ps), &V_I1(pd));
    case VT_I4:       return VarI1FromI4(V_I4(ps), &V_I1(pd));
    case VT_UI1:      V_I1(pd) = V_UI1(ps); return S_OK;
    case VT_UI2:      return VarI1FromUI2(V_UI2(ps), &V_I1(pd));
    case VT_UI4:      return VarI1FromUI4(V_UI4(ps), &V_I1(pd));
    case VT_I8:       return VarI1FromI8(V_I8(ps), &V_I1(pd));
    case VT_UI8:      return VarI1FromUI8(V_UI8(ps), &V_I1(pd));
    case VT_R4:       return VarI1FromR4(V_R4(ps), &V_I1(pd));
    case VT_R8:       return VarI1FromR8(V_R8(ps), &V_I1(pd));
    case VT_DATE:     return VarI1FromDate(V_DATE(ps), &V_I1(pd));
    case VT_BOOL:     return VarI1FromBool(V_BOOL(ps), &V_I1(pd));
    case VT_CY:       return VarI1FromCy(V_CY(ps), &V_I1(pd));
    case VT_DECIMAL:  return VarI1FromDec(&V_DECIMAL(ps), &V_I1(pd) );
    case VT_DISPATCH: return VarI1FromDisp(V_DISPATCH(ps), lcid, &V_I1(pd) );
    case VT_BSTR:     return VarI1FromStr(V_BSTR(ps), lcid, dwFlags, &V_I1(pd) );
    }
    break;
 
  case VT_I2:
    switch (vtFrom)
    {
    case VT_EMPTY:    V_I2(pd) = 0; return S_OK;
    case VT_I1:       return VarI2FromI1(V_I1(ps), &V_I2(pd));
    case VT_I4:       return VarI2FromI4(V_I4(ps), &V_I2(pd));
    case VT_UI1:      return VarI2FromUI1(V_UI1(ps), &V_I2(pd));
    case VT_UI2:      V_I2(pd) = V_UI2(ps); return S_OK;
    case VT_UI4:      return VarI2FromUI4(V_UI4(ps), &V_I2(pd));
    case VT_I8:       return VarI2FromI8(V_I8(ps), &V_I2(pd));
    case VT_UI8:      return VarI2FromUI8(V_UI8(ps), &V_I2(pd));
    case VT_R4:       return VarI2FromR4(V_R4(ps), &V_I2(pd));
    case VT_R8:       return VarI2FromR8(V_R8(ps), &V_I2(pd));
    case VT_DATE:     return VarI2FromDate(V_DATE(ps), &V_I2(pd));
    case VT_BOOL:     return VarI2FromBool(V_BOOL(ps), &V_I2(pd));
    case VT_CY:       return VarI2FromCy(V_CY(ps), &V_I2(pd));
    case VT_DECIMAL:  return VarI2FromDec(&V_DECIMAL(ps), &V_I2(pd));
    case VT_DISPATCH: return VarI2FromDisp(V_DISPATCH(ps), lcid, &V_I2(pd));
    case VT_BSTR:     return VarI2FromStr(V_BSTR(ps), lcid, dwFlags, &V_I2(pd));
    }
    break;
 
  case VT_I4:
    switch (vtFrom)
    {
    case VT_EMPTY:    V_I4(pd) = 0; return S_OK;
    case VT_I1:       return VarI4FromI1(V_I1(ps), &V_I4(pd));
    case VT_I2:       return VarI4FromI2(V_I2(ps), &V_I4(pd));
    case VT_UI1:      return VarI4FromUI1(V_UI1(ps), &V_I4(pd));
    case VT_UI2:      return VarI4FromUI2(V_UI2(ps), &V_I4(pd));
    case VT_UI4:      V_I4(pd) = V_UI4(ps); return S_OK;
    case VT_I8:       return VarI4FromI8(V_I8(ps), &V_I4(pd));
    case VT_UI8:      return VarI4FromUI8(V_UI8(ps), &V_I4(pd));
    case VT_R4:       return VarI4FromR4(V_R4(ps), &V_I4(pd));
    case VT_R8:       return VarI4FromR8(V_R8(ps), &V_I4(pd));
    case VT_DATE:     return VarI4FromDate(V_DATE(ps), &V_I4(pd));
    case VT_BOOL:     return VarI4FromBool(V_BOOL(ps), &V_I4(pd));
    case VT_CY:       return VarI4FromCy(V_CY(ps), &V_I4(pd));
    case VT_DECIMAL:  return VarI4FromDec(&V_DECIMAL(ps), &V_I4(pd));
    case VT_DISPATCH: return VarI4FromDisp(V_DISPATCH(ps), lcid, &V_I4(pd));
    case VT_BSTR:     return VarI4FromStr(V_BSTR(ps), lcid, dwFlags, &V_I4(pd));
    }
    break;
 
  case VT_UI1:
    switch (vtFrom)
    {
    case VT_EMPTY:    V_UI1(pd) = 0; return S_OK;
    case VT_I1:       V_UI1(pd) = V_I1(ps); return S_OK;
    case VT_I2:       return VarUI1FromI2(V_I2(ps), &V_UI1(pd));
    case VT_I4:       return VarUI1FromI4(V_I4(ps), &V_UI1(pd));
    case VT_UI2:      return VarUI1FromUI2(V_UI2(ps), &V_UI1(pd));
    case VT_UI4:      return VarUI1FromUI4(V_UI4(ps), &V_UI1(pd));
    case VT_I8:       return VarUI1FromI8(V_I8(ps), &V_UI1(pd));
    case VT_UI8:      return VarUI1FromUI8(V_UI8(ps), &V_UI1(pd));
    case VT_R4:       return VarUI1FromR4(V_R4(ps), &V_UI1(pd));
    case VT_R8:       return VarUI1FromR8(V_R8(ps), &V_UI1(pd));
    case VT_DATE:     return VarUI1FromDate(V_DATE(ps), &V_UI1(pd));
    case VT_BOOL:     return VarUI1FromBool(V_BOOL(ps), &V_UI1(pd));
    case VT_CY:       return VarUI1FromCy(V_CY(ps), &V_UI1(pd));
    case VT_DECIMAL:  return VarUI1FromDec(&V_DECIMAL(ps), &V_UI1(pd));
    case VT_DISPATCH: return VarUI1FromDisp(V_DISPATCH(ps), lcid, &V_UI1(pd));
    case VT_BSTR:     return VarUI1FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI1(pd));
    }
    break;
 
  case VT_UI2:
    switch (vtFrom)
    {
    case VT_EMPTY:    V_UI2(pd) = 0; return S_OK;
    case VT_I1:       return VarUI2FromI1(V_I1(ps), &V_UI2(pd));
    case VT_I2:       V_UI2(pd) = V_I2(ps); return S_OK;
    case VT_I4:       return VarUI2FromI4(V_I4(ps), &V_UI2(pd));
    case VT_UI1:      return VarUI2FromUI1(V_UI1(ps), &V_UI2(pd));
    case VT_UI4:      return VarUI2FromUI4(V_UI4(ps), &V_UI2(pd));
    case VT_I8:       return VarUI4FromI8(V_I8(ps), &V_UI4(pd));
    case VT_UI8:      return VarUI4FromUI8(V_UI8(ps), &V_UI4(pd));
    case VT_R4:       return VarUI2FromR4(V_R4(ps), &V_UI2(pd));
    case VT_R8:       return VarUI2FromR8(V_R8(ps), &V_UI2(pd));
    case VT_DATE:     return VarUI2FromDate(V_DATE(ps), &V_UI2(pd));
    case VT_BOOL:     return VarUI2FromBool(V_BOOL(ps), &V_UI2(pd));
    case VT_CY:       return VarUI2FromCy(V_CY(ps), &V_UI2(pd));
    case VT_DECIMAL:  return VarUI2FromDec(&V_DECIMAL(ps), &V_UI2(pd));
    case VT_DISPATCH: return VarUI2FromDisp(V_DISPATCH(ps), lcid, &V_UI2(pd));
    case VT_BSTR:     return VarUI2FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI2(pd));
    }
    break;
 
  case VT_UI4:
    switch (vtFrom)
    {
    case VT_EMPTY:    V_UI4(pd) = 0; return S_OK;
    case VT_I1:       return VarUI4FromI1(V_I1(ps), &V_UI4(pd));
    case VT_I2:       return VarUI4FromI2(V_I2(ps), &V_UI4(pd));
    case VT_I4:       V_UI4(pd) = V_I4(ps); return S_OK;
    case VT_UI1:      return VarUI4FromUI1(V_UI1(ps), &V_UI4(pd));
    case VT_UI2:      return VarUI4FromUI2(V_UI2(ps), &V_UI4(pd));
    case VT_I8:       return VarUI4FromI8(V_I8(ps), &V_UI4(pd));
    case VT_UI8:      return VarUI4FromUI8(V_UI8(ps), &V_UI4(pd));
    case VT_R4:       return VarUI4FromR4(V_R4(ps), &V_UI4(pd));
    case VT_R8:       return VarUI4FromR8(V_R8(ps), &V_UI4(pd));
    case VT_DATE:     return VarUI4FromDate(V_DATE(ps), &V_UI4(pd));
    case VT_BOOL:     return VarUI4FromBool(V_BOOL(ps), &V_UI4(pd));
    case VT_CY:       return VarUI4FromCy(V_CY(ps), &V_UI4(pd));
    case VT_DECIMAL:  return VarUI4FromDec(&V_DECIMAL(ps), &V_UI4(pd));
    case VT_DISPATCH: return VarUI4FromDisp(V_DISPATCH(ps), lcid, &V_UI4(pd));
    case VT_BSTR:     return VarUI4FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI4(pd));
    }
    break;
 
  case VT_UI8:
    switch (vtFrom)
    {
    case VT_EMPTY:    V_UI8(pd) = 0; return S_OK;
    case VT_I4:       if (V_I4(ps) < 0) return DISP_E_OVERFLOW; V_UI8(pd) = V_I4(ps); return S_OK;
    case VT_I1:       return VarUI8FromI1(V_I1(ps), &V_UI8(pd));
    case VT_I2:       return VarUI8FromI2(V_I2(ps), &V_UI8(pd));
    case VT_UI1:      return VarUI8FromUI1(V_UI1(ps), &V_UI8(pd));
    case VT_UI2:      return VarUI8FromUI2(V_UI2(ps), &V_UI8(pd));
    case VT_UI4:      return VarUI8FromUI4(V_UI4(ps), &V_UI8(pd));
    case VT_I8:       V_UI8(pd) = V_I8(ps); return S_OK;
    case VT_R4:       return VarUI8FromR4(V_R4(ps), &V_UI8(pd));
    case VT_R8:       return VarUI8FromR8(V_R8(ps), &V_UI8(pd));
    case VT_DATE:     return VarUI8FromDate(V_DATE(ps), &V_UI8(pd));
    case VT_BOOL:     return VarUI8FromBool(V_BOOL(ps), &V_UI8(pd));
    case VT_CY:       return VarUI8FromCy(V_CY(ps), &V_UI8(pd));
    case VT_DECIMAL:  return VarUI8FromDec(&V_DECIMAL(ps), &V_UI8(pd));
    case VT_DISPATCH: return VarUI8FromDisp(V_DISPATCH(ps), lcid, &V_UI8(pd));
    case VT_BSTR:     return VarUI8FromStr(V_BSTR(ps), lcid, dwFlags, &V_UI8(pd));
    }
    break;
 
  case VT_I8:
    switch (vtFrom)
    {
    case VT_EMPTY:    V_I8(pd) = 0; return S_OK;
    case VT_I4:       V_I8(pd) = V_I4(ps); return S_OK;
    case VT_I1:       return VarI8FromI1(V_I1(ps), &V_I8(pd));
    case VT_I2:       return VarI8FromI2(V_I2(ps), &V_I8(pd));
    case VT_UI1:      return VarI8FromUI1(V_UI1(ps), &V_I8(pd));
    case VT_UI2:      return VarI8FromUI2(V_UI2(ps), &V_I8(pd));
    case VT_UI4:      return VarI8FromUI4(V_UI4(ps), &V_I8(pd));
    case VT_UI8:      V_I8(pd) = V_UI8(ps); return S_OK;
    case VT_R4:       return VarI8FromR4(V_R4(ps), &V_I8(pd));
    case VT_R8:       return VarI8FromR8(V_R8(ps), &V_I8(pd));
    case VT_DATE:     return VarI8FromDate(V_DATE(ps), &V_I8(pd));
    case VT_BOOL:     return VarI8FromBool(V_BOOL(ps), &V_I8(pd));
    case VT_CY:       return VarI8FromCy(V_CY(ps), &V_I8(pd));
    case VT_DECIMAL:  return VarI8FromDec(&V_DECIMAL(ps), &V_I8(pd));
    case VT_DISPATCH: return VarI8FromDisp(V_DISPATCH(ps), lcid, &V_I8(pd));
    case VT_BSTR:     return VarI8FromStr(V_BSTR(ps), lcid, dwFlags, &V_I8(pd));
    }
    break;
 
  case VT_R4:
    switch (vtFrom)
    {
    case VT_EMPTY:    V_R4(pd) = 0.0f; return S_OK;
    case VT_I1:       return VarR4FromI1(V_I1(ps), &V_R4(pd));
    case VT_I2:       return VarR4FromI2(V_I2(ps), &V_R4(pd));
    case VT_I4:       return VarR4FromI4(V_I4(ps), &V_R4(pd));
    case VT_UI1:      return VarR4FromUI1(V_UI1(ps), &V_R4(pd));
    case VT_UI2:      return VarR4FromUI2(V_UI2(ps), &V_R4(pd));
    case VT_UI4:      return VarR4FromUI4(V_UI4(ps), &V_R4(pd));
    case VT_I8:       return VarR4FromI8(V_I8(ps), &V_R4(pd));
    case VT_UI8:      return VarR4FromUI8(V_UI8(ps), &V_R4(pd));
    case VT_R8:       return VarR4FromR8(V_R8(ps), &V_R4(pd));
    case VT_DATE:     return VarR4FromDate(V_DATE(ps), &V_R4(pd));
    case VT_BOOL:     return VarR4FromBool(V_BOOL(ps), &V_R4(pd));
    case VT_CY:       return VarR4FromCy(V_CY(ps), &V_R4(pd));
    case VT_DECIMAL:  return VarR4FromDec(&V_DECIMAL(ps), &V_R4(pd));
    case VT_DISPATCH: return VarR4FromDisp(V_DISPATCH(ps), lcid, &V_R4(pd));
    case VT_BSTR:     return VarR4FromStr(V_BSTR(ps), lcid, dwFlags, &V_R4(pd));
    }
    break;
 
  case VT_R8:
    switch (vtFrom)
    {
    case VT_EMPTY:    V_R8(pd) = 0.0; return S_OK;
    case VT_I1:       return VarR8FromI1(V_I1(ps), &V_R8(pd));
    case VT_I2:       return VarR8FromI2(V_I2(ps), &V_R8(pd));
    case VT_I4:       return VarR8FromI4(V_I4(ps), &V_R8(pd));
    case VT_UI1:      return VarR8FromUI1(V_UI1(ps), &V_R8(pd));
    case VT_UI2:      return VarR8FromUI2(V_UI2(ps), &V_R8(pd));
    case VT_UI4:      return VarR8FromUI4(V_UI4(ps), &V_R8(pd));
    case VT_I8:       return VarR8FromI8(V_I8(ps), &V_R8(pd));
    case VT_UI8:      return VarR8FromUI8(V_UI8(ps), &V_R8(pd));
    case VT_R4:       return VarR8FromR4(V_R4(ps), &V_R8(pd));
    case VT_DATE:     return VarR8FromDate(V_DATE(ps), &V_R8(pd));
    case VT_BOOL:     return VarR8FromBool(V_BOOL(ps), &V_R8(pd));
    case VT_CY:       return VarR8FromCy(V_CY(ps), &V_R8(pd));
    case VT_DECIMAL:  return VarR8FromDec(&V_DECIMAL(ps), &V_R8(pd));
    case VT_DISPATCH: return VarR8FromDisp(V_DISPATCH(ps), lcid, &V_R8(pd));
    case VT_BSTR:     return VarR8FromStr(V_BSTR(ps), lcid, dwFlags, &V_R8(pd));
    }
    break;
 
  case VT_DATE:
    switch (vtFrom)
    {
    case VT_EMPTY:    V_DATE(pd) = 0.0; return S_OK;
    case VT_I1:       return VarDateFromI1(V_I1(ps), &V_DATE(pd));
    case VT_I2:       return VarDateFromI2(V_I2(ps), &V_DATE(pd));
    case VT_I4:       return VarDateFromI4(V_I4(ps), &V_DATE(pd));
    case VT_UI1:      return VarDateFromUI1(V_UI1(ps), &V_DATE(pd));
    case VT_UI2:      return VarDateFromUI2(V_UI2(ps), &V_DATE(pd));
    case VT_UI4:      return VarDateFromUI4(V_UI4(ps), &V_DATE(pd));
    case VT_I8:       return VarDateFromI8(V_I8(ps), &V_DATE(pd));
    case VT_UI8:      return VarDateFromUI8(V_UI8(ps), &V_DATE(pd));
    case VT_R4:       return VarDateFromR4(V_R4(ps), &V_DATE(pd));
    case VT_R8:       return VarDateFromR8(V_R8(ps), &V_DATE(pd));
    case VT_BOOL:     return VarDateFromBool(V_BOOL(ps), &V_DATE(pd));
    case VT_CY:       return VarDateFromCy(V_CY(ps), &V_DATE(pd));
    case VT_DECIMAL:  return VarDateFromDec(&V_DECIMAL(ps), &V_DATE(pd));
    case VT_DISPATCH: return VarDateFromDisp(V_DISPATCH(ps), lcid, &V_DATE(pd));
    case VT_BSTR:     return VarDateFromStr(V_BSTR(ps), lcid, dwFlags, &V_DATE(pd));
    }
    break;
 
  case VT_BOOL:
    switch (vtFrom)
    {
    case VT_EMPTY:    V_BOOL(pd) = 0; return S_OK;
    case VT_I1:       return VarBoolFromI1(V_I1(ps), &V_BOOL(pd));
    case VT_I2:       return VarBoolFromI2(V_I2(ps), &V_BOOL(pd));
    case VT_I4:       return VarBoolFromI4(V_I4(ps), &V_BOOL(pd));
    case VT_UI1:      return VarBoolFromUI1(V_UI1(ps), &V_BOOL(pd));
    case VT_UI2:      return VarBoolFromUI2(V_UI2(ps), &V_BOOL(pd));
    case VT_UI4:      return VarBoolFromUI4(V_UI4(ps), &V_BOOL(pd));
    case VT_I8:       return VarBoolFromI8(V_I8(ps), &V_BOOL(pd));
    case VT_UI8:      return VarBoolFromUI8(V_UI8(ps), &V_BOOL(pd));
    case VT_R4:       return VarBoolFromR4(V_R4(ps), &V_BOOL(pd));
    case VT_R8:       return VarBoolFromR8(V_R8(ps), &V_BOOL(pd));
    case VT_DATE:     return VarBoolFromDate(V_DATE(ps), &V_BOOL(pd));
    case VT_CY:       return VarBoolFromCy(V_CY(ps), &V_BOOL(pd));
    case VT_DECIMAL:  return VarBoolFromDec(&V_DECIMAL(ps), &V_BOOL(pd));
    case VT_DISPATCH: return VarBoolFromDisp(V_DISPATCH(ps), lcid, &V_BOOL(pd));
    case VT_BSTR:     return VarBoolFromStr(V_BSTR(ps), lcid, dwFlags, &V_BOOL(pd));
    }
    break;
 
  case VT_BSTR:
    switch (vtFrom)
    {
    case VT_EMPTY:
      V_BSTR(pd) = SysAllocStringLen(NULL, 0);
      return V_BSTR(pd) ? S_OK : E_OUTOFMEMORY;
    case VT_BOOL:
      if (wFlags & (VARIANT_ALPHABOOL|VARIANT_LOCALBOOL))
         return VarBstrFromBool(V_BOOL(ps), lcid, dwFlags, &V_BSTR(pd));
      return VarBstrFromI2(V_BOOL(ps), lcid, dwFlags, &V_BSTR(pd));
    case VT_I1:       return VarBstrFromI1(V_I1(ps), lcid, dwFlags, &V_BSTR(pd));
    case VT_I2:       return VarBstrFromI2(V_I2(ps), lcid, dwFlags, &V_BSTR(pd));
    case VT_I4:       return VarBstrFromI4(V_I4(ps), lcid, dwFlags, &V_BSTR(pd));
    case VT_UI1:      return VarBstrFromUI1(V_UI1(ps), lcid, dwFlags, &V_BSTR(pd));
    case VT_UI2:      return VarBstrFromUI2(V_UI2(ps), lcid, dwFlags, &V_BSTR(pd));
    case VT_UI4:      return VarBstrFromUI4(V_UI4(ps), lcid, dwFlags, &V_BSTR(pd));
    case VT_I8:       return VarBstrFromI8(V_I8(ps), lcid, dwFlags, &V_BSTR(pd));
    case VT_UI8:      return VarBstrFromUI8(V_UI8(ps), lcid, dwFlags, &V_BSTR(pd));
    case VT_R4:       return VarBstrFromR4(V_R4(ps), lcid, dwFlags, &V_BSTR(pd));
    case VT_R8:       return VarBstrFromR8(V_R8(ps), lcid, dwFlags, &V_BSTR(pd));
    case VT_DATE:     return VarBstrFromDate(V_DATE(ps), lcid, dwFlags, &V_BSTR(pd));
    case VT_CY:       return VarBstrFromCy(V_CY(ps), lcid, dwFlags, &V_BSTR(pd));
    case VT_DECIMAL:  return VarBstrFromDec(&V_DECIMAL(ps), lcid, dwFlags, &V_BSTR(pd));
    case VT_DISPATCH: return VarBstrFromDisp(V_DISPATCH(ps), lcid, dwFlags, &V_BSTR(pd));
    }
    break;
 
  case VT_CY:
    switch (vtFrom)
    {
    case VT_EMPTY:    V_CY(pd).int64 = 0; return S_OK;
    case VT_I1:       return VarCyFromI1(V_I1(ps), &V_CY(pd));
    case VT_I2:       return VarCyFromI2(V_I2(ps), &V_CY(pd));
    case VT_I4:       return VarCyFromI4(V_I4(ps), &V_CY(pd));
    case VT_UI1:      return VarCyFromUI1(V_UI1(ps), &V_CY(pd));
    case VT_UI2:      return VarCyFromUI2(V_UI2(ps), &V_CY(pd));
    case VT_UI4:      return VarCyFromUI4(V_UI4(ps), &V_CY(pd));
    case VT_I8:       return VarCyFromI8(V_I8(ps), &V_CY(pd));
    case VT_UI8:      return VarCyFromUI8(V_UI8(ps), &V_CY(pd));
    case VT_R4:       return VarCyFromR4(V_R4(ps), &V_CY(pd));
    case VT_R8:       return VarCyFromR8(V_R8(ps), &V_CY(pd));
    case VT_DATE:     return VarCyFromDate(V_DATE(ps), &V_CY(pd));
    case VT_BOOL:     return VarCyFromBool(V_BOOL(ps), &V_CY(pd));
    case VT_DECIMAL:  return VarCyFromDec(&V_DECIMAL(ps), &V_CY(pd));
    case VT_DISPATCH: return VarCyFromDisp(V_DISPATCH(ps), lcid, &V_CY(pd));
    case VT_BSTR:     return VarCyFromStr(V_BSTR(ps), lcid, dwFlags, &V_CY(pd));
    }
    break;
 
  case VT_DECIMAL:
    switch (vtFrom)
    {
    case VT_EMPTY:
    case VT_BOOL:
       DEC_SIGNSCALE(&V_DECIMAL(pd)) = SIGNSCALE(DECIMAL_POS,0);
       DEC_HI32(&V_DECIMAL(pd)) = 0;
       DEC_MID32(&V_DECIMAL(pd)) = 0;
        /* VarDecFromBool() coerces to -1/0, ChangeTypeEx() coerces to 1/0.
         * VT_NULL and VT_EMPTY always give a 0 value.
         */
       DEC_LO32(&V_DECIMAL(pd)) = vtFrom == VT_BOOL && V_BOOL(ps) ? 1 : 0;
       return S_OK;
    case VT_I1:       return VarDecFromI1(V_I1(ps), &V_DECIMAL(pd));
    case VT_I2:       return VarDecFromI2(V_I2(ps), &V_DECIMAL(pd));
    case VT_I4:       return VarDecFromI4(V_I4(ps), &V_DECIMAL(pd));
    case VT_UI1:      return VarDecFromUI1(V_UI1(ps), &V_DECIMAL(pd));
    case VT_UI2:      return VarDecFromUI2(V_UI2(ps), &V_DECIMAL(pd));
    case VT_UI4:      return VarDecFromUI4(V_UI4(ps), &V_DECIMAL(pd));
    case VT_I8:       return VarDecFromI8(V_I8(ps), &V_DECIMAL(pd));
    case VT_UI8:      return VarDecFromUI8(V_UI8(ps), &V_DECIMAL(pd));
    case VT_R4:       return VarDecFromR4(V_R4(ps), &V_DECIMAL(pd));
    case VT_R8:       return VarDecFromR8(V_R8(ps), &V_DECIMAL(pd));
    case VT_DATE:     return VarDecFromDate(V_DATE(ps), &V_DECIMAL(pd));
    case VT_CY:       return VarDecFromCy(V_CY(ps), &V_DECIMAL(pd));
    case VT_DISPATCH: return VarDecFromDisp(V_DISPATCH(ps), lcid, &V_DECIMAL(pd));
    case VT_BSTR:     return VarDecFromStr(V_BSTR(ps), lcid, dwFlags, &V_DECIMAL(pd));
    }
    break;
 
  case VT_UNKNOWN:
    switch (vtFrom)
    {
    case VT_DISPATCH:
      if (V_DISPATCH(ps) == NULL)
      {
        V_UNKNOWN(pd) = NULL;
        res = S_OK;
      }
      else
        res = IDispatch_QueryInterface(V_DISPATCH(ps), &IID_IUnknown, (LPVOID*)&V_UNKNOWN(pd));
      break;
    }
    break;
 
  case VT_DISPATCH:
    switch (vtFrom)
    {
    case VT_UNKNOWN:
      if (V_UNKNOWN(ps) == NULL)
      {
        V_DISPATCH(pd) = NULL;
        res = S_OK;
      }
      else
        res = IUnknown_QueryInterface(V_UNKNOWN(ps), &IID_IDispatch, (LPVOID*)&V_DISPATCH(pd));
      break;
    }
    break;
 
  case VT_RECORD:
    break;
  }
  return res;
}

Referenced by VariantChangeTypeEx().

VARIANT_CoerceArray()

static HRESULT VARIANT_CoerceArray ( VARIANTARG *  pd, VARIANTARG *  ps, VARTYPE  vt  )

inlinestatic

Definition at line 501 of file variant.c.

{
  if (vt == VT_BSTR && V_VT(ps) == (VT_ARRAY|VT_UI1))
    return BstrFromVector(V_ARRAY(ps), &V_BSTR(pd));
 
  if (V_VT(ps) == VT_BSTR && vt == (VT_ARRAY|VT_UI1))
    return VectorFromBstr(V_BSTR(ps), &V_ARRAY(pd));
 
  if (V_VT(ps) == vt)
    return SafeArrayCopy(V_ARRAY(ps), &V_ARRAY(pd));
 
  return DISP_E_TYPEMISMATCH;
}

Referenced by VariantChangeTypeEx().

VARIANT_CopyIRecordInfo()

static HRESULT VARIANT_CopyIRecordInfo ( VARIANT *  dest, VARIANT *  src  )

static

Definition at line 692 of file variant.c.

{
  struct __tagBRECORD *dest_rec = &V_UNION(dest, brecVal);
  struct __tagBRECORD *src_rec = &V_UNION(src, brecVal);
  HRESULT hr = S_OK;
  ULONG size;
 
  if (!src_rec->pRecInfo)
  {
    if (src_rec->pvRecord) return E_INVALIDARG;
    return S_OK;
  }
 
  hr = IRecordInfo_GetSize(src_rec->pRecInfo, &size);
  if (FAILED(hr)) return hr;
 
  /* This could look cleaner if only RecordCreate() was used, but native doesn't use it.
     Memory should be allocated in a same way as RecordCreate() does, so RecordDestroy()
     could free it later. */
  dest_rec->pvRecord = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
  if (!dest_rec->pvRecord) return E_OUTOFMEMORY;
 
  dest_rec->pRecInfo = src_rec->pRecInfo;
  IRecordInfo_AddRef(src_rec->pRecInfo);
 
  return IRecordInfo_RecordCopy(src_rec->pRecInfo, src_rec->pvRecord, dest_rec->pvRecord);
}

Referenced by VariantCopy(), and VariantCopyInd().

VARIANT_DataSize()

static size_t VARIANT_DataSize ( const VARIANT *  pv )

inlinestatic

Definition at line 791 of file variant.c.

{
  switch (V_TYPE(pv))
  {
  case VT_I1:
  case VT_UI1:   return sizeof(BYTE);
  case VT_I2:
  case VT_UI2:   return sizeof(SHORT);
  case VT_INT:
  case VT_UINT:
  case VT_I4:
  case VT_UI4:   return sizeof(LONG);
  case VT_I8:
  case VT_UI8:   return sizeof(LONGLONG);
  case VT_R4:    return sizeof(float);
  case VT_R8:    return sizeof(double);
  case VT_DATE:  return sizeof(DATE);
  case VT_BOOL:  return sizeof(VARIANT_BOOL);
  case VT_DISPATCH:
  case VT_UNKNOWN:
  case VT_BSTR:  return sizeof(void*);
  case VT_CY:    return sizeof(CY);
  case VT_ERROR: return sizeof(SCODE);
  }
  TRACE("Shouldn't be called for variant %s!\n", debugstr_variant(pv));
  return 0;
}

Referenced by VariantCopyInd().

VARIANT_DateFromJulian()

static int VARIANT_DateFromJulian ( int  dateIn )

inlinestatic

Definition at line 1061 of file variant.c.

{
  int julianDays = dateIn;
 
  julianDays -= 1757585;  /* Convert to + days from 1 Jan 100 AD */
  julianDays += DATE_MIN; /* Convert to +/- days from 1 Jan 1899 AD */
  return julianDays;
}

Referenced by VarDateFromUdateEx().

VARIANT_DMYFromJulian()

static void VARIANT_DMYFromJulian ( int  jd, USHORT *  year, USHORT *  month, USHORT *  day  )

inlinestatic

Definition at line 1071 of file variant.c.

{
  int j, i, l, n;
 
  l = jd + 68569;
  n = l * 4 / 146097;
  l -= (n * 146097 + 3) / 4;
  i = (4000 * (l + 1)) / 1461001;
  l += 31 - (i * 1461) / 4;
  j = (l * 80) / 2447;
  *day = l - (j * 2447) / 80;
  l = j / 11;
  *month = (j + 2) - (12 * l);
  *year = 100 * (n - 49) + i + l;
}

Referenced by VarUdateFromDate().

VARIANT_FetchDispatchValue()

static HRESULT VARIANT_FetchDispatchValue ( LPVARIANT  pvDispatch, LPVARIANT  pValue  )

static

Definition at line 515 of file variant.c.

{
    HRESULT hres;
    static DISPPARAMS emptyParams = { NULL, NULL, 0, 0 };
 
    if ((V_VT(pvDispatch) & VT_TYPEMASK) == VT_DISPATCH) {
        if (NULL == V_DISPATCH(pvDispatch)) return DISP_E_TYPEMISMATCH;
        hres = IDispatch_Invoke(V_DISPATCH(pvDispatch), DISPID_VALUE, &IID_NULL,
            LOCALE_USER_DEFAULT, DISPATCH_PROPERTYGET, &emptyParams, pValue,
            NULL, NULL);
    } else {
        hres = DISP_E_TYPEMISMATCH;
    }
    return hres;
}

Referenced by VarAbs(), VarAdd(), VarAnd(), VarCat(), VarDiv(), VarFix(), VarImp(), VarInt(), VarMod(), VarMul(), VarNeg(), VarNot(), VarOr(), VarPow(), VarRound(), VarSub(), and VarXor().

VARIANT_GetLocalisedNumberChars()

static void VARIANT_GetLocalisedNumberChars ( VARIANT_NUMBER_CHARS *  lpChars, LCID  lcid, DWORD  dwFlags  )

static

Definition at line 1518 of file variant.c.

{
  static const VARIANT_NUMBER_CHARS defaultChars = { '-','+','.',',','$',0,'.',',' };
  static VARIANT_NUMBER_CHARS lastChars;
  static LCID lastLcid = -1;
  static DWORD lastFlags = 0;
  LCTYPE lctype = dwFlags & LOCALE_NOUSEROVERRIDE;
  WCHAR buff[4];
 
  /* To make caching thread-safe, a critical section is needed */
  EnterCriticalSection(&cache_cs);
 
  /* Asking for default locale entries is very expensive: It is a registry
     server call. So cache one locally, as Microsoft does it too */
  if(lcid == lastLcid && dwFlags == lastFlags)
  {
    memcpy(lpChars, &lastChars, sizeof(defaultChars));
    LeaveCriticalSection(&cache_cs);
    return;
  }
 
  memcpy(lpChars, &defaultChars, sizeof(defaultChars));
  GET_NUMBER_TEXT(LOCALE_SNEGATIVESIGN, cNegativeSymbol);
  GET_NUMBER_TEXT(LOCALE_SPOSITIVESIGN, cPositiveSymbol);
  GET_NUMBER_TEXT(LOCALE_SDECIMAL, cDecimalPoint);
  GET_NUMBER_TEXT(LOCALE_STHOUSAND, cDigitSeparator);
  GET_NUMBER_TEXT(LOCALE_SMONDECIMALSEP, cCurrencyDecimalPoint);
  GET_NUMBER_TEXT(LOCALE_SMONTHOUSANDSEP, cCurrencyDigitSeparator);
 
  /* Local currency symbols are often 2 characters */
  lpChars->cCurrencyLocal2 = '\0';
  switch(GetLocaleInfoW(lcid, lctype|LOCALE_SCURRENCY, buff, ARRAY_SIZE(buff)))
  {
    case 3: lpChars->cCurrencyLocal2 = buff[1]; /* Fall through */
    case 2: lpChars->cCurrencyLocal  = buff[0];
            break;
    default: WARN("buffer too small for LOCALE_SCURRENCY\n");
  }
  TRACE("lcid 0x%x, cCurrencyLocal =%d,%d '%c','%c'\n", lcid, lpChars->cCurrencyLocal,
        lpChars->cCurrencyLocal2, lpChars->cCurrencyLocal, lpChars->cCurrencyLocal2);
 
  memcpy(&lastChars, lpChars, sizeof(defaultChars));
  lastLcid = lcid;
  lastFlags = dwFlags;
  LeaveCriticalSection(&cache_cs);
}

Referenced by VarParseNumFromStr().

VARIANT_JulianFromDate()

static int VARIANT_JulianFromDate ( int  dateIn )

inlinestatic

Definition at line 1051 of file variant.c.

{
  int julianDays = dateIn;
 
  julianDays -= DATE_MIN; /* Convert to + days from 1 Jan 100 AD */
  julianDays += 1757585;  /* Convert to + days from 23 Nov 4713 BC (Julian) */
  return julianDays;
}

Referenced by VarUdateFromDate().

VARIANT_JulianFromDMY()

static double VARIANT_JulianFromDMY ( USHORT  year, USHORT  month, USHORT  day  )

inlinestatic

Definition at line 1088 of file variant.c.

{
  int m12 = (month - 14) / 12;
 
  return ((1461 * (year + 4800 + m12)) / 4 + (367 * (month - 2 - 12 * m12)) / 12 -
           (3 * ((year + 4900 + m12) / 100)) / 4 + day - 32075);
}

Referenced by VarDateFromUdateEx().

VARIANT_RollUdate()

static HRESULT VARIANT_RollUdate ( UDATE *  lpUd )

static

Definition at line 1108 of file variant.c.

{
  static const BYTE days[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
  short iYear, iMonth, iDay, iHour, iMinute, iSecond;
 
  /* interpret values signed */
  iYear   = lpUd->st.wYear;
  iMonth  = lpUd->st.wMonth;
  iDay    = lpUd->st.wDay;
  iHour   = lpUd->st.wHour;
  iMinute = lpUd->st.wMinute;
  iSecond = lpUd->st.wSecond;
 
  TRACE("Raw date: %d/%d/%d %d:%d:%d\n", iDay, iMonth,
        iYear, iHour, iMinute, iSecond);
 
  if (iYear > 9999 || iYear < -9999)
    return E_INVALIDARG; /* Invalid value */
  /* Year 0 to 29 are treated as 2000 + year */
  if (iYear >= 0 && iYear < 30)
    iYear += 2000;
  /* Remaining years < 100 are treated as 1900 + year */
  else if (iYear >= 30 && iYear < 100)
    iYear += 1900;
 
  iMinute += iSecond / 60;
  iSecond  = iSecond % 60;
  iHour   += iMinute / 60;
  iMinute  = iMinute % 60;
  iDay    += iHour / 24;
  iHour    = iHour % 24;
  iYear   += iMonth / 12;
  iMonth   = iMonth % 12;
  if (iMonth<=0) {iMonth+=12; iYear--;}
  while (iDay > days[iMonth])
  {
    if (iMonth == 2 && IsLeapYear(iYear))
      iDay -= 29;
    else
      iDay -= days[iMonth];
    iMonth++;
    iYear += iMonth / 12;
    iMonth = iMonth % 12;
  }
  while (iDay <= 0)
  {
    iMonth--;
    if (iMonth<=0) {iMonth+=12; iYear--;}
    if (iMonth == 2 && IsLeapYear(iYear))
      iDay += 29;
    else
      iDay += days[iMonth];
  }
 
  if (iSecond<0){iSecond+=60; iMinute--;}
  if (iMinute<0){iMinute+=60; iHour--;}
  if (iHour<0)  {iHour+=24; iDay--;}
  if (iYear<=0)  iYear+=2000;
 
  lpUd->st.wYear   = iYear;
  lpUd->st.wMonth  = iMonth;
  lpUd->st.wDay    = iDay;
  lpUd->st.wHour   = iHour;
  lpUd->st.wMinute = iMinute;
  lpUd->st.wSecond = iSecond;
 
  TRACE("Rolled date: %d/%d/%d %d:%d:%d\n", lpUd->st.wDay, lpUd->st.wMonth,
        lpUd->st.wYear, lpUd->st.wHour, lpUd->st.wMinute, lpUd->st.wSecond);
  return S_OK;
}

Referenced by VarDateFromUdateEx(), and VarUdateFromDate().

VARIANT_ValidateType()

static HRESULT VARIANT_ValidateType ( VARTYPE  vt )

inlinestatic

Definition at line 534 of file variant.c.

{
  VARTYPE vtExtra = vt & VT_EXTRA_TYPE;
 
  vt &= VT_TYPEMASK;
 
  if (!(vtExtra & (VT_VECTOR|VT_RESERVED)))
  {
    if (vt < VT_VOID || vt == VT_RECORD || vt == VT_CLSID)
    {
      if ((vtExtra & (VT_BYREF|VT_ARRAY)) && vt <= VT_NULL)
        return DISP_E_BADVARTYPE;
      if (vt != (VARTYPE)15)
        return S_OK;
    }
  }
  return DISP_E_BADVARTYPE;
}

Referenced by VarFix(), VARIANT_ClearInd(), VariantChangeTypeEx(), VariantClear(), VariantCopy(), VarNeg(), and VarNot().

VariantChangeType()

HRESULT WINAPI DECLSPEC_HOTPATCH VariantChangeType	(	VARIANTARG *	pvargDest,
		VARIANTARG *	pvargSrc,
		USHORT	wFlags,
		VARTYPE	vt
	)

Definition at line 962 of file variant.c.

{
  return VariantChangeTypeEx( pvargDest, pvargSrc, LOCALE_USER_DEFAULT, wFlags, vt );
}

Referenced by add_ull_as_bstr_property(), call_script(), change_type(), copy_from_variant(), DispGetParam(), get_elem_attr_value_by_dispid(), Global_CBool(), Global_CByte(), Global_CCur(), Global_CDbl(), Global_CInt(), Global_CSng(), HTMLStyle3_put_zoom(), InstallerImpl_RegistryValue(), CFolderItems::Item(), CFolderItemVerbs::Item(), ITypeInfo_fnInvoke(), CShellDispatch::NameSpace(), OLEFontImpl_IPersistPropertyBag_Load(), PropertyBag_Read(), query_prop(), request_send(), test_nodeTypedValue(), TLB_SanitizeVariant(), to_double(), to_int(), to_string(), to_system_time(), VarAdd(), VarAnd(), VarDiv(), VarIdiv(), VarImp(), VarMod(), VarMul(), VarOr(), VarPow(), VarSub(), VarXor(), winhttp_request_Open(), winhttp_request_put_Option(), WMSFT_encode_variant(), CRegPropertyBag::Write(), CIniPropertyBag::Write(), WshShell3_Popup(), WshShell3_RegWrite(), and WshShell3_Run().

VariantChangeTypeEx()

HRESULT WINAPI VariantChangeTypeEx	(	VARIANTARG *	pvargDest,
		VARIANTARG *	pvargSrc,
		LCID	lcid,
		USHORT	wFlags,
		VARTYPE	vt
	)

Definition at line 988 of file variant.c.

{
  HRESULT res = S_OK;
 
  TRACE("(%s,%s,0x%08x,0x%04x,%s)\n", debugstr_variant(pvargDest),
        debugstr_variant(pvargSrc), lcid, wFlags, debugstr_vt(vt));
 
  if (vt == VT_CLSID)
    res = DISP_E_BADVARTYPE;
  else
  {
    res = VARIANT_ValidateType(V_VT(pvargSrc));
 
    if (SUCCEEDED(res))
    {
      res = VARIANT_ValidateType(vt);
 
      if (SUCCEEDED(res))
      {
        VARIANTARG vTmp, vSrcDeref;
 
        if(V_ISBYREF(pvargSrc) && !V_BYREF(pvargSrc))
          res = DISP_E_TYPEMISMATCH;
        else
        {
          V_VT(&vTmp) = VT_EMPTY;
          V_VT(&vSrcDeref) = VT_EMPTY;
          VariantClear(&vTmp);
          VariantClear(&vSrcDeref);
        }
 
        if (SUCCEEDED(res))
        {
          res = VariantCopyInd(&vSrcDeref, pvargSrc);
          if (SUCCEEDED(res))
          {
            if (V_ISARRAY(&vSrcDeref) || (vt & VT_ARRAY))
              res = VARIANT_CoerceArray(&vTmp, &vSrcDeref, vt);
            else
              res = VARIANT_Coerce(&vTmp, lcid, wFlags, &vSrcDeref, vt);
 
            if (SUCCEEDED(res)) {
                V_VT(&vTmp) = vt;
                res = VariantCopy(pvargDest, &vTmp);
            }
            VariantClear(&vTmp);
            VariantClear(&vSrcDeref);
          }
        }
      }
    }
  }
 
  TRACE("returning 0x%08x, %s\n", res, debugstr_variant(pvargDest));
  return res;
}

Referenced by _VarChangeTypeExWrap(), document_write(), double_to_string(), invoke(), OLEFontImpl_Invoke(), OLEPictureImpl_Invoke(), RegistryPropertyBag_IPropertyBag_Read(), test_ChangeType_keep_dst(), test_EmptyChangeTypeEx(), test_ErrorChangeTypeEx(), test_IDispatchChangeTypeEx(), test_IUnknownChangeTypeEx(), test_nodeTypedValue(), test_NullByRef(), test_NullChangeTypeEx(), test_safearray(), test_SafeArrayChangeTypeEx(), test_UintChangeTypeEx(), test_VarDateChangeTypeEx(), test_VarUI1FromDisp(), VarCat(), VarCmp(), VarFormatCurrency(), VarFormatFromTokens(), VarFormatNumber(), VarFormatPercent(), VARIANT_FormatDate(), VARIANT_FormatNumber(), VARIANT_FormatString(), VARIANT_FromDisp(), and VariantChangeType().

VariantClear()

HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear

(

VARIANTARG *

pVarg

)

Definition at line 648 of file variant.c.

{
  HRESULT hres;
 
  TRACE("(%s)\n", debugstr_variant(pVarg));
 
  hres = VARIANT_ValidateType(V_VT(pVarg));
 
  if (SUCCEEDED(hres))
  {
    if (!V_ISBYREF(pVarg))
    {
      if (V_ISARRAY(pVarg) || V_VT(pVarg) == VT_SAFEARRAY)
      {
        hres = SafeArrayDestroy(V_ARRAY(pVarg));
      }
      else if (V_VT(pVarg) == VT_BSTR)
      {
        SysFreeString(V_BSTR(pVarg));
      }
      else if (V_VT(pVarg) == VT_RECORD)
      {
        struct __tagBRECORD* pBr = &V_UNION(pVarg,brecVal);
        if (pBr->pRecInfo)
        {
          IRecordInfo_RecordClear(pBr->pRecInfo, pBr->pvRecord);
          IRecordInfo_Release(pBr->pRecInfo);
        }
      }
      else if (V_VT(pVarg) == VT_DISPATCH ||
               V_VT(pVarg) == VT_UNKNOWN)
      {
        if (V_UNKNOWN(pVarg))
          IUnknown_Release(V_UNKNOWN(pVarg));
      }
    }
    V_VT(pVarg) = VT_EMPTY;
  }
  return hres;
}

Referenced by _check_default_props(), _check_property(), _check_set_props(), _create_img_elem(), _create_option_elem(), CRegPropertyBag::_ReadString(), _set_framebase_marginheight(), _set_framebase_marginwidth(), _set_iframe_height(), _set_iframe_width(), _set_props(), _test_border_styles(), _test_clone(), _test_disp_value(), _test_elem_attr(), _test_framebase_marginheight(), _test_framebase_marginwidth(), _test_iframe_height(), _test_iframe_width(), _test_node_get_value_str(), _test_node_put_value_str(), _test_readyState(), _test_table_cell_padding(), _test_table_cell_spacing(), _test_tr_possess(), _unset_props(), add_keyitem_pair(), assign_value(), AutomationObject_Invoke(), AVICompressorPropertyBag_Load(), build_directshowfilters_tree(), builtin_propput(), call_event_handlers(), call_script(), call_timer_disp(), clean_props(), SEALED_::CleanupEventArgumentsCallback(), ClearCustData(), Client_EnumVARIANT_Next(), Compartment_Destructor(), Compartment_SetValue(), create_enumerator(), create_signature_columns_and_data(), create_xmlhttprequest(), database_invoke(), disp_call(), disp_call_value(), disp_propget(), disp_propput(), DispatchEx_InvokeEx(), dispex_unlink(), document_write(), enum_find_filter(), enumvar_get_next_item(), exec_assoc_view(), exec_query(), fill_filter_container(), fill_processor_information(), FilterGraph2_Connect(), FilterGraph2_Render(), FilterMapper3_EnumMatchingFilters(), FilterMapper_EnumMatchingFilters(), free_keyitem_pair(), free_property_information(), free_request(), get_attribute_value(), get_diskdrivetodiskpartition_pairs(), get_doc_ready_state(), get_fixed_drive(), get_logicaldisktopartition_pairs(), get_owner(), GetFilterInfo(), GetSplitter(), Global_Abs(), Global_CBool(), Global_CByte(), Global_CCur(), Global_Fix(), Global_Int(), Global_InvokeEx(), HTMLDocument_execCommand(), HTMLElement3_put_disabled(), HTMLElement_populate_props(), HTMLElement_put_title(), IDispatch_Invoke_Proxy(), IDispatch_Invoke_Stub(), iframe_onreadystatechange(), Installer_ProductInfo(), Installer_ProductState(), Installer_RegistryValue(), Installer_RegistryValueE(), Installer_RegistryValueI(), Installer_RegistryValueW(), Installer_VersionGet(), InstallerImpl_InstallProduct(), InstallerImpl_OpenDatabase(), InstallerImpl_OpenPackage(), InstallerImpl_OpenProduct(), InstallerImpl_ProductInfo(), InstallerImpl_ProductState(), InstallerImpl_RegistryValue(), InstallerImpl_RelatedProducts(), InstallerImpl_SummaryInformation(), interp_enumnext(), interp_incc(), interp_newenum(), interp_retval(), invoke(), invoke_builtin_function(), invoke_builtin_prop(), invoke_vbdisp(), IPropertyBag_Read_Stub(), IRecordInfoImpl_GetField(), IRecordInfoImpl_GetFieldNoCopy(), ITypeInfo2_fnGetCustData(), ITypeInfo_fnInvoke(), ITypeInfoImpl_Destroy(), jsval_release(), list_free(), MatchCollectionEnum_Next(), navigate_javascript_proc(), navigate_url(), notif_enabled(), objectset_ItemIndex(), OleCommandTarget_Exec(), OLEFont_SendNotify(), OLEFontImpl_Invoke(), OLEFontImpl_IPersistPropertyBag_Load(), OLEPictureImpl_Invoke(), prepare_for_binding(), process_get_owner(), PropertyBag_Release(), propertyset_Item(), query_prop(), read_property_names(), Record_FieldCountGet(), Record_IntegerDataGet(), record_invoke(), Record_StringDataGet(), refresh_document(), reg_create_key(), reg_enum_key(), reg_enum_values(), reg_get_stringvalue(), register_avicap_devices(), register_codec(), register_dsound_devices(), register_midiout_devices(), register_vfw_codecs(), register_wavein_devices(), register_waveout_devices(), release_dispex(), release_dynamic_vars(), release_exec(), release_val(), remove_attribute(), remove_event_handler(), reset_request(), run_script(), SAFEARRAY_DestroyData(), security_get_sd(), service_pause_service(), service_resume_service(), service_start_service(), service_stop_service(), Session_DoAction(), Session_EvaluateCondition(), Session_FeatureCurrentState(), Session_FeatureRequestStateGet(), session_invoke(), Session_LanguageGet(), Session_ModeGet(), Session_PropertyGet(), set_status_text(), SHPropertyBag_OnIniFile(), SHPropertyBag_OnMemory(), SHPropertyBag_OnRegKey(), stack_pop_disp(), stack_popn(), stack_push(), StringList_Count(), StringList_Item(), summaryinfo_invoke(), SummaryInfo_PropertyCountGet(), super_navigate(), test_attr(), test_attr_collection(), test_attr_collection_disp(), test_body_funs(), test_body_style(), test_BstrCopy(), test_change_type(), test_child_col_disp(), test_cloneNode(), test_codec(), test_container_properties(), test_create(), test_CreateTypeLib(), test_current_style(), test_default_body(), test_default_client_accessible_object(), test_default_properties(), test_default_value(), test_devenum(), test_directshow_filter(), test_dispatch(), test_DispCallFunc(), test_DispGetParam(), test_dmo(), test_dom_implementation(), test_domdoc(), test_domnode(), test_DriveCollection(), test_dsound(), test_EmptyChangeTypeEx(), test_exec_fontname(), test_exec_script(), test_FileCollection(), test_focus(), test_FolderCollection(), test_font_events_disp(), test_frames_collection(), test_func(), test_get_childNodes(), test_get_dataType(), test_get_namespaces(), test_get_set_attr(), test_get_xml(), test_getAttribute(), test_global_id(), test_hash_value(), test_IDispatchClear(), test_imgload(), test_InitPropVariantFromBuffer(), test_InitPropVariantFromGUIDAsString(), test_Installer_Products(), test_Installer_RegistryValue(), test_interfaces(), test_invokeex(), test_isexpression(), test_items(), test_ITextDocument_Open(), test_IUnknownClear(), test_IWinHttpRequest(), test_IXMLDOMDocument2(), test_Keys(), test_legacy_filter(), test_load(), test_locator(), test_marshal_variant(), test_midiout(), test_mxnamespacemanager(), test_mxwriter_cdata(), test_mxwriter_characters(), test_mxwriter_comment(), test_mxwriter_dtd(), test_mxwriter_encoding(), test_mxwriter_flush(), test_mxwriter_ignorablespaces(), test_mxwriter_indent(), test_mxwriter_pi(), test_mxwriter_properties(), test_mxwriter_startenddocument(), test_mxwriter_startendelement(), test_mxwriter_startendelement_batch(), test_mxwriter_startendelement_batch2(), test_mxwriter_stream(), test_namedmap_newenum(), test_namespace(), test_nodeTypedValue(), test_nodeValue(), test_NullByRef(), test_object_elem(), test_OleLoadPicturePath(), test_onclick(), test_ParseDisplayName(), test_ParseName(), test_procedures(), test_propertybag_read(), test_propertybag_write(), test_PropVariantToGUID(), test_put_nodeTypedValue(), test_put_nodeValue(), test_RegExp(), test_registry(), test_safearray(), test_SafeArrayChangeTypeEx(), test_SafeArrayClear(), test_saxreader(), test_saxreader_properties(), test_schema_refs(), test_script_dispatch(), test_script_run(), test_selection(), test_set_csstext(), test_specific_encoder_properties(), test_StaticWidget(), test_StdRegProv(), test_style2(), test_style3(), test_style4(), test_style5(), test_stylesheets(), test_SummaryInfo(), test_SystemSecurity(), test_table_elem(), test_td_elem(), test_tr_elem(), test_type_info(), test_TypeInfo(), test_typelibmarshal(), test_var_call1(), test_var_call2(), test_VarAdd(), test_VarCat(), test_VarDateChangeTypeEx(), test_VarFormatFromTokens(), test_VariantClear(), test_VariantCopy(), test_VariantCopyInd(), test_Verbs(), test_vfw(), test_wavein(), test_waveout(), test_Win32_Baseboard(), test_Win32_Bios(), test_Win32_ComputerSystem(), test_Win32_OperatingSystem(), test_Win32_PnPEntity(), test_Win32_Printer(), test_Win32_Process(), test_Win32_Service(), test_Win32_SystemEnclosure(), test_Win32_VideoController(), test_wshshell(), test_XDR_datatypes(), test_XDR_schemas(), test_xmlelem(), test_xmlelem_collection(), test_XMLHTTP(), test_xmlhttprequest(), test_xmlTypes(), test_XPath(), test_xsltemplate(), TLB_AllocAndInitVarDesc(), TLB_FreeCustData(), TLB_FreeElemDesc(), TLB_FreeVarDesc(), TLB_set_custdata(), update_readystate(), validate_regex_document(), VarAbs(), VarAdd(), VarAnd(), VarCat(), VarCmp(), VarDiv(), VarFix(), VARIANT_ClearInd(), VARIANT_Coerce(), VARIANT_FormatNumber(), VARIANT_FormatString(), VARIANT_FromDisp(), VARIANT_UserFree(), VARIANT_UserUnmarshal(), VariantChangeType_ChangeType(), VariantChangeTypeEx(), VariantCopy(), VariantCopyInd(), VarIdiv(), VarImp(), VarInt(), VarMod(), VarMul(), VarNeg(), VarNot(), VarOr(), VarPow(), VarRound(), VarSub(), VarXor(), VBArray_getItem(), view_invoke(), Widget_variant(), winhttp_request_Send(), CRegPropertyBag::Write(), CIniPropertyBag::Write(), write_filter_data(), WshShell3_Popup(), WshShell3_RegWrite(), and xslprocessor_transform().

VariantCopy()

HRESULT WINAPI VariantCopy	(	VARIANTARG *	pvargDest,
		VARIANTARG *	pvargSrc
	)

Definition at line 748 of file variant.c.

{
  HRESULT hres = S_OK;
 
  TRACE("(%s,%s)\n", debugstr_variant(pvargDest), debugstr_variant(pvargSrc));
 
  if (V_TYPE(pvargSrc) == VT_CLSID || /* VT_CLSID is a special case */
      FAILED(VARIANT_ValidateType(V_VT(pvargSrc))))
    return DISP_E_BADVARTYPE;
 
  if (pvargSrc != pvargDest &&
      SUCCEEDED(hres = VariantClear(pvargDest)))
  {
    *pvargDest = *pvargSrc; /* Shallow copy the value */
 
    if (!V_ISBYREF(pvargSrc))
    {
      switch (V_VT(pvargSrc))
      {
      case VT_BSTR:
        V_BSTR(pvargDest) = SysAllocStringByteLen((char*)V_BSTR(pvargSrc), SysStringByteLen(V_BSTR(pvargSrc)));
        if (!V_BSTR(pvargDest))
          hres = E_OUTOFMEMORY;
        break;
      case VT_RECORD:
        hres = VARIANT_CopyIRecordInfo(pvargDest, pvargSrc);
        break;
      case VT_DISPATCH:
      case VT_UNKNOWN:
        V_UNKNOWN(pvargDest) = V_UNKNOWN(pvargSrc);
        if (V_UNKNOWN(pvargSrc))
          IUnknown_AddRef(V_UNKNOWN(pvargSrc));
        break;
      default:
        if (V_ISARRAY(pvargSrc))
          hres = SafeArrayCopy(V_ARRAY(pvargSrc), &V_ARRAY(pvargDest));
      }
    }
  }
  return hres;
}

Referenced by Compartment_GetValue(), dict_enum_Next(), dictionary_get_Item(), dictionary_Items(), dictionary_Keys(), function_invoke(), get_event_handler(), HTMLEventObj_get_returnValue(), HTMLStyle3_get_zoom(), IDispatch_Invoke_Proxy(), IDispatch_Invoke_Stub(), IDxDiagContainerImpl_GetProp(), Installer_RegistryValue(), interp_retval(), interp_val(), ITypeInfo2_fnGetCustData(), ITypeInfo2_fnGetFuncCustData(), ITypeInfo2_fnGetImplTypeCustData(), ITypeInfo2_fnGetParamCustData(), ITypeInfo2_fnGetVarCustData(), ITypeInfo_fnInvoke(), ITypeLib2_fnGetCustData(), jsval_to_variant(), jsval_variant(), list_invoke(), ListEnumerator_Next(), PropertyBag_Read(), PropertyBag_Write(), CMemPropertyBag::Read(), SAFEARRAY_CopyData(), safearray_iter_IEnumVARIANT_Next(), SafeArrayGetElement(), SafeArrayPutElement(), stack_assume_val(), test_BstrCopy(), test_IDispatchCopy(), test_IUnknownCopy(), test_SafeArrayCopy(), test_VarI8Copy(), test_VariantCopy(), test_VarUI8Copy(), TLB_AllocAndInitVarDesc(), TLB_copy_all_custdata(), TLB_CopyElemDesc(), TLB_set_custdata(), VarAdd(), VarAnd(), VARIANT_Coerce(), variant_copy(), VariantChangeTypeEx(), VariantCopyInd(), VarImp(), VarMul(), VarOr(), and VarXor().

VariantCopyInd()

HRESULT WINAPI VariantCopyInd	(	VARIANT *	pvargDest,
		VARIANTARG *	pvargSrc
	)

Definition at line 847 of file variant.c.

{
  VARIANTARG vTmp, *pSrc = pvargSrc;
  VARTYPE vt;
  HRESULT hres = S_OK;
 
  TRACE("(%s,%s)\n", debugstr_variant(pvargDest), debugstr_variant(pvargSrc));
 
  if (!V_ISBYREF(pvargSrc))
    return VariantCopy(pvargDest, pvargSrc);
 
  /* Argument checking is more lax than VariantCopy()... */
  vt = V_TYPE(pvargSrc);
  if (V_ISARRAY(pvargSrc) || (V_VT(pvargSrc) == (VT_RECORD|VT_BYREF)) ||
     (vt > VT_NULL && vt != (VARTYPE)15 && vt < VT_VOID &&
     !(V_VT(pvargSrc) & (VT_VECTOR|VT_RESERVED))))
  {
    /* OK */
  }
  else
    return E_INVALIDARG; /* ...And the return value for invalid types differs too */
 
  if (pvargSrc == pvargDest)
  {
    /* In place copy. Use a shallow copy of pvargSrc & init pvargDest.
     * This avoids an expensive VariantCopy() call - e.g. SafeArrayCopy().
     */
    vTmp = *pvargSrc;
    pSrc = &vTmp;
    V_VT(pvargDest) = VT_EMPTY;
  }
  else
  {
    /* Copy into another variant. Free the variant in pvargDest */
    if (FAILED(hres = VariantClear(pvargDest)))
    {
      TRACE("VariantClear() of destination failed\n");
      return hres;
    }
  }
 
  if (V_ISARRAY(pSrc))
  {
    /* Native doesn't check that *V_ARRAYREF(pSrc) is valid */
    hres = SafeArrayCopy(*V_ARRAYREF(pSrc), &V_ARRAY(pvargDest));
  }
  else if (V_VT(pSrc) == (VT_BSTR|VT_BYREF))
  {
    /* Native doesn't check that *V_BSTRREF(pSrc) is valid */
    V_BSTR(pvargDest) = SysAllocStringByteLen((char*)*V_BSTRREF(pSrc), SysStringByteLen(*V_BSTRREF(pSrc)));
  }
  else if (V_VT(pSrc) == (VT_RECORD|VT_BYREF))
  {
    hres = VARIANT_CopyIRecordInfo(pvargDest, pvargSrc);
  }
  else if (V_VT(pSrc) == (VT_DISPATCH|VT_BYREF) ||
           V_VT(pSrc) == (VT_UNKNOWN|VT_BYREF))
  {
    /* Native doesn't check that *V_UNKNOWNREF(pSrc) is valid */
    V_UNKNOWN(pvargDest) = *V_UNKNOWNREF(pSrc);
    if (*V_UNKNOWNREF(pSrc))
      IUnknown_AddRef(*V_UNKNOWNREF(pSrc));
  }
  else if (V_VT(pSrc) == (VT_VARIANT|VT_BYREF))
  {
    /* Native doesn't check that *V_VARIANTREF(pSrc) is valid */
    if (V_VT(V_VARIANTREF(pSrc)) == (VT_VARIANT|VT_BYREF))
      hres = E_INVALIDARG; /* Don't dereference more than one level */
    else
      hres = VariantCopyInd(pvargDest, V_VARIANTREF(pSrc));
 
    /* Use the dereferenced variants type value, not VT_VARIANT */
    goto VariantCopyInd_Return;
  }
  else if (V_VT(pSrc) == (VT_DECIMAL|VT_BYREF))
  {
    memcpy(&DEC_SCALE(&V_DECIMAL(pvargDest)), &DEC_SCALE(V_DECIMALREF(pSrc)),
           sizeof(DECIMAL) - sizeof(USHORT));
  }
  else
  {
    /* Copy the pointed to data into this variant */
    memcpy(&V_BYREF(pvargDest), V_BYREF(pSrc), VARIANT_DataSize(pSrc));
  }
 
  V_VT(pvargDest) = V_VT(pSrc) & ~VT_BYREF;
 
VariantCopyInd_Return:
 
  if (pSrc != pvargSrc)
    VariantClear(pSrc);
 
  TRACE("returning 0x%08x, %s\n", hres, debugstr_variant(pvargDest));
  return hres;
}

Referenced by add_keyitem_pair(), assign_value(), dictionary_put_Item(), DispGetParam_CopyOnly(), exec_script(), Global_Array(), invoke_variant_prop(), CFolderItems::Item(), ITypeInfo_fnInvoke(), SummaryInfo_PropertyPut(), test_IDispatchCopy(), test_IUnknownCopy(), test_VarI8Copy(), test_VariantCopyInd(), test_VarUI8Copy(), VarFormatCurrency(), VarFormatNumber(), VarFormatPercent(), VariantChangeTypeEx(), VariantCopyInd(), and winhttp_request_Send().

VariantInit()

void WINAPI VariantInit

(

VARIANTARG *

pVarg

)

Definition at line 568 of file variant.c.

{
  TRACE("(%p)\n", pVarg);
 
  /* Win8.1 zeroes whole struct. Previous implementations don't set any other fields. */
  V_VT(pVarg) = VT_EMPTY;
}

Referenced by _call_change_type(), _check_default_props(), _check_property(), _check_set_props(), _set_props(), _test_clone(), _test_elem_attr(), _test_readyState(), _unset_props(), AccessibleChildren(), add_keyitem_pair(), AutomationObject_Invoke(), call_docview_84(), call_explorer_69(), ATL::CComVariant::CComVariant(), Compartment_Constructor(), Compartment_GetValue(), create_enumerator(), create_xmlhttprequest(), database_invoke(), Database_OpenView(), Database_SummaryInformation(), DatabaseImpl_LastErrorRecord(), DEVENUM_IMediaCatMoniker_BindToObject(), dictionary_get_Item(), dictionary_put_Key(), enum_find_filter(), enumvar_get_next_item(), fill_filter_container(), FilterMapper3_EnumMatchingFilters(), FilterMapper_EnumMatchingFilters(), get_client_disp_property(), get_dynamic_prop(), GetFilterInfo(), IDispatch_Invoke_Proxy(), IDispatch_Invoke_Stub(), IDxDiagContainerImpl_GetProp(), initialize_request(), Installer_CreateRecord(), Installer_InstallProduct(), Installer_OpenDatabase(), Installer_OpenPackage(), Installer_ProductInfo(), Installer_ProductState(), Installer_RegistryValue(), Installer_RegistryValueE(), Installer_RegistryValueI(), Installer_RegistryValueW(), Installer_RelatedProducts(), Installer_SummaryInformation(), Installer_UILevelPut(), InstallerImpl_CreateRecord(), InstallerImpl_EnableLog(), InstallerImpl_Environment(), InstallerImpl_FileAttributes(), InstallerImpl_FileSize(), InstallerImpl_FileVersion(), InstallerImpl_InstallProduct(), InstallerImpl_LastErrorRecord(), InstallerImpl_OpenDatabase(), InstallerImpl_OpenPackage(), InstallerImpl_OpenProduct(), InstallerImpl_ProductInfo(), InstallerImpl_ProductState(), InstallerImpl_RegistryValue(), InstallerImpl_RelatedProducts(), InstallerImpl_SummaryInformation(), InstallerImpl_UILevel(), invoke(), ITypeInfo2_fnGetCustData(), ITypeInfo2_fnGetFuncCustData(), ITypeInfo2_fnGetImplTypeCustData(), ITypeInfo2_fnGetParamCustData(), ITypeInfo2_fnGetVarCustData(), ITypeInfo_fnInvoke(), ITypeLib2_fnGetCustData(), list_invoke(), ListEnumerator_Next(), load_manifest(), OLEFont_SendNotify(), OLEFontImpl_Invoke(), OLEFontImpl_IPersistPropertyBag_Load(), OLEPictureImpl_Invoke(), parse_elem_text(), process_get_owner(), PropertyBag_Read(), CMemPropertyBag::Read(), CRegPropertyBag::Read(), CIniPropertyBag::Read(), CDesktopUpgradePropertyBag::Read(), read_property_names(), Record_IntegerDataGet(), Record_IntegerDataPut(), record_invoke(), Record_StringDataGet(), Record_StringDataPut(), reg_enum_key(), reg_enum_values(), reg_get_stringvalue(), request_get_property(), request_send(), security_get_sd(), Session_DoAction(), Session_EvaluateCondition(), Session_FeatureCurrentState(), Session_FeatureRequestStateGet(), Session_FeatureRequestStatePut(), session_invoke(), Session_Message(), Session_ModeGet(), Session_ModePut(), Session_PropertyGet(), Session_PropertyPut(), Session_SetInstallLevel(), SHPropertyBag_OnIniFile(), SHPropertyBag_OnMemory(), SHPropertyBag_OnRegKey(), StringList_Item(), summaryinfo_invoke(), SummaryInfo_PropertyGet(), SummaryInfo_PropertyPut(), test_attr_collection_disp(), test_ChangeType_keep_dst(), test_child_col_disp(), test_ClearCustData(), test_codec(), test_comparemode(), test_container_properties(), test_CreateTypeLib(), test_devenum(), test_directshow_filter(), test_dispatch(), test_DispCallFunc(), test_DispGetParam(), test_dmo(), test_domdoc(), test_domnode(), test_dsound(), test_EmptyChangeTypeEx(), test_ErrorChangeTypeEx(), test_events(), test_Exists(),