diff --git a/base/applications/cmdutils/wscript/widl.q0aaaa b/base/applications/cmdutils/wscript/widl.q0aaaa new file mode 100644 index 0000000000000..885ccc21be2f8 --- /dev/null +++ b/base/applications/cmdutils/wscript/widl.q0aaaa @@ -0,0 +1,1632 @@ +# 1 "C:/Users/darkfire/Desktop/d3dsync/new/reactos/sdk/include/psdk/oaidl.idl" 1 + + + + + + + + + + + + + + + + + + + +import "objidl.idl"; + + +interface IDispatch; +interface ITypeInfo; +interface ITypeLib; +interface IRecordInfo; + +[ + version(1.0), + pointer_default(unique) +] +interface IOleAutomationTypes +{ + +typedef CY CURRENCY; + + + +typedef struct tagSAFEARRAYBOUND { + ULONG cElements; + LONG lLbound; +} SAFEARRAYBOUND, *LPSAFEARRAYBOUND; + +typedef [unique] struct _wireVARIANT *wireVARIANT; +typedef [unique] struct _wireBRECORD *wireBRECORD; + +typedef struct _wireSAFEARR_BSTR { + ULONG Size; + [size_is(Size), ref] wireBSTR *aBstr; +} SAFEARR_BSTR; + +typedef struct _wireSAFEARR_UNKNOWN { + ULONG Size; + [size_is(Size), ref] IUnknown **apUnknown; +} SAFEARR_UNKNOWN; + +typedef struct _wireSAFEARR_DISPATCH { + ULONG Size; + [size_is(Size), ref] IDispatch **apDispatch; +} SAFEARR_DISPATCH; + +typedef struct _wireSAFEARR_VARIANT { + ULONG Size; + [size_is(Size), ref] wireVARIANT *aVariant; +} SAFEARR_VARIANT; + +typedef struct _wireSAFEARR_BRECORD { + ULONG Size; + [size_is(Size), ref] wireBRECORD *aRecord; +} SAFEARR_BRECORD; + +typedef struct _wireSAFEARR_HAVEIID { + ULONG Size; + [size_is(Size), ref] IUnknown **apUnknown; + IID iid; +} SAFEARR_HAVEIID; + +typedef [v1_enum] enum tagSF_TYPE { + SF_ERROR = VT_ERROR, + SF_I1 = VT_I1, + SF_I2 = VT_I2, + SF_I4 = VT_I4, + SF_I8 = VT_I8, + SF_BSTR = VT_BSTR, + SF_UNKNOWN = VT_UNKNOWN, + SF_DISPATCH = VT_DISPATCH, + SF_VARIANT = VT_VARIANT, + SF_RECORD = VT_RECORD, + SF_HAVEIID = VT_UNKNOWN|VT_RESERVED, +} SF_TYPE; + +typedef union _wireSAFEARRAY_UNION switch(ULONG sfType) u { + case SF_BSTR: SAFEARR_BSTR BstrStr; + case SF_UNKNOWN: SAFEARR_UNKNOWN UnknownStr; + case SF_DISPATCH: SAFEARR_DISPATCH DispatchStr; + case SF_VARIANT: SAFEARR_VARIANT VariantStr; + case SF_RECORD: SAFEARR_BRECORD RecordStr; + case SF_HAVEIID: SAFEARR_HAVEIID HaveIidStr; + case SF_I1: BYTE_SIZEDARR ByteStr; + case SF_I2: WORD_SIZEDARR WordStr; + case SF_I4: DWORD_SIZEDARR LongStr; + case SF_I8: HYPER_SIZEDARR HyperStr; +} SAFEARRAYUNION; + +typedef [unique] struct _wireSAFEARRAY { + USHORT cDims; + USHORT fFeatures; + ULONG cbElements; + ULONG cLocks; + SAFEARRAYUNION uArrayStructs; + [size_is(cDims)] SAFEARRAYBOUND rgsabound[]; +} *wireSAFEARRAY; + +typedef [unique] wireSAFEARRAY *wirePSAFEARRAY; + +typedef struct tagSAFEARRAY { + USHORT cDims; + USHORT fFeatures; + ULONG cbElements; + ULONG cLocks; + PVOID pvData; + SAFEARRAYBOUND rgsabound[]; +} SAFEARRAY; + +typedef [wire_marshal(wirePSAFEARRAY)] SAFEARRAY *LPSAFEARRAY; + +const USHORT FADF_AUTO = 0x0001; +const USHORT FADF_STATIC = 0x0002; +const USHORT FADF_EMBEDDED = 0x0004; +const USHORT FADF_FIXEDSIZE = 0x0010; +const USHORT FADF_RECORD = 0x0020; +const USHORT FADF_HAVEIID = 0x0040; +const USHORT FADF_HAVEVARTYPE = 0x0080; +const USHORT FADF_BSTR = 0x0100; +const USHORT FADF_UNKNOWN = 0x0200; +const USHORT FADF_DISPATCH = 0x0400; +const USHORT FADF_VARIANT = 0x0800; +const USHORT FADF_RESERVED = 0xF008; + +const USHORT FADF_DATADELETED = 0x1000; +const USHORT FADF_CREATEVECTOR = 0x2000; + + + +cpp_quote("#if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION)") +cpp_quote("#define __VARIANT_NAME_1 n1") +cpp_quote("#define __VARIANT_NAME_2 n2") +cpp_quote("#define __VARIANT_NAME_3 n3") +cpp_quote("#define __VARIANT_NAME_4 brecVal") +cpp_quote("#else") +cpp_quote("#define __tagVARIANT") +cpp_quote("#define __VARIANT_NAME_1") +cpp_quote("#define __VARIANT_NAME_2") +cpp_quote("#define __VARIANT_NAME_3") +cpp_quote("#define __tagBRECORD") +cpp_quote("#define __VARIANT_NAME_4") +cpp_quote("#endif") + +typedef [wire_marshal(wireVARIANT)] struct tagVARIANT VARIANT; + +struct tagVARIANT { + union { + struct __tagVARIANT { + VARTYPE vt; + WORD wReserved1; + WORD wReserved2; + WORD wReserved3; + union { + signed char cVal; + USHORT uiVal; + ULONG ulVal; + INT intVal; + UINT uintVal; + BYTE bVal; + SHORT iVal; + LONG lVal; + FLOAT fltVal; + DOUBLE dblVal; + VARIANT_BOOL boolVal; + + + + SCODE scode; + DATE date; + BSTR bstrVal; + CY cyVal; + IUnknown *punkVal; + IDispatch *pdispVal; + SAFEARRAY *parray; + LONGLONG llVal; + ULONGLONG ullVal; + signed char *pcVal; + USHORT *puiVal; + ULONG *pulVal; + INT *pintVal; + UINT *puintVal; + BYTE *pbVal; + SHORT *piVal; + LONG *plVal; + FLOAT *pfltVal; + DOUBLE *pdblVal; + VARIANT_BOOL *pboolVal; + + + + SCODE *pscode; + DATE *pdate; + BSTR *pbstrVal; + VARIANT *pvarVal; + PVOID byref; + CY *pcyVal; + DECIMAL *pdecVal; + IUnknown **ppunkVal; + IDispatch **ppdispVal; + SAFEARRAY **pparray; + LONGLONG *pllVal; + ULONGLONG *pullVal; + struct __tagBRECORD { + PVOID pvRecord; + IRecordInfo *pRecInfo; + } __VARIANT_NAME_4; + } __VARIANT_NAME_3; + } __VARIANT_NAME_2; + + DECIMAL decVal; + } __VARIANT_NAME_1; +}; + +typedef VARIANT *LPVARIANT; +typedef VARIANT VARIANTARG; +typedef VARIANTARG *LPVARIANTARG; + +struct _wireBRECORD { + ULONG fFlags; + ULONG clSize; + IRecordInfo *pRecInfo; + [size_is(clSize)] byte *pRecord; +}; + +struct _wireVARIANT { + DWORD clSize; + DWORD rpcReserved; + USHORT vt; + USHORT wReserved1; + USHORT wReserved2; + USHORT wReserved3; + [switch_is(vt)] union { + [case(VT_EMPTY, VT_NULL)] ; + [case(VT_I1)] signed char cVal; + [case(VT_UI2)] USHORT uiVal; + [case(VT_UI4)] ULONG ulVal; + [case(VT_INT)] INT intVal; + [case(VT_UINT)] UINT uintVal; + [case(VT_UI1)] BYTE bVal; + [case(VT_I2)] SHORT iVal; + [case(VT_I4)] LONG lVal; + [case(VT_R4)] FLOAT fltVal; + [case(VT_R8)] DOUBLE dblVal; + [case(VT_BOOL)] VARIANT_BOOL boolVal; + [case(VT_ERROR)] SCODE scode; + [case(VT_DATE)] DATE date; + [case(VT_BSTR)] wireBSTR bstrVal; + [case(VT_CY)] CY cyVal; + [case(VT_DECIMAL)] DECIMAL decVal; + [case(VT_UNKNOWN)] IUnknown *punkVal; + [case(VT_DISPATCH)] IDispatch *pdispVal; + [case(VT_ARRAY)] wireSAFEARRAY parray; + [case(VT_I1|VT_BYREF)] signed char *pcVal; + [case(VT_UI2|VT_BYREF)] USHORT *puiVal; + [case(VT_UI4|VT_BYREF)] ULONG *pulVal; + [case(VT_INT|VT_BYREF)] INT *pintVal; + [case(VT_UINT|VT_BYREF)] UINT *puintVal; + [case(VT_UI1|VT_BYREF)] BYTE *pbVal; + [case(VT_I2|VT_BYREF)] SHORT *piVal; + [case(VT_I4|VT_BYREF)] LONG *plVal; + [case(VT_R4|VT_BYREF)] FLOAT *pfltVal; + [case(VT_R8|VT_BYREF)] DOUBLE *pdblVal; + [case(VT_BOOL|VT_BYREF)] VARIANT_BOOL *pboolVal; + [case(VT_ERROR|VT_BYREF)] SCODE *pscode; + [case(VT_DATE|VT_BYREF)] DATE *pdate; + [case(VT_BSTR|VT_BYREF)] wireBSTR *pbstrVal; + [case(VT_VARIANT|VT_BYREF)] wireVARIANT *pvarVal; + [case(VT_CY|VT_BYREF)] CY *pcyVal; + [case(VT_DECIMAL|VT_BYREF)] DECIMAL *pdecVal; + [case(VT_UNKNOWN|VT_BYREF)] IUnknown **ppunkVal; + [case(VT_DISPATCH|VT_BYREF)] IDispatch **ppdispVal; + [case(VT_ARRAY|VT_BYREF)] wireSAFEARRAY *pparray; + [case(VT_RECORD, VT_RECORD|VT_BYREF)] wireBRECORD brecVal; + } DUMMYUNIONNAME; +}; + + + +typedef LONG DISPID; +typedef DWORD HREFTYPE; +typedef DISPID MEMBERID; + +typedef [v1_enum] enum tagTYPEKIND { + TKIND_ENUM = 0, + TKIND_RECORD, + TKIND_MODULE, + TKIND_INTERFACE, + TKIND_DISPATCH, + TKIND_COCLASS, + TKIND_ALIAS, + TKIND_UNION, + TKIND_MAX +} TYPEKIND; + +typedef struct tagTYPEDESC { + [switch_is(vt)] union { + [case(VT_PTR, VT_SAFEARRAY)] struct tagTYPEDESC *lptdesc; + [case(VT_CARRAY)] struct tagARRAYDESC *lpadesc; + [case(VT_USERDEFINED)] HREFTYPE hreftype; + [default] ; + } DUMMYUNIONNAME; + VARTYPE vt; +} TYPEDESC; + +typedef struct tagARRAYDESC { + TYPEDESC tdescElem; + USHORT cDims; + [size_is(cDims)] SAFEARRAYBOUND rgbounds[]; +} ARRAYDESC; + +typedef struct tagPARAMDESCEX { + ULONG cBytes; + VARIANTARG varDefaultValue; +} PARAMDESCEX, *LPPARAMDESCEX; + +typedef struct tagPARAMDESC { + LPPARAMDESCEX pparamdescex; + USHORT wParamFlags; +} PARAMDESC, *LPPARAMDESC; + +const USHORT PARAMFLAG_NONE = 0x00; +const USHORT PARAMFLAG_FIN = 0x01; +const USHORT PARAMFLAG_FOUT = 0x02; +const USHORT PARAMFLAG_FLCID = 0x04; +const USHORT PARAMFLAG_FRETVAL = 0x08; +const USHORT PARAMFLAG_FOPT = 0x10; +const USHORT PARAMFLAG_FHASDEFAULT = 0x20; +const USHORT PARAMFLAG_FHASCUSTDATA = 0x40; + +typedef struct tagIDLDESC { + ULONG_PTR dwReserved; + USHORT wIDLFlags; +} IDLDESC, *LPIDLDESC; + +const USHORT IDLFLAG_NONE = PARAMFLAG_NONE; +const USHORT IDLFLAG_FIN = PARAMFLAG_FIN; +const USHORT IDLFLAG_FOUT = PARAMFLAG_FOUT; +const USHORT IDLFLAG_FLCID = PARAMFLAG_FLCID; +const USHORT IDLFLAG_FRETVAL = PARAMFLAG_FRETVAL; + +cpp_quote("#if 0") +typedef struct tagELEMDESC { + TYPEDESC tdesc; + PARAMDESC paramdesc; +} ELEMDESC; +cpp_quote("#else") +cpp_quote("typedef struct tagELEMDESC {") +cpp_quote(" TYPEDESC tdesc;") +cpp_quote(" union {") +cpp_quote(" IDLDESC idldesc;") +cpp_quote(" PARAMDESC paramdesc;") +cpp_quote(" } DUMMYUNIONNAME;") +cpp_quote("} ELEMDESC, *LPELEMDESC;") +cpp_quote("#endif") + +typedef struct tagTYPEATTR { + GUID guid; + LCID lcid; + DWORD dwReserved; + MEMBERID memidConstructor; + MEMBERID memidDestructor; + LPOLESTR lpstrSchema; + ULONG cbSizeInstance; + TYPEKIND typekind; + WORD cFuncs; + WORD cVars; + WORD cImplTypes; + WORD cbSizeVft; + WORD cbAlignment; + WORD wTypeFlags; + WORD wMajorVerNum; + WORD wMinorVerNum; + TYPEDESC tdescAlias; + IDLDESC idldescType; +} TYPEATTR, *LPTYPEATTR; + +typedef struct tagDISPPARAMS { + [size_is(cArgs)] VARIANTARG *rgvarg; + [size_is(cNamedArgs)] DISPID *rgdispidNamedArgs; + UINT cArgs; + UINT cNamedArgs; +} DISPPARAMS; + +cpp_quote("#if 0") +typedef struct tagEXCEPINFO { + WORD wCode; + WORD wReserved; + BSTR bstrSource; + BSTR bstrDescription; + BSTR bstrHelpFile; + DWORD dwHelpContext; + ULONG_PTR pvReserved; + ULONG_PTR pfnDeferredFillIn; + SCODE scode; +} EXCEPINFO; +cpp_quote("#else") +cpp_quote("typedef struct tagEXCEPINFO {") +cpp_quote(" WORD wCode;") +cpp_quote(" WORD wReserved;") +cpp_quote(" BSTR bstrSource;") +cpp_quote(" BSTR bstrDescription;") +cpp_quote(" BSTR bstrHelpFile;") +cpp_quote(" DWORD dwHelpContext;") +cpp_quote(" PVOID pvReserved;") +cpp_quote(" HRESULT (__stdcall *pfnDeferredFillIn)(struct tagEXCEPINFO *);") +cpp_quote(" SCODE scode;") +cpp_quote("} EXCEPINFO, *LPEXCEPINFO;") +cpp_quote("#endif") + +typedef [v1_enum] enum tagCALLCONV { + CC_FASTCALL = 0, + CC_CDECL = 1, + CC_MSCPASCAL, + CC_PASCAL = CC_MSCPASCAL, + CC_MACPASCAL, + CC_STDCALL, + CC_FPFASTCALL, + CC_SYSCALL, + CC_MPWCDECL, + CC_MPWPASCAL, + CC_MAX +} CALLCONV; + +typedef [v1_enum] enum tagFUNCKIND { + FUNC_VIRTUAL, + FUNC_PUREVIRTUAL, + FUNC_NONVIRTUAL, + FUNC_STATIC, + FUNC_DISPATCH +} FUNCKIND; + +typedef [v1_enum] enum tagINVOKEKIND { + INVOKE_FUNC = 1, + INVOKE_PROPERTYGET = 2, + INVOKE_PROPERTYPUT = 4, + INVOKE_PROPERTYPUTREF = 8 +} INVOKEKIND; + +typedef struct tagFUNCDESC { + MEMBERID memid; + [size_is(cScodes)] SCODE *lprgscode; + [size_is(cParams)] ELEMDESC *lprgelemdescParam; + FUNCKIND funckind; + INVOKEKIND invkind; + CALLCONV callconv; + SHORT cParams; + SHORT cParamsOpt; + SHORT oVft; + SHORT cScodes; + ELEMDESC elemdescFunc; + WORD wFuncFlags; +} FUNCDESC, *LPFUNCDESC; + +typedef [v1_enum] enum tagVARKIND { + VAR_PERINSTANCE, + VAR_STATIC, + VAR_CONST, + VAR_DISPATCH +} VARKIND; + +const USHORT IMPLTYPEFLAG_FDEFAULT = 0x1; +const USHORT IMPLTYPEFLAG_FSOURCE = 0x2; +const USHORT IMPLTYPEFLAG_FRESTRICTED = 0x4; +const USHORT IMPLTYPEFLAG_FDEFAULTVTABLE = 0x8; + +typedef struct tagVARDESC { + MEMBERID memid; + LPOLESTR lpstrSchema; + [switch_is(varkind)] union { + [case(VAR_PERINSTANCE, VAR_DISPATCH, VAR_STATIC)] ULONG oInst; + [case(VAR_CONST)] VARIANT *lpvarValue; + } DUMMYUNIONNAME; + ELEMDESC elemdescVar; + WORD wVarFlags; + VARKIND varkind; +} VARDESC, *LPVARDESC; + +typedef enum tagTYPEFLAGS { + TYPEFLAG_FAPPOBJECT = 0x0001, + TYPEFLAG_FCANCREATE = 0x0002, + TYPEFLAG_FLICENSED = 0x0004, + TYPEFLAG_FPREDECLID = 0x0008, + TYPEFLAG_FHIDDEN = 0x0010, + TYPEFLAG_FCONTROL = 0x0020, + TYPEFLAG_FDUAL = 0x0040, + TYPEFLAG_FNONEXTENSIBLE = 0x0080, + TYPEFLAG_FOLEAUTOMATION = 0x0100, + TYPEFLAG_FRESTRICTED = 0x0200, + TYPEFLAG_FAGGREGATABLE = 0x0400, + TYPEFLAG_FREPLACEABLE = 0x0800, + TYPEFLAG_FDISPATCHABLE = 0x1000, + TYPEFLAG_FREVERSEBIND = 0x2000, + TYPEFLAG_FPROXY = 0x4000 +} TYPEFLAGS; + +typedef enum tagFUNCFLAGS { + FUNCFLAG_FRESTRICTED = 0x0001, + FUNCFLAG_FSOURCE = 0x0002, + FUNCFLAG_FBINDABLE = 0x0004, + FUNCFLAG_FREQUESTEDIT = 0x0008, + FUNCFLAG_FDISPLAYBIND = 0x0010, + FUNCFLAG_FDEFAULTBIND = 0x0020, + FUNCFLAG_FHIDDEN = 0x0040, + FUNCFLAG_FUSESGETLASTERROR = 0x0080, + FUNCFLAG_FDEFAULTCOLLELEM = 0x0100, + FUNCFLAG_FUIDEFAULT = 0x0200, + FUNCFLAG_FNONBROWSABLE = 0x0400, + FUNCFLAG_FREPLACEABLE = 0x0800, + FUNCFLAG_FIMMEDIATEBIND = 0x1000 +} FUNCFLAGS; + +typedef enum tagVARFLAGS { + VARFLAG_FREADONLY = 0x0001, + VARFLAG_FSOURCE = 0x0002, + VARFLAG_FBINDABLE = 0x0004, + VARFLAG_FREQUESTEDIT = 0x0008, + VARFLAG_FDISPLAYBIND = 0x0010, + VARFLAG_FDEFAULTBIND = 0x0020, + VARFLAG_FHIDDEN = 0x0040, + VARFLAG_FRESTRICTED = 0x0080, + VARFLAG_FDEFAULTCOLLELEM = 0x0100, + VARFLAG_FUIDEFAULT = 0x0200, + VARFLAG_FNONBROWSABLE = 0x0400, + VARFLAG_FREPLACEABLE = 0x0800, + VARFLAG_FIMMEDIATEBIND = 0x1000 +} VARFLAGS; + +typedef [wire_marshal(DWORD)] struct tagCLEANLOCALSTORAGE { + IUnknown *pInterface; + PVOID pStorage; + DWORD flags; +} CLEANLOCALSTORAGE; + +typedef struct tagCUSTDATAITEM { + GUID guid; + VARIANTARG varValue; +} CUSTDATAITEM, *LPCUSTDATAITEM; + +typedef struct tagCUSTDATA { + DWORD cCustData; + [size_is(cCustData)] LPCUSTDATAITEM prgCustData; +} CUSTDATA, *LPCUSTDATA; + +} + + + +[ + object, + uuid(00020400-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IDispatch : IUnknown +{ + typedef [unique] IDispatch *LPDISPATCH; + + const DISPID DISPID_UNKNOWN = -1; + const DISPID DISPID_VALUE = 0; + const DISPID DISPID_PROPERTYPUT = -3; + const DISPID DISPID_NEWENUM = -4; + const DISPID DISPID_EVALUATE = -5; + const DISPID DISPID_CONSTRUCTOR = -6; + const DISPID DISPID_DESTRUCTOR = -7; + const DISPID DISPID_COLLECT = -8; + + HRESULT GetTypeInfoCount( + [out] UINT *pctinfo); + + HRESULT GetTypeInfo( + [in] UINT iTInfo, + [in] LCID lcid, + [out] ITypeInfo **ppTInfo); + + HRESULT GetIDsOfNames( + [in] REFIID riid, + [in, size_is(cNames)] LPOLESTR *rgszNames, + [in] UINT cNames, + [in] LCID lcid, + [out, size_is(cNames)] DISPID *rgDispId); + + [local] + HRESULT Invoke( + [in] DISPID dispIdMember, + [in] REFIID riid, + [in] LCID lcid, + [in] WORD wFlags, + [in, out] DISPPARAMS *pDispParams, + [out] VARIANT *pVarResult, + [out] EXCEPINFO *pExcepInfo, + [out] UINT *puArgErr); + + [call_as(Invoke)] + HRESULT RemoteInvoke( + [in] DISPID dispIdMember, + [in] REFIID riid, + [in] LCID lcid, + [in] DWORD dwFlags, + [in] DISPPARAMS *pDispParams, + [out] VARIANT *pVarResult, + [out] EXCEPINFO *pExcepInfo, + [out] UINT *pArgErr, + [in] UINT cVarRef, + [in, size_is(cVarRef)] UINT *rgVarRefIdx, + [in, out, size_is(cVarRef)] VARIANTARG *rgVarRef); +} + +[ + object, + uuid(00020404-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface IEnumVARIANT : IUnknown +{ + typedef [unique] IEnumVARIANT *LPENUMVARIANT; + + [local] + HRESULT Next( + [in] ULONG celt, + [out] VARIANT *rgVar, + [out] ULONG *pCeltFetched); + + [call_as(Next)] + HRESULT RemoteNext( + [in] ULONG celt, + [out, size_is(celt), length_is(*pCeltFetched)] + VARIANT *rgVar, + [out] ULONG *pCeltFetched); + + HRESULT Skip( + [in] ULONG celt); + + HRESULT Reset(); + + HRESULT Clone( + [out] IEnumVARIANT **ppEnum); +} + +[ + object, + uuid(00020403-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ITypeComp : IUnknown +{ + typedef [unique] ITypeComp *LPTYPECOMP; + + typedef [v1_enum] enum tagDESCKIND { + DESCKIND_NONE = 0, + DESCKIND_FUNCDESC, + DESCKIND_VARDESC, + DESCKIND_TYPECOMP, + DESCKIND_IMPLICITAPPOBJ, + DESCKIND_MAX + } DESCKIND; + + typedef union tagBINDPTR { + FUNCDESC *lpfuncdesc; + VARDESC *lpvardesc; + ITypeComp *lptcomp; + } BINDPTR, *LPBINDPTR; + + [local] + HRESULT Bind( + [in] LPOLESTR szName, + [in] ULONG lHashVal, + [in] WORD wFlags, + [out] ITypeInfo **ppTInfo, + [out] DESCKIND *pDescKind, + [out] BINDPTR *pBindPtr); + + [call_as(Bind)] + HRESULT RemoteBind( + [in] LPOLESTR szName, + [in] ULONG lHashVal, + [in] WORD wFlags, + [out] ITypeInfo **ppTInfo, + [out] DESCKIND *pDescKind, + [out] LPFUNCDESC *ppFuncDesc, + [out] LPVARDESC *ppVarDesc, + [out] ITypeComp **ppTypeComp, + [out] CLEANLOCALSTORAGE *pDummy); + + [local] + HRESULT BindType( + [in] LPOLESTR szName, + [in] ULONG lHashVal, + [out] ITypeInfo **ppTInfo, + [out] ITypeComp **ppTComp); + + [call_as(BindType)] + HRESULT RemoteBindType( + [in] LPOLESTR szName, + [in] ULONG lHashVal, + [out] ITypeInfo **ppTInfo); +} + +[ + object, + uuid(00020401-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ITypeInfo : IUnknown +{ + typedef [unique] ITypeInfo *LPTYPEINFO; + + [local] + HRESULT GetTypeAttr( + [out] TYPEATTR **ppTypeAttr); + + [call_as(GetTypeAttr)] + HRESULT RemoteGetTypeAttr( + [out] LPTYPEATTR *ppTypeAttr, + [out] CLEANLOCALSTORAGE *pDummy); + + HRESULT GetTypeComp( + [out] ITypeComp **ppTComp); + + [local] + HRESULT GetFuncDesc( + [in] UINT index, + [out] FUNCDESC **ppFuncDesc); + + [call_as(GetFuncDesc)] + HRESULT RemoteGetFuncDesc( + [in] UINT index, + [out] LPFUNCDESC *ppFuncDesc, + [out] CLEANLOCALSTORAGE *pDummy); + + [local] + HRESULT GetVarDesc( + [in] UINT index, + [out] VARDESC **ppVarDesc); + + [call_as(GetVarDesc)] + HRESULT RemoteGetVarDesc( + [in] UINT index, + [out] LPVARDESC *ppVarDesc, + [out] CLEANLOCALSTORAGE *pDummy); + + [local] + HRESULT GetNames( + [in] MEMBERID memid, + [out, size_is(cMaxNames), length_is(*pcNames)] BSTR *rgBstrNames, + [in] UINT cMaxNames, + [out] UINT *pcNames); + + [call_as(GetNames)] + HRESULT RemoteGetNames( + [in] MEMBERID memid, + [out, size_is(cMaxNames), length_is(*pcNames)] BSTR *rgBstrNames, + [in] UINT cMaxNames, + [out] UINT *pcNames); + + HRESULT GetRefTypeOfImplType( + [in] UINT index, + [out] HREFTYPE *pRefType); + + HRESULT GetImplTypeFlags( + [in] UINT index, + [out] INT *pImplTypeFlags); + + [local] + HRESULT GetIDsOfNames( + [in, size_is(cNames)] LPOLESTR *rgszNames, + [in] UINT cNames, + [out, size_is(cNames)] MEMBERID *pMemId); + + [call_as(GetIDsOfNames)] + HRESULT LocalGetIDsOfNames(); + + [local] + HRESULT Invoke( + [in] PVOID pvInstance, + [in] MEMBERID memid, + [in] WORD wFlags, + [in, out] DISPPARAMS *pDispParams, + [out] VARIANT *pVarResult, + [out] EXCEPINFO *pExcepInfo, + [out] UINT *puArgErr); + + [call_as(Invoke)] + HRESULT LocalInvoke(); + + [local] + HRESULT GetDocumentation( + [in] MEMBERID memid, + [out] BSTR *pBstrName, + [out] BSTR *pBstrDocString, + [out] DWORD *pdwHelpContext, + [out] BSTR *pBstrHelpFile); + + [call_as(GetDocumentation)] + HRESULT RemoteGetDocumentation( + [in] MEMBERID memid, + [in] DWORD refPtrFlags, + [out] BSTR *pBstrName, + [out] BSTR *pBstrDocString, + [out] DWORD *pdwHelpContext, + [out] BSTR *pBstrHelpFile); + + [local] + HRESULT GetDllEntry( + [in] MEMBERID memid, + [in] INVOKEKIND invKind, + [out] BSTR *pBstrDllName, + [out] BSTR *pBstrName, + [out] WORD *pwOrdinal); + + [call_as(GetDllEntry)] + HRESULT RemoteGetDllEntry( + [in] MEMBERID memid, + [in] INVOKEKIND invKind, + [in] DWORD refPtrFlags, + [out] BSTR *pBstrDllName, + [out] BSTR *pBstrName, + [out] WORD *pwOrdinal); + + HRESULT GetRefTypeInfo( + [in] HREFTYPE hRefType, + [out] ITypeInfo **ppTInfo); + + [local] + HRESULT AddressOfMember( + [in] MEMBERID memid, + [in] INVOKEKIND invKind, + [out] PVOID *ppv); + + [call_as(AddressOfMember)] + HRESULT LocalAddressOfMember(); + + [local] + HRESULT CreateInstance( + [in] IUnknown *pUnkOuter, + [in] REFIID riid, + [out, iid_is(riid)] PVOID *ppvObj); + + [call_as(CreateInstance)] + HRESULT RemoteCreateInstance( + [in] REFIID riid, + [out, iid_is(riid)] IUnknown **ppvObj); + + HRESULT GetMops( + [in] MEMBERID memid, + [out] BSTR *pBstrMops); + + [local] + HRESULT GetContainingTypeLib( + [out] ITypeLib **ppTLib, + [out] UINT *pIndex); + + [call_as(GetContainingTypeLib)] + HRESULT RemoteGetContainingTypeLib( + [out] ITypeLib **ppTLib, + [out] UINT *pIndex); + + [local] + void ReleaseTypeAttr( + [in] TYPEATTR *pTypeAttr); + + [call_as(ReleaseTypeAttr)] + HRESULT LocalReleaseTypeAttr(); + + [local] + void ReleaseFuncDesc( + [in] FUNCDESC *pFuncDesc); + + [call_as(ReleaseFuncDesc)] + HRESULT LocalReleaseFuncDesc(); + + [local] + void ReleaseVarDesc( + [in] VARDESC *pVarDesc); + + [call_as(ReleaseVarDesc)] + HRESULT LocalReleaseVarDesc(); +} + +[ + object, + uuid(00020412-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ITypeInfo2 : ITypeInfo +{ + typedef [unique] ITypeInfo2 *LPTYPEINFO2; + + HRESULT GetTypeKind( + [out] TYPEKIND *pTypeKind); + + HRESULT GetTypeFlags( + [out] ULONG *pTypeFlags); + + HRESULT GetFuncIndexOfMemId( + [in] MEMBERID memid, + [in] INVOKEKIND invKind, + [out] UINT *pFuncIndex); + + HRESULT GetVarIndexOfMemId( + [in] MEMBERID memid, + [out] UINT *pVarIndex); + + HRESULT GetCustData( + [in] REFGUID guid, + [out] VARIANT *pVarVal); + + HRESULT GetFuncCustData( + [in] UINT index, + [in] REFGUID guid, + [out] VARIANT *pVarVal); + + HRESULT GetParamCustData( + [in] UINT indexFunc, + [in] UINT indexParam, + [in] REFGUID guid, + [out] VARIANT *pVarVal); + + HRESULT GetVarCustData( + [in] UINT index, + [in] REFGUID guid, + [out] VARIANT *pVarVal); + + HRESULT GetImplTypeCustData( + [in] UINT index, + [in] REFGUID guid, + [out] VARIANT *pVarVal); + + [local] + HRESULT GetDocumentation2( + [in] MEMBERID memid, + [in] LCID lcid, + [out] BSTR *pbstrHelpString, + [out] DWORD *pdwHelpStringContext, + [out] BSTR *pbstrHelpStringDll); + + [call_as(GetDocumentation2)] + HRESULT RemoteGetDocumentation2( + [in] MEMBERID memid, + [in] LCID lcid, + [in] DWORD refPtrFlags, + [out] BSTR *pbstrHelpString, + [out] DWORD *pdwHelpStringContext, + [out] BSTR *pbstrHelpStringDll); + + HRESULT GetAllCustData( + [out] CUSTDATA *pCustData); + + HRESULT GetAllFuncCustData( + [in] UINT index, + [out] CUSTDATA *pCustData); + + HRESULT GetAllParamCustData( + [in] UINT indexFunc, + [in] UINT indexParam, + [out] CUSTDATA *pCustData); + + HRESULT GetAllVarCustData( + [in] UINT index, + [out] CUSTDATA *pCustData); + + HRESULT GetAllImplTypeCustData( + [in] UINT index, + [out] CUSTDATA *pCustData); +} + +[ + object, + uuid(00020402-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ITypeLib : IUnknown +{ + typedef [unique] ITypeLib *LPTYPELIB; + + typedef [v1_enum] enum tagSYSKIND { + SYS_WIN16 = 0, + SYS_WIN32, + SYS_MAC, + SYS_WIN64 + } SYSKIND; + + typedef [v1_enum] enum tagLIBFLAGS { + LIBFLAG_FRESTRICTED = 0x01, + LIBFLAG_FCONTROL = 0x02, + LIBFLAG_FHIDDEN = 0x04, + LIBFLAG_FHASDISKIMAGE = 0x08 + } LIBFLAGS; + + typedef struct tagTLIBATTR { + GUID guid; + LCID lcid; + SYSKIND syskind; + WORD wMajorVerNum; + WORD wMinorVerNum; + WORD wLibFlags; + } TLIBATTR, *LPTLIBATTR; + + [local] + UINT GetTypeInfoCount(); + + [call_as(GetTypeInfoCount)] + HRESULT RemoteGetTypeInfoCount( + [out] UINT *pcTInfo); + + HRESULT GetTypeInfo( + [in] UINT index, + [out] ITypeInfo **ppTInfo); + + HRESULT GetTypeInfoType( + [in] UINT index, + [out] TYPEKIND *pTKind); + + HRESULT GetTypeInfoOfGuid( + [in] REFGUID guid, + [out] ITypeInfo **ppTinfo); + + [local] + HRESULT GetLibAttr( + [out] TLIBATTR **ppTLibAttr); + + [call_as(GetLibAttr)] + HRESULT RemoteGetLibAttr( + [out] LPTLIBATTR *ppTLibAttr, + [out] CLEANLOCALSTORAGE *pDummy); + + HRESULT GetTypeComp( + [out] ITypeComp **ppTComp); + + [local] + HRESULT GetDocumentation( + [in] INT index, + [out] BSTR *pBstrName, + [out] BSTR *pBstrDocString, + [out] DWORD *pdwHelpContext, + [out] BSTR *pBstrHelpFile); + + [call_as(GetDocumentation)] + HRESULT RemoteGetDocumentation( + [in] INT index, + [in] DWORD refPtrFlags, + [out] BSTR *pBstrName, + [out] BSTR *pBstrDocString, + [out] DWORD *pdwHelpContext, + [out] BSTR *pBstrHelpFile); + + [local] + HRESULT IsName( + [in, out] LPOLESTR szNameBuf, + [in] ULONG lHashVal, + [out] BOOL *pfName); + + [call_as(IsName)] + HRESULT RemoteIsName( + [in] LPOLESTR szNameBuf, + [in] ULONG lHashVal, + [out] BOOL *pfName, + [out] BSTR *pBstrLibName); + + [local] + HRESULT FindName( + [in, out] LPOLESTR szNameBuf, + [in] ULONG lHashVal, + [out, size_is(*pcFound), length_is(*pcFound)] ITypeInfo **ppTInfo, + [out, size_is(*pcFound), length_is(*pcFound)] MEMBERID *rgMemId, + [in, out] USHORT *pcFound); + + [call_as(FindName)] + HRESULT RemoteFindName( + [in] LPOLESTR szNameBuf, + [in] ULONG lHashVal, + [out, size_is(*pcFound), length_is(*pcFound)] ITypeInfo **ppTInfo, + [out, size_is(*pcFound), length_is(*pcFound)] MEMBERID *rgMemId, + [in, out] USHORT *pcFound, + [out] BSTR *pBstrLibName); + + [local] + void ReleaseTLibAttr( + [in] TLIBATTR *pTLibAttr); + + [call_as(ReleaseTLibAttr)] + HRESULT LocalReleaseTLibAttr(); +} + +[ + object, + uuid(00020411-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ITypeLib2 : ITypeLib +{ + typedef [unique] ITypeLib2 *LPTYPELIB2; + + HRESULT GetCustData( + [in] REFGUID guid, + [out] VARIANT *pVarVal); + + [local] + HRESULT GetLibStatistics( + [out] ULONG *pcUniqueNames, + [out] ULONG *pcchUniqueNames); + + [call_as(GetLibStatistics)] + HRESULT RemoteGetLibStatistics( + [out] ULONG *pcUniqueNames, + [out] ULONG *pcchUniqueNames); + + [local] + HRESULT GetDocumentation2( + [in] INT index, + [in] LCID lcid, + [out] BSTR *pbstrHelpString, + [out] DWORD *pdwHelpStringContext, + [out] BSTR *pbstrHelpStringDll); + + [call_as(GetDocumentation2)] + HRESULT RemoteGetDocumentation2( + [in] INT index, + [in] LCID lcid, + [in] DWORD refPtrFlags, + [out] BSTR *pbstrHelpString, + [out] DWORD *pdwHelpStringContext, + [out] BSTR *pbstrHelpStringDll); + + HRESULT GetAllCustData( + [out] CUSTDATA *pCustData); +} + +[ + local, + object, + uuid(00020410-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ITypeChangeEvents : IUnknown +{ + typedef [unique] ITypeChangeEvents *LPTYPECHANGEEVENTS; + + typedef enum tagCHANGEKIND { + CHANGEKIND_ADDMEMBER, + CHANGEKIND_DELETEMEMBER, + CHANGEKIND_SETNAMES, + CHANGEKIND_SETDOCUMENTATION, + CHANGEKIND_GENERAL, + CHANGEKIND_INVALIDATE, + CHANGEKIND_CHANGEFAILED, + CHANGEKIND_MAX + } CHANGEKIND; + + HRESULT RequestTypeChange( + [in] CHANGEKIND changeKind, + [in] ITypeInfo *pTInfoBefore, + [in] LPOLESTR pStrName, + [out] INT *pfCancel); + + HRESULT AfterTypeChange( + [in] CHANGEKIND changeKind, + [in] ITypeInfo *pTInfoAfter, + [in] LPOLESTR pStrName); +} + +[ + object, + uuid(1CF2B120-547D-101B-8E65-08002B2BD119), + pointer_default(unique) +] +interface IErrorInfo : IUnknown +{ + typedef [unique] IErrorInfo *LPERRORINFO; + + HRESULT GetGUID( + [out] GUID *pGUID); + + HRESULT GetSource( + [out] BSTR *pBstrSource); + + HRESULT GetDescription( + [out] BSTR *pBstrDescription); + + HRESULT GetHelpFile( + [out] BSTR *pBstrHelpFile); + + HRESULT GetHelpContext( + [out] DWORD *pdwHelpContext); +} + +[ + object, + uuid(22F03340-547D-101B-8E65-08002B2BD119), + pointer_default(unique) +] +interface ICreateErrorInfo : IUnknown +{ + typedef [unique] ICreateErrorInfo *LPCREATEERRORINFO; + + HRESULT SetGUID( + [in] REFGUID rguid); + + HRESULT SetSource( + [in] LPOLESTR szSource); + + HRESULT SetDescription( + [in] LPOLESTR szDescription); + + HRESULT SetHelpFile( + [in] LPOLESTR szHelpFile); + + HRESULT SetHelpContext( + [in] DWORD dwHelpContext); +} + +[ + object, + uuid(DF0B3D60-548F-101B-8E65-08002B2BD119), + pointer_default(unique) +] +interface ISupportErrorInfo : IUnknown +{ + typedef [unique] ISupportErrorInfo *LPSUPPORTERRORINFO; + + HRESULT InterfaceSupportsErrorInfo( + [in] REFIID riid); +} + +[ + object, + uuid(0000002E-0000-0000-C000-000000000046) +] +interface ITypeFactory : IUnknown +{ + HRESULT CreateFromTypeInfo( + [in] ITypeInfo *pTypeInfo, + [in] REFIID riid, + [out, iid_is(riid)] IUnknown **ppv); +} + +[ + local, + object, + uuid(0000002D-0000-0000-C000-000000000046) +] +interface ITypeMarshal : IUnknown +{ + HRESULT Size( + [in] PVOID pvType, + [in] DWORD dwDestContext, + [in] PVOID pvDestContext, + [out] ULONG *pSize); + + HRESULT Marshal( + [in] PVOID pvType, + [in] DWORD dwDestContext, + [in] PVOID pvDestContext, + [in] ULONG cbBufferLength, + [out] BYTE *pBuffer, + [out] ULONG *pcbWritten); + + HRESULT Unmarshal( + [out] PVOID pvType, + [in] DWORD dwFlags, + [in] ULONG cbBufferLength, + [in] BYTE *pBuffer, + [out] ULONG *pcbRead); + + HRESULT Free( + [in] PVOID pvType); +} + +[ + local, + object, + uuid(0000002F-0000-0000-C000-000000000046) +] +interface IRecordInfo : IUnknown +{ + typedef [unique] IRecordInfo *LPRECORDINFO; + + HRESULT RecordInit( + [out] PVOID pvNew); + + HRESULT RecordClear( + [in] PVOID pvExisting); + + HRESULT RecordCopy( + [in] PVOID pvExisting, + [out] PVOID pvNew); + + HRESULT GetGuid( + [out] GUID *pguid); + + HRESULT GetName( + [out] BSTR *pbstrName); + + HRESULT GetSize( + [out] ULONG *pcbSize); + + HRESULT GetTypeInfo( + [out] ITypeInfo **ppTypeInfo); + + HRESULT GetField( + [in] PVOID pvData, + [in] LPCOLESTR szFieldName, + [out] VARIANT *pvarField); + + HRESULT GetFieldNoCopy( + [in] PVOID pvData, + [in] LPCOLESTR szFieldName, + [out] VARIANT *pvarField, + [out] PVOID *ppvDataCArray); + + HRESULT PutField( + [in] ULONG wFlags, + [in, out] PVOID pvData, + [in] LPCOLESTR szFieldName, + [in] VARIANT *pvarField); + + HRESULT PutFieldNoCopy( + [in] ULONG wFlags, + [in, out] PVOID pvData, + [in] LPCOLESTR szFieldName, + [in] VARIANT *pvarField); + + HRESULT GetFieldNames( + [in, out] ULONG *pcNames, + [out, size_is(*pcNames), length_is(*pcNames)] BSTR *rgBstrNames); + + BOOL IsMatchingType( + [in] IRecordInfo *pRecordInfo); + + PVOID RecordCreate(); + + HRESULT RecordCreateCopy( + [in] PVOID pvSource, + [out] PVOID *ppvDest); + + HRESULT RecordDestroy( + [in] PVOID pvRecord); +} + +[ + local, + object, + uuid(00020405-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ICreateTypeInfo : IUnknown +{ + typedef [unique] ICreateTypeInfo *LPCREATETYPEINFO; + + HRESULT SetGuid( + [in] REFGUID guid); + + HRESULT SetTypeFlags( + [in] UINT uTypeFlags); + + HRESULT SetDocString( + [in] LPOLESTR pStrDoc); + + HRESULT SetHelpContext( + [in] DWORD dwHelpContext); + + HRESULT SetVersion( + [in] WORD wMajorVerNum, + [in] WORD wMinorVerNum); + + HRESULT AddRefTypeInfo( + [in] ITypeInfo *pTInfo, + [in] HREFTYPE *phRefType); + + HRESULT AddFuncDesc( + [in] UINT index, + [in] FUNCDESC *pFuncDesc); + + HRESULT AddImplType( + [in] UINT index, + [in] HREFTYPE hRefType); + + HRESULT SetImplTypeFlags( + [in] UINT index, + [in] INT implTypeFlags); + + HRESULT SetAlignment( + [in] WORD cbAlignment); + + HRESULT SetSchema( + [in] LPOLESTR pStrSchema); + + HRESULT AddVarDesc( + [in] UINT index, + [in] VARDESC *pVarDesc); + + HRESULT SetFuncAndParamNames( + [in] UINT index, + [in, size_is(cNames)] LPOLESTR *rgszNames, + [in] UINT cNames); + + HRESULT SetVarName( + [in] UINT index, + [in] LPOLESTR szName); + + HRESULT SetTypeDescAlias( + [in] TYPEDESC *pTDescAlias); + + HRESULT DefineFuncAsDllEntry( + [in] UINT index, + [in] LPOLESTR szDllName, + [in] LPOLESTR szProcName); + + HRESULT SetFuncDocString( + [in] UINT index, + [in] LPOLESTR szDocString); + + HRESULT SetVarDocString( + [in] UINT index, + [in] LPOLESTR szDocString); + + HRESULT SetFuncHelpContext( + [in] UINT index, + [in] DWORD dwHelpContext); + + HRESULT SetVarHelpContext( + [in] UINT index, + [in] DWORD dwHelpContext); + + HRESULT SetMops( + [in] UINT index, + [in] BSTR bstrMops); + + HRESULT SetTypeIdldesc( + [in] IDLDESC * pIdlDesc); + + HRESULT LayOut(); +} + +[ + local, + object, + uuid(0002040E-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ICreateTypeInfo2 : ICreateTypeInfo +{ + typedef [unique] ICreateTypeInfo2 *LPCREATETYPEINFO2; + + HRESULT DeleteFuncDesc( + [in] UINT index); + + HRESULT DeleteFuncDescByMemId( + [in] MEMBERID memid, + [in] INVOKEKIND invKind); + + HRESULT DeleteVarDesc( + [in] UINT index); + + HRESULT DeleteVarDescByMemId( + [in] MEMBERID memid); + + HRESULT DeleteImplType( + [in] UINT index); + + HRESULT SetCustData( + [in] REFGUID guid, + [in] VARIANT *pVarVal); + + HRESULT SetFuncCustData( + [in] UINT index, + [in] REFGUID guid, + [in] VARIANT *pVarVal); + + HRESULT SetParamCustData( + [in] UINT indexFunc, + [in] UINT indexParam, + [in] REFGUID guid, + [in] VARIANT *pVarVal); + + HRESULT SetVarCustData( + [in] UINT index, + [in] REFGUID guid, + [in] VARIANT *pVarVal); + + HRESULT SetImplTypeCustData( + [in] UINT index, + [in] REFGUID guid, + [in] VARIANT *pVarVal); + + HRESULT SetHelpStringContext( + [in] ULONG dwHelpStringContext); + + HRESULT SetFuncHelpStringContext( + [in] UINT index, + [in] ULONG dwHelpStringContext); + + HRESULT SetVarHelpStringContext( + [in] UINT index, + [in] ULONG dwHelpStringContext); + + HRESULT Invalidate(); + + HRESULT SetName( + [in] LPOLESTR szName); +} + +[ + local, + object, + uuid(00020406-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ICreateTypeLib : IUnknown +{ + typedef [unique] ICreateTypeLib *LPCREATETYPELIB; + + HRESULT CreateTypeInfo( + [in] LPOLESTR szName, + [in] TYPEKIND tkind, + [out] ICreateTypeInfo **ppCTInfo); + + HRESULT SetName( + [in] LPOLESTR szName); + + HRESULT SetVersion( + [in] WORD wMajorVerNum, + [in] WORD wMinorVerNum); + + HRESULT SetGuid( + [in] REFGUID guid); + + HRESULT SetDocString( + [in] LPOLESTR szDoc); + + HRESULT SetHelpFileName( + [in] LPOLESTR szHelpFileName); + + HRESULT SetHelpContext( + [in] DWORD dwHelpContext); + + HRESULT SetLcid( + [in] LCID lcid); + + HRESULT SetLibFlags( + [in] UINT uLibFlags); + + HRESULT SaveAllChanges(); +} + +[ + local, + object, + uuid(0002040F-0000-0000-C000-000000000046), + pointer_default(unique) +] +interface ICreateTypeLib2 : ICreateTypeLib +{ + typedef [unique] ICreateTypeLib2 *LPCREATETYPELIB2; + + HRESULT DeleteTypeInfo( + [in] LPOLESTR szName); + + HRESULT SetCustData( + [in] REFGUID guid, + [in] VARIANT *pVarVal); + + HRESULT SetHelpStringContext( + [in] ULONG dwHelpStringContext); + + HRESULT SetHelpStringDll( + [in] LPOLESTR szFileName); +} + + + + + +[ + object, + uuid(3127ca40-446e-11ce-8135-00aa004bb851), + pointer_default(unique) +] +interface IErrorLog : IUnknown +{ + typedef IErrorLog *LPERRORLOG; + + HRESULT AddError( + [in] LPCOLESTR pszPropName, + [in] EXCEPINFO *pExcepInfo); +} + + + + + +[ + object, + uuid(55272a00-42cb-11ce-8135-00aa004bb851), + pointer_default(unique) +] +interface IPropertyBag : IUnknown +{ + typedef IPropertyBag *LPPROPERTYBAG; + + [local] + HRESULT Read( + [in] LPCOLESTR pszPropName, + [in, out] VARIANT *pVar, + [in] IErrorLog *pErrorLog); + + [call_as(Read)] + HRESULT RemoteRead( + [in] LPCOLESTR pszPropName, + [out] VARIANT *pVar, + [in] IErrorLog *pErrorLog, + [in] DWORD varType, + [in] IUnknown *pUnkObj); + + HRESULT Write( + [in] LPCOLESTR pszPropName, + [in] VARIANT *pVar); +} diff --git a/dll/directx/wine/wined3d/context.c b/dll/directx/wine/wined3d/context.c index 525711e353bdd..8d19b6ad442ef 100644 --- a/dll/directx/wine/wined3d/context.c +++ b/dll/directx/wine/wined3d/context.c @@ -5660,7 +5660,7 @@ void wined3d_context_gl_draw_shaded_quad(struct wined3d_context_gl *context_gl, GL_EXTCALL(glBufferData(GL_ARRAY_BUFFER, sizeof(quad), quad, GL_STREAM_DRAW)); GL_EXTCALL(glVertexAttribPointer(0, 2, GL_FLOAT, FALSE, sizeof(*quad), NULL)); GL_EXTCALL(glVertexAttribPointer(1, 3, GL_FLOAT, FALSE, sizeof(*quad), - (void *)FIELD_OFFSET(struct blit_vertex, texcoord))); + (PVOID)(ULONG_PTR)FIELD_OFFSET(struct blit_vertex, texcoord))); GL_EXTCALL(glEnableVertexAttribArray(0)); GL_EXTCALL(glEnableVertexAttribArray(1)); diff --git a/dll/win32/kernel32/kernel32.spec b/dll/win32/kernel32/kernel32.spec index eda82b9285fba..a6f2f81b6368c 100644 --- a/dll/win32/kernel32/kernel32.spec +++ b/dll/win32/kernel32/kernel32.spec @@ -715,7 +715,7 @@ @ stdcall InitializeCriticalSection(ptr) @ stdcall InitializeCriticalSectionAndSpinCount(ptr long) @ stdcall -version=0x600+ InitializeCriticalSectionEx(ptr long long) -@ stdcall -stub -version=0x600+ InitializeProcThreadAttributeList(ptr long long ptr) +@ stdcall -version=0x600+ InitializeProcThreadAttributeList(ptr long long ptr) @ stdcall InitializeSListHead(ptr) ntdll.RtlInitializeSListHead @ stdcall -version=0x600+ InitializeSRWLock(ptr) ntdll.RtlInitializeSRWLock @ stdcall -arch=i386 -ret64 InterlockedCompareExchange64(ptr double double) ntdll.RtlInterlockedCompareExchange64 @@ -1286,8 +1286,6 @@ @ stdcall -version=0x600+ K32QueryWorkingSet(ptr ptr long) @ stdcall -version=0x600+ K32QueryWorkingSetEx(ptr ptr long) @ stdcall -version=0x600+ K32GetMappedFileNameW(ptr ptr ptr long) -@ stdcall -stub -version=0x600+ K32GetProcessImageFileNameW(ptr ptr long) - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; #Vista Functions diff --git a/dll/win32/kernel32/kernel32_vista/k32.c b/dll/win32/kernel32/kernel32_vista/k32.c index be169ef4796a3..457c540f0f396 100644 --- a/dll/win32/kernel32/kernel32_vista/k32.c +++ b/dll/win32/kernel32/kernel32_vista/k32.c @@ -671,51 +671,6 @@ BOOL WINAPI K32GetModuleInformation(HANDLE process, HMODULE module, } - -/*********************************************************************** - * K32EnumProcesses (KERNEL32.@) - */ -BOOL WINAPI K32EnumProcesses(DWORD *lpdwProcessIDs, DWORD cb, DWORD *lpcbUsed) -{ - SYSTEM_PROCESS_INFORMATION *spi; - ULONG size = 0x4000; - void *buf = NULL; - NTSTATUS status; - - do { - size *= 2; - HeapFree(GetProcessHeap(), 0, buf); - buf = HeapAlloc(GetProcessHeap(), 0, size); - if (!buf) - return FALSE; - - status = NtQuerySystemInformation(SystemProcessInformation, buf, size, NULL); - } while(status == STATUS_INFO_LENGTH_MISMATCH); - - if (status != STATUS_SUCCESS) - { - HeapFree(GetProcessHeap(), 0, buf); - SetLastError(RtlNtStatusToDosError(status)); - return FALSE; - } - - spi = buf; - - for (*lpcbUsed = 0; cb >= sizeof(DWORD); cb -= sizeof(DWORD)) - { - *lpdwProcessIDs++ = HandleToUlong(spi->UniqueProcessId); - *lpcbUsed += sizeof(DWORD); - - if (spi->NextEntryOffset == 0) - break; - - spi = (SYSTEM_PROCESS_INFORMATION *)(((PCHAR)spi) + spi->NextEntryOffset); - } - - HeapFree(GetProcessHeap(), 0, buf); - return TRUE; -} - typedef struct _PROCESS_MEMORY_COUNTERS { DWORD cb; DWORD PageFaultCount; @@ -730,49 +685,6 @@ typedef struct _PROCESS_MEMORY_COUNTERS { } PROCESS_MEMORY_COUNTERS; typedef PROCESS_MEMORY_COUNTERS *PPROCESS_MEMORY_COUNTERS; -/*********************************************************************** - * K32GetProcessMemoryInfo (KERNEL32.@) - * - * Retrieve memory usage information for a given process - * - */ -BOOL WINAPI K32GetProcessMemoryInfo(HANDLE process, - PPROCESS_MEMORY_COUNTERS pmc, DWORD cb) -{ - NTSTATUS status; - VM_COUNTERS vmc; - - if (cb < sizeof(PROCESS_MEMORY_COUNTERS)) - { - SetLastError(ERROR_INSUFFICIENT_BUFFER); - return FALSE; - } - - status = NtQueryInformationProcess(process, ProcessVmCounters, - &vmc, sizeof(vmc), NULL); - - if (status) - { - SetLastError(RtlNtStatusToDosError(status)); - return FALSE; - } - - pmc->cb = sizeof(PROCESS_MEMORY_COUNTERS); - pmc->PageFaultCount = vmc.PageFaultCount; - pmc->PeakWorkingSetSize = vmc.PeakWorkingSetSize; - pmc->WorkingSetSize = vmc.WorkingSetSize; - pmc->QuotaPeakPagedPoolUsage = vmc.QuotaPeakPagedPoolUsage; - pmc->QuotaPagedPoolUsage = vmc.QuotaPagedPoolUsage; - pmc->QuotaPeakNonPagedPoolUsage = vmc.QuotaPeakNonPagedPoolUsage; - pmc->QuotaNonPagedPoolUsage = vmc.QuotaNonPagedPoolUsage; - pmc->PagefileUsage = vmc.PagefileUsage; - pmc->PeakPagefileUsage = vmc.PeakPagefileUsage; - - return TRUE; -} - - - /*********************************************************************** * InitializeProcThreadAttributeList (kernelbase.@) */ @@ -792,25 +704,3 @@ struct _PROC_THREAD_ATTRIBUTE_LIST struct proc_thread_attr attrs[10]; }; - -BOOL -K32QueryWorkingSet( - HANDLE hProcess, - PVOID pv, - DWORD cb -) -{ - UNIMPLEMENTED; - return TRUE; -} - -BOOL -K32QueryWorkingSetEx( - HANDLE hProcess, - PVOID pv, - DWORD cb -) -{ - UNIMPLEMENTED; - return TRUE; -} diff --git a/dll/win32/ole32/ole32.spec b/dll/win32/ole32/ole32.spec index 8b5d747a84eb7..13110c5fd67df 100644 --- a/dll/win32/ole32/ole32.spec +++ b/dll/win32/ole32/ole32.spec @@ -73,7 +73,6 @@ @ stdcall CoIsOle1Class (ptr) @ stdcall CoLoadLibrary(wstr long) @ stdcall CoLockObjectExternal(ptr long long) -@ stdcall -version=0x600+ CoGetApartmentType(ptr ptr) @ stdcall CoMarshalHresult(ptr long) @ stdcall CoMarshalInterThreadInterfaceInStream(ptr ptr ptr) @ stdcall CoMarshalInterface(ptr ptr ptr long ptr long) diff --git a/dll/win32_vista/shcore/main.c b/dll/win32_vista/shcore/main.c index 2d0764c7c0038..19ac75d2d73f3 100644 --- a/dll/win32_vista/shcore/main.c +++ b/dll/win32_vista/shcore/main.c @@ -70,20 +70,20 @@ BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, void *reserved) HRESULT WINAPI GetProcessDpiAwareness(HANDLE process, PROCESS_DPI_AWARENESS *value) { - if (GetProcessDpiAwarenessInternal( process, (DPI_AWARENESS *)value )) return S_OK; - return HRESULT_FROM_WIN32( GetLastError() ); + // if (GetProcessDpiAwarenessInternal( process, (DPI_AWARENESS *)value )) return S_OK; + return 0;//HRESULT_FROM_WIN32( GetLastError() ); } HRESULT WINAPI SetProcessDpiAwareness(PROCESS_DPI_AWARENESS value) { - if (SetProcessDpiAwarenessInternal( value )) return S_OK; - return HRESULT_FROM_WIN32( GetLastError() ); + // if (SetProcessDpiAwarenessInternal( value )) return S_OK; + return 0;//HRESULT_FROM_WIN32( GetLastError() ); } HRESULT WINAPI GetDpiForMonitor(HMONITOR monitor, MONITOR_DPI_TYPE type, UINT *x, UINT *y) { - if (GetDpiForMonitorInternal( monitor, type, x, y )) return S_OK; - return HRESULT_FROM_WIN32( GetLastError() ); + // if (GetDpiForMonitorInternal( monitor, type, x, y )) return S_OK; + return 1;//HRESULT_FROM_WIN32( GetLastError() ); } HRESULT diff --git a/sdk/cmake/baseaddress_msvc.cmake b/sdk/cmake/baseaddress_msvc.cmake index 28fd74618ca3d..031896bfba74c 100644 --- a/sdk/cmake/baseaddress_msvc.cmake +++ b/sdk/cmake/baseaddress_msvc.cmake @@ -1,393 +1,409 @@ -# Generated from C:\Users\darkfire\Desktop\d3dsync\new\reactos\output-VS-i386 +# Generated from C:\Users\darkfire\Desktop\d3dsync\new\reactos/output-vs-i386 # Generated by sdk/tools/gen_baseaddress.py set(baseaddress_ntdll 0x7c920000) # should be above 0x7c920000 -set(baseaddress_kernel32 0x7c680000) -set(baseaddress_msvcrt 0x7c600000) -set(baseaddress_advapi32 0x7c570000) -set(baseaddress_gdi32 0x7c510000) +set(baseaddress_kernel32 0x7c670000) +set(baseaddress_msvcrt 0x7c5d0000) +set(baseaddress_advapi32 0x7c540000) +set(baseaddress_gdi32 0x7c4e0000) set(baseaddress_user32 0x77a20000) # reserved -set(baseaddress_dhcpcsvc 0x7c4d0000) -set(baseaddress_dnsapi 0x7c490000) -set(baseaddress_icmp 0x7c470000) -set(baseaddress_iphlpapi 0x7c430000) -set(baseaddress_ws2_32 0x7c400000) -set(baseaddress_ws2help 0x7c3e0000) -set(baseaddress_shlwapi 0x7c360000) -set(baseaddress_rpcrt4 0x7c2c0000) -set(baseaddress_comctl32 0x7c170000) -set(baseaddress_ole32 0x7c020000) -set(baseaddress_winspool 0x7bfd0000) -set(baseaddress_winmm 0x7bf30000) -set(baseaddress_comdlg32 0x7be50000) -set(baseaddress_shell32 0x7b5c0000) -set(baseaddress_lz32 0x7b5a0000) -set(baseaddress_version 0x7b570000) -set(baseaddress_oleaut32 0x7b440000) -set(baseaddress_setupapi 0x7b310000) -set(baseaddress_mpr 0x7b2e0000) -set(baseaddress_crypt32 0x7b210000) -set(baseaddress_wininet 0x7b180000) -set(baseaddress_urlmon 0x7b0d0000) -set(baseaddress_psapi 0x7b0b0000) -set(baseaddress_imm32 0x7b070000) -set(baseaddress_msvfw32 0x7b030000) -set(baseaddress_dbghelp 0x7afb0000) -set(baseaddress_devmgr 0x7af00000) -set(baseaddress_msacm32 0x7aec0000) -set(baseaddress_netapi32 0x7ae50000) -set(baseaddress_powrprof 0x7ae30000) -set(baseaddress_secur32 0x7adf0000) -set(baseaddress_wintrust 0x7adb0000) -set(baseaddress_avicap32 0x7ad90000) -set(baseaddress_cabinet 0x7ad50000) -set(baseaddress_dsound 0x7acf0000) -set(baseaddress_glu32 0x7ac70000) -set(baseaddress_opengl32 0x7ab90000) -set(baseaddress_riched20 0x7ab00000) -set(baseaddress_userenv 0x7aac0000) -set(baseaddress_uxtheme 0x7aa70000) -set(baseaddress_cryptui 0x7a9d0000) -set(baseaddress_csrsrv 0x7a9a0000) -set(baseaddress_basesrv 0x7a970000) -set(baseaddress_winsrv 0x7a8f0000) -set(baseaddress_dplayx 0x7a8a0000) -set(baseaddress_gdiplus 0x7a800000) -set(baseaddress_msimg32 0x7a7e0000) -set(baseaddress_mswsock 0x7a7c0000) -set(baseaddress_oledlg 0x7a780000) -set(baseaddress_rasapi32 0x7a750000) -set(baseaddress_rsaenh 0x7a700000) -set(baseaddress_samlib 0x7a6d0000) -set(baseaddress_sensapi 0x7a6b0000) -set(baseaddress_sfc_os 0x7a690000) -set(baseaddress_snmpapi 0x7a670000) -set(baseaddress_spoolss 0x7a640000) -set(baseaddress_usp10 0x7a5e0000) -set(baseaddress_access 0x7a560000) -set(baseaddress_acgenral 0x7a540000) -set(baseaddress_aclayers 0x7a510000) -set(baseaddress_acledit 0x7a4f0000) -set(baseaddress_aclui 0x7a4c0000) -set(baseaddress_acppage 0x7a480000) -set(baseaddress_activeds 0x7a460000) -set(baseaddress_actxprxy 0x7a2e0000) -set(baseaddress_advapi32_vista 0x7a2c0000) -set(baseaddress_advpack 0x7a290000) -set(baseaddress_amstream 0x7a260000) -set(baseaddress_apphelp 0x7a220000) -set(baseaddress_appwiz 0x7a1b0000) -set(baseaddress_atl 0x7a180000) -set(baseaddress_atl100 0x7a150000) -set(baseaddress_atl80 0x7a120000) -set(baseaddress_authz 0x7a100000) -set(baseaddress_avifil32 0x7a0b0000) -set(baseaddress_avrt 0x7a090000) -set(baseaddress_batt 0x7a070000) -set(baseaddress_bcrypt 0x7a040000) -set(baseaddress_beepmidi 0x7a020000) -set(baseaddress_browser 0x7a000000) -set(baseaddress_browseui 0x79ee0000) -set(baseaddress_bthci 0x79ec0000) -set(baseaddress_bthprops 0x79ea0000) -set(baseaddress_cards 0x79de0000) -set(baseaddress_cfgmgr32 0x79dc0000) -set(baseaddress_clb 0x79da0000) -set(baseaddress_clusapi 0x79d70000) -set(baseaddress_cmicpl 0x79d40000) -set(baseaddress_comcat 0x79d20000) -set(baseaddress_compstui 0x79d00000) -set(baseaddress_console 0x79cb0000) -set(baseaddress_credui 0x79c70000) -set(baseaddress_crtdll 0x79c10000) -set(baseaddress_cryptdlg 0x79be0000) -set(baseaddress_cryptdll 0x79bc0000) -set(baseaddress_cryptext 0x79ba0000) -set(baseaddress_cryptnet 0x79b70000) -set(baseaddress_d3d10 0x79b20000) -set(baseaddress_d3d10_1 0x79b00000) -set(baseaddress_d3d10core 0x79ae0000) -set(baseaddress_d3d11 0x79a70000) -set(baseaddress_d3d8 0x79a30000) -set(baseaddress_d3d8thk 0x79a10000) -set(baseaddress_d3d9 0x799c0000) -set(baseaddress_d3dcompiler_43 0x79930000) -set(baseaddress_d3drm 0x798c0000) -set(baseaddress_d3dwine 0x79700000) -set(baseaddress_d3dx9_24 0x79640000) -set(baseaddress_d3dx9_25 0x79580000) -set(baseaddress_d3dx9_26 0x794c0000) -set(baseaddress_d3dx9_27 0x79400000) -set(baseaddress_d3dx9_28 0x79340000) -set(baseaddress_d3dx9_29 0x79280000) -set(baseaddress_d3dx9_30 0x791c0000) -set(baseaddress_d3dx9_31 0x79100000) -set(baseaddress_d3dx9_32 0x79030000) -set(baseaddress_d3dx9_33 0x78f60000) -set(baseaddress_d3dx9_34 0x78e90000) -set(baseaddress_d3dx9_35 0x78dc0000) -set(baseaddress_d3dx9_36 0x78cf0000) -set(baseaddress_d3dx9_37 0x78c20000) -set(baseaddress_d3dx9_38 0x78b50000) -set(baseaddress_d3dx9_39 0x78a80000) -set(baseaddress_d3dx9_40 0x789b0000) -set(baseaddress_d3dx9_41 0x788e0000) -set(baseaddress_d3dx9_42 0x78810000) -set(baseaddress_d3dx9_43 0x78740000) -set(baseaddress_d3dxof 0x78710000) -set(baseaddress_dbgeng 0x786d0000) -set(baseaddress_dciman32 0x786b0000) -set(baseaddress_dcomlaunch 0x78690000) -set(baseaddress_ddraw 0x78600000) -set(baseaddress_desk 0x78560000) -set(baseaddress_deskadp 0x78530000) -set(baseaddress_deskmon 0x78500000) -set(baseaddress_devcpux 0x784e0000) -set(baseaddress_devenum 0x784b0000) -set(baseaddress_dinput 0x78470000) -set(baseaddress_dinput8 0x78430000) -set(baseaddress_dmusic 0x783f0000) -set(baseaddress_dnsrslvr 0x783d0000) -set(baseaddress_dplay 0x783b0000) -set(baseaddress_dpnhpast 0x78390000) -set(baseaddress_dxdiagn 0x78360000) -set(baseaddress_dxgi 0x78320000) -set(baseaddress_dxtn 0x78300000) -set(baseaddress_esent 0x782d0000) -set(baseaddress_faultrep 0x782b0000) -set(baseaddress_fltlib 0x78290000) -set(baseaddress_fmifs 0x78270000) -set(baseaddress_fontext 0x78240000) -set(baseaddress_fontsub 0x78220000) -set(baseaddress_framedyn 0x78200000) -set(baseaddress_gdi32_vista 0x781e0000) -set(baseaddress_getuname 0x78050000) -set(baseaddress_halpc98 0x77e90000) -set(baseaddress_halxbox 0x77cd0000) -set(baseaddress_hdwwiz 0x77c60000) -set(baseaddress_hhctrl 0x77c20000) -set(baseaddress_hid 0x77c00000) -set(baseaddress_hlink 0x77bd0000) -set(baseaddress_hnetcfg 0x77ba0000) -set(baseaddress_hotplug 0x77b80000) -set(baseaddress_httpapi 0x77b60000) -set(baseaddress_iccvid 0x77b40000) -set(baseaddress_ieframe 0x77990000) -set(baseaddress_iernonce 0x77960000) -set(baseaddress_imaadp32.acm 0x77940000) -set(baseaddress_imagehlp 0x77910000) -set(baseaddress_inetcomm 0x778c0000) -set(baseaddress_inetcpl 0x77860000) -set(baseaddress_inetmib1 0x77840000) -set(baseaddress_initpki 0x77820000) -set(baseaddress_input 0x777b0000) -set(baseaddress_inseng 0x77780000) -set(baseaddress_intl 0x77710000) -set(baseaddress_iologmsg 0x776f0000) -set(baseaddress_itircl 0x776d0000) -set(baseaddress_itss 0x776a0000) -set(baseaddress_joy 0x77660000) -set(baseaddress_jscript 0x775b0000) -set(baseaddress_jsproxy 0x77590000) -set(baseaddress_kbsdll 0x77570000) -set(baseaddress_kernel32_vista 0x77550000) -set(baseaddress_ksuser 0x77530000) -set(baseaddress_libjpeg 0x774d0000) -set(baseaddress_libpng 0x77470000) -set(baseaddress_libtiff 0x773d0000) -set(baseaddress_libtirpc 0x77390000) -set(baseaddress_libxslt 0x77280000) -set(baseaddress_loadperf 0x77260000) -set(baseaddress_localmon 0x77230000) -set(baseaddress_localspl 0x771f0000) -set(baseaddress_localui 0x771c0000) -set(baseaddress_lpk 0x771a0000) -set(baseaddress_lsasrv 0x77140000) -set(baseaddress_main 0x77060000) -set(baseaddress_mapi32 0x77030000) -set(baseaddress_mbedtls 0x76fc0000) -set(baseaddress_mciavi32 0x76f90000) -set(baseaddress_mcicda 0x76f60000) -set(baseaddress_mciqtz32 0x76f30000) -set(baseaddress_mciseq 0x76f00000) -set(baseaddress_mciwave 0x76ed0000) -set(baseaddress_mgmtapi 0x76eb0000) -set(baseaddress_midimap 0x76e90000) -set(baseaddress_mlang 0x76e60000) -set(baseaddress_mmdrv 0x76e40000) -set(baseaddress_mmsys 0x76d60000) -set(baseaddress_modemui 0x76ce0000) -set(baseaddress_mprapi 0x76cb0000) -set(baseaddress_msacm32.drv 0x76c80000) -set(baseaddress_msadp32.acm 0x76c60000) -set(baseaddress_msafd 0x76c30000) -set(baseaddress_mscat32 0x76c10000) -set(baseaddress_mscms 0x76be0000) -set(baseaddress_mscoree 0x76ba0000) -set(baseaddress_msctf 0x76b60000) -set(baseaddress_msdmo 0x76b40000) -set(baseaddress_msftedit 0x76b20000) -set(baseaddress_msg711.acm 0x76b00000) -set(baseaddress_msgina 0x76a30000) -set(baseaddress_msgsm32.acm 0x76a10000) -set(baseaddress_mshtml 0x76880000) -set(baseaddress_msi 0x76740000) -set(baseaddress_msimtf 0x76720000) -set(baseaddress_msisip 0x76700000) -set(baseaddress_msisys 0x766e0000) -set(baseaddress_mspatcha 0x766c0000) -set(baseaddress_msports 0x76690000) -set(baseaddress_msrle32 0x76660000) -set(baseaddress_mssign32 0x76640000) -set(baseaddress_mssip32 0x76620000) -set(baseaddress_mstask 0x765f0000) -set(baseaddress_msv1_0 0x765c0000) -set(baseaddress_msvcrt20 0x76530000) -set(baseaddress_msvcrt40 0x764a0000) -set(baseaddress_msvidc32 0x76480000) -set(baseaddress_msxml 0x76450000) -set(baseaddress_msxml2 0x76420000) -set(baseaddress_msxml3 0x76240000) -set(baseaddress_msxml3r 0x76220000) -set(baseaddress_msxml4 0x761e0000) -set(baseaddress_msxml6 0x761a0000) -set(baseaddress_mycomput 0x76180000) -set(baseaddress_mydocs 0x76150000) -set(baseaddress_ncpa 0x76130000) -set(baseaddress_nddeapi 0x76110000) -set(baseaddress_netcfgx 0x76080000) -set(baseaddress_netevent 0x76050000) -set(baseaddress_netid 0x76000000) -set(baseaddress_netlogon 0x75fd0000) -set(baseaddress_netmsg 0x75e50000) -set(baseaddress_netplwiz 0x75e20000) -set(baseaddress_netshell 0x75d90000) -set(baseaddress_newdev 0x75d40000) -set(baseaddress_nfs41_np 0x75d20000) -set(baseaddress_normaliz 0x75d00000) -set(baseaddress_npptools 0x75ce0000) -set(baseaddress_ntdll_vista 0x75cc0000) -set(baseaddress_ntdsapi 0x75c90000) -set(baseaddress_ntlanman 0x75c70000) -set(baseaddress_ntmarta 0x75c50000) -set(baseaddress_ntobjshex 0x75bf0000) -set(baseaddress_ntprint 0x75bd0000) -set(baseaddress_objsel 0x75bb0000) -set(baseaddress_odbc32 0x75b70000) -set(baseaddress_odbccp32 0x75b40000) -set(baseaddress_odbccp32i 0x75b20000) -set(baseaddress_oleacc 0x75ad0000) -set(baseaddress_olecli32 0x75ab0000) -set(baseaddress_olepro32 0x75a90000) -set(baseaddress_olesvr32 0x75a70000) -set(baseaddress_olethk32 0x75a50000) -set(baseaddress_openglcfg 0x75a20000) -set(baseaddress_pdh 0x759f0000) -set(baseaddress_pidgen 0x759d0000) -set(baseaddress_pifmgr 0x75960000) -set(baseaddress_powercfg 0x75900000) -set(baseaddress_printui 0x758e0000) -set(baseaddress_profmap 0x758c0000) -set(baseaddress_propsys 0x75880000) -set(baseaddress_pstorec 0x75860000) -set(baseaddress_qcap 0x75820000) -set(baseaddress_qedit 0x757f0000) -set(baseaddress_qmgr 0x757c0000) -set(baseaddress_qmgrprxy 0x75780000) -set(baseaddress_quartz 0x75670000) -set(baseaddress_query 0x75650000) -set(baseaddress_rasadhlp 0x75630000) -set(baseaddress_rasdlg 0x75450000) -set(baseaddress_rasman 0x75420000) -set(baseaddress_regapi 0x75400000) -set(baseaddress_resutils 0x753e0000) -set(baseaddress_riched32 0x753c0000) -set(baseaddress_rsabase 0x753a0000) -set(baseaddress_samsrv 0x75340000) -set(baseaddress_sccbase 0x75320000) -set(baseaddress_schannel 0x752f0000) -set(baseaddress_schedsvc 0x752d0000) -set(baseaddress_scrrun 0x75290000) -set(baseaddress_seclogon 0x75270000) -set(baseaddress_security 0x75250000) -set(baseaddress_sendmail 0x75220000) -set(baseaddress_serialui 0x75200000) -set(baseaddress_sfc 0x751e0000) -set(baseaddress_sfcfiles 0x751c0000) -set(baseaddress_shdoclc 0x75180000) -set(baseaddress_shdocvw 0x75140000) -set(baseaddress_shellbtrfs 0x75070000) -set(baseaddress_shfolder 0x75050000) -set(baseaddress_shimgvw 0x75010000) -set(baseaddress_shsvcs 0x74ff0000) -set(baseaddress_slbcsp 0x74fd0000) -set(baseaddress_sndblst 0x74fb0000) -set(baseaddress_softpub 0x74f90000) -set(baseaddress_srclient 0x74f70000) -set(baseaddress_srvsvc 0x74f40000) -set(baseaddress_sti 0x74f10000) -set(baseaddress_stobject 0x74ea0000) -set(baseaddress_storprop 0x74e80000) -set(baseaddress_streamci 0x74e60000) -set(baseaddress_sxs 0x74e40000) -set(baseaddress_sysdm 0x74d50000) -set(baseaddress_syssetup 0x74c00000) -set(baseaddress_t2embed 0x74be0000) -set(baseaddress_tapi32 0x74bb0000) -set(baseaddress_tapiui 0x74b20000) -set(baseaddress_telephon 0x74b00000) -set(baseaddress_themeui 0x74ae0000) -set(baseaddress_timedate 0x74a70000) -set(baseaddress_traffic 0x74a50000) -set(baseaddress_twain_32 0x74a30000) -set(baseaddress_ubtrfs 0x74a00000) -set(baseaddress_ucdfs 0x749e0000) -set(baseaddress_uext2 0x749b0000) -set(baseaddress_ufat 0x74980000) -set(baseaddress_ufatx 0x74960000) -set(baseaddress_umandlg 0x74940000) -set(baseaddress_umpnpmgr 0x74910000) -set(baseaddress_untfs 0x748f0000) -set(baseaddress_updspapi 0x748d0000) -set(baseaddress_url 0x748b0000) -set(baseaddress_usrmgr 0x74860000) -set(baseaddress_vbscript 0x747f0000) -set(baseaddress_vdmdbg 0x747d0000) -set(baseaddress_verifier 0x747b0000) -set(baseaddress_vssapi 0x74780000) -set(baseaddress_w32time 0x74760000) -set(baseaddress_wbemdisp 0x74720000) -set(baseaddress_wbemprox 0x746d0000) -set(baseaddress_wdmaud.drv 0x74540000) -set(baseaddress_windowscodecs 0x74460000) -set(baseaddress_windowscodecsext 0x74440000) -set(baseaddress_wined3dcfg 0x74410000) -set(baseaddress_winemp3.acm 0x743a0000) -set(baseaddress_winfax 0x74380000) -set(baseaddress_wing32 0x74360000) -set(baseaddress_winhttp 0x74320000) -set(baseaddress_winprint 0x74300000) -set(baseaddress_winscard 0x742e0000) -set(baseaddress_winsta 0x742b0000) -set(baseaddress_wkssvc 0x74290000) -set(baseaddress_wlanapi 0x74270000) -set(baseaddress_wldap32 0x74240000) -set(baseaddress_wlnotify 0x74210000) -set(baseaddress_wmi 0x741f0000) -set(baseaddress_wmisvc 0x741d0000) -set(baseaddress_wmiutils 0x741a0000) -set(baseaddress_wmvcore 0x74170000) -set(baseaddress_wshirda 0x74150000) -set(baseaddress_wshom 0x74120000) -set(baseaddress_wshtcpip 0x74100000) -set(baseaddress_wsock32 0x740e0000) -set(baseaddress_wtsapi32 0x740c0000) -set(baseaddress_wuapi 0x74090000) -set(baseaddress_wuauserv 0x74070000) -set(baseaddress_xinput1_1 0x74050000) -set(baseaddress_xinput1_2 0x74030000) -set(baseaddress_xinput1_3 0x74010000) -set(baseaddress_xinput9_1_0 0x73ff0000) -set(baseaddress_xmllite 0x73fc0000) -set(baseaddress_xolehlp 0x73fa0000) -set(baseaddress_zipfldr 0x73ed0000) +set(baseaddress_dhcpcsvc 0x7c4a0000) +set(baseaddress_dnsapi 0x7c460000) +set(baseaddress_icmp 0x7c440000) +set(baseaddress_iphlpapi 0x7c400000) +set(baseaddress_ws2_32 0x7c3d0000) +set(baseaddress_ws2help 0x7c3b0000) +set(baseaddress_shlwapi 0x7c330000) +set(baseaddress_rpcrt4 0x7c290000) +set(baseaddress_comctl32 0x7c140000) +set(baseaddress_ole32 0x7bff0000) +set(baseaddress_winspool 0x7bfa0000) +set(baseaddress_winmm 0x7bf00000) +set(baseaddress_comdlg32 0x7be20000) +set(baseaddress_shell32 0x7b590000) +set(baseaddress_lz32 0x7b570000) +set(baseaddress_version 0x7b540000) +set(baseaddress_oleaut32 0x7b410000) +set(baseaddress_setupapi 0x7b2e0000) +set(baseaddress_mpr 0x7b2b0000) +set(baseaddress_crypt32 0x7b1e0000) +set(baseaddress_wininet 0x7b150000) +set(baseaddress_urlmon 0x7b0a0000) +set(baseaddress_psapi 0x7b080000) +set(baseaddress_imm32 0x7b040000) +set(baseaddress_msvfw32 0x7b000000) +set(baseaddress_dbghelp 0x7af80000) +set(baseaddress_devmgr 0x7aed0000) +set(baseaddress_msacm32 0x7ae90000) +set(baseaddress_netapi32 0x7ae20000) +set(baseaddress_powrprof 0x7ae00000) +set(baseaddress_secur32 0x7adc0000) +set(baseaddress_wintrust 0x7ad80000) +set(baseaddress_avicap32 0x7ad60000) +set(baseaddress_cabinet 0x7ad20000) +set(baseaddress_dsound 0x7acc0000) +set(baseaddress_glu32 0x7ac40000) +set(baseaddress_opengl32 0x7ab60000) +set(baseaddress_riched20 0x7aad0000) +set(baseaddress_userenv 0x7aa90000) +set(baseaddress_uxtheme 0x7aa40000) +set(baseaddress_cryptui 0x7a9a0000) +set(baseaddress_csrsrv 0x7a970000) +set(baseaddress_basesrv 0x7a940000) +set(baseaddress_winsrv 0x7a8c0000) +set(baseaddress_dplayx 0x7a870000) +set(baseaddress_gdiplus 0x7a7d0000) +set(baseaddress_msimg32 0x7a7b0000) +set(baseaddress_mswsock 0x7a790000) +set(baseaddress_oledlg 0x7a750000) +set(baseaddress_rasapi32 0x7a720000) +set(baseaddress_rsaenh 0x7a6d0000) +set(baseaddress_samlib 0x7a6a0000) +set(baseaddress_sensapi 0x7a680000) +set(baseaddress_sfc_os 0x7a660000) +set(baseaddress_snmpapi 0x7a640000) +set(baseaddress_spoolss 0x7a610000) +set(baseaddress_usp10 0x7a5b0000) +set(baseaddress_access 0x7a530000) +set(baseaddress_acgenral 0x7a510000) +set(baseaddress_aclayers 0x7a4e0000) +set(baseaddress_acledit 0x7a4c0000) +set(baseaddress_aclui 0x7a490000) +set(baseaddress_acppage 0x7a450000) +set(baseaddress_activeds 0x7a430000) +set(baseaddress_actxprxy 0x7a2b0000) +set(baseaddress_advapi32_vista 0x7a290000) +set(baseaddress_advpack 0x7a260000) +set(baseaddress_amstream 0x7a230000) +set(baseaddress_apphelp 0x7a1f0000) +set(baseaddress_appwiz 0x7a180000) +set(baseaddress_atl 0x7a150000) +set(baseaddress_atl100 0x7a120000) +set(baseaddress_atl80 0x7a0f0000) +set(baseaddress_authz 0x7a0d0000) +set(baseaddress_avifil32 0x7a080000) +set(baseaddress_avrt 0x7a060000) +set(baseaddress_batt 0x7a040000) +set(baseaddress_bcrypt 0x7a010000) +set(baseaddress_beepmidi 0x79ff0000) +set(baseaddress_bluetoothapis 0x79fd0000) +set(baseaddress_browser 0x79fb0000) +set(baseaddress_browseui 0x79e90000) +set(baseaddress_bthci 0x79e70000) +set(baseaddress_bthprops 0x79e50000) +set(baseaddress_cards 0x79d90000) +set(baseaddress_cfgmgr32 0x79d70000) +set(baseaddress_clb 0x79d50000) +set(baseaddress_clbcatq 0x79d30000) +set(baseaddress_clusapi 0x79d00000) +set(baseaddress_cmicpl 0x79cd0000) +set(baseaddress_comcat 0x79cb0000) +set(baseaddress_compstui 0x79c90000) +set(baseaddress_console 0x79c40000) +set(baseaddress_credui 0x79c00000) +set(baseaddress_crtdll 0x79ba0000) +set(baseaddress_cryptbase 0x79b80000) +set(baseaddress_cryptdlg 0x79b50000) +set(baseaddress_cryptdll 0x79b30000) +set(baseaddress_cryptext 0x79b10000) +set(baseaddress_cryptnet 0x79ae0000) +set(baseaddress_d3d10 0x79a90000) +set(baseaddress_d3d10_1 0x79a70000) +set(baseaddress_d3d10core 0x79a50000) +set(baseaddress_d3d11 0x799e0000) +set(baseaddress_d3d8 0x799a0000) +set(baseaddress_d3d8thk 0x79980000) +set(baseaddress_d3d9 0x79930000) +set(baseaddress_d3dcompiler_43 0x798a0000) +set(baseaddress_d3drm 0x79830000) +set(baseaddress_d3dwine 0x79670000) +set(baseaddress_d3dx9_24 0x795b0000) +set(baseaddress_d3dx9_25 0x794f0000) +set(baseaddress_d3dx9_26 0x79430000) +set(baseaddress_d3dx9_27 0x79370000) +set(baseaddress_d3dx9_28 0x792b0000) +set(baseaddress_d3dx9_29 0x791f0000) +set(baseaddress_d3dx9_30 0x79130000) +set(baseaddress_d3dx9_31 0x79070000) +set(baseaddress_d3dx9_32 0x78fa0000) +set(baseaddress_d3dx9_33 0x78ed0000) +set(baseaddress_d3dx9_34 0x78e00000) +set(baseaddress_d3dx9_35 0x78d30000) +set(baseaddress_d3dx9_36 0x78c60000) +set(baseaddress_d3dx9_37 0x78b90000) +set(baseaddress_d3dx9_38 0x78ac0000) +set(baseaddress_d3dx9_39 0x789f0000) +set(baseaddress_d3dx9_40 0x78920000) +set(baseaddress_d3dx9_41 0x78850000) +set(baseaddress_d3dx9_42 0x78780000) +set(baseaddress_d3dx9_43 0x786b0000) +set(baseaddress_d3dxof 0x78680000) +set(baseaddress_dbgeng 0x78640000) +set(baseaddress_dciman32 0x78620000) +set(baseaddress_dcomlaunch 0x78600000) +set(baseaddress_ddraw 0x78570000) +set(baseaddress_desk 0x784d0000) +set(baseaddress_deskadp 0x784a0000) +set(baseaddress_deskmon 0x78470000) +set(baseaddress_devcpux 0x78450000) +set(baseaddress_devenum 0x78420000) +set(baseaddress_dinput 0x783e0000) +set(baseaddress_dinput8 0x783a0000) +set(baseaddress_dmusic 0x78360000) +set(baseaddress_dnsrslvr 0x78340000) +set(baseaddress_dplay 0x78320000) +set(baseaddress_dpnhpast 0x78300000) +set(baseaddress_dwmapi 0x782e0000) +set(baseaddress_dxdiagn 0x782b0000) +set(baseaddress_dxgi 0x78270000) +set(baseaddress_dxtn 0x78250000) +set(baseaddress_esent 0x78220000) +set(baseaddress_faultrep 0x78200000) +set(baseaddress_feclient 0x781e0000) +set(baseaddress_fltlib 0x781c0000) +set(baseaddress_fmifs 0x781a0000) +set(baseaddress_fontext 0x78170000) +set(baseaddress_fontsub 0x78150000) +set(baseaddress_framedyn 0x78130000) +set(baseaddress_gdi32_vista 0x78110000) +set(baseaddress_getuname 0x77f80000) +set(baseaddress_halpc98 0x77dc0000) +set(baseaddress_halxbox 0x77c00000) +set(baseaddress_hdwwiz 0x77b90000) +set(baseaddress_hhctrl 0x77b50000) +set(baseaddress_hid 0x77b30000) +set(baseaddress_hlink 0x779f0000) +set(baseaddress_hnetcfg 0x779c0000) +set(baseaddress_hotplug 0x779a0000) +set(baseaddress_httpapi 0x77980000) +set(baseaddress_iccvid 0x77960000) +set(baseaddress_ieframe 0x778d0000) +set(baseaddress_iernonce 0x778a0000) +set(baseaddress_imaadp32.acm 0x77880000) +set(baseaddress_imagehlp 0x77850000) +set(baseaddress_inetcomm 0x77800000) +set(baseaddress_inetcpl 0x777a0000) +set(baseaddress_inetmib1 0x77780000) +set(baseaddress_initpki 0x77760000) +set(baseaddress_input 0x776f0000) +set(baseaddress_inseng 0x776c0000) +set(baseaddress_intl 0x77650000) +set(baseaddress_iologmsg 0x77630000) +set(baseaddress_itircl 0x77610000) +set(baseaddress_itss 0x775e0000) +set(baseaddress_joy 0x775a0000) +set(baseaddress_jscript 0x774f0000) +set(baseaddress_jsproxy 0x774d0000) +set(baseaddress_kbsdll 0x774b0000) +set(baseaddress_kernel32_vista 0x77490000) +set(baseaddress_ksuser 0x77470000) +set(baseaddress_libjpeg 0x77410000) +set(baseaddress_libpng 0x773b0000) +set(baseaddress_libtiff 0x77310000) +set(baseaddress_libtirpc 0x772d0000) +set(baseaddress_libxslt 0x771c0000) +set(baseaddress_loadperf 0x771a0000) +set(baseaddress_localmon 0x77170000) +set(baseaddress_localspl 0x77130000) +set(baseaddress_localui 0x77100000) +set(baseaddress_logoncli 0x770e0000) +set(baseaddress_lpk 0x770c0000) +set(baseaddress_lsasrv 0x77060000) +set(baseaddress_main 0x76f80000) +set(baseaddress_mapi32 0x76f50000) +set(baseaddress_mbedtls 0x76ee0000) +set(baseaddress_mciavi32 0x76eb0000) +set(baseaddress_mcicda 0x76e80000) +set(baseaddress_mciqtz32 0x76e50000) +set(baseaddress_mciseq 0x76e20000) +set(baseaddress_mciwave 0x76df0000) +set(baseaddress_mf 0x76dd0000) +set(baseaddress_mfplat 0x76da0000) +set(baseaddress_mfreadwrite 0x76d80000) +set(baseaddress_mgmtapi 0x76d60000) +set(baseaddress_midimap 0x76d40000) +set(baseaddress_mlang 0x76d10000) +set(baseaddress_mmdrv 0x76cf0000) +set(baseaddress_mmsys 0x76c10000) +set(baseaddress_modemui 0x76b90000) +set(baseaddress_mprapi 0x76b60000) +set(baseaddress_msacm32.drv 0x76b30000) +set(baseaddress_msadp32.acm 0x76b10000) +set(baseaddress_msafd 0x76ae0000) +set(baseaddress_mscat32 0x76ac0000) +set(baseaddress_mscms 0x76a90000) +set(baseaddress_mscoree 0x76a50000) +set(baseaddress_msctf 0x76a10000) +set(baseaddress_msdmo 0x769f0000) +set(baseaddress_msftedit 0x769d0000) +set(baseaddress_msg711.acm 0x769b0000) +set(baseaddress_msgina 0x768e0000) +set(baseaddress_msgsm32.acm 0x768c0000) +set(baseaddress_mshtml 0x76730000) +set(baseaddress_msi 0x765f0000) +set(baseaddress_msimtf 0x765d0000) +set(baseaddress_msisip 0x765b0000) +set(baseaddress_msisys 0x76590000) +set(baseaddress_mspatcha 0x76570000) +set(baseaddress_msports 0x76540000) +set(baseaddress_msrle32 0x76510000) +set(baseaddress_mssign32 0x764f0000) +set(baseaddress_mssip32 0x764d0000) +set(baseaddress_mstask 0x764a0000) +set(baseaddress_msv1_0 0x76470000) +set(baseaddress_msvcrt20 0x763e0000) +set(baseaddress_msvcrt40 0x76350000) +set(baseaddress_msvidc32 0x76330000) +set(baseaddress_msxml 0x76300000) +set(baseaddress_msxml2 0x762d0000) +set(baseaddress_msxml3 0x760f0000) +set(baseaddress_msxml3r 0x760d0000) +set(baseaddress_msxml4 0x76090000) +set(baseaddress_msxml6 0x76050000) +set(baseaddress_mycomput 0x76030000) +set(baseaddress_mydocs 0x76000000) +set(baseaddress_ncpa 0x75fe0000) +set(baseaddress_ncrypt 0x75fc0000) +set(baseaddress_nddeapi 0x75fa0000) +set(baseaddress_ndfapi 0x75f80000) +set(baseaddress_netcfgx 0x75ef0000) +set(baseaddress_netevent 0x75ec0000) +set(baseaddress_netid 0x75e70000) +set(baseaddress_netlogon 0x75e40000) +set(baseaddress_netmsg 0x75cc0000) +set(baseaddress_netplwiz 0x75c90000) +set(baseaddress_netshell 0x75c00000) +set(baseaddress_newdev 0x75bb0000) +set(baseaddress_nfs41_np 0x75b90000) +set(baseaddress_normaliz 0x75b70000) +set(baseaddress_npptools 0x75b50000) +set(baseaddress_ntdll_vista 0x75b30000) +set(baseaddress_ntdsapi 0x75b00000) +set(baseaddress_ntlanman 0x75ae0000) +set(baseaddress_ntmarta 0x75ac0000) +set(baseaddress_ntobjshex 0x75a60000) +set(baseaddress_ntprint 0x75a40000) +set(baseaddress_objsel 0x75a20000) +set(baseaddress_odbc32 0x759e0000) +set(baseaddress_odbccp32 0x759b0000) +set(baseaddress_odbccp32i 0x75990000) +set(baseaddress_oleacc 0x75940000) +set(baseaddress_olecli32 0x75920000) +set(baseaddress_olepro32 0x75900000) +set(baseaddress_olesvr32 0x758e0000) +set(baseaddress_olethk32 0x758c0000) +set(baseaddress_openglcfg 0x75890000) +set(baseaddress_pdh 0x75860000) +set(baseaddress_pidgen 0x75840000) +set(baseaddress_pifmgr 0x757d0000) +set(baseaddress_powercfg 0x75770000) +set(baseaddress_printui 0x75750000) +set(baseaddress_profmap 0x75730000) +set(baseaddress_propsys 0x756f0000) +set(baseaddress_pstorec 0x756d0000) +set(baseaddress_qcap 0x75690000) +set(baseaddress_qedit 0x75660000) +set(baseaddress_qmgr 0x75630000) +set(baseaddress_qmgrprxy 0x755f0000) +set(baseaddress_quartz 0x754e0000) +set(baseaddress_query 0x754c0000) +set(baseaddress_rasadhlp 0x754a0000) +set(baseaddress_rasdlg 0x752c0000) +set(baseaddress_rasman 0x75290000) +set(baseaddress_regapi 0x75270000) +set(baseaddress_resutils 0x75250000) +set(baseaddress_riched32 0x75230000) +set(baseaddress_rsabase 0x75210000) +set(baseaddress_samsrv 0x751b0000) +set(baseaddress_sccbase 0x75190000) +set(baseaddress_schannel 0x75160000) +set(baseaddress_schedsvc 0x75140000) +set(baseaddress_scrrun 0x75100000) +set(baseaddress_seclogon 0x750e0000) +set(baseaddress_security 0x750c0000) +set(baseaddress_sendmail 0x75090000) +set(baseaddress_serialui 0x75070000) +set(baseaddress_sfc 0x75050000) +set(baseaddress_sfcfiles 0x75030000) +set(baseaddress_shcore 0x75000000) +set(baseaddress_shdoclc 0x74fc0000) +set(baseaddress_shdocvw 0x74f80000) +set(baseaddress_shellbtrfs 0x74eb0000) +set(baseaddress_shfolder 0x74e90000) +set(baseaddress_shimgvw 0x74e50000) +set(baseaddress_shsvcs 0x74e30000) +set(baseaddress_slbcsp 0x74e10000) +set(baseaddress_sndblst 0x74df0000) +set(baseaddress_softpub 0x74dd0000) +set(baseaddress_srclient 0x74db0000) +set(baseaddress_srvsvc 0x74d80000) +set(baseaddress_sspicli 0x74d60000) +set(baseaddress_sti 0x74d30000) +set(baseaddress_stobject 0x74cc0000) +set(baseaddress_storprop 0x74ca0000) +set(baseaddress_streamci 0x74c80000) +set(baseaddress_sxs 0x74c60000) +set(baseaddress_sysdm 0x74b70000) +set(baseaddress_syssetup 0x74a20000) +set(baseaddress_t2embed 0x74a00000) +set(baseaddress_tapi32 0x749d0000) +set(baseaddress_tapiui 0x74940000) +set(baseaddress_telephon 0x74920000) +set(baseaddress_themeui 0x74900000) +set(baseaddress_timedate 0x74890000) +set(baseaddress_traffic 0x74870000) +set(baseaddress_twain_32 0x74850000) +set(baseaddress_ubtrfs 0x74820000) +set(baseaddress_ucdfs 0x74800000) +set(baseaddress_uext2 0x747d0000) +set(baseaddress_ufat 0x747a0000) +set(baseaddress_ufatx 0x74780000) +set(baseaddress_uianimation 0x74760000) +set(baseaddress_uiautomationcore 0x74730000) +set(baseaddress_umandlg 0x74710000) +set(baseaddress_umpnpmgr 0x746e0000) +set(baseaddress_untfs 0x746c0000) +set(baseaddress_updspapi 0x746a0000) +set(baseaddress_url 0x74680000) +set(baseaddress_usrmgr 0x74630000) +set(baseaddress_vbscript 0x745c0000) +set(baseaddress_vdmdbg 0x745a0000) +set(baseaddress_verifier 0x74580000) +set(baseaddress_vssapi 0x74550000) +set(baseaddress_w32time 0x74530000) +set(baseaddress_wbemdisp 0x744f0000) +set(baseaddress_wbemprox 0x744a0000) +set(baseaddress_wdmaud.drv 0x74310000) +set(baseaddress_windowscodecs 0x74230000) +set(baseaddress_windowscodecsext 0x74210000) +set(baseaddress_wined3dcfg 0x741e0000) +set(baseaddress_winemp3.acm 0x74170000) +set(baseaddress_winfax 0x74150000) +set(baseaddress_wing32 0x74130000) +set(baseaddress_winhttp 0x740f0000) +set(baseaddress_winprint 0x740d0000) +set(baseaddress_winscard 0x740b0000) +set(baseaddress_winsta 0x74080000) +set(baseaddress_winusb 0x74060000) +set(baseaddress_wkssvc 0x74040000) +set(baseaddress_wlanapi 0x74020000) +set(baseaddress_wldap32 0x73ff0000) +set(baseaddress_wlnotify 0x73fc0000) +set(baseaddress_wmi 0x73fa0000) +set(baseaddress_wmisvc 0x73f80000) +set(baseaddress_wmiutils 0x73f50000) +set(baseaddress_wmvcore 0x73f20000) +set(baseaddress_wshirda 0x73f00000) +set(baseaddress_wshom 0x73ed0000) +set(baseaddress_wshtcpip 0x73eb0000) +set(baseaddress_wsock32 0x73e90000) +set(baseaddress_wtsapi32 0x73e70000) +set(baseaddress_wuapi 0x73e40000) +set(baseaddress_wuauserv 0x73e20000) +set(baseaddress_xinput1_1 0x73e00000) +set(baseaddress_xinput1_2 0x73de0000) +set(baseaddress_xinput1_3 0x73dc0000) +set(baseaddress_xinput9_1_0 0x73da0000) +set(baseaddress_xmllite 0x73d70000) +set(baseaddress_xolehlp 0x73d50000) +set(baseaddress_zipfldr 0x73c80000) diff --git a/sdk/lib/rtl/condvar.c b/sdk/lib/rtl/condvar.c index edbe074cd9998..65ec59c19068e 100644 --- a/sdk/lib/rtl/condvar.c +++ b/sdk/lib/rtl/condvar.c @@ -157,7 +157,7 @@ InternalLockCondVar(IN OUT PRTL_CONDITION_VARIABLE ConditionVariable, { /* We know that OldVal contains a valid address in this case. */ - ASSERT(OldListHead != NULL); + //ASSERT(OldListHead != NULL); return CONTAINING_COND_VAR_WAIT_ENTRY(OldListHead, ListEntry); } @@ -197,8 +197,6 @@ InternalUnlockCondVar(IN OUT PRTL_CONDITION_VARIABLE ConditionVariable, ULONG_PTR OldVal = (ULONG_PTR)ConditionVariable->Ptr; PLIST_ENTRY NewHeadEntry; - ASSERT((OldVal & COND_VAR_LOCKED_FLAG) && - (OldVal & COND_VAR_ADDRESS_MASK)); NewHeadEntry = (PLIST_ENTRY)(OldVal & COND_VAR_ADDRESS_MASK); if (RemoveEntry != NULL) @@ -268,7 +266,7 @@ InternalWake(IN OUT PRTL_CONDITION_VARIABLE ConditionVariable, LARGE_INTEGER Timeout; PCOND_VAR_WAIT_ENTRY RemoveOnUnlockEntry; - ASSERT(CondVarKeyedEventHandle != NULL); + //ASSERT(CondVarKeyedEventHandle != NULL); if (HeadEntry == NULL) { @@ -312,7 +310,7 @@ InternalWake(IN OUT PRTL_CONDITION_VARIABLE ConditionVariable, if (!NT_SUCCESS(Status)) { /* We failed to wake a thread. We'll keep trying. */ - ASSERT(STATUS_INVALID_HANDLE != Status); + // ASSERT(STATUS_INVALID_HANDLE != Status); continue; } @@ -377,8 +375,8 @@ InternalSleep(IN OUT PRTL_CONDITION_VARIABLE ConditionVariable, COND_VAR_WAIT_ENTRY OwnEntry; NTSTATUS Status; - ASSERT(CondVarKeyedEventHandle != NULL); - ASSERT((CriticalSection == NULL) != (SRWLock == NULL)); + // ASSERT(CondVarKeyedEventHandle != NULL); + // ASSERT((CriticalSection == NULL) != (SRWLock == NULL)); RtlZeroMemory(&OwnEntry, sizeof(OwnEntry)); @@ -410,7 +408,7 @@ InternalSleep(IN OUT PRTL_CONDITION_VARIABLE ConditionVariable, FALSE, (PLARGE_INTEGER)TimeOut); - ASSERT(STATUS_INVALID_HANDLE != Status); + //ASSERT(STATUS_INVALID_HANDLE != Status); if (!*InternalGetListRemovalHandledFlag(&OwnEntry)) { @@ -458,14 +456,14 @@ InternalSleep(IN OUT PRTL_CONDITION_VARIABLE ConditionVariable, VOID RtlpInitializeKeyedEvent(VOID) { - ASSERT(CondVarKeyedEventHandle == NULL); + // ASSERT(CondVarKeyedEventHandle == NULL); NtCreateKeyedEvent(&CondVarKeyedEventHandle, EVENT_ALL_ACCESS, NULL, 0); } VOID RtlpCloseKeyedEvent(VOID) { - ASSERT(CondVarKeyedEventHandle != NULL); + // ASSERT(CondVarKeyedEventHandle != NULL); NtClose(CondVarKeyedEventHandle); CondVarKeyedEventHandle = NULL; } diff --git a/sdk/tools/spec2def/spec2def.c b/sdk/tools/spec2def/spec2def.c index 21d59a47b6d02..2ec775cc390f0 100644 --- a/sdk/tools/spec2def/spec2def.c +++ b/sdk/tools/spec2def/spec2def.c @@ -73,7 +73,7 @@ char *pszSourceFileName = NULL; char *pszDllName = NULL; char *gpszUnderscore = ""; int gbDebug; -unsigned guOsVersion = 0x601; +unsigned guOsVersion = 0x502; #define DbgPrint(...) (!gbDebug || fprintf(stderr, __VA_ARGS__)) enum