1 /*************************************************************************
2 * OLE Automation - SafeArray
3 *
4 * This file contains the implementation of the SafeArray functions.
5 *
6 * Copyright 1999 Sylvain St-Germain
7 * Copyright 2002-2003 Marcus Meissner
8 * Copyright 2003 Jon Griffiths
9 *
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.
14 *
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.
19 *
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
23 */
24 /* Memory Layout of a SafeArray:
25 *
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))
30 * 0x00: SAFEARRAY,
31 * 0x10: SAFEARRAYBOUNDS[0...]
32 */
33
34 #include "config.h"
35
36 #include <string.h>
37 #include <stdarg.h>
38 #include <stdio.h>
39
40 #define COBJMACROS
41
42 #include "windef.h"
43 #include "winerror.h"
44 #include "winbase.h"
45 #include "variant.h"
46 #include "wine/debug.h"
47
48 WINE_DEFAULT_DEBUG_CHANNEL(variant);
49
50 /************************************************************************
51 * SafeArray {OLEAUT32}
52 *
53 * NOTES
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.
58 *
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.
63 *
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
68 * single dimension.
69 *
70 * DATATYPES
71 * The following types of data can be stored within a SafeArray.
72 * Numeric:
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
75 * Interfaces:
76 *| VT_DISPATCH, VT_UNKNOWN, VT_RECORD
77 * Other:
78 *| VT_VARIANT, VT_INT_PTR, VT_UINT_PTR, VT_BOOL, VT_ERROR, VT_DATE, VT_BSTR
79 *
80 * FUNCTIONS
81 * BstrFromVector()
82 * VectorFromBstr()
83 */
84
85 /* Undocumented hidden space before the start of a SafeArray descriptor */
86 #define SAFEARRAY_HIDDEN_SIZE sizeof(GUID)
87
88 /* Allocate memory */
89 static inline LPVOID SAFEARRAY_Malloc(ULONG ulSize)
90 {
91 /* FIXME: Memory should be allocated and freed using a per-thread IMalloc
92 * instance returned from CoGetMalloc().
93 */
94 return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, ulSize);
95 }
96
97 /* Free memory */
98 static inline BOOL SAFEARRAY_Free(LPVOID lpData)
99 {
100 return HeapFree(GetProcessHeap(), 0, lpData);
101 }
102
103 /* Get the size of a supported VT type (0 means unsupported) */
104 static DWORD SAFEARRAY_GetVTSize(VARTYPE vt)
105 {
106 switch (vt)
107 {
108 case VT_I1:
109 case VT_UI1: return sizeof(BYTE);
110 case VT_BOOL:
111 case VT_I2:
112 case VT_UI2: return sizeof(SHORT);
113 case VT_I4:
114 case VT_UI4:
115 case VT_R4:
116 case VT_ERROR: return sizeof(LONG);
117 case VT_R8:
118 case VT_I8:
119 case VT_UI8: return sizeof(LONG64);
120 case VT_INT:
121 case VT_UINT: return sizeof(INT);
122 case VT_INT_PTR:
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().
133 */
134 case VT_RECORD: return 32;
135 }
136 return 0;
137 }
138
139 /* Set the hidden data for an array */
140 static inline void SAFEARRAY_SetHiddenDWORD(SAFEARRAY* psa, DWORD dw)
141 {
142 /* Implementation data is stored in the 4 bytes before the header */
143 LPDWORD lpDw = (LPDWORD)psa;
144 lpDw[-1] = dw;
145 }
146
147 /* Get the hidden data from an array */
148 static inline DWORD SAFEARRAY_GetHiddenDWORD(SAFEARRAY* psa)
149 {
150 LPDWORD lpDw = (LPDWORD)psa;
151 return lpDw[-1];
152 }
153
154 /* Get the number of cells in a SafeArray */
155 static ULONG SAFEARRAY_GetCellCount(const SAFEARRAY *psa)
156 {
157 const SAFEARRAYBOUND* psab = psa->rgsabound;
158 USHORT cCount = psa->cDims;
159 ULONG ulNumCells = 1;
160
161 while (cCount--)
162 {
163 /* This is a valid bordercase. See testcases. -Marcus */
164 if (!psab->cElements)
165 return 0;
166 ulNumCells *= psab->cElements;
167 psab++;
168 }
169 return ulNumCells;
170 }
171
172 /* Allocate a descriptor for an array */
173 static HRESULT SAFEARRAY_AllocDescriptor(ULONG ulSize, SAFEARRAY **ppsaOut)
174 {
175 *ppsaOut = (SAFEARRAY*)((char*)SAFEARRAY_Malloc(ulSize + SAFEARRAY_HIDDEN_SIZE) + SAFEARRAY_HIDDEN_SIZE);
176
177 if (!*ppsaOut)
178 return E_UNEXPECTED;
179
180 return S_OK;
181 }
182
183 /* Set the features of an array */
184 static void SAFEARRAY_SetFeatures(VARTYPE vt, SAFEARRAY *psa)
185 {
186 /* Set the IID if we have one, otherwise set the type */
187 if (vt == VT_DISPATCH)
188 {
189 psa->fFeatures = FADF_HAVEIID;
190 SafeArraySetIID(psa, &IID_IDispatch);
191 }
192 else if (vt == VT_UNKNOWN)
193 {
194 psa->fFeatures = FADF_HAVEIID;
195 SafeArraySetIID(psa, &IID_IUnknown);
196 }
197 else if (vt == VT_RECORD)
198 psa->fFeatures = FADF_RECORD;
199 else
200 {
201 psa->fFeatures = FADF_HAVEVARTYPE;
202 SAFEARRAY_SetHiddenDWORD(psa, vt);
203 }
204 }
205
206 /* Create an array */
207 static SAFEARRAY* SAFEARRAY_Create(VARTYPE vt, UINT cDims, const SAFEARRAYBOUND *rgsabound, ULONG ulSize)
208 {
209 SAFEARRAY *psa = NULL;
210 int i;
211
212 if (!rgsabound)
213 return NULL;
214
215 if (SUCCEEDED(SafeArrayAllocDescriptorEx(vt, cDims, &psa)))
216 {
217 switch (vt)
218 {
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;
223 }
224
225 for (i = 0; i < cDims; i++)
226 memcpy(psa->rgsabound + i, rgsabound + cDims - 1 - i, sizeof(SAFEARRAYBOUND));
227
228 if (ulSize)
229 psa->cbElements = ulSize;
230
231 if (!psa->cbElements || FAILED(SafeArrayAllocData(psa)))
232 {
233 SafeArrayDestroyDescriptor(psa);
234 psa = NULL;
235 }
236 }
237 return psa;
238 }
239
240 /* Create an array as a vector */
241 static SAFEARRAY* SAFEARRAY_CreateVector(VARTYPE vt, LONG lLbound, ULONG cElements, ULONG ulSize)
242 {
243 SAFEARRAY *psa = NULL;
244
245 if (ulSize || (vt == VT_RECORD))
246 {
247 /* Allocate the header and data together */
248 if (SUCCEEDED(SAFEARRAY_AllocDescriptor(sizeof(SAFEARRAY) + ulSize * cElements, &psa)))
249 {
250 SAFEARRAY_SetFeatures(vt, psa);
251
252 psa->cDims = 1;
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;
258
259 switch (vt)
260 {
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;
265 }
266 }
267 }
268 return psa;
269 }
270
271 /* Free data items in an array */
272 static HRESULT SAFEARRAY_DestroyData(SAFEARRAY *psa, ULONG ulStartCell)
273 {
274 if (psa->pvData && !(psa->fFeatures & FADF_DATADELETED))
275 {
276 ULONG ulCellCount = SAFEARRAY_GetCellCount(psa);
277
278 if (ulStartCell > ulCellCount) {
279 FIXME("unexpted ulcellcount %d, start %d\n",ulCellCount,ulStartCell);
280 return E_UNEXPECTED;
281 }
282
283 ulCellCount -= ulStartCell;
284
285 if (psa->fFeatures & (FADF_UNKNOWN|FADF_DISPATCH))
286 {
287 LPUNKNOWN *lpUnknown = (LPUNKNOWN *)psa->pvData + ulStartCell;
288
289 while(ulCellCount--)
290 {
291 if (*lpUnknown)
292 IUnknown_Release(*lpUnknown);
293 lpUnknown++;
294 }
295 }
296 else if (psa->fFeatures & (FADF_RECORD))
297 {
298 IRecordInfo *lpRecInfo;
299
300 if (SUCCEEDED(SafeArrayGetRecordInfo(psa, &lpRecInfo)))
301 {
302 PBYTE pRecordData = (PBYTE)psa->pvData;
303 while(ulCellCount--)
304 {
305 IRecordInfo_RecordClear(lpRecInfo, pRecordData);
306 pRecordData += psa->cbElements;
307 }
308 IRecordInfo_Release(lpRecInfo);
309 }
310 }
311 else if (psa->fFeatures & FADF_BSTR)
312 {
313 BSTR* lpBstr = (BSTR*)psa->pvData + ulStartCell;
314
315 while(ulCellCount--)
316 {
317 if (*lpBstr)
318 SysFreeString(*lpBstr);
319 lpBstr++;
320 }
321 }
322 else if (psa->fFeatures & FADF_VARIANT)
323 {
324 VARIANT* lpVariant = (VARIANT*)psa->pvData + ulStartCell;
325
326 while(ulCellCount--)
327 {
328 HRESULT hRet = VariantClear(lpVariant);
329
330 if (FAILED(hRet)) FIXME("VariantClear of element failed!\n");
331 lpVariant++;
332 }
333 }
334 }
335 return S_OK;
336 }
337
338 /* Copy data items from one array to another */
339 static HRESULT SAFEARRAY_CopyData(SAFEARRAY *psa, SAFEARRAY *dest)
340 {
341 if (!psa->pvData)
342 return S_OK;
343 else if (!dest->pvData || psa->fFeatures & FADF_DATADELETED)
344 return E_INVALIDARG;
345 else
346 {
347 ULONG ulCellCount = SAFEARRAY_GetCellCount(psa);
348
349 dest->fFeatures = (dest->fFeatures & FADF_CREATEVECTOR) |
350 (psa->fFeatures & ~(FADF_CREATEVECTOR|FADF_DATADELETED));
351
352 if (psa->fFeatures & FADF_VARIANT)
353 {
354 VARIANT* lpVariant = (VARIANT*)psa->pvData;
355 VARIANT* lpDest = (VARIANT*)dest->pvData;
356
357 while(ulCellCount--)
358 {
359 HRESULT hRet;
360
361 hRet = VariantCopy(lpDest, lpVariant);
362 if (FAILED(hRet)) FIXME("VariantCopy failed with 0x%x\n", hRet);
363 lpVariant++;
364 lpDest++;
365 }
366 }
367 else if (psa->fFeatures & FADF_BSTR)
368 {
369 BSTR* lpBstr = (BSTR*)psa->pvData;
370 BSTR* lpDest = (BSTR*)dest->pvData;
371
372 while(ulCellCount--)
373 {
374 if (*lpBstr)
375 {
376 *lpDest = SysAllocStringByteLen((char*)*lpBstr, SysStringByteLen(*lpBstr));
377 if (!*lpDest)
378 return E_OUTOFMEMORY;
379 }
380 else
381 *lpDest = NULL;
382 lpBstr++;
383 lpDest++;
384 }
385 }
386 else
387 {
388 /* Copy the data over */
389 memcpy(dest->pvData, psa->pvData, ulCellCount * psa->cbElements);
390
391 if (psa->fFeatures & (FADF_UNKNOWN|FADF_DISPATCH))
392 {
393 LPUNKNOWN *lpUnknown = (LPUNKNOWN *)dest->pvData;
394
395 while(ulCellCount--)
396 {
397 if (*lpUnknown)
398 IUnknown_AddRef(*lpUnknown);
399 lpUnknown++;
400 }
401 }
402 }
403
404 if (psa->fFeatures & FADF_RECORD)
405 {
406 IRecordInfo* pRecInfo = NULL;
407
408 SafeArrayGetRecordInfo(psa, &pRecInfo);
409 SafeArraySetRecordInfo(dest, pRecInfo);
410
411 if (pRecInfo)
412 {
413 /* Release because Get() adds a reference */
414 IRecordInfo_Release(pRecInfo);
415 }
416 }
417 else if (psa->fFeatures & FADF_HAVEIID)
418 {
419 GUID guid;
420 SafeArrayGetIID(psa, &guid);
421 SafeArraySetIID(dest, &guid);
422 }
423 else if (psa->fFeatures & FADF_HAVEVARTYPE)
424 {
425 SAFEARRAY_SetHiddenDWORD(dest, SAFEARRAY_GetHiddenDWORD(psa));
426 }
427 }
428 return S_OK;
429 }
430
431 /*************************************************************************
432 * SafeArrayAllocDescriptor (OLEAUT32.36)
433 *
434 * Allocate and initialise a descriptor for a SafeArray.
435 *
436 * PARAMS
437 * cDims [I] Number of dimensions of the array
438 * ppsaOut [O] Destination for new descriptor
439 *
440 * RETURNS
441 * Success: S_OK. ppsaOut is filled with a newly allocated descriptor.
442 * Failure: An HRESULT error code indicating the error.
443 *
444 * NOTES
445 * See SafeArray.
446 */
447 HRESULT WINAPI SafeArrayAllocDescriptor(UINT cDims, SAFEARRAY **ppsaOut)
448 {
449 LONG allocSize;
450
451 TRACE("(%d,%p)\n", cDims, ppsaOut);
452
453 if (!cDims || cDims >= 0x10000) /* Maximum 65535 dimensions */
454 return E_INVALIDARG;
455
456 if (!ppsaOut)
457 return E_POINTER;
458
459 /* We need enough space for the header and its bounds */
460 allocSize = sizeof(SAFEARRAY) + sizeof(SAFEARRAYBOUND) * (cDims - 1);
461
462 if (FAILED(SAFEARRAY_AllocDescriptor(allocSize, ppsaOut)))
463 return E_UNEXPECTED;
464
465 (*ppsaOut)->cDims = cDims;
466
467 TRACE("(%d): %u bytes allocated for descriptor.\n", cDims, allocSize);
468 return S_OK;
469 }
470
471 /*************************************************************************
472 * SafeArrayAllocDescriptorEx (OLEAUT32.41)
473 *
474 * Allocate and initialise a descriptor for a SafeArray of a given type.
475 *
476 * PARAMS
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
480 *
481 * RETURNS
482 * Success: S_OK. ppsaOut is filled with a newly allocated descriptor.
483 * Failure: An HRESULT error code indicating the error.
484 *
485 * NOTES
486 * - This function does not check that vt is an allowed VARTYPE.
487 * - Unlike SafeArrayAllocDescriptor(), vt is associated with the array.
488 * See SafeArray.
489 */
490 HRESULT WINAPI SafeArrayAllocDescriptorEx(VARTYPE vt, UINT cDims, SAFEARRAY **ppsaOut)
491 {
492 ULONG cbElements;
493 HRESULT hRet = E_UNEXPECTED;
494
495 TRACE("(%d->%s,%d,%p)\n", vt, debugstr_vt(vt), cDims, ppsaOut);
496
497 cbElements = SAFEARRAY_GetVTSize(vt);
498 if (!cbElements)
499 WARN("Creating a descriptor with an invalid VARTYPE!\n");
500
501 hRet = SafeArrayAllocDescriptor(cDims, ppsaOut);
502
503 if (SUCCEEDED(hRet))
504 {
505 SAFEARRAY_SetFeatures(vt, *ppsaOut);
506 (*ppsaOut)->cbElements = cbElements;
507 }
508 return hRet;
509 }
510
511 /*************************************************************************
512 * SafeArrayAllocData (OLEAUT32.37)
513 *
514 * Allocate the data area of a SafeArray.
515 *
516 * PARAMS
517 * psa [I] SafeArray to allocate the data area of.
518 *
519 * RETURNS
520 * Success: S_OK. The data area is allocated and initialised.
521 * Failure: An HRESULT error code indicating the error.
522 *
523 * NOTES
524 * See SafeArray.
525 */
526 HRESULT WINAPI SafeArrayAllocData(SAFEARRAY *psa)
527 {
528 HRESULT hRet = E_INVALIDARG;
529
530 TRACE("(%p)\n", psa);
531
532 if (psa)
533 {
534 ULONG ulSize = SAFEARRAY_GetCellCount(psa);
535
536 psa->pvData = SAFEARRAY_Malloc(ulSize * psa->cbElements);
537
538 if (psa->pvData)
539 {
540 hRet = S_OK;
541 TRACE("%u bytes allocated for data at %p (%u objects).\n",
542 ulSize * psa->cbElements, psa->pvData, ulSize);
543 }
544 else
545 hRet = E_OUTOFMEMORY;
546 }
547 return hRet;
548 }
549
550 /*************************************************************************
551 * SafeArrayCreate (OLEAUT32.15)
552 *
553 * Create a new SafeArray.
554 *
555 * PARAMS
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
559 *
560 * RETURNS
561 * Success: A pointer to a new array object.
562 * Failure: NULL, if any parameter is invalid or memory allocation fails.
563 *
564 * NOTES
565 * Win32 allows arrays with 0 sized dimensions. This bug is not reproduced
566 * in the Wine implementation.
567 * See SafeArray.
568 */
569 SAFEARRAY* WINAPI SafeArrayCreate(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsabound)
570 {
571 TRACE("(%d->%s,%d,%p)\n", vt, debugstr_vt(vt), cDims, rgsabound);
572
573 if (vt == VT_RECORD)
574 return NULL;
575
576 return SAFEARRAY_Create(vt, cDims, rgsabound, 0);
577 }
578
579 /*************************************************************************
580 * SafeArrayCreateEx (OLEAUT32.15)
581 *
582 * Create a new SafeArray.
583 *
584 * PARAMS
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
589 *
590 * RETURNS
591 * Success: A pointer to a new array object.
592 * Failure: NULL, if any parameter is invalid or memory allocation fails.
593 *
594 * NOTES
595 * See SafeArray.
596 */
597 SAFEARRAY* WINAPI SafeArrayCreateEx(VARTYPE vt, UINT cDims, SAFEARRAYBOUND *rgsabound, LPVOID pvExtra)
598 {
599 ULONG ulSize = 0;
600 IRecordInfo* iRecInfo = (IRecordInfo*)pvExtra;
601 SAFEARRAY* psa;
602
603 TRACE("(%d->%s,%d,%p,%p)\n", vt, debugstr_vt(vt), cDims, rgsabound, pvExtra);
604
605 if (vt == VT_RECORD)
606 {
607 if (!iRecInfo)
608 return NULL;
609 IRecordInfo_GetSize(iRecInfo, &ulSize);
610 }
611 psa = SAFEARRAY_Create(vt, cDims, rgsabound, ulSize);
612
613 if (pvExtra)
614 {
615 switch(vt)
616 {
617 case VT_RECORD:
618 SafeArraySetRecordInfo(psa, pvExtra);
619 break;
620 case VT_UNKNOWN:
621 case VT_DISPATCH:
622 SafeArraySetIID(psa, pvExtra);
623 break;
624 }
625 }
626 return psa;
627 }
628
629 /************************************************************************
630 * SafeArrayCreateVector (OLEAUT32.411)
631 *
632 * Create a one dimensional, contiguous SafeArray.
633 *
634 * PARAMS
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
638 *
639 * RETURNS
640 * Success: A pointer to a new array object.
641 * Failure: NULL, if any parameter is invalid or memory allocation fails.
642 *
643 * NOTES
644 * See SafeArray.
645 */
646 SAFEARRAY* WINAPI SafeArrayCreateVector(VARTYPE vt, LONG lLbound, ULONG cElements)
647 {
648 TRACE("(%d->%s,%d,%d\n", vt, debugstr_vt(vt), lLbound, cElements);
649
650 if (vt == VT_RECORD)
651 return NULL;
652
653 return SAFEARRAY_CreateVector(vt, lLbound, cElements, SAFEARRAY_GetVTSize(vt));
654 }
655
656 /************************************************************************
657 * SafeArrayCreateVectorEx (OLEAUT32.411)
658 *
659 * Create a one dimensional, contiguous SafeArray.
660 *
661 * PARAMS
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
666 *
667 * RETURNS
668 * Success: A pointer to a new array object.
669 * Failure: NULL, if any parameter is invalid or memory allocation fails.
670 *
671 * NOTES
672 * See SafeArray.
673 */
674 SAFEARRAY* WINAPI SafeArrayCreateVectorEx(VARTYPE vt, LONG lLbound, ULONG cElements, LPVOID pvExtra)
675 {
676 ULONG ulSize;
677 IRecordInfo* iRecInfo = (IRecordInfo*)pvExtra;
678 SAFEARRAY* psa;
679
680 TRACE("(%d->%s,%d,%d,%p\n", vt, debugstr_vt(vt), lLbound, cElements, pvExtra);
681
682 if (vt == VT_RECORD)
683 {
684 if (!iRecInfo)
685 return NULL;
686 IRecordInfo_GetSize(iRecInfo, &ulSize);
687 }
688 else
689 ulSize = SAFEARRAY_GetVTSize(vt);
690
691 psa = SAFEARRAY_CreateVector(vt, lLbound, cElements, ulSize);
692
693 if (pvExtra)
694 {
695 switch(vt)
696 {
697 case VT_RECORD:
698 SafeArraySetRecordInfo(psa, iRecInfo);
699 break;
700 case VT_UNKNOWN:
701 case VT_DISPATCH:
702 SafeArraySetIID(psa, pvExtra);
703 break;
704 }
705 }
706 return psa;
707 }
708
709 /*************************************************************************
710 * SafeArrayDestroyDescriptor (OLEAUT32.38)
711 *
712 * Destroy a SafeArray.
713 *
714 * PARAMS
715 * psa [I] SafeArray to destroy.
716 *
717 * RETURNS
718 * Success: S_OK. The resources used by the array are freed.
719 * Failure: An HRESULT error code indicating the error.
720 *
721 * NOTES
722 * See SafeArray.
723 */
724 HRESULT WINAPI SafeArrayDestroyDescriptor(SAFEARRAY *psa)
725 {
726 TRACE("(%p)\n", psa);
727
728 if (psa)
729 {
730 LPVOID lpv = (char*)psa - SAFEARRAY_HIDDEN_SIZE;
731
732 if (psa->cLocks)
733 return DISP_E_ARRAYISLOCKED; /* Can't destroy a locked array */
734
735 if (psa->fFeatures & FADF_RECORD)
736 SafeArraySetRecordInfo(psa, NULL);
737
738 if (psa->fFeatures & FADF_CREATEVECTOR &&
739 !(psa->fFeatures & FADF_DATADELETED))
740 SAFEARRAY_DestroyData(psa, 0); /* Data not previously deleted */
741
742 if (!SAFEARRAY_Free(lpv))
743 return E_UNEXPECTED;
744 }
745 return S_OK;
746 }
747
748 /*************************************************************************
749 * SafeArrayLock (OLEAUT32.21)
750 *
751 * Increment the lock counter of a SafeArray.
752 *
753 * PARAMS
754 * psa [O] SafeArray to lock
755 *
756 * RETURNS
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.
760 *
761 * NOTES
762 * In Win32 these locks are not thread safe.
763 * See SafeArray.
764 */
765 HRESULT WINAPI SafeArrayLock(SAFEARRAY *psa)
766 {
767 ULONG ulLocks;
768
769 TRACE("(%p)\n", psa);
770
771 if (!psa)
772 return E_INVALIDARG;
773
774 ulLocks = InterlockedIncrement( (LONG*) &psa->cLocks);
775
776 if (ulLocks > 0xffff) /* Maximum of 16384 locks at a time */
777 {
778 WARN("Out of locks!\n");
779 InterlockedDecrement( (LONG*) &psa->cLocks);
780 return E_UNEXPECTED;
781 }
782 return S_OK;
783 }
784
785 /*************************************************************************
786 * SafeArrayUnlock (OLEAUT32.22)
787 *
788 * Decrement the lock counter of a SafeArray.
789 *
790 * PARAMS
791 * psa [O] SafeArray to unlock
792 *
793 * RETURNS
794 * Success: S_OK. The array lock is decremented.
795 * Failure: E_INVALIDARG if psa is NULL, or E_UNEXPECTED if no locks are
796 * held on the array.
797 *
798 * NOTES
799 * See SafeArray.
800 */
801 HRESULT WINAPI SafeArrayUnlock(SAFEARRAY *psa)
802 {
803 TRACE("(%p)\n", psa);
804
805 if (!psa)
806 return E_INVALIDARG;
807
808 if (InterlockedDecrement( (LONG*) &psa->cLocks) < 0)
809 {
810 WARN("Unlocked but no lock held!\n");
811 InterlockedIncrement( (LONG*) &psa->cLocks);
812 return E_UNEXPECTED;
813 }
814 return S_OK;
815 }
816
817 /*************************************************************************
818 * SafeArrayPutElement (OLEAUT32.26)
819 *
820 * Put an item into a SafeArray.
821 *
822 * PARAMS
823 * psa [I] SafeArray to insert into
824 * rgIndices [I] Indices to insert at
825 * pvData [I] Data to insert
826 *
827 * RETURNS
828 * Success: S_OK. The item is inserted
829 * Failure: An HRESULT error code indicating the error.
830 *
831 * NOTES
832 * See SafeArray.
833 */
834 HRESULT WINAPI SafeArrayPutElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData)
835 {
836 HRESULT hRet;
837
838 TRACE("(%p,%p,%p)\n", psa, rgIndices, pvData);
839
840 if (!psa || !rgIndices)
841 return E_INVALIDARG;
842
843 hRet = SafeArrayLock(psa);
844
845 if (SUCCEEDED(hRet))
846 {
847 PVOID lpvDest;
848
849 hRet = SafeArrayPtrOfIndex(psa, rgIndices, &lpvDest);
850
851 if (SUCCEEDED(hRet))
852 {
853 if (psa->fFeatures & FADF_VARIANT)
854 {
855 VARIANT* lpVariant = (VARIANT*)pvData;
856 VARIANT* lpDest = (VARIANT*)lpvDest;
857
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);
862 }
863 else if (psa->fFeatures & FADF_BSTR)
864 {
865 BSTR lpBstr = (BSTR)pvData;
866 BSTR* lpDest = (BSTR*)lpvDest;
867
868 if (*lpDest)
869 SysFreeString(*lpDest);
870
871 *lpDest = SysAllocStringByteLen((char*)lpBstr, SysStringByteLen(lpBstr));
872 if (!*lpDest)
873 hRet = E_OUTOFMEMORY;
874 }
875 else
876 {
877 if (psa->fFeatures & (FADF_UNKNOWN|FADF_DISPATCH))
878 {
879 LPUNKNOWN lpUnknown = (LPUNKNOWN)pvData;
880 LPUNKNOWN *lpDest = (LPUNKNOWN *)lpvDest;
881
882 if (lpUnknown)
883 IUnknown_AddRef(lpUnknown);
884 if (*lpDest)
885 IUnknown_Release(*lpDest);
886 *lpDest = lpUnknown;
887 } else {
888 /* Copy the data over */
889 memcpy(lpvDest, pvData, psa->cbElements);
890 }
891 }
892 }
893 SafeArrayUnlock(psa);
894 }
895 return hRet;
896 }
897
898
899 /*************************************************************************
900 * SafeArrayGetElement (OLEAUT32.25)
901 *
902 * Get an item from a SafeArray.
903 *
904 * PARAMS
905 * psa [I] SafeArray to get from
906 * rgIndices [I] Indices to get from
907 * pvData [O] Destination for data
908 *
909 * RETURNS
910 * Success: S_OK. The item data is returned in pvData.
911 * Failure: An HRESULT error code indicating the error.
912 *
913 * NOTES
914 * See SafeArray.
915 */
916 HRESULT WINAPI SafeArrayGetElement(SAFEARRAY *psa, LONG *rgIndices, void *pvData)
917 {
918 HRESULT hRet;
919
920 TRACE("(%p,%p,%p)\n", psa, rgIndices, pvData);
921
922 if (!psa || !rgIndices || !pvData)
923 return E_INVALIDARG;
924
925 hRet = SafeArrayLock(psa);
926
927 if (SUCCEEDED(hRet))
928 {
929 PVOID lpvSrc;
930
931 hRet = SafeArrayPtrOfIndex(psa, rgIndices, &lpvSrc);
932
933 if (SUCCEEDED(hRet))
934 {
935 if (psa->fFeatures & FADF_VARIANT)
936 {
937 VARIANT* lpVariant = (VARIANT*)lpvSrc;
938 VARIANT* lpDest = (VARIANT*)pvData;
939
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);
944 }
945 else if (psa->fFeatures & FADF_BSTR)
946 {
947 BSTR* lpBstr = (BSTR*)lpvSrc;
948 BSTR* lpDest = (BSTR*)pvData;
949
950 if (*lpBstr)
951 {
952 *lpDest = SysAllocStringByteLen((char*)*lpBstr, SysStringByteLen(*lpBstr));
953 if (!*lpBstr)
954 hRet = E_OUTOFMEMORY;
955 }
956 else
957 *lpDest = NULL;
958 }
959 else
960 {
961 if (psa->fFeatures & (FADF_UNKNOWN|FADF_DISPATCH))
962 {
963 LPUNKNOWN *lpUnknown = (LPUNKNOWN *)lpvSrc;
964
965 if (*lpUnknown)
966 IUnknown_AddRef(*lpUnknown);
967 }
968 /* Copy the data over */
969 memcpy(pvData, lpvSrc, psa->cbElements);
970 }
971 }
972 SafeArrayUnlock(psa);
973 }
974 return hRet;
975 }
976
977 /*************************************************************************
978 * SafeArrayGetUBound (OLEAUT32.19)
979 *
980 * Get the upper bound for a given SafeArray dimension
981 *
982 * PARAMS
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
986 *
987 * RETURNS
988 * Success: S_OK. plUbound contains the dimensions upper bound.
989 * Failure: An HRESULT error code indicating the error.
990 *
991 * NOTES
992 * See SafeArray.
993 */
994 HRESULT WINAPI SafeArrayGetUBound(SAFEARRAY *psa, UINT nDim, LONG *plUbound)
995 {
996 TRACE("(%p,%d,%p)\n", psa, nDim, plUbound);
997
998 if (!psa || !plUbound)
999 return E_INVALIDARG;
1000
1001 if(!nDim || nDim > psa->cDims)
1002 return DISP_E_BADINDEX;
1003
1004 *plUbound = psa->rgsabound[psa->cDims - nDim].lLbound +
1005 psa->rgsabound[psa->cDims - nDim].cElements - 1;
1006
1007 return S_OK;
1008 }
1009
1010 /*************************************************************************
1011 * SafeArrayGetLBound (OLEAUT32.20)
1012 *
1013 * Get the lower bound for a given SafeArray dimension
1014 *
1015 * PARAMS
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
1019 *
1020 * RETURNS
1021 * Success: S_OK. plUbound contains the dimensions lower bound.
1022 * Failure: An HRESULT error code indicating the error.
1023 *
1024 * NOTES
1025 * See SafeArray.
1026 */
1027 HRESULT WINAPI SafeArrayGetLBound(SAFEARRAY *psa, UINT nDim, LONG *plLbound)
1028 {
1029 TRACE("(%p,%d,%p)\n", psa, nDim, plLbound);
1030
1031 if (!psa || !plLbound)
1032 return E_INVALIDARG;
1033
1034 if(!nDim || nDim > psa->cDims)
1035 return DISP_E_BADINDEX;
1036
1037 *plLbound = psa->rgsabound[psa->cDims - nDim].lLbound;
1038 return S_OK;
1039 }
1040
1041 /*************************************************************************
1042 * SafeArrayGetDim (OLEAUT32.17)
1043 *
1044 * Get the number of dimensions in a SafeArray.
1045 *
1046 * PARAMS
1047 * psa [I] Array to get the dimensions of
1048 *
1049 * RETURNS
1050 * The number of array dimensions in psa, or 0 if psa is NULL.
1051 *
1052 * NOTES
1053 * See SafeArray.
1054 */
1055 UINT WINAPI SafeArrayGetDim(SAFEARRAY *psa)
1056 {
1057 TRACE("(%p) returning %d\n", psa, psa ? psa->cDims : 0u);
1058 return psa ? psa->cDims : 0;
1059 }
1060
1061 /*************************************************************************
1062 * SafeArrayGetElemsize (OLEAUT32.18)
1063 *
1064 * Get the size of an element in a SafeArray.
1065 *
1066 * PARAMS
1067 * psa [I] Array to get the element size from
1068 *
1069 * RETURNS
1070 * The size of a single element in psa, or 0 if psa is NULL.
1071 *
1072 * NOTES
1073 * See SafeArray.
1074 */
1075 UINT WINAPI SafeArrayGetElemsize(SAFEARRAY *psa)
1076 {
1077 TRACE("(%p) returning %d\n", psa, psa ? psa->cbElements : 0u);
1078 return psa ? psa->cbElements : 0;
1079 }
1080
1081 /*************************************************************************
1082 * SafeArrayAccessData (OLEAUT32.23)
1083 *
1084 * Lock a SafeArray and return a pointer to its data.
1085 *
1086 * PARAMS
1087 * psa [I] Array to get the data pointer from
1088 * ppvData [O] Destination for the arrays data pointer
1089 *
1090 * RETURNS
1091 * Success: S_OK. ppvData contains the arrays data pointer, and the array
1092 * is locked.
1093 * Failure: An HRESULT error code indicating the error.
1094 *
1095 * NOTES
1096 * See SafeArray.
1097 */
1098 HRESULT WINAPI SafeArrayAccessData(SAFEARRAY *psa, void **ppvData)
1099 {
1100 TRACE("(%p,%p)\n", psa, ppvData);
1101
1102 if(!psa || !ppvData)
1103 return E_INVALIDARG;
1104
1105 if (SUCCEEDED(SafeArrayLock(psa)))
1106 {
1107 *ppvData = psa->pvData;
1108 return S_OK;
1109 }
1110 *ppvData = NULL;
1111 return E_UNEXPECTED;
1112 }
1113
1114
1115 /*************************************************************************
1116 * SafeArrayUnaccessData (OLEAUT32.24)
1117 *
1118 * Unlock a SafeArray after accessing its data.
1119 *
1120 * PARAMS
1121 * psa [I] Array to unlock
1122 *
1123 * RETURNS
1124 * Success: S_OK. The array is unlocked.
1125 * Failure: An HRESULT error code indicating the error.
1126 *
1127 * NOTES
1128 * See SafeArray.
1129 */
1130 HRESULT WINAPI SafeArrayUnaccessData(SAFEARRAY *psa)
1131 {
1132 TRACE("(%p)\n", psa);
1133 return SafeArrayUnlock(psa);
1134 }
1135
1136 /************************************************************************
1137 * SafeArrayPtrOfIndex (OLEAUT32.148)
1138 *
1139 * Get the address of an item in a SafeArray.
1140 *
1141 * PARAMS
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
1145 *
1146 * RETURNS
1147 * Success: S_OK. ppvData contains a pointer to the item.
1148 * Failure: An HRESULT error code indicating the error.
1149 *
1150 * NOTES
1151 * This function does not lock the array.
1152 *
1153 * NOTES
1154 * See SafeArray.
1155 */
1156 HRESULT WINAPI SafeArrayPtrOfIndex(SAFEARRAY *psa, LONG *rgIndices, void **ppvData)
1157 {
1158 USHORT dim;
1159 ULONG cell = 0, dimensionSize = 1;
1160 SAFEARRAYBOUND* psab;
1161 LONG c1;
1162
1163 TRACE("(%p,%p,%p)\n", psa, rgIndices, ppvData);
1164
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:
1167 *
1168 * c1 + c2 * sizeof(d1) + c3 * sizeof(d2) ... + cn * sizeof(c(n-1))
1169 *
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.
1172 */
1173 if (!psa || !rgIndices || !ppvData)
1174 return E_INVALIDARG;
1175
1176 psab = psa->rgsabound + psa->cDims - 1;
1177 c1 = *rgIndices++;
1178
1179 if (c1 < psab->lLbound || c1 >= psab->lLbound + (LONG)psab->cElements)
1180 return DISP_E_BADINDEX; /* Initial index out of bounds */
1181
1182 for (dim = 1; dim < psa->cDims; dim++)
1183 {
1184 dimensionSize *= psab->cElements;
1185
1186 psab--;
1187
1188 if (!psab->cElements ||
1189 *rgIndices < psab->lLbound ||
1190 *rgIndices >= psab->lLbound + (LONG)psab->cElements)
1191 return DISP_E_BADINDEX; /* Index out of bounds */
1192
1193 cell += (*rgIndices - psab->lLbound) * dimensionSize;
1194 rgIndices++;
1195 }
1196
1197 cell += (c1 - psa->rgsabound[psa->cDims - 1].lLbound);
1198
1199 *ppvData = (char*)psa->pvData + cell * psa->cbElements;
1200 return S_OK;
1201 }
1202
1203 /************************************************************************
1204 * SafeArrayDestroyData (OLEAUT32.39)
1205 *
1206 * Destroy the data associated with a SafeArray.
1207 *
1208 * PARAMS
1209 * psa [I] Array to delete the data from
1210 *
1211 * RETURNS
1212 * Success: S_OK. All items and the item data are freed.
1213 * Failure: An HRESULT error code indicating the error.
1214 *
1215 * NOTES
1216 * See SafeArray.
1217 */
1218 HRESULT WINAPI SafeArrayDestroyData(SAFEARRAY *psa)
1219 {
1220 TRACE("(%p)\n", psa);
1221
1222 if (!psa)
1223 return E_INVALIDARG;
1224
1225 if (psa->cLocks)
1226 return DISP_E_ARRAYISLOCKED; /* Can't delete a locked array */
1227
1228 /* Delete the actual item data */
1229 if (FAILED(SAFEARRAY_DestroyData(psa, 0)))
1230 return E_UNEXPECTED;
1231
1232 if (psa->pvData)
1233 {
1234 if (psa->fFeatures & FADF_STATIC)
1235 {
1236 ZeroMemory(psa->pvData, SAFEARRAY_GetCellCount(psa) * psa->cbElements);
1237 return S_OK;
1238 }
1239 /* If this is not a vector, free the data memory block */
1240 if (!(psa->fFeatures & FADF_CREATEVECTOR))
1241 {
1242 if (!SAFEARRAY_Free(psa->pvData))
1243 return E_UNEXPECTED;
1244 psa->pvData = NULL;
1245 }
1246 else
1247 psa->fFeatures |= FADF_DATADELETED; /* Mark the data deleted */
1248
1249 }
1250 return S_OK;
1251 }
1252
1253 /************************************************************************
1254 * SafeArrayCopyData (OLEAUT32.412)
1255 *
1256 * Copy all data from one SafeArray to another.
1257 *
1258 * PARAMS
1259 * psaSource [I] Source for copy
1260 * psaTarget [O] Destination for copy
1261 *
1262 * RETURNS
1263 * Success: S_OK. psaTarget contains a copy of psaSource.
1264 * Failure: An HRESULT error code indicating the error.
1265 *
1266 * NOTES
1267 * The two arrays must have the same number of dimensions and elements.
1268 *
1269 * NOTES
1270 * See SafeArray.
1271 */
1272 HRESULT WINAPI SafeArrayCopyData(SAFEARRAY *psaSource, SAFEARRAY *psaTarget)
1273 {
1274 int dim;
1275
1276 TRACE("(%p,%p)\n", psaSource, psaTarget);
1277
1278 if (!psaSource || !psaTarget ||
1279 psaSource->cDims != psaTarget->cDims ||
1280 psaSource->cbElements != psaTarget->cbElements)
1281 return E_INVALIDARG;
1282
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;
1288
1289 if (SUCCEEDED(SAFEARRAY_DestroyData(psaTarget, 0)) &&
1290 SUCCEEDED(SAFEARRAY_CopyData(psaSource, psaTarget)))
1291 return S_OK;
1292 return E_UNEXPECTED;
1293 }
1294
1295 /************************************************************************
1296 * SafeArrayDestroy (OLEAUT32.16)
1297 *
1298 * Destroy a SafeArray.
1299 *
1300 * PARAMS
1301 * psa [I] Array to destroy
1302 *
1303 * RETURNS
1304 * Success: S_OK. All resources used by the array are freed.
1305 * Failure: An HRESULT error code indicating the error.
1306 *
1307 * NOTES
1308 * See SafeArray.
1309 */
1310 HRESULT WINAPI SafeArrayDestroy(SAFEARRAY *psa)
1311 {
1312 TRACE("(%p)\n", psa);
1313
1314 if(!psa)
1315 return S_OK;
1316
1317 if(psa->cLocks > 0)
1318 return DISP_E_ARRAYISLOCKED;
1319
1320 /* Native doesn't check to see if the free succeeds */
1321 SafeArrayDestroyData(psa);
1322 SafeArrayDestroyDescriptor(psa);
1323 return S_OK;
1324 }
1325
1326 /************************************************************************
1327 * SafeArrayCopy (OLEAUT32.27)
1328 *
1329 * Make a duplicate of a SafeArray.
1330 *
1331 * PARAMS
1332 * psa [I] Source for copy
1333 * ppsaOut [O] Destination for new copy
1334 *
1335 * RETURNS
1336 * Success: S_OK. ppsaOut contains a copy of the array.
1337 * Failure: An HRESULT error code indicating the error.
1338 *
1339 * NOTES
1340 * See SafeArray.
1341 */
1342 HRESULT WINAPI SafeArrayCopy(SAFEARRAY *psa, SAFEARRAY **ppsaOut)
1343 {
1344 HRESULT hRet;
1345
1346 TRACE("(%p,%p)\n", psa, ppsaOut);
1347
1348 if (!ppsaOut)
1349 return E_INVALIDARG;
1350
1351 *ppsaOut = NULL;
1352
1353 if (!psa)
1354 return S_OK; /* Handles copying of NULL arrays */
1355
1356 if (!psa->cbElements)
1357 {
1358 ERR("not copying an array of 0 elements\n");
1359 return E_INVALIDARG;
1360 }
1361
1362 if (psa->fFeatures & (FADF_RECORD|FADF_HAVEIID|FADF_HAVEVARTYPE))
1363 {
1364 VARTYPE vt;
1365 if (FAILED(SafeArrayGetVartype(psa, &vt)))
1366 hRet = E_UNEXPECTED;
1367 else
1368 hRet = SafeArrayAllocDescriptorEx(vt, psa->cDims, ppsaOut);
1369 }
1370 else
1371 {
1372 hRet = SafeArrayAllocDescriptor(psa->cDims, ppsaOut);
1373 if (SUCCEEDED(hRet))
1374 {
1375 (*ppsaOut)->fFeatures = psa->fFeatures & ~FADF_CREATEVECTOR;
1376 (*ppsaOut)->cbElements = psa->cbElements;
1377 }
1378 }
1379
1380 if (SUCCEEDED(hRet))
1381 {
1382 /* Copy dimension bounds */
1383 memcpy((*ppsaOut)->rgsabound, psa->rgsabound, psa->cDims * sizeof(SAFEARRAYBOUND));
1384
1385 (*ppsaOut)->pvData = SAFEARRAY_Malloc(SAFEARRAY_GetCellCount(psa) * psa->cbElements);
1386
1387 if ((*ppsaOut)->pvData)
1388 {
1389 hRet = SAFEARRAY_CopyData(psa, *ppsaOut);
1390
1391 if (SUCCEEDED(hRet))
1392 return hRet;
1393
1394 SAFEARRAY_Free((*ppsaOut)->pvData);
1395 }
1396 SafeArrayDestroyDescriptor(*ppsaOut);
1397 }
1398 *ppsaOut = NULL;
1399 return hRet;
1400 }
1401
1402 /************************************************************************
1403 * SafeArrayRedim (OLEAUT32.40)
1404 *
1405 * Changes the characteristics of the last dimension of a SafeArray
1406 *
1407 * PARAMS
1408 * psa [I] Array to change
1409 * psabound [I] New bound details for the last dimension
1410 *
1411 * RETURNS
1412 * Success: S_OK. psa is updated to reflect the new bounds.
1413 * Failure: An HRESULT error code indicating the error.
1414 *
1415 * NOTES
1416 * See SafeArray.
1417 */
1418 HRESULT WINAPI SafeArrayRedim(SAFEARRAY *psa, SAFEARRAYBOUND *psabound)
1419 {
1420 SAFEARRAYBOUND *oldBounds;
1421
1422 TRACE("(%p,%p)\n", psa, psabound);
1423
1424 if (!psa || psa->fFeatures & FADF_FIXEDSIZE || !psabound)
1425 return E_INVALIDARG;
1426
1427 if (psa->cLocks > 0)
1428 return DISP_E_ARRAYISLOCKED;
1429
1430 if (FAILED(SafeArrayLock(psa)))
1431 return E_UNEXPECTED;
1432
1433 oldBounds = psa->rgsabound;
1434 oldBounds->lLbound = psabound->lLbound;
1435
1436 if (psabound->cElements != oldBounds->cElements)
1437 {
1438 if (psabound->cElements < oldBounds->cElements)
1439 {
1440 /* Shorten the final dimension. */
1441 ULONG ulStartCell = psabound->cElements *
1442 (SAFEARRAY_GetCellCount(psa) / oldBounds->cElements);
1443 SAFEARRAY_DestroyData(psa, ulStartCell);
1444 }
1445 else
1446 {
1447 /* Lengthen the final dimension */
1448 ULONG ulOldSize, ulNewSize;
1449 PVOID pvNewData;
1450
1451 ulOldSize = SAFEARRAY_GetCellCount(psa) * psa->cbElements;
1452 if (ulOldSize)
1453 ulNewSize = (ulOldSize / oldBounds->cElements) * psabound->cElements;
1454 else {
1455 int oldelems = oldBounds->cElements;
1456 oldBounds->cElements = psabound->cElements;
1457 ulNewSize = SAFEARRAY_GetCellCount(psa) * psa->cbElements;
1458 oldBounds->cElements = oldelems;
1459 }
1460
1461 if (!(pvNewData = SAFEARRAY_Malloc(ulNewSize)))
1462 {
1463 SafeArrayUnlock(psa);
1464 return E_UNEXPECTED;
1465 }
1466
1467 memcpy(pvNewData, psa->pvData, ulOldSize);
1468 SAFEARRAY_Free(psa->pvData);
1469 psa->pvData = pvNewData;
1470 }
1471 oldBounds->cElements = psabound->cElements;
1472 }
1473
1474 SafeArrayUnlock(psa);
1475 return S_OK;
1476 }
1477
1478 /************************************************************************
1479 * SafeArrayGetVartype (OLEAUT32.77)
1480 *
1481 * Get the type of the items in a SafeArray.
1482 *
1483 * PARAMS
1484 * psa [I] Array to get the type from
1485 * pvt [O] Destination for the type
1486 *
1487 * RETURNS
1488 * Success: S_OK. pvt contains the type of the items.
1489 * Failure: An HRESULT error code indicating the error.
1490 *
1491 * NOTES
1492 * See SafeArray.
1493 */
1494 HRESULT WINAPI SafeArrayGetVartype(SAFEARRAY* psa, VARTYPE* pvt)
1495 {
1496 TRACE("(%p,%p)\n", psa, pvt);
1497
1498 if (!psa || !pvt)
1499 return E_INVALIDARG;
1500
1501 if (psa->fFeatures & FADF_RECORD)
1502 *pvt = VT_RECORD;
1503 else if (psa->fFeatures & FADF_HAVEIID)
1504 *pvt = VT_UNKNOWN;
1505 else if (psa->fFeatures & FADF_HAVEVARTYPE)
1506 {
1507 VARTYPE vt = SAFEARRAY_GetHiddenDWORD(psa);
1508 *pvt = vt;
1509 }
1510 else
1511 return E_INVALIDARG;
1512
1513 return S_OK;
1514 }
1515
1516 /************************************************************************
1517 * SafeArraySetRecordInfo (OLEAUT32.@)
1518 *
1519 * Set the record info for a SafeArray.
1520 *
1521 * PARAMS
1522 * psa [I] Array to set the record info for
1523 * pRinfo [I] Record info
1524 *
1525 * RETURNS
1526 * Success: S_OK. The record info is stored with the array.
1527 * Failure: An HRESULT error code indicating the error.
1528 *
1529 * NOTES
1530 * See SafeArray.
1531 */
1532 HRESULT WINAPI SafeArraySetRecordInfo(SAFEARRAY *psa, IRecordInfo *pRinfo)
1533 {
1534 IRecordInfo** dest = (IRecordInfo**)psa;
1535
1536 TRACE("(%p,%p)\n", psa, pRinfo);
1537
1538 if (!psa || !(psa->fFeatures & FADF_RECORD))
1539 return E_INVALIDARG;
1540
1541 if (pRinfo)
1542 IRecordInfo_AddRef(pRinfo);
1543
1544 if (dest[-1])
1545 IRecordInfo_Release(dest[-1]);
1546
1547 dest[-1] = pRinfo;
1548 return S_OK;
1549 }
1550
1551 /************************************************************************
1552 * SafeArrayGetRecordInfo (OLEAUT32.@)
1553 *
1554 * Get the record info from a SafeArray.
1555 *
1556 * PARAMS
1557 * psa [I] Array to get the record info from
1558 * pRinfo [O] Destination for the record info
1559 *
1560 * RETURNS
1561 * Success: S_OK. pRinfo contains the record info, or NULL if there was none.
1562 * Failure: An HRESULT error code indicating the error.
1563 *
1564 * NOTES
1565 * See SafeArray.
1566 */
1567 HRESULT WINAPI SafeArrayGetRecordInfo(SAFEARRAY *psa, IRecordInfo **pRinfo)
1568 {
1569 IRecordInfo** src = (IRecordInfo**)psa;
1570
1571 TRACE("(%p,%p)\n", psa, pRinfo);
1572
1573 if (!psa || !pRinfo || !(psa->fFeatures & FADF_RECORD))
1574 return E_INVALIDARG;
1575
1576 *pRinfo = src[-1];
1577
1578 if (*pRinfo)
1579 IRecordInfo_AddRef(*pRinfo);
1580 return S_OK;
1581 }
1582
1583 /************************************************************************
1584 * SafeArraySetIID (OLEAUT32.@)
1585 *
1586 * Set the IID for a SafeArray.
1587 *
1588 * PARAMS
1589 * psa [I] Array to set the IID from
1590 * guid [I] IID
1591 *
1592 * RETURNS
1593 * Success: S_OK. The IID is stored with the array
1594 * Failure: An HRESULT error code indicating the error.
1595 *
1596 * NOTES
1597 * See SafeArray.
1598 */
1599 HRESULT WINAPI SafeArraySetIID(SAFEARRAY *psa, REFGUID guid)
1600 {
1601 GUID* dest = (GUID*)psa;
1602
1603 TRACE("(%p,%s)\n", psa, debugstr_guid(guid));
1604
1605 if (!psa || !guid || !(psa->fFeatures & FADF_HAVEIID))
1606 return E_INVALIDARG;
1607
1608 dest[-1] = *guid;
1609 return S_OK;
1610 }
1611
1612 /************************************************************************
1613 * SafeArrayGetIID (OLEAUT32.@)
1614 *
1615 * Get the IID from a SafeArray.
1616 *
1617 * PARAMS
1618 * psa [I] Array to get the ID from
1619 * pGuid [O] Destination for the IID
1620 *
1621 * RETURNS
1622 * Success: S_OK. pRinfo contains the IID, or NULL if there was none.
1623 * Failure: An HRESULT error code indicating the error.
1624 *
1625 * NOTES
1626 * See SafeArray.
1627 */
1628 HRESULT WINAPI SafeArrayGetIID(SAFEARRAY *psa, GUID *pGuid)
1629 {
1630 GUID* src = (GUID*)psa;
1631
1632 TRACE("(%p,%p)\n", psa, pGuid);
1633
1634 if (!psa || !pGuid || !(psa->fFeatures & FADF_HAVEIID))
1635 return E_INVALIDARG;
1636
1637 *pGuid = src[-1];
1638 return S_OK;
1639 }
1640
1641 /************************************************************************
1642 * VectorFromBstr (OLEAUT32.@)
1643 *
1644 * Create a SafeArray Vector from the bytes of a BSTR.
1645 *
1646 * PARAMS
1647 * bstr [I] String to get bytes from
1648 * ppsa [O] Destination for the array
1649 *
1650 * RETURNS
1651 * Success: S_OK. ppsa contains the strings bytes as a VT_UI1 array.
1652 * Failure: An HRESULT error code indicating the error.
1653 *
1654 * NOTES
1655 * See SafeArray.
1656 */
1657 HRESULT WINAPI VectorFromBstr(BSTR bstr, SAFEARRAY **ppsa)
1658 {
1659 SAFEARRAYBOUND sab;
1660
1661 TRACE("(%p,%p)\n", bstr, ppsa);
1662
1663 if (!ppsa)
1664 return E_INVALIDARG;
1665
1666 sab.lLbound = 0;
1667 sab.cElements = SysStringByteLen(bstr);
1668
1669 *ppsa = SAFEARRAY_Create(VT_UI1, 1, &sab, 0);
1670
1671 if (*ppsa)
1672 {
1673 memcpy((*ppsa)->pvData, bstr, sab.cElements);
1674 return S_OK;
1675 }
1676 return E_OUTOFMEMORY;
1677 }
1678
1679 /************************************************************************
1680 * BstrFromVector (OLEAUT32.@)
1681 *
1682 * Create a BSTR from a SafeArray.
1683 *
1684 * PARAMS
1685 * psa [I] Source array
1686 * pbstr [O] Destination for output BSTR
1687 *
1688 * RETURNS
1689 * Success: S_OK. pbstr contains the arrays data.
1690 * Failure: An HRESULT error code indicating the error.
1691 *
1692 * NOTES
1693 * psa must be a 1 dimensional array of a 1 byte type.
1694 *
1695 * NOTES
1696 * See SafeArray.
1697 */
1698 HRESULT WINAPI BstrFromVector(SAFEARRAY *psa, BSTR *pbstr)
1699 {
1700 TRACE("(%p,%p)\n", psa, pbstr);
1701
1702 if (!pbstr)
1703 return E_INVALIDARG;
1704
1705 *pbstr = NULL;
1706
1707 if (!psa || psa->cbElements != 1 || psa->cDims != 1)
1708 return E_INVALIDARG;
1709
1710 *pbstr = SysAllocStringByteLen(psa->pvData, psa->rgsabound[0].cElements);
1711 if (!*pbstr)
1712 return E_OUTOFMEMORY;
1713 return S_OK;
1714 }
1715
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.