?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3drm: Implement IDirect3DRMMeshBuilder3_GetNormalCount.
[wine/multimedia.git] / dlls / oleaut32 / typelib2.c
blob1aeb27abb3b67e2f994968249c44e20fb1cb43d1
1 /*
2 * TYPELIB2
3 *
4 * Copyright 2004 Alastair Bridgewater
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 *
20 * --------------------------------------------------------------------------------------
21 * Known problems:
22 *
23 * Badly incomplete.
24 *
25 * Only works on little-endian systems.
26 *
27 */
28
29 #include "config.h"
30 #include "wine/port.h"
31
32 #include <stdlib.h>
33 #include <string.h>
34 #include <stdarg.h>
35 #include <stdio.h>
36 #include <ctype.h>
37
38 #define COBJMACROS
39 #define NONAMELESSUNION
40 #define NONAMELESSSTRUCT
41
42 #include "winerror.h"
43 #include "windef.h"
44 #include "winbase.h"
45 #include "winnls.h"
46 #include "winreg.h"
47 #include "winuser.h"
48
49 #include "wine/unicode.h"
50 #include "objbase.h"
51 #include "typelib.h"
52 #include "wine/debug.h"
53
54 WINE_DEFAULT_DEBUG_CHANNEL(typelib2);
55 /* WINE_DEFAULT_DEBUG_CHANNEL(ole); */
56
57
58 /******************************************************************************
59 * ICreateTypeLib2 {OLEAUT32}
60 *
61 * NOTES
62 * The ICreateTypeLib2 interface provides an interface whereby one may create
63 * new type library (.tlb) files.
64 *
65 * This interface inherits from ICreateTypeLib, and can be freely cast back
66 * and forth between an ICreateTypeLib and an ICreateTypeLib2 on local clients.
67 * This dispensation applies only to ICreateTypeLib objects obtained on MSFT
68 * format type libraries (those made through CreateTypeLib2).
69 *
70 * METHODS
71 */
72
73 /******************************************************************************
74 * ICreateTypeInfo2 {OLEAUT32}
75 *
76 * NOTES
77 * The ICreateTypeInfo2 interface provides an interface whereby one may add
78 * type information to type library (.tlb) files.
79 *
80 * This interface inherits from ICreateTypeInfo, and can be freely cast back
81 * and forth between an ICreateTypeInfo and an ICreateTypeInfo2 on local clients.
82 * This dispensation applies only to ICreateTypeInfo objects obtained on MSFT
83 * format type libraries (those made through CreateTypeLib2).
84 *
85 * METHODS
86 */
87
88 /******************************************************************************
89 * ITypeLib2 {OLEAUT32}
90 *
91 * NOTES
92 * The ITypeLib2 interface provides an interface whereby one may query MSFT
93 * format type library (.tlb) files.
94 *
95 * This interface inherits from ITypeLib, and can be freely cast back and
96 * forth between an ITypeLib and an ITypeLib2 on local clients. This
97 * dispensation applies only to ITypeLib objects obtained on MSFT format type
98 * libraries (those made through CreateTypeLib2).
99 *
100 * METHODS
101 */
102
103 /******************************************************************************
104 * ITypeInfo2 {OLEAUT32}
105 *
106 * NOTES
107 * The ITypeInfo2 interface provides an interface whereby one may query type
108 * information stored in MSFT format type library (.tlb) files.
109 *
110 * This interface inherits from ITypeInfo, and can be freely cast back and
111 * forth between an ITypeInfo and an ITypeInfo2 on local clients. This
112 * dispensation applies only to ITypeInfo objects obtained on MSFT format type
113 * libraries (those made through CreateTypeLib2).
114 *
115 * METHODS
116 */
117
118 /*================== Implementation Structures ===================================*/
119
120 /* Used for storing cyclic list. Tail address is kept */
121 typedef enum tagCyclicListElementType {
122 CyclicListSentinel,
123 CyclicListFunc,
124 CyclicListVar
125 } CyclicListElementType;
126 typedef struct tagCyclicList {
127 struct tagCyclicList *next;
128 int indice;
129 int name;
130 CyclicListElementType type;
131
132 union {
133 int val;
134 MSFT_VarRecord *var;
135 MSFT_FuncRecord *func;
136 int *data;
137 }u;
138 } CyclicList;
139
140 enum MSFT_segment_index {
141 MSFT_SEG_TYPEINFO = 0, /* type information */
142 MSFT_SEG_IMPORTINFO, /* import information */
143 MSFT_SEG_IMPORTFILES, /* import filenames */
144 MSFT_SEG_REFERENCES, /* references (?) */
145 MSFT_SEG_GUIDHASH, /* hash table for guids? */
146 MSFT_SEG_GUID, /* guid storage */
147 MSFT_SEG_NAMEHASH, /* hash table for names */
148 MSFT_SEG_NAME, /* name storage */
149 MSFT_SEG_STRING, /* string storage */
150 MSFT_SEG_TYPEDESC, /* type descriptions */
151 MSFT_SEG_ARRAYDESC, /* array descriptions */
152 MSFT_SEG_CUSTDATA, /* custom data */
153 MSFT_SEG_CUSTDATAGUID, /* custom data guids */
154 MSFT_SEG_UNKNOWN, /* ??? */
155 MSFT_SEG_UNKNOWN2, /* ??? */
156 MSFT_SEG_MAX /* total number of segments */
157 };
158
159 typedef struct tagMSFT_ImpFile {
160 int guid;
161 LCID lcid;
162 int version;
163 char filename[0]; /* preceded by two bytes of encoded (length << 2) + flags in the low two bits. */
164 } MSFT_ImpFile;
165
166 typedef struct tagICreateTypeLib2Impl
167 {
168 ICreateTypeLib2 ICreateTypeLib2_iface;
169 ITypeLib2 ITypeLib2_iface;
170 LONG ref;
171
172 BSTR filename;
173
174 MSFT_Header typelib_header;
175 INT helpStringDll;
176 MSFT_pSeg typelib_segdir[MSFT_SEG_MAX];
177 unsigned char *typelib_segment_data[MSFT_SEG_MAX];
178 int typelib_segment_block_length[MSFT_SEG_MAX];
179
180 int typelib_guids; /* Number of defined typelib guids */
181 int typeinfo_guids; /* Number of defined typeinfo guids */
182
183 INT *typelib_typeinfo_offsets;
184 int typeinfo_offsets_size;
185
186 INT *typelib_namehash_segment;
187 INT *typelib_guidhash_segment;
188
189 struct tagICreateTypeInfo2Impl *typeinfos;
190 struct tagICreateTypeInfo2Impl *last_typeinfo;
191 } ICreateTypeLib2Impl;
192
193 static inline ICreateTypeLib2Impl *impl_from_ICreateTypeLib2(ICreateTypeLib2 *iface)
194 {
195 return CONTAINING_RECORD(iface, ICreateTypeLib2Impl, ICreateTypeLib2_iface);
196 }
197
198 static inline ICreateTypeLib2Impl *impl_from_ITypeLib2(ITypeLib2 *iface)
199 {
200 return CONTAINING_RECORD(iface, ICreateTypeLib2Impl, ITypeLib2_iface);
201 }
202
203 typedef struct tagICreateTypeInfo2Impl
204 {
205 ICreateTypeInfo2 ICreateTypeInfo2_iface;
206 ITypeInfo2 ITypeInfo2_iface;
207
208 LONG ref;
209
210 ICreateTypeLib2Impl *typelib;
211 MSFT_TypeInfoBase *typeinfo;
212
213 struct tagCyclicList *typedata; /* tail of cyclic list */
214
215 TYPEKIND typekind;
216 int datawidth;
217
218 struct tagICreateTypeInfo2Impl *next_typeinfo;
219 struct tagICreateTypeInfo2Impl *dual;
220 } ICreateTypeInfo2Impl;
221
222 static inline ICreateTypeInfo2Impl *impl_from_ICreateTypeInfo2(ICreateTypeInfo2 *iface)
223 {
224 return CONTAINING_RECORD(iface, ICreateTypeInfo2Impl, ICreateTypeInfo2_iface);
225 }
226
227 static inline ICreateTypeInfo2Impl *impl_from_ITypeInfo2( ITypeInfo2 *iface )
228 {
229 return CONTAINING_RECORD(iface, ICreateTypeInfo2Impl, ITypeInfo2_iface);
230 }
231
232 static ULONG WINAPI ICreateTypeLib2_fnRelease(ICreateTypeLib2 *iface);
233
234 static CyclicList *alloc_cyclic_list_item(CyclicListElementType type)
235 {
236 CyclicList *ret = heap_alloc_zero(sizeof(CyclicList));
237 if (!ret)
238 return NULL;
239 ret->type = type;
240 return ret;
241 }
242
243 /*================== Internal functions ===================================*/
244
245 static inline UINT cti2_get_var_count(const MSFT_TypeInfoBase *typeinfo)
246 {
247 return typeinfo->cElement >> 16;
248 }
249
250 static inline UINT cti2_get_func_count(const MSFT_TypeInfoBase *typeinfo)
251 {
252 return typeinfo->cElement & 0xFFFF;
253 }
254
255 static inline INT ctl2_get_record_size(const CyclicList *iter)
256 {
257 return iter->u.data[0] & 0xFFFF;
258 }
259
260 static void ctl2_update_func_size(const ICreateTypeInfo2Impl *This, MSFT_FuncRecord *func)
261 {
262 int old = func->Info & 0xFFFF, size;
263
264 if(func->oCustData != -1)
265 size = FIELD_OFFSET(MSFT_FuncRecord, oArgCustData);
266 else if(func->HelpStringContext)
267 size = FIELD_OFFSET(MSFT_FuncRecord, oCustData);
268 else if(func->resA != -1)
269 size = FIELD_OFFSET(MSFT_FuncRecord, HelpStringContext);
270 else if(func->res9 != -1)
271 size = FIELD_OFFSET(MSFT_FuncRecord, resA);
272 else if(func->oEntry != -1)
273 size = FIELD_OFFSET(MSFT_FuncRecord, res9);
274 else if(func->oHelpString != -1)
275 size = FIELD_OFFSET(MSFT_FuncRecord, oEntry);
276 else if(func->HelpContext)
277 size = FIELD_OFFSET(MSFT_FuncRecord, oHelpString);
278 else
279 size = FIELD_OFFSET(MSFT_FuncRecord, HelpContext);
280
281 size += func->nrargs * (func->FKCCIC&0x1000 ? 16 : 12);
282
283 func->Info += size - old;
284 This->typedata->next->u.val += size - old;
285 }
286
287 static void ctl2_update_var_size(const ICreateTypeInfo2Impl *This, MSFT_VarRecord *var)
288 {
289 int old = var->Info & 0xFFFF, size;
290
291 if(var->HelpStringContext)
292 size = sizeof(*var);
293 else if(var->HelpContext)
294 size = FIELD_OFFSET(MSFT_VarRecord, HelpString);
295 else
296 size = FIELD_OFFSET(MSFT_VarRecord, HelpContext);
297
298 var->Info += size - old;
299 This->typedata->next->u.val += size - old;
300 }
301
302 static inline INVOKEKIND ctl2_get_invokekind(const MSFT_FuncRecord *func)
303 {
304 /* INVOKEKIND uses bit flags up to 8 */
305 return (func->FKCCIC >> 3) & 0xF;
306 }
307
308 static inline SYSKIND ctl2_get_syskind(const ICreateTypeLib2Impl *This)
309 {
310 return This->typelib_header.varflags & 0xF;
311 }
312
313 /****************************************************************************
314 * ctl2_init_header
315 *
316 * Initializes the type library header of a new typelib.
317 */
318 static void ctl2_init_header(
319 ICreateTypeLib2Impl *This) /* [I] The typelib to initialize. */
320 {
321 This->typelib_header.magic1 = MSFT_SIGNATURE;
322 This->typelib_header.magic2 = 0x00010002;
323 This->typelib_header.posguid = -1;
324 This->typelib_header.lcid = This->typelib_header.lcid2 = GetUserDefaultLCID();
325 This->typelib_header.varflags = 0x40;
326 This->typelib_header.version = 0;
327 This->typelib_header.flags = 0;
328 This->typelib_header.nrtypeinfos = 0;
329 This->typelib_header.helpstring = -1;
330 This->typelib_header.helpstringcontext = 0;
331 This->typelib_header.helpcontext = 0;
332 This->typelib_header.nametablecount = 0;
333 This->typelib_header.nametablechars = 0;
334 This->typelib_header.NameOffset = -1;
335 This->typelib_header.helpfile = -1;
336 This->typelib_header.CustomDataOffset = -1;
337 This->typelib_header.res44 = 0x20;
338 This->typelib_header.res48 = 0x80;
339 This->typelib_header.dispatchpos = -1;
340 This->typelib_header.nimpinfos = 0;
341 This->helpStringDll = -1;
342 }
343
344 /****************************************************************************
345 * ctl2_init_segdir
346 *
347 * Initializes the segment directory of a new typelib.
348 */
349 static void ctl2_init_segdir(
350 ICreateTypeLib2Impl *This) /* [I] The typelib to initialize. */
351 {
352 int i;
353 MSFT_pSeg *segdir;
354
355 segdir = &This->typelib_segdir[MSFT_SEG_TYPEINFO];
356
357 for (i = 0; i < 15; i++) {
358 segdir[i].offset = -1;
359 segdir[i].length = 0;
360 segdir[i].res08 = -1;
361 segdir[i].res0c = 0x0f;
362 }
363 }
364
365 /****************************************************************************
366 * ctl2_hash_guid
367 *
368 * Generates a hash key from a GUID.
369 *
370 * RETURNS
371 *
372 * The hash key for the GUID.
373 */
374 static int ctl2_hash_guid(
375 REFGUID guid) /* [I] The guid to find. */
376 {
377 int hash;
378 int i;
379
380 hash = 0;
381 for (i = 0; i < 8; i ++) {
382 hash ^= ((const short *)guid)[i];
383 }
384
385 return hash & 0x1f;
386 }
387
388 /****************************************************************************
389 * ctl2_find_guid
390 *
391 * Locates a guid in a type library.
392 *
393 * RETURNS
394 *
395 * The offset into the GUID segment of the guid, or -1 if not found.
396 */
397 static int ctl2_find_guid(
398 ICreateTypeLib2Impl *This, /* [I] The typelib to operate against. */
399 int hash_key, /* [I] The hash key for the guid. */
400 REFGUID guid) /* [I] The guid to find. */
401 {
402 int offset;
403 MSFT_GuidEntry *guidentry;
404
405 offset = This->typelib_guidhash_segment[hash_key];
406 while (offset != -1) {
407 guidentry = (MSFT_GuidEntry *)&This->typelib_segment_data[MSFT_SEG_GUID][offset];
408
409 if (IsEqualGUID(guidentry, guid)) return offset;
410
411 offset = guidentry->next_hash;
412 }
413
414 return offset;
415 }
416
417 /****************************************************************************
418 * ctl2_find_name
419 *
420 * Locates a name in a type library.
421 *
422 * RETURNS
423 *
424 * The offset into the NAME segment of the name, or -1 if not found.
425 *
426 * NOTES
427 *
428 * The name must be encoded as with ctl2_encode_name().
429 */
430 static int ctl2_find_name(
431 ICreateTypeLib2Impl *This, /* [I] The typelib to operate against. */
432 const char *name) /* [I] The encoded name to find. */
433 {
434 int offset;
435 int *namestruct;
436
437 offset = This->typelib_namehash_segment[name[2] & 0x7f];
438 while (offset != -1) {
439 namestruct = (int *)&This->typelib_segment_data[MSFT_SEG_NAME][offset];
440
441 if (!((namestruct[2] ^ *((const int *)name)) & 0xffff00ff)) {
442 /* hash codes and lengths match, final test */
443 if (!strncasecmp(name+4, (void *)(namestruct+3), name[0])) break;
444 }
445
446 /* move to next item in hash bucket */
447 offset = namestruct[1];
448 }
449
450 return offset;
451 }
452
453 /****************************************************************************
454 * ctl2_encode_name
455 *
456 * Encodes a name string to a form suitable for storing into a type library
457 * or comparing to a name stored in a type library.
458 *
459 * RETURNS
460 *
461 * The length of the encoded name, including padding and length+hash fields.
462 *
463 * NOTES
464 *
465 * Will throw an exception if name or result are NULL. Is not multithread
466 * safe in the slightest.
467 */
468 static int ctl2_encode_name(
469 ICreateTypeLib2Impl *This, /* [I] The typelib to operate against (used for LCID only). */
470 const WCHAR *name, /* [I] The name string to encode. */
471 char **result) /* [O] A pointer to a pointer to receive the encoded name. */
472 {
473 int length;
474 static char converted_name[0x104];
475 int offset;
476 int value;
477
478 length = WideCharToMultiByte(CP_ACP, 0, name, strlenW(name), converted_name+4, 0x100, NULL, NULL);
479 converted_name[0] = length & 0xff;
480
481 converted_name[length + 4] = 0;
482
483 converted_name[1] = 0x00;
484
485 value = LHashValOfNameSysA(ctl2_get_syskind(This), This->typelib_header.lcid, converted_name + 4);
486
487 converted_name[2] = value;
488 converted_name[3] = value >> 8;
489
490 for (offset = (4 - length) & 3; offset; offset--) converted_name[length + offset + 3] = 0x57;
491
492 *result = converted_name;
493
494 return (length + 7) & ~3;
495 }
496
497 /****************************************************************************
498 * ctl2_decode_name
499 *
500 * Converts string stored in typelib data to unicode.
501 */
502 static void ctl2_decode_name(
503 char *data, /* [I] String to be decoded */
504 WCHAR **string) /* [O] Decoded string */
505 {
506 int i, length;
507 static WCHAR converted_string[0x104];
508
509 length = data[0];
510
511 for(i=0; i<length; i++)
512 converted_string[i] = data[i+4];
513 converted_string[length] = '\0';
514
515 *string = converted_string;
516 }
517
518 /****************************************************************************
519 * ctl2_encode_string
520 *
521 * Encodes a string to a form suitable for storing into a type library or
522 * comparing to a string stored in a type library.
523 *
524 * RETURNS
525 *
526 * The length of the encoded string, including padding and length fields.
527 *
528 * NOTES
529 *
530 * Will throw an exception if string or result are NULL. Is not multithread
531 * safe in the slightest.
532 */
533 static int ctl2_encode_string(
534 ICreateTypeLib2Impl *This, /* [I] The typelib to operate against (not used?). */
535 const WCHAR *string, /* [I] The string to encode. */
536 char **result) /* [O] A pointer to a pointer to receive the encoded string. */
537 {
538 int length;
539 static char converted_string[0x104];
540 int offset;
541
542 length = WideCharToMultiByte(CP_ACP, 0, string, strlenW(string), converted_string+2, 0x102, NULL, NULL);
543 converted_string[0] = length & 0xff;
544 converted_string[1] = (length >> 8) & 0xff;
545
546 for (offset = (4 - (length + 2)) & 3; offset; offset--) converted_string[length + offset + 1] = 0x57;
547
548 *result = converted_string;
549
550 return (length + 5) & ~3;
551 }
552
553 /****************************************************************************
554 * ctl2_decode_string
555 *
556 * Converts string stored in typelib data to unicode.
557 */
558 static void ctl2_decode_string(
559 unsigned char *data,/* [I] String to be decoded */
560 WCHAR **string) /* [O] Decoded string */
561 {
562 int i, length;
563 static WCHAR converted_string[0x104];
564
565 length = data[0] + (data[1]<<8);
566 if((length&0x3) == 1)
567 length >>= 2;
568
569 for(i=0; i<length; i++)
570 converted_string[i] = data[i+2];
571 converted_string[length] = '\0';
572
573 *string = converted_string;
574 }
575
576 /****************************************************************************
577 * ctl2_alloc_segment
578 *
579 * Allocates memory from a segment in a type library.
580 *
581 * RETURNS
582 *
583 * Success: The offset within the segment of the new data area.
584 * Failure: -1 (this is invariably an out of memory condition).
585 *
586 * BUGS
587 *
588 * Does not (yet) handle the case where the allocated segment memory needs to grow.
589 */
590 static int ctl2_alloc_segment(
591 ICreateTypeLib2Impl *This, /* [I] The type library in which to allocate. */
592 enum MSFT_segment_index segment, /* [I] The segment in which to allocate. */
593 int size, /* [I] The amount to allocate. */
594 int block_size) /* [I] Initial allocation block size, or 0 for default. */
595 {
596 int offset;
597
598 if(!This->typelib_segment_data[segment]) {
599 if (!block_size) block_size = 0x2000;
600
601 This->typelib_segment_block_length[segment] = block_size;
602 This->typelib_segment_data[segment] = heap_alloc(block_size);
603 if (!This->typelib_segment_data[segment]) return -1;
604 memset(This->typelib_segment_data[segment], 0x57, block_size);
605 }
606
607 while ((This->typelib_segdir[segment].length + size) > This->typelib_segment_block_length[segment]) {
608 unsigned char *block;
609
610 block_size = This->typelib_segment_block_length[segment];
611 block = heap_realloc(This->typelib_segment_data[segment], block_size << 1);
612 if (!block) return -1;
613
614 if (segment == MSFT_SEG_TYPEINFO) {
615 /* TypeInfos have a direct pointer to their memory space, so we have to fix them up. */
616 ICreateTypeInfo2Impl *typeinfo;
617
618 for (typeinfo = This->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
619 typeinfo->typeinfo = (void *)&block[((unsigned char *)typeinfo->typeinfo) - This->typelib_segment_data[segment]];
620 }
621 }
622
623 memset(block + block_size, 0x57, block_size);
624 This->typelib_segment_block_length[segment] = block_size << 1;
625 This->typelib_segment_data[segment] = block;
626 }
627
628 offset = This->typelib_segdir[segment].length;
629 This->typelib_segdir[segment].length += size;
630
631 return offset;
632 }
633
634 /****************************************************************************
635 * ctl2_alloc_typeinfo
636 *
637 * Allocates and initializes a typeinfo structure in a type library.
638 *
639 * RETURNS
640 *
641 * Success: The offset of the new typeinfo.
642 * Failure: -1 (this is invariably an out of memory condition).
643 */
644 static int ctl2_alloc_typeinfo(
645 ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
646 int nameoffset) /* [I] The offset of the name for this typeinfo. */
647 {
648 int offset;
649 MSFT_TypeInfoBase *typeinfo;
650
651 if (!This->typeinfo_offsets_size) {
652 This->typelib_typeinfo_offsets = heap_alloc(8*sizeof(INT));
653 if(!This->typelib_typeinfo_offsets)
654 return -1;
655 This->typeinfo_offsets_size = 8;
656 }else if (This->typelib_header.nrtypeinfos == This->typeinfo_offsets_size) {
657 INT *new_offsets = heap_realloc(This->typelib_typeinfo_offsets,
658 2*This->typeinfo_offsets_size*sizeof(INT));
659 if(!new_offsets)
660 return -1;
661
662 This->typelib_typeinfo_offsets = new_offsets;
663 This->typeinfo_offsets_size *= 2;
664 }
665
666 offset = ctl2_alloc_segment(This, MSFT_SEG_TYPEINFO, sizeof(MSFT_TypeInfoBase), 0);
667 if (offset == -1) return -1;
668
669 This->typelib_typeinfo_offsets[This->typelib_header.nrtypeinfos++] = offset;
670
671 typeinfo = (void *)(This->typelib_segment_data[MSFT_SEG_TYPEINFO] + offset);
672
673 typeinfo->typekind = (This->typelib_header.nrtypeinfos - 1) << 16;
674 typeinfo->memoffset = -1; /* should be EOF if no elements */
675 typeinfo->res2 = 0;
676 typeinfo->res3 = 0;
677 typeinfo->res4 = 3;
678 typeinfo->res5 = 0;
679 typeinfo->cElement = 0;
680 typeinfo->res7 = 0;
681 typeinfo->res8 = 0;
682 typeinfo->res9 = 0;
683 typeinfo->resA = 0;
684 typeinfo->posguid = -1;
685 typeinfo->flags = 0;
686 typeinfo->NameOffset = nameoffset;
687 typeinfo->version = 0;
688 typeinfo->docstringoffs = -1;
689 typeinfo->helpstringcontext = 0;
690 typeinfo->helpcontext = 0;
691 typeinfo->oCustData = -1;
692 typeinfo->cbSizeVft = 0;
693 typeinfo->cImplTypes = 0;
694 typeinfo->size = 0;
695 typeinfo->datatype1 = -1;
696 typeinfo->datatype2 = 0;
697 typeinfo->res18 = 0;
698 typeinfo->res19 = -1;
699
700 return offset;
701 }
702
703 /****************************************************************************
704 * ctl2_alloc_guid
705 *
706 * Allocates and initializes a GUID structure in a type library. Also updates
707 * the GUID hash table as needed.
708 *
709 * RETURNS
710 *
711 * Success: The offset of the new GUID.
712 * Failure: -1 (this is invariably an out of memory condition).
713 */
714 static int ctl2_alloc_guid(
715 ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
716 MSFT_GuidEntry *guid) /* [I] The GUID to store. */
717 {
718 int offset;
719 MSFT_GuidEntry *guid_space;
720 int hash_key;
721
722 hash_key = ctl2_hash_guid(&guid->guid);
723
724 offset = ctl2_find_guid(This, hash_key, &guid->guid);
725 if (offset != -1) return offset;
726
727 offset = ctl2_alloc_segment(This, MSFT_SEG_GUID, sizeof(MSFT_GuidEntry), 0);
728 if (offset == -1) return -1;
729
730 guid_space = (void *)(This->typelib_segment_data[MSFT_SEG_GUID] + offset);
731 *guid_space = *guid;
732
733 guid_space->next_hash = This->typelib_guidhash_segment[hash_key];
734 This->typelib_guidhash_segment[hash_key] = offset;
735
736 return offset;
737 }
738
739 /****************************************************************************
740 * ctl2_alloc_name
741 *
742 * Allocates and initializes a name within a type library. Also updates the
743 * name hash table as needed.
744 *
745 * RETURNS
746 *
747 * Success: The offset within the segment of the new name.
748 * Failure: -1 (this is invariably an out of memory condition).
749 */
750 static int ctl2_alloc_name(
751 ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
752 const WCHAR *name) /* [I] The name to store. */
753 {
754 int length;
755 int offset;
756 MSFT_NameIntro *name_space;
757 char *encoded_name;
758
759 length = ctl2_encode_name(This, name, &encoded_name);
760
761 offset = ctl2_find_name(This, encoded_name);
762 if (offset != -1) return offset;
763
764 offset = ctl2_alloc_segment(This, MSFT_SEG_NAME, length + 8, 0);
765 if (offset == -1) return -1;
766
767 name_space = (void *)(This->typelib_segment_data[MSFT_SEG_NAME] + offset);
768 name_space->hreftype = -1;
769 name_space->next_hash = -1;
770 memcpy(&name_space->namelen, encoded_name, length);
771
772 if (This->typelib_namehash_segment[encoded_name[2] & 0x7f] != -1)
773 name_space->next_hash = This->typelib_namehash_segment[encoded_name[2] & 0x7f];
774
775 This->typelib_namehash_segment[encoded_name[2] & 0x7f] = offset;
776
777 This->typelib_header.nametablecount += 1;
778 This->typelib_header.nametablechars += *encoded_name;
779
780 return offset;
781 }
782
783 /****************************************************************************
784 * ctl2_alloc_string
785 *
786 * Allocates and initializes a string in a type library.
787 *
788 * RETURNS
789 *
790 * Success: The offset within the segment of the new string.
791 * Failure: -1 (this is invariably an out of memory condition).
792 */
793 static int ctl2_alloc_string(
794 ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
795 const WCHAR *string) /* [I] The string to store. */
796 {
797 int length;
798 int offset;
799 unsigned char *string_space;
800 char *encoded_string;
801
802 length = ctl2_encode_string(This, string, &encoded_string);
803
804 for (offset = 0; offset < This->typelib_segdir[MSFT_SEG_STRING].length;
805 offset += (((This->typelib_segment_data[MSFT_SEG_STRING][offset + 1] << 8) |
806 This->typelib_segment_data[MSFT_SEG_STRING][offset + 0]) + 5) & ~3) {
807 if (!memcmp(encoded_string, This->typelib_segment_data[MSFT_SEG_STRING] + offset, length)) return offset;
808 }
809
810 offset = ctl2_alloc_segment(This, MSFT_SEG_STRING, length, 0);
811 if (offset == -1) return -1;
812
813 string_space = This->typelib_segment_data[MSFT_SEG_STRING] + offset;
814 memcpy(string_space, encoded_string, length);
815
816 return offset;
817 }
818
819 /****************************************************************************
820 * ctl2_alloc_importinfo
821 *
822 * Allocates and initializes an import information structure in a type library.
823 *
824 * RETURNS
825 *
826 * Success: The offset of the new importinfo.
827 * Failure: -1 (this is invariably an out of memory condition).
828 */
829 static int ctl2_alloc_importinfo(
830 ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
831 MSFT_ImpInfo *impinfo) /* [I] The import information to store. */
832 {
833 int offset;
834 MSFT_ImpInfo *impinfo_space;
835
836 impinfo_space = (MSFT_ImpInfo*)&This->typelib_segment_data[MSFT_SEG_IMPORTINFO][0];
837 for (offset=0; offset<This->typelib_segdir[MSFT_SEG_IMPORTINFO].length;
838 offset+=sizeof(MSFT_ImpInfo)) {
839 if(impinfo_space->oImpFile == impinfo->oImpFile
840 && impinfo_space->oGuid == impinfo->oGuid)
841 return offset;
842
843 impinfo_space += 1;
844 }
845
846 impinfo->flags |= This->typelib_header.nimpinfos++;
847
848 offset = ctl2_alloc_segment(This, MSFT_SEG_IMPORTINFO, sizeof(MSFT_ImpInfo), 0);
849 if (offset == -1) return -1;
850
851 impinfo_space = (void *)(This->typelib_segment_data[MSFT_SEG_IMPORTINFO] + offset);
852 *impinfo_space = *impinfo;
853
854 return offset;
855 }
856
857 /****************************************************************************
858 * ctl2_alloc_importfile
859 *
860 * Allocates and initializes an import file definition in a type library.
861 *
862 * RETURNS
863 *
864 * Success: The offset of the new importinfo.
865 * Failure: -1 (this is invariably an out of memory condition).
866 */
867 static int ctl2_alloc_importfile(
868 ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
869 int guidoffset, /* [I] The offset to the GUID for the imported library. */
870 LCID lcid, /* [I] The LCID of imported library. */
871 int major_version, /* [I] The major version number of the imported library. */
872 int minor_version, /* [I] The minor version number of the imported library. */
873 const WCHAR *filename) /* [I] The filename of the imported library. */
874 {
875 int length;
876 int offset;
877 MSFT_ImpFile *importfile;
878 char *encoded_string;
879
880 length = ctl2_encode_string(This, filename, &encoded_string);
881
882 encoded_string[0] <<= 2;
883 encoded_string[0] |= 1;
884
885 for (offset = 0; offset < This->typelib_segdir[MSFT_SEG_IMPORTFILES].length;
886 offset += (((((This->typelib_segment_data[MSFT_SEG_IMPORTFILES][offset + 0xd] << 8) |
887 This->typelib_segment_data[MSFT_SEG_IMPORTFILES][offset + 0xc]) >> 2) + 5) & 0xfffc) + 0xc) {
888 if (!memcmp(encoded_string, This->typelib_segment_data[MSFT_SEG_IMPORTFILES] + offset + 0xc, length)) return offset;
889 }
890
891 offset = ctl2_alloc_segment(This, MSFT_SEG_IMPORTFILES, length + 0xc, 0);
892 if (offset == -1) return -1;
893
894 importfile = (MSFT_ImpFile *)&This->typelib_segment_data[MSFT_SEG_IMPORTFILES][offset];
895 importfile->guid = guidoffset;
896 importfile->lcid = lcid;
897 importfile->version = major_version | (minor_version << 16);
898 memcpy(importfile->filename, encoded_string, length);
899
900 return offset;
901 }
902
903 /****************************************************************************
904 * ctl2_encode_variant
905 *
906 * Encodes a variant, inline if possible or in custom data segment
907 *
908 * RETURNS
909 *
910 * Success: S_OK
911 * Failure: Error code from winerror.h
912 */
913 static HRESULT ctl2_encode_variant(
914 ICreateTypeLib2Impl *This, /* [I] The typelib to allocate data in */
915 int *encoded_value, /* [O] The encoded default value or data offset */
916 VARIANT *value, /* [I] Default value to be encoded */
917 VARTYPE arg_type) /* [I] Argument type */
918 {
919 VARIANT v;
920 HRESULT hres;
921 int mask = 0;
922
923 TRACE("%p %d %d\n", This, V_VT(value), arg_type);
924
925 if(arg_type == VT_INT)
926 arg_type = VT_I4;
927 if(arg_type == VT_UINT)
928 arg_type = VT_UI4;
929
930 v = *value;
931 if(arg_type==VT_VARIANT || arg_type==VT_USERDEFINED) {
932 arg_type = V_VT(value);
933 }else if(V_VT(value) != arg_type) {
934 hres = VariantChangeType(&v, value, 0, arg_type);
935 if(FAILED(hres))
936 return hres;
937 }
938
939 /* Check if default value can be stored in encoded_value */
940 switch(arg_type) {
941 case VT_INT:
942 case VT_UINT:
943 case VT_I4:
944 case VT_UI4:
945 mask = 0x3ffffff;
946 if(V_UI4(&v)>0x3ffffff)
947 break;
948 /* fall through */
949 case VT_I1:
950 case VT_UI1:
951 case VT_BOOL:
952 if(!mask)
953 mask = 0xff;
954 /* fall through */
955 case VT_I2:
956 case VT_UI2:
957 if(!mask)
958 mask = 0xffff;
959 *encoded_value = (V_UI4(&v)&mask) | ((0x80+0x4*arg_type)<<24);
960 return S_OK;
961 }
962
963 switch(arg_type) {
964 case VT_I4:
965 case VT_R4:
966 case VT_UI4:
967 case VT_INT:
968 case VT_UINT:
969 case VT_HRESULT:
970 case VT_PTR: {
971 /* Construct the data to be allocated */
972 int data[2];
973 data[0] = arg_type + (V_UI4(&v)<<16);
974 data[1] = (V_UI4(&v)>>16) + 0x57570000;
975
976 /* Check if the data was already allocated */
977 /* Currently the structures doesn't allow to do it in a nice way */
978 for(*encoded_value=0; *encoded_value<=This->typelib_segdir[MSFT_SEG_CUSTDATA].length-8; *encoded_value+=4)
979 if(!memcmp(&This->typelib_segment_data[MSFT_SEG_CUSTDATA][*encoded_value], data, 8))
980 return S_OK;
981
982 /* Allocate the data */
983 *encoded_value = ctl2_alloc_segment(This, MSFT_SEG_CUSTDATA, 8, 0);
984 if(*encoded_value == -1)
985 return E_OUTOFMEMORY;
986
987 memcpy(&This->typelib_segment_data[MSFT_SEG_CUSTDATA][*encoded_value], data, 8);
988 return S_OK;
989 }
990 case VT_BSTR: {
991 /* Construct the data */
992 int i, len = (6+SysStringLen(V_BSTR(&v))+3) & ~0x3;
993 char *data = heap_alloc(len);
994
995 if(!data)
996 return E_OUTOFMEMORY;
997
998 *((unsigned short*)data) = arg_type;
999 *((unsigned*)(data+2)) = SysStringLen(V_BSTR(&v));
1000 for(i=0; i<SysStringLen(V_BSTR(&v)); i++) {
1001 if(V_BSTR(&v)[i] <= 0x7f)
1002 data[i+6] = V_BSTR(&v)[i];
1003 else
1004 data[i+6] = '?';
1005 }
1006 WideCharToMultiByte(CP_ACP, 0, V_BSTR(&v), SysStringLen(V_BSTR(&v)), &data[6], len-6, NULL, NULL);
1007 for(i=6+SysStringLen(V_BSTR(&v)); i<len; i++)
1008 data[i] = 0x57;
1009
1010 /* Check if the data was already allocated */
1011 for(*encoded_value=0; *encoded_value<=This->typelib_segdir[MSFT_SEG_CUSTDATA].length-len; *encoded_value+=4)
1012 if(!memcmp(&This->typelib_segment_data[MSFT_SEG_CUSTDATA][*encoded_value], data, len)) {
1013 heap_free(data);
1014 return S_OK;
1015 }
1016
1017 /* Allocate the data */
1018 *encoded_value = ctl2_alloc_segment(This, MSFT_SEG_CUSTDATA, len, 0);
1019 if(*encoded_value == -1) {
1020 heap_free(data);
1021 return E_OUTOFMEMORY;
1022 }
1023
1024 memcpy(&This->typelib_segment_data[MSFT_SEG_CUSTDATA][*encoded_value], data, len);
1025 heap_free(data);
1026 return S_OK;
1027 }
1028 default:
1029 FIXME("Argument type not yet handled\n");
1030 return E_NOTIMPL;
1031 }
1032 }
1033
1034 static int ctl2_find_custdata(
1035 ICreateTypeLib2Impl *This,
1036 REFGUID guid,
1037 int offset)
1038 {
1039 while (offset != -1) {
1040 MSFT_CDGuid *cdentry =
1041 (MSFT_CDGuid *)&This->typelib_segment_data[MSFT_SEG_CUSTDATAGUID][offset];
1042 MSFT_GuidEntry *guidentry =
1043 (MSFT_GuidEntry *)&This->typelib_segment_data[MSFT_SEG_GUID][cdentry->GuidOffset];
1044
1045 if (IsEqualGUID(guidentry, guid))
1046 return offset;
1047
1048 offset = cdentry->next;
1049 }
1050
1051 return -1;
1052 }
1053
1054 /****************************************************************************
1055 * ctl2_decode_variant
1056 *
1057 * Decodes a variant
1058 *
1059 * RETURNS
1060 *
1061 * Success: S_OK
1062 * Failure: Error code from winerror.h
1063 */
1064 static HRESULT ctl2_decode_variant(
1065 ICreateTypeLib2Impl *This, /* [I] The typelib that contains the variant */
1066 int data_offs, /* [I] Offset within the data array, or the encoded value itself */
1067 VARIANT *value) /* [O] Decoded value */
1068 {
1069 unsigned char *encoded_data;
1070 VARTYPE type;
1071
1072 if (data_offs & 0x80000000) {
1073 /* data_offs contains the encoded value */
1074 V_VT(value) = (data_offs & ~0x80000000) >> 26;
1075 V_UI4(value) = data_offs & ~0xFF000000;
1076 return S_OK;
1077 }
1078
1079 encoded_data = &This->typelib_segment_data[MSFT_SEG_CUSTDATA][data_offs];
1080 type = *encoded_data;
1081
1082 switch(type) {
1083 case VT_I4:
1084 case VT_R4:
1085 case VT_UI4:
1086 case VT_INT:
1087 case VT_UINT:
1088 case VT_HRESULT:
1089 case VT_PTR: {
1090 V_VT(value) = type;
1091 V_UI4(value) = *(unsigned*)(encoded_data + 2);
1092 return S_OK;
1093 }
1094 case VT_BSTR: {
1095 unsigned len, i;
1096
1097 len = *(unsigned*)(encoded_data + 2);
1098
1099 V_VT(value) = type;
1100 V_BSTR(value) = SysAllocStringByteLen(NULL, len * sizeof(OLECHAR));
1101 for (i = 0; i < len; ++i)
1102 V_BSTR(value)[i] = *(encoded_data + 6 + i);
1103
1104 return S_OK;
1105 }
1106 default:
1107 FIXME("Don't yet have decoder for this VARTYPE: %u\n", type);
1108 return E_NOTIMPL;
1109 }
1110 }
1111
1112 /****************************************************************************
1113 * ctl2_set_custdata
1114 *
1115 * Adds a custom data element to an object in a type library.
1116 *
1117 * RETURNS
1118 *
1119 * Success: S_OK.
1120 * Failure: One of E_INVALIDARG or E_OUTOFMEMORY.
1121 */
1122 static HRESULT ctl2_set_custdata(
1123 ICreateTypeLib2Impl *This, /* [I] The type library to store the custom data in. */
1124 REFGUID guid, /* [I] The GUID used as a key to retrieve the custom data. */
1125 VARIANT *pVarVal, /* [I] The custom data itself. */
1126 int *offset) /* [I/O] The list of custom data to prepend to. */
1127 {
1128 MSFT_GuidEntry guidentry;
1129 HRESULT status;
1130 int dataoffset;
1131 int guidoffset;
1132 int custoffset;
1133 int *custdata;
1134 BOOL new_segment = FALSE;
1135
1136 switch(V_VT(pVarVal))
1137 {
1138 case VT_I4:
1139 case VT_R4:
1140 case VT_UI4:
1141 case VT_INT:
1142 case VT_UINT:
1143 case VT_HRESULT:
1144 case VT_BSTR:
1145 /* empty */
1146 break;
1147 default:
1148 return DISP_E_BADVARTYPE;
1149 }
1150
1151 guidentry.guid = *guid;
1152
1153 guidentry.hreftype = -1;
1154 guidentry.next_hash = -1;
1155
1156 guidoffset = ctl2_alloc_guid(This, &guidentry);
1157 if (guidoffset == -1) return E_OUTOFMEMORY;
1158
1159 status = ctl2_encode_variant(This, &dataoffset, pVarVal, V_VT(pVarVal));
1160 if (status)
1161 return status;
1162
1163 custoffset = ctl2_find_custdata(This, guid, *offset);
1164 if (custoffset == -1) {
1165 custoffset = ctl2_alloc_segment(This, MSFT_SEG_CUSTDATAGUID, 12, 0);
1166 if (custoffset == -1)
1167 return E_OUTOFMEMORY;
1168 new_segment = TRUE;
1169 }
1170
1171 custdata = (int *)&This->typelib_segment_data[MSFT_SEG_CUSTDATAGUID][custoffset];
1172 custdata[0] = guidoffset;
1173 custdata[1] = dataoffset;
1174 if (new_segment) {
1175 custdata[2] = *offset;
1176 *offset = custoffset;
1177 }
1178
1179 return S_OK;
1180 }
1181
1182 /****************************************************************************
1183 * ctl2_encode_typedesc
1184 *
1185 * Encodes a type description, storing information in the TYPEDESC and ARRAYDESC
1186 * segments as needed.
1187 *
1188 * RETURNS
1189 *
1190 * Success: 0.
1191 * Failure: -1.
1192 */
1193 static int ctl2_encode_typedesc(
1194 ICreateTypeLib2Impl *This, /* [I] The type library in which to encode the TYPEDESC. */
1195 const TYPEDESC *tdesc, /* [I] The type description to encode. */
1196 int *encoded_tdesc, /* [O] The encoded type description. */
1197 int *width, /* [O] The width of the type, or NULL. */
1198 int *alignment, /* [O] The alignment of the type, or NULL. */
1199 int *decoded_size) /* [O] The total size of the unencoded TYPEDESCs, including nested descs. */
1200 {
1201 int default_tdesc;
1202 int scratch;
1203 int typeoffset;
1204 int arrayoffset;
1205 int *typedata;
1206 int *arraydata;
1207 int target_type;
1208 int child_size;
1209
1210 default_tdesc = 0x80000000 | (tdesc->vt << 16) | tdesc->vt;
1211 if (!width) width = &scratch;
1212 if (!alignment) alignment = &scratch;
1213 if (!decoded_size) decoded_size = &scratch;
1214
1215 *decoded_size = 0;
1216
1217 switch (tdesc->vt) {
1218 case VT_UI1:
1219 case VT_I1:
1220 *encoded_tdesc = default_tdesc;
1221 *width = 1;
1222 *alignment = 1;
1223 break;
1224
1225 case VT_INT:
1226 *encoded_tdesc = 0x80000000 | (VT_I4 << 16) | VT_INT;
1227 if (ctl2_get_syskind(This) == SYS_WIN16) {
1228 *width = 2;
1229 *alignment = 2;
1230 } else {
1231 *width = 4;
1232 *alignment = 4;
1233 }
1234 break;
1235
1236 case VT_UINT:
1237 *encoded_tdesc = 0x80000000 | (VT_UI4 << 16) | VT_UINT;
1238 if (ctl2_get_syskind(This) == SYS_WIN16) {
1239 *width = 2;
1240 *alignment = 2;
1241 } else {
1242 *width = 4;
1243 *alignment = 4;
1244 }
1245 break;
1246
1247 case VT_UI2:
1248 case VT_I2:
1249 case VT_BOOL:
1250 *encoded_tdesc = default_tdesc;
1251 *width = 2;
1252 *alignment = 2;
1253 break;
1254
1255 case VT_I4:
1256 case VT_UI4:
1257 case VT_R4:
1258 case VT_ERROR:
1259 case VT_BSTR:
1260 case VT_HRESULT:
1261 *encoded_tdesc = default_tdesc;
1262 *width = 4;
1263 *alignment = 4;
1264 break;
1265
1266 case VT_CY:
1267 *encoded_tdesc = default_tdesc;
1268 *width = 8;
1269 *alignment = 4; /* guess? */
1270 break;
1271
1272 case VT_VARIANT:
1273 *encoded_tdesc = default_tdesc;
1274 *width = sizeof(VT_VARIANT);
1275 *alignment = 4;
1276 break;
1277
1278 case VT_VOID:
1279 *encoded_tdesc = 0x80000000 | (VT_EMPTY << 16) | tdesc->vt;
1280 *width = 0;
1281 *alignment = 1;
1282 break;
1283
1284 case VT_PTR:
1285 case VT_SAFEARRAY:
1286 /* FIXME: Make with the error checking. */
1287 FIXME("PTR or SAFEARRAY vartype, may not work correctly.\n");
1288
1289 ctl2_encode_typedesc(This, tdesc->u.lptdesc, &target_type, NULL, NULL, &child_size);
1290
1291 for (typeoffset = 0; typeoffset < This->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
1292 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1293 if (((typedata[0] & 0xffff) == tdesc->vt) && (typedata[1] == target_type)) break;
1294 }
1295
1296 if (typeoffset == This->typelib_segdir[MSFT_SEG_TYPEDESC].length) {
1297 int mix_field;
1298
1299 if (target_type & 0x80000000) {
1300 mix_field = (target_type >> 16) & VT_TYPEMASK;
1301 } else {
1302 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][target_type];
1303 switch((typedata[0]>>16) & ~VT_ARRAY)
1304 {
1305 case VT_UI1:
1306 case VT_I1:
1307 case VT_UI2:
1308 case VT_I2:
1309 case VT_I4:
1310 case VT_UI4:
1311 mix_field = typedata[0]>>16;
1312 break;
1313 default:
1314 mix_field = ((typedata[0] >> 16) == 0x7fff) ? 0x7fff : 0x7ffe;
1315 break;
1316 }
1317 }
1318
1319 if (tdesc->vt == VT_PTR)
1320 mix_field |= VT_BYREF;
1321 else if (tdesc->vt == VT_SAFEARRAY)
1322 mix_field |= VT_ARRAY;
1323
1324 typeoffset = ctl2_alloc_segment(This, MSFT_SEG_TYPEDESC, 8, 0);
1325 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1326
1327 typedata[0] = (mix_field << 16) | tdesc->vt;
1328 typedata[1] = target_type;
1329 }
1330
1331 *encoded_tdesc = typeoffset;
1332
1333 *width = 4;
1334 *alignment = 4;
1335 *decoded_size = sizeof(TYPEDESC) + child_size;
1336 break;
1337
1338 case VT_CARRAY:
1339 {
1340 /* FIXME: Make with the error checking. */
1341 int num_dims = tdesc->u.lpadesc->cDims, elements = 1, dim;
1342
1343 ctl2_encode_typedesc(This, &tdesc->u.lpadesc->tdescElem, &target_type, width, alignment, NULL);
1344 arrayoffset = ctl2_alloc_segment(This, MSFT_SEG_ARRAYDESC, (2 + 2 * num_dims) * sizeof(int), 0);
1345 arraydata = (void *)&This->typelib_segment_data[MSFT_SEG_ARRAYDESC][arrayoffset];
1346
1347 arraydata[0] = target_type;
1348 arraydata[1] = num_dims;
1349 arraydata[1] |= ((num_dims * 2 * sizeof(int)) << 16);
1350 arraydata += 2;
1351
1352 for(dim = 0; dim < num_dims; dim++) {
1353 arraydata[0] = tdesc->u.lpadesc->rgbounds[dim].cElements;
1354 arraydata[1] = tdesc->u.lpadesc->rgbounds[dim].lLbound;
1355 elements *= tdesc->u.lpadesc->rgbounds[dim].cElements;
1356 arraydata += 2;
1357 }
1358 typeoffset = ctl2_alloc_segment(This, MSFT_SEG_TYPEDESC, 8, 0);
1359 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1360
1361 typedata[0] = (0x7ffe << 16) | VT_CARRAY;
1362 typedata[1] = arrayoffset;
1363
1364 *encoded_tdesc = typeoffset;
1365 *width = *width * elements;
1366 *decoded_size = sizeof(ARRAYDESC) + (num_dims - 1) * sizeof(SAFEARRAYBOUND);
1367
1368 break;
1369 }
1370 case VT_USERDEFINED:
1371 {
1372 const MSFT_TypeInfoBase *basetype;
1373 INT basevt = 0x7fff;
1374
1375 TRACE("USERDEFINED.\n");
1376 if (tdesc->u.hreftype % sizeof(*basetype) == 0 && tdesc->u.hreftype < This->typelib_segdir[MSFT_SEG_TYPEINFO].length)
1377 {
1378 basetype = (MSFT_TypeInfoBase*)&(This->typelib_segment_data[MSFT_SEG_TYPEINFO][tdesc->u.hreftype]);
1379 switch(basetype->typekind & 0xf)
1380 {
1381 case TKIND_ENUM:
1382 basevt = VT_I4;
1383 break;
1384 default:
1385 FIXME("USERDEFINED basetype %d not handled\n", basetype->typekind & 0xf);
1386 break;
1387 }
1388 }
1389 for (typeoffset = 0; typeoffset < This->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
1390 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1391 if ((typedata[0] == ((basevt << 16) | VT_USERDEFINED)) && (typedata[1] == tdesc->u.hreftype)) break;
1392 }
1393
1394 if (typeoffset == This->typelib_segdir[MSFT_SEG_TYPEDESC].length) {
1395 typeoffset = ctl2_alloc_segment(This, MSFT_SEG_TYPEDESC, 8, 0);
1396 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1397
1398 typedata[0] = (basevt << 16) | VT_USERDEFINED;
1399 typedata[1] = tdesc->u.hreftype;
1400 }
1401
1402 *encoded_tdesc = typeoffset;
1403 *width = 0;
1404 *alignment = 1;
1405 break;
1406 }
1407
1408 default:
1409 FIXME("Unrecognized type %d.\n", tdesc->vt);
1410 *encoded_tdesc = default_tdesc;
1411 *width = 0;
1412 *alignment = 1;
1413 break;
1414 }
1415
1416 return 0;
1417 }
1418
1419 /****************************************************************************
1420 * ctl2_decode_typedesc
1421 *
1422 * Decodes a type description from an ICreateTypeLib2Impl.
1423 *
1424 * RETURNS
1425 *
1426 * Success: S_OK.
1427 * Failure: HRESULT error code.
1428 */
1429 static HRESULT ctl2_decode_typedesc(
1430 ICreateTypeLib2Impl *This, /* [I] The type library from which to decode the TYPEDESC. */
1431 int encoded_tdesc, /* [I] The encoded type description. */
1432 TYPEDESC *tdesc) /* [O] The decoded type description. */
1433 {
1434 int *typedata, i;
1435 HRESULT hres;
1436
1437 if (encoded_tdesc & 0x80000000) {
1438 tdesc->vt = encoded_tdesc & VT_TYPEMASK;
1439 tdesc->u.lptdesc = NULL;
1440 return S_OK;
1441 }
1442
1443 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][encoded_tdesc];
1444
1445 tdesc->vt = typedata[0] & 0xFFFF;
1446
1447 switch(tdesc->vt) {
1448 case VT_PTR:
1449 case VT_SAFEARRAY:
1450 tdesc->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
1451 if (!tdesc->u.lptdesc)
1452 return E_OUTOFMEMORY;
1453
1454 hres = ctl2_decode_typedesc(This, typedata[1], tdesc->u.lptdesc);
1455 if (FAILED(hres)) {
1456 heap_free(tdesc->u.lptdesc);
1457 return hres;
1458 }
1459
1460 return S_OK;
1461
1462 case VT_CARRAY: {
1463 int arrayoffset, *arraydata, num_dims;
1464
1465 arrayoffset = typedata[1];
1466 arraydata = (void *)&This->typelib_segment_data[MSFT_SEG_ARRAYDESC][arrayoffset];
1467 num_dims = arraydata[1] & 0xFFFF;
1468
1469 tdesc->u.lpadesc = heap_alloc_zero(sizeof(ARRAYDESC) + sizeof(SAFEARRAYBOUND) * (num_dims - 1));
1470 if (!tdesc->u.lpadesc)
1471 return E_OUTOFMEMORY;
1472
1473 hres = ctl2_decode_typedesc(This, arraydata[0], &tdesc->u.lpadesc->tdescElem);
1474 if (FAILED(hres)) {
1475 heap_free(tdesc->u.lpadesc);
1476 return E_OUTOFMEMORY;
1477 }
1478
1479 for (i = 0; i < num_dims; ++i) {
1480 tdesc->u.lpadesc->rgbounds[i].cElements = arraydata[2 + i * 2];
1481 tdesc->u.lpadesc->rgbounds[i].lLbound = arraydata[3 + i * 2];
1482 }
1483
1484 return S_OK;
1485 }
1486 case VT_USERDEFINED:
1487 tdesc->u.hreftype = typedata[1];
1488 return S_OK;
1489 default:
1490 FIXME("unable to decode typedesc (%08x): unknown VT: %d\n", encoded_tdesc, tdesc->vt);
1491 return E_NOTIMPL;
1492 }
1493 }
1494
1495 /****************************************************************************
1496 * ctl2_find_nth_reference
1497 *
1498 * Finds a reference by index into the linked list of reference records.
1499 *
1500 * RETURNS
1501 *
1502 * Success: Offset of the desired reference record.
1503 * Failure: -1.
1504 */
1505 static int ctl2_find_nth_reference(
1506 ICreateTypeLib2Impl *This, /* [I] The type library in which to search. */
1507 int offset, /* [I] The starting offset of the reference list. */
1508 int index) /* [I] The index of the reference to find. */
1509 {
1510 MSFT_RefRecord *ref;
1511
1512 for (; index && (offset != -1); index--) {
1513 ref = (MSFT_RefRecord *)&This->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
1514 offset = ref->onext;
1515 }
1516
1517 return offset;
1518 }
1519
1520 /****************************************************************************
1521 * ctl2_find_typeinfo_from_offset
1522 *
1523 * Finds an ITypeInfo given an offset into the TYPEINFO segment.
1524 *
1525 * RETURNS
1526 *
1527 * Success: S_OK.
1528 * Failure: TYPE_E_ELEMENTNOTFOUND.
1529 */
1530 static HRESULT ctl2_find_typeinfo_from_offset(
1531 ICreateTypeLib2Impl *This, /* [I] The typelib to find the typeinfo in. */
1532 int offset, /* [I] The offset of the desired typeinfo. */
1533 ITypeInfo **ppTinfo) /* [I] The typeinfo found. */
1534 {
1535 void *typeinfodata;
1536 ICreateTypeInfo2Impl *typeinfo;
1537
1538 typeinfodata = &This->typelib_segment_data[MSFT_SEG_TYPEINFO][offset];
1539
1540 for (typeinfo = This->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
1541 if (typeinfo->typeinfo == typeinfodata) {
1542 *ppTinfo = (ITypeInfo *)&typeinfo->ITypeInfo2_iface;
1543 ITypeInfo_AddRef(*ppTinfo);
1544 return S_OK;
1545 }
1546 }
1547
1548 ERR("Failed to find typeinfo, invariant varied.\n");
1549
1550 return TYPE_E_ELEMENTNOTFOUND;
1551 }
1552
1553 /*================== ICreateTypeInfo2 Implementation ===================================*/
1554
1555 /******************************************************************************
1556 * ICreateTypeInfo2_QueryInterface {OLEAUT32}
1557 *
1558 */
1559 static HRESULT WINAPI ICreateTypeInfo2_fnQueryInterface(
1560 ICreateTypeInfo2 * iface,
1561 REFIID riid,
1562 VOID **ppvObject)
1563 {
1564 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
1565
1566 TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
1567
1568 *ppvObject=NULL;
1569 if(IsEqualIID(riid, &IID_IUnknown) ||
1570 IsEqualIID(riid,&IID_ICreateTypeInfo)||
1571 IsEqualIID(riid,&IID_ICreateTypeInfo2))
1572 {
1573 *ppvObject = This;
1574 } else if (IsEqualIID(riid, &IID_ITypeInfo) ||
1575 IsEqualIID(riid, &IID_ITypeInfo2)) {
1576 *ppvObject = &This->ITypeInfo2_iface;
1577 }
1578
1579 if(*ppvObject)
1580 {
1581 ICreateTypeInfo2_AddRef(iface);
1582 TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
1583 return S_OK;
1584 }
1585 TRACE("-- Interface: E_NOINTERFACE\n");
1586 return E_NOINTERFACE;
1587 }
1588
1589 /******************************************************************************
1590 * ICreateTypeInfo2_AddRef {OLEAUT32}
1591 */
1592 static ULONG WINAPI ICreateTypeInfo2_fnAddRef(ICreateTypeInfo2 *iface)
1593 {
1594 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
1595 ULONG ref = InterlockedIncrement(&This->ref);
1596
1597 TRACE("(%p)->ref was %u\n",This, ref - 1);
1598
1599 if(ref==1 && This->typelib)
1600 ICreateTypeLib2_AddRef(&This->typelib->ICreateTypeLib2_iface);
1601
1602 return ref;
1603 }
1604
1605 /******************************************************************************
1606 * ICreateTypeInfo2_Release {OLEAUT32}
1607 */
1608 static ULONG WINAPI ICreateTypeInfo2_fnRelease(ICreateTypeInfo2 *iface)
1609 {
1610 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
1611 ULONG ref = InterlockedDecrement(&This->ref);
1612
1613 TRACE("(%p)->(%u)\n",This, ref);
1614
1615 if (!ref) {
1616 if (This->typelib) {
1617 ICreateTypeLib2_fnRelease(&This->typelib->ICreateTypeLib2_iface);
1618 /* Keep This->typelib reference to make stored ICreateTypeInfo structure valid */
1619 /* This->typelib = NULL; */
1620 }
1621
1622 /* ICreateTypeLib2 frees all ICreateTypeInfos when it releases. */
1623 /* HeapFree(GetProcessHeap(),0,This); */
1624 return 0;
1625 }
1626
1627 return ref;
1628 }
1629
1630
1631 /******************************************************************************
1632 * ICreateTypeInfo2_SetGuid {OLEAUT32}
1633 */
1634 static HRESULT WINAPI ICreateTypeInfo2_fnSetGuid(ICreateTypeInfo2 *iface, REFGUID guid)
1635 {
1636 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
1637
1638 MSFT_GuidEntry guidentry;
1639 int offset;
1640
1641 TRACE("(%p,%s)\n", iface, debugstr_guid(guid));
1642
1643 guidentry.guid = *guid;
1644 guidentry.hreftype = This->typelib->typelib_typeinfo_offsets[This->typeinfo->typekind >> 16];
1645 guidentry.next_hash = -1;
1646
1647 offset = ctl2_alloc_guid(This->typelib, &guidentry);
1648
1649 if (offset == -1) return E_OUTOFMEMORY;
1650
1651 This->typeinfo->posguid = offset;
1652
1653 if (IsEqualIID(guid, &IID_IDispatch)) {
1654 This->typelib->typelib_header.dispatchpos = This->typelib->typelib_typeinfo_offsets[This->typeinfo->typekind >> 16];
1655 }
1656
1657 return S_OK;
1658 }
1659
1660 /******************************************************************************
1661 * ICreateTypeInfo2_SetTypeFlags {OLEAUT32}
1662 */
1663 static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeFlags(ICreateTypeInfo2 *iface, UINT uTypeFlags)
1664 {
1665 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
1666
1667 TRACE("(%p,0x%x)\n", iface, uTypeFlags);
1668
1669 if(uTypeFlags & TYPEFLAG_FDUAL) {
1670 static const WCHAR stdole2tlb[] = { 's','t','d','o','l','e','2','.','t','l','b',0 };
1671 ITypeLib *stdole;
1672 ITypeInfo *dispatch;
1673 HREFTYPE hreftype;
1674 HRESULT hres;
1675
1676 This->typeinfo->typekind |= 0x10;
1677 This->typeinfo->typekind &= ~0x0f;
1678 This->typeinfo->typekind |= TKIND_DISPATCH;
1679
1680 if(!This->dual) {
1681 This->dual = heap_alloc(sizeof(ICreateTypeInfo2Impl));
1682 if(!This->dual)
1683 return E_OUTOFMEMORY;
1684
1685 memcpy(This->dual, This, sizeof(ICreateTypeInfo2Impl));
1686 This->dual->ref = 0;
1687 This->dual->typekind = This->typekind==TKIND_DISPATCH ?
1688 TKIND_INTERFACE : TKIND_DISPATCH;
1689 This->dual->dual = This;
1690 }
1691
1692 /* Make sure dispatch is in typeinfos queue */
1693 if(This->typekind != TKIND_DISPATCH) {
1694 if(This->typelib->last_typeinfo == This)
1695 This->typelib->last_typeinfo = This->dual;
1696
1697 if(This->typelib->typeinfos == This)
1698 This->typelib->typeinfos = This->dual;
1699 else {
1700 ICreateTypeInfo2Impl *iter;
1701
1702 for(iter=This->typelib->typeinfos; iter->next_typeinfo!=This; iter=iter->next_typeinfo);
1703 iter->next_typeinfo = This->dual;
1704 }
1705 } else
1706 iface = &This->dual->ICreateTypeInfo2_iface;
1707
1708 hres = LoadTypeLib(stdole2tlb, &stdole);
1709 if(FAILED(hres))
1710 return hres;
1711
1712 hres = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IDispatch, &dispatch);
1713 ITypeLib_Release(stdole);
1714 if(FAILED(hres))
1715 return hres;
1716
1717 hres = ICreateTypeInfo2_AddRefTypeInfo(iface, dispatch, &hreftype);
1718 ITypeInfo_Release(dispatch);
1719 if(FAILED(hres))
1720 return hres;
1721 }
1722
1723 This->typeinfo->flags = uTypeFlags;
1724 return S_OK;
1725 }
1726
1727 /******************************************************************************
1728 * ICreateTypeInfo2_SetDocString {OLEAUT32}
1729 */
1730 static HRESULT WINAPI ICreateTypeInfo2_fnSetDocString(
1731 ICreateTypeInfo2* iface,
1732 LPOLESTR pStrDoc)
1733 {
1734 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
1735
1736 int offset;
1737
1738 TRACE("(%p,%s)\n", iface, debugstr_w(pStrDoc));
1739 if (!pStrDoc)
1740 return E_INVALIDARG;
1741
1742 offset = ctl2_alloc_string(This->typelib, pStrDoc);
1743 if (offset == -1) return E_OUTOFMEMORY;
1744 This->typeinfo->docstringoffs = offset;
1745 return S_OK;
1746 }
1747
1748 /******************************************************************************
1749 * ICreateTypeInfo2_SetHelpContext {OLEAUT32}
1750 */
1751 static HRESULT WINAPI ICreateTypeInfo2_fnSetHelpContext(
1752 ICreateTypeInfo2* iface,
1753 DWORD dwHelpContext)
1754 {
1755 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
1756
1757 TRACE("(%p,%d)\n", iface, dwHelpContext);
1758
1759 This->typeinfo->helpcontext = dwHelpContext;
1760
1761 return S_OK;
1762 }
1763
1764 /******************************************************************************
1765 * ICreateTypeInfo2_SetVersion {OLEAUT32}
1766 */
1767 static HRESULT WINAPI ICreateTypeInfo2_fnSetVersion(
1768 ICreateTypeInfo2* iface,
1769 WORD wMajorVerNum,
1770 WORD wMinorVerNum)
1771 {
1772 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
1773
1774 TRACE("(%p,%d,%d)\n", iface, wMajorVerNum, wMinorVerNum);
1775
1776 This->typeinfo->version = wMajorVerNum | (wMinorVerNum << 16);
1777 return S_OK;
1778 }
1779
1780 /******************************************************************************
1781 * ICreateTypeInfo2_AddRefTypeInfo {OLEAUT32}
1782 */
1783 static HRESULT WINAPI ICreateTypeInfo2_fnAddRefTypeInfo(
1784 ICreateTypeInfo2* iface,
1785 ITypeInfo* pTInfo,
1786 HREFTYPE* phRefType)
1787 {
1788 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
1789
1790 ITypeLib *container;
1791 UINT index;
1792 HRESULT res;
1793
1794 TRACE("(%p,%p,%p)\n", iface, pTInfo, phRefType);
1795
1796 if(!pTInfo || !phRefType)
1797 return E_INVALIDARG;
1798
1799 /*
1800 * Unfortunately, we can't rely on the passed-in TypeInfo even having the
1801 * same internal structure as one of ours. It could be from another
1802 * implementation of ITypeInfo. So we need to do the following...
1803 */
1804 res = ITypeInfo_GetContainingTypeLib(pTInfo, &container, &index);
1805 if (FAILED(res)) {
1806 TRACE("failed to find containing typelib.\n");
1807 return res;
1808 }
1809
1810 if (container == (ITypeLib *)&This->typelib->ITypeLib2_iface) {
1811 /* Process locally defined TypeInfo */
1812 *phRefType = This->typelib->typelib_typeinfo_offsets[index];
1813 } else {
1814 BSTR name;
1815 TLIBATTR *tlibattr;
1816 TYPEATTR *typeattr;
1817 TYPEKIND typekind;
1818 MSFT_GuidEntry guid, *check_guid;
1819 MSFT_ImpInfo impinfo;
1820 int guid_offset, import_offset;
1821 HRESULT hres;
1822
1823 /* Allocate container GUID */
1824 hres = ITypeLib_GetLibAttr(container, &tlibattr);
1825 if(FAILED(hres)) {
1826 ITypeLib_Release(container);
1827 return hres;
1828 }
1829
1830 guid.guid = tlibattr->guid;
1831 guid.hreftype = This->typelib->typelib_segdir[MSFT_SEG_IMPORTFILES].length+2;
1832 guid.next_hash = -1;
1833
1834 guid_offset = ctl2_alloc_guid(This->typelib, &guid);
1835 if(guid_offset == -1) {
1836 ITypeLib_ReleaseTLibAttr(container, tlibattr);
1837 ITypeLib_Release(container);
1838 return E_OUTOFMEMORY;
1839 }
1840
1841 check_guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][guid_offset];
1842 if(check_guid->hreftype == guid.hreftype)
1843 This->typelib->typelib_guids++;
1844
1845 /* Get import file name */
1846 hres = QueryPathOfRegTypeLib(&guid.guid, tlibattr->wMajorVerNum,
1847 tlibattr->wMinorVerNum, tlibattr->lcid, &name);
1848 if(FAILED(hres)) {
1849 ITypeLib_ReleaseTLibAttr(container, tlibattr);
1850 ITypeLib_Release(container);
1851 return hres;
1852 }
1853
1854 /* Import file */
1855 import_offset = ctl2_alloc_importfile(This->typelib, guid_offset, tlibattr->lcid,
1856 tlibattr->wMajorVerNum, tlibattr->wMinorVerNum, strrchrW(name, '\\')+1);
1857 ITypeLib_ReleaseTLibAttr(container, tlibattr);
1858 SysFreeString(name);
1859
1860 if(import_offset == -1) {
1861 ITypeLib_Release(container);
1862 return E_OUTOFMEMORY;
1863 }
1864
1865 /* Allocate referenced guid */
1866 hres = ITypeInfo_GetTypeAttr(pTInfo, &typeattr);
1867 if(FAILED(hres)) {
1868 ITypeLib_Release(container);
1869 return hres;
1870 }
1871
1872 guid.guid = typeattr->guid;
1873 guid.hreftype = This->typelib->typeinfo_guids*12+1;
1874 guid.next_hash = -1;
1875 typekind = typeattr->typekind;
1876 ITypeInfo_ReleaseTypeAttr(pTInfo, typeattr);
1877
1878 guid_offset = ctl2_alloc_guid(This->typelib, &guid);
1879 if(guid_offset == -1) {
1880 ITypeLib_Release(container);
1881 return E_OUTOFMEMORY;
1882 }
1883
1884 check_guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][guid_offset];
1885 if(check_guid->hreftype == guid.hreftype)
1886 This->typelib->typeinfo_guids++;
1887
1888 /* Allocate importinfo */
1889 impinfo.flags = (typekind<<24) | MSFT_IMPINFO_OFFSET_IS_GUID;
1890 impinfo.oImpFile = import_offset;
1891 impinfo.oGuid = guid_offset;
1892 *phRefType = ctl2_alloc_importinfo(This->typelib, &impinfo)+1;
1893
1894 if(IsEqualGUID(&guid.guid, &IID_IDispatch))
1895 This->typelib->typelib_header.dispatchpos = *phRefType;
1896 }
1897
1898 ITypeLib_Release(container);
1899 return S_OK;
1900 }
1901
1902 /******************************************************************************
1903 * ICreateTypeInfo2_AddFuncDesc {OLEAUT32}
1904 */
1905 static HRESULT WINAPI ICreateTypeInfo2_fnAddFuncDesc(
1906 ICreateTypeInfo2* iface,
1907 UINT index,
1908 FUNCDESC* pFuncDesc)
1909 {
1910 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
1911
1912 CyclicList *iter, *insert;
1913 MSFT_FuncRecord *typedata;
1914 int i, num_defaults = 0, num_retval = 0;
1915 int decoded_size;
1916 HRESULT hres;
1917
1918 TRACE("(%p,%d,%p)\n", iface, index, pFuncDesc);
1919
1920 if(!pFuncDesc || pFuncDesc->oVft&3)
1921 return E_INVALIDARG;
1922
1923 TRACE("{%d,%p,%p,%d,%d,%d,%d,%d,%d,%d,{%d},%d}\n", pFuncDesc->memid,
1924 pFuncDesc->lprgscode, pFuncDesc->lprgelemdescParam, pFuncDesc->funckind,
1925 pFuncDesc->invkind, pFuncDesc->callconv, pFuncDesc->cParams,
1926 pFuncDesc->cParamsOpt, pFuncDesc->oVft, pFuncDesc->cScodes,
1927 pFuncDesc->elemdescFunc.tdesc.vt, pFuncDesc->wFuncFlags);
1928
1929 if(pFuncDesc->cParamsOpt || pFuncDesc->cScodes)
1930 FIXME("Unimplemented parameter - created typelib will be incorrect\n");
1931
1932 switch(This->typekind) {
1933 case TKIND_MODULE:
1934 if(pFuncDesc->funckind != FUNC_STATIC)
1935 return TYPE_E_BADMODULEKIND;
1936 break;
1937 case TKIND_DISPATCH:
1938 if(pFuncDesc->funckind != FUNC_DISPATCH)
1939 return TYPE_E_BADMODULEKIND;
1940 break;
1941 default:
1942 if(pFuncDesc->funckind != FUNC_PUREVIRTUAL)
1943 return TYPE_E_BADMODULEKIND;
1944 }
1945
1946 if(cti2_get_func_count(This->typeinfo) < index)
1947 return TYPE_E_ELEMENTNOTFOUND;
1948
1949 if((pFuncDesc->invkind&(INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF)) &&
1950 !pFuncDesc->cParams)
1951 return TYPE_E_INCONSISTENTPROPFUNCS;
1952
1953 /* get number of arguments with default values specified */
1954 for (i = 0; i < pFuncDesc->cParams; i++) {
1955 if(pFuncDesc->lprgelemdescParam[i].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
1956 num_defaults++;
1957 if(pFuncDesc->lprgelemdescParam[i].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL)
1958 num_retval++;
1959 }
1960
1961 if (!This->typedata) {
1962 This->typedata = alloc_cyclic_list_item(CyclicListSentinel);
1963 if(!This->typedata)
1964 return E_OUTOFMEMORY;
1965
1966 This->typedata->next = This->typedata;
1967
1968 if(This->dual)
1969 This->dual->typedata = This->typedata;
1970 }
1971
1972 /* allocate type data space for us */
1973 insert = alloc_cyclic_list_item(CyclicListFunc);
1974 if(!insert)
1975 return E_OUTOFMEMORY;
1976 insert->u.func = heap_alloc(sizeof(MSFT_FuncRecord) + sizeof(int)*(num_defaults?4:3)*pFuncDesc->cParams);
1977 if(!insert->u.func) {
1978 heap_free(insert);
1979 return E_OUTOFMEMORY;
1980 }
1981
1982 /* fill out the basic type information */
1983 typedata = insert->u.func;
1984 memset(typedata, 0xff, sizeof(MSFT_FuncRecord));
1985 typedata->HelpContext = 0;
1986 typedata->HelpStringContext = 0;
1987
1988 typedata->Info = FIELD_OFFSET(MSFT_FuncRecord, HelpContext) + pFuncDesc->cParams*(num_defaults?16:12);
1989 ctl2_encode_typedesc(This->typelib, &pFuncDesc->elemdescFunc.tdesc, &typedata->DataType, NULL, NULL, &decoded_size);
1990 typedata->Flags = pFuncDesc->wFuncFlags;
1991 typedata->VtableOffset = pFuncDesc->oVft ? pFuncDesc->oVft+1 : 0;
1992 typedata->funcdescsize = sizeof(FUNCDESC) + decoded_size;
1993 typedata->FKCCIC = (pFuncDesc->callconv << 8) | (pFuncDesc->invkind << 3) | pFuncDesc->funckind;
1994 if(num_defaults) typedata->FKCCIC |= 0x1000;
1995 if (num_retval) typedata->FKCCIC |= 0x4000;
1996 typedata->nrargs = pFuncDesc->cParams;
1997 typedata->nroargs = 0;
1998
1999 /* NOTE: typedata->funcdescsize is total size of FUNCDESC + size of all ELEMDESCs for params + TYPEDESCs for pointer params and return types. */
2000 /* That is, total memory allocation required to reconstitute the FUNCDESC in its entirety. */
2001 typedata->funcdescsize += sizeof(ELEMDESC) * pFuncDesc->cParams;
2002 typedata->funcdescsize += sizeof(PARAMDESCEX) * num_defaults;
2003
2004 /* add default values */
2005 if(num_defaults) {
2006 for (i = 0; i < pFuncDesc->cParams; i++)
2007 if(pFuncDesc->lprgelemdescParam[i].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT) {
2008 hres = ctl2_encode_variant(This->typelib, &typedata->oArgCustData[i],
2009 &pFuncDesc->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue,
2010 pFuncDesc->lprgelemdescParam[i].tdesc.vt);
2011
2012 if(FAILED(hres)) {
2013 heap_free(insert->u.func);
2014 heap_free(insert);
2015 return hres;
2016 }
2017 } else
2018 typedata->oArgCustData[i] = -1;
2019
2020 num_defaults = pFuncDesc->cParams;
2021 }
2022
2023 /* add arguments */
2024 for (i = 0; i < pFuncDesc->cParams; i++) {
2025 ctl2_encode_typedesc(This->typelib, &pFuncDesc->lprgelemdescParam[i].tdesc,
2026 &typedata->oArgCustData[num_defaults+(i*3)], NULL, NULL, &decoded_size);
2027 typedata->oArgCustData[num_defaults+(i*3)+1] = -1;
2028 typedata->oArgCustData[num_defaults+(i*3)+2] = pFuncDesc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
2029 typedata->funcdescsize += decoded_size;
2030 }
2031
2032 /* update the index data */
2033 insert->indice = pFuncDesc->memid;
2034 insert->name = -1;
2035
2036 /* insert type data to list */
2037 if(index == cti2_get_func_count(This->typeinfo)) {
2038 insert->next = This->typedata->next;
2039 This->typedata->next = insert;
2040 This->typedata = insert;
2041
2042 if(This->dual)
2043 This->dual->typedata = This->typedata;
2044 } else {
2045 unsigned int j;
2046
2047 iter = This->typedata->next;
2048 for (j = 0; j < index; j++)
2049 iter = iter->next;
2050
2051 insert->next = iter->next;
2052 iter->next = insert;
2053 }
2054
2055 /* update type data size */
2056 This->typedata->next->u.val += typedata->Info;
2057
2058 /* Increment the number of function elements */
2059 This->typeinfo->cElement += 1;
2060
2061 return S_OK;
2062 }
2063
2064 /******************************************************************************
2065 * ICreateTypeInfo2_AddImplType {OLEAUT32}
2066 */
2067 static HRESULT WINAPI ICreateTypeInfo2_fnAddImplType(
2068 ICreateTypeInfo2* iface,
2069 UINT index,
2070 HREFTYPE hRefType)
2071 {
2072 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
2073
2074 TRACE("(%p,%d,%d)\n", iface, index, hRefType);
2075
2076 if (This->typekind == TKIND_COCLASS) {
2077 int offset;
2078 MSFT_RefRecord *ref;
2079
2080 if (index == 0) {
2081 if (This->typeinfo->datatype1 != -1) return TYPE_E_ELEMENTNOTFOUND;
2082
2083 offset = ctl2_alloc_segment(This->typelib, MSFT_SEG_REFERENCES, sizeof(MSFT_RefRecord), 0);
2084 if (offset == -1) return E_OUTOFMEMORY;
2085
2086 This->typeinfo->datatype1 = offset;
2087 } else {
2088 int lastoffset;
2089
2090 lastoffset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index - 1);
2091 if (lastoffset == -1) return TYPE_E_ELEMENTNOTFOUND;
2092
2093 ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][lastoffset];
2094 if (ref->onext != -1) return TYPE_E_ELEMENTNOTFOUND;
2095
2096 offset = ctl2_alloc_segment(This->typelib, MSFT_SEG_REFERENCES, sizeof(MSFT_RefRecord), 0);
2097 if (offset == -1) return E_OUTOFMEMORY;
2098
2099 ref->onext = offset;
2100 }
2101
2102 ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
2103
2104 ref->reftype = hRefType;
2105 ref->flags = 0;
2106 ref->oCustData = -1;
2107 ref->onext = -1;
2108 This->typeinfo->cImplTypes++;
2109 } else if (This->typekind == TKIND_INTERFACE) {
2110 if (This->typeinfo->cImplTypes && index==1)
2111 return TYPE_E_BADMODULEKIND;
2112
2113 if( index != 0) return TYPE_E_ELEMENTNOTFOUND;
2114
2115 This->typeinfo->datatype1 = hRefType;
2116 This->typeinfo->cImplTypes = 1;
2117 } else if (This->typekind == TKIND_DISPATCH) {
2118 if(index != 0) return TYPE_E_ELEMENTNOTFOUND;
2119
2120 /* FIXME: Check if referenced typeinfo is IDispatch */
2121 This->typeinfo->flags |= TYPEFLAG_FDISPATCHABLE;
2122 This->typeinfo->cImplTypes = 1;
2123 } else {
2124 FIXME("AddImplType unsupported on typekind %d\n", This->typekind);
2125 return E_OUTOFMEMORY;
2126 }
2127
2128 return S_OK;
2129 }
2130
2131 /******************************************************************************
2132 * ICreateTypeInfo2_SetImplTypeFlags {OLEAUT32}
2133 */
2134 static HRESULT WINAPI ICreateTypeInfo2_fnSetImplTypeFlags(
2135 ICreateTypeInfo2* iface,
2136 UINT index,
2137 INT implTypeFlags)
2138 {
2139 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
2140 int offset;
2141 MSFT_RefRecord *ref;
2142
2143 TRACE("(%p,%d,0x%x)\n", iface, index, implTypeFlags);
2144
2145 if (This->typekind != TKIND_COCLASS) {
2146 return TYPE_E_BADMODULEKIND;
2147 }
2148
2149 offset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index);
2150 if (offset == -1) return TYPE_E_ELEMENTNOTFOUND;
2151
2152 ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
2153 ref->flags = implTypeFlags;
2154
2155 return S_OK;
2156 }
2157
2158 /******************************************************************************
2159 * ICreateTypeInfo2_SetAlignment {OLEAUT32}
2160 */
2161 static HRESULT WINAPI ICreateTypeInfo2_fnSetAlignment(
2162 ICreateTypeInfo2* iface,
2163 WORD cbAlignment)
2164 {
2165 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
2166
2167 TRACE("(%p,%d)\n", iface, cbAlignment);
2168
2169 if (!cbAlignment) return E_INVALIDARG;
2170 if (cbAlignment > 16) return E_INVALIDARG;
2171
2172 This->typeinfo->typekind &= ~0xffc0;
2173 This->typeinfo->typekind |= cbAlignment << 6;
2174
2175 /* FIXME: There's probably some way to simplify this. */
2176 switch (This->typekind) {
2177 case TKIND_ALIAS:
2178 default:
2179 break;
2180
2181 case TKIND_ENUM:
2182 case TKIND_INTERFACE:
2183 case TKIND_DISPATCH:
2184 case TKIND_COCLASS:
2185 if (cbAlignment > 4) cbAlignment = 4;
2186 break;
2187
2188 case TKIND_RECORD:
2189 case TKIND_MODULE:
2190 case TKIND_UNION:
2191 cbAlignment = 1;
2192 break;
2193 }
2194
2195 This->typeinfo->typekind |= cbAlignment << 11;
2196
2197 return S_OK;
2198 }
2199
2200 /******************************************************************************
2201 * ICreateTypeInfo2_SetSchema {OLEAUT32}
2202 */
2203 static HRESULT WINAPI ICreateTypeInfo2_fnSetSchema(
2204 ICreateTypeInfo2* iface,
2205 LPOLESTR pStrSchema)
2206 {
2207 FIXME("(%p,%s), stub!\n", iface, debugstr_w(pStrSchema));
2208 return E_OUTOFMEMORY;
2209 }
2210
2211 /******************************************************************************
2212 * ICreateTypeInfo2_AddVarDesc {OLEAUT32}
2213 */
2214 static HRESULT WINAPI ICreateTypeInfo2_fnAddVarDesc(
2215 ICreateTypeInfo2* iface,
2216 UINT index,
2217 VARDESC* pVarDesc)
2218 {
2219 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
2220
2221 HRESULT status = S_OK;
2222 CyclicList *insert;
2223 MSFT_VarRecord *typedata;
2224 int var_datawidth;
2225 int var_alignment;
2226 int var_type_size;
2227 int alignment;
2228
2229 TRACE("(%p,%d,%p)\n", iface, index, pVarDesc);
2230 TRACE("%d, %p, %d, {{%x, %d}, {%p, %x}}, 0x%x, %d\n", pVarDesc->memid, pVarDesc->lpstrSchema, pVarDesc->u.oInst,
2231 pVarDesc->elemdescVar.tdesc.u.hreftype, pVarDesc->elemdescVar.tdesc.vt,
2232 pVarDesc->elemdescVar.u.paramdesc.pparamdescex, pVarDesc->elemdescVar.u.paramdesc.wParamFlags,
2233 pVarDesc->wVarFlags, pVarDesc->varkind);
2234
2235 if (cti2_get_var_count(This->typeinfo) != index)
2236 return TYPE_E_ELEMENTNOTFOUND;
2237
2238 if (!This->typedata) {
2239 This->typedata = alloc_cyclic_list_item(CyclicListSentinel);
2240 if(!This->typedata)
2241 return E_OUTOFMEMORY;
2242
2243 This->typedata->next = This->typedata;
2244
2245 if(This->dual)
2246 This->dual->typedata = This->typedata;
2247 }
2248
2249 insert = alloc_cyclic_list_item(CyclicListVar);
2250 if(!insert)
2251 return E_OUTOFMEMORY;
2252
2253 /* allocate whole structure, it's fixed size always */
2254 insert->u.var = heap_alloc(sizeof(MSFT_VarRecord));
2255 if(!insert->u.var) {
2256 heap_free(insert);
2257 return E_OUTOFMEMORY;
2258 }
2259
2260 insert->next = This->typedata->next;
2261 This->typedata->next = insert;
2262 This->typedata = insert;
2263
2264 if(This->dual)
2265 This->dual->typedata = This->typedata;
2266
2267 This->typedata->next->u.val += FIELD_OFFSET(MSFT_VarRecord, HelpContext);
2268 typedata = This->typedata->u.var;
2269
2270 /* fill out the basic type information */
2271 memset(typedata, 0xff, sizeof(MSFT_VarRecord));
2272 typedata->HelpContext = 0;
2273 typedata->HelpStringContext = 0;
2274
2275 /* no optional fields initially */
2276 typedata->Info = FIELD_OFFSET(MSFT_VarRecord, HelpContext) | (index << 16);
2277 typedata->Flags = pVarDesc->wVarFlags;
2278 typedata->VarKind = pVarDesc->varkind;
2279 typedata->vardescsize = sizeof(VARDESC);
2280
2281 /* update the index data */
2282 insert->indice = 0x40000000 + index;
2283 insert->name = -1;
2284
2285 /* figure out type widths and whatnot */
2286 ctl2_encode_typedesc(This->typelib, &pVarDesc->elemdescVar.tdesc,
2287 &typedata->DataType, &var_datawidth, &var_alignment,
2288 &var_type_size);
2289
2290 if (pVarDesc->varkind != VAR_CONST)
2291 {
2292 /* pad out starting position to data width */
2293 This->datawidth += var_alignment - 1;
2294 This->datawidth &= ~(var_alignment - 1);
2295 typedata->OffsValue = This->datawidth;
2296
2297 /* add the new variable to the total data width */
2298 This->datawidth += var_datawidth;
2299 if(This->dual)
2300 This->dual->datawidth = This->datawidth;
2301
2302 /* add type description size to total required allocation */
2303 typedata->vardescsize += var_type_size;
2304
2305 /* fix type alignment */
2306 alignment = (This->typeinfo->typekind >> 11) & 0x1f;
2307 if (alignment < var_alignment) {
2308 alignment = var_alignment;
2309 This->typeinfo->typekind &= ~0xf800;
2310 This->typeinfo->typekind |= alignment << 11;
2311 }
2312
2313 /* ??? */
2314 if (!This->typeinfo->res2) This->typeinfo->res2 = 0x1a;
2315 if ((index == 0) || (index == 1) || (index == 2) || (index == 4) || (index == 9)) {
2316 This->typeinfo->res2 <<= 1;
2317 }
2318
2319 /* ??? */
2320 if (This->typeinfo->res3 == -1) This->typeinfo->res3 = 0;
2321 This->typeinfo->res3 += 0x2c;
2322
2323 /* pad data width to alignment */
2324 This->typeinfo->size = (This->datawidth + (alignment - 1)) & ~(alignment - 1);
2325 } else {
2326 VARIANT *value = pVarDesc->DUMMYUNIONNAME.lpvarValue;
2327 status = ctl2_encode_variant(This->typelib, &typedata->OffsValue, value, V_VT(value));
2328 /* ??? native sets size 0x34 */
2329 typedata->vardescsize += 0x10;
2330 }
2331
2332 /* increment the number of variable elements */
2333 This->typeinfo->cElement += 0x10000;
2334
2335 return status;
2336 }
2337
2338 /******************************************************************************
2339 * ICreateTypeInfo2_SetFuncAndParamNames {OLEAUT32}
2340 */
2341 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncAndParamNames(
2342 ICreateTypeInfo2* iface,
2343 UINT index,
2344 LPOLESTR* names,
2345 UINT cNames)
2346 {
2347 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
2348 CyclicList *iter, *iter2;
2349 int offset, len, i;
2350 unsigned char *namedata;
2351
2352 TRACE("(%p %d %p %d)\n", This, index, names, cNames);
2353
2354 if(!names)
2355 return E_INVALIDARG;
2356
2357 if(index >= cti2_get_func_count(This->typeinfo) || cNames == 0)
2358 return TYPE_E_ELEMENTNOTFOUND;
2359
2360 for(iter=This->typedata->next->next, i=0; /* empty */; iter=iter->next)
2361 if (iter->type == CyclicListFunc)
2362 if (i++ >= index)
2363 break;
2364
2365 /* cNames == cParams for put or putref accessor, cParams+1 otherwise */
2366 if(cNames != iter->u.func->nrargs + (ctl2_get_invokekind(iter->u.func) & (INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF) ? 0 : 1))
2367 return TYPE_E_ELEMENTNOTFOUND;
2368
2369 TRACE("function name %s\n", debugstr_w(names[0]));
2370 len = ctl2_encode_name(This->typelib, names[0], (char**)&namedata);
2371 for(iter2=This->typedata->next->next; iter2!=This->typedata->next; iter2=iter2->next) {
2372
2373 int cmp = memcmp(namedata, This->typelib->typelib_segment_data[MSFT_SEG_NAME]+iter2->name+8, len);
2374 if (iter2->name != -1 && cmp == 0) {
2375 if (iter2->type == CyclicListFunc) {
2376 INVOKEKIND inv1 = ctl2_get_invokekind(iter->u.func);
2377 INVOKEKIND inv2 = ctl2_get_invokekind(iter2->u.func);
2378
2379 /* it's allowed to have PUT, PUTREF and GET methods with the same name */
2380 if ((inv1 != inv2) &&
2381 (inv1 & (INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF|INVOKE_PROPERTYGET)) &&
2382 (inv2 & (INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF|INVOKE_PROPERTYGET)))
2383 continue;
2384 }
2385
2386 return TYPE_E_AMBIGUOUSNAME;
2387 }
2388 }
2389
2390 offset = ctl2_alloc_name(This->typelib, names[0]);
2391 if(offset == -1)
2392 return E_OUTOFMEMORY;
2393
2394 iter->name = offset;
2395
2396 namedata = This->typelib->typelib_segment_data[MSFT_SEG_NAME] + offset;
2397 if (*((INT*)namedata) == -1)
2398 *((INT *)namedata) = This->typelib->typelib_typeinfo_offsets[This->typeinfo->typekind >> 16];
2399
2400 if(iter->u.func->FKCCIC & 0x1000)
2401 len = iter->u.func->nrargs;
2402 else
2403 len = 0;
2404
2405 for (i = 1; i < cNames; i++) {
2406 offset = ctl2_alloc_name(This->typelib, names[i]);
2407 iter->u.func->oArgCustData[len+(i-1)*3+1] = offset;
2408 }
2409
2410 return S_OK;
2411 }
2412
2413 /******************************************************************************
2414 * ICreateTypeInfo2_SetVarName {OLEAUT32}
2415 */
2416 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarName(
2417 ICreateTypeInfo2* iface,
2418 UINT index,
2419 LPOLESTR szName)
2420 {
2421 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
2422 CyclicList *iter;
2423 int offset, i;
2424 unsigned char *namedata;
2425
2426 TRACE("(%p,%d,%s)\n", This, index, debugstr_w(szName));
2427
2428 if (cti2_get_var_count(This->typeinfo) <= index)
2429 return TYPE_E_ELEMENTNOTFOUND;
2430
2431 offset = ctl2_alloc_name(This->typelib, szName);
2432 if (offset == -1) return E_OUTOFMEMORY;
2433
2434 namedata = This->typelib->typelib_segment_data[MSFT_SEG_NAME] + offset;
2435 if (*((INT *)namedata) == -1) {
2436 *((INT *)namedata) = This->typelib->typelib_typeinfo_offsets[This->typeinfo->typekind >> 16];
2437 namedata[9] |= 0x10;
2438 }
2439 if (This->typekind == TKIND_ENUM) {
2440 namedata[9] |= 0x20;
2441 }
2442
2443 for(iter = This->typedata->next->next, i = 0; /* empty */; iter = iter->next)
2444 if (iter->type == CyclicListVar)
2445 if (i++ >= index)
2446 break;
2447
2448 iter->name = offset;
2449 return S_OK;
2450 }
2451
2452 /******************************************************************************
2453 * ICreateTypeInfo2_SetTypeDescAlias {OLEAUT32}
2454 */
2455 static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeDescAlias(
2456 ICreateTypeInfo2* iface,
2457 TYPEDESC* pTDescAlias)
2458 {
2459 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
2460
2461 int encoded_typedesc;
2462 int width;
2463
2464 if (This->typekind != TKIND_ALIAS) {
2465 return TYPE_E_WRONGTYPEKIND;
2466 }
2467
2468 FIXME("(%p,%p), hack!\n", iface, pTDescAlias);
2469
2470 if (ctl2_encode_typedesc(This->typelib, pTDescAlias, &encoded_typedesc, &width, NULL, NULL) == -1) {
2471 return E_OUTOFMEMORY;
2472 }
2473
2474 This->typeinfo->size = width;
2475 This->typeinfo->datatype1 = encoded_typedesc;
2476
2477 return S_OK;
2478 }
2479
2480 /******************************************************************************
2481 * ICreateTypeInfo2_DefineFuncAsDllEntry {OLEAUT32}
2482 */
2483 static HRESULT WINAPI ICreateTypeInfo2_fnDefineFuncAsDllEntry(
2484 ICreateTypeInfo2* iface,
2485 UINT index,
2486 LPOLESTR szDllName,
2487 LPOLESTR szProcName)
2488 {
2489 FIXME("(%p,%d,%s,%s), stub!\n", iface, index, debugstr_w(szDllName), debugstr_w(szProcName));
2490 return E_OUTOFMEMORY;
2491 }
2492
2493 /******************************************************************************
2494 * ICreateTypeInfo2_SetFuncDocString {OLEAUT32}
2495 */
2496 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncDocString(
2497 ICreateTypeInfo2* iface,
2498 UINT index,
2499 LPOLESTR szDocString)
2500 {
2501 FIXME("(%p,%d,%s), stub!\n", iface, index, debugstr_w(szDocString));
2502 return E_OUTOFMEMORY;
2503 }
2504
2505 /******************************************************************************
2506 * ICreateTypeInfo2_SetVarDocString {OLEAUT32}
2507 */
2508 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarDocString(
2509 ICreateTypeInfo2* iface,
2510 UINT index,
2511 LPOLESTR docstring)
2512 {
2513 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
2514 CyclicList *iter;
2515
2516 TRACE("(%p,%d,%s)\n", This, index, debugstr_w(docstring));
2517
2518 if (!docstring) return E_INVALIDARG;
2519
2520 if (cti2_get_var_count(This->typeinfo) <= index)
2521 return TYPE_E_ELEMENTNOTFOUND;
2522
2523 for (iter = This->typedata->next->next; iter != This->typedata->next; iter = iter->next)
2524 if (iter->type == CyclicListVar)
2525 {
2526 if (index-- == 0)
2527 {
2528 int offset = ctl2_alloc_string(This->typelib, docstring);
2529
2530 if (offset == -1) return E_OUTOFMEMORY;
2531 iter->u.var->HelpString = offset;
2532 ctl2_update_var_size(This, iter->u.var);
2533 return S_OK;
2534 }
2535 }
2536
2537 return TYPE_E_ELEMENTNOTFOUND;
2538 }
2539
2540 /******************************************************************************
2541 * ICreateTypeInfo2_SetFuncHelpContext {OLEAUT32}
2542 */
2543 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncHelpContext(
2544 ICreateTypeInfo2* iface,
2545 UINT index,
2546 DWORD dwHelpContext)
2547 {
2548 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
2549 CyclicList *func;
2550
2551 TRACE("(%p,%d,%d)\n", iface, index, dwHelpContext);
2552
2553 if(cti2_get_func_count(This->typeinfo) < index)
2554 return TYPE_E_ELEMENTNOTFOUND;
2555
2556 if(cti2_get_func_count(This->typeinfo) == index && This->typedata->type == CyclicListFunc)
2557 func = This->typedata;
2558 else
2559 for(func=This->typedata->next->next; func!=This->typedata; func=func->next)
2560 if (func->type == CyclicListFunc)
2561 if(index-- == 0)
2562 break;
2563
2564 func->u.func->HelpContext = dwHelpContext;
2565 ctl2_update_func_size(This, func->u.func);
2566 return S_OK;
2567 }
2568
2569 /******************************************************************************
2570 * ICreateTypeInfo2_SetVarHelpContext {OLEAUT32}
2571 */
2572 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarHelpContext(
2573 ICreateTypeInfo2* iface,
2574 UINT index,
2575 DWORD context)
2576 {
2577 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
2578 CyclicList *iter;
2579
2580 TRACE("(%p,%d,%d)\n", This, index, context);
2581
2582 if (cti2_get_var_count(This->typeinfo) <= index)
2583 return TYPE_E_ELEMENTNOTFOUND;
2584
2585 for (iter = This->typedata->next->next; iter != This->typedata->next; iter = iter->next)
2586 if (iter->type == CyclicListVar)
2587 {
2588 if (index-- == 0)
2589 {
2590 iter->u.var->HelpContext = context;
2591 ctl2_update_var_size(This, iter->u.var);
2592 return S_OK;
2593 }
2594 }
2595
2596 return TYPE_E_ELEMENTNOTFOUND;
2597 }
2598
2599 /******************************************************************************
2600 * ICreateTypeInfo2_SetMops {OLEAUT32}
2601 */
2602 static HRESULT WINAPI ICreateTypeInfo2_fnSetMops(
2603 ICreateTypeInfo2* iface,
2604 UINT index,
2605 BSTR bstrMops)
2606 {
2607 FIXME("(%p,%d,%p), stub!\n", iface, index, bstrMops);
2608 return E_OUTOFMEMORY;
2609 }
2610
2611 /******************************************************************************
2612 * ICreateTypeInfo2_SetTypeIdldesc {OLEAUT32}
2613 */
2614 static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeIdldesc(
2615 ICreateTypeInfo2* iface,
2616 IDLDESC* pIdlDesc)
2617 {
2618 FIXME("(%p,%p), stub!\n", iface, pIdlDesc);
2619 return E_OUTOFMEMORY;
2620 }
2621
2622 /******************************************************************************
2623 * ICreateTypeInfo2_LayOut {OLEAUT32}
2624 */
2625 static HRESULT WINAPI ICreateTypeInfo2_fnLayOut(
2626 ICreateTypeInfo2* iface)
2627 {
2628 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
2629 CyclicList *iter, *iter2, *last = NULL, **typedata;
2630 HREFTYPE hreftype;
2631 HRESULT hres;
2632 unsigned user_vft = 0;
2633 int i;
2634
2635 TRACE("(%p)\n", This);
2636
2637 /* FIXME: LayOut should be run on all ImplTypes */
2638 if(This->typekind == TKIND_COCLASS || This->typekind == TKIND_ALIAS)
2639 return S_OK;
2640
2641 /* Validate inheritance */
2642 This->typeinfo->datatype2 = 0;
2643 hreftype = This->typeinfo->datatype1;
2644
2645 /* Process internally defined interfaces */
2646 for(i=0; i<This->typelib->typelib_header.nrtypeinfos; i++) {
2647 MSFT_TypeInfoBase *header;
2648
2649 if(hreftype&1)
2650 break;
2651
2652 header = (MSFT_TypeInfoBase*)&(This->typelib->typelib_segment_data[MSFT_SEG_TYPEINFO][hreftype]);
2653 This->typeinfo->datatype2 += (header->cElement<<16) + 1;
2654 hreftype = header->datatype1;
2655 }
2656 if(i == This->typelib->typelib_header.nrtypeinfos)
2657 return TYPE_E_CIRCULARTYPE;
2658
2659 /* Process externally defined interfaces */
2660 if(hreftype != -1) {
2661 ITypeInfo *cur, *next;
2662 TYPEATTR *typeattr;
2663
2664 hres = ICreateTypeInfo2_QueryInterface(iface, &IID_ITypeInfo, (void**)&next);
2665 if(FAILED(hres))
2666 return hres;
2667
2668 hres = ITypeInfo_GetRefTypeInfo(next, hreftype, &cur);
2669 ITypeInfo_Release(next);
2670 if(FAILED(hres))
2671 return hres;
2672
2673
2674 while(1) {
2675 hres = ITypeInfo_GetTypeAttr(cur, &typeattr);
2676 if(FAILED(hres)) {
2677 ITypeInfo_Release(cur);
2678 return hres;
2679 }
2680
2681 if(IsEqualGUID(&typeattr->guid, &IID_IDispatch))
2682 This->typeinfo->flags |= TYPEFLAG_FDISPATCHABLE;
2683
2684 This->typeinfo->datatype2 += (typeattr->cFuncs<<16) + 1;
2685 ITypeInfo_ReleaseTypeAttr(cur, typeattr);
2686
2687 hres = ITypeInfo_GetRefTypeOfImplType(cur, 0, &hreftype);
2688 if(hres == TYPE_E_ELEMENTNOTFOUND)
2689 break;
2690 if(FAILED(hres)) {
2691 ITypeInfo_Release(cur);
2692 return hres;
2693 }
2694
2695 hres = ITypeInfo_GetRefTypeInfo(cur, hreftype, &next);
2696 if(FAILED(hres)) {
2697 ITypeInfo_Release(cur);
2698 return hres;
2699 }
2700
2701 ITypeInfo_Release(cur);
2702 cur = next;
2703 }
2704 ITypeInfo_Release(cur);
2705 }
2706
2707 /* Get cbSizeVft of inherited interface */
2708 /* Makes LayOut running recursively */
2709 if(This->typeinfo->datatype1 != -1) {
2710 ITypeInfo *cur, *inherited;
2711 TYPEATTR *typeattr;
2712
2713 hres = ICreateTypeInfo2_QueryInterface(iface, &IID_ITypeInfo, (void**)&cur);
2714 if(FAILED(hres))
2715 return hres;
2716
2717 hres = ITypeInfo_GetRefTypeInfo(cur, This->typeinfo->datatype1, &inherited);
2718 ITypeInfo_Release(cur);
2719 if(FAILED(hres))
2720 return hres;
2721
2722 hres = ITypeInfo_GetTypeAttr(inherited, &typeattr);
2723 if(FAILED(hres)) {
2724 ITypeInfo_Release(inherited);
2725 return hres;
2726 }
2727
2728 This->typeinfo->cbSizeVft = typeattr->cbSizeVft * 4 / sizeof(void *);
2729
2730 ITypeInfo_ReleaseTypeAttr(inherited, typeattr);
2731 ITypeInfo_Release(inherited);
2732 } else
2733 This->typeinfo->cbSizeVft = 0;
2734
2735 if(!This->typedata)
2736 return S_OK;
2737
2738 typedata = heap_alloc(sizeof(CyclicList*)*cti2_get_func_count(This->typeinfo));
2739 if(!typedata)
2740 return E_OUTOFMEMORY;
2741
2742 /* Assign IDs and VTBL entries */
2743 for(iter=This->typedata->next->next; iter!=This->typedata->next; iter=iter->next)
2744 if (iter->type == CyclicListFunc)
2745 last = iter;
2746
2747 if(last && last->u.func->VtableOffset & 1)
2748 user_vft = last->u.func->VtableOffset;
2749
2750 i = 0;
2751 for(iter=This->typedata->next->next; iter!=This->typedata->next; iter=iter->next) {
2752 /* Assign MEMBERID if MEMBERID_NIL was specified */
2753 if(iter->indice == MEMBERID_NIL) {
2754 iter->indice = 0x60000000 + i + (This->typeinfo->datatype2<<16);
2755
2756 for(iter2=This->typedata->next->next; iter2!=This->typedata->next; iter2=iter2->next) {
2757 if(iter == iter2) continue;
2758 if(iter2->indice == iter->indice) {
2759 iter->indice = 0x60000000 + This->typeinfo->cElement + (This->typeinfo->datatype2<<16);
2760
2761 for(iter2=This->typedata->next->next; iter2!=This->typedata->next; iter2=iter2->next) {
2762 if(iter == iter2) continue;
2763 if(iter2->indice == iter->indice) {
2764 ++iter->indice;
2765 iter2 = This->typedata->next;
2766 }
2767 }
2768
2769 break;
2770 }
2771 }
2772 }
2773
2774 if (iter->type != CyclicListFunc)
2775 continue;
2776
2777 typedata[i] = iter;
2778
2779 iter->u.func->Info = (iter->u.func->Info&0xffff) | (i<<16);
2780
2781 if((iter->u.func->VtableOffset&1) != (user_vft&1)) {
2782 heap_free(typedata);
2783 return TYPE_E_INVALIDID;
2784 }
2785
2786 if(user_vft&1) {
2787 if(user_vft < iter->u.func->VtableOffset)
2788 user_vft = iter->u.func->VtableOffset;
2789
2790 if((unsigned short)iter->u.func->VtableOffset < This->typeinfo->cbSizeVft) {
2791 heap_free(typedata);
2792 return TYPE_E_INVALIDID;
2793 }
2794 } else if(This->typekind != TKIND_MODULE) {
2795 iter->u.func->VtableOffset = This->typeinfo->cbSizeVft;
2796 This->typeinfo->cbSizeVft += 4;
2797 }
2798
2799 /* Construct a list of elements with the same memberid */
2800 iter->u.func->FKCCIC = (iter->u.func->FKCCIC&0xffff) | (i<<16);
2801 for(iter2=This->typedata->next->next; iter2!=iter; iter2=iter2->next) {
2802 if(iter->indice == iter2->indice) {
2803 int v1, v2;
2804
2805 v1 = iter->u.func->FKCCIC >> 16;
2806 v2 = iter2->u.func->FKCCIC >> 16;
2807
2808 iter->u.func->FKCCIC = (iter->u.func->FKCCIC&0xffff) | (v2<<16);
2809 iter2->u.func->FKCCIC = (iter2->u.func->FKCCIC&0xffff) | (v1<<16);
2810 break;
2811 }
2812 }
2813
2814 i++;
2815 }
2816
2817 if(user_vft)
2818 This->typeinfo->cbSizeVft = user_vft+3;
2819
2820 for(i=0; i< cti2_get_func_count(This->typeinfo); i++) {
2821 if(typedata[i]->u.func->FKCCIC>>16 > i) {
2822 INVOKEKIND inv = ctl2_get_invokekind(typedata[i]->u.func);
2823
2824 i = typedata[i]->u.func->FKCCIC >> 16;
2825
2826 while(i > typedata[i]->u.func->FKCCIC >>16) {
2827 INVOKEKIND invkind = ctl2_get_invokekind(typedata[i]->u.func);
2828
2829 if(inv & invkind) {
2830 heap_free(typedata);
2831 return TYPE_E_DUPLICATEID;
2832 }
2833
2834 i = typedata[i]->u.func->FKCCIC >> 16;
2835 inv |= invkind;
2836 }
2837
2838 if(inv & INVOKE_FUNC) {
2839 heap_free(typedata);
2840 return TYPE_E_INCONSISTENTPROPFUNCS;
2841 }
2842 }
2843 }
2844
2845 heap_free(typedata);
2846 return S_OK;
2847 }
2848
2849 /******************************************************************************
2850 * ICreateTypeInfo2_DeleteFuncDesc {OLEAUT32}
2851 *
2852 * Delete a function description from a type.
2853 *
2854 * RETURNS
2855 *
2856 * Success: S_OK.
2857 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2858 */
2859 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteFuncDesc(
2860 ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete a function. */
2861 UINT index) /* [I] The index of the function to delete. */
2862 {
2863 FIXME("(%p,%d), stub!\n", iface, index);
2864 return E_OUTOFMEMORY;
2865 }
2866
2867 /******************************************************************************
2868 * ICreateTypeInfo2_DeleteFuncDescByMemId {OLEAUT32}
2869 *
2870 * Delete a function description from a type.
2871 *
2872 * RETURNS
2873 *
2874 * Success: S_OK.
2875 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2876 */
2877 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteFuncDescByMemId(
2878 ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete a function. */
2879 MEMBERID memid, /* [I] The member id of the function to delete. */
2880 INVOKEKIND invKind) /* [I] The invocation type of the function to delete. (?) */
2881 {
2882 FIXME("(%p,%d,%d), stub!\n", iface, memid, invKind);
2883 return E_OUTOFMEMORY;
2884 }
2885
2886 /******************************************************************************
2887 * ICreateTypeInfo2_DeleteVarDesc {OLEAUT32}
2888 *
2889 * Delete a variable description from a type.
2890 *
2891 * RETURNS
2892 *
2893 * Success: S_OK.
2894 * Failure: One of E_OUTOFMEMORY, E_INVALIDARG, TYPE_E_IOERROR,
2895 * TYPE_E_INVDATAREAD, TYPE_E_UNSUPFORMAT or TYPE_E_INVALIDSTATE.
2896 */
2897 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteVarDesc(
2898 ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete the variable description. */
2899 UINT index) /* [I] The index of the variable description to delete. */
2900 {
2901 FIXME("(%p,%d), stub!\n", iface, index);
2902 return E_OUTOFMEMORY;
2903 }
2904
2905 /******************************************************************************
2906 * ICreateTypeInfo2_DeleteVarDescByMemId {OLEAUT32}
2907 *
2908 * Delete a variable description from a type.
2909 *
2910 * RETURNS
2911 *
2912 * Success: S_OK.
2913 * Failure: One of E_OUTOFMEMORY, E_INVALIDARG, TYPE_E_IOERROR,
2914 * TYPE_E_INVDATAREAD, TYPE_E_UNSUPFORMAT or TYPE_E_INVALIDSTATE.
2915 */
2916 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteVarDescByMemId(
2917 ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete the variable description. */
2918 MEMBERID memid) /* [I] The member id of the variable description to delete. */
2919 {
2920 FIXME("(%p,%d), stub!\n", iface, memid);
2921 return E_OUTOFMEMORY;
2922 }
2923
2924 /******************************************************************************
2925 * ICreateTypeInfo2_DeleteImplType {OLEAUT32}
2926 *
2927 * Delete an interface implementation from a type. (?)
2928 *
2929 * RETURNS
2930 *
2931 * Success: S_OK.
2932 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2933 */
2934 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteImplType(
2935 ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete. */
2936 UINT index) /* [I] The index of the interface to delete. */
2937 {
2938 FIXME("(%p,%d), stub!\n", iface, index);
2939 return E_OUTOFMEMORY;
2940 }
2941
2942 /******************************************************************************
2943 * ICreateTypeInfo2_SetCustData {OLEAUT32}
2944 *
2945 * Set the custom data for a type.
2946 *
2947 * RETURNS
2948 *
2949 * Success: S_OK.
2950 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2951 */
2952 static HRESULT WINAPI ICreateTypeInfo2_fnSetCustData(
2953 ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
2954 REFGUID guid, /* [I] The GUID used as a key to retrieve the custom data. */
2955 VARIANT* pVarVal) /* [I] The custom data. */
2956 {
2957 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
2958
2959 TRACE("(%p,%s,%p)!\n", iface, debugstr_guid(guid), pVarVal);
2960
2961 if (!pVarVal)
2962 return E_INVALIDARG;
2963
2964 return ctl2_set_custdata(This->typelib, guid, pVarVal, &This->typeinfo->oCustData);
2965 }
2966
2967 /******************************************************************************
2968 * ICreateTypeInfo2_SetFuncCustData {OLEAUT32}
2969 *
2970 * Set the custom data for a function.
2971 *
2972 * RETURNS
2973 *
2974 * Success: S_OK.
2975 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2976 */
2977 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncCustData(
2978 ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
2979 UINT index, /* [I] The index of the function for which to set the custom data. */
2980 REFGUID guid, /* [I] The GUID used as a key to retrieve the custom data. */
2981 VARIANT* pVarVal) /* [I] The custom data. */
2982 {
2983 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
2984 CyclicList *iter;
2985 HRESULT hres;
2986
2987 TRACE("(%p,%d,%s,%p)\n", iface, index, debugstr_guid(guid), pVarVal);
2988
2989 if(index >= cti2_get_func_count(This->typeinfo))
2990 return TYPE_E_ELEMENTNOTFOUND;
2991
2992 for(iter=This->typedata->next->next; /* empty */; iter=iter->next)
2993 if (iter->type == CyclicListFunc)
2994 if (index-- == 0)
2995 break;
2996
2997 hres = ctl2_set_custdata(This->typelib, guid, pVarVal, &iter->u.func->oCustData);
2998 if(FAILED(hres))
2999 return hres;
3000
3001 ctl2_update_func_size(This, iter->u.func);
3002 iter->u.func->FKCCIC |= 0x80;
3003 return S_OK;
3004 }
3005
3006 /******************************************************************************
3007 * ICreateTypeInfo2_SetParamCustData {OLEAUT32}
3008 *
3009 * Set the custom data for a function parameter.
3010 *
3011 * RETURNS
3012 *
3013 * Success: S_OK.
3014 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3015 */
3016 static HRESULT WINAPI ICreateTypeInfo2_fnSetParamCustData(
3017 ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
3018 UINT indexFunc, /* [I] The index of the function on which the parameter resides. */
3019 UINT indexParam, /* [I] The index of the parameter on which to set the custom data. */
3020 REFGUID guid, /* [I] The GUID used as a key to retrieve the custom data. */
3021 VARIANT* pVarVal) /* [I] The custom data. */
3022 {
3023 FIXME("(%p,%d,%d,%s,%p), stub!\n", iface, indexFunc, indexParam, debugstr_guid(guid), pVarVal);
3024 return E_OUTOFMEMORY;
3025 }
3026
3027 /******************************************************************************
3028 * ICreateTypeInfo2_SetVarCustData {OLEAUT32}
3029 *
3030 * Set the custom data for a variable.
3031 *
3032 * RETURNS
3033 *
3034 * Success: S_OK.
3035 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3036 */
3037 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarCustData(
3038 ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
3039 UINT index, /* [I] The index of the variable on which to set the custom data. */
3040 REFGUID guid, /* [I] The GUID used as a key to retrieve the custom data. */
3041 VARIANT* pVarVal) /* [I] The custom data. */
3042 {
3043 FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
3044 return E_OUTOFMEMORY;
3045 }
3046
3047 /******************************************************************************
3048 * ICreateTypeInfo2_SetImplTypeCustData {OLEAUT32}
3049 *
3050 * Set the custom data for an implemented interface.
3051 *
3052 * RETURNS
3053 *
3054 * Success: S_OK.
3055 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3056 */
3057 static HRESULT WINAPI ICreateTypeInfo2_fnSetImplTypeCustData(
3058 ICreateTypeInfo2* iface, /* [I] The typeinfo on which to set the custom data. */
3059 UINT index, /* [I] The index of the implemented interface on which to set the custom data. */
3060 REFGUID guid, /* [I] The GUID used as a key to retrieve the custom data. */
3061 VARIANT* pVarVal) /* [I] The custom data. */
3062 {
3063 FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
3064 return E_OUTOFMEMORY;
3065 }
3066
3067 /******************************************************************************
3068 * ICreateTypeInfo2_SetHelpStringContext {OLEAUT32}
3069 *
3070 * Set the help string context for the typeinfo.
3071 *
3072 * RETURNS
3073 *
3074 * Success: S_OK.
3075 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3076 */
3077 static HRESULT WINAPI ICreateTypeInfo2_fnSetHelpStringContext(
3078 ICreateTypeInfo2* iface, /* [I] The typeinfo on which to set the help string context. */
3079 ULONG helpcontext) /* [I] The help string context. */
3080 {
3081 ICreateTypeInfo2Impl *This = impl_from_ICreateTypeInfo2(iface);
3082
3083 TRACE("(%p, %d)\n", iface, helpcontext);
3084
3085 This->typelib->typelib_header.helpcontext = helpcontext;
3086
3087 return S_OK;
3088 }
3089
3090 /******************************************************************************
3091 * ICreateTypeInfo2_SetFuncHelpStringContext {OLEAUT32}
3092 *
3093 * Set the help string context for a function.
3094 *
3095 * RETURNS
3096 *
3097 * Success: S_OK.
3098 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3099 */
3100 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncHelpStringContext(
3101 ICreateTypeInfo2* iface, /* [I] The typeinfo on which to set the help string context. */
3102 UINT index, /* [I] The index for the function on which to set the help string context. */
3103 ULONG dwHelpStringContext) /* [I] The help string context. */
3104 {
3105 FIXME("(%p,%d,%d), stub!\n", iface, index, dwHelpStringContext);
3106 return E_OUTOFMEMORY;
3107 }
3108
3109 /******************************************************************************
3110 * ICreateTypeInfo2_SetVarHelpStringContext {OLEAUT32}
3111 *
3112 * Set the help string context for a variable.
3113 *
3114 * RETURNS
3115 *
3116 * Success: S_OK.
3117 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3118 */
3119 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarHelpStringContext(
3120 ICreateTypeInfo2* iface, /* [I] The typeinfo on which to set the help string context. */
3121 UINT index, /* [I] The index of the variable on which to set the help string context. */
3122 ULONG dwHelpStringContext) /* [I] The help string context */
3123 {
3124 FIXME("(%p,%d,%d), stub!\n", iface, index, dwHelpStringContext);
3125 return E_OUTOFMEMORY;
3126 }
3127
3128 /******************************************************************************
3129 * ICreateTypeInfo2_Invalidate {OLEAUT32}
3130 *
3131 * Undocumented function. (!)
3132 */
3133 static HRESULT WINAPI ICreateTypeInfo2_fnInvalidate(
3134 ICreateTypeInfo2* iface)
3135 {
3136 FIXME("(%p), stub!\n", iface);
3137 return E_OUTOFMEMORY;
3138 }
3139
3140 /******************************************************************************
3141 * ICreateTypeInfo2_SetName {OLEAUT32}
3142 *
3143 * Set the name for a typeinfo.
3144 *
3145 * RETURNS
3146 *
3147 * Success: S_OK.
3148 * Failure: One of STG_E_INSUFFICIENTMEMORY, E_OUTOFMEMORY, E_INVALIDARG or TYPE_E_INVALIDSTATE.
3149 */
3150 static HRESULT WINAPI ICreateTypeInfo2_fnSetName(
3151 ICreateTypeInfo2* iface,
3152 LPOLESTR szName)
3153 {
3154 FIXME("(%p,%s), stub!\n", iface, debugstr_w(szName));
3155 return E_OUTOFMEMORY;
3156 }
3157
3158 /*================== ITypeInfo2 Implementation ===================================*/
3159
3160 /******************************************************************************
3161 * ITypeInfo2_QueryInterface {OLEAUT32}
3162 */
3163 static HRESULT WINAPI ITypeInfo2_fnQueryInterface(ITypeInfo2 * iface, REFIID riid, LPVOID * ppv)
3164 {
3165 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3166
3167 return ICreateTypeInfo2_QueryInterface(&This->ICreateTypeInfo2_iface, riid, ppv);
3168 }
3169
3170 /******************************************************************************
3171 * ITypeInfo2_AddRef {OLEAUT32}
3172 */
3173 static ULONG WINAPI ITypeInfo2_fnAddRef(ITypeInfo2 * iface)
3174 {
3175 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3176
3177 return ICreateTypeInfo2_AddRef(&This->ICreateTypeInfo2_iface);
3178 }
3179
3180 /******************************************************************************
3181 * ITypeInfo2_Release {OLEAUT32}
3182 */
3183 static ULONG WINAPI ITypeInfo2_fnRelease(ITypeInfo2 * iface)
3184 {
3185 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3186
3187 return ICreateTypeInfo2_Release(&This->ICreateTypeInfo2_iface);
3188 }
3189
3190 /******************************************************************************
3191 * ITypeInfo2_GetTypeAttr {OLEAUT32}
3192 */
3193 static HRESULT WINAPI ITypeInfo2_fnGetTypeAttr(
3194 ITypeInfo2* iface,
3195 TYPEATTR** ppTypeAttr)
3196 {
3197 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3198 HRESULT hres;
3199
3200 TRACE("(%p,%p)\n", iface, ppTypeAttr);
3201
3202 if(!ppTypeAttr)
3203 return E_INVALIDARG;
3204
3205 hres = ICreateTypeInfo2_LayOut(&This->ICreateTypeInfo2_iface);
3206 if(FAILED(hres))
3207 return hres;
3208
3209 *ppTypeAttr = heap_alloc_zero(sizeof(TYPEATTR));
3210 if(!*ppTypeAttr)
3211 return E_OUTOFMEMORY;
3212
3213 if(This->typeinfo->posguid != -1) {
3214 MSFT_GuidEntry *guid;
3215
3216 guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][This->typeinfo->posguid];
3217 (*ppTypeAttr)->guid = guid->guid;
3218 }
3219
3220 (*ppTypeAttr)->lcid = This->typelib->typelib_header.lcid;
3221 (*ppTypeAttr)->cbSizeInstance = This->typeinfo->size;
3222 (*ppTypeAttr)->typekind = This->typekind;
3223 (*ppTypeAttr)->cFuncs = cti2_get_func_count(This->typeinfo);
3224 if(This->typeinfo->flags&TYPEFLAG_FDUAL && This->typekind==TKIND_DISPATCH)
3225 (*ppTypeAttr)->cFuncs += sizeof(IDispatchVtbl)/sizeof(void*);
3226 (*ppTypeAttr)->cVars = cti2_get_var_count(This->typeinfo);
3227 (*ppTypeAttr)->cImplTypes = This->typeinfo->cImplTypes;
3228 (*ppTypeAttr)->cbSizeVft = This->typekind == TKIND_DISPATCH ? sizeof(IDispatchVtbl) : This->typeinfo->cbSizeVft;
3229 (*ppTypeAttr)->cbAlignment = (This->typeinfo->typekind>>11) & 0x1f;
3230 (*ppTypeAttr)->wTypeFlags = This->typeinfo->flags;
3231 (*ppTypeAttr)->wMajorVerNum = LOWORD(This->typeinfo->version);
3232 (*ppTypeAttr)->wMinorVerNum = HIWORD(This->typeinfo->version);
3233
3234 if((*ppTypeAttr)->typekind == TKIND_ALIAS)
3235 FIXME("TKIND_ALIAS handling not implemented\n");
3236
3237 return S_OK;
3238 }
3239
3240 /******************************************************************************
3241 * ITypeInfo2_GetTypeComp {OLEAUT32}
3242 */
3243 static HRESULT WINAPI ITypeInfo2_fnGetTypeComp(
3244 ITypeInfo2* iface,
3245 ITypeComp** ppTComp)
3246 {
3247 FIXME("(%p,%p), stub!\n", iface, ppTComp);
3248 return E_OUTOFMEMORY;
3249 }
3250
3251 /******************************************************************************
3252 * ITypeInfo2_GetFuncDesc {OLEAUT32}
3253 */
3254 static HRESULT WINAPI ITypeInfo2_fnGetFuncDesc(
3255 ITypeInfo2* iface,
3256 UINT index,
3257 FUNCDESC** ppFuncDesc)
3258 {
3259 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3260 MSFT_FuncRecord *typedata;
3261 int i, num_defaults = 0, has_defaults;
3262 CyclicList *desc;
3263 HRESULT hres;
3264
3265 TRACE("(%p,%d,%p), semi-stub\n", iface, index, ppFuncDesc);
3266
3267 if (!ppFuncDesc)
3268 return E_INVALIDARG;
3269
3270 if (index >= cti2_get_func_count(This->typeinfo))
3271 return TYPE_E_ELEMENTNOTFOUND;
3272
3273 hres = ICreateTypeInfo2_LayOut(&This->ICreateTypeInfo2_iface);
3274 if (FAILED(hres))
3275 return hres;
3276
3277 desc = This->typedata->next;
3278 for (i = index; i >= 0; ) {
3279 desc = desc->next;
3280 if (desc->type == CyclicListFunc)
3281 --i;
3282 }
3283
3284 typedata = desc->u.func;
3285
3286 *ppFuncDesc = heap_alloc_zero(sizeof(FUNCDESC));
3287 if (!*ppFuncDesc)
3288 return E_OUTOFMEMORY;
3289
3290 (*ppFuncDesc)->memid = desc->indice;
3291 (*ppFuncDesc)->lprgscode = NULL; /* FIXME: Unimplemented */
3292 (*ppFuncDesc)->funckind = typedata->FKCCIC & 0x7;
3293 (*ppFuncDesc)->invkind = (typedata->FKCCIC >> 3) & 0xF;
3294 (*ppFuncDesc)->callconv = (typedata->FKCCIC >> 8) & 0xF;
3295 (*ppFuncDesc)->cParams = typedata->nrargs;
3296 (*ppFuncDesc)->cParamsOpt = typedata->nroargs;
3297 (*ppFuncDesc)->oVft = typedata->VtableOffset & 0xFFFC;
3298 (*ppFuncDesc)->cScodes = 0; /* FIXME: Unimplemented*/
3299 hres = ctl2_decode_typedesc(This->typelib, typedata->DataType,
3300 &(*ppFuncDesc)->elemdescFunc.tdesc);
3301 if (FAILED(hres)) {
3302 heap_free(*ppFuncDesc);
3303 return hres;
3304 }
3305 (*ppFuncDesc)->wFuncFlags = typedata->Flags;
3306
3307 has_defaults = typedata->FKCCIC & 0x1000;
3308
3309 if ((*ppFuncDesc)->cParams > 0) {
3310 (*ppFuncDesc)->lprgelemdescParam = heap_alloc_zero((*ppFuncDesc)->cParams * sizeof(ELEMDESC));
3311 if (!(*ppFuncDesc)->lprgelemdescParam) {
3312 heap_free(*ppFuncDesc);
3313 return E_OUTOFMEMORY;
3314 }
3315 if (has_defaults) {
3316 num_defaults = (*ppFuncDesc)->cParams;
3317
3318 for (i = 0; i < num_defaults; ++i) {
3319 if (typedata->oArgCustData[i] != 0xFFFFFFFF) {
3320 (*ppFuncDesc)->lprgelemdescParam[i].u.paramdesc.wParamFlags |= PARAMFLAG_FHASDEFAULT;
3321
3322 (*ppFuncDesc)->lprgelemdescParam[i].u.paramdesc.pparamdescex = heap_alloc(sizeof(PARAMDESCEX));
3323 if (!(*ppFuncDesc)->lprgelemdescParam[i].u.paramdesc.pparamdescex) {
3324 ITypeInfo2_ReleaseFuncDesc(iface, *ppFuncDesc);
3325 return E_OUTOFMEMORY;
3326 }
3327
3328 (*ppFuncDesc)->lprgelemdescParam[i].u.paramdesc.pparamdescex->cBytes = sizeof(PARAMDESCEX);
3329 VariantInit(&(*ppFuncDesc)->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue);
3330 hres = ctl2_decode_variant(This->typelib, typedata->oArgCustData[i],
3331 &(*ppFuncDesc)->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue);
3332 if (FAILED(hres)) {
3333 ITypeInfo2_ReleaseFuncDesc(iface, *ppFuncDesc);
3334 return hres;
3335 }
3336 }
3337 }
3338 }
3339
3340 for (i = 0; i < (*ppFuncDesc)->cParams; ++i) {
3341 hres = ctl2_decode_typedesc(This->typelib, typedata->oArgCustData[num_defaults+i*3],
3342 &((*ppFuncDesc)->lprgelemdescParam + i)->tdesc);
3343 if (FAILED(hres)) {
3344 ITypeInfo2_ReleaseFuncDesc(iface, *ppFuncDesc);
3345 return hres;
3346 }
3347 (*ppFuncDesc)->lprgelemdescParam[i].u.paramdesc.wParamFlags = typedata->oArgCustData[num_defaults+i*3+2];
3348 }
3349 }
3350
3351 return S_OK;
3352 }
3353
3354 /******************************************************************************
3355 * ITypeInfo2_GetVarDesc {OLEAUT32}
3356 */
3357 static HRESULT WINAPI ITypeInfo2_fnGetVarDesc(
3358 ITypeInfo2* iface,
3359 UINT index,
3360 VARDESC** ppVarDesc)
3361 {
3362 FIXME("(%p,%d,%p), stub!\n", iface, index, ppVarDesc);
3363 return E_OUTOFMEMORY;
3364 }
3365
3366 /******************************************************************************
3367 * ITypeInfo2_GetNames {OLEAUT32}
3368 */
3369 static HRESULT WINAPI ITypeInfo2_fnGetNames(
3370 ITypeInfo2* iface,
3371 MEMBERID memid,
3372 BSTR* rgBstrNames,
3373 UINT cMaxNames,
3374 UINT* pcNames)
3375 {
3376 FIXME("(%p,%d,%p,%d,%p), stub!\n", iface, memid, rgBstrNames, cMaxNames, pcNames);
3377 return E_OUTOFMEMORY;
3378 }
3379
3380 /******************************************************************************
3381 * ITypeInfo2_GetRefTypeOfImplType {OLEAUT32}
3382 */
3383 static HRESULT WINAPI ITypeInfo2_fnGetRefTypeOfImplType(
3384 ITypeInfo2* iface,
3385 UINT index,
3386 HREFTYPE* pRefType)
3387 {
3388 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3389 MSFT_RefRecord *ref;
3390 int offset;
3391
3392 TRACE("(%p,%d,%p)\n", iface, index, pRefType);
3393
3394 if(!pRefType)
3395 return E_INVALIDARG;
3396
3397 if(This->typeinfo->flags&TYPEFLAG_FDUAL) {
3398 if(index == -1) {
3399 *pRefType = -2;
3400 return S_OK;
3401 }
3402
3403 if(This->typekind == TKIND_DISPATCH)
3404 return ITypeInfo2_GetRefTypeOfImplType(&This->dual->ITypeInfo2_iface,
3405 index, pRefType);
3406 }
3407
3408 if(index>=This->typeinfo->cImplTypes)
3409 return TYPE_E_ELEMENTNOTFOUND;
3410
3411 if(This->typekind == TKIND_INTERFACE) {
3412 *pRefType = This->typeinfo->datatype1 + 2;
3413 return S_OK;
3414 }
3415
3416 offset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index);
3417 if(offset == -1)
3418 return TYPE_E_ELEMENTNOTFOUND;
3419
3420 ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
3421 *pRefType = ref->reftype;
3422 return S_OK;
3423 }
3424
3425 /******************************************************************************
3426 * ITypeInfo2_GetImplTypeFlags {OLEAUT32}
3427 */
3428 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeFlags(
3429 ITypeInfo2* iface,
3430 UINT index,
3431 INT* pImplTypeFlags)
3432 {
3433 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3434 int offset;
3435 MSFT_RefRecord *ref;
3436
3437 TRACE("(%p,%d,%p)\n", iface, index, pImplTypeFlags);
3438
3439 if(!pImplTypeFlags)
3440 return E_INVALIDARG;
3441
3442 if(index >= This->typeinfo->cImplTypes)
3443 return TYPE_E_ELEMENTNOTFOUND;
3444
3445 if(This->typekind != TKIND_COCLASS) {
3446 *pImplTypeFlags = 0;
3447 return S_OK;
3448 }
3449
3450 offset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index);
3451 if(offset == -1)
3452 return TYPE_E_ELEMENTNOTFOUND;
3453
3454 ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
3455 *pImplTypeFlags = ref->flags;
3456 return S_OK;
3457 }
3458
3459 /******************************************************************************
3460 * ITypeInfo2_GetIDsOfNames {OLEAUT32}
3461 */
3462 static HRESULT WINAPI ITypeInfo2_fnGetIDsOfNames(
3463 ITypeInfo2* iface,
3464 LPOLESTR* rgszNames,
3465 UINT cNames,
3466 MEMBERID* pMemId)
3467 {
3468 FIXME("(%p,%p,%d,%p), stub!\n", iface, rgszNames, cNames, pMemId);
3469 return E_OUTOFMEMORY;
3470 }
3471
3472 /******************************************************************************
3473 * ITypeInfo2_Invoke {OLEAUT32}
3474 */
3475 static HRESULT WINAPI ITypeInfo2_fnInvoke(
3476 ITypeInfo2* iface,
3477 PVOID pvInstance,
3478 MEMBERID memid,
3479 WORD wFlags,
3480 DISPPARAMS* pDispParams,
3481 VARIANT* pVarResult,
3482 EXCEPINFO* pExcepInfo,
3483 UINT* puArgErr)
3484 {
3485 FIXME("(%p,%p,%d,%x,%p,%p,%p,%p), stub!\n", iface, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3486 return E_OUTOFMEMORY;
3487 }
3488
3489 /******************************************************************************
3490 * ITypeInfo2_GetDocumentation {OLEAUT32}
3491 */
3492 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation(
3493 ITypeInfo2* iface,
3494 MEMBERID memid,
3495 BSTR* pBstrName,
3496 BSTR* pBstrDocString,
3497 DWORD* pdwHelpContext,
3498 BSTR* pBstrHelpFile)
3499 {
3500 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3501 HRESULT status = TYPE_E_ELEMENTNOTFOUND;
3502 INT nameoffset, docstringoffset, helpcontext;
3503
3504 TRACE("(%p,%d,%p,%p,%p,%p)\n", iface, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
3505
3506 if (memid == -1)
3507 {
3508 nameoffset = This->typeinfo->NameOffset;
3509 docstringoffset = This->typeinfo->docstringoffs;
3510 helpcontext = This->typeinfo->helpcontext;
3511 status = S_OK;
3512 } else {
3513 CyclicList *iter;
3514 if (This->typedata) {
3515 for(iter=This->typedata->next->next; iter!=This->typedata->next; iter=iter->next) {
3516 if (iter->indice == memid) {
3517 if (iter->type == CyclicListFunc) {
3518 nameoffset = iter->name;
3519 /* FIXME implement this once SetFuncDocString is implemented */
3520 docstringoffset = -1;
3521 helpcontext = iter->u.func->HelpContext;
3522
3523 status = S_OK;
3524 } else {
3525 FIXME("Not implemented for variable members\n");
3526 }
3527
3528 break;
3529 }
3530 }
3531 }
3532 }
3533
3534 if (!status) {
3535 WCHAR *string;
3536 if (pBstrName) {
3537 if (nameoffset == -1)
3538 *pBstrName = NULL;
3539 else {
3540 MSFT_NameIntro *name = (MSFT_NameIntro*)&This->typelib->
3541 typelib_segment_data[MSFT_SEG_NAME][nameoffset];
3542 ctl2_decode_name((char*)&name->namelen, &string);
3543 *pBstrName = SysAllocString(string);
3544 if(!*pBstrName)
3545 return E_OUTOFMEMORY;
3546 }
3547 }
3548
3549 if (pBstrDocString) {
3550 if (docstringoffset == -1)
3551 *pBstrDocString = NULL;
3552 else {
3553 MSFT_NameIntro *name = (MSFT_NameIntro*)&This->typelib->
3554 typelib_segment_data[MSFT_SEG_NAME][docstringoffset];
3555 ctl2_decode_name((char*)&name->namelen, &string);
3556 *pBstrDocString = SysAllocString(string);
3557 if(!*pBstrDocString) {
3558 if (pBstrName) SysFreeString(*pBstrName);
3559 return E_OUTOFMEMORY;
3560 }
3561 }
3562 }
3563
3564 if (pdwHelpContext) {
3565 *pdwHelpContext = helpcontext;
3566 }
3567
3568 if (pBstrHelpFile) {
3569 status = ITypeLib_GetDocumentation((ITypeLib*)&This->typelib->ITypeLib2_iface,
3570 -1, NULL, NULL, NULL, pBstrHelpFile);
3571 if (status) {
3572 if (pBstrName) SysFreeString(*pBstrName);
3573 if (pBstrDocString) SysFreeString(*pBstrDocString);
3574 }
3575 }
3576 }
3577
3578 return status;
3579 }
3580
3581 /******************************************************************************
3582 * ITypeInfo2_GetDllEntry {OLEAUT32}
3583 */
3584 static HRESULT WINAPI ITypeInfo2_fnGetDllEntry(
3585 ITypeInfo2* iface,
3586 MEMBERID memid,
3587 INVOKEKIND invKind,
3588 BSTR* pBstrDllName,
3589 BSTR* pBstrName,
3590 WORD* pwOrdinal)
3591 {
3592 FIXME("(%p,%d,%d,%p,%p,%p), stub!\n", iface, memid, invKind, pBstrDllName, pBstrName, pwOrdinal);
3593 return E_OUTOFMEMORY;
3594 }
3595
3596 /******************************************************************************
3597 * ITypeInfo2_GetRefTypeInfo {OLEAUT32}
3598 */
3599 static HRESULT WINAPI ITypeInfo2_fnGetRefTypeInfo(
3600 ITypeInfo2* iface,
3601 HREFTYPE hRefType,
3602 ITypeInfo** ppTInfo)
3603 {
3604 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3605
3606 TRACE("(%p,%d,%p)\n", iface, hRefType, ppTInfo);
3607
3608 if(!ppTInfo)
3609 return E_INVALIDARG;
3610
3611 if(hRefType==-2 && This->dual) {
3612 *ppTInfo = (ITypeInfo *)&This->dual->ITypeInfo2_iface;
3613 ITypeInfo_AddRef(*ppTInfo);
3614 return S_OK;
3615 }
3616
3617 if(hRefType&1) {
3618 ITypeLib *tl;
3619 MSFT_ImpInfo *impinfo;
3620 MSFT_ImpFile *impfile;
3621 MSFT_GuidEntry *guid;
3622 WCHAR *filename;
3623 HRESULT hres;
3624
3625 if((hRefType&(~0x3)) >= This->typelib->typelib_segdir[MSFT_SEG_IMPORTINFO].length)
3626 return E_FAIL;
3627
3628 impinfo = (MSFT_ImpInfo*)&This->typelib->typelib_segment_data[MSFT_SEG_IMPORTINFO][hRefType&(~0x3)];
3629 impfile = (MSFT_ImpFile*)&This->typelib->typelib_segment_data[MSFT_SEG_IMPORTFILES][impinfo->oImpFile];
3630 guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][impinfo->oGuid];
3631
3632 ctl2_decode_string((unsigned char*)impfile->filename, &filename);
3633
3634 hres = LoadTypeLib(filename, &tl);
3635 if(FAILED(hres))
3636 return hres;
3637
3638 hres = ITypeLib_GetTypeInfoOfGuid(tl, &guid->guid, ppTInfo);
3639
3640 ITypeLib_Release(tl);
3641 return hres;
3642 } else {
3643 ICreateTypeInfo2Impl *iter;
3644 int i = 0;
3645
3646 for(iter=This->typelib->typeinfos; iter; iter=iter->next_typeinfo) {
3647 if(This->typelib->typelib_typeinfo_offsets[i] == (hRefType&(~0x3))) {
3648 *ppTInfo = (ITypeInfo *)&iter->ITypeInfo2_iface;
3649
3650 ITypeInfo_AddRef(*ppTInfo);
3651 return S_OK;
3652 }
3653 i++;
3654 }
3655 }
3656
3657 return E_FAIL;
3658 }
3659
3660 /******************************************************************************
3661 * ITypeInfo2_AddressOfMember {OLEAUT32}
3662 */
3663 static HRESULT WINAPI ITypeInfo2_fnAddressOfMember(
3664 ITypeInfo2* iface,
3665 MEMBERID memid,
3666 INVOKEKIND invKind,
3667 PVOID* ppv)
3668 {
3669 FIXME("(%p,%d,%d,%p), stub!\n", iface, memid, invKind, ppv);
3670 return E_OUTOFMEMORY;
3671 }
3672
3673 /******************************************************************************
3674 * ITypeInfo2_CreateInstance {OLEAUT32}
3675 */
3676 static HRESULT WINAPI ITypeInfo2_fnCreateInstance(
3677 ITypeInfo2* iface,
3678 IUnknown* pUnkOuter,
3679 REFIID riid,
3680 PVOID* ppvObj)
3681 {
3682 FIXME("(%p,%p,%s,%p), stub!\n", iface, pUnkOuter, debugstr_guid(riid), ppvObj);
3683 return E_OUTOFMEMORY;
3684 }
3685
3686 /******************************************************************************
3687 * ITypeInfo2_GetMops {OLEAUT32}
3688 */
3689 static HRESULT WINAPI ITypeInfo2_fnGetMops(
3690 ITypeInfo2* iface,
3691 MEMBERID memid,
3692 BSTR* pBstrMops)
3693 {
3694 FIXME("(%p,%d,%p), stub!\n", iface, memid, pBstrMops);
3695 return E_OUTOFMEMORY;
3696 }
3697
3698 /******************************************************************************
3699 * ITypeInfo2_GetContainingTypeLib {OLEAUT32}
3700 */
3701 static HRESULT WINAPI ITypeInfo2_fnGetContainingTypeLib(
3702 ITypeInfo2* iface,
3703 ITypeLib** ppTLib,
3704 UINT* pIndex)
3705 {
3706 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3707
3708 TRACE("(%p,%p,%p)\n", iface, ppTLib, pIndex);
3709
3710 *ppTLib = (ITypeLib *)&This->typelib->ITypeLib2_iface;
3711 ICreateTypeLib_AddRef((ICreateTypeLib*)This->typelib);
3712 *pIndex = This->typeinfo->typekind >> 16;
3713
3714 return S_OK;
3715 }
3716
3717 static void release_typedesc(TYPEDESC *tdesc)
3718 {
3719 while (tdesc) {
3720 TYPEDESC *next;
3721 if (tdesc->vt == VT_USERDEFINED)
3722 next = NULL;
3723 else
3724 next = tdesc->u.lptdesc;
3725 heap_free(tdesc);
3726 tdesc = next;
3727 }
3728 }
3729
3730 /******************************************************************************
3731 * ITypeInfo2_ReleaseTypeAttr {OLEAUT32}
3732 */
3733 static void WINAPI ITypeInfo2_fnReleaseTypeAttr(
3734 ITypeInfo2* iface,
3735 TYPEATTR* pTypeAttr)
3736 {
3737 TRACE("(%p,%p)\n", iface, pTypeAttr);
3738
3739 if (pTypeAttr->tdescAlias.vt != VT_USERDEFINED)
3740 release_typedesc(pTypeAttr->tdescAlias.u.lptdesc);
3741
3742 heap_free(pTypeAttr);
3743 }
3744
3745 /******************************************************************************
3746 * ITypeInfo2_ReleaseFuncDesc {OLEAUT32}
3747 */
3748 static void WINAPI ITypeInfo2_fnReleaseFuncDesc(
3749 ITypeInfo2* iface,
3750 FUNCDESC* pFuncDesc)
3751 {
3752 int i;
3753
3754 TRACE("(%p,%p)\n", iface, pFuncDesc);
3755
3756 heap_free(pFuncDesc->lprgscode);
3757
3758 if (pFuncDesc->lprgelemdescParam) {
3759 for (i = 0; i < pFuncDesc->cParams; ++i) {
3760 if (pFuncDesc->lprgelemdescParam[i].tdesc.vt != VT_USERDEFINED)
3761 release_typedesc(pFuncDesc->lprgelemdescParam[i].tdesc.u.lptdesc);
3762
3763 if (pFuncDesc->lprgelemdescParam[i].u.paramdesc.pparamdescex)
3764 {
3765 VariantClear(&pFuncDesc->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue);
3766 heap_free(pFuncDesc->lprgelemdescParam[i].u.paramdesc.pparamdescex);
3767 }
3768 }
3769 heap_free(pFuncDesc->lprgelemdescParam);
3770 }
3771
3772 heap_free(pFuncDesc->elemdescFunc.u.paramdesc.pparamdescex);
3773
3774 if (pFuncDesc->elemdescFunc.tdesc.vt != VT_USERDEFINED)
3775 release_typedesc(pFuncDesc->elemdescFunc.tdesc.u.lptdesc);
3776
3777 heap_free(pFuncDesc);
3778 }
3779
3780 /******************************************************************************
3781 * ITypeInfo2_ReleaseVarDesc {OLEAUT32}
3782 */
3783 static void WINAPI ITypeInfo2_fnReleaseVarDesc(
3784 ITypeInfo2* iface,
3785 VARDESC* pVarDesc)
3786 {
3787 FIXME("(%p,%p), stub!\n", iface, pVarDesc);
3788 }
3789
3790 /******************************************************************************
3791 * ITypeInfo2_GetTypeKind {OLEAUT32}
3792 *
3793 * Get the TYPEKIND value for a TypeInfo.
3794 *
3795 * RETURNS
3796 *
3797 * Success: S_OK.
3798 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3799 */
3800 static HRESULT WINAPI ITypeInfo2_fnGetTypeKind(
3801 ITypeInfo2* iface, /* [I] The TypeInfo to obtain the typekind for. */
3802 TYPEKIND* pTypeKind) /* [O] The typekind for this TypeInfo. */
3803 {
3804 FIXME("(%p,%p), stub!\n", iface, pTypeKind);
3805 return E_OUTOFMEMORY;
3806 }
3807
3808 /******************************************************************************
3809 * ITypeInfo2_GetTypeFlags {OLEAUT32}
3810 *
3811 * Get the Type Flags for a TypeInfo.
3812 *
3813 * RETURNS
3814 *
3815 * Success: S_OK.
3816 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3817 */
3818 static HRESULT WINAPI ITypeInfo2_fnGetTypeFlags(
3819 ITypeInfo2* iface, /* [I] The TypeInfo to obtain the typeflags for. */
3820 ULONG* pTypeFlags) /* [O] The type flags for this TypeInfo. */
3821 {
3822 FIXME("(%p,%p), stub!\n", iface, pTypeFlags);
3823 return E_OUTOFMEMORY;
3824 }
3825
3826 /******************************************************************************
3827 * ITypeInfo2_GetFuncIndexOfMemId {OLEAUT32}
3828 *
3829 * Gets the index of a function given its member id.
3830 *
3831 * RETURNS
3832 *
3833 * Success: S_OK.
3834 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3835 */
3836 static HRESULT WINAPI ITypeInfo2_fnGetFuncIndexOfMemId(
3837 ITypeInfo2* iface, /* [I] The TypeInfo in which to find the function. */
3838 MEMBERID memid, /* [I] The member id for the function. */
3839 INVOKEKIND invKind, /* [I] The invocation kind for the function. */
3840 UINT* pFuncIndex) /* [O] The index of the function. */
3841 {
3842 FIXME("(%p,%d,%d,%p), stub!\n", iface, memid, invKind, pFuncIndex);
3843 return E_OUTOFMEMORY;
3844 }
3845
3846 /******************************************************************************
3847 * ITypeInfo2_GetVarIndexOfMemId {OLEAUT32}
3848 *
3849 * Gets the index of a variable given its member id.
3850 *
3851 * RETURNS
3852 *
3853 * Success: S_OK.
3854 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3855 */
3856 static HRESULT WINAPI ITypeInfo2_fnGetVarIndexOfMemId(
3857 ITypeInfo2* iface, /* [I] The TypeInfo in which to find the variable. */
3858 MEMBERID memid, /* [I] The member id for the variable. */
3859 UINT* pVarIndex) /* [O] The index of the variable. */
3860 {
3861 FIXME("(%p,%d,%p), stub!\n", iface, memid, pVarIndex);
3862 return E_OUTOFMEMORY;
3863 }
3864
3865 /******************************************************************************
3866 * ITypeInfo2_GetCustData {OLEAUT32}
3867 *
3868 * Gets a custom data element from a TypeInfo.
3869 *
3870 * RETURNS
3871 *
3872 * Success: S_OK.
3873 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3874 */
3875 static HRESULT WINAPI ITypeInfo2_fnGetCustData(
3876 ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
3877 REFGUID guid, /* [I] The GUID under which the custom data is stored. */
3878 VARIANT* pVarVal) /* [O] The custom data. */
3879 {
3880 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3881 MSFT_CDGuid *cdentry;
3882 int offset;
3883
3884 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(guid), pVarVal);
3885
3886 if (!guid || !pVarVal)
3887 return E_INVALIDARG;
3888
3889 VariantClear(pVarVal);
3890
3891 offset = ctl2_find_custdata(This->typelib, guid, This->typeinfo->oCustData);
3892 if (offset == -1)
3893 return S_OK;
3894
3895 cdentry = (MSFT_CDGuid *)&This->typelib->typelib_segment_data[MSFT_SEG_CUSTDATAGUID][offset];
3896 return ctl2_decode_variant(This->typelib, cdentry->DataOffset, pVarVal);
3897 }
3898
3899 /******************************************************************************
3900 * ITypeInfo2_GetFuncCustData {OLEAUT32}
3901 *
3902 * Gets a custom data element from a function.
3903 *
3904 * RETURNS
3905 *
3906 * Success: S_OK.
3907 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3908 */
3909 static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData(
3910 ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
3911 UINT index, /* [I] The index of the function for which to retrieve the custom data. */
3912 REFGUID guid, /* [I] The GUID under which the custom data is stored. */
3913 VARIANT* pVarVal) /* [O] The custom data. */
3914 {
3915 FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
3916 return E_OUTOFMEMORY;
3917 }
3918
3919 /******************************************************************************
3920 * ITypeInfo2_GetParamCustData {OLEAUT32}
3921 *
3922 * Gets a custom data element from a parameter.
3923 *
3924 * RETURNS
3925 *
3926 * Success: S_OK.
3927 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3928 */
3929 static HRESULT WINAPI ITypeInfo2_fnGetParamCustData(
3930 ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
3931 UINT indexFunc, /* [I] The index of the function for which to retrieve the custom data. */
3932 UINT indexParam, /* [I] The index of the parameter for which to retrieve the custom data. */
3933 REFGUID guid, /* [I] The GUID under which the custom data is stored. */
3934 VARIANT* pVarVal) /* [O] The custom data. */
3935 {
3936 FIXME("(%p,%d,%d,%s,%p), stub!\n", iface, indexFunc, indexParam, debugstr_guid(guid), pVarVal);
3937 return E_OUTOFMEMORY;
3938 }
3939
3940 /******************************************************************************
3941 * ITypeInfo2_GetVarCustData {OLEAUT32}
3942 *
3943 * Gets a custom data element from a variable.
3944 *
3945 * RETURNS
3946 *
3947 * Success: S_OK.
3948 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3949 */
3950 static HRESULT WINAPI ITypeInfo2_fnGetVarCustData(
3951 ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
3952 UINT index, /* [I] The index of the variable for which to retrieve the custom data. */
3953 REFGUID guid, /* [I] The GUID under which the custom data is stored. */
3954 VARIANT* pVarVal) /* [O] The custom data. */
3955 {
3956 FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
3957 return E_OUTOFMEMORY;
3958 }
3959
3960 /******************************************************************************
3961 * ITypeInfo2_GetImplTypeCustData {OLEAUT32}
3962 *
3963 * Gets a custom data element from an implemented type of a TypeInfo.
3964 *
3965 * RETURNS
3966 *
3967 * Success: S_OK.
3968 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3969 */
3970 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData(
3971 ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
3972 UINT index, /* [I] The index of the implemented type for which to retrieve the custom data. */
3973 REFGUID guid, /* [I] The GUID under which the custom data is stored. */
3974 VARIANT* pVarVal) /* [O] The custom data. */
3975 {
3976 FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
3977 return E_OUTOFMEMORY;
3978 }
3979
3980 /******************************************************************************
3981 * ITypeInfo2_GetDocumentation2 {OLEAUT32}
3982 *
3983 * Gets some documentation from a TypeInfo in a locale-aware fashion.
3984 *
3985 * RETURNS
3986 *
3987 * Success: S_OK.
3988 * Failure: One of STG_E_INSUFFICIENTMEMORY or E_INVALIDARG.
3989 */
3990 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2(
3991 ITypeInfo2* iface, /* [I] The TypeInfo to retrieve the documentation from. */
3992 MEMBERID memid, /* [I] The member id (why?). */
3993 LCID lcid, /* [I] The locale (why?). */
3994 BSTR* pbstrHelpString, /* [O] The help string. */
3995 DWORD* pdwHelpStringContext, /* [O] The help string context. */
3996 BSTR* pbstrHelpStringDll) /* [O] The help file name. */
3997 {
3998 FIXME("(%p,%d,%d,%p,%p,%p), stub!\n", iface, memid, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll);
3999 return E_OUTOFMEMORY;
4000 }
4001
4002 /******************************************************************************
4003 * ITypeInfo2_GetAllCustData {OLEAUT32}
4004 *
4005 * Gets all of the custom data associated with a TypeInfo.
4006 *
4007 * RETURNS
4008 *
4009 * Success: S_OK.
4010 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
4011 */
4012 static HRESULT WINAPI ITypeInfo2_fnGetAllCustData(
4013 ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
4014 CUSTDATA* pCustData) /* [O] A pointer to the custom data. */
4015 {
4016 FIXME("(%p,%p), stub!\n", iface, pCustData);
4017 return E_OUTOFMEMORY;
4018 }
4019
4020 /******************************************************************************
4021 * ITypeInfo2_GetAllFuncCustData {OLEAUT32}
4022 *
4023 * Gets all of the custom data associated with a function.
4024 *
4025 * RETURNS
4026 *
4027 * Success: S_OK.
4028 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
4029 */
4030 static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData(
4031 ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
4032 UINT index, /* [I] The index of the function for which to retrieve the custom data. */
4033 CUSTDATA* pCustData) /* [O] A pointer to the custom data. */
4034 {
4035 FIXME("(%p,%d,%p), stub!\n", iface, index, pCustData);
4036 return E_OUTOFMEMORY;
4037 }
4038
4039 /******************************************************************************
4040 * ITypeInfo2_GetAllParamCustData {OLEAUT32}
4041 *
4042 * Gets all of the custom data associated with a parameter.
4043 *
4044 * RETURNS
4045 *
4046 * Success: S_OK.
4047 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
4048 */
4049 static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData(
4050 ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
4051 UINT indexFunc, /* [I] The index of the function for which to retrieve the custom data. */
4052 UINT indexParam, /* [I] The index of the parameter for which to retrieve the custom data. */
4053 CUSTDATA* pCustData) /* [O] A pointer to the custom data. */
4054 {
4055 FIXME("(%p,%d,%d,%p), stub!\n", iface, indexFunc, indexParam, pCustData);
4056 return E_OUTOFMEMORY;
4057 }
4058
4059 /******************************************************************************
4060 * ITypeInfo2_GetAllVarCustData {OLEAUT32}
4061 *
4062 * Gets all of the custom data associated with a variable.
4063 *
4064 * RETURNS
4065 *
4066 * Success: S_OK.
4067 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
4068 */
4069 static HRESULT WINAPI ITypeInfo2_fnGetAllVarCustData(
4070 ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
4071 UINT index, /* [I] The index of the variable for which to retrieve the custom data. */
4072 CUSTDATA* pCustData) /* [O] A pointer to the custom data. */
4073 {
4074 FIXME("(%p,%d,%p), stub!\n", iface, index, pCustData);
4075 return E_OUTOFMEMORY;
4076 }
4077
4078 /******************************************************************************
4079 * ITypeInfo2_GetAllImplTypeCustData {OLEAUT32}
4080 *
4081 * Gets all of the custom data associated with an implemented type.
4082 *
4083 * RETURNS
4084 *
4085 * Success: S_OK.
4086 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
4087 */
4088 static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData(
4089 ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
4090 UINT index, /* [I] The index of the implemented type for which to retrieve the custom data. */
4091 CUSTDATA* pCustData) /* [O] A pointer to the custom data. */
4092 {
4093 FIXME("(%p,%d,%p), stub!\n", iface, index, pCustData);
4094 return E_OUTOFMEMORY;
4095 }
4096
4097
4098 /*================== ICreateTypeInfo2 & ITypeInfo2 VTABLEs And Creation ===================================*/
4099
4100 static const ICreateTypeInfo2Vtbl ctypeinfo2vt =
4101 {
4102
4103 ICreateTypeInfo2_fnQueryInterface,
4104 ICreateTypeInfo2_fnAddRef,
4105 ICreateTypeInfo2_fnRelease,
4106
4107 ICreateTypeInfo2_fnSetGuid,
4108 ICreateTypeInfo2_fnSetTypeFlags,
4109 ICreateTypeInfo2_fnSetDocString,
4110 ICreateTypeInfo2_fnSetHelpContext,
4111 ICreateTypeInfo2_fnSetVersion,
4112 ICreateTypeInfo2_fnAddRefTypeInfo,
4113 ICreateTypeInfo2_fnAddFuncDesc,
4114 ICreateTypeInfo2_fnAddImplType,
4115 ICreateTypeInfo2_fnSetImplTypeFlags,
4116 ICreateTypeInfo2_fnSetAlignment,
4117 ICreateTypeInfo2_fnSetSchema,
4118 ICreateTypeInfo2_fnAddVarDesc,
4119 ICreateTypeInfo2_fnSetFuncAndParamNames,
4120 ICreateTypeInfo2_fnSetVarName,
4121 ICreateTypeInfo2_fnSetTypeDescAlias,
4122 ICreateTypeInfo2_fnDefineFuncAsDllEntry,
4123 ICreateTypeInfo2_fnSetFuncDocString,
4124 ICreateTypeInfo2_fnSetVarDocString,
4125 ICreateTypeInfo2_fnSetFuncHelpContext,
4126 ICreateTypeInfo2_fnSetVarHelpContext,
4127 ICreateTypeInfo2_fnSetMops,
4128 ICreateTypeInfo2_fnSetTypeIdldesc,
4129 ICreateTypeInfo2_fnLayOut,
4130
4131 ICreateTypeInfo2_fnDeleteFuncDesc,
4132 ICreateTypeInfo2_fnDeleteFuncDescByMemId,
4133 ICreateTypeInfo2_fnDeleteVarDesc,
4134 ICreateTypeInfo2_fnDeleteVarDescByMemId,
4135 ICreateTypeInfo2_fnDeleteImplType,
4136 ICreateTypeInfo2_fnSetCustData,
4137 ICreateTypeInfo2_fnSetFuncCustData,
4138 ICreateTypeInfo2_fnSetParamCustData,
4139 ICreateTypeInfo2_fnSetVarCustData,
4140 ICreateTypeInfo2_fnSetImplTypeCustData,
4141 ICreateTypeInfo2_fnSetHelpStringContext,
4142 ICreateTypeInfo2_fnSetFuncHelpStringContext,
4143 ICreateTypeInfo2_fnSetVarHelpStringContext,
4144 ICreateTypeInfo2_fnInvalidate,
4145 ICreateTypeInfo2_fnSetName
4146 };
4147
4148 static const ITypeInfo2Vtbl typeinfo2vt =
4149 {
4150
4151 ITypeInfo2_fnQueryInterface,
4152 ITypeInfo2_fnAddRef,
4153 ITypeInfo2_fnRelease,
4154
4155 ITypeInfo2_fnGetTypeAttr,
4156 ITypeInfo2_fnGetTypeComp,
4157 ITypeInfo2_fnGetFuncDesc,
4158 ITypeInfo2_fnGetVarDesc,
4159 ITypeInfo2_fnGetNames,
4160 ITypeInfo2_fnGetRefTypeOfImplType,
4161 ITypeInfo2_fnGetImplTypeFlags,
4162 ITypeInfo2_fnGetIDsOfNames,
4163 ITypeInfo2_fnInvoke,
4164 ITypeInfo2_fnGetDocumentation,
4165 ITypeInfo2_fnGetDllEntry,
4166 ITypeInfo2_fnGetRefTypeInfo,
4167 ITypeInfo2_fnAddressOfMember,
4168 ITypeInfo2_fnCreateInstance,
4169 ITypeInfo2_fnGetMops,
4170 ITypeInfo2_fnGetContainingTypeLib,
4171 ITypeInfo2_fnReleaseTypeAttr,
4172 ITypeInfo2_fnReleaseFuncDesc,
4173 ITypeInfo2_fnReleaseVarDesc,
4174
4175 ITypeInfo2_fnGetTypeKind,
4176 ITypeInfo2_fnGetTypeFlags,
4177 ITypeInfo2_fnGetFuncIndexOfMemId,
4178 ITypeInfo2_fnGetVarIndexOfMemId,
4179 ITypeInfo2_fnGetCustData,
4180 ITypeInfo2_fnGetFuncCustData,
4181 ITypeInfo2_fnGetParamCustData,
4182 ITypeInfo2_fnGetVarCustData,
4183 ITypeInfo2_fnGetImplTypeCustData,
4184 ITypeInfo2_fnGetDocumentation2,
4185 ITypeInfo2_fnGetAllCustData,
4186 ITypeInfo2_fnGetAllFuncCustData,
4187 ITypeInfo2_fnGetAllParamCustData,
4188 ITypeInfo2_fnGetAllVarCustData,
4189 ITypeInfo2_fnGetAllImplTypeCustData,
4190 };
4191
4192 static ICreateTypeInfo2 *ICreateTypeInfo2_Constructor(ICreateTypeLib2Impl *typelib, WCHAR *szName, TYPEKIND tkind)
4193 {
4194 ICreateTypeInfo2Impl *pCreateTypeInfo2Impl;
4195
4196 int nameoffset;
4197 int typeinfo_offset;
4198 MSFT_TypeInfoBase *typeinfo;
4199
4200 TRACE("Constructing ICreateTypeInfo2 for %s with tkind %d\n", debugstr_w(szName), tkind);
4201
4202 pCreateTypeInfo2Impl = heap_alloc_zero(sizeof(ICreateTypeInfo2Impl));
4203 if (!pCreateTypeInfo2Impl) return NULL;
4204
4205 pCreateTypeInfo2Impl->ICreateTypeInfo2_iface.lpVtbl = &ctypeinfo2vt;
4206 pCreateTypeInfo2Impl->ITypeInfo2_iface.lpVtbl = &typeinfo2vt;
4207 pCreateTypeInfo2Impl->ref = 1;
4208
4209 pCreateTypeInfo2Impl->typelib = typelib;
4210 ICreateTypeLib_AddRef((ICreateTypeLib*)typelib);
4211
4212 nameoffset = ctl2_alloc_name(typelib, szName);
4213 typeinfo_offset = ctl2_alloc_typeinfo(typelib, nameoffset);
4214 typeinfo = (MSFT_TypeInfoBase *)&typelib->typelib_segment_data[MSFT_SEG_TYPEINFO][typeinfo_offset];
4215
4216 typelib->typelib_segment_data[MSFT_SEG_NAME][nameoffset + 9] = 0x38;
4217 *((int *)&typelib->typelib_segment_data[MSFT_SEG_NAME][nameoffset]) = typeinfo_offset;
4218
4219 pCreateTypeInfo2Impl->typeinfo = typeinfo;
4220
4221 pCreateTypeInfo2Impl->typekind = tkind;
4222 typeinfo->typekind |= tkind | 0x20;
4223 ICreateTypeInfo2_SetAlignment(&pCreateTypeInfo2Impl->ICreateTypeInfo2_iface, 4);
4224
4225 switch (tkind) {
4226 case TKIND_ENUM:
4227 case TKIND_INTERFACE:
4228 case TKIND_DISPATCH:
4229 case TKIND_COCLASS:
4230 typeinfo->size = 4;
4231 break;
4232
4233 case TKIND_RECORD:
4234 case TKIND_UNION:
4235 typeinfo->size = 0;
4236 break;
4237
4238 case TKIND_MODULE:
4239 typeinfo->size = 2;
4240 break;
4241
4242 case TKIND_ALIAS:
4243 typeinfo->size = -0x75;
4244 break;
4245
4246 default:
4247 FIXME("(%s,%d), unrecognized typekind %d\n", debugstr_w(szName), tkind, tkind);
4248 typeinfo->size = 0xdeadbeef;
4249 break;
4250 }
4251
4252 if (typelib->last_typeinfo) typelib->last_typeinfo->next_typeinfo = pCreateTypeInfo2Impl;
4253 typelib->last_typeinfo = pCreateTypeInfo2Impl;
4254 if (!typelib->typeinfos) typelib->typeinfos = pCreateTypeInfo2Impl;
4255
4256 TRACE(" -- %p\n", pCreateTypeInfo2Impl);
4257
4258 return &pCreateTypeInfo2Impl->ICreateTypeInfo2_iface;
4259 }
4260
4261
4262 /*================== ICreateTypeLib2 Implementation ===================================*/
4263
4264 /******************************************************************************
4265 * ICreateTypeLib2_QueryInterface {OLEAUT32}
4266 */
4267 static HRESULT WINAPI ICreateTypeLib2_fnQueryInterface(
4268 ICreateTypeLib2 * iface,
4269 REFIID riid,
4270 VOID **ppvObject)
4271 {
4272 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4273
4274 TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
4275
4276 *ppvObject=NULL;
4277 if(IsEqualIID(riid, &IID_IUnknown) ||
4278 IsEqualIID(riid,&IID_ICreateTypeLib)||
4279 IsEqualIID(riid,&IID_ICreateTypeLib2))
4280 {
4281 *ppvObject = This;
4282 } else if (IsEqualIID(riid, &IID_ITypeLib) ||
4283 IsEqualIID(riid, &IID_ITypeLib2)) {
4284 *ppvObject = &This->ITypeLib2_iface;
4285 }
4286
4287 if(*ppvObject)
4288 {
4289 ICreateTypeLib2_AddRef(iface);
4290 TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
4291 return S_OK;
4292 }
4293 TRACE("-- Interface: E_NOINTERFACE\n");
4294 return E_NOINTERFACE;
4295 }
4296
4297 /******************************************************************************
4298 * ICreateTypeLib2_AddRef {OLEAUT32}
4299 */
4300 static ULONG WINAPI ICreateTypeLib2_fnAddRef(ICreateTypeLib2 *iface)
4301 {
4302 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4303 ULONG ref = InterlockedIncrement(&This->ref);
4304
4305 TRACE("(%p)->(%u)\n", This, ref);
4306
4307 return ref;
4308 }
4309
4310 /******************************************************************************
4311 * ICreateTypeLib2_Release {OLEAUT32}
4312 */
4313 static ULONG WINAPI ICreateTypeLib2_fnRelease(ICreateTypeLib2 *iface)
4314 {
4315 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4316 ULONG ref = InterlockedDecrement(&This->ref);
4317
4318 TRACE("(%p)->(%u)\n", This, ref);
4319
4320 if (!ref) {
4321 int i;
4322
4323 for (i = 0; i < MSFT_SEG_MAX; i++) {
4324 heap_free(This->typelib_segment_data[i]);
4325 This->typelib_segment_data[i] = NULL;
4326 }
4327 heap_free(This->typelib_typeinfo_offsets);
4328
4329 SysFreeString(This->filename);
4330 This->filename = NULL;
4331
4332 while (This->typeinfos) {
4333 ICreateTypeInfo2Impl *typeinfo = This->typeinfos;
4334 This->typeinfos = typeinfo->next_typeinfo;
4335 if(typeinfo->typedata) {
4336 CyclicList *iter, *rem;
4337
4338 rem = typeinfo->typedata->next;
4339 typeinfo->typedata->next = NULL;
4340 iter = rem->next;
4341 heap_free(rem);
4342
4343 while(iter) {
4344 rem = iter;
4345 iter = iter->next;
4346 heap_free(rem->u.data);
4347 heap_free(rem);
4348 }
4349 }
4350
4351 heap_free(typeinfo->dual);
4352 heap_free(typeinfo);
4353 }
4354
4355 heap_free(This);
4356 }
4357
4358 return ref;
4359 }
4360
4361
4362 /******************************************************************************
4363 * ICreateTypeLib2_CreateTypeInfo {OLEAUT32}
4364 */
4365 static HRESULT WINAPI ICreateTypeLib2_fnCreateTypeInfo(
4366 ICreateTypeLib2 * iface,
4367 LPOLESTR szName,
4368 TYPEKIND tkind,
4369 ICreateTypeInfo **tinfo)
4370 {
4371 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4372 char *name;
4373
4374 TRACE("(%p,%s,%d,%p)\n", iface, debugstr_w(szName), tkind, tinfo);
4375
4376 if (!szName || !tinfo) return E_INVALIDARG;
4377
4378 ctl2_encode_name(This, szName, &name);
4379 if(ctl2_find_name(This, name) != -1)
4380 return TYPE_E_NAMECONFLICT;
4381
4382 *tinfo = (ICreateTypeInfo *)ICreateTypeInfo2_Constructor(This, szName, tkind);
4383 if (!*tinfo) return E_OUTOFMEMORY;
4384
4385 return S_OK;
4386 }
4387
4388 /******************************************************************************
4389 * ICreateTypeLib2_SetName {OLEAUT32}
4390 */
4391 static HRESULT WINAPI ICreateTypeLib2_fnSetName(
4392 ICreateTypeLib2 * iface,
4393 LPOLESTR szName)
4394 {
4395 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4396 int offset;
4397
4398 TRACE("(%p,%s)\n", iface, debugstr_w(szName));
4399
4400 offset = ctl2_alloc_name(This, szName);
4401 if (offset == -1) return E_OUTOFMEMORY;
4402 This->typelib_header.NameOffset = offset;
4403 return S_OK;
4404 }
4405
4406 /******************************************************************************
4407 * ICreateTypeLib2_SetVersion {OLEAUT32}
4408 */
4409 static HRESULT WINAPI ICreateTypeLib2_fnSetVersion(ICreateTypeLib2 * iface, WORD wMajorVerNum, WORD wMinorVerNum)
4410 {
4411 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4412
4413 TRACE("(%p,%d,%d)\n", iface, wMajorVerNum, wMinorVerNum);
4414
4415 This->typelib_header.version = wMajorVerNum | (wMinorVerNum << 16);
4416 return S_OK;
4417 }
4418
4419 /******************************************************************************
4420 * ICreateTypeLib2_SetGuid {OLEAUT32}
4421 */
4422 static HRESULT WINAPI ICreateTypeLib2_fnSetGuid(ICreateTypeLib2 * iface, REFGUID guid)
4423 {
4424 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4425 MSFT_GuidEntry guidentry;
4426 int offset;
4427
4428 TRACE("(%p,%s)\n", iface, debugstr_guid(guid));
4429
4430 guidentry.guid = *guid;
4431 guidentry.hreftype = -2;
4432 guidentry.next_hash = -1;
4433
4434 offset = ctl2_alloc_guid(This, &guidentry);
4435
4436 if (offset == -1) return E_OUTOFMEMORY;
4437
4438 This->typelib_header.posguid = offset;
4439
4440 return S_OK;
4441 }
4442
4443 /******************************************************************************
4444 * ICreateTypeLib2_SetDocString {OLEAUT32}
4445 */
4446 static HRESULT WINAPI ICreateTypeLib2_fnSetDocString(ICreateTypeLib2 * iface, LPOLESTR szDoc)
4447 {
4448 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4449 int offset;
4450
4451 TRACE("(%p,%s)\n", iface, debugstr_w(szDoc));
4452 if (!szDoc)
4453 return E_INVALIDARG;
4454
4455 offset = ctl2_alloc_string(This, szDoc);
4456 if (offset == -1) return E_OUTOFMEMORY;
4457 This->typelib_header.helpstring = offset;
4458 return S_OK;
4459 }
4460
4461 /******************************************************************************
4462 * ICreateTypeLib2_SetHelpFileName {OLEAUT32}
4463 */
4464 static HRESULT WINAPI ICreateTypeLib2_fnSetHelpFileName(ICreateTypeLib2 * iface, LPOLESTR szHelpFileName)
4465 {
4466 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4467 int offset;
4468
4469 TRACE("(%p,%s)\n", iface, debugstr_w(szHelpFileName));
4470
4471 offset = ctl2_alloc_string(This, szHelpFileName);
4472 if (offset == -1) return E_OUTOFMEMORY;
4473 This->typelib_header.helpfile = offset;
4474 This->typelib_header.varflags |= 0x10;
4475 return S_OK;
4476 }
4477
4478 /******************************************************************************
4479 * ICreateTypeLib2_SetHelpContext {OLEAUT32}
4480 */
4481 static HRESULT WINAPI ICreateTypeLib2_fnSetHelpContext(ICreateTypeLib2 * iface, DWORD dwHelpContext)
4482 {
4483 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4484
4485 TRACE("(%p,%d)\n", iface, dwHelpContext);
4486 This->typelib_header.helpcontext = dwHelpContext;
4487 return S_OK;
4488 }
4489
4490 /******************************************************************************
4491 * ICreateTypeLib2_SetLcid {OLEAUT32}
4492 *
4493 * Sets both the lcid and lcid2 members in the header to lcid.
4494 *
4495 * As a special case if lcid == LOCALE_NEUTRAL (0), then the first header lcid
4496 * is set to US English while the second one is set to 0.
4497 */
4498 static HRESULT WINAPI ICreateTypeLib2_fnSetLcid(ICreateTypeLib2 * iface, LCID lcid)
4499 {
4500 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4501
4502 TRACE("(%p,%d)\n", iface, lcid);
4503
4504 This->typelib_header.lcid = This->typelib_header.lcid2 = lcid;
4505
4506 if(lcid == LOCALE_NEUTRAL) This->typelib_header.lcid = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
4507
4508 return S_OK;
4509 }
4510
4511 /******************************************************************************
4512 * ICreateTypeLib2_SetLibFlags {OLEAUT32}
4513 */
4514 static HRESULT WINAPI ICreateTypeLib2_fnSetLibFlags(ICreateTypeLib2 * iface, UINT uLibFlags)
4515 {
4516 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4517
4518 TRACE("(%p,0x%x)\n", iface, uLibFlags);
4519
4520 This->typelib_header.flags = uLibFlags;
4521
4522 return S_OK;
4523 }
4524
4525 static int ctl2_write_chunk(HANDLE hFile, const void *segment, int length)
4526 {
4527 DWORD dwWritten;
4528 if (!WriteFile(hFile, segment, length, &dwWritten, 0)) {
4529 TRACE("Writefile(%p, %d) failed, lasterror %d\n", segment, length, GetLastError());
4530 CloseHandle(hFile);
4531 return 0;
4532 }
4533 return -1;
4534 }
4535
4536 static int ctl2_write_segment(ICreateTypeLib2Impl *This, HANDLE hFile, int segment)
4537 {
4538 DWORD dwWritten;
4539 if (!WriteFile(hFile, This->typelib_segment_data[segment],
4540 This->typelib_segdir[segment].length, &dwWritten, 0)) {
4541 CloseHandle(hFile);
4542 return 0;
4543 }
4544
4545 return -1;
4546 }
4547
4548 static HRESULT ctl2_finalize_typeinfos(ICreateTypeLib2Impl *This, int filesize)
4549 {
4550 ICreateTypeInfo2Impl *typeinfo;
4551 HRESULT hres;
4552
4553 for (typeinfo = This->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
4554 typeinfo->typeinfo->memoffset = filesize;
4555
4556 hres = ICreateTypeInfo2_fnLayOut(&typeinfo->ICreateTypeInfo2_iface);
4557 if(FAILED(hres))
4558 return hres;
4559
4560 if (typeinfo->typedata)
4561 filesize += typeinfo->typedata->next->u.val
4562 + cti2_get_var_count(typeinfo->typeinfo) * 12
4563 + cti2_get_func_count(typeinfo->typeinfo) * 12 + 4;
4564 }
4565
4566 return S_OK;
4567 }
4568
4569 static int ctl2_finalize_segment(ICreateTypeLib2Impl *This, int filepos, int segment)
4570 {
4571 if (This->typelib_segdir[segment].length) {
4572 This->typelib_segdir[segment].offset = filepos;
4573 } else {
4574 This->typelib_segdir[segment].offset = -1;
4575 }
4576
4577 return This->typelib_segdir[segment].length;
4578 }
4579
4580 static int ctl2_write_typeinfos(ICreateTypeLib2Impl *This, HANDLE hFile)
4581 {
4582 ICreateTypeInfo2Impl *typeinfo;
4583
4584 for (typeinfo = This->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
4585 CyclicList *iter;
4586 int offset = 0;
4587
4588 if (!typeinfo->typedata) continue;
4589
4590 iter = typeinfo->typedata->next;
4591 if (!ctl2_write_chunk(hFile, &iter->u.val, sizeof(int)))
4592 return 0;
4593 for(iter=iter->next; iter!=typeinfo->typedata->next; iter=iter->next) {
4594 if(iter->type == CyclicListFunc) {
4595 DWORD cust_size = iter->u.func->nrargs * (iter->u.func->FKCCIC&0x1000 ? 16 : 12);
4596 if(!ctl2_write_chunk(hFile, iter->u.func, (iter->u.func->Info&0xffff)-cust_size))
4597 return 0;
4598 if(!ctl2_write_chunk(hFile, iter->u.func->oArgCustData, cust_size))
4599 return 0;
4600 }else if (!ctl2_write_chunk(hFile, iter->u.data, ctl2_get_record_size(iter))) {
4601 return 0;
4602 }
4603 }
4604
4605 for(iter=typeinfo->typedata->next->next; iter!=typeinfo->typedata->next; iter=iter->next)
4606 if (!ctl2_write_chunk(hFile, &iter->indice, sizeof(int)))
4607 return 0;
4608
4609 for(iter=typeinfo->typedata->next->next; iter!=typeinfo->typedata->next; iter=iter->next)
4610 if (!ctl2_write_chunk(hFile, &iter->name, sizeof(int)))
4611 return 0;
4612
4613 for(iter=typeinfo->typedata->next->next; iter!=typeinfo->typedata->next; iter=iter->next) {
4614 if (!ctl2_write_chunk(hFile, &offset, sizeof(int)))
4615 return 0;
4616 offset += ctl2_get_record_size(iter);
4617 }
4618 }
4619 return 1;
4620 }
4621
4622 /******************************************************************************
4623 * ICreateTypeLib2_SaveAllChanges {OLEAUT32}
4624 */
4625 static HRESULT WINAPI ICreateTypeLib2_fnSaveAllChanges(ICreateTypeLib2 * iface)
4626 {
4627 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4628 int retval;
4629 int filepos;
4630 HANDLE hFile;
4631 HRESULT hres;
4632
4633 TRACE("(%p)\n", iface);
4634
4635 retval = TYPE_E_IOERROR;
4636
4637 hFile = CreateFileW(This->filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
4638 if (hFile == INVALID_HANDLE_VALUE) return retval;
4639
4640 filepos = sizeof(MSFT_Header) + sizeof(MSFT_SegDir);
4641 filepos += This->typelib_header.nrtypeinfos * 4;
4642
4643 filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_TYPEINFO);
4644 filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_GUIDHASH);
4645 filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_GUID);
4646 filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_REFERENCES);
4647 filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_IMPORTINFO);
4648 filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_IMPORTFILES);
4649 filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_NAMEHASH);
4650 filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_NAME);
4651 filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_STRING);
4652 filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_TYPEDESC);
4653 filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_ARRAYDESC);
4654 filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_CUSTDATA);
4655 filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_CUSTDATAGUID);
4656
4657 hres = ctl2_finalize_typeinfos(This, filepos);
4658 if(FAILED(hres)) {
4659 CloseHandle(hFile);
4660 return hres;
4661 }
4662
4663 if (!ctl2_write_chunk(hFile, &This->typelib_header, sizeof(This->typelib_header))) return retval;
4664 if (This->typelib_header.varflags & HELPDLLFLAG)
4665 if (!ctl2_write_chunk(hFile, &This->helpStringDll, sizeof(This->helpStringDll))) return retval;
4666 if (!ctl2_write_chunk(hFile, This->typelib_typeinfo_offsets, This->typelib_header.nrtypeinfos * 4)) return retval;
4667 if (!ctl2_write_chunk(hFile, This->typelib_segdir, sizeof(This->typelib_segdir))) return retval;
4668 if (!ctl2_write_segment(This, hFile, MSFT_SEG_TYPEINFO )) return retval;
4669 if (!ctl2_write_segment(This, hFile, MSFT_SEG_GUIDHASH )) return retval;
4670 if (!ctl2_write_segment(This, hFile, MSFT_SEG_GUID )) return retval;
4671 if (!ctl2_write_segment(This, hFile, MSFT_SEG_REFERENCES )) return retval;
4672 if (!ctl2_write_segment(This, hFile, MSFT_SEG_IMPORTINFO )) return retval;
4673 if (!ctl2_write_segment(This, hFile, MSFT_SEG_IMPORTFILES )) return retval;
4674 if (!ctl2_write_segment(This, hFile, MSFT_SEG_NAMEHASH )) return retval;
4675 if (!ctl2_write_segment(This, hFile, MSFT_SEG_NAME )) return retval;
4676 if (!ctl2_write_segment(This, hFile, MSFT_SEG_STRING )) return retval;
4677 if (!ctl2_write_segment(This, hFile, MSFT_SEG_TYPEDESC )) return retval;
4678 if (!ctl2_write_segment(This, hFile, MSFT_SEG_ARRAYDESC )) return retval;
4679 if (!ctl2_write_segment(This, hFile, MSFT_SEG_CUSTDATA )) return retval;
4680 if (!ctl2_write_segment(This, hFile, MSFT_SEG_CUSTDATAGUID)) return retval;
4681
4682 if (!ctl2_write_typeinfos(This, hFile)) return retval;
4683
4684 if (!CloseHandle(hFile)) return retval;
4685
4686 return S_OK;
4687 }
4688
4689
4690 /******************************************************************************
4691 * ICreateTypeLib2_DeleteTypeInfo {OLEAUT32}
4692 *
4693 * Deletes a named TypeInfo from a type library.
4694 *
4695 * RETURNS
4696 *
4697 * Success: S_OK
4698 * Failure: E_OUTOFMEMORY or E_INVALIDARG.
4699 */
4700 static HRESULT WINAPI ICreateTypeLib2_fnDeleteTypeInfo(
4701 ICreateTypeLib2 * iface, /* [I] The type library to delete from. */
4702 LPOLESTR szName) /* [I] The name of the typeinfo to delete. */
4703 {
4704 FIXME("(%p,%s), stub!\n", iface, debugstr_w(szName));
4705 return E_OUTOFMEMORY;
4706 }
4707
4708 /******************************************************************************
4709 * ICreateTypeLib2_SetCustData {OLEAUT32}
4710 *
4711 * Sets custom data for a type library.
4712 *
4713 * RETURNS
4714 *
4715 * Success: S_OK
4716 * Failure: E_OUTOFMEMORY or E_INVALIDARG.
4717 */
4718 static HRESULT WINAPI ICreateTypeLib2_fnSetCustData(
4719 ICreateTypeLib2 * iface, /* [I] The type library to store the custom data in. */
4720 REFGUID guid, /* [I] The GUID used as a key to retrieve the custom data. */
4721 VARIANT *pVarVal) /* [I] The custom data itself. */
4722 {
4723 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4724
4725 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(guid), pVarVal);
4726
4727 return ctl2_set_custdata(This, guid, pVarVal, &This->typelib_header.CustomDataOffset);
4728 }
4729
4730 /******************************************************************************
4731 * ICreateTypeLib2_SetHelpStringContext {OLEAUT32}
4732 *
4733 * Sets a context number for the library help string.
4734 *
4735 * PARAMS
4736 * iface [I] The type library to set the help string context for.
4737 * dwContext [I] The help string context.
4738 *
4739 * RETURNS
4740 * Success: S_OK
4741 * Failure: E_OUTOFMEMORY or E_INVALIDARG.
4742 */
4743 static
4744 HRESULT WINAPI ICreateTypeLib2_fnSetHelpStringContext(ICreateTypeLib2 * iface,
4745 ULONG dwContext)
4746 {
4747 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4748
4749 TRACE("(%p,%d)\n", iface, dwContext);
4750
4751 This->typelib_header.helpstringcontext = dwContext;
4752 return S_OK;
4753 }
4754
4755 /******************************************************************************
4756 * ICreateTypeLib2_SetHelpStringDll {OLEAUT32}
4757 *
4758 * Set the DLL used to look up localized help strings.
4759 *
4760 * PARAMS
4761 * iface [I] The type library to set the help DLL for.
4762 * szDllName [I] The name of the help DLL.
4763 *
4764 * RETURNS
4765 * Success: S_OK
4766 * Failure: E_OUTOFMEMORY or E_INVALIDARG.
4767 */
4768 static
4769 HRESULT WINAPI ICreateTypeLib2_fnSetHelpStringDll(ICreateTypeLib2 * iface,
4770 LPOLESTR szDllName)
4771 {
4772 ICreateTypeLib2Impl *This = impl_from_ICreateTypeLib2(iface);
4773 int offset;
4774
4775 TRACE("(%p,%s)\n", iface, debugstr_w(szDllName));
4776 if (!szDllName)
4777 return E_INVALIDARG;
4778
4779 offset = ctl2_alloc_string(This, szDllName);
4780 if (offset == -1)
4781 return E_OUTOFMEMORY;
4782 This->typelib_header.varflags |= HELPDLLFLAG;
4783 This->helpStringDll = offset;
4784 return S_OK;
4785 }
4786
4787 /*================== ITypeLib2 Implementation ===================================*/
4788
4789 /******************************************************************************
4790 * ITypeLib2_QueryInterface {OLEAUT32}
4791 */
4792 static HRESULT WINAPI ITypeLib2_fnQueryInterface(ITypeLib2 * iface, REFIID riid, LPVOID * ppv)
4793 {
4794 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4795
4796 return ICreateTypeLib2_QueryInterface(&This->ICreateTypeLib2_iface, riid, ppv);
4797 }
4798
4799 /******************************************************************************
4800 * ITypeLib2_AddRef {OLEAUT32}
4801 */
4802 static ULONG WINAPI ITypeLib2_fnAddRef(ITypeLib2 * iface)
4803 {
4804 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4805
4806 return ICreateTypeLib2_AddRef(&This->ICreateTypeLib2_iface);
4807 }
4808
4809 /******************************************************************************
4810 * ITypeLib2_Release {OLEAUT32}
4811 */
4812 static ULONG WINAPI ITypeLib2_fnRelease(ITypeLib2 * iface)
4813 {
4814 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4815
4816 return ICreateTypeLib2_Release(&This->ICreateTypeLib2_iface);
4817 }
4818
4819 /******************************************************************************
4820 * ITypeLib2_GetTypeInfoCount {OLEAUT32}
4821 */
4822 static UINT WINAPI ITypeLib2_fnGetTypeInfoCount(
4823 ITypeLib2 * iface)
4824 {
4825 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4826
4827 TRACE("(%p)\n", iface);
4828
4829 return This->typelib_header.nrtypeinfos;
4830 }
4831
4832 /******************************************************************************
4833 * ITypeLib2_GetTypeInfo {OLEAUT32}
4834 */
4835 static HRESULT WINAPI ITypeLib2_fnGetTypeInfo(
4836 ITypeLib2 * iface,
4837 UINT index,
4838 ITypeInfo** ppTInfo)
4839 {
4840 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4841
4842 TRACE("(%p,%d,%p)\n", iface, index, ppTInfo);
4843
4844 if (!ppTInfo) return E_INVALIDARG;
4845
4846 if (index >= This->typelib_header.nrtypeinfos) {
4847 return TYPE_E_ELEMENTNOTFOUND;
4848 }
4849
4850 return ctl2_find_typeinfo_from_offset(This, This->typelib_typeinfo_offsets[index], ppTInfo);
4851 }
4852
4853 /******************************************************************************
4854 * ITypeLib2_GetTypeInfoType {OLEAUT32}
4855 */
4856 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoType(
4857 ITypeLib2 * iface,
4858 UINT index,
4859 TYPEKIND* kind)
4860 {
4861 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4862
4863 TRACE("(%p,%d,%p)\n", iface, index, kind);
4864
4865 if (!kind) return E_INVALIDARG;
4866
4867 if (index >= This->typelib_header.nrtypeinfos) {
4868 return TYPE_E_ELEMENTNOTFOUND;
4869 }
4870
4871 *kind = (This->typelib_segment_data[MSFT_SEG_TYPEINFO][This->typelib_typeinfo_offsets[index]]) & 0xF;
4872
4873 return S_OK;
4874 }
4875
4876 /******************************************************************************
4877 * ITypeLib2_GetTypeInfoOfGuid {OLEAUT32}
4878 */
4879 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoOfGuid(
4880 ITypeLib2 * iface,
4881 REFGUID guid,
4882 ITypeInfo** ppTinfo)
4883 {
4884 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4885
4886 int guidoffset;
4887 int typeinfo;
4888
4889 TRACE("(%p,%s,%p)\n", iface, debugstr_guid(guid), ppTinfo);
4890
4891 guidoffset = ctl2_find_guid(This, ctl2_hash_guid(guid), guid);
4892 if (guidoffset == -1) return TYPE_E_ELEMENTNOTFOUND;
4893
4894 typeinfo = ((MSFT_GuidEntry *)&This->typelib_segment_data[MSFT_SEG_GUID][guidoffset])->hreftype;
4895 if (typeinfo < 0) return TYPE_E_ELEMENTNOTFOUND;
4896
4897 return ctl2_find_typeinfo_from_offset(This, typeinfo, ppTinfo);
4898 }
4899
4900 /******************************************************************************
4901 * ITypeLib2_GetLibAttr {OLEAUT32}
4902 */
4903 static HRESULT WINAPI ITypeLib2_fnGetLibAttr(
4904 ITypeLib2 * iface,
4905 TLIBATTR** ppTLibAttr)
4906 {
4907 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4908
4909 TRACE("(%p,%p)\n", This, ppTLibAttr);
4910
4911 if(!ppTLibAttr)
4912 return E_INVALIDARG;
4913
4914 *ppTLibAttr = heap_alloc_zero(sizeof(TLIBATTR));
4915 if(!*ppTLibAttr)
4916 return E_OUTOFMEMORY;
4917
4918 if(This->typelib_header.posguid != -1) {
4919 MSFT_GuidEntry *guid;
4920
4921 guid = (MSFT_GuidEntry*)&This->typelib_segment_data[MSFT_SEG_GUID][This->typelib_header.posguid];
4922 (*ppTLibAttr)->guid = guid->guid;
4923 }
4924
4925 (*ppTLibAttr)->lcid = This->typelib_header.lcid;
4926 (*ppTLibAttr)->syskind = ctl2_get_syskind(This);
4927 (*ppTLibAttr)->wMajorVerNum = LOWORD(This->typelib_header.version);
4928 (*ppTLibAttr)->wMinorVerNum = HIWORD(This->typelib_header.version);
4929 (*ppTLibAttr)->wLibFlags = This->typelib_header.flags;
4930 return S_OK;
4931 }
4932
4933 /******************************************************************************
4934 * ITypeLib2_GetTypeComp {OLEAUT32}
4935 */
4936 static HRESULT WINAPI ITypeLib2_fnGetTypeComp(
4937 ITypeLib2 * iface,
4938 ITypeComp** ppTComp)
4939 {
4940 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4941
4942 FIXME("(%p,%p), stub!\n", This, ppTComp);
4943
4944 return E_OUTOFMEMORY;
4945 }
4946
4947 /******************************************************************************
4948 * ITypeLib2_GetDocumentation {OLEAUT32}
4949 */
4950 static HRESULT WINAPI ITypeLib2_fnGetDocumentation(
4951 ITypeLib2 * iface,
4952 INT index,
4953 BSTR* pBstrName,
4954 BSTR* pBstrDocString,
4955 DWORD* pdwHelpContext,
4956 BSTR* pBstrHelpFile)
4957 {
4958 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4959 WCHAR *string;
4960
4961 TRACE("(%p,%d,%p,%p,%p,%p)\n", This, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
4962
4963 if(index != -1) {
4964 ICreateTypeInfo2Impl *iter;
4965
4966 for(iter=This->typeinfos; iter!=NULL && index!=0; iter=iter->next_typeinfo)
4967 index--;
4968
4969 if(!iter)
4970 return TYPE_E_ELEMENTNOTFOUND;
4971
4972 return ITypeInfo2_GetDocumentation(&iter->ITypeInfo2_iface,
4973 -1, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
4974 }
4975
4976 if(pBstrName) {
4977 if(This->typelib_header.NameOffset == -1)
4978 *pBstrName = NULL;
4979 else {
4980 MSFT_NameIntro *name = (MSFT_NameIntro*)&This->
4981 typelib_segment_data[MSFT_SEG_NAME][This->typelib_header.NameOffset];
4982
4983 ctl2_decode_name((char*)&name->namelen, &string);
4984
4985 *pBstrName = SysAllocString(string);
4986 if(!*pBstrName)
4987 return E_OUTOFMEMORY;
4988 }
4989 }
4990
4991 if(pBstrDocString) {
4992 if(This->typelib_header.helpstring == -1)
4993 *pBstrDocString = NULL;
4994 else {
4995 ctl2_decode_string(&This->typelib_segment_data[MSFT_SEG_STRING][This->typelib_header.helpstring], &string);
4996
4997 *pBstrDocString = SysAllocString(string);
4998 if(!*pBstrDocString) {
4999 if(pBstrName) SysFreeString(*pBstrName);
5000 return E_OUTOFMEMORY;
5001 }
5002 }
5003 }
5004
5005 if(pdwHelpContext)
5006 *pdwHelpContext = This->typelib_header.helpcontext;
5007
5008 if(pBstrHelpFile) {
5009 if(This->typelib_header.helpfile == -1)
5010 *pBstrHelpFile = NULL;
5011 else {
5012 ctl2_decode_string(&This->typelib_segment_data[MSFT_SEG_STRING][This->typelib_header.helpfile], &string);
5013
5014 *pBstrHelpFile = SysAllocString(string);
5015 if(!*pBstrHelpFile) {
5016 if(pBstrName) SysFreeString(*pBstrName);
5017 if(pBstrDocString) SysFreeString(*pBstrDocString);
5018 return E_OUTOFMEMORY;
5019 }
5020 }
5021 }
5022
5023 return S_OK;
5024 }
5025
5026 /******************************************************************************
5027 * ITypeLib2_IsName {OLEAUT32}
5028 */
5029 static HRESULT WINAPI ITypeLib2_fnIsName(
5030 ITypeLib2 * iface,
5031 LPOLESTR szNameBuf,
5032 ULONG lHashVal,
5033 BOOL* pfName)
5034 {
5035 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
5036
5037 char *encoded_name;
5038 int nameoffset;
5039 MSFT_NameIntro *nameintro;
5040
5041 TRACE("(%p,%s,%x,%p)\n", iface, debugstr_w(szNameBuf), lHashVal, pfName);
5042
5043 ctl2_encode_name(This, szNameBuf, &encoded_name);
5044 nameoffset = ctl2_find_name(This, encoded_name);
5045
5046 *pfName = 0;
5047
5048 if (nameoffset == -1) return S_OK;
5049
5050 nameintro = (MSFT_NameIntro *)(&This->typelib_segment_data[MSFT_SEG_NAME][nameoffset]);
5051 if (nameintro->hreftype == -1) return S_OK;
5052
5053 *pfName = 1;
5054
5055 FIXME("Should be decoding our copy of the name over szNameBuf.\n");
5056
5057 return S_OK;
5058 }
5059
5060 /******************************************************************************
5061 * ITypeLib2_FindName {OLEAUT32}
5062 */
5063 static HRESULT WINAPI ITypeLib2_fnFindName(
5064 ITypeLib2 * iface,
5065 LPOLESTR szNameBuf,
5066 ULONG lHashVal,
5067 ITypeInfo** ppTInfo,
5068 MEMBERID* rgMemId,
5069 USHORT* pcFound)
5070 {
5071 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
5072
5073 FIXME("(%p,%s,%x,%p,%p,%p), stub!\n", This, debugstr_w(szNameBuf), lHashVal, ppTInfo, rgMemId, pcFound);
5074
5075 return E_OUTOFMEMORY;
5076 }
5077
5078 /******************************************************************************
5079 * ITypeLib2_ReleaseTLibAttr {OLEAUT32}
5080 */
5081 static void WINAPI ITypeLib2_fnReleaseTLibAttr(
5082 ITypeLib2 * iface,
5083 TLIBATTR* attr)
5084 {
5085 TRACE("(%p,%p)\n", iface, attr);
5086 heap_free(attr);
5087 }
5088
5089 /******************************************************************************
5090 * ICreateTypeLib2_GetCustData {OLEAUT32}
5091 *
5092 * Retrieves a custom data value stored on a type library.
5093 *
5094 * RETURNS
5095 *
5096 * Success: S_OK
5097 * Failure: E_OUTOFMEMORY or E_INVALIDARG.
5098 */
5099 static HRESULT WINAPI ITypeLib2_fnGetCustData(
5100 ITypeLib2 * iface, /* [I] The type library in which to find the custom data. */
5101 REFGUID guid, /* [I] The GUID under which the custom data is stored. */
5102 VARIANT* pVarVal) /* [O] The custom data. */
5103 {
5104 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
5105
5106 FIXME("(%p,%s,%p), stub!\n", This, debugstr_guid(guid), pVarVal);
5107
5108 return E_OUTOFMEMORY;
5109 }
5110
5111 /******************************************************************************
5112 * ICreateTypeLib2_GetLibStatistics {OLEAUT32}
5113 *
5114 * Retrieves some statistics about names in a type library, supposedly for
5115 * hash table optimization purposes.
5116 *
5117 * RETURNS
5118 *
5119 * Success: S_OK
5120 * Failure: E_OUTOFMEMORY or E_INVALIDARG.
5121 */
5122 static HRESULT WINAPI ITypeLib2_fnGetLibStatistics(
5123 ITypeLib2 * iface, /* [I] The type library to get statistics about. */
5124 ULONG* pcUniqueNames, /* [O] The number of unique names in the type library. */
5125 ULONG* pcchUniqueNames) /* [O] The number of changed (?) characters in names in the type library. */
5126 {
5127 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
5128
5129 FIXME("(%p,%p,%p), stub!\n", This, pcUniqueNames, pcchUniqueNames);
5130
5131 return E_OUTOFMEMORY;
5132 }
5133
5134 /******************************************************************************
5135 * ICreateTypeLib2_GetDocumentation2 {OLEAUT32}
5136 *
5137 * Obtain locale-aware help string information.
5138 *
5139 * RETURNS
5140 *
5141 * Success: S_OK
5142 * Failure: STG_E_INSUFFICIENTMEMORY or E_INVALIDARG.
5143 */
5144 static HRESULT WINAPI ITypeLib2_fnGetDocumentation2(
5145 ITypeLib2 * iface,
5146 INT index,
5147 LCID lcid,
5148 BSTR* pbstrHelpString,
5149 DWORD* pdwHelpStringContext,
5150 BSTR* pbstrHelpStringDll)
5151 {
5152 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
5153
5154 FIXME("(%p,%d,%d,%p,%p,%p), stub!\n", This, index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll);
5155
5156 return E_OUTOFMEMORY;
5157 }
5158
5159 /******************************************************************************
5160 * ICreateTypeLib2_GetAllCustData {OLEAUT32}
5161 *
5162 * Retrieve all of the custom data for a type library.
5163 *
5164 * RETURNS
5165 *
5166 * Success: S_OK
5167 * Failure: E_OUTOFMEMORY or E_INVALIDARG.
5168 */
5169 static HRESULT WINAPI ITypeLib2_fnGetAllCustData(
5170 ITypeLib2 * iface, /* [I] The type library in which to find the custom data. */
5171 CUSTDATA* pCustData) /* [O] The structure in which to place the custom data. */
5172 {
5173 ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
5174
5175 FIXME("(%p,%p), stub!\n", This, pCustData);
5176
5177 return E_OUTOFMEMORY;
5178 }
5179
5180
5181 /*================== ICreateTypeLib2 & ITypeLib2 VTABLEs And Creation ===================================*/
5182
5183 static const ICreateTypeLib2Vtbl ctypelib2vt =
5184 {
5185
5186 ICreateTypeLib2_fnQueryInterface,
5187 ICreateTypeLib2_fnAddRef,
5188 ICreateTypeLib2_fnRelease,
5189
5190 ICreateTypeLib2_fnCreateTypeInfo,
5191 ICreateTypeLib2_fnSetName,
5192 ICreateTypeLib2_fnSetVersion,
5193 ICreateTypeLib2_fnSetGuid,
5194 ICreateTypeLib2_fnSetDocString,
5195 ICreateTypeLib2_fnSetHelpFileName,
5196 ICreateTypeLib2_fnSetHelpContext,
5197 ICreateTypeLib2_fnSetLcid,
5198 ICreateTypeLib2_fnSetLibFlags,
5199 ICreateTypeLib2_fnSaveAllChanges,
5200
5201 ICreateTypeLib2_fnDeleteTypeInfo,
5202 ICreateTypeLib2_fnSetCustData,
5203 ICreateTypeLib2_fnSetHelpStringContext,
5204 ICreateTypeLib2_fnSetHelpStringDll
5205 };
5206
5207 static const ITypeLib2Vtbl typelib2vt =
5208 {
5209
5210 ITypeLib2_fnQueryInterface,
5211 ITypeLib2_fnAddRef,
5212 ITypeLib2_fnRelease,
5213
5214 ITypeLib2_fnGetTypeInfoCount,
5215 ITypeLib2_fnGetTypeInfo,
5216 ITypeLib2_fnGetTypeInfoType,
5217 ITypeLib2_fnGetTypeInfoOfGuid,
5218 ITypeLib2_fnGetLibAttr,
5219 ITypeLib2_fnGetTypeComp,
5220 ITypeLib2_fnGetDocumentation,
5221 ITypeLib2_fnIsName,
5222 ITypeLib2_fnFindName,
5223 ITypeLib2_fnReleaseTLibAttr,
5224
5225 ITypeLib2_fnGetCustData,
5226 ITypeLib2_fnGetLibStatistics,
5227 ITypeLib2_fnGetDocumentation2,
5228 ITypeLib2_fnGetAllCustData,
5229 };
5230
5231 static ICreateTypeLib2 *ICreateTypeLib2_Constructor(SYSKIND syskind, LPCOLESTR filename)
5232 {
5233 ICreateTypeLib2Impl *create_tlib2;
5234 int failed = 0;
5235
5236 TRACE("Constructing ICreateTypeLib2 (%d, %s)\n", syskind, debugstr_w(filename));
5237
5238 create_tlib2 = heap_alloc_zero(sizeof(ICreateTypeLib2Impl));
5239 if (!create_tlib2) return NULL;
5240
5241 create_tlib2->filename = SysAllocString(filename);
5242 if (!create_tlib2->filename) {
5243 heap_free(create_tlib2);
5244 return NULL;
5245 }
5246
5247 ctl2_init_header(create_tlib2);
5248 ctl2_init_segdir(create_tlib2);
5249
5250 create_tlib2->typelib_header.varflags |= syskind;
5251
5252 /*
5253 * The following two calls return an offset or -1 if out of memory. We
5254 * specifically need an offset of 0, however, so...
5255 */
5256 if (ctl2_alloc_segment(create_tlib2, MSFT_SEG_GUIDHASH, 0x80, 0x80) == 0)
5257 {
5258 create_tlib2->typelib_guidhash_segment = (int *)create_tlib2->typelib_segment_data[MSFT_SEG_GUIDHASH];
5259 memset(create_tlib2->typelib_guidhash_segment, 0xff, 0x80);
5260 }
5261 else
5262 failed = 1;
5263
5264 if (ctl2_alloc_segment(create_tlib2, MSFT_SEG_NAMEHASH, 0x200, 0x200) == 0)
5265 {
5266 create_tlib2->typelib_namehash_segment = (int *)create_tlib2->typelib_segment_data[MSFT_SEG_NAMEHASH];
5267 memset(create_tlib2->typelib_namehash_segment, 0xff, 0x200);
5268 }
5269 else
5270 failed = 1;
5271
5272 create_tlib2->ICreateTypeLib2_iface.lpVtbl = &ctypelib2vt;
5273 create_tlib2->ITypeLib2_iface.lpVtbl = &typelib2vt;
5274 create_tlib2->ref = 1;
5275
5276 if (failed) {
5277 ICreateTypeLib2_fnRelease(&create_tlib2->ICreateTypeLib2_iface);
5278 heap_free(create_tlib2);
5279 return NULL;
5280 }
5281
5282 return &create_tlib2->ICreateTypeLib2_iface;
5283 }
5284
5285 /******************************************************************************
5286 * CreateTypeLib2 [OLEAUT32.180]
5287 *
5288 * Obtains an ICreateTypeLib2 object for creating a new-style (MSFT) type
5289 * library.
5290 *
5291 * NOTES
5292 *
5293 * See also CreateTypeLib.
5294 *
5295 * RETURNS
5296 * Success: S_OK
5297 * Failure: Status
5298 */
5299 HRESULT WINAPI CreateTypeLib2(
5300 SYSKIND syskind, /* [I] System type library is for */
5301 LPCOLESTR szFile, /* [I] Type library file name */
5302 ICreateTypeLib2** ppctlib) /* [O] Storage for object returned */
5303 {
5304 TRACE("(%d,%s,%p)\n", syskind, debugstr_w(szFile), ppctlib);
5305
5306 if (!szFile) return E_INVALIDARG;
5307 *ppctlib = ICreateTypeLib2_Constructor(syskind, szFile);
5308 return (*ppctlib)? S_OK: E_OUTOFMEMORY;
5309 }
5310
5311 /******************************************************************************
5312 * ClearCustData (OLEAUT32.171)
5313 *
5314 * Clear a custom data types' data.
5315 *
5316 * PARAMS
5317 * lpCust [I] The custom data type instance
5318 *
5319 * RETURNS
5320 * Nothing.
5321 */
5322 void WINAPI ClearCustData(LPCUSTDATA lpCust)
5323 {
5324 if (lpCust && lpCust->cCustData)
5325 {
5326 if (lpCust->prgCustData)
5327 {
5328 DWORD i;
5329
5330 for (i = 0; i < lpCust->cCustData; i++)
5331 VariantClear(&lpCust->prgCustData[i].varValue);
5332
5333 /* FIXME - Should be using a per-thread IMalloc */
5334 heap_free(lpCust->prgCustData);
5335 lpCust->prgCustData = NULL;
5336 }
5337 lpCust->cCustData = 0;
5338 }
5339 }
Maarten's multimedia branch