33 #if (__STDC__ && !defined(_FORCENAMELESSUNION)) || defined(NONAMELESSUNION) 34 # define V_U2(A) ((A)->n1.n2) 36 # define V_U2(A) (*(A)) 48 hr = pSafeArrayGetVartype(
psa, &
vt);
51 if(
psa->fFeatures & FADF_VARIANT)
return SF_VARIANT;
53 switch(
psa->cbElements)
63 if (
psa->fFeatures & FADF_HAVEIID)
77 case VT_R4:
return SF_I4;
93 default:
return SF_ERROR;
101 ULONG ulNumCells = 1;
115 if (sftype == SF_BSTR)
116 return sizeof(
DWORD);
123 unsigned char *wiresa =
buffer;
132 ok(*(
DWORD *)wiresa == 0,
"wiresa + 0x0 should be NULL instead of 0x%08x\n", *(
DWORD *)wiresa);
136 if (!pSafeArrayGetVartype || !pSafeArrayGetIID)
139 if(
FAILED(pSafeArrayGetVartype(lpsa, &
vt)))
145 ok(*(
DWORD *)wiresa,
"wiresa + 0x0 should be non-NULL instead of 0x%08x\n", *(
DWORD *)wiresa);
146 wiresa +=
sizeof(
DWORD);
147 ok(*(
DWORD *)wiresa == lpsa->
cDims,
"wiresa + 0x4 should be lpsa->cDims instead of 0x%08x\n", *(
DWORD *)wiresa);
148 wiresa +=
sizeof(
DWORD);
149 ok(*(
WORD *)wiresa == lpsa->
cDims,
"wiresa + 0x8 should be lpsa->cDims instead of 0x%04x\n", *(
WORD *)wiresa);
150 wiresa +=
sizeof(
WORD);
151 ok(*(
WORD *)wiresa == lpsa->
fFeatures,
"wiresa + 0xa should be lpsa->fFeatures instead of 0x%08x\n", *(
WORD *)wiresa);
152 wiresa +=
sizeof(
WORD);
154 wiresa +=
sizeof(
DWORD);
155 ok(*(
WORD *)wiresa == lpsa->
cLocks,
"wiresa + 0x10 should be lpsa->cLocks instead of 0x%04x\n", *(
WORD *)wiresa);
156 wiresa +=
sizeof(
WORD);
157 ok(*(
WORD *)wiresa ==
vt,
"wiresa + 0x12 should be %04x instead of 0x%04x\n",
vt, *(
WORD *)wiresa);
158 wiresa +=
sizeof(
WORD);
159 ok(*(
DWORD *)wiresa == sftype,
"wiresa + 0x14 should be %08x instead of 0x%08x\n", (
DWORD)sftype, *(
DWORD *)wiresa);
160 wiresa +=
sizeof(
DWORD);
161 ok(*(
DWORD *)wiresa == cell_count,
"wiresa + 0x18 should be %u instead of %u\n", cell_count, *(
DWORD *)wiresa);
162 wiresa +=
sizeof(
DWORD);
163 ok(*(
DWORD *)wiresa,
"wiresa + 0x1c should be non-zero instead of 0x%08x\n", *(
DWORD *)wiresa);
164 wiresa +=
sizeof(
DWORD);
165 if(sftype == SF_HAVEIID)
168 pSafeArrayGetIID(lpsa, &
guid);
170 wiresa +=
sizeof(
GUID);
178 "bounds mismatch for dimension %d, got (%d,%d), expected (%d,%d)\n",
i,
186 ok(*(
DWORD *)wiresa == cell_count,
"wiresa + 0x28 should be %u instead of %u\n", cell_count, *(
DWORD*)wiresa);
187 wiresa +=
sizeof(
DWORD);
193 ok(0,
"unexpected user_allocate call\n");
199 ok(0,
"unexpected user_free call\n");
212 memset(stub_msg, 0,
sizeof(*stub_msg));
218 memset(umcb, 0,
sizeof(*umcb));
238 int expected_bstr_size;
270 ok(lpsa2 !=
NULL,
"LPSAFEARRAY didn't unmarshal\n");
271 if (pSafeArrayGetVartype)
273 pSafeArrayGetVartype(lpsa, &
vt);
274 pSafeArrayGetVartype(lpsa2, &vt2);
275 ok(
vt == vt2,
"vts differ %x %x\n",
vt, vt2);
277 ok(lpsa2->
cLocks == 0,
"got lock count %u, expected 0\n", lpsa2->
cLocks);
280 ok(!lpsa2,
"lpsa2 was not set to 0 by LPSAFEARRAY_UserFree\n");
317 ok(lpsa2 !=
NULL,
"LPSAFEARRAY didn't unmarshal\n");
318 if (pSafeArrayGetVartype)
320 pSafeArrayGetVartype(lpsa, &
vt);
321 pSafeArrayGetVartype(lpsa2, &vt2);
322 ok(
vt == vt2,
"vts differ %x %x\n",
vt, vt2);
324 ok(lpsa2->
cLocks == 0,
"got lock count %u, expected 0\n", lpsa2->
cLocks);
347 ok(lpsa2 ==
NULL,
"NULL LPSAFEARRAY didn't unmarshal\n");
356 *(
double *)lpsa->
pvData = 3.1415;
361 expected = (44 + 1 + (
sizeof(
double) - 1)) & ~(
sizeof(
double) - 1);
393 if (pSafeArrayGetVartype)
395 hr = pSafeArrayGetVartype(lpsa, &
vt);
422 expected_bstr_size = 0;
427 for (
j = 0;
j <=
i;
j++)
433 ok(
hr ==
S_OK,
"Failed to put bstr element hr 0x%x\n",
hr);
434 expected_bstr_size += (
j *
sizeof(
WCHAR)) + (3 *
sizeof(
DWORD));
436 expected_bstr_size +=
sizeof(
WCHAR);
464 ok(lpsa2 !=
NULL,
"LPSAFEARRAY didn't unmarshal, result %p\n",
next);
474 ok(
hr ==
S_OK,
"Failed to get bstr element at hres 0x%x\n",
hr);
503 if (pSafeArrayGetVartype)
505 hr = pSafeArrayGetVartype(lpsa, &
vt);
535 ok(*wireb == (
len + 1) / 2,
"wv[0] %08x\n", *wireb);
538 ok(*wireb ==
len,
"wv[1] %08x\n", *wireb);
540 ok(*wireb == 0xffffffff,
"wv[1] %08x\n", *wireb);
542 ok(*wireb == (
len + 1) / 2,
"wv[2] %08x\n", *wireb);
546 ok(!
memcmp(wireb,
b, (
len + 1) & ~1),
"strings differ\n");
559 WCHAR str[] = {
'm',
'a',
'r',
's',
'h',
'a',
'l',
' ',
't',
'e',
's',
't',
'1',0};
586 ok(
b2 !=
NULL,
"BSTR didn't unmarshal\n");
609 ok(
b2 ==
NULL,
"NULL BSTR didn't unmarshal\n");
615 *(((
char*)
b) + 3) =
'd';
637 ok(
b2 !=
NULL,
"BSTR didn't unmarshal\n");
664 ok(
b2 !=
NULL,
"NULL LPSAFEARRAY didn't unmarshal\n");
688 IUnknown_AddRef(iface);
734 ok(
header->rpcReserved == 0,
"wv[1] %08x\n",
header->rpcReserved);
743 ok(
header->switch_is == switch_is,
"switch_is %08x expected %08x\n",
header->switch_is, switch_is);
771 WCHAR str[] = {
'm',
'a',
'r',
's',
'h',
'a',
'l',
' ',
't',
'e',
's',
't',0};
798 V_U2(&
v).wReserved1 = 0x1234;
799 V_U2(&
v).wReserved2 = 0x5678;
800 V_U2(&
v).wReserved3 = 0x9abc;
816 ok(*(
char*)wirev ==
V_I1(&
v),
"wv[5] %08x\n", *wirev);
842 ok(*(
short*)wirev ==
V_I2(&
v),
"wv[5] %08x\n", *wirev);
869 ok(*wirev == 0x4,
"wv[5] %08x\n", *wirev);
871 ok(*(
short*)wirev ==
s,
"wv[6] %08x\n", *wirev);
900 ok(*wirev ==
V_I4(&
v),
"wv[5] %08x\n", *wirev);
927 ok(*wirev == 0x1234,
"wv[5] %08x\n", *wirev);
954 ok(*wirev == 0x4,
"wv[5] %08x\n", *wirev);
956 ok(*wirev == ul,
"wv[6] %08x\n", *wirev);
984 ok(*wirev == 0xcccccccc,
"wv[5] %08x\n", *wirev);
1013 ok(*(
float*)wirev ==
V_R4(&
v),
"wv[5] %08x\n", *wirev);
1040 ok(*wirev == 0xcccccccc,
"wv[5] %08x\n", *wirev);
1042 ok(*(
double*)wirev ==
V_R8(&
v),
"wv[6] %08x, wv[7] %08x\n", *wirev, *(wirev+1));
1069 ok(*wirev == 8,
"wv[5] %08x\n", *wirev);
1071 ok(*(
double*)wirev ==
d,
"wv[6] %08x wv[7] %08x\n", *wirev, *(wirev+1));
1097 ok(*(
short*)wirev ==
V_BOOL(&
v),
"wv[5] %04x\n", *(
WORD*)wirev);
1110 dec.wReserved = 0xfedc;
1126 ok(*wirev == 0xcccccccc,
"wirev[5] %08x\n", *wirev);
1130 ok(!
memcmp(wirev, &dec2,
sizeof(dec2)),
"wirev[6] %08x wirev[7] %08x wirev[8] %08x wirev[9] %08x\n",
1131 *wirev, *(wirev + 1), *(wirev + 2), *(wirev + 3));
1157 ok(*wirev == 16,
"wv[5] %08x\n", *wirev);
1159 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));
1164 V_U2(&
v2).wReserved1 = 0x0123;
1165 V_U2(&
v2).wReserved2 = 0x4567;
1166 V_U2(&
v2).wReserved3 = 0x89ab;
1238 ok(*wirev,
"wv[5] %08x\n", *wirev);
1266 ok(*wirev == 0x4,
"wv[5] %08x\n", *wirev);
1268 ok(*wirev,
"wv[6] %08x\n", *wirev);
1280 ok(
mem ==
b2,
"BSTR should be reused\n");
1312 ok(*wirev,
"wv[5] %08x\n", *wirev);
1323 ok(bound == bound2,
"array lbounds differ\n");
1326 ok(bound == bound2,
"array ubounds differ\n");
1327 if (pSafeArrayGetVartype)
1330 pSafeArrayGetVartype(
V_ARRAY(&
v2), &vt2);
1331 ok(
vt == vt2,
"array vts differ %x %x\n",
vt, vt2);
1352 ok(*wirev == 4,
"wv[5] %08x\n", *wirev);
1354 ok(*wirev,
"wv[6] %08x\n", *wirev);
1365 ok(bound == bound2,
"array lbounds differ\n");
1368 ok(bound == bound2,
"array ubounds differ\n");
1369 if (pSafeArrayGetVartype)
1373 ok(
vt == vt2,
"array vts differ %x %x\n",
vt, vt2);
1395 ok(*wirev == 4,
"wv[5] %08x\n", *wirev);
1397 ok(*wirev,
"wv[6] %08x\n", *wirev);
1410 ok(lpsa2 == lpsa_copy,
"safearray should be reused\n");
1411 ok(
mem == lpsa2->
pvData,
"safearray data should be reused\n");
1415 ok(bound == bound2,
"array lbounds differ\n");
1418 ok(bound == bound2,
"array ubounds differ\n");
1419 if (pSafeArrayGetVartype)
1423 ok(
vt == vt2,
"array vts differ %x %x\n",
vt, vt2);
1451 ok(*wirev ==
sizeof(
VARIANT),
"wv[5] %08x\n", *wirev);
1453 ok(*wirev == (
'U' |
's' << 8 |
'e' << 16 |
'r' << 24),
"wv[6] %08x\n", *wirev);
1455 ok(*wirev == 0xcccccccc,
"wv[7] %08x\n", *wirev);
1458 ok(*wirev == 0xcccccccc,
"wv[13] %08x\n", *wirev);
1460 ok(*(
double*)wirev ==
V_R8(&
v2),
"wv[6] %08x wv[7] %08x\n", *wirev, *(wirev+1));
1475 heap_unknown->
refs = 1;
1488 ok(heap_unknown->
refs == 2,
"got refcount %d\n", heap_unknown->
refs);
1495 ok(*wirev ==
next -
buffer - 0x20,
"wv[6] %08x\n", *wirev);
1497 ok(*wirev ==
next -
buffer - 0x20,
"wv[7] %08x\n", *wirev);
1499 ok(*wirev == 0x574f454d,
"wv[8] %08x\n", *wirev);
1506 ok(heap_unknown->
refs == 3,
"got refcount %d\n", heap_unknown->
refs);
1511 ok(heap_unknown->
refs == 1,
"%d refcounts of IUnknown leaked\n", heap_unknown->
refs - 1);
1528 ok(*wirev == 0,
"wv[5] %08x\n", *wirev);
1541 heap_unknown->
refs = 1;
1552 ok(heap_unknown->
refs == 1,
"got refcount %d\n", heap_unknown->
refs);
1555 ok(heap_unknown->
refs == 2,
"got refcount %d\n", heap_unknown->
refs);
1559 ok(*wirev == 4,
"wv[5] %08x\n", *wirev);
1562 *wirev == (
DWORD_PTR)heap_unknown + 1 ,
"wv[6] %08x\n", *wirev);
1564 ok(*wirev ==
next -
buffer - 0x24,
"wv[7] %08x\n", *wirev);
1566 ok(*wirev ==
next -
buffer - 0x24,
"wv[8] %08x\n", *wirev);
1568 ok(*wirev == 0x574f454d,
"wv[9] %08x\n", *wirev);
1576 ok(heap_unknown->
refs == 2,
"got refcount %d\n", heap_unknown->
refs);
1580 ok(heap_unknown->
refs == 1,
"%d refcounts of IUnknown leaked\n", heap_unknown->
refs - 1);
1599 ok(*wirev == 4,
"wv[5] %08x\n", *wirev);
1615 #define GETPTR(func) p##func = (void*)GetProcAddress(hOleaut32, #func) 1621 if (!pSafeArrayGetIID || !pSafeArrayGetVartype)
1622 win_skip(
"SafeArrayGetIID and/or SafeArrayGetVartype is not available, some tests will be skipped\n");
unsigned __int3264 UINT_PTR
UINT WINAPI SafeArrayGetDim(SAFEARRAY *psa)
GLuint GLuint GLsizei GLenum const GLvoid * indices
struct tagVARIANT VARIANT
static void check_bstr(void *buffer, BSTR b)
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
VOID WINAPI CoTaskMemFree(LPVOID ptr)
static ULONG get_cell_count(const SAFEARRAY *psa)
unsigned char *WINAPI BSTR_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
static GUID *static VARTYPE *static ULONG
static void check_safearray(void *buffer, LPSAFEARRAY lpsa)
static ULONG WINAPI HeapUnknown_AddRef(IUnknown *iface)
static void test_marshal_LPSAFEARRAY(void)
GLboolean GLenum GLenum GLvoid * values
ios_base &_STLP_CALL dec(ios_base &__s)
static GUID *static VARTYPE *static LCID
UINT WINAPI SysStringByteLen(BSTR str)
HRESULT WINAPI SafeArrayGetElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData)
void WINAPI VariantInit(VARIANTARG *pVarg)
ULONG WINAPI LPSAFEARRAY_UserSize(ULONG *pFlags, ULONG StartingSize, LPSAFEARRAY *ppsa)
unsigned char *WINAPI VARIANT_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, VARIANT *pvar)
unsigned int BufferLength
GLenum GLuint GLenum GLsizei const GLchar * buf
static GUID *static VARTYPE *static BSTR
static const IUnknownVtbl HeapUnknown_Vtbl
static HRESULT(WINAPI *pSafeArrayGetIID)(SAFEARRAY *
void WINAPI LPSAFEARRAY_UserFree(ULONG *pFlags, LPSAFEARRAY *ppsa)
static HRESULT WINAPI HeapUnknown_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
unsigned char *WINAPI VARIANT_UserMarshal(ULONG *pFlags, unsigned char *Buffer, VARIANT *pvar)
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
BSTR WINAPI SysAllocString(LPCOLESTR str)
static DWORD elem_wire_size(LPSAFEARRAY lpsa, SF_TYPE sftype)
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)
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
ULONG WINAPI BSTR_UserSize(ULONG *pFlags, ULONG Start, BSTR *pstr)
BSTR WINAPI DECLSPEC_HOTPATCH SysAllocStringByteLen(LPCSTR str, UINT len)
void WINAPI BSTR_UserFree(ULONG *pFlags, BSTR *pstr)
struct tagSAFEARRAYBOUND SAFEARRAYBOUND
GLboolean GLboolean GLboolean b
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
HRESULT WINAPI SafeArrayGetLBound(SAFEARRAY *psa, UINT nDim, LONG *plLbound)
HRESULT WINAPI SafeArrayAllocData(SAFEARRAY *psa)
unsigned __int3264 UINT_PTR
static REFPROPVARIANT PROPVAR_CHANGE_FLAGS VARTYPE vt
unsigned char * BufferStart
HRESULT WINAPI SafeArrayDestroy(SAFEARRAY *psa)
HRESULT WINAPI VarBstrCmp(BSTR pbstrLeft, BSTR pbstrRight, LCID lcid, DWORD dwFlags)
unsigned char * BufferEnd
unsigned char *WINAPI BSTR_UserMarshal(ULONG *pFlags, unsigned char *Buffer, BSTR *pstr)
static SF_TYPE get_union_type(SAFEARRAY *psa)
#define InterlockedDecrement
void WINAPI VARIANT_UserFree(ULONG *pFlags, VARIANT *pvar)
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
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)
UINT WINAPI SysStringLen(BSTR str)
unsigned char *WINAPI LPSAFEARRAY_UserMarshal(ULONG *pFlags, unsigned char *Buffer, LPSAFEARRAY *ppsa)
GLfloat GLfloat GLfloat GLfloat v3
HRESULT WINAPI SafeArrayDestroyData(SAFEARRAY *psa)
static ULONG WINAPI HeapUnknown_Release(IUnknown *iface)
GLfloat GLfloat GLfloat v2
HRESULT WINAPI SafeArrayDestroyDescriptor(SAFEARRAY *psa)
static DWORD * check_variant_header(DWORD *wirev, VARIANT *v, ULONG size)
USER_MARSHAL_CB_TYPE CBType
SAFEARRAY *WINAPI SafeArrayCreate(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsabound)
HRESULT WINAPI SafeArrayGetIID(SAFEARRAY *psa, GUID *pGuid)
HRESULT WINAPI SafeArrayGetUBound(SAFEARRAY *psa, UINT nDim, LONG *plUbound)
#define NDR_LOCAL_DATA_REPRESENTATION
static unsigned __int64 next
#define InterlockedIncrement
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
#define USER_MARSHAL_CB_SIGNATURE
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
HRESULT WINAPI SafeArrayGetVartype(SAFEARRAY *psa, VARTYPE *pvt)
unsigned char *WINAPI LPSAFEARRAY_UserUnmarshal(ULONG *pFlags, unsigned char *Buffer, LPSAFEARRAY *ppsa)
HRESULT WINAPI VarDecFromI4(LONG lIn, DECIMAL *pDecOut)
static SCRIPT_CACHE SCRIPT_ANALYSIS * psa
HRESULT WINAPI CoInitialize(LPVOID lpReserved)
static void test_marshal_BSTR(void)
HRESULT WINAPI SafeArrayPutElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData)
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
static void WINAPI user_free(void *p)
PMIDL_STUB_MESSAGE pStubMsg
static CRYPT_DATA_BLOB b2[]
HRESULT WINAPI SafeArrayAllocDescriptor(UINT cDims, SAFEARRAY **ppsaOut)
static void test_marshal_VARIANT(void)
static void *WINAPI user_allocate(SIZE_T size)
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
#define HeapFree(x, y, z)
static HeapUnknown * impl_from_IUnknown(IUnknown *iface)
#define IsEqualIID(riid1, riid2)
ULONG WINAPI VARIANT_UserSize(ULONG *pFlags, ULONG Start, VARIANT *pvar)
static void * alloc_aligned(SIZE_T size, void **buf)