Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 849 insertions, 0 deletions

diff --git a/vendor/winapi/src/um/oleauto.rs b/vendor/winapi/src/um/oleauto.rs
new file mode 100644
index 000000000..194ef0598
--- /dev/null
+++ b/vendor/winapi/src/um/oleauto.rs
@@ -0,0 +1,849 @@
+// 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();
+}