1 /*************************************************************************
2 * OLE Automation - SafeArray
4 * This file contains the implementation of the SafeArray functions.
6 * Copyright 1999 Sylvain St-Germain
7 * Copyright 2002-2003 Marcus Meissner
8 * Copyright 2003 Jon Griffiths
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 /* Memory Layout of a SafeArray:
26 * -0x10: start of memory.
27 * -0x10: GUID for VT_DISPATCH and VT_UNKNOWN safearrays (if FADF_HAVEIID)
28 * -0x04: DWORD varianttype; (for all others, except VT_RECORD) (if FADF_HAVEVARTYPE)
29 * -0x4: IRecordInfo* iface; (if FADF_RECORD, for VT_RECORD (can be NULL))
31 * 0x10: SAFEARRAYBOUNDS[0...]
46 #include "wine/debug.h"
48 WINE_DEFAULT_DEBUG_CHANNEL(variant
);
50 /************************************************************************
51 * SafeArray {OLEAUT32}
54 * The SafeArray data type provides the underlying interface for Ole
55 * Automations arrays, used for example to represent array types in
56 * Visual Basic(tm) and to gather user defined parameters for invocation through
57 * an IDispatch interface.
59 * Safe arrays provide bounds checking and automatically manage the data
60 * types they contain, for example handing reference counting and copying
61 * of interface pointers. User defined types can be stored in arrays
62 * using the IRecordInfo interface.
64 * There are two types of SafeArray, normal and vectors. Normal arrays can have
65 * multiple dimensions and the data for the array is allocated separately from
66 * the array header. This is the most flexible type of array. Vectors, on the
67 * other hand, are fixed in size and consist of a single allocated block, and a
71 * The following types of data can be stored within a SafeArray.
73 *| VT_I1, VT_UI1, VT_I2, VT_UI2, VT_I4, VT_UI4, VT_I8, VT_UI8, VT_INT, VT_UINT,
74 *| VT_R4, VT_R8, VT_CY, VT_DECIMAL
76 *| VT_DISPATCH, VT_UNKNOWN, VT_RECORD
78 *| VT_VARIANT, VT_INT_PTR, VT_UINT_PTR, VT_BOOL, VT_ERROR, VT_DATE, VT_BSTR
85 /* Undocumented hidden space before the start of a SafeArray descriptor */
86 #define SAFEARRAY_HIDDEN_SIZE sizeof(GUID)
89 static inline LPVOID
SAFEARRAY_Malloc(ULONG ulSize
)
91 /* FIXME: Memory should be allocated and freed using a per-thread IMalloc
92 * instance returned from CoGetMalloc().
94 return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, ulSize
);
98 static inline BOOL
SAFEARRAY_Free(LPVOID lpData
)
100 return HeapFree(GetProcessHeap(), 0, lpData
);
103 /* Get the size of a supported VT type (0 means unsupported) */
104 static DWORD
SAFEARRAY_GetVTSize(VARTYPE vt
)
109 case VT_UI1
: return sizeof(BYTE
);
112 case VT_UI2
: return sizeof(SHORT
);
116 case VT_ERROR
: return sizeof(LONG
);
119 case VT_UI8
: return sizeof(LONG64
);
121 case VT_UINT
: return sizeof(INT
);
123 case VT_UINT_PTR
: return sizeof(UINT_PTR
);
124 case VT_CY
: return sizeof(CY
);
125 case VT_DATE
: return sizeof(DATE
);
126 case VT_BSTR
: return sizeof(BSTR
);
127 case VT_DISPATCH
: return sizeof(LPDISPATCH
);
128 case VT_VARIANT
: return sizeof(VARIANT
);
129 case VT_UNKNOWN
: return sizeof(LPUNKNOWN
);
130 case VT_DECIMAL
: return sizeof(DECIMAL
);
131 /* Note: Return a non-zero size to indicate vt is valid. The actual size
132 * of a UDT is taken from the result of IRecordInfo_GetSize().
134 case VT_RECORD
: return 32;
139 /* Set the hidden data for an array */
140 static inline void SAFEARRAY_SetHiddenDWORD(SAFEARRAY
* psa
, DWORD dw
)
142 /* Implementation data is stored in the 4 bytes before the header */
143 LPDWORD lpDw
= (LPDWORD
)psa
;
147 /* Get the hidden data from an array */
148 static inline DWORD
SAFEARRAY_GetHiddenDWORD(SAFEARRAY
* psa
)
150 LPDWORD lpDw
= (LPDWORD
)psa
;
154 /* Get the number of cells in a SafeArray */
155 static ULONG
SAFEARRAY_GetCellCount(const SAFEARRAY
*psa
)
157 const SAFEARRAYBOUND
* psab
= psa
->rgsabound
;
158 USHORT cCount
= psa
->cDims
;
159 ULONG ulNumCells
= 1;
163 /* This is a valid bordercase. See testcases. -Marcus */
164 if (!psab
->cElements
)
166 ulNumCells
*= psab
->cElements
;
172 /* Allocate a descriptor for an array */
173 static HRESULT
SAFEARRAY_AllocDescriptor(ULONG ulSize
, SAFEARRAY
**ppsaOut
)
175 *ppsaOut
= (SAFEARRAY
*)((char*)SAFEARRAY_Malloc(ulSize
+ SAFEARRAY_HIDDEN_SIZE
) + SAFEARRAY_HIDDEN_SIZE
);
183 /* Set the features of an array */
184 static void SAFEARRAY_SetFeatures(VARTYPE vt
, SAFEARRAY
*psa
)
186 /* Set the IID if we have one, otherwise set the type */
187 if (vt
== VT_DISPATCH
)
189 psa
->fFeatures
= FADF_HAVEIID
;
190 SafeArraySetIID(psa
, &IID_IDispatch
);
192 else if (vt
== VT_UNKNOWN
)
194 psa
->fFeatures
= FADF_HAVEIID
;
195 SafeArraySetIID(psa
, &IID_IUnknown
);
197 else if (vt
== VT_RECORD
)
198 psa
->fFeatures
= FADF_RECORD
;
201 psa
->fFeatures
= FADF_HAVEVARTYPE
;
202 SAFEARRAY_SetHiddenDWORD(psa
, vt
);
206 /* Create an array */
207 static SAFEARRAY
* SAFEARRAY_Create(VARTYPE vt
, UINT cDims
, const SAFEARRAYBOUND
*rgsabound
, ULONG ulSize
)
209 SAFEARRAY
*psa
= NULL
;
215 if (SUCCEEDED(SafeArrayAllocDescriptorEx(vt
, cDims
, &psa
)))
219 case VT_BSTR
: psa
->fFeatures
|= FADF_BSTR
; break;
220 case VT_UNKNOWN
: psa
->fFeatures
|= FADF_UNKNOWN
; break;
221 case VT_DISPATCH
: psa
->fFeatures
|= FADF_DISPATCH
; break;
222 case VT_VARIANT
: psa
->fFeatures
|= FADF_VARIANT
; break;
225 for (i
= 0; i
< cDims
; i
++)
226 memcpy(psa
->rgsabound
+ i
, rgsabound
+ cDims
- 1 - i
, sizeof(SAFEARRAYBOUND
));
229 psa
->cbElements
= ulSize
;
231 if (!psa
->cbElements
|| FAILED(SafeArrayAllocData(psa
)))
233 SafeArrayDestroyDescriptor(psa
);
240 /* Create an array as a vector */
241 static SAFEARRAY
* SAFEARRAY_CreateVector(VARTYPE vt
, LONG lLbound
, ULONG cElements
, ULONG ulSize
)
243 SAFEARRAY
*psa
= NULL
;
245 if (ulSize
|| (vt
== VT_RECORD
))
247 /* Allocate the header and data together */
248 if (SUCCEEDED(SAFEARRAY_AllocDescriptor(sizeof(SAFEARRAY
) + ulSize
* cElements
, &psa
)))
250 SAFEARRAY_SetFeatures(vt
, psa
);
253 psa
->fFeatures
|= FADF_CREATEVECTOR
;
254 psa
->pvData
= &psa
[1]; /* Data follows the header */
255 psa
->cbElements
= ulSize
;
256 psa
->rgsabound
[0].cElements
= cElements
;
257 psa
->rgsabound
[0].lLbound
= lLbound
;
261 case VT_BSTR
: psa
->fFeatures
|= FADF_BSTR
; break;
262 case VT_UNKNOWN
: psa
->fFeatures
|= FADF_UNKNOWN
; break;
263 case VT_DISPATCH
: psa
->fFeatures
|= FADF_DISPATCH
; break;
264 case VT_VARIANT
: psa
->fFeatures
|= FADF_VARIANT
; break;
271 /* Free data items in an array */
272 static HRESULT
SAFEARRAY_DestroyData(SAFEARRAY
*psa
, ULONG ulStartCell
)
274 if (psa
->pvData
&& !(psa
->fFeatures
& FADF_DATADELETED
))
276 ULONG ulCellCount
= SAFEARRAY_GetCellCount(psa
);
278 if (ulStartCell
> ulCellCount
) {
279 FIXME("unexpted ulcellcount %d, start %d\n",ulCellCount
,ulStartCell
);
283 ulCellCount
-= ulStartCell
;
285 if (psa
->fFeatures
& (FADF_UNKNOWN
|FADF_DISPATCH
))
287 LPUNKNOWN
*lpUnknown
= (LPUNKNOWN
*)psa
->pvData
+ ulStartCell
;
292 IUnknown_Release(*lpUnknown
);
296 else if (psa
->fFeatures
& (FADF_RECORD
))
298 IRecordInfo
*lpRecInfo
;
300 if (SUCCEEDED(SafeArrayGetRecordInfo(psa
, &lpRecInfo
)))
302 PBYTE pRecordData
= (PBYTE
)psa
->pvData
;
305 IRecordInfo_RecordClear(lpRecInfo
, pRecordData
);
306 pRecordData
+= psa
->cbElements
;
308 IRecordInfo_Release(lpRecInfo
);
311 else if (psa
->fFeatures
& FADF_BSTR
)
313 BSTR
* lpBstr
= (BSTR
*)psa
->pvData
+ ulStartCell
;
318 SysFreeString(*lpBstr
);
322 else if (psa
->fFeatures
& FADF_VARIANT
)
324 VARIANT
* lpVariant
= (VARIANT
*)psa
->pvData
+ ulStartCell
;
328 HRESULT hRet
= VariantClear(lpVariant
);
330 if (FAILED(hRet
)) FIXME("VariantClear of element failed!\n");
338 /* Copy data items from one array to another */
339 static HRESULT
SAFEARRAY_CopyData(SAFEARRAY
*psa
, SAFEARRAY
*dest
)
343 else if (!dest
->pvData
|| psa
->fFeatures
& FADF_DATADELETED
)
347 ULONG ulCellCount
= SAFEARRAY_GetCellCount(psa
);
349 dest
->fFeatures
= (dest
->fFeatures
& FADF_CREATEVECTOR
) |
350 (psa
->fFeatures
& ~(FADF_CREATEVECTOR
|FADF_DATADELETED
));
352 if (psa
->fFeatures
& FADF_VARIANT
)
354 VARIANT
* lpVariant
= (VARIANT
*)psa
->pvData
;
355 VARIANT
* lpDest
= (VARIANT
*)dest
->pvData
;
361 hRet
= VariantCopy(lpDest
, lpVariant
);
362 if (FAILED(hRet
)) FIXME("VariantCopy failed with 0x%x\n", hRet
);
367 else if (psa
->fFeatures
& FADF_BSTR
)
369 BSTR
* lpBstr
= (BSTR
*)psa
->pvData
;
370 BSTR
* lpDest
= (BSTR
*)dest
->pvData
;
376 *lpDest
= SysAllocStringByteLen((char*)*lpBstr
, SysStringByteLen(*lpBstr
));
378 return E_OUTOFMEMORY
;
388 /* Copy the data over */
389 memcpy(dest
->pvData
, psa
->pvData
, ulCellCount
* psa
->cbElements
);
391 if (psa
->fFeatures
& (FADF_UNKNOWN
|FADF_DISPATCH
))
393 LPUNKNOWN
*lpUnknown
= (LPUNKNOWN
*)dest
->pvData
;
398 IUnknown_AddRef(*lpUnknown
);
404 if (psa
->fFeatures
& FADF_RECORD
)
406 IRecordInfo
* pRecInfo
= NULL
;
408 SafeArrayGetRecordInfo(psa
, &pRecInfo
);
409 SafeArraySetRecordInfo(dest
, pRecInfo
);
413 /* Release because Get() adds a reference */
414 IRecordInfo_Release(pRecInfo
);
417 else if (psa
->fFeatures
& FADF_HAVEIID
)
420 SafeArrayGetIID(psa
, &guid
);
421 SafeArraySetIID(dest
, &guid
);
423 else if (psa
->fFeatures
& FADF_HAVEVARTYPE
)
425 SAFEARRAY_SetHiddenDWORD(dest
, SAFEARRAY_GetHiddenDWORD(psa
));
431 /*************************************************************************
432 * SafeArrayAllocDescriptor (OLEAUT32.36)
434 * Allocate and initialise a descriptor for a SafeArray.
437 * cDims [I] Number of dimensions of the array
438 * ppsaOut [O] Destination for new descriptor
441 * Success: S_OK. ppsaOut is filled with a newly allocated descriptor.
442 * Failure: An HRESULT error code indicating the error.
447 HRESULT WINAPI
SafeArrayAllocDescriptor(UINT cDims
, SAFEARRAY
**ppsaOut
)
451 TRACE("(%d,%p)\n", cDims
, ppsaOut
);
453 if (!cDims
|| cDims
>= 0x10000) /* Maximum 65535 dimensions */
459 /* We need enough space for the header and its bounds */
460 allocSize
= sizeof(SAFEARRAY
) + sizeof(SAFEARRAYBOUND
) * (cDims
- 1);
462 if (FAILED(SAFEARRAY_AllocDescriptor(allocSize
, ppsaOut
)))
465 (*ppsaOut
)->cDims
= cDims
;
467 TRACE("(%d): %u bytes allocated for descriptor.\n", cDims
, allocSize
);
471 /*************************************************************************
472 * SafeArrayAllocDescriptorEx (OLEAUT32.41)
474 * Allocate and initialise a descriptor for a SafeArray of a given type.
477 * vt [I] The type of items to store in the array
478 * cDims [I] Number of dimensions of the array
479 * ppsaOut [O] Destination for new descriptor
482 * Success: S_OK. ppsaOut is filled with a newly allocated descriptor.
483 * Failure: An HRESULT error code indicating the error.
486 * - This function does not chack that vt is an allowed VARTYPE.
487 * - Unlike SafeArrayAllocDescriptor(), vt is associated with the array.
490 HRESULT WINAPI
SafeArrayAllocDescriptorEx(VARTYPE vt
, UINT cDims
, SAFEARRAY
**ppsaOut
)
493 HRESULT hRet
= E_UNEXPECTED
;
495 TRACE("(%d->%s,%d,%p)\n", vt
, debugstr_vt(vt
), cDims
, ppsaOut
);
497 cbElements
= SAFEARRAY_GetVTSize(vt
);
499 WARN("Creating a descriptor with an invalid VARTYPE!\n");
501 hRet
= SafeArrayAllocDescriptor(cDims
, ppsaOut
);
505 SAFEARRAY_SetFeatures(vt
, *ppsaOut
);
506 (*ppsaOut
)->cbElements
= cbElements
;
511 /*************************************************************************
512 * SafeArrayAllocData (OLEAUT32.37)
514 * Allocate the data area of a SafeArray.
517 * psa [I] SafeArray to allocate the data area of.
520 * Success: S_OK. The data area is allocated and initialised.
521 * Failure: An HRESULT error code indicating the error.
526 HRESULT WINAPI
SafeArrayAllocData(SAFEARRAY
*psa
)
528 HRESULT hRet
= E_INVALIDARG
;
530 TRACE("(%p)\n", psa
);
534 ULONG ulSize
= SAFEARRAY_GetCellCount(psa
);
536 psa
->pvData
= SAFEARRAY_Malloc(ulSize
* psa
->cbElements
);
541 TRACE("%u bytes allocated for data at %p (%u objects).\n",
542 ulSize
* psa
->cbElements
, psa
->pvData
, ulSize
);
545 hRet
= E_OUTOFMEMORY
;
550 /*************************************************************************
551 * SafeArrayCreate (OLEAUT32.15)
553 * Create a new SafeArray.
556 * vt [I] Type to store in the safe array
557 * cDims [I] Number of array dimensions
558 * rgsabound [I] Bounds of the array dimensions
561 * Success: A pointer to a new array object.
562 * Failure: NULL, if any parameter is invalid or memory allocation fails.
565 * Win32 allows arrays with 0 sized dimensions. This bug is not reproduced
566 * in the Wine implementation.
569 SAFEARRAY
* WINAPI
SafeArrayCreate(VARTYPE vt
, UINT cDims
, SAFEARRAYBOUND
*rgsabound
)
571 TRACE("(%d->%s,%d,%p)\n", vt
, debugstr_vt(vt
), cDims
, rgsabound
);
576 return SAFEARRAY_Create(vt
, cDims
, rgsabound
, 0);
579 /*************************************************************************
580 * SafeArrayCreateEx (OLEAUT32.15)
582 * Create a new SafeArray.
585 * vt [I] Type to store in the safe array
586 * cDims [I] Number of array dimensions
587 * rgsabound [I] Bounds of the array dimensions
588 * pvExtra [I] Extra data
591 * Success: A pointer to a new array object.
592 * Failure: NULL, if any parameter is invalid or memory allocation fails.
597 SAFEARRAY
* WINAPI
SafeArrayCreateEx(VARTYPE vt
, UINT cDims
, SAFEARRAYBOUND
*rgsabound
, LPVOID pvExtra
)
600 IRecordInfo
* iRecInfo
= (IRecordInfo
*)pvExtra
;
603 TRACE("(%d->%s,%d,%p,%p)\n", vt
, debugstr_vt(vt
), cDims
, rgsabound
, pvExtra
);
609 IRecordInfo_GetSize(iRecInfo
, &ulSize
);
611 psa
= SAFEARRAY_Create(vt
, cDims
, rgsabound
, ulSize
);
618 SafeArraySetRecordInfo(psa
, pvExtra
);
622 SafeArraySetIID(psa
, pvExtra
);
629 /************************************************************************
630 * SafeArrayCreateVector (OLEAUT32.411)
632 * Create a one dimensional, contiguous SafeArray.
635 * vt [I] Type to store in the safe array
636 * lLbound [I] Lower bound of the array
637 * cElements [I] Number of elements in the array
640 * Success: A pointer to a new array object.
641 * Failure: NULL, if any parameter is invalid or memory allocation fails.
646 SAFEARRAY
* WINAPI
SafeArrayCreateVector(VARTYPE vt
, LONG lLbound
, ULONG cElements
)
648 TRACE("(%d->%s,%d,%d\n", vt
, debugstr_vt(vt
), lLbound
, cElements
);
653 return SAFEARRAY_CreateVector(vt
, lLbound
, cElements
, SAFEARRAY_GetVTSize(vt
));
656 /************************************************************************
657 * SafeArrayCreateVectorEx (OLEAUT32.411)
659 * Create a one dimensional, contiguous SafeArray.
662 * vt [I] Type to store in the safe array
663 * lLbound [I] Lower bound of the array
664 * cElements [I] Number of elements in the array
665 * pvExtra [I] Extra data
668 * Success: A pointer to a new array object.
669 * Failure: NULL, if any parameter is invalid or memory allocation fails.
674 SAFEARRAY
* WINAPI
SafeArrayCreateVectorEx(VARTYPE vt
, LONG lLbound
, ULONG cElements
, LPVOID pvExtra
)
677 IRecordInfo
* iRecInfo
= (IRecordInfo
*)pvExtra
;
680 TRACE("(%d->%s,%d,%d,%p\n", vt
, debugstr_vt(vt
), lLbound
, cElements
, pvExtra
);
686 IRecordInfo_GetSize(iRecInfo
, &ulSize
);
689 ulSize
= SAFEARRAY_GetVTSize(vt
);
691 psa
= SAFEARRAY_CreateVector(vt
, lLbound
, cElements
, ulSize
);
698 SafeArraySetRecordInfo(psa
, iRecInfo
);
702 SafeArraySetIID(psa
, pvExtra
);
709 /*************************************************************************
710 * SafeArrayDestroyDescriptor (OLEAUT32.38)
712 * Destroy a SafeArray.
715 * psa [I] SafeArray to destroy.
718 * Success: S_OK. The resources used by the array are freed.
719 * Failure: An HRESULT error code indicating the error.
724 HRESULT WINAPI
SafeArrayDestroyDescriptor(SAFEARRAY
*psa
)
726 TRACE("(%p)\n", psa
);
730 LPVOID lpv
= (char*)psa
- SAFEARRAY_HIDDEN_SIZE
;
733 return DISP_E_ARRAYISLOCKED
; /* Can't destroy a locked array */
735 if (psa
->fFeatures
& FADF_RECORD
)
736 SafeArraySetRecordInfo(psa
, NULL
);
738 if (psa
->fFeatures
& FADF_CREATEVECTOR
&&
739 !(psa
->fFeatures
& FADF_DATADELETED
))
740 SAFEARRAY_DestroyData(psa
, 0); /* Data not previously deleted */
742 if (!SAFEARRAY_Free(lpv
))
748 /*************************************************************************
749 * SafeArrayLock (OLEAUT32.21)
751 * Increment the lock counter of a SafeArray.
754 * psa [O] SafeArray to lock
757 * Success: S_OK. The array lock is incremented.
758 * Failure: E_INVALIDARG if psa is NULL, or E_UNEXPECTED if too many locks
759 * are held on the array at once.
762 * In Win32 these locks are not thread safe.
765 HRESULT WINAPI
SafeArrayLock(SAFEARRAY
*psa
)
769 TRACE("(%p)\n", psa
);
774 ulLocks
= InterlockedIncrement( (LONG
*) &psa
->cLocks
);
776 if (ulLocks
> 0xffff) /* Maximum of 16384 locks at a time */
778 WARN("Out of locks!\n");
779 InterlockedDecrement( (LONG
*) &psa
->cLocks
);
785 /*************************************************************************
786 * SafeArrayUnlock (OLEAUT32.22)
788 * Decrement the lock counter of a SafeArray.
791 * psa [O] SafeArray to unlock
794 * Success: S_OK. The array lock is decremented.
795 * Failure: E_INVALIDARG if psa is NULL, or E_UNEXPECTED if no locks are
801 HRESULT WINAPI
SafeArrayUnlock(SAFEARRAY
*psa
)
803 TRACE("(%p)\n", psa
);
808 if (InterlockedDecrement( (LONG
*) &psa
->cLocks
) < 0)
810 WARN("Unlocked but no lock held!\n");
811 InterlockedIncrement( (LONG
*) &psa
->cLocks
);
817 /*************************************************************************
818 * SafeArrayPutElement (OLEAUT32.26)
820 * Put an item into a SafeArray.
823 * psa [I] SafeArray to insert into
824 * rgIndices [I] Indices to insert at
825 * pvData [I] Data to insert
828 * Success: S_OK. The item is inserted
829 * Failure: An HRESULT error code indicating the error.
834 HRESULT WINAPI
SafeArrayPutElement(SAFEARRAY
*psa
, LONG
*rgIndices
, void *pvData
)
838 TRACE("(%p,%p,%p)\n", psa
, rgIndices
, pvData
);
840 if (!psa
|| !rgIndices
)
843 hRet
= SafeArrayLock(psa
);
849 hRet
= SafeArrayPtrOfIndex(psa
, rgIndices
, &lpvDest
);
853 if (psa
->fFeatures
& FADF_VARIANT
)
855 VARIANT
* lpVariant
= (VARIANT
*)pvData
;
856 VARIANT
* lpDest
= (VARIANT
*)lpvDest
;
858 hRet
= VariantClear(lpDest
);
859 if (FAILED(hRet
)) FIXME("VariantClear failed with 0x%x\n", hRet
);
860 hRet
= VariantCopy(lpDest
, lpVariant
);
861 if (FAILED(hRet
)) FIXME("VariantCopy failed with 0x%x\n", hRet
);
863 else if (psa
->fFeatures
& FADF_BSTR
)
865 BSTR lpBstr
= (BSTR
)pvData
;
866 BSTR
* lpDest
= (BSTR
*)lpvDest
;
869 SysFreeString(*lpDest
);
871 *lpDest
= SysAllocStringByteLen((char*)lpBstr
, SysStringByteLen(lpBstr
));
873 hRet
= E_OUTOFMEMORY
;
877 if (psa
->fFeatures
& (FADF_UNKNOWN
|FADF_DISPATCH
))
879 LPUNKNOWN lpUnknown
= (LPUNKNOWN
)pvData
;
880 LPUNKNOWN
*lpDest
= (LPUNKNOWN
*)lpvDest
;
883 IUnknown_AddRef(lpUnknown
);
885 IUnknown_Release(*lpDest
);
888 /* Copy the data over */
889 memcpy(lpvDest
, pvData
, psa
->cbElements
);
893 SafeArrayUnlock(psa
);
899 /*************************************************************************
900 * SafeArrayGetElement (OLEAUT32.25)
902 * Get an item from a SafeArray.
905 * psa [I] SafeArray to get from
906 * rgIndices [I] Indices to get from
907 * pvData [O] Destination for data
910 * Success: S_OK. The item data is returned in pvData.
911 * Failure: An HRESULT error code indicating the error.
916 HRESULT WINAPI
SafeArrayGetElement(SAFEARRAY
*psa
, LONG
*rgIndices
, void *pvData
)
920 TRACE("(%p,%p,%p)\n", psa
, rgIndices
, pvData
);
922 if (!psa
|| !rgIndices
|| !pvData
)
925 hRet
= SafeArrayLock(psa
);
931 hRet
= SafeArrayPtrOfIndex(psa
, rgIndices
, &lpvSrc
);
935 if (psa
->fFeatures
& FADF_VARIANT
)
937 VARIANT
* lpVariant
= (VARIANT
*)lpvSrc
;
938 VARIANT
* lpDest
= (VARIANT
*)pvData
;
940 /* The original content of pvData is ignored. */
941 V_VT(lpDest
) = VT_EMPTY
;
942 hRet
= VariantCopy(lpDest
, lpVariant
);
943 if (FAILED(hRet
)) FIXME("VariantCopy failed with 0x%x\n", hRet
);
945 else if (psa
->fFeatures
& FADF_BSTR
)
947 BSTR
* lpBstr
= (BSTR
*)lpvSrc
;
948 BSTR
* lpDest
= (BSTR
*)pvData
;
952 *lpDest
= SysAllocStringByteLen((char*)*lpBstr
, SysStringByteLen(*lpBstr
));
954 hRet
= E_OUTOFMEMORY
;
961 if (psa
->fFeatures
& (FADF_UNKNOWN
|FADF_DISPATCH
))
963 LPUNKNOWN
*lpUnknown
= (LPUNKNOWN
*)lpvSrc
;
966 IUnknown_AddRef(*lpUnknown
);
968 /* Copy the data over */
969 memcpy(pvData
, lpvSrc
, psa
->cbElements
);
972 SafeArrayUnlock(psa
);
977 /*************************************************************************
978 * SafeArrayGetUBound (OLEAUT32.19)
980 * Get the upper bound for a given SafeArray dimension
983 * psa [I] Array to get dimension upper bound from
984 * nDim [I] The dimension number to get the upper bound of
985 * plUbound [O] Destination for the upper bound
988 * Success: S_OK. plUbound contains the dimensions upper bound.
989 * Failure: An HRESULT error code indicating the error.
994 HRESULT WINAPI
SafeArrayGetUBound(SAFEARRAY
*psa
, UINT nDim
, LONG
*plUbound
)
996 TRACE("(%p,%d,%p)\n", psa
, nDim
, plUbound
);
998 if (!psa
|| !plUbound
)
1001 if(!nDim
|| nDim
> psa
->cDims
)
1002 return DISP_E_BADINDEX
;
1004 *plUbound
= psa
->rgsabound
[psa
->cDims
- nDim
].lLbound
+
1005 psa
->rgsabound
[psa
->cDims
- nDim
].cElements
- 1;
1010 /*************************************************************************
1011 * SafeArrayGetLBound (OLEAUT32.20)
1013 * Get the lower bound for a given SafeArray dimension
1016 * psa [I] Array to get dimension lower bound from
1017 * nDim [I] The dimension number to get the lowe bound of
1018 * plLbound [O] Destination for the lower bound
1021 * Success: S_OK. plUbound contains the dimensions lower bound.
1022 * Failure: An HRESULT error code indicating the error.
1027 HRESULT WINAPI
SafeArrayGetLBound(SAFEARRAY
*psa
, UINT nDim
, LONG
*plLbound
)
1029 TRACE("(%p,%d,%p)\n", psa
, nDim
, plLbound
);
1031 if (!psa
|| !plLbound
)
1032 return E_INVALIDARG
;
1034 if(!nDim
|| nDim
> psa
->cDims
)
1035 return DISP_E_BADINDEX
;
1037 *plLbound
= psa
->rgsabound
[psa
->cDims
- nDim
].lLbound
;
1041 /*************************************************************************
1042 * SafeArrayGetDim (OLEAUT32.17)
1044 * Get the number of dimensions in a SafeArray.
1047 * psa [I] Array to get the dimensions of
1050 * The number of array dimensions in psa, or 0 if psa is NULL.
1055 UINT WINAPI
SafeArrayGetDim(SAFEARRAY
*psa
)
1057 TRACE("(%p) returning %d\n", psa
, psa
? psa
->cDims
: 0u);
1058 return psa
? psa
->cDims
: 0;
1061 /*************************************************************************
1062 * SafeArrayGetElemsize (OLEAUT32.18)
1064 * Get the size of an element in a SafeArray.
1067 * psa [I] Array to get the element size from
1070 * The size of a single element in psa, or 0 if psa is NULL.
1075 UINT WINAPI
SafeArrayGetElemsize(SAFEARRAY
*psa
)
1077 TRACE("(%p) returning %d\n", psa
, psa
? psa
->cbElements
: 0u);
1078 return psa
? psa
->cbElements
: 0;
1081 /*************************************************************************
1082 * SafeArrayAccessData (OLEAUT32.23)
1084 * Lock a SafeArray and return a pointer to its data.
1087 * psa [I] Array to get the data pointer from
1088 * ppvData [O] Destination for the arrays data pointer
1091 * Success: S_OK. ppvData contains the arrays data pointer, and the array
1093 * Failure: An HRESULT error code indicating the error.
1098 HRESULT WINAPI
SafeArrayAccessData(SAFEARRAY
*psa
, void **ppvData
)
1100 TRACE("(%p,%p)\n", psa
, ppvData
);
1102 if(!psa
|| !ppvData
)
1103 return E_INVALIDARG
;
1105 if (SUCCEEDED(SafeArrayLock(psa
)))
1107 *ppvData
= psa
->pvData
;
1111 return E_UNEXPECTED
;
1115 /*************************************************************************
1116 * SafeArrayUnaccessData (OLEAUT32.24)
1118 * Unlock a SafeArray after accessing its data.
1121 * psa [I] Array to unlock
1124 * Success: S_OK. The array is unlocked.
1125 * Failure: An HRESULT error code indicating the error.
1130 HRESULT WINAPI
SafeArrayUnaccessData(SAFEARRAY
*psa
)
1132 TRACE("(%p)\n", psa
);
1133 return SafeArrayUnlock(psa
);
1136 /************************************************************************
1137 * SafeArrayPtrOfIndex (OLEAUT32.148)
1139 * Get the address of an item in a SafeArray.
1142 * psa [I] Array to get the items address from
1143 * rgIndices [I] Index of the item in the array
1144 * ppvData [O] Destination for item address
1147 * Success: S_OK. ppvData contains a pointer to the item.
1148 * Failure: An HRESULT error code indicating the error.
1151 * This function does not lock the array.
1156 HRESULT WINAPI
SafeArrayPtrOfIndex(SAFEARRAY
*psa
, LONG
*rgIndices
, void **ppvData
)
1159 ULONG cell
= 0, dimensionSize
= 1;
1160 SAFEARRAYBOUND
* psab
;
1163 TRACE("(%p,%p,%p)\n", psa
, rgIndices
, ppvData
);
1165 /* The general formula for locating the cell number of an entry in an n
1166 * dimensional array (where cn = coordinate in dimension dn) is:
1168 * c1 + c2 * sizeof(d1) + c3 * sizeof(d2) ... + cn * sizeof(c(n-1))
1170 * We calculate the size of the last dimension at each step through the
1171 * dimensions to avoid recursing to calculate the last dimensions size.
1173 if (!psa
|| !rgIndices
|| !ppvData
)
1174 return E_INVALIDARG
;
1176 psab
= psa
->rgsabound
+ psa
->cDims
- 1;
1179 if (c1
< psab
->lLbound
|| c1
>= psab
->lLbound
+ (LONG
)psab
->cElements
)
1180 return DISP_E_BADINDEX
; /* Initial index out of bounds */
1182 for (dim
= 1; dim
< psa
->cDims
; dim
++)
1184 dimensionSize
*= psab
->cElements
;
1188 if (!psab
->cElements
||
1189 *rgIndices
< psab
->lLbound
||
1190 *rgIndices
>= psab
->lLbound
+ (LONG
)psab
->cElements
)
1191 return DISP_E_BADINDEX
; /* Index out of bounds */
1193 cell
+= (*rgIndices
- psab
->lLbound
) * dimensionSize
;
1197 cell
+= (c1
- psa
->rgsabound
[psa
->cDims
- 1].lLbound
);
1199 *ppvData
= (char*)psa
->pvData
+ cell
* psa
->cbElements
;
1203 /************************************************************************
1204 * SafeArrayDestroyData (OLEAUT32.39)
1206 * Destroy the data associated with a SafeArray.
1209 * psa [I] Array to delete the data from
1212 * Success: S_OK. All items and the item data are freed.
1213 * Failure: An HRESULT error code indicating the error.
1218 HRESULT WINAPI
SafeArrayDestroyData(SAFEARRAY
*psa
)
1220 TRACE("(%p)\n", psa
);
1223 return E_INVALIDARG
;
1226 return DISP_E_ARRAYISLOCKED
; /* Can't delete a locked array */
1228 /* Delete the actual item data */
1229 if (FAILED(SAFEARRAY_DestroyData(psa
, 0)))
1230 return E_UNEXPECTED
;
1234 if (psa
->fFeatures
& FADF_STATIC
)
1236 ZeroMemory(psa
->pvData
, SAFEARRAY_GetCellCount(psa
) * psa
->cbElements
);
1239 /* If this is not a vector, free the data memory block */
1240 if (!(psa
->fFeatures
& FADF_CREATEVECTOR
))
1242 if (!SAFEARRAY_Free(psa
->pvData
))
1243 return E_UNEXPECTED
;
1247 psa
->fFeatures
|= FADF_DATADELETED
; /* Mark the data deleted */
1253 /************************************************************************
1254 * SafeArrayCopyData (OLEAUT32.412)
1256 * Copy all data from one SafeArray to another.
1259 * psaSource [I] Source for copy
1260 * psaTarget [O] Destination for copy
1263 * Success: S_OK. psaTarget contains a copy of psaSource.
1264 * Failure: An HRESULT error code indicating the error.
1267 * The two arrays must have the same number of dimensions and elements.
1272 HRESULT WINAPI
SafeArrayCopyData(SAFEARRAY
*psaSource
, SAFEARRAY
*psaTarget
)
1276 TRACE("(%p,%p)\n", psaSource
, psaTarget
);
1278 if (!psaSource
|| !psaTarget
||
1279 psaSource
->cDims
!= psaTarget
->cDims
||
1280 psaSource
->cbElements
!= psaTarget
->cbElements
)
1281 return E_INVALIDARG
;
1283 /* Each dimension must be the same size */
1284 for (dim
= psaSource
->cDims
- 1; dim
>= 0 ; dim
--)
1285 if (psaSource
->rgsabound
[dim
].cElements
!=
1286 psaTarget
->rgsabound
[dim
].cElements
)
1287 return E_INVALIDARG
;
1289 if (SUCCEEDED(SAFEARRAY_DestroyData(psaTarget
, 0)) &&
1290 SUCCEEDED(SAFEARRAY_CopyData(psaSource
, psaTarget
)))
1292 return E_UNEXPECTED
;
1295 /************************************************************************
1296 * SafeArrayDestroy (OLEAUT32.16)
1298 * Destroy a SafeArray.
1301 * psa [I] Array to destroy
1304 * Success: S_OK. All resources used by the array are freed.
1305 * Failure: An HRESULT error code indicating the error.
1310 HRESULT WINAPI
SafeArrayDestroy(SAFEARRAY
*psa
)
1312 TRACE("(%p)\n", psa
);
1318 return DISP_E_ARRAYISLOCKED
;
1320 /* Native doesn't check to see if the free succeeds */
1321 SafeArrayDestroyData(psa
);
1322 SafeArrayDestroyDescriptor(psa
);
1326 /************************************************************************
1327 * SafeArrayCopy (OLEAUT32.27)
1329 * Make a duplicate of a SafeArray.
1332 * psa [I] Source for copy
1333 * ppsaOut [O] Destination for new copy
1336 * Success: S_OK. ppsaOut contains a copy of the array.
1337 * Failure: An HRESULT error code indicating the error.
1342 HRESULT WINAPI
SafeArrayCopy(SAFEARRAY
*psa
, SAFEARRAY
**ppsaOut
)
1346 TRACE("(%p,%p)\n", psa
, ppsaOut
);
1349 return E_INVALIDARG
;
1354 return S_OK
; /* Handles copying of NULL arrays */
1356 if (!psa
->cbElements
)
1358 ERR("not copying an array of 0 elements\n");
1359 return E_INVALIDARG
;
1362 if (psa
->fFeatures
& (FADF_RECORD
|FADF_HAVEIID
|FADF_HAVEVARTYPE
))
1365 if (FAILED(SafeArrayGetVartype(psa
, &vt
)))
1366 hRet
= E_UNEXPECTED
;
1368 hRet
= SafeArrayAllocDescriptorEx(vt
, psa
->cDims
, ppsaOut
);
1372 hRet
= SafeArrayAllocDescriptor(psa
->cDims
, ppsaOut
);
1373 if (SUCCEEDED(hRet
))
1375 (*ppsaOut
)->fFeatures
= psa
->fFeatures
& ~FADF_CREATEVECTOR
;
1376 (*ppsaOut
)->cbElements
= psa
->cbElements
;
1380 if (SUCCEEDED(hRet
))
1382 /* Copy dimension bounds */
1383 memcpy((*ppsaOut
)->rgsabound
, psa
->rgsabound
, psa
->cDims
* sizeof(SAFEARRAYBOUND
));
1385 (*ppsaOut
)->pvData
= SAFEARRAY_Malloc(SAFEARRAY_GetCellCount(psa
) * psa
->cbElements
);
1387 if ((*ppsaOut
)->pvData
)
1389 hRet
= SAFEARRAY_CopyData(psa
, *ppsaOut
);
1391 if (SUCCEEDED(hRet
))
1394 SAFEARRAY_Free((*ppsaOut
)->pvData
);
1396 SafeArrayDestroyDescriptor(*ppsaOut
);
1402 /************************************************************************
1403 * SafeArrayRedim (OLEAUT32.40)
1405 * Changes the characteristics of the last dimension of a SafeArray
1408 * psa [I] Array to change
1409 * psabound [I] New bound details for the last dimension
1412 * Success: S_OK. psa is updated to reflect the new bounds.
1413 * Failure: An HRESULT error code indicating the error.
1418 HRESULT WINAPI
SafeArrayRedim(SAFEARRAY
*psa
, SAFEARRAYBOUND
*psabound
)
1420 SAFEARRAYBOUND
*oldBounds
;
1422 TRACE("(%p,%p)\n", psa
, psabound
);
1424 if (!psa
|| psa
->fFeatures
& FADF_FIXEDSIZE
|| !psabound
)
1425 return E_INVALIDARG
;
1427 if (psa
->cLocks
> 0)
1428 return DISP_E_ARRAYISLOCKED
;
1430 if (FAILED(SafeArrayLock(psa
)))
1431 return E_UNEXPECTED
;
1433 oldBounds
= psa
->rgsabound
;
1434 oldBounds
->lLbound
= psabound
->lLbound
;
1436 if (psabound
->cElements
!= oldBounds
->cElements
)
1438 if (psabound
->cElements
< oldBounds
->cElements
)
1440 /* Shorten the final dimension. */
1441 ULONG ulStartCell
= psabound
->cElements
*
1442 (SAFEARRAY_GetCellCount(psa
) / oldBounds
->cElements
);
1443 SAFEARRAY_DestroyData(psa
, ulStartCell
);
1447 /* Lengthen the final dimension */
1448 ULONG ulOldSize
, ulNewSize
;
1451 ulOldSize
= SAFEARRAY_GetCellCount(psa
) * psa
->cbElements
;
1453 ulNewSize
= (ulOldSize
/ oldBounds
->cElements
) * psabound
->cElements
;
1455 int oldelems
= oldBounds
->cElements
;
1456 oldBounds
->cElements
= psabound
->cElements
;
1457 ulNewSize
= SAFEARRAY_GetCellCount(psa
) * psa
->cbElements
;
1458 oldBounds
->cElements
= oldelems
;
1461 if (!(pvNewData
= SAFEARRAY_Malloc(ulNewSize
)))
1463 SafeArrayUnlock(psa
);
1464 return E_UNEXPECTED
;
1467 memcpy(pvNewData
, psa
->pvData
, ulOldSize
);
1468 SAFEARRAY_Free(psa
->pvData
);
1469 psa
->pvData
= pvNewData
;
1471 oldBounds
->cElements
= psabound
->cElements
;
1474 SafeArrayUnlock(psa
);
1478 /************************************************************************
1479 * SafeArrayGetVartype (OLEAUT32.77)
1481 * Get the type of the items in a SafeArray.
1484 * psa [I] Array to get the type from
1485 * pvt [O] Destination for the type
1488 * Success: S_OK. pvt contains the type of the items.
1489 * Failure: An HRESULT error code indicating the error.
1494 HRESULT WINAPI
SafeArrayGetVartype(SAFEARRAY
* psa
, VARTYPE
* pvt
)
1496 TRACE("(%p,%p)\n", psa
, pvt
);
1499 return E_INVALIDARG
;
1501 if (psa
->fFeatures
& FADF_RECORD
)
1503 else if (psa
->fFeatures
& FADF_HAVEIID
)
1505 else if (psa
->fFeatures
& FADF_HAVEVARTYPE
)
1507 VARTYPE vt
= SAFEARRAY_GetHiddenDWORD(psa
);
1511 return E_INVALIDARG
;
1516 /************************************************************************
1517 * SafeArraySetRecordInfo (OLEAUT32.@)
1519 * Set the record info for a SafeArray.
1522 * psa [I] Array to set the record info for
1523 * pRinfo [I] Record info
1526 * Success: S_OK. The record info is stored with the array.
1527 * Failure: An HRESULT error code indicating the error.
1532 HRESULT WINAPI
SafeArraySetRecordInfo(SAFEARRAY
*psa
, IRecordInfo
*pRinfo
)
1534 IRecordInfo
** dest
= (IRecordInfo
**)psa
;
1536 TRACE("(%p,%p)\n", psa
, pRinfo
);
1538 if (!psa
|| !(psa
->fFeatures
& FADF_RECORD
))
1539 return E_INVALIDARG
;
1542 IRecordInfo_AddRef(pRinfo
);
1545 IRecordInfo_Release(dest
[-1]);
1551 /************************************************************************
1552 * SafeArrayGetRecordInfo (OLEAUT32.@)
1554 * Get the record info from a SafeArray.
1557 * psa [I] Array to get the record info from
1558 * pRinfo [O] Destination for the record info
1561 * Success: S_OK. pRinfo contains the record info, or NULL if there was none.
1562 * Failure: An HRESULT error code indicating the error.
1567 HRESULT WINAPI
SafeArrayGetRecordInfo(SAFEARRAY
*psa
, IRecordInfo
**pRinfo
)
1569 IRecordInfo
** src
= (IRecordInfo
**)psa
;
1571 TRACE("(%p,%p)\n", psa
, pRinfo
);
1573 if (!psa
|| !pRinfo
|| !(psa
->fFeatures
& FADF_RECORD
))
1574 return E_INVALIDARG
;
1579 IRecordInfo_AddRef(*pRinfo
);
1583 /************************************************************************
1584 * SafeArraySetIID (OLEAUT32.@)
1586 * Set the IID for a SafeArray.
1589 * psa [I] Array to set the IID from
1593 * Success: S_OK. The IID is stored with the array
1594 * Failure: An HRESULT error code indicating the error.
1599 HRESULT WINAPI
SafeArraySetIID(SAFEARRAY
*psa
, REFGUID guid
)
1601 GUID
* dest
= (GUID
*)psa
;
1603 TRACE("(%p,%s)\n", psa
, debugstr_guid(guid
));
1605 if (!psa
|| !guid
|| !(psa
->fFeatures
& FADF_HAVEIID
))
1606 return E_INVALIDARG
;
1612 /************************************************************************
1613 * SafeArrayGetIID (OLEAUT32.@)
1615 * Get the IID from a SafeArray.
1618 * psa [I] Array to get the ID from
1619 * pGuid [O] Destination for the IID
1622 * Success: S_OK. pRinfo contains the IID, or NULL if there was none.
1623 * Failure: An HRESULT error code indicating the error.
1628 HRESULT WINAPI
SafeArrayGetIID(SAFEARRAY
*psa
, GUID
*pGuid
)
1630 GUID
* src
= (GUID
*)psa
;
1632 TRACE("(%p,%p)\n", psa
, pGuid
);
1634 if (!psa
|| !pGuid
|| !(psa
->fFeatures
& FADF_HAVEIID
))
1635 return E_INVALIDARG
;
1641 /************************************************************************
1642 * VectorFromBstr (OLEAUT32.@)
1644 * Create a SafeArray Vector from the bytes of a BSTR.
1647 * bstr [I] String to get bytes from
1648 * ppsa [O] Destination for the array
1651 * Success: S_OK. ppsa contains the strings bytes as a VT_UI1 array.
1652 * Failure: An HRESULT error code indicating the error.
1657 HRESULT WINAPI
VectorFromBstr(BSTR bstr
, SAFEARRAY
**ppsa
)
1661 TRACE("(%p,%p)\n", bstr
, ppsa
);
1664 return E_INVALIDARG
;
1667 sab
.cElements
= SysStringByteLen(bstr
);
1669 *ppsa
= SAFEARRAY_Create(VT_UI1
, 1, &sab
, 0);
1673 memcpy((*ppsa
)->pvData
, bstr
, sab
.cElements
);
1676 return E_OUTOFMEMORY
;
1679 /************************************************************************
1680 * BstrFromVector (OLEAUT32.@)
1682 * Create a BSTR from a SafeArray.
1685 * psa [I] Source array
1686 * pbstr [O] Destination for output BSTR
1689 * Success: S_OK. pbstr contains the arrays data.
1690 * Failure: An HRESULT error code indicating the error.
1693 * psa must be a 1 dimensional array of a 1 byte type.
1698 HRESULT WINAPI
BstrFromVector(SAFEARRAY
*psa
, BSTR
*pbstr
)
1700 TRACE("(%p,%p)\n", psa
, pbstr
);
1703 return E_INVALIDARG
;
1707 if (!psa
|| psa
->cbElements
!= 1 || psa
->cDims
!= 1)
1708 return E_INVALIDARG
;
1710 *pbstr
= SysAllocStringByteLen(psa
->pvData
, psa
->rgsabound
[0].cElements
);
1712 return E_OUTOFMEMORY
;