vartype.c File Reference

#include <wchar.h>
#include "wine/debug.h"
#include "winbase.h"
#include "winuser.h"
#include "winnt.h"
#include "variant.h"
#include "resource.h"

Include dependency graph for vartype.c:

Go to the source code of this file.

Classes
struct	DECIMAL_internal
union	R4_FIELDS
union	R8_FIELDS
struct	tagDATEPARSE

Macros
#define	COBJMACROS
#define	NONAMELESSUNION
#define	NONAMELESSSTRUCT
#define	CY_MULTIPLIER   10000 /* 4 dp of precision */
#define	CY_MULTIPLIER_F   10000.0
#define	CY_HALF   (CY_MULTIPLIER/2) /* 0.5 */
#define	CY_HALF_F   (CY_MULTIPLIER_F/2.0)
#define	VARIANT_DutchRound(typ, value, res)
#define	RETTYP   static inline HRESULT
#define	SIMPLE(dest, src, func)
#define	NEGTST(dest, src, func)
#define	POSTST(dest, src, func, tst)
#define	BOTHTST(dest, src, func, lo, hi)
#define	DP_TIMESEP   0x01 /* Time separator ( _must_ remain 0x1, used as a bitmask) */
#define	DP_DATESEP   0x02 /* Date separator */
#define	DP_MONTH   0x04 /* Month name */
#define	DP_AM   0x08 /* AM */
#define	DP_PM   0x10 /* PM */
#define	TIMEFLAG(i)   ((dp.dwFlags[i] & DP_TIMESEP) << i)
#define	IsLeapYear(y)   (((y % 4) == 0) && (((y % 100) != 0) || ((y % 400) == 0)))
#define	ORDER_MDY   0x01
#define	ORDER_YMD   0x02
#define	ORDER_YDM   0x04
#define	ORDER_DMY   0x08
#define	ORDER_MYD   0x10 /* Synthetic order, used only for funky 2 digit dates */
#define	DATE_SWAP(x, y)   do { dwTemp = x; x = y; y = dwTemp; } while (0)

Typedefs
typedef struct DECIMAL_internal	VARIANT_DI
typedef struct tagDATEPARSE	DATEPARSE

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (variant)
static void	VARIANT_CopyData (const VARIANT *srcVar, VARTYPE vt, void *pOut)
static HRESULT	VARIANT_NumberFromBstr (OLECHAR *pStrIn, LCID lcid, ULONG ulFlags, void *pOut, VARTYPE vt)
static HRESULT	VARIANT_FromDisp (IDispatch *pdispIn, LCID lcid, void *pOut, VARTYPE vt, DWORD dwFlags)
RETTYP	_VarR8FromCy (CY i, double *o)
HRESULT WINAPI	VarI1FromUI1 (BYTE bIn, signed char *pcOut)
HRESULT WINAPI	VarI1FromI2 (SHORT sIn, signed char *pcOut)
HRESULT WINAPI	VarI1FromI4 (LONG iIn, signed char *pcOut)
HRESULT WINAPI	VarI1FromR4 (FLOAT fltIn, signed char *pcOut)
HRESULT WINAPI	VarI1FromR8 (double dblIn, signed char *pcOut)
HRESULT WINAPI	VarI1FromDate (DATE dateIn, signed char *pcOut)
HRESULT WINAPI	VarI1FromCy (CY cyIn, signed char *pcOut)
HRESULT WINAPI	VarI1FromStr (OLECHAR *strIn, LCID lcid, ULONG dwFlags, signed char *pcOut)
HRESULT WINAPI	VarI1FromDisp (IDispatch *pdispIn, LCID lcid, signed char *pcOut)
HRESULT WINAPI	VarI1FromBool (VARIANT_BOOL boolIn, signed char *pcOut)
HRESULT WINAPI	VarI1FromUI2 (USHORT usIn, signed char *pcOut)
HRESULT WINAPI	VarI1FromUI4 (ULONG ulIn, signed char *pcOut)
HRESULT WINAPI	VarI1FromDec (DECIMAL *pdecIn, signed char *pcOut)
HRESULT WINAPI	VarI1FromI8 (LONG64 llIn, signed char *pcOut)
HRESULT WINAPI	VarI1FromUI8 (ULONG64 ullIn, signed char *pcOut)
HRESULT WINAPI	VarUI1FromI2 (SHORT sIn, BYTE *pbOut)
HRESULT WINAPI	VarUI1FromI4 (LONG iIn, BYTE *pbOut)
HRESULT WINAPI	VarUI1FromR4 (FLOAT fltIn, BYTE *pbOut)
HRESULT WINAPI	VarUI1FromR8 (double dblIn, BYTE *pbOut)
HRESULT WINAPI	VarUI1FromCy (CY cyIn, BYTE *pbOut)
HRESULT WINAPI	VarUI1FromDate (DATE dateIn, BYTE *pbOut)
HRESULT WINAPI	VarUI1FromStr (OLECHAR *strIn, LCID lcid, ULONG dwFlags, BYTE *pbOut)
HRESULT WINAPI	VarUI1FromDisp (IDispatch *pdispIn, LCID lcid, BYTE *pbOut)
HRESULT WINAPI	VarUI1FromBool (VARIANT_BOOL boolIn, BYTE *pbOut)
HRESULT WINAPI	VarUI1FromI1 (signed char cIn, BYTE *pbOut)
HRESULT WINAPI	VarUI1FromUI2 (USHORT usIn, BYTE *pbOut)
HRESULT WINAPI	VarUI1FromUI4 (ULONG ulIn, BYTE *pbOut)
HRESULT WINAPI	VarUI1FromDec (DECIMAL *pdecIn, BYTE *pbOut)
HRESULT WINAPI	VarUI1FromI8 (LONG64 llIn, BYTE *pbOut)
HRESULT WINAPI	VarUI1FromUI8 (ULONG64 ullIn, BYTE *pbOut)
HRESULT WINAPI	VarI2FromUI1 (BYTE bIn, SHORT *psOut)
HRESULT WINAPI	VarI2FromI4 (LONG iIn, SHORT *psOut)
HRESULT WINAPI	VarI2FromR4 (FLOAT fltIn, SHORT *psOut)
HRESULT WINAPI	VarI2FromR8 (double dblIn, SHORT *psOut)
HRESULT WINAPI	VarI2FromCy (CY cyIn, SHORT *psOut)
HRESULT WINAPI	VarI2FromDate (DATE dateIn, SHORT *psOut)
HRESULT WINAPI	VarI2FromStr (OLECHAR *strIn, LCID lcid, ULONG dwFlags, SHORT *psOut)
HRESULT WINAPI	VarI2FromDisp (IDispatch *pdispIn, LCID lcid, SHORT *psOut)
HRESULT WINAPI	VarI2FromBool (VARIANT_BOOL boolIn, SHORT *psOut)
HRESULT WINAPI	VarI2FromI1 (signed char cIn, SHORT *psOut)
HRESULT WINAPI	VarI2FromUI2 (USHORT usIn, SHORT *psOut)
HRESULT WINAPI	VarI2FromUI4 (ULONG ulIn, SHORT *psOut)
HRESULT WINAPI	VarI2FromDec (DECIMAL *pdecIn, SHORT *psOut)
HRESULT WINAPI	VarI2FromI8 (LONG64 llIn, SHORT *psOut)
HRESULT WINAPI	VarI2FromUI8 (ULONG64 ullIn, SHORT *psOut)
HRESULT WINAPI	VarUI2FromUI1 (BYTE bIn, USHORT *pusOut)
HRESULT WINAPI	VarUI2FromI2 (SHORT sIn, USHORT *pusOut)
HRESULT WINAPI	VarUI2FromI4 (LONG iIn, USHORT *pusOut)
HRESULT WINAPI	VarUI2FromR4 (FLOAT fltIn, USHORT *pusOut)
HRESULT WINAPI	VarUI2FromR8 (double dblIn, USHORT *pusOut)
HRESULT WINAPI	VarUI2FromDate (DATE dateIn, USHORT *pusOut)
HRESULT WINAPI	VarUI2FromCy (CY cyIn, USHORT *pusOut)
HRESULT WINAPI	VarUI2FromStr (OLECHAR *strIn, LCID lcid, ULONG dwFlags, USHORT *pusOut)
HRESULT WINAPI	VarUI2FromDisp (IDispatch *pdispIn, LCID lcid, USHORT *pusOut)
HRESULT WINAPI	VarUI2FromBool (VARIANT_BOOL boolIn, USHORT *pusOut)
HRESULT WINAPI	VarUI2FromI1 (signed char cIn, USHORT *pusOut)
HRESULT WINAPI	VarUI2FromUI4 (ULONG ulIn, USHORT *pusOut)
HRESULT WINAPI	VarUI2FromDec (DECIMAL *pdecIn, USHORT *pusOut)
HRESULT WINAPI	VarUI2FromI8 (LONG64 llIn, USHORT *pusOut)
HRESULT WINAPI	VarUI2FromUI8 (ULONG64 ullIn, USHORT *pusOut)
HRESULT WINAPI	VarI4FromUI1 (BYTE bIn, LONG *piOut)
HRESULT WINAPI	VarI4FromI2 (SHORT sIn, LONG *piOut)
HRESULT WINAPI	VarI4FromR4 (FLOAT fltIn, LONG *piOut)
HRESULT WINAPI	VarI4FromR8 (double dblIn, LONG *piOut)
HRESULT WINAPI	VarI4FromCy (CY cyIn, LONG *piOut)
HRESULT WINAPI	VarI4FromDate (DATE dateIn, LONG *piOut)
HRESULT WINAPI	VarI4FromStr (OLECHAR *strIn, LCID lcid, ULONG dwFlags, LONG *piOut)
HRESULT WINAPI	VarI4FromDisp (IDispatch *pdispIn, LCID lcid, LONG *piOut)
HRESULT WINAPI	VarI4FromBool (VARIANT_BOOL boolIn, LONG *piOut)
HRESULT WINAPI	VarI4FromI1 (signed char cIn, LONG *piOut)
HRESULT WINAPI	VarI4FromUI2 (USHORT usIn, LONG *piOut)
HRESULT WINAPI	VarI4FromUI4 (ULONG ulIn, LONG *piOut)
HRESULT WINAPI	VarI4FromDec (DECIMAL *pdecIn, LONG *piOut)
HRESULT WINAPI	VarI4FromI8 (LONG64 llIn, LONG *piOut)
HRESULT WINAPI	VarI4FromUI8 (ULONG64 ullIn, LONG *piOut)
HRESULT WINAPI	VarUI4FromUI1 (BYTE bIn, ULONG *pulOut)
HRESULT WINAPI	VarUI4FromI2 (SHORT sIn, ULONG *pulOut)
HRESULT WINAPI	VarUI4FromI4 (LONG iIn, ULONG *pulOut)
HRESULT WINAPI	VarUI4FromR4 (FLOAT fltIn, ULONG *pulOut)
HRESULT WINAPI	VarUI4FromR8 (double dblIn, ULONG *pulOut)
HRESULT WINAPI	VarUI4FromDate (DATE dateIn, ULONG *pulOut)
HRESULT WINAPI	VarUI4FromCy (CY cyIn, ULONG *pulOut)
HRESULT WINAPI	VarUI4FromStr (OLECHAR *strIn, LCID lcid, ULONG dwFlags, ULONG *pulOut)
HRESULT WINAPI	VarUI4FromDisp (IDispatch *pdispIn, LCID lcid, ULONG *pulOut)
HRESULT WINAPI	VarUI4FromBool (VARIANT_BOOL boolIn, ULONG *pulOut)
HRESULT WINAPI	VarUI4FromI1 (signed char cIn, ULONG *pulOut)
HRESULT WINAPI	VarUI4FromUI2 (USHORT usIn, ULONG *pulOut)
HRESULT WINAPI	VarUI4FromDec (DECIMAL *pdecIn, ULONG *pulOut)
HRESULT WINAPI	VarUI4FromI8 (LONG64 llIn, ULONG *pulOut)
HRESULT WINAPI	VarUI4FromUI8 (ULONG64 ullIn, ULONG *pulOut)
HRESULT WINAPI	VarI8FromUI1 (BYTE bIn, LONG64 *pi64Out)
HRESULT WINAPI	VarI8FromI2 (SHORT sIn, LONG64 *pi64Out)
HRESULT WINAPI	VarI8FromR4 (FLOAT fltIn, LONG64 *pi64Out)
HRESULT WINAPI	VarI8FromR8 (double dblIn, LONG64 *pi64Out)
HRESULT WINAPI	VarI8FromCy (CY cyIn, LONG64 *pi64Out)
HRESULT WINAPI	VarI8FromDate (DATE dateIn, LONG64 *pi64Out)
HRESULT WINAPI	VarI8FromStr (OLECHAR *strIn, LCID lcid, ULONG dwFlags, LONG64 *pi64Out)
HRESULT WINAPI	VarI8FromDisp (IDispatch *pdispIn, LCID lcid, LONG64 *pi64Out)
HRESULT WINAPI	VarI8FromBool (VARIANT_BOOL boolIn, LONG64 *pi64Out)
HRESULT WINAPI	VarI8FromI1 (signed char cIn, LONG64 *pi64Out)
HRESULT WINAPI	VarI8FromUI2 (USHORT usIn, LONG64 *pi64Out)
HRESULT WINAPI	VarI8FromUI4 (ULONG ulIn, LONG64 *pi64Out)
HRESULT WINAPI	VarI8FromDec (DECIMAL *pdecIn, LONG64 *pi64Out)
HRESULT WINAPI	VarI8FromUI8 (ULONG64 ullIn, LONG64 *pi64Out)
HRESULT WINAPI	VarUI8FromI8 (LONG64 llIn, ULONG64 *pui64Out)
HRESULT WINAPI	VarUI8FromUI1 (BYTE bIn, ULONG64 *pui64Out)
HRESULT WINAPI	VarUI8FromI2 (SHORT sIn, ULONG64 *pui64Out)
HRESULT WINAPI	VarUI8FromR4 (FLOAT fltIn, ULONG64 *pui64Out)
HRESULT WINAPI	VarUI8FromR8 (double dblIn, ULONG64 *pui64Out)
HRESULT WINAPI	VarUI8FromCy (CY cyIn, ULONG64 *pui64Out)
HRESULT WINAPI	VarUI8FromDate (DATE dateIn, ULONG64 *pui64Out)
HRESULT WINAPI	VarUI8FromStr (OLECHAR *strIn, LCID lcid, ULONG dwFlags, ULONG64 *pui64Out)
HRESULT WINAPI	VarUI8FromDisp (IDispatch *pdispIn, LCID lcid, ULONG64 *pui64Out)
HRESULT WINAPI	VarUI8FromBool (VARIANT_BOOL boolIn, ULONG64 *pui64Out)
HRESULT WINAPI	VarUI8FromI1 (signed char cIn, ULONG64 *pui64Out)
HRESULT WINAPI	VarUI8FromUI2 (USHORT usIn, ULONG64 *pui64Out)
HRESULT WINAPI	VarUI8FromUI4 (ULONG ulIn, ULONG64 *pui64Out)
HRESULT WINAPI	VarUI8FromDec (DECIMAL *pdecIn, ULONG64 *pui64Out)
HRESULT WINAPI	VarR4FromUI1 (BYTE bIn, float *pFltOut)
HRESULT WINAPI	VarR4FromI2 (SHORT sIn, float *pFltOut)
HRESULT WINAPI	VarR4FromI4 (LONG lIn, float *pFltOut)
HRESULT WINAPI	VarR4FromR8 (double dblIn, float *pFltOut)
HRESULT WINAPI	VarR4FromCy (CY cyIn, float *pFltOut)
HRESULT WINAPI	VarR4FromDate (DATE dateIn, float *pFltOut)
HRESULT WINAPI	VarR4FromStr (OLECHAR *strIn, LCID lcid, ULONG dwFlags, float *pFltOut)
HRESULT WINAPI	VarR4FromDisp (IDispatch *pdispIn, LCID lcid, float *pFltOut)
HRESULT WINAPI	VarR4FromBool (VARIANT_BOOL boolIn, float *pFltOut)
HRESULT WINAPI	VarR4FromI1 (signed char cIn, float *pFltOut)
HRESULT WINAPI	VarR4FromUI2 (USHORT usIn, float *pFltOut)
HRESULT WINAPI	VarR4FromUI4 (ULONG ulIn, float *pFltOut)
HRESULT WINAPI	VarR4FromDec (DECIMAL *pDecIn, float *pFltOut)
HRESULT WINAPI	VarR4FromI8 (LONG64 llIn, float *pFltOut)
HRESULT WINAPI	VarR4FromUI8 (ULONG64 ullIn, float *pFltOut)
HRESULT WINAPI	VarR4CmpR8 (float fltLeft, double dblRight)
HRESULT WINAPI	VarR8FromUI1 (BYTE bIn, double *pDblOut)
HRESULT WINAPI	VarR8FromI2 (SHORT sIn, double *pDblOut)
HRESULT WINAPI	VarR8FromI4 (LONG lIn, double *pDblOut)
HRESULT WINAPI	VarR8FromR4 (FLOAT fltIn, double *pDblOut)
HRESULT WINAPI	VarR8FromCy (CY cyIn, double *pDblOut)
HRESULT WINAPI	VarR8FromDate (DATE dateIn, double *pDblOut)
HRESULT WINAPI	VarR8FromStr (OLECHAR *strIn, LCID lcid, ULONG dwFlags, double *pDblOut)
HRESULT WINAPI	VarR8FromDisp (IDispatch *pdispIn, LCID lcid, double *pDblOut)
HRESULT WINAPI	VarR8FromBool (VARIANT_BOOL boolIn, double *pDblOut)
HRESULT WINAPI	VarR8FromI1 (signed char cIn, double *pDblOut)
HRESULT WINAPI	VarR8FromUI2 (USHORT usIn, double *pDblOut)
HRESULT WINAPI	VarR8FromUI4 (ULONG ulIn, double *pDblOut)
HRESULT WINAPI	VarR8FromDec (const DECIMAL *pDecIn, double *pDblOut)
HRESULT WINAPI	VarR8FromI8 (LONG64 llIn, double *pDblOut)
HRESULT WINAPI	VarR8FromUI8 (ULONG64 ullIn, double *pDblOut)
HRESULT WINAPI	VarR8Pow (double dblLeft, double dblPow, double *pDblOut)
HRESULT WINAPI	VarR8Round (double dblIn, int nDig, double *pDblOut)
HRESULT WINAPI	VarCyFromUI1 (BYTE bIn, CY *pCyOut)
HRESULT WINAPI	VarCyFromI2 (SHORT sIn, CY *pCyOut)
HRESULT WINAPI	VarCyFromI4 (LONG lIn, CY *pCyOut)
HRESULT WINAPI	VarCyFromR4 (FLOAT fltIn, CY *pCyOut)
HRESULT WINAPI	VarCyFromR8 (double dblIn, CY *pCyOut)
HRESULT WINAPI	VarCyFromDate (DATE dateIn, CY *pCyOut)
HRESULT WINAPI	VarCyFromStr (OLECHAR *strIn, LCID lcid, ULONG dwFlags, CY *pCyOut)
HRESULT WINAPI	VarCyFromDisp (IDispatch *pdispIn, LCID lcid, CY *pCyOut)
HRESULT WINAPI	VarCyFromBool (VARIANT_BOOL boolIn, CY *pCyOut)
HRESULT WINAPI	VarCyFromI1 (signed char cIn, CY *pCyOut)
HRESULT WINAPI	VarCyFromUI2 (USHORT usIn, CY *pCyOut)
HRESULT WINAPI	VarCyFromUI4 (ULONG ulIn, CY *pCyOut)
HRESULT WINAPI	VarCyFromDec (DECIMAL *pdecIn, CY *pCyOut)
HRESULT WINAPI	VarCyFromI8 (LONG64 llIn, CY *pCyOut)
HRESULT WINAPI	VarCyFromUI8 (ULONG64 ullIn, CY *pCyOut)
HRESULT WINAPI	VarCyAdd (CY cyLeft, CY cyRight, CY *pCyOut)
HRESULT WINAPI	VarCyMul (CY cyLeft, CY cyRight, CY *pCyOut)
HRESULT WINAPI	VarCyMulI4 (CY cyLeft, LONG lRight, CY *pCyOut)
HRESULT WINAPI	VarCySub (CY cyLeft, CY cyRight, CY *pCyOut)
HRESULT WINAPI	VarCyAbs (CY cyIn, CY *pCyOut)
HRESULT WINAPI	VarCyFix (CY cyIn, CY *pCyOut)
HRESULT WINAPI	VarCyInt (CY cyIn, CY *pCyOut)
HRESULT WINAPI	VarCyNeg (CY cyIn, CY *pCyOut)
HRESULT WINAPI	VarCyRound (CY cyIn, int cDecimals, CY *pCyOut)
HRESULT WINAPI	VarCyCmp (CY cyLeft, CY cyRight)
HRESULT WINAPI	VarCyCmpR8 (CY cyLeft, double dblRight)
HRESULT WINAPI	VarCyMulI8 (CY cyLeft, LONG64 llRight, CY *pCyOut)
HRESULT WINAPI	VarDecFromUI1 (BYTE bIn, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecFromI2 (SHORT sIn, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecFromI4 (LONG lIn, DECIMAL *pDecOut)
static HRESULT	VARIANT_DI_FromR4 (float source, VARIANT_DI *dest)
static HRESULT	VARIANT_DI_FromR8 (double source, VARIANT_DI *dest)
static void	VARIANT_DIFromDec (const DECIMAL *from, VARIANT_DI *to)
static void	VARIANT_DecFromDI (const VARIANT_DI *from, DECIMAL *to)
static unsigned char	VARIANT_int_divbychar (DWORD *p, unsigned int n, unsigned char divisor)
static BOOL	VARIANT_int_iszero (const DWORD *p, unsigned int n)
HRESULT WINAPI	VarDecFromR4 (FLOAT fltIn, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecFromR8 (double dblIn, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecFromDate (DATE dateIn, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecFromCy (CY cyIn, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecFromStr (OLECHAR *strIn, LCID lcid, ULONG dwFlags, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecFromDisp (IDispatch *pdispIn, LCID lcid, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecFromBool (VARIANT_BOOL bIn, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecFromI1 (signed char cIn, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecFromUI2 (USHORT usIn, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecFromUI4 (ULONG ulIn, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecFromI8 (LONG64 llIn, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecFromUI8 (ULONG64 ullIn, DECIMAL *pDecOut)
static HRESULT	VARIANT_DecScale (const DECIMAL **ppDecLeft, const DECIMAL **ppDecRight, DECIMAL pDecOut[2])
static ULONG	VARIANT_Add (ULONG ulLeft, ULONG ulRight, ULONG *pulHigh)
static ULONG	VARIANT_Sub (ULONG ulLeft, ULONG ulRight, ULONG *pulHigh)
static ULONG	VARIANT_Mul (ULONG ulLeft, ULONG ulRight, ULONG *pulHigh)
static int	VARIANT_DecCmp (const DECIMAL *pDecLeft, const DECIMAL *pDecRight)
HRESULT WINAPI	VarDecAdd (const DECIMAL *pDecLeft, const DECIMAL *pDecRight, DECIMAL *pDecOut)
static void	VARIANT_DI_clear (VARIANT_DI *i)
static int	VARIANT_DI_mul (const VARIANT_DI *a, const VARIANT_DI *b, VARIANT_DI *result)
static BOOL	VARIANT_DI_tostringW (const VARIANT_DI *a, WCHAR *s, unsigned int n)
static void	VARIANT_int_shiftleft (DWORD *p, unsigned int n, unsigned int shift)
static unsigned char	VARIANT_int_add (DWORD *v, unsigned int nv, const DWORD *p, unsigned int np)
static void	VARIANT_int_div (DWORD *p, unsigned int n, const DWORD *divisor, unsigned int dn)
static unsigned char	VARIANT_int_mulbychar (DWORD *p, unsigned int n, unsigned char m)
static int	VARIANT_int_addlossy (DWORD *a, int *ascale, unsigned int an, DWORD *b, int *bscale, unsigned int bn)
static HRESULT	VARIANT_DI_div (const VARIANT_DI *dividend, const VARIANT_DI *divisor, VARIANT_DI *quotient, BOOL round_remainder)
static HRESULT	VARIANT_DI_normalize (VARIANT_DI *val, int exponent2, BOOL isDouble)
static HRESULT	VARIANT_do_division (const DECIMAL *pDecLeft, const DECIMAL *pDecRight, DECIMAL *pDecOut, BOOL round)
HRESULT WINAPI	VarDecDiv (const DECIMAL *pDecLeft, const DECIMAL *pDecRight, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecMul (const DECIMAL *pDecLeft, const DECIMAL *pDecRight, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecSub (const DECIMAL *pDecLeft, const DECIMAL *pDecRight, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecAbs (const DECIMAL *pDecIn, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecFix (const DECIMAL *pDecIn, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecInt (const DECIMAL *pDecIn, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecNeg (const DECIMAL *pDecIn, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecRound (const DECIMAL *pDecIn, int cDecimals, DECIMAL *pDecOut)
HRESULT WINAPI	VarDecCmp (const DECIMAL *pDecLeft, const DECIMAL *pDecRight)
HRESULT WINAPI	VarDecCmpR8 (const DECIMAL *pDecLeft, double dblRight)
HRESULT WINAPI	VarBoolFromUI1 (BYTE bIn, VARIANT_BOOL *pBoolOut)
HRESULT WINAPI	VarBoolFromI2 (SHORT sIn, VARIANT_BOOL *pBoolOut)
HRESULT WINAPI	VarBoolFromI4 (LONG lIn, VARIANT_BOOL *pBoolOut)
HRESULT WINAPI	VarBoolFromR4 (FLOAT fltIn, VARIANT_BOOL *pBoolOut)
HRESULT WINAPI	VarBoolFromR8 (double dblIn, VARIANT_BOOL *pBoolOut)
HRESULT WINAPI	VarBoolFromDate (DATE dateIn, VARIANT_BOOL *pBoolOut)
HRESULT WINAPI	VarBoolFromCy (CY cyIn, VARIANT_BOOL *pBoolOut)
static BOOL	VARIANT_GetLocalisedText (LANGID langId, DWORD dwId, WCHAR *lpszDest)
HRESULT WINAPI	VarBoolFromStr (OLECHAR *strIn, LCID lcid, ULONG dwFlags, VARIANT_BOOL *pBoolOut)
HRESULT WINAPI	VarBoolFromDisp (IDispatch *pdispIn, LCID lcid, VARIANT_BOOL *pBoolOut)
HRESULT WINAPI	VarBoolFromI1 (signed char cIn, VARIANT_BOOL *pBoolOut)
HRESULT WINAPI	VarBoolFromUI2 (USHORT usIn, VARIANT_BOOL *pBoolOut)
HRESULT WINAPI	VarBoolFromUI4 (ULONG ulIn, VARIANT_BOOL *pBoolOut)
HRESULT WINAPI	VarBoolFromDec (DECIMAL *pDecIn, VARIANT_BOOL *pBoolOut)
HRESULT WINAPI	VarBoolFromI8 (LONG64 llIn, VARIANT_BOOL *pBoolOut)
HRESULT WINAPI	VarBoolFromUI8 (ULONG64 ullIn, VARIANT_BOOL *pBoolOut)
static WCHAR *	VARIANT_WriteNumber (ULONG64 ulVal, WCHAR *szOut)
static BSTR	VARIANT_MakeBstr (LCID lcid, DWORD dwFlags, WCHAR *szOut)
static HRESULT	VARIANT_BstrFromUInt (ULONG64 ulVal, LCID lcid, DWORD dwFlags, BSTR *pbstrOut)
HRESULT WINAPI	VarBstrFromUI1 (BYTE bIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
HRESULT WINAPI	VarBstrFromI2 (short sIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
HRESULT WINAPI	VarBstrFromI4 (LONG lIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
static BSTR	VARIANT_BstrReplaceDecimal (const WCHAR *buff, LCID lcid, ULONG dwFlags)
static HRESULT	VARIANT_BstrFromReal (DOUBLE dblIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut, LPCWSTR lpszFormat)
HRESULT WINAPI	VarBstrFromR4 (FLOAT fltIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
HRESULT WINAPI	VarBstrFromR8 (double dblIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
HRESULT WINAPI	VarBstrFromCy (CY cyIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
static int	output_int_len (int o, int min_len, WCHAR *date, int date_len)
BOOL	get_date_format (LCID lcid, DWORD flags, const SYSTEMTIME *st, const WCHAR *fmt, WCHAR *date, int date_len)
HRESULT WINAPI	VarBstrFromDate (DATE dateIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
HRESULT WINAPI	VarBstrFromBool (VARIANT_BOOL boolIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
HRESULT WINAPI	VarBstrFromI1 (signed char cIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
HRESULT WINAPI	VarBstrFromUI2 (USHORT usIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
HRESULT WINAPI	VarBstrFromUI4 (ULONG ulIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
HRESULT WINAPI	VarBstrFromDec (DECIMAL *pDecIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
HRESULT WINAPI	VarBstrFromI8 (LONG64 llIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
HRESULT WINAPI	VarBstrFromUI8 (ULONG64 ullIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
HRESULT WINAPI	VarBstrFromDisp (IDispatch *pdispIn, LCID lcid, ULONG dwFlags, BSTR *pbstrOut)
HRESULT WINAPI	VarBstrCat (BSTR pbstrLeft, BSTR pbstrRight, BSTR *pbstrOut)
HRESULT WINAPI	VarBstrCmp (BSTR pbstrLeft, BSTR pbstrRight, LCID lcid, DWORD dwFlags)
HRESULT WINAPI	VarDateFromUI1 (BYTE bIn, DATE *pdateOut)
HRESULT WINAPI	VarDateFromI2 (short sIn, DATE *pdateOut)
HRESULT WINAPI	VarDateFromI4 (LONG lIn, DATE *pdateOut)
HRESULT WINAPI	VarDateFromR4 (FLOAT fltIn, DATE *pdateOut)
HRESULT WINAPI	VarDateFromR8 (double dblIn, DATE *pdateOut)
HRESULT WINAPI	VarDateFromDisp (IDispatch *pdispIn, LCID lcid, DATE *pdateOut)
HRESULT WINAPI	VarDateFromBool (VARIANT_BOOL boolIn, DATE *pdateOut)
HRESULT WINAPI	VarDateFromCy (CY cyIn, DATE *pdateOut)
static BOOL	VARIANT_IsValidMonthDay (DWORD day, DWORD month, DWORD year)
static HRESULT	VARIANT_MakeDate (DATEPARSE *dp, DWORD iDate, DWORD offset, SYSTEMTIME *st)
HRESULT WINAPI	VarDateFromStr (OLECHAR *strIn, LCID lcid, ULONG dwFlags, DATE *pdateOut)
HRESULT WINAPI	VarDateFromI1 (signed char cIn, DATE *pdateOut)
HRESULT WINAPI	VarDateFromUI2 (USHORT uiIn, DATE *pdateOut)
HRESULT WINAPI	VarDateFromUI4 (ULONG ulIn, DATE *pdateOut)
HRESULT WINAPI	VarDateFromDec (DECIMAL *pdecIn, DATE *pdateOut)
HRESULT WINAPI	VarDateFromI8 (LONG64 llIn, DATE *pdateOut)
HRESULT WINAPI	VarDateFromUI8 (ULONG64 ullIn, DATE *pdateOut)

Variables
HMODULE hProxyDll	DECLSPEC_HIDDEN
static const WCHAR	szFloatFormatW [] = { '%','.','7','G','\0' }
static const WCHAR	szDoubleFormatW [] = { '%','.','1','5','G','\0' }
static const int	CY_Divisors [5]

Macro Definition Documentation

BOTHTST

#define BOTHTST	(		dest,
			src,
			func,
			lo,
			hi
	)

Value:

  RETTYP _##func(src in, dest* out) { \
  if (in < (dest)lo || in > hi) return DISP_E_OVERFLOW; *out = in; return S_OK; }

Definition at line 162 of file vartype.c.

COBJMACROS

#define COBJMACROS

Definition at line 21 of file vartype.c.

CY_HALF

#define CY_HALF   (CY_MULTIPLIER/2) /* 0.5 */

Definition at line 40 of file vartype.c.

CY_HALF_F

#define CY_HALF_F   (CY_MULTIPLIER_F/2.0)

Definition at line 41 of file vartype.c.

CY_MULTIPLIER

#define CY_MULTIPLIER   10000 /* 4 dp of precision */

Definition at line 38 of file vartype.c.

CY_MULTIPLIER_F

#define CY_MULTIPLIER_F   10000.0

Definition at line 39 of file vartype.c.

DATE_SWAP

#define DATE_SWAP	(		x,
			y
	)		do { dwTemp = x; x = y; y = dwTemp; } while (0)

DP_AM

#define DP_AM   0x08 /* AM */

Definition at line 7358 of file vartype.c.

DP_DATESEP

#define DP_DATESEP   0x02 /* Date separator */

Definition at line 7356 of file vartype.c.

DP_MONTH

#define DP_MONTH   0x04 /* Month name */

Definition at line 7357 of file vartype.c.

DP_PM

#define DP_PM   0x10 /* PM */

Definition at line 7359 of file vartype.c.

DP_TIMESEP

#define DP_TIMESEP   0x01 /* Time separator ( _must_ remain 0x1, used as a bitmask) */

Definition at line 7355 of file vartype.c.

IsLeapYear

#define IsLeapYear

(

y

)

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

Definition at line 7371 of file vartype.c.

NEGTST

#define NEGTST	(		dest,
			src,
			func
	)

Value:

  RETTYP _##func(src in, dest* out) { \
  if (in < 0) return DISP_E_OVERFLOW; *out = in; return S_OK; }

Definition at line 154 of file vartype.c.

NONAMELESSSTRUCT

#define NONAMELESSSTRUCT

Definition at line 23 of file vartype.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 22 of file vartype.c.

ORDER_DMY

#define ORDER_DMY   0x08

Definition at line 7390 of file vartype.c.

ORDER_MDY

#define ORDER_MDY   0x01

Definition at line 7387 of file vartype.c.

ORDER_MYD

#define ORDER_MYD   0x10 /* Synthetic order, used only for funky 2 digit dates */

Definition at line 7391 of file vartype.c.

ORDER_YDM

#define ORDER_YDM   0x04

Definition at line 7389 of file vartype.c.

ORDER_YMD

#define ORDER_YMD   0x02

Definition at line 7388 of file vartype.c.

POSTST

#define POSTST	(		dest,
			src,
			func,
			tst
	)

Value:

  RETTYP _##func(src in, dest* out) { \
  if (in > (dest)tst) return DISP_E_OVERFLOW; *out = in; return S_OK; }

Definition at line 158 of file vartype.c.

RETTYP

#define RETTYP   static inline HRESULT

Definition at line 146 of file vartype.c.

SIMPLE

#define SIMPLE	(		dest,
			src,
			func
	)

Value:

  RETTYP _##func(src in, dest* out) { \
  *out = in; return S_OK; }

Definition at line 150 of file vartype.c.

TIMEFLAG

#define TIMEFLAG

(

i

)

((dp.dwFlags[i] & DP_TIMESEP) << i)

Definition at line 7369 of file vartype.c.

VARIANT_DutchRound

#define VARIANT_DutchRound	(		typ,
			value,
			res
	)

Value:

  do { \
  double whole = value < 0 ? ceil(value) : floor(value); \
  double fract = value - whole; \
  if (fract > 0.5) res = (typ)whole + (typ)1; \
  else if (fract == 0.5) { typ is_odd = (typ)whole & 1; res = whole + is_odd; } \
  else if (fract >= 0.0) res = (typ)whole; \
  else if (fract == -0.5) { typ is_odd = (typ)whole & 1; res = whole - is_odd; } \
  else if (fract > -0.5) res = (typ)whole; \
  else res = (typ)whole - (typ)1; \
} while(0)

Definition at line 77 of file vartype.c.

Typedef Documentation

DATEPARSE

typedef struct tagDATEPARSE DATEPARSE

VARIANT_DI

typedef struct DECIMAL_internal VARIANT_DI

Function Documentation

_VarR8FromCy()

RETTYP _VarR8FromCy	(	CY	i,
		double *	o
	)

Definition at line 255 of file vartype.c.

{ *o = (double)i.int64 / CY_MULTIPLIER_F; return S_OK; }

Referenced by VarCyAdd(), VarCyMul(), VarCyMulI4(), VarCyMulI8(), VarCyRound(), VarCySub(), and VarR8FromCy().

get_date_format()

BOOL get_date_format	(	LCID	lcid,
		DWORD	flags,
		const SYSTEMTIME *	st,
		const WCHAR *	fmt,
		WCHAR *	date,
		int	date_len
	)

Definition at line 6668 of file vartype.c.

{
    static const LCTYPE dayname[] = {
        LOCALE_SDAYNAME7, LOCALE_SDAYNAME1, LOCALE_SDAYNAME2, LOCALE_SDAYNAME3,
        LOCALE_SDAYNAME4, LOCALE_SDAYNAME5, LOCALE_SDAYNAME6
    };
    static const LCTYPE sdayname[] = {
        LOCALE_SABBREVDAYNAME7, LOCALE_SABBREVDAYNAME1, LOCALE_SABBREVDAYNAME2,
        LOCALE_SABBREVDAYNAME3, LOCALE_SABBREVDAYNAME4, LOCALE_SABBREVDAYNAME5,
        LOCALE_SABBREVDAYNAME6
    };
    static const LCTYPE monthname[] = {
        LOCALE_SMONTHNAME1, LOCALE_SMONTHNAME2, LOCALE_SMONTHNAME3, LOCALE_SMONTHNAME4,
        LOCALE_SMONTHNAME5, LOCALE_SMONTHNAME6, LOCALE_SMONTHNAME7, LOCALE_SMONTHNAME8,
        LOCALE_SMONTHNAME9, LOCALE_SMONTHNAME10, LOCALE_SMONTHNAME11, LOCALE_SMONTHNAME12
    };
    static const LCTYPE smonthname[] = {
        LOCALE_SABBREVMONTHNAME1, LOCALE_SABBREVMONTHNAME2, LOCALE_SABBREVMONTHNAME3,
        LOCALE_SABBREVMONTHNAME4, LOCALE_SABBREVMONTHNAME5, LOCALE_SABBREVMONTHNAME6,
        LOCALE_SABBREVMONTHNAME7, LOCALE_SABBREVMONTHNAME8, LOCALE_SABBREVMONTHNAME9,
        LOCALE_SABBREVMONTHNAME10, LOCALE_SABBREVMONTHNAME11, LOCALE_SABBREVMONTHNAME12
    };
 
    if(flags & ~(LOCALE_NOUSEROVERRIDE|VAR_DATEVALUEONLY))
        FIXME("ignoring flags %x\n", flags);
    flags &= LOCALE_NOUSEROVERRIDE;
 
    while(*fmt && date_len) {
        int count = 1;
 
        switch(*fmt) {
            case 'd':
            case 'M':
            case 'y':
            case 'g':
                while(*fmt == *(fmt+count))
                    count++;
                fmt += count-1;
        }
 
        switch(*fmt) {
        case 'd':
            if(count >= 4)
                count = GetLocaleInfoW(lcid, dayname[st->wDayOfWeek] | flags, date, date_len)-1;
            else if(count == 3)
                count = GetLocaleInfoW(lcid, sdayname[st->wDayOfWeek] | flags, date, date_len)-1;
            else
                count = output_int_len(st->wDay, count, date, date_len);
            break;
        case 'M':
            if(count >= 4)
                count = GetLocaleInfoW(lcid, monthname[st->wMonth-1] | flags, date, date_len)-1;
            else if(count == 3)
                count = GetLocaleInfoW(lcid, smonthname[st->wMonth-1] | flags, date, date_len)-1;
            else
                count = output_int_len(st->wMonth, count, date, date_len);
            break;
        case 'y':
            if(count >= 3)
                count = output_int_len(st->wYear, 0, date, date_len);
            else
                count = output_int_len(st->wYear%100, count, date, date_len);
            break;
        case 'g':
            if(count == 2) {
                FIXME("Should be using GetCalendarInfo(CAL_SERASTRING), defaulting to 'AD'\n");
 
                *date++ = 'A';
                date_len--;
                if(date_len)
                    *date = 'D';
                else
                    count = -1;
                break;
            }
        /* fall through */
        default:
            *date = *fmt;
        }
 
        if(count < 0)
            break;
        fmt++;
        date += count;
        date_len -= count;
    }
 
    if(!date_len)
        return FALSE;
    *date++ = 0;
    return TRUE;
}

Referenced by VarBstrFromDate(), and VARIANT_FormatDate().

output_int_len()

static int output_int_len ( int  o, int  min_len, WCHAR *  date, int  date_len  )

inlinestatic

Definition at line 6648 of file vartype.c.

{
    int len, tmp;
 
    if(min_len >= date_len)
        return -1;
 
    for(len=0, tmp=o; tmp; tmp/=10) len++;
    if(!len) len++;
    if(len >= date_len)
        return -1;
 
    for(tmp=min_len-len; tmp>0; tmp--)
        *date++ = '0';
    for(tmp=len; tmp>0; tmp--, o/=10)
        date[tmp-1] = '0' + o%10;
    return min_len>len ? min_len : len;
}

Referenced by get_date_format().

VarBoolFromCy()

HRESULT WINAPI VarBoolFromCy	(	CY	cyIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6048 of file vartype.c.

{
  *pBoolOut = cyIn.int64 ? VARIANT_TRUE : VARIANT_FALSE;
  return S_OK;
}

Referenced by test_VarBoolFromCy(), and VARIANT_Coerce().

VarBoolFromDate()

HRESULT WINAPI VarBoolFromDate	(	DATE	dateIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6030 of file vartype.c.

{
  *pBoolOut = dateIn ? VARIANT_TRUE : VARIANT_FALSE;
  return S_OK;
}

Referenced by test_VarBoolFromDate(), and VARIANT_Coerce().

VarBoolFromDec()

HRESULT WINAPI VarBoolFromDec	(	DECIMAL *	pDecIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6278 of file vartype.c.

{
  if (DEC_SCALE(pDecIn) > DEC_MAX_SCALE || (DEC_SIGN(pDecIn) & ~DECIMAL_NEG))
    return E_INVALIDARG;
 
  if (DEC_HI32(pDecIn) || DEC_MID32(pDecIn) || DEC_LO32(pDecIn))
    *pBoolOut = VARIANT_TRUE;
  else
    *pBoolOut = VARIANT_FALSE;
  return S_OK;
}

Referenced by test_VarBoolFromDec(), and VARIANT_Coerce().

VarBoolFromDisp()

HRESULT WINAPI VarBoolFromDisp	(	IDispatch *	pdispIn,
		LCID	lcid,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6206 of file vartype.c.

{
  return VARIANT_FromDisp(pdispIn, lcid, pBoolOut, VT_BOOL, 0);
}

Referenced by VARIANT_Coerce().

VarBoolFromI1()

HRESULT WINAPI VarBoolFromI1	(	signed char	cIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6223 of file vartype.c.

{
  *pBoolOut = cIn ? VARIANT_TRUE : VARIANT_FALSE;
  return S_OK;
}

Referenced by test_VarBoolFromI1(), and VARIANT_Coerce().

VarBoolFromI2()

HRESULT WINAPI VarBoolFromI2	(	SHORT	sIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 5958 of file vartype.c.

{
  *pBoolOut = sIn ? VARIANT_TRUE : VARIANT_FALSE;
  return S_OK;
}

Referenced by test_VarBoolFromI2(), and VARIANT_Coerce().

VarBoolFromI4()

HRESULT WINAPI VarBoolFromI4	(	LONG	lIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 5976 of file vartype.c.

{
  *pBoolOut = lIn ? VARIANT_TRUE : VARIANT_FALSE;
  return S_OK;
}

Referenced by test_VarBoolFromI4(), test_VarBoolFromUI4(), and VARIANT_Coerce().

VarBoolFromI8()

HRESULT WINAPI VarBoolFromI8	(	LONG64	llIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6302 of file vartype.c.

{
  *pBoolOut = llIn ? VARIANT_TRUE : VARIANT_FALSE;
  return S_OK;
}

Referenced by test_VarBoolFromI8(), and VARIANT_Coerce().

VarBoolFromR4()

HRESULT WINAPI VarBoolFromR4	(	FLOAT	fltIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 5994 of file vartype.c.

{
  *pBoolOut = fltIn ? VARIANT_TRUE : VARIANT_FALSE;
  return S_OK;
}

Referenced by test_VarBoolFromR4(), and VARIANT_Coerce().

VarBoolFromR8()

HRESULT WINAPI VarBoolFromR8	(	double	dblIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6012 of file vartype.c.

{
  *pBoolOut = dblIn ? VARIANT_TRUE : VARIANT_FALSE;
  return S_OK;
}

Referenced by test_VarBoolFromR8(), and VARIANT_Coerce().

VarBoolFromStr()

HRESULT WINAPI VarBoolFromStr	(	OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6114 of file vartype.c.

{
  /* Any VB/VBA programmers out there should recognise these strings... */
  static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
  static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
  WCHAR szBuff[64];
  LANGID langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
  HRESULT hRes = S_OK;
 
  if (!strIn || !pBoolOut)
    return DISP_E_TYPEMISMATCH;
 
  /* Check if we should be comparing against localised text */
  if (dwFlags & VAR_LOCALBOOL)
  {
    /* Convert our LCID into a usable value */
    lcid = ConvertDefaultLocale(lcid);
 
    langId = LANGIDFROMLCID(lcid);
 
    if (PRIMARYLANGID(langId) == LANG_NEUTRAL)
      langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
 
    /* Note: Native oleaut32 always copies strIn and maps halfwidth characters.
     * I don't think this is needed unless any of the localised text strings
     * contain characters that can be so mapped. In the event that this is
     * true for a given language (possibly some Asian languages), then strIn
     * should be mapped here _only_ if langId is an Id for which this can occur.
     */
  }
 
  /* Note that if we are not comparing against localised strings, langId
   * will have its default value of LANG_ENGLISH. This allows us to mimic
   * the native behaviour of always checking against English strings even
   * after we've checked for localised ones.
   */
VarBoolFromStr_CheckLocalised:
  if (VARIANT_GetLocalisedText(langId, IDS_TRUE, szBuff))
  {
    /* Compare against localised strings, ignoring case */
    if (!wcsicmp(strIn, szBuff))
    {
      *pBoolOut = VARIANT_TRUE; /* Matched localised 'true' text */
      return hRes;
    }
    VARIANT_GetLocalisedText(langId, IDS_FALSE, szBuff);
    if (!wcsicmp(strIn, szBuff))
    {
      *pBoolOut = VARIANT_FALSE; /* Matched localised 'false' text */
      return hRes;
    }
  }
 
  if (langId != MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT))
  {
    /* We have checked the localised text, now check English */
    langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
    goto VarBoolFromStr_CheckLocalised;
  }
 
  /* All checks against localised text have failed, try #TRUE#/#FALSE# */
  if (!wcscmp(strIn, szFalse))
    *pBoolOut = VARIANT_FALSE;
  else if (!wcscmp(strIn, szTrue))
    *pBoolOut = VARIANT_TRUE;
  else
  {
    double d;
 
    /* If this string is a number, convert it as one */
    hRes = VarR8FromStr(strIn, lcid, dwFlags, &d);
    if (SUCCEEDED(hRes)) *pBoolOut = d ? VARIANT_TRUE : VARIANT_FALSE;
  }
  return hRes;
}

Referenced by test_VarBoolFromStr(), VarAnd(), VARIANT_Coerce(), VarImp(), VarNot(), and VarOr().

VarBoolFromUI1()

HRESULT WINAPI VarBoolFromUI1	(	BYTE	bIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 5940 of file vartype.c.

{
  *pBoolOut = bIn ? VARIANT_TRUE : VARIANT_FALSE;
  return S_OK;
}

Referenced by test_VarBoolFromUI1(), and VARIANT_Coerce().

VarBoolFromUI2()

HRESULT WINAPI VarBoolFromUI2	(	USHORT	usIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6241 of file vartype.c.

{
  *pBoolOut = usIn ? VARIANT_TRUE : VARIANT_FALSE;
  return S_OK;
}

Referenced by test_VarBoolFromUI2(), and VARIANT_Coerce().

VarBoolFromUI4()

HRESULT WINAPI VarBoolFromUI4	(	ULONG	ulIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6259 of file vartype.c.

{
  *pBoolOut = ulIn ? VARIANT_TRUE : VARIANT_FALSE;
  return S_OK;
}

Referenced by VARIANT_Coerce().

VarBoolFromUI8()

HRESULT WINAPI VarBoolFromUI8	(	ULONG64	ullIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6320 of file vartype.c.

{
  *pBoolOut = ullIn ? VARIANT_TRUE : VARIANT_FALSE;
  return S_OK;
}

Referenced by test_VarBoolFromUI8(), and VARIANT_Coerce().

VarBstrCat()

HRESULT WINAPI VarBstrCat	(	BSTR	pbstrLeft,
		BSTR	pbstrRight,
		BSTR *	pbstrOut
	)

Definition at line 7107 of file vartype.c.

{
  unsigned int lenLeft, lenRight;
 
  TRACE("%s,%s,%p\n",
   debugstr_wn(pbstrLeft, SysStringLen(pbstrLeft)),
   debugstr_wn(pbstrRight, SysStringLen(pbstrRight)), pbstrOut);
 
  if (!pbstrOut)
    return E_INVALIDARG;
 
  /* use byte length here to properly handle ansi-allocated BSTRs */
  lenLeft = pbstrLeft ? SysStringByteLen(pbstrLeft) : 0;
  lenRight = pbstrRight ? SysStringByteLen(pbstrRight) : 0;
 
  *pbstrOut = SysAllocStringByteLen(NULL, lenLeft + lenRight);
  if (!*pbstrOut)
    return E_OUTOFMEMORY;
 
  (*pbstrOut)[0] = '\0';
 
  if (pbstrLeft)
    memcpy(*pbstrOut, pbstrLeft, lenLeft);
 
  if (pbstrRight)
    memcpy((CHAR*)*pbstrOut + lenLeft, pbstrRight, lenRight);
 
  TRACE("%s\n", debugstr_wn(*pbstrOut, SysStringLen(*pbstrOut)));
  return S_OK;
}

Referenced by test_VarBstrCat(), VarAdd(), and VarCat().

VarBstrCmp()

HRESULT WINAPI VarBstrCmp	(	BSTR	pbstrLeft,
		BSTR	pbstrRight,
		LCID	lcid,
		DWORD	dwFlags
	)

Definition at line 7158 of file vartype.c.

{
    HRESULT hres;
    int ret;
 
    TRACE("%s,%s,%d,%08x\n",
     debugstr_wn(pbstrLeft, SysStringLen(pbstrLeft)),
     debugstr_wn(pbstrRight, SysStringLen(pbstrRight)), lcid, dwFlags);
 
    if (!pbstrLeft || !*pbstrLeft)
    {
      if (pbstrRight && *pbstrRight)
        return VARCMP_LT;
    }
    else if (!pbstrRight || !*pbstrRight)
        return VARCMP_GT;
 
    if (lcid == 0)
    {
      unsigned int lenLeft = SysStringByteLen(pbstrLeft);
      unsigned int lenRight = SysStringByteLen(pbstrRight);
      ret = memcmp(pbstrLeft, pbstrRight, min(lenLeft, lenRight));
      if (ret < 0)
        return VARCMP_LT;
      if (ret > 0)
        return VARCMP_GT;
      if (lenLeft < lenRight)
        return VARCMP_LT;
      if (lenLeft > lenRight)
        return VARCMP_GT;
      return VARCMP_EQ;
    }
    else
    {
      unsigned int lenLeft = SysStringLen(pbstrLeft);
      unsigned int lenRight = SysStringLen(pbstrRight);
 
      if (lenLeft == 0 || lenRight == 0)
      {
          if (lenLeft == 0 && lenRight == 0) return VARCMP_EQ;
          return lenLeft < lenRight ? VARCMP_LT : VARCMP_GT;
      }
 
      hres = CompareStringW(lcid, dwFlags, pbstrLeft, lenLeft,
              pbstrRight, lenRight) - CSTR_LESS_THAN;
      TRACE("%d\n", hres);
      return hres;
    }
}

Referenced by START_TEST(), and VarCmp().

VarBstrFromBool()

HRESULT WINAPI VarBstrFromBool	(	VARIANT_BOOL	boolIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 6852 of file vartype.c.

{
  WCHAR szBuff[64];
  DWORD dwResId = IDS_TRUE;
  LANGID langId;
 
  TRACE("%d,0x%08x,0x%08x,%p\n", boolIn, lcid, dwFlags, pbstrOut);
 
  if (!pbstrOut)
    return E_INVALIDARG;
 
  /* VAR_BOOLONOFF and VAR_BOOLYESNO are internal flags used
   * for variant formatting */
  switch (dwFlags & (VAR_LOCALBOOL|VAR_BOOLONOFF|VAR_BOOLYESNO))
  {
  case VAR_BOOLONOFF:
      dwResId = IDS_ON;
      break;
  case VAR_BOOLYESNO:
      dwResId = IDS_YES;
      break;
  case VAR_LOCALBOOL:
      break;
  default:
    lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),SORT_DEFAULT);
  }
 
  lcid = ConvertDefaultLocale(lcid);
  langId = LANGIDFROMLCID(lcid);
  if (PRIMARYLANGID(langId) == LANG_NEUTRAL)
    langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
 
  if (boolIn == VARIANT_FALSE)
    dwResId++; /* Use negative form */
 
VarBstrFromBool_GetLocalised:
  if (VARIANT_GetLocalisedText(langId, dwResId, szBuff))
  {
    *pbstrOut = SysAllocString(szBuff);
    return *pbstrOut ? S_OK : E_OUTOFMEMORY;
  }
 
  if (langId != MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT))
  {
    langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
    goto VarBstrFromBool_GetLocalised;
  }
 
  /* Should never get here */
  WARN("Failed to load bool text!\n");
  return E_OUTOFMEMORY;
}

Referenced by init(), VARIANT_Coerce(), and VARIANT_FormatNumber().

VarBstrFromCy()

HRESULT WINAPI VarBstrFromCy	(	CY	cyIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 6608 of file vartype.c.

{
  WCHAR buff[256];
  VARIANT_DI decVal;
 
  if (!pbstrOut)
    return E_INVALIDARG;
 
  decVal.scale = 4;
  decVal.sign = 0;
  decVal.bitsnum[0] = cyIn.s.Lo;
  decVal.bitsnum[1] = cyIn.s.Hi;
  if (cyIn.s.Hi & 0x80000000UL) {
    DWORD one = 1;
 
    /* Negative number! */
    decVal.sign = 1;
    decVal.bitsnum[0] = ~decVal.bitsnum[0];
    decVal.bitsnum[1] = ~decVal.bitsnum[1];
    VARIANT_int_add(decVal.bitsnum, 3, &one, 1);
  }
  decVal.bitsnum[2] = 0;
  VARIANT_DI_tostringW(&decVal, buff, ARRAY_SIZE(buff));
 
  if (dwFlags & LOCALE_USE_NLS)
  {
    WCHAR cybuff[256];
 
    /* Format the currency for the locale */
    cybuff[0] = '\0';
    GetCurrencyFormatW(lcid, dwFlags & LOCALE_NOUSEROVERRIDE,
                       buff, NULL, cybuff, ARRAY_SIZE(cybuff));
    *pbstrOut = SysAllocString(cybuff);
  }
  else
    *pbstrOut = VARIANT_BstrReplaceDecimal(buff,lcid,dwFlags);
 
  return *pbstrOut ? S_OK : E_OUTOFMEMORY;
}

Referenced by _BSTR_CY(), and VARIANT_Coerce().

VarBstrFromDate()

HRESULT WINAPI VarBstrFromDate	(	DATE	dateIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 6778 of file vartype.c.

{
  SYSTEMTIME st;
  DWORD dwFormatFlags = dwFlags & LOCALE_NOUSEROVERRIDE;
  WCHAR date[128], fmt_buff[80], *time;
 
  TRACE("(%g,0x%08x,0x%08x,%p)\n", dateIn, lcid, dwFlags, pbstrOut);
 
  if (!pbstrOut || !VariantTimeToSystemTime(dateIn, &st))
    return E_INVALIDARG;
 
  *pbstrOut = NULL;
 
  if (dwFlags & VAR_CALENDAR_THAI)
      st.wYear += 553; /* Use the Thai buddhist calendar year */
  else if (dwFlags & (VAR_CALENDAR_HIJRI|VAR_CALENDAR_GREGORIAN))
      FIXME("VAR_CALENDAR_HIJRI/VAR_CALENDAR_GREGORIAN not handled\n");
 
  if (dwFlags & LOCALE_USE_NLS)
    dwFlags &= ~(VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY);
  else
  {
    double whole = dateIn < 0 ? ceil(dateIn) : floor(dateIn);
    double partial = dateIn - whole;
 
    if (whole == 0.0)
      dwFlags |= VAR_TIMEVALUEONLY;
    else if (partial > -1e-12 && partial < 1e-12)
      dwFlags |= VAR_DATEVALUEONLY;
  }
 
  if (dwFlags & VAR_TIMEVALUEONLY)
    date[0] = '\0';
  else
    if (!GetLocaleInfoW(lcid, LOCALE_SSHORTDATE, fmt_buff, ARRAY_SIZE(fmt_buff)) ||
        !get_date_format(lcid, dwFlags, &st, fmt_buff, date, ARRAY_SIZE(date)))
      return E_INVALIDARG;
 
  if (!(dwFlags & VAR_DATEVALUEONLY))
  {
    time = date + lstrlenW(date);
    if (time != date)
      *time++ = ' ';
    if (!GetTimeFormatW(lcid, dwFormatFlags, &st, NULL, time, ARRAY_SIZE(date)-(time-date)))
      return E_INVALIDARG;
  }
 
  *pbstrOut = SysAllocString(date);
  if (*pbstrOut)
    TRACE("returning %s\n", debugstr_w(*pbstrOut));
  return *pbstrOut ? S_OK : E_OUTOFMEMORY;
}

Referenced by _BSTR_DATE(), VARIANT_Coerce(), and VARIANT_FormatDate().

VarBstrFromDec()

HRESULT WINAPI VarBstrFromDec	(	DECIMAL *	pDecIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 6991 of file vartype.c.

{
  WCHAR buff[256];
  VARIANT_DI temp;
 
  if (!pbstrOut)
    return E_INVALIDARG;
 
  VARIANT_DIFromDec(pDecIn, &temp);
  VARIANT_DI_tostringW(&temp, buff, 256);
 
  if (dwFlags & LOCALE_USE_NLS)
  {
    WCHAR numbuff[256];
 
    /* Format the number for the locale */
    numbuff[0] = '\0';
    GetNumberFormatW(lcid, dwFlags & LOCALE_NOUSEROVERRIDE,
                     buff, NULL, numbuff, ARRAY_SIZE(numbuff));
    TRACE("created NLS string %s\n", debugstr_w(numbuff));
    *pbstrOut = SysAllocString(numbuff);
  }
  else
  {
    *pbstrOut = VARIANT_BstrReplaceDecimal(buff, lcid, dwFlags);
  }
  
  TRACE("returning %s\n", debugstr_w(*pbstrOut));
  return *pbstrOut ? S_OK : E_OUTOFMEMORY;
}

Referenced by _BSTR_DEC(), and VARIANT_Coerce().

VarBstrFromDisp()

HRESULT WINAPI VarBstrFromDisp	(	IDispatch *	pdispIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 7087 of file vartype.c.

{
  return VARIANT_FromDisp(pdispIn, lcid, pbstrOut, VT_BSTR, dwFlags);
}

Referenced by VARIANT_Coerce().

VarBstrFromI1()

HRESULT WINAPI VarBstrFromI1	(	signed char	cIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 6921 of file vartype.c.

{
  ULONG64 ul64 = cIn;
 
  if (cIn < 0)
  {
    ul64 = -cIn;
    dwFlags |= VAR_NEGATIVE;
  }
  return VARIANT_BstrFromUInt(ul64, lcid, dwFlags, pbstrOut);
}

Referenced by VARIANT_Coerce().

VarBstrFromI2()

HRESULT WINAPI VarBstrFromI2	(	short	sIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 6417 of file vartype.c.

{
  ULONG64 ul64 = sIn;
 
  if (sIn < 0)
  {
    ul64 = -sIn;
    dwFlags |= VAR_NEGATIVE;
  }
  return VARIANT_BstrFromUInt(ul64, lcid, dwFlags, pbstrOut);
}

Referenced by VARIANT_Coerce().

VarBstrFromI4()

HRESULT WINAPI VarBstrFromI4	(	LONG	lIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 6445 of file vartype.c.

{
  ULONG64 ul64 = lIn;
 
  if (lIn < 0)
  {
    ul64 = -(LONG64)lIn;
    dwFlags |= VAR_NEGATIVE;
  }
  return VARIANT_BstrFromUInt(ul64, lcid, dwFlags, pbstrOut);
}

Referenced by test_VarBstrFromI4(), var2str(), and VARIANT_Coerce().

VarBstrFromI8()

HRESULT WINAPI VarBstrFromI8	(	LONG64	llIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 7038 of file vartype.c.

{
  ULONG64 ul64 = llIn;
 
  if (llIn < 0)
  {
    ul64 = -llIn;
    dwFlags |= VAR_NEGATIVE;
  }
  return VARIANT_BstrFromUInt(ul64, lcid, dwFlags, pbstrOut);
}

Referenced by VARIANT_Coerce().

VarBstrFromR4()

HRESULT WINAPI VarBstrFromR4	(	FLOAT	fltIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 6566 of file vartype.c.

{
  return VARIANT_BstrFromReal(fltIn, lcid, dwFlags, pbstrOut, szFloatFormatW);
}

Referenced by test_VarBstrFromR4(), var2str(), and VARIANT_Coerce().

VarBstrFromR8()

HRESULT WINAPI VarBstrFromR8	(	double	dblIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 6587 of file vartype.c.

{
  return VARIANT_BstrFromReal(dblIn, lcid, dwFlags, pbstrOut, szDoubleFormatW);
}

Referenced by Global_InvokeEx(), var2str(), and VARIANT_Coerce().

VarBstrFromUI1()

HRESULT WINAPI VarBstrFromUI1	(	BYTE	bIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 6396 of file vartype.c.

{
  return VARIANT_BstrFromUInt(bIn, lcid, dwFlags, pbstrOut);
}

Referenced by VARIANT_Coerce().

VarBstrFromUI2()

HRESULT WINAPI VarBstrFromUI2	(	USHORT	usIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 6949 of file vartype.c.

{
  return VARIANT_BstrFromUInt(usIn, lcid, dwFlags, pbstrOut);
}

Referenced by VARIANT_Coerce().

VarBstrFromUI4()

HRESULT WINAPI VarBstrFromUI4	(	ULONG	ulIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 6970 of file vartype.c.

{
  return VARIANT_BstrFromUInt(ulIn, lcid, dwFlags, pbstrOut);
}

Referenced by VARIANT_Coerce().

VarBstrFromUI8()

HRESULT WINAPI VarBstrFromUI8	(	ULONG64	ullIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 7066 of file vartype.c.

{
  return VARIANT_BstrFromUInt(ullIn, lcid, dwFlags, pbstrOut);
}

Referenced by VARIANT_Coerce().

VarCyAbs()

HRESULT WINAPI VarCyAbs	(	CY	cyIn,
		CY *	pCyOut
	)

Definition at line 3876 of file vartype.c.

{
  if (cyIn.s.Hi == (int)0x80000000 && !cyIn.s.Lo)
    return DISP_E_OVERFLOW;
 
  pCyOut->int64 = cyIn.int64 < 0 ? -cyIn.int64 : cyIn.int64;
  return S_OK;
}

Referenced by test_VarCyAbs(), and VarAbs().

VarCyAdd()

HRESULT WINAPI VarCyAdd	(	CY	cyLeft,
		CY	cyRight,
		CY *	pCyOut
	)

Definition at line 3785 of file vartype.c.

{
  double l,r;
  _VarR8FromCy(cyLeft, &l);
  _VarR8FromCy(cyRight, &r);
  l = l + r;
  return VarCyFromR8(l, pCyOut);
}

Referenced by test_VarCyAdd(), and VarAdd().

VarCyCmp()

HRESULT WINAPI VarCyCmp	(	CY	cyLeft,
		CY	cyRight
	)

Definition at line 4012 of file vartype.c.

{
  HRESULT hRet;
  CY result;
 
  /* Subtract right from left, and compare the result to 0 */
  hRet = VarCySub(cyLeft, cyRight, &result);
 
  if (SUCCEEDED(hRet))
  {
    if (result.int64 < 0)
      hRet = (HRESULT)VARCMP_LT;
    else if (result.int64 > 0)
      hRet = (HRESULT)VARCMP_GT;
    else
      hRet = (HRESULT)VARCMP_EQ;
  }
  return hRet;
}

Referenced by VarCmp(), and VarCyCmpR8().

VarCyCmpR8()

HRESULT WINAPI VarCyCmpR8	(	CY	cyLeft,
		double	dblRight
	)

Definition at line 4046 of file vartype.c.

{
  HRESULT hRet;
  CY cyRight;
 
  hRet = VarCyFromR8(dblRight, &cyRight);
 
  if (SUCCEEDED(hRet))
    hRet = VarCyCmp(cyLeft, cyRight);
 
  return hRet;
}

VarCyFix()

HRESULT WINAPI VarCyFix	(	CY	cyIn,
		CY *	pCyOut
	)

Definition at line 3902 of file vartype.c.

{
  pCyOut->int64 = cyIn.int64 / CY_MULTIPLIER;
  pCyOut->int64 *= CY_MULTIPLIER;
  return S_OK;
}

Referenced by VarFix().

VarCyFromBool()

HRESULT WINAPI VarCyFromBool	(	VARIANT_BOOL	boolIn,
		CY *	pCyOut
	)

Definition at line 3620 of file vartype.c.

{
    pCyOut->int64 = (LONG64)boolIn * CY_MULTIPLIER;
    return S_OK;
}

Referenced by test_VarCyFromBool(), and VARIANT_Coerce().

VarCyFromDate()

HRESULT WINAPI VarCyFromDate	(	DATE	dateIn,
		CY *	pCyOut
	)

Definition at line 3553 of file vartype.c.

{
  return VarCyFromR8(dateIn, pCyOut);
}

Referenced by test_VarCyFromDate(), and VARIANT_Coerce().

VarCyFromDec()

HRESULT WINAPI VarCyFromDec	(	DECIMAL *	pdecIn,
		CY *	pCyOut
	)

Definition at line 3704 of file vartype.c.

{
  DECIMAL rounded;
  HRESULT hRet;
 
  hRet = VarDecRound(pdecIn, 4, &rounded);
 
  if (SUCCEEDED(hRet))
  {
    double d;
 
    if (DEC_HI32(&rounded))
      return DISP_E_OVERFLOW;
 
    /* Note: Without the casts this promotes to int64 which loses precision */
    d = (double)DEC_LO64(&rounded) / (double)CY_Divisors[DEC_SCALE(&rounded)];
    if (DEC_SIGN(&rounded))
      d = -d;
    return VarCyFromR8(d, pCyOut);
  }
  return hRet;
}

Referenced by test_VarCyFromDec(), and VARIANT_Coerce().

VarCyFromDisp()

HRESULT WINAPI VarCyFromDisp	(	IDispatch *	pdispIn,
		LCID	lcid,
		CY *	pCyOut
	)

Definition at line 3596 of file vartype.c.

{
  return VARIANT_FromDisp(pdispIn, lcid, pCyOut, VT_CY, 0);
}

Referenced by VARIANT_Coerce().

VarCyFromI1()

HRESULT WINAPI VarCyFromI1	(	signed char	cIn,
		CY *	pCyOut
	)

Definition at line 3641 of file vartype.c.

{
    pCyOut->int64 = (LONG64)cIn * CY_MULTIPLIER;
    return S_OK;
}

Referenced by test_VarCyFromI1(), and VARIANT_Coerce().

VarCyFromI2()

HRESULT WINAPI VarCyFromI2	(	SHORT	sIn,
		CY *	pCyOut
	)

Definition at line 3441 of file vartype.c.

{
    pCyOut->int64 = (LONG64)sIn * CY_MULTIPLIER;
    return S_OK;
}

Referenced by test_VarCyFromI2(), and VARIANT_Coerce().

VarCyFromI4()

HRESULT WINAPI VarCyFromI4	(	LONG	lIn,
		CY *	pCyOut
	)

Definition at line 3462 of file vartype.c.

{
    pCyOut->int64 = (LONG64)lIn * CY_MULTIPLIER;
    return S_OK;
}

Referenced by test_VarAdd(), test_VarCyFromI4(), test_VarDiv(), test_VarIdiv(), test_VarImp(), test_VarMul(), test_VarPow(), test_VarSub(), and VARIANT_Coerce().

VarCyFromI8()

HRESULT WINAPI VarCyFromI8	(	LONG64	llIn,
		CY *	pCyOut
	)

Definition at line 3742 of file vartype.c.

{
  if (llIn <= (I8_MIN/CY_MULTIPLIER) || llIn >= (I8_MAX/CY_MULTIPLIER)) return DISP_E_OVERFLOW;
  pCyOut->int64 = llIn * CY_MULTIPLIER;
  return S_OK;
}

Referenced by test_VarCyFromI8(), and VARIANT_Coerce().

VarCyFromR4()

HRESULT WINAPI VarCyFromR4	(	FLOAT	fltIn,
		CY *	pCyOut
	)

Definition at line 3483 of file vartype.c.

{
  return VarCyFromR8(fltIn, pCyOut);
}

Referenced by test_VarCyFromR4(), and VARIANT_Coerce().

VarCyFromR8()

HRESULT WINAPI VarCyFromR8	(	double	dblIn,
		CY *	pCyOut
	)

Definition at line 3503 of file vartype.c.

{
#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
  /* This code gives identical results to Win32 on Intel.
   * Here we use fp exceptions to catch overflows when storing the value.
   */
  static const unsigned short r8_fpcontrol = 0x137f;
  static const double r8_multiplier = CY_MULTIPLIER_F;
  unsigned short old_fpcontrol, result_fpstatus;
 
  /* Clear exceptions, save the old fp state and load the new state */
  __asm__ __volatile__( "fnclex" );
  __asm__ __volatile__( "fstcw %0"   :   "=m" (old_fpcontrol) : );
  __asm__ __volatile__( "fldcw %0"   : : "m"  (r8_fpcontrol) );
  /* Perform the conversion. */
  __asm__ __volatile__( "fldl  %0"   : : "m"  (dblIn) );
  __asm__ __volatile__( "fmull %0"   : : "m"  (r8_multiplier) );
  __asm__ __volatile__( "fistpll %0" : : "m"  (*pCyOut) );
  /* Save the resulting fp state, load the old state and clear exceptions */
  __asm__ __volatile__( "fstsw %0"   :   "=m" (result_fpstatus) : );
  __asm__ __volatile__( "fnclex" );
  __asm__ __volatile__( "fldcw %0"   : : "m"  (old_fpcontrol) );
 
  if (result_fpstatus & 0x9) /* Overflow | Invalid */
    return DISP_E_OVERFLOW;
#else
  /* This version produces slightly different results for boundary cases */
  if (dblIn < -922337203685477.5807 || dblIn >= 922337203685477.5807)
    return DISP_E_OVERFLOW;
  dblIn *= CY_MULTIPLIER_F;
  VARIANT_DutchRound(LONG64, dblIn, pCyOut->int64);
#endif
  return S_OK;
}

Referenced by test_VarCyFromDate(), test_VarCyFromR8(), VarCyAdd(), VarCyCmpR8(), VarCyFromDate(), VarCyFromDec(), VarCyFromR4(), VarCyMul(), VarCyMulI4(), VarCyMulI8(), VarCySub(), VARIANT_Coerce(), and VarNumFromParseNum().

VarCyFromStr()

HRESULT WINAPI VarCyFromStr	(	OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		CY *	pCyOut
	)

Definition at line 3575 of file vartype.c.

{
  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pCyOut, VT_CY);
}

Referenced by VARIANT_Coerce().

VarCyFromUI1()

HRESULT WINAPI VarCyFromUI1	(	BYTE	bIn,
		CY *	pCyOut
	)

Definition at line 3420 of file vartype.c.

{
    pCyOut->int64 = (ULONG64)bIn * CY_MULTIPLIER;
    return S_OK;
}

Referenced by test_VarCyFromUI1(), and VARIANT_Coerce().

VarCyFromUI2()

HRESULT WINAPI VarCyFromUI2	(	USHORT	usIn,
		CY *	pCyOut
	)

Definition at line 3662 of file vartype.c.

{
    pCyOut->int64 = (ULONG64)usIn * CY_MULTIPLIER;
    return S_OK;
}

Referenced by test_VarCyFromUI2(), and VARIANT_Coerce().

VarCyFromUI4()

HRESULT WINAPI VarCyFromUI4	(	ULONG	ulIn,
		CY *	pCyOut
	)

Definition at line 3683 of file vartype.c.

{
    pCyOut->int64 = (ULONG64)ulIn * CY_MULTIPLIER;
    return S_OK;
}

Referenced by test_VarCyFromUI4(), and VARIANT_Coerce().

VarCyFromUI8()

HRESULT WINAPI VarCyFromUI8	(	ULONG64	ullIn,
		CY *	pCyOut
	)

Definition at line 3764 of file vartype.c.

{
    if (ullIn > (I8_MAX/CY_MULTIPLIER)) return DISP_E_OVERFLOW;
    pCyOut->int64 = ullIn * CY_MULTIPLIER;
    return S_OK;
}

Referenced by test_VarCyFromUI8(), and VARIANT_Coerce().

VarCyInt()

HRESULT WINAPI VarCyInt	(	CY	cyIn,
		CY *	pCyOut
	)

Definition at line 3926 of file vartype.c.

{
  pCyOut->int64 = cyIn.int64 / CY_MULTIPLIER;
  pCyOut->int64 *= CY_MULTIPLIER;
 
  if (cyIn.int64 < 0 && cyIn.int64 % CY_MULTIPLIER != 0)
  {
    pCyOut->int64 -= CY_MULTIPLIER;
  }
  return S_OK;
}

Referenced by VarInt().

VarCyMul()

HRESULT WINAPI VarCyMul	(	CY	cyLeft,
		CY	cyRight,
		CY *	pCyOut
	)

Definition at line 3808 of file vartype.c.

{
  double l,r;
  _VarR8FromCy(cyLeft, &l);
  _VarR8FromCy(cyRight, &r);
  l = l * r;
  return VarCyFromR8(l, pCyOut);
}

Referenced by test_VarCyMul(), and VarMul().

VarCyMulI4()

HRESULT WINAPI VarCyMulI4	(	CY	cyLeft,
		LONG	lRight,
		CY *	pCyOut
	)

Definition at line 3831 of file vartype.c.

{
  double d;
 
  _VarR8FromCy(cyLeft, &d);
  d = d * lRight;
  return VarCyFromR8(d, pCyOut);
}

VarCyMulI8()

HRESULT WINAPI VarCyMulI8	(	CY	cyLeft,
		LONG64	llRight,
		CY *	pCyOut
	)

Definition at line 4073 of file vartype.c.

{
  double d;
 
  _VarR8FromCy(cyLeft, &d);
  d = d  * (double)llRight;
  return VarCyFromR8(d, pCyOut);
}

VarCyNeg()

HRESULT WINAPI VarCyNeg	(	CY	cyIn,
		CY *	pCyOut
	)

Definition at line 3951 of file vartype.c.

{
  if (cyIn.s.Hi == (int)0x80000000 && !cyIn.s.Lo)
    return DISP_E_OVERFLOW;
 
  pCyOut->int64 = -cyIn.int64;
  return S_OK;
}

Referenced by test_VarCyNeg(), and VarNeg().

VarCyRound()

HRESULT WINAPI VarCyRound	(	CY	cyIn,
		int	cDecimals,
		CY *	pCyOut
	)

Definition at line 3974 of file vartype.c.

{
  if (cDecimals < 0)
    return E_INVALIDARG;
 
  if (cDecimals > 3)
  {
    /* Rounding to more precision than we have */
    *pCyOut = cyIn;
    return S_OK;
  }
  else
  {
    double d, div = CY_Divisors[cDecimals];
 
    _VarR8FromCy(cyIn, &d);
    d = d * div;
    VARIANT_DutchRound(LONGLONG, d, pCyOut->int64);
    d = (double)pCyOut->int64 / div * CY_MULTIPLIER_F;
    VARIANT_DutchRound(LONGLONG, d, pCyOut->int64);
    return S_OK;
  }
}

VarCySub()

HRESULT WINAPI VarCySub	(	CY	cyLeft,
		CY	cyRight,
		CY *	pCyOut
	)

Definition at line 3854 of file vartype.c.

{
  double l,r;
  _VarR8FromCy(cyLeft, &l);
  _VarR8FromCy(cyRight, &r);
  l = l - r;
  return VarCyFromR8(l, pCyOut);
}

Referenced by test_VarCySub(), VarCyCmp(), and VarSub().

VarDateFromBool()

HRESULT WINAPI VarDateFromBool	(	VARIANT_BOOL	boolIn,
		DATE *	pdateOut
	)

Definition at line 7332 of file vartype.c.

{
  return VarR8FromBool(boolIn, pdateOut);
}

Referenced by test_VarDateFromBool(), and VARIANT_Coerce().

VarDateFromCy()

HRESULT WINAPI VarDateFromCy	(	CY	cyIn,
		DATE *	pdateOut
	)

Definition at line 7349 of file vartype.c.

{
  return VarR8FromCy(cyIn, pdateOut);
}

Referenced by test_VarDateFromCy(), and VARIANT_Coerce().

VarDateFromDec()

HRESULT WINAPI VarDateFromDec	(	DECIMAL *	pdecIn,
		DATE *	pdateOut
	)

Definition at line 8005 of file vartype.c.

{
  return VarR8FromDec(pdecIn, pdateOut);
}

Referenced by test_VarDateFromDec(), and VARIANT_Coerce().

VarDateFromDisp()

HRESULT WINAPI VarDateFromDisp	(	IDispatch *	pdispIn,
		LCID	lcid,
		DATE *	pdateOut
	)

Definition at line 7315 of file vartype.c.

{
  return VARIANT_FromDisp(pdispIn, lcid, pdateOut, VT_DATE, 0);
}

Referenced by VARIANT_Coerce().

VarDateFromI1()

HRESULT WINAPI VarDateFromI1	(	signed char	cIn,
		DATE *	pdateOut
	)

Definition at line 7954 of file vartype.c.

{
  return VarR8FromI1(cIn, pdateOut);
}

Referenced by test_VarDateFromI1(), and VARIANT_Coerce().

VarDateFromI2()

HRESULT WINAPI VarDateFromI2	(	short	sIn,
		DATE *	pdateOut
	)

Definition at line 7241 of file vartype.c.

{
  return VarR8FromI2(sIn, pdateOut);
}

Referenced by test_VarDateFromI2(), and VARIANT_Coerce().

VarDateFromI4()

HRESULT WINAPI VarDateFromI4	(	LONG	lIn,
		DATE *	pdateOut
	)

Definition at line 7258 of file vartype.c.

{
  return VarDateFromR8(lIn, pdateOut);
}

Referenced by test_VarDateFromI4(), and VARIANT_Coerce().

VarDateFromI8()

HRESULT WINAPI VarDateFromI8	(	LONG64	llIn,
		DATE *	pdateOut
	)

Definition at line 8023 of file vartype.c.

{
  if (llIn < DATE_MIN || llIn > DATE_MAX) return DISP_E_OVERFLOW;
  *pdateOut = (DATE)llIn;
  return S_OK;
}

Referenced by test_VarDateFromI8(), and VARIANT_Coerce().

VarDateFromR4()

HRESULT WINAPI VarDateFromR4	(	FLOAT	fltIn,
		DATE *	pdateOut
	)

Definition at line 7275 of file vartype.c.

{
  return VarR8FromR4(fltIn, pdateOut);
}

Referenced by test_VarDateFromR4(), and VARIANT_Coerce().

VarDateFromR8()

HRESULT WINAPI VarDateFromR8	(	double	dblIn,
		DATE *	pdateOut
	)

Definition at line 7292 of file vartype.c.

{
  if (dblIn <= (DATE_MIN - 1.0) || dblIn >= (DATE_MAX + 1.0)) return DISP_E_OVERFLOW;
  *pdateOut = (DATE)dblIn;
  return S_OK;
}

Referenced by test_VarDateFromR8(), VarDateFromI4(), VarDateFromUI4(), and VARIANT_Coerce().

VarDateFromStr()

HRESULT WINAPI VarDateFromStr	(	OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		DATE *	pdateOut
	)

Definition at line 7595 of file vartype.c.

{
  static const USHORT ParseDateTokens[] =
  {
    LOCALE_SMONTHNAME1, LOCALE_SMONTHNAME2, LOCALE_SMONTHNAME3, LOCALE_SMONTHNAME4,
    LOCALE_SMONTHNAME5, LOCALE_SMONTHNAME6, LOCALE_SMONTHNAME7, LOCALE_SMONTHNAME8,
    LOCALE_SMONTHNAME9, LOCALE_SMONTHNAME10, LOCALE_SMONTHNAME11, LOCALE_SMONTHNAME12,
    LOCALE_SMONTHNAME13,
    LOCALE_SABBREVMONTHNAME1, LOCALE_SABBREVMONTHNAME2, LOCALE_SABBREVMONTHNAME3,
    LOCALE_SABBREVMONTHNAME4, LOCALE_SABBREVMONTHNAME5, LOCALE_SABBREVMONTHNAME6,
    LOCALE_SABBREVMONTHNAME7, LOCALE_SABBREVMONTHNAME8, LOCALE_SABBREVMONTHNAME9,
    LOCALE_SABBREVMONTHNAME10, LOCALE_SABBREVMONTHNAME11, LOCALE_SABBREVMONTHNAME12,
    LOCALE_SABBREVMONTHNAME13,
    LOCALE_SDAYNAME1, LOCALE_SDAYNAME2, LOCALE_SDAYNAME3, LOCALE_SDAYNAME4,
    LOCALE_SDAYNAME5, LOCALE_SDAYNAME6, LOCALE_SDAYNAME7,
    LOCALE_SABBREVDAYNAME1, LOCALE_SABBREVDAYNAME2, LOCALE_SABBREVDAYNAME3,
    LOCALE_SABBREVDAYNAME4, LOCALE_SABBREVDAYNAME5, LOCALE_SABBREVDAYNAME6,
    LOCALE_SABBREVDAYNAME7,
    LOCALE_S1159, LOCALE_S2359,
    LOCALE_SDATE
  };
  static const BYTE ParseDateMonths[] =
  {
    1,2,3,4,5,6,7,8,9,10,11,12,13,
    1,2,3,4,5,6,7,8,9,10,11,12,13
  };
  unsigned int i;
  BSTR tokens[ARRAY_SIZE(ParseDateTokens)];
  DATEPARSE dp;
  DWORD dwDateSeps = 0, iDate = 0;
  HRESULT hRet = S_OK;
 
  if ((dwFlags & (VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY)) ==
      (VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY))
    return E_INVALIDARG;
 
  if (!strIn)
    return DISP_E_TYPEMISMATCH;
 
  *pdateOut = 0.0;
 
  TRACE("(%s,0x%08x,0x%08x,%p)\n", debugstr_w(strIn), lcid, dwFlags, pdateOut);
 
  memset(&dp, 0, sizeof(dp));
 
  GetLocaleInfoW(lcid, LOCALE_IDATE|LOCALE_RETURN_NUMBER|(dwFlags & LOCALE_NOUSEROVERRIDE),
                 (LPWSTR)&iDate, sizeof(iDate)/sizeof(WCHAR));
  TRACE("iDate is %d\n", iDate);
 
  /* Get the month/day/am/pm tokens for this locale */
  for (i = 0; i < ARRAY_SIZE(tokens); i++)
  {
    WCHAR buff[128];
    LCTYPE lctype =  ParseDateTokens[i] | (dwFlags & LOCALE_NOUSEROVERRIDE);
 
    /* FIXME: Alternate calendars - should use GetCalendarInfo() and/or
     *        GetAltMonthNames(). We should really cache these strings too.
     */
    buff[0] = '\0';
    GetLocaleInfoW(lcid, lctype, buff, ARRAY_SIZE(buff));
    tokens[i] = SysAllocString(buff);
    TRACE("token %d is %s\n", i, debugstr_w(tokens[i]));
  }
 
  /* Parse the string into our structure */
  while (*strIn)
  {
    if (iswdigit(*strIn))
    {
      if (dp.dwCount >= 6)
      {
        hRet = DISP_E_TYPEMISMATCH;
        break;
      }
      dp.dwValues[dp.dwCount] = wcstoul(strIn, &strIn, 10);
      dp.dwCount++;
      strIn--;
    }
    else if (iswalpha(*strIn))
    {
      BOOL bFound = FALSE;
 
      for (i = 0; i < ARRAY_SIZE(tokens); i++)
      {
        DWORD dwLen = lstrlenW(tokens[i]);
        if (dwLen && !_wcsnicmp(strIn, tokens[i], dwLen))
        {
          if (i <= 25)
          {
            if (dp.dwCount >= 6)
              hRet = DISP_E_TYPEMISMATCH;
            else
            {
              dp.dwValues[dp.dwCount] = ParseDateMonths[i];
              dp.dwFlags[dp.dwCount] |= (DP_MONTH|DP_DATESEP);
              dp.dwCount++;
            }
          }
          else if (i > 39 && i < 42)
          {
            if (!dp.dwCount || dp.dwParseFlags & (DP_AM|DP_PM))
              hRet = DISP_E_TYPEMISMATCH;
            else
            {
              dp.dwFlags[dp.dwCount - 1] |= (i == 40 ? DP_AM : DP_PM);
              dp.dwParseFlags |= (i == 40 ? DP_AM : DP_PM);
            }
          }
          strIn += (dwLen - 1);
          bFound = TRUE;
          break;
        }
      }
 
      if (!bFound)
      {
        if ((*strIn == 'a' || *strIn == 'A' || *strIn == 'p' || *strIn == 'P') &&
            (dp.dwCount && !(dp.dwParseFlags & (DP_AM|DP_PM))))
        {
          /* Special case - 'a' and 'p' are recognised as short for am/pm */
          if (*strIn == 'a' || *strIn == 'A')
          {
            dp.dwFlags[dp.dwCount - 1] |= DP_AM;
            dp.dwParseFlags |=  DP_AM;
          }
          else
          {
            dp.dwFlags[dp.dwCount - 1] |= DP_PM;
            dp.dwParseFlags |=  DP_PM;
          }
          strIn++;
        }
        else
        {
          TRACE("No matching token for %s\n", debugstr_w(strIn));
          hRet = DISP_E_TYPEMISMATCH;
          break;
        }
      }
    }
    else if (*strIn == ':' ||  *strIn == '.')
    {
      if (!dp.dwCount || !strIn[1])
        hRet = DISP_E_TYPEMISMATCH;
      else
        if (tokens[42][0] == *strIn)
        {
          dwDateSeps++;
          if (dwDateSeps > 2)
            hRet = DISP_E_TYPEMISMATCH;
          else
            dp.dwFlags[dp.dwCount - 1] |= DP_DATESEP;
        }
        else
          dp.dwFlags[dp.dwCount - 1] |= DP_TIMESEP;
    }
    else if (*strIn == '-' || *strIn == '/')
    {
      dwDateSeps++;
      if (dwDateSeps > 2 || !dp.dwCount || !strIn[1])
        hRet = DISP_E_TYPEMISMATCH;
      else
        dp.dwFlags[dp.dwCount - 1] |= DP_DATESEP;
    }
    else if (*strIn == ',' || iswspace(*strIn))
    {
      if (*strIn == ',' && !strIn[1])
        hRet = DISP_E_TYPEMISMATCH;
    }
    else
    {
      hRet = DISP_E_TYPEMISMATCH;
    }
    strIn++;
  }
 
  if (!dp.dwCount || dp.dwCount > 6 ||
      (dp.dwCount == 1 && !(dp.dwParseFlags & (DP_AM|DP_PM))))
    hRet = DISP_E_TYPEMISMATCH;
 
  if (SUCCEEDED(hRet))
  {
    SYSTEMTIME st;
    DWORD dwOffset = 0; /* Start of date fields in dp.dwValues */
 
    st.wDayOfWeek = st.wHour = st.wMinute = st.wSecond = st.wMilliseconds = 0;
 
    /* Figure out which numbers correspond to which fields.
     *
     * This switch statement works based on the fact that native interprets any
     * fields that are not joined with a time separator ('.' or ':') as date
     * fields. Thus we construct a value from 0-32 where each set bit indicates
     * a time field. This encapsulates the hundreds of permutations of 2-6 fields.
     * For valid permutations, we set dwOffset to point to the first date field
     * and shorten dp.dwCount by the number of time fields found. The real
     * magic here occurs in VARIANT_MakeDate() above, where we determine what
     * each date number must represent in the context of iDate.
     */
    TRACE("0x%08x\n", TIMEFLAG(0)|TIMEFLAG(1)|TIMEFLAG(2)|TIMEFLAG(3)|TIMEFLAG(4));
 
    switch (TIMEFLAG(0)|TIMEFLAG(1)|TIMEFLAG(2)|TIMEFLAG(3)|TIMEFLAG(4))
    {
    case 0x1: /* TT TTDD TTDDD */
      if (dp.dwCount > 3 &&
          ((dp.dwFlags[2] & (DP_AM|DP_PM)) || (dp.dwFlags[3] & (DP_AM|DP_PM)) ||
          (dp.dwFlags[4] & (DP_AM|DP_PM))))
        hRet = DISP_E_TYPEMISMATCH;
      else if (dp.dwCount != 2 && dp.dwCount != 4 && dp.dwCount != 5)
        hRet = DISP_E_TYPEMISMATCH;
      st.wHour = dp.dwValues[0];
      st.wMinute  = dp.dwValues[1];
      dp.dwCount -= 2;
      dwOffset = 2;
      break;
 
    case 0x3: /* TTT TTTDD TTTDDD */
      if (dp.dwCount > 4 &&
          ((dp.dwFlags[3] & (DP_AM|DP_PM)) || (dp.dwFlags[4] & (DP_AM|DP_PM)) ||
          (dp.dwFlags[5] & (DP_AM|DP_PM))))
        hRet = DISP_E_TYPEMISMATCH;
      else if (dp.dwCount != 3 && dp.dwCount != 5 && dp.dwCount != 6)
        hRet = DISP_E_TYPEMISMATCH;
      st.wHour   = dp.dwValues[0];
      st.wMinute = dp.dwValues[1];
      st.wSecond = dp.dwValues[2];
      dwOffset = 3;
      dp.dwCount -= 3;
      break;
 
    case 0x4: /* DDTT */
      if (dp.dwCount != 4 ||
          (dp.dwFlags[0] & (DP_AM|DP_PM)) || (dp.dwFlags[1] & (DP_AM|DP_PM)))
        hRet = DISP_E_TYPEMISMATCH;
 
      st.wHour = dp.dwValues[2];
      st.wMinute  = dp.dwValues[3];
      dp.dwCount -= 2;
      break;
 
   case 0x0: /* T DD DDD TDDD TDDD */
      if (dp.dwCount == 1 && (dp.dwParseFlags & (DP_AM|DP_PM)))
      {
        st.wHour = dp.dwValues[0]; /* T */
        dp.dwCount = 0;
        break;
      }
      else if (dp.dwCount > 4 || (dp.dwCount < 3 && dp.dwParseFlags & (DP_AM|DP_PM)))
      {
        hRet = DISP_E_TYPEMISMATCH;
      }
      else if (dp.dwCount == 3)
      {
        if (dp.dwFlags[0] & (DP_AM|DP_PM)) /* TDD */
        {
          dp.dwCount = 2;
          st.wHour = dp.dwValues[0];
          dwOffset = 1;
          break;
        }
        if (dp.dwFlags[2] & (DP_AM|DP_PM)) /* DDT */
        {
          dp.dwCount = 2;
          st.wHour = dp.dwValues[2];
          break;
        }
        else if (dp.dwParseFlags & (DP_AM|DP_PM))
          hRet = DISP_E_TYPEMISMATCH;
      }
      else if (dp.dwCount == 4)
      {
        dp.dwCount = 3;
        if (dp.dwFlags[0] & (DP_AM|DP_PM)) /* TDDD */
        {
          st.wHour = dp.dwValues[0];
          dwOffset = 1;
        }
        else if (dp.dwFlags[3] & (DP_AM|DP_PM)) /* DDDT */
        {
          st.wHour = dp.dwValues[3];
        }
        else
          hRet = DISP_E_TYPEMISMATCH;
        break;
      }
      /* .. fall through .. */
 
    case 0x8: /* DDDTT */
      if ((dp.dwCount == 2 && (dp.dwParseFlags & (DP_AM|DP_PM))) ||
          (dp.dwCount == 5 && ((dp.dwFlags[0] & (DP_AM|DP_PM)) ||
           (dp.dwFlags[1] & (DP_AM|DP_PM)) || (dp.dwFlags[2] & (DP_AM|DP_PM)))) ||
           dp.dwCount == 4 || dp.dwCount == 6)
        hRet = DISP_E_TYPEMISMATCH;
      st.wHour   = dp.dwValues[3];
      st.wMinute = dp.dwValues[4];
      if (dp.dwCount == 5)
        dp.dwCount -= 2;
      break;
 
    case 0xC: /* DDTTT */
      if (dp.dwCount != 5 ||
          (dp.dwFlags[0] & (DP_AM|DP_PM)) || (dp.dwFlags[1] & (DP_AM|DP_PM)))
        hRet = DISP_E_TYPEMISMATCH;
      st.wHour   = dp.dwValues[2];
      st.wMinute = dp.dwValues[3];
      st.wSecond = dp.dwValues[4];
      dp.dwCount -= 3;
      break;
 
    case 0x18: /* DDDTTT */
      if ((dp.dwFlags[0] & (DP_AM|DP_PM)) || (dp.dwFlags[1] & (DP_AM|DP_PM)) ||
          (dp.dwFlags[2] & (DP_AM|DP_PM)))
        hRet = DISP_E_TYPEMISMATCH;
      st.wHour   = dp.dwValues[3];
      st.wMinute = dp.dwValues[4];
      st.wSecond = dp.dwValues[5];
      dp.dwCount -= 3;
      break;
 
    default:
      hRet = DISP_E_TYPEMISMATCH;
      break;
    }
 
    if (SUCCEEDED(hRet))
    {
      hRet = VARIANT_MakeDate(&dp, iDate, dwOffset, &st);
 
      if (dwFlags & VAR_TIMEVALUEONLY)
      {
        st.wYear = 1899;
        st.wMonth = 12;
        st.wDay = 30;
      }
      else if (dwFlags & VAR_DATEVALUEONLY)
       st.wHour = st.wMinute = st.wSecond = 0;
 
      /* Finally, convert the value to a VT_DATE */
      if (SUCCEEDED(hRet))
        hRet = SystemTimeToVariantTime(&st, pdateOut) ? S_OK : DISP_E_TYPEMISMATCH;
    }
  }
 
  for (i = 0; i < ARRAY_SIZE(tokens); i++)
    SysFreeString(tokens[i]);
  return hRet;
}

Referenced by test_VarDateFromStr(), and VARIANT_Coerce().

VarDateFromUI1()

HRESULT WINAPI VarDateFromUI1	(	BYTE	bIn,
		DATE *	pdateOut
	)

Definition at line 7224 of file vartype.c.

{
  return VarR8FromUI1(bIn, pdateOut);
}

Referenced by test_VarDateFromUI1(), and VARIANT_Coerce().

VarDateFromUI2()

HRESULT WINAPI VarDateFromUI2	(	USHORT	uiIn,
		DATE *	pdateOut
	)

Definition at line 7971 of file vartype.c.

{
  return VarR8FromUI2(uiIn, pdateOut);
}

Referenced by test_VarDateFromUI2(), and VARIANT_Coerce().

VarDateFromUI4()

HRESULT WINAPI VarDateFromUI4	(	ULONG	ulIn,
		DATE *	pdateOut
	)

Definition at line 7988 of file vartype.c.

{
  return VarDateFromR8(ulIn, pdateOut);
}

Referenced by test_VarDateFromUI4(), and VARIANT_Coerce().

VarDateFromUI8()

HRESULT WINAPI VarDateFromUI8	(	ULONG64	ullIn,
		DATE *	pdateOut
	)

Definition at line 8043 of file vartype.c.

{
  if (ullIn > DATE_MAX) return DISP_E_OVERFLOW;
  *pdateOut = (DATE)ullIn;
  return S_OK;
}

Referenced by test_VarDateFromUI8(), and VARIANT_Coerce().

VarDecAbs()

HRESULT WINAPI VarDecAbs	(	const DECIMAL *	pDecIn,
		DECIMAL *	pDecOut
	)

Definition at line 5698 of file vartype.c.

{
  *pDecOut = *pDecIn;
  DEC_SIGN(pDecOut) &= ~DECIMAL_NEG;
  return S_OK;
}

Referenced by test_VarDecAbs().

VarDecAdd()

HRESULT WINAPI VarDecAdd	(	const DECIMAL *	pDecLeft,
		const DECIMAL *	pDecRight,
		DECIMAL *	pDecOut
	)

Definition at line 4588 of file vartype.c.

{
  HRESULT hRet;
  DECIMAL scaled[2];
 
  hRet = VARIANT_DecScale(&pDecLeft, &pDecRight, scaled);
 
  if (SUCCEEDED(hRet))
  {
    /* Our decimals now have the same scale, we can add them as 96 bit integers */
    ULONG overflow = 0;
    BYTE sign = DECIMAL_POS;
    int cmp;
 
    /* Correct for the sign of the result */
    if (DEC_SIGN(pDecLeft) && DEC_SIGN(pDecRight))
    {
      /* -x + -y : Negative */
      sign = DECIMAL_NEG;
      goto VarDecAdd_AsPositive;
    }
    else if (DEC_SIGN(pDecLeft) && !DEC_SIGN(pDecRight))
    {
      cmp = VARIANT_DecCmp(pDecLeft, pDecRight);
 
      /* -x + y : Negative if x > y */
      if (cmp > 0)
      {
        sign = DECIMAL_NEG;
VarDecAdd_AsNegative:
        DEC_LO32(pDecOut)  = VARIANT_Sub(DEC_LO32(pDecLeft),  DEC_LO32(pDecRight),  &overflow);
        DEC_MID32(pDecOut) = VARIANT_Sub(DEC_MID32(pDecLeft), DEC_MID32(pDecRight), &overflow);
        DEC_HI32(pDecOut)  = VARIANT_Sub(DEC_HI32(pDecLeft),  DEC_HI32(pDecRight),  &overflow);
      }
      else
      {
VarDecAdd_AsInvertedNegative:
        DEC_LO32(pDecOut)  = VARIANT_Sub(DEC_LO32(pDecRight),  DEC_LO32(pDecLeft),  &overflow);
        DEC_MID32(pDecOut) = VARIANT_Sub(DEC_MID32(pDecRight), DEC_MID32(pDecLeft), &overflow);
        DEC_HI32(pDecOut)  = VARIANT_Sub(DEC_HI32(pDecRight),  DEC_HI32(pDecLeft),  &overflow);
      }
    }
    else if (!DEC_SIGN(pDecLeft) && DEC_SIGN(pDecRight))
    {
      cmp = VARIANT_DecCmp(pDecLeft, pDecRight);
 
      /* x + -y : Negative if x <= y */
      if (cmp <= 0)
      {
        sign = DECIMAL_NEG;
        goto VarDecAdd_AsInvertedNegative;
      }
      goto VarDecAdd_AsNegative;
    }
    else
    {
      /* x + y : Positive */
VarDecAdd_AsPositive:
      DEC_LO32(pDecOut)  = VARIANT_Add(DEC_LO32(pDecLeft),  DEC_LO32(pDecRight),  &overflow);
      DEC_MID32(pDecOut) = VARIANT_Add(DEC_MID32(pDecLeft), DEC_MID32(pDecRight), &overflow);
      DEC_HI32(pDecOut)  = VARIANT_Add(DEC_HI32(pDecLeft),  DEC_HI32(pDecRight),  &overflow);
    }
 
    if (overflow)
      return DISP_E_OVERFLOW; /* overflowed */
 
    DEC_SCALE(pDecOut) = DEC_SCALE(pDecLeft);
    DEC_SIGN(pDecOut) = sign;
  }
  return hRet;
}

Referenced by test_VarDecAdd(), VarAdd(), and VarDecSub().

VarDecCmp()

HRESULT WINAPI VarDecCmp	(	const DECIMAL *	pDecLeft,
		const DECIMAL *	pDecRight
	)

Definition at line 5866 of file vartype.c.

{
  HRESULT hRet;
  DECIMAL result;
 
  if (!pDecLeft || !pDecRight)
    return VARCMP_NULL;
 
  if ((!(DEC_SIGN(pDecLeft) & DECIMAL_NEG)) && (DEC_SIGN(pDecRight) & DECIMAL_NEG) &&
      (DEC_HI32(pDecLeft) | DEC_MID32(pDecLeft) | DEC_LO32(pDecLeft)))
    return VARCMP_GT;
  else if ((DEC_SIGN(pDecLeft) & DECIMAL_NEG) && (!(DEC_SIGN(pDecRight) & DECIMAL_NEG)) &&
      (DEC_HI32(pDecLeft) | DEC_MID32(pDecLeft) | DEC_LO32(pDecLeft)))
    return VARCMP_LT;
 
  /* Subtract right from left, and compare the result to 0 */
  hRet = VarDecSub(pDecLeft, pDecRight, &result);
 
  if (SUCCEEDED(hRet))
  {
    int non_zero = DEC_HI32(&result) | DEC_MID32(&result) | DEC_LO32(&result);
 
    if ((DEC_SIGN(&result) & DECIMAL_NEG) && non_zero)
      hRet = (HRESULT)VARCMP_LT;
    else if (non_zero)
      hRet = (HRESULT)VARCMP_GT;
    else
      hRet = (HRESULT)VARCMP_EQ;
  }
  return hRet;
}

Referenced by test_VarDecCmp(), VarCmp(), and VarDecCmpR8().

VarDecCmpR8()

HRESULT WINAPI VarDecCmpR8	(	const DECIMAL *	pDecLeft,
		double	dblRight
	)

Definition at line 5912 of file vartype.c.

{
  HRESULT hRet;
  DECIMAL decRight;
 
  hRet = VarDecFromR8(dblRight, &decRight);
 
  if (SUCCEEDED(hRet))
    hRet = VarDecCmp(pDecLeft, &decRight);
 
  return hRet;
}

Referenced by test_VarDecCmpR8().

VarDecDiv()

HRESULT WINAPI VarDecDiv	(	const DECIMAL *	pDecLeft,
		const DECIMAL *	pDecRight,
		DECIMAL *	pDecOut
	)

Definition at line 5601 of file vartype.c.

{
  if (!pDecLeft || !pDecRight || !pDecOut) return E_INVALIDARG;
 
  return VARIANT_do_division(pDecLeft, pDecRight, pDecOut, FALSE);
}

Referenced by test_VarDecDiv(), and VarDiv().

VarDecFix()

HRESULT WINAPI VarDecFix	(	const DECIMAL *	pDecIn,
		DECIMAL *	pDecOut
	)

Definition at line 5722 of file vartype.c.

{
  double dbl;
  HRESULT hr;
 
  if (DEC_SIGN(pDecIn) & ~DECIMAL_NEG)
    return E_INVALIDARG;
 
  if (!DEC_SCALE(pDecIn))
  {
    *pDecOut = *pDecIn; /* Already an integer */
    return S_OK;
  }
 
  hr = VarR8FromDec(pDecIn, &dbl);
  if (SUCCEEDED(hr)) {
    LONGLONG rounded = dbl;
 
    hr = VarDecFromI8(rounded, pDecOut);
  }
  return hr;
}

Referenced by VarDecInt(), and VarFix().

VarDecFromBool()

HRESULT WINAPI VarDecFromBool	(	VARIANT_BOOL	bIn,
		DECIMAL *	pDecOut
	)

Definition at line 4312 of file vartype.c.

{
  DEC_HI32(pDecOut) = 0;
  DEC_MID32(pDecOut) = 0;
  if (bIn)
  {
    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_NEG,0);
    DEC_LO32(pDecOut) = 1;
  }
  else
  {
    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,0);
    DEC_LO32(pDecOut) = 0;
  }
  return S_OK;
}

Referenced by test_VarDecFromBool().

VarDecFromCy()

HRESULT WINAPI VarDecFromCy	(	CY	cyIn,
		DECIMAL *	pDecOut
	)

Definition at line 4239 of file vartype.c.

{
  DEC_HI32(pDecOut) = 0;
 
  /* Note: This assumes 2s complement integer representation */
  if (cyIn.s.Hi & 0x80000000)
  {
    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_NEG,4);
    DEC_LO64(pDecOut) = -cyIn.int64;
  }
  else
  {
    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,4);
    DEC_MID32(pDecOut) = cyIn.s.Hi;
    DEC_LO32(pDecOut) = cyIn.s.Lo;
  }
  return S_OK;
}

Referenced by test_VarDecFromCy(), and VARIANT_Coerce().

VarDecFromDate()

HRESULT WINAPI VarDecFromDate	(	DATE	dateIn,
		DECIMAL *	pDecOut
	)

Definition at line 4222 of file vartype.c.

{
  return VarDecFromR8(dateIn, pDecOut);
}

Referenced by test_VarDecFromDate(), and VARIANT_Coerce().

VarDecFromDisp()

HRESULT WINAPI VarDecFromDisp	(	IDispatch *	pdispIn,
		LCID	lcid,
		DECIMAL *	pDecOut
	)

Definition at line 4292 of file vartype.c.

{
  return VARIANT_FromDisp(pdispIn, lcid, pDecOut, VT_DECIMAL, 0);
}

Referenced by VARIANT_Coerce().

VarDecFromI1()

HRESULT WINAPI VarDecFromI1	(	signed char	cIn,
		DECIMAL *	pDecOut
	)

Definition at line 4341 of file vartype.c.

{
  return VarDecFromI4(cIn, pDecOut);
}

Referenced by test_VarDecFromI1(), and VARIANT_Coerce().

VarDecFromI2()

HRESULT WINAPI VarDecFromI2	(	SHORT	sIn,
		DECIMAL *	pDecOut
	)

Definition at line 4114 of file vartype.c.

{
  return VarDecFromI4(sIn, pDecOut);
}

Referenced by test_VarDecFromI2(), and VARIANT_Coerce().

VarDecFromI4()

HRESULT WINAPI VarDecFromI4	(	LONG	lIn,
		DECIMAL *	pDecOut
	)

Definition at line 4131 of file vartype.c.

{
  DEC_HI32(pDecOut) = 0;
  DEC_MID32(pDecOut) = 0;
 
  if (lIn < 0)
  {
    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_NEG,0);
    DEC_LO32(pDecOut) = -lIn;
  }
  else
  {
    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,0);
    DEC_LO32(pDecOut) = lIn;
  }
  return S_OK;
}

Referenced by test_marshal_VARIANT(), test_VarDecFromI4(), test_VarMod(), VarDecFromI1(), VarDecFromI2(), and VARIANT_Coerce().

VarDecFromI8()

HRESULT WINAPI VarDecFromI8	(	LONG64	llIn,
		DECIMAL *	pDecOut
	)

Definition at line 4396 of file vartype.c.

{
  PULARGE_INTEGER pLi = (PULARGE_INTEGER)&llIn;
 
  DEC_HI32(pDecOut) = 0;
 
  /* Note: This assumes 2s complement integer representation */
  if (pLi->u.HighPart & 0x80000000)
  {
    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_NEG,0);
    DEC_LO64(pDecOut) = -pLi->QuadPart;
  }
  else
  {
    DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,0);
    DEC_MID32(pDecOut) = pLi->u.HighPart;
    DEC_LO32(pDecOut) = pLi->u.LowPart;
  }
  return S_OK;
}

Referenced by test_VarDecFromI8(), VarDecFix(), VarDecInt(), and VARIANT_Coerce().

VarDecFromR4()

HRESULT WINAPI VarDecFromR4	(	FLOAT	fltIn,
		DECIMAL *	pDecOut
	)

Definition at line 4178 of file vartype.c.

{
  VARIANT_DI di;
  HRESULT hres;
 
  hres = VARIANT_DI_FromR4(fltIn, &di);
  if (hres == S_OK) VARIANT_DecFromDI(&di, pDecOut);
  return hres;
}

Referenced by test_VarDecFromR4(), and VARIANT_Coerce().

VarDecFromR8()

HRESULT WINAPI VarDecFromR8	(	double	dblIn,
		DECIMAL *	pDecOut
	)

Definition at line 4200 of file vartype.c.

{
  VARIANT_DI di;
  HRESULT hres;
 
  hres = VARIANT_DI_FromR8(dblIn, &di);
  if (hres == S_OK) VARIANT_DecFromDI(&di, pDecOut);
  return hres;
}

Referenced by test_VarAdd(), test_VarCat(), test_VarDecFromR8(), test_VarDiv(), test_VarIdiv(), test_VarImp(), test_VarMul(), test_VarPow(), test_VarSub(), VarDecCmpR8(), VarDecFromDate(), VARIANT_Coerce(), and VarRound().

VarDecFromStr()

HRESULT WINAPI VarDecFromStr	(	OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		DECIMAL *	pDecOut
	)

Definition at line 4273 of file vartype.c.

{
  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pDecOut, VT_DECIMAL);
}

Referenced by test_VarDecFromStr(), and VARIANT_Coerce().

VarDecFromUI1()

HRESULT WINAPI VarDecFromUI1	(	BYTE	bIn,
		DECIMAL *	pDecOut
	)

Definition at line 4097 of file vartype.c.

{
  return VarDecFromUI4(bIn, pDecOut);
}

Referenced by test_VarDecFromUI1(), and VARIANT_Coerce().

VarDecFromUI2()

HRESULT WINAPI VarDecFromUI2	(	USHORT	usIn,
		DECIMAL *	pDecOut
	)

Definition at line 4358 of file vartype.c.

{
  return VarDecFromUI4(usIn, pDecOut);
}

Referenced by test_VarDecFromUI2(), and VARIANT_Coerce().

VarDecFromUI4()

HRESULT WINAPI VarDecFromUI4	(	ULONG	ulIn,
		DECIMAL *	pDecOut
	)

Definition at line 4375 of file vartype.c.

{
  DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,0);
  DEC_HI32(pDecOut) = 0;
  DEC_MID32(pDecOut) = 0;
  DEC_LO32(pDecOut) = ulIn;
  return S_OK;
}

Referenced by test_VarDecFromUI4(), VarDecFromUI1(), VarDecFromUI2(), and VARIANT_Coerce().

VarDecFromUI8()

HRESULT WINAPI VarDecFromUI8	(	ULONG64	ullIn,
		DECIMAL *	pDecOut
	)

Definition at line 4429 of file vartype.c.

{
  DEC_SIGNSCALE(pDecOut) = SIGNSCALE(DECIMAL_POS,0);
  DEC_HI32(pDecOut) = 0;
  DEC_LO64(pDecOut) = ullIn;
  return S_OK;
}

Referenced by test_VarDecFromUI8(), and VARIANT_Coerce().

VarDecInt()

HRESULT WINAPI VarDecInt	(	const DECIMAL *	pDecIn,
		DECIMAL *	pDecOut
	)

Definition at line 5762 of file vartype.c.

{
  double dbl;
  HRESULT hr;
 
  if (DEC_SIGN(pDecIn) & ~DECIMAL_NEG)
    return E_INVALIDARG;
 
  if (!(DEC_SIGN(pDecIn) & DECIMAL_NEG) || !DEC_SCALE(pDecIn))
    return VarDecFix(pDecIn, pDecOut); /* The same, if +ve or no fractionals */
 
  hr = VarR8FromDec(pDecIn, &dbl);
  if (SUCCEEDED(hr)) {
    LONGLONG rounded = dbl >= 0.0 ? dbl + 0.5 : dbl - 0.5;
 
    hr = VarDecFromI8(rounded, pDecOut);
  }
  return hr;
}

Referenced by VarInt().

VarDecMul()

HRESULT WINAPI VarDecMul	(	const DECIMAL *	pDecLeft,
		const DECIMAL *	pDecRight,
		DECIMAL *	pDecOut
	)

Definition at line 5622 of file vartype.c.

{
  HRESULT hRet = S_OK;
  VARIANT_DI di_left, di_right, di_result;
  int mulresult;
 
  VARIANT_DIFromDec(pDecLeft, &di_left);
  VARIANT_DIFromDec(pDecRight, &di_right);
  mulresult = VARIANT_DI_mul(&di_left, &di_right, &di_result);
  if (mulresult)
  {
    /* multiplication actually overflowed */
    hRet = DISP_E_OVERFLOW;
  }
  else
  {
    if (di_result.scale > DEC_MAX_SCALE)
    {
      /* multiplication underflowed. In order to comply with the MSDN
         specifications for DECIMAL ranges, some significant digits
         must be removed
       */
      WARN("result scale is %u, scaling (with loss of significant digits)...\n",
          di_result.scale);
      while (di_result.scale > DEC_MAX_SCALE && 
            !VARIANT_int_iszero(di_result.bitsnum, ARRAY_SIZE(di_result.bitsnum)))
      {
        VARIANT_int_divbychar(di_result.bitsnum, ARRAY_SIZE(di_result.bitsnum), 10);
        di_result.scale--;
      }
      if (di_result.scale > DEC_MAX_SCALE)
      {
        WARN("result underflowed, setting to 0\n");
        di_result.scale = 0;
        di_result.sign = 0;
      }
    }
    VARIANT_DecFromDI(&di_result, pDecOut);
  }
  return hRet;
}

Referenced by test_VarDecMul(), VarDecRound(), VARIANT_DecScale(), and VarMul().

VarDecNeg()

HRESULT WINAPI VarDecNeg	(	const DECIMAL *	pDecIn,
		DECIMAL *	pDecOut
	)

Definition at line 5794 of file vartype.c.

{
  *pDecOut = *pDecIn;
  DEC_SIGN(pDecOut) ^= DECIMAL_NEG;
  return S_OK;
}

Referenced by test_VarDecNeg(), VarDecSub(), and VarNeg().

VarDecRound()

HRESULT WINAPI VarDecRound	(	const DECIMAL *	pDecIn,
		int	cDecimals,
		DECIMAL *	pDecOut
	)

Definition at line 5815 of file vartype.c.

{
  DECIMAL divisor, tmp;
  HRESULT hr;
  unsigned int i;
 
  if (cDecimals < 0 || (DEC_SIGN(pDecIn) & ~DECIMAL_NEG) || DEC_SCALE(pDecIn) > DEC_MAX_SCALE)
    return E_INVALIDARG;
 
  if (cDecimals >= DEC_SCALE(pDecIn))
  {
    *pDecOut = *pDecIn; /* More precision than we have */
    return S_OK;
  }
 
  /* truncate significant digits and rescale */
  memset(&divisor, 0, sizeof(divisor));
  DEC_LO64(&divisor) = 1;
 
  memset(&tmp, 0, sizeof(tmp));
  DEC_LO64(&tmp) = 10;
  for (i = 0; i < DEC_SCALE(pDecIn) - cDecimals; ++i)
  {
    hr = VarDecMul(&divisor, &tmp, &divisor);
    if (FAILED(hr))
      return hr;
  }
 
  hr = VARIANT_do_division(pDecIn, &divisor, pDecOut, TRUE);
  if (FAILED(hr))
    return hr;
 
  DEC_SCALE(pDecOut) = cDecimals;
 
  return S_OK;
}

Referenced by test_VarDecRound(), and VarCyFromDec().

VarDecSub()

HRESULT WINAPI VarDecSub	(	const DECIMAL *	pDecLeft,
		const DECIMAL *	pDecRight,
		DECIMAL *	pDecOut
	)

Definition at line 5677 of file vartype.c.

{
  DECIMAL decRight;
 
  /* Implement as addition of the negative */
  VarDecNeg(pDecRight, &decRight);
  return VarDecAdd(pDecLeft, &decRight, pDecOut);
}

Referenced by test_VarDecSub(), VarDecCmp(), and VarSub().

VarI1FromBool()

HRESULT WINAPI VarI1FromBool	(	VARIANT_BOOL	boolIn,
		signed char *	pcOut
	)

Definition at line 465 of file vartype.c.

{
  return _VarI1FromBool(boolIn, pcOut);
}

Referenced by test_VarI1FromBool(), and VARIANT_Coerce().

VarI1FromCy()

HRESULT WINAPI VarI1FromCy	(	CY	cyIn,
		signed char *	pcOut
	)

Definition at line 402 of file vartype.c.

{
  LONG i = I1_MAX + 1;
 
  VarI4FromCy(cyIn, &i);
  return _VarI1FromI4(i, pcOut);
}

Referenced by test_VarI1FromCy(), and VARIANT_Coerce().

VarI1FromDate()

HRESULT WINAPI VarI1FromDate	(	DATE	dateIn,
		signed char *	pcOut
	)

Definition at line 383 of file vartype.c.

{
  return VarI1FromR8(dateIn, pcOut);
}

Referenced by test_VarI1FromDate(), and VARIANT_Coerce().

VarI1FromDec()

HRESULT WINAPI VarI1FromDec	(	DECIMAL *	pdecIn,
		signed char *	pcOut
	)

Definition at line 523 of file vartype.c.

{
  LONG64 i64;
  HRESULT hRet;
 
  hRet = VarI8FromDec(pdecIn, &i64);
 
  if (SUCCEEDED(hRet))
    hRet = _VarI1FromI8(i64, pcOut);
  return hRet;
}

Referenced by test_VarI1FromDec(), and VARIANT_Coerce().

VarI1FromDisp()

HRESULT WINAPI VarI1FromDisp	(	IDispatch *	pdispIn,
		LCID	lcid,
		signed char *	pcOut
	)

Definition at line 448 of file vartype.c.

{
  return VARIANT_FromDisp(pdispIn, lcid, pcOut, VT_I1, 0);
}

Referenced by VARIANT_Coerce().

VarI1FromI2()

HRESULT WINAPI VarI1FromI2	(	SHORT	sIn,
		signed char *	pcOut
	)

Definition at line 301 of file vartype.c.

{
  return _VarI1FromI2(sIn, pcOut);
}

Referenced by test_VarI1FromI2(), and VARIANT_Coerce().

VarI1FromI4()

HRESULT WINAPI VarI1FromI4	(	LONG	iIn,
		signed char *	pcOut
	)

Definition at line 320 of file vartype.c.

{
  return _VarI1FromI4(iIn, pcOut);
}

Referenced by test_VarI1FromI4(), and VARIANT_Coerce().

VarI1FromI8()

HRESULT WINAPI VarI1FromI8	(	LONG64	llIn,
		signed char *	pcOut
	)

Definition at line 549 of file vartype.c.

{
  return _VarI1FromI8(llIn, pcOut);
}

Referenced by test_VarI1FromI8(), and VARIANT_Coerce().

VarI1FromR4()

HRESULT WINAPI VarI1FromR4	(	FLOAT	fltIn,
		signed char *	pcOut
	)

Definition at line 339 of file vartype.c.

{
  return VarI1FromR8(fltIn, pcOut);
}

Referenced by test_VarI1FromR4(), and VARIANT_Coerce().

VarI1FromR8()

HRESULT WINAPI VarI1FromR8	(	double	dblIn,
		signed char *	pcOut
	)

Definition at line 361 of file vartype.c.

{
  if (dblIn < I1_MIN - 0.5 || dblIn >= I1_MAX + 0.5)
    return DISP_E_OVERFLOW;
  VARIANT_DutchRound(CHAR, dblIn, *pcOut);
  return S_OK;
}

Referenced by test_VarI1FromR8(), VarI1FromDate(), VarI1FromR4(), and VARIANT_Coerce().

VarI1FromStr()

HRESULT WINAPI VarI1FromStr	(	OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		signed char *	pcOut
	)

Definition at line 427 of file vartype.c.

{
  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pcOut, VT_I1);
}

Referenced by test_VarI1FromStr(), and VARIANT_Coerce().

VarI1FromUI1()

HRESULT WINAPI VarI1FromUI1	(	BYTE	bIn,
		signed char *	pcOut
	)

Definition at line 282 of file vartype.c.

{
  return _VarI1FromUI1(bIn, pcOut);
}

Referenced by test_VarI1FromUI1().

VarI1FromUI2()

HRESULT WINAPI VarI1FromUI2	(	USHORT	usIn,
		signed char *	pcOut
	)

Definition at line 484 of file vartype.c.

{
  return _VarI1FromUI2(usIn, pcOut);
}

Referenced by test_VarI1FromUI2(), and VARIANT_Coerce().

VarI1FromUI4()

HRESULT WINAPI VarI1FromUI4	(	ULONG	ulIn,
		signed char *	pcOut
	)

Definition at line 504 of file vartype.c.

{
  return _VarI1FromUI4(ulIn, pcOut);
}

Referenced by test_VarI1FromUI4(), and VARIANT_Coerce().

VarI1FromUI8()

HRESULT WINAPI VarI1FromUI8	(	ULONG64	ullIn,
		signed char *	pcOut
	)

Definition at line 568 of file vartype.c.

{
  return _VarI1FromUI8(ullIn, pcOut);
}

Referenced by test_VarI1FromUI8(), and VARIANT_Coerce().

VarI2FromBool()

HRESULT WINAPI VarI2FromBool	(	VARIANT_BOOL	boolIn,
		SHORT *	psOut
	)

Definition at line 1059 of file vartype.c.

{
  return _VarI2FromBool(boolIn, psOut);
}

Referenced by test_VarI2FromBool(), and VARIANT_Coerce().

VarI2FromCy()

HRESULT WINAPI VarI2FromCy	(	CY	cyIn,
		SHORT *	psOut
	)

Definition at line 978 of file vartype.c.

{
  LONG i = I2_MAX + 1;
 
  VarI4FromCy(cyIn, &i);
  return _VarI2FromI4(i, psOut);
}

Referenced by test_VarI2FromCy(), and VARIANT_Coerce().

VarI2FromDate()

HRESULT WINAPI VarI2FromDate	(	DATE	dateIn,
		SHORT *	psOut
	)

Definition at line 999 of file vartype.c.

{
  return VarI2FromR8(dateIn, psOut);
}

Referenced by test_VarI2FromDate(), and VARIANT_Coerce().

VarI2FromDec()

HRESULT WINAPI VarI2FromDec	(	DECIMAL *	pdecIn,
		SHORT *	psOut
	)

Definition at line 1131 of file vartype.c.

{
  LONG64 i64;
  HRESULT hRet;
 
  hRet = VarI8FromDec(pdecIn, &i64);
 
  if (SUCCEEDED(hRet))
    hRet = _VarI2FromI8(i64, psOut);
  return hRet;
}

Referenced by test_VarI2FromDec(), and VARIANT_Coerce().

VarI2FromDisp()

HRESULT WINAPI VarI2FromDisp	(	IDispatch *	pdispIn,
		LCID	lcid,
		SHORT *	psOut
	)

Definition at line 1042 of file vartype.c.

{
  return VARIANT_FromDisp(pdispIn, lcid, psOut, VT_I2, 0);
}

Referenced by VARIANT_Coerce().

VarI2FromI1()

HRESULT WINAPI VarI2FromI1	(	signed char	cIn,
		SHORT *	psOut
	)

Definition at line 1076 of file vartype.c.

{
  return _VarI2FromI1(cIn, psOut);
}

Referenced by test_VarI2FromI1(), and VARIANT_Coerce().

VarI2FromI4()

HRESULT WINAPI VarI2FromI4	(	LONG	iIn,
		SHORT *	psOut
	)

Definition at line 918 of file vartype.c.

{
  return _VarI2FromI4(iIn, psOut);
}

Referenced by test_VarI2FromI4(), and VARIANT_Coerce().

VarI2FromI8()

HRESULT WINAPI VarI2FromI8	(	LONG64	llIn,
		SHORT *	psOut
	)

Definition at line 1156 of file vartype.c.

{
  return _VarI2FromI8(llIn, psOut);
}

Referenced by test_VarI2FromI8(), and VARIANT_Coerce().

VarI2FromR4()

HRESULT WINAPI VarI2FromR4	(	FLOAT	fltIn,
		SHORT *	psOut
	)

Definition at line 936 of file vartype.c.

{
  return VarI2FromR8(fltIn, psOut);
}

Referenced by test_VarI2FromR4(), and VARIANT_Coerce().

VarI2FromR8()

HRESULT WINAPI VarI2FromR8	(	double	dblIn,
		SHORT *	psOut
	)

Definition at line 957 of file vartype.c.

{
  if (dblIn < I2_MIN - 0.5 || dblIn >= I2_MAX + 0.5)
    return DISP_E_OVERFLOW;
  VARIANT_DutchRound(SHORT, dblIn, *psOut);
  return S_OK;
}

Referenced by test_VarI2FromR8(), VarI2FromDate(), VarI2FromR4(), and VARIANT_Coerce().

VarI2FromStr()

HRESULT WINAPI VarI2FromStr	(	OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		SHORT *	psOut
	)

Definition at line 1021 of file vartype.c.

{
  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, psOut, VT_I2);
}

Referenced by test_VarI2FromStr(), and VARIANT_Coerce().

VarI2FromUI1()

HRESULT WINAPI VarI2FromUI1	(	BYTE	bIn,
		SHORT *	psOut
	)

Definition at line 900 of file vartype.c.

{
  return _VarI2FromUI1(bIn, psOut);
}

Referenced by test_VarI2FromUI1(), and VARIANT_Coerce().

VarI2FromUI2()

HRESULT WINAPI VarI2FromUI2	(	USHORT	usIn,
		SHORT *	psOut
	)

Definition at line 1094 of file vartype.c.

{
  return _VarI2FromUI2(usIn, psOut);
}

Referenced by test_VarI2FromUI2().

VarI2FromUI4()

HRESULT WINAPI VarI2FromUI4	(	ULONG	ulIn,
		SHORT *	psOut
	)

Definition at line 1112 of file vartype.c.

{
  return _VarI2FromUI4(ulIn, psOut);
}

Referenced by test_VarI2FromUI4(), and VARIANT_Coerce().

VarI2FromUI8()

HRESULT WINAPI VarI2FromUI8	(	ULONG64	ullIn,
		SHORT *	psOut
	)

Definition at line 1174 of file vartype.c.

{
  return _VarI2FromUI8(ullIn, psOut);
}

Referenced by test_VarI2FromUI8(), and VARIANT_Coerce().

VarI4FromBool()

HRESULT WINAPI VarI4FromBool	(	VARIANT_BOOL	boolIn,
		LONG *	piOut
	)

Definition at line 1649 of file vartype.c.

{
  return _VarI4FromBool(boolIn, piOut);
}

Referenced by test_VarI4FromBool(), and VARIANT_Coerce().

VarI4FromCy()

HRESULT WINAPI VarI4FromCy	(	CY	cyIn,
		LONG *	piOut
	)

Definition at line 1570 of file vartype.c.

{
  double d = cyIn.int64 / CY_MULTIPLIER_F;
  return VarI4FromR8(d, piOut);
}

Referenced by test_VarI4FromCy(), VarI1FromCy(), VarI2FromCy(), VARIANT_Coerce(), and VarNot().

VarI4FromDate()

HRESULT WINAPI VarI4FromDate	(	DATE	dateIn,
		LONG *	piOut
	)

Definition at line 1589 of file vartype.c.

{
  return VarI4FromR8(dateIn, piOut);
}

Referenced by test_VarI4FromDate(), and VARIANT_Coerce().

VarI4FromDec()

HRESULT WINAPI VarI4FromDec	(	DECIMAL *	pdecIn,
		LONG *	piOut
	)

Definition at line 1720 of file vartype.c.

{
  LONG64 i64;
  HRESULT hRet;
 
  hRet = VarI8FromDec(pdecIn, &i64);
 
  if (SUCCEEDED(hRet))
    hRet = _VarI4FromI8(i64, piOut);
  return hRet;
}

Referenced by test_VarI4FromDec(), VARIANT_Coerce(), and VarNot().

VarI4FromDisp()

HRESULT WINAPI VarI4FromDisp	(	IDispatch *	pdispIn,
		LCID	lcid,
		LONG *	piOut
	)

Definition at line 1632 of file vartype.c.

{
  return VARIANT_FromDisp(pdispIn, lcid, piOut, VT_I4, 0);
}

Referenced by VARIANT_Coerce().

VarI4FromI1()

HRESULT WINAPI VarI4FromI1	(	signed char	cIn,
		LONG *	piOut
	)

Definition at line 1666 of file vartype.c.

{
  return _VarI4FromI1(cIn, piOut);
}

Referenced by test_VarI4FromI1(), and VARIANT_Coerce().

VarI4FromI2()

HRESULT WINAPI VarI4FromI2	(	SHORT	sIn,
		LONG *	piOut
	)

Definition at line 1510 of file vartype.c.

{
  return _VarI4FromI2(sIn, piOut);
}

Referenced by test_VarI4FromI2(), and VARIANT_Coerce().

VarI4FromI8()

HRESULT WINAPI VarI4FromI8	(	LONG64	llIn,
		LONG *	piOut
	)

Definition at line 1745 of file vartype.c.

{
  return _VarI4FromI8(llIn, piOut);
}

Referenced by test_VarI4FromI8(), and VARIANT_Coerce().

VarI4FromR4()

HRESULT WINAPI VarI4FromR4	(	FLOAT	fltIn,
		LONG *	piOut
	)

Definition at line 1528 of file vartype.c.

{
  return VarI4FromR8(fltIn, piOut);
}

Referenced by test_VarI4FromR4(), VARIANT_Coerce(), and VarNot().

VarI4FromR8()

HRESULT WINAPI VarI4FromR8	(	double	dblIn,
		LONG *	piOut
	)

Definition at line 1549 of file vartype.c.

{
  if (dblIn < I4_MIN - 0.5 || dblIn >= I4_MAX + 0.5)
    return DISP_E_OVERFLOW;
  VARIANT_DutchRound(LONG, dblIn, *piOut);
  return S_OK;
}

Referenced by test_VarI4FromR8(), VarI4FromCy(), VarI4FromDate(), VarI4FromR4(), VARIANT_Coerce(), and VarNot().

VarI4FromStr()

HRESULT WINAPI VarI4FromStr	(	OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		LONG *	piOut
	)

Definition at line 1611 of file vartype.c.

{
  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, piOut, VT_I4);
}

Referenced by test_VarI4FromStr(), var_to_size(), and VARIANT_Coerce().

VarI4FromUI1()

HRESULT WINAPI VarI4FromUI1	(	BYTE	bIn,
		LONG *	piOut
	)

Definition at line 1491 of file vartype.c.

{
  return _VarI4FromUI1(bIn, piOut);
}

Referenced by test_VarI4FromUI1(), and VARIANT_Coerce().

VarI4FromUI2()

HRESULT WINAPI VarI4FromUI2	(	USHORT	usIn,
		LONG *	piOut
	)

Definition at line 1683 of file vartype.c.

{
  return _VarI4FromUI2(usIn, piOut);
}

Referenced by test_VarI4FromUI2(), and VARIANT_Coerce().

VarI4FromUI4()

HRESULT WINAPI VarI4FromUI4	(	ULONG	ulIn,
		LONG *	piOut
	)

Definition at line 1701 of file vartype.c.

{
  return _VarI4FromUI4(ulIn, piOut);
}

Referenced by test_VarI4FromUI4().

VarI4FromUI8()

HRESULT WINAPI VarI4FromUI8	(	ULONG64	ullIn,
		LONG *	piOut
	)

Definition at line 1763 of file vartype.c.

{
  return _VarI4FromUI8(ullIn, piOut);
}

Referenced by test_VarI4FromUI8(), and VARIANT_Coerce().

VarI8FromBool()

HRESULT WINAPI VarI8FromBool	(	VARIANT_BOOL	boolIn,
		LONG64 *	pi64Out
	)

Definition at line 2265 of file vartype.c.

{
  return VarI8FromI2(boolIn, pi64Out);
}

Referenced by test_VarI8FromBool(), and VARIANT_Coerce().

VarI8FromCy()

HRESULT WINAPI VarI8FromCy	(	CY	cyIn,
		LONG64 *	pi64Out
	)

Definition at line 2174 of file vartype.c.

{
  *pi64Out = cyIn.int64 / CY_MULTIPLIER;
 
  if (cyIn.int64 < 0)
    (*pi64Out)--; /* Mimic Win32 bug */
  else
  {
    cyIn.int64 -= *pi64Out * CY_MULTIPLIER; /* cyIn.s.Lo now holds fractional remainder */
 
    if (cyIn.s.Lo > CY_HALF || (cyIn.s.Lo == CY_HALF && (*pi64Out & 0x1)))
      (*pi64Out)++;
  }
  return S_OK;
}

Referenced by test_VarI8FromCy(), and VARIANT_Coerce().

VarI8FromDate()

HRESULT WINAPI VarI8FromDate	(	DATE	dateIn,
		LONG64 *	pi64Out
	)

Definition at line 2205 of file vartype.c.

{
  return VarI8FromR8(dateIn, pi64Out);
}

Referenced by test_VarI8FromDate(), and VARIANT_Coerce().

VarI8FromDec()

HRESULT WINAPI VarI8FromDec	(	DECIMAL *	pdecIn,
		LONG64 *	pi64Out
	)

Definition at line 2335 of file vartype.c.

{
  if (!DEC_SCALE(pdecIn))
  {
    /* This decimal is just a 96 bit integer */
    if (DEC_SIGN(pdecIn) & ~DECIMAL_NEG)
      return E_INVALIDARG;
 
    if (DEC_HI32(pdecIn) || DEC_MID32(pdecIn) & 0x80000000)
      return DISP_E_OVERFLOW;
 
    if (DEC_SIGN(pdecIn))
      *pi64Out = -DEC_LO64(pdecIn);
    else
      *pi64Out = DEC_LO64(pdecIn);
    return S_OK;
  }
  else
  {
    /* Decimal contains a floating point number */
    HRESULT hRet;
    double dbl;
 
    hRet = VarR8FromDec(pdecIn, &dbl);
    if (SUCCEEDED(hRet))
      hRet = VarI8FromR8(dbl, pi64Out);
    return hRet;
  }
}

Referenced by test_VarI8FromDec(), VarI1FromDec(), VarI2FromDec(), VarI4FromDec(), VARIANT_Coerce(), VarUI1FromDec(), VarUI2FromDec(), and VarUI4FromDec().

VarI8FromDisp()

HRESULT WINAPI VarI8FromDisp	(	IDispatch *	pdispIn,
		LCID	lcid,
		LONG64 *	pi64Out
	)

Definition at line 2248 of file vartype.c.

{
  return VARIANT_FromDisp(pdispIn, lcid, pi64Out, VT_I8, 0);
}

Referenced by VARIANT_Coerce().

VarI8FromI1()

HRESULT WINAPI VarI8FromI1	(	signed char	cIn,
		LONG64 *	pi64Out
	)

Definition at line 2282 of file vartype.c.

{
  return _VarI8FromI1(cIn, pi64Out);
}

Referenced by test_VarI8FromI1(), and VARIANT_Coerce().

VarI8FromI2()

HRESULT WINAPI VarI8FromI2	(	SHORT	sIn,
		LONG64 *	pi64Out
	)

Definition at line 2093 of file vartype.c.

{
  return _VarI8FromI2(sIn, pi64Out);
}

Referenced by test_VarI8FromI2(), VarI8FromBool(), VARIANT_Coerce(), and VarUI8FromBool().

VarI8FromR4()

HRESULT WINAPI VarI8FromR4	(	FLOAT	fltIn,
		LONG64 *	pi64Out
	)

Definition at line 2112 of file vartype.c.

{
  return VarI8FromR8(fltIn, pi64Out);
}

Referenced by test_VarI8FromR4(), and VARIANT_Coerce().

VarI8FromR8()

HRESULT WINAPI VarI8FromR8	(	double	dblIn,
		LONG64 *	pi64Out
	)

Definition at line 2148 of file vartype.c.

{
  if ( dblIn < -4611686018427387904.0 || dblIn >= 4611686018427387904.0)
    return DISP_E_OVERFLOW;
  VARIANT_DutchRound(LONG64, dblIn, *pi64Out);
  return S_OK;
}

Referenced by test_VarI8FromR8(), VarI8FromDate(), VarI8FromDec(), VarI8FromR4(), and VARIANT_Coerce().

VarI8FromStr()

HRESULT WINAPI VarI8FromStr	(	OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		LONG64 *	pi64Out
	)

Definition at line 2227 of file vartype.c.

{
  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pi64Out, VT_I8);
}

Referenced by test_VarI8FromStr(), and VARIANT_Coerce().

VarI8FromUI1()

HRESULT WINAPI VarI8FromUI1	(	BYTE	bIn,
		LONG64 *	pi64Out
	)

Definition at line 2075 of file vartype.c.

{
  return _VarI8FromUI1(bIn, pi64Out);
}

Referenced by test_VarI8FromUI1(), and VARIANT_Coerce().

VarI8FromUI2()

HRESULT WINAPI VarI8FromUI2	(	USHORT	usIn,
		LONG64 *	pi64Out
	)

Definition at line 2299 of file vartype.c.

{
  return _VarI8FromUI2(usIn, pi64Out);
}

Referenced by test_VarI8FromUI2(), and VARIANT_Coerce().

VarI8FromUI4()

HRESULT WINAPI VarI8FromUI4	(	ULONG	ulIn,
		LONG64 *	pi64Out
	)

Definition at line 2316 of file vartype.c.

{
  return _VarI8FromUI4(ulIn, pi64Out);
}

Referenced by test_VarI8FromUI4(), and VARIANT_Coerce().

VarI8FromUI8()

HRESULT WINAPI VarI8FromUI8	(	ULONG64	ullIn,
		LONG64 *	pi64Out
	)

Definition at line 2378 of file vartype.c.

{
  return _VarI8FromUI8(ullIn, pi64Out);
}

Referenced by test_VarI8FromUI8().

VARIANT_Add()

static ULONG VARIANT_Add ( ULONG  ulLeft, ULONG  ulRight, ULONG *  pulHigh  )

static

Definition at line 4520 of file vartype.c.

{
  ULARGE_INTEGER ul64;
 
  ul64.QuadPart = (ULONG64)ulLeft + (ULONG64)ulRight + (ULONG64)*pulHigh;
  *pulHigh = ul64.u.HighPart;
  return ul64.u.LowPart;
}

Referenced by VarDecAdd(), and VARIANT_DI_mul().

VARIANT_BstrFromReal()

static HRESULT VARIANT_BstrFromReal ( DOUBLE  dblIn, LCID  lcid, ULONG  dwFlags, BSTR *  pbstrOut, LPCWSTR  lpszFormat  )

static

Definition at line 6509 of file vartype.c.

{
  WCHAR buff[256];
 
  if (!pbstrOut)
    return E_INVALIDARG;
 
  swprintf( buff, lpszFormat, dblIn );
 
  /* Negative zeroes are disallowed (some applications depend on this).
     If buff starts with a minus, and then nothing follows but zeroes
     and/or a period, it is a negative zero and is replaced with a
     canonical zero. This duplicates native oleaut32 behavior.
   */
  if (buff[0] == '-')
  {
    static const WCHAR szAccept[] = {'0', '.', '\0'};
    if (lstrlenW(buff + 1) == wcsspn(buff + 1, szAccept))
    { buff[0] = '0'; buff[1] = '\0'; }
  }
 
  TRACE("created string %s\n", debugstr_w(buff));
  if (dwFlags & LOCALE_USE_NLS)
  {
    WCHAR numbuff[256];
 
    /* Format the number for the locale */
    numbuff[0] = '\0';
    GetNumberFormatW(lcid, dwFlags & LOCALE_NOUSEROVERRIDE,
                     buff, NULL, numbuff, ARRAY_SIZE(numbuff));
    TRACE("created NLS string %s\n", debugstr_w(numbuff));
    *pbstrOut = SysAllocString(numbuff);
  }
  else
  {
    *pbstrOut = VARIANT_BstrReplaceDecimal(buff, lcid, dwFlags);
  }
  return *pbstrOut ? S_OK : E_OUTOFMEMORY;
}

Referenced by VarBstrFromR4(), and VarBstrFromR8().

VARIANT_BstrFromUInt()

static HRESULT VARIANT_BstrFromUInt ( ULONG64  ulVal, LCID  lcid, DWORD  dwFlags, BSTR *  pbstrOut  )

static

Definition at line 6364 of file vartype.c.

{
  WCHAR szBuff[64], *szOut = szBuff + ARRAY_SIZE(szBuff) - 1;
 
  if (!pbstrOut)
    return E_INVALIDARG;
 
  /* Create the basic number string */
  *szOut-- = '\0';
  szOut = VARIANT_WriteNumber(ulVal, szOut);
 
  *pbstrOut = VARIANT_MakeBstr(lcid, dwFlags, szOut);
  TRACE("returning %s\n", debugstr_w(*pbstrOut));
  return *pbstrOut ? S_OK : E_OUTOFMEMORY;
}

Referenced by VarBstrFromI1(), VarBstrFromI2(), VarBstrFromI4(), VarBstrFromI8(), VarBstrFromUI1(), VarBstrFromUI2(), VarBstrFromUI4(), and VarBstrFromUI8().

VARIANT_BstrReplaceDecimal()

static BSTR VARIANT_BstrReplaceDecimal ( const WCHAR *  buff, LCID  lcid, ULONG  dwFlags  )

static

Definition at line 6457 of file vartype.c.

{
  BSTR bstrOut;
  WCHAR lpDecimalSep[16];
 
  /* Native oleaut32 uses the locale-specific decimal separator even in the
     absence of the LOCALE_USE_NLS flag. For example, the Spanish/Latin 
     American locales will see "one thousand and one tenth" as "1000,1" 
     instead of "1000.1" (notice the comma). The following code checks for
     the need to replace the decimal separator, and if so, will prepare an
     appropriate NUMBERFMTW structure to do the job via GetNumberFormatW().
   */
  GetLocaleInfoW(lcid, LOCALE_SDECIMAL | (dwFlags & LOCALE_NOUSEROVERRIDE),
                 lpDecimalSep, ARRAY_SIZE(lpDecimalSep));
  if (lpDecimalSep[0] == '.' && lpDecimalSep[1] == '\0')
  {
    /* locale is compatible with English - return original string */
    bstrOut = SysAllocString(buff);
  }
  else
  {
    WCHAR *p;
    WCHAR numbuff[256];
    WCHAR empty[] = {'\0'};
    NUMBERFMTW minFormat;
 
    minFormat.NumDigits = 0;
    minFormat.LeadingZero = 0;
    minFormat.Grouping = 0;
    minFormat.lpDecimalSep = lpDecimalSep;
    minFormat.lpThousandSep = empty;
    minFormat.NegativeOrder = 1; /* NLS_NEG_LEFT */
 
    /* count number of decimal digits in string */
    p = wcschr( buff, '.' );
    if (p) minFormat.NumDigits = lstrlenW(p + 1);
 
    numbuff[0] = '\0';
    if (!GetNumberFormatW(lcid, 0, buff, &minFormat, numbuff, ARRAY_SIZE(numbuff)))
    {
      WARN("GetNumberFormatW() failed, returning raw number string instead\n");
      bstrOut = SysAllocString(buff);
    }
    else
    {
      TRACE("created minimal NLS string %s\n", debugstr_w(numbuff));
      bstrOut = SysAllocString(numbuff);
    }
  }
  return bstrOut;
}

Referenced by VarBstrFromCy(), VarBstrFromDec(), and VARIANT_BstrFromReal().

VARIANT_CopyData()

static void VARIANT_CopyData ( const VARIANT *  srcVar, VARTYPE  vt, void *  pOut  )

inlinestatic

Definition at line 47 of file vartype.c.

{
  switch (vt)
  {
  case VT_I1:
  case VT_UI1: memcpy(pOut, &V_UI1(srcVar), sizeof(BYTE)); break;
  case VT_BOOL:
  case VT_I2:
  case VT_UI2: memcpy(pOut, &V_UI2(srcVar), sizeof(SHORT)); break;
  case VT_R4:
  case VT_INT:
  case VT_I4:
  case VT_UINT:
  case VT_UI4: memcpy(pOut, &V_UI4(srcVar), sizeof (LONG)); break;
  case VT_R8:
  case VT_DATE:
  case VT_CY:
  case VT_I8:
  case VT_UI8: memcpy(pOut, &V_UI8(srcVar), sizeof (LONG64)); break;
  case VT_INT_PTR: memcpy(pOut, &V_INT_PTR(srcVar), sizeof (INT_PTR)); break;
  case VT_DECIMAL: memcpy(pOut, &V_DECIMAL(srcVar), sizeof (DECIMAL)); break;
  case VT_BSTR: memcpy(pOut, &V_BSTR(srcVar), sizeof(BSTR)); break;
  default:
    FIXME("VT_ type %d unhandled, please report!\n", vt);
  }
}

Referenced by VARIANT_FromDisp(), and VARIANT_NumberFromBstr().

VARIANT_DecCmp()

static int VARIANT_DecCmp ( const DECIMAL *  pDecLeft, const DECIMAL *  pDecRight  )

inlinestatic

Definition at line 4564 of file vartype.c.

{
  if ( DEC_HI32(pDecLeft) < DEC_HI32(pDecRight) ||
      (DEC_HI32(pDecLeft) <= DEC_HI32(pDecRight) && DEC_LO64(pDecLeft) < DEC_LO64(pDecRight)))
    return -1;
  else if (DEC_HI32(pDecLeft) == DEC_HI32(pDecRight) && DEC_LO64(pDecLeft) == DEC_LO64(pDecRight))
    return 0;
  return 1;
}

Referenced by VarDecAdd().

VARIANT_DecFromDI()

static void VARIANT_DecFromDI ( const VARIANT_DI *  from, DECIMAL *  to  )

static

Definition at line 4671 of file vartype.c.

{
    if (from->sign) {
        DEC_SIGNSCALE(to) = SIGNSCALE(DECIMAL_NEG, from->scale);
    } else {
        DEC_SIGNSCALE(to) = SIGNSCALE(DECIMAL_POS, from->scale);
    }
 
    DEC_LO32(to) = from->bitsnum[0];
    DEC_MID32(to) = from->bitsnum[1];
    DEC_HI32(to) = from->bitsnum[2];
}

Referenced by VarDecFromR4(), VarDecFromR8(), VarDecMul(), VARIANT_DecScale(), and VARIANT_do_division().

VARIANT_DecScale()

static HRESULT VARIANT_DecScale ( const DECIMAL **  ppDecLeft, const DECIMAL **  ppDecRight, DECIMAL  pDecOut[2]  )

static

Definition at line 4438 of file vartype.c.

{
  static DECIMAL scaleFactor;
  unsigned char remainder;
  DECIMAL decTemp;
  VARIANT_DI di;
  int scaleAmount, i;
 
  if (DEC_SIGN(*ppDecLeft) & ~DECIMAL_NEG || DEC_SIGN(*ppDecRight) & ~DECIMAL_NEG)
    return E_INVALIDARG;
 
  DEC_LO32(&scaleFactor) = 10;
 
  i = scaleAmount = DEC_SCALE(*ppDecLeft) - DEC_SCALE(*ppDecRight);
 
  if (!scaleAmount)
    return S_OK; /* Same scale */
 
  if (scaleAmount > 0)
  {
    decTemp = *(*ppDecRight); /* Left is bigger - scale the right hand side */
    *ppDecRight = &pDecOut[0];
  }
  else
  {
    decTemp = *(*ppDecLeft); /* Right is bigger - scale the left hand side */
    *ppDecLeft  = &pDecOut[0];
    i = -scaleAmount;
  }
 
  /* Multiply up the value to be scaled by the correct amount (if possible) */
  while (i > 0 && SUCCEEDED(VarDecMul(&decTemp, &scaleFactor, &pDecOut[0])))
  {
    decTemp = pDecOut[0];
    i--;
  }
 
  if (!i)
  {
    DEC_SCALE(&pDecOut[0]) += (scaleAmount > 0) ? scaleAmount : (-scaleAmount);
    return S_OK; /* Same scale */
  }
 
  /* Scaling further not possible, reduce accuracy of other argument */
  pDecOut[0] = decTemp;
  if (scaleAmount > 0)
  {
    DEC_SCALE(&pDecOut[0]) += scaleAmount - i;
    VARIANT_DIFromDec(*ppDecLeft, &di);
    *ppDecLeft = &pDecOut[1];
  }
  else
  {
    DEC_SCALE(&pDecOut[0]) += (-scaleAmount) - i;
    VARIANT_DIFromDec(*ppDecRight, &di);
    *ppDecRight = &pDecOut[1];
  }
 
  di.scale -= i;
  remainder = 0;
  while (i-- > 0 && !VARIANT_int_iszero(di.bitsnum, ARRAY_SIZE(di.bitsnum)))
  {
    remainder = VARIANT_int_divbychar(di.bitsnum, ARRAY_SIZE(di.bitsnum), 10);
    if (remainder > 0) WARN("losing significant digits (remainder %u)...\n", remainder);
  }
 
  /* round up the result - native oleaut32 does this */
  if (remainder >= 5) {
      for (remainder = 1, i = 0; i < ARRAY_SIZE(di.bitsnum) && remainder; i++) {
          ULONGLONG digit = di.bitsnum[i] + 1;
          remainder = (digit > 0xFFFFFFFF) ? 1 : 0;
          di.bitsnum[i] = digit & 0xFFFFFFFF;
      }
  }
 
  VARIANT_DecFromDI(&di, &pDecOut[1]);
  return S_OK;
}

Referenced by VarDecAdd().

VARIANT_DI_clear()

static void VARIANT_DI_clear ( VARIANT_DI *  i )

static

Definition at line 4685 of file vartype.c.

{
    memset(i, 0, sizeof(VARIANT_DI));
}

Referenced by VARIANT_DI_div(), VARIANT_DI_FromR4(), VARIANT_DI_FromR8(), and VARIANT_DI_mul().

VARIANT_DI_div()

static HRESULT VARIANT_DI_div ( const VARIANT_DI *  dividend, const VARIANT_DI *  divisor, VARIANT_DI *  quotient, BOOL  round_remainder  )

static

Definition at line 5172 of file vartype.c.

{
    HRESULT r_overflow = S_OK;
 
    if (VARIANT_int_iszero(divisor->bitsnum, ARRAY_SIZE(divisor->bitsnum))) {
        /* division by 0 */
        r_overflow = DISP_E_DIVBYZERO;
    } else if (VARIANT_int_iszero(dividend->bitsnum, ARRAY_SIZE(dividend->bitsnum))) {
        VARIANT_DI_clear(quotient);
    } else {
        int quotientscale, remainderscale, tempquotientscale;
        DWORD remainderplusquotient[8];
        int underflow;
 
        quotientscale = remainderscale = (int)dividend->scale - (int)divisor->scale;
        tempquotientscale = quotientscale;
        VARIANT_DI_clear(quotient);
        quotient->sign = (dividend->sign ^ divisor->sign) ? 1 : 0;
 
        /*  The following strategy is used for division
            1) if there was a nonzero remainder from previous iteration, use it as
               dividend for this iteration, else (for first iteration) use intended
               dividend
            2) perform integer division in temporary buffer, develop quotient in
               low-order part, remainder in high-order part
            3) add quotient from step 2 to final result, with possible loss of
               significant digits
            4) multiply integer part of remainder by 10, while incrementing the
               scale of the remainder. This operation preserves the intended value
               of the remainder.
            5) loop to step 1 until one of the following is true:
                a) remainder is zero (exact division achieved)
                b) addition in step 3 fails to modify bits in quotient (remainder underflow)
         */
        memset(remainderplusquotient, 0, sizeof(remainderplusquotient));
        memcpy(remainderplusquotient, dividend->bitsnum, sizeof(dividend->bitsnum));
        do {
            VARIANT_int_div(remainderplusquotient, 4, divisor->bitsnum, ARRAY_SIZE(divisor->bitsnum));
            underflow = VARIANT_int_addlossy( quotient->bitsnum, &quotientscale,
                ARRAY_SIZE(quotient->bitsnum), remainderplusquotient, &tempquotientscale, 4);
            if (round_remainder) {
                if(remainderplusquotient[4] >= 5){
                    unsigned int i;
                    unsigned char remainder = 1;
                    for (i = 0; i < ARRAY_SIZE(quotient->bitsnum) && remainder; i++) {
                        ULONGLONG digit = quotient->bitsnum[i] + 1;
                        remainder = (digit > 0xFFFFFFFF) ? 1 : 0;
                        quotient->bitsnum[i] = digit & 0xFFFFFFFF;
                    }
                }
                memset(remainderplusquotient, 0, sizeof(remainderplusquotient));
            } else {
                VARIANT_int_mulbychar(remainderplusquotient + 4, 4, 10);
                memcpy(remainderplusquotient, remainderplusquotient + 4, 4 * sizeof(DWORD));
            }
            tempquotientscale = ++remainderscale;
        } while (!underflow && !VARIANT_int_iszero(remainderplusquotient + 4, 4));
 
        /* quotient scale might now be negative (extremely big number). If, so, try
           to multiply quotient by 10 (without overflowing), while adjusting the scale,
           until scale is 0. If this cannot be done, it is a real overflow.
         */
        while (r_overflow == S_OK && quotientscale < 0) {
            memset(remainderplusquotient, 0, sizeof(remainderplusquotient));
            memcpy(remainderplusquotient, quotient->bitsnum, sizeof(quotient->bitsnum));
            VARIANT_int_mulbychar(remainderplusquotient, ARRAY_SIZE(remainderplusquotient), 10);
            if (VARIANT_int_iszero(remainderplusquotient + ARRAY_SIZE(quotient->bitsnum),
                ARRAY_SIZE(remainderplusquotient) - ARRAY_SIZE(quotient->bitsnum))) {
                quotientscale++;
                memcpy(quotient->bitsnum, remainderplusquotient, sizeof(quotient->bitsnum));
            } else r_overflow = DISP_E_OVERFLOW;
        }
        if (r_overflow == S_OK) {
            if (quotientscale <= 255) quotient->scale = quotientscale;
            else VARIANT_DI_clear(quotient);
        }
    }
    return r_overflow;
}

Referenced by VARIANT_do_division().

VARIANT_DI_FromR4()

static HRESULT VARIANT_DI_FromR4 ( float  source, VARIANT_DI *  dest  )

static

Definition at line 5424 of file vartype.c.

{
    HRESULT hres = S_OK;
    R4_FIELDS fx;
 
    fx.f = source;
 
    /* Detect special cases */
    if (fx.i.m == 0 && fx.i.exp_bias == 0) {
        /* Floating-point zero */
        VARIANT_DI_clear(dest);
    } else if (fx.i.m == 0  && fx.i.exp_bias == 0xFF) {
        /* Floating-point infinity */
        hres = DISP_E_OVERFLOW;
    } else if (fx.i.exp_bias == 0xFF) {
        /* Floating-point NaN */
        hres = DISP_E_BADVARTYPE;
    } else {
        int exponent2;
        VARIANT_DI_clear(dest);
 
        exponent2 = fx.i.exp_bias - 127;   /* Get unbiased exponent */
        dest->sign = fx.i.sign;             /* Sign is simply copied */
 
        /* Copy significant bits to VARIANT_DI mantissa */
        dest->bitsnum[0] = fx.i.m;
        dest->bitsnum[0] &= 0x007FFFFF;
        if (fx.i.exp_bias == 0) {
            /* Denormalized number - correct exponent */
            exponent2++;
        } else {
            /* Add hidden bit to mantissa */
            dest->bitsnum[0] |= 0x00800000;
        }
 
        /* The act of copying a FP mantissa as integer bits is equivalent to
           shifting left the mantissa 23 bits. The exponent2 is reduced to
           compensate. */
        exponent2 -= 23;
 
        hres = VARIANT_DI_normalize(dest, exponent2, FALSE);
    }
 
    return hres;
}

Referenced by VarDecFromR4().

VARIANT_DI_FromR8()

static HRESULT VARIANT_DI_FromR8 ( double  source, VARIANT_DI *  dest  )

static

Definition at line 5484 of file vartype.c.

{
    HRESULT hres = S_OK;
    R8_FIELDS fx;
 
    fx.d = source;
 
    /* Detect special cases */
    if (fx.i.m_lo == 0 && fx.i.m_hi == 0 && fx.i.exp_bias == 0) {
        /* Floating-point zero */
        VARIANT_DI_clear(dest);
    } else if (fx.i.m_lo == 0 && fx.i.m_hi == 0 && fx.i.exp_bias == 0x7FF) {
        /* Floating-point infinity */
        hres = DISP_E_OVERFLOW;
    } else if (fx.i.exp_bias == 0x7FF) {
        /* Floating-point NaN */
        hres = DISP_E_BADVARTYPE;
    } else {
        int exponent2;
        VARIANT_DI_clear(dest);
 
        exponent2 = fx.i.exp_bias - 1023;   /* Get unbiased exponent */
        dest->sign = fx.i.sign;             /* Sign is simply copied */
 
        /* Copy significant bits to VARIANT_DI mantissa */
        dest->bitsnum[0] = fx.i.m_lo;
        dest->bitsnum[1] = fx.i.m_hi;
        dest->bitsnum[1] &= 0x000FFFFF;
        if (fx.i.exp_bias == 0) {
            /* Denormalized number - correct exponent */
            exponent2++;
        } else {
            /* Add hidden bit to mantissa */
            dest->bitsnum[1] |= 0x00100000;
        }
 
        /* The act of copying a FP mantissa as integer bits is equivalent to
           shifting left the mantissa 52 bits. The exponent2 is reduced to
           compensate. */
        exponent2 -= 52;
 
        hres = VARIANT_DI_normalize(dest, exponent2, TRUE);
    }
 
    return hres;
}

Referenced by VarDecFromR8().

VARIANT_DI_mul()

static int VARIANT_DI_mul ( const VARIANT_DI *  a, const VARIANT_DI *  b, VARIANT_DI *  result  )

static

Definition at line 4731 of file vartype.c.

{
    BOOL r_overflow = FALSE;
    DWORD running[6];
    signed int mulstart;
 
    VARIANT_DI_clear(result);
    result->sign = (a->sign ^ b->sign) ? 1 : 0;
 
    /* Multiply 128-bit operands into a (max) 256-bit result. The scale
       of the result is formed by adding the scales of the operands.
     */
    result->scale = a->scale + b->scale;
    memset(running, 0, sizeof(running));
 
    /* count number of leading zero-bytes in operand A */
    for (mulstart = ARRAY_SIZE(a->bitsnum) - 1; mulstart >= 0 && !a->bitsnum[mulstart]; mulstart--);
    if (mulstart < 0) {
        /* result is 0, because operand A is 0 */
        result->scale = 0;
        result->sign = 0;
    } else {
        unsigned char remainder = 0;
        int iA;        
 
        /* perform actual multiplication */
        for (iA = 0; iA <= mulstart; iA++) {
            ULONG iOverflowMul;
            int iB;
            
            for (iOverflowMul = 0, iB = 0; iB < ARRAY_SIZE(b->bitsnum); iB++) {
                ULONG iRV;
                int iR;
                
                iRV = VARIANT_Mul(b->bitsnum[iB], a->bitsnum[iA], &iOverflowMul);
                iR = iA + iB;
                do {
                    running[iR] = VARIANT_Add(running[iR], 0, &iRV);
                    iR++;
                } while (iRV);
            }
        }
 
/* Too bad - native oleaut does not do this, so we should not either */
#if 0
        /* While the result is divisible by 10, and the scale > 0, divide by 10.
           This operation should not lose significant digits, and gives an
           opportunity to reduce the possibility of overflows in future
           operations issued by the application.
         */
        while (result->scale > 0) {
            memcpy(quotient, running, sizeof(quotient));
            remainder = VARIANT_int_divbychar(quotient, sizeof(quotient) / sizeof(DWORD), 10);
            if (remainder > 0) break;
            memcpy(running, quotient, sizeof(quotient));
            result->scale--;
        }
#endif
        /* While the 256-bit result overflows, and the scale > 0, divide by 10.
           This operation *will* lose significant digits of the result because
           all the factors of 10 were consumed by the previous operation.
        */
        while (result->scale > 0 && !VARIANT_int_iszero(running + ARRAY_SIZE(result->bitsnum),
            ARRAY_SIZE(running) - ARRAY_SIZE(result->bitsnum))) {
 
            remainder = VARIANT_int_divbychar(running, ARRAY_SIZE(running), 10);
            if (remainder > 0) WARN("losing significant digits (remainder %u)...\n", remainder);
            result->scale--;
        }
        
        /* round up the result - native oleaut32 does this */
        if (remainder >= 5) {
            unsigned int i;
            for (remainder = 1, i = 0; i < ARRAY_SIZE(running) && remainder; i++) {
                ULONGLONG digit = running[i] + 1;
                remainder = (digit > 0xFFFFFFFF) ? 1 : 0;
                running[i] = digit & 0xFFFFFFFF;
            }
        }
 
        /* Signal overflow if scale == 0 and 256-bit result still overflows,
           and copy result bits into result structure
        */
        r_overflow = !VARIANT_int_iszero(running + ARRAY_SIZE(result->bitsnum),
            ARRAY_SIZE(running) - ARRAY_SIZE(result->bitsnum));
        memcpy(result->bitsnum, running, sizeof(result->bitsnum));
    }
    return r_overflow;
}

Referenced by VarDecMul().

VARIANT_DI_normalize()

static HRESULT VARIANT_DI_normalize ( VARIANT_DI *  val, int  exponent2, BOOL  isDouble  )

static

Definition at line 5260 of file vartype.c.

{
    HRESULT hres = S_OK;
    int exponent5, exponent10;
 
    /* A factor of 2^exponent2 is equivalent to (10^exponent2)/(5^exponent2), and
       thus equal to (5^-exponent2)*(10^exponent2). After all manipulations,
       exponent10 might be used to set the VARIANT_DI scale directly. However,
       the value of 5^-exponent5 must be assimilated into the VARIANT_DI. */
    exponent5 = -exponent2;
    exponent10 = exponent2;
 
    /* Handle exponent5 > 0 */
    while (exponent5 > 0) {
        char bPrevCarryBit;
        char bCurrCarryBit;
 
        /* In order to multiply the value represented by the VARIANT_DI by 5, it
           is best to multiply by 10/2. Therefore, exponent10 is incremented, and
           somehow the mantissa should be divided by 2.  */
        if ((val->bitsnum[0] & 1) == 0) {
            /* The mantissa is divisible by 2. Therefore the division can be done
               without losing significant digits. */
            exponent10++; exponent5--;
 
            /* Shift right */
            bPrevCarryBit = val->bitsnum[2] & 1;
            val->bitsnum[2] >>= 1;
            bCurrCarryBit = val->bitsnum[1] & 1;
            val->bitsnum[1] = (val->bitsnum[1] >> 1) | (bPrevCarryBit ? 0x80000000 : 0);
            val->bitsnum[0] = (val->bitsnum[0] >> 1) | (bCurrCarryBit ? 0x80000000 : 0);
        } else {
            /* The mantissa is NOT divisible by 2. Therefore the mantissa should
               be multiplied by 5, unless the multiplication overflows. */
            DWORD temp_bitsnum[3];
 
            exponent5--;
 
            memcpy(temp_bitsnum, val->bitsnum, 3 * sizeof(DWORD));
            if (0 == VARIANT_int_mulbychar(temp_bitsnum, 3, 5)) {
                /* Multiplication succeeded without overflow, so copy result back
                   into VARIANT_DI */
                memcpy(val->bitsnum, temp_bitsnum, 3 * sizeof(DWORD));
 
                /* Mask out 3 extraneous bits introduced by the multiply */
            } else {
                /* Multiplication by 5 overflows. The mantissa should be divided
                   by 2, and therefore will lose significant digits. */
                exponent10++;
 
                /* Shift right */
                bPrevCarryBit = val->bitsnum[2] & 1;
                val->bitsnum[2] >>= 1;
                bCurrCarryBit = val->bitsnum[1] & 1;
                val->bitsnum[1] = (val->bitsnum[1] >> 1) | (bPrevCarryBit ? 0x80000000 : 0);
                val->bitsnum[0] = (val->bitsnum[0] >> 1) | (bCurrCarryBit ? 0x80000000 : 0);
            }
        }
    }
 
    /* Handle exponent5 < 0 */
    while (exponent5 < 0) {
        /* In order to divide the value represented by the VARIANT_DI by 5, it
           is best to multiply by 2/10. Therefore, exponent10 is decremented,
           and the mantissa should be multiplied by 2 */
        if ((val->bitsnum[2] & 0x80000000) == 0) {
            /* The mantissa can withstand a shift-left without overflowing */
            exponent10--; exponent5++;
            VARIANT_int_shiftleft(val->bitsnum, 3, 1);
        } else {
            /* The mantissa would overflow if shifted. Therefore it should be
               directly divided by 5. This will lose significant digits, unless
               by chance the mantissa happens to be divisible by 5 */
            exponent5++;
            VARIANT_int_divbychar(val->bitsnum, 3, 5);
        }
    }
 
    /* At this point, the mantissa has assimilated the exponent5, but the
       exponent10 might not be suitable for assignment. The exponent10 must be
       in the range [-DEC_MAX_SCALE..0], so the mantissa must be scaled up or
       down appropriately. */
    while (hres == S_OK && exponent10 > 0) {
        /* In order to bring exponent10 down to 0, the mantissa should be
           multiplied by 10 to compensate. If the exponent10 is too big, this
           will cause the mantissa to overflow. */
        if (0 == VARIANT_int_mulbychar(val->bitsnum, 3, 10)) {
            exponent10--;
        } else {
            hres = DISP_E_OVERFLOW;
        }
    }
    while (exponent10 < -DEC_MAX_SCALE) {
        int rem10;
        /* In order to bring exponent up to -DEC_MAX_SCALE, the mantissa should
           be divided by 10 to compensate. If the exponent10 is too small, this
           will cause the mantissa to underflow and become 0 */
        rem10 = VARIANT_int_divbychar(val->bitsnum, 3, 10);
        exponent10++;
        if (VARIANT_int_iszero(val->bitsnum, 3)) {
            /* Underflow, unable to keep dividing */
            exponent10 = 0;
        } else if (rem10 >= 5) {
            DWORD x = 1;
            VARIANT_int_add(val->bitsnum, 3, &x, 1);
        }
    }
    /* This step is required in order to remove excess bits of precision from the
       end of the bit representation, down to the precision guaranteed by the
       floating point number. */
    if (isDouble) {
        while (exponent10 < 0 && (val->bitsnum[2] != 0 || (val->bitsnum[1] & 0xFFE00000) != 0)) {
            int rem10;
 
            rem10 = VARIANT_int_divbychar(val->bitsnum, 3, 10);
            exponent10++;
            if (rem10 >= 5) {
                DWORD x = 1;
                VARIANT_int_add(val->bitsnum, 3, &x, 1);
            }
        }
    } else {
        while (exponent10 < 0 && (val->bitsnum[2] != 0 || val->bitsnum[1] != 0 ||
            (val->bitsnum[2] == 0 && val->bitsnum[1] == 0 && (val->bitsnum[0] & 0xFF000000) != 0))) {
            int rem10;
 
            rem10 = VARIANT_int_divbychar(val->bitsnum, 3, 10);
            exponent10++;
            if (rem10 >= 5) {
                DWORD x = 1;
                VARIANT_int_add(val->bitsnum, 3, &x, 1);
            }
        }
    }
    /* Remove multiples of 10 from the representation */
    while (exponent10 < 0) {
        DWORD temp_bitsnum[3];
 
        memcpy(temp_bitsnum, val->bitsnum, 3 * sizeof(DWORD));
        if (0 == VARIANT_int_divbychar(temp_bitsnum, 3, 10)) {
            exponent10++;
            memcpy(val->bitsnum, temp_bitsnum, 3 * sizeof(DWORD));
        } else break;
    }
 
    /* Scale assignment */
    if (hres == S_OK) val->scale = -exponent10;
 
    return hres;
}

Referenced by VARIANT_DI_FromR4(), and VARIANT_DI_FromR8().

VARIANT_DI_tostringW()

static BOOL VARIANT_DI_tostringW ( const VARIANT_DI *  a, WCHAR *  s, unsigned int  n  )

static

Definition at line 4825 of file vartype.c.

{
    BOOL overflow = FALSE;
    DWORD quotient[3];
    unsigned char remainder;
    unsigned int i;
 
    /* place negative sign */
    if (!VARIANT_int_iszero(a->bitsnum, ARRAY_SIZE(a->bitsnum)) && a->sign) {
        if (n > 0) {
            *s++ = '-';
            n--;
        }
        else overflow = TRUE;
    }
 
    /* prepare initial 0 */
    if (!overflow) {
        if (n >= 2) {
            s[0] = '0';
            s[1] = '\0';
        } else overflow = TRUE;
    }
 
    i = 0;
    memcpy(quotient, a->bitsnum, sizeof(a->bitsnum));
    while (!overflow && !VARIANT_int_iszero(quotient, ARRAY_SIZE(quotient))) {
        remainder = VARIANT_int_divbychar(quotient, ARRAY_SIZE(quotient), 10);
        if (i + 2 > n) {
            overflow = TRUE;
        } else {
            s[i++] = '0' + remainder;
            s[i] = '\0';
        }
    }
 
    if (!overflow && !VARIANT_int_iszero(a->bitsnum, ARRAY_SIZE(a->bitsnum))) {
 
        /* reverse order of digits */
        WCHAR * x = s; WCHAR * y = s + i - 1;
        while (x < y) {
            *x ^= *y;
            *y ^= *x;
            *x++ ^= *y--;
        }
 
        /* check for decimal point. "i" now has string length */
        if (i <= a->scale) {
            unsigned int numzeroes = a->scale + 1 - i;
            if (i + 1 + numzeroes >= n) {
                overflow = TRUE;
            } else {
                memmove(s + numzeroes, s, (i + 1) * sizeof(WCHAR));
                i += numzeroes;
                while (numzeroes > 0) {
                    s[--numzeroes] = '0';
                }
            }
        }
 
        /* place decimal point */
        if (a->scale > 0) {
            unsigned int periodpos = i - a->scale;
            if (i + 2 >= n) {
                overflow = TRUE;
            } else {
                memmove(s + periodpos + 1, s + periodpos, (i + 1 - periodpos) * sizeof(WCHAR));
                s[periodpos] = '.'; i++;
                
                /* remove extra zeros at the end, if any */
                while (s[i - 1] == '0') s[--i] = '\0';
                if (s[i - 1] == '.') s[--i] = '\0';
            }
        }
    }
 
    return !overflow;
}

Referenced by VarBstrFromCy(), and VarBstrFromDec().

VARIANT_DIFromDec()

static void VARIANT_DIFromDec ( const DECIMAL *  from, VARIANT_DI *  to  )

static

Definition at line 4661 of file vartype.c.

{
    to->scale = DEC_SCALE(from);
    to->sign = DEC_SIGN(from) ? 1 : 0;
 
    to->bitsnum[0] = DEC_LO32(from);
    to->bitsnum[1] = DEC_MID32(from);
    to->bitsnum[2] = DEC_HI32(from);
}

Referenced by VarBstrFromDec(), VarDecMul(), VARIANT_DecScale(), and VARIANT_do_division().

VARIANT_do_division()

static HRESULT VARIANT_do_division ( const DECIMAL *  pDecLeft, const DECIMAL *  pDecRight, DECIMAL *  pDecOut, BOOL  round  )

static

Definition at line 5531 of file vartype.c.

{
  HRESULT hRet = S_OK;
  VARIANT_DI di_left, di_right, di_result;
  HRESULT divresult;
 
  VARIANT_DIFromDec(pDecLeft, &di_left);
  VARIANT_DIFromDec(pDecRight, &di_right);
  divresult = VARIANT_DI_div(&di_left, &di_right, &di_result, round);
  if (divresult != S_OK)
  {
      /* division actually overflowed */
      hRet = divresult;
  }
  else
  {
      hRet = S_OK;
 
      if (di_result.scale > DEC_MAX_SCALE)
      {
        unsigned char remainder = 0;
      
        /* division underflowed. In order to comply with the MSDN
           specifications for DECIMAL ranges, some significant digits
           must be removed
         */
        WARN("result scale is %u, scaling (with loss of significant digits)...\n",
            di_result.scale);
        while (di_result.scale > DEC_MAX_SCALE && 
               !VARIANT_int_iszero(di_result.bitsnum, ARRAY_SIZE(di_result.bitsnum)))
        {
            remainder = VARIANT_int_divbychar(di_result.bitsnum, ARRAY_SIZE(di_result.bitsnum), 10);
            di_result.scale--;
        }
        if (di_result.scale > DEC_MAX_SCALE)
        {
            WARN("result underflowed, setting to 0\n");
            di_result.scale = 0;
            di_result.sign = 0;
        }
        else if (remainder >= 5)    /* round up result - native oleaut32 does this */
        {
            unsigned int i;
            for (remainder = 1, i = 0; i < ARRAY_SIZE(di_result.bitsnum) && remainder; i++) {
                ULONGLONG digit = di_result.bitsnum[i] + 1;
                remainder = (digit > 0xFFFFFFFF) ? 1 : 0;
                di_result.bitsnum[i] = digit & 0xFFFFFFFF;
            }
        }
      }
      VARIANT_DecFromDI(&di_result, pDecOut);
  }
  return hRet;
}

Referenced by VarDecDiv(), and VarDecRound().

VARIANT_FromDisp()

static HRESULT VARIANT_FromDisp ( IDispatch *  pdispIn, LCID  lcid, void *  pOut, VARTYPE  vt, DWORD  dwFlags  )

static

Definition at line 115 of file vartype.c.

{
  static DISPPARAMS emptyParams = { NULL, NULL, 0, 0 };
  VARIANTARG srcVar, dstVar;
  HRESULT hRet;
 
  if (!pdispIn)
    return DISP_E_BADVARTYPE;
 
  /* Get the default 'value' property from the IDispatch */
  VariantInit(&srcVar);
  hRet = IDispatch_Invoke(pdispIn, DISPID_VALUE, &IID_NULL, lcid, DISPATCH_PROPERTYGET,
                          &emptyParams, &srcVar, NULL, NULL);
 
  if (SUCCEEDED(hRet))
  {
    /* Convert the property to the requested type */
    VariantInit(&dstVar);
    hRet = VariantChangeTypeEx(&dstVar, &srcVar, lcid, dwFlags, vt);
    VariantClear(&srcVar);
 
    if (SUCCEEDED(hRet))
      VARIANT_CopyData(&dstVar, vt, pOut);
  }
  else
    hRet = DISP_E_TYPEMISMATCH;
  return hRet;
}

Referenced by VarBoolFromDisp(), VarBstrFromDisp(), VarCyFromDisp(), VarDateFromDisp(), VarDecFromDisp(), VarI1FromDisp(), VarI2FromDisp(), VarI4FromDisp(), VarI8FromDisp(), VarR4FromDisp(), VarR8FromDisp(), VarUI1FromDisp(), VarUI2FromDisp(), VarUI4FromDisp(), and VarUI8FromDisp().

VARIANT_GetLocalisedText()

static BOOL VARIANT_GetLocalisedText ( LANGID  langId, DWORD  dwId, WCHAR *  lpszDest  )

static

Definition at line 6060 of file vartype.c.

{
  HRSRC hrsrc;
 
  hrsrc = FindResourceExW( hProxyDll, (LPWSTR)RT_STRING,
                           MAKEINTRESOURCEW((dwId >> 4) + 1), langId );
  if (hrsrc)
  {
    HGLOBAL hmem = LoadResource( hProxyDll, hrsrc );
 
    if (hmem)
    {
      const WCHAR *p;
      unsigned int i;
 
      p = LockResource( hmem );
      for (i = 0; i < (dwId & 0x0f); i++) p += *p + 1;
 
      memcpy( lpszDest, p + 1, *p * sizeof(WCHAR) );
      lpszDest[*p] = '\0';
      TRACE("got %s for LANGID %08x\n", debugstr_w(lpszDest), langId);
      return TRUE;
    }
  }
  return FALSE;
}

Referenced by VarBoolFromStr(), and VarBstrFromBool().

VARIANT_int_add()

static unsigned char VARIANT_int_add ( DWORD *  v, unsigned int  nv, const DWORD *  p, unsigned int  np  )

static

Definition at line 4932 of file vartype.c.

{
    unsigned char carry = 0;
 
    if (nv >= np) {
        ULONGLONG sum;
        unsigned int i;
 
        for (i = 0; i < np; i++) {
            sum = (ULONGLONG)v[i]
                + (ULONGLONG)p[i]
                + (ULONGLONG)carry;
            v[i] = sum & 0xffffffff;
            carry = sum >> 32;
        }
        for (; i < nv && carry; i++) {
            sum = (ULONGLONG)v[i]
                + (ULONGLONG)carry;
            v[i] = sum & 0xffffffff;
            carry = sum >> 32;
        }
    }
    return carry;
}

Referenced by VarBstrFromCy(), VARIANT_DI_normalize(), VARIANT_int_addlossy(), and VARIANT_int_div().

VARIANT_int_addlossy()

static int VARIANT_int_addlossy ( DWORD *  a, int *  ascale, unsigned int  an, DWORD *  b, int *  bscale, unsigned int  bn  )

static

Definition at line 5018 of file vartype.c.

{
    int underflow = 0;
 
    if (VARIANT_int_iszero(a, an)) {
        /* if A is zero, copy B into A, after removing digits */
        while (bn > an && !VARIANT_int_iszero(b + an, bn - an)) {
            VARIANT_int_divbychar(b, bn, 10);
            (*bscale)--;
        }
        memcpy(a, b, an * sizeof(DWORD));
        *ascale = *bscale;
    } else if (!VARIANT_int_iszero(b, bn)) {
        unsigned int tn = an + 1;
        DWORD t[5];
 
        if (bn + 1 > tn) tn = bn + 1;
        if (*ascale != *bscale) {
            /* first (optimistic) try - try to scale down the one with the bigger
               scale, while this number is divisible by 10 */
            DWORD * digitchosen;
            unsigned int nchosen;
            int * scalechosen;
            int targetscale;
 
            if (*ascale < *bscale) {
                targetscale = *ascale;
                scalechosen = bscale;
                digitchosen = b;
                nchosen = bn;
            } else {
                targetscale = *bscale;
                scalechosen = ascale;
                digitchosen = a;
                nchosen = an;
            }
            memset(t, 0, tn * sizeof(DWORD));
            memcpy(t, digitchosen, nchosen * sizeof(DWORD));
 
            /* divide by 10 until target scale is reached */
            while (*scalechosen > targetscale) {
                unsigned char remainder = VARIANT_int_divbychar(t, tn, 10);
                if (!remainder) {
                    (*scalechosen)--;
                    memcpy(digitchosen, t, nchosen * sizeof(DWORD));
                } else break;
            }
        }
 
        if (*ascale != *bscale) {
            DWORD * digitchosen;
            unsigned int nchosen;
            int * scalechosen;
            int targetscale;
 
            /* try to scale up the one with the smaller scale */
            if (*ascale > *bscale) {
                targetscale = *ascale;
                scalechosen = bscale;
                digitchosen = b;
                nchosen = bn;
            } else {
                targetscale = *bscale;
                scalechosen = ascale;
                digitchosen = a;
                nchosen = an;
            }
            memset(t, 0, tn * sizeof(DWORD));
            memcpy(t, digitchosen, nchosen * sizeof(DWORD));
 
            /* multiply by 10 until target scale is reached, or
               significant bytes overflow the number
             */
            while (*scalechosen < targetscale && t[nchosen] == 0) {
                VARIANT_int_mulbychar(t, tn, 10);
                if (t[nchosen] == 0) {
                    /* still does not overflow */
                    (*scalechosen)++;
                    memcpy(digitchosen, t, nchosen * sizeof(DWORD));
                }
            }
        }
 
        if (*ascale != *bscale) {
            /* still different? try to scale down the one with the bigger scale
               (this *will* lose significant digits) */
            DWORD * digitchosen;
            unsigned int nchosen;
            int * scalechosen;
            int targetscale;
 
            if (*ascale < *bscale) {
                targetscale = *ascale;
                scalechosen = bscale;
                digitchosen = b;
                nchosen = bn;
            } else {
                targetscale = *bscale;
                scalechosen = ascale;
                digitchosen = a;
                nchosen = an;
            }
            memset(t, 0, tn * sizeof(DWORD));
            memcpy(t, digitchosen, nchosen * sizeof(DWORD));
 
            /* divide by 10 until target scale is reached */
            while (*scalechosen > targetscale) {
                VARIANT_int_divbychar(t, tn, 10);
                (*scalechosen)--;
                memcpy(digitchosen, t, nchosen * sizeof(DWORD));
            }
        }
 
        /* check whether any of the operands still has significant digits
           (underflow case 1)
         */
        if (VARIANT_int_iszero(a, an) || VARIANT_int_iszero(b, bn)) {
            underflow = 1;
        } else {
            /* at this step, both numbers have the same scale and can be added
               as integers. However, the result might not fit in A, so further
               scaling down might be necessary.
             */
            while (!underflow) {
                memset(t, 0, tn * sizeof(DWORD));
                memcpy(t, a, an * sizeof(DWORD));
 
                VARIANT_int_add(t, tn, b, bn);
                if (VARIANT_int_iszero(t + an, tn - an)) {
                    /* addition was successful */
                    memcpy(a, t, an * sizeof(DWORD));
                    break;
                } else {
                    /* addition overflowed - remove significant digits
                       from both operands and try again */
                    VARIANT_int_divbychar(a, an, 10); (*ascale)--;
                    VARIANT_int_divbychar(b, bn, 10); (*bscale)--;
                    /* check whether any operand keeps significant digits after
                       scaledown (underflow case 2)
                     */
                    underflow = (VARIANT_int_iszero(a, an) || VARIANT_int_iszero(b, bn));
                }
            }
        }
    }
    return underflow;
}

Referenced by VARIANT_DI_div().

VARIANT_int_div()

static void VARIANT_int_div ( DWORD *  p, unsigned int  n, const DWORD *  divisor, unsigned int  dn  )

static

Definition at line 4971 of file vartype.c.

{
    unsigned int i;
    DWORD tempsub[8];
    DWORD * negdivisor = tempsub + n;
 
    /* build 2s-complement of divisor */
    for (i = 0; i < n; i++) negdivisor[i] = (i < dn) ? ~divisor[i] : 0xFFFFFFFF;
    p[n] = 1;
    VARIANT_int_add(negdivisor, n, p + n, 1);
    memset(p + n, 0, n * sizeof(DWORD));
 
    /* skip all leading zero DWORDs in quotient */
    for (i = 0; i < n && !p[n - 1]; i++) VARIANT_int_shiftleft(p, n, 32);
    /* i is now number of DWORDs left to process */
    for (i <<= 5; i < (n << 5); i++) {
        VARIANT_int_shiftleft(p, n << 1, 1);    /* shl quotient+remainder */
 
        /* trial subtraction */
        memcpy(tempsub, p + n, n * sizeof(DWORD));
        VARIANT_int_add(tempsub, n, negdivisor, n);
 
        /* check whether result of subtraction was negative */
        if ((tempsub[n - 1] & 0x80000000) == 0) {
            memcpy(p + n, tempsub, n * sizeof(DWORD));
            p[0] |= 1;
        }
    }
}

Referenced by VARIANT_DI_div().

VARIANT_int_divbychar()

static unsigned char VARIANT_int_divbychar ( DWORD *  p, unsigned int  n, unsigned char  divisor  )

static

Definition at line 4695 of file vartype.c.

{
    if (divisor == 0) {
        /* division by 0 */
        return 0xFF;
    } else if (divisor == 1) {
        /* dividend remains unchanged */
        return 0;
    } else {
        unsigned char remainder = 0;
        ULONGLONG iTempDividend;
        signed int i;
        
        for (i = n - 1; i >= 0 && !p[i]; i--);  /* skip leading zeros */
        for (; i >= 0; i--) {
            iTempDividend = ((ULONGLONG)remainder << 32) + p[i];
            remainder = iTempDividend % divisor;
            p[i] = iTempDividend / divisor;
        }
        
        return remainder;
    }
}

Referenced by VarDecMul(), VARIANT_DecScale(), VARIANT_DI_mul(), VARIANT_DI_normalize(), VARIANT_DI_tostringW(), VARIANT_do_division(), and VARIANT_int_addlossy().

VARIANT_int_iszero()

static BOOL VARIANT_int_iszero ( const DWORD *  p, unsigned int  n  )

static

Definition at line 4720 of file vartype.c.

{
    for (; n > 0; n--) if (*p++ != 0) return FALSE;
    return TRUE;
}

Referenced by VarDecMul(), VARIANT_DecScale(), VARIANT_DI_div(), VARIANT_DI_mul(), VARIANT_DI_normalize(), VARIANT_DI_tostringW(), VARIANT_do_division(), and VARIANT_int_addlossy().

VARIANT_int_mulbychar()

static unsigned char VARIANT_int_mulbychar ( DWORD *  p, unsigned int  n, unsigned char  m  )

static

Definition at line 5003 of file vartype.c.

{
    unsigned int i;
    ULONG iOverflowMul;
    
    for (iOverflowMul = 0, i = 0; i < n; i++)
        p[i] = VARIANT_Mul(p[i], m, &iOverflowMul);
    return (unsigned char)iOverflowMul;
}

Referenced by VARIANT_DI_div(), VARIANT_DI_normalize(), and VARIANT_int_addlossy().

VARIANT_int_shiftleft()

static void VARIANT_int_shiftleft ( DWORD *  p, unsigned int  n, unsigned int  shift  )

static

Definition at line 4905 of file vartype.c.

{
    DWORD shifted;
    unsigned int i;
    
    /* shift whole DWORDs to the left */
    while (shift >= 32)
    {
        memmove(p + 1, p, (n - 1) * sizeof(DWORD));
        *p = 0; shift -= 32;
    }
    
    /* shift remainder (1..31 bits) */
    shifted = 0;
    if (shift > 0) for (i = 0; i < n; i++)
    {
        DWORD b;
        b = p[i] >> (32 - shift);
        p[i] = (p[i] << shift) | shifted;
        shifted = b;
    }
}

Referenced by VARIANT_DI_normalize(), and VARIANT_int_div().

VARIANT_IsValidMonthDay()

static BOOL VARIANT_IsValidMonthDay ( DWORD  day, DWORD  month, DWORD  year  )

static

Definition at line 7374 of file vartype.c.

{
  static const BYTE days[] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 
  if (day && month && month < 13)
  {
    if (day <= days[month] || (month == 2 && day == 29 && IsLeapYear(year)))
      return TRUE;
  }
  return FALSE;
}

Referenced by VARIANT_MakeDate().

VARIANT_MakeBstr()

static BSTR VARIANT_MakeBstr ( LCID  lcid, DWORD  dwFlags, WCHAR *  szOut  )

static

Definition at line 6345 of file vartype.c.

{
  WCHAR szConverted[256];
 
  if (dwFlags & VAR_NEGATIVE)
    *--szOut = '-';
 
  if (dwFlags & LOCALE_USE_NLS)
  {
    /* Format the number for the locale */
    szConverted[0] = '\0';
    GetNumberFormatW(lcid, dwFlags & LOCALE_NOUSEROVERRIDE,
                     szOut, NULL, szConverted, ARRAY_SIZE(szConverted));
    szOut = szConverted;
  }
  return SysAllocStringByteLen((LPCSTR)szOut, lstrlenW(szOut) * sizeof(WCHAR));
}

Referenced by VARIANT_BstrFromUInt().

VARIANT_MakeDate()

static HRESULT VARIANT_MakeDate ( DATEPARSE *  dp, DWORD  iDate, DWORD  offset, SYSTEMTIME *  st  )

inlinestatic

Definition at line 7394 of file vartype.c.

{
  DWORD dwAllOrders, dwTry, dwCount = 0, v1, v2, v3;
 
  if (!dp->dwCount)
  {
    v1 = 30; /* Default to (Variant) 0 date part */
    v2 = 12;
    v3 = 1899;
    goto VARIANT_MakeDate_OK;
  }
 
  v1 = dp->dwValues[offset + 0];
  v2 = dp->dwValues[offset + 1];
  if (dp->dwCount == 2)
  {
    SYSTEMTIME current;
    GetSystemTime(&current);
    v3 = current.wYear;
  }
  else
    v3 = dp->dwValues[offset + 2];
 
  TRACE("(%d,%d,%d,%d,%d)\n", v1, v2, v3, iDate, offset);
 
  /* If one number must be a month (Because a month name was given), then only
   * consider orders with the month in that position.
   * If we took the current year as 'v3', then only allow a year in that position.
   */
  if (dp->dwFlags[offset + 0] & DP_MONTH)
  {
    dwAllOrders = ORDER_MDY;
  }
  else if (dp->dwFlags[offset + 1] & DP_MONTH)
  {
    dwAllOrders = ORDER_DMY;
    if (dp->dwCount > 2)
      dwAllOrders |= ORDER_YMD;
  }
  else if (dp->dwCount > 2 && dp->dwFlags[offset + 2] & DP_MONTH)
  {
    dwAllOrders = ORDER_YDM;
  }
  else
  {
    dwAllOrders = ORDER_MDY|ORDER_DMY;
    if (dp->dwCount > 2)
      dwAllOrders |= (ORDER_YMD|ORDER_YDM);
  }
 
VARIANT_MakeDate_Start:
  TRACE("dwAllOrders is 0x%08x\n", dwAllOrders);
 
  while (dwAllOrders)
  {
    DWORD dwTemp;
 
    if (dwCount == 0)
    {
      /* First: Try the order given by iDate */
      switch (iDate)
      {
      case 0:  dwTry = dwAllOrders & ORDER_MDY; break;
      case 1:  dwTry = dwAllOrders & ORDER_DMY; break;
      default: dwTry = dwAllOrders & ORDER_YMD; break;
      }
    }
    else if (dwCount == 1)
    {
      /* Second: Try all the orders compatible with iDate */
      switch (iDate)
      {
      case 0:  dwTry = dwAllOrders & ~(ORDER_DMY|ORDER_YDM); break;
      case 1:  dwTry = dwAllOrders & ~(ORDER_MDY|ORDER_YDM|ORDER_MYD); break;
      default: dwTry = dwAllOrders & ~(ORDER_DMY|ORDER_YDM); break;
      }
    }
    else
    {
      /* Finally: Try any remaining orders */
      dwTry = dwAllOrders;
    }
 
    TRACE("Attempt %d, dwTry is 0x%08x\n", dwCount, dwTry);
 
    dwCount++;
    if (!dwTry)
      continue;
 
#define DATE_SWAP(x,y) do { dwTemp = x; x = y; y = dwTemp; } while (0)
 
    if (dwTry & ORDER_MDY)
    {
      if (VARIANT_IsValidMonthDay(v2,v1,v3))
      {
        DATE_SWAP(v1,v2);
        goto VARIANT_MakeDate_OK;
      }
      dwAllOrders &= ~ORDER_MDY;
    }
    if (dwTry & ORDER_YMD)
    {
      if (VARIANT_IsValidMonthDay(v3,v2,v1))
      {
        DATE_SWAP(v1,v3);
        goto VARIANT_MakeDate_OK;
      }
      dwAllOrders &= ~ORDER_YMD;
    }
    if (dwTry & ORDER_YDM)
    {
      if (VARIANT_IsValidMonthDay(v2,v3,v1))
      {
        DATE_SWAP(v1,v2);
        DATE_SWAP(v2,v3);
        goto VARIANT_MakeDate_OK;
      }
      dwAllOrders &= ~ORDER_YDM;
    }
    if (dwTry & ORDER_DMY)
    {
      if (VARIANT_IsValidMonthDay(v1,v2,v3))
        goto VARIANT_MakeDate_OK;
      dwAllOrders &= ~ORDER_DMY;
    }
    if (dwTry & ORDER_MYD)
    {
      /* Only occurs if we are trying a 2 year date as M/Y not D/M */
      if (VARIANT_IsValidMonthDay(v3,v1,v2))
      {
        DATE_SWAP(v1,v3);
        DATE_SWAP(v2,v3);
        goto VARIANT_MakeDate_OK;
      }
      dwAllOrders &= ~ORDER_MYD;
    }
  }
 
  if (dp->dwCount == 2)
  {
    /* We couldn't make a date as D/M or M/D, so try M/Y or Y/M */
    v3 = 1; /* 1st of the month */
    dwAllOrders = ORDER_YMD|ORDER_MYD;
    dp->dwCount = 0; /* Don't return to this code path again */
    dwCount = 0;
    goto VARIANT_MakeDate_Start;
  }
 
  /* No valid dates were able to be constructed */
  return DISP_E_TYPEMISMATCH;
 
VARIANT_MakeDate_OK:
 
  /* Check that the time part is ok */
  if (st->wHour > 23 || st->wMinute > 59 || st->wSecond > 59)
    return DISP_E_TYPEMISMATCH;
 
  TRACE("Time %d %d %d\n", st->wHour, st->wMinute, st->wSecond);
  if (st->wHour < 12 && (dp->dwParseFlags & DP_PM))
    st->wHour += 12;
  else if (st->wHour == 12 && (dp->dwParseFlags & DP_AM))
    st->wHour = 0;
  TRACE("Time %d %d %d\n", st->wHour, st->wMinute, st->wSecond);
 
  st->wDay = v1;
  st->wMonth = v2;
  /* FIXME: For 2 digit dates, I'm not sure if 30 is hard coded or not. It may
   * be retrieved from:
   * HKCU\Control Panel\International\Calendars\TwoDigitYearMax
   * But Wine doesn't have/use that key as at the time of writing.
   */
  st->wYear = v3 < 30 ? 2000 + v3 : v3 < 100 ? 1900 + v3 : v3;
  TRACE("Returning date %d/%d/%d\n", v1, v2, st->wYear);
  return S_OK;
}

Referenced by VarDateFromStr().

VARIANT_Mul()

static ULONG VARIANT_Mul ( ULONG  ulLeft, ULONG  ulRight, ULONG *  pulHigh  )

static

Definition at line 4554 of file vartype.c.

{
  ULARGE_INTEGER ul64;
 
  ul64.QuadPart = (ULONG64)ulLeft * (ULONG64)ulRight + (ULONG64)*pulHigh;
  *pulHigh = ul64.u.HighPart;
  return ul64.u.LowPart;
}

Referenced by VARIANT_DI_mul(), and VARIANT_int_mulbychar().

VARIANT_NumberFromBstr()

static HRESULT VARIANT_NumberFromBstr ( OLECHAR *  pStrIn, LCID  lcid, ULONG  ulFlags, void *  pOut, VARTYPE  vt  )

static

Definition at line 90 of file vartype.c.

{
  VARIANTARG dstVar;
  HRESULT hRet;
  NUMPARSE np;
  BYTE rgb[1024];
 
  /* Use VarParseNumFromStr/VarNumFromParseNum as MSDN indicates */
  np.cDig = ARRAY_SIZE(rgb);
  np.dwInFlags = NUMPRS_STD;
 
  hRet = VarParseNumFromStr(pStrIn, lcid, ulFlags, &np, rgb);
 
  if (SUCCEEDED(hRet))
  {
    /* 1 << vt gives us the VTBIT constant for the destination number type */
    hRet = VarNumFromParseNum(&np, rgb, 1 << vt, &dstVar);
    if (SUCCEEDED(hRet))
      VARIANT_CopyData(&dstVar, vt, pOut);
  }
  return hRet;
}

Referenced by VarCyFromStr(), VarDecFromStr(), VarI1FromStr(), VarI2FromStr(), VarI4FromStr(), VarI8FromStr(), VarR4FromStr(), VarR8FromStr(), VarUI1FromStr(), VarUI2FromStr(), VarUI4FromStr(), and VarUI8FromStr().

VARIANT_Sub()

static ULONG VARIANT_Sub ( ULONG  ulLeft, ULONG  ulRight, ULONG *  pulHigh  )

static

Definition at line 4530 of file vartype.c.

{
  BOOL invert = FALSE;
  ULARGE_INTEGER ul64;
 
  ul64.QuadPart = (LONG64)ulLeft - (ULONG64)ulRight;
  if (ulLeft < ulRight)
    invert = TRUE;
 
  if (ul64.QuadPart > (ULONG64)*pulHigh)
    ul64.QuadPart -= (ULONG64)*pulHigh;
  else
  {
    ul64.QuadPart -= (ULONG64)*pulHigh;
    invert = TRUE;
  }
  if (invert)
    ul64.u.HighPart = -ul64.u.HighPart ;
 
  *pulHigh = ul64.u.HighPart;
  return ul64.u.LowPart;
}

Referenced by VarDecAdd().

VARIANT_WriteNumber()

static WCHAR * VARIANT_WriteNumber ( ULONG64  ulVal, WCHAR *  szOut  )

static

Definition at line 6330 of file vartype.c.

{
  do
  {
    WCHAR ulNextDigit = ulVal % 10;
 
    *szOut-- = '0' + ulNextDigit;
    ulVal = (ulVal - ulNextDigit) / 10;
  } while (ulVal);
 
  szOut++;
  return szOut;
}

Referenced by VARIANT_BstrFromUInt().

VarR4CmpR8()

HRESULT WINAPI VarR4CmpR8	(	float	fltLeft,
		double	dblRight
	)

Definition at line 3021 of file vartype.c.

{
  if (fltLeft < dblRight)
    return VARCMP_LT;
  else if (fltLeft > dblRight)
    return VARCMP_GT;
  return VARCMP_EQ;
}

VarR4FromBool()

HRESULT WINAPI VarR4FromBool	(	VARIANT_BOOL	boolIn,
		float *	pFltOut
	)

Definition at line 2868 of file vartype.c.

{
  return VarR4FromI2(boolIn, pFltOut);
}

Referenced by test_VarR4FromBool(), and VARIANT_Coerce().

VarR4FromCy()

HRESULT WINAPI VarR4FromCy	(	CY	cyIn,
		float *	pFltOut
	)

Definition at line 2790 of file vartype.c.

{
  *pFltOut = (double)cyIn.int64 / CY_MULTIPLIER_F;
  return S_OK;
}

Referenced by test_VarR4FromCy(), and VARIANT_Coerce().

VarR4FromDate()

HRESULT WINAPI VarR4FromDate	(	DATE	dateIn,
		float *	pFltOut
	)

Definition at line 2809 of file vartype.c.

{
  return VarR4FromR8(dateIn, pFltOut);
}

Referenced by test_VarR4FromDate(), and VARIANT_Coerce().

VarR4FromDec()

HRESULT WINAPI VarR4FromDec	(	DECIMAL *	pDecIn,
		float *	pFltOut
	)

Definition at line 2946 of file vartype.c.

{
  BYTE scale = DEC_SCALE(pDecIn);
  double divisor = 1.0;
  double highPart;
 
  if (scale > DEC_MAX_SCALE || DEC_SIGN(pDecIn) & ~DECIMAL_NEG)
    return E_INVALIDARG;
 
  while (scale--)
    divisor *= 10.0;
 
  if (DEC_SIGN(pDecIn))
    divisor = -divisor;
 
  if (DEC_HI32(pDecIn))
  {
    highPart = (double)DEC_HI32(pDecIn) / divisor;
    highPart *= 4294967296.0F;
    highPart *= 4294967296.0F;
  }
  else
    highPart = 0.0;
 
  *pFltOut = (double)DEC_LO64(pDecIn) / divisor + highPart;
  return S_OK;
}

Referenced by test_VarR4FromDec(), and VARIANT_Coerce().

VarR4FromDisp()

HRESULT WINAPI VarR4FromDisp	(	IDispatch *	pdispIn,
		LCID	lcid,
		float *	pFltOut
	)

Definition at line 2851 of file vartype.c.

{
  return VARIANT_FromDisp(pdispIn, lcid, pFltOut, VT_R4, 0);
}

Referenced by VARIANT_Coerce().

VarR4FromI1()

HRESULT WINAPI VarR4FromI1	(	signed char	cIn,
		float *	pFltOut
	)

Definition at line 2888 of file vartype.c.

{
  return _VarR4FromI1(cIn, pFltOut);
}

Referenced by test_VarR4FromI1(), and VARIANT_Coerce().

VarR4FromI2()

HRESULT WINAPI VarR4FromI2	(	SHORT	sIn,
		float *	pFltOut
	)

Definition at line 2735 of file vartype.c.

{
  return _VarR4FromI2(sIn, pFltOut);
}

Referenced by test_VarR4FromI2(), VARIANT_Coerce(), and VarR4FromBool().

VarR4FromI4()

HRESULT WINAPI VarR4FromI4	(	LONG	lIn,
		float *	pFltOut
	)

Definition at line 2752 of file vartype.c.

{
  return _VarR4FromI4(lIn, pFltOut);
}

Referenced by test_VarR4FromI4(), and VARIANT_Coerce().

VarR4FromI8()

HRESULT WINAPI VarR4FromI8	(	LONG64	llIn,
		float *	pFltOut
	)

Definition at line 2986 of file vartype.c.

{
  return _VarR4FromI8(llIn, pFltOut);
}

Referenced by test_VarR4FromI8(), and VARIANT_Coerce().

VarR4FromR8()

HRESULT WINAPI VarR4FromR8	(	double	dblIn,
		float *	pFltOut
	)

Definition at line 2770 of file vartype.c.

{
  double d = dblIn < 0.0 ? -dblIn : dblIn;
  if (d > R4_MAX) return DISP_E_OVERFLOW;
  *pFltOut = dblIn;
  return S_OK;
}

Referenced by test_VarR4FromR8(), VARIANT_Coerce(), and VarR4FromDate().

VarR4FromStr()

HRESULT WINAPI VarR4FromStr	(	OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		float *	pFltOut
	)

Definition at line 2830 of file vartype.c.

{
  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pFltOut, VT_R4);
}

Referenced by test_VarR4FromStr(), and VARIANT_Coerce().

VarR4FromUI1()

HRESULT WINAPI VarR4FromUI1	(	BYTE	bIn,
		float *	pFltOut
	)

Definition at line 2718 of file vartype.c.

{
  return _VarR4FromUI1(bIn, pFltOut);
}

Referenced by test_VarR4FromUI1(), and VARIANT_Coerce().

VarR4FromUI2()

HRESULT WINAPI VarR4FromUI2	(	USHORT	usIn,
		float *	pFltOut
	)

Definition at line 2908 of file vartype.c.

{
  return _VarR4FromUI2(usIn, pFltOut);
}

Referenced by test_VarR4FromUI2(), and VARIANT_Coerce().

VarR4FromUI4()

HRESULT WINAPI VarR4FromUI4	(	ULONG	ulIn,
		float *	pFltOut
	)

Definition at line 2928 of file vartype.c.

{
  return _VarR4FromUI4(ulIn, pFltOut);
}

Referenced by test_VarR4FromUI4(), and VARIANT_Coerce().

VarR4FromUI8()

HRESULT WINAPI VarR4FromUI8	(	ULONG64	ullIn,
		float *	pFltOut
	)

Definition at line 3003 of file vartype.c.

{
  return _VarR4FromUI8(ullIn, pFltOut);
}

Referenced by test_VarR4FromUI8(), and VARIANT_Coerce().

VarR8FromBool()

HRESULT WINAPI VarR8FromBool	(	VARIANT_BOOL	boolIn,
		double *	pDblOut
	)

Definition at line 3189 of file vartype.c.

{
  return VarR8FromI2(boolIn, pDblOut);
}

Referenced by test_VarR8FromBool(), VarDateFromBool(), and VARIANT_Coerce().

VarR8FromCy()

HRESULT WINAPI VarR8FromCy	(	CY	cyIn,
		double *	pDblOut
	)

Definition at line 3113 of file vartype.c.

{
  return _VarR8FromCy(cyIn, pDblOut);
}

Referenced by test_VarAdd(), test_VarMul(), test_VarR8FromCy(), test_VarSub(), VarDateFromCy(), and VARIANT_Coerce().

VarR8FromDate()

HRESULT WINAPI VarR8FromDate	(	DATE	dateIn,
		double *	pDblOut
	)

Definition at line 3130 of file vartype.c.

{
  return _VarR8FromDate(dateIn, pDblOut);
}

Referenced by test_VarR8FromDate(), and VARIANT_Coerce().

VarR8FromDec()

HRESULT WINAPI VarR8FromDec	(	const DECIMAL *	pDecIn,
		double *	pDblOut
	)

Definition at line 3267 of file vartype.c.

{
  BYTE scale = DEC_SCALE(pDecIn);
  double divisor = 1.0, highPart;
 
  if (scale > DEC_MAX_SCALE || DEC_SIGN(pDecIn) & ~DECIMAL_NEG)
    return E_INVALIDARG;
 
  while (scale--)
    divisor *= 10;
 
  if (DEC_SIGN(pDecIn))
    divisor = -divisor;
 
  if (DEC_HI32(pDecIn))
  {
    highPart = (double)DEC_HI32(pDecIn) / divisor;
    highPart *= 4294967296.0F;
    highPart *= 4294967296.0F;
  }
  else
    highPart = 0.0;
 
  *pDblOut = (double)DEC_LO64(pDecIn) / divisor + highPart;
  return S_OK;
}

Referenced by test_VarAdd(), test_VarDiv(), test_VarMul(), test_VarR8FromDec(), test_VarSub(), VarDateFromDec(), VarDecFix(), VarDecInt(), VarI8FromDec(), VARIANT_Coerce(), VarRound(), and VarUI8FromDec().

VarR8FromDisp()

HRESULT WINAPI VarR8FromDisp	(	IDispatch *	pdispIn,
		LCID	lcid,
		double *	pDblOut
	)

Definition at line 3172 of file vartype.c.

{
  return VARIANT_FromDisp(pdispIn, lcid, pDblOut, VT_R8, 0);
}

Referenced by VARIANT_Coerce().

VarR8FromI1()

HRESULT WINAPI VarR8FromI1	(	signed char	cIn,
		double *	pDblOut
	)

Definition at line 3209 of file vartype.c.

{
  return _VarR8FromI1(cIn, pDblOut);
}

Referenced by test_VarR8FromI1(), VarDateFromI1(), and VARIANT_Coerce().

VarR8FromI2()

HRESULT WINAPI VarR8FromI2	(	SHORT	sIn,
		double *	pDblOut
	)

Definition at line 3062 of file vartype.c.

{
  return _VarR8FromI2(sIn, pDblOut);
}

Referenced by test_VarR8FromI2(), VarDateFromI2(), VARIANT_Coerce(), and VarR8FromBool().

VarR8FromI4()

HRESULT WINAPI VarR8FromI4	(	LONG	lIn,
		double *	pDblOut
	)

Definition at line 3079 of file vartype.c.

{
  return _VarR8FromI4(lIn, pDblOut);
}

Referenced by test_VarR8FromI4(), and VARIANT_Coerce().

VarR8FromI8()

HRESULT WINAPI VarR8FromI8	(	LONG64	llIn,
		double *	pDblOut
	)

Definition at line 3306 of file vartype.c.

{
  return _VarR8FromI8(llIn, pDblOut);
}

Referenced by test_VarR8FromI8(), VARIANT_Coerce(), and VarNeg().

VarR8FromR4()

HRESULT WINAPI VarR8FromR4	(	FLOAT	fltIn,
		double *	pDblOut
	)

Definition at line 3096 of file vartype.c.

{
  return _VarR8FromR4(fltIn, pDblOut);
}

Referenced by test_VarR8FromR4(), VarDateFromR4(), and VARIANT_Coerce().

VarR8FromStr()

HRESULT WINAPI VarR8FromStr	(	OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		double *	pDblOut
	)

Definition at line 3151 of file vartype.c.

{
  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pDblOut, VT_R8);
}

Referenced by test_VarAdd(), test_VarR8FromStr(), VarAbs(), VarAnd(), VarBoolFromStr(), VarFix(), VARIANT_Coerce(), VarImp(), VarInt(), VarNeg(), VarNot(), VarOr(), VarRound(), and VarXor().

VarR8FromUI1()

HRESULT WINAPI VarR8FromUI1	(	BYTE	bIn,
		double *	pDblOut
	)

Definition at line 3045 of file vartype.c.

{
  return _VarR8FromUI1(bIn, pDblOut);
}

Referenced by test_VarR8FromUI1(), VarDateFromUI1(), and VARIANT_Coerce().

VarR8FromUI2()

HRESULT WINAPI VarR8FromUI2	(	USHORT	usIn,
		double *	pDblOut
	)

Definition at line 3229 of file vartype.c.

{
  return _VarR8FromUI2(usIn, pDblOut);
}

Referenced by test_VarR8FromUI2(), VarDateFromUI2(), and VARIANT_Coerce().

VarR8FromUI4()

HRESULT WINAPI VarR8FromUI4	(	ULONG	ulIn,
		double *	pDblOut
	)

Definition at line 3249 of file vartype.c.

{
  return _VarR8FromUI4(ulIn, pDblOut);
}

Referenced by test_VarR8FromUI4(), and VARIANT_Coerce().

VarR8FromUI8()

HRESULT WINAPI VarR8FromUI8	(	ULONG64	ullIn,
		double *	pDblOut
	)

Definition at line 3323 of file vartype.c.

{
  return _VarR8FromUI8(ullIn, pDblOut);
}

Referenced by test_VarR8FromUI8(), VARIANT_Coerce(), and variant_from_largeint().

VarR8Pow()

HRESULT WINAPI VarR8Pow	(	double	dblLeft,
		double	dblPow,
		double *	pDblOut
	)

Definition at line 3341 of file vartype.c.

{
  *pDblOut = pow(dblLeft, dblPow);
  return S_OK;
}

VarR8Round()

HRESULT WINAPI VarR8Round	(	double	dblIn,
		int	nDig,
		double *	pDblOut
	)

Definition at line 3368 of file vartype.c.

{
  double scale, whole, fract;
 
  if (nDig < 0)
    return E_INVALIDARG;
 
  scale = pow(10.0, nDig);
 
  dblIn *= scale;
  whole = dblIn < 0 ? ceil(dblIn) : floor(dblIn);
  fract = dblIn - whole;
 
  if (fract > 0.5)
    dblIn = whole + 1.0;
  else if (fract == 0.5)
    dblIn = whole + fmod(whole, 2.0);
  else if (fract >= 0.0)
    dblIn = whole;
  else if (fract == -0.5)
    dblIn = whole - fmod(whole, 2.0);
  else if (fract > -0.5)
    dblIn = whole;
  else
    dblIn = whole - 1.0;
 
  *pDblOut = dblIn / scale;
  return S_OK;
}

VarUI1FromBool()

HRESULT WINAPI VarUI1FromBool	(	VARIANT_BOOL	boolIn,
		BYTE *	pbOut
	)

Definition at line 758 of file vartype.c.

{
  return _VarUI1FromBool(boolIn, pbOut);
}

Referenced by test_VarUI1FromBool(), and VARIANT_Coerce().

VarUI1FromCy()

HRESULT WINAPI VarUI1FromCy	(	CY	cyIn,
		BYTE *	pbOut
	)

Definition at line 676 of file vartype.c.

{
  ULONG i = UI1_MAX + 1;
 
  VarUI4FromCy(cyIn, &i);
  return _VarUI1FromUI4(i, pbOut);
}

Referenced by test_VarUI1FromCy(), and VARIANT_Coerce().

VarUI1FromDate()

HRESULT WINAPI VarUI1FromDate	(	DATE	dateIn,
		BYTE *	pbOut
	)

Definition at line 698 of file vartype.c.

{
  return VarUI1FromR8(dateIn, pbOut);
}

Referenced by test_VarUI1FromDate(), and VARIANT_Coerce().

VarUI1FromDec()

HRESULT WINAPI VarUI1FromDec	(	DECIMAL *	pdecIn,
		BYTE *	pbOut
	)

Definition at line 834 of file vartype.c.

{
  LONG64 i64;
  HRESULT hRet;
 
  hRet = VarI8FromDec(pdecIn, &i64);
 
  if (SUCCEEDED(hRet))
    hRet = _VarUI1FromI8(i64, pbOut);
  return hRet;
}

Referenced by test_VarUI1FromDec(), and VARIANT_Coerce().

VarUI1FromDisp()

HRESULT WINAPI VarUI1FromDisp	(	IDispatch *	pdispIn,
		LCID	lcid,
		BYTE *	pbOut
	)

Definition at line 741 of file vartype.c.

{
  return VARIANT_FromDisp(pdispIn, lcid, pbOut, VT_UI1, 0);
}

Referenced by test_VarUI1FromDisp(), and VARIANT_Coerce().

VarUI1FromI1()

HRESULT WINAPI VarUI1FromI1	(	signed char	cIn,
		BYTE *	pbOut
	)

Definition at line 777 of file vartype.c.

{
  return _VarUI1FromI1(cIn, pbOut);
}

Referenced by test_VarUI1FromI1().

VarUI1FromI2()

HRESULT WINAPI VarUI1FromI2	(	SHORT	sIn,
		BYTE *	pbOut
	)

Definition at line 590 of file vartype.c.

{
  return _VarUI1FromI2(sIn, pbOut);
}

Referenced by test_VarUI1FromI2(), and VARIANT_Coerce().

VarUI1FromI4()

HRESULT WINAPI VarUI1FromI4	(	LONG	iIn,
		BYTE *	pbOut
	)

Definition at line 609 of file vartype.c.

{
  return _VarUI1FromI4(iIn, pbOut);
}

Referenced by test_VarUI1FromI4(), and VARIANT_Coerce().

VarUI1FromI8()

HRESULT WINAPI VarUI1FromI8	(	LONG64	llIn,
		BYTE *	pbOut
	)

Definition at line 860 of file vartype.c.

{
  return _VarUI1FromI8(llIn, pbOut);
}

Referenced by test_VarUI1FromI8(), and VARIANT_Coerce().

VarUI1FromR4()

HRESULT WINAPI VarUI1FromR4	(	FLOAT	fltIn,
		BYTE *	pbOut
	)

Definition at line 629 of file vartype.c.

{
  return VarUI1FromR8(fltIn, pbOut);
}

Referenced by test_VarUI1FromR4(), and VARIANT_Coerce().

VarUI1FromR8()

HRESULT WINAPI VarUI1FromR8	(	double	dblIn,
		BYTE *	pbOut
	)

Definition at line 651 of file vartype.c.

{
  if (dblIn < -0.5 || dblIn >= UI1_MAX + 0.5)
    return DISP_E_OVERFLOW;
  VARIANT_DutchRound(BYTE, dblIn, *pbOut);
  return S_OK;
}

Referenced by test_VarUI1FromR8(), VARIANT_Coerce(), VarUI1FromDate(), and VarUI1FromR4().

VarUI1FromStr()

HRESULT WINAPI VarUI1FromStr	(	OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		BYTE *	pbOut
	)

Definition at line 720 of file vartype.c.

{
  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pbOut, VT_UI1);
}

Referenced by test_VarUI1FromStr(), and VARIANT_Coerce().

VarUI1FromUI2()

HRESULT WINAPI VarUI1FromUI2	(	USHORT	usIn,
		BYTE *	pbOut
	)

Definition at line 796 of file vartype.c.

{
  return _VarUI1FromUI2(usIn, pbOut);
}

Referenced by test_VarUI1FromUI2(), and VARIANT_Coerce().

VarUI1FromUI4()

HRESULT WINAPI VarUI1FromUI4	(	ULONG	ulIn,
		BYTE *	pbOut
	)

Definition at line 815 of file vartype.c.

{
  return _VarUI1FromUI4(ulIn, pbOut);
}

Referenced by test_VarUI1FromUI4(), and VARIANT_Coerce().

VarUI1FromUI8()

HRESULT WINAPI VarUI1FromUI8	(	ULONG64	ullIn,
		BYTE *	pbOut
	)

Definition at line 879 of file vartype.c.

{
  return _VarUI1FromUI8(ullIn, pbOut);
}

Referenced by test_VarUI1FromUI8(), and VARIANT_Coerce().

VarUI2FromBool()

HRESULT WINAPI VarUI2FromBool	(	VARIANT_BOOL	boolIn,
		USHORT *	pusOut
	)

Definition at line 1373 of file vartype.c.

{
  return _VarUI2FromBool(boolIn, pusOut);
}

Referenced by test_VarUI2FromBool(), and VARIANT_Coerce().

VarUI2FromCy()

HRESULT WINAPI VarUI2FromCy	(	CY	cyIn,
		USHORT *	pusOut
	)

Definition at line 1311 of file vartype.c.

{
  ULONG i = UI2_MAX + 1;
 
  VarUI4FromCy(cyIn, &i);
  return _VarUI2FromUI4(i, pusOut);
}

Referenced by test_VarUI2FromCy(), and VARIANT_Coerce().

VarUI2FromDate()

HRESULT WINAPI VarUI2FromDate	(	DATE	dateIn,
		USHORT *	pusOut
	)

Definition at line 1290 of file vartype.c.

{
  return VarUI2FromR8(dateIn, pusOut);
}

Referenced by test_VarUI2FromDate(), and VARIANT_Coerce().

VarUI2FromDec()

HRESULT WINAPI VarUI2FromDec	(	DECIMAL *	pdecIn,
		USHORT *	pusOut
	)

Definition at line 1428 of file vartype.c.

{
  LONG64 i64;
  HRESULT hRet;
 
  hRet = VarI8FromDec(pdecIn, &i64);
 
  if (SUCCEEDED(hRet))
    hRet = _VarUI2FromI8(i64, pusOut);
  return hRet;
}

Referenced by test_VarUI2FromDec(), and VARIANT_Coerce().

VarUI2FromDisp()

HRESULT WINAPI VarUI2FromDisp	(	IDispatch *	pdispIn,
		LCID	lcid,
		USHORT *	pusOut
	)

Definition at line 1356 of file vartype.c.

{
  return VARIANT_FromDisp(pdispIn, lcid, pusOut, VT_UI2, 0);
}

Referenced by VARIANT_Coerce().

VarUI2FromI1()

HRESULT WINAPI VarUI2FromI1	(	signed char	cIn,
		USHORT *	pusOut
	)

Definition at line 1391 of file vartype.c.

{
  return _VarUI2FromI1(cIn, pusOut);
}

Referenced by test_VarUI2FromI1(), and VARIANT_Coerce().

VarUI2FromI2()

HRESULT WINAPI VarUI2FromI2	(	SHORT	sIn,
		USHORT *	pusOut
	)

Definition at line 1212 of file vartype.c.

{
  return _VarUI2FromI2(sIn, pusOut);
}

Referenced by test_VarUI2FromI2().

VarUI2FromI4()

HRESULT WINAPI VarUI2FromI4	(	LONG	iIn,
		USHORT *	pusOut
	)

Definition at line 1230 of file vartype.c.

{
  return _VarUI2FromI4(iIn, pusOut);
}

Referenced by test_VarUI2FromI4(), and VARIANT_Coerce().

VarUI2FromI8()

HRESULT WINAPI VarUI2FromI8	(	LONG64	llIn,
		USHORT *	pusOut
	)

Definition at line 1453 of file vartype.c.

{
  return _VarUI2FromI8(llIn, pusOut);
}

Referenced by test_VarUI2FromI8().

VarUI2FromR4()

HRESULT WINAPI VarUI2FromR4	(	FLOAT	fltIn,
		USHORT *	pusOut
	)

Definition at line 1248 of file vartype.c.

{
  return VarUI2FromR8(fltIn, pusOut);
}

Referenced by test_VarUI2FromR4(), and VARIANT_Coerce().

VarUI2FromR8()

HRESULT WINAPI VarUI2FromR8	(	double	dblIn,
		USHORT *	pusOut
	)

Definition at line 1269 of file vartype.c.

{
  if (dblIn < -0.5 || dblIn >= UI2_MAX + 0.5)
    return DISP_E_OVERFLOW;
  VARIANT_DutchRound(USHORT, dblIn, *pusOut);
  return S_OK;
}

Referenced by test_VarUI2FromR8(), VARIANT_Coerce(), VarUI2FromDate(), and VarUI2FromR4().

VarUI2FromStr()

HRESULT WINAPI VarUI2FromStr	(	OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		USHORT *	pusOut
	)

Definition at line 1335 of file vartype.c.

{
  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pusOut, VT_UI2);
}

Referenced by test_VarUI2FromStr(), and VARIANT_Coerce().

VarUI2FromUI1()

HRESULT WINAPI VarUI2FromUI1	(	BYTE	bIn,
		USHORT *	pusOut
	)

Definition at line 1194 of file vartype.c.

{
  return _VarUI2FromUI1(bIn, pusOut);
}

Referenced by test_VarUI2FromUI1(), and VARIANT_Coerce().

VarUI2FromUI4()

HRESULT WINAPI VarUI2FromUI4	(	ULONG	ulIn,
		USHORT *	pusOut
	)

Definition at line 1409 of file vartype.c.

{
  return _VarUI2FromUI4(ulIn, pusOut);
}

Referenced by test_VarUI2FromUI4(), and VARIANT_Coerce().

VarUI2FromUI8()

HRESULT WINAPI VarUI2FromUI8	(	ULONG64	ullIn,
		USHORT *	pusOut
	)

Definition at line 1471 of file vartype.c.

{
  return _VarUI2FromUI8(ullIn, pusOut);
}

Referenced by test_VarUI2FromUI8().

VarUI4FromBool()

HRESULT WINAPI VarUI4FromBool	(	VARIANT_BOOL	boolIn,
		ULONG *	pulOut
	)

Definition at line 1958 of file vartype.c.

{
  return _VarUI4FromBool(boolIn, pulOut);
}

Referenced by test_VarUI4FromBool(), and VARIANT_Coerce().

VarUI4FromCy()

HRESULT WINAPI VarUI4FromCy	(	CY	cyIn,
		ULONG *	pulOut
	)

Definition at line 1897 of file vartype.c.

{
  double d = cyIn.int64 / CY_MULTIPLIER_F;
  return VarUI4FromR8(d, pulOut);
}

Referenced by test_VarUI4FromCy(), VARIANT_Coerce(), VarUI1FromCy(), and VarUI2FromCy().

VarUI4FromDate()

HRESULT WINAPI VarUI4FromDate	(	DATE	dateIn,
		ULONG *	pulOut
	)

Definition at line 1879 of file vartype.c.

{
  return VarUI4FromR8(dateIn, pulOut);
}

Referenced by test_VarUI4FromDate(), and VARIANT_Coerce().

VarUI4FromDec()

HRESULT WINAPI VarUI4FromDec	(	DECIMAL *	pdecIn,
		ULONG *	pulOut
	)

Definition at line 2012 of file vartype.c.

{
  LONG64 i64;
  HRESULT hRet;
 
  hRet = VarI8FromDec(pdecIn, &i64);
 
  if (SUCCEEDED(hRet))
    hRet = _VarUI4FromI8(i64, pulOut);
  return hRet;
}

Referenced by test_VarUI4FromDec(), and VARIANT_Coerce().

VarUI4FromDisp()

HRESULT WINAPI VarUI4FromDisp	(	IDispatch *	pdispIn,
		LCID	lcid,
		ULONG *	pulOut
	)

Definition at line 1941 of file vartype.c.

{
  return VARIANT_FromDisp(pdispIn, lcid, pulOut, VT_UI4, 0);
}

Referenced by VARIANT_Coerce().

VarUI4FromI1()

HRESULT WINAPI VarUI4FromI1	(	signed char	cIn,
		ULONG *	pulOut
	)

Definition at line 1976 of file vartype.c.

{
  return _VarUI4FromI1(cIn, pulOut);
}

Referenced by test_VarUI4FromI1(), and VARIANT_Coerce().

VarUI4FromI2()

HRESULT WINAPI VarUI4FromI2	(	SHORT	sIn,
		ULONG *	pulOut
	)

Definition at line 1801 of file vartype.c.

{
  return _VarUI4FromI2(sIn, pulOut);
}

Referenced by test_VarUI4FromI2(), and VARIANT_Coerce().

VarUI4FromI4()

HRESULT WINAPI VarUI4FromI4	(	LONG	iIn,
		ULONG *	pulOut
	)

Definition at line 1819 of file vartype.c.

{
  return _VarUI4FromI4(iIn, pulOut);
}

Referenced by test_VarUI4FromI4().

VarUI4FromI8()

HRESULT WINAPI VarUI4FromI8	(	LONG64	llIn,
		ULONG *	pulOut
	)

Definition at line 2037 of file vartype.c.

{
  return _VarUI4FromI8(llIn, pulOut);
}

Referenced by test_VarUI4FromI8(), test_VarUI4FromUI8(), and VARIANT_Coerce().

VarUI4FromR4()

HRESULT WINAPI VarUI4FromR4	(	FLOAT	fltIn,
		ULONG *	pulOut
	)

Definition at line 1837 of file vartype.c.

{
  return VarUI4FromR8(fltIn, pulOut);
}

Referenced by test_VarUI4FromR4(), test_VarUI4FromR8(), and VARIANT_Coerce().

VarUI4FromR8()

HRESULT WINAPI VarUI4FromR8	(	double	dblIn,
		ULONG *	pulOut
	)

Definition at line 1858 of file vartype.c.

{
  if (dblIn < -0.5 || dblIn >= UI4_MAX + 0.5)
    return DISP_E_OVERFLOW;
  VARIANT_DutchRound(ULONG, dblIn, *pulOut);
  return S_OK;
}

Referenced by test_VarUI4FromR8(), VARIANT_Coerce(), VarUI4FromCy(), VarUI4FromDate(), and VarUI4FromR4().

VarUI4FromStr()

HRESULT WINAPI VarUI4FromStr	(	OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		ULONG *	pulOut
	)

Definition at line 1920 of file vartype.c.

{
  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pulOut, VT_UI4);
}

Referenced by test_VarUI4FromStr(), and VARIANT_Coerce().

VarUI4FromUI1()

HRESULT WINAPI VarUI4FromUI1	(	BYTE	bIn,
		ULONG *	pulOut
	)

Definition at line 1783 of file vartype.c.

{
  return _VarUI4FromUI1(bIn, pulOut);
}

Referenced by test_VarUI4FromUI1(), and VARIANT_Coerce().

VarUI4FromUI2()

HRESULT WINAPI VarUI4FromUI2	(	USHORT	usIn,
		ULONG *	pulOut
	)

Definition at line 1993 of file vartype.c.

{
  return _VarUI4FromUI2(usIn, pulOut);
}

Referenced by test_VarUI4FromUI2(), and VARIANT_Coerce().

VarUI4FromUI8()

HRESULT WINAPI VarUI4FromUI8	(	ULONG64	ullIn,
		ULONG *	pulOut
	)

Definition at line 2055 of file vartype.c.

{
  return _VarUI4FromUI8(ullIn, pulOut);
}

Referenced by test_VarUI4FromUI8(), and VARIANT_Coerce().

VarUI8FromBool()

HRESULT WINAPI VarUI8FromBool	(	VARIANT_BOOL	boolIn,
		ULONG64 *	pui64Out
	)

Definition at line 2594 of file vartype.c.

{
  return VarI8FromI2(boolIn, (LONG64 *)pui64Out);
}

Referenced by test_VarUI8FromBool(), and VARIANT_Coerce().

VarUI8FromCy()

HRESULT WINAPI VarUI8FromCy	(	CY	cyIn,
		ULONG64 *	pui64Out
	)

Definition at line 2498 of file vartype.c.

{
  if (cyIn.int64 < 0)
  {
    if (cyIn.int64 < -CY_HALF)
      return DISP_E_OVERFLOW;
    *pui64Out = 0;
  }
  else
  {
    *pui64Out = cyIn.int64 / CY_MULTIPLIER;
 
    cyIn.int64 -= *pui64Out * CY_MULTIPLIER; /* cyIn.s.Lo now holds fractional remainder */
 
    if (cyIn.s.Lo > CY_HALF || (cyIn.s.Lo == CY_HALF && (*pui64Out & 0x1)))
      (*pui64Out)++;
  }
  return S_OK;
}

Referenced by test_VarUI8FromCy(), and VARIANT_Coerce().

VarUI8FromDate()

HRESULT WINAPI VarUI8FromDate	(	DATE	dateIn,
		ULONG64 *	pui64Out
	)

Definition at line 2533 of file vartype.c.

{
  return VarUI8FromR8(dateIn, pui64Out);
}

Referenced by test_VarUI8FromDate(), and VARIANT_Coerce().

VarUI8FromDec()

HRESULT WINAPI VarUI8FromDec	(	DECIMAL *	pdecIn,
		ULONG64 *	pui64Out
	)

Definition at line 2670 of file vartype.c.

{
  if (!DEC_SCALE(pdecIn))
  {
    /* This decimal is just a 96 bit integer */
    if (DEC_SIGN(pdecIn) & ~DECIMAL_NEG)
      return E_INVALIDARG;
 
    if (DEC_HI32(pdecIn))
      return DISP_E_OVERFLOW;
 
    if (DEC_SIGN(pdecIn))
    {
      WARN("Sign would be ignored under Win32!\n");
      return DISP_E_OVERFLOW;
    }
 
    *pui64Out = DEC_LO64(pdecIn);
    return S_OK;
  }
  else
  {
    /* Decimal contains a floating point number */
    HRESULT hRet;
    double dbl;
 
    hRet = VarR8FromDec(pdecIn, &dbl);
    if (SUCCEEDED(hRet))
      hRet = VarUI8FromR8(dbl, pui64Out);
    return hRet;
  }
}

Referenced by test_VarUI8FromDec(), and VARIANT_Coerce().

VarUI8FromDisp()

HRESULT WINAPI VarUI8FromDisp	(	IDispatch *	pdispIn,
		LCID	lcid,
		ULONG64 *	pui64Out
	)

Definition at line 2576 of file vartype.c.

{
  return VARIANT_FromDisp(pdispIn, lcid, pui64Out, VT_UI8, 0);
}

Referenced by VARIANT_Coerce().

VarUI8FromI1()

HRESULT WINAPI VarUI8FromI1	(	signed char	cIn,
		ULONG64 *	pui64Out
	)

Definition at line 2611 of file vartype.c.

{
  return _VarUI8FromI1(cIn, pui64Out);
}

Referenced by test_VarUI8FromI1(), and VARIANT_Coerce().

VarUI8FromI2()

HRESULT WINAPI VarUI8FromI2	(	SHORT	sIn,
		ULONG64 *	pui64Out
	)

Definition at line 2433 of file vartype.c.

{
  return _VarUI8FromI2(sIn, pui64Out);
}

Referenced by test_VarUI8FromI2(), and VARIANT_Coerce().

VarUI8FromI8()

HRESULT WINAPI VarUI8FromI8	(	LONG64	llIn,
		ULONG64 *	pui64Out
	)

Definition at line 2399 of file vartype.c.

{
  return _VarUI8FromI8(llIn, pui64Out);
}

Referenced by test_VarUI8FromI8().

VarUI8FromR4()

HRESULT WINAPI VarUI8FromR4	(	FLOAT	fltIn,
		ULONG64 *	pui64Out
	)

Definition at line 2451 of file vartype.c.

{
  return VarUI8FromR8(fltIn, pui64Out);
}

Referenced by test_VarUI8FromR4(), and VARIANT_Coerce().

VarUI8FromR8()

HRESULT WINAPI VarUI8FromR8	(	double	dblIn,
		ULONG64 *	pui64Out
	)

Definition at line 2473 of file vartype.c.

{
  if (dblIn < -0.5 || dblIn > 1.844674407370955e19)
    return DISP_E_OVERFLOW;
  VARIANT_DutchRound(ULONG64, dblIn, *pui64Out);
  return S_OK;
}

Referenced by test_VarUI8FromR8(), VARIANT_Coerce(), VarUI8FromDate(), VarUI8FromDec(), and VarUI8FromR4().

VarUI8FromStr()

HRESULT WINAPI VarUI8FromStr	(	OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		ULONG64 *	pui64Out
	)

Definition at line 2555 of file vartype.c.

{
  return VARIANT_NumberFromBstr(strIn, lcid, dwFlags, pui64Out, VT_UI8);
}

Referenced by test_VarUI8FromStr(), and VARIANT_Coerce().

VarUI8FromUI1()

HRESULT WINAPI VarUI8FromUI1	(	BYTE	bIn,
		ULONG64 *	pui64Out
	)

Definition at line 2416 of file vartype.c.

{
  return _VarUI8FromUI1(bIn, pui64Out);
}

Referenced by test_VarUI8FromUI1(), and VARIANT_Coerce().

VarUI8FromUI2()

HRESULT WINAPI VarUI8FromUI2	(	USHORT	usIn,
		ULONG64 *	pui64Out
	)

Definition at line 2628 of file vartype.c.

{
  return _VarUI8FromUI2(usIn, pui64Out);
}

Referenced by test_VarUI8FromUI2(), and VARIANT_Coerce().

VarUI8FromUI4()

HRESULT WINAPI VarUI8FromUI4	(	ULONG	ulIn,
		ULONG64 *	pui64Out
	)

Definition at line 2645 of file vartype.c.

{
  return _VarUI8FromUI4(ulIn, pui64Out);
}

Referenced by test_VarUI8FromUI4(), and VARIANT_Coerce().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

variant

)

Variable Documentation

CY_Divisors

const int CY_Divisors[5]

static

Initial value:

= { CY_MULTIPLIER/10000, CY_MULTIPLIER/1000,
  CY_MULTIPLIER/100, CY_MULTIPLIER/10, CY_MULTIPLIER }

Definition at line 3402 of file vartype.c.

Referenced by VarCyFromDec(), and VarCyRound().

DECLSPEC_HIDDEN

HMODULE hProxyDll DECLSPEC_HIDDEN

extern

Definition at line 289 of file d3dcompiler_private.h.

szDoubleFormatW

const WCHAR szDoubleFormatW[] = { '%','.','1','5','G','\0' }

static

Definition at line 44 of file vartype.c.

Referenced by VarBstrFromR8().

szFloatFormatW

const WCHAR szFloatFormatW[] = { '%','.','7','G','\0' }

static

Definition at line 43 of file vartype.c.

Referenced by VarBstrFromR4().