开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 查看源码
comCoreTypes.idl
资源名称：vxWorks_src.rar　[点击查看]
上传用户：baixin
上传日期：2008-03-13
资源大小：4795k
文件大小：14k
源码类别：

嵌入式/单片机编程

开发平台：

MultiPlatform

comCoreTypes.idl：源码内容
  1. /* comCoreTypes.idl -- VxDCOM base definitions */
  3. /* Copyright (c) 1999-2001, Wind River Systems, Inc. */
  5. /*
  6. modification history
  7. --------------------
  8. 02i,10dec01,dbs  diab build
  9. 02h,18oct01,nel  Correct def of CY type to conform to Microsoft spec.
  10. 02g,11oct01,nel  Add conditional define for SIMNT build.
  11. 02f,07aug01,dbs  return multiple interfaces during creation
  12. 02e,06aug01,dbs  add registry-show capability
  13. 02d,17jul01,dbs  fix widl_marshal attributes
  14. 02c,21jun01,dbs  add IMalloc interface
  15. 02b,20jun01,dbs  remove obsolete typedefs
  16. 02a,20jun01,nel  Remove SafeArray and VARIANT defs to new files.
  17. 01a,20jun01,dbs  created from WindTypes.idl
  18. */
  20. [
  21. uuid(5E0645F9-6F69-11d3-A821-00C04F68A5B5),
  22. pointer_default(unique),
  23. local
  24. ]
  25. interface IWindTypes
  26.     {
  27. /*
  28.  * Some typedefs not required at the C level.
  29.  */
  30. cpp_quote("#if 0")
  31. cpp_quote("/* These types are defined by the OS (vxWorks.h) */")
  32. typedef unsigned char   UCHAR;
  33. typedef unsigned short  USHORT;
  34. typedef unsigned long   ULONG;
  35. typedef int BOOL;
  36. typedef unsigned int UINT;
  37. cpp_quote("#endif")
  40. cpp_quote("#if !(defined (CPU) && defined (SIMNT) && (CPU == SIMNT))")
  41. cpp_quote("/* These are defined by the SIMNT BSP */")
  42. typedef short           WORD;
  43. typedef unsigned long   DWORD;
  44. cpp_quote("#endif")
  46. typedef unsigned char BYTE;
  47. typedef char CHAR;
  48. typedef short           SHORT;
  49. typedef long LONG;
  50. typedef float FLOAT;
  51. typedef double          DOUBLE;
  52. typedef long SCODE;
  53. typedef long HRESULT;
  54. typedef int INT;
  55. typedef unsigned short WCHAR;
  56. typedef unsigned short OLECHAR;
  57. typedef void* PVOID;
  58. typedef void* LPVOID;
  60. // VxDCOM does not use the wchar_t as it varies from one architecture
  61. // to another, instead it uses unsigned short as WCHAR.
  63. typedef [string] OLECHAR* LPOLESTR;
  64. typedef [string] WCHAR* LPWSTR;
  65. typedef [string] const OLECHAR* LPCOLESTR;
  66. typedef [string] const WCHAR* LPCWSTR;
  67.  
  68. cpp_quote("typedef long long LONGLONG;")
  69. cpp_quote("typedef long unsigned long ULONGLONG;")
  71. cpp_quote("#if 0")
  72. typedef hyper LONGLONG;
  73. typedef unsigned hyper ULONGLONG;
  74. cpp_quote("#else")
  75. cpp_quote("typedef LONGLONG hyper;")
  76. cpp_quote("typedef ULONGLONG uhyper;")
  77. cpp_quote("#endif")
  79. typedef LONGLONG LARGE_INTEGER;
  80. typedef ULONGLONG ULARGE_INTEGER;
  81. typedef struct _tagCY
  82.     {
  83.     LONGLONG int64;
  84.     } CY;
  85. typedef LONGLONG        OID;
  86. typedef LONGLONG        OXID;
  87. typedef unsigned short PROTSEQ;
  88.  
  89. cpp_quote("/* Basic IDL types */") 
  90. cpp_quote("typedef unsigned char byte;")
  91. cpp_quote("typedef unsigned char uchar;")
  92. //cpp_quote("typedef unsigned short ushort;")
  93. cpp_quote("typedef unsigned long ulong;")
  94.     
  95. typedef struct _FILETIME
  96.     {
  97.     DWORD dwLowDateTime;
  98.     DWORD dwHighDateTime;
  99.     } FILETIME, *PFILETIME, *LPFILETIME;
  101. typedef struct _SYSTEMTIME
  102.     {
  103.     WORD wYear;
  104.     WORD wMonth;
  105.     WORD wDayOfWeek;
  106.     WORD wDay;
  107.     WORD wHour;
  108.     WORD wMinute;
  109.     WORD wSecond;
  110.     WORD wMilliseconds;
  111.     } SYSTEMTIME, *PSYSTEMTIME, *LPSYSTEMTIME;
  113. typedef struct _SECURITY_ATTRIBUTES
  114.     {
  115.     DWORD nLength;
  116.     [size_is(nLength)] LPVOID lpSecurityDescriptor;
  117.     BOOL bInheritHandle;
  118.     } SECURITY_ATTRIBUTES, *PSECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES;
  120. typedef USHORT SECURITY_DESCRIPTOR_CONTROL, *PSECURITY_DESCRIPTOR_CONTROL;
  122. typedef PVOID PSID;      
  124. typedef struct _ACL
  125.     {
  126.     UCHAR AclRevision;
  127.     UCHAR Sbz1;
  128.     USHORT AclSize;
  129.     USHORT AceCount;
  130.     USHORT Sbz2;
  131.     } ACL;
  133. typedef ACL *PACL;
  135. typedef struct _SECURITY_DESCRIPTOR
  136.     {
  137.     UCHAR Revision;
  138.     UCHAR Sbz1;
  139.     SECURITY_DESCRIPTOR_CONTROL Control;
  140.     PSID Owner;
  141.     PSID Group;
  142.     PACL Sacl;
  143.     PACL Dacl;
  144.     } SECURITY_DESCRIPTOR, *PISECURITY_DESCRIPTOR;
  146. typedef struct _COAUTHIDENTITY
  147.     {
  148.     [string] LPWSTR User;
  149.     ULONG UserLength;
  150.     [string] LPWSTR Domain;
  151.     ULONG DomainLength;
  152.     [string] LPWSTR Password;
  153.     ULONG PasswordLength;
  154.     ULONG Flags;
  155.     } COAUTHIDENTITY;
  157. typedef struct _COAUTHINFO
  158.     {
  159.     DWORD               dwAuthnSvc;
  160.     DWORD               dwAuthzSvc;
  161.     LPWSTR              pwszServerPrincName;
  162.     DWORD               dwAuthnLevel;
  163.     DWORD               dwImpersonationLevel;
  164.     COAUTHIDENTITY *    pAuthIdentityData;
  165.     DWORD               dwCapabilities;
  166.     } COAUTHINFO;
  168. typedef struct _COSERVERINFO
  169.     {
  170.     DWORD           dwReserved1;
  171.     LPWSTR          pwszName;
  172.     COAUTHINFO *    pAuthInfo;
  173.     DWORD           dwReserved2;
  174.     } COSERVERINFO;
  176. /* GUID Definition */
  177. cpp_quote("#ifndef GUID_DEFINED")
  178. cpp_quote("#define GUID_DEFINED")
  179. typedef struct _GUID
  180.     {
  181.     DWORD Data1;
  182.     WORD  Data2;
  183.     WORD  Data3;
  184.     BYTE  Data4[8];
  185.     } GUID, *LPGUID;
  186.     cpp_quote("#endif /* !GUID_DEFINED */")
  188. cpp_quote("extern const GUID GUID_NULL;")
  190. /* IID Definition */
  191. cpp_quote("#define IID_NULL GUID_NULL")
  192. typedef GUID IID;
  193. typedef IID* LPIID;
  194. cpp_quote("#define __IID_DEFINED__")
  196. /* CLSID Definition */ 
  197. typedef GUID CLSID;
  198. typedef CLSID* LPCLSID;
  199. cpp_quote("#define CLSID_NULL GUID_NULL")
  201. /* IPID Definition */
  202. typedef GUID IPID;
  203. typedef IPID* LPIPID;
  205. /* CATID Definition */ 
  206. typedef GUID CATID;
  207. typedef CATID* LPCATID;
  208. cpp_quote("#define CATID_NULL GUID_NULL")
  211. /*
  212.   Here, we use the WIDL-specific attribute [cpp_ref] to indicate that
  213.   a pointer should be treated as a C++ reference-type. In plain old C
  214.   this will still look like a pointer, but in C++ it will look like a
  215.   reference type.
  216. */
  218. typedef [cpp_ref] const GUID* REFGUID;
  219. typedef [cpp_ref] const IID* REFIID;
  220. typedef [cpp_ref] const CLSID* REFCLSID;
  221. typedef [cpp_ref] const IPID* REFIPID;
  223. typedef enum tagCLSCTX
  224.     {
  225. CLSCTX_INPROC_SERVER = 0x01,    
  226. CLSCTX_INPROC_HANDLER = 0x02,   
  227. CLSCTX_LOCAL_SERVER = 0x04,     
  228. CLSCTX_INPROC_SERVER16 = 0x08,  
  229. CLSCTX_REMOTE_SERVER = 0x10,     
  230. CLSCTX_INPROC_HANDLER16 = 0x20,  
  231. CLSCTX_INPROC_SERVERX86 = 0x40,  
  232. CLSCTX_INPROC_HANDLERX86 = 0x80
  233.     } CLSCTX;
  235. typedef enum tagMSHLFLAGS
  236.     {
  237.         MSHLFLAGS_NORMAL = 0,        
  238.         MSHLFLAGS_TABLESTRONG = 1,   
  239. MSHLFLAGS_TABLEWEAK = 2,     
  240. MSHLFLAGS_NOPING = 4      
  241.     } MSHLFLAGS;
  244.  
  245. typedef enum tagMSHCTX
  246.     {
  247. MSHCTX_LOCAL = 0,            
  248. MSHCTX_NOSHAREDMEM = 1,      
  249. MSHCTX_DIFFERENTMACHINE = 2, 
  250. MSHCTX_INPROC = 3
  251.     } MSHCTX;
  253.  
  254. typedef DWORD LCID;
  256. typedef struct _BYTE_BLOB
  257.     {
  258.                         unsigned long   clSize;
  259.     [size_is(clSize)]   byte            abData[];
  260.     } BYTE_BLOB;
  262. typedef [unique] BYTE_BLOB * UP_BYTE_BLOB;
  264. typedef struct _WORD_BLOB
  265.     {
  266.                         unsigned long   clSize;
  267.     [size_is(clSize)]   unsigned short  asData[];
  268.     } WORD_BLOB;
  270. typedef [unique] WORD_BLOB * UP_WORD_BLOB;
  272. typedef struct _DWORD_BLOB
  273.     {
  274.                         unsigned long   clSize;
  275.     [size_is(clSize)]   unsigned long   alData[];
  276.     } DWORD_BLOB;
  278. typedef [unique] DWORD_BLOB * UP_DWORD_BLOB;
  280. typedef struct _FLAGGED_BYTE_BLOB
  281.     {
  282.                         unsigned long   fFlags;
  283.                         unsigned long   clSize;
  284.     [size_is(clSize)]   byte            abData[];
  285.     } FLAGGED_BYTE_BLOB;
  287. typedef [unique] FLAGGED_BYTE_BLOB * UP_FLAGGED_BYTE_BLOB;
  289. typedef struct _FLAGGED_WORD_BLOB {
  290.                         unsigned long   fFlags;
  291.                         unsigned long   clSize;
  292.     [size_is(clSize)]   unsigned short  asData[];
  293. } FLAGGED_WORD_BLOB;
  295. typedef [unique] FLAGGED_WORD_BLOB * UP_FLAGGED_WORD_BLOB;
  297. typedef struct _BYTE_SIZEDARR
  298.     {
  299.                         unsigned long   clSize;
  300.     [size_is(clSize)]   byte     *      pData ;
  301.     } BYTE_SIZEDARR;
  303. typedef struct _SHORT_SIZEDARR
  304.     {
  305.                         unsigned long   clSize;
  306.     [size_is(clSize)]   unsigned short* pData ;
  307.     } WORD_SIZEDARR;
  309. typedef struct _LONG_SIZEDARR
  310.     {
  311.                         unsigned long   clSize;
  312.     [size_is(clSize)]   unsigned long * pData ;
  313.     } DWORD_SIZEDARR;
  315. typedef struct _HYPER_SIZEDARR
  316.     {
  317.                         unsigned long   clSize;
  318.     [size_is(clSize)]   hyper         * pData ;
  319.     } HYPER_SIZEDARR;
  321. typedef double DATE;
  323. typedef struct tagDEC {
  324.     USHORT wReserved;
  325.     BYTE  scale;
  326.     BYTE  sign;
  327.     ULONG Hi32;
  328.     ULONGLONG Lo64;
  329. } DECIMAL;
  331. // BSTR marshaling is handled by WIDL internally
  332. typedef [widl_marshal(bstr)] OLECHAR *  BSTR;
  333. typedef BSTR * LPBSTR;
  335. cpp_quote("/* 0 == FALSE, -1 == TRUE */")
  336. typedef short VARIANT_BOOL;
  337. cpp_quote("typedef BYTE boolean;")
  338. cpp_quote("#if 0")
  339. typedef boolean BOOLEAN;
  340. cpp_quote("#endif")
  341.     
  342. cpp_quote("#define VARIANT_TRUE ((VARIANT_BOOL)0xffff)")
  343. cpp_quote("#define VARIANT_FALSE ((VARIANT_BOOL)0)")
  345. typedef struct tagBLOB
  346.     {
  347.     ULONG cbSize;
  348.     [size_is(cbSize)]
  349.     BYTE  *pBlobData;
  350.     } BLOB, * LPBLOB;
  352. typedef ULONG PROPID;
  354.     }
  356. //
  357. // This interface (IUnknown) is the base interface of all COM objects.
  358. //
  360. [
  361.   local,
  362.   object,
  363.   uuid(00000000-0000-0000-C000-000000000046),
  364.   pointer_default(unique)
  365. ]
  366. interface IUnknown
  367.     {
  368.     typedef [unique] IUnknown *LPUNKNOWN;
  369.     HRESULT QueryInterface(
  370.         [in] REFIID riid,
  371.         [out, iid_is(riid)] void **ppvObject);
  372.     ULONG AddRef();
  373.     ULONG Release();
  374.     }
  376. //
  377. // This interface (IClassFactory) requires special treatment (the
  378. // method CreateInstance() is marshaled quite differently, as if its
  379. // signature were:-
  380. //
  381. // HRESULT CreateInstance ([in] REFIID riid, [out, iid_is(riid)] IUnknown** ppObj);
  382. //
  383. // It is given the [local] attribute here so that WIDL does not
  384. // generate proxy/stubs for it, but the p/s is in fact hard-coded
  385. // elsewhere in the DCOM implementation.
  386. //
  388. [
  389.     object,
  390.     local,
  391.     uuid(00000001-0000-0000-C000-000000000046),
  392.     pointer_default(unique)
  393. ]
  395. interface IClassFactory : IUnknown
  396.     {
  397.     typedef [unique] IClassFactory * LPCLASSFACTORY;
  399.     HRESULT CreateInstance
  400. (
  401.         [in, unique] IUnknown * pUnkOuter,
  402.         [in] REFIID riid,
  403.         [out, iid_is(riid)] void **ppvObject
  404. );
  406.     HRESULT LockServer ([in] BOOL fLock);
  407.     }
  410. //
  411. // This interface allows multiple remote QI operations at one time.
  412. //
  414. [
  415.     object,
  416.     local,
  417.     uuid(00000020-0000-0000-C000-000000000046)
  418. ]
  420. interface IMultiQI : IUnknown
  421.     {
  422.     typedef [unique] IMultiQI* LPMULTIQI;
  424.     typedef struct tagMULTI_QI
  425. {
  426.         const IID  *pIID;  
  427.         IUnknown   *pItf;  
  428.         HRESULT     hr;
  429. } MULTI_QI;
  431.     HRESULT QueryMultipleInterfaces
  432. (
  433.         [in]     ULONG      cMQIs,
  434.         [in,out] MULTI_QI  *pMQIs
  435. );
  436.     }
  439. //
  440. // This interface (IRegistry) is used internally by comCoreLib and
  441. // VxCOM for registration of coclasses.
  442. //
  444. [
  445.     uuid(a01ccc02-cfeb-4311-8ebc-d7edb4a8de9c),
  446.     pointer_default(unique),
  447.     local,
  448.     object
  449. ]
  450. interface IRegistry : IUnknown
  451.     {
  452.     /*
  453.      * RegisterClass - registers a GetClassObject() function pointer
  454.      * against the given CLSID in this registry.
  455.      */
  456.     HRESULT RegisterClass
  457.         (
  458.         [in] REFCLSID           clsid,
  459.         [in] void *             pfnGetClassObject
  460.         );
  462.     /*
  463.      * IsClassRegistered - determines if the CLSID is known to this
  464.      * registry. Returns S_OK if it is, or S_FALSE if not. Other
  465.      * failure values may be returned if appropriate.
  466.      */
  467.     HRESULT IsClassRegistered
  468.         (
  469.         [in] REFCLSID           clsid
  470.         );
  472.     /*
  473.      * CreateInstance - creates an instance of the class given by
  474.      * <clsid>, with the interface given by <iid>, using the <hint>
  475.      * argument if necessary, and returns the new object's interface
  476.      * pointer in the variable pointed to by <ppObj>.
  477.      */
  478.     HRESULT CreateInstance
  479.         (
  480.         [in] REFCLSID           clsid,
  481.         [in] IUnknown *         pUnkOuter,
  482.         [in] DWORD              dwClsContext,
  483.         [in] const char *       hint,
  484.         [in] ULONG              cMQIs,
  485.         [in,out] MULTI_QI *     pMQIs
  486.         );
  488.     /*
  489.      * GetClassObject - returns an instance of the class-object for
  490.      * the given <clsid>. The <iid> parameter indicates which
  491.      * interface on the class-object is to be returned, and is usually
  492.      * (though not always) IClassFactory.
  493.      */
  494.     HRESULT GetClassObject
  495.         (
  496.         [in] REFCLSID           clsid,
  497.         [in] REFIID             iid,
  498.         [in] DWORD              dwClsContext,
  499.         [in] const char *       hint,
  500.         [out, iid_is(iid)] IUnknown ** ppClsObj
  501.         );
  503.     /*
  504.      * This method allows a client to read back the CLSIDs held by
  505.      * this registry. The 'dwIndex' parameter identifies the position
  506.      * in the registry to read, if out of range it will return E_FAIL. 
  507.      */
  508.     HRESULT GetClassID
  509.         (
  510.         [in] DWORD              dwIndex,
  511.         [out] LPCLSID           pclsid
  512.         );        
  513.     
  514.     };
  517. [
  518.     object,
  519.     uuid(0002E000-0000-0000-C000-000000000046),
  520.     pointer_default(unique)
  521. ]
  522. interface IEnumGUID : IUnknown
  523.     {
  524.     typedef [unique] IEnumGUID *LPENUMGUID;
  526.     HRESULT Next
  527. (
  528. [in] ULONG celt,
  529. [out, size_is(celt), length_is(*pceltFetched)] GUID *rgelt,
  530. [out] ULONG *pceltFetched
  531. );
  533.     HRESULT Skip ([in] ULONG celt);
  535.     HRESULT Reset ();
  537.     HRESULT Clone ([out] IEnumGUID **ppenum);
  538.     }
  541. [
  542.     object,
  543.     uuid(00000101-0000-0000-C000-000000000046),
  544.     pointer_default(unique)
  545. ]
  547. interface IEnumString : IUnknown
  548.     {
  550.     typedef [unique] IEnumString *LPENUMSTRING;
  552.     HRESULT Next
  553. (
  554.         [in] ULONG celt,
  555.         [out, size_is(celt), length_is(*pceltFetched)]
  556.         LPOLESTR *rgelt,
  557.         [out] ULONG *pceltFetched
  558. );
  560.     HRESULT Skip ([in] ULONG celt);
  562.     HRESULT Reset ();
  564.     HRESULT Clone ([out] IEnumString **ppenum);
  565.     }
  567. [
  568.     object,
  569.     uuid(00000100-0000-0000-C000-000000000046),
  570.     pointer_default(unique)
  571. ]
  572. interface IEnumUnknown : IUnknown
  573.     {
  575.     typedef [unique] IEnumUnknown *LPENUMUNKNOWN;
  577.     HRESULT Next(
  578.         [in] ULONG celt,
  579.         [out, size_is(celt), length_is(*pceltFetched)]
  580.         IUnknown **rgelt,
  581.         [out] ULONG *pceltFetched);
  583.     HRESULT Skip ([in] ULONG celt);
  585.     HRESULT Reset ();
  587.     HRESULT Clone ([out] IEnumUnknown **ppenum);
  588. }
  590. [
  591.     object,
  592.     local,
  593.     uuid(00000002-0000-0000-C000-000000000046),
  594.     pointer_default(unique)
  595. ]
  596. interface IMalloc : IUnknown
  597.     {
  598.     void* Alloc ([in] ULONG cb);        
  599.     void* Realloc ([in] void *pv, [in] ULONG cb);
  600.     void  Free ([in] void *pv);
  601.     ULONG GetSize ([in] void *pv);
  602.     int   DidAlloc ([in] void *pv);
  603.     void  HeapMinimize ();        
  604.     };