| // Licensed under the Apache License, Version 2.0 |
| // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license |
| // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option. |
| // All files in the project carrying such notice may not be copied, modified, or distributed |
| // except according to those terms. |
| //! Mappings for the contents of OleAuto.h |
| use ctypes::{c_double, c_float, c_int, c_uint, c_void}; |
| use shared::basetsd::{LONG64, ULONG64}; |
| use shared::minwindef::{BYTE, DWORD, FLOAT, UINT, ULONG, USHORT, WORD}; |
| use shared::wtypes::{BSTR, DATE, DECIMAL, LPBSTR, LPDECIMAL, VARTYPE}; |
| use shared::wtypesbase::{DOUBLE, LPCOLESTR, LPOLESTR, OLECHAR}; |
| use um::minwinbase::LPSYSTEMTIME; |
| use um::oaidl::{ |
| DISPID_UNKNOWN, ICreateErrorInfo, IErrorInfo, ITypeLib, SAFEARRAY, VARIANT, VARIANTARG |
| }; |
| use um::winnt::{CHAR, HRESULT, INT, LCID, LONG, LPCSTR, SHORT}; |
| extern "system" { |
| pub fn SysAllocString( |
| psz: *const OLECHAR, |
| ) -> BSTR; |
| pub fn SysReAllocString( |
| pbstr: *mut BSTR, |
| psz: *const OLECHAR, |
| ) -> INT; |
| pub fn SysAllocStringLen( |
| strIn: *const OLECHAR, |
| ui: UINT, |
| ) -> BSTR; |
| pub fn SysReAllocStringLen( |
| pbstr: *mut BSTR, |
| psz: *const OLECHAR, |
| len: c_uint, |
| ) -> INT; |
| pub fn SysFreeString( |
| bstrString: BSTR, |
| ); |
| pub fn SysStringLen( |
| pbstr: BSTR, |
| ) -> UINT; |
| pub fn SysStringByteLen( |
| bstr: BSTR, |
| ) -> UINT; |
| pub fn SysAllocStringByteLen( |
| psz: LPCSTR, |
| len: UINT, |
| ) -> BSTR; |
| pub fn DosDateTimeToVariantTime( |
| wDosDate: USHORT, |
| wDosTime: USHORT, |
| pvtime: *mut DOUBLE, |
| ) -> INT; |
| pub fn VariantTimeToDosDateTime( |
| vtime: DOUBLE, |
| pwDosDate: *mut USHORT, |
| pwDosTime: *mut USHORT, |
| ) -> INT; |
| pub fn SystemTimeToVariantTime( |
| lpSystemTime: LPSYSTEMTIME, |
| pvtime: *mut DOUBLE, |
| ) -> INT; |
| pub fn VariantTimeToSystemTime( |
| vtime: DOUBLE, |
| lpSystemTime: LPSYSTEMTIME, |
| ) -> INT; |
| pub fn SafeArrayAccessData( |
| psa: *mut SAFEARRAY, |
| ppvData: *mut *mut c_void, |
| ) -> HRESULT; |
| pub fn SafeArrayUnaccessData( |
| psa: *mut SAFEARRAY, |
| ) -> HRESULT; |
| pub fn SafeArrayCreateVector( |
| vt: VARTYPE, |
| lLbound: LONG, |
| cElements: ULONG, |
| ) -> *mut SAFEARRAY; |
| pub fn SafeArrayGetLBound( |
| psa: *mut SAFEARRAY, |
| nDim: UINT, |
| plLbound: *mut LONG |
| ) -> HRESULT; |
| pub fn SafeArrayGetUBound( |
| psa: *mut SAFEARRAY, |
| nDim: UINT, |
| plUbound: *mut LONG |
| ) -> HRESULT; |
| pub fn SafeArrayDestroy( |
| psa: *mut SAFEARRAY |
| ) -> HRESULT; |
| pub fn VariantInit( |
| pvarg: *mut VARIANTARG, |
| ); |
| pub fn VariantClear( |
| pvarg: *mut VARIANTARG, |
| ) -> HRESULT; |
| pub fn VariantCopy( |
| pvargDest: *mut VARIANTARG, |
| pvargSrc: *const VARIANTARG, |
| ) -> HRESULT; |
| pub fn VariantCopyInd( |
| pvarDest: *mut VARIANT, |
| pvargSrc: *const VARIANTARG, |
| ) -> HRESULT; |
| pub fn VariantChangeType( |
| pvargDest: *mut VARIANTARG, |
| pvarSrc: *const VARIANTARG, |
| wFlags: USHORT, |
| vt: VARTYPE, |
| ) -> HRESULT; |
| pub fn VariantChangeTypeEx( |
| pvargDest: *mut VARIANTARG, |
| pvarSrc: *const VARIANTARG, |
| lcid: LCID, |
| wFlags: USHORT, |
| vt: VARTYPE, |
| ) -> HRESULT; |
| pub fn VarUI1FromI2( |
| sIn: SHORT, |
| pbOut: *mut BYTE, |
| ); |
| pub fn VarUI1FromI4( |
| lIn: LONG, |
| pbOut: *mut BYTE, |
| ); |
| pub fn VarUI1FromI8( |
| i64In: LONG64, |
| pbOut: *mut BYTE, |
| ); |
| pub fn VarUI1FromR4( |
| fltIn: FLOAT, |
| pbOut: *mut BYTE, |
| ); |
| pub fn VarUI1FromR8( |
| dblIn: DOUBLE, |
| pbOut: *mut BYTE, |
| ); |
| pub fn VarUI1FromDate( |
| dateIn: DATE, |
| pbOut: *mut BYTE, |
| ); |
| pub fn VarUI1FromStr( |
| strIn: LPCOLESTR, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pbOut: *mut BYTE, |
| ); |
| pub fn VarUI1FromI1( |
| cIn: CHAR, |
| pbOut: *mut BYTE, |
| ); |
| pub fn VarUI1FromUI2( |
| uiIn: USHORT, |
| pbOut: *mut BYTE, |
| ); |
| pub fn VarUI1FromUI4( |
| ulIn: ULONG, |
| pbOut: *mut BYTE, |
| ); |
| pub fn VarUI1FromUI8( |
| ui64In: ULONG64, |
| pbOut: *mut BYTE, |
| ); |
| pub fn VarUI1FromDec( |
| pdecIn: *const DECIMAL, |
| pbOut: *mut BYTE, |
| ); |
| pub fn VarI2FromUI1( |
| bIn: BYTE, |
| psOut: *mut SHORT, |
| ); |
| pub fn VarI2FromI4( |
| lIn: LONG, |
| psOut: *mut SHORT, |
| ); |
| pub fn VarI2FromI8( |
| i64In: LONG64, |
| psOut: *mut SHORT, |
| ); |
| pub fn VarI2FromR4( |
| fltIn: FLOAT, |
| psOut: *mut SHORT, |
| ); |
| pub fn VarI2FromR8( |
| dblIn: DOUBLE, |
| psOut: *mut SHORT, |
| ); |
| pub fn VarI2FromDate( |
| dateIn: DATE, |
| psOut: *mut SHORT, |
| ); |
| pub fn VarI2FromStr( |
| strIn: LPCOLESTR, |
| lcid: LCID, |
| dwFlags: ULONG, |
| psOut: *mut SHORT, |
| ); |
| pub fn VarI2FromI1( |
| cIn: CHAR, |
| psOut: *mut SHORT, |
| ); |
| pub fn VarI2FromUI2( |
| uiIn: USHORT, |
| psOut: *mut SHORT, |
| ); |
| pub fn VarI2FromUI4( |
| ulIn: ULONG, |
| psOut: *mut SHORT, |
| ); |
| pub fn VarI2FromUI8( |
| ui64In: ULONG64, |
| psOut: *mut SHORT, |
| ); |
| pub fn VarI2FromDec( |
| pdecIn: *const DECIMAL, |
| psOut: *mut SHORT, |
| ); |
| pub fn VarI4FromUI1( |
| bIn: BYTE, |
| plOut: *mut LONG, |
| ); |
| pub fn VarI4FromI2( |
| sIn: SHORT, |
| plOut: *mut LONG, |
| ); |
| pub fn VarI4FromI8( |
| i64In: LONG64, |
| plOut: *mut LONG, |
| ); |
| pub fn VarI4FromR4( |
| fltIn: FLOAT, |
| plOut: *mut LONG, |
| ); |
| pub fn VarI4FromR8( |
| dblIn: DOUBLE, |
| plOut: *mut LONG, |
| ); |
| pub fn VarI4FromDate( |
| dateIn: DATE, |
| plOut: *mut LONG, |
| ); |
| pub fn VarI4FromStr( |
| strIn: LPCOLESTR, |
| lcid: LCID, |
| dwFlags: ULONG, |
| plOut: *mut LONG, |
| ); |
| pub fn VarI4FromI1( |
| cIn: CHAR, |
| plOut: *mut LONG, |
| ); |
| pub fn VarI4FromUI2( |
| uiIn: USHORT, |
| plOut: *mut LONG, |
| ); |
| pub fn VarI4FromUI4( |
| ulIn: ULONG, |
| plOut: *mut LONG, |
| ); |
| pub fn VarI4FromUI8( |
| ui64In: ULONG64, |
| plOut: *mut LONG, |
| ); |
| pub fn VarI4FromDec( |
| pdecIn: *const DECIMAL, |
| plOut: *mut LONG, |
| ); |
| pub fn VarI8FromUI1( |
| bIn: BYTE, |
| pi64Out: *mut LONG64, |
| ); |
| pub fn VarI8FromI2( |
| sIn: SHORT, |
| pi64Out: *mut LONG64, |
| ); |
| pub fn VarI8FromR4( |
| fltIn: FLOAT, |
| pi64Out: *mut LONG64, |
| ); |
| pub fn VarI8FromR8( |
| dblIn: DOUBLE, |
| pi64Out: *mut LONG64, |
| ); |
| pub fn VarI8FromDate( |
| dateIn: DATE, |
| pi64Out: *mut LONG64, |
| ); |
| pub fn VarI8FromStr( |
| strIn: LPCOLESTR, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pi64Out: *mut LONG64, |
| ); |
| pub fn VarI8FromI1( |
| cIn: CHAR, |
| pi64Out: *mut LONG64, |
| ); |
| pub fn VarI8FromUI2( |
| uiIn: USHORT, |
| pi64Out: *mut LONG64, |
| ); |
| pub fn VarI8FromUI4( |
| ulIn: ULONG, |
| pi64Out: *mut LONG64, |
| ); |
| pub fn VarI8FromUI8( |
| ui64In: ULONG64, |
| pi64Out: *mut LONG64, |
| ); |
| pub fn VarI8FromDec( |
| pdecIn: *const DECIMAL, |
| pi64Out: *mut LONG64, |
| ); |
| pub fn VarR4FromUI1( |
| bIn: BYTE, |
| pfltOut: *mut FLOAT, |
| ); |
| pub fn VarR4FromI2( |
| sIn: SHORT, |
| pfltOut: *mut FLOAT, |
| ); |
| pub fn VarR4FromI4( |
| lIn: LONG, |
| pfltOut: *mut FLOAT, |
| ); |
| pub fn VarR4FromI8( |
| i64In: LONG64, |
| pfltOut: *mut FLOAT, |
| ); |
| pub fn VarR4FromR8( |
| dblIn: DOUBLE, |
| pfltOut: *mut FLOAT, |
| ); |
| pub fn VarR4FromDate( |
| dateIn: DATE, |
| pfltOut: *mut FLOAT, |
| ); |
| pub fn VarR4FromStr( |
| strIn: LPCOLESTR, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pfltOut: *mut FLOAT, |
| ); |
| pub fn VarR4FromI1( |
| cIn: CHAR, |
| pfltOut: *mut FLOAT, |
| ); |
| pub fn VarR4FromUI2( |
| uiIn: USHORT, |
| pfltOut: *mut FLOAT, |
| ); |
| pub fn VarR4FromUI4( |
| ulIn: ULONG, |
| pfltOut: *mut FLOAT, |
| ); |
| pub fn VarR4FromUI8( |
| ui64In: ULONG64, |
| pfltOut: *mut FLOAT, |
| ); |
| pub fn VarR4FromDec( |
| pdecIn: *const DECIMAL, |
| pfltOut: *mut FLOAT, |
| ); |
| pub fn VarR8FromUI1( |
| bIn: BYTE, |
| pdblOut: *mut DOUBLE, |
| ); |
| pub fn VarR8FromI2( |
| sIn: SHORT, |
| pdblOut: *mut DOUBLE, |
| ); |
| pub fn VarR8FromI4( |
| lIn: LONG, |
| pdblOut: *mut DOUBLE, |
| ); |
| pub fn VarR8FromI8( |
| i64In: LONG64, |
| pdblOut: *mut DOUBLE, |
| ); |
| pub fn VarR8FromR4( |
| fltIn: FLOAT, |
| pdblOut: *mut DOUBLE, |
| ); |
| pub fn VarR8FromDate( |
| dateIn: DATE, |
| pdblOut: *mut DOUBLE, |
| ); |
| pub fn VarR8FromStr( |
| strIn: LPCOLESTR, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pdblOut: *mut DOUBLE, |
| ); |
| pub fn VarR8FromI1( |
| cIn: CHAR, |
| pdblOut: *mut DOUBLE, |
| ); |
| pub fn VarR8FromUI2( |
| uiIn: USHORT, |
| pdblOut: *mut DOUBLE, |
| ); |
| pub fn VarR8FromUI4( |
| ulIn: ULONG, |
| pdblOut: *mut DOUBLE, |
| ); |
| pub fn VarR8FromUI8( |
| ui64In: ULONG64, |
| pdblOut: *mut DOUBLE, |
| ); |
| pub fn VarR8FromDec( |
| pdecIn: *const DECIMAL, |
| pdblOut: *mut DOUBLE, |
| ); |
| pub fn VarDateFromUI1( |
| bIn: BYTE, |
| pdateOut: *mut DATE, |
| ); |
| pub fn VarDateFromI2( |
| sIn: SHORT, |
| pdateOut: *mut DATE, |
| ); |
| pub fn VarDateFromI4( |
| lIn: LONG, |
| pdateOut: *mut DATE, |
| ); |
| pub fn VarDateFromI8( |
| i64In: LONG64, |
| pdateOut: *mut DATE, |
| ); |
| pub fn VarDateFromR4( |
| fltIn: FLOAT, |
| pdateOut: *mut DATE, |
| ); |
| pub fn VarDateFromR8( |
| dblIn: DOUBLE, |
| pdateOut: *mut DATE, |
| ); |
| pub fn VarDateFromStr( |
| strIn: LPCOLESTR, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pdateOut: *mut DATE, |
| ); |
| pub fn VarDateFromI1( |
| cIn: CHAR, |
| pdateOut: *mut DATE, |
| ); |
| pub fn VarDateFromUI2( |
| uiIn: USHORT, |
| pdateOut: *mut DATE, |
| ); |
| pub fn VarDateFromUI4( |
| ulIn: ULONG, |
| pdateOut: *mut DATE, |
| ); |
| pub fn VarDateFromUI8( |
| ui64In: ULONG64, |
| pdateOut: *mut DATE, |
| ); |
| pub fn VarDateFromDec( |
| pdecIn: *const DECIMAL, |
| pdateOut: *mut DATE, |
| ); |
| pub fn VarBstrFromUI1( |
| bVal: BYTE, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pbstrOut: *mut BSTR, |
| ); |
| pub fn VarBstrFromI2( |
| iVal: SHORT, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pbstrOut: *mut BSTR, |
| ); |
| pub fn VarBstrFromI4( |
| lIn: LONG, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pbstrOut: *mut BSTR, |
| ); |
| pub fn VarBstrFromI8( |
| i64In: LONG64, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pbstrOut: *mut BSTR, |
| ); |
| pub fn VarBstrFromR4( |
| fltIn: FLOAT, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pbstrOut: *mut BSTR, |
| ); |
| pub fn VarBstrFromR8( |
| dblIn: DOUBLE, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pbstrOut: *mut BSTR, |
| ); |
| pub fn VarBstrFromDate( |
| dateIn: DATE, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pbstrOut: *mut BSTR, |
| ); |
| pub fn VarBstrFromI1( |
| cIn: CHAR, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pbstrOut: *mut BSTR, |
| ); |
| pub fn VarBstrFromUI2( |
| uiIn: USHORT, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pbstrOut: *mut BSTR, |
| ); |
| pub fn VarBstrFromUI4( |
| ulIn: ULONG, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pbstrOut: *mut BSTR, |
| ); |
| pub fn VarBstrFromUI8( |
| ui64In: ULONG64, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pbstrOut: *mut BSTR, |
| ); |
| pub fn VarBstrFromDec( |
| pdecIn: *const DECIMAL, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pbstrOut: *mut BSTR, |
| ); |
| pub fn VarUI2FromUI1( |
| bIn: BYTE, |
| puiOut: *mut USHORT, |
| ); |
| pub fn VarUI2FromI2( |
| uiIn: SHORT, |
| puiOut: *mut USHORT, |
| ); |
| pub fn VarUI2FromI4( |
| lIn: LONG, |
| puiOut: *mut USHORT, |
| ); |
| pub fn VarUI2FromI8( |
| i64In: LONG64, |
| puiOut: *mut USHORT, |
| ); |
| pub fn VarUI2FromR4( |
| fltIn: FLOAT, |
| puiOut: *mut USHORT, |
| ); |
| pub fn VarUI2FromR8( |
| dblIn: DOUBLE, |
| puiOut: *mut USHORT, |
| ); |
| pub fn VarUI2FromDate( |
| dateIn: DATE, |
| puiOut: *mut USHORT, |
| ); |
| pub fn VarUI2FromStr( |
| strIn: LPCOLESTR, |
| lcid: LCID, |
| dwFlags: ULONG, |
| puiOut: *mut USHORT, |
| ); |
| pub fn VarUI2FromI1( |
| cIn: CHAR, |
| puiOut: *mut USHORT, |
| ); |
| pub fn VarUI2FromUI4( |
| ulIn: ULONG, |
| puiOut: *mut USHORT, |
| ); |
| pub fn VarUI2FromUI8( |
| i64In: ULONG64, |
| puiOut: *mut USHORT, |
| ); |
| pub fn VarUI2FromDec( |
| pdecIn: *const DECIMAL, |
| puiOut: *mut USHORT, |
| ); |
| pub fn VarUI4FromUI1( |
| bIn: BYTE, |
| pulOut: *mut ULONG, |
| ); |
| pub fn VarUI4FromI2( |
| uiIn: SHORT, |
| pulOut: *mut ULONG, |
| ); |
| pub fn VarUI4FromI4( |
| lIn: LONG, |
| pulOut: *mut ULONG, |
| ); |
| pub fn VarUI4FromI8( |
| i64In: LONG64, |
| plOut: *mut ULONG, |
| ); |
| pub fn VarUI4FromR4( |
| fltIn: FLOAT, |
| pulOut: *mut ULONG, |
| ); |
| pub fn VarUI4FromR8( |
| dblIn: DOUBLE, |
| pulOut: *mut ULONG, |
| ); |
| pub fn VarUI4FromDate( |
| dateIn: DATE, |
| pulOut: *mut ULONG, |
| ); |
| pub fn VarUI4FromStr( |
| strIn: LPCOLESTR, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pulOut: *mut ULONG, |
| ); |
| pub fn VarUI4FromI1( |
| cIn: CHAR, |
| pulOut: *mut ULONG, |
| ); |
| pub fn VarUI4FromUI2( |
| uiIn: USHORT, |
| pulOut: *mut ULONG, |
| ); |
| pub fn VarUI4FromUI8( |
| ui64In: ULONG64, |
| plOut: *mut ULONG, |
| ); |
| pub fn VarUI4FromDec( |
| pdecIn: *const DECIMAL, |
| pulOut: *mut ULONG, |
| ); |
| pub fn VarUI8FromUI1( |
| bIn: BYTE, |
| pi64Out: *mut ULONG64, |
| ); |
| pub fn VarUI8FromI2( |
| sIn: SHORT, |
| pi64Out: *mut ULONG64, |
| ); |
| pub fn VarUI8FromI4( |
| lIn: LONG, |
| pi64Out: *mut ULONG64, |
| ); |
| pub fn VarUI8FromI8( |
| ui64In: LONG64, |
| pi64Out: *mut ULONG64, |
| ); |
| pub fn VarUI8FromR4( |
| fltIn: FLOAT, |
| pi64Out: *mut ULONG64, |
| ); |
| pub fn VarUI8FromR8( |
| dblIn: DOUBLE, |
| pi64Out: *mut ULONG64, |
| ); |
| pub fn VarUI8FromDate( |
| dateIn: DATE, |
| pi64Out: *mut ULONG64, |
| ); |
| pub fn VarUI8FromStr( |
| strIn: LPCOLESTR, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pi64Out: *mut ULONG64, |
| ); |
| pub fn VarUI8FromI1( |
| cIn: CHAR, |
| pi64Out: *mut ULONG64, |
| ); |
| pub fn VarUI8FromUI2( |
| uiIn: USHORT, |
| pi64Out: *mut ULONG64, |
| ); |
| pub fn VarUI8FromUI4( |
| ulIn: ULONG, |
| pi64Out: *mut ULONG64, |
| ); |
| pub fn VarUI8FromDec( |
| pdecIn: *const DECIMAL, |
| pi64Out: *mut ULONG64, |
| ); |
| pub fn VarDecFromUI1( |
| bIn: BYTE, |
| pdecOut: *mut DECIMAL, |
| ); |
| pub fn VarDecFromI2( |
| uiIn: SHORT, |
| pdecOut: *mut DECIMAL, |
| ); |
| pub fn VarDecFromI4( |
| lIn: LONG, |
| pdecOut: *mut DECIMAL, |
| ); |
| pub fn VarDecFromI8( |
| i64In: LONG64, |
| pdecOut: *mut DECIMAL, |
| ); |
| pub fn VarDecFromR4( |
| fltIn: FLOAT, |
| pdecOut: *mut DECIMAL, |
| ); |
| pub fn VarDecFromR8( |
| dblIn: DOUBLE, |
| pdecOut: *mut DECIMAL, |
| ); |
| pub fn VarDecFromDate( |
| dateIn: DATE, |
| pdecOut: *mut DECIMAL, |
| ); |
| pub fn VarDecFromStr( |
| strIn: LPCOLESTR, |
| lcid: LCID, |
| dwFlags: ULONG, |
| pdecOut: *mut DECIMAL, |
| ); |
| pub fn VarDecFromI1( |
| cIn: CHAR, |
| pdecOut: *mut DECIMAL, |
| ); |
| pub fn VarDecFromUI2( |
| uiIn: USHORT, |
| pdecOut: *mut DECIMAL, |
| ); |
| pub fn VarDecFromUI4( |
| ulIn: ULONG, |
| pdecOut: *mut DECIMAL, |
| ); |
| pub fn VarDecFromUI8( |
| ui64In: ULONG64, |
| pdecOut: *mut DECIMAL, |
| ); |
| pub fn VarDecAdd( |
| pdecLeft: LPDECIMAL, |
| pdecRight: LPDECIMAL, |
| pdecResult: LPDECIMAL, |
| ); |
| pub fn VarDecDiv( |
| pdecLeft: LPDECIMAL, |
| pdecRight: LPDECIMAL, |
| pdecResult: LPDECIMAL, |
| ); |
| pub fn VarDecMul( |
| pdecLeft: LPDECIMAL, |
| pdecRight: LPDECIMAL, |
| pdecResult: LPDECIMAL, |
| ); |
| pub fn VarDecSub( |
| pdecLeft: LPDECIMAL, |
| pdecRight: LPDECIMAL, |
| pdecResult: LPDECIMAL, |
| ); |
| pub fn VarDecAbs( |
| pdecIn: LPDECIMAL, |
| pdecResult: LPDECIMAL, |
| ); |
| pub fn VarDecFix( |
| pdecIn: LPDECIMAL, |
| pdecResult: LPDECIMAL, |
| ); |
| pub fn VarDecInt( |
| pdecIn: LPDECIMAL, |
| pdecResult: LPDECIMAL, |
| ); |
| pub fn VarDecNeg( |
| pdecIn: LPDECIMAL, |
| pdecResult: LPDECIMAL, |
| ); |
| pub fn VarDecRound( |
| pdecIn: LPDECIMAL, |
| cDecimals: c_int, |
| pdecResult: LPDECIMAL, |
| ); |
| pub fn VarDecCmp( |
| pdecLeft: LPDECIMAL, |
| pdecRight: LPDECIMAL, |
| ); |
| pub fn VarDecCmpR8( |
| pdecLeft: LPDECIMAL, |
| dblRight: c_double, |
| ); |
| pub fn VarBstrCat( |
| bstrLeft: BSTR, |
| bstrRight: BSTR, |
| pbstrResult: LPBSTR, |
| ); |
| pub fn VarBstrCmp( |
| bstrLeft: BSTR, |
| bstrRight: BSTR, |
| lcid: LCID, |
| dwFlags: ULONG, |
| ); |
| pub fn VarR8Pow( |
| dblLeft: c_double, |
| dblRight: c_double, |
| pdblResult: *mut c_double, |
| ); |
| pub fn VarR4CmpR8( |
| fltLeft: c_float, |
| dblRight: c_double, |
| ); |
| pub fn VarR8Round( |
| dblIn: c_double, |
| cDecimals: c_int, |
| pdblResult: *mut c_double, |
| ); |
| pub fn GetAltMonthNames( |
| lcid: LCID, |
| prgp: *mut LPOLESTR, |
| ); |
| } |
| pub type DISPID = LONG; |
| pub type MEMBERID = DISPID; |
| pub const MEMBERID_NIL: MEMBERID = DISPID_UNKNOWN; |
| pub const DISPATCH_METHOD: WORD = 0x1; |
| pub const DISPATCH_PROPERTYGET: WORD = 0x2; |
| pub const DISPATCH_PROPERTYPUT: WORD = 0x4; |
| pub const DISPATCH_PROPERTYPUTREF: WORD = 0x8; |
| ENUM!{enum REGKIND { |
| REGKIND_DEFAULT = 0, |
| REGKIND_REGISTER, |
| REGKIND_NONE, |
| }} |
| extern "system" { |
| pub fn LoadTypeLibEx( |
| szFile: LPCOLESTR, |
| regkind: REGKIND, |
| pptlib: *mut *mut ITypeLib, |
| ) -> HRESULT; |
| pub fn RevokeActiveObject( |
| dwRegister: DWORD, |
| pvReserved: *mut c_void, |
| ); |
| pub fn SetErrorInfo( |
| dwReserved: ULONG, |
| perrinfo: *mut IErrorInfo, |
| ) -> HRESULT; |
| pub fn GetErrorInfo( |
| dwReserved: ULONG, |
| pperrinfo: *mut *mut IErrorInfo, |
| ) -> HRESULT; |
| pub fn CreateErrorInfo( |
| pperrinfo: *mut *mut ICreateErrorInfo, |
| ) -> HRESULT; |
| pub fn OaBuildVersion() -> ULONG; |
| pub fn OaEnablePerUserTLibRegistration(); |
| } |
