33#if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION)
34# define V_U2(A) ((A)->n1.n2)
36# define V_U2(A) (*(A))
58 hr = pSafeArrayGetVartype(
psa, &
vt);
61 if(
psa->fFeatures & FADF_VARIANT)
return SF_VARIANT;
63 switch(
psa->cbElements)
73 if (
psa->fFeatures & FADF_HAVEIID)
87 case VT_R4:
return SF_I4;
103 default:
return SF_ERROR;
111 ULONG ulNumCells = 1;
133 if (sftype == SF_BSTR)
135 return sizeof(
DWORD);
150 unsigned char *wiresa =
buffer;
159 ok(*(
DWORD *)wiresa == 0,
"wiresa + 0x0 should be NULL instead of 0x%08x\n", *(
DWORD *)wiresa);
163 if (!pSafeArrayGetVartype || !pSafeArrayGetIID)
170 if(
FAILED(pSafeArrayGetVartype(lpsa, &
vt)))
177 ok(*(
DWORD *)wiresa,
"wiresa + 0x0 should be non-NULL instead of 0x%08x\n", *(
DWORD *)wiresa);
178 wiresa +=
sizeof(
DWORD);
179 ok(*(
DWORD *)wiresa == lpsa->
cDims,
"wiresa + 0x4 should be lpsa->cDims instead of 0x%08x\n", *(
DWORD *)wiresa);
180 wiresa +=
sizeof(
DWORD);
181 ok(*(
WORD *)wiresa == lpsa->
cDims,
"wiresa + 0x8 should be lpsa->cDims instead of 0x%04x\n", *(
WORD *)wiresa);
182 wiresa +=
sizeof(
WORD);
183 ok(*(
WORD *)wiresa == lpsa->
fFeatures,
"wiresa + 0xa should be lpsa->fFeatures instead of 0x%08x\n", *(
WORD *)wiresa);
184 wiresa +=
sizeof(
WORD);
186 wiresa +=
sizeof(
DWORD);
187 ok(*(
WORD *)wiresa == lpsa->
cLocks,
"wiresa + 0x10 should be lpsa->cLocks instead of 0x%04x\n", *(
WORD *)wiresa);
188 wiresa +=
sizeof(
WORD);
189 ok(*(
WORD *)wiresa ==
vt,
"wiresa + 0x12 should be %04x instead of 0x%04x\n",
vt, *(
WORD *)wiresa);
190 wiresa +=
sizeof(
WORD);
191 ok(*(
DWORD *)wiresa == sftype,
"wiresa + 0x14 should be %08x instead of 0x%08x\n", (
DWORD)sftype, *(
DWORD *)wiresa);
192 wiresa +=
sizeof(
DWORD);
193 ok(*(
DWORD *)wiresa == cell_count,
"wiresa + 0x18 should be %u instead of %u\n", cell_count, *(
DWORD *)wiresa);
194 wiresa +=
sizeof(
DWORD);
195 ok(*(
DWORD *)wiresa,
"wiresa + 0x1c should be non-zero instead of 0x%08x\n", *(
DWORD *)wiresa);
196 wiresa +=
sizeof(
DWORD);
197 if(sftype == SF_HAVEIID)
200 pSafeArrayGetIID(lpsa, &
guid);
202 wiresa +=
sizeof(
GUID);
210 "bounds mismatch for dimension %d, got (%d,%d), expected (%d,%d)\n",
i,
218 ok(*(
DWORD *)wiresa == cell_count,
"wiresa + 0x28 should be %u instead of %u\n", cell_count, *(
DWORD*)wiresa);
219 wiresa +=
sizeof(
DWORD);
225 ok(0,
"unexpected user_allocate call\n");
231 ok(0,
"unexpected user_free call\n");
244 memset(stub_msg, 0,
sizeof(*stub_msg));
250 memset(umcb, 0,
sizeof(*umcb));
277 int expected_bstr_size;
309 ok(lpsa2 !=
NULL,
"LPSAFEARRAY didn't unmarshal\n");
310 if (pSafeArrayGetVartype)
312 pSafeArrayGetVartype(lpsa, &
vt);
313 pSafeArrayGetVartype(lpsa2, &vt2);
314 ok(
vt == vt2,
"vts differ %x %x\n",
vt, vt2);
316 ok(lpsa2->
cLocks == 0,
"got lock count %u, expected 0\n", lpsa2->
cLocks);
319 ok(!lpsa2,
"lpsa2 was not set to 0 by LPSAFEARRAY_UserFree\n");
356 ok(lpsa2 !=
NULL,
"LPSAFEARRAY didn't unmarshal\n");
357 if (pSafeArrayGetVartype)
359 pSafeArrayGetVartype(lpsa, &
vt);
360 pSafeArrayGetVartype(lpsa2, &vt2);
361 ok(
vt == vt2,
"vts differ %x %x\n",
vt, vt2);
363 ok(lpsa2->
cLocks == 0,
"got lock count %u, expected 0\n", lpsa2->
cLocks);
386 ok(lpsa2 ==
NULL,
"NULL LPSAFEARRAY didn't unmarshal\n");
395 *(
double *)lpsa->
pvData = 3.1415;
400 expected = (44 + 1 + (
sizeof(
double) - 1)) & ~(
sizeof(
double) - 1);
432 if (pSafeArrayGetVartype)
434 hr = pSafeArrayGetVartype(lpsa, &
vt);
461 expected_bstr_size = 0;
466 for (
j = 0;
j <=
i;
j++)
472 ok(
hr ==
S_OK,
"Failed to put bstr element hr 0x%x\n",
hr);
473 expected_bstr_size += (
j *
sizeof(
WCHAR)) + (3 *
sizeof(
DWORD));
475 expected_bstr_size +=
sizeof(
WCHAR);
503 ok(lpsa2 !=
NULL,
"LPSAFEARRAY didn't unmarshal, result %p\n",
next);
513 ok(
hr ==
S_OK,
"Failed to get bstr element at hres 0x%x\n",
hr);
542 if (pSafeArrayGetVartype)
544 hr = pSafeArrayGetVartype(lpsa, &
vt);
590 heap_unknown[
i] = unk;
592 ok(
hr ==
S_OK,
"Failed to put unknown element hr 0x%x\n",
hr);
593 ok(unk->
refs == 2,
"VT_UNKNOWN safearray elem %d, refcount %d\n",
i, unk->
refs);
603 "size should be at least %u bytes, not %u\n",
expected,
size);
608 "size should be %u bytes, not %u\n",
size + (
ULONG)
sizeof(
DWORD), size2);
617 ok(heap_unknown[0]->refs == 3,
"Unexpected refcount %d\n", heap_unknown[0]->refs);
623 ok(lpsa2 !=
NULL,
"LPSAFEARRAY didn't unmarshal, result %p\n",
next);
633 ok(
hr ==
S_OK,
"Failed to get unk element at %d, hres 0x%x\n",
i,
hr);
636 ok(gotvalue == &heap_unknown[
i]->IUnknown_iface,
"Interface %d mismatch, expected %p, got %p\n",
637 i, &heap_unknown[
i]->IUnknown_iface, gotvalue);
638 IUnknown_Release(gotvalue);
649 ok(
hr ==
S_OK,
"Failed to put unknown element hr 0x%x\n",
hr);
664 "size should be at least %u bytes, not %u\n",
expected,
size);
669 "size should be %u bytes, not %u\n",
size + (
ULONG)
sizeof(
DWORD), size2);
682 ok(lpsa2 !=
NULL,
"LPSAFEARRAY didn't unmarshal, result %p\n",
next);
692 ok(
hr ==
S_OK,
"Failed to get unk element at %d, hres 0x%x\n",
i,
hr);
697 ok(gotvalue ==
NULL,
"Interface %d expected NULL, got %p\n",
i, gotvalue);
700 ok(gotvalue == &heap_unknown[
i]->IUnknown_iface,
"Interface %d mismatch, expected %p, got %p\n",
701 i, &heap_unknown[
i]->IUnknown_iface, gotvalue);
702 IUnknown_Release(gotvalue);
706 IUnknown_Release(&heap_unknown[
i]->IUnknown_iface);
712 ok(heap_unknown[0]->refs == 1,
"Unexpected refcount %d\n", heap_unknown[0]->refs);
724 ok(*wireb == (
len + 1) / 2,
"wv[0] %08x\n", *wireb);
727 ok(*wireb ==
len,
"wv[1] %08x\n", *wireb);
729 ok(*wireb == 0xffffffff,
"wv[1] %08x\n", *wireb);
731 ok(*wireb == (
len + 1) / 2,
"wv[2] %08x\n", *wireb);
735 ok(!
memcmp(wireb,
b, (
len + 1) & ~1),
"strings differ\n");
748 WCHAR str[] = {
'm',
'a',
'r',
's',
'h',
'a',
'l',
' ',
't',
'e',
's',
't',
'1',0};
775 ok(
b2 !=
NULL,
"BSTR didn't unmarshal\n");
798 ok(
b2 ==
NULL,
"NULL BSTR didn't unmarshal\n");
804 *(((
char*)
b) + 3) =
'd';
826 ok(
b2 !=
NULL,
"BSTR didn't unmarshal\n");
853 ok(
b2 !=
NULL,
"NULL LPSAFEARRAY didn't unmarshal\n");
879 IUnknown_AddRef(iface);
925 ok(
header->rpcReserved == 0,
"wv[1] %08x\n",
header->rpcReserved);
933 switch_is &= ~VT_TYPEMASK;
934 ok(
header->switch_is == switch_is,
"switch_is %08x expected %08x\n",
header->switch_is, switch_is);
962 WCHAR str[] = {
'm',
'a',
'r',
's',
'h',
'a',
'l',
' ',
't',
'e',
's',
't',0};
989 V_U2(&
v).wReserved1 = 0x1234;
990 V_U2(&
v).wReserved2 = 0x5678;
991 V_U2(&
v).wReserved3 = 0x9abc;
1007 ok(*(
char*)wirev ==
V_I1(&
v),
"wv[5] %08x\n", *wirev);
1033 ok(*(
short*)wirev ==
V_I2(&
v),
"wv[5] %08x\n", *wirev);
1060 ok(*wirev == 0x4,
"wv[5] %08x\n", *wirev);
1062 ok(*(
short*)wirev ==
s,
"wv[6] %08x\n", *wirev);
1091 ok(*wirev ==
V_I4(&
v),
"wv[5] %08x\n", *wirev);
1118 ok(*wirev == 0x1234,
"wv[5] %08x\n", *wirev);
1145 ok(*wirev == 0x4,
"wv[5] %08x\n", *wirev);
1147 ok(*wirev == ul,
"wv[6] %08x\n", *wirev);
1175 ok(*wirev == 0xcccccccc,
"wv[5] %08x\n", *wirev);
1204 ok(*(
float*)wirev ==
V_R4(&
v),
"wv[5] %08x\n", *wirev);
1231 ok(*wirev == 0xcccccccc,
"wv[5] %08x\n", *wirev);
1233 ok(*(
double*)wirev ==
V_R8(&
v),
"wv[6] %08x, wv[7] %08x\n", *wirev, *(wirev+1));
1260 ok(*wirev == 8,
"wv[5] %08x\n", *wirev);
1262 ok(*(
double*)wirev ==
d,
"wv[6] %08x wv[7] %08x\n", *wirev, *(wirev+1));
1288 ok(*(
short*)wirev ==
V_BOOL(&
v),
"wv[5] %04x\n", *(
WORD*)wirev);
1301 dec.wReserved = 0xfedc;
1317 ok(*wirev == 0xcccccccc,
"wirev[5] %08x\n", *wirev);
1321 ok(!
memcmp(wirev, &dec2,
sizeof(dec2)),
"wirev[6] %08x wirev[7] %08x wirev[8] %08x wirev[9] %08x\n",
1322 *wirev, *(wirev + 1), *(wirev + 2), *(wirev + 3));
1348 ok(*wirev == 16,
"wv[5] %08x\n", *wirev);
1350 ok(!
memcmp(wirev, &
dec,
sizeof(
dec)),
"wirev[6] %08x wirev[7] %08x wirev[8] %08x wirev[9] %08x\n", *wirev, *(wirev + 1), *(wirev + 2), *(wirev + 3));
1355 V_U2(&
v2).wReserved1 = 0x0123;
1356 V_U2(&
v2).wReserved2 = 0x4567;
1357 V_U2(&
v2).wReserved3 = 0x89ab;
1429 ok(*wirev,
"wv[5] %08x\n", *wirev);
1457 ok(*wirev == 0x4,
"wv[5] %08x\n", *wirev);
1459 ok(*wirev,
"wv[6] %08x\n", *wirev);
1471 ok(
mem ==
b2,
"BSTR should be reused\n");
1503 ok(*wirev,
"wv[5] %08x\n", *wirev);
1514 ok(bound == bound2,
"array lbounds differ\n");
1517 ok(bound == bound2,
"array ubounds differ\n");
1518 if (pSafeArrayGetVartype)
1521 pSafeArrayGetVartype(
V_ARRAY(&
v2), &vt2);
1522 ok(
vt == vt2,
"array vts differ %x %x\n",
vt, vt2);
1543 ok(*wirev == 4,
"wv[5] %08x\n", *wirev);
1545 ok(*wirev,
"wv[6] %08x\n", *wirev);
1556 ok(bound == bound2,
"array lbounds differ\n");
1559 ok(bound == bound2,
"array ubounds differ\n");
1560 if (pSafeArrayGetVartype)
1564 ok(
vt == vt2,
"array vts differ %x %x\n",
vt, vt2);
1586 ok(*wirev == 4,
"wv[5] %08x\n", *wirev);
1588 ok(*wirev,
"wv[6] %08x\n", *wirev);
1601 ok(lpsa2 == lpsa_copy,
"safearray should be reused\n");
1602 ok(
mem == lpsa2->
pvData,
"safearray data should be reused\n");
1606 ok(bound == bound2,
"array lbounds differ\n");
1609 ok(bound == bound2,
"array ubounds differ\n");
1610 if (pSafeArrayGetVartype)
1614 ok(
vt == vt2,
"array vts differ %x %x\n",
vt, vt2);
1642 ok(*wirev ==
sizeof(
VARIANT),
"wv[5] %08x\n", *wirev);
1644 ok(*wirev == (
'U' |
's' << 8 |
'e' << 16 |
'r' << 24),
"wv[6] %08x\n", *wirev);
1646 ok(*wirev == 0xcccccccc,
"wv[7] %08x\n", *wirev);
1649 ok(*wirev == 0xcccccccc,
"wv[13] %08x\n", *wirev);
1651 ok(*(
double*)wirev ==
V_R8(&
v2),
"wv[6] %08x wv[7] %08x\n", *wirev, *(wirev+1));
1666 heap_unknown->
refs = 1;
1679 ok(heap_unknown->
refs == 2,
"got refcount %d\n", heap_unknown->
refs);
1686 ok(*wirev ==
next -
buffer - 0x20,
"wv[6] %08x\n", *wirev);
1688 ok(*wirev ==
next -
buffer - 0x20,
"wv[7] %08x\n", *wirev);
1690 ok(*wirev == 0x574f454d,
"wv[8] %08x\n", *wirev);
1697 ok(heap_unknown->
refs == 3,
"got refcount %d\n", heap_unknown->
refs);
1702 ok(heap_unknown->
refs == 1,
"%d refcounts of IUnknown leaked\n", heap_unknown->
refs - 1);
1719 ok(*wirev == 0,
"wv[5] %08x\n", *wirev);
1732 heap_unknown->
refs = 1;
1743 ok(heap_unknown->
refs == 1,
"got refcount %d\n", heap_unknown->
refs);
1746 ok(heap_unknown->
refs == 2,
"got refcount %d\n", heap_unknown->
refs);
1750 ok(*wirev == 4,
"wv[5] %08x\n", *wirev);
1753 *wirev == (
DWORD_PTR)heap_unknown + 1 ,
"wv[6] %08x\n", *wirev);
1755 ok(*wirev ==
next -
buffer - 0x24,
"wv[7] %08x\n", *wirev);
1757 ok(*wirev ==
next -
buffer - 0x24,
"wv[8] %08x\n", *wirev);
1759 ok(*wirev == 0x574f454d,
"wv[9] %08x\n", *wirev);
1767 ok(heap_unknown->
refs == 2,
"got refcount %d\n", heap_unknown->
refs);
1771 ok(heap_unknown->
refs == 1,
"%d refcounts of IUnknown leaked\n", heap_unknown->
refs - 1);
1790 ok(*wirev == 4,
"wv[5] %08x\n", *wirev);
1806#define GETPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func)
1812 if (!pSafeArrayGetIID || !pSafeArrayGetVartype)
1813 win_skip(
"SafeArrayGetIID and/or SafeArrayGetVartype is not available, some tests will be skipped\n");
ios_base &_STLP_CALL dec(ios_base &__s)
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
#define InterlockedIncrement
#define InterlockedDecrement
struct tagVARIANT VARIANT
struct tagSAFEARRAYBOUND SAFEARRAYBOUND
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
#define HeapFree(x, y, z)
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
static REFPROPVARIANT PROPVAR_CHANGE_FLAGS VARTYPE vt
HRESULT WINAPI CoInitialize(LPVOID lpReserved)
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
HRESULT WINAPI SafeArrayGetUBound(SAFEARRAY *psa, UINT nDim, LONG *plUbound)
HRESULT WINAPI SafeArrayDestroyDescriptor(SAFEARRAY *psa)
HRESULT WINAPI SafeArrayGetElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData)
UINT WINAPI SafeArrayGetDim(SAFEARRAY *psa)
HRESULT WINAPI SafeArrayGetIID(SAFEARRAY *psa, GUID *pGuid)
HRESULT WINAPI SafeArrayGetLBound(SAFEARRAY *psa, UINT nDim, LONG *plLbound)
HRESULT WINAPI SafeArrayDestroyData(SAFEARRAY *psa)
HRESULT WINAPI SafeArrayAllocDescriptor(UINT cDims, SAFEARRAY **ppsaOut)
HRESULT WINAPI SafeArrayDestroy(SAFEARRAY *psa)
SAFEARRAY *WINAPI SafeArrayCreate(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsabound)
HRESULT WINAPI SafeArrayAllocData(SAFEARRAY *psa)
HRESULT WINAPI SafeArrayGetVartype(SAFEARRAY *psa, VARTYPE *pvt)
HRESULT WINAPI SafeArrayPutElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData)
void WINAPI VARIANT_UserFree(ULONG *pFlags, VARIANT *pvar)
unsigned char *WINAPI LPSAFEARRAY_UserMarshal(ULONG *pFlags, unsigned char *Buffer, LPSAFEARRAY *ppsa)
void WINAPI BSTR_UserFree(ULONG *pFlags, BSTR *pstr)
unsigned char *WINAPI VARIANT_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, VARIANT *pvar)
ULONG WINAPI LPSAFEARRAY_UserSize(ULONG *pFlags, ULONG StartingSize, LPSAFEARRAY *ppsa)
ULONG WINAPI BSTR_UserSize(ULONG *pFlags, ULONG Start, BSTR *pstr)
unsigned char *WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer, VARIANT *pvar)
ULONG WINAPI VARIANT_UserSize(ULONG *pFlags, ULONG Start, VARIANT *pvar)
unsigned char *WINAPI LPSAFEARRAY_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, LPSAFEARRAY *ppsa)
static DWORD elem_wire_size(LPSAFEARRAY lpsa, SF_TYPE sftype)
void WINAPI LPSAFEARRAY_UserFree(ULONG *pFlags, LPSAFEARRAY *ppsa)
unsigned char *WINAPI BSTR_UserMarshal(ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
unsigned char *WINAPI BSTR_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
HRESULT WINAPI VarBstrCmp(BSTR pbstrLeft, BSTR pbstrRight, LCID lcid, DWORD dwFlags)
HRESULT WINAPI VarDecFromI4(LONG lIn, DECIMAL *pDecOut)
GLuint GLuint GLsizei GLenum const GLvoid * indices
GLboolean GLboolean GLboolean b
GLenum GLuint GLenum GLsizei const GLchar * buf
GLboolean GLenum GLenum GLvoid * values
GLfloat GLfloat GLfloat GLfloat v3
GLfloat GLfloat GLfloat v2
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
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 GLint GLint j
VOID WINAPI CoTaskMemFree(LPVOID ptr)
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
static CRYPT_DATA_BLOB b2[]
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
static void WINAPI user_free(void *p)
static TestUnknown * impl_from_IUnknown(IUnknown *iface)
static void init_user_marshal_cb(USER_MARSHAL_CB *umcb, PMIDL_STUB_MESSAGE stub_msg, PRPC_MESSAGE rpc_msg, unsigned char *buffer, unsigned int size, MSHCTX context)
static void *WINAPI user_allocate(SIZE_T size)
static void test_marshal_BSTR(void)
static SF_TYPE get_union_type(SAFEARRAY *psa)
static void * alloc_aligned(SIZE_T size, void **buf)
static void test_marshal_LPSAFEARRAY(void)
static void check_bstr(void *buffer, BSTR b)
static void check_safearray(void *buffer, LPSAFEARRAY lpsa)
static ULONG WINAPI HeapUnknown_AddRef(IUnknown *iface)
static DWORD * check_variant_header(DWORD *wirev, VARIANT *v, ULONG size)
static ULONG WINAPI HeapUnknown_Release(IUnknown *iface)
static ULONG get_cell_count(const SAFEARRAY *psa)
static HRESULT WINAPI HeapUnknown_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
static void test_marshal_VARIANT(void)
static GUID *static VARTYPE *static LCID
static const IUnknownVtbl HeapUnknown_Vtbl
static SCRIPT_CACHE SCRIPT_ANALYSIS * psa
unsigned __int3264 UINT_PTR
UINT WINAPI SysStringByteLen(BSTR str)
BSTR WINAPI SysAllocString(LPCOLESTR str)
UINT WINAPI SysStringLen(BSTR str)
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
BSTR WINAPI DECLSPEC_HOTPATCH SysAllocStringByteLen(LPCSTR str, UINT len)
#define IsEqualGUID(rguid1, rguid2)
#define IsEqualIID(riid1, riid2)
static unsigned __int64 next
#define NDR_LOCAL_DATA_REPRESENTATION
@ USER_MARSHAL_CB_BUFFER_SIZE
@ USER_MARSHAL_CB_UNMARSHALL
#define USER_MARSHAL_CB_SIGNATURE
unsigned char * BufferEnd
unsigned char * BufferStart
unsigned int BufferLength
USER_MARSHAL_CB_TYPE CBType
PMIDL_STUB_MESSAGE pStubMsg
#define CONTAINING_RECORD(address, type, field)
void WINAPI VariantInit(VARIANTARG *pVarg)