?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Drop support for WINED3DFMT_D32_UNORM.
[wine.git] / dlls / oledb32 / convert.c
bloba53d926b29042f7a25abef2dde12b455802225a0
1 /* OLE DB Conversion library
2 *
3 * Copyright 2009 Huw Davies
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #include <stdarg.h>
21
22 #define COBJMACROS
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winnls.h"
27 #include "ole2.h"
28 #include "msdadc.h"
29 #include "oledberr.h"
30
31 #include "oledb_private.h"
32
33 #include "wine/debug.h"
34 #include "wine/heap.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(oledb);
37
38 typedef struct
39 {
40 IDataConvert IDataConvert_iface;
41 IDCInfo IDCInfo_iface;
42
43 LONG ref;
44
45 UINT version; /* Set by IDCInfo_SetInfo */
46 } convert;
47
48 static inline convert *impl_from_IDataConvert(IDataConvert *iface)
49 {
50 return CONTAINING_RECORD(iface, convert, IDataConvert_iface);
51 }
52
53 static inline convert *impl_from_IDCInfo(IDCInfo *iface)
54 {
55 return CONTAINING_RECORD(iface, convert, IDCInfo_iface);
56 }
57
58 static HRESULT WINAPI convert_QueryInterface(IDataConvert* iface,
59 REFIID riid,
60 void **obj)
61 {
62 convert *This = impl_from_IDataConvert(iface);
63 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), obj);
64
65 *obj = NULL;
66
67 if(IsEqualIID(riid, &IID_IUnknown) ||
68 IsEqualIID(riid, &IID_IDataConvert))
69 {
70 *obj = iface;
71 }
72 else if(IsEqualIID(riid, &IID_IDCInfo))
73 {
74 *obj = &This->IDCInfo_iface;
75 }
76 else
77 {
78 FIXME("interface %s not implemented\n", debugstr_guid(riid));
79 return E_NOINTERFACE;
80 }
81
82 IDataConvert_AddRef(iface);
83 return S_OK;
84 }
85
86
87 static ULONG WINAPI convert_AddRef(IDataConvert* iface)
88 {
89 convert *This = impl_from_IDataConvert(iface);
90 TRACE("(%p)\n", This);
91
92 return InterlockedIncrement(&This->ref);
93 }
94
95
96 static ULONG WINAPI convert_Release(IDataConvert* iface)
97 {
98 convert *This = impl_from_IDataConvert(iface);
99 LONG ref;
100
101 TRACE("(%p)\n", This);
102
103 ref = InterlockedDecrement(&This->ref);
104 if(ref == 0)
105 heap_free(This);
106
107 return ref;
108 }
109
110 static int get_length(DBTYPE type)
111 {
112 switch(type)
113 {
114 case DBTYPE_I1:
115 case DBTYPE_UI1:
116 return 1;
117 case DBTYPE_I2:
118 case DBTYPE_UI2:
119 return 2;
120 case DBTYPE_BOOL:
121 return sizeof(VARIANT_BOOL);
122 case DBTYPE_I4:
123 case DBTYPE_UI4:
124 case DBTYPE_R4:
125 return 4;
126 case DBTYPE_I8:
127 case DBTYPE_UI8:
128 case DBTYPE_R8:
129 case DBTYPE_DATE:
130 return 8;
131 case DBTYPE_DBDATE:
132 return sizeof(DBDATE);
133 case DBTYPE_DBTIMESTAMP:
134 return sizeof(DBTIMESTAMP);
135 case DBTYPE_CY:
136 return sizeof(CY);
137 case DBTYPE_BSTR:
138 return sizeof(BSTR);
139 case DBTYPE_FILETIME:
140 return sizeof(FILETIME);
141 case DBTYPE_GUID:
142 return sizeof(GUID);
143 case DBTYPE_NUMERIC:
144 return sizeof(DB_NUMERIC);
145 case DBTYPE_BYTES:
146 case DBTYPE_WSTR:
147 case DBTYPE_STR:
148 case DBTYPE_BYREF | DBTYPE_WSTR:
149 return 0;
150 case DBTYPE_VARIANT:
151 return sizeof(VARIANT);
152 default:
153 FIXME("Unhandled type %04x\n", type);
154 return 0;
155 }
156 }
157
158 static HRESULT WINAPI convert_DataConvert(IDataConvert* iface,
159 DBTYPE src_type, DBTYPE dst_type,
160 DBLENGTH src_len, DBLENGTH *dst_len,
161 void *src, void *dst,
162 DBLENGTH dst_max_len,
163 DBSTATUS src_status, DBSTATUS *dst_status,
164 BYTE precision, BYTE scale,
165 DBDATACONVERT flags)
166 {
167 convert *This = impl_from_IDataConvert(iface);
168 DBLENGTH dst_len_loc;
169 DBSTATUS dst_status_loc;
170 VARIANT tmp;
171 HRESULT hr;
172
173 TRACE("(%p)->(%d, %d, %ld, %p, %p, %p, %ld, %d, %p, %d, %d, %x)\n", This,
174 src_type, dst_type, src_len, dst_len, src, dst, dst_max_len,
175 src_status, dst_status, precision, scale, flags);
176
177 if (!dst_len) dst_len = &dst_len_loc;
178 if (!dst_status) dst_status = &dst_status_loc;
179
180 *dst_status = DBSTATUS_E_BADACCESSOR;
181
182 if(src_status == DBSTATUS_S_ISNULL)
183 {
184 *dst_status = DBSTATUS_S_ISNULL;
185 *dst_len = 0;
186 return S_OK;
187 }
188
189 if(src_type == DBTYPE_VARIANT && V_VT((VARIANT*)src) == VT_NULL)
190 {
191 if(dst_type == DBTYPE_VARIANT)
192 *dst_len = sizeof(VARIANT);
193
194 *dst_status = DBSTATUS_S_ISNULL;
195 return S_OK;
196 }
197
198 if(IDataConvert_CanConvert(iface, src_type, dst_type) != S_OK)
199 {
200 return DB_E_UNSUPPORTEDCONVERSION;
201 }
202
203 if(dst == NULL && get_length(dst_type) != 0)
204 {
205 *dst_len = get_length(src_type);
206 *dst_status = DBSTATUS_S_OK;
207 return S_OK;
208 }
209
210 if(src_type == DBTYPE_STR)
211 {
212 BSTR b;
213 DWORD len;
214
215 if(flags & DBDATACONVERT_LENGTHFROMNTS)
216 len = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0) - 1;
217 else
218 len = MultiByteToWideChar(CP_ACP, 0, src, src_len, NULL, 0);
219 b = SysAllocStringLen(NULL, len);
220 if(!b) return E_OUTOFMEMORY;
221 if(flags & DBDATACONVERT_LENGTHFROMNTS)
222 MultiByteToWideChar(CP_ACP, 0, src, -1, b, len + 1);
223 else
224 MultiByteToWideChar(CP_ACP, 0, src, src_len, b, len);
225
226 hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
227 &b, dst, dst_max_len, src_status, dst_status,
228 precision, scale, flags);
229
230 SysFreeString(b);
231 return hr;
232 }
233
234 if(src_type == DBTYPE_WSTR)
235 {
236 BSTR b;
237
238 if(flags & DBDATACONVERT_LENGTHFROMNTS)
239 b = SysAllocString(src);
240 else
241 b = SysAllocStringLen(src, src_len / 2);
242 if(!b) return E_OUTOFMEMORY;
243 hr = IDataConvert_DataConvert(iface, DBTYPE_BSTR, dst_type, 0, dst_len,
244 &b, dst, dst_max_len, src_status, dst_status,
245 precision, scale, flags);
246 SysFreeString(b);
247 return hr;
248 }
249
250 switch(dst_type)
251 {
252 case DBTYPE_I1:
253 {
254 signed char *d = dst;
255 switch(src_type)
256 {
257 case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
258 case DBTYPE_I1: *d = *(signed char*)src; hr = S_OK; break;
259 case DBTYPE_I2: hr = VarI1FromI2(*(signed short*)src, d); break;
260 case DBTYPE_I4: hr = VarI1FromI4(*(signed int*)src, d); break;
261 case DBTYPE_R4: hr = VarI1FromR4(*(FLOAT*)src, d); break;
262 case DBTYPE_R8: hr = VarI1FromR8(*(double*)src, d); break;
263 case DBTYPE_CY: hr = VarI1FromCy(*(CY*)src, d); break;
264 case DBTYPE_DATE: hr = VarI1FromDate(*(DATE*)src, d); break;
265 case DBTYPE_BSTR: hr = VarI1FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
266 case DBTYPE_BOOL: hr = VarI1FromBool(*(VARIANT_BOOL*)src, d); break;
267 case DBTYPE_DECIMAL: hr = VarI1FromDec((DECIMAL*)src, d); break;
268 case DBTYPE_UI1: hr = VarI1FromUI1(*(BYTE*)src, d); break;
269 case DBTYPE_UI2: hr = VarI1FromUI2(*(WORD*)src, d); break;
270 case DBTYPE_UI4: hr = VarI1FromUI4(*(DWORD*)src, d); break;
271 case DBTYPE_I8: hr = VarI1FromI8(*(LONGLONG*)src, d); break;
272 case DBTYPE_UI8: hr = VarI1FromUI8(*(ULONGLONG*)src, d); break;
273 case DBTYPE_VARIANT:
274 VariantInit(&tmp);
275 if ((hr = VariantChangeType(&tmp, (VARIANT*)src, 0, VT_I1)) == S_OK)
276 *d = V_I1(&tmp);
277 break;
278 default: FIXME("Unimplemented conversion %04x -> I1\n", src_type); return E_NOTIMPL;
279 }
280 break;
281 }
282
283 case DBTYPE_I2:
284 {
285 signed short *d = dst;
286 switch(src_type)
287 {
288 case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
289 case DBTYPE_I2: *d = *(signed short*)src; hr = S_OK; break;
290 case DBTYPE_I4: hr = VarI2FromI4(*(signed int*)src, d); break;
291 case DBTYPE_R4: hr = VarI2FromR4(*(FLOAT*)src, d); break;
292 case DBTYPE_R8: hr = VarI2FromR8(*(double*)src, d); break;
293 case DBTYPE_CY: hr = VarI2FromCy(*(CY*)src, d); break;
294 case DBTYPE_DATE: hr = VarI2FromDate(*(DATE*)src, d); break;
295 case DBTYPE_BSTR: hr = VarI2FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
296 case DBTYPE_BOOL: hr = VarI2FromBool(*(VARIANT_BOOL*)src, d); break;
297 case DBTYPE_DECIMAL: hr = VarI2FromDec((DECIMAL*)src, d); break;
298 case DBTYPE_I1: hr = VarI2FromI1(*(signed char*)src, d); break;
299 case DBTYPE_UI1: hr = VarI2FromUI1(*(BYTE*)src, d); break;
300 case DBTYPE_UI2: hr = VarI2FromUI2(*(WORD*)src, d); break;
301 case DBTYPE_UI4: hr = VarI2FromUI4(*(DWORD*)src, d); break;
302 case DBTYPE_I8: hr = VarI2FromI8(*(LONGLONG*)src, d); break;
303 case DBTYPE_UI8: hr = VarI2FromUI8(*(ULONGLONG*)src, d); break;
304 case DBTYPE_VARIANT:
305 VariantInit(&tmp);
306 if ((hr = VariantChangeType(&tmp, (VARIANT*)src, 0, VT_I2)) == S_OK)
307 *d = V_I2(&tmp);
308 break;
309 default: FIXME("Unimplemented conversion %04x -> I2\n", src_type); return E_NOTIMPL;
310 }
311 break;
312 }
313
314 case DBTYPE_I4:
315 {
316 signed int *d = dst;
317 switch(src_type)
318 {
319 case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
320 case DBTYPE_I2: hr = VarI4FromI2(*(signed short*)src, d); break;
321 case DBTYPE_I4: *d = *(signed int*)src; hr = S_OK; break;
322 case DBTYPE_R4: hr = VarI4FromR4(*(FLOAT*)src, d); break;
323 case DBTYPE_R8: hr = VarI4FromR8(*(double*)src, d); break;
324 case DBTYPE_CY: hr = VarI4FromCy(*(CY*)src, d); break;
325 case DBTYPE_DATE: hr = VarI4FromDate(*(DATE*)src, d); break;
326 case DBTYPE_BSTR: hr = VarI4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
327 case DBTYPE_BOOL: hr = VarI4FromBool(*(VARIANT_BOOL*)src, d); break;
328 case DBTYPE_DECIMAL: hr = VarI4FromDec((DECIMAL*)src, d); break;
329 case DBTYPE_I1: hr = VarI4FromI1(*(signed char*)src, d); break;
330 case DBTYPE_UI1: hr = VarI4FromUI1(*(BYTE*)src, d); break;
331 case DBTYPE_UI2: hr = VarI4FromUI2(*(WORD*)src, d); break;
332 case DBTYPE_UI4: hr = VarI4FromUI4(*(DWORD*)src, d); break;
333 case DBTYPE_I8: hr = VarI4FromI8(*(LONGLONG*)src, d); break;
334 case DBTYPE_UI8: hr = VarI4FromUI8(*(ULONGLONG*)src, d); break;
335 case DBTYPE_VARIANT:
336 VariantInit(&tmp);
337 if ((hr = VariantChangeType(&tmp, (VARIANT*)src, 0, VT_I4)) == S_OK)
338 *d = V_I4(&tmp);
339 break;
340 default: FIXME("Unimplemented conversion %04x -> I4\n", src_type); return E_NOTIMPL;
341 }
342 break;
343 }
344
345 case DBTYPE_I8:
346 {
347 LONGLONG *d = dst;
348 switch(src_type)
349 {
350 case DBTYPE_BSTR: hr = VarI8FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
351 case DBTYPE_I8: *d = *(LONGLONG*)src; hr = S_OK; break;
352 default: FIXME("Unimplemented conversion %04x -> I8\n", src_type); return E_NOTIMPL;
353 }
354 break;
355 }
356
357 case DBTYPE_R4:
358 {
359 FLOAT *d = dst;
360 switch(src_type)
361 {
362 case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
363 case DBTYPE_I2: hr = VarR4FromI2(*(signed short*)src, d); break;
364 case DBTYPE_I4: hr = VarR4FromI4(*(signed int*)src, d); break;
365 case DBTYPE_R4: *d = *(FLOAT*)src; hr = S_OK; break;
366 case DBTYPE_R8: hr = VarR4FromR8(*(double*)src, d); break;
367 case DBTYPE_CY: hr = VarR4FromCy(*(CY*)src, d); break;
368 case DBTYPE_DATE: hr = VarR4FromDate(*(DATE*)src, d); break;
369 case DBTYPE_BSTR: hr = VarR4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
370 case DBTYPE_BOOL: hr = VarR4FromBool(*(VARIANT_BOOL*)src, d); break;
371 case DBTYPE_DECIMAL: hr = VarR4FromDec((DECIMAL*)src, d); break;
372 case DBTYPE_I1: hr = VarR4FromI1(*(signed char*)src, d); break;
373 case DBTYPE_UI1: hr = VarR4FromUI1(*(BYTE*)src, d); break;
374 case DBTYPE_UI2: hr = VarR4FromUI2(*(WORD*)src, d); break;
375 case DBTYPE_UI4: hr = VarR4FromUI4(*(DWORD*)src, d); break;
376 case DBTYPE_I8: hr = VarR4FromI8(*(LONGLONG*)src, d); break;
377 case DBTYPE_UI8: hr = VarR4FromUI8(*(ULONGLONG*)src, d); break;
378 case DBTYPE_VARIANT:
379 VariantInit(&tmp);
380 if ((hr = VariantChangeType(&tmp, (VARIANT*)src, 0, VT_R4)) == S_OK)
381 *d = V_R4(&tmp);
382 break;
383 default: FIXME("Unimplemented conversion %04x -> R4\n", src_type); return E_NOTIMPL;
384 }
385 break;
386 }
387 case DBTYPE_R8:
388 {
389 DOUBLE *d=dst;
390 switch (src_type)
391 {
392 case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
393 case DBTYPE_I1: hr = VarR8FromI1(*(signed char*)src, d); break;
394 case DBTYPE_I2: hr = VarR8FromI2(*(signed short*)src, d); break;
395 case DBTYPE_I4: hr = VarR8FromI4(*(signed int*)src, d); break;
396 case DBTYPE_I8: hr = VarR8FromI8(*(LONGLONG*)src, d); break;
397 case DBTYPE_UI1: hr = VarR8FromUI1(*(BYTE*)src, d); break;
398 case DBTYPE_UI2: hr = VarR8FromUI2(*(WORD*)src, d); break;
399 case DBTYPE_UI4: hr = VarR8FromUI4(*(DWORD*)src, d); break;
400 case DBTYPE_UI8: hr = VarR8FromUI8(*(ULONGLONG*)src, d); break;
401 case DBTYPE_R4: hr = VarR8FromR4(*(FLOAT*)src, d); break;
402 case DBTYPE_R8: *d = *(DOUBLE*)src; hr = S_OK; break;
403 case DBTYPE_CY: hr = VarR8FromCy(*(CY*)src, d); break;
404 case DBTYPE_DATE: hr = VarR8FromDate(*(DATE*)src, d); break;
405 case DBTYPE_BSTR: hr = VarR8FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
406 case DBTYPE_BOOL: hr = VarR8FromBool(*(VARIANT_BOOL*)src, d); break;
407 case DBTYPE_DECIMAL: hr = VarR8FromDec((DECIMAL*)src, d); break;
408 case DBTYPE_VARIANT:
409 VariantInit(&tmp);
410 if ((hr = VariantChangeType(&tmp, (VARIANT*)src, 0, VT_R8)) == S_OK)
411 *d = V_R8(&tmp);
412 break;
413 default: FIXME("Unimplemented conversion %04x -> R8\n", src_type); return E_NOTIMPL;
414 }
415 break;
416 }
417 case DBTYPE_BOOL:
418 {
419 VARIANT_BOOL *d=dst;
420 switch (src_type)
421 {
422 case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
423 case DBTYPE_I1: hr = VarBoolFromI1(*(signed char*)src, d); break;
424 case DBTYPE_I2: hr = VarBoolFromI2(*(signed short*)src, d); break;
425 case DBTYPE_I4: hr = VarBoolFromI4(*(signed int*)src, d); break;
426 case DBTYPE_I8: hr = VarBoolFromI8(*(LONGLONG*)src, d); break;
427 case DBTYPE_UI1: hr = VarBoolFromUI1(*(BYTE*)src, d); break;
428 case DBTYPE_UI2: hr = VarBoolFromUI2(*(WORD*)src, d); break;
429 case DBTYPE_UI4: hr = VarBoolFromUI4(*(DWORD*)src, d); break;
430 case DBTYPE_UI8: hr = VarBoolFromUI8(*(ULONGLONG*)src, d); break;
431 case DBTYPE_R4: hr = VarBoolFromR4(*(FLOAT*)src, d); break;
432 case DBTYPE_R8: hr = VarBoolFromR8(*(DOUBLE*)src, d); break;
433 case DBTYPE_CY: hr = VarBoolFromCy(*(CY*)src, d); break;
434 case DBTYPE_DATE: hr = VarBoolFromDate(*(DATE*)src, d); break;
435 case DBTYPE_BSTR: hr = VarBoolFromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
436 case DBTYPE_BOOL: *d = *(VARIANT_BOOL*)src; hr = S_OK; break;
437 case DBTYPE_DECIMAL: hr = VarBoolFromDec((DECIMAL*)src, d); break;
438 default: FIXME("Unimplemented conversion %04x -> BOOL\n", src_type); return E_NOTIMPL;
439 }
440 break;
441 }
442 case DBTYPE_DATE:
443 {
444 DATE *d=dst;
445 switch (src_type)
446 {
447 case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
448 case DBTYPE_I1: hr = VarDateFromI1(*(signed char*)src, d); break;
449 case DBTYPE_I2: hr = VarDateFromI2(*(signed short*)src, d); break;
450 case DBTYPE_I4: hr = VarDateFromI4(*(signed int*)src, d); break;
451 case DBTYPE_I8: hr = VarDateFromI8(*(LONGLONG*)src, d); break;
452 case DBTYPE_UI1: hr = VarDateFromUI1(*(BYTE*)src, d); break;
453 case DBTYPE_UI2: hr = VarDateFromUI2(*(WORD*)src, d); break;
454 case DBTYPE_UI4: hr = VarDateFromUI4(*(DWORD*)src, d); break;
455 case DBTYPE_UI8: hr = VarDateFromUI8(*(ULONGLONG*)src, d); break;
456 case DBTYPE_R4: hr = VarDateFromR4(*(FLOAT*)src, d); break;
457 case DBTYPE_R8: hr = VarDateFromR8(*(DOUBLE*)src, d); break;
458 case DBTYPE_CY: hr = VarDateFromCy(*(CY*)src, d); break;
459 case DBTYPE_DATE: *d = *(DATE*)src; hr = S_OK; break;
460 case DBTYPE_BSTR: hr = VarDateFromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
461 case DBTYPE_BOOL: hr = VarDateFromBool(*(VARIANT_BOOL*)src, d); break;
462 case DBTYPE_DECIMAL: hr = VarDateFromDec((DECIMAL*)src, d); break;
463 case DBTYPE_DBTIMESTAMP:
464 {
465 SYSTEMTIME st;
466 DBTIMESTAMP *ts=(DBTIMESTAMP*)src;
467
468 st.wYear = ts->year;
469 st.wMonth = ts->month;
470 st.wDay = ts->day;
471 st.wHour = ts->hour;
472 st.wMinute = ts->minute;
473 st.wSecond = ts->second;
474 st.wMilliseconds = ts->fraction/1000000;
475 hr = (SystemTimeToVariantTime(&st, d) ? S_OK : E_FAIL);
476 break;
477 }
478 default: FIXME("Unimplemented conversion %04x -> DATE\n", src_type); return E_NOTIMPL;
479 }
480 break;
481 }
482 case DBTYPE_DBDATE:
483 {
484 DBDATE *d=dst;
485 switch (src_type)
486 {
487 case DBTYPE_DBDATE: memcpy(d, src, sizeof(DBDATE)); hr = S_OK; break;
488 case DBTYPE_BSTR:
489 {
490 VARIANT var;
491 BSTR s = *(WCHAR**)src;
492
493 VariantInit(&var);
494 V_VT(&var) = VT_BSTR;
495 V_BSTR(&var) = SysAllocString(s);
496
497 if ((hr = VariantChangeType(&var, &var, 0, VT_DATE)) == S_OK)
498 {
499 SYSTEMTIME st;
500 hr = (VariantTimeToSystemTime( V_DATE(&var), &st) ? S_OK : E_FAIL);
501 d->year = st.wYear;
502 d->month = st.wMonth;
503 d->day = st.wDay;
504 }
505
506 VariantClear(&var);
507 }
508 break;
509 case DBTYPE_VARIANT:
510 {
511 VariantInit(&tmp);
512
513 if ((hr = VariantChangeType(&tmp, (VARIANT*)src, 0, VT_DATE)) == S_OK)
514 {
515 SYSTEMTIME st;
516 hr = (VariantTimeToSystemTime( V_DATE(&tmp), &st) ? S_OK : E_FAIL);
517 d->year = st.wYear;
518 d->month = st.wMonth;
519 d->day = st.wDay;
520 }
521 else
522 {
523 FIXME("Unimplemented variant type %d -> DBDATE\n", V_VT((VARIANT*)src));
524 return E_NOTIMPL;
525 }
526 break;
527 }
528 default: FIXME("Unimplemented conversion %04x -> DBDATE\n", src_type); return E_NOTIMPL;
529 }
530 break;
531 }
532 case DBTYPE_DBTIMESTAMP:
533 {
534 DBTIMESTAMP *d=dst;
535 switch (src_type)
536 {
537 case DBTYPE_EMPTY: memset(d, 0, sizeof(DBTIMESTAMP)); hr = S_OK; break;
538 case DBTYPE_DBTIMESTAMP: memcpy(d, src, sizeof(DBTIMESTAMP)); hr = S_OK; break;
539 case DBTYPE_BSTR:
540 {
541 VARIANT var;
542 BSTR s = *(WCHAR**)src;
543
544 VariantInit(&var);
545 V_VT(&var) = VT_BSTR;
546 V_BSTR(&var) = SysAllocString(s);
547
548 if ((hr = VariantChangeType(&var, &var, 0, VT_DATE)) == S_OK)
549 {
550 SYSTEMTIME st;
551
552 hr = (VariantTimeToSystemTime( V_DATE(&var), &st) ? S_OK : E_FAIL);
553 d->year = st.wYear;
554 d->month = st.wMonth;
555 d->day = st.wDay;
556 d->hour = st.wHour;
557 d->minute = st.wMinute;
558 d->second = st.wSecond;
559 d->fraction = st.wMilliseconds * 1000000;
560 }
561
562 VariantClear(&var);
563 }
564 break;
565 case DBTYPE_DATE:
566 {
567 SYSTEMTIME st;
568 hr = (VariantTimeToSystemTime(*(double*)src, &st) ? S_OK : E_FAIL);
569 d->year = st.wYear;
570 d->month = st.wMonth;
571 d->day = st.wDay;
572 d->hour = st.wHour;
573 d->minute = st.wMinute;
574 d->second = st.wSecond;
575 d->fraction = st.wMilliseconds * 1000000;
576 break;
577 }
578 case DBTYPE_VARIANT:
579 if( V_VT((VARIANT*)src) == VT_DATE)
580 {
581 SYSTEMTIME st;
582 hr = (VariantTimeToSystemTime( V_DATE((VARIANT*)src), &st) ? S_OK : E_FAIL);
583 d->year = st.wYear;
584 d->month = st.wMonth;
585 d->day = st.wDay;
586 d->hour = st.wHour;
587 d->minute = st.wMinute;
588 d->second = st.wSecond;
589 d->fraction = st.wMilliseconds * 1000000;
590 }
591 else
592 {
593 FIXME("Unimplemented variant type %d -> DBTIMESTAMP\n", V_VT((VARIANT*)src));
594 return E_NOTIMPL;
595 }
596 break;
597 default: FIXME("Unimplemented conversion %04x -> DBTIMESTAMP\n", src_type); return E_NOTIMPL;
598 }
599 break;
600 }
601
602 case DBTYPE_CY:
603 {
604 CY *d = dst;
605 switch(src_type)
606 {
607 case DBTYPE_EMPTY: d->int64 = 0; hr = S_OK; break;
608 case DBTYPE_I2: hr = VarCyFromI2(*(signed short*)src, d); break;
609 case DBTYPE_I4: hr = VarCyFromI4(*(signed int*)src, d); break;
610 case DBTYPE_R4: hr = VarCyFromR4(*(FLOAT*)src, d); break;
611 case DBTYPE_R8: hr = VarCyFromR8(*(double*)src, d); break;
612 case DBTYPE_CY: *d = *(CY*)src; hr = S_OK; break;
613 case DBTYPE_DATE: hr = VarCyFromDate(*(DATE*)src, d); break;
614 case DBTYPE_BSTR: hr = VarCyFromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
615 case DBTYPE_BOOL: hr = VarCyFromBool(*(VARIANT_BOOL*)src, d); break;
616 case DBTYPE_DECIMAL: hr = VarCyFromDec((DECIMAL*)src, d); break;
617 case DBTYPE_I1: hr = VarCyFromI1(*(signed char*)src, d); break;
618 case DBTYPE_UI1: hr = VarCyFromUI1(*(BYTE*)src, d); break;
619 case DBTYPE_UI2: hr = VarCyFromUI2(*(WORD*)src, d); break;
620 case DBTYPE_UI4: hr = VarCyFromUI4(*(DWORD*)src, d); break;
621 case DBTYPE_I8: hr = VarCyFromI8(*(LONGLONG*)src, d); break;
622 case DBTYPE_UI8: hr = VarCyFromUI8(*(ULONGLONG*)src, d); break;
623 default: FIXME("Unimplemented conversion %04x -> CY\n", src_type); return E_NOTIMPL;
624 }
625 break;
626 }
627
628 case DBTYPE_BSTR:
629 {
630 BSTR *d = dst;
631 switch(src_type)
632 {
633 case DBTYPE_EMPTY: *d = SysAllocStringLen(NULL, 0); hr = *d ? S_OK : E_OUTOFMEMORY; break;
634 case DBTYPE_I2: hr = VarBstrFromI2(*(signed short*)src, LOCALE_USER_DEFAULT, 0, d); break;
635 case DBTYPE_I4: hr = VarBstrFromI4(*(signed int*)src, LOCALE_USER_DEFAULT, 0, d); break;
636 case DBTYPE_R4: hr = VarBstrFromR4(*(FLOAT*)src, LOCALE_USER_DEFAULT, 0, d); break;
637 case DBTYPE_R8: hr = VarBstrFromR8(*(double*)src, LOCALE_USER_DEFAULT, 0, d); break;
638 case DBTYPE_CY: hr = VarBstrFromCy(*(CY*)src, LOCALE_USER_DEFAULT, 0, d); break;
639 case DBTYPE_DATE: hr = VarBstrFromDate(*(DATE*)src, LOCALE_USER_DEFAULT, 0, d); break;
640 case DBTYPE_BSTR: *d = SysAllocStringLen(*(BSTR*)src, SysStringLen(*(BSTR*)src)); hr = *d ? S_OK : E_OUTOFMEMORY; break;
641 case DBTYPE_BOOL: hr = VarBstrFromBool(*(VARIANT_BOOL*)src, LOCALE_USER_DEFAULT, 0, d); break;
642 case DBTYPE_DECIMAL: hr = VarBstrFromDec((DECIMAL*)src, LOCALE_USER_DEFAULT, 0, d); break;
643 case DBTYPE_I1: hr = VarBstrFromI1(*(signed char*)src, LOCALE_USER_DEFAULT, 0, d); break;
644 case DBTYPE_UI1: hr = VarBstrFromUI1(*(BYTE*)src, LOCALE_USER_DEFAULT, 0, d); break;
645 case DBTYPE_UI2: hr = VarBstrFromUI2(*(WORD*)src, LOCALE_USER_DEFAULT, 0, d); break;
646 case DBTYPE_UI4: hr = VarBstrFromUI4(*(DWORD*)src, LOCALE_USER_DEFAULT, 0, d); break;
647 case DBTYPE_I8: hr = VarBstrFromI8(*(LONGLONG*)src, LOCALE_USER_DEFAULT, 0, d); break;
648 case DBTYPE_UI8: hr = VarBstrFromUI8(*(ULONGLONG*)src, LOCALE_USER_DEFAULT, 0, d); break;
649 case DBTYPE_GUID:
650 {
651 WCHAR szBuff[39];
652 const GUID *id = (const GUID *)src;
653 static const WCHAR format[] = {
654 '{','%','0','8','X','-','%','0','4','X','-','%','0','4','X','-',
655 '%','0','2','X','%','0','2','X','-',
656 '%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X','}',0};
657 wsprintfW(szBuff, format,
658 id->Data1, id->Data2, id->Data3,
659 id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
660 id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7] );
661 *d = SysAllocString(szBuff);
662 hr = *d ? S_OK : E_OUTOFMEMORY;
663 }
664 break;
665 case DBTYPE_BYTES:
666 {
667 *d = SysAllocStringLen(NULL, 2 * src_len);
668 if (*d == NULL)
669 hr = E_OUTOFMEMORY;
670 else
671 {
672 static const char hexchars[] = "0123456789ABCDEF";
673 WCHAR *s = *d;
674 unsigned char *p = src;
675 while (src_len > 0)
676 {
677 *s++ = hexchars[(*p >> 4) & 0x0F];
678 *s++ = hexchars[(*p) & 0x0F];
679 src_len--; p++;
680 }
681 hr = S_OK;
682 }
683 }
684 break;
685 case DBTYPE_DBTIMESTAMP:
686 {
687 WCHAR szBuff[64];
688 static const WCHAR format1[] = {
689 '%','0','4','d','-','%','0','2','d','-','%','0','2','d',' ','%','0','2','d',':','%','0','2','d',
690 ':','%','0','2','d', 0};
691 static const WCHAR format2[] = {
692 '%','0','4','d','-','%','0','2','d','-','%','0','2','d',' ','%','0','2','d',':','%','0','2','d',
693 ':','%','0','2','d','.','%','0','9','d', 0};
694 DBTIMESTAMP *ts = (DBTIMESTAMP *)src;
695
696 if(ts->fraction == 0)
697 wsprintfW(szBuff, format1, ts->year, ts->month, ts->day, ts->hour, ts->minute, ts->second);
698 else
699 wsprintfW(szBuff, format2, ts->year, ts->month, ts->day, ts->hour, ts->minute, ts->second, ts->fraction );
700 *d = SysAllocString(szBuff);
701 hr = *d ? S_OK : E_OUTOFMEMORY;
702 break;
703 }
704 case DBTYPE_VARIANT:
705 VariantInit(&tmp);
706 if ((hr = VariantChangeType(&tmp, (VARIANT*)src, 0, VT_BSTR)) == S_OK)
707 *d = V_BSTR(&tmp);
708 break;
709 default: FIXME("Unimplemented conversion %04x -> BSTR\n", src_type); return E_NOTIMPL;
710 }
711 break;
712 }
713
714 case DBTYPE_UI1:
715 {
716 BYTE *d = dst;
717 switch(src_type)
718 {
719 case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
720 case DBTYPE_I2: hr = VarUI1FromI2(*(signed short*)src, d); break;
721 case DBTYPE_I4: hr = VarUI1FromI4(*(signed int*)src, d); break;
722 case DBTYPE_R4: hr = VarUI1FromR4(*(FLOAT*)src, d); break;
723 case DBTYPE_R8: hr = VarUI1FromR8(*(double*)src, d); break;
724 case DBTYPE_CY: hr = VarUI1FromCy(*(CY*)src, d); break;
725 case DBTYPE_DATE: hr = VarUI1FromDate(*(DATE*)src, d); break;
726 case DBTYPE_BSTR: hr = VarUI1FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
727 case DBTYPE_BOOL: hr = VarUI1FromBool(*(VARIANT_BOOL*)src, d); break;
728 case DBTYPE_DECIMAL: hr = VarUI1FromDec((DECIMAL*)src, d); break;
729 case DBTYPE_I1: hr = VarUI1FromI1(*(signed char*)src, d); break;
730 case DBTYPE_UI1: *d = *(BYTE*)src; hr = S_OK; break;
731 case DBTYPE_UI2: hr = VarUI1FromUI2(*(WORD*)src, d); break;
732 case DBTYPE_UI4: hr = VarUI1FromUI4(*(DWORD*)src, d); break;
733 case DBTYPE_I8: hr = VarUI1FromI8(*(LONGLONG*)src, d); break;
734 case DBTYPE_UI8: hr = VarUI1FromUI8(*(ULONGLONG*)src, d); break;
735 default: FIXME("Unimplemented conversion %04x -> UI1\n", src_type); return E_NOTIMPL;
736 }
737 break;
738 }
739 case DBTYPE_UI2:
740 {
741 WORD *d = dst;
742 switch(src_type)
743 {
744 case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
745 case DBTYPE_I2: hr = VarUI2FromI2(*(signed short*)src, d); break;
746 case DBTYPE_I4: hr = VarUI2FromI4(*(signed int*)src, d); break;
747 case DBTYPE_R4: hr = VarUI2FromR4(*(FLOAT*)src, d); break;
748 case DBTYPE_R8: hr = VarUI2FromR8(*(double*)src, d); break;
749 case DBTYPE_CY: hr = VarUI2FromCy(*(CY*)src, d); break;
750 case DBTYPE_DATE: hr = VarUI2FromDate(*(DATE*)src, d); break;
751 case DBTYPE_BSTR: hr = VarUI2FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
752 case DBTYPE_BOOL: hr = VarUI2FromBool(*(VARIANT_BOOL*)src, d); break;
753 case DBTYPE_DECIMAL: hr = VarUI2FromDec((DECIMAL*)src, d); break;
754 case DBTYPE_I1: hr = VarUI2FromI1(*(signed char*)src, d); break;
755 case DBTYPE_UI1: hr = VarUI2FromUI1(*(BYTE*)src, d); break;
756 case DBTYPE_UI2: *d = *(WORD*)src; hr = S_OK; break;
757 case DBTYPE_UI4: hr = VarUI2FromUI4(*(DWORD*)src, d); break;
758 case DBTYPE_I8: hr = VarUI2FromI8(*(LONGLONG*)src, d); break;
759 case DBTYPE_UI8: hr = VarUI2FromUI8(*(ULONGLONG*)src, d); break;
760 default: FIXME("Unimplemented conversion %04x -> UI2\n", src_type); return E_NOTIMPL;
761 }
762 break;
763 }
764
765 case DBTYPE_UI4:
766 {
767 DWORD *d = dst;
768 switch(src_type)
769 {
770 case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
771 case DBTYPE_I2: hr = VarUI4FromI2(*(signed short*)src, d); break;
772 case DBTYPE_I4: hr = VarUI4FromI4(*(signed int*)src, d); break;
773 case DBTYPE_R4: hr = VarUI4FromR4(*(FLOAT*)src, d); break;
774 case DBTYPE_R8: hr = VarUI4FromR8(*(double*)src, d); break;
775 case DBTYPE_CY: hr = VarUI4FromCy(*(CY*)src, d); break;
776 case DBTYPE_DATE: hr = VarUI4FromDate(*(DATE*)src, d); break;
777 case DBTYPE_BSTR: hr = VarUI4FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
778 case DBTYPE_BOOL: hr = VarUI4FromBool(*(VARIANT_BOOL*)src, d); break;
779 case DBTYPE_DECIMAL: hr = VarUI4FromDec((DECIMAL*)src, d); break;
780 case DBTYPE_I1: hr = VarUI4FromI1(*(signed char*)src, d); break;
781 case DBTYPE_UI1: hr = VarUI4FromUI1(*(BYTE*)src, d); break;
782 case DBTYPE_UI2: hr = VarUI4FromUI2(*(WORD*)src, d); break;
783 case DBTYPE_UI4: *d = *(DWORD*)src; hr = S_OK; break;
784 case DBTYPE_I8: hr = VarUI4FromI8(*(LONGLONG*)src, d); break;
785 case DBTYPE_UI8: hr = VarUI4FromUI8(*(ULONGLONG*)src, d); break;
786 case DBTYPE_VARIANT:
787 VariantInit(&tmp);
788 if ((hr = VariantChangeType(&tmp, (VARIANT*)src, 0, VT_UI4)) == S_OK)
789 *d = V_UI4(&tmp);
790 break;
791 default: FIXME("Unimplemented conversion %04x -> UI4\n", src_type); return E_NOTIMPL;
792 }
793 break;
794 }
795
796 case DBTYPE_UI8:
797 {
798 ULONGLONG *d = dst;
799 switch(src_type)
800 {
801 case DBTYPE_EMPTY: *d = 0; hr = S_OK; break;
802 case DBTYPE_I2: hr = VarUI8FromI2(*(signed short*)src, d); break;
803 case DBTYPE_I4: {LONGLONG s = *(signed int*)src; hr = VarUI8FromI8(s, d); break;}
804 case DBTYPE_R4: hr = VarUI8FromR4(*(FLOAT*)src, d); break;
805 case DBTYPE_R8: hr = VarUI8FromR8(*(double*)src, d); break;
806 case DBTYPE_CY: hr = VarUI8FromCy(*(CY*)src, d); break;
807 case DBTYPE_DATE: hr = VarUI8FromDate(*(DATE*)src, d); break;
808 case DBTYPE_BSTR: hr = VarUI8FromStr(*(WCHAR**)src, LOCALE_USER_DEFAULT, 0, d); break;
809 case DBTYPE_BOOL: hr = VarUI8FromBool(*(VARIANT_BOOL*)src, d); break;
810 case DBTYPE_DECIMAL: hr = VarUI8FromDec((DECIMAL*)src, d); break;
811 case DBTYPE_I1: hr = VarUI8FromI1(*(signed char*)src, d); break;
812 case DBTYPE_UI1: hr = VarUI8FromUI1(*(BYTE*)src, d); break;
813 case DBTYPE_UI2: hr = VarUI8FromUI2(*(WORD*)src, d); break;
814 case DBTYPE_UI4: hr = VarUI8FromUI4(*(DWORD*)src, d); break;
815 case DBTYPE_I8: hr = VarUI8FromI8(*(LONGLONG*)src, d); break;
816 case DBTYPE_UI8: *d = *(ULONGLONG*)src; hr = S_OK; break;
817 default: FIXME("Unimplemented conversion %04x -> UI8\n", src_type); return E_NOTIMPL;
818 }
819 break;
820 }
821
822 case DBTYPE_FILETIME:
823 {
824 FILETIME *d = dst;
825 switch(src_type)
826 {
827 case DBTYPE_EMPTY: d->dwLowDateTime = d->dwHighDateTime = 0; hr = S_OK; break;
828 case DBTYPE_FILETIME: *d = *(FILETIME*)src; hr = S_OK; break;
829 default: FIXME("Unimplemented conversion %04x -> FILETIME\n", src_type); return E_NOTIMPL;
830 }
831 break;
832 }
833
834 case DBTYPE_GUID:
835 {
836 GUID *d = dst;
837 switch(src_type)
838 {
839 case DBTYPE_EMPTY: *d = GUID_NULL; hr = S_OK; break;
840 case DBTYPE_GUID: *d = *(GUID*)src; hr = S_OK; break;
841 default: FIXME("Unimplemented conversion %04x -> GUID\n", src_type); return E_NOTIMPL;
842 }
843 break;
844 }
845
846 case DBTYPE_WSTR:
847 {
848 BSTR b;
849 DBLENGTH bstr_len;
850 INT bytes_to_copy;
851 hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
852 src, &b, sizeof(BSTR), src_status, dst_status,
853 precision, scale, flags);
854 if(hr != S_OK || *dst_status == DBSTATUS_S_ISNULL)
855 return hr;
856 bstr_len = SysStringLen(b);
857 *dst_len = bstr_len * sizeof(WCHAR); /* Doesn't include size for '\0' */
858 *dst_status = DBSTATUS_S_OK;
859 bytes_to_copy = min(*dst_len + sizeof(WCHAR), dst_max_len);
860 if(dst)
861 {
862 if(bytes_to_copy >= sizeof(WCHAR))
863 {
864 memcpy(dst, b, bytes_to_copy - sizeof(WCHAR));
865 *((WCHAR*)dst + bytes_to_copy / sizeof(WCHAR) - 1) = 0;
866 if(bytes_to_copy < *dst_len + sizeof(WCHAR))
867 *dst_status = DBSTATUS_S_TRUNCATED;
868 }
869 else
870 {
871 *dst_status = DBSTATUS_E_DATAOVERFLOW;
872 hr = DB_E_ERRORSOCCURRED;
873 }
874 }
875 SysFreeString(b);
876 return hr;
877 }
878
879 case DBTYPE_STR:
880 {
881 BSTR b;
882 DBLENGTH length;
883 INT bytes_to_copy;
884 hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &length,
885 src, &b, sizeof(BSTR), src_status, dst_status,
886 precision, scale, flags);
887 if(hr != S_OK) return hr;
888 length = WideCharToMultiByte(CP_ACP, 0, b, SysStringLen(b), NULL, 0, NULL, NULL);
889 *dst_len = length; /* Doesn't include size for '\0' */
890 *dst_status = DBSTATUS_S_OK;
891 bytes_to_copy = min(length + 1, dst_max_len);
892 if(dst)
893 {
894 if(bytes_to_copy >= sizeof(char))
895 {
896 WideCharToMultiByte(CP_ACP, 0, b, SysStringLen(b), dst, bytes_to_copy - 1, NULL, NULL);
897 *((char *)dst + bytes_to_copy - 1) = 0;
898 if(bytes_to_copy < length + 1)
899 *dst_status = DBSTATUS_S_TRUNCATED;
900 }
901 else
902 {
903 *dst_status = DBSTATUS_E_DATAOVERFLOW;
904 hr = DB_E_ERRORSOCCURRED;
905 }
906 }
907 SysFreeString(b);
908 return hr;
909 }
910
911 case DBTYPE_BYREF | DBTYPE_WSTR:
912 {
913 BSTR b;
914 WCHAR **d = dst;
915 DBLENGTH bstr_len;
916 hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &bstr_len,
917 src, &b, sizeof(BSTR), src_status, dst_status,
918 precision, scale, flags);
919 if(hr != S_OK) return hr;
920
921 bstr_len = SysStringLen(b) * sizeof(WCHAR);
922 *dst_len = bstr_len; /* Doesn't include size for '\0' */
923
924 *d = CoTaskMemAlloc(bstr_len + sizeof(WCHAR));
925 if(*d) memcpy(*d, b, bstr_len + sizeof(WCHAR));
926 else hr = E_OUTOFMEMORY;
927 SysFreeString(b);
928 return hr;
929 }
930
931 case DBTYPE_BYREF | DBTYPE_STR:
932 {
933 BSTR b;
934 char **d = dst;
935 DBLENGTH length;
936 hr = IDataConvert_DataConvert(iface, src_type, DBTYPE_BSTR, src_len, &length,
937 src, &b, sizeof(BSTR), src_status, dst_status,
938 precision, scale, flags);
939 if(hr != S_OK) return hr;
940
941 length = WideCharToMultiByte(CP_ACP, 0, b, SysStringLen(b) + 1, NULL, 0, NULL, NULL);
942 *dst_len = length - 1; /* Doesn't include size for '\0' */
943 *dst_status = DBSTATUS_S_OK;
944 *d = CoTaskMemAlloc(length);
945
946 if(*d)
947 WideCharToMultiByte(CP_ACP, 0, b, SysStringLen(b) + 1, *d, length, NULL, NULL);
948 else
949 hr = E_OUTOFMEMORY;
950 SysFreeString(b);
951
952 return hr;
953 }
954
955 case DBTYPE_VARIANT:
956 {
957 VARIANT *v = dst;
958
959 switch(src_type)
960 {
961 case DBTYPE_BOOL:
962 V_VT(v) = VT_BOOL;
963 V_BOOL(v) = *(VARIANT_BOOL*)src;
964 hr = S_OK;
965 break;
966 case DBTYPE_I2:
967 V_VT(v) = VT_I2;
968 V_I2(v) = *(signed short*)src;
969 hr = S_OK;
970 break;
971 case DBTYPE_I4:
972 V_VT(v) = VT_I4;
973 V_I4(v) = *(signed int*)src;
974 hr = S_OK;
975 break;
976 case DBTYPE_I8:
977 V_VT(v) = VT_DECIMAL;
978 hr = VarDecFromI8( *(LONGLONG*)src, &V_DECIMAL(v));
979 break;
980 case DBTYPE_R4:
981 V_VT(v) = VT_R4;
982 V_R4(v) = *(FLOAT*)src;
983 hr = S_OK;
984 break;
985 case DBTYPE_R8:
986 V_VT(v) = VT_R8;
987 V_R8(v) = *(double*)src;
988 hr = S_OK;
989 break;
990 case DBTYPE_BSTR:
991 {
992 BSTR s = *(WCHAR**)src;
993 TRACE("%s\n", debugstr_w(s));
994 V_VT(v) = VT_BSTR;
995 V_BSTR(v) = SysAllocString(s);
996 hr = V_BSTR(v) ? S_OK : E_OUTOFMEMORY;
997 break;
998 }
999 case DBTYPE_DATE:
1000 V_VT(v) = VT_DATE;
1001 V_DATE(v) = *(DATE*)src;
1002 hr = S_OK;
1003 break;
1004 case DBTYPE_DBDATE:
1005 {
1006 SYSTEMTIME st;
1007 DBDATE *ts=(DBDATE*)src;
1008
1009 V_VT(v) = VT_DATE;
1010
1011 st.wYear = ts->year;
1012 st.wMonth = ts->month;
1013 st.wDay = ts->day;
1014 st.wHour = 0;
1015 st.wMinute = 0;
1016 st.wSecond = 0;
1017 st.wMilliseconds = 0;
1018 hr = (SystemTimeToVariantTime(&st, &V_DATE(v)) ? S_OK : E_FAIL);
1019 break;
1020 }
1021 case DBTYPE_DBTIMESTAMP:
1022 {
1023 SYSTEMTIME st;
1024 DBTIMESTAMP *ts = (DBTIMESTAMP *)src;
1025
1026 V_VT(v) = VT_DATE;
1027
1028 st.wYear = ts->year;
1029 st.wMonth = ts->month;
1030 st.wDay = ts->day;
1031 st.wHour = ts->hour;
1032 st.wMinute = ts->minute;
1033 st.wSecond = ts->second;
1034 st.wMilliseconds = ts->fraction/1000000;
1035 hr = SystemTimeToVariantTime(&st, &V_DATE(v)) ? S_OK : E_FAIL;
1036 break;
1037 }
1038 case DBTYPE_CY:
1039 V_VT(v) = VT_CY;
1040 V_CY(v) = *(CY*)src;
1041 hr = S_OK;
1042 break;
1043 case DBTYPE_BYTES:
1044 {
1045 LONG i;
1046 SAFEARRAY *psa = NULL;
1047 SAFEARRAYBOUND rgsabound[1];
1048 unsigned char *p = src;
1049
1050 rgsabound[0].lLbound = 0;
1051 rgsabound[0].cElements = src_len;
1052
1053 psa = SafeArrayCreate(VT_UI1,1,rgsabound);
1054 for(i =0; i < src_len; i++,p++)
1055 {
1056 hr = SafeArrayPutElement(psa, &i, p);
1057 if(FAILED(hr)) {
1058 SafeArrayDestroy (psa);
1059 return hr;
1060 }
1061 }
1062
1063 V_VT(v) = VT_ARRAY|VT_UI1;
1064 V_ARRAY(v) = psa;
1065 hr = S_OK;
1066 break;
1067 }
1068 default: FIXME("Unimplemented conversion %04x -> VARIANT\n", src_type); return E_NOTIMPL;
1069 }
1070 break;
1071 }
1072 case DBTYPE_BYTES:
1073 {
1074 BYTE *d = dst;
1075
1076 switch(src_type)
1077 {
1078 case DBTYPE_BYTES:
1079 if( src_len > dst_max_len)
1080 *dst_status = DBSTATUS_S_TRUNCATED;
1081 else
1082 *dst_status = DBSTATUS_S_OK;
1083
1084 *dst_len = src_len;
1085 memcpy(d, src, min(src_len, dst_max_len));
1086
1087 return S_OK;
1088 case DBTYPE_VARIANT:
1089 {
1090 switch(V_VT((VARIANT*)src))
1091 {
1092 case VT_UI1 | VT_ARRAY:
1093 {
1094 LONG l;
1095 BYTE *data = NULL;
1096
1097 hr = SafeArrayGetUBound(V_ARRAY((VARIANT*)src), 1, &l);
1098 if(FAILED(hr))
1099 return hr;
1100
1101 hr = SafeArrayAccessData(V_ARRAY((VARIANT*)src), (VOID**)&data);
1102 if(FAILED(hr))
1103 {
1104 ERR("SafeArrayAccessData Failed = 0x%08x\n", hr);
1105 return hr;
1106 }
1107
1108 *dst_len = l+1;
1109 *dst_status = DBSTATUS_S_OK;
1110 memcpy(d, data, *dst_len);
1111
1112 SafeArrayUnaccessData(V_ARRAY((VARIANT*)src));
1113 return S_OK;
1114 }
1115 break;
1116 default:
1117 FIXME("Unimplemented variant type %d -> BYTES\n", V_VT((VARIANT*)src));
1118 return E_NOTIMPL;
1119 }
1120 }
1121 break;
1122 default: FIXME("Unimplemented conversion %04x -> DBTYPE_BYTES\n", src_type); return E_NOTIMPL;
1123 }
1124 break;
1125 }
1126 case DBTYPE_BYTES | DBTYPE_BYREF:
1127 {
1128 BYTE **d = dst;
1129
1130 switch(src_type)
1131 {
1132 case DBTYPE_BYTES:
1133 *d = CoTaskMemAlloc(src_len);
1134 if(*d) memcpy(*d, src, src_len);
1135 else hr = E_OUTOFMEMORY;
1136
1137 *dst_len = src_len;
1138 *dst_status = DBSTATUS_S_OK;
1139 return S_OK;
1140 default: FIXME("Unimplemented conversion %04x -> DBTYPE_BYTES | DBTYPE_BYREF\n", src_type); return E_NOTIMPL;
1141 }
1142 break;
1143 }
1144
1145 case DBTYPE_NUMERIC:
1146 FIXME("Unimplemented conversion %04x -> DBTYPE_NUMERIC\n", src_type);
1147 return E_NOTIMPL;
1148
1149 default:
1150 FIXME("Unimplemented conversion %04x -> %04x\n", src_type, dst_type);
1151 return E_NOTIMPL;
1152 }
1153
1154 if(hr == DISP_E_OVERFLOW)
1155 {
1156 *dst_status = DBSTATUS_E_DATAOVERFLOW;
1157 *dst_len = get_length(dst_type);
1158 hr = DB_E_ERRORSOCCURRED;
1159 }
1160 else if(hr == S_OK)
1161 {
1162 *dst_status = DBSTATUS_S_OK;
1163 *dst_len = get_length(dst_type);
1164 }
1165
1166 return hr;
1167 }
1168
1169 static inline WORD get_dbtype_class(DBTYPE type)
1170 {
1171 switch(type)
1172 {
1173 case DBTYPE_I2:
1174 case DBTYPE_R4:
1175 case DBTYPE_R8:
1176 case DBTYPE_I1:
1177 case DBTYPE_UI1:
1178 case DBTYPE_UI2:
1179 return DBTYPE_I2;
1180
1181 case DBTYPE_I4:
1182 case DBTYPE_UI4:
1183 return DBTYPE_I4;
1184
1185 case DBTYPE_I8:
1186 case DBTYPE_UI8:
1187 return DBTYPE_I8;
1188
1189 case DBTYPE_BSTR:
1190 case DBTYPE_STR:
1191 case DBTYPE_WSTR:
1192 return DBTYPE_BSTR;
1193
1194 case DBTYPE_DBDATE:
1195 case DBTYPE_DBTIME:
1196 case DBTYPE_DBTIMESTAMP:
1197 return DBTYPE_DBDATE;
1198 }
1199 return type;
1200 }
1201
1202 /* Many src types will convert to this group of dst types */
1203 static inline BOOL common_class(WORD dst_class)
1204 {
1205 switch(dst_class)
1206 {
1207 case DBTYPE_EMPTY:
1208 case DBTYPE_NULL:
1209 case DBTYPE_I2:
1210 case DBTYPE_I4:
1211 case DBTYPE_BSTR:
1212 case DBTYPE_BOOL:
1213 case DBTYPE_VARIANT:
1214 case DBTYPE_I8:
1215 case DBTYPE_CY:
1216 case DBTYPE_DECIMAL:
1217 case DBTYPE_NUMERIC:
1218 return TRUE;
1219 }
1220 return FALSE;
1221 }
1222
1223 static inline BOOL array_type(DBTYPE type)
1224 {
1225 return (type >= DBTYPE_I2 && type <= DBTYPE_UI4);
1226 }
1227
1228 static HRESULT WINAPI convert_CanConvert(IDataConvert* iface,
1229 DBTYPE src_type, DBTYPE dst_type)
1230 {
1231 convert *This = impl_from_IDataConvert(iface);
1232 DBTYPE src_base_type = src_type & 0x1ff;
1233 DBTYPE dst_base_type = dst_type & 0x1ff;
1234 WORD dst_class = get_dbtype_class(dst_base_type);
1235
1236 TRACE("(%p)->(%d, %d)\n", This, src_type, dst_type);
1237
1238 if(src_type & DBTYPE_VECTOR || dst_type & DBTYPE_VECTOR) return S_FALSE;
1239
1240 if(src_type & DBTYPE_ARRAY)
1241 {
1242 if(!array_type(src_base_type)) return S_FALSE;
1243 if(dst_type & DBTYPE_ARRAY)
1244 {
1245 if(src_type == dst_type) return S_OK;
1246 return S_FALSE;
1247 }
1248 if(dst_type == DBTYPE_VARIANT) return S_OK;
1249 return S_FALSE;
1250 }
1251
1252 if(dst_type & DBTYPE_ARRAY)
1253 {
1254 if(!array_type(dst_base_type)) return S_FALSE;
1255 if(src_type == DBTYPE_IDISPATCH || src_type == DBTYPE_VARIANT) return S_OK;
1256 return S_FALSE;
1257 }
1258
1259 if(dst_type & DBTYPE_BYREF)
1260 if(dst_base_type != DBTYPE_BYTES && dst_base_type != DBTYPE_STR && dst_base_type != DBTYPE_WSTR)
1261 return S_FALSE;
1262
1263 switch(get_dbtype_class(src_base_type))
1264 {
1265 case DBTYPE_EMPTY:
1266 if(common_class(dst_class)) return S_OK;
1267 switch(dst_class)
1268 {
1269 case DBTYPE_DATE:
1270 case DBTYPE_GUID:
1271 case DBTYPE_FILETIME:
1272 return S_OK;
1273 default:
1274 if(dst_base_type == DBTYPE_DBTIMESTAMP) return S_OK;
1275 return S_FALSE;
1276 }
1277
1278 case DBTYPE_NULL:
1279 switch(dst_base_type)
1280 {
1281 case DBTYPE_NULL:
1282 case DBTYPE_VARIANT:
1283 case DBTYPE_FILETIME: return S_OK;
1284 default: return S_FALSE;
1285 }
1286
1287 case DBTYPE_I4:
1288 if(dst_base_type == DBTYPE_BYTES) return S_OK;
1289 /* fall through */
1290 case DBTYPE_I2:
1291 if(dst_base_type == DBTYPE_DATE) return S_OK;
1292 /* fall through */
1293 case DBTYPE_DECIMAL:
1294 if(common_class(dst_class)) return S_OK;
1295 if(dst_class == DBTYPE_DBDATE) return S_OK;
1296 return S_FALSE;
1297
1298 case DBTYPE_BOOL:
1299 if(dst_base_type == DBTYPE_DATE) return S_OK;
1300 /* fall through */
1301 case DBTYPE_NUMERIC:
1302 case DBTYPE_CY:
1303 if(common_class(dst_class)) return S_OK;
1304 return S_FALSE;
1305
1306 case DBTYPE_I8:
1307 if(common_class(dst_class)) return S_OK;
1308 switch(dst_base_type)
1309 {
1310 case DBTYPE_BYTES:
1311 case DBTYPE_FILETIME: return S_OK;
1312 default: return S_FALSE;
1313 }
1314
1315 case DBTYPE_DATE:
1316 switch(dst_class)
1317 {
1318 case DBTYPE_EMPTY:
1319 case DBTYPE_NULL:
1320 case DBTYPE_I2:
1321 case DBTYPE_I4:
1322 case DBTYPE_BSTR:
1323 case DBTYPE_BOOL:
1324 case DBTYPE_VARIANT:
1325 case DBTYPE_I8:
1326 case DBTYPE_DATE:
1327 case DBTYPE_DBDATE:
1328 case DBTYPE_FILETIME:
1329 return S_OK;
1330 default: return S_FALSE;
1331 }
1332
1333 case DBTYPE_IDISPATCH:
1334 case DBTYPE_VARIANT:
1335 switch(dst_base_type)
1336 {
1337 case DBTYPE_IDISPATCH:
1338 case DBTYPE_ERROR:
1339 case DBTYPE_IUNKNOWN:
1340 return S_OK;
1341 }
1342 /* fall through */
1343 case DBTYPE_BSTR:
1344 if(common_class(dst_class)) return S_OK;
1345 switch(dst_class)
1346 {
1347 case DBTYPE_DATE:
1348 case DBTYPE_GUID:
1349 case DBTYPE_BYTES:
1350 case DBTYPE_DBDATE:
1351 case DBTYPE_FILETIME:
1352 return S_OK;
1353 default: return S_FALSE;
1354 }
1355
1356 case DBTYPE_ERROR:
1357 switch(dst_base_type)
1358 {
1359 case DBTYPE_BSTR:
1360 case DBTYPE_ERROR:
1361 case DBTYPE_VARIANT:
1362 case DBTYPE_WSTR:
1363 return S_OK;
1364 default: return S_FALSE;
1365 }
1366
1367 case DBTYPE_IUNKNOWN:
1368 switch(dst_base_type)
1369 {
1370 case DBTYPE_EMPTY:
1371 case DBTYPE_NULL:
1372 case DBTYPE_IDISPATCH:
1373 case DBTYPE_VARIANT:
1374 case DBTYPE_IUNKNOWN:
1375 return S_OK;
1376 default: return S_FALSE;
1377 }
1378
1379 case DBTYPE_BYTES:
1380 if(dst_class == DBTYPE_I4 || dst_class == DBTYPE_I8) return S_OK;
1381 /* fall through */
1382 case DBTYPE_GUID:
1383 switch(dst_class)
1384 {
1385 case DBTYPE_EMPTY:
1386 case DBTYPE_NULL:
1387 case DBTYPE_BSTR:
1388 case DBTYPE_VARIANT:
1389 case DBTYPE_GUID:
1390 case DBTYPE_BYTES:
1391 return S_OK;
1392 default: return S_FALSE;
1393 }
1394
1395 case DBTYPE_FILETIME:
1396 if(dst_class == DBTYPE_I8) return S_OK;
1397 /* fall through */
1398 case DBTYPE_DBDATE:
1399 switch(dst_class)
1400 {
1401 case DBTYPE_EMPTY:
1402 case DBTYPE_NULL:
1403 case DBTYPE_DATE:
1404 case DBTYPE_BSTR:
1405 case DBTYPE_VARIANT:
1406 case DBTYPE_DBDATE:
1407 case DBTYPE_FILETIME:
1408 return S_OK;
1409 default: return S_FALSE;
1410 }
1411
1412 }
1413 return S_FALSE;
1414 }
1415
1416 static HRESULT WINAPI convert_GetConversionSize(IDataConvert* iface,
1417 DBTYPE src_type, DBTYPE dst_type,
1418 DBLENGTH *src_len, DBLENGTH *dst_len,
1419 void *src)
1420 {
1421 convert *This = impl_from_IDataConvert(iface);
1422 HRESULT hr;
1423
1424 TRACE("(%p)->(%d, %d, %p, %p, %p)\n", This, src_type, dst_type, src_len, dst_len, src);
1425
1426 hr = IDataConvert_CanConvert(iface, src_type, dst_type);
1427 if (hr != S_OK)
1428 return DB_E_UNSUPPORTEDCONVERSION;
1429
1430 if (!dst_len)
1431 return E_INVALIDARG;
1432
1433 /* for some types we don't need to look into source data */
1434 if ((*dst_len = get_length(dst_type)))
1435 return S_OK;
1436
1437 *dst_len = 110;
1438
1439 if(src_type == DBTYPE_VARIANT && V_VT((VARIANT*)src) == VT_NULL)
1440 return S_OK;
1441
1442 switch (dst_type)
1443 {
1444 case DBTYPE_STR:
1445 switch (src_type)
1446 {
1447 case DBTYPE_VARIANT:
1448 {
1449 VARIANT v;
1450
1451 VariantInit(&v);
1452 if ((hr = VariantChangeType(&v, (VARIANT*)src, 0, VT_BSTR)) == S_OK)
1453 {
1454 *dst_len = WideCharToMultiByte(CP_ACP, 0, V_BSTR(&v), -1, NULL, 0, NULL, NULL);
1455 VariantClear(&v);
1456 }
1457 else
1458 return hr;
1459 }
1460 break;
1461 case DBTYPE_DATE:
1462 case DBTYPE_DECIMAL:
1463 case DBTYPE_EMPTY:
1464 case DBTYPE_I1:
1465 case DBTYPE_I2:
1466 case DBTYPE_UI2:
1467 case DBTYPE_I4:
1468 case DBTYPE_UI4:
1469 case DBTYPE_I8:
1470 case DBTYPE_UI8:
1471 case DBTYPE_R4:
1472 case DBTYPE_DBDATE:
1473 case DBTYPE_DBTIMESTAMP:
1474 case DBTYPE_DBTIME:
1475 break;
1476 default:
1477 FIXME("unimplemented for %04x -> DBTYPE_STR\n", src_type);
1478 return E_NOTIMPL;
1479 }
1480 break;
1481 case DBTYPE_WSTR:
1482 switch (src_type)
1483 {
1484 case DBTYPE_VARIANT:
1485 {
1486 VARIANT v;
1487
1488 VariantInit(&v);
1489 if ((hr = VariantChangeType(&v, (VARIANT*)src, 0, VT_BSTR)) == S_OK)
1490 {
1491 *dst_len = (SysStringLen(V_BSTR(&v))+1) * sizeof(WCHAR);
1492 VariantClear(&v);
1493 }
1494 }
1495 break;
1496 case DBTYPE_STR:
1497 if(src_len)
1498 *dst_len = (*src_len + 1) * sizeof(WCHAR);
1499 else
1500 *dst_len = (strlen(src) + 1) * sizeof(WCHAR);
1501 break;
1502 case DBTYPE_WSTR:
1503 if(src_len)
1504 *dst_len = (*src_len) + sizeof(WCHAR);
1505 else
1506 *dst_len = (lstrlenW(src) + 1) * sizeof(WCHAR);
1507 break;
1508 case DBTYPE_DATE:
1509 case DBTYPE_DECIMAL:
1510 case DBTYPE_EMPTY:
1511 case DBTYPE_I1:
1512 case DBTYPE_I2:
1513 case DBTYPE_UI2:
1514 case DBTYPE_I4:
1515 case DBTYPE_UI4:
1516 case DBTYPE_I8:
1517 case DBTYPE_UI8:
1518 case DBTYPE_R4:
1519 case DBTYPE_DBDATE:
1520 case DBTYPE_DBTIMESTAMP:
1521 case DBTYPE_DBTIME:
1522 break;
1523 default:
1524 FIXME("unimplemented for %04x -> DBTYPE_WSTR\n", src_type);
1525 return E_NOTIMPL;
1526 }
1527 break;
1528 case DBTYPE_BYTES:
1529 switch (src_type)
1530 {
1531 case DBTYPE_VARIANT:
1532 if(V_VT((VARIANT*)src) == VT_BSTR)
1533 *dst_len = (SysStringLen(V_BSTR((VARIANT*)src))) / sizeof(WCHAR);
1534 else
1535 {
1536 switch(V_VT((VARIANT*)src))
1537 {
1538 case VT_UI1 | VT_ARRAY:
1539 {
1540 LONG l;
1541
1542 hr = SafeArrayGetUBound(V_ARRAY((VARIANT*)src), 1, &l);
1543 if(FAILED(hr))
1544 return hr;
1545 *dst_len = l+1;
1546
1547 break;
1548 }
1549 default:
1550 WARN("DBTYPE_VARIANT(%d)->DBTYPE_BYTES unimplemented\n", V_VT((VARIANT*)src));
1551 }
1552 }
1553 break;
1554 default:
1555 FIXME("unimplemented for %04x -> DBTYPE_BYTES\n", src_type);
1556 return E_NOTIMPL;
1557 }
1558 break;
1559 default:
1560 FIXME("unimplemented for conversion %d->%d\n", src_type, dst_type);
1561 return E_NOTIMPL;
1562 }
1563
1564 return S_OK;
1565 }
1566
1567 static const struct IDataConvertVtbl convert_vtbl =
1568 {
1569 convert_QueryInterface,
1570 convert_AddRef,
1571 convert_Release,
1572 convert_DataConvert,
1573 convert_CanConvert,
1574 convert_GetConversionSize
1575 };
1576
1577 static HRESULT WINAPI dcinfo_QueryInterface(IDCInfo* iface, REFIID riid, void **obj)
1578 {
1579 convert *This = impl_from_IDCInfo(iface);
1580
1581 return IDataConvert_QueryInterface(&This->IDataConvert_iface, riid, obj);
1582 }
1583
1584 static ULONG WINAPI dcinfo_AddRef(IDCInfo* iface)
1585 {
1586 convert *This = impl_from_IDCInfo(iface);
1587
1588 return IDataConvert_AddRef(&This->IDataConvert_iface);
1589 }
1590
1591 static ULONG WINAPI dcinfo_Release(IDCInfo* iface)
1592 {
1593 convert *This = impl_from_IDCInfo(iface);
1594
1595 return IDataConvert_Release(&This->IDataConvert_iface);
1596 }
1597
1598 static HRESULT WINAPI dcinfo_GetInfo(IDCInfo *iface, ULONG num, DCINFOTYPE types[], DCINFO **info_ptr)
1599 {
1600 convert *This = impl_from_IDCInfo(iface);
1601 ULONG i;
1602 DCINFO *infos;
1603
1604 TRACE("(%p)->(%d, %p, %p)\n", This, num, types, info_ptr);
1605
1606 *info_ptr = infos = CoTaskMemAlloc(num * sizeof(*infos));
1607 if(!infos) return E_OUTOFMEMORY;
1608
1609 for(i = 0; i < num; i++)
1610 {
1611 infos[i].eInfoType = types[i];
1612 VariantInit(&infos[i].vData);
1613
1614 switch(types[i])
1615 {
1616 case DCINFOTYPE_VERSION:
1617 V_VT(&infos[i].vData) = VT_UI4;
1618 V_UI4(&infos[i].vData) = This->version;
1619 break;
1620 }
1621 }
1622
1623 return S_OK;
1624 }
1625
1626 static HRESULT WINAPI dcinfo_SetInfo(IDCInfo* iface, ULONG num, DCINFO info[])
1627 {
1628 convert *This = impl_from_IDCInfo(iface);
1629 ULONG i;
1630 HRESULT hr = S_OK;
1631
1632 TRACE("(%p)->(%d, %p)\n", This, num, info);
1633
1634 for(i = 0; i < num; i++)
1635 {
1636 switch(info[i].eInfoType)
1637 {
1638 case DCINFOTYPE_VERSION:
1639 if(V_VT(&info[i].vData) != VT_UI4)
1640 {
1641 FIXME("VERSION with vt %x\n", V_VT(&info[i].vData));
1642 hr = DB_S_ERRORSOCCURRED;
1643 break;
1644 }
1645 This->version = V_UI4(&info[i].vData);
1646 break;
1647
1648 default:
1649 FIXME("Unhandled info type %d (vt %x)\n", info[i].eInfoType, V_VT(&info[i].vData));
1650 }
1651 }
1652 return hr;
1653 }
1654
1655 static const struct IDCInfoVtbl dcinfo_vtbl =
1656 {
1657 dcinfo_QueryInterface,
1658 dcinfo_AddRef,
1659 dcinfo_Release,
1660 dcinfo_GetInfo,
1661 dcinfo_SetInfo
1662 };
1663
1664 HRESULT create_oledb_convert(IUnknown *outer, void **obj)
1665 {
1666 convert *This;
1667
1668 TRACE("(%p, %p)\n", outer, obj);
1669
1670 *obj = NULL;
1671
1672 if(outer) return CLASS_E_NOAGGREGATION;
1673
1674 This = heap_alloc(sizeof(*This));
1675 if(!This) return E_OUTOFMEMORY;
1676
1677 This->IDataConvert_iface.lpVtbl = &convert_vtbl;
1678 This->IDCInfo_iface.lpVtbl = &dcinfo_vtbl;
1679 This->ref = 1;
1680 This->version = 0x110;
1681
1682 *obj = &This->IDataConvert_iface;
1683
1684 return S_OK;
1685 }
Windows API implementation