vartype.c File Reference

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

Include dependency graph for vartype.c:

Go to the source code of this file.

Classes
struct	DECIMAL_internal
union	R4_FIELDS
union	R8_FIELDS
struct	tagDATEPARSE

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

Typedefs
typedef struct DECIMAL_internal	VARIANT_DI
typedef struct tagDATEPARSE	DATEPARSE

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

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

Macro Definition Documentation

BOTHTST

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

Value:

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

Definition at line 162 of file vartype.c.

COBJMACROS

#define COBJMACROS

Definition at line 21 of file vartype.c.

CY_HALF

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

Definition at line 40 of file vartype.c.

CY_HALF_F

#define CY_HALF_F   (CY_MULTIPLIER_F/2.0)

Definition at line 41 of file vartype.c.

CY_MULTIPLIER

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

Definition at line 38 of file vartype.c.

CY_MULTIPLIER_F

#define CY_MULTIPLIER_F   10000.0

Definition at line 39 of file vartype.c.

DATE_SWAP

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

DP_AM

#define DP_AM   0x08 /* AM */

Definition at line 7358 of file vartype.c.

DP_DATESEP

#define DP_DATESEP   0x02 /* Date separator */

Definition at line 7356 of file vartype.c.

DP_MONTH

#define DP_MONTH   0x04 /* Month name */

Definition at line 7357 of file vartype.c.

DP_PM

#define DP_PM   0x10 /* PM */

Definition at line 7359 of file vartype.c.

DP_TIMESEP

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

Definition at line 7355 of file vartype.c.

IsLeapYear

#define IsLeapYear

(

y

)

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

Definition at line 7371 of file vartype.c.

NEGTST

#define NEGTST	(		dest,
			src,
			func
	)

Value:

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

Definition at line 154 of file vartype.c.

NONAMELESSSTRUCT

#define NONAMELESSSTRUCT

Definition at line 23 of file vartype.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 22 of file vartype.c.

ORDER_DMY

#define ORDER_DMY   0x08

Definition at line 7390 of file vartype.c.

ORDER_MDY

#define ORDER_MDY   0x01

Definition at line 7387 of file vartype.c.

ORDER_MYD

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

Definition at line 7391 of file vartype.c.

ORDER_YDM

#define ORDER_YDM   0x04

Definition at line 7389 of file vartype.c.

ORDER_YMD

#define ORDER_YMD   0x02

Definition at line 7388 of file vartype.c.

POSTST

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

Value:

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

Definition at line 158 of file vartype.c.

RETTYP

#define RETTYP   static inline HRESULT

Definition at line 146 of file vartype.c.

SIMPLE

#define SIMPLE	(		dest,
			src,
			func
	)

Value:

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

Definition at line 150 of file vartype.c.

TIMEFLAG

#define TIMEFLAG

(

i

)

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

Definition at line 7369 of file vartype.c.

VARIANT_DutchRound

#define VARIANT_DutchRound	(		typ,
			value,
			res
	)

Value:

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

Definition at line 77 of file vartype.c.

Typedef Documentation

DATEPARSE

typedef struct tagDATEPARSE DATEPARSE

VARIANT_DI

typedef struct DECIMAL_internal VARIANT_DI

Function Documentation

_VarR8FromCy()

RETTYP _VarR8FromCy	(	CY	i,
		double *	o
	)

Definition at line 255 of file vartype.c.

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

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

get_date_format()

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

Definition at line 6668 of file vartype.c.

{
    static const LCTYPE dayname[] = {
        LOCALE_SDAYNAME7, LOCALE_SDAYNAME1, LOCALE_SDAYNAME2, LOCALE_SDAYNAME3,
        LOCALE_SDAYNAME4, LOCALE_SDAYNAME5, LOCALE_SDAYNAME6
    };
    static const LCTYPE sdayname[] = {
        LOCALE_SABBREVDAYNAME7, LOCALE_SABBREVDAYNAME1, LOCALE_SABBREVDAYNAME2,
        LOCALE_SABBREVDAYNAME3, LOCALE_SABBREVDAYNAME4, LOCALE_SABBREVDAYNAME5,
        LOCALE_SABBREVDAYNAME6
    };
    static const LCTYPE monthname[] = {
        LOCALE_SMONTHNAME1, LOCALE_SMONTHNAME2, LOCALE_SMONTHNAME3, LOCALE_SMONTHNAME4,
        LOCALE_SMONTHNAME5, LOCALE_SMONTHNAME6, LOCALE_SMONTHNAME7, LOCALE_SMONTHNAME8,
        LOCALE_SMONTHNAME9, LOCALE_SMONTHNAME10, LOCALE_SMONTHNAME11, LOCALE_SMONTHNAME12
    };
    static const LCTYPE smonthname[] = {
        LOCALE_SABBREVMONTHNAME1, LOCALE_SABBREVMONTHNAME2, LOCALE_SABBREVMONTHNAME3,
        LOCALE_SABBREVMONTHNAME4, LOCALE_SABBREVMONTHNAME5, LOCALE_SABBREVMONTHNAME6,
        LOCALE_SABBREVMONTHNAME7, LOCALE_SABBREVMONTHNAME8, LOCALE_SABBREVMONTHNAME9,
        LOCALE_SABBREVMONTHNAME10, LOCALE_SABBREVMONTHNAME11, LOCALE_SABBREVMONTHNAME12
    };

    if(flags & ~(LOCALE_NOUSEROVERRIDE|VAR_DATEVALUEONLY))
        FIXME("ignoring flags %x\n", flags);
    flags &= LOCALE_NOUSEROVERRIDE;

    while(*fmt && date_len) {
        int count = 1;

        switch(*fmt) {
            case 'd':
            case 'M':
            case 'y':
            case 'g':
                while(*fmt == *(fmt+count))
                    count++;
                fmt += count-1;
        }

        switch(*fmt) {
        case 'd':
            if(count >= 4)
                count = GetLocaleInfoW(lcid, dayname[st->wDayOfWeek] | flags, date, date_len)-1;
            else if(count == 3)
                count = GetLocaleInfoW(lcid, sdayname[st->wDayOfWeek] | flags, date, date_len)-1;
            else
                count = output_int_len(st->wDay, count, date, date_len);
            break;
        case 'M':
            if(count >= 4)
                count = GetLocaleInfoW(lcid, monthname[st->wMonth-1] | flags, date, date_len)-1;
            else if(count == 3)
                count = GetLocaleInfoW(lcid, smonthname[st->wMonth-1] | flags, date, date_len)-1;
            else
                count = output_int_len(st->wMonth, count, date, date_len);
            break;
        case 'y':
            if(count >= 3)
                count = output_int_len(st->wYear, 0, date, date_len);
            else
                count = output_int_len(st->wYear%100, count, date, date_len);
            break;
        case 'g':
            if(count == 2) {
                FIXME("Should be using GetCalendarInfo(CAL_SERASTRING), defaulting to 'AD'\n");

                *date++ = 'A';
                date_len--;
                if(date_len)
                    *date = 'D';
                else
                    count = -1;
                break;
            }
        /* fall through */
        default:
            *date = *fmt;
        }

        if(count < 0)
            break;
        fmt++;
        date += count;
        date_len -= count;
    }

    if(!date_len)
        return FALSE;
    *date++ = 0;
    return TRUE;
}

Referenced by VarBstrFromDate(), and VARIANT_FormatDate().

output_int_len()

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

inlinestatic

Definition at line 6648 of file vartype.c.

{
    int len, tmp;

    if(min_len >= date_len)
        return -1;

    for(len=0, tmp=o; tmp; tmp/=10) len++;
    if(!len) len++;
    if(len >= date_len)
        return -1;

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

Referenced by get_date_format().

VarBoolFromCy()

HRESULT WINAPI VarBoolFromCy	(	CY	cyIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6048 of file vartype.c.

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

Referenced by test_VarBoolFromCy(), and VARIANT_Coerce().

VarBoolFromDate()

HRESULT WINAPI VarBoolFromDate	(	DATE	dateIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6030 of file vartype.c.

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

Referenced by test_VarBoolFromDate(), and VARIANT_Coerce().

VarBoolFromDec()

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

Definition at line 6278 of file vartype.c.

{
  if (DEC_SCALE(pDecIn) > DEC_MAX_SCALE || (DEC_SIGN(pDecIn) & ~DECIMAL_NEG))
    return E_INVALIDARG;

  if (DEC_HI32(pDecIn) || DEC_MID32(pDecIn) || DEC_LO32(pDecIn))
    *pBoolOut = VARIANT_TRUE;
  else
    *pBoolOut = VARIANT_FALSE;
  return S_OK;
}

Referenced by test_VarBoolFromDec(), and VARIANT_Coerce().

VarBoolFromDisp()

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

Definition at line 6206 of file vartype.c.

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

Referenced by VARIANT_Coerce().

VarBoolFromI1()

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

Definition at line 6223 of file vartype.c.

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

Referenced by test_VarBoolFromI1(), and VARIANT_Coerce().

VarBoolFromI2()

HRESULT WINAPI VarBoolFromI2	(	SHORT	sIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 5958 of file vartype.c.

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

Referenced by test_VarBoolFromI2(), and VARIANT_Coerce().

VarBoolFromI4()

HRESULT WINAPI VarBoolFromI4	(	LONG	lIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 5976 of file vartype.c.

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

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

VarBoolFromI8()

HRESULT WINAPI VarBoolFromI8	(	LONG64	llIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6302 of file vartype.c.

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

Referenced by test_VarBoolFromI8(), and VARIANT_Coerce().

VarBoolFromR4()

HRESULT WINAPI VarBoolFromR4	(	FLOAT	fltIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 5994 of file vartype.c.

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

Referenced by test_VarBoolFromR4(), and VARIANT_Coerce().

VarBoolFromR8()

HRESULT WINAPI VarBoolFromR8	(	double	dblIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6012 of file vartype.c.

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

Referenced by test_VarBoolFromR8(), and VARIANT_Coerce().

VarBoolFromStr()

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

Definition at line 6114 of file vartype.c.

{
  /* Any VB/VBA programmers out there should recognise these strings... */
  static const WCHAR szFalse[] = { '#','F','A','L','S','E','#','\0' };
  static const WCHAR szTrue[] = { '#','T','R','U','E','#','\0' };
  WCHAR szBuff[64];
  LANGID langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
  HRESULT hRes = S_OK;

  if (!strIn || !pBoolOut)
    return DISP_E_TYPEMISMATCH;

  /* Check if we should be comparing against localised text */
  if (dwFlags & VAR_LOCALBOOL)
  {
    /* Convert our LCID into a usable value */
    lcid = ConvertDefaultLocale(lcid);

    langId = LANGIDFROMLCID(lcid);

    if (PRIMARYLANGID(langId) == LANG_NEUTRAL)
      langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);

    /* Note: Native oleaut32 always copies strIn and maps halfwidth characters.
     * I don't think this is needed unless any of the localised text strings
     * contain characters that can be so mapped. In the event that this is
     * true for a given language (possibly some Asian languages), then strIn
     * should be mapped here _only_ if langId is an Id for which this can occur.
     */
  }

  /* Note that if we are not comparing against localised strings, langId
   * will have its default value of LANG_ENGLISH. This allows us to mimic
   * the native behaviour of always checking against English strings even
   * after we've checked for localised ones.
   */
VarBoolFromStr_CheckLocalised:
  if (VARIANT_GetLocalisedText(langId, IDS_TRUE, szBuff))
  {
    /* Compare against localised strings, ignoring case */
    if (!wcsicmp(strIn, szBuff))
    {
      *pBoolOut = VARIANT_TRUE; /* Matched localised 'true' text */
      return hRes;
    }
    VARIANT_GetLocalisedText(langId, IDS_FALSE, szBuff);
    if (!wcsicmp(strIn, szBuff))
    {
      *pBoolOut = VARIANT_FALSE; /* Matched localised 'false' text */
      return hRes;
    }
  }

  if (langId != MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT))
  {
    /* We have checked the localised text, now check English */
    langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
    goto VarBoolFromStr_CheckLocalised;
  }

  /* All checks against localised text have failed, try #TRUE#/#FALSE# */
  if (!wcscmp(strIn, szFalse))
    *pBoolOut = VARIANT_FALSE;
  else if (!wcscmp(strIn, szTrue))
    *pBoolOut = VARIANT_TRUE;
  else
  {
    double d;

    /* If this string is a number, convert it as one */
    hRes = VarR8FromStr(strIn, lcid, dwFlags, &d);
    if (SUCCEEDED(hRes)) *pBoolOut = d ? VARIANT_TRUE : VARIANT_FALSE;
  }
  return hRes;
}

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

VarBoolFromUI1()

HRESULT WINAPI VarBoolFromUI1	(	BYTE	bIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 5940 of file vartype.c.

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

Referenced by test_VarBoolFromUI1(), and VARIANT_Coerce().

VarBoolFromUI2()

HRESULT WINAPI VarBoolFromUI2	(	USHORT	usIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6241 of file vartype.c.

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

Referenced by test_VarBoolFromUI2(), and VARIANT_Coerce().

VarBoolFromUI4()

HRESULT WINAPI VarBoolFromUI4	(	ULONG	ulIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6259 of file vartype.c.

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

Referenced by VARIANT_Coerce().

VarBoolFromUI8()

HRESULT WINAPI VarBoolFromUI8	(	ULONG64	ullIn,
		VARIANT_BOOL *	pBoolOut
	)

Definition at line 6320 of file vartype.c.

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

Referenced by test_VarBoolFromUI8(), and VARIANT_Coerce().

VarBstrCat()

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

Definition at line 7107 of file vartype.c.

{
  unsigned int lenLeft, lenRight;

  TRACE("%s,%s,%p\n",
   debugstr_wn(pbstrLeft, SysStringLen(pbstrLeft)),
   debugstr_wn(pbstrRight, SysStringLen(pbstrRight)), pbstrOut);

  if (!pbstrOut)
    return E_INVALIDARG;

  /* use byte length here to properly handle ansi-allocated BSTRs */
  lenLeft = pbstrLeft ? SysStringByteLen(pbstrLeft) : 0;
  lenRight = pbstrRight ? SysStringByteLen(pbstrRight) : 0;

  *pbstrOut = SysAllocStringByteLen(NULL, lenLeft + lenRight);
  if (!*pbstrOut)
    return E_OUTOFMEMORY;

  (*pbstrOut)[0] = '\0';

  if (pbstrLeft)
    memcpy(*pbstrOut, pbstrLeft, lenLeft);

  if (pbstrRight)
    memcpy((CHAR*)*pbstrOut + lenLeft, pbstrRight, lenRight);

  TRACE("%s\n", debugstr_wn(*pbstrOut, SysStringLen(*pbstrOut)));
  return S_OK;
}

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

VarBstrCmp()

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

Definition at line 7158 of file vartype.c.

{
    HRESULT hres;
    int ret;

    TRACE("%s,%s,%d,%08x\n",
     debugstr_wn(pbstrLeft, SysStringLen(pbstrLeft)),
     debugstr_wn(pbstrRight, SysStringLen(pbstrRight)), lcid, dwFlags);

    if (!pbstrLeft || !*pbstrLeft)
    {
      if (pbstrRight && *pbstrRight)
        return VARCMP_LT;
    }
    else if (!pbstrRight || !*pbstrRight)
        return VARCMP_GT;

    if (lcid == 0)
    {
      unsigned int lenLeft = SysStringByteLen(pbstrLeft);
      unsigned int lenRight = SysStringByteLen(pbstrRight);
      ret = memcmp(pbstrLeft, pbstrRight, min(lenLeft, lenRight));
      if (ret < 0)
        return VARCMP_LT;
      if (ret > 0)
        return VARCMP_GT;
      if (lenLeft < lenRight)
        return VARCMP_LT;
      if (lenLeft > lenRight)
        return VARCMP_GT;
      return VARCMP_EQ;
    }
    else
    {
      unsigned int lenLeft = SysStringLen(pbstrLeft);
      unsigned int lenRight = SysStringLen(pbstrRight);

      if (lenLeft == 0 || lenRight == 0)
      {
          if (lenLeft == 0 && lenRight == 0) return VARCMP_EQ;
          return lenLeft < lenRight ? VARCMP_LT : VARCMP_GT;
      }

      hres = CompareStringW(lcid, dwFlags, pbstrLeft, lenLeft,
              pbstrRight, lenRight) - CSTR_LESS_THAN;
      TRACE("%d\n", hres);
      return hres;
    }
}

Referenced by START_TEST(), and VarCmp().

VarBstrFromBool()

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

Definition at line 6852 of file vartype.c.

{
  WCHAR szBuff[64];
  DWORD dwResId = IDS_TRUE;
  LANGID langId;

  TRACE("%d,0x%08x,0x%08x,%p\n", boolIn, lcid, dwFlags, pbstrOut);

  if (!pbstrOut)
    return E_INVALIDARG;

  /* VAR_BOOLONOFF and VAR_BOOLYESNO are internal flags used
   * for variant formatting */
  switch (dwFlags & (VAR_LOCALBOOL|VAR_BOOLONOFF|VAR_BOOLYESNO))
  {
  case VAR_BOOLONOFF:
      dwResId = IDS_ON;
      break;
  case VAR_BOOLYESNO:
      dwResId = IDS_YES;
      break;
  case VAR_LOCALBOOL:
      break;
  default:
    lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT),SORT_DEFAULT);
  }

  lcid = ConvertDefaultLocale(lcid);
  langId = LANGIDFROMLCID(lcid);
  if (PRIMARYLANGID(langId) == LANG_NEUTRAL)
    langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);

  if (boolIn == VARIANT_FALSE)
    dwResId++; /* Use negative form */

VarBstrFromBool_GetLocalised:
  if (VARIANT_GetLocalisedText(langId, dwResId, szBuff))
  {
    *pbstrOut = SysAllocString(szBuff);
    return *pbstrOut ? S_OK : E_OUTOFMEMORY;
  }

  if (langId != MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT))
  {
    langId = MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT);
    goto VarBstrFromBool_GetLocalised;
  }

  /* Should never get here */
  WARN("Failed to load bool text!\n");
  return E_OUTOFMEMORY;
}

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

VarBstrFromCy()

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

Definition at line 6608 of file vartype.c.

{
  WCHAR buff[256];
  VARIANT_DI decVal;

  if (!pbstrOut)
    return E_INVALIDARG;

  decVal.scale = 4;
  decVal.sign = 0;
  decVal.bitsnum[0] = cyIn.s.Lo;
  decVal.bitsnum[1] = cyIn.s.Hi;
  if (cyIn.s.Hi & 0x80000000UL) {
    DWORD one = 1;

    /* Negative number! */
    decVal.sign = 1;
    decVal.bitsnum[0] = ~decVal.bitsnum[0];
    decVal.bitsnum[1] = ~decVal.bitsnum[1];
    VARIANT_int_add(decVal.bitsnum, 3, &one, 1);
  }
  decVal.bitsnum[2] = 0;
  VARIANT_DI_tostringW(&decVal, buff, ARRAY_SIZE(buff));

  if (dwFlags & LOCALE_USE_NLS)
  {
    WCHAR cybuff[256];

    /* Format the currency for the locale */
    cybuff[0] = '\0';
    GetCurrencyFormatW(lcid, dwFlags & LOCALE_NOUSEROVERRIDE,
                       buff, NULL, cybuff, ARRAY_SIZE(cybuff));
    *pbstrOut = SysAllocString(cybuff);
  }
  else
    *pbstrOut = VARIANT_BstrReplaceDecimal(buff,lcid,dwFlags);

  return *pbstrOut ? S_OK : E_OUTOFMEMORY;
}

Referenced by _BSTR_CY(), and VARIANT_Coerce().

VarBstrFromDate()

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

Definition at line 6778 of file vartype.c.

{
  SYSTEMTIME st;
  DWORD dwFormatFlags = dwFlags & LOCALE_NOUSEROVERRIDE;
  WCHAR date[128], fmt_buff[80], *time;

  TRACE("(%g,0x%08x,0x%08x,%p)\n", dateIn, lcid, dwFlags, pbstrOut);

  if (!pbstrOut || !VariantTimeToSystemTime(dateIn, &st))
    return E_INVALIDARG;

  *pbstrOut = NULL;

  if (dwFlags & VAR_CALENDAR_THAI)
      st.wYear += 553; /* Use the Thai buddhist calendar year */
  else if (dwFlags & (VAR_CALENDAR_HIJRI|VAR_CALENDAR_GREGORIAN))
      FIXME("VAR_CALENDAR_HIJRI/VAR_CALENDAR_GREGORIAN not handled\n");

  if (dwFlags & LOCALE_USE_NLS)
    dwFlags &= ~(VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY);
  else
  {
    double whole = dateIn < 0 ? ceil(dateIn) : floor(dateIn);
    double partial = dateIn - whole;

    if (whole == 0.0)
      dwFlags |= VAR_TIMEVALUEONLY;
    else if (partial > -1e-12 && partial < 1e-12)
      dwFlags |= VAR_DATEVALUEONLY;
  }

  if (dwFlags & VAR_TIMEVALUEONLY)
    date[0] = '\0';
  else
    if (!GetLocaleInfoW(lcid, LOCALE_SSHORTDATE, fmt_buff, ARRAY_SIZE(fmt_buff)) ||
        !get_date_format(lcid, dwFlags, &st, fmt_buff, date, ARRAY_SIZE(date)))
      return E_INVALIDARG;

  if (!(dwFlags & VAR_DATEVALUEONLY))
  {
    time = date + lstrlenW(date);
    if (time != date)
      *time++ = ' ';
    if (!GetTimeFormatW(lcid, dwFormatFlags, &st, NULL, time, ARRAY_SIZE(date)-(time-date)))
      return E_INVALIDARG;
  }

  *pbstrOut = SysAllocString(date);
  if (*pbstrOut)
    TRACE("returning %s\n", debugstr_w(*pbstrOut));
  return *pbstrOut ? S_OK : E_OUTOFMEMORY;
}

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

VarBstrFromDec()

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

Definition at line 6991 of file vartype.c.

{
  WCHAR buff[256];
  VARIANT_DI temp;

  if (!pbstrOut)
    return E_INVALIDARG;

  VARIANT_DIFromDec(pDecIn, &temp);
  VARIANT_DI_tostringW(&temp, buff, 256);

  if (dwFlags & LOCALE_USE_NLS)
  {
    WCHAR numbuff[256];

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

Referenced by _BSTR_DEC(), and VARIANT_Coerce().

VarBstrFromDisp()

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

Definition at line 7087 of file vartype.c.

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

Referenced by VARIANT_Coerce().

VarBstrFromI1()

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

Definition at line 6921 of file vartype.c.

{
  ULONG64 ul64 = cIn;

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

Referenced by VARIANT_Coerce().

VarBstrFromI2()

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

Definition at line 6417 of file vartype.c.

{
  ULONG64 ul64 = sIn;

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

Referenced by VARIANT_Coerce().

VarBstrFromI4()

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

Definition at line 6445 of file vartype.c.

{
  ULONG64 ul64 = lIn;

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

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

VarBstrFromI8()

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

Definition at line 7038 of file vartype.c.

{
  ULONG64 ul64 = llIn;

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

Referenced by VARIANT_Coerce().

VarBstrFromR4()

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

Definition at line 6566 of file vartype.c.

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

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

VarBstrFromR8()

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

Definition at line 6587 of file vartype.c.

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

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

VarBstrFromUI1()

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

Definition at line 6396 of file vartype.c.

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

Referenced by VARIANT_Coerce().

VarBstrFromUI2()

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

Definition at line 6949 of file vartype.c.

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

Referenced by VARIANT_Coerce().

VarBstrFromUI4()

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

Definition at line 6970 of file vartype.c.

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

Referenced by VARIANT_Coerce().

VarBstrFromUI8()

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

Definition at line 7066 of file vartype.c.

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

Referenced by VARIANT_Coerce().

VarCyAbs()

HRESULT WINAPI VarCyAbs	(	CY	cyIn,
		CY *	pCyOut
	)

Definition at line 3876 of file vartype.c.

{
  if (cyIn.s.Hi == (int)0x80000000 && !cyIn.s.Lo)
    return DISP_E_OVERFLOW;

  pCyOut->int64 = cyIn.int64 < 0 ? -cyIn.int64 : cyIn.int64;
  return S_OK;
}

Referenced by test_VarCyAbs(), and VarAbs().

VarCyAdd()

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

Definition at line 3785 of file vartype.c.

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

Referenced by test_VarCyAdd(), and VarAdd().

VarCyCmp()

HRESULT WINAPI VarCyCmp	(	CY	cyLeft,
		CY	cyRight
	)

Definition at line 4012 of file vartype.c.

{
  HRESULT hRet;
  CY result;

  /* Subtract right from left, and compare the result to 0 */
  hRet = VarCySub(cyLeft, cyRight, &result);

  if (SUCCEEDED(hRet))
  {
    if (result.int64 < 0)
      hRet = (HRESULT)VARCMP_LT;
    else if (result.int64 > 0)
      hRet = (HRESULT)VARCMP_GT;
    else
      hRet = (HRESULT)VARCMP_EQ;
  }
  return hRet;
}

Referenced by VarCmp(), and VarCyCmpR8().

VarCyCmpR8()

HRESULT WINAPI VarCyCmpR8	(	CY	cyLeft,
		double	dblRight
	)

Definition at line 4046 of file vartype.c.

{
  HRESULT hRet;
  CY cyRight;

  hRet = VarCyFromR8(dblRight, &cyRight);

  if (SUCCEEDED(hRet))
    hRet = VarCyCmp(cyLeft, cyRight);

  return hRet;
}

VarCyFix()

HRESULT WINAPI VarCyFix	(	CY	cyIn,
		CY *	pCyOut
	)

Definition at line 3902 of file vartype.c.

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

Referenced by VarFix().

VarCyFromBool()

HRESULT WINAPI VarCyFromBool	(	VARIANT_BOOL	boolIn,
		CY *	pCyOut
	)

Definition at line 3620 of file vartype.c.

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

Referenced by test_VarCyFromBool(), and VARIANT_Coerce().

VarCyFromDate()

HRESULT WINAPI VarCyFromDate	(	DATE	dateIn,
		CY *	pCyOut
	)

Definition at line 3553 of file vartype.c.

{
  return VarCyFromR8(dateIn, pCyOut);
}

Referenced by test_VarCyFromDate(), and VARIANT_Coerce().

VarCyFromDec()

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

Definition at line 3704 of file vartype.c.

{
  DECIMAL rounded;
  HRESULT hRet;

  hRet = VarDecRound(pdecIn, 4, &rounded);

  if (SUCCEEDED(hRet))
  {
    double d;

    if (DEC_HI32(&rounded))
      return DISP_E_OVERFLOW;

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

Referenced by test_VarCyFromDec(), and VARIANT_Coerce().

VarCyFromDisp()

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

Definition at line 3596 of file vartype.c.

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

Referenced by VARIANT_Coerce().

VarCyFromI1()

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

Definition at line 3641 of file vartype.c.

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

Referenced by test_VarCyFromI1(), and VARIANT_Coerce().

VarCyFromI2()

HRESULT WINAPI VarCyFromI2	(	SHORT	sIn,
		CY *	pCyOut
	)

Definition at line 3441 of file vartype.c.

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

Referenced by test_VarCyFromI2(), and VARIANT_Coerce().

VarCyFromI4()

HRESULT WINAPI VarCyFromI4	(	LONG	lIn,
		CY *	pCyOut
	)

Definition at line 3462 of file vartype.c.

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

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

VarCyFromI8()

HRESULT WINAPI VarCyFromI8	(	LONG64	llIn,
		CY *	pCyOut
	)

Definition at line 3742 of file vartype.c.

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

Referenced by test_VarCyFromI8(), and VARIANT_Coerce().

VarCyFromR4()

HRESULT WINAPI VarCyFromR4	(	FLOAT	fltIn,
		CY *	pCyOut
	)

Definition at line 3483 of file vartype.c.

{
  return VarCyFromR8(fltIn, pCyOut);
}

Referenced by test_VarCyFromR4(), and VARIANT_Coerce().

VarCyFromR8()

HRESULT WINAPI VarCyFromR8	(	double	dblIn,
		CY *	pCyOut
	)

Definition at line 3503 of file vartype.c.

{
#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
  /* This code gives identical results to Win32 on Intel.
   * Here we use fp exceptions to catch overflows when storing the value.
   */
  static const unsigned short r8_fpcontrol = 0x137f;
  static const double r8_multiplier = CY_MULTIPLIER_F;
  unsigned short old_fpcontrol, result_fpstatus;

  /* Clear exceptions, save the old fp state and load the new state */
  __asm__ __volatile__( "fnclex" );
  __asm__ __volatile__( "fstcw %0"   :   "=m" (old_fpcontrol) : );
  __asm__ __volatile__( "fldcw %0"   : : "m"  (r8_fpcontrol) );
  /* Perform the conversion. */
  __asm__ __volatile__( "fldl  %0"   : : "m"  (dblIn) );
  __asm__ __volatile__( "fmull %0"   : : "m"  (r8_multiplier) );
  __asm__ __volatile__( "fistpll %0" : : "m"  (*pCyOut) );
  /* Save the resulting fp state, load the old state and clear exceptions */
  __asm__ __volatile__( "fstsw %0"   :   "=m" (result_fpstatus) : );
  __asm__ __volatile__( "fnclex" );
  __asm__ __volatile__( "fldcw %0"   : : "m"  (old_fpcontrol) );

  if (result_fpstatus & 0x9) /* Overflow | Invalid */
    return DISP_E_OVERFLOW;
#else
  /* This version produces slightly different results for boundary cases */
  if (dblIn < -922337203685477.5807 || dblIn >= 922337203685477.5807)
    return DISP_E_OVERFLOW;
  dblIn *= CY_MULTIPLIER_F;
  VARIANT_DutchRound(LONG64, dblIn, pCyOut->int64);
#endif
  return S_OK;
}

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

VarCyFromStr()

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

Definition at line 3575 of file vartype.c.

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

Referenced by VARIANT_Coerce().

VarCyFromUI1()

HRESULT WINAPI VarCyFromUI1	(	BYTE	bIn,
		CY *	pCyOut
	)

Definition at line 3420 of file vartype.c.

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

Referenced by test_VarCyFromUI1(), and VARIANT_Coerce().

VarCyFromUI2()

HRESULT WINAPI VarCyFromUI2	(	USHORT	usIn,
		CY *	pCyOut
	)

Definition at line 3662 of file vartype.c.

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

Referenced by test_VarCyFromUI2(), and VARIANT_Coerce().

VarCyFromUI4()

HRESULT WINAPI VarCyFromUI4	(	ULONG	ulIn,
		CY *	pCyOut
	)

Definition at line 3683 of file vartype.c.

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

Referenced by test_VarCyFromUI4(), and VARIANT_Coerce().

VarCyFromUI8()

HRESULT WINAPI VarCyFromUI8	(	ULONG64	ullIn,
		CY *	pCyOut
	)

Definition at line 3764 of file vartype.c.

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

Referenced by test_VarCyFromUI8(), and VARIANT_Coerce().

VarCyInt()

HRESULT WINAPI VarCyInt	(	CY	cyIn,
		CY *	pCyOut
	)

Definition at line 3926 of file vartype.c.

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

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

Referenced by VarInt().

VarCyMul()

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

Definition at line 3808 of file vartype.c.

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

Referenced by test_VarCyMul(), and VarMul().

VarCyMulI4()

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

Definition at line 3831 of file vartype.c.

{
  double d;

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

VarCyMulI8()

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

Definition at line 4073 of file vartype.c.

{
  double d;

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

VarCyNeg()

HRESULT WINAPI VarCyNeg	(	CY	cyIn,
		CY *	pCyOut
	)

Definition at line 3951 of file vartype.c.

{
  if (cyIn.s.Hi == (int)0x80000000 && !cyIn.s.Lo)
    return DISP_E_OVERFLOW;

  pCyOut->int64 = -cyIn.int64;
  return S_OK;
}

Referenced by test_VarCyNeg(), and VarNeg().

VarCyRound()

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

Definition at line 3974 of file vartype.c.

{
  if (cDecimals < 0)
    return E_INVALIDARG;

  if (cDecimals > 3)
  {
    /* Rounding to more precision than we have */
    *pCyOut = cyIn;
    return S_OK;
  }
  else
  {
    double d, div = CY_Divisors[cDecimals];

    _VarR8FromCy(cyIn, &d);
    d = d * div;
    VARIANT_DutchRound(LONGLONG, d, pCyOut->int64);
    d = (double)pCyOut->int64 / div * CY_MULTIPLIER_F;
    VARIANT_DutchRound(LONGLONG, d, pCyOut->int64);
    return S_OK;
  }
}

VarCySub()

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

Definition at line 3854 of file vartype.c.

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

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

VarDateFromBool()

HRESULT WINAPI VarDateFromBool	(	VARIANT_BOOL	boolIn,
		DATE *	pdateOut
	)

Definition at line 7332 of file vartype.c.

{
  return VarR8FromBool(boolIn, pdateOut);
}

Referenced by test_VarDateFromBool(), and VARIANT_Coerce().

VarDateFromCy()

HRESULT WINAPI VarDateFromCy	(	CY	cyIn,
		DATE *	pdateOut
	)

Definition at line 7349 of file vartype.c.

{
  return VarR8FromCy(cyIn, pdateOut);
}

Referenced by test_VarDateFromCy(), and VARIANT_Coerce().

VarDateFromDec()

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

Definition at line 8005 of file vartype.c.

{
  return VarR8FromDec(pdecIn, pdateOut);
}

Referenced by test_VarDateFromDec(), and VARIANT_Coerce().

VarDateFromDisp()

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

Definition at line 7315 of file vartype.c.

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

Referenced by VARIANT_Coerce().

VarDateFromI1()

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

Definition at line 7954 of file vartype.c.

{
  return VarR8FromI1(cIn, pdateOut);
}

Referenced by test_VarDateFromI1(), and VARIANT_Coerce().

VarDateFromI2()

HRESULT WINAPI VarDateFromI2	(	short	sIn,
		DATE *	pdateOut
	)

Definition at line 7241 of file vartype.c.

{
  return VarR8FromI2(sIn, pdateOut);
}

Referenced by test_VarDateFromI2(), and VARIANT_Coerce().

VarDateFromI4()

HRESULT WINAPI VarDateFromI4	(	LONG	lIn,
		DATE *	pdateOut
	)

Definition at line 7258 of file vartype.c.

{
  return VarDateFromR8(lIn, pdateOut);
}

Referenced by test_VarDateFromI4(), and VARIANT_Coerce().

VarDateFromI8()

HRESULT WINAPI VarDateFromI8	(	LONG64	llIn,
		DATE *	pdateOut
	)

Definition at line 8023 of file vartype.c.

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

Referenced by test_VarDateFromI8(), and VARIANT_Coerce().

VarDateFromR4()

HRESULT WINAPI VarDateFromR4	(	FLOAT	fltIn,
		DATE *	pdateOut
	)

Definition at line 7275 of file vartype.c.

{
  return VarR8FromR4(fltIn, pdateOut);
}

Referenced by test_VarDateFromR4(), and VARIANT_Coerce().

VarDateFromR8()

HRESULT WINAPI VarDateFromR8	(	double	dblIn,
		DATE *	pdateOut
	)

Definition at line 7292 of file vartype.c.

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

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

VarDateFromStr()

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

Definition at line 7595 of file vartype.c.

{
  static const USHORT ParseDateTokens[] =
  {
    LOCALE_SMONTHNAME1, LOCALE_SMONTHNAME2, LOCALE_SMONTHNAME3, LOCALE_SMONTHNAME4,
    LOCALE_SMONTHNAME5, LOCALE_SMONTHNAME6, LOCALE_SMONTHNAME7, LOCALE_SMONTHNAME8,
    LOCALE_SMONTHNAME9, LOCALE_SMONTHNAME10, LOCALE_SMONTHNAME11, LOCALE_SMONTHNAME12,
    LOCALE_SMONTHNAME13,
    LOCALE_SABBREVMONTHNAME1, LOCALE_SABBREVMONTHNAME2, LOCALE_SABBREVMONTHNAME3,
    LOCALE_SABBREVMONTHNAME4, LOCALE_SABBREVMONTHNAME5, LOCALE_SABBREVMONTHNAME6,
    LOCALE_SABBREVMONTHNAME7, LOCALE_SABBREVMONTHNAME8, LOCALE_SABBREVMONTHNAME9,
    LOCALE_SABBREVMONTHNAME10, LOCALE_SABBREVMONTHNAME11, LOCALE_SABBREVMONTHNAME12,
    LOCALE_SABBREVMONTHNAME13,
    LOCALE_SDAYNAME1, LOCALE_SDAYNAME2, LOCALE_SDAYNAME3, LOCALE_SDAYNAME4,
    LOCALE_SDAYNAME5, LOCALE_SDAYNAME6, LOCALE_SDAYNAME7,
    LOCALE_SABBREVDAYNAME1, LOCALE_SABBREVDAYNAME2, LOCALE_SABBREVDAYNAME3,
    LOCALE_SABBREVDAYNAME4, LOCALE_SABBREVDAYNAME5, LOCALE_SABBREVDAYNAME6,
    LOCALE_SABBREVDAYNAME7,
    LOCALE_S1159, LOCALE_S2359,
    LOCALE_SDATE
  };
  static const BYTE ParseDateMonths[] =
  {
    1,2,3,4,5,6,7,8,9,10,11,12,13,
    1,2,3,4,5,6,7,8,9,10,11,12,13
  };
  unsigned int i;
  BSTR tokens[ARRAY_SIZE(ParseDateTokens)];
  DATEPARSE dp;
  DWORD dwDateSeps = 0, iDate = 0;
  HRESULT hRet = S_OK;

  if ((dwFlags & (VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY)) ==
      (VAR_TIMEVALUEONLY|VAR_DATEVALUEONLY))
    return E_INVALIDARG;

  if (!strIn)
    return DISP_E_TYPEMISMATCH;

  *pdateOut = 0.0;

  TRACE("(%s,0x%08x,0x%08x,%p)\n", debugstr_w(strIn), lcid, dwFlags, pdateOut);

  memset(&dp, 0, sizeof(dp));

  GetLocaleInfoW(lcid, LOCALE_IDATE|LOCALE_RETURN_NUMBER|(dwFlags & LOCALE_NOUSEROVERRIDE),
                 (LPWSTR)&iDate, sizeof(iDate)/sizeof(WCHAR));
  TRACE("iDate is %d\n", iDate);

  /* Get the month/day/am/pm tokens for this locale */
  for (i = 0; i < ARRAY_SIZE(tokens); i++)
  {
    WCHAR buff[128];
    LCTYPE lctype =  ParseDateTokens[i] | (dwFlags & LOCALE_NOUSEROVERRIDE);

    /* FIXME: Alternate calendars - should use GetCalendarInfo() and/or
     *        GetAltMonthNames(). We should really cache these strings too.
     */
    buff[0] = '\0';
    GetLocaleInfoW(lcid, lctype, buff, ARRAY_SIZE(buff));
    tokens[i] = SysAllocString(buff);
    TRACE("token %d is %s\n", i, debugstr_w(tokens[i]));
  }

  /* Parse the string into our structure */
  while (*strIn)
  {
    if (iswdigit(*strIn))
    {
      if (dp.dwCount >= 6)
      {
        hRet = DISP_E_TYPEMISMATCH;
        break;
      }
      dp.dwValues[dp.dwCount] = wcstoul(strIn, &strIn, 10);
      dp.dwCount++;
      strIn--;
    }
    else if (iswalpha(*strIn))
    {
      BOOL bFound = FALSE;

      for (i = 0; i < ARRAY_SIZE(tokens); i++)
      {
        DWORD dwLen = lstrlenW(tokens[i]);
        if (dwLen && !_wcsnicmp(strIn, tokens[i], dwLen))
        {
          if (i <= 25)
          {
            if (dp.dwCount >= 6)
              hRet = DISP_E_TYPEMISMATCH;
            else
            {
              dp.dwValues[dp.dwCount] = ParseDateMonths[i];
              dp.dwFlags[dp.dwCount] |= (DP_MONTH|DP_DATESEP);
              dp.dwCount++;
            }
          }
          else if (i > 39 && i < 42)
          {
            if (!dp.dwCount || dp.dwParseFlags & (DP_AM|DP_PM))
              hRet = DISP_E_TYPEMISMATCH;
            else
            {
              dp.dwFlags[dp.dwCount - 1] |= (i == 40 ? DP_AM : DP_PM);
              dp.dwParseFlags |= (i == 40 ? DP_AM : DP_PM);
            }
          }
          strIn += (dwLen - 1);
          bFound = TRUE;
          break;
        }
      }

      if (!bFound)
      {
        if ((*strIn == 'a' || *strIn == 'A' || *strIn == 'p' || *strIn == 'P') &&
            (dp.dwCount && !(dp.dwParseFlags & (DP_AM|DP_PM))))
        {
          /* Special case - 'a' and 'p' are recognised as short for am/pm */
          if (*strIn == 'a' || *strIn == 'A')
          {
            dp.dwFlags[dp.dwCount - 1] |= DP_AM;
            dp.dwParseFlags |=  DP_AM;
          }
          else
          {
            dp.dwFlags[dp.dwCount - 1] |= DP_PM;
            dp.dwParseFlags |=  DP_PM;
          }
          strIn++;
        }
        else
        {
          TRACE("No matching token for %s\n", debugstr_w(strIn));
          hRet = DISP_E_TYPEMISMATCH;
          break;
        }
      }
    }
    else if (*strIn == ':' ||  *strIn == '.')
    {
      if (!dp.dwCount || !strIn[1])
        hRet = DISP_E_TYPEMISMATCH;
      else
        if (tokens[42][0] == *strIn)
        {
          dwDateSeps++;
          if (dwDateSeps > 2)
            hRet = DISP_E_TYPEMISMATCH;
          else
            dp.dwFlags[dp.dwCount - 1] |= DP_DATESEP;
        }
        else
          dp.dwFlags[dp.dwCount - 1] |= DP_TIMESEP;
    }
    else if (*strIn == '-' || *strIn == '/')
    {
      dwDateSeps++;
      if (dwDateSeps > 2 || !dp.dwCount || !strIn[1])
        hRet = DISP_E_TYPEMISMATCH;
      else
        dp.dwFlags[dp.dwCount - 1] |= DP_DATESEP;
    }
    else if (*strIn == ',' || iswspace(*strIn))
    {
      if (*strIn == ',' && !strIn[1])
        hRet = DISP_E_TYPEMISMATCH;
    }
    else
    {
      hRet = DISP_E_TYPEMISMATCH;
    }
    strIn++;
  }

  if (!dp.dwCount || dp.dwCount > 6 ||
      (dp.dwCount == 1 && !(dp.dwParseFlags & (DP_AM|DP_PM))))
    hRet = DISP_E_TYPEMISMATCH;

  if (SUCCEEDED(hRet))
  {
    SYSTEMTIME st;
    DWORD dwOffset = 0; /* Start of date fields in dp.dwValues */

    st.wDayOfWeek = st.wHour = st.wMinute = st.wSecond = st.wMilliseconds = 0;

    /* Figure out which numbers correspond to which fields.
     *
     * This switch statement works based on the fact that native interprets any
     * fields that are not joined with a time separator ('.' or ':') as date
     * fields. Thus we construct a value from 0-32 where each set bit indicates
     * a time field. This encapsulates the hundreds of permutations of 2-6 fields.
     * For valid permutations, we set dwOffset to point to the first date field
     * and shorten dp.dwCount by the number of time fields found. The real
     * magic here occurs in VARIANT_MakeDate() above, where we determine what
     * each date number must represent in the context of iDate.
     */
    TRACE("0x%08x\n", TIMEFLAG(0)|TIMEFLAG(1)|TIMEFLAG(2)|TIMEFLAG(3)|TIMEFLAG(4));

    switch (TIMEFLAG(0)|TIMEFLAG(1)|TIMEFLAG(2)|TIMEFLAG(3)|TIMEFLAG(4))
    {
    case 0x1: /* TT TTDD TTDDD */
      if (dp.dwCount > 3 &&
          ((dp.dwFlags[2] & (DP_AM|DP_PM)) || (dp.dwFlags[3] & (DP_AM|DP_PM)) ||
          (dp.dwFlags[4] & (DP_AM|DP_PM))))
        hRet = DISP_E_TYPEMISMATCH;
      else if (dp.dwCount != 2 && dp.dwCount != 4 && dp.dwCount != 5)
        hRet = DISP_E_TYPEMISMATCH;
      st.wHour = dp.dwValues[0];
      st.wMinute  = dp.dwValues[1];
      dp.dwCount -= 2;
      dwOffset = 2;
      break;

    case 0x3: /* TTT TTTDD TTTDDD */
      if (dp.dwCount > 4 &&
          ((dp.dwFlags[3] & (DP_AM|DP_PM)) || (dp.dwFlags[4] & (DP_AM|DP_PM)) ||
          (dp.dwFlags[5] & (DP_AM|DP_PM))))
        hRet = DISP_E_TYPEMISMATCH;
      else if (dp.dwCount != 3 && dp.dwCount != 5 && dp.dwCount != 6)
        hRet = DISP_E_TYPEMISMATCH;
      st.wHour   = dp.dwValues[0];
      st.wMinute = dp.dwValues[1];
      st.wSecond = dp.dwValues[2];
      dwOffset = 3;
      dp.dwCount -= 3;
      break;

    case 0x4: /* DDTT */
      if (dp.dwCount != 4 ||
          (dp.dwFlags[0] & (DP_AM|DP_PM)) || (dp.dwFlags[1] & (DP_AM|DP_PM)))
        hRet = DISP_E_TYPEMISMATCH;

      st.wHour = dp.dwValues[2];
      st.wMinute  = dp.dwValues[3];
      dp.dwCount -= 2;
      break;

   case 0x0: /* T DD DDD TDDD TDDD */
      if (dp.dwCount == 1 && (dp.dwParseFlags & (DP_AM|DP_PM)))
      {
        st.wHour = dp.dwValues[0]; /* T */
        dp.dwCount = 0;
        break;
      }
      else if (dp.dwCount > 4 || (dp.dwCount < 3 && dp.dwParseFlags & (DP_AM|DP_PM)))
      {
        hRet = DISP_E_TYPEMISMATCH;
      }
      else if (dp.dwCount == 3)
      {
        if (dp.dwFlags[0] & (DP_AM|DP_PM)) /* TDD */
        {
          dp.dwCount = 2;
          st.wHour = dp.dwValues[0];
          dwOffset = 1;
          break;
        }
        if (dp.dwFlags[2] & (DP_AM|DP_PM)) /* DDT */
        {
          dp.dwCount = 2;
          st.wHour = dp.dwValues[2];
          break;
        }
        else if (dp.dwParseFlags & (DP_AM|DP_PM))
          hRet = DISP_E_TYPEMISMATCH;
      }
      else if (dp.dwCount == 4)
      {
        dp.dwCount = 3;
        if (dp.dwFlags[0] & (DP_AM|DP_PM)) /* TDDD */
        {
          st.wHour = dp.dwValues[0];
          dwOffset = 1;
        }
        else if (dp.dwFlags[3] & (DP_AM|DP_PM)) /* DDDT */
        {
          st.wHour = dp.dwValues[3];
        }
        else
          hRet = DISP_E_TYPEMISMATCH;
        break;
      }
      /* .. fall through .. */

    case 0x8: /* DDDTT */
      if ((dp.dwCount == 2 && (dp.dwParseFlags & (DP_AM|DP_PM))) ||
          (dp.dwCount == 5 && ((dp.dwFlags[0] & (DP_AM|DP_PM)) ||
           (dp.dwFlags[1] & (DP_AM|DP_PM)) || (dp.dwFlags[2] & (DP_AM|DP_PM)))) ||
           dp.dwCount == 4 || dp.dwCount == 6)
        hRet = DISP_E_TYPEMISMATCH;
      st.wHour   = dp.dwValues[3];
      st.wMinute = dp.dwValues[4];
      if (dp.dwCount == 5)
        dp.dwCount -= 2;
      break;

    case 0xC: /* DDTTT */
      if (dp.dwCount != 5 ||
          (dp.dwFlags[0] & (DP_AM|DP_PM)) || (dp.dwFlags[1] & (DP_AM|DP_PM)))
        hRet = DISP_E_TYPEMISMATCH;
      st.wHour   = dp.dwValues[2];
      st.wMinute = dp.dwValues[3];
      st.wSecond = dp.dwValues[4];
      dp.dwCount -= 3;
      break;

    case 0x18: /* DDDTTT */
      if ((dp.dwFlags[0] & (DP_AM|DP_PM)) || (dp.dwFlags[1] & (DP_AM|DP_PM)) ||
          (dp.dwFlags[2] & (DP_AM|DP_PM)))
        hRet = DISP_E_TYPEMISMATCH;
      st.wHour   = dp.dwValues[3];
      st.wMinute = dp.dwValues[4];
      st.wSecond = dp.dwValues[5];
      dp.dwCount -= 3;
      break;

    default:
      hRet = DISP_E_TYPEMISMATCH;
      break;
    }

    if (SUCCEEDED(hRet))
    {
      hRet = VARIANT_MakeDate(&dp, iDate, dwOffset, &st);

      if (dwFlags & VAR_TIMEVALUEONLY)
      {
        st.wYear = 1899;
        st.wMonth = 12;
        st.wDay = 30;
      }
      else if (dwFlags & VAR_DATEVALUEONLY)
       st.wHour = st.wMinute = st.wSecond = 0;

      /* Finally, convert the value to a VT_DATE */
      if (SUCCEEDED(hRet))
        hRet = SystemTimeToVariantTime(&st, pdateOut) ? S_OK : DISP_E_TYPEMISMATCH;
    }
  }

  for (i = 0; i < ARRAY_SIZE(tokens); i++)
    SysFreeString(tokens[i]);
  return hRet;
}

Referenced by test_VarDateFromStr(), and VARIANT_Coerce().

VarDateFromUI1()

HRESULT WINAPI VarDateFromUI1	(	BYTE	bIn,
		DATE *	pdateOut
	)

Definition at line 7224 of file vartype.c.

{
  return VarR8FromUI1(bIn, pdateOut);
}

Referenced by test_VarDateFromUI1(), and VARIANT_Coerce().

VarDateFromUI2()

HRESULT WINAPI VarDateFromUI2	(	USHORT	uiIn,
		DATE *	pdateOut
	)

Definition at line 7971 of file vartype.c.

{
  return VarR8FromUI2(uiIn, pdateOut);
}

Referenced by test_VarDateFromUI2(), and VARIANT_Coerce().

VarDateFromUI4()

HRESULT WINAPI VarDateFromUI4	(	ULONG	ulIn,
		DATE *	pdateOut
	)

Definition at line 7988 of file vartype.c.

{
  return VarDateFromR8(ulIn, pdateOut);
}

Referenced by test_VarDateFromUI4(), and VARIANT_Coerce().

VarDateFromUI8()

HRESULT WINAPI VarDateFromUI8	(	ULONG64	ullIn,
		DATE *	pdateOut
	)

Definition at line 8043 of file vartype.c.

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

Referenced by test_VarDateFromUI8(), and VARIANT_Coerce().

VarDecAbs()

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

Definition at line 5698 of file vartype.c.

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

Referenced by test_VarDecAbs().

VarDecAdd()

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

Definition at line 4588 of file vartype.c.

{
  HRESULT hRet;
  DECIMAL scaled[2];

  hRet = VARIANT_DecScale(&pDecLeft, &pDecRight, scaled);

  if (SUCCEEDED(hRet))
  {
    /* Our decimals now have the same scale, we can add them as 96 bit integers */
    ULONG overflow = 0;
    BYTE sign = DECIMAL_POS;
    int cmp;

    /* Correct for the sign of the result */
    if (DEC_SIGN(pDecLeft) && DEC_SIGN(pDecRight))
    {
      /* -x + -y : Negative */
      sign = DECIMAL_NEG;
      goto VarDecAdd_AsPositive;
    }
    else if (DEC_SIGN(pDecLeft) && !DEC_SIGN(pDecRight))
    {
      cmp = VARIANT_DecCmp(pDecLeft, pDecRight);

      /* -x + y : Negative if x > y */
      if (cmp > 0)
      {
        sign = DECIMAL_NEG;
VarDecAdd_AsNegative:
        DEC_LO32(pDecOut)  = VARIANT_Sub(DEC_LO32(pDecLeft),  DEC_LO32(pDecRight),  &overflow);
        DEC_MID32(pDecOut) = VARIANT_Sub(DEC_MID32(pDecLeft), DEC_MID32(pDecRight), &overflow);
        DEC_HI32(pDecOut)  = VARIANT_Sub(DEC_HI32(pDecLeft),  DEC_HI32(pDecRight),  &overflow);
      }
      else
      {
VarDecAdd_AsInvertedNegative:
        DEC_LO32(pDecOut)  = VARIANT_Sub(DEC_LO32(pDecRight),  DEC_LO32(pDecLeft),  &overflow);
        DEC_MID32(pDecOut) = VARIANT_Sub(DEC_MID32(pDecRight), DEC_MID32(pDecLeft), &overflow);
        DEC_HI32(pDecOut)  = VARIANT_Sub(DEC_HI32(pDecRight),  DEC_HI32(pDecLeft),  &overflow);
      }
    }
    else if (!DEC_SIGN(pDecLeft) && DEC_SIGN(pDecRight))
    {
      cmp = VARIANT_DecCmp(pDecLeft, pDecRight);

      /* x + -y : Negative if x <= y */
      if (cmp <= 0)
      {
        sign = DECIMAL_NEG;
        goto VarDecAdd_AsInvertedNegative;
      }
      goto VarDecAdd_AsNegative;
    }
    else
    {
      /* x + y : Positive */
VarDecAdd_AsPositive:
      DEC_LO32(pDecOut)  = VARIANT_Add(DEC_LO32(pDecLeft),  DEC_LO32(pDecRight),  &overflow);
      DEC_MID32(pDecOut) = VARIANT_Add(DEC_MID32(pDecLeft), DEC_MID32(pDecRight), &overflow);
      DEC_HI32(pDecOut)  = VARIANT_Add(DEC_HI32(pDecLeft),  DEC_HI32(pDecRight),  &overflow);
    }

    if (overflow)
      return DISP_E_OVERFLOW; /* overflowed */

    DEC_SCALE(pDecOut) = DEC_SCALE(pDecLeft);
    DEC_SIGN(pDecOut) = sign;
  }
  return hRet;
}

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

VarDecCmp()

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

Definition at line 5866 of file vartype.c.

{
  HRESULT hRet;
  DECIMAL result;

  if (!pDecLeft || !pDecRight)
    return VARCMP_NULL;

  if ((!(DEC_SIGN(pDecLeft) & DECIMAL_NEG)) && (DEC_SIGN(pDecRight) & DECIMAL_NEG) &&
      (DEC_HI32(pDecLeft) | DEC_MID32(pDecLeft) | DEC_LO32(pDecLeft)))
    return VARCMP_GT;
  else if ((DEC_SIGN(pDecLeft) & DECIMAL_NEG) && (!(DEC_SIGN(pDecRight) & DECIMAL_NEG)) &&
      (DEC_HI32(pDecLeft) | DEC_MID32(pDecLeft) | DEC_LO32(pDecLeft)))
    return VARCMP_LT;

  /* Subtract right from left, and compare the result to 0 */
  hRet = VarDecSub(pDecLeft, pDecRight, &result);

  if (SUCCEEDED(hRet))
  {
    int non_zero = DEC_HI32(&result) | DEC_MID32(&result) | DEC_LO32(&result);

    if ((DEC_SIGN(&result) & DECIMAL_NEG) && non_zero)
      hRet = (HRESULT)VARCMP_LT;
    else if (non_zero)
      hRet = (HRESULT)VARCMP_GT;
    else
      hRet = (HRESULT)VARCMP_EQ;
  }
  return hRet;
}

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

VarDecCmpR8()

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

Definition at line 5912 of file vartype.c.

{
  HRESULT hRet;
  DECIMAL decRight;

  hRet = VarDecFromR8(dblRight, &decRight);

  if (SUCCEEDED(hRet))
    hRet = VarDecCmp(pDecLeft, &decRight);

  return hRet;
}

Referenced by test_VarDecCmpR8().

VarDecDiv()

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

Definition at line 5601 of file vartype.c.

{
  if (!pDecLeft || !pDecRight || !pDecOut) return E_INVALIDARG;

  return VARIANT_do_division(pDecLeft, pDecRight, pDecOut, FALSE);
}

Referenced by test_VarDecDiv(), and VarDiv().

VarDecFix()

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

Definition at line 5722 of file vartype.c.

{
  double dbl;
  HRESULT hr;

  if (DEC_SIGN(pDecIn) & ~DECIMAL_NEG)
    return E_INVALIDARG;

  if (!DEC_SCALE(pDecIn))
  {
    *pDecOut = *pDecIn; /* Already an integer */
    return S_OK;
  }

  hr = VarR8FromDec(pDecIn, &dbl);
  if (SUCCEEDED(hr)) {
    LONGLONG rounded = dbl;

    hr = VarDecFromI8(rounded, pDecOut);
  }
  return hr;
}

Referenced by VarDecInt(), and VarFix().

VarDecFromBool()

HRESULT WINAPI VarDecFromBool	(	VARIANT_BOOL	bIn,
		DECIMAL *	pDecOut
	)

Definition at line 4312 of file vartype.c.

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

Referenced by test_VarDecFromBool().

VarDecFromCy()

HRESULT WINAPI VarDecFromCy	(	CY	cyIn,
		DECIMAL *	pDecOut
	)

Definition at line 4239 of file vartype.c.

{
  DEC_HI32(pDecOut) = 0;

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

Referenced by test_VarDecFromCy(), and VARIANT_Coerce().

VarDecFromDate()

HRESULT WINAPI VarDecFromDate	(	DATE	dateIn,
		DECIMAL *	pDecOut
	)

Definition at line 4222 of file vartype.c.

{
  return VarDecFromR8(dateIn, pDecOut);
}

Referenced by test_VarDecFromDate(), and VARIANT_Coerce().

VarDecFromDisp()

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

Definition at line 4292 of file vartype.c.

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

Referenced by VARIANT_Coerce().

VarDecFromI1()

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

Definition at line 4341 of file vartype.c.

{
  return VarDecFromI4(cIn, pDecOut);
}

Referenced by test_VarDecFromI1(), and VARIANT_Coerce().

VarDecFromI2()

HRESULT WINAPI VarDecFromI2	(	SHORT	sIn,
		DECIMAL *	pDecOut
	)

Definition at line 4114 of file vartype.c.

{
  return VarDecFromI4(sIn, pDecOut);
}