ReactOS 0.4.16-dev-838-g27bb510
propvar.c
Go to the documentation of this file.
1/*
2 * PropVariant implementation
3 *
4 * Copyright 2008 James Hawkins for CodeWeavers
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21
22#include <stdarg.h>
23#include <stdio.h>
24#include <stdlib.h>
25
26#include "windef.h"
27#include "winbase.h"
28#include "winerror.h"
29#include "winreg.h"
30#include "winuser.h"
31#include "shlobj.h"
32#include "propvarutil.h"
33#include "strsafe.h"
34#include "wine/debug.h"
35
37
38#define GUID_STR_LEN 38
40{
41 VARTYPE vtExtra = vt & (VT_VECTOR | VT_ARRAY | VT_BYREF | VT_RESERVED);
42
43 vt &= VT_TYPEMASK;
44
45 if (!(vtExtra & (VT_VECTOR | VT_RESERVED)))
46 {
47 if (vt < VT_VOID || vt == VT_RECORD || vt == VT_CLSID)
48 {
49 if ((vtExtra & (VT_BYREF | VT_ARRAY)) && vt <= VT_NULL)
50 return DISP_E_BADVARTYPE;
51 if (vt != (VARTYPE)15)
52 return S_OK;
53 }
54 }
55
56 return DISP_E_BADVARTYPE;
57}
58
59static HRESULT PROPVAR_ConvertFILETIME(const FILETIME *ft, PROPVARIANT *ppropvarDest, VARTYPE vt)
60{
62
64
65 switch (vt)
66 {
67 case VT_LPSTR:
68 ppropvarDest->pszVal = HeapAlloc(GetProcessHeap(), 0, 64);
69 if (!ppropvarDest->pszVal)
70 return E_OUTOFMEMORY;
71
72 sprintf( ppropvarDest->pszVal, "%04d/%02d/%02d:%02d:%02d:%02d.%03d",
73 time.wYear, time.wMonth, time.wDay,
74 time.wHour, time.wMinute, time.wSecond,
75 time.wMilliseconds );
76
77 return S_OK;
78
79 default:
80 FIXME("Unhandled target type: %d\n", vt);
81 }
82
83 return E_FAIL;
84}
85
86static HRESULT PROPVAR_ConvertNumber(REFPROPVARIANT pv, int dest_bits,
87 BOOL dest_signed, LONGLONG *res)
88{
89 BOOL src_signed;
90
91 switch (pv->vt)
92 {
93 case VT_I1:
94 src_signed = TRUE;
95 *res = pv->cVal;
96 break;
97 case VT_UI1:
98 src_signed = FALSE;
99 *res = pv->bVal;
100 break;
101 case VT_I2:
102 src_signed = TRUE;
103 *res = pv->iVal;
104 break;
105 case VT_UI2:
106 src_signed = FALSE;
107 *res = pv->uiVal;
108 break;
109 case VT_I4:
110 src_signed = TRUE;
111 *res = pv->lVal;
112 break;
113 case VT_UI4:
114 src_signed = FALSE;
115 *res = pv->ulVal;
116 break;
117 case VT_I8:
118 src_signed = TRUE;
119 *res = pv->hVal.QuadPart;
120 break;
121 case VT_UI8:
122 src_signed = FALSE;
123 *res = pv->uhVal.QuadPart;
124 break;
125 case VT_EMPTY:
126 src_signed = FALSE;
127 *res = 0;
128 break;
129 case VT_LPSTR:
130 {
131 char *end;
132#ifdef __REACTOS__
133 *res = _strtoi64(pv->pszVal, &end, 0);
134#else
135 *res = strtoll(pv->pszVal, &end, 0);
136#endif
137 if (pv->pszVal == end)
138 return DISP_E_TYPEMISMATCH;
139 src_signed = *res < 0;
140 break;
141 }
142 case VT_LPWSTR:
143 case VT_BSTR:
144 {
145 WCHAR *end;
146 *res = wcstol(pv->pwszVal, &end, 0);
147 if (pv->pwszVal == end)
148 return DISP_E_TYPEMISMATCH;
149 src_signed = *res < 0;
150 break;
151 }
152 case VT_R8:
153 {
154 src_signed = TRUE;
155 *res = pv->dblVal;
156 break;
157 }
158 default:
159 FIXME("unhandled vt %d\n", pv->vt);
160 return E_NOTIMPL;
161 }
162
163 if (*res < 0 && src_signed != dest_signed)
165
166 if (dest_bits < 64)
167 {
168 if (dest_signed)
169 {
170 if (*res >= ((LONGLONG)1 << (dest_bits-1)) ||
171 *res < ((LONGLONG)-1 << (dest_bits-1)))
173 }
174 else
175 {
176 if ((ULONGLONG)(*res) >= ((ULONGLONG)1 << dest_bits))
178 }
179 }
180
181 return S_OK;
182}
183
184HRESULT WINAPI PropVariantToDouble(REFPROPVARIANT propvarIn, double *ret)
185{
187 HRESULT hr;
188
189 TRACE("(%p, %p)\n", propvarIn, ret);
190
191 hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
192 if (SUCCEEDED(hr)) *ret = (double)res;
193 return hr;
194}
195
196HRESULT WINAPI PropVariantToInt16(REFPROPVARIANT propvarIn, SHORT *ret)
197{
199 HRESULT hr;
200
201 TRACE("%p,%p\n", propvarIn, ret);
202
203 hr = PROPVAR_ConvertNumber(propvarIn, 16, TRUE, &res);
204 if (SUCCEEDED(hr)) *ret = (SHORT)res;
205 return hr;
206}
207
208HRESULT WINAPI PropVariantToInt32(REFPROPVARIANT propvarIn, LONG *ret)
209{
211 HRESULT hr;
212
213 TRACE("%p,%p\n", propvarIn, ret);
214
215 hr = PROPVAR_ConvertNumber(propvarIn, 32, TRUE, &res);
216 if (SUCCEEDED(hr)) *ret = (LONG)res;
217 return hr;
218}
219
220HRESULT WINAPI PropVariantToInt64(REFPROPVARIANT propvarIn, LONGLONG *ret)
221{
223 HRESULT hr;
224
225 TRACE("%p,%p\n", propvarIn, ret);
226
227 hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
228 if (SUCCEEDED(hr)) *ret = res;
229 return hr;
230}
231
232HRESULT WINAPI PropVariantToUInt16(REFPROPVARIANT propvarIn, USHORT *ret)
233{
235 HRESULT hr;
236
237 TRACE("%p,%p\n", propvarIn, ret);
238
239 hr = PROPVAR_ConvertNumber(propvarIn, 16, FALSE, &res);
240 if (SUCCEEDED(hr)) *ret = (USHORT)res;
241 return hr;
242}
243
244HRESULT WINAPI PropVariantToUInt32(REFPROPVARIANT propvarIn, ULONG *ret)
245{
247 HRESULT hr;
248
249 TRACE("%p,%p\n", propvarIn, ret);
250
251 hr = PROPVAR_ConvertNumber(propvarIn, 32, FALSE, &res);
252 if (SUCCEEDED(hr)) *ret = (ULONG)res;
253 return hr;
254}
255
256ULONG WINAPI PropVariantToUInt32WithDefault(REFPROPVARIANT propvarIn, ULONG ulDefault)
257{
259 HRESULT hr;
260
261 TRACE("%p,%lu\n", propvarIn, ulDefault);
262
263 hr = PROPVAR_ConvertNumber(propvarIn, 32, FALSE, &res);
264 if (SUCCEEDED(hr))
265 return (ULONG)res;
266
267 return ulDefault;
268}
269
270HRESULT WINAPI PropVariantToUInt64(REFPROPVARIANT propvarIn, ULONGLONG *ret)
271{
273 HRESULT hr;
274
275 TRACE("%p,%p\n", propvarIn, ret);
276
277 hr = PROPVAR_ConvertNumber(propvarIn, 64, FALSE, &res);
278 if (SUCCEEDED(hr)) *ret = (ULONGLONG)res;
279 return hr;
280}
281
282HRESULT WINAPI PropVariantToBoolean(REFPROPVARIANT propvarIn, BOOL *ret)
283{
285 HRESULT hr;
286
287 TRACE("%p,%p\n", propvarIn, ret);
288
289 *ret = FALSE;
290
291 switch (propvarIn->vt)
292 {
293 case VT_BOOL:
294 *ret = propvarIn->boolVal == VARIANT_TRUE;
295 return S_OK;
296
297 case VT_LPWSTR:
298 case VT_BSTR:
299 if (!propvarIn->pwszVal)
300 return DISP_E_TYPEMISMATCH;
301
302 if (!lstrcmpiW(propvarIn->pwszVal, L"true") || !lstrcmpW(propvarIn->pwszVal, L"#TRUE#"))
303 {
304 *ret = TRUE;
305 return S_OK;
306 }
307
308 if (!lstrcmpiW(propvarIn->pwszVal, L"false") || !lstrcmpW(propvarIn->pwszVal, L"#FALSE#"))
309 {
310 *ret = FALSE;
311 return S_OK;
312 }
313 break;
314
315 case VT_LPSTR:
316 if (!propvarIn->pszVal)
317 return DISP_E_TYPEMISMATCH;
318
319 if (!lstrcmpiA(propvarIn->pszVal, "true") || !lstrcmpA(propvarIn->pszVal, "#TRUE#"))
320 {
321 *ret = TRUE;
322 return S_OK;
323 }
324
325 if (!lstrcmpiA(propvarIn->pszVal, "false") || !lstrcmpA(propvarIn->pszVal, "#FALSE#"))
326 {
327 *ret = FALSE;
328 return S_OK;
329 }
330 break;
331 }
332
333 hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
334 *ret = !!res;
335 return hr;
336}
337
338HRESULT WINAPI PropVariantToBSTR(REFPROPVARIANT propvar, BSTR *bstr)
339{
340 WCHAR *str;
341 HRESULT hr;
342
343 TRACE("propvar %p, propvar->vt %#x, bstr %p.\n",
344 propvar, propvar ? propvar->vt : 0, bstr);
345
346 if (FAILED(hr = PropVariantToStringAlloc(propvar, &str)))
347 return hr;
348
349 *bstr = SysAllocString(str);
351
352 if (!*bstr)
353 return E_OUTOFMEMORY;
354
355 return S_OK;
356}
357
358HRESULT WINAPI PropVariantToBuffer(REFPROPVARIANT propvarIn, void *ret, UINT cb)
359{
360 HRESULT hr = S_OK;
361
362 TRACE("(%p, %p, %d)\n", propvarIn, ret, cb);
363
364 switch(propvarIn->vt)
365 {
366 case VT_VECTOR|VT_UI1:
367 if(cb > propvarIn->caub.cElems)
368 return E_FAIL;
369 memcpy(ret, propvarIn->caub.pElems, cb);
370 break;
371 case VT_ARRAY|VT_UI1:
372 FIXME("Unsupported type: VT_ARRAY|VT_UI1\n");
373 hr = E_NOTIMPL;
374 break;
375 default:
376 WARN("Unexpected type: %x\n", propvarIn->vt);
378 }
379
380 return hr;
381}
382
383HRESULT WINAPI PropVariantToString(REFPROPVARIANT propvarIn, PWSTR ret, UINT cch)
384{
385 HRESULT hr;
386 WCHAR *stringW = NULL;
387
388 TRACE("(%p, %p, %d)\n", propvarIn, ret, cch);
389
390 ret[0] = '\0';
391
392 if(!cch)
393 return E_INVALIDARG;
394
395 hr = PropVariantToStringAlloc(propvarIn, &stringW);
396 if(SUCCEEDED(hr))
397 {
398 if(lstrlenW(stringW) >= cch)
402 }
403
404 return hr;
405}
406
407HRESULT WINAPI PropVariantToStringAlloc(REFPROPVARIANT propvarIn, WCHAR **ret)
408{
409 WCHAR *res = NULL;
410 HRESULT hr = S_OK;
411
412 TRACE("%p,%p semi-stub\n", propvarIn, ret);
413
414 switch(propvarIn->vt)
415 {
416 case VT_EMPTY:
417 case VT_NULL:
418 res = CoTaskMemAlloc(1*sizeof(WCHAR));
419 res[0] = '\0';
420 break;
421
422 case VT_LPSTR:
423 if(propvarIn->pszVal)
424 {
425 DWORD len;
426
427 len = MultiByteToWideChar(CP_ACP, 0, propvarIn->pszVal, -1, NULL, 0);
428 res = CoTaskMemAlloc(len*sizeof(WCHAR));
429 if(!res)
430 return E_OUTOFMEMORY;
431
432 MultiByteToWideChar(CP_ACP, 0, propvarIn->pszVal, -1, res, len);
433 }
434 break;
435
436 case VT_LPWSTR:
437 case VT_BSTR:
438 if (propvarIn->pwszVal)
439 {
440 DWORD size = (lstrlenW(propvarIn->pwszVal) + 1) * sizeof(WCHAR);
442 if(!res) return E_OUTOFMEMORY;
443 memcpy(res, propvarIn->pwszVal, size);
444 }
445 break;
446
447 case VT_CLSID:
448 if (propvarIn->puuid)
449 {
450 if (!(res = CoTaskMemAlloc((GUID_STR_LEN + 1) * sizeof(WCHAR))))
451 return E_OUTOFMEMORY;
452 StringFromGUID2(propvarIn->puuid, res, GUID_STR_LEN + 1);
453 }
454 break;
455
456 default:
457 FIXME("Unsupported conversion (%d)\n", propvarIn->vt);
458 hr = E_FAIL;
459 break;
460 }
461
462 *ret = res;
463
464 return hr;
465}
466
468{
469 if (propvarIn->vt == VT_BSTR)
470 {
471 if (propvarIn->bstrVal == NULL)
472 return L"";
473
474 return propvarIn->bstrVal;
475 }
476
477 if (propvarIn->vt == VT_LPWSTR && propvarIn->pwszVal != NULL)
478 return propvarIn->pwszVal;
479
480 return pszDefault;
481}
482
483/******************************************************************
484 * VariantToStringWithDefault (PROPSYS.@)
485 */
486PCWSTR WINAPI VariantToStringWithDefault(const VARIANT *pvar, const WCHAR *default_value)
487{
488 TRACE("%s, %s.\n", debugstr_variant(pvar), debugstr_w(default_value));
489
490 if (V_VT(pvar) == (VT_BYREF | VT_VARIANT)) pvar = V_VARIANTREF(pvar);
491 if (V_VT(pvar) == (VT_BYREF | VT_BSTR) || V_VT(pvar) == VT_BSTR)
492 {
493 BSTR ret = V_ISBYREF(pvar) ? *V_BSTRREF(pvar) : V_BSTR(pvar);
494 return ret ? ret : L"";
495 }
496
497 return default_value;
498}
499
500/******************************************************************
501 * VariantToString (PROPSYS.@)
502 */
504{
505 WCHAR buffer[64], *str = buffer;
506
507 TRACE("%p, %p, %u.\n", var, ret, cch);
508
509 *ret = 0;
510
511 if (!cch)
512 return E_INVALIDARG;
513
514 switch (V_VT(var))
515 {
516 case VT_BSTR:
517 str = V_BSTR(var);
518 break;
519 case VT_I4:
521 break;
522 default:
523 FIXME("Unsupported type %d.\n", V_VT(var));
524 return E_NOTIMPL;
525 }
526
527 if (wcslen(str) > cch - 1)
529 wcscpy(ret, str);
530
531 return S_OK;
532}
533
534/******************************************************************
535 * PropVariantChangeType (PROPSYS.@)
536 */
537HRESULT WINAPI PropVariantChangeType(PROPVARIANT *ppropvarDest, REFPROPVARIANT propvarSrc,
539{
540 HRESULT hr;
541
542 FIXME("(%p, %p, %d, %d, %d): semi-stub!\n", ppropvarDest, propvarSrc,
543 propvarSrc->vt, flags, vt);
544
545 if (vt == propvarSrc->vt)
546 return PropVariantCopy(ppropvarDest, propvarSrc);
547
548 if (propvarSrc->vt == VT_FILETIME)
549 return PROPVAR_ConvertFILETIME(&propvarSrc->filetime, ppropvarDest, vt);
550
551 switch (vt)
552 {
553 case VT_I1:
554 {
556
558 if (SUCCEEDED(hr))
559 {
560 ppropvarDest->vt = VT_I1;
561 ppropvarDest->cVal = (char)res;
562 }
563 return hr;
564 }
565
566 case VT_UI1:
567 {
569
571 if (SUCCEEDED(hr))
572 {
573 ppropvarDest->vt = VT_UI1;
574 ppropvarDest->bVal = (UCHAR)res;
575 }
576 return hr;
577 }
578
579 case VT_I2:
580 {
581 SHORT res;
583 if (SUCCEEDED(hr))
584 {
585 ppropvarDest->vt = VT_I2;
586 ppropvarDest->iVal = res;
587 }
588 return hr;
589 }
590 case VT_UI2:
591 {
592 USHORT res;
594 if (SUCCEEDED(hr))
595 {
596 ppropvarDest->vt = VT_UI2;
597 ppropvarDest->uiVal = res;
598 }
599 return hr;
600 }
601 case VT_I4:
602 {
603 LONG res;
605 if (SUCCEEDED(hr))
606 {
607 ppropvarDest->vt = VT_I4;
608 ppropvarDest->lVal = res;
609 }
610 return hr;
611 }
612 case VT_UI4:
613 {
614 ULONG res;
616 if (SUCCEEDED(hr))
617 {
618 ppropvarDest->vt = VT_UI4;
619 ppropvarDest->ulVal = res;
620 }
621 return hr;
622 }
623 case VT_I8:
624 {
627 if (SUCCEEDED(hr))
628 {
629 ppropvarDest->vt = VT_I8;
630 ppropvarDest->hVal.QuadPart = res;
631 }
632 return hr;
633 }
634 case VT_UI8:
635 {
638 if (SUCCEEDED(hr))
639 {
640 ppropvarDest->vt = VT_UI8;
641 ppropvarDest->uhVal.QuadPart = res;
642 }
643 return hr;
644 }
645
646 case VT_LPWSTR:
647 case VT_BSTR:
648 {
649 WCHAR *res;
651 if (SUCCEEDED(hr))
652 {
653 ppropvarDest->vt = VT_LPWSTR;
654 ppropvarDest->pwszVal = res;
655 }
656 return hr;
657 }
658
659 case VT_LPSTR:
660 {
661 WCHAR *resW;
663 if (SUCCEEDED(hr))
664 {
665 char *res;
666 DWORD len;
667
668 len = WideCharToMultiByte(CP_ACP, 0, resW, -1, NULL, 0, NULL, NULL);
670 if (res)
671 {
672 WideCharToMultiByte(CP_ACP, 0, resW, -1, res, len, NULL, NULL);
673 ppropvarDest->vt = VT_LPSTR;
674 ppropvarDest->pszVal = res;
675 }
676 else
678
679 CoTaskMemFree(resW);
680 }
681 return hr;
682 }
683
684 default:
685 FIXME("Unhandled dest type: %d\n", vt);
686 return E_FAIL;
687 }
688}
690{
691 TRACE("(%p %p)\n", guid, ppropvar);
692
693 if(!guid)
694 return E_FAIL;
695
696 ppropvar->vt = VT_LPWSTR;
697 ppropvar->pwszVal = CoTaskMemAlloc((GUID_STR_LEN + 1) * sizeof(WCHAR));
698 if(!ppropvar->pwszVal)
699 return E_OUTOFMEMORY;
700
701 StringFromGUID2(guid, ppropvar->pwszVal, GUID_STR_LEN + 1);
702 return S_OK;
703}
704
706{
707 TRACE("(%p %p)\n", guid, pvar);
708
709 if(!guid) {
710 FIXME("guid == NULL\n");
711 return E_FAIL;
712 }
713
714 V_VT(pvar) = VT_BSTR;
716 if(!V_BSTR(pvar))
717 return E_OUTOFMEMORY;
718
720 return S_OK;
721}
722
723HRESULT WINAPI InitPropVariantFromBuffer(const VOID *pv, UINT cb, PROPVARIANT *ppropvar)
724{
725 TRACE("(%p %u %p)\n", pv, cb, ppropvar);
726
727 ppropvar->caub.pElems = CoTaskMemAlloc(cb);
728 if(!ppropvar->caub.pElems)
729 return E_OUTOFMEMORY;
730
731 ppropvar->vt = VT_VECTOR|VT_UI1;
732 ppropvar->caub.cElems = cb;
733 memcpy(ppropvar->caub.pElems, pv, cb);
734 return S_OK;
735}
736
738{
739 TRACE("(%s %p)\n", debugstr_guid(clsid), ppropvar);
740
741 ppropvar->puuid = CoTaskMemAlloc(sizeof(*ppropvar->puuid));
742 if(!ppropvar->puuid)
743 return E_OUTOFMEMORY;
744
745 ppropvar->vt = VT_CLSID;
746 memcpy(ppropvar->puuid, clsid, sizeof(*ppropvar->puuid));
747 return S_OK;
748}
749
751{
752 unsigned int i;
753
754 TRACE("(%p %lu %p)\n", strs, count, ppropvar);
755
756 ppropvar->calpwstr.pElems = CoTaskMemAlloc(count * sizeof(*ppropvar->calpwstr.pElems));
757 if(!ppropvar->calpwstr.pElems)
758 return E_OUTOFMEMORY;
759
760 ppropvar->vt = VT_LPWSTR | VT_VECTOR;
761 ppropvar->calpwstr.cElems = 0;
762 if (count)
763 memset(ppropvar->calpwstr.pElems, 0, count * sizeof(*ppropvar->calpwstr.pElems));
764
765 for (i = 0; i < count; ++i)
766 {
767 if (strs[i])
768 {
769 if (!(ppropvar->calpwstr.pElems[i] = CoTaskMemAlloc((wcslen(strs[i]) + 1)*sizeof(**strs))))
770 {
771 PropVariantClear(ppropvar);
772 return E_OUTOFMEMORY;
773 }
774 }
775 wcscpy(ppropvar->calpwstr.pElems[i], strs[i]);
776 ppropvar->calpwstr.cElems++;
777 }
778
779 return S_OK;
780}
781
783{
784 SAFEARRAY *arr;
785 void *data;
787
788 TRACE("(%p %u %p)\n", pv, cb, pvar);
789
791 if(!arr)
792 return E_OUTOFMEMORY;
793
795 if(FAILED(hres)) {
796 SafeArrayDestroy(arr);
797 return hres;
798 }
799
800 memcpy(data, pv, cb);
801
803 if(FAILED(hres)) {
804 SafeArrayDestroy(arr);
805 return hres;
806 }
807
808 V_VT(pvar) = VT_ARRAY|VT_UI1;
809 V_ARRAY(pvar) = arr;
810 return S_OK;
811}
812
814{
815 SYSTEMTIME st;
816
817 TRACE("%p, %p\n", ft, var);
818
820 if (!FileTimeToSystemTime(ft, &st))
821 return E_INVALIDARG;
823 return E_INVALIDARG;
824 V_VT(var) = VT_DATE;
825 return S_OK;
826}
827
828static inline DWORD PROPVAR_HexToNum(const WCHAR *hex)
829{
830 DWORD ret;
831
832 if(hex[0]>='0' && hex[0]<='9')
833 ret = hex[0]-'0';
834 else if(hex[0]>='a' && hex[0]<='f')
835 ret = hex[0]-'a'+10;
836 else if(hex[0]>='A' && hex[0]<='F')
837 ret = hex[0]-'A'+10;
838 else
839 return -1;
840
841 ret <<= 4;
842 if(hex[1]>='0' && hex[1]<='9')
843 return ret + hex[1]-'0';
844 else if(hex[1]>='a' && hex[1]<='f')
845 return ret + hex[1]-'a'+10;
846 else if(hex[1]>='A' && hex[1]<='F')
847 return ret + hex[1]-'A'+10;
848 else
849 return -1;
850}
851
852static inline HRESULT PROPVAR_WCHARToGUID(const WCHAR *str, int len, GUID *guid)
853{
854 DWORD i, val=0;
855 const WCHAR *p;
856
857 memset(guid, 0, sizeof(GUID));
858
859 if(len!=38 || str[0]!='{' || str[9]!='-' || str[14]!='-'
860 || str[19]!='-' || str[24]!='-' || str[37]!='}') {
861 WARN("Error parsing %s\n", debugstr_w(str));
862 return E_INVALIDARG;
863 }
864
865 p = str+1;
866 for(i=0; i<4 && val!=-1; i++) {
868 guid->Data1 = (guid->Data1<<8) + val;
869 p += 2;
870 }
871 p++;
872 for(i=0; i<2 && val!=-1; i++) {
874 guid->Data2 = (guid->Data2<<8) + val;
875 p += 2;
876 }
877 p++;
878 for(i=0; i<2 && val!=-1; i++) {
880 guid->Data3 = (guid->Data3<<8) + val;
881 p += 2;
882 }
883 p++;
884 for(i=0; i<8 && val!=-1; i++) {
885 if(i == 2)
886 p++;
887
888 val = guid->Data4[i] = PROPVAR_HexToNum(p);
889 p += 2;
890 }
891
892 if(val == -1) {
893 WARN("Error parsing %s\n", debugstr_w(str));
894 memset(guid, 0, sizeof(GUID));
895 return E_INVALIDARG;
896 }
897 return S_OK;
898}
899
900HRESULT WINAPI PropVariantToGUID(const PROPVARIANT *ppropvar, GUID *guid)
901{
902 TRACE("%p %p)\n", ppropvar, guid);
903
904 switch(ppropvar->vt) {
905 case VT_BSTR:
906 return PROPVAR_WCHARToGUID(ppropvar->bstrVal, SysStringLen(ppropvar->bstrVal), guid);
907 case VT_LPWSTR:
908 return PROPVAR_WCHARToGUID(ppropvar->pwszVal, lstrlenW(ppropvar->pwszVal), guid);
909 case VT_CLSID:
910 memcpy(guid, ppropvar->puuid, sizeof(*ppropvar->puuid));
911 return S_OK;
912
913 default:
914 FIXME("unsupported vt: %d\n", ppropvar->vt);
915 return E_NOTIMPL;
916 }
917}
918
920{
921 TRACE("(%p %p)\n", pvar, guid);
922
923 switch(V_VT(pvar)) {
924 case VT_BSTR: {
926 if(hres == E_INVALIDARG)
927 return E_FAIL;
928 return hres;
929 }
930
931 default:
932 FIXME("unsupported vt: %d\n", V_VT(pvar));
933 return E_NOTIMPL;
934 }
935}
936
937static BOOL isemptyornull(const PROPVARIANT *propvar)
938{
939 if (propvar->vt == VT_EMPTY || propvar->vt == VT_NULL)
940 return TRUE;
941 if ((propvar->vt & VT_ARRAY) == VT_ARRAY)
942 {
943 int i;
944 for (i=0; i<propvar->parray->cDims; i++)
945 {
946 if (propvar->parray->rgsabound[i].cElements != 0)
947 break;
948 }
949 return i == propvar->parray->cDims;
950 }
951 if (propvar->vt == VT_CLSID)
952 return !propvar->puuid;
953
954 if (propvar->vt & VT_VECTOR)
955 return !propvar->caub.cElems;
956
957 /* FIXME: byrefs, errors? */
958 return FALSE;
959}
960
961INT WINAPI PropVariantCompareEx(REFPROPVARIANT propvar1, REFPROPVARIANT propvar2,
963{
964 const PROPVARIANT *propvar2_converted;
965 PROPVARIANT propvar2_static;
966 unsigned int count;
967 HRESULT hr;
968 INT res=-1;
969
970 TRACE("%p,%p,%x,%x\n", propvar1, propvar2, unit, flags);
971
972 if (isemptyornull(propvar1))
973 {
975 return 0;
976 return (flags & PVCF_TREATEMPTYASGREATERTHAN) ? 1 : -1;
977 }
978
980 return (flags & PVCF_TREATEMPTYASGREATERTHAN) ? -1 : 1;
981
982 if (propvar1->vt != propvar2->vt)
983 {
984 hr = PropVariantChangeType(&propvar2_static, propvar2, 0, propvar1->vt);
985
986 if (FAILED(hr))
987 return -1;
988
989 propvar2_converted = &propvar2_static;
990 }
991 else
992 propvar2_converted = propvar2;
993
994#define CMP_NUM_VALUE(var) do { \
995 if (propvar1->var > propvar2_converted->var) \
996 res = 1; \
997 else if (propvar1->var < propvar2_converted->var) \
998 res = -1; \
999 else \
1000 res = 0; \
1001 } while (0)
1002
1003 switch (propvar1->vt)
1004 {
1005 case VT_I1:
1006 CMP_NUM_VALUE(cVal);
1007 break;
1008 case VT_UI1:
1009 CMP_NUM_VALUE(bVal);
1010 break;
1011 case VT_I2:
1012 CMP_NUM_VALUE(iVal);
1013 break;
1014 case VT_UI2:
1015 CMP_NUM_VALUE(uiVal);
1016 break;
1017 case VT_I4:
1018 CMP_NUM_VALUE(lVal);
1019 break;
1020 case VT_UI4:
1021 CMP_NUM_VALUE(ulVal);
1022 break;
1023 case VT_I8:
1024 CMP_NUM_VALUE(hVal.QuadPart);
1025 break;
1026 case VT_UI8:
1027 CMP_NUM_VALUE(uhVal.QuadPart);
1028 break;
1029 case VT_R4:
1030 CMP_NUM_VALUE(fltVal);
1031 break;
1032 case VT_R8:
1033 CMP_NUM_VALUE(dblVal);
1034 break;
1035 case VT_BSTR:
1036 case VT_LPWSTR:
1037 /* FIXME: Use other string flags. */
1039 res = lstrcmpiW(propvar1->bstrVal, propvar2_converted->bstrVal);
1040 else
1041 res = lstrcmpW(propvar1->bstrVal, propvar2_converted->bstrVal);
1042 break;
1043 case VT_LPSTR:
1044 /* FIXME: Use other string flags. */
1046 res = lstrcmpiA(propvar1->pszVal, propvar2_converted->pszVal);
1047 else
1048 res = lstrcmpA(propvar1->pszVal, propvar2_converted->pszVal);
1049 break;
1050 case VT_CLSID:
1051 res = memcmp(propvar1->puuid, propvar2->puuid, sizeof(*propvar1->puuid));
1052 if (res) res = res > 0 ? 1 : -1;
1053 break;
1054 case VT_VECTOR | VT_UI1:
1055 count = min(propvar1->caub.cElems, propvar2->caub.cElems);
1056 res = count ? memcmp(propvar1->caub.pElems, propvar2->caub.pElems, sizeof(*propvar1->caub.pElems) * count) : 0;
1057 if (res) res = res > 0 ? 1 : -1;
1058 if (!res && propvar1->caub.cElems != propvar2->caub.cElems)
1059 res = propvar1->caub.cElems > propvar2->caub.cElems ? 1 : -1;
1060 break;
1061 default:
1062 FIXME("vartype %#x not handled\n", propvar1->vt);
1063 res = -1;
1064 break;
1065 }
1066
1067 if (propvar2_converted == &propvar2_static)
1068 PropVariantClear(&propvar2_static);
1069
1070 return res;
1071}
1072
1073HRESULT WINAPI PropVariantToVariant(const PROPVARIANT *propvar, VARIANT *var)
1074{
1075 HRESULT hr = S_OK;
1076
1077 TRACE("propvar %p, var %p, propvar->vt %#x.\n", propvar, var, propvar ? propvar->vt : 0);
1078
1079 if (!var || !propvar)
1080 return E_INVALIDARG;
1081
1083#ifdef __REACTOS__
1084 V_VT(var) = propvar->vt;
1085#else
1086 var->vt = propvar->vt;
1087#endif
1088
1089 switch (propvar->vt)
1090 {
1091 case VT_EMPTY:
1092 case VT_NULL:
1093 break;
1094 case VT_I1:
1095 V_I1(var) = propvar->cVal;
1096 break;
1097 case VT_I2:
1098 V_I2(var) = propvar->iVal;
1099 break;
1100 case VT_I4:
1101 V_I4(var) = propvar->lVal;
1102 break;
1103 case VT_I8:
1104 V_I8(var) = propvar->hVal.QuadPart;
1105 break;
1106 case VT_UI1:
1107 V_UI1(var) = propvar->bVal;
1108 break;
1109 case VT_UI2:
1110 V_UI2(var) = propvar->uiVal;
1111 break;
1112 case VT_UI4:
1113 V_UI4(var) = propvar->ulVal;
1114 break;
1115 case VT_UI8:
1116 V_UI8(var) = propvar->uhVal.QuadPart;
1117 break;
1118 case VT_BOOL:
1119 V_BOOL(var) = propvar->boolVal;
1120 break;
1121 case VT_R4:
1122 V_R4(var) = propvar->fltVal;
1123 break;
1124 case VT_R8:
1125 V_R8(var) = propvar->dblVal;
1126 break;
1127 case VT_LPSTR:
1128 case VT_LPWSTR:
1129 case VT_BSTR:
1130 case VT_CLSID:
1131#ifdef __REACTOS__
1132 V_VT(var) = VT_BSTR;
1133#else
1134 var->vt = VT_BSTR;
1135#endif
1136 hr = PropVariantToBSTR(propvar, &V_BSTR(var));
1137 break;
1138 default:
1139 FIXME("Unsupported type %d.\n", propvar->vt);
1140 return E_INVALIDARG;
1141 }
1142
1143 return hr;
1144}
1145
1146HRESULT WINAPI VariantToPropVariant(const VARIANT *var, PROPVARIANT *propvar)
1147{
1148 HRESULT hr;
1149
1150 TRACE("var %p, propvar %p.\n", debugstr_variant(var), propvar);
1151
1152 if (!var || !propvar)
1153 return E_INVALIDARG;
1154
1155#ifdef __REACTOS__
1157#else
1158 if (FAILED(hr = VARIANT_ValidateType(var->vt)))
1159#endif
1160 return hr;
1161
1162 PropVariantInit(propvar);
1163
1164
1165#ifdef __REACTOS__
1166 propvar->vt = V_VT(var);
1167#else
1168 propvar->vt = var->vt;
1169#endif
1170
1171#ifdef __REACTOS__
1172 switch (V_VT(var))
1173#else
1174 switch (var->vt)
1175#endif
1176 {
1177 case VT_EMPTY:
1178 case VT_NULL:
1179 break;
1180 case VT_I1:
1181 propvar->cVal = V_I1(var);
1182 break;
1183 case VT_I2:
1184 propvar->iVal = V_I2(var);
1185 break;
1186 case VT_I4:
1187 propvar->lVal = V_I4(var);
1188 break;
1189 case VT_I8:
1190 propvar->hVal.QuadPart = V_I8(var);
1191 break;
1192 case VT_UI1:
1193 propvar->bVal = V_UI1(var);
1194 break;
1195 case VT_UI2:
1196 propvar->uiVal = V_UI2(var);
1197 break;
1198 case VT_UI4:
1199 propvar->ulVal = V_UI4(var);
1200 break;
1201 case VT_UI8:
1202 propvar->uhVal.QuadPart = V_UI8(var);
1203 break;
1204 case VT_BOOL:
1205 propvar->boolVal = V_BOOL(var);
1206 break;
1207 case VT_R4:
1208 propvar->fltVal = V_R4(var);
1209 break;
1210 case VT_R8:
1211 propvar->dblVal = V_R8(var);
1212 break;
1213 case VT_BSTR:
1214 propvar->bstrVal = SysAllocString(V_BSTR(var));
1215 break;
1216 default:
1217#ifdef __REACTOS__
1218 FIXME("Unsupported type %d.\n", V_VT(var));
1219#else
1220 FIXME("Unsupported type %d.\n", var->vt);
1221#endif
1222 return E_INVALIDARG;
1223 }
1224
1225 return S_OK;
1226}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
#define ARRAY_SIZE(A)
Definition: main.h:20
#define FIXME(fmt,...)
Definition: precomp.h:53
#define WARN(fmt,...)
Definition: precomp.h:61
wcscpy
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_INVALIDARG
Definition: ddrawi.h:101
#define E_NOTIMPL
Definition: ddrawi.h:99
#define E_FAIL
Definition: ddrawi.h:102
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define GetProcessHeap()
Definition: compat.h:736
#define CP_ACP
Definition: compat.h:109
#define HeapAlloc
Definition: compat.h:733
OLECHAR * BSTR
Definition: compat.h:2293
unsigned short VARTYPE
Definition: compat.h:2254
#define WideCharToMultiByte
Definition: compat.h:111
#define MultiByteToWideChar
Definition: compat.h:110
@ VT_UI8
Definition: compat.h:2315
@ VT_BSTR
Definition: compat.h:2303
@ VT_VOID
Definition: compat.h:2318
@ VT_LPSTR
Definition: compat.h:2324
@ VT_R4
Definition: compat.h:2299
@ VT_NULL
Definition: compat.h:2296
@ VT_TYPEMASK
Definition: compat.h:2346
@ VT_RESERVED
Definition: compat.h:2343
@ VT_BYREF
Definition: compat.h:2342
@ VT_UI2
Definition: compat.h:2312
@ VT_CLSID
Definition: compat.h:2337
@ VT_ARRAY
Definition: compat.h:2341
@ VT_LPWSTR
Definition: compat.h:2325
@ VT_R8
Definition: compat.h:2300
@ VT_VARIANT
Definition: compat.h:2307
@ VT_I8
Definition: compat.h:2314
@ VT_I1
Definition: compat.h:2310
@ VT_I4
Definition: compat.h:2298
@ VT_FILETIME
Definition: compat.h:2329
@ VT_DATE
Definition: compat.h:2302
@ VT_BOOL
Definition: compat.h:2306
@ VT_I2
Definition: compat.h:2297
@ VT_UI4
Definition: compat.h:2313
@ VT_EMPTY
Definition: compat.h:2295
@ VT_RECORD
Definition: compat.h:2326
@ VT_VECTOR
Definition: compat.h:2340
@ VT_UI1
Definition: compat.h:2311
#define lstrcpynW
Definition: compat.h:738
#define lstrlenW
Definition: compat.h:750
BOOL WINAPI FileTimeToSystemTime(IN CONST FILETIME *lpFileTime, OUT LPSYSTEMTIME lpSystemTime)
Definition: time.c:188
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4243
int WINAPI lstrcmpA(LPCSTR str1, LPCSTR str2)
Definition: locale.c:4195
int WINAPI lstrcmpiW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4262
int WINAPI lstrcmpiA(LPCSTR str1, LPCSTR str2)
Definition: locale.c:4224
static REFPROPVARIANT propvarSrc
Definition: suminfo.c:90
static REFPROPVARIANT PROPVAR_CHANGE_FLAGS VARTYPE vt
Definition: suminfo.c:91
INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
Definition: compobj.c:2434
HRESULT WINAPI PropVariantClear(PROPVARIANT *pvar)
Definition: ole2.c:2968
HRESULT WINAPI PropVariantCopy(PROPVARIANT *pvarDest, const PROPVARIANT *pvarSrc)
Definition: ole2.c:3086
HRESULT WINAPI SafeArrayAccessData(SAFEARRAY *psa, void **ppvData)
Definition: safearray.c:1137
HRESULT WINAPI SafeArrayUnaccessData(SAFEARRAY *psa)
Definition: safearray.c:1168
SAFEARRAY *WINAPI SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements)
Definition: safearray.c:677
HRESULT WINAPI SafeArrayDestroy(SAFEARRAY *psa)
Definition: safearray.c:1347
HRESULT WINAPI PropVariantToInt32(REFPROPVARIANT propvarIn, LONG *ret)
Definition: propvar.c:208
HRESULT WINAPI InitVariantFromGUIDAsString(REFGUID guid, VARIANT *pvar)
Definition: propvar.c:705
HRESULT WINAPI InitVariantFromFileTime(const FILETIME *ft, VARIANT *var)
Definition: propvar.c:813
PCWSTR WINAPI PropVariantToStringWithDefault(REFPROPVARIANT propvarIn, LPCWSTR pszDefault)
Definition: propvar.c:467
static HRESULT PROPVAR_ConvertFILETIME(const FILETIME *ft, PROPVARIANT *ppropvarDest, VARTYPE vt)
Definition: propvar.c:59
static HRESULT VARIANT_ValidateType(VARTYPE vt)
Definition: propvar.c:39
#define GUID_STR_LEN
Definition: propvar.c:38
INT WINAPI PropVariantCompareEx(REFPROPVARIANT propvar1, REFPROPVARIANT propvar2, PROPVAR_COMPARE_UNIT unit, PROPVAR_COMPARE_FLAGS flags)
Definition: propvar.c:961
ULONG WINAPI PropVariantToUInt32WithDefault(REFPROPVARIANT propvarIn, ULONG ulDefault)
Definition: propvar.c:256
HRESULT WINAPI VariantToGUID(const VARIANT *pvar, GUID *guid)
Definition: propvar.c:919
HRESULT WINAPI PropVariantToBuffer(REFPROPVARIANT propvarIn, void *ret, UINT cb)
Definition: propvar.c:358
HRESULT WINAPI PropVariantToUInt16(REFPROPVARIANT propvarIn, USHORT *ret)
Definition: propvar.c:232
static HRESULT PROPVAR_WCHARToGUID(const WCHAR *str, int len, GUID *guid)
Definition: propvar.c:852
#define CMP_NUM_VALUE(var)
static BOOL isemptyornull(const PROPVARIANT *propvar)
Definition: propvar.c:937
HRESULT WINAPI InitPropVariantFromCLSID(REFCLSID clsid, PROPVARIANT *ppropvar)
Definition: propvar.c:737
HRESULT WINAPI VariantToString(REFVARIANT var, PWSTR ret, UINT cch)
Definition: propvar.c:503
HRESULT WINAPI PropVariantToStringAlloc(REFPROPVARIANT propvarIn, WCHAR **ret)
Definition: propvar.c:407
HRESULT WINAPI PropVariantChangeType(PROPVARIANT *ppropvarDest, REFPROPVARIANT propvarSrc, PROPVAR_CHANGE_FLAGS flags, VARTYPE vt)
Definition: propvar.c:537
HRESULT WINAPI InitPropVariantFromBuffer(const VOID *pv, UINT cb, PROPVARIANT *ppropvar)
Definition: propvar.c:723
static HRESULT PROPVAR_ConvertNumber(REFPROPVARIANT pv, int dest_bits, BOOL dest_signed, LONGLONG *res)
Definition: propvar.c:86
HRESULT WINAPI InitPropVariantFromStringVector(PCWSTR *strs, ULONG count, PROPVARIANT *ppropvar)
Definition: propvar.c:750
HRESULT WINAPI PropVariantToBoolean(REFPROPVARIANT propvarIn, BOOL *ret)
Definition: propvar.c:282
HRESULT WINAPI PropVariantToBSTR(REFPROPVARIANT propvar, BSTR *bstr)
Definition: propvar.c:338
PCWSTR WINAPI VariantToStringWithDefault(const VARIANT *pvar, const WCHAR *default_value)
Definition: propvar.c:486
HRESULT WINAPI PropVariantToInt64(REFPROPVARIANT propvarIn, LONGLONG *ret)
Definition: propvar.c:220
static DWORD PROPVAR_HexToNum(const WCHAR *hex)
Definition: propvar.c:828
HRESULT WINAPI PropVariantToDouble(REFPROPVARIANT propvarIn, double *ret)
Definition: propvar.c:184
HRESULT WINAPI PropVariantToString(REFPROPVARIANT propvarIn, PWSTR ret, UINT cch)
Definition: propvar.c:383
HRESULT WINAPI PropVariantToUInt64(REFPROPVARIANT propvarIn, ULONGLONG *ret)
Definition: propvar.c:270
HRESULT WINAPI PropVariantToUInt32(REFPROPVARIANT propvarIn, ULONG *ret)
Definition: propvar.c:244
HRESULT WINAPI PropVariantToGUID(const PROPVARIANT *ppropvar, GUID *guid)
Definition: propvar.c:900
HRESULT WINAPI VariantToPropVariant(const VARIANT *var, PROPVARIANT *propvar)
Definition: propvar.c:1146
HRESULT WINAPI PropVariantToInt16(REFPROPVARIANT propvarIn, SHORT *ret)
Definition: propvar.c:196
HRESULT WINAPI InitVariantFromBuffer(const VOID *pv, UINT cb, VARIANT *pvar)
Definition: propvar.c:782
HRESULT WINAPI InitPropVariantFromGUIDAsString(REFGUID guid, PROPVARIANT *ppropvar)
Definition: propvar.c:689
HRESULT WINAPI PropVariantToVariant(const PROPVARIANT *propvar, VARIANT *var)
Definition: propvar.c:1073
unsigned char
Definition: typeof.h:29
#define swprintf
Definition: precomp.h:40
static const WCHAR stringW[]
Definition: engine.c:38
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLuint GLuint end
Definition: gl.h:1545
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLuint res
Definition: glext.h:9613
GLuint buffer
Definition: glext.h:5915
GLsizeiptr size
Definition: glext.h:5919
GLbitfield flags
Definition: glext.h:7161
GLuint GLfloat * val
Definition: glext.h:7180
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLsizei len
Definition: glext.h:6722
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
int hex(char ch)
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:426
_Check_return_ long __cdecl wcstol(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
__MINGW_EXTENSION long long __cdecl strtoll(const char *__restrict__, char **__restrict, int)
Definition: strtox.cpp:119
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
_Check_return_ _ACRTIMP __int64 __cdecl _strtoi64(_In_z_ char const *_String, _Out_opt_ _Deref_post_z_ char **_EndPtr, _In_ int _Radix)
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
#define debugstr_guid
Definition: kernel32.h:35
#define debugstr_w
Definition: kernel32.h:32
const GUID * guid
__u16 time
Definition: mkdosfs.c:8
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define sprintf(buf, format,...)
Definition: sprintf.c:55
static DWORD DWORD void LPSTR DWORD cch
Definition: str.c:202
const char * var
Definition: shader.c:5666
static const char * debugstr_variant(const VARIANT *var)
Definition: container.c:46
HRESULT hres
Definition: protocol.c:465
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:89
#define min(a, b)
Definition: monoChain.cc:55
REFCLSID clsid
Definition: msctf.c:82
unsigned int UINT
Definition: ndis.h:50
#define L(x)
Definition: ntvdm.h:50
BSTR WINAPI SysAllocString(LPCOLESTR str)
Definition: oleaut.c:238
UINT WINAPI SysStringLen(BSTR str)
Definition: oleaut.c:196
BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
Definition: oleaut.c:339
#define V_UI1(A)
Definition: oleauto.h:266
#define V_I8(A)
Definition: oleauto.h:249
#define V_BOOL(A)
Definition: oleauto.h:224
#define V_ARRAY(A)
Definition: oleauto.h:222
#define V_BSTRREF(A)
Definition: oleauto.h:227
#define V_UI2(A)
Definition: oleauto.h:268
#define V_I1(A)
Definition: oleauto.h:243
#define V_ISBYREF(A)
Definition: oleauto.h:217
#define V_VARIANTREF(A)
Definition: oleauto.h:283
#define V_VT(A)
Definition: oleauto.h:211
#define V_BSTR(A)
Definition: oleauto.h:226
#define V_I4(A)
Definition: oleauto.h:247
#define V_R4(A)
Definition: oleauto.h:260
#define V_UI4(A)
Definition: oleauto.h:270
#define V_R8(A)
Definition: oleauto.h:262
#define V_DATE(A)
Definition: oleauto.h:231
#define V_UI8(A)
Definition: oleauto.h:272
#define V_I2(A)
Definition: oleauto.h:245
short SHORT
Definition: pedump.c:59
long LONG
Definition: pedump.c:60
unsigned short USHORT
Definition: pedump.c:61
png_const_structrp png_const_inforp int * unit
Definition: png.h:2159
static IPropertySystem propsys
Definition: propsys_main.c:202
@ PVCF_USESTRCMPI
Definition: propvarutil.h:70
@ PVCF_USESTRCMPIC
Definition: propvarutil.h:71
@ PVCF_TREATEMPTYASGREATERTHAN
Definition: propvarutil.h:67
int PROPVAR_COMPARE_UNIT
Definition: propvarutil.h:62
int PROPVAR_CHANGE_FLAGS
Definition: propvarutil.h:49
LPCWSTR pszDefault
Definition: propvarutil.h:103
REFPROPVARIANT propvar2
Definition: propvarutil.h:86
int PROPVAR_COMPARE_FLAGS
Definition: propvarutil.h:74
#define REFCLSID
Definition: guiddef.h:117
const WCHAR * str
#define memset(x, y, z)
Definition: compat.h:39
HRESULT hr
Definition: shlfolder.c:183
#define TRACE(s)
Definition: solgame.cpp:4
#define STRSAFE_E_INSUFFICIENT_BUFFER
Definition: strsafe.h:103
Definition: scsiwmi.h:51
uint16_t * PWSTR
Definition: typedefs.h:56
const uint16_t * PCWSTR
Definition: typedefs.h:57
int64_t LONGLONG
Definition: typedefs.h:68
int32_t INT
Definition: typedefs.h:58
uint32_t ULONG
Definition: typedefs.h:59
uint64_t ULONGLONG
Definition: typedefs.h:67
void WINAPI VariantInit(VARIANTARG *pVarg)
Definition: variant.c:568
INT WINAPI SystemTimeToVariantTime(LPSYSTEMTIME lpSt, double *pDateOut)
Definition: variant.c:1286
int ret
#define WINAPI
Definition: msvc.h:6
#define DISP_E_BADVARTYPE
Definition: winerror.h:2517
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
#define ERROR_ARITHMETIC_OVERFLOW
Definition: winerror.h:351
#define DISP_E_TYPEMISMATCH
Definition: winerror.h:2514
unsigned char UCHAR
Definition: xmlstorage.h:181
__wchar_t WCHAR
Definition: xmlstorage.h:180
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185