ReactOS 0.4.16-dev-2491-g3dc6630
comutil.h
Go to the documentation of this file.
1
6#ifndef _INC_COMUTIL
7#define _INC_COMUTIL
8
9#include <ole2.h>
10
11#ifndef _COM_ASSERT
12#define _COM_ASSERT(x) ((void)0)
13#endif
14
15#define _COM_MEMCPY_S(dest,destsize,src,count) memcpy(dest,src,count)
16
17/* Use of wsprintf might be impossible, if strsafe.h is included. */
18#if !defined(__STDC_SECURE_LIB__) || defined(__REACTOS__)
19#define _COM_PRINTF_S_1(dest,destsize,format,arg1) wsprintf(dest,format,arg1)
20#elif defined(UNICODE)
21#define _COM_PRINTF_S_1(dest,destsize,format,arg1) swprintf_s(dest,destsize,format,arg1)
22#else
23#define _COM_PRINTF_S_1(dest,destsize,format,arg1) sprintf_s(dest,destsize,format,arg1)
24#endif
25
26#ifdef __cplusplus
27
28#pragma push_macro("new")
29#undef new
30
31#ifndef WINAPI
32#define WINAPI __stdcall
33#endif
34
35class _com_error;
36
37void WINAPI _com_issue_error(HRESULT);
38
39class _bstr_t;
40class _variant_t;
41
42namespace _com_util {
43 inline void CheckError(HRESULT hr) {
44 if(FAILED(hr)) { _com_issue_error(hr); }
45 }
46}
47
48namespace _com_util {
49 BSTR WINAPI ConvertStringToBSTR(const char *pSrc);
50 char *WINAPI ConvertBSTRToString(BSTR pSrc);
51}
52
53class _bstr_t {
54public:
55 _bstr_t() throw();
56 _bstr_t(const _bstr_t &s) throw();
57 _bstr_t(const char *s);
58 _bstr_t(const wchar_t *s);
59 _bstr_t(const _variant_t &var);
60 _bstr_t(BSTR bstr,bool fCopy);
61 ~_bstr_t() throw();
62 _bstr_t &operator=(const _bstr_t &s) throw();
63 _bstr_t &operator=(const char *s);
64 _bstr_t &operator=(const wchar_t *s);
65 _bstr_t &operator=(const _variant_t &var);
66 _bstr_t &operator+=(const _bstr_t &s);
67 _bstr_t operator+(const _bstr_t &s) const;
68 friend _bstr_t operator+(const char *s1,const _bstr_t &s2);
69 friend _bstr_t operator+(const wchar_t *s1,const _bstr_t &s2);
70 operator const wchar_t *() const throw();
71 operator wchar_t *() const throw();
72 operator const char *() const;
73 operator char *() const;
74 bool operator!() const throw();
75 bool operator==(const _bstr_t &str) const throw();
76 bool operator!=(const _bstr_t &str) const throw();
77 bool operator<(const _bstr_t &str) const throw();
78 bool operator>(const _bstr_t &str) const throw();
79 bool operator<=(const _bstr_t &str) const throw();
80 bool operator>=(const _bstr_t &str) const throw();
81 BSTR copy(bool fCopy = true) const;
82 unsigned int length() const throw();
83 void Assign(BSTR s);
84 BSTR &GetBSTR();
85 BSTR *GetAddress();
86 void Attach(BSTR s);
87 BSTR Detach();
88private:
89 class Data_t {
90 public:
91 Data_t(const char *s);
92 Data_t(const wchar_t *s);
93 Data_t(BSTR bstr,bool fCopy);
94 Data_t(const _bstr_t &s1,const _bstr_t &s2);
95 unsigned long AddRef() throw();
96 unsigned long Release() throw();
97 unsigned long RefCount() const throw();
98 operator const wchar_t *() const throw();
99 operator const char *() const;
100 const wchar_t *GetWString() const throw();
101 wchar_t *&GetWString() throw();
102 const char *GetString() const;
103 BSTR Copy() const;
104 void Assign(BSTR s);
105 void Attach(BSTR s) throw();
106 unsigned int Length() const throw();
107 int Compare(const Data_t &str) const throw();
108 void *operator new(size_t sz);
109 private:
110 BSTR m_wstr;
111 mutable char *m_str;
112 unsigned long m_RefCount;
113 Data_t() throw();
114 Data_t(const Data_t &s) throw();
115 ~Data_t() throw();
116 void _Free() throw();
117 };
118private:
119 Data_t *m_Data;
120private:
121 void _AddRef() throw();
122 void _Free() throw();
123 int _Compare(const _bstr_t &str) const throw();
124};
125
126inline _bstr_t::_bstr_t() throw() : m_Data(NULL) { }
127
128inline _bstr_t::_bstr_t(const _bstr_t &s) throw() : m_Data(s.m_Data) { _AddRef(); }
129
130inline _bstr_t::_bstr_t(const char *s) : m_Data(new Data_t(s)) {
131 if(!m_Data) { _com_issue_error(E_OUTOFMEMORY); }
132}
133
134inline _bstr_t::_bstr_t(const wchar_t *s) : m_Data(new Data_t(s)) {
135 if(!m_Data) { _com_issue_error(E_OUTOFMEMORY); }
136}
137
138inline _bstr_t::_bstr_t(BSTR bstr,bool fCopy) : m_Data(new Data_t(bstr,fCopy)) {
139 if(!m_Data) { _com_issue_error(E_OUTOFMEMORY); }
140}
141
142inline _bstr_t::~_bstr_t() throw() { _Free(); }
143
144inline _bstr_t &_bstr_t::operator=(const _bstr_t &s) throw() {
145 if(this!=&s) {
146 _Free();
147 m_Data = s.m_Data;
148 _AddRef();
149 }
150 return *this;
151}
152
153inline _bstr_t &_bstr_t::operator=(const char *s) {
154 _COM_ASSERT(!s || static_cast<const char *>(*this)!=s);
155 if(!s || static_cast<const char *>(*this)!=s) {
156 _Free();
157 m_Data = new Data_t(s);
158 if(!m_Data) { _com_issue_error(E_OUTOFMEMORY); }
159 }
160 return *this;
161}
162
163inline _bstr_t &_bstr_t::operator=(const wchar_t *s) {
164 _COM_ASSERT(!s || static_cast<const wchar_t *>(*this)!=s);
165 if(!s || static_cast<const wchar_t *>(*this)!=s) {
166 _Free();
167 m_Data = new Data_t(s);
168 if(!m_Data) { _com_issue_error(E_OUTOFMEMORY); }
169 }
170 return *this;
171}
172
173inline _bstr_t &_bstr_t::operator+=(const _bstr_t &s) {
174 Data_t *newData = new Data_t(*this,s);
175 if(!newData) { _com_issue_error(E_OUTOFMEMORY); }
176 else {
177 _Free();
178 m_Data = newData;
179 }
180 return *this;
181}
182
183inline _bstr_t _bstr_t::operator+(const _bstr_t &s) const {
184 _bstr_t b = *this;
185 b += s;
186 return b;
187}
188
189inline _bstr_t operator+(const char *s1,const _bstr_t &s2) {
190 _bstr_t b = s1;
191 b += s2;
192 return b;
193}
194
195inline _bstr_t operator+(const wchar_t *s1,const _bstr_t &s2) {
196 _bstr_t b = s1;
197 b += s2;
198 return b;
199}
200
201inline _bstr_t::operator const wchar_t *() const throw() { return (m_Data!=NULL) ? m_Data->GetWString() : NULL; }
202inline _bstr_t::operator wchar_t *() const throw() { return const_cast<wchar_t *>((m_Data!=NULL) ? m_Data->GetWString() : NULL); }
203inline _bstr_t::operator const char *() const { return (m_Data!=NULL) ? m_Data->GetString() : NULL; }
204inline _bstr_t::operator char *() const { return const_cast<char *>((m_Data!=NULL) ? m_Data->GetString() : NULL); }
205inline bool _bstr_t::operator!() const throw() { return (m_Data!=NULL) ? !m_Data->GetWString() : true; }
206inline bool _bstr_t::operator==(const _bstr_t &str) const throw() { return _Compare(str)==0; }
207inline bool _bstr_t::operator!=(const _bstr_t &str) const throw() { return _Compare(str)!=0; }
208inline bool _bstr_t::operator<(const _bstr_t &str) const throw() { return _Compare(str)<0; }
209inline bool _bstr_t::operator>(const _bstr_t &str) const throw() { return _Compare(str)>0; }
210inline bool _bstr_t::operator<=(const _bstr_t &str) const throw() { return _Compare(str)<=0; }
211inline bool _bstr_t::operator>=(const _bstr_t &str) const throw() { return _Compare(str)>=0; }
212inline BSTR _bstr_t::copy(bool fCopy) const { return (m_Data!=NULL) ? (fCopy ? m_Data->Copy() : m_Data->GetWString()) : NULL; }
213inline unsigned int _bstr_t::length() const throw() { return (m_Data!=NULL) ? m_Data->Length() : 0; }
214inline void _bstr_t::Assign(BSTR s) {
215 _COM_ASSERT(!s || !m_Data || m_Data->GetWString()!=s);
216 if(!s || !m_Data || m_Data->GetWString()!=s) {
217 _Free();
218 m_Data = new Data_t(s,TRUE);
219 if(!m_Data) { _com_issue_error(E_OUTOFMEMORY); }
220 }
221}
222
223inline BSTR &_bstr_t::GetBSTR() {
224 if(!m_Data) {
225 m_Data = new Data_t(0,FALSE);
226 if(!m_Data) { _com_issue_error(E_OUTOFMEMORY); }
227 }
228 return m_Data->GetWString();
229}
230
231inline BSTR *_bstr_t::GetAddress() {
232 Attach(0);
233 return &m_Data->GetWString();
234}
235
236inline void _bstr_t::Attach(BSTR s) {
237 _Free();
238 m_Data = new Data_t(s,FALSE);
239 if(!m_Data) { _com_issue_error(E_OUTOFMEMORY); }
240}
241
242inline BSTR _bstr_t::Detach() {
243 _COM_ASSERT(m_Data!=NULL && m_Data->RefCount()==1);
244 if(m_Data!=NULL && m_Data->RefCount()==1) {
245 BSTR b = m_Data->GetWString();
246 m_Data->GetWString() = NULL;
247 _Free();
248 return b;
249 } else {
250 _com_issue_error(E_POINTER);
251 return NULL;
252 }
253}
254
255inline void _bstr_t::_AddRef() throw() {
256 if(m_Data!=NULL) m_Data->AddRef();
257}
258
259inline void _bstr_t::_Free() throw() {
260 if(m_Data!=NULL) {
261 m_Data->Release();
262 m_Data = NULL;
263 }
264}
265
266inline int _bstr_t::_Compare(const _bstr_t &str) const throw() {
267 if(m_Data==str.m_Data) return 0;
268 if(!m_Data) return -1;
269 if(!str.m_Data) return 1;
270 return m_Data->Compare(*str.m_Data);
271}
272
273inline _bstr_t::Data_t::Data_t(const char *s) : m_str(NULL),m_RefCount(1) {
274 m_wstr = _com_util::ConvertStringToBSTR(s);
275}
276
277inline _bstr_t::Data_t::Data_t(const wchar_t *s) : m_str(NULL),m_RefCount(1) {
278 m_wstr = ::SysAllocString(s);
279 if(!m_wstr && s!=NULL) { _com_issue_error(E_OUTOFMEMORY); }
280}
281
282inline _bstr_t::Data_t::Data_t(BSTR bstr,bool fCopy) : m_str(NULL),m_RefCount(1) {
283 if(fCopy && bstr!=NULL) {
284 m_wstr = ::SysAllocStringByteLen(reinterpret_cast<char *>(bstr),::SysStringByteLen(bstr));
285 if(!m_wstr) { _com_issue_error(E_OUTOFMEMORY); }
286 } else m_wstr = bstr;
287}
288
289inline _bstr_t::Data_t::Data_t(const _bstr_t &s1,const _bstr_t &s2) : m_str(NULL),m_RefCount(1) {
290 const unsigned int l1 = s1.length();
291 const unsigned int l2 = s2.length();
292 m_wstr = ::SysAllocStringByteLen(NULL,(l1 + l2) *sizeof(wchar_t));
293 if(!m_wstr) {
294 _com_issue_error(E_OUTOFMEMORY);
295 return;
296 }
297 const wchar_t *wstr1 = static_cast<const wchar_t *>(s1);
298 if(wstr1!=NULL) {
299 _COM_MEMCPY_S(m_wstr,(l1 + l2 + 1) *sizeof(wchar_t),wstr1,(l1 + 1) *sizeof(wchar_t));
300 }
301 const wchar_t *wstr2 = static_cast<const wchar_t *>(s2);
302 if(wstr2!=NULL) {
303 _COM_MEMCPY_S(m_wstr + l1,(l2 + 1) *sizeof(wchar_t),wstr2,(l2 + 1) *sizeof(wchar_t));
304 }
305}
306
307inline unsigned long _bstr_t::Data_t::AddRef() throw() {
308 InterlockedIncrement(reinterpret_cast<LONG*>(&m_RefCount));
309 return m_RefCount;
310}
311
312inline unsigned long _bstr_t::Data_t::Release() throw() {
313 unsigned long cRef = InterlockedDecrement(reinterpret_cast<LONG*>(&m_RefCount));
314 if(cRef==0) delete this;
315 return cRef;
316}
317
318inline unsigned long _bstr_t::Data_t::RefCount() const throw() { return m_RefCount; }
319inline _bstr_t::Data_t::operator const wchar_t *() const throw() { return m_wstr; }
320inline _bstr_t::Data_t::operator const char *() const { return GetString(); }
321inline const wchar_t *_bstr_t::Data_t::GetWString() const throw() { return m_wstr; }
322inline wchar_t *&_bstr_t::Data_t::GetWString() throw() { return m_wstr; }
323inline const char *_bstr_t::Data_t::GetString() const {
324 if(!m_str) m_str = _com_util::ConvertBSTRToString(m_wstr);
325 return m_str;
326}
327inline BSTR _bstr_t::Data_t::Copy() const {
328 if(m_wstr!=NULL) {
329 BSTR bstr = ::SysAllocStringByteLen(reinterpret_cast<char *>(m_wstr),::SysStringByteLen(m_wstr));
330 if(!bstr) { _com_issue_error(E_OUTOFMEMORY); }
331 return bstr;
332 }
333 return NULL;
334}
335inline void _bstr_t::Data_t::Assign(BSTR s) {
336 _Free();
337 if(s!=NULL) {
338 m_wstr = ::SysAllocStringByteLen(reinterpret_cast<char *>(s),::SysStringByteLen(s));
339 m_str = 0;
340 }
341}
342inline void _bstr_t::Data_t::Attach(BSTR s) throw() {
343 _Free();
344 m_wstr = s;
345 m_str = 0;
346 m_RefCount = 1;
347}
348inline unsigned int _bstr_t::Data_t::Length() const throw() { return m_wstr ? ::SysStringLen(m_wstr) : 0; }
349inline int _bstr_t::Data_t::Compare(const _bstr_t::Data_t &str) const throw() {
350 if(!m_wstr) return str.m_wstr ? -1 : 0;
351 if(!str.m_wstr) return 1;
352 const unsigned int l1 = ::SysStringLen(m_wstr);
353 const unsigned int l2 = ::SysStringLen(str.m_wstr);
354 unsigned int len = l1;
355 if(len>l2) len = l2;
356 BSTR bstr1 = m_wstr;
357 BSTR bstr2 = str.m_wstr;
358 while (len-->0) {
359 if(*bstr1++!=*bstr2++) return bstr1[-1] - bstr2[-1];
360 }
361 return (l1<l2) ? -1 : (l1==l2) ? 0 : 1;
362}
363
364#ifdef _COM_OPERATOR_NEW_THROWS
365inline void *_bstr_t::Data_t::operator new(size_t sz) {
366 try {
367 return ::operator new(sz);
368 } catch (...) {
369 return NULL;
370 }
371}
372#else
373inline void *_bstr_t::Data_t::operator new(size_t sz) {
374 return ::operator new(sz);
375}
376#endif
377
378inline _bstr_t::Data_t::~Data_t() throw() { _Free(); }
379inline void _bstr_t::Data_t::_Free() throw() {
380 if(m_wstr!=NULL) ::SysFreeString(m_wstr);
381 if(m_str!=NULL) delete [] m_str;
382}
383
384class _variant_t : public ::tagVARIANT {
385public:
386 _variant_t() throw();
387 _variant_t(const VARIANT &varSrc);
388 _variant_t(const VARIANT *pSrc);
389 _variant_t(const _variant_t &varSrc);
390 _variant_t(VARIANT &varSrc,bool fCopy);
391 _variant_t(short sSrc,VARTYPE vtSrc = VT_I2);
392 _variant_t(long lSrc,VARTYPE vtSrc = VT_I4);
393 _variant_t(float fltSrc) throw();
394 _variant_t(double dblSrc,VARTYPE vtSrc = VT_R8);
395 _variant_t(const CY &cySrc) throw();
396 _variant_t(const _bstr_t &bstrSrc);
397 _variant_t(const wchar_t *pSrc);
398 _variant_t(const char *pSrc);
399 _variant_t(IDispatch *pSrc,bool fAddRef = true) throw();
400 _variant_t(bool boolSrc) throw();
401 _variant_t(IUnknown *pSrc,bool fAddRef = true) throw();
402 _variant_t(const DECIMAL &decSrc) throw();
403 _variant_t(BYTE bSrc) throw();
404 _variant_t(char cSrc) throw();
405 _variant_t(unsigned short usSrc) throw();
406 _variant_t(unsigned long ulSrc) throw();
407 _variant_t(int iSrc) throw();
408 _variant_t(unsigned int uiSrc) throw();
409 __MINGW_EXTENSION _variant_t(__int64 i8Src) throw();
410 __MINGW_EXTENSION _variant_t(unsigned __int64 ui8Src) throw();
411 ~_variant_t() throw();
412 operator short() const;
413 operator long() const;
414 operator float() const;
415 operator double() const;
416 operator CY() const;
417 operator _bstr_t() const;
418 operator IDispatch*() const;
419 operator bool() const;
420 operator IUnknown*() const;
421 operator DECIMAL() const;
422 operator BYTE() const;
423 operator char() const;
424 operator unsigned short() const;
425 operator unsigned long() const;
426 operator int() const;
427 operator unsigned int() const;
428 __MINGW_EXTENSION operator __int64() const;
429 __MINGW_EXTENSION operator unsigned __int64() const;
430 _variant_t &operator=(const VARIANT &varSrc);
431 _variant_t &operator=(const VARIANT *pSrc);
432 _variant_t &operator=(const _variant_t &varSrc);
433 _variant_t &operator=(short sSrc);
434 _variant_t &operator=(long lSrc);
435 _variant_t &operator=(float fltSrc);
436 _variant_t &operator=(double dblSrc);
437 _variant_t &operator=(const CY &cySrc);
438 _variant_t &operator=(const _bstr_t &bstrSrc);
439 _variant_t &operator=(const wchar_t *pSrc);
440 _variant_t &operator=(const char *pSrc);
441 _variant_t &operator=(IDispatch *pSrc);
442 _variant_t &operator=(bool boolSrc);
443 _variant_t &operator=(IUnknown *pSrc);
444 _variant_t &operator=(const DECIMAL &decSrc);
445 _variant_t &operator=(BYTE bSrc);
446 _variant_t &operator=(char cSrc);
447 _variant_t &operator=(unsigned short usSrc);
448 _variant_t &operator=(unsigned long ulSrc);
449 _variant_t &operator=(int iSrc);
450 _variant_t &operator=(unsigned int uiSrc);
451 __MINGW_EXTENSION _variant_t &operator=(__int64 i8Src);
452 __MINGW_EXTENSION _variant_t &operator=(unsigned __int64 ui8Src);
453 bool operator==(const VARIANT &varSrc) const throw();
454 bool operator==(const VARIANT *pSrc) const throw();
455 bool operator!=(const VARIANT &varSrc) const throw();
456 bool operator!=(const VARIANT *pSrc) const throw();
457 void Clear();
458 void Attach(VARIANT &varSrc);
459 VARIANT Detach();
460 VARIANT &GetVARIANT() throw();
461 VARIANT *GetAddress();
462 void ChangeType(VARTYPE vartype,const _variant_t *pSrc = NULL);
463 void SetString(const char *pSrc);
464};
465
466inline _variant_t::_variant_t() throw() { ::VariantInit(this); }
467inline _variant_t::_variant_t(const VARIANT &varSrc) {
468 ::VariantInit(this);
469 _com_util::CheckError(::VariantCopy(this,const_cast<VARIANT*>(&varSrc)));
470}
471inline _variant_t::_variant_t(const VARIANT *pSrc) {
472 if(!pSrc) { _com_issue_error(E_POINTER); }
473 else {
474 ::VariantInit(this);
475 _com_util::CheckError(::VariantCopy(this,const_cast<VARIANT*>(pSrc)));
476 }
477}
478inline _variant_t::_variant_t(const _variant_t &varSrc) {
479 ::VariantInit(this);
480 _com_util::CheckError(::VariantCopy(this,const_cast<VARIANT*>(static_cast<const VARIANT*>(&varSrc))));
481}
482inline _variant_t::_variant_t(VARIANT &varSrc,bool fCopy) {
483 if(fCopy) {
484 ::VariantInit(this);
485 _com_util::CheckError(::VariantCopy(this,&varSrc));
486 } else {
487 _COM_MEMCPY_S(static_cast<void*>(this),sizeof(varSrc),&varSrc,sizeof(varSrc));
488 V_VT(&varSrc) = VT_EMPTY;
489 }
490}
491inline _variant_t::_variant_t(short sSrc,VARTYPE vtSrc) {
492 if((vtSrc!=VT_I2) && (vtSrc!=VT_BOOL)) {
493 _com_issue_error(E_INVALIDARG);
494 return;
495 }
496 if(vtSrc==VT_BOOL) {
497 V_VT(this) = VT_BOOL;
498 V_BOOL(this) = (sSrc ? VARIANT_TRUE : VARIANT_FALSE);
499 } else {
500 V_VT(this) = VT_I2;
501 V_I2(this) = sSrc;
502 }
503}
504inline _variant_t::_variant_t(long lSrc,VARTYPE vtSrc) {
505 if((vtSrc!=VT_I4) && (vtSrc!=VT_ERROR) && (vtSrc!=VT_BOOL)) {
506 _com_issue_error(E_INVALIDARG);
507 return;
508 }
509 if(vtSrc==VT_ERROR) {
510 V_VT(this) = VT_ERROR;
511 V_ERROR(this) = lSrc;
512 } else if(vtSrc==VT_BOOL) {
513 V_VT(this) = VT_BOOL;
514 V_BOOL(this) = (lSrc ? VARIANT_TRUE : VARIANT_FALSE);
515 } else {
516 V_VT(this) = VT_I4;
517 V_I4(this) = lSrc;
518 }
519}
520inline _variant_t::_variant_t(float fltSrc) throw() {
521 V_VT(this) = VT_R4;
522 V_R4(this) = fltSrc;
523}
524
525inline _variant_t::_variant_t(double dblSrc,VARTYPE vtSrc) {
526 if((vtSrc!=VT_R8) && (vtSrc!=VT_DATE)) {
527 _com_issue_error(E_INVALIDARG);
528 return;
529 }
530 if(vtSrc==VT_DATE) {
531 V_VT(this) = VT_DATE;
532 V_DATE(this) = dblSrc;
533 } else {
534 V_VT(this) = VT_R8;
535 V_R8(this) = dblSrc;
536 }
537}
538inline _variant_t::_variant_t(const CY &cySrc) throw() {
539 V_VT(this) = VT_CY;
540 V_CY(this) = cySrc;
541}
542inline _variant_t::_variant_t(const _bstr_t &bstrSrc) {
543 V_VT(this) = VT_BSTR;
544 BSTR bstr = static_cast<wchar_t *>(bstrSrc);
545 if(!bstr) V_BSTR(this) = NULL;
546 else {
547 V_BSTR(this) = ::SysAllocStringByteLen(reinterpret_cast<char *>(bstr),::SysStringByteLen(bstr));
548 if(!(V_BSTR(this))) { _com_issue_error(E_OUTOFMEMORY); }
549 }
550}
551inline _variant_t::_variant_t(const wchar_t *pSrc) {
552 V_VT(this) = VT_BSTR;
553 V_BSTR(this) = ::SysAllocString(pSrc);
554 if(!(V_BSTR(this)) && pSrc!=NULL) { _com_issue_error(E_OUTOFMEMORY); }
555}
556inline _variant_t::_variant_t(const char *pSrc) {
557 V_VT(this) = VT_BSTR;
558 V_BSTR(this) = _com_util::ConvertStringToBSTR(pSrc);
559}
560inline _variant_t::_variant_t(IDispatch *pSrc,bool fAddRef) throw() {
561 V_VT(this) = VT_DISPATCH;
562 V_DISPATCH(this) = pSrc;
563 if(fAddRef && V_DISPATCH(this)!=NULL) V_DISPATCH(this)->AddRef();
564}
565inline _variant_t::_variant_t(bool boolSrc) throw() {
566 V_VT(this) = VT_BOOL;
567 V_BOOL(this) = (boolSrc ? VARIANT_TRUE : VARIANT_FALSE);
568}
569inline _variant_t::_variant_t(IUnknown *pSrc,bool fAddRef) throw() {
570 V_VT(this) = VT_UNKNOWN;
571 V_UNKNOWN(this) = pSrc;
572 if(fAddRef && V_UNKNOWN(this)!=NULL) V_UNKNOWN(this)->AddRef();
573}
574inline _variant_t::_variant_t(const DECIMAL &decSrc) throw() {
575 V_DECIMAL(this) = decSrc;
576 V_VT(this) = VT_DECIMAL;
577}
578inline _variant_t::_variant_t(BYTE bSrc) throw() {
579 V_VT(this) = VT_UI1;
580 V_UI1(this) = bSrc;
581}
582inline _variant_t::_variant_t(char cSrc) throw() {
583 V_VT(this) = VT_I1;
584 V_I1(this) = cSrc;
585}
586inline _variant_t::_variant_t(unsigned short usSrc) throw() {
587 V_VT(this) = VT_UI2;
588 V_UI2(this) = usSrc;
589}
590inline _variant_t::_variant_t(unsigned long ulSrc) throw() {
591 V_VT(this) = VT_UI4;
592 V_UI4(this) = ulSrc;
593}
594inline _variant_t::_variant_t(int iSrc) throw() {
595 V_VT(this) = VT_INT;
596 V_INT(this) = iSrc;
597}
598inline _variant_t::_variant_t(unsigned int uiSrc) throw() {
599 V_VT(this) = VT_UINT;
600 V_UINT(this) = uiSrc;
601}
602__MINGW_EXTENSION inline _variant_t::_variant_t(__int64 i8Src) throw() {
603 V_VT(this) = VT_I8;
604 V_I8(this) = i8Src;
605}
606__MINGW_EXTENSION inline _variant_t::_variant_t(unsigned __int64 ui8Src) throw() {
607 V_VT(this) = VT_UI8;
608 V_UI8(this) = ui8Src;
609}
610inline _variant_t::operator short() const {
611 if(V_VT(this)==VT_I2) return V_I2(this);
612 _variant_t varDest;
613 varDest.ChangeType(VT_I2,this);
614 return V_I2(&varDest);
615}
616inline _variant_t::operator long() const {
617 if(V_VT(this)==VT_I4) return V_I4(this);
618 _variant_t varDest;
619 varDest.ChangeType(VT_I4,this);
620 return V_I4(&varDest);
621}
622
623inline _variant_t::operator float() const {
624 if(V_VT(this)==VT_R4) return V_R4(this);
625 _variant_t varDest;
626 varDest.ChangeType(VT_R4,this);
627 return V_R4(&varDest);
628}
629
630inline _variant_t::operator double() const {
631 if(V_VT(this)==VT_R8) return V_R8(this);
632 _variant_t varDest;
633 varDest.ChangeType(VT_R8,this);
634 return V_R8(&varDest);
635}
636
637inline _variant_t::operator CY() const {
638 if(V_VT(this)==VT_CY) return V_CY(this);
639 _variant_t varDest;
640 varDest.ChangeType(VT_CY,this);
641 return V_CY(&varDest);
642}
643
644inline _variant_t::operator _bstr_t() const {
645 if(V_VT(this)==VT_BSTR) return V_BSTR(this);
646 _variant_t varDest;
647 varDest.ChangeType(VT_BSTR,this);
648 return V_BSTR(&varDest);
649}
650
651inline _variant_t::operator IDispatch*() const {
652 if(V_VT(this)==VT_DISPATCH) {
653 if(V_DISPATCH(this)!=NULL) V_DISPATCH(this)->AddRef();
654 return V_DISPATCH(this);
655 }
656 _variant_t varDest;
657 varDest.ChangeType(VT_DISPATCH,this);
658 if(V_DISPATCH(&varDest)!=NULL) V_DISPATCH(&varDest)->AddRef();
659 return V_DISPATCH(&varDest);
660}
661inline _variant_t::operator bool() const {
662 if(V_VT(this)==VT_BOOL) return V_BOOL(this) ? true : false;
663 _variant_t varDest;
664 varDest.ChangeType(VT_BOOL,this);
665 return (V_BOOL(&varDest)==VARIANT_TRUE) ? true : false;
666}
667
668inline _variant_t::operator IUnknown*() const {
669 if(V_VT(this)==VT_UNKNOWN) {
670 if(V_UNKNOWN(this)!=NULL) V_UNKNOWN(this)->AddRef();
671 return V_UNKNOWN(this);
672 }
673 _variant_t varDest;
674 varDest.ChangeType(VT_UNKNOWN,this);
675 if(V_UNKNOWN(&varDest)!=NULL) V_UNKNOWN(&varDest)->AddRef();
676 return V_UNKNOWN(&varDest);
677}
678inline _variant_t::operator DECIMAL() const {
679 if(V_VT(this)==VT_DECIMAL) return V_DECIMAL(this);
680 _variant_t varDest;
681 varDest.ChangeType(VT_DECIMAL,this);
682 return V_DECIMAL(&varDest);
683}
684inline _variant_t::operator BYTE() const {
685 if(V_VT(this)==VT_UI1) return V_UI1(this);
686 _variant_t varDest;
687 varDest.ChangeType(VT_UI1,this);
688 return V_UI1(&varDest);
689}
690inline _variant_t::operator char() const {
691 if(V_VT(this)==VT_I1) return V_I1(this);
692 _variant_t varDest;
693 varDest.ChangeType(VT_I1,this);
694 return V_I1(&varDest);
695}
696
697inline _variant_t::operator unsigned short() const {
698 if(V_VT(this)==VT_UI2) return V_UI2(this);
699 _variant_t varDest;
700 varDest.ChangeType(VT_UI2,this);
701 return V_UI2(&varDest);
702}
703
704inline _variant_t::operator unsigned long() const {
705 if(V_VT(this)==VT_UI4) return V_UI4(this);
706 _variant_t varDest;
707 varDest.ChangeType(VT_UI4,this);
708 return V_UI4(&varDest);
709}
710inline _variant_t::operator int() const {
711 if(V_VT(this)==VT_INT) return V_INT(this);
712 _variant_t varDest;
713 varDest.ChangeType(VT_INT,this);
714 return V_INT(&varDest);
715}
716inline _variant_t::operator unsigned int() const {
717 if(V_VT(this)==VT_UINT) return V_UINT(this);
718 _variant_t varDest;
719 varDest.ChangeType(VT_UINT,this);
720 return V_UINT(&varDest);
721}
722__MINGW_EXTENSION inline _variant_t::operator __int64() const {
723 if(V_VT(this)==VT_I8) return V_I8(this);
724 _variant_t varDest;
725 varDest.ChangeType(VT_I8,this);
726 return V_I8(&varDest);
727}
728__MINGW_EXTENSION inline _variant_t::operator unsigned __int64() const {
729 if(V_VT(this)==VT_UI8) return V_UI8(this);
730 _variant_t varDest;
731 varDest.ChangeType(VT_UI8,this);
732 return V_UI8(&varDest);
733}
734inline _variant_t &_variant_t::operator=(const VARIANT &varSrc) {
735 _com_util::CheckError(::VariantCopy(this,const_cast<VARIANT*>(&varSrc)));
736 return *this;
737}
738inline _variant_t &_variant_t::operator=(const VARIANT *pSrc) {
739 if(!pSrc) { _com_issue_error(E_POINTER); }
740 else { _com_util::CheckError(::VariantCopy(this,const_cast<VARIANT*>(pSrc))); }
741 return *this;
742}
743inline _variant_t &_variant_t::operator=(const _variant_t &varSrc) {
744 _com_util::CheckError(::VariantCopy(this,const_cast<VARIANT*>(static_cast<const VARIANT*>(&varSrc))));
745 return *this;
746}
747inline _variant_t &_variant_t::operator=(short sSrc) {
748 if(V_VT(this)==VT_I2) V_I2(this) = sSrc;
749 else if(V_VT(this)==VT_BOOL) V_BOOL(this) = (sSrc ? VARIANT_TRUE : VARIANT_FALSE);
750 else {
751 Clear();
752 V_VT(this) = VT_I2;
753 V_I2(this) = sSrc;
754 }
755 return *this;
756}
757inline _variant_t &_variant_t::operator=(long lSrc) {
758 if(V_VT(this)==VT_I4) V_I4(this) = lSrc;
759 else if(V_VT(this)==VT_ERROR) V_ERROR(this) = lSrc;
760 else if(V_VT(this)==VT_BOOL) V_BOOL(this) = (lSrc ? VARIANT_TRUE : VARIANT_FALSE);
761 else {
762 Clear();
763 V_VT(this) = VT_I4;
764 V_I4(this) = lSrc;
765 }
766 return *this;
767}
768inline _variant_t &_variant_t::operator=(float fltSrc) {
769 if(V_VT(this)!=VT_R4) {
770 Clear();
771 V_VT(this) = VT_R4;
772 }
773 V_R4(this) = fltSrc;
774 return *this;
775}
776
777inline _variant_t &_variant_t::operator=(double dblSrc)
778{
779 if(V_VT(this)==VT_R8) {
780 V_R8(this) = dblSrc;
781 }
782 else if(V_VT(this)==VT_DATE) {
783 V_DATE(this) = dblSrc;
784 }
785 else {
786
787 Clear();
788
789 V_VT(this) = VT_R8;
790 V_R8(this) = dblSrc;
791 }
792
793 return *this;
794}
795
796inline _variant_t &_variant_t::operator=(const CY &cySrc)
797{
798 if(V_VT(this)!=VT_CY) {
799
800 Clear();
801
802 V_VT(this) = VT_CY;
803 }
804
805 V_CY(this) = cySrc;
806
807 return *this;
808}
809
810inline _variant_t &_variant_t::operator=(const _bstr_t &bstrSrc)
811{
812 _COM_ASSERT(V_VT(this)!=VT_BSTR || !((BSTR) bstrSrc) || V_BSTR(this)!=(BSTR) bstrSrc);
813
814 Clear();
815
816 V_VT(this) = VT_BSTR;
817
818 if(!bstrSrc) {
819 V_BSTR(this) = NULL;
820 }
821 else {
822 BSTR bstr = static_cast<wchar_t *>(bstrSrc);
823 V_BSTR(this) = ::SysAllocStringByteLen(reinterpret_cast<char *>(bstr),::SysStringByteLen(bstr));
824
825 if(!(V_BSTR(this))) {
826 _com_issue_error(E_OUTOFMEMORY);
827 }
828 }
829
830 return *this;
831}
832
833inline _variant_t &_variant_t::operator=(const wchar_t *pSrc)
834{
835 _COM_ASSERT(V_VT(this)!=VT_BSTR || !pSrc || V_BSTR(this)!=pSrc);
836
837 Clear();
838
839 V_VT(this) = VT_BSTR;
840
841 if(!pSrc) {
842 V_BSTR(this) = NULL;
843 }
844 else {
845 V_BSTR(this) = ::SysAllocString(pSrc);
846
847 if(!(V_BSTR(this))) {
848 _com_issue_error(E_OUTOFMEMORY);
849 }
850 }
851
852 return *this;
853}
854
855inline _variant_t &_variant_t::operator=(const char *pSrc)
856{
857 _COM_ASSERT(V_VT(this)!=(VT_I1 | VT_BYREF) || !pSrc || V_I1REF(this)!=pSrc);
858
859 Clear();
860
861 V_VT(this) = VT_BSTR;
862 V_BSTR(this) = _com_util::ConvertStringToBSTR(pSrc);
863
864 return *this;
865}
866
867inline _variant_t &_variant_t::operator=(IDispatch *pSrc)
868{
869 _COM_ASSERT(V_VT(this)!=VT_DISPATCH || pSrc==0 || V_DISPATCH(this)!=pSrc);
870
871 Clear();
872
873 V_VT(this) = VT_DISPATCH;
874 V_DISPATCH(this) = pSrc;
875
876 if(V_DISPATCH(this)!=NULL) {
877
878 V_DISPATCH(this)->AddRef();
879 }
880
881 return *this;
882}
883
884inline _variant_t &_variant_t::operator=(bool boolSrc)
885{
886 if(V_VT(this)!=VT_BOOL) {
887
888 Clear();
889
890 V_VT(this) = VT_BOOL;
891 }
892
893 V_BOOL(this) = (boolSrc ? VARIANT_TRUE : VARIANT_FALSE);
894
895 return *this;
896}
897
898inline _variant_t &_variant_t::operator=(IUnknown *pSrc)
899{
900 _COM_ASSERT(V_VT(this)!=VT_UNKNOWN || !pSrc || V_UNKNOWN(this)!=pSrc);
901
902 Clear();
903
904 V_VT(this) = VT_UNKNOWN;
905 V_UNKNOWN(this) = pSrc;
906
907 if(V_UNKNOWN(this)!=NULL) {
908
909 V_UNKNOWN(this)->AddRef();
910 }
911
912 return *this;
913}
914
915inline _variant_t &_variant_t::operator=(const DECIMAL &decSrc)
916{
917 if(V_VT(this)!=VT_DECIMAL) {
918
919 Clear();
920 }
921
922 V_DECIMAL(this) = decSrc;
923 V_VT(this) = VT_DECIMAL;
924
925 return *this;
926}
927
928inline _variant_t &_variant_t::operator=(BYTE bSrc)
929{
930 if(V_VT(this)!=VT_UI1) {
931
932 Clear();
933
934 V_VT(this) = VT_UI1;
935 }
936
937 V_UI1(this) = bSrc;
938
939 return *this;
940}
941
942inline _variant_t &_variant_t::operator=(char cSrc)
943{
944 if(V_VT(this)!=VT_I1) {
945
946 Clear();
947
948 V_VT(this) = VT_I1;
949 }
950
951 V_I1(this) = cSrc;
952
953 return *this;
954}
955
956inline _variant_t &_variant_t::operator=(unsigned short usSrc)
957{
958 if(V_VT(this)!=VT_UI2) {
959
960 Clear();
961
962 V_VT(this) = VT_UI2;
963 }
964
965 V_UI2(this) = usSrc;
966
967 return *this;
968}
969
970inline _variant_t &_variant_t::operator=(unsigned long ulSrc)
971{
972 if(V_VT(this)!=VT_UI4) {
973
974 Clear();
975
976 V_VT(this) = VT_UI4;
977 }
978
979 V_UI4(this) = ulSrc;
980
981 return *this;
982}
983
984inline _variant_t &_variant_t::operator=(int iSrc)
985{
986 if(V_VT(this)!=VT_INT) {
987
988 Clear();
989
990 V_VT(this) = VT_INT;
991 }
992
993 V_INT(this) = iSrc;
994
995 return *this;
996}
997
998inline _variant_t &_variant_t::operator=(unsigned int uiSrc)
999{
1000 if(V_VT(this)!=VT_UINT) {
1001
1002 Clear();
1003
1004 V_VT(this) = VT_UINT;
1005 }
1006
1007 V_UINT(this) = uiSrc;
1008
1009 return *this;
1010}
1011
1012__MINGW_EXTENSION inline _variant_t &_variant_t::operator=(__int64 i8Src) {
1013 if(V_VT(this)!=VT_I8) {
1014
1015 Clear();
1016
1017 V_VT(this) = VT_I8;
1018 }
1019
1020 V_I8(this) = i8Src;
1021
1022 return *this;
1023}
1024
1025__MINGW_EXTENSION inline _variant_t &_variant_t::operator=(unsigned __int64 ui8Src) {
1026 if(V_VT(this)!=VT_UI8) {
1027
1028 Clear();
1029
1030 V_VT(this) = VT_UI8;
1031 }
1032
1033 V_UI8(this) = ui8Src;
1034
1035 return *this;
1036}
1037
1038inline bool _variant_t::operator==(const VARIANT &varSrc) const throw() {
1039 return *this==&varSrc;
1040}
1041
1042inline bool _variant_t::operator==(const VARIANT *pSrc) const throw()
1043{
1044 if(!pSrc) {
1045 return false;
1046 }
1047
1048 if(this==pSrc) {
1049 return true;
1050 }
1051
1052 if(V_VT(this)!=V_VT(pSrc)) {
1053 return false;
1054 }
1055
1056 switch (V_VT(this)) {
1057case VT_EMPTY:
1058case VT_NULL:
1059 return true;
1060
1061case VT_I2:
1062 return V_I2(this)==V_I2(pSrc);
1063
1064case VT_I4:
1065 return V_I4(this)==V_I4(pSrc);
1066
1067case VT_R4:
1068 return V_R4(this)==V_R4(pSrc);
1069
1070case VT_R8:
1071 return V_R8(this)==V_R8(pSrc);
1072
1073case VT_CY:
1074 return memcmp(&(V_CY(this)),&(V_CY(pSrc)),sizeof(CY))==0;
1075
1076case VT_DATE:
1077 return V_DATE(this)==V_DATE(pSrc);
1078
1079case VT_BSTR:
1080 return (::SysStringByteLen(V_BSTR(this))==::SysStringByteLen(V_BSTR(pSrc))) &&
1081 (memcmp(V_BSTR(this),V_BSTR(pSrc),::SysStringByteLen(V_BSTR(this)))==0);
1082
1083case VT_DISPATCH:
1084 return V_DISPATCH(this)==V_DISPATCH(pSrc);
1085
1086case VT_ERROR:
1087 return V_ERROR(this)==V_ERROR(pSrc);
1088
1089case VT_BOOL:
1090 return V_BOOL(this)==V_BOOL(pSrc);
1091
1092case VT_UNKNOWN:
1093 return V_UNKNOWN(this)==V_UNKNOWN(pSrc);
1094
1095case VT_DECIMAL:
1096 return memcmp(&(V_DECIMAL(this)),&(V_DECIMAL(pSrc)),sizeof(DECIMAL))==0;
1097
1098case VT_UI1:
1099 return V_UI1(this)==V_UI1(pSrc);
1100
1101case VT_I1:
1102 return V_I1(this)==V_I1(pSrc);
1103
1104case VT_UI2:
1105 return V_UI2(this)==V_UI2(pSrc);
1106
1107case VT_UI4:
1108 return V_UI4(this)==V_UI4(pSrc);
1109
1110case VT_INT:
1111 return V_INT(this)==V_INT(pSrc);
1112
1113case VT_UINT:
1114 return V_UINT(this)==V_UINT(pSrc);
1115
1116case VT_I8:
1117 return V_I8(this)==V_I8(pSrc);
1118
1119case VT_UI8:
1120 return V_UI8(this)==V_UI8(pSrc);
1121
1122default:
1123 _com_issue_error(E_INVALIDARG);
1124
1125 }
1126
1127 return false;
1128}
1129
1130inline bool _variant_t::operator!=(const VARIANT &varSrc) const throw()
1131{
1132 return !(*this==&varSrc);
1133}
1134
1135inline bool _variant_t::operator!=(const VARIANT *pSrc) const throw()
1136{
1137 return !(*this==pSrc);
1138}
1139
1140inline void _variant_t::Clear()
1141{
1142 _com_util::CheckError(::VariantClear(this));
1143}
1144
1145inline void _variant_t::Attach(VARIANT &varSrc)
1146{
1147
1148 Clear();
1149
1150 _COM_MEMCPY_S(static_cast<void*>(this),sizeof(varSrc),&varSrc,sizeof(varSrc));
1151 V_VT(&varSrc) = VT_EMPTY;
1152}
1153
1154inline VARIANT _variant_t::Detach()
1155{
1156 VARIANT varResult = *this;
1157 V_VT(this) = VT_EMPTY;
1158
1159 return varResult;
1160}
1161
1162inline VARIANT &_variant_t::GetVARIANT() throw()
1163{
1164 return *(VARIANT*) this;
1165}
1166
1167inline VARIANT *_variant_t::GetAddress() {
1168 Clear();
1169 return (VARIANT*) this;
1170}
1171inline void _variant_t::ChangeType(VARTYPE vartype,const _variant_t *pSrc) {
1172 if(!pSrc) pSrc = this;
1173 if((this!=pSrc) || (vartype!=V_VT(this))) {
1174 _com_util::CheckError(::VariantChangeType(static_cast<VARIANT*>(this),const_cast<VARIANT*>(static_cast<const VARIANT*>(pSrc)),0,vartype));
1175 }
1176}
1177inline void _variant_t::SetString(const char *pSrc) { operator=(pSrc); }
1178inline _variant_t::~_variant_t() throw() { ::VariantClear(this); }
1179inline _bstr_t::_bstr_t(const _variant_t &var) : m_Data(NULL) {
1180 if(V_VT(&var)==VT_BSTR) {
1181 *this = V_BSTR(&var);
1182 return;
1183 }
1184 _variant_t varDest;
1185 varDest.ChangeType(VT_BSTR,&var);
1186 *this = V_BSTR(&varDest);
1187}
1188inline _bstr_t &_bstr_t::operator=(const _variant_t &var) {
1189 if(V_VT(&var)==VT_BSTR) {
1190 *this = V_BSTR(&var);
1191 return *this;
1192 }
1193 _variant_t varDest;
1194 varDest.ChangeType(VT_BSTR,&var);
1195 *this = V_BSTR(&varDest);
1196 return *this;
1197}
1198
1199extern _variant_t vtMissing;
1200
1201#ifndef _USE_RAW
1202#define bstr_t _bstr_t
1203#define variant_t _variant_t
1204#endif
1205
1206#pragma pop_macro("new")
1207
1208#endif /* __cplusplus */
1209
1210#endif
__MINGW_EXTENSION
#define __MINGW_EXTENSION
Definition: _mingw.h:166
InterlockedIncrement
#define InterlockedIncrement
Definition: armddk.h:53
InterlockedDecrement
#define InterlockedDecrement
Definition: armddk.h:52
class
const WCHAR * class
Definition: main.c:68
copy
INT copy(TCHAR source[MAX_PATH], TCHAR dest[MAX_PATH], INT append, DWORD lpdwFlags, BOOL bTouch)
Definition: copy.c:51
Release
_In_ BOOLEAN Release
Definition: cdrom.h:920
operator+
CHString WINAPI operator+(CHSTRING_WCHAR ch, const CHString &string)
Definition: chstring.cpp:1356
_com_issue_error
void WINAPI _com_issue_error(HRESULT hr)
Definition: comsupp.cpp:32
vtMissing
_variant_t vtMissing(DISP_E_PARAMNOTFOUND, VT_ERROR)
_COM_ASSERT
#define _COM_ASSERT(x)
Definition: comutil.h:12
_COM_MEMCPY_S
#define _COM_MEMCPY_S(dest, destsize, src, count)
Definition: comutil.h:15
throw
result_buffer_count char *const _In_ int const _In_ bool const _In_ unsigned const _In_ STRFLT const _In_ bool const _Inout_ __crt_cached_ptd_host &ptd throw()
Definition: cvt.cpp:119
E_OUTOFMEMORY
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
E_INVALIDARG
#define E_INVALIDARG
Definition: ddrawi.h:101
hr
HRESULT hr
Definition: delayimp.cpp:573
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
CY
union tagCY CY
DECIMAL
struct tagDEC DECIMAL
BSTR
OLECHAR * BSTR
Definition: compat.h:2293
VARTYPE
unsigned short VARTYPE
Definition: compat.h:2254
VT_UI8
@ VT_UI8
Definition: compat.h:2315
VT_BSTR
@ VT_BSTR
Definition: compat.h:2303
VT_INT
@ VT_INT
Definition: compat.h:2316
VT_R4
@ VT_R4
Definition: compat.h:2299
VT_NULL
@ VT_NULL
Definition: compat.h:2296
VT_UNKNOWN
@ VT_UNKNOWN
Definition: compat.h:2308
VT_BYREF
@ VT_BYREF
Definition: compat.h:2342
VT_UI2
@ VT_UI2
Definition: compat.h:2312
VT_DECIMAL
@ VT_DECIMAL
Definition: compat.h:2309
VT_ERROR
@ VT_ERROR
Definition: compat.h:2305
VT_R8
@ VT_R8
Definition: compat.h:2300
VT_CY
@ VT_CY
Definition: compat.h:2301
VT_I8
@ VT_I8
Definition: compat.h:2314
VT_I1
@ VT_I1
Definition: compat.h:2310
VT_I4
@ VT_I4
Definition: compat.h:2298
VT_DATE
@ VT_DATE
Definition: compat.h:2302
VT_BOOL
@ VT_BOOL
Definition: compat.h:2306
VT_I2
@ VT_I2
Definition: compat.h:2297
VT_UI4
@ VT_UI4
Definition: compat.h:2313
VT_UINT
@ VT_UINT
Definition: compat.h:2317
VT_EMPTY
@ VT_EMPTY
Definition: compat.h:2295
VT_DISPATCH
@ VT_DISPATCH
Definition: compat.h:2304
VT_UI1
@ VT_UI1
Definition: compat.h:2311
__int64
#define __int64
Definition: corecrt.h:72
memcmp
_ACRTIMP int __cdecl memcmp(const void *, const void *, size_t)
Definition: string.c:2802
true
#define true
Definition: stdbool.h:24
Copy
VOID Copy(PVOID Src, PVOID Dst, ULONG NumBytes)
Definition: mmixer.c:126
char
unsigned char
Definition: typeof.h:29
int
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
short
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:94
Assign
return DeviceInit Security Sddl Assign(SDDLString)
s
GLdouble s
Definition: gl.h:2039
b
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
length
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
len
GLenum GLsizei len
Definition: glext.h:6722
GetAddress
BOOL GetAddress(const WCHAR *, INTERNET_PORT, SOCKADDR *, int *, char *) DECLSPEC_HIDDEN
Definition: utility.c:133
FAILED
#define FAILED(hr)
Definition: intsafe.h:51
b
#define b
Definition: ke_i.h:79
s1
struct S1 s1
Clear
static void Clear(void)
Definition: treeview.c:388
var
const char * var
Definition: shader.c:5666
double
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:91
GetBSTR
static BSTR GetBSTR(const LPINTERNAL_BSTR bstr)
Definition: vartype.c:4900
float
static float(__cdecl *square_half_float)(float x
AddRef
static ULONG WINAPI AddRef(IStream *iface)
Definition: clist.c:83
_com_util
Definition: comsupp.cpp:57
_com_util::ConvertStringToBSTR
BSTR WINAPI ConvertStringToBSTR(const char *pSrc)
Definition: comsupp.cpp:59
_com_util::ConvertBSTRToString
char *WINAPI ConvertBSTRToString(BSTR pSrc)
Definition: comsupp.cpp:93
bool
#define bool
Definition: nsiface.idl:72
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
SysStringByteLen
UINT WINAPI SysStringByteLen(BSTR str)
Definition: oleaut.c:215
SysAllocString
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238
SysStringLen
UINT WINAPI SysStringLen(BSTR str)
Definition: oleaut.c:196
SysFreeString
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:271
SysAllocStringByteLen
BSTR WINAPI DECLSPEC_HOTPATCH SysAllocStringByteLen(LPCSTR str, UINT len)
Definition: oleaut.c:428
V_ERROR
#define V_ERROR(A)
Definition: oleauto.h:241
V_UI1
#define V_UI1(A)
Definition: oleauto.h:266
V_I8
#define V_I8(A)
Definition: oleauto.h:249
V_BOOL
#define V_BOOL(A)
Definition: oleauto.h:224
V_UNKNOWN
#define V_UNKNOWN(A)
Definition: oleauto.h:281
V_UI2
#define V_UI2(A)
Definition: oleauto.h:268
V_I1
#define V_I1(A)
Definition: oleauto.h:243
V_VT
#define V_VT(A)
Definition: oleauto.h:211
V_BSTR
#define V_BSTR(A)
Definition: oleauto.h:226
V_I4
#define V_I4(A)
Definition: oleauto.h:247
V_R4
#define V_R4(A)
Definition: oleauto.h:260
V_DECIMAL
#define V_DECIMAL(A)
Definition: oleauto.h:236
V_UINT
#define V_UINT(A)
Definition: oleauto.h:264
V_CY
#define V_CY(A)
Definition: oleauto.h:229
V_UI4
#define V_UI4(A)
Definition: oleauto.h:270
V_DISPATCH
#define V_DISPATCH(A)
Definition: oleauto.h:239
V_R8
#define V_R8(A)
Definition: oleauto.h:262
V_DATE
#define V_DATE(A)
Definition: oleauto.h:231
V_I1REF
#define V_I1REF(A)
Definition: oleauto.h:244
V_UI8
#define V_UI8(A)
Definition: oleauto.h:272
V_I2
#define V_I2(A)
Definition: oleauto.h:245
LONG
long LONG
Definition: pedump.c:60
long
#define long
Definition: qsort.c:33
str
const WCHAR * str
Definition: rpc_transport.c:2696
inline
#define inline
Definition: compat.h:23
s2
PCWSTR s2
Definition: shell32_main.h:38
CheckError
void CheckError(HRESULT hr)
Definition: shellclasses.h:167
new
#define new(TYPE, numElems)
Definition: treelist.c:54
tagCY
Definition: compat.h:2255
VariantChangeType
HRESULT WINAPI DECLSPEC_HOTPATCH VariantChangeType(VARIANTARG *pvargDest, VARIANTARG *pvargSrc, USHORT wFlags, VARTYPE vt)
Definition: variant.c:962
VariantClear
HRESULT WINAPI DECLSPEC_HOTPATCH VariantClear(VARIANTARG *pVarg)
Definition: variant.c:648
VariantInit
void WINAPI VariantInit(VARIANTARG *pVarg)
Definition: variant.c:568
VariantCopy
HRESULT WINAPI VariantCopy(VARIANTARG *pvargDest, VARIANTARG *pvargSrc)
Definition: variant.c:748
operator
operator
Definition: wbemprox_private.h:48
V_INT
#define V_INT(x)
Definition: webchild.h:78
WINAPI
#define WINAPI
Definition: msvc.h:6
E_POINTER
#define E_POINTER
Definition: winerror.h:3480
BYTE
unsigned char BYTE
Definition: xxhash.c:193
const
#define const
Definition: zconf.h:233