ReactOS  0.4.14-dev-583-g2a1ba2c
asmname.c
Go to the documentation of this file.
1 /*
2  * IAssemblyName implementation
3  *
4  * Copyright 2008 James Hawkins
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 #include <stdarg.h>
22 #include <assert.h>
23 
24 #define COBJMACROS
25 #define INITGUID
26 #ifdef __REACTOS__
27 #define WIN32_NO_STATUS
28 #endif
29 
30 #include "windef.h"
31 #include "winbase.h"
32 #include "winuser.h"
33 #include "ole2.h"
34 #include "guiddef.h"
35 #include "fusion.h"
36 #include "corerror.h"
37 #include "strsafe.h"
38 
39 #include "wine/debug.h"
40 #include "fusionpriv.h"
41 
43 
44 typedef struct {
46 
48 
53 
56 
59 
61 
64 
65 static const WCHAR separator[] = {',',' ',0};
66 static const WCHAR version[] = {'V','e','r','s','i','o','n',0};
67 static const WCHAR culture[] = {'C','u','l','t','u','r','e',0};
68 static const WCHAR pubkey[] =
69  {'P','u','b','l','i','c','K','e','y','T','o','k','e','n',0};
70 static const WCHAR procarch[] = {'p','r','o','c','e','s','s','o','r',
71  'A','r','c','h','i','t','e','c','t','u','r','e',0};
72 
73 #define CHARS_PER_PUBKEY 16
74 
76 {
77  return CONTAINING_RECORD(iface, IAssemblyNameImpl, IAssemblyName_iface);
78 }
79 
81  REFIID riid, LPVOID *ppobj)
82 {
84 
85  TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
86 
87  *ppobj = NULL;
88 
89  if (IsEqualIID(riid, &IID_IUnknown) ||
90  IsEqualIID(riid, &IID_IAssemblyName))
91  {
92  IAssemblyName_AddRef(iface);
93  *ppobj = &This->IAssemblyName_iface;
94  return S_OK;
95  }
96 
97  WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
98  return E_NOINTERFACE;
99 }
100 
102 {
104  ULONG refCount = InterlockedIncrement(&This->ref);
105 
106  TRACE("(%p)->(ref before = %u)\n", This, refCount - 1);
107 
108  return refCount;
109 }
110 
112 {
114  ULONG refCount = InterlockedDecrement(&This->ref);
115 
116  TRACE("(%p)->(ref before = %u)\n", This, refCount + 1);
117 
118  if (!refCount)
119  {
120  heap_free(This->path);
121  heap_free(This->displayname);
122  heap_free(This->name);
123  heap_free(This->culture);
124  heap_free(This->procarch);
125  heap_free(This);
126  }
127 
128  return refCount;
129 }
130 
133  LPVOID pvProperty,
134  DWORD cbProperty)
135 {
136  FIXME("(%p, %d, %p, %d) stub!\n", iface, PropertyId, pvProperty, cbProperty);
137  return E_NOTIMPL;
138 }
139 
142  LPVOID pvProperty,
143  LPDWORD pcbProperty)
144 {
146  DWORD size;
147 
148  TRACE("(%p, %d, %p, %p)\n", iface, PropertyId, pvProperty, pcbProperty);
149 
150  size = *pcbProperty;
151  switch (PropertyId)
152  {
153  case ASM_NAME_NULL_PUBLIC_KEY:
154  case ASM_NAME_NULL_PUBLIC_KEY_TOKEN:
155  if (name->haspubkey)
156  return S_OK;
157  return S_FALSE;
158 
159  case ASM_NAME_NULL_CUSTOM:
160  return S_OK;
161 
162  case ASM_NAME_NAME:
163  *pcbProperty = 0;
164  if (name->name)
165  {
166  *pcbProperty = (lstrlenW(name->name) + 1) * 2;
167  if (size < *pcbProperty)
169  lstrcpyW(pvProperty, name->name);
170  }
171  break;
172 
173  case ASM_NAME_MAJOR_VERSION:
174  *pcbProperty = 0;
175  if (name->versize >= 1)
176  {
177  *pcbProperty = sizeof(WORD);
178  if (size < *pcbProperty)
180  *((WORD *)pvProperty) = name->version[0];
181  }
182  break;
183 
184  case ASM_NAME_MINOR_VERSION:
185  *pcbProperty = 0;
186  if (name->versize >= 2)
187  {
188  *pcbProperty = sizeof(WORD);
189  if (size < *pcbProperty)
191  *((WORD *)pvProperty) = name->version[1];
192  }
193  break;
194 
195  case ASM_NAME_BUILD_NUMBER:
196  *pcbProperty = 0;
197  if (name->versize >= 3)
198  {
199  *pcbProperty = sizeof(WORD);
200  if (size < *pcbProperty)
202  *((WORD *)pvProperty) = name->version[2];
203  }
204  break;
205 
206  case ASM_NAME_REVISION_NUMBER:
207  *pcbProperty = 0;
208  if (name->versize >= 4)
209  {
210  *pcbProperty = sizeof(WORD);
211  if (size < *pcbProperty)
213  *((WORD *)pvProperty) = name->version[3];
214  }
215  break;
216 
217  case ASM_NAME_CULTURE:
218  *pcbProperty = 0;
219  if (name->culture)
220  {
221  *pcbProperty = (lstrlenW(name->culture) + 1) * 2;
222  if (size < *pcbProperty)
224  lstrcpyW(pvProperty, name->culture);
225  }
226  break;
227 
228  case ASM_NAME_PUBLIC_KEY_TOKEN:
229  *pcbProperty = 0;
230  if (name->haspubkey)
231  {
232  *pcbProperty = sizeof(DWORD) * 2;
233  if (size < *pcbProperty)
235  memcpy(pvProperty, name->pubkey, sizeof(DWORD) * 2);
236  }
237  break;
238 
239  case ASM_NAME_ARCHITECTURE:
240  *pcbProperty = 0;
241  if (name->pekind != peNone)
242  {
243  *pcbProperty = sizeof(PEKIND);
244  if (size < *pcbProperty)
246  *((PEKIND *)pvProperty) = name->pekind;
247  }
248  break;
249 
250  default:
251  *pcbProperty = 0;
252  break;
253  }
254 
255  return S_OK;
256 }
257 
259 {
260  FIXME("(%p) stub!\n", iface);
261  return E_NOTIMPL;
262 }
263 
265  LPOLESTR szDisplayName,
266  LPDWORD pccDisplayName,
267  DWORD dwDisplayFlags)
268 {
269  static const WCHAR equals[] = {'=',0};
271  WCHAR verstr[30], *cultureval = NULL;
272  DWORD size;
273 
274  TRACE("(%p, %p, %p, %d)\n", iface, szDisplayName,
275  pccDisplayName, dwDisplayFlags);
276 
277  if (dwDisplayFlags == 0)
278  {
279  if (!name->displayname || !*name->displayname)
280  return FUSION_E_INVALID_NAME;
281 
282  size = lstrlenW(name->displayname) + 1;
283 
284  if (*pccDisplayName < size)
285  {
286  *pccDisplayName = size;
288  }
289 
290  if (szDisplayName) lstrcpyW(szDisplayName, name->displayname);
291  *pccDisplayName = size;
292 
293  return S_OK;
294  }
295 
296  if (!name->name || !*name->name)
297  return FUSION_E_INVALID_NAME;
298 
299  /* Verify buffer size is sufficient */
300  size = lstrlenW(name->name) + 1;
301 
302  if ((dwDisplayFlags & ASM_DISPLAYF_VERSION) && (name->versize > 0))
303  {
304  static const WCHAR spec[] = {'%','d',0};
305  static const WCHAR period[] = {'.',0};
306  DWORD i;
307 
308  wsprintfW(verstr, spec, name->version[0]);
309 
310  for (i = 1; i < name->versize; i++)
311  {
312  WCHAR value[6];
313  wsprintfW(value, spec, name->version[i]);
314 
315  lstrcatW(verstr, period);
316  lstrcatW(verstr, value);
317  }
318 
319  size += lstrlenW(separator) + lstrlenW(version) + lstrlenW(equals) + lstrlenW(verstr);
320  }
321 
322  if ((dwDisplayFlags & ASM_DISPLAYF_CULTURE) && (name->culture))
323  {
324  static const WCHAR neutral[] = {'n','e','u','t','r','a','l', 0};
325 
326  cultureval = (lstrlenW(name->culture) == 2) ? name->culture : (LPWSTR) neutral;
327  size += lstrlenW(separator) + lstrlenW(culture) + lstrlenW(equals) + lstrlenW(cultureval);
328  }
329 
330  if ((dwDisplayFlags & ASM_DISPLAYF_PUBLIC_KEY_TOKEN) && (name->haspubkey))
332 
333  if ((dwDisplayFlags & ASM_DISPLAYF_PROCESSORARCHITECTURE) && (name->procarch))
334  size += lstrlenW(separator) + lstrlenW(procarch) + lstrlenW(equals) + lstrlenW(name->procarch);
335 
336  if (size > *pccDisplayName)
337  {
338  *pccDisplayName = size;
340  }
341 
342  /* Construct the string */
343  lstrcpyW(szDisplayName, name->name);
344 
345  if ((dwDisplayFlags & ASM_DISPLAYF_VERSION) && (name->versize > 0))
346  {
347  lstrcatW(szDisplayName, separator);
348 
349  lstrcatW(szDisplayName, version);
350  lstrcatW(szDisplayName, equals);
351  lstrcatW(szDisplayName, verstr);
352  }
353 
354  if ((dwDisplayFlags & ASM_DISPLAYF_CULTURE) && (name->culture))
355  {
356  lstrcatW(szDisplayName, separator);
357 
358  lstrcatW(szDisplayName, culture);
359  lstrcatW(szDisplayName, equals);
360  lstrcatW(szDisplayName, cultureval);
361  }
362 
363  if ((dwDisplayFlags & ASM_DISPLAYF_PUBLIC_KEY_TOKEN) && (name->haspubkey))
364  {
365  WCHAR pkt[CHARS_PER_PUBKEY + 1];
366  static const WCHAR spec[] = {'%','0','2','x','%','0','2','x','%','0','2','x',
367  '%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x','%','0','2','x',0};
368 
369  lstrcatW(szDisplayName, separator);
370 
371  lstrcatW(szDisplayName, pubkey);
372  lstrcatW(szDisplayName, equals);
373 
374  wsprintfW(pkt, spec, name->pubkey[0], name->pubkey[1], name->pubkey[2],
375  name->pubkey[3], name->pubkey[4], name->pubkey[5], name->pubkey[6],
376  name->pubkey[7]);
377 
378  lstrcatW(szDisplayName, pkt);
379  }
380 
381  if ((dwDisplayFlags & ASM_DISPLAYF_PROCESSORARCHITECTURE) && (name->procarch))
382  {
383  lstrcatW(szDisplayName, separator);
384 
385  lstrcatW(szDisplayName, procarch);
386  lstrcatW(szDisplayName, equals);
387  lstrcatW(szDisplayName, name->procarch);
388  }
389 
390  *pccDisplayName = size;
391  return S_OK;
392 }
393 
395  REFIID refIID,
396  IUnknown *pUnkReserved1,
397  IUnknown *pUnkReserved2,
398  LPCOLESTR szReserved,
399  LONGLONG llReserved,
401  DWORD cbReserved,
402  LPVOID *ppReserved)
403 {
404  TRACE("(%p, %s, %p, %p, %s, %s, %p, %d, %p)\n", iface,
405  debugstr_guid(refIID), pUnkReserved1, pUnkReserved2,
406  debugstr_w(szReserved), wine_dbgstr_longlong(llReserved),
407  pvReserved, cbReserved, ppReserved);
408 
409  return E_NOTIMPL;
410 }
411 
413  LPDWORD lpcwBuffer,
414  WCHAR *pwzName)
415 {
417  DWORD len;
418 
419  TRACE("(%p, %p, %p)\n", iface, lpcwBuffer, pwzName);
420 
421  if (name->name)
422  len = lstrlenW(name->name) + 1;
423  else
424  len = 0;
425 
426  if (*lpcwBuffer < len)
427  {
428  *lpcwBuffer = len;
430  }
431  if (!name->name) lpcwBuffer[0] = 0;
432  else lstrcpyW(pwzName, name->name);
433 
434  *lpcwBuffer = len;
435  return S_OK;
436 }
437 
439  LPDWORD pdwVersionHi,
440  LPDWORD pdwVersionLow)
441 {
443 
444  TRACE("(%p, %p, %p)\n", iface, pdwVersionHi, pdwVersionLow);
445 
446  *pdwVersionHi = 0;
447  *pdwVersionLow = 0;
448 
449  if (name->versize != 4)
450  return FUSION_E_INVALID_NAME;
451 
452  *pdwVersionHi = (name->version[0] << 16) + name->version[1];
453  *pdwVersionLow = (name->version[2] << 16) + name->version[3];
454 
455  return S_OK;
456 }
457 
460  DWORD flags)
461 {
464 
465  TRACE("(%p, %p, 0x%08x)\n", iface, pName, flags);
466 
467  if (!pName) return S_FALSE;
468  if (flags & ~ASM_CMPF_IL_ALL) FIXME("unsupported flags\n");
469 
470  if ((flags & ASM_CMPF_NAME) && lstrcmpW(name1->name, name2->name)) return S_FALSE;
471  if (name1->versize && name2->versize)
472  {
473  if ((flags & ASM_CMPF_MAJOR_VERSION) &&
474  name1->version[0] != name2->version[0]) return S_FALSE;
475  if ((flags & ASM_CMPF_MINOR_VERSION) &&
476  name1->version[1] != name2->version[1]) return S_FALSE;
477  if ((flags & ASM_CMPF_BUILD_NUMBER) &&
478  name1->version[2] != name2->version[2]) return S_FALSE;
479  if ((flags & ASM_CMPF_REVISION_NUMBER) &&
480  name1->version[3] != name2->version[3]) return S_FALSE;
481  }
482  if ((flags & ASM_CMPF_PUBLIC_KEY_TOKEN) &&
483  name1->haspubkey && name2->haspubkey &&
484  memcmp(name1->pubkey, name2->pubkey, sizeof(name1->pubkey))) return S_FALSE;
485 
486  if ((flags & ASM_CMPF_CULTURE) &&
487  name1->culture && name2->culture &&
488  lstrcmpW(name1->culture, name2->culture)) return S_FALSE;
489 
490  return S_OK;
491 }
492 
495 {
496  FIXME("(%p, %p) stub!\n", iface, pName);
497  return E_NOTIMPL;
498 }
499 
500 static const IAssemblyNameVtbl AssemblyNameVtbl = {
513 };
514 
515 /* Internal methods */
517 {
518  assert(iface->lpVtbl == &AssemblyNameVtbl);
519 
520  return impl_from_IAssemblyName(iface);
521 }
522 
524 {
526 
527  name->path = strdupW(path);
528  if (!name->path)
529  return E_OUTOFMEMORY;
530 
531  return S_OK;
532 }
533 
535 {
536  ULONG buffer_size = *len;
538 
539  if (!name->path)
540  return S_OK;
541 
542  if (!buf)
543  buffer_size = 0;
544 
545  *len = lstrlenW(name->path) + 1;
546 
547  if (*len <= buffer_size)
548  lstrcpyW(buf, name->path);
549  else
551 
552  return S_OK;
553 }
554 
556 {
557  LPWSTR beg, end;
558  int i;
559 
560  for (i = 0, beg = version; i < 4; i++)
561  {
562  if (!*beg)
563  return S_OK;
564 
565  end = wcschr(beg, '.');
566 
567  if (end) *end = '\0';
568  name->version[i] = wcstol(beg, NULL, 10);
569  name->versize++;
570 
571  if (!end && i < 3)
572  return S_OK;
573 
574  beg = end + 1;
575  }
576 
577  return S_OK;
578 }
579 
581 {
582  static const WCHAR empty[] = {0};
583 
584  if (lstrlenW(culture) == 2)
585  name->culture = strdupW(culture);
586  else
587  name->culture = strdupW(empty);
588 
589  return S_OK;
590 }
591 
593 {
594  return ((c >= 'a' && c <= 'f') ||
595  (c >= 'A' && c <= 'F') ||
596  (c >= '0' && c <= '9'));
597 }
598 
600 {
601  if(c >= '0' && c <= '9')
602  return c - '0';
603  if(c >= 'A' && c <= 'F')
604  return c - 'A' + 10;
605  if(c >= 'a' && c <= 'f')
606  return c - 'a' + 10;
607  return 0;
608 }
609 
611 {
612  int i;
613  BYTE val;
614  static const WCHAR nullstr[] = {'n','u','l','l',0};
615 
616  if(lstrcmpiW(pubkey, nullstr) == 0)
618 
620  return FUSION_E_INVALID_NAME;
621 
622  for (i = 0; i < CHARS_PER_PUBKEY; i++)
623  if (!is_hex(pubkey[i]))
624  return FUSION_E_INVALID_NAME;
625 
626  name->haspubkey = TRUE;
627 
628  for (i = 0; i < CHARS_PER_PUBKEY; i += 2)
629  {
630  val = (hextobyte(pubkey[i]) << 4) + hextobyte(pubkey[i + 1]);
631  name->pubkey[i / 2] = val;
632  }
633 
634  return S_OK;
635 }
636 
638 {
639  static const WCHAR msilW[] = {'m','s','i','l',0};
640  static const WCHAR x86W[] = {'x','8','6',0};
641  static const WCHAR ia64W[] = {'i','a','6','4',0};
642  static const WCHAR amd64W[] = {'a','m','d','6','4',0};
643 
644  if (!lstrcmpiW(procarch, msilW))
645  name->pekind = peMSIL;
646  else if (!lstrcmpiW(procarch, x86W))
647  name->pekind = peI386;
648  else if (!lstrcmpiW(procarch, ia64W))
649  name->pekind = peIA64;
650  else if (!lstrcmpiW(procarch, amd64W))
651  name->pekind = peAMD64;
652  else
653  {
654  ERR("unrecognized architecture: %s\n", wine_dbgstr_w(procarch));
655  return FUSION_E_INVALID_NAME;
656  }
657 
658  return S_OK;
659 }
660 
661 static WCHAR *parse_value( const WCHAR *str, unsigned int len )
662 {
663  WCHAR *ret;
664  const WCHAR *p = str;
665  BOOL quoted = FALSE;
666  unsigned int i = 0;
667 
668  if (!(ret = heap_alloc( (len + 1) * sizeof(WCHAR) ))) return NULL;
669  if (*p == '\"')
670  {
671  quoted = TRUE;
672  p++;
673  }
674  while (*p && *p != '\"') ret[i++] = *p++;
675  if ((quoted && *p != '\"') || (!quoted && *p == '\"'))
676  {
677  heap_free( ret );
678  return NULL;
679  }
680  ret[i] = 0;
681  return ret;
682 }
683 
685 {
686  LPWSTR str, save, ptr, ptr2, value;
687  HRESULT hr = S_OK;
688  BOOL done = FALSE;
689 
690  if (!szAssemblyName)
691  return S_OK;
692 
693  name->displayname = strdupW(szAssemblyName);
694  if (!name->displayname)
695  return E_OUTOFMEMORY;
696 
698  save = str;
699  if (!str)
700  {
701  hr = E_OUTOFMEMORY;
702  goto done;
703  }
704 
705  ptr = wcschr(str, ',');
706  if (ptr) *ptr = '\0';
707 
708  /* no ',' but ' ' only */
709  if( !ptr && wcschr(str, ' ') )
710  {
712  goto done;
713  }
714 
715  name->name = strdupW(str);
716  if (!name->name)
717  {
718  hr = E_OUTOFMEMORY;
719  goto done;
720  }
721 
722  if (!ptr)
723  goto done;
724 
725  str = ptr + 1;
726  while (!done)
727  {
728  ptr = wcschr(str, '=');
729  if (!ptr)
730  {
732  goto done;
733  }
734 
735  *(ptr++) = '\0';
736  if (!*ptr)
737  {
739  goto done;
740  }
741 
742  if (!(ptr2 = wcschr(ptr, ',')))
743  {
744  if (!(ptr2 = wcschr(ptr, '\0')))
745  {
747  goto done;
748  }
749 
750  done = TRUE;
751  }
752 
753  *ptr2 = '\0';
754  if (!(value = parse_value( ptr, ptr2 - ptr )))
755  {
757  goto done;
758  }
759  while (*str == ' ') str++;
760 
761  if (!lstrcmpiW(str, version))
762  hr = parse_version( name, value );
763  else if (!lstrcmpiW(str, culture))
764  hr = parse_culture( name, value );
765  else if (!lstrcmpiW(str, pubkey))
766  hr = parse_pubkey( name, value );
767  else if (!lstrcmpiW(str, procarch))
768  {
769  name->procarch = value;
770  value = NULL;
771 
772  hr = parse_procarch( name, name->procarch );
773  }
774  heap_free( value );
775 
776  if (FAILED(hr))
777  goto done;
778 
779  str = ptr2 + 1;
780  }
781 
782 done:
783  heap_free(save);
784  if (FAILED(hr))
785  {
786  heap_free(name->displayname);
787  heap_free(name->name);
788  heap_free(name->culture);
789  heap_free(name->procarch);
790  }
791  return hr;
792 }
793 
794 /******************************************************************
795  * CreateAssemblyNameObject (FUSION.@)
796  */
800 {
802  HRESULT hr;
803 
804  TRACE("(%p, %s, %08x, %p)\n", ppAssemblyNameObj,
806 
807  if (!ppAssemblyNameObj)
808  return E_INVALIDARG;
809 
812  return E_INVALIDARG;
813 
814  if (!(name = heap_alloc_zero(sizeof(*name)))) return E_OUTOFMEMORY;
815 
817  name->ref = 1;
818 
820  if (FAILED(hr))
821  {
822  heap_free(name);
823  return hr;
824  }
825 
826  *ppAssemblyNameObj = &name->IAssemblyName_iface;
827 
828  return S_OK;
829 }
int WINAPIV wsprintfW(_Out_ LPWSTR, _In_ _Printf_format_string_ LPCWSTR,...)
static HRESULT WINAPI IAssemblyNameImpl_GetProperty(IAssemblyName *iface, DWORD PropertyId, LPVOID pvProperty, LPDWORD pcbProperty)
Definition: asmname.c:140
static HRESULT parse_version(IAssemblyNameImpl *name, LPWSTR version)
Definition: asmname.c:555
LPWSTR procarch
Definition: asmname.c:52
LPWSTR displayname
Definition: asmname.c:49
#define REFIID
Definition: guiddef.h:118
#define TRUE
Definition: types.h:120
#define E_NOINTERFACE
Definition: winerror.h:2364
static HRESULT WINAPI IAssemblyNameImpl_GetName(IAssemblyName *iface, LPDWORD lpcwBuffer, WCHAR *pwzName)
Definition: asmname.c:412
static const WCHAR separator[]
Definition: asmname.c:65
static WCHAR * parse_value(const WCHAR *str, unsigned int len)
Definition: asmname.c:661
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
WCHAR * version
Definition: name.c:46
HRESULT hr
Definition: shlfolder.c:183
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
static HRESULT WINAPI IAssemblyNameImpl_Finalize(IAssemblyName *iface)
Definition: asmname.c:258
_In_ PSTORAGE_PROPERTY_ID PropertyId
Definition: classpnp.h:966
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
static WCHAR * strdupW(const WCHAR *src)
Definition: main.c:92
static const WCHAR pubkey[]
Definition: asmname.c:68
REFIID riid
Definition: precomp.h:44
char * wine_dbgstr_w(const wchar_t *wstr)
Definition: atltest.h:87
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
#define FUSION_E_PRIVATE_ASM_DISALLOWED
Definition: corerror.h:122
#define WARN(fmt,...)
Definition: debug.h:111
#define CHARS_PER_PUBKEY
Definition: asmname.c:73
#define assert(x)
Definition: debug.h:53
static HRESULT WINAPI IAssemblyNameImpl_GetVersion(IAssemblyName *iface, LPDWORD pdwVersionHi, LPDWORD pdwVersionLow)
Definition: asmname.c:438
static HRESULT WINAPI IAssemblyNameImpl_SetProperty(IAssemblyName *iface, DWORD PropertyId, LPVOID pvProperty, DWORD cbProperty)
Definition: asmname.c:131
static LPCWSTR szAssemblyName
Definition: asmname.c:40
IAssemblyName IAssemblyName_iface
Definition: name.c:40
static HRESULT WINAPI IAssemblyNameImpl_Clone(IAssemblyName *iface, IAssemblyName **pName)
Definition: asmname.c:493
GLuint GLuint end
Definition: gl.h:1545
_Check_return_ long __cdecl wcstol(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
static IAssemblyNameImpl * impl_from_IAssemblyName(IAssemblyName *iface)
Definition: asmname.c:75
static WCHAR name1[]
Definition: record.c:34
static LPOLESTR
Definition: stg_prop.c:27
#define lstrlenW
Definition: compat.h:415
#define STRSAFE_E_INSUFFICIENT_BUFFER
Definition: strsafe.h:103
#define DWORD
Definition: nt_native.h:44
static const WCHAR procarch[]
Definition: asmname.c:70
static void * heap_alloc(size_t len)
Definition: appwiz.h:65
static IAssemblyNameImpl * unsafe_impl_from_IAssemblyName(IAssemblyName *iface)
Definition: asmname.c:516
int WINAPI lstrcmpiW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:194
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
static LPCWSTR DWORD LPVOID pvReserved
Definition: asmname.c:40
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
static HRESULT WINAPI IAssemblyNameImpl_IsEqual(IAssemblyName *iface, IAssemblyName *pName, DWORD flags)
Definition: asmname.c:458
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
#define debugstr_w
Definition: kernel32.h:32
#define FIXME(fmt,...)
Definition: debug.h:110
static PVOID ptr
Definition: dispmode.c:27
static void buffer_size(GLcontext *ctx, GLuint *width, GLuint *height)
Definition: swimpl.c:927
#define S_FALSE
Definition: winerror.h:2357
#define E_INVALIDARG
Definition: ddrawi.h:101
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
static const WCHAR version[]
Definition: asmname.c:66
LPWSTR culture
Definition: asmname.c:51
static HRESULT parse_procarch(IAssemblyNameImpl *name, LPCWSTR procarch)
Definition: asmname.c:637
#define debugstr_guid
Definition: kernel32.h:35
static const IAssemblyNameVtbl AssemblyNameVtbl
Definition: asmname.c:500
static BOOL is_hex(WCHAR c)
Definition: asmname.c:592
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
GLuint GLfloat * val
Definition: glext.h:7180
static HRESULT parse_display_name(IAssemblyNameImpl *name, LPCWSTR szAssemblyName)
Definition: asmname.c:684
static ULONG WINAPI IAssemblyNameImpl_AddRef(IAssemblyName *iface)
Definition: asmname.c:101
int64_t LONGLONG
Definition: typedefs.h:66
WINE_DEFAULT_DEBUG_CHANNEL(fusion)
#define TRACE(s)
Definition: solgame.cpp:4
static LPSTR pName
Definition: security.c:75
GLsizeiptr size
Definition: glext.h:5919
_CONST_RETURN wchar_t *__cdecl wcschr(_In_z_ const wchar_t *_Str, wchar_t _Ch)
__wchar_t WCHAR
Definition: xmlstorage.h:180
LONG HRESULT
Definition: typedefs.h:77
const GUID IID_IUnknown
#define WINAPI
Definition: msvc.h:6
#define FUSION_E_INVALID_NAME
Definition: corerror.h:123
const GLubyte * c
Definition: glext.h:8905
unsigned short WORD
Definition: ntddk_ex.h:93
unsigned long DWORD
Definition: ntddk_ex.h:95
HRESULT WINAPI CreateAssemblyNameObject(IAssemblyName **ppAssemblyNameObj, LPCWSTR szAssemblyName, DWORD dwFlags, LPVOID pvReserved)
Definition: asmname.c:797
GLbitfield flags
Definition: glext.h:7161
int ret
PEKIND
Definition: fusion.idl:35
#define InterlockedDecrement
Definition: armddk.h:52
static HRESULT parse_culture(IAssemblyNameImpl *name, LPCWSTR culture)
Definition: asmname.c:580
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
unsigned char BYTE
Definition: mem.h:68
static HRESULT WINAPI IAssemblyNameImpl_Reserved(IAssemblyName *iface, REFIID refIID, IUnknown *pUnkReserved1, IUnknown *pUnkReserved2, LPCOLESTR szReserved, LONGLONG llReserved, LPVOID pvReserved, DWORD cbReserved, LPVOID *ppReserved)
Definition: asmname.c:394
#define E_NOT_SUFFICIENT_BUFFER
Definition: winerror.h:2345
GLsizei const GLfloat * value
Definition: glext.h:6069
#define ERR(fmt,...)
Definition: debug.h:109
static HRESULT WINAPI IAssemblyNameImpl_GetDisplayName(IAssemblyName *iface, LPOLESTR szDisplayName, LPDWORD pccDisplayName, DWORD dwDisplayFlags)
Definition: asmname.c:264
static HRESULT WINAPI IAssemblyNameImpl_QueryInterface(IAssemblyName *iface, REFIID riid, LPVOID *ppobj)
Definition: asmname.c:80
#define S_OK
Definition: intsafe.h:59
HRESULT IAssemblyName_SetPath(IAssemblyName *iface, LPCWSTR path)
Definition: asmname.c:523
#define InterlockedIncrement
Definition: armddk.h:53
#define lstrcpyW
Definition: compat.h:414
PEKIND pekind
Definition: asmname.c:60
#define E_NOTIMPL
Definition: ddrawi.h:99
BOOL empty
Definition: button.c:170
HRESULT IAssemblyName_GetPath(IAssemblyName *iface, LPWSTR buf, ULONG *len)
Definition: asmname.c:534
Definition: name.c:38
uint32_t * LPDWORD
Definition: typedefs.h:57
unsigned int ULONG
Definition: retypes.h:1
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:41
static WCHAR name2[]
Definition: record.c:35
static const WCHAR culture[]
Definition: asmname.c:67
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
GLfloat GLfloat p
Definition: glext.h:8902
WCHAR * LPWSTR
Definition: xmlstorage.h:184
IAssemblyName IAssemblyName_iface
Definition: asmname.c:45
static ULONG WINAPI IAssemblyNameImpl_Release(IAssemblyName *iface)
Definition: asmname.c:111
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
static HRESULT parse_pubkey(IAssemblyNameImpl *name, LPCWSTR pubkey)
Definition: asmname.c:610
static BYTE hextobyte(WCHAR c)
Definition: asmname.c:599
WCHAR * name
Definition: name.c:42
static BOOL heap_free(void *mem)
Definition: appwiz.h:75
GLuint const GLchar * name
Definition: glext.h:6031