wined3d: Fix a bug in BtlFast which was uncovered by the 32-bit dibsection support.
[wine] / dlls / oleaut32 / recinfo.c
1 /*
2  * Copyright 2005 Jacek Caban
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include <stdarg.h>
20
21 #define COBJMACROS
22 #define NONAMELESSUNION
23 #define NONAMELESSSTRUCT
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "objbase.h"
28 #include "oaidl.h"
29 #include "oleauto.h"
30
31 #include "wine/unicode.h"
32 #include "wine/debug.h"
33
34 WINE_DEFAULT_DEBUG_CHANNEL(ole);
35
36 typedef struct {
37     enum VARENUM vt;
38     VARKIND varkind;
39     ULONG offset;
40     BSTR name;
41 } fieldstr;
42
43 typedef struct {
44     const IRecordInfoVtbl *lpVtbl;
45     LONG ref;
46
47     GUID guid;
48     UINT lib_index;
49     WORD n_vars;
50     ULONG size;
51     BSTR name;
52     fieldstr *fields;
53     ITypeInfo *pTypeInfo;
54 } IRecordInfoImpl;
55
56 static HRESULT copy_to_variant(void *src, VARIANT *pvar, enum VARENUM vt)
57 {
58     TRACE("%p %p %d\n", src, pvar, vt);
59
60 #define CASE_COPY(x) \
61     case VT_ ## x: \
62         memcpy(&V_ ## x(pvar), src, sizeof(V_ ## x(pvar))); \
63         break 
64
65     switch(vt) {
66         CASE_COPY(I2);
67         CASE_COPY(I4);
68         CASE_COPY(R4);
69         CASE_COPY(R8);
70         CASE_COPY(CY);
71         CASE_COPY(DATE);
72         CASE_COPY(BSTR);
73         CASE_COPY(ERROR);
74         CASE_COPY(BOOL);
75         CASE_COPY(DECIMAL);
76         CASE_COPY(I1);
77         CASE_COPY(UI1);
78         CASE_COPY(UI2);
79         CASE_COPY(UI4);
80         CASE_COPY(I8);
81         CASE_COPY(UI8);
82         CASE_COPY(INT);
83         CASE_COPY(UINT);
84         CASE_COPY(INT_PTR);
85         CASE_COPY(UINT_PTR);
86     default:
87         FIXME("Not supported type: %d\n", vt);
88         return E_NOTIMPL;
89     };
90 #undef CASE_COPY
91
92     V_VT(pvar) = vt;
93     return S_OK;
94 }
95
96 static HRESULT copy_from_variant(VARIANT *src, void *dest, enum VARENUM vt)
97 {
98     VARIANT var;
99     HRESULT hres;
100
101     TRACE("(%p(%d) %p %d)\n", src, V_VT(src), dest, vt);
102
103     hres = VariantChangeType(&var, src, 0, vt);
104     if(FAILED(hres))
105         return hres;
106
107 #define CASE_COPY(x) \
108     case VT_ ## x: \
109         memcpy(dest, &V_ ## x(&var), sizeof(V_ ## x(&var))); \
110         break
111
112     switch(vt) {
113         CASE_COPY(I2);
114         CASE_COPY(I4);
115         CASE_COPY(R4);
116         CASE_COPY(R8);
117         CASE_COPY(CY);
118         CASE_COPY(DATE);
119         CASE_COPY(BSTR);
120         CASE_COPY(ERROR);
121         CASE_COPY(BOOL);
122         CASE_COPY(DECIMAL);
123         CASE_COPY(I1);
124         CASE_COPY(UI1);
125         CASE_COPY(UI2);
126         CASE_COPY(UI4);
127         CASE_COPY(I8);
128         CASE_COPY(UI8);
129         CASE_COPY(INT);
130         CASE_COPY(UINT);
131         CASE_COPY(INT_PTR);
132         CASE_COPY(UINT_PTR);
133     default:
134         FIXME("Not supported type: %d\n", V_VT(&var));
135         return E_NOTIMPL;
136     };
137 #undef CASE_COPY
138     return S_OK;
139 }
140
141 static HRESULT WINAPI IRecordInfoImpl_QueryInterface(IRecordInfo *iface, REFIID riid,
142                                                 void **ppvObject)
143 {
144     TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppvObject);
145
146     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IRecordInfo, riid)) {
147        *ppvObject = iface;
148        IRecordInfo_AddRef(iface);
149        return S_OK;
150     }
151
152     FIXME("Not supported interface: %s\n", debugstr_guid(riid));
153     return E_NOINTERFACE;
154 }
155
156 static ULONG WINAPI IRecordInfoImpl_AddRef(IRecordInfo *iface)
157 {
158     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
159     ULONG ref = InterlockedIncrement(&This->ref);
160     TRACE("(%p) -> %d\n", This, ref);
161     return ref;
162 }
163
164 static ULONG WINAPI IRecordInfoImpl_Release(IRecordInfo *iface)
165 {
166     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
167     ULONG ref = InterlockedDecrement(&This->ref);
168
169     TRACE("(%p) -> %d\n", This, ref);
170
171     if(!ref) {
172         int i;
173         for(i=0; i<This->n_vars; i++)
174             SysFreeString(This->fields[i].name);
175         HeapFree(GetProcessHeap(), 0, This->name);
176         HeapFree(GetProcessHeap(), 0, This->fields);
177         ITypeInfo_Release(This->pTypeInfo);
178         HeapFree(GetProcessHeap(), 0, This);
179     }
180     return ref;
181 }
182
183 static HRESULT WINAPI IRecordInfoImpl_RecordInit(IRecordInfo *iface, PVOID pvNew)
184 {
185     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
186     TRACE("(%p)->(%p)\n", This, pvNew);
187
188     if(!pvNew)
189         return E_INVALIDARG;
190
191     memset(pvNew, 0, This->size);
192     return S_OK;
193 }
194
195 static HRESULT WINAPI IRecordInfoImpl_RecordClear(IRecordInfo *iface, PVOID pvExisting)
196 {
197     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
198     int i;
199     PVOID var;
200
201     TRACE("(%p)->(%p)\n", This, pvExisting);
202
203     if(!pvExisting)
204         return E_INVALIDARG;
205
206     for(i=0; i<This->n_vars; i++) {
207         if(This->fields[i].varkind != VAR_PERINSTANCE) {
208             ERR("varkind != VAR_PERINSTANCE\n");
209             continue;
210         }
211         var = ((PBYTE)pvExisting)+This->fields[i].offset;
212         switch(This->fields[i].vt) {
213             case VT_BSTR:
214                SysFreeString(*(BSTR*)var);
215                 *(BSTR*)var = NULL;
216                 break;
217             case VT_I2:
218             case VT_I4:
219             case VT_R4:
220             case VT_R8:
221             case VT_CY:
222             case VT_DATE:
223             case VT_ERROR:
224             case VT_BOOL:
225             case VT_DECIMAL:
226             case VT_I1:
227             case VT_UI1:
228             case VT_UI2:
229             case VT_UI4:
230             case VT_I8:
231             case VT_UI8:
232             case VT_INT:
233             case VT_UINT:
234                 break;
235             case VT_INT_PTR:
236             case VT_UINT_PTR:
237                 *(void**)var = NULL;
238                 break;
239             case VT_SAFEARRAY:
240                 SafeArrayDestroy(var);
241                 break;
242             default:
243                 FIXME("Not supported vt = %d\n", This->fields[i].vt);
244                 break;
245         }
246     }
247     
248     return S_OK;
249 }
250
251 static HRESULT WINAPI IRecordInfoImpl_RecordCopy(IRecordInfo *iface, PVOID pvExisting,
252                                                 PVOID pvNew)
253 {
254     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
255
256     TRACE("(%p)->(%p %p)\n", This, pvExisting, pvNew);
257     
258     if(!pvExisting || !pvNew)
259         return E_INVALIDARG;
260
261     memcpy(pvExisting, pvNew, This->size);
262     return S_OK;
263 }
264
265 static HRESULT WINAPI IRecordInfoImpl_GetGuid(IRecordInfo *iface, GUID *pguid)
266 {
267     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
268
269     TRACE("(%p)->(%p)\n", This, pguid);
270
271     if(!pguid)
272         return E_INVALIDARG;
273
274     *pguid = This->guid;
275     return S_OK;
276 }
277
278 static HRESULT WINAPI IRecordInfoImpl_GetName(IRecordInfo *iface, BSTR *pbstrName)
279 {
280     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
281
282     TRACE("(%p)->(%p)\n", This, pbstrName);
283
284     if(!pbstrName)
285         return E_INVALIDARG;
286
287     *pbstrName = SysAllocString(This->name);
288     return S_OK;
289 }
290
291 static HRESULT WINAPI IRecordInfoImpl_GetSize(IRecordInfo *iface, ULONG *pcbSize)
292 {
293     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
294     
295     TRACE("(%p)->(%p)\n", This, pcbSize);
296
297     if(!pcbSize)
298         return E_INVALIDARG;
299     
300     *pcbSize = This->size;
301     return S_OK;
302 }
303
304 static HRESULT WINAPI IRecordInfoImpl_GetTypeInfo(IRecordInfo *iface, ITypeInfo **ppTypeInfo)
305 {
306     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
307
308     TRACE("(%p)->(%p)\n", This, ppTypeInfo);
309
310     if(!ppTypeInfo)
311         return E_INVALIDARG;
312
313     ITypeInfo_AddRef(This->pTypeInfo);
314     *ppTypeInfo = This->pTypeInfo;
315
316     return S_OK;
317 }
318
319 static HRESULT WINAPI IRecordInfoImpl_GetField(IRecordInfo *iface, PVOID pvData,
320                                                 LPCOLESTR szFieldName, VARIANT *pvarField)
321 {
322     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
323     int i;
324
325     TRACE("(%p)->(%p %s %p)\n", This, pvData, debugstr_w(szFieldName), pvarField);
326
327     if(!pvData || !szFieldName || !pvarField)
328         return E_INVALIDARG;
329
330     for(i=0; i<This->n_vars; i++)
331         if(!strcmpW(This->fields[i].name, szFieldName))
332             break;
333     if(i == This->n_vars)
334         return TYPE_E_FIELDNOTFOUND;
335     
336     VariantClear(pvarField);
337     return copy_to_variant(((PBYTE)pvData)+This->fields[i].offset, pvarField,
338             This->fields[i].vt);
339 }
340
341 static HRESULT WINAPI IRecordInfoImpl_GetFieldNoCopy(IRecordInfo *iface, PVOID pvData,
342                             LPCOLESTR szFieldName, VARIANT *pvarField, PVOID *ppvDataCArray)
343 {
344     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
345     int i;
346
347     TRACE("(%p)->(%p %s %p %p)\n", This, pvData, debugstr_w(szFieldName), pvarField, ppvDataCArray);
348
349     if(!pvData || !szFieldName || !pvarField)
350         return E_INVALIDARG;
351
352     for(i=0; i<This->n_vars; i++)
353         if(!strcmpW(This->fields[i].name, szFieldName))
354             break;
355     if(i == This->n_vars)
356         return TYPE_E_FIELDNOTFOUND;
357
358     VariantClear(pvarField);
359     V_VT(pvarField) = VT_BYREF|This->fields[i].vt;
360     V_BYREF(pvarField) = ((PBYTE)pvData)+This->fields[i].offset;
361     *ppvDataCArray = NULL;
362     return S_OK;
363 }
364
365 static HRESULT WINAPI IRecordInfoImpl_PutField(IRecordInfo *iface, ULONG wFlags, PVOID pvData,
366                                             LPCOLESTR szFieldName, VARIANT *pvarField)
367 {
368     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
369     int i;
370
371     TRACE("(%p)->(%08x %p %s %p)\n", This, wFlags, pvData, debugstr_w(szFieldName),
372                                     pvarField);
373
374     if(!pvData || !szFieldName || !pvarField
375             || (wFlags != INVOKE_PROPERTYPUTREF && wFlags != INVOKE_PROPERTYPUT))
376         return E_INVALIDARG;
377
378     if(wFlags == INVOKE_PROPERTYPUTREF) {
379         FIXME("wFlag == INVOKE_PROPERTYPUTREF not supported\n");
380         return E_NOTIMPL;
381     }
382
383     for(i=0; i<This->n_vars; i++)
384         if(!strcmpW(This->fields[i].name, szFieldName))
385             break;
386     if(i == This->n_vars)
387         return TYPE_E_FIELDNOTFOUND;
388
389     return copy_from_variant(pvarField, ((PBYTE)pvData)+This->fields[i].offset,
390             This->fields[i].vt);
391 }
392
393 static HRESULT WINAPI IRecordInfoImpl_PutFieldNoCopy(IRecordInfo *iface, ULONG wFlags,
394                 PVOID pvData, LPCOLESTR szFieldName, VARIANT *pvarField)
395 {
396     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
397     int i;
398
399     FIXME("(%p)->(%08x %p %s %p) stub\n", This, wFlags, pvData, debugstr_w(szFieldName), pvarField);
400
401     if(!pvData || !szFieldName || !pvarField
402             || (wFlags != INVOKE_PROPERTYPUTREF && wFlags != INVOKE_PROPERTYPUT))
403         return E_INVALIDARG;
404
405     for(i=0; i<This->n_vars; i++)
406         if(!strcmpW(This->fields[i].name, szFieldName))
407             break;
408     if(i == This->n_vars)
409         return TYPE_E_FIELDNOTFOUND;
410
411     return E_NOTIMPL;
412 }
413
414 static HRESULT WINAPI IRecordInfoImpl_GetFieldNames(IRecordInfo *iface, ULONG *pcNames,
415                                                 BSTR *rgBstrNames)
416 {
417     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
418     ULONG n = This->n_vars, i;
419
420     TRACE("(%p)->(%p %p)\n", This, pcNames, rgBstrNames);
421
422     if(!pcNames)
423         return E_INVALIDARG;
424
425     if(*pcNames < n)
426         n =  *pcNames;
427
428     if(rgBstrNames) {
429         for(i=0; i<n; i++)
430             rgBstrNames[i] = SysAllocString(This->fields[i].name);
431     }
432     
433     *pcNames = n;
434     return S_OK;
435 }
436
437 static BOOL WINAPI IRecordInfoImpl_IsMatchingType(IRecordInfo *iface, IRecordInfo *pRecordInfo)
438 {
439     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
440
441     FIXME("(%p)->(%p) stub\n", This, pRecordInfo);
442
443     return FALSE;
444 }
445
446 static PVOID WINAPI IRecordInfoImpl_RecordCreate(IRecordInfo *iface)
447 {
448     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
449
450     TRACE("(%p)\n", This);
451
452     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->size);
453 }
454
455 static HRESULT WINAPI IRecordInfoImpl_RecordCreateCopy(IRecordInfo *iface, PVOID pvSource,
456                                                     PVOID *ppvDest)
457 {
458     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
459
460     TRACE("(%p)->(%p %p)\n", This, pvSource, ppvDest);
461
462     if(!pvSource || !ppvDest)
463         return E_INVALIDARG;
464     
465     *ppvDest = IRecordInfo_RecordCreate(iface);
466     return IRecordInfo_RecordCopy(iface, pvSource, *ppvDest);
467 }
468
469 static HRESULT WINAPI IRecordInfoImpl_RecordDestroy(IRecordInfo *iface, PVOID pvRecord)
470 {
471     IRecordInfoImpl *This = (IRecordInfoImpl*)iface;
472     HRESULT hres;
473
474     TRACE("(%p)->(%p)\n", This, pvRecord);
475
476     hres = IRecordInfo_RecordClear(iface, pvRecord);
477     if(FAILED(hres))
478         return hres;
479
480     if(!HeapFree(GetProcessHeap(), 0, pvRecord))
481         return E_INVALIDARG;
482
483     return S_OK;
484 }
485
486 static const IRecordInfoVtbl IRecordInfoImplVtbl = {
487     IRecordInfoImpl_QueryInterface,
488     IRecordInfoImpl_AddRef,
489     IRecordInfoImpl_Release,
490     IRecordInfoImpl_RecordInit,
491     IRecordInfoImpl_RecordClear,
492     IRecordInfoImpl_RecordCopy,
493     IRecordInfoImpl_GetGuid,
494     IRecordInfoImpl_GetName,
495     IRecordInfoImpl_GetSize,
496     IRecordInfoImpl_GetTypeInfo,
497     IRecordInfoImpl_GetField,
498     IRecordInfoImpl_GetFieldNoCopy,
499     IRecordInfoImpl_PutField,
500     IRecordInfoImpl_PutFieldNoCopy,
501     IRecordInfoImpl_GetFieldNames,
502     IRecordInfoImpl_IsMatchingType,
503     IRecordInfoImpl_RecordCreate,
504     IRecordInfoImpl_RecordCreateCopy,
505     IRecordInfoImpl_RecordDestroy
506 };
507
508 /******************************************************************************
509  *      GetRecordInfoFromGuids  [OLEAUT32.322]
510  *
511  * RETURNS
512  *  Success: S_OK
513  *  Failure: E_INVALIDARG, if any argument is invalid.
514  */
515 HRESULT WINAPI GetRecordInfoFromGuids(REFGUID rGuidTypeLib, ULONG uVerMajor,
516                         ULONG uVerMinor, LCID lcid, REFGUID rGuidTypeInfo, IRecordInfo** ppRecInfo)
517 {
518     ITypeInfo *pTypeInfo;
519     ITypeLib *pTypeLib;
520     HRESULT hres;
521     
522     TRACE("(%p,%d,%d,%d,%p,%p)\n", rGuidTypeLib, uVerMajor, uVerMinor,
523             lcid, rGuidTypeInfo, ppRecInfo);
524
525     hres = LoadRegTypeLib(rGuidTypeLib, uVerMajor, uVerMinor, lcid, &pTypeLib);
526     if(FAILED(hres)) {
527         WARN("LoadRegTypeLib failed!\n");
528         return hres;
529     }
530
531     hres = ITypeLib_GetTypeInfoOfGuid(pTypeLib, rGuidTypeInfo, &pTypeInfo);
532     ITypeLib_Release(pTypeLib);
533     if(FAILED(hres)) {
534         WARN("GetTypeInfoOfGuid failed!\n");
535         return hres;
536     }
537
538     hres = GetRecordInfoFromTypeInfo(pTypeInfo, ppRecInfo);
539     ITypeInfo_Release(pTypeInfo);
540     return hres;
541 }
542
543 /******************************************************************************
544  *      GetRecordInfoFromTypeInfo [OLEAUT32.332]
545  */
546 HRESULT WINAPI GetRecordInfoFromTypeInfo(ITypeInfo* pTI, IRecordInfo** ppRecInfo) {
547     HRESULT hres;
548     TYPEATTR *typeattr;
549     IRecordInfoImpl *ret;
550     ITypeInfo *pTypeInfo;
551     int i;
552     GUID guid;
553
554     TRACE("(%p %p)\n", pTI, ppRecInfo);
555
556     if(!pTI || !ppRecInfo)
557         return E_INVALIDARG;
558     
559     hres = ITypeInfo_GetTypeAttr(pTI, &typeattr);
560     if(FAILED(hres) || !typeattr) {
561         WARN("GetTypeAttr failed: %08x\n", hres);
562         return hres;
563     }
564
565     if(typeattr->typekind == TKIND_ALIAS) {
566         hres = ITypeInfo_GetRefTypeInfo(pTI, typeattr->tdescAlias.u.hreftype, &pTypeInfo);
567         guid = typeattr->guid;
568         ITypeInfo_ReleaseTypeAttr(pTI, typeattr);
569         if(FAILED(hres)) {
570             WARN("GetRefTypeInfo failed: %08x\n", hres);
571             return hres;
572         }
573         ITypeInfo_GetTypeAttr(pTypeInfo, &typeattr);
574     }else  {
575         pTypeInfo = pTI;
576         ITypeInfo_AddRef(pTypeInfo);
577         guid = typeattr->guid;
578     }
579
580     if(typeattr->typekind != TKIND_RECORD) {
581         WARN("typekind != TKIND_RECORD\n");
582         ITypeInfo_ReleaseTypeAttr(pTypeInfo, typeattr);
583         ITypeInfo_Release(pTypeInfo);
584         return E_INVALIDARG;
585     }
586
587     ret = HeapAlloc(GetProcessHeap(), 0, sizeof(*ret));
588     ret->lpVtbl = &IRecordInfoImplVtbl;
589     ret->ref = 1;
590     ret->pTypeInfo = pTypeInfo;
591     ret->n_vars = typeattr->cVars;
592     ret->size = typeattr->cbSizeInstance;
593     ITypeInfo_ReleaseTypeAttr(pTypeInfo, typeattr);
594
595     ret->guid = guid;
596
597     /* NOTE: Windows implementation calls ITypeInfo::GetCantainingTypeLib and
598      *       ITypeLib::GetLibAttr, but we currently don't need this.
599      */
600
601     hres = ITypeInfo_GetDocumentation(pTypeInfo, MEMBERID_NIL, &ret->name, NULL, NULL, NULL);
602     if(FAILED(hres)) {
603         WARN("ITypeInfo::GetDocumentation failed\n");
604         ret->name = NULL;
605     }
606
607     ret->fields = HeapAlloc(GetProcessHeap(), 0, ret->n_vars*sizeof(VARDESC));
608     for(i = 0; i<ret->n_vars; i++) {
609         VARDESC *vardesc;
610         hres = ITypeInfo_GetVarDesc(pTypeInfo, i, &vardesc);
611         if(FAILED(hres)) {
612             WARN("GetVarDesc failed\n");
613             continue;
614         }
615         ret->fields[i].vt = vardesc->elemdescVar.tdesc.vt;
616         ret->fields[i].varkind = vardesc->varkind;
617         ret->fields[i].offset = vardesc->u.oInst;
618         hres = ITypeInfo_GetDocumentation(pTypeInfo, vardesc->memid, &ret->fields[i].name,
619                 NULL, NULL, NULL);
620         if(FAILED(hres))
621             WARN("GetDocumentation failed: %08x\n", hres);
622         ITypeInfo_ReleaseVarDesc(pTypeInfo, vardesc);
623     }
624         
625     *ppRecInfo = (IRecordInfo*)ret;
626
627     return S_OK;
628 }