vartype.c File Reference

#include "wine/debug.h"
#include "winbase.h"
#include "winuser.h"
#include "winnt.h"
#include "variant.h"
#include "resource.h"
#include "locale.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	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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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 (const 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, int ndigits)
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 (const 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 (const 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 (const DECIMAL *pdecIn, DATE *pdateOut)
HRESULT WINAPI	VarDateFromI8 (LONG64 llIn, DATE *pdateOut)
HRESULT WINAPI	VarDateFromUI8 (ULONG64 ullIn, DATE *pdateOut)

Variables
HMODULE	hProxyDll
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 156 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 37 of file vartype.c.

CY_HALF_F

#define CY_HALF_F   (CY_MULTIPLIER_F/2.0)

Definition at line 38 of file vartype.c.

CY_MULTIPLIER

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

Definition at line 35 of file vartype.c.

CY_MULTIPLIER_F

#define CY_MULTIPLIER_F   10000.0

Definition at line 36 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 7419 of file vartype.c.

DP_DATESEP

#define DP_DATESEP   0x02 /* Date separator */

Definition at line 7417 of file vartype.c.

DP_MONTH

#define DP_MONTH   0x04 /* Month name */

Definition at line 7418 of file vartype.c.

DP_PM

#define DP_PM   0x10 /* PM */

Definition at line 7420 of file vartype.c.

DP_TIMESEP

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

Definition at line 7416 of file vartype.c.

IsLeapYear

#define IsLeapYear

(

y

)

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

Definition at line 7432 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 148 of file vartype.c.

ORDER_DMY

#define ORDER_DMY   0x08

Definition at line 7451 of file vartype.c.

ORDER_MDY

#define ORDER_MDY   0x01

Definition at line 7448 of file vartype.c.

ORDER_MYD

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

Definition at line 7452 of file vartype.c.

ORDER_YDM

#define ORDER_YDM   0x04

Definition at line 7450 of file vartype.c.

ORDER_YMD

#define ORDER_YMD   0x02

Definition at line 7449 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 152 of file vartype.c.

RETTYP

#define RETTYP   static inline HRESULT

Definition at line 140 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 144 of file vartype.c.

TIMEFLAG

#define TIMEFLAG

(

i

)

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

Definition at line 7430 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 71 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 249 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 6729 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 %lx\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().

output_int_len()

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

inlinestatic

Definition at line 6709 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 6073 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 6055 of file vartype.c.

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

Referenced by test_VarBoolFromDate(), and VARIANT_Coerce().

VarBoolFromDec()

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

Definition at line 6300 of file vartype.c.

{
  if (pDecIn->scale > DEC_MAX_SCALE || (pDecIn->sign & ~DECIMAL_NEG))
    return E_INVALIDARG;
 
  if (pDecIn->Hi32 || pDecIn->Lo64)
    *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 6228 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 6245 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 5983 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 6001 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 6324 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 6019 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 6037 of file vartype.c.

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

Referenced by test_VarBoolFromR8(), and VARIANT_Coerce().

VarBoolFromStr()

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

Definition at line 6139 of file vartype.c.

{
  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, L"#FALSE#"))
    *pBoolOut = VARIANT_FALSE;
  else if (!wcscmp(strIn, L"#TRUE#"))
    *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 5965 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 6263 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 6281 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 6342 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 7168 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 7219 of file vartype.c.

{
    HRESULT hres;
    int ret;
 
    TRACE("%s, %s, %#lx, %#lx.\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("%ld\n", hres);
      return hres;
    }
}

Referenced by test_marshal_LPSAFEARRAY(), test_VarWeekdayName(), and VarCmp().

VarBstrFromBool()

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

Definition at line 6913 of file vartype.c.

{
  WCHAR szBuff[64];
  DWORD dwResId = IDS_TRUE;
  LANGID langId;
 
  TRACE("%d, %#lx, %#lx, %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 6669 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.Lo;
  decVal.bitsnum[1] = cyIn.Hi;
  if (cyIn.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 6839 of file vartype.c.

{
  SYSTEMTIME st;
  DWORD dwFormatFlags = dwFlags & LOCALE_NOUSEROVERRIDE;
  WCHAR date[128], fmt_buff[80], *time;
 
  TRACE("%g, %#lx, %#lx, %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	(	const DECIMAL *	pDecIn,
		LCID	lcid,
		ULONG	dwFlags,
		BSTR *	pbstrOut
	)

Definition at line 7052 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 7148 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 6982 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 6439 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 6467 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 7099 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 6627 of file vartype.c.

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

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

VarBstrFromR8()

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

Definition at line 6648 of file vartype.c.

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

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

VarBstrFromUI1()

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

Definition at line 6418 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 7010 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 7031 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 7127 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 3870 of file vartype.c.

{
  if (cyIn.Hi == 0x80000000 && !cyIn.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 3779 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 4006 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 4040 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 3896 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 3614 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 3547 of file vartype.c.

{
  return VarCyFromR8(dateIn, pCyOut);
}

Referenced by test_VarCyFromDate(), and VARIANT_Coerce().

VarCyFromDec()

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

Definition at line 3698 of file vartype.c.

{
  DECIMAL rounded;
  HRESULT hRet;
 
  hRet = VarDecRound(pdecIn, 4, &rounded);
 
  if (SUCCEEDED(hRet))
  {
    double d;
 
    if (rounded.Hi32)
      return DISP_E_OVERFLOW;
 
    /* Note: Without the casts this promotes to int64 which loses precision */
    d = (double)rounded.Lo64 / (double)CY_Divisors[rounded.scale];
    if (rounded.sign)
      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 3590 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 3635 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 3435 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 3456 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 3736 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 3477 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 3497 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	(	const OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		CY *	pCyOut
	)

Definition at line 3569 of file vartype.c.

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

Referenced by VarFormatCurrency(), and VARIANT_Coerce().

VarCyFromUI1()

HRESULT WINAPI VarCyFromUI1	(	BYTE	bIn,
		CY *	pCyOut
	)

Definition at line 3414 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 3656 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 3677 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 3758 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 3920 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 3802 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 3825 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 4067 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 3945 of file vartype.c.

{
  if (cyIn.Hi == 0x80000000 && !cyIn.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 3968 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 3848 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 7393 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 7410 of file vartype.c.

{
  return VarR8FromCy(cyIn, pdateOut);
}

Referenced by test_VarDateFromCy(), and VARIANT_Coerce().

VarDateFromDec()

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

Definition at line 8074 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 7376 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 8023 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 7302 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 7319 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 8092 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 7336 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 7353 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(), VARIANT_Coerce(), and VARIANT_FormatDate().

VarDateFromStr()

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

Definition at line 7663 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, %#lx, %#lx, %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 %ld\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 ('0' <= *strIn && *strIn <= '9')
    {
      OLECHAR* end;
      if (dp.dwCount >= 6)
      {
        hRet = DISP_E_TYPEMISMATCH;
        break;
      }
      dp.dwValues[dp.dwCount] = wcstoul(strIn, &end, 10);
      dp.dwCount++;
      strIn = end - 1;
    }
    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("%#lx\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 parse_date_literal(), test_VarDateFromStr(), and VARIANT_Coerce().

VarDateFromUI1()

HRESULT WINAPI VarDateFromUI1	(	BYTE	bIn,
		DATE *	pdateOut
	)

Definition at line 7285 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 8040 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 8057 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 8112 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 5723 of file vartype.c.

{
  *pDecOut = *pDecIn;
  pDecOut->sign &= ~DECIMAL_NEG;
  return S_OK;
}

Referenced by test_VarDecAbs().

VarDecAdd()

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

Definition at line 4580 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 (pDecLeft->sign && pDecRight->sign)
    {
      /* -x + -y : Negative */
      sign = DECIMAL_NEG;
      goto VarDecAdd_AsPositive;
    }
    else if (pDecLeft->sign && !pDecRight->sign)
    {
      cmp = VARIANT_DecCmp(pDecLeft, pDecRight);
 
      /* -x + y : Negative if x > y */
      if (cmp > 0)
      {
        sign = DECIMAL_NEG;
VarDecAdd_AsNegative:
        pDecOut->Lo32  = VARIANT_Sub(pDecLeft->Lo32,  pDecRight->Lo32,  &overflow);
        pDecOut->Mid32 = VARIANT_Sub(pDecLeft->Mid32, pDecRight->Mid32, &overflow);
        pDecOut->Hi32  = VARIANT_Sub(pDecLeft->Hi32,  pDecRight->Hi32,  &overflow);
      }
      else
      {
VarDecAdd_AsInvertedNegative:
        pDecOut->Lo32  = VARIANT_Sub(pDecRight->Lo32,  pDecLeft->Lo32,  &overflow);
        pDecOut->Mid32 = VARIANT_Sub(pDecRight->Mid32, pDecLeft->Mid32, &overflow);
        pDecOut->Hi32  = VARIANT_Sub(pDecRight->Hi32,  pDecLeft->Hi32,  &overflow);
      }
    }
    else if (!pDecLeft->sign && pDecRight->sign)
    {
      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:
      pDecOut->Lo32  = VARIANT_Add(pDecLeft->Lo32,  pDecRight->Lo32,  &overflow);
      pDecOut->Mid32 = VARIANT_Add(pDecLeft->Mid32, pDecRight->Mid32, &overflow);
      pDecOut->Hi32  = VARIANT_Add(pDecLeft->Hi32,  pDecRight->Hi32,  &overflow);
 
      if (overflow)
      {
        int i;
        DWORD n[4];
        unsigned char remainder;
 
        if (!pDecLeft->scale)
          return DISP_E_OVERFLOW;
 
        pDecOut->scale = pDecLeft->scale - 1;
        pDecOut->sign = sign;
 
        n[0] = pDecOut->Lo32;
        n[1] = pDecOut->Mid32;
        n[2] = pDecOut->Hi32;
        n[3] = overflow;
 
        remainder = VARIANT_int_divbychar(n,4,10);
 
        /* round up the result */
        if (remainder >= 5)
        {
          for (remainder = 1, i = 0; i < ARRAY_SIZE(n) && remainder; i++)
          {
            ULONGLONG digit = n[i] + 1;
            remainder = (digit > 0xFFFFFFFF) ? 1 : 0;
            n[i] = digit & 0xFFFFFFFF;
          }
        }
 
        pDecOut->Lo32 = n[0] ;
        pDecOut->Mid32 = n[1];
        pDecOut->Hi32 = n[2];
 
        return S_OK;
      }
    }
 
    if (overflow)
      return DISP_E_OVERFLOW; /* overflowed */
 
    pDecOut->scale = pDecLeft->scale;
    pDecOut->sign = sign;
  }
  return hRet;
}

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

VarDecCmp()

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

Definition at line 5891 of file vartype.c.

{
  HRESULT hRet;
  DECIMAL result;
 
  if (!pDecLeft || !pDecRight)
    return VARCMP_NULL;
 
  if ((!(pDecLeft->sign & DECIMAL_NEG)) && (pDecRight->sign & DECIMAL_NEG) &&
      (pDecLeft->Hi32 || pDecLeft->Lo64))
    return VARCMP_GT;
  else if ((pDecLeft->sign & DECIMAL_NEG) && (!(pDecRight->sign & DECIMAL_NEG)) &&
      (pDecLeft->Hi32 || pDecLeft->Lo64))
    return VARCMP_LT;
 
  /* Subtract right from left, and compare the result to 0 */
  hRet = VarDecSub(pDecLeft, pDecRight, &result);
 
  if (SUCCEEDED(hRet))
  {
    int non_zero = result.Hi32 || result.Lo64;
 
    if ((result.sign & 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 5937 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 5626 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 5747 of file vartype.c.

{
  double dbl;
  HRESULT hr;
 
  if (pDecIn->sign & ~DECIMAL_NEG)
    return E_INVALIDARG;
 
  if (!pDecIn->scale)
  {
    *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 4306 of file vartype.c.

{
  pDecOut->Hi32 = 0;
  pDecOut->scale = 0;
  if (bIn)
  {
      pDecOut->sign = DECIMAL_NEG;
      pDecOut->Lo64 = 1;
  }
  else
  {
      pDecOut->sign = DECIMAL_POS;
      pDecOut->Lo64 = 0;
  }
  return S_OK;
}

Referenced by test_VarDecFromBool().

VarDecFromCy()

HRESULT WINAPI VarDecFromCy	(	CY	cyIn,
		DECIMAL *	pDecOut
	)

Definition at line 4234 of file vartype.c.

{
  pDecOut->Hi32 = 0;
  pDecOut->scale = 4;
 
  if (cyIn.int64 < 0)
  {
      pDecOut->sign = DECIMAL_NEG;
      pDecOut->Lo64 = -cyIn.int64;
  }
  else
  {
      pDecOut->sign = DECIMAL_POS;
      pDecOut->Lo64 = cyIn.int64;
  }
  return S_OK;
}

Referenced by test_VarDecFromCy(), and VARIANT_Coerce().

VarDecFromDate()

HRESULT WINAPI VarDecFromDate	(	DATE	dateIn,
		DECIMAL *	pDecOut
	)

Definition at line 4217 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 4286 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 4335 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 4108 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 4125 of file vartype.c.

{
  pDecOut->Hi32 = 0;
  pDecOut->Mid32 = 0;
  pDecOut->scale = 0;
 
  if (lIn < 0)
  {
      pDecOut->sign = DECIMAL_NEG;
      pDecOut->Lo32 = -lIn;
  }
  else
  {
      pDecOut->sign = DECIMAL_POS;
      pDecOut->Lo32 = 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 4390 of file vartype.c.

{
    pDecOut->Hi32 = 0;
    pDecOut->scale = 0;
 
    if (llIn < 0)
    {
        pDecOut->sign = DECIMAL_NEG;
        pDecOut->Lo64 = -llIn;
    }
    else
    {
        pDecOut->sign = DECIMAL_POS;
        pDecOut->Lo64 = llIn;
    }
    return S_OK;
}

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

VarDecFromR4()

HRESULT WINAPI VarDecFromR4	(	FLOAT	fltIn,
		DECIMAL *	pDecOut
	)

Definition at line 4173 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 4195 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	(	const OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		DECIMAL *	pDecOut
	)

Definition at line 4267 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 4091 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 4352 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 4369 of file vartype.c.

{
    pDecOut->sign = DECIMAL_POS;
    pDecOut->scale = 0;
    pDecOut->Hi32 = 0;
    pDecOut->Lo64 = ulIn;
    return S_OK;
}

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

VarDecFromUI8()

HRESULT WINAPI VarDecFromUI8	(	ULONG64	ullIn,
		DECIMAL *	pDecOut
	)

Definition at line 4420 of file vartype.c.

{
    pDecOut->sign = DECIMAL_POS;
    pDecOut->scale = 0;
    pDecOut->Hi32 = 0;
    pDecOut->Lo64 = ullIn;
    return S_OK;
}

Referenced by test_VarDecFromUI8(), and VARIANT_Coerce().

VarDecInt()

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

Definition at line 5787 of file vartype.c.

{
  double dbl;
  HRESULT hr;
 
  if (pDecIn->sign & ~DECIMAL_NEG)
    return E_INVALIDARG;
 
  if (!(pDecIn->sign & DECIMAL_NEG) || !pDecIn->scale)
    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 5647 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 5819 of file vartype.c.

{
  *pDecOut = *pDecIn;
  pDecOut->sign ^= 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 5840 of file vartype.c.

{
  DECIMAL divisor, tmp;
  HRESULT hr;
  unsigned int i;
 
  if (cDecimals < 0 || (pDecIn->sign & ~DECIMAL_NEG) || pDecIn->scale > DEC_MAX_SCALE)
    return E_INVALIDARG;
 
  if (cDecimals >= pDecIn->scale)
  {
    *pDecOut = *pDecIn; /* More precision than we have */
    return S_OK;
  }
 
  /* truncate significant digits and rescale */
  memset(&divisor, 0, sizeof(divisor));
  divisor.Lo64 = 1;
 
  memset(&tmp, 0, sizeof(tmp));
  tmp.Lo64 = 10;
  for (i = 0; i < pDecIn->scale - 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;
 
  pDecOut->scale = 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 5702 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 459 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 396 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 377 of file vartype.c.

{
  return VarI1FromR8(dateIn, pcOut);
}

Referenced by test_VarI1FromDate(), and VARIANT_Coerce().

VarI1FromDec()

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

Definition at line 517 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 442 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 295 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 314 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 543 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 333 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 355 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	(	const OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		signed char *	pcOut
	)

Definition at line 421 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 276 of file vartype.c.

{
  return _VarI1FromUI1(bIn, pcOut);
}

Referenced by test_VarI1FromUI1().

VarI1FromUI2()

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

Definition at line 478 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 498 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 562 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 1053 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 972 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 993 of file vartype.c.

{
  return VarI2FromR8(dateIn, psOut);
}

Referenced by test_VarI2FromDate(), and VARIANT_Coerce().

VarI2FromDec()

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

Definition at line 1125 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 1036 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 1070 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 912 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 1150 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 930 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 951 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	(	const OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		SHORT *	psOut
	)

Definition at line 1015 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 894 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 1088 of file vartype.c.

{
  return _VarI2FromUI2(usIn, psOut);
}

Referenced by test_VarI2FromUI2().

VarI2FromUI4()

HRESULT WINAPI VarI2FromUI4	(	ULONG	ulIn,
		SHORT *	psOut
	)

Definition at line 1106 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 1168 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 1643 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 1564 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 1583 of file vartype.c.

{
  return VarI4FromR8(dateIn, piOut);
}

Referenced by test_VarI4FromDate(), and VARIANT_Coerce().

VarI4FromDec()

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

Definition at line 1714 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 1626 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 1660 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 1504 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 1739 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 1522 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 1543 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	(	const OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		LONG *	piOut
	)

Definition at line 1605 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 1485 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 1677 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 1695 of file vartype.c.

{
  return _VarI4FromUI4(ulIn, piOut);
}

Referenced by test_VarI4FromUI4().

VarI4FromUI8()

HRESULT WINAPI VarI4FromUI8	(	ULONG64	ullIn,
		LONG *	piOut
	)

Definition at line 1757 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 2259 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 2168 of file vartype.c.

{
  *pi64Out = cyIn.int64 / CY_MULTIPLIER;
 
  if (cyIn.int64 < 0)
    (*pi64Out)--; /* Mimic Win32 bug */
  else
  {
    cyIn.int64 -= *pi64Out * CY_MULTIPLIER; /* cyIn.Lo now holds fractional remainder */
 
    if (cyIn.Lo > CY_HALF || (cyIn.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 2199 of file vartype.c.

{
  return VarI8FromR8(dateIn, pi64Out);
}

Referenced by test_VarI8FromDate(), and VARIANT_Coerce().

VarI8FromDec()

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

Definition at line 2329 of file vartype.c.

{
  if (!pdecIn->scale)
  {
    /* This decimal is just a 96 bit integer */
    if (pdecIn->sign & ~DECIMAL_NEG)
      return E_INVALIDARG;
 
    if (pdecIn->Hi32 || pdecIn->Mid32 & 0x80000000)
      return DISP_E_OVERFLOW;
 
    if (pdecIn->sign)
      *pi64Out = -pdecIn->Lo64;
    else
      *pi64Out = pdecIn->Lo64;
    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 2242 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 2276 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 2087 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 2106 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 2142 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	(	const OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		LONG64 *	pi64Out
	)

Definition at line 2221 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 2069 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 2293 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 2310 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 2372 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 4512 of file vartype.c.

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

Referenced by VarDecAdd(), and VARIANT_DI_mul().

VARIANT_BstrFromReal()

static HRESULT VARIANT_BstrFromReal ( DOUBLE  dblIn, LCID  lcid, ULONG  dwFlags, BSTR *  pbstrOut, int  ndigits  )

static

Definition at line 6540 of file vartype.c.

{
#ifndef __REACTOS__
  _locale_t locale;
#endif
  WCHAR *e, buff[256];
  int len;
 
  if (!pbstrOut)
    return E_INVALIDARG;
 
#ifdef __REACTOS__ /* FIXME: Inspect */
    len = swprintf(buff, ARRAY_SIZE(buff), L"%.*G", ndigits, dblIn);
#else
  if (!(locale = _create_locale(LC_ALL, "C"))) return E_OUTOFMEMORY;
  len = _swprintf_l(buff, ARRAY_SIZE(buff), L"%.*G", locale, ndigits, dblIn);
#endif
  e = wcschr(buff, 'E');
  if (e)
  {
      int extra_decimals;
      WCHAR *dot;
 
      dot = wcschr(buff, '.');
      extra_decimals = dot ? e - dot - 2 : 0;
      if (labs(wcstol(e+1, NULL, 10)) + extra_decimals < ndigits)
      {
#ifdef __REACTOS__ /* FIXME: Inspect */
          len = swprintf(buff, ARRAY_SIZE(buff), L"%.*f", ndigits, dblIn);
#else
          len = _swprintf_l(buff, ARRAY_SIZE(buff), L"%.*f", locale, ndigits, dblIn);
#endif
          while (len > 0 && (buff[len-1] == '0')) len--;
      }
  }
  buff[len] = 0;
#ifndef __REACTOS__
  _free_locale(locale);
#endif
 
  /* 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] == '-')
  {
    if (lstrlenW(buff + 1) == wcsspn(buff + 1, L"0."))
    { 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 6386 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 6479 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, *e;
    WCHAR numbuff[256];
    WCHAR empty[] = L"";
    NUMBERFMTW minFormat;
 
    minFormat.NumDigits = 0;
    minFormat.Grouping = 0;
    minFormat.lpDecimalSep = lpDecimalSep;
    minFormat.lpThousandSep = empty;
    minFormat.NegativeOrder = 1; /* NLS_NEG_LEFT */
 
    GetLocaleInfoW(lcid, LOCALE_ILZERO | LOCALE_RETURN_NUMBER | (dwFlags & LOCALE_NOUSEROVERRIDE),
                   (WCHAR *)&minFormat.LeadingZero, sizeof(DWORD)/sizeof(WCHAR) );
 
    /* count number of decimal digits in string */
    p = wcschr(buff, '.');
    e = wcschr(p ? ++p : buff, 'E');
    if (p) minFormat.NumDigits = e ? e - p : lstrlenW(p);
 
    if (e) *e = '\0';
    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
    {
      if (e)
      {
        *e = 'E';
        wcscat(numbuff, e);
      }
      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 41 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 4556 of file vartype.c.

{
  if ( pDecLeft->Hi32 < pDecRight->Hi32 ||
      (pDecLeft->Hi32 <= pDecRight->Hi32 && pDecLeft->Lo64 < pDecRight->Lo64))
    return -1;
  else if (pDecLeft->Hi32 == pDecRight->Hi32 && pDecLeft->Lo64 == pDecRight->Lo64)
    return 0;
  return 1;
}

Referenced by VarDecAdd().

VARIANT_DecFromDI()

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

static

Definition at line 4700 of file vartype.c.

{
    to->sign = from->sign ? DECIMAL_NEG : DECIMAL_POS;
    to->scale = from->scale;
    to->Lo32 = from->bitsnum[0];
    to->Mid32 = from->bitsnum[1];
    to->Hi32 = 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 4430 of file vartype.c.

{
  static DECIMAL scaleFactor;
  unsigned char remainder;
  DECIMAL decTemp;
  VARIANT_DI di;
  int scaleAmount, i;
 
  if ((*ppDecLeft)->sign & ~DECIMAL_NEG || (*ppDecRight)->sign & ~DECIMAL_NEG)
    return E_INVALIDARG;
 
  scaleFactor.Lo32 = 10;
 
  i = scaleAmount = (*ppDecLeft)->scale - (*ppDecRight)->scale;
 
  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)
  {
    pDecOut[0].scale += (scaleAmount > 0) ? scaleAmount : (-scaleAmount);
    return S_OK; /* Same scale */
  }
 
  /* Scaling further not possible, reduce accuracy of other argument */
  pDecOut[0] = decTemp;
  if (scaleAmount > 0)
  {
    pDecOut[0].scale += scaleAmount - i;
    VARIANT_DIFromDec(*ppDecLeft, &di);
    *ppDecLeft = &pDecOut[1];
  }
  else
  {
    pDecOut[0].scale += (-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 4710 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 5197 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 5449 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 5509 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 4756 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 5285 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 4850 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 4690 of file vartype.c.

{
    to->scale = from->scale;
    to->sign = from->sign ? 1 : 0;
 
    to->bitsnum[0] = from->Lo32;
    to->bitsnum[1] = from->Mid32;
    to->bitsnum[2] = from->Hi32;
}

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 5556 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 109 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 6085 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 4957 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 5043 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 4996 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 4720 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 VarDecAdd(), 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 4745 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 5028 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 4930 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 7435 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 6367 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 7455 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("%ld, %ld, %ld, %ld, %ld.\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 %#lx\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 %ld, dwTry is %#lx\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 old versions of Windows used 29 but
   * Windows 10 1903 and greater use 49. This cutoff may also be modified by
   * setting the value as a string for the relevant calendar id in the
   * registry.
   *
   * For instance to emulate old Windows versions:
   * [HKCU\Control Panel\International\Calendars\TwoDigitYearMax]
   * "1"="29"
   * (also 2, 9, 10, 11 and 12 for the other Gregorian calendars)
   *
   * But Wine doesn't have/use that key at the time of writing.
   */
  st->wYear = v3 <= 49 ? 2000 + v3 : v3 <= 99 ? 1900 + v3 : v3;
  TRACE("Returning date %ld/%ld/%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 4546 of file vartype.c.

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

Referenced by VARIANT_DI_mul(), and VARIANT_int_mulbychar().

VARIANT_NumberFromBstr()

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

static

Definition at line 84 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 4522 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.HighPart = -ul64.HighPart ;
 
  *pulHigh = ul64.HighPart;
  return ul64.LowPart;
}

Referenced by VarDecAdd().

VARIANT_WriteNumber()

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

static

Definition at line 6352 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 3015 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 2862 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 2784 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 2803 of file vartype.c.

{
  return VarR4FromR8(dateIn, pFltOut);
}

Referenced by test_VarR4FromDate(), and VARIANT_Coerce().

VarR4FromDec()

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

Definition at line 2940 of file vartype.c.

{
  BYTE scale = pDecIn->scale;
  double divisor = 1.0;
  double highPart;
 
  if (scale > DEC_MAX_SCALE || pDecIn->sign & ~DECIMAL_NEG)
    return E_INVALIDARG;
 
  while (scale--)
    divisor *= 10.0;
 
  if (pDecIn->sign)
    divisor = -divisor;
 
  if (pDecIn->Hi32)
  {
    highPart = (double)pDecIn->Hi32 / divisor;
    highPart *= 4294967296.0F;
    highPart *= 4294967296.0F;
  }
  else
    highPart = 0.0;
 
  *pFltOut = (double)pDecIn->Lo64 / 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 2845 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 2882 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 2729 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 2746 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 2980 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 2764 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	(	const OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		float *	pFltOut
	)

Definition at line 2824 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 2712 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 2902 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 2922 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 2997 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 3183 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 3107 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 3124 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 3261 of file vartype.c.

{
  BYTE scale = pDecIn->scale;
  double divisor = 1.0, highPart;
 
  if (scale > DEC_MAX_SCALE || pDecIn->sign & ~DECIMAL_NEG)
    return E_INVALIDARG;
 
  while (scale--)
    divisor *= 10;
 
  if (pDecIn->sign)
    divisor = -divisor;
 
  if (pDecIn->Hi32)
  {
    highPart = (double)pDecIn->Hi32 / divisor;
    highPart *= 4294967296.0F;
    highPart *= 4294967296.0F;
  }
  else
    highPart = 0.0;
 
  *pDblOut = (double)pDecIn->Lo64 / 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 3166 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 3203 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 3056 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 3073 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 3300 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 3090 of file vartype.c.

{
  return _VarR8FromR4(fltIn, pDblOut);
}

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

VarR8FromStr()

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

Definition at line 3145 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 3039 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 3223 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 3243 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 3317 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 3335 of file vartype.c.

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

VarR8Round()

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

Definition at line 3362 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;
}

Referenced by Global_Round().

VarUI1FromBool()

HRESULT WINAPI VarUI1FromBool	(	VARIANT_BOOL	boolIn,
		BYTE *	pbOut
	)

Definition at line 752 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 670 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 692 of file vartype.c.

{
  return VarUI1FromR8(dateIn, pbOut);
}

Referenced by test_VarUI1FromDate(), and VARIANT_Coerce().

VarUI1FromDec()

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

Definition at line 828 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 735 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 771 of file vartype.c.

{
  return _VarUI1FromI1(cIn, pbOut);
}

Referenced by test_VarUI1FromI1().

VarUI1FromI2()

HRESULT WINAPI VarUI1FromI2	(	SHORT	sIn,
		BYTE *	pbOut
	)

Definition at line 584 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 603 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 854 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 623 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 645 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	(	const OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		BYTE *	pbOut
	)

Definition at line 714 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 790 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 809 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 873 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 1367 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 1305 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 1284 of file vartype.c.

{
  return VarUI2FromR8(dateIn, pusOut);
}

Referenced by test_VarUI2FromDate(), and VARIANT_Coerce().

VarUI2FromDec()

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

Definition at line 1422 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 1350 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 1385 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 1206 of file vartype.c.

{
  return _VarUI2FromI2(sIn, pusOut);
}

Referenced by test_VarUI2FromI2().

VarUI2FromI4()

HRESULT WINAPI VarUI2FromI4	(	LONG	iIn,
		USHORT *	pusOut
	)

Definition at line 1224 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 1447 of file vartype.c.

{
  return _VarUI2FromI8(llIn, pusOut);
}

Referenced by test_VarUI2FromI8().

VarUI2FromR4()

HRESULT WINAPI VarUI2FromR4	(	FLOAT	fltIn,
		USHORT *	pusOut
	)

Definition at line 1242 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 1263 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	(	const OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		USHORT *	pusOut
	)

Definition at line 1329 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 1188 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 1403 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 1465 of file vartype.c.

{
  return _VarUI2FromUI8(ullIn, pusOut);
}

Referenced by test_VarUI2FromUI8().

VarUI4FromBool()

HRESULT WINAPI VarUI4FromBool	(	VARIANT_BOOL	boolIn,
		ULONG *	pulOut
	)

Definition at line 1952 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 1891 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 1873 of file vartype.c.

{
  return VarUI4FromR8(dateIn, pulOut);
}

Referenced by test_VarUI4FromDate(), and VARIANT_Coerce().

VarUI4FromDec()

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

Definition at line 2006 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 1935 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 1970 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 1795 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 1813 of file vartype.c.

{
  return _VarUI4FromI4(iIn, pulOut);
}

Referenced by test_VarUI4FromI4().

VarUI4FromI8()

HRESULT WINAPI VarUI4FromI8	(	LONG64	llIn,
		ULONG *	pulOut
	)

Definition at line 2031 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 1831 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 1852 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	(	const OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		ULONG *	pulOut
	)

Definition at line 1914 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 1777 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 1987 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 2049 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 2588 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 2492 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.Lo now holds fractional remainder */
 
    if (cyIn.Lo > CY_HALF || (cyIn.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 2527 of file vartype.c.

{
  return VarUI8FromR8(dateIn, pui64Out);
}

Referenced by test_VarUI8FromDate(), and VARIANT_Coerce().

VarUI8FromDec()

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

Definition at line 2664 of file vartype.c.

{
  if (!pdecIn->scale)
  {
    /* This decimal is just a 96 bit integer */
    if (pdecIn->sign & ~DECIMAL_NEG)
      return E_INVALIDARG;
 
    if (pdecIn->Hi32)
      return DISP_E_OVERFLOW;
 
    if (pdecIn->sign)
    {
      WARN("Sign would be ignored under Win32!\n");
      return DISP_E_OVERFLOW;
    }
 
    *pui64Out = pdecIn->Lo64;
    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 2570 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 2605 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 2427 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 2393 of file vartype.c.

{
  return _VarUI8FromI8(llIn, pui64Out);
}

Referenced by test_VarUI8FromI8().

VarUI8FromR4()

HRESULT WINAPI VarUI8FromR4	(	FLOAT	fltIn,
		ULONG64 *	pui64Out
	)

Definition at line 2445 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 2467 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	(	const OLECHAR *	strIn,
		LCID	lcid,
		ULONG	dwFlags,
		ULONG64 *	pui64Out
	)

Definition at line 2549 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 2410 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 2622 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 2639 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 3396 of file vartype.c.

Referenced by VarCyFromDec(), and VarCyRound().

hProxyDll

HMODULE hProxyDll

extern

Definition at line 40 of file combase.c.

Referenced by VARIANT_GetLocalisedText().