Back to home page

Wine source
 
 

    

File indexing completed on 2021-07-20 23:34:05 

0799c1a78… Alex*0001 /*
                0002  * Copyright (C) the Wine project
                0003  *
                0004  * This library is free software; you can redistribute it and/or
                0005  * modify it under the terms of the GNU Lesser General Public
                0006  * License as published by the Free Software Foundation; either
                0007  * version 2.1 of the License, or (at your option) any later version.
                0008  *
                0009  * This library is distributed in the hope that it will be useful,
                0010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
                0011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
                0012  * Lesser General Public License for more details.
                0013  *
                0014  * You should have received a copy of the GNU Lesser General Public
                0015  * License along with this library; if not, write to the Free Software
360a3f914… Jona*0016  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
0799c1a78… Alex*0017  */
                0018 
46ea8b3f7… Alex*0019 #ifndef __WINE_OLEAUTO_H
                0020 #define __WINE_OLEAUTO_H
                0021 
53f9c21fb… Dimi*0022 #include <oaidl.h>
4405f3c36… Mich*0023 
975feaf0e… Adri*0024 #ifdef __cplusplus
                0025 extern "C" {
42c803630… Niko*0026 #endif
975feaf0e… Adri*0027 
008f4ce91… Ove *0028 DEFINE_OLEGUID(IID_StdOle, 0x00020430,0,0);
                0029 
2f558b53f… Jon *0030 #define STDOLE_MAJORVERNUM  1
                0031 #define STDOLE_MINORVERNUM  0
                0032 #define STDOLE_LCID         0
                0033 
                0034 #define STDOLE2_MAJORVERNUM 2
                0035 #define STDOLE2_MINORVERNUM 0
                0036 #define STDOLE2_LCID        0
9e23b509a… Fran*0037 
2f558b53f… Jon *0038 ULONG WINAPI OaBuildVersion(void);
                0039 
                0040 /* BSTR functions */
dfc0f5ec8… Fran*0041 BSTR WINAPI SysAllocString(const OLECHAR*);
529779cf4… Fran*0042 BSTR WINAPI SysAllocStringByteLen(LPCSTR,UINT);
9e23b509a… Fran*0043 BSTR WINAPI SysAllocStringLen(const OLECHAR*,UINT);
                0044 void WINAPI SysFreeString(BSTR);
                0045 INT  WINAPI SysReAllocString(LPBSTR,const OLECHAR*);
                0046 int  WINAPI SysReAllocStringLen(BSTR*,const OLECHAR*,UINT);
4932f5606… Mart*0047 UINT WINAPI SysStringByteLen(BSTR);
                0048 UINT WINAPI SysStringLen(BSTR);
9e23b509a… Fran*0049 
2f558b53f… Jon *0050 /* IErrorInfo helpers */
58422dc83… Jon *0051 HRESULT WINAPI SetErrorInfo(ULONG,IErrorInfo*);
                0052 HRESULT WINAPI GetErrorInfo(ULONG,IErrorInfo**);
                0053 HRESULT WINAPI CreateErrorInfo(ICreateErrorInfo**);
a9855b512… Patr*0054 
2f558b53f… Jon *0055 /* SafeArray functions */
58422dc83… Jon *0056 SAFEARRAY* WINAPI SafeArrayCreate(VARTYPE,UINT,SAFEARRAYBOUND*);
                0057 SAFEARRAY* WINAPI SafeArrayCreateEx(VARTYPE,UINT,SAFEARRAYBOUND*,LPVOID);
                0058 SAFEARRAY* WINAPI SafeArrayCreateVector(VARTYPE,LONG,ULONG);
                0059 SAFEARRAY* WINAPI SafeArrayCreateVectorEx(VARTYPE,LONG,ULONG,LPVOID);
                0060 
                0061 HRESULT WINAPI SafeArrayAllocDescriptor(UINT,SAFEARRAY**);
                0062 HRESULT WINAPI SafeArrayAllocDescriptorEx(VARTYPE,UINT,SAFEARRAY**);
                0063 HRESULT WINAPI SafeArrayAllocData(SAFEARRAY*);
                0064 HRESULT WINAPI SafeArrayDestroyDescriptor(SAFEARRAY*);
                0065 HRESULT WINAPI SafeArrayPutElement(SAFEARRAY*,LONG*,void*);
                0066 HRESULT WINAPI SafeArrayGetElement(SAFEARRAY*,LONG*,void*);
                0067 HRESULT WINAPI SafeArrayLock(SAFEARRAY*);
                0068 HRESULT WINAPI SafeArrayUnlock(SAFEARRAY*);
                0069 HRESULT WINAPI SafeArrayGetUBound(SAFEARRAY*,UINT,LONG*);
                0070 HRESULT WINAPI SafeArrayGetLBound(SAFEARRAY*,UINT,LONG*);
                0071 UINT    WINAPI SafeArrayGetDim(SAFEARRAY*);
                0072 UINT    WINAPI SafeArrayGetElemsize(SAFEARRAY*);
                0073 HRESULT WINAPI SafeArrayGetVartype(SAFEARRAY*,VARTYPE*);
                0074 HRESULT WINAPI SafeArrayAccessData(SAFEARRAY*,void**);
                0075 HRESULT WINAPI SafeArrayUnaccessData(SAFEARRAY*);
                0076 HRESULT WINAPI SafeArrayPtrOfIndex(SAFEARRAY*,LONG*,void **);
                0077 HRESULT WINAPI SafeArrayCopyData(SAFEARRAY*,SAFEARRAY*);
                0078 HRESULT WINAPI SafeArrayDestroyData(SAFEARRAY*);
                0079 HRESULT WINAPI SafeArrayDestroy(SAFEARRAY*);
                0080 HRESULT WINAPI SafeArrayCopy(SAFEARRAY*,SAFEARRAY**);
                0081 HRESULT WINAPI SafeArrayRedim(SAFEARRAY*,SAFEARRAYBOUND*);
                0082 HRESULT WINAPI SafeArraySetRecordInfo(SAFEARRAY*,IRecordInfo*);
                0083 HRESULT WINAPI SafeArrayGetRecordInfo(SAFEARRAY*,IRecordInfo**);
                0084 HRESULT WINAPI SafeArraySetIID(SAFEARRAY*,REFGUID);
                0085 HRESULT WINAPI SafeArrayGetIID(SAFEARRAY*,GUID*);
b00cbeadb… Jean*0086 
2f558b53f… Jon *0087 HRESULT WINAPI VectorFromBstr(BSTR,SAFEARRAY**);
                0088 HRESULT WINAPI BstrFromVector(SAFEARRAY*,BSTR*);
                0089 
                0090 /* Object registration helpers */
                0091 #define ACTIVEOBJECT_STRONG 0
                0092 #define ACTIVEOBJECT_WEAK   1
                0093 
                0094 HRESULT WINAPI RegisterActiveObject(LPUNKNOWN,REFCLSID,DWORD,LPDWORD);
                0095 HRESULT WINAPI RevokeActiveObject(DWORD,LPVOID);
                0096 HRESULT WINAPI GetActiveObject(REFCLSID,LPVOID,LPUNKNOWN*);
                0097 
                0098 /* IRecordInfo helpers */
                0099 HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo*,IRecordInfo**);
                0100 HRESULT WINAPI GetRecordInfoFromGuids(REFGUID,ULONG,ULONG,LCID,REFGUID,IRecordInfo**);
                0101 
                0102 /*
                0103  * Variants
b00cbeadb… Jean*0104  */
2f558b53f… Jon *0105 
                0106 /* Macros for accessing the fields of the VARIANT type */
9947b68c3… Fran*0107 #if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION)
be3fea546… Fran*0108 #define V_VT(A)         ((A)->n1.n2.vt)
                0109 #define V_UNION(A,B)    ((A)->n1.n2.n3.B)
                0110 #define V_RECORD(A)     (V_UNION(A,brecVal).pvRecord)
                0111 #define V_RECORDINFO(A) (V_UNION(A,brecVal).pRecInfo)
89b21b4c2… Paul*0112 #else
be3fea546… Fran*0113 #define V_VT(A)         ((A)->vt)
                0114 #define V_UNION(A,B)    ((A)->B)
                0115 #define V_RECORD(A)     ((A)->pvRecord)
                0116 #define V_RECORDINFO(A) ((A)->pRecInfo)
2f558b53f… Jon *0117 #endif
                0118 
                0119 #define V_ISBYREF(A)  (V_VT(A) & VT_BYREF)
                0120 #define V_ISARRAY(A)  (V_VT(A) & VT_ARRAY)
                0121 #define V_ISVECTOR(A) (V_VT(A) & VT_VECTOR)
                0122 #define V_NONE(A)     V_I2(A)
                0123 
                0124 #define V_ARRAY(A)       V_UNION(A,parray)
                0125 #define V_ARRAYREF(A)    V_UNION(A,pparray)
                0126 #define V_BOOL(A)        V_UNION(A,boolVal)
                0127 #define V_BOOLREF(A)     V_UNION(A,pboolVal)
                0128 #define V_BSTR(A)        V_UNION(A,bstrVal)
                0129 #define V_BSTRREF(A)     V_UNION(A,pbstrVal)
                0130 #define V_BYREF(A)       V_UNION(A,byref)
                0131 #define V_CY(A)          V_UNION(A,cyVal)
                0132 #define V_CYREF(A)       V_UNION(A,pcyVal)
                0133 #define V_DATE(A)        V_UNION(A,date)
                0134 #define V_DATEREF(A)     V_UNION(A,pdate)
421660e89… Greg*0135 #if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION)
2f558b53f… Jon *0136 #define V_DECIMAL(A)     ((A)->n1.decVal)
421660e89… Greg*0137 #else
2f558b53f… Jon *0138 #define V_DECIMAL(A)     ((A)->decVal)
421660e89… Greg*0139 #endif
2f558b53f… Jon *0140 #define V_DECIMALREF(A)  V_UNION(A,pdecVal)
                0141 #define V_DISPATCH(A)    V_UNION(A,pdispVal)
                0142 #define V_DISPATCHREF(A) V_UNION(A,ppdispVal)
                0143 #define V_ERROR(A)       V_UNION(A,scode)
                0144 #define V_ERRORREF(A)    V_UNION(A,pscode)
                0145 #define V_I1(A)          V_UNION(A,cVal)
                0146 #define V_I1REF(A)       V_UNION(A,pcVal)
                0147 #define V_I2(A)          V_UNION(A,iVal)
                0148 #define V_I2REF(A)       V_UNION(A,piVal)
                0149 #define V_I4(A)          V_UNION(A,lVal)
                0150 #define V_I4REF(A)       V_UNION(A,plVal)
                0151 #define V_I8(A)          V_UNION(A,llVal)
                0152 #define V_I8REF(A)       V_UNION(A,pllVal)
                0153 #define V_INT(A)         V_UNION(A,intVal)
                0154 #define V_INTREF(A)      V_UNION(A,pintVal)
                0155 #ifdef _WIN64
                0156 #define V_INT_PTR(A)     V_I8(A)
                0157 #define V_INT_PTRREF(A)  V_I8REF(A)
                0158 #else
                0159 #define V_INT_PTR(A)     V_I4(A)
                0160 #define V_INT_PTRREF(A)  V_I4REF(A)
                0161 #endif
                0162 #define V_R4(A)          V_UNION(A,fltVal)
                0163 #define V_R4REF(A)       V_UNION(A,pfltVal)
                0164 #define V_R8(A)          V_UNION(A,dblVal)
                0165 #define V_R8REF(A)       V_UNION(A,pdblVal)
                0166 #define V_UINT(A)        V_UNION(A,uintVal)
                0167 #define V_UINTREF(A)     V_UNION(A,puintVal)
                0168 #define V_UI1(A)         V_UNION(A,bVal)
                0169 #define V_UI1REF(A)      V_UNION(A,pbVal)
                0170 #define V_UI2(A)         V_UNION(A,uiVal)
                0171 #define V_UI2REF(A)      V_UNION(A,puiVal)
                0172 #define V_UI4(A)         V_UNION(A,ulVal)
                0173 #define V_UI4REF(A)      V_UNION(A,pulVal)
                0174 #define V_UI8(A)         V_UNION(A,ullVal)
                0175 #define V_UI8REF(A)      V_UNION(A,pullVal)
                0176 #ifdef _WIN64
                0177 #define V_UINT_PTR(A)    V_UI8(A)
                0178 #define V_UINT_PTRREF(A) V_UI8REF(A)
                0179 #else
                0180 #define V_UINT_PTR(A)    V_UI4(A)
                0181 #define V_UINT_PTRREF(A) V_UI4REF(A)
                0182 #endif
                0183 #define V_UNKNOWN(A)     V_UNION(A,punkVal)
                0184 #define V_UNKNOWNREF(A)  V_UNION(A,ppunkVal)
                0185 #define V_VARIANTREF(A)  V_UNION(A,pvarVal)
b00cbeadb… Jean*0186 
58422dc83… Jon *0187 void    WINAPI VariantInit(VARIANT*);
                0188 HRESULT WINAPI VariantClear(VARIANT*);
a55f4f9fc… Niko*0189 HRESULT WINAPI VariantCopy(VARIANTARG *dst, const VARIANTARG *src);
                0190 HRESULT WINAPI VariantCopyInd(VARIANT *dst, const VARIANTARG *src);
25ec9d4c3… Niko*0191 HRESULT WINAPI VariantChangeType(VARIANTARG *dst, const VARIANTARG *src, USHORT flags, VARTYPE vt);
                0192 HRESULT WINAPI VariantChangeTypeEx(VARIANTARG *dst, const VARIANTARG *src, LCID lcid, USHORT flags, VARTYPE vt);
b00cbeadb… Jean*0193 
2f558b53f… Jon *0194 /* VariantChangeType/VariantChangeTypeEx flags */
                0195 #define VARIANT_NOVALUEPROP        0x01 /* Don't get the default value property from IDispatch */
                0196 #define VARIANT_ALPHABOOL          0x02 /* Coerce to "True"|"False" instead of "-1"|"0" */
                0197 #define VARIANT_NOUSEROVERRIDE     0x04 /* Pass LOCALE_NOUSEROVERRIDE to low level conversions */
                0198 #define VARIANT_CALENDAR_HIJRI     0x08 /* Use the Hijri calendar */
                0199 #define VARIANT_LOCALBOOL          0x10 /* Like VARIANT_ALPHABOOL, but use localised text */
                0200 #define VARIANT_CALENDAR_THAI      0x20 /* Use the Thai buddhist calendar */
                0201 #define VARIANT_CALENDAR_GREGORIAN 0x40 /* Use the Gregorian calendar */
                0202 #define VARIANT_USE_NLS            0x80 /* Format result using NLS calls */
b00cbeadb… Jean*0203 
                0204 /*
2f558b53f… Jon *0205  * Low level Variant coercion functions
b00cbeadb… Jean*0206  */
                0207 
2f558b53f… Jon *0208 #define VT_HARDTYPE VT_RESERVED /* Don't coerce this variant when comparing it to others */
                0209 
                0210 /* Flags for low level coercions. LOCALE_ flags can also be passed */
                0211 #define VAR_TIMEVALUEONLY       0x001 /* Ignore date portion of VT_DATE */
                0212 #define VAR_DATEVALUEONLY       0x002 /* Ignore time portion of VT_DATE */
                0213 #define VAR_VALIDDATE           0x004
87b090678… Fran*0214 #define VAR_CALENDAR_HIJRI      0x008 /* Use the Hijri calendar */
2f558b53f… Jon *0215 #define VAR_LOCALBOOL           0x010 /* VT_BOOL<->VT_BSTR: Use localised boolean text */
                0216 #define VAR_FORMAT_NOSUBSTITUTE 0x020 /* Don't change format strings for un-coercable types */
                0217 #define VAR_FOURDIGITYEARS      0x040 /* Always print years with 4 digits */
                0218 #define VAR_CALENDAR_THAI       0x080 /* Use the Thai buddhist calendar */
                0219 #define VAR_CALENDAR_GREGORIAN  0x100 /* Use the Gregorian calendar */
                0220 
                0221 #ifndef LOCALE_USE_NLS
                0222 /* This is missing from native winnls.h, but may be added at some point */
                0223 #define LOCALE_USE_NLS          0x10000000
                0224 #endif
b00cbeadb… Jean*0225 
2f558b53f… Jon *0226 #define VTDATEGRE_MIN -657434 /* Minimum possible Gregorian date: 1/1/100 */
                0227 #define VTDATEGRE_MAX 2958465 /* Maximum possible Gregorian date: 31/12/9999 */
b00cbeadb… Jean*0228 
58422dc83… Jon *0229 HRESULT WINAPI VarUI1FromI2(SHORT,BYTE*);
                0230 HRESULT WINAPI VarUI1FromI4(LONG,BYTE*);
                0231 HRESULT WINAPI VarUI1FromI8(LONG64,BYTE*);
                0232 HRESULT WINAPI VarUI1FromR4(FLOAT,BYTE*);
                0233 HRESULT WINAPI VarUI1FromR8(DOUBLE,BYTE*);
                0234 HRESULT WINAPI VarUI1FromDate(DATE,BYTE*);
                0235 HRESULT WINAPI VarUI1FromBool(VARIANT_BOOL,BYTE*);
                0236 HRESULT WINAPI VarUI1FromI1(signed char,BYTE*);
                0237 HRESULT WINAPI VarUI1FromUI2(USHORT,BYTE*);
                0238 HRESULT WINAPI VarUI1FromUI4(ULONG,BYTE*);
                0239 HRESULT WINAPI VarUI1FromUI8(ULONG64,BYTE*);
1e627d118… Fran*0240 HRESULT WINAPI VarUI1FromStr(const OLECHAR*,LCID,ULONG,BYTE*);
58422dc83… Jon *0241 HRESULT WINAPI VarUI1FromCy(CY,BYTE*);
02d29c6a9… Niko*0242 HRESULT WINAPI VarUI1FromDec(const DECIMAL*,BYTE*);
58422dc83… Jon *0243 HRESULT WINAPI VarUI1FromDisp(IDispatch*,LCID,BYTE*);
                0244 
                0245 HRESULT WINAPI VarI2FromUI1(BYTE,SHORT*);
                0246 HRESULT WINAPI VarI2FromI4(LONG,SHORT*);
                0247 HRESULT WINAPI VarI2FromI8(LONG64,SHORT*);
                0248 HRESULT WINAPI VarI2FromR4(FLOAT,SHORT*);
                0249 HRESULT WINAPI VarI2FromR8(DOUBLE,SHORT*);
                0250 HRESULT WINAPI VarI2FromDate(DATE,SHORT*);
                0251 HRESULT WINAPI VarI2FromBool(VARIANT_BOOL,SHORT*);
                0252 HRESULT WINAPI VarI2FromI1(signed char,SHORT*);
                0253 HRESULT WINAPI VarI2FromUI2(USHORT,SHORT*);
                0254 HRESULT WINAPI VarI2FromUI4(ULONG,SHORT*);
                0255 HRESULT WINAPI VarI2FromUI8(ULONG64,SHORT*);
1e627d118… Fran*0256 HRESULT WINAPI VarI2FromStr(const OLECHAR*,LCID,ULONG,SHORT*);
58422dc83… Jon *0257 HRESULT WINAPI VarI2FromCy(CY,SHORT*);
02d29c6a9… Niko*0258 HRESULT WINAPI VarI2FromDec(const DECIMAL*,SHORT*);
58422dc83… Jon *0259 HRESULT WINAPI VarI2FromDisp(IDispatch*,LCID,SHORT*);
                0260 
                0261 HRESULT WINAPI VarI4FromUI1(BYTE,LONG*);
                0262 HRESULT WINAPI VarI4FromI2(SHORT,LONG*);
                0263 HRESULT WINAPI VarI4FromI8(LONG64,LONG*);
                0264 HRESULT WINAPI VarI4FromR4(FLOAT,LONG*);
                0265 HRESULT WINAPI VarI4FromR8(DOUBLE,LONG*);
                0266 HRESULT WINAPI VarI4FromDate(DATE,LONG*);
                0267 HRESULT WINAPI VarI4FromBool(VARIANT_BOOL,LONG*);
                0268 HRESULT WINAPI VarI4FromI1(signed char,LONG*);
                0269 HRESULT WINAPI VarI4FromUI2(USHORT,LONG*);
                0270 HRESULT WINAPI VarI4FromUI4(ULONG,LONG*);
                0271 HRESULT WINAPI VarI4FromUI8(ULONG64,LONG*);
1e627d118… Fran*0272 HRESULT WINAPI VarI4FromStr(const OLECHAR*,LCID,ULONG,LONG*);
58422dc83… Jon *0273 HRESULT WINAPI VarI4FromCy(CY,LONG*);
02d29c6a9… Niko*0274 HRESULT WINAPI VarI4FromDec(const DECIMAL*,LONG*);
58422dc83… Jon *0275 HRESULT WINAPI VarI4FromDisp(IDispatch*,LCID,LONG*);
                0276 
                0277 HRESULT WINAPI VarI8FromUI1(BYTE,LONG64*);
                0278 HRESULT WINAPI VarI8FromI2(SHORT,LONG64*);
                0279 HRESULT WINAPI VarI8FromI4(LONG,LONG64*);
                0280 HRESULT WINAPI VarI8FromR4(FLOAT,LONG64*);
                0281 HRESULT WINAPI VarI8FromR8(DOUBLE,LONG64*);
                0282 HRESULT WINAPI VarI8FromDate(DATE,LONG64*);
1e627d118… Fran*0283 HRESULT WINAPI VarI8FromStr(const OLECHAR*,LCID,ULONG,LONG64*);
58422dc83… Jon *0284 HRESULT WINAPI VarI8FromBool(VARIANT_BOOL,LONG64*);
                0285 HRESULT WINAPI VarI8FromI1(signed char,LONG64*);
                0286 HRESULT WINAPI VarI8FromUI2(USHORT,LONG64*);
                0287 HRESULT WINAPI VarI8FromUI4(ULONG,LONG64*);
                0288 HRESULT WINAPI VarI8FromUI8(ULONG64,LONG64*);
02d29c6a9… Niko*0289 HRESULT WINAPI VarI8FromDec(const DECIMAL *pdecIn,LONG64*);
58422dc83… Jon *0290 HRESULT WINAPI VarI8FromInt(INT intIn,LONG64*);
                0291 HRESULT WINAPI VarI8FromCy(CY,LONG64*);
                0292 HRESULT WINAPI VarI8FromDisp(IDispatch*,LCID,LONG64*);
                0293 
                0294 HRESULT WINAPI VarR4FromUI1(BYTE,FLOAT*);
                0295 HRESULT WINAPI VarR4FromI2(SHORT,FLOAT*);
                0296 HRESULT WINAPI VarR4FromI4(LONG,FLOAT*);
                0297 HRESULT WINAPI VarR4FromI8(LONG64,FLOAT*);
                0298 HRESULT WINAPI VarR4FromR8(DOUBLE,FLOAT*);
                0299 HRESULT WINAPI VarR4FromDate(DATE,FLOAT*);
                0300 HRESULT WINAPI VarR4FromBool(VARIANT_BOOL,FLOAT*);
                0301 HRESULT WINAPI VarR4FromI1(signed char,FLOAT*);
                0302 HRESULT WINAPI VarR4FromUI2(USHORT,FLOAT*);
                0303 HRESULT WINAPI VarR4FromUI4(ULONG,FLOAT*);
                0304 HRESULT WINAPI VarR4FromUI8(ULONG64,FLOAT*);
1e627d118… Fran*0305 HRESULT WINAPI VarR4FromStr(const OLECHAR*,LCID,ULONG,FLOAT*);
58422dc83… Jon *0306 HRESULT WINAPI VarR4FromCy(CY,FLOAT*);
02d29c6a9… Niko*0307 HRESULT WINAPI VarR4FromDec(const DECIMAL*,FLOAT*);
58422dc83… Jon *0308 HRESULT WINAPI VarR4FromDisp(IDispatch*,LCID,FLOAT*);
                0309 
                0310 HRESULT WINAPI VarR8FromUI1(BYTE,double*);
                0311 HRESULT WINAPI VarR8FromI2(SHORT,double*);
                0312 HRESULT WINAPI VarR8FromI4(LONG,double*);
                0313 HRESULT WINAPI VarR8FromI8(LONG64,double*);
                0314 HRESULT WINAPI VarR8FromR4(FLOAT,double*);
                0315 HRESULT WINAPI VarR8FromDate(DATE,double*);
                0316 HRESULT WINAPI VarR8FromBool(VARIANT_BOOL,double*);
                0317 HRESULT WINAPI VarR8FromI1(signed char,double*);
                0318 HRESULT WINAPI VarR8FromUI2(USHORT,double*);
                0319 HRESULT WINAPI VarR8FromUI4(ULONG,double*);
                0320 HRESULT WINAPI VarR8FromUI8(ULONG64,double*);
1e627d118… Fran*0321 HRESULT WINAPI VarR8FromStr(const OLECHAR*,LCID,ULONG,double*);
58422dc83… Jon *0322 HRESULT WINAPI VarR8FromCy(CY,double*);
d693dfda8… Juan*0323 HRESULT WINAPI VarR8FromDec(const DECIMAL*,double*);
58422dc83… Jon *0324 HRESULT WINAPI VarR8FromDisp(IDispatch*,LCID,double*);
                0325 
                0326 HRESULT WINAPI VarDateFromUI1(BYTE,DATE*);
                0327 HRESULT WINAPI VarDateFromI2(SHORT,DATE*);
                0328 HRESULT WINAPI VarDateFromI4(LONG,DATE*);
                0329 HRESULT WINAPI VarDateFromI8(LONG64,DATE*);
                0330 HRESULT WINAPI VarDateFromR4(FLOAT,DATE*);
                0331 HRESULT WINAPI VarDateFromR8(DOUBLE,DATE*);
1e627d118… Fran*0332 HRESULT WINAPI VarDateFromStr(const OLECHAR*,LCID,ULONG,DATE*);
58422dc83… Jon *0333 HRESULT WINAPI VarDateFromI1(signed char,DATE*);
                0334 HRESULT WINAPI VarDateFromUI2(USHORT,DATE*);
                0335 HRESULT WINAPI VarDateFromUI4(ULONG,DATE*);
                0336 HRESULT WINAPI VarDateFromUI8(ULONG64,DATE*);
                0337 HRESULT WINAPI VarDateFromBool(VARIANT_BOOL,DATE*);
                0338 HRESULT WINAPI VarDateFromCy(CY,DATE*);
02d29c6a9… Niko*0339 HRESULT WINAPI VarDateFromDec(const DECIMAL*,DATE*);
58422dc83… Jon *0340 HRESULT WINAPI VarDateFromDisp(IDispatch*,LCID,DATE*);
                0341 
                0342 HRESULT WINAPI VarCyFromUI1(BYTE,CY*);
                0343 HRESULT WINAPI VarCyFromI2(SHORT sIn,CY*);
                0344 HRESULT WINAPI VarCyFromI4(LONG,CY*);
                0345 HRESULT WINAPI VarCyFromI8(LONG64,CY*);
                0346 HRESULT WINAPI VarCyFromR4(FLOAT,CY*);
                0347 HRESULT WINAPI VarCyFromR8(DOUBLE,CY*);
                0348 HRESULT WINAPI VarCyFromDate(DATE,CY*);
1e627d118… Fran*0349 HRESULT WINAPI VarCyFromStr(const OLECHAR*,LCID,ULONG,CY*);
58422dc83… Jon *0350 HRESULT WINAPI VarCyFromBool(VARIANT_BOOL,CY*);
                0351 HRESULT WINAPI VarCyFromI1(signed char,CY*);
                0352 HRESULT WINAPI VarCyFromUI2(USHORT,CY*);
                0353 HRESULT WINAPI VarCyFromUI4(ULONG,CY*);
                0354 HRESULT WINAPI VarCyFromUI8(ULONG64,CY*);
02d29c6a9… Niko*0355 HRESULT WINAPI VarCyFromDec(const DECIMAL*,CY*);
58422dc83… Jon *0356 HRESULT WINAPI VarCyFromDisp(IDispatch*,LCID,CY*);
                0357 
                0358 HRESULT WINAPI VarBstrFromUI1(BYTE,LCID,ULONG,BSTR*);
                0359 HRESULT WINAPI VarBstrFromI2(SHORT,LCID,ULONG,BSTR*);
                0360 HRESULT WINAPI VarBstrFromI4(LONG,LCID,ULONG,BSTR*);
                0361 HRESULT WINAPI VarBstrFromI8(LONG64,LCID,ULONG,BSTR*);
                0362 HRESULT WINAPI VarBstrFromR4(FLOAT,LCID,ULONG,BSTR*);
                0363 HRESULT WINAPI VarBstrFromR8(DOUBLE,LCID,ULONG,BSTR*);
                0364 HRESULT WINAPI VarBstrFromDate(DATE,LCID,ULONG,BSTR*);
                0365 HRESULT WINAPI VarBstrFromBool(VARIANT_BOOL,LCID,ULONG,BSTR*);
                0366 HRESULT WINAPI VarBstrFromI1(signed char,LCID,ULONG,BSTR*);
                0367 HRESULT WINAPI VarBstrFromUI2(USHORT,LCID,ULONG,BSTR*);
                0368 HRESULT WINAPI VarBstrFromUI8(ULONG64,LCID,ULONG,BSTR*);
                0369 HRESULT WINAPI VarBstrFromUI4(ULONG,LCID,ULONG,BSTR*);
                0370 HRESULT WINAPI VarBstrFromCy(CY,LCID,ULONG,BSTR*);
02d29c6a9… Niko*0371 HRESULT WINAPI VarBstrFromDec(const DECIMAL*,LCID,ULONG,BSTR*);
58422dc83… Jon *0372 HRESULT WINAPI VarBstrFromDisp(IDispatch*,LCID,ULONG,BSTR*);
                0373 
                0374 HRESULT WINAPI VarBoolFromUI1(BYTE,VARIANT_BOOL*);
                0375 HRESULT WINAPI VarBoolFromI2(SHORT,VARIANT_BOOL*);
                0376 HRESULT WINAPI VarBoolFromI4(LONG,VARIANT_BOOL*);
                0377 HRESULT WINAPI VarBoolFromI8(LONG64,VARIANT_BOOL*);
                0378 HRESULT WINAPI VarBoolFromR4(FLOAT,VARIANT_BOOL*);
                0379 HRESULT WINAPI VarBoolFromR8(DOUBLE,VARIANT_BOOL*);
                0380 HRESULT WINAPI VarBoolFromDate(DATE,VARIANT_BOOL*);
1e627d118… Fran*0381 HRESULT WINAPI VarBoolFromStr(const OLECHAR*,LCID,ULONG,VARIANT_BOOL*);
58422dc83… Jon *0382 HRESULT WINAPI VarBoolFromI1(signed char,VARIANT_BOOL*);
                0383 HRESULT WINAPI VarBoolFromUI2(USHORT,VARIANT_BOOL*);
                0384 HRESULT WINAPI VarBoolFromUI4(ULONG,VARIANT_BOOL*);
                0385 HRESULT WINAPI VarBoolFromUI8(ULONG64,VARIANT_BOOL*);
                0386 HRESULT WINAPI VarBoolFromCy(CY,VARIANT_BOOL*);
02d29c6a9… Niko*0387 HRESULT WINAPI VarBoolFromDec(const DECIMAL*,VARIANT_BOOL*);
58422dc83… Jon *0388 HRESULT WINAPI VarBoolFromDisp(IDispatch*,LCID,VARIANT_BOOL*);
                0389 
                0390 HRESULT WINAPI VarI1FromUI1(BYTE,signed char*);
                0391 HRESULT WINAPI VarI1FromI2(SHORT,signed char*);
                0392 HRESULT WINAPI VarI1FromI4(LONG,signed char*);
                0393 HRESULT WINAPI VarI1FromI8(LONG64,signed char*);
                0394 HRESULT WINAPI VarI1FromR4(FLOAT,signed char*);
                0395 HRESULT WINAPI VarI1FromR8(DOUBLE,signed char*);
                0396 HRESULT WINAPI VarI1FromDate(DATE,signed char*);
1e627d118… Fran*0397 HRESULT WINAPI VarI1FromStr(const OLECHAR*,LCID,ULONG,signed char*);
58422dc83… Jon *0398 HRESULT WINAPI VarI1FromBool(VARIANT_BOOL,signed char*);
                0399 HRESULT WINAPI VarI1FromUI2(USHORT,signed char*);
                0400 HRESULT WINAPI VarI1FromUI4(ULONG,signed char*);
                0401 HRESULT WINAPI VarI1FromUI8(ULONG64,signed char*);
                0402 HRESULT WINAPI VarI1FromCy(CY,signed char*);
02d29c6a9… Niko*0403 HRESULT WINAPI VarI1FromDec(const DECIMAL*,signed char*);
58422dc83… Jon *0404 HRESULT WINAPI VarI1FromDisp(IDispatch*,LCID,signed char*);
                0405 
                0406 HRESULT WINAPI VarUI2FromUI1(BYTE,USHORT*);
                0407 HRESULT WINAPI VarUI2FromI2(SHORT,USHORT*);
                0408 HRESULT WINAPI VarUI2FromI4(LONG,USHORT*);
                0409 HRESULT WINAPI VarUI2FromI8(LONG64,USHORT*);
                0410 HRESULT WINAPI VarUI2FromR4(FLOAT,USHORT*);
                0411 HRESULT WINAPI VarUI2FromR8(DOUBLE,USHORT*);
                0412 HRESULT WINAPI VarUI2FromDate(DATE,USHORT*);
1e627d118… Fran*0413 HRESULT WINAPI VarUI2FromStr(const OLECHAR*,LCID,ULONG,USHORT*);
58422dc83… Jon *0414 HRESULT WINAPI VarUI2FromBool(VARIANT_BOOL,USHORT*);
                0415 HRESULT WINAPI VarUI2FromI1(signed char,USHORT*);
                0416 HRESULT WINAPI VarUI2FromUI4(ULONG,USHORT*);
                0417 HRESULT WINAPI VarUI2FromUI8(ULONG64,USHORT*);
                0418 HRESULT WINAPI VarUI2FromCy(CY,USHORT*);
02d29c6a9… Niko*0419 HRESULT WINAPI VarUI2FromDec(const DECIMAL*,USHORT*);
58422dc83… Jon *0420 HRESULT WINAPI VarUI2FromDisp(IDispatch*,LCID,USHORT*);
                0421 
1e627d118… Fran*0422 HRESULT WINAPI VarUI4FromStr(const OLECHAR*,LCID,ULONG,ULONG*);
58422dc83… Jon *0423 HRESULT WINAPI VarUI4FromUI1(BYTE,ULONG*);
                0424 HRESULT WINAPI VarUI4FromI2(SHORT,ULONG*);
                0425 HRESULT WINAPI VarUI4FromI4(LONG,ULONG*);
                0426 HRESULT WINAPI VarUI4FromI8(LONG64,ULONG*);
                0427 HRESULT WINAPI VarUI4FromR4(FLOAT,ULONG*);
                0428 HRESULT WINAPI VarUI4FromR8(DOUBLE,ULONG*);
                0429 HRESULT WINAPI VarUI4FromDate(DATE,ULONG*);
                0430 HRESULT WINAPI VarUI4FromBool(VARIANT_BOOL,ULONG*);
                0431 HRESULT WINAPI VarUI4FromI1(signed char,ULONG*);
                0432 HRESULT WINAPI VarUI4FromUI2(USHORT,ULONG*);
                0433 HRESULT WINAPI VarUI4FromUI8(ULONG64,ULONG*);
                0434 HRESULT WINAPI VarUI4FromCy(CY,ULONG*);
02d29c6a9… Niko*0435 HRESULT WINAPI VarUI4FromDec(const DECIMAL*,ULONG*);
58422dc83… Jon *0436 HRESULT WINAPI VarUI4FromDisp(IDispatch*,LCID,ULONG*);
                0437 
                0438 HRESULT WINAPI VarUI8FromUI1(BYTE,ULONG64*);
                0439 HRESULT WINAPI VarUI8FromI2(SHORT,ULONG64*);
                0440 HRESULT WINAPI VarUI8FromI4(LONG,ULONG64*);
                0441 HRESULT WINAPI VarUI8FromI8(LONG64,ULONG64*);
                0442 HRESULT WINAPI VarUI8FromR4(FLOAT,ULONG64*);
                0443 HRESULT WINAPI VarUI8FromR8(DOUBLE,ULONG64*);
                0444 HRESULT WINAPI VarUI8FromDate(DATE,ULONG64*);
1e627d118… Fran*0445 HRESULT WINAPI VarUI8FromStr(const OLECHAR*,LCID,ULONG,ULONG64*);
58422dc83… Jon *0446 HRESULT WINAPI VarUI8FromBool(VARIANT_BOOL,ULONG64*);
                0447 HRESULT WINAPI VarUI8FromI1(signed char,ULONG64*);
                0448 HRESULT WINAPI VarUI8FromUI2(USHORT,ULONG64*);
                0449 HRESULT WINAPI VarUI8FromUI4(ULONG,ULONG64*);
02d29c6a9… Niko*0450 HRESULT WINAPI VarUI8FromDec(const DECIMAL*,ULONG64*);
58422dc83… Jon *0451 HRESULT WINAPI VarUI8FromInt(INT,ULONG64*);
                0452 HRESULT WINAPI VarUI8FromCy(CY,ULONG64*);
                0453 HRESULT WINAPI VarUI8FromDisp(IDispatch*,LCID,ULONG64*);
                0454 
                0455 HRESULT WINAPI VarDecFromUI1(BYTE,DECIMAL*);
                0456 HRESULT WINAPI VarDecFromI2(SHORT,DECIMAL*);
                0457 HRESULT WINAPI VarDecFromI4(LONG,DECIMAL*);
                0458 HRESULT WINAPI VarDecFromI8(LONG64,DECIMAL*);
                0459 HRESULT WINAPI VarDecFromR4(FLOAT,DECIMAL*);
                0460 HRESULT WINAPI VarDecFromR8(DOUBLE,DECIMAL*);
                0461 HRESULT WINAPI VarDecFromDate(DATE,DECIMAL*);
1e627d118… Fran*0462 HRESULT WINAPI VarDecFromStr(const OLECHAR*,LCID,ULONG,DECIMAL*);
58422dc83… Jon *0463 HRESULT WINAPI VarDecFromBool(VARIANT_BOOL,DECIMAL*);
                0464 HRESULT WINAPI VarDecFromI1(signed char,DECIMAL*);
                0465 HRESULT WINAPI VarDecFromUI2(USHORT,DECIMAL*);
                0466 HRESULT WINAPI VarDecFromUI4(ULONG,DECIMAL*);
                0467 HRESULT WINAPI VarDecFromUI8(ULONG64,DECIMAL*);
                0468 HRESULT WINAPI VarDecFromCy(CY,DECIMAL*);
                0469 HRESULT WINAPI VarDecFromDisp(IDispatch*,LCID,DECIMAL*);
                0470 
                0471 #define VarUI4FromUI4( in,pOut ) ( *(pOut) =  (in) )
                0472 #define VarI4FromI4( in,pOut )   ( *(pOut) =  (in) )
b00cbeadb… Jean*0473 
2f558b53f… Jon *0474 #define VarUI1FromInt   VarUI1FromI4
                0475 #define VarUI1FromUint  VarUI1FromUI4
                0476 #define VarI2FromInt    VarI2FromI4
                0477 #define VarI2FromUint   VarI2FromUI4
                0478 #define VarI4FromInt    VarI4FromI4
                0479 #define VarI4FromUint   VarI4FromUI4
                0480 #define VarI8FromInt    VarI8FromI4
                0481 #define VarI8FromUint   VarI8FromUI4
                0482 #define VarR4FromInt    VarR4FromI4
                0483 #define VarR4FromUint   VarR4FromUI4
                0484 #define VarR8FromInt    VarR8FromI4
                0485 #define VarR8FromUint   VarR8FromUI4
                0486 #define VarDateFromInt  VarDateFromI4
                0487 #define VarDateFromUint VarDateFromUI4
                0488 #define VarCyFromInt    VarCyFromI4
                0489 #define VarCyFromUint   VarCyFromUI4
                0490 #define VarBstrFromInt  VarBstrFromI4
                0491 #define VarBstrFromUint VarBstrFromUI4
                0492 #define VarBoolFromInt  VarBoolFromI4
                0493 #define VarBoolFromUint VarBoolFromUI4
                0494 #define VarI1FromInt    VarI1FromI4
                0495 #define VarI1FromUint   VarI1FromUI4
                0496 #define VarUI2FromInt   VarUI2FromI4
                0497 #define VarUI2FromUint  VarUI2FromUI4
                0498 #define VarUI4FromInt   VarUI4FromI4
                0499 #define VarUI4FromUint  VarUI4FromUI4
                0500 #define VarUI8FromInt   VarUI8FromI4
                0501 #define VarUI8FromUint  VarUI8FromUI4
                0502 #define VarDecFromInt   VarDecFromI4
                0503 #define VarDecFromUint  VarDecFromUI4
                0504 #define VarIntFromUI1   VarI4FromUI1
                0505 #define VarIntFromI2    VarI4FromI2
                0506 #define VarIntFromI4    VarI4FromI4
                0507 #define VarIntFromI8    VarI4FromI8
                0508 #define VarIntFromR4    VarI4FromR4
                0509 #define VarIntFromR8    VarI4FromR8
                0510 #define VarIntFromDate  VarI4FromDate
                0511 #define VarIntFromCy    VarI4FromCy
                0512 #define VarIntFromStr   VarI4FromStr
                0513 #define VarIntFromDisp  VarI4FromDisp
                0514 #define VarIntFromBool  VarI4FromBool
                0515 #define VarIntFromI1    VarI4FromI1
                0516 #define VarIntFromUI2   VarI4FromUI2
                0517 #define VarIntFromUI4   VarI4FromUI4
                0518 #define VarIntFromUI8   VarI4FromUI8
                0519 #define VarIntFromDec   VarI4FromDec
                0520 #define VarIntFromUint  VarI4FromUI4
                0521 #define VarUintFromUI1  VarUI4FromUI1
                0522 #define VarUintFromI2   VarUI4FromI2
                0523 #define VarUintFromI4   VarUI4FromI4
                0524 #define VarUintFromI8   VarUI4FromI8
                0525 #define VarUintFromR4   VarUI4FromR4
                0526 #define VarUintFromR8   VarUI4FromR8
                0527 #define VarUintFromDate VarUI4FromDate
                0528 #define VarUintFromCy   VarUI4FromCy
                0529 #define VarUintFromStr  VarUI4FromStr
                0530 #define VarUintFromDisp VarUI4FromDisp
                0531 #define VarUintFromBool VarUI4FromBool
                0532 #define VarUintFromI1   VarUI4FromI1
                0533 #define VarUintFromUI2  VarUI4FromUI2
                0534 #define VarUintFromUI4  VarUI4FromUI4
                0535 #define VarUintFromUI8  VarUI4FromUI8
                0536 #define VarUintFromDec  VarUI4FromDec
                0537 #define VarUintFromInt  VarUI4FromI4
b00cbeadb… Jean*0538 
5853bd3c7… Fran*0539 /*
                0540  * Variant Math operations
                0541  */
                0542 #define VARCMP_LT   0
                0543 #define VARCMP_EQ   1
                0544 #define VARCMP_GT   2
                0545 #define VARCMP_NULL 3
                0546 
2f558b53f… Jon *0547 HRESULT WINAPI VarR4CmpR8(float,double);
                0548 
                0549 HRESULT WINAPI VarR8Pow(double,double,double*);
                0550 HRESULT WINAPI VarR8Round(double,int,double*);
                0551 
58422dc83… Jon *0552 HRESULT WINAPI VarDecAbs(const DECIMAL*,DECIMAL*);
                0553 HRESULT WINAPI VarDecAdd(const DECIMAL*,const DECIMAL*,DECIMAL*);
                0554 HRESULT WINAPI VarDecCmp(const DECIMAL*,const DECIMAL*);
                0555 HRESULT WINAPI VarDecCmpR8(const DECIMAL*,DOUBLE);
                0556 HRESULT WINAPI VarDecDiv(const DECIMAL*,const DECIMAL*,DECIMAL*);
                0557 HRESULT WINAPI VarDecFix(const DECIMAL*,DECIMAL*);
                0558 HRESULT WINAPI VarDecInt(const DECIMAL*,DECIMAL*);
                0559 HRESULT WINAPI VarDecMul(const DECIMAL*,const DECIMAL*,DECIMAL*);
                0560 HRESULT WINAPI VarDecNeg(const DECIMAL*,DECIMAL*);
                0561 HRESULT WINAPI VarDecRound(const DECIMAL*,int,DECIMAL*);
                0562 HRESULT WINAPI VarDecSub(const DECIMAL*,const DECIMAL*,DECIMAL*);
                0563 
18f7ec367… Alex*0564 HRESULT WINAPI VarCyAbs(CY,CY*);
                0565 HRESULT WINAPI VarCyAdd(CY,CY,CY*);
                0566 HRESULT WINAPI VarCyCmp(CY,CY);
                0567 HRESULT WINAPI VarCyCmpR8(CY,DOUBLE);
                0568 HRESULT WINAPI VarCyFix(CY,CY*);
                0569 HRESULT WINAPI VarCyInt(CY,CY*);
                0570 HRESULT WINAPI VarCyMul(CY,CY,CY*);
                0571 HRESULT WINAPI VarCyMulI4(CY,LONG,CY*);
                0572 HRESULT WINAPI VarCyMulI8(CY,LONG64,CY*);
                0573 HRESULT WINAPI VarCyNeg(CY,CY*);
                0574 HRESULT WINAPI VarCyRound(CY,INT,CY*);
                0575 HRESULT WINAPI VarCySub(CY,CY,CY*);
58422dc83… Jon *0576 
5853bd3c7… Fran*0577 HRESULT WINAPI VarAdd(LPVARIANT,LPVARIANT,LPVARIANT);
                0578 HRESULT WINAPI VarAnd(LPVARIANT,LPVARIANT,LPVARIANT);
                0579 HRESULT WINAPI VarCat(LPVARIANT,LPVARIANT,LPVARIANT);
                0580 HRESULT WINAPI VarDiv(LPVARIANT,LPVARIANT,LPVARIANT);
                0581 HRESULT WINAPI VarEqv(LPVARIANT,LPVARIANT,LPVARIANT);
                0582 HRESULT WINAPI VarIdiv(LPVARIANT,LPVARIANT,LPVARIANT);
                0583 HRESULT WINAPI VarImp(LPVARIANT,LPVARIANT,LPVARIANT);
                0584 HRESULT WINAPI VarMod(LPVARIANT,LPVARIANT,LPVARIANT);
                0585 HRESULT WINAPI VarMul(LPVARIANT,LPVARIANT,LPVARIANT);
                0586 HRESULT WINAPI VarOr(LPVARIANT,LPVARIANT,LPVARIANT);
                0587 HRESULT WINAPI VarPow(LPVARIANT,LPVARIANT,LPVARIANT);
                0588 HRESULT WINAPI VarSub(LPVARIANT,LPVARIANT,LPVARIANT);
                0589 HRESULT WINAPI VarXor(LPVARIANT,LPVARIANT,LPVARIANT);
                0590 
                0591 HRESULT WINAPI VarAbs(LPVARIANT,LPVARIANT);
                0592 HRESULT WINAPI VarFix(LPVARIANT,LPVARIANT);
                0593 HRESULT WINAPI VarInt(LPVARIANT,LPVARIANT);
                0594 HRESULT WINAPI VarNeg(LPVARIANT,LPVARIANT);
                0595 HRESULT WINAPI VarNot(LPVARIANT,LPVARIANT);
                0596 
                0597 HRESULT WINAPI VarRound(LPVARIANT,int,LPVARIANT);
                0598 
                0599 HRESULT WINAPI VarCmp(LPVARIANT,LPVARIANT,LCID,ULONG);
                0600 
2f558b53f… Jon *0601 HRESULT WINAPI VarBstrCmp(BSTR,BSTR,LCID,ULONG);
                0602 HRESULT WINAPI VarBstrCat(BSTR,BSTR,BSTR*);
5853bd3c7… Fran*0603 
                0604 
3e3e230d3… Dani*0605 typedef struct {
                0606     SYSTEMTIME st;
                0607     USHORT wDayOfYear;
                0608 } UDATE;
260cd4ec9… Rein*0609 
2f558b53f… Jon *0610 typedef struct
                0611 {
                0612     INT   cDig;       /* Number of parsed digits */
                0613     ULONG dwInFlags;  /* Acceptable state of the input string (NUMPRS_ flags) */
                0614     ULONG dwOutFlags; /* Parsed state of the output string (NUMPRS_ flags) */
                0615     INT   cchUsed;    /* Number of characters parsed from input string */
                0616     INT   nBaseShift; /* Base of the number (but apparently unused) */
                0617     INT   nPwr10;     /* Scale of the number in powers of 10 */
4736cc8cd… Marc*0618 } NUMPARSE;
                0619 
2f558b53f… Jon *0620 #define NUMPRS_LEADING_WHITE  0x00001 /* Leading whitespace */
                0621 #define NUMPRS_TRAILING_WHITE 0x00002 /* Trailing whitespace */
                0622 #define NUMPRS_LEADING_PLUS   0x00004 /* Leading '+' sign */
                0623 #define NUMPRS_TRAILING_PLUS  0x00008 /* Trailing '+' sign */
                0624 #define NUMPRS_LEADING_MINUS  0x00010 /* Leading '-' sign */
                0625 #define NUMPRS_TRAILING_MINUS 0x00020 /* Trailing '-' sign */
                0626 #define NUMPRS_HEX_OCT        0x00040 /* Octal number (with a leading 0) */
                0627 #define NUMPRS_PARENS         0x00080 /* Parentheses for negative numbers */
84540b4dc… Fran*0628 #define NUMPRS_DECIMAL        0x00100 /* Decimal separator */
                0629 #define NUMPRS_THOUSANDS      0x00200 /* Thousands separator */
2f558b53f… Jon *0630 #define NUMPRS_CURRENCY       0x00400 /* Currency symbol */
                0631 #define NUMPRS_EXPONENT       0x00800 /* Exponent (e.g. "e-14") */
                0632 #define NUMPRS_USE_ALL        0x01000 /* Parse the entire string */
                0633 #define NUMPRS_STD            0x01FFF /* Standard flags for internal coercions (All of the above) */
                0634 #define NUMPRS_NEG            0x10000 /* Number is negative (dwOutFlags only) */
                0635 #define NUMPRS_INEXACT        0x20000 /* Number is represented inexactly (dwOutFlags only) */
                0636 
                0637 #define VTBIT_I1      (1 << VT_I1)
                0638 #define VTBIT_UI1     (1 << VT_UI1)
                0639 #define VTBIT_I2      (1 << VT_I2)
                0640 #define VTBIT_UI2     (1 << VT_UI2)
                0641 #define VTBIT_I4      (1 << VT_I4)
                0642 #define VTBIT_UI4     (1 << VT_UI4)
                0643 #define VTBIT_I8      (1 << VT_I8)
                0644 #define VTBIT_UI8     (1 << VT_UI8)
                0645 #define VTBIT_R4      (1 << VT_R4)
                0646 #define VTBIT_R8      (1 << VT_R8)
                0647 #define VTBIT_CY      (1 << VT_CY)
                0648 #define VTBIT_DECIMAL (1 << VT_DECIMAL)
4736cc8cd… Marc*0649 
1e627d118… Fran*0650 HRESULT WINAPI VarParseNumFromStr(const OLECHAR*,LCID,ULONG,NUMPARSE*,BYTE*);
4736cc8cd… Marc*0651 HRESULT WINAPI VarNumFromParseNum(NUMPARSE*,BYTE*,ULONG,VARIANT*);
                0652 
2f558b53f… Jon *0653 INT WINAPI DosDateTimeToVariantTime(USHORT,USHORT,double*);
                0654 INT WINAPI VariantTimeToDosDateTime(double,USHORT*,USHORT*);
3e3e230d3… Dani*0655 
2f558b53f… Jon *0656 INT WINAPI VariantTimeToSystemTime(DOUBLE,LPSYSTEMTIME);
                0657 INT WINAPI SystemTimeToVariantTime(LPSYSTEMTIME,double*);
3e3e230d3… Dani*0658 
58422dc83… Jon *0659 HRESULT WINAPI VarDateFromUdate(UDATE*,ULONG,DATE*);
2f558b53f… Jon *0660 HRESULT WINAPI VarDateFromUdateEx(UDATE*,LCID,ULONG,DATE*);
58422dc83… Jon *0661 HRESULT WINAPI VarUdateFromDate(DATE,ULONG,UDATE*);
                0662 
2f558b53f… Jon *0663 /* Variant formatting */
                0664 HRESULT WINAPI VarWeekdayName(int,int,int,ULONG,BSTR*);
                0665 HRESULT WINAPI VarMonthName(int,int,ULONG,BSTR*);
                0666 HRESULT WINAPI GetAltMonthNames(LCID,LPOLESTR**);
                0667 
                0668 HRESULT WINAPI VarFormat(LPVARIANT,LPOLESTR,int,int,ULONG,BSTR*);
                0669 HRESULT WINAPI VarFormatCurrency(LPVARIANT,int,int,int,int,ULONG,BSTR*);
                0670 HRESULT WINAPI VarFormatDateTime(LPVARIANT,int,ULONG,BSTR*);
                0671 HRESULT WINAPI VarFormatNumber(LPVARIANT,int,int,int,int,ULONG,BSTR*);
                0672 HRESULT WINAPI VarFormatPercent(LPVARIANT,int,int,int,int,ULONG,BSTR*);
                0673 
                0674 HRESULT WINAPI VarFormatFromTokens(LPVARIANT,LPOLESTR,LPBYTE,ULONG,BSTR*,LCID);
                0675 HRESULT WINAPI VarTokenizeFormatString(LPOLESTR,LPBYTE,int,int,int,LCID,int*);
                0676 
                0677 
                0678 /*
                0679  * IDispatch types and helper functions
                0680  */
                0681 
                0682 /* A structure describing a single parameter to a com object method. */
                0683 typedef struct tagPARAMDATA
                0684 {
                0685     OLECHAR *szName; /* Name of Parameter */
                0686     VARTYPE  vt;     /* Type of Parameter */
                0687 } PARAMDATA, *LPPARAMDATA;
                0688 
                0689 /* A structure describing a single method of a com object. */
                0690 typedef struct tagMETHODDATA
                0691 {
                0692     OLECHAR   *szName;   /* Name of method */
                0693     PARAMDATA *ppdata;   /* Parameters of the method */
                0694     DISPID     dispid;   /* Id of the method */
                0695     UINT       iMeth;    /* Vtable index of the method */
                0696     CALLCONV   cc;       /* Calling convention of the method */
                0697     UINT       cArgs;    /* Number of parameters in the method */
                0698     WORD       wFlags;   /* Type of the method (DISPATCH_ flags) */
                0699     VARTYPE    vtReturn; /* Type of the return value */
                0700 } METHODDATA, *LPMETHODDATA;
                0701 
                0702 /* Structure describing a single com object */
                0703 typedef struct tagINTERFACEDATA
                0704 {
                0705     METHODDATA *pmethdata;  /* Methods of the object */
                0706     UINT        cMembers;   /* Number of methods in the object */
                0707 } INTERFACEDATA, *LPINTERFACEDATA;
                0708 
                0709 typedef enum tagREGKIND
                0710 {
                0711     REGKIND_DEFAULT,
                0712     REGKIND_REGISTER,
                0713     REGKIND_NONE
                0714 } REGKIND;
58422dc83… Jon *0715 
                0716 HRESULT WINAPI DispGetParam(DISPPARAMS*,UINT,VARTYPE,VARIANT*,UINT*);
                0717 HRESULT WINAPI DispGetIDsOfNames(ITypeInfo*,OLECHAR**,UINT,DISPID*);
                0718 HRESULT WINAPI DispInvoke(void*,ITypeInfo*,DISPID,WORD,DISPPARAMS*,VARIANT*,
                0719                           EXCEPINFO*,UINT*);
                0720 HRESULT WINAPI CreateDispTypeInfo(INTERFACEDATA*,LCID,ITypeInfo**);
                0721 HRESULT WINAPI CreateStdDispatch(IUnknown*,void*,ITypeInfo*,IUnknown**);
806cdce35… Robe*0722 HRESULT WINAPI DispCallFunc(void*,ULONG_PTR,CALLCONV,VARTYPE,UINT,VARTYPE*,
58422dc83… Jon *0723                             VARIANTARG**,VARIANT*);
565b00857… Pete*0724 
9e23b509a… Fran*0725 
                0726 /*
                0727  * TypeLib API
                0728  */
                0729 
2f558b53f… Jon *0730 ULONG WINAPI LHashValOfNameSysA(SYSKIND,LCID,LPCSTR);
                0731 ULONG WINAPI LHashValOfNameSys(SYSKIND,LCID,LPCOLESTR);
                0732 
                0733 #define LHashValOfName(lcid,name) LHashValOfNameSys(SYS_WIN32,lcid,name)
                0734 #define WHashValOfLHashVal(hash) ((USHORT)((hash) & 0xffff))
                0735 #define IsHashValCompatible(hash1,hash2) ((hash1) & 0xff0000 == (hash2) & 0xff0000)
                0736 
                0737 #define MEMBERID_NIL   DISPID_UNKNOWN
                0738 #define ID_DEFAULTINST -2
008f4ce91… Ove *0739 
                0740 #define DISPATCH_METHOD         0x1
                0741 #define DISPATCH_PROPERTYGET    0x2
                0742 #define DISPATCH_PROPERTYPUT    0x4
                0743 #define DISPATCH_PROPERTYPUTREF 0x8
                0744 
2f558b53f… Jon *0745 #define LOAD_TLB_AS_32BIT       0x20
                0746 #define LOAD_TLB_AS_64BIT       0x40
                0747 #define MASK_TO_RESET_TLB_BITS  ~(LOAD_TLB_AS_32BIT|LOAD_TLB_AS_64BIT)
                0748 
9e23b509a… Fran*0749 HRESULT WINAPI CreateTypeLib(SYSKIND,const OLECHAR*,ICreateTypeLib**);
                0750 HRESULT WINAPI CreateTypeLib2(SYSKIND,LPCOLESTR,ICreateTypeLib2**);
                0751 HRESULT WINAPI LoadRegTypeLib(REFGUID,WORD,WORD,LCID,ITypeLib**);
                0752 HRESULT WINAPI LoadTypeLib(const OLECHAR*,ITypeLib**);
                0753 HRESULT WINAPI LoadTypeLibEx(LPCOLESTR,REGKIND,ITypeLib**);
                0754 HRESULT WINAPI QueryPathOfRegTypeLib(REFGUID,WORD,WORD,LCID,LPBSTR);
e10e59fa0… Kevi*0755 HRESULT WINAPI RegisterTypeLib(ITypeLib*,LPCOLESTR,LPCOLESTR);
9e23b509a… Fran*0756 HRESULT WINAPI UnRegisterTypeLib(REFGUID,WORD,WORD,LCID,SYSKIND);
f4fa417be… Andr*0757 HRESULT WINAPI RegisterTypeLibForUser(ITypeLib*,OLECHAR*,OLECHAR*);
f2610a610… Andr*0758 HRESULT WINAPI UnRegisterTypeLibForUser(REFGUID,WORD,WORD,LCID,SYSKIND);
9e23b509a… Fran*0759 
2f558b53f… Jon *0760 VOID WINAPI ClearCustData(LPCUSTDATA);
                0761 
0062892c6… Fran*0762 #ifdef __cplusplus
                0763 } /* extern "C" */
9a6249166… Vinc*0764 #endif
0062892c6… Fran*0765 
9e23b509a… Fran*0766 
b00cbeadb… Jean*0767 #endif /*__WINE_OLEAUTO_H*/
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ General search ]

This page was automatically generated by the 2.3.4 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!