sync with trunk r46493
[reactos.git] / dll / win32 / oleaut32 / typelib2.c
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 struct tagCyclicList {
122 struct tagCyclicList *next;
123 int indice;
124 int name;
125
126 union {
127 int val;
128 int *data;
129 }u;
130 } CyclicList;
131
132 enum MSFT_segment_index {
133 MSFT_SEG_TYPEINFO = 0, /* type information */
134 MSFT_SEG_IMPORTINFO, /* import information */
135 MSFT_SEG_IMPORTFILES, /* import filenames */
136 MSFT_SEG_REFERENCES, /* references (?) */
137 MSFT_SEG_GUIDHASH, /* hash table for guids? */
138 MSFT_SEG_GUID, /* guid storage */
139 MSFT_SEG_NAMEHASH, /* hash table for names */
140 MSFT_SEG_NAME, /* name storage */
141 MSFT_SEG_STRING, /* string storage */
142 MSFT_SEG_TYPEDESC, /* type descriptions */
143 MSFT_SEG_ARRAYDESC, /* array descriptions */
144 MSFT_SEG_CUSTDATA, /* custom data */
145 MSFT_SEG_CUSTDATAGUID, /* custom data guids */
146 MSFT_SEG_UNKNOWN, /* ??? */
147 MSFT_SEG_UNKNOWN2, /* ??? */
148 MSFT_SEG_MAX /* total number of segments */
149 };
150
151 typedef struct tagMSFT_ImpFile {
152 int guid;
153 LCID lcid;
154 int version;
155 char filename[0]; /* preceded by two bytes of encoded (length << 2) + flags in the low two bits. */
156 } MSFT_ImpFile;
157
158 typedef struct tagICreateTypeLib2Impl
159 {
160 const ICreateTypeLib2Vtbl *lpVtbl;
161 const ITypeLib2Vtbl *lpVtblTypeLib2;
162
163 LONG ref;
164
165 WCHAR *filename;
166
167 MSFT_Header typelib_header;
168 INT helpStringDll;
169 MSFT_pSeg typelib_segdir[MSFT_SEG_MAX];
170 char *typelib_segment_data[MSFT_SEG_MAX];
171 int typelib_segment_block_length[MSFT_SEG_MAX];
172
173 int typelib_guids; /* Number of defined typelib guids */
174 int typeinfo_guids; /* Number of defined typeinfo guids */
175
176 INT typelib_typeinfo_offsets[0x200]; /* Hope that's enough. */
177
178 INT *typelib_namehash_segment;
179 INT *typelib_guidhash_segment;
180
181 struct tagICreateTypeInfo2Impl *typeinfos;
182 struct tagICreateTypeInfo2Impl *last_typeinfo;
183 } ICreateTypeLib2Impl;
184
185 static inline ICreateTypeLib2Impl *impl_from_ITypeLib2( ITypeLib2 *iface )
186 {
187 return (ICreateTypeLib2Impl *)((char*)iface - FIELD_OFFSET(ICreateTypeLib2Impl, lpVtblTypeLib2));
188 }
189
190 typedef struct tagICreateTypeInfo2Impl
191 {
192 const ICreateTypeInfo2Vtbl *lpVtbl;
193 const ITypeInfo2Vtbl *lpVtblTypeInfo2;
194
195 LONG ref;
196
197 ICreateTypeLib2Impl *typelib;
198 MSFT_TypeInfoBase *typeinfo;
199
200 struct tagCyclicList *typedata; /* tail of cyclic list */
201
202 TYPEKIND typekind;
203 int datawidth;
204
205 struct tagICreateTypeInfo2Impl *next_typeinfo;
206 struct tagICreateTypeInfo2Impl *dual;
207 } ICreateTypeInfo2Impl;
208
209 static inline ICreateTypeInfo2Impl *impl_from_ITypeInfo2( ITypeInfo2 *iface )
210 {
211 return (ICreateTypeInfo2Impl *)((char*)iface - FIELD_OFFSET(ICreateTypeInfo2Impl, lpVtblTypeInfo2));
212 }
213
214 static ULONG WINAPI ICreateTypeLib2_fnRelease(ICreateTypeLib2 *iface);
215
216
217 /*================== Internal functions ===================================*/
218
219 /****************************************************************************
220 * ctl2_init_header
221 *
222 * Initializes the type library header of a new typelib.
223 */
224 static void ctl2_init_header(
225 ICreateTypeLib2Impl *This) /* [I] The typelib to initialize. */
226 {
227 This->typelib_header.magic1 = 0x5446534d;
228 This->typelib_header.magic2 = 0x00010002;
229 This->typelib_header.posguid = -1;
230 This->typelib_header.lcid = This->typelib_header.lcid2 = GetUserDefaultLCID();
231 This->typelib_header.varflags = 0x40;
232 This->typelib_header.version = 0;
233 This->typelib_header.flags = 0;
234 This->typelib_header.nrtypeinfos = 0;
235 This->typelib_header.helpstring = -1;
236 This->typelib_header.helpstringcontext = 0;
237 This->typelib_header.helpcontext = 0;
238 This->typelib_header.nametablecount = 0;
239 This->typelib_header.nametablechars = 0;
240 This->typelib_header.NameOffset = -1;
241 This->typelib_header.helpfile = -1;
242 This->typelib_header.CustomDataOffset = -1;
243 This->typelib_header.res44 = 0x20;
244 This->typelib_header.res48 = 0x80;
245 This->typelib_header.dispatchpos = -1;
246 This->typelib_header.nimpinfos = 0;
247 This->helpStringDll = -1;
248 }
249
250 /****************************************************************************
251 * ctl2_init_segdir
252 *
253 * Initializes the segment directory of a new typelib.
254 */
255 static void ctl2_init_segdir(
256 ICreateTypeLib2Impl *This) /* [I] The typelib to initialize. */
257 {
258 int i;
259 MSFT_pSeg *segdir;
260
261 segdir = &This->typelib_segdir[MSFT_SEG_TYPEINFO];
262
263 for (i = 0; i < 15; i++) {
264 segdir[i].offset = -1;
265 segdir[i].length = 0;
266 segdir[i].res08 = -1;
267 segdir[i].res0c = 0x0f;
268 }
269 }
270
271 /****************************************************************************
272 * ctl2_hash_guid
273 *
274 * Generates a hash key from a GUID.
275 *
276 * RETURNS
277 *
278 * The hash key for the GUID.
279 */
280 static int ctl2_hash_guid(
281 REFGUID guid) /* [I] The guid to find. */
282 {
283 int hash;
284 int i;
285
286 hash = 0;
287 for (i = 0; i < 8; i ++) {
288 hash ^= ((const short *)guid)[i];
289 }
290
291 return hash & 0x1f;
292 }
293
294 /****************************************************************************
295 * ctl2_find_guid
296 *
297 * Locates a guid in a type library.
298 *
299 * RETURNS
300 *
301 * The offset into the GUID segment of the guid, or -1 if not found.
302 */
303 static int ctl2_find_guid(
304 ICreateTypeLib2Impl *This, /* [I] The typelib to operate against. */
305 int hash_key, /* [I] The hash key for the guid. */
306 REFGUID guid) /* [I] The guid to find. */
307 {
308 int offset;
309 MSFT_GuidEntry *guidentry;
310
311 offset = This->typelib_guidhash_segment[hash_key];
312 while (offset != -1) {
313 guidentry = (MSFT_GuidEntry *)&This->typelib_segment_data[MSFT_SEG_GUID][offset];
314
315 if (!memcmp(guidentry, guid, sizeof(GUID))) return offset;
316
317 offset = guidentry->next_hash;
318 }
319
320 return offset;
321 }
322
323 /****************************************************************************
324 * ctl2_find_name
325 *
326 * Locates a name in a type library.
327 *
328 * RETURNS
329 *
330 * The offset into the NAME segment of the name, or -1 if not found.
331 *
332 * NOTES
333 *
334 * The name must be encoded as with ctl2_encode_name().
335 */
336 static int ctl2_find_name(
337 ICreateTypeLib2Impl *This, /* [I] The typelib to operate against. */
338 const char *name) /* [I] The encoded name to find. */
339 {
340 int offset;
341 int *namestruct;
342
343 offset = This->typelib_namehash_segment[name[2] & 0x7f];
344 while (offset != -1) {
345 namestruct = (int *)&This->typelib_segment_data[MSFT_SEG_NAME][offset];
346
347 if (!((namestruct[2] ^ *((const int *)name)) & 0xffff00ff)) {
348 /* hash codes and lengths match, final test */
349 if (!strncasecmp(name+4, (void *)(namestruct+3), name[0])) break;
350 }
351
352 /* move to next item in hash bucket */
353 offset = namestruct[1];
354 }
355
356 return offset;
357 }
358
359 /****************************************************************************
360 * ctl2_encode_name
361 *
362 * Encodes a name string to a form suitable for storing into a type library
363 * or comparing to a name stored in a type library.
364 *
365 * RETURNS
366 *
367 * The length of the encoded name, including padding and length+hash fields.
368 *
369 * NOTES
370 *
371 * Will throw an exception if name or result are NULL. Is not multithread
372 * safe in the slightest.
373 */
374 static int ctl2_encode_name(
375 ICreateTypeLib2Impl *This, /* [I] The typelib to operate against (used for LCID only). */
376 const WCHAR *name, /* [I] The name string to encode. */
377 char **result) /* [O] A pointer to a pointer to receive the encoded name. */
378 {
379 int length;
380 static char converted_name[0x104];
381 int offset;
382 int value;
383
384 length = WideCharToMultiByte(CP_ACP, 0, name, strlenW(name), converted_name+4, 0x100, NULL, NULL);
385 converted_name[0] = length & 0xff;
386
387 converted_name[length + 4] = 0;
388
389 converted_name[1] = 0x00;
390
391 value = LHashValOfNameSysA(This->typelib_header.varflags & 0x0f, This->typelib_header.lcid, converted_name + 4);
392
393 converted_name[2] = value;
394 converted_name[3] = value >> 8;
395
396 for (offset = (4 - length) & 3; offset; offset--) converted_name[length + offset + 3] = 0x57;
397
398 *result = converted_name;
399
400 return (length + 7) & ~3;
401 }
402
403 /****************************************************************************
404 * ctl2_decode_name
405 *
406 * Converts string stored in typelib data to unicode.
407 */
408 static void ctl2_decode_name(
409 char *data, /* [I] String to be decoded */
410 WCHAR **string) /* [O] Decoded string */
411 {
412 int i, length;
413 static WCHAR converted_string[0x104];
414
415 length = data[0];
416
417 for(i=0; i<length; i++)
418 converted_string[i] = data[i+4];
419 converted_string[length] = '\0';
420
421 *string = converted_string;
422 }
423
424 /****************************************************************************
425 * ctl2_encode_string
426 *
427 * Encodes a string to a form suitable for storing into a type library or
428 * comparing to a string stored in a type library.
429 *
430 * RETURNS
431 *
432 * The length of the encoded string, including padding and length fields.
433 *
434 * NOTES
435 *
436 * Will throw an exception if string or result are NULL. Is not multithread
437 * safe in the slightest.
438 */
439 static int ctl2_encode_string(
440 ICreateTypeLib2Impl *This, /* [I] The typelib to operate against (not used?). */
441 const WCHAR *string, /* [I] The string to encode. */
442 char **result) /* [O] A pointer to a pointer to receive the encoded string. */
443 {
444 int length;
445 static char converted_string[0x104];
446 int offset;
447
448 length = WideCharToMultiByte(CP_ACP, 0, string, strlenW(string), converted_string+2, 0x102, NULL, NULL);
449 converted_string[0] = length & 0xff;
450 converted_string[1] = (length >> 8) & 0xff;
451
452 for (offset = (4 - (length + 2)) & 3; offset; offset--) converted_string[length + offset + 1] = 0x57;
453
454 *result = converted_string;
455
456 return (length + 5) & ~3;
457 }
458
459 /****************************************************************************
460 * ctl2_decode_string
461 *
462 * Converts string stored in typelib data to unicode.
463 */
464 static void ctl2_decode_string(
465 char *data, /* [I] String to be decoded */
466 WCHAR **string) /* [O] Decoded string */
467 {
468 int i, length;
469 static WCHAR converted_string[0x104];
470
471 length = data[0] + (data[1]<<8);
472 if((length&0x3) == 1)
473 length >>= 2;
474
475 for(i=0; i<length; i++)
476 converted_string[i] = data[i+2];
477 converted_string[length] = '\0';
478
479 *string = converted_string;
480 }
481
482 /****************************************************************************
483 * ctl2_alloc_segment
484 *
485 * Allocates memory from a segment in a type library.
486 *
487 * RETURNS
488 *
489 * Success: The offset within the segment of the new data area.
490 * Failure: -1 (this is invariably an out of memory condition).
491 *
492 * BUGS
493 *
494 * Does not (yet) handle the case where the allocated segment memory needs to grow.
495 */
496 static int ctl2_alloc_segment(
497 ICreateTypeLib2Impl *This, /* [I] The type library in which to allocate. */
498 enum MSFT_segment_index segment, /* [I] The segment in which to allocate. */
499 int size, /* [I] The amount to allocate. */
500 int block_size) /* [I] Initial allocation block size, or 0 for default. */
501 {
502 int offset;
503
504 if(!This->typelib_segment_data[segment]) {
505 if (!block_size) block_size = 0x2000;
506
507 This->typelib_segment_block_length[segment] = block_size;
508 This->typelib_segment_data[segment] = HeapAlloc(GetProcessHeap(), 0, block_size);
509 if (!This->typelib_segment_data[segment]) return -1;
510 memset(This->typelib_segment_data[segment], 0x57, block_size);
511 }
512
513 while ((This->typelib_segdir[segment].length + size) > This->typelib_segment_block_length[segment]) {
514 char *block;
515
516 block_size = This->typelib_segment_block_length[segment];
517 block = HeapReAlloc(GetProcessHeap(), 0, This->typelib_segment_data[segment], block_size << 1);
518 if (!block) return -1;
519
520 if (segment == MSFT_SEG_TYPEINFO) {
521 /* TypeInfos have a direct pointer to their memory space, so we have to fix them up. */
522 ICreateTypeInfo2Impl *typeinfo;
523
524 for (typeinfo = This->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
525 typeinfo->typeinfo = (void *)&block[((char *)typeinfo->typeinfo) - This->typelib_segment_data[segment]];
526 }
527 }
528
529 memset(block + block_size, 0x57, block_size);
530 This->typelib_segment_block_length[segment] = block_size << 1;
531 This->typelib_segment_data[segment] = block;
532 }
533
534 offset = This->typelib_segdir[segment].length;
535 This->typelib_segdir[segment].length += size;
536
537 return offset;
538 }
539
540 /****************************************************************************
541 * ctl2_alloc_typeinfo
542 *
543 * Allocates and initializes a typeinfo structure in a type library.
544 *
545 * RETURNS
546 *
547 * Success: The offset of the new typeinfo.
548 * Failure: -1 (this is invariably an out of memory condition).
549 */
550 static int ctl2_alloc_typeinfo(
551 ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
552 int nameoffset) /* [I] The offset of the name for this typeinfo. */
553 {
554 int offset;
555 MSFT_TypeInfoBase *typeinfo;
556
557 offset = ctl2_alloc_segment(This, MSFT_SEG_TYPEINFO, sizeof(MSFT_TypeInfoBase), 0);
558 if (offset == -1) return -1;
559
560 This->typelib_typeinfo_offsets[This->typelib_header.nrtypeinfos++] = offset;
561
562 typeinfo = (void *)(This->typelib_segment_data[MSFT_SEG_TYPEINFO] + offset);
563
564 typeinfo->typekind = (This->typelib_header.nrtypeinfos - 1) << 16;
565 typeinfo->memoffset = -1; /* should be EOF if no elements */
566 typeinfo->res2 = 0;
567 typeinfo->res3 = 0;
568 typeinfo->res4 = 3;
569 typeinfo->res5 = 0;
570 typeinfo->cElement = 0;
571 typeinfo->res7 = 0;
572 typeinfo->res8 = 0;
573 typeinfo->res9 = 0;
574 typeinfo->resA = 0;
575 typeinfo->posguid = -1;
576 typeinfo->flags = 0;
577 typeinfo->NameOffset = nameoffset;
578 typeinfo->version = 0;
579 typeinfo->docstringoffs = -1;
580 typeinfo->helpstringcontext = 0;
581 typeinfo->helpcontext = 0;
582 typeinfo->oCustData = -1;
583 typeinfo->cbSizeVft = 0;
584 typeinfo->cImplTypes = 0;
585 typeinfo->size = 0;
586 typeinfo->datatype1 = -1;
587 typeinfo->datatype2 = 0;
588 typeinfo->res18 = 0;
589 typeinfo->res19 = -1;
590
591 return offset;
592 }
593
594 /****************************************************************************
595 * ctl2_alloc_guid
596 *
597 * Allocates and initializes a GUID structure in a type library. Also updates
598 * the GUID hash table as needed.
599 *
600 * RETURNS
601 *
602 * Success: The offset of the new GUID.
603 * Failure: -1 (this is invariably an out of memory condition).
604 */
605 static int ctl2_alloc_guid(
606 ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
607 MSFT_GuidEntry *guid) /* [I] The GUID to store. */
608 {
609 int offset;
610 MSFT_GuidEntry *guid_space;
611 int hash_key;
612
613 hash_key = ctl2_hash_guid(&guid->guid);
614
615 offset = ctl2_find_guid(This, hash_key, &guid->guid);
616 if (offset != -1) return offset;
617
618 offset = ctl2_alloc_segment(This, MSFT_SEG_GUID, sizeof(MSFT_GuidEntry), 0);
619 if (offset == -1) return -1;
620
621 guid_space = (void *)(This->typelib_segment_data[MSFT_SEG_GUID] + offset);
622 *guid_space = *guid;
623
624 guid_space->next_hash = This->typelib_guidhash_segment[hash_key];
625 This->typelib_guidhash_segment[hash_key] = offset;
626
627 return offset;
628 }
629
630 /****************************************************************************
631 * ctl2_alloc_name
632 *
633 * Allocates and initializes a name within a type library. Also updates the
634 * name hash table as needed.
635 *
636 * RETURNS
637 *
638 * Success: The offset within the segment of the new name.
639 * Failure: -1 (this is invariably an out of memory condition).
640 */
641 static int ctl2_alloc_name(
642 ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
643 const WCHAR *name) /* [I] The name to store. */
644 {
645 int length;
646 int offset;
647 MSFT_NameIntro *name_space;
648 char *encoded_name;
649
650 length = ctl2_encode_name(This, name, &encoded_name);
651
652 offset = ctl2_find_name(This, encoded_name);
653 if (offset != -1) return offset;
654
655 offset = ctl2_alloc_segment(This, MSFT_SEG_NAME, length + 8, 0);
656 if (offset == -1) return -1;
657
658 name_space = (void *)(This->typelib_segment_data[MSFT_SEG_NAME] + offset);
659 name_space->hreftype = -1;
660 name_space->next_hash = -1;
661 memcpy(&name_space->namelen, encoded_name, length);
662
663 if (This->typelib_namehash_segment[encoded_name[2] & 0x7f] != -1)
664 name_space->next_hash = This->typelib_namehash_segment[encoded_name[2] & 0x7f];
665
666 This->typelib_namehash_segment[encoded_name[2] & 0x7f] = offset;
667
668 This->typelib_header.nametablecount += 1;
669 This->typelib_header.nametablechars += *encoded_name;
670
671 return offset;
672 }
673
674 /****************************************************************************
675 * ctl2_alloc_string
676 *
677 * Allocates and initializes a string in a type library.
678 *
679 * RETURNS
680 *
681 * Success: The offset within the segment of the new string.
682 * Failure: -1 (this is invariably an out of memory condition).
683 */
684 static int ctl2_alloc_string(
685 ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
686 const WCHAR *string) /* [I] The string to store. */
687 {
688 int length;
689 int offset;
690 char *string_space;
691 char *encoded_string;
692
693 length = ctl2_encode_string(This, string, &encoded_string);
694
695 for (offset = 0; offset < This->typelib_segdir[MSFT_SEG_STRING].length;
696 offset += ((((This->typelib_segment_data[MSFT_SEG_STRING][offset + 1] << 8) & 0xff)
697 | (This->typelib_segment_data[MSFT_SEG_STRING][offset + 0] & 0xff)) + 5) & ~3) {
698 if (!memcmp(encoded_string, This->typelib_segment_data[MSFT_SEG_STRING] + offset, length)) return offset;
699 }
700
701 offset = ctl2_alloc_segment(This, MSFT_SEG_STRING, length, 0);
702 if (offset == -1) return -1;
703
704 string_space = This->typelib_segment_data[MSFT_SEG_STRING] + offset;
705 memcpy(string_space, encoded_string, length);
706
707 return offset;
708 }
709
710 /****************************************************************************
711 * ctl2_alloc_importinfo
712 *
713 * Allocates and initializes an import information structure in a type library.
714 *
715 * RETURNS
716 *
717 * Success: The offset of the new importinfo.
718 * Failure: -1 (this is invariably an out of memory condition).
719 */
720 static int ctl2_alloc_importinfo(
721 ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
722 MSFT_ImpInfo *impinfo) /* [I] The import information to store. */
723 {
724 int offset;
725 MSFT_ImpInfo *impinfo_space;
726
727 impinfo_space = (MSFT_ImpInfo*)&This->typelib_segment_data[MSFT_SEG_IMPORTINFO][0];
728 for (offset=0; offset<This->typelib_segdir[MSFT_SEG_IMPORTINFO].length;
729 offset+=sizeof(MSFT_ImpInfo)) {
730 if(impinfo_space->oImpFile == impinfo->oImpFile
731 && impinfo_space->oGuid == impinfo->oGuid)
732 return offset;
733
734 impinfo_space += 1;
735 }
736
737 impinfo->flags |= This->typelib_header.nimpinfos++;
738
739 offset = ctl2_alloc_segment(This, MSFT_SEG_IMPORTINFO, sizeof(MSFT_ImpInfo), 0);
740 if (offset == -1) return -1;
741
742 impinfo_space = (void *)(This->typelib_segment_data[MSFT_SEG_IMPORTINFO] + offset);
743 *impinfo_space = *impinfo;
744
745 return offset;
746 }
747
748 /****************************************************************************
749 * ctl2_alloc_importfile
750 *
751 * Allocates and initializes an import file definition in a type library.
752 *
753 * RETURNS
754 *
755 * Success: The offset of the new importinfo.
756 * Failure: -1 (this is invariably an out of memory condition).
757 */
758 static int ctl2_alloc_importfile(
759 ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
760 int guidoffset, /* [I] The offset to the GUID for the imported library. */
761 LCID lcid, /* [I] The LCID of imported library. */
762 int major_version, /* [I] The major version number of the imported library. */
763 int minor_version, /* [I] The minor version number of the imported library. */
764 const WCHAR *filename) /* [I] The filename of the imported library. */
765 {
766 int length;
767 int offset;
768 MSFT_ImpFile *importfile;
769 char *encoded_string;
770
771 length = ctl2_encode_string(This, filename, &encoded_string);
772
773 encoded_string[0] <<= 2;
774 encoded_string[0] |= 1;
775
776 for (offset = 0; offset < This->typelib_segdir[MSFT_SEG_IMPORTFILES].length;
777 offset += ((((This->typelib_segment_data[MSFT_SEG_IMPORTFILES][offset + 0xd] << 8) & 0xff)
778 | (This->typelib_segment_data[MSFT_SEG_IMPORTFILES][offset + 0xc] & 0xff)) >> 2) + 0xc) {
779 if (!memcmp(encoded_string, This->typelib_segment_data[MSFT_SEG_IMPORTFILES] + offset + 0xc, length)) return offset;
780 }
781
782 offset = ctl2_alloc_segment(This, MSFT_SEG_IMPORTFILES, length + 0xc, 0);
783 if (offset == -1) return -1;
784
785 importfile = (MSFT_ImpFile *)&This->typelib_segment_data[MSFT_SEG_IMPORTFILES][offset];
786 importfile->guid = guidoffset;
787 importfile->lcid = lcid;
788 importfile->version = major_version | (minor_version << 16);
789 memcpy(importfile->filename, encoded_string, length);
790
791 return offset;
792 }
793
794 /****************************************************************************
795 * ctl2_alloc_custdata
796 *
797 * Allocates and initializes a "custom data" value in a type library.
798 *
799 * RETURNS
800 *
801 * Success: The offset of the new custdata.
802 * Failure:
803 *
804 * -1: Out of memory.
805 * -2: Unable to encode VARIANT data (typically a bug).
806 */
807 static int ctl2_alloc_custdata(
808 ICreateTypeLib2Impl *This, /* [I] The type library in which to encode the value. */
809 VARIANT *pVarVal) /* [I] The value to encode. */
810 {
811 int offset;
812
813 TRACE("(%p,%p(%d))\n",This,pVarVal,V_VT(pVarVal));
814
815 switch (V_VT(pVarVal)) {
816 case VT_UI4:
817 offset = ctl2_alloc_segment(This, MSFT_SEG_CUSTDATA, 8, 0);
818 if (offset == -1) return offset;
819
820 *((unsigned short *)&This->typelib_segment_data[MSFT_SEG_CUSTDATA][offset]) = VT_UI4;
821 *((unsigned int *)&This->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+2]) = V_UI4(pVarVal);
822 break;
823
824 default:
825 FIXME("Unknown variable encoding vt %d.\n", V_VT(pVarVal));
826 return -2;
827 }
828
829 return offset;
830 }
831
832 /****************************************************************************
833 * ctl2_set_custdata
834 *
835 * Adds a custom data element to an object in a type library.
836 *
837 * RETURNS
838 *
839 * Success: S_OK.
840 * Failure: One of E_INVALIDARG or E_OUTOFMEMORY.
841 */
842 static HRESULT ctl2_set_custdata(
843 ICreateTypeLib2Impl *This, /* [I] The type library to store the custom data in. */
844 REFGUID guid, /* [I] The GUID used as a key to retrieve the custom data. */
845 VARIANT *pVarVal, /* [I] The custom data itself. */
846 int *offset) /* [I/O] The list of custom data to prepend to. */
847 {
848 MSFT_GuidEntry guidentry;
849 int dataoffset;
850 int guidoffset;
851 int custoffset;
852 int *custdata;
853
854 guidentry.guid = *guid;
855
856 guidentry.hreftype = -1;
857 guidentry.next_hash = -1;
858
859 guidoffset = ctl2_alloc_guid(This, &guidentry);
860 if (guidoffset == -1) return E_OUTOFMEMORY;
861 dataoffset = ctl2_alloc_custdata(This, pVarVal);
862 if (dataoffset == -1) return E_OUTOFMEMORY;
863 if (dataoffset == -2) return E_INVALIDARG;
864
865 custoffset = ctl2_alloc_segment(This, MSFT_SEG_CUSTDATAGUID, 12, 0);
866 if (custoffset == -1) return E_OUTOFMEMORY;
867
868 custdata = (int *)&This->typelib_segment_data[MSFT_SEG_CUSTDATAGUID][custoffset];
869 custdata[0] = guidoffset;
870 custdata[1] = dataoffset;
871 custdata[2] = *offset;
872 *offset = custoffset;
873
874 return S_OK;
875 }
876
877 /****************************************************************************
878 * ctl2_encode_typedesc
879 *
880 * Encodes a type description, storing information in the TYPEDESC and ARRAYDESC
881 * segments as needed.
882 *
883 * RETURNS
884 *
885 * Success: 0.
886 * Failure: -1.
887 */
888 static int ctl2_encode_typedesc(
889 ICreateTypeLib2Impl *This, /* [I] The type library in which to encode the TYPEDESC. */
890 const TYPEDESC *tdesc, /* [I] The type description to encode. */
891 int *encoded_tdesc, /* [O] The encoded type description. */
892 int *width, /* [O] The width of the type, or NULL. */
893 int *alignment, /* [O] The alignment of the type, or NULL. */
894 int *decoded_size) /* [O] The total size of the unencoded TYPEDESCs, including nested descs. */
895 {
896 int default_tdesc;
897 int scratch;
898 int typeoffset;
899 int arrayoffset;
900 int *typedata;
901 int *arraydata;
902 int target_type;
903 int child_size;
904
905 default_tdesc = 0x80000000 | (tdesc->vt << 16) | tdesc->vt;
906 if (!width) width = &scratch;
907 if (!alignment) alignment = &scratch;
908 if (!decoded_size) decoded_size = &scratch;
909
910 *decoded_size = 0;
911
912 switch (tdesc->vt) {
913 case VT_UI1:
914 case VT_I1:
915 *encoded_tdesc = default_tdesc;
916 *width = 1;
917 *alignment = 1;
918 break;
919
920 case VT_INT:
921 *encoded_tdesc = 0x80000000 | (VT_I4 << 16) | VT_INT;
922 if ((This->typelib_header.varflags & 0x0f) == SYS_WIN16) {
923 *width = 2;
924 *alignment = 2;
925 } else {
926 *width = 4;
927 *alignment = 4;
928 }
929 break;
930
931 case VT_UINT:
932 *encoded_tdesc = 0x80000000 | (VT_UI4 << 16) | VT_UINT;
933 if ((This->typelib_header.varflags & 0x0f) == SYS_WIN16) {
934 *width = 2;
935 *alignment = 2;
936 } else {
937 *width = 4;
938 *alignment = 4;
939 }
940 break;
941
942 case VT_UI2:
943 case VT_I2:
944 case VT_BOOL:
945 *encoded_tdesc = default_tdesc;
946 *width = 2;
947 *alignment = 2;
948 break;
949
950 case VT_I4:
951 case VT_UI4:
952 case VT_R4:
953 case VT_ERROR:
954 case VT_BSTR:
955 case VT_HRESULT:
956 *encoded_tdesc = default_tdesc;
957 *width = 4;
958 *alignment = 4;
959 break;
960
961 case VT_CY:
962 *encoded_tdesc = default_tdesc;
963 *width = 8;
964 *alignment = 4; /* guess? */
965 break;
966
967 case VT_VOID:
968 *encoded_tdesc = 0x80000000 | (VT_EMPTY << 16) | tdesc->vt;
969 *width = 0;
970 *alignment = 1;
971 break;
972
973 case VT_PTR:
974 /* FIXME: Make with the error checking. */
975 FIXME("PTR vartype, may not work correctly.\n");
976
977 ctl2_encode_typedesc(This, tdesc->u.lptdesc, &target_type, NULL, NULL, &child_size);
978
979 for (typeoffset = 0; typeoffset < This->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
980 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
981 if (((typedata[0] & 0xffff) == VT_PTR) && (typedata[1] == target_type)) break;
982 }
983
984 if (typeoffset == This->typelib_segdir[MSFT_SEG_TYPEDESC].length) {
985 int mix_field;
986
987 if (target_type & 0x80000000) {
988 mix_field = ((target_type >> 16) & 0x3fff) | VT_BYREF;
989 } else {
990 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][target_type];
991 mix_field = ((typedata[0] >> 16) == 0x7fff)? 0x7fff: 0x7ffe;
992 }
993
994 typeoffset = ctl2_alloc_segment(This, MSFT_SEG_TYPEDESC, 8, 0);
995 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
996
997 typedata[0] = (mix_field << 16) | VT_PTR;
998 typedata[1] = target_type;
999 }
1000
1001 *encoded_tdesc = typeoffset;
1002
1003 *width = 4;
1004 *alignment = 4;
1005 *decoded_size = sizeof(TYPEDESC) + child_size;
1006 break;
1007
1008 case VT_SAFEARRAY:
1009 /* FIXME: Make with the error checking. */
1010 FIXME("SAFEARRAY vartype, may not work correctly.\n");
1011
1012 ctl2_encode_typedesc(This, tdesc->u.lptdesc, &target_type, NULL, NULL, &child_size);
1013
1014 for (typeoffset = 0; typeoffset < This->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
1015 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1016 if (((typedata[0] & 0xffff) == VT_SAFEARRAY) && (typedata[1] == target_type)) break;
1017 }
1018
1019 if (typeoffset == This->typelib_segdir[MSFT_SEG_TYPEDESC].length) {
1020 int mix_field;
1021
1022 if (target_type & 0x80000000) {
1023 mix_field = ((target_type >> 16) & VT_TYPEMASK) | VT_ARRAY;
1024 } else {
1025 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][target_type];
1026 mix_field = ((typedata[0] >> 16) == 0x7fff)? 0x7fff: 0x7ffe;
1027 }
1028
1029 typeoffset = ctl2_alloc_segment(This, MSFT_SEG_TYPEDESC, 8, 0);
1030 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1031
1032 typedata[0] = (mix_field << 16) | VT_SAFEARRAY;
1033 typedata[1] = target_type;
1034 }
1035
1036 *encoded_tdesc = typeoffset;
1037
1038 *width = 4;
1039 *alignment = 4;
1040 *decoded_size = sizeof(TYPEDESC) + child_size;
1041 break;
1042
1043 case VT_CARRAY:
1044 {
1045 /* FIXME: Make with the error checking. */
1046 int num_dims = tdesc->u.lpadesc->cDims, elements = 1, dim;
1047
1048 ctl2_encode_typedesc(This, &tdesc->u.lpadesc->tdescElem, &target_type, width, alignment, NULL);
1049 arrayoffset = ctl2_alloc_segment(This, MSFT_SEG_ARRAYDESC, (2 + 2 * num_dims) * sizeof(int), 0);
1050 arraydata = (void *)&This->typelib_segment_data[MSFT_SEG_ARRAYDESC][arrayoffset];
1051
1052 arraydata[0] = target_type;
1053 arraydata[1] = num_dims;
1054 arraydata[1] |= ((num_dims * 2 * sizeof(int)) << 16);
1055 arraydata += 2;
1056
1057 for(dim = 0; dim < num_dims; dim++) {
1058 arraydata[0] = tdesc->u.lpadesc->rgbounds[dim].cElements;
1059 arraydata[1] = tdesc->u.lpadesc->rgbounds[dim].lLbound;
1060 elements *= tdesc->u.lpadesc->rgbounds[dim].cElements;
1061 arraydata += 2;
1062 }
1063 typeoffset = ctl2_alloc_segment(This, MSFT_SEG_TYPEDESC, 8, 0);
1064 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1065
1066 typedata[0] = (0x7ffe << 16) | VT_CARRAY;
1067 typedata[1] = arrayoffset;
1068
1069 *encoded_tdesc = typeoffset;
1070 *width = *width * elements;
1071 *decoded_size = sizeof(ARRAYDESC) + (num_dims - 1) * sizeof(SAFEARRAYBOUND);
1072
1073 break;
1074 }
1075 case VT_USERDEFINED:
1076 TRACE("USERDEFINED.\n");
1077 for (typeoffset = 0; typeoffset < This->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
1078 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1079 if ((typedata[0] == ((0x7fff << 16) | VT_USERDEFINED)) && (typedata[1] == tdesc->u.hreftype)) break;
1080 }
1081
1082 if (typeoffset == This->typelib_segdir[MSFT_SEG_TYPEDESC].length) {
1083 typeoffset = ctl2_alloc_segment(This, MSFT_SEG_TYPEDESC, 8, 0);
1084 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1085
1086 typedata[0] = (0x7fff << 16) | VT_USERDEFINED;
1087 typedata[1] = tdesc->u.hreftype;
1088 }
1089
1090 *encoded_tdesc = typeoffset;
1091 *width = 0;
1092 *alignment = 1;
1093 break;
1094
1095 default:
1096 FIXME("Unrecognized type %d.\n", tdesc->vt);
1097 *encoded_tdesc = default_tdesc;
1098 *width = 0;
1099 *alignment = 1;
1100 break;
1101 }
1102
1103 return 0;
1104 }
1105
1106 /****************************************************************************
1107 * ctl2_find_nth_reference
1108 *
1109 * Finds a reference by index into the linked list of reference records.
1110 *
1111 * RETURNS
1112 *
1113 * Success: Offset of the desired reference record.
1114 * Failure: -1.
1115 */
1116 static int ctl2_find_nth_reference(
1117 ICreateTypeLib2Impl *This, /* [I] The type library in which to search. */
1118 int offset, /* [I] The starting offset of the reference list. */
1119 int index) /* [I] The index of the reference to find. */
1120 {
1121 MSFT_RefRecord *ref;
1122
1123 for (; index && (offset != -1); index--) {
1124 ref = (MSFT_RefRecord *)&This->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
1125 offset = ref->onext;
1126 }
1127
1128 return offset;
1129 }
1130
1131 /****************************************************************************
1132 * ctl2_find_typeinfo_from_offset
1133 *
1134 * Finds an ITypeInfo given an offset into the TYPEINFO segment.
1135 *
1136 * RETURNS
1137 *
1138 * Success: S_OK.
1139 * Failure: TYPE_E_ELEMENTNOTFOUND.
1140 */
1141 static HRESULT ctl2_find_typeinfo_from_offset(
1142 ICreateTypeLib2Impl *This, /* [I] The typelib to find the typeinfo in. */
1143 int offset, /* [I] The offset of the desired typeinfo. */
1144 ITypeInfo **ppTinfo) /* [I] The typeinfo found. */
1145 {
1146 void *typeinfodata;
1147 ICreateTypeInfo2Impl *typeinfo;
1148
1149 typeinfodata = &This->typelib_segment_data[MSFT_SEG_TYPEINFO][offset];
1150
1151 for (typeinfo = This->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
1152 if (typeinfo->typeinfo == typeinfodata) {
1153 *ppTinfo = (ITypeInfo *)&typeinfo->lpVtblTypeInfo2;
1154 ITypeInfo2_AddRef(*ppTinfo);
1155 return S_OK;
1156 }
1157 }
1158
1159 ERR("Failed to find typeinfo, invariant varied.\n");
1160
1161 return TYPE_E_ELEMENTNOTFOUND;
1162 }
1163
1164 /****************************************************************************
1165 * ctl2_add_default_value
1166 *
1167 * Adds default value of an argument
1168 *
1169 * RETURNS
1170 *
1171 * Success: S_OK
1172 * Failure: Error code from winerror.h
1173 */
1174 static HRESULT ctl2_add_default_value(
1175 ICreateTypeLib2Impl *This, /* [I] The typelib to allocate data in */
1176 int *encoded_value, /* [O] The encoded default value or data offset */
1177 VARIANT *value, /* [I] Default value to be encoded */
1178 VARTYPE arg_type) /* [I] Argument type */
1179 {
1180 VARIANT v;
1181 HRESULT hres;
1182 int mask = 0;
1183
1184 TRACE("%p %d %d\n", This, V_VT(value), arg_type);
1185
1186 if(arg_type == VT_INT)
1187 arg_type = VT_I4;
1188 if(arg_type == VT_UINT)
1189 arg_type = VT_UI4;
1190
1191 v = *value;
1192 if(V_VT(value) != arg_type) {
1193 hres = VariantChangeType(&v, value, 0, arg_type);
1194 if(FAILED(hres))
1195 return hres;
1196 }
1197
1198 /* Check if default value can be stored in encoded_value */
1199 switch(arg_type) {
1200 case VT_I4:
1201 case VT_UI4:
1202 mask = 0x3ffffff;
1203 if(V_UI4(&v)>0x3ffffff)
1204 break;
1205 case VT_I1:
1206 case VT_UI1:
1207 case VT_BOOL:
1208 if(!mask)
1209 mask = 0xff;
1210 case VT_I2:
1211 case VT_UI2:
1212 if(!mask)
1213 mask = 0xffff;
1214 *encoded_value = (V_UI4(&v)&mask) | ((0x80+0x4*arg_type)<<24);
1215 return S_OK;
1216 }
1217
1218 switch(arg_type) {
1219 case VT_I4:
1220 case VT_R4:
1221 case VT_UI4:
1222 case VT_INT:
1223 case VT_UINT:
1224 case VT_HRESULT:
1225 case VT_PTR: {
1226 /* Construct the data to be allocated */
1227 int data[2];
1228 data[0] = arg_type + (V_UI4(&v)<<16);
1229 data[1] = (V_UI4(&v)>>16) + 0x57570000;
1230
1231 /* Check if the data was already allocated */
1232 /* Currently the structures doesn't allow to do it in a nice way */
1233 for(*encoded_value=0; *encoded_value<=This->typelib_segdir[MSFT_SEG_CUSTDATA].length-8; *encoded_value+=4)
1234 if(!memcmp(&This->typelib_segment_data[MSFT_SEG_CUSTDATA][*encoded_value], data, 8))
1235 return S_OK;
1236
1237 /* Allocate the data */
1238 *encoded_value = ctl2_alloc_segment(This, MSFT_SEG_CUSTDATA, 8, 0);
1239 if(*encoded_value == -1)
1240 return E_OUTOFMEMORY;
1241
1242 memcpy(&This->typelib_segment_data[MSFT_SEG_CUSTDATA][*encoded_value], data, 8);
1243 return S_OK;
1244 }
1245 case VT_BSTR: {
1246 /* Construct the data */
1247 int i, len = (6+SysStringLen(V_BSTR(&v))+3) & ~0x3;
1248 char *data = HeapAlloc(GetProcessHeap(), 0, len);
1249
1250 if(!data)
1251 return E_OUTOFMEMORY;
1252
1253 *((unsigned short*)data) = arg_type;
1254 *((unsigned*)(data+2)) = SysStringLen(V_BSTR(&v));
1255 for(i=0; i<SysStringLen(V_BSTR(&v)); i++) {
1256 if(V_BSTR(&v)[i] <= 0x7f)
1257 data[i+6] = V_BSTR(&v)[i];
1258 else
1259 data[i+6] = '?';
1260 }
1261 WideCharToMultiByte(CP_ACP, 0, V_BSTR(&v), SysStringLen(V_BSTR(&v)), &data[6], len-6, NULL, NULL);
1262 for(i=6+SysStringLen(V_BSTR(&v)); i<len; i++)
1263 data[i] = 0x57;
1264
1265 /* Check if the data was already allocated */
1266 for(*encoded_value=0; *encoded_value<=This->typelib_segdir[MSFT_SEG_CUSTDATA].length-len; *encoded_value+=4)
1267 if(!memcmp(&This->typelib_segment_data[MSFT_SEG_CUSTDATA][*encoded_value], data, len)) {
1268 HeapFree(GetProcessHeap(), 0, data);
1269 return S_OK;
1270 }
1271
1272 /* Allocate the data */
1273 *encoded_value = ctl2_alloc_segment(This, MSFT_SEG_CUSTDATA, len, 0);
1274 if(*encoded_value == -1) {
1275 HeapFree(GetProcessHeap(), 0, data);
1276 return E_OUTOFMEMORY;
1277 }
1278
1279 memcpy(&This->typelib_segment_data[MSFT_SEG_CUSTDATA][*encoded_value], data, len);
1280 HeapFree(GetProcessHeap(), 0, data);
1281 return S_OK;
1282 }
1283 default:
1284 FIXME("Argument type not yet handled\n");
1285 return E_NOTIMPL;
1286 }
1287 }
1288
1289 /*================== ICreateTypeInfo2 Implementation ===================================*/
1290
1291 /******************************************************************************
1292 * ICreateTypeInfo2_QueryInterface {OLEAUT32}
1293 *
1294 * See IUnknown_QueryInterface.
1295 */
1296 static HRESULT WINAPI ICreateTypeInfo2_fnQueryInterface(
1297 ICreateTypeInfo2 * iface,
1298 REFIID riid,
1299 VOID **ppvObject)
1300 {
1301 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1302
1303 TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
1304
1305 *ppvObject=NULL;
1306 if(IsEqualIID(riid, &IID_IUnknown) ||
1307 IsEqualIID(riid,&IID_ICreateTypeInfo)||
1308 IsEqualIID(riid,&IID_ICreateTypeInfo2))
1309 {
1310 *ppvObject = This;
1311 } else if (IsEqualIID(riid, &IID_ITypeInfo) ||
1312 IsEqualIID(riid, &IID_ITypeInfo2)) {
1313 *ppvObject = &This->lpVtblTypeInfo2;
1314 }
1315
1316 if(*ppvObject)
1317 {
1318 ICreateTypeInfo2_AddRef(iface);
1319 TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
1320 return S_OK;
1321 }
1322 TRACE("-- Interface: E_NOINTERFACE\n");
1323 return E_NOINTERFACE;
1324 }
1325
1326 /******************************************************************************
1327 * ICreateTypeInfo2_AddRef {OLEAUT32}
1328 *
1329 * See IUnknown_AddRef.
1330 */
1331 static ULONG WINAPI ICreateTypeInfo2_fnAddRef(ICreateTypeInfo2 *iface)
1332 {
1333 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1334 ULONG ref = InterlockedIncrement(&This->ref);
1335
1336 TRACE("(%p)->ref was %u\n",This, ref - 1);
1337
1338 if(ref==1 && This->typelib)
1339 ICreateTypeLib2_AddRef((ICreateTypeLib2 *)This->typelib);
1340
1341 return ref;
1342 }
1343
1344 /******************************************************************************
1345 * ICreateTypeInfo2_Release {OLEAUT32}
1346 *
1347 * See IUnknown_Release.
1348 */
1349 static ULONG WINAPI ICreateTypeInfo2_fnRelease(ICreateTypeInfo2 *iface)
1350 {
1351 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1352 ULONG ref = InterlockedDecrement(&This->ref);
1353
1354 TRACE("(%p)->(%u)\n",This, ref);
1355
1356 if (!ref) {
1357 if (This->typelib) {
1358 ICreateTypeLib2_fnRelease((ICreateTypeLib2 *)This->typelib);
1359 /* Keep This->typelib reference to make stored ICreateTypeInfo structure valid */
1360 /* This->typelib = NULL; */
1361 }
1362
1363 /* ICreateTypeLib2 frees all ICreateTypeInfos when it releases. */
1364 /* HeapFree(GetProcessHeap(),0,This); */
1365 return 0;
1366 }
1367
1368 return ref;
1369 }
1370
1371
1372 /******************************************************************************
1373 * ICreateTypeInfo2_SetGuid {OLEAUT32}
1374 *
1375 * See ICreateTypeInfo_SetGuid.
1376 */
1377 static HRESULT WINAPI ICreateTypeInfo2_fnSetGuid(ICreateTypeInfo2 *iface, REFGUID guid)
1378 {
1379 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1380
1381 MSFT_GuidEntry guidentry;
1382 int offset;
1383
1384 TRACE("(%p,%s)\n", iface, debugstr_guid(guid));
1385
1386 guidentry.guid = *guid;
1387 guidentry.hreftype = This->typelib->typelib_typeinfo_offsets[This->typeinfo->typekind >> 16];
1388 guidentry.next_hash = -1;
1389
1390 offset = ctl2_alloc_guid(This->typelib, &guidentry);
1391
1392 if (offset == -1) return E_OUTOFMEMORY;
1393
1394 This->typeinfo->posguid = offset;
1395
1396 if (IsEqualIID(guid, &IID_IDispatch)) {
1397 This->typelib->typelib_header.dispatchpos = This->typelib->typelib_typeinfo_offsets[This->typeinfo->typekind >> 16];
1398 }
1399
1400 return S_OK;
1401 }
1402
1403 /******************************************************************************
1404 * ICreateTypeInfo2_SetTypeFlags {OLEAUT32}
1405 *
1406 * See ICreateTypeInfo_SetTypeFlags.
1407 */
1408 static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeFlags(ICreateTypeInfo2 *iface, UINT uTypeFlags)
1409 {
1410 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1411
1412 TRACE("(%p,0x%x)\n", iface, uTypeFlags);
1413
1414 if(uTypeFlags & TYPEFLAG_FDUAL) {
1415 This->typeinfo->typekind |= 0x10;
1416 This->typeinfo->typekind &= ~0x0f;
1417 This->typeinfo->typekind |= TKIND_DISPATCH;
1418
1419 if(!This->dual) {
1420 This->dual = HeapAlloc(GetProcessHeap(), 0, sizeof(ICreateTypeInfo2Impl));
1421 if(!This->dual)
1422 return E_OUTOFMEMORY;
1423
1424 memcpy(This->dual, This, sizeof(ICreateTypeInfo2Impl));
1425 This->dual->ref = 0;
1426 This->dual->typekind = This->typekind==TKIND_DISPATCH ?
1427 TKIND_INTERFACE : TKIND_DISPATCH;
1428 This->dual->dual = This;
1429 }
1430
1431 /* Make sure dispatch is in typeinfos queue */
1432 if(This->typekind != TKIND_DISPATCH) {
1433 if(This->typelib->last_typeinfo == This)
1434 This->typelib->last_typeinfo = This->dual;
1435
1436 if(This->typelib->typeinfos == This)
1437 This->typelib->typeinfos = This->dual;
1438 else {
1439 ICreateTypeInfo2Impl *iter;
1440
1441 for(iter=This->typelib->typeinfos; iter->next_typeinfo!=This; iter=iter->next_typeinfo);
1442 iter->next_typeinfo = This->dual;
1443 }
1444 } else
1445 iface = (ICreateTypeInfo2*)&This->dual->lpVtbl;
1446 }
1447
1448 if (uTypeFlags & (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL)) {
1449 static const WCHAR stdole2tlb[] = { 's','t','d','o','l','e','2','.','t','l','b',0 };
1450 ITypeLib *stdole;
1451 ITypeInfo *dispatch;
1452 HREFTYPE hreftype;
1453 HRESULT hres;
1454
1455 hres = LoadTypeLib(stdole2tlb, &stdole);
1456 if(FAILED(hres))
1457 return hres;
1458
1459 hres = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IDispatch, &dispatch);
1460 ITypeLib_Release(stdole);
1461 if(FAILED(hres))
1462 return hres;
1463
1464 hres = ICreateTypeInfo2_AddRefTypeInfo(iface, dispatch, &hreftype);
1465 ITypeInfo_Release(dispatch);
1466 if(FAILED(hres))
1467 return hres;
1468 }
1469
1470 This->typeinfo->flags = uTypeFlags;
1471 return S_OK;
1472 }
1473
1474 /******************************************************************************
1475 * ICreateTypeInfo2_SetDocString {OLEAUT32}
1476 *
1477 * See ICreateTypeInfo_SetDocString.
1478 */
1479 static HRESULT WINAPI ICreateTypeInfo2_fnSetDocString(
1480 ICreateTypeInfo2* iface,
1481 LPOLESTR pStrDoc)
1482 {
1483 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1484
1485 int offset;
1486
1487 TRACE("(%p,%s)\n", iface, debugstr_w(pStrDoc));
1488 if (!pStrDoc)
1489 return E_INVALIDARG;
1490
1491 offset = ctl2_alloc_string(This->typelib, pStrDoc);
1492 if (offset == -1) return E_OUTOFMEMORY;
1493 This->typeinfo->docstringoffs = offset;
1494 return S_OK;
1495 }
1496
1497 /******************************************************************************
1498 * ICreateTypeInfo2_SetHelpContext {OLEAUT32}
1499 *
1500 * See ICreateTypeInfo_SetHelpContext.
1501 */
1502 static HRESULT WINAPI ICreateTypeInfo2_fnSetHelpContext(
1503 ICreateTypeInfo2* iface,
1504 DWORD dwHelpContext)
1505 {
1506 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1507
1508 TRACE("(%p,%d)\n", iface, dwHelpContext);
1509
1510 This->typeinfo->helpcontext = dwHelpContext;
1511
1512 return S_OK;
1513 }
1514
1515 /******************************************************************************
1516 * ICreateTypeInfo2_SetVersion {OLEAUT32}
1517 *
1518 * See ICreateTypeInfo_SetVersion.
1519 */
1520 static HRESULT WINAPI ICreateTypeInfo2_fnSetVersion(
1521 ICreateTypeInfo2* iface,
1522 WORD wMajorVerNum,
1523 WORD wMinorVerNum)
1524 {
1525 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1526
1527 TRACE("(%p,%d,%d)\n", iface, wMajorVerNum, wMinorVerNum);
1528
1529 This->typeinfo->version = wMajorVerNum | (wMinorVerNum << 16);
1530 return S_OK;
1531 }
1532
1533 /******************************************************************************
1534 * ICreateTypeInfo2_AddRefTypeInfo {OLEAUT32}
1535 *
1536 * See ICreateTypeInfo_AddRefTypeInfo.
1537 */
1538 static HRESULT WINAPI ICreateTypeInfo2_fnAddRefTypeInfo(
1539 ICreateTypeInfo2* iface,
1540 ITypeInfo* pTInfo,
1541 HREFTYPE* phRefType)
1542 {
1543 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1544
1545 ITypeLib *container;
1546 UINT index;
1547 HRESULT res;
1548
1549 TRACE("(%p,%p,%p)\n", iface, pTInfo, phRefType);
1550
1551 if(!pTInfo || !phRefType)
1552 return E_INVALIDARG;
1553
1554 /*
1555 * Unfortunately, we can't rely on the passed-in TypeInfo even having the
1556 * same internal structure as one of ours. It could be from another
1557 * implementation of ITypeInfo. So we need to do the following...
1558 */
1559 res = ITypeInfo_GetContainingTypeLib(pTInfo, &container, &index);
1560 if (FAILED(res)) {
1561 TRACE("failed to find containing typelib.\n");
1562 return res;
1563 }
1564
1565 if (container == (ITypeLib *)&This->typelib->lpVtblTypeLib2) {
1566 /* Process locally defined TypeInfo */
1567 *phRefType = This->typelib->typelib_typeinfo_offsets[index];
1568 } else {
1569 BSTR name;
1570 TLIBATTR *tlibattr;
1571 TYPEATTR *typeattr;
1572 TYPEKIND typekind;
1573 MSFT_GuidEntry guid, *check_guid;
1574 MSFT_ImpInfo impinfo;
1575 int guid_offset, import_offset;
1576 HRESULT hres;
1577
1578 /* Allocate container GUID */
1579 hres = ITypeLib_GetLibAttr(container, &tlibattr);
1580 if(FAILED(hres)) {
1581 ITypeLib_Release(container);
1582 return hres;
1583 }
1584
1585 guid.guid = tlibattr->guid;
1586 guid.hreftype = This->typelib->typelib_guids*12+2;
1587 guid.next_hash = -1;
1588
1589 guid_offset = ctl2_alloc_guid(This->typelib, &guid);
1590 if(guid_offset == -1) {
1591 ITypeLib_ReleaseTLibAttr(container, tlibattr);
1592 ITypeLib_Release(container);
1593 return E_OUTOFMEMORY;
1594 }
1595
1596 check_guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][guid_offset];
1597 if(check_guid->hreftype == guid.hreftype)
1598 This->typelib->typelib_guids++;
1599
1600 /* Get import file name */
1601 hres = QueryPathOfRegTypeLib(&guid.guid, tlibattr->wMajorVerNum,
1602 tlibattr->wMinorVerNum, tlibattr->lcid, &name);
1603 if(FAILED(hres)) {
1604 ITypeLib_ReleaseTLibAttr(container, tlibattr);
1605 ITypeLib_Release(container);
1606 return hres;
1607 }
1608
1609 /* Import file */
1610 import_offset = ctl2_alloc_importfile(This->typelib, guid_offset, tlibattr->lcid,
1611 tlibattr->wMajorVerNum, tlibattr->wMinorVerNum, strrchrW(name, '\\')+1);
1612 ITypeLib_ReleaseTLibAttr(container, tlibattr);
1613 SysFreeString(name);
1614
1615 if(import_offset == -1) {
1616 ITypeLib_Release(container);
1617 return E_OUTOFMEMORY;
1618 }
1619
1620 /* Allocate referenced guid */
1621 hres = ITypeInfo_GetTypeAttr(pTInfo, &typeattr);
1622 if(FAILED(hres)) {
1623 ITypeLib_Release(container);
1624 return hres;
1625 }
1626
1627 guid.guid = typeattr->guid;
1628 guid.hreftype = This->typelib->typeinfo_guids*12+1;
1629 guid.next_hash = -1;
1630 typekind = typeattr->typekind;
1631 ITypeInfo_ReleaseTypeAttr(pTInfo, typeattr);
1632
1633 guid_offset = ctl2_alloc_guid(This->typelib, &guid);
1634 if(guid_offset == -1) {
1635 ITypeLib_Release(container);
1636 return E_OUTOFMEMORY;
1637 }
1638
1639 check_guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][guid_offset];
1640 if(check_guid->hreftype == guid.hreftype)
1641 This->typelib->typeinfo_guids++;
1642
1643 /* Allocate importinfo */
1644 impinfo.flags = (typekind<<24) | MSFT_IMPINFO_OFFSET_IS_GUID;
1645 impinfo.oImpFile = import_offset;
1646 impinfo.oGuid = guid_offset;
1647 *phRefType = ctl2_alloc_importinfo(This->typelib, &impinfo)+1;
1648
1649 if(!memcmp(&guid.guid, &IID_IDispatch, sizeof(GUID)))
1650 This->typelib->typelib_header.dispatchpos = *phRefType;
1651 }
1652
1653 ITypeLib_Release(container);
1654 return S_OK;
1655 }
1656
1657 /******************************************************************************
1658 * ICreateTypeInfo2_AddFuncDesc {OLEAUT32}
1659 *
1660 * See ICreateTypeInfo_AddFuncDesc.
1661 */
1662 static HRESULT WINAPI ICreateTypeInfo2_fnAddFuncDesc(
1663 ICreateTypeInfo2* iface,
1664 UINT index,
1665 FUNCDESC* pFuncDesc)
1666 {
1667 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1668
1669 CyclicList *iter, *insert;
1670 int *typedata;
1671 int i, num_defaults = 0;
1672 int decoded_size;
1673 HRESULT hres;
1674
1675 TRACE("(%p,%d,%p)\n", iface, index, pFuncDesc);
1676
1677 if(!pFuncDesc || pFuncDesc->oVft&3)
1678 return E_INVALIDARG;
1679
1680 TRACE("{%d,%p,%p,%d,%d,%d,%d,%d,%d,%d,{%d},%d}\n", pFuncDesc->memid,
1681 pFuncDesc->lprgscode, pFuncDesc->lprgelemdescParam, pFuncDesc->funckind,
1682 pFuncDesc->invkind, pFuncDesc->callconv, pFuncDesc->cParams,
1683 pFuncDesc->cParamsOpt, pFuncDesc->oVft, pFuncDesc->cScodes,
1684 pFuncDesc->elemdescFunc.tdesc.vt, pFuncDesc->wFuncFlags);
1685
1686 if(pFuncDesc->cParamsOpt || pFuncDesc->cScodes)
1687 FIXME("Unimplemented parameter - created typelib will be incorrect\n");
1688
1689 switch(This->typekind) {
1690 case TKIND_MODULE:
1691 if(pFuncDesc->funckind != FUNC_STATIC)
1692 return TYPE_E_BADMODULEKIND;
1693 break;
1694 case TKIND_DISPATCH:
1695 if(pFuncDesc->funckind != FUNC_DISPATCH)
1696 return TYPE_E_BADMODULEKIND;
1697 break;
1698 default:
1699 if(pFuncDesc->funckind != FUNC_PUREVIRTUAL)
1700 return TYPE_E_BADMODULEKIND;
1701 }
1702
1703 if(This->typeinfo->cElement<index)
1704 return TYPE_E_ELEMENTNOTFOUND;
1705
1706 if((pFuncDesc->invkind&(INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF)) &&
1707 !pFuncDesc->cParams)
1708 return TYPE_E_INCONSISTENTPROPFUNCS;
1709
1710 /* get number of arguments with default values specified */
1711 for (i = 0; i < pFuncDesc->cParams; i++)
1712 if(pFuncDesc->lprgelemdescParam[i].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
1713 num_defaults++;
1714
1715 if (!This->typedata) {
1716 This->typedata = HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList));
1717 if(!This->typedata)
1718 return E_OUTOFMEMORY;
1719
1720 This->typedata->next = This->typedata;
1721 This->typedata->u.val = 0;
1722
1723 if(This->dual)
1724 This->dual->typedata = This->typedata;
1725 }
1726
1727 /* allocate type data space for us */
1728 insert = HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList));
1729 if(!insert)
1730 return E_OUTOFMEMORY;
1731 insert->u.data = HeapAlloc(GetProcessHeap(), 0, sizeof(int[6])+sizeof(int[(num_defaults?4:3)])*pFuncDesc->cParams);
1732 if(!insert->u.data) {
1733 HeapFree(GetProcessHeap(), 0, insert);
1734 return E_OUTOFMEMORY;
1735 }
1736
1737 /* fill out the basic type information */
1738 typedata = insert->u.data;
1739 typedata[0] = 0x18 + pFuncDesc->cParams*(num_defaults?16:12);
1740 ctl2_encode_typedesc(This->typelib, &pFuncDesc->elemdescFunc.tdesc, &typedata[1], NULL, NULL, &decoded_size);
1741 typedata[2] = pFuncDesc->wFuncFlags;
1742 typedata[3] = ((sizeof(FUNCDESC) + decoded_size) << 16) | (unsigned short)(pFuncDesc->oVft?pFuncDesc->oVft+1:0);
1743 typedata[4] = (pFuncDesc->callconv << 8) | (pFuncDesc->invkind << 3) | pFuncDesc->funckind;
1744 if(num_defaults) typedata[4] |= 0x1000;
1745 typedata[5] = pFuncDesc->cParams;
1746
1747 /* NOTE: High word of typedata[3] is total size of FUNCDESC + size of all ELEMDESCs for params + TYPEDESCs for pointer params and return types. */
1748 /* That is, total memory allocation required to reconstitute the FUNCDESC in its entirety. */
1749 typedata[3] += (sizeof(ELEMDESC) * pFuncDesc->cParams) << 16;
1750 typedata[3] += (sizeof(PARAMDESCEX) * num_defaults) << 16;
1751
1752 /* add default values */
1753 if(num_defaults) {
1754 for (i = 0; i < pFuncDesc->cParams; i++)
1755 if(pFuncDesc->lprgelemdescParam[i].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT) {
1756 hres = ctl2_add_default_value(This->typelib, typedata+6+i,
1757 &pFuncDesc->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue,
1758 pFuncDesc->lprgelemdescParam[i].tdesc.vt);
1759
1760 if(FAILED(hres)) {
1761 HeapFree(GetProcessHeap(), 0, insert->u.data);
1762 HeapFree(GetProcessHeap(), 0, insert);
1763 return hres;
1764 }
1765 } else
1766 typedata[6+i] = 0xffffffff;
1767
1768 num_defaults = pFuncDesc->cParams;
1769 }
1770
1771 /* add arguments */
1772 for (i = 0; i < pFuncDesc->cParams; i++) {
1773 ctl2_encode_typedesc(This->typelib, &pFuncDesc->lprgelemdescParam[i].tdesc,
1774 &typedata[6+num_defaults+(i*3)], NULL, NULL, &decoded_size);
1775 typedata[7+num_defaults+(i*3)] = -1;
1776 typedata[8+num_defaults+(i*3)] = pFuncDesc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
1777 typedata[3] += decoded_size << 16;
1778 }
1779
1780 /* update the index data */
1781 insert->indice = pFuncDesc->memid;
1782 insert->name = -1;
1783
1784 /* insert type data to list */
1785 if(index == This->typeinfo->cElement) {
1786 insert->next = This->typedata->next;
1787 This->typedata->next = insert;
1788 This->typedata = insert;
1789
1790 if(This->dual)
1791 This->dual->typedata = This->typedata;
1792 } else {
1793 iter = This->typedata->next;
1794 for(i=0; i<index; i++)
1795 iter = iter->next;
1796
1797 insert->next = iter->next;
1798 iter->next = insert;
1799 }
1800
1801 /* update type data size */
1802 This->typedata->next->u.val += 0x18 + pFuncDesc->cParams*(num_defaults?16:12);
1803
1804 /* Increment the number of function elements */
1805 This->typeinfo->cElement += 1;
1806
1807 return S_OK;
1808 }
1809
1810 /******************************************************************************
1811 * ICreateTypeInfo2_AddImplType {OLEAUT32}
1812 *
1813 * See ICreateTypeInfo_AddImplType.
1814 */
1815 static HRESULT WINAPI ICreateTypeInfo2_fnAddImplType(
1816 ICreateTypeInfo2* iface,
1817 UINT index,
1818 HREFTYPE hRefType)
1819 {
1820 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1821
1822 TRACE("(%p,%d,%d)\n", iface, index, hRefType);
1823
1824 if (This->typekind == TKIND_COCLASS) {
1825 int offset;
1826 MSFT_RefRecord *ref;
1827
1828 if (index == 0) {
1829 if (This->typeinfo->datatype1 != -1) return TYPE_E_ELEMENTNOTFOUND;
1830
1831 offset = ctl2_alloc_segment(This->typelib, MSFT_SEG_REFERENCES, sizeof(MSFT_RefRecord), 0);
1832 if (offset == -1) return E_OUTOFMEMORY;
1833
1834 This->typeinfo->datatype1 = offset;
1835 } else {
1836 int lastoffset;
1837
1838 lastoffset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index - 1);
1839 if (lastoffset == -1) return TYPE_E_ELEMENTNOTFOUND;
1840
1841 ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][lastoffset];
1842 if (ref->onext != -1) return TYPE_E_ELEMENTNOTFOUND;
1843
1844 offset = ctl2_alloc_segment(This->typelib, MSFT_SEG_REFERENCES, sizeof(MSFT_RefRecord), 0);
1845 if (offset == -1) return E_OUTOFMEMORY;
1846
1847 ref->onext = offset;
1848 }
1849
1850 ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
1851
1852 ref->reftype = hRefType;
1853 ref->flags = 0;
1854 ref->oCustData = -1;
1855 ref->onext = -1;
1856 This->typeinfo->cImplTypes++;
1857 } else if (This->typekind == TKIND_INTERFACE) {
1858 if (This->typeinfo->cImplTypes && index==1)
1859 return TYPE_E_BADMODULEKIND;
1860
1861 if( index != 0) return TYPE_E_ELEMENTNOTFOUND;
1862
1863 This->typeinfo->datatype1 = hRefType;
1864 This->typeinfo->cImplTypes = 1;
1865 } else if (This->typekind == TKIND_DISPATCH) {
1866 if(index != 0) return TYPE_E_ELEMENTNOTFOUND;
1867
1868 /* FIXME: Check if referenced typeinfo is IDispatch */
1869 This->typeinfo->flags |= TYPEFLAG_FDISPATCHABLE;
1870 This->typeinfo->cImplTypes = 1;
1871 } else {
1872 FIXME("AddImplType unsupported on typekind %d\n", This->typekind);
1873 return E_OUTOFMEMORY;
1874 }
1875
1876 return S_OK;
1877 }
1878
1879 /******************************************************************************
1880 * ICreateTypeInfo2_SetImplTypeFlags {OLEAUT32}
1881 *
1882 * See ICreateTypeInfo_SetImplTypeFlags.
1883 */
1884 static HRESULT WINAPI ICreateTypeInfo2_fnSetImplTypeFlags(
1885 ICreateTypeInfo2* iface,
1886 UINT index,
1887 INT implTypeFlags)
1888 {
1889 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1890 int offset;
1891 MSFT_RefRecord *ref;
1892
1893 TRACE("(%p,%d,0x%x)\n", iface, index, implTypeFlags);
1894
1895 if (This->typekind != TKIND_COCLASS) {
1896 return TYPE_E_BADMODULEKIND;
1897 }
1898
1899 offset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index);
1900 if (offset == -1) return TYPE_E_ELEMENTNOTFOUND;
1901
1902 ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
1903 ref->flags = implTypeFlags;
1904
1905 return S_OK;
1906 }
1907
1908 /******************************************************************************
1909 * ICreateTypeInfo2_SetAlignment {OLEAUT32}
1910 *
1911 * See ICreateTypeInfo_SetAlignment.
1912 */
1913 static HRESULT WINAPI ICreateTypeInfo2_fnSetAlignment(
1914 ICreateTypeInfo2* iface,
1915 WORD cbAlignment)
1916 {
1917 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1918
1919 TRACE("(%p,%d)\n", iface, cbAlignment);
1920
1921 if (!cbAlignment) return E_INVALIDARG;
1922 if (cbAlignment > 16) return E_INVALIDARG;
1923
1924 This->typeinfo->typekind &= ~0xffc0;
1925 This->typeinfo->typekind |= cbAlignment << 6;
1926
1927 /* FIXME: There's probably some way to simplify this. */
1928 switch (This->typekind) {
1929 case TKIND_ALIAS:
1930 default:
1931 break;
1932
1933 case TKIND_ENUM:
1934 case TKIND_INTERFACE:
1935 case TKIND_DISPATCH:
1936 case TKIND_COCLASS:
1937 if (cbAlignment > 4) cbAlignment = 4;
1938 break;
1939
1940 case TKIND_RECORD:
1941 case TKIND_MODULE:
1942 case TKIND_UNION:
1943 cbAlignment = 1;
1944 break;
1945 }
1946
1947 This->typeinfo->typekind |= cbAlignment << 11;
1948
1949 return S_OK;
1950 }
1951
1952 /******************************************************************************
1953 * ICreateTypeInfo2_SetSchema {OLEAUT32}
1954 *
1955 * See ICreateTypeInfo_SetSchema.
1956 */
1957 static HRESULT WINAPI ICreateTypeInfo2_fnSetSchema(
1958 ICreateTypeInfo2* iface,
1959 LPOLESTR pStrSchema)
1960 {
1961 FIXME("(%p,%s), stub!\n", iface, debugstr_w(pStrSchema));
1962 return E_OUTOFMEMORY;
1963 }
1964
1965 /******************************************************************************
1966 * ICreateTypeInfo2_AddVarDesc {OLEAUT32}
1967 *
1968 * See ICreateTypeInfo_AddVarDesc.
1969 */
1970 static HRESULT WINAPI ICreateTypeInfo2_fnAddVarDesc(
1971 ICreateTypeInfo2* iface,
1972 UINT index,
1973 VARDESC* pVarDesc)
1974 {
1975 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1976
1977 CyclicList *insert;
1978 INT *typedata;
1979 int var_datawidth;
1980 int var_alignment;
1981 int var_type_size;
1982 int alignment;
1983
1984 TRACE("(%p,%d,%p), stub!\n", iface, index, pVarDesc);
1985 TRACE("%d, %p, %d, {{%x, %d}, {%p, %x}}, 0x%x, %d\n", pVarDesc->memid, pVarDesc->lpstrSchema, pVarDesc->u.oInst,
1986 pVarDesc->elemdescVar.tdesc.u.hreftype, pVarDesc->elemdescVar.tdesc.vt,
1987 pVarDesc->elemdescVar.u.paramdesc.pparamdescex, pVarDesc->elemdescVar.u.paramdesc.wParamFlags,
1988 pVarDesc->wVarFlags, pVarDesc->varkind);
1989
1990 if ((This->typeinfo->cElement >> 16) != index) {
1991 TRACE("Out-of-order element.\n");
1992 return TYPE_E_ELEMENTNOTFOUND;
1993 }
1994
1995 if (!This->typedata) {
1996 This->typedata = HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList));
1997 if(!This->typedata)
1998 return E_OUTOFMEMORY;
1999
2000 This->typedata->next = This->typedata;
2001 This->typedata->u.val = 0;
2002
2003 if(This->dual)
2004 This->dual->typedata = This->typedata;
2005 }
2006
2007 /* allocate type data space for us */
2008 insert = HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList));
2009 if(!insert)
2010 return E_OUTOFMEMORY;
2011 insert->u.data = HeapAlloc(GetProcessHeap(), 0, sizeof(int[5]));
2012 if(!insert->u.data) {
2013 HeapFree(GetProcessHeap(), 0, insert);
2014 return E_OUTOFMEMORY;
2015 }
2016
2017 insert->next = This->typedata->next;
2018 This->typedata->next = insert;
2019 This->typedata = insert;
2020
2021 if(This->dual)
2022 This->dual->typedata = This->typedata;
2023
2024 This->typedata->next->u.val += 0x14;
2025 typedata = This->typedata->u.data;
2026
2027 /* fill out the basic type information */
2028 typedata[0] = 0x14 | (index << 16);
2029 typedata[2] = pVarDesc->wVarFlags;
2030 typedata[3] = (sizeof(VARDESC) << 16) | 0;
2031
2032 /* update the index data */
2033 insert->indice = 0x40000000 + index;
2034 insert->name = -1;
2035
2036 /* figure out type widths and whatnot */
2037 ctl2_encode_typedesc(This->typelib, &pVarDesc->elemdescVar.tdesc,
2038 &typedata[1], &var_datawidth, &var_alignment,
2039 &var_type_size);
2040
2041 /* pad out starting position to data width */
2042 This->datawidth += var_alignment - 1;
2043 This->datawidth &= ~(var_alignment - 1);
2044 typedata[4] = This->datawidth;
2045
2046 /* add the new variable to the total data width */
2047 This->datawidth += var_datawidth;
2048 if(This->dual)
2049 This->dual->datawidth = This->datawidth;
2050
2051 /* add type description size to total required allocation */
2052 typedata[3] += var_type_size << 16;
2053
2054 /* fix type alignment */
2055 alignment = (This->typeinfo->typekind >> 11) & 0x1f;
2056 if (alignment < var_alignment) {
2057 alignment = var_alignment;
2058 This->typeinfo->typekind &= ~0xf800;
2059 This->typeinfo->typekind |= alignment << 11;
2060 }
2061
2062 /* ??? */
2063 if (!This->typeinfo->res2) This->typeinfo->res2 = 0x1a;
2064 if ((index == 0) || (index == 1) || (index == 2) || (index == 4) || (index == 9)) {
2065 This->typeinfo->res2 <<= 1;
2066 }
2067
2068 /* ??? */
2069 if (This->typeinfo->res3 == -1) This->typeinfo->res3 = 0;
2070 This->typeinfo->res3 += 0x2c;
2071
2072 /* increment the number of variable elements */
2073 This->typeinfo->cElement += 0x10000;
2074
2075 /* pad data width to alignment */
2076 This->typeinfo->size = (This->datawidth + (alignment - 1)) & ~(alignment - 1);
2077
2078 return S_OK;
2079 }
2080
2081 /******************************************************************************
2082 * ICreateTypeInfo2_SetFuncAndParamNames {OLEAUT32}
2083 *
2084 * See ICreateTypeInfo_SetFuncAndParamNames.
2085 */
2086 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncAndParamNames(
2087 ICreateTypeInfo2* iface,
2088 UINT index,
2089 LPOLESTR* rgszNames,
2090 UINT cNames)
2091 {
2092 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2093 CyclicList *iter = NULL, *iter2;
2094 int offset, len, i=0;
2095 char *namedata;
2096
2097 TRACE("(%p %d %p %d)\n", iface, index, rgszNames, cNames);
2098
2099 if(!rgszNames)
2100 return E_INVALIDARG;
2101
2102 if(index >= This->typeinfo->cElement || !cNames)
2103 return TYPE_E_ELEMENTNOTFOUND;
2104
2105 len = ctl2_encode_name(This->typelib, rgszNames[0], &namedata);
2106 for(iter2=This->typedata->next->next; iter2!=This->typedata->next; iter2=iter2->next) {
2107 if(i == index)
2108 iter = iter2;
2109 else if(iter2->name!=-1 && !memcmp(namedata,
2110 This->typelib->typelib_segment_data[MSFT_SEG_NAME]+iter2->name+8, len))
2111 return TYPE_E_AMBIGUOUSNAME;
2112
2113 i++;
2114 }
2115
2116 /* cNames == cParams for put or putref accessor, cParams+1 otherwise */
2117 if(cNames != iter->u.data[5] + ((iter->u.data[4]>>3)&(INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF) ? 0 : 1))
2118 return TYPE_E_ELEMENTNOTFOUND;
2119
2120 offset = ctl2_alloc_name(This->typelib, rgszNames[0]);
2121 if(offset == -1)
2122 return E_OUTOFMEMORY;
2123
2124 iter->name = offset;
2125
2126 namedata = This->typelib->typelib_segment_data[MSFT_SEG_NAME] + offset;
2127 *((INT *)namedata) = This->typelib->typelib_typeinfo_offsets[This->typeinfo->typekind >> 16];
2128
2129 if(iter->u.data[4]&0x1000)
2130 len = iter->u.data[5];
2131 else
2132 len = 0;
2133
2134 for (i = 1; i < cNames; i++) {
2135 offset = ctl2_alloc_name(This->typelib, rgszNames[i]);
2136 iter->u.data[(i*3) + 4 + len] = offset;
2137 }
2138
2139 return S_OK;
2140 }
2141
2142 /******************************************************************************
2143 * ICreateTypeInfo2_SetVarName {OLEAUT32}
2144 *
2145 * See ICreateTypeInfo_SetVarName.
2146 */
2147 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarName(
2148 ICreateTypeInfo2* iface,
2149 UINT index,
2150 LPOLESTR szName)
2151 {
2152 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2153 CyclicList *iter;
2154 int offset, i;
2155 char *namedata;
2156
2157 TRACE("(%p,%d,%s), stub!\n", iface, index, debugstr_w(szName));
2158
2159 if ((This->typeinfo->cElement >> 16) <= index) {
2160 TRACE("Out-of-order element.\n");
2161 return TYPE_E_ELEMENTNOTFOUND;
2162 }
2163
2164 offset = ctl2_alloc_name(This->typelib, szName);
2165 if (offset == -1) return E_OUTOFMEMORY;
2166
2167 namedata = This->typelib->typelib_segment_data[MSFT_SEG_NAME] + offset;
2168 if (*((INT *)namedata) == -1) {
2169 *((INT *)namedata) = This->typelib->typelib_typeinfo_offsets[This->typeinfo->typekind >> 16];
2170 namedata[9] |= 0x10;
2171 }
2172 if (This->typekind == TKIND_ENUM) {
2173 namedata[9] |= 0x20;
2174 }
2175
2176 iter = This->typedata->next->next;
2177 for(i=0; i<index; i++)
2178 iter = iter->next;
2179
2180 iter->name = offset;
2181 return S_OK;
2182 }
2183
2184 /******************************************************************************
2185 * ICreateTypeInfo2_SetTypeDescAlias {OLEAUT32}
2186 *
2187 * See ICreateTypeInfo_SetTypeDescAlias.
2188 */
2189 static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeDescAlias(
2190 ICreateTypeInfo2* iface,
2191 TYPEDESC* pTDescAlias)
2192 {
2193 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2194
2195 int encoded_typedesc;
2196 int width;
2197
2198 if (This->typekind != TKIND_ALIAS) {
2199 return TYPE_E_WRONGTYPEKIND;
2200 }
2201
2202 FIXME("(%p,%p), hack!\n", iface, pTDescAlias);
2203
2204 if (ctl2_encode_typedesc(This->typelib, pTDescAlias, &encoded_typedesc, &width, NULL, NULL) == -1) {
2205 return E_OUTOFMEMORY;
2206 }
2207
2208 This->typeinfo->size = width;
2209 This->typeinfo->datatype1 = encoded_typedesc;
2210
2211 return S_OK;
2212 }
2213
2214 /******************************************************************************
2215 * ICreateTypeInfo2_DefineFuncAsDllEntry {OLEAUT32}
2216 *
2217 * See ICreateTypeInfo_DefineFuncAsDllEntry.
2218 */
2219 static HRESULT WINAPI ICreateTypeInfo2_fnDefineFuncAsDllEntry(
2220 ICreateTypeInfo2* iface,
2221 UINT index,
2222 LPOLESTR szDllName,
2223 LPOLESTR szProcName)
2224 {
2225 FIXME("(%p,%d,%s,%s), stub!\n", iface, index, debugstr_w(szDllName), debugstr_w(szProcName));
2226 return E_OUTOFMEMORY;
2227 }
2228
2229 /******************************************************************************
2230 * ICreateTypeInfo2_SetFuncDocString {OLEAUT32}
2231 *
2232 * See ICreateTypeInfo_SetFuncDocString.
2233 */
2234 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncDocString(
2235 ICreateTypeInfo2* iface,
2236 UINT index,
2237 LPOLESTR szDocString)
2238 {
2239 FIXME("(%p,%d,%s), stub!\n", iface, index, debugstr_w(szDocString));
2240 return E_OUTOFMEMORY;
2241 }
2242
2243 /******************************************************************************
2244 * ICreateTypeInfo2_SetVarDocString {OLEAUT32}
2245 *
2246 * See ICreateTypeInfo_SetVarDocString.
2247 */
2248 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarDocString(
2249 ICreateTypeInfo2* iface,
2250 UINT index,
2251 LPOLESTR szDocString)
2252 {
2253 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2254
2255 FIXME("(%p,%d,%s), stub!\n", iface, index, debugstr_w(szDocString));
2256
2257 ctl2_alloc_string(This->typelib, szDocString);
2258
2259 return E_OUTOFMEMORY;
2260 }
2261
2262 /******************************************************************************
2263 * ICreateTypeInfo2_SetFuncHelpContext {OLEAUT32}
2264 *
2265 * See ICreateTypeInfo_SetFuncHelpContext.
2266 */
2267 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncHelpContext(
2268 ICreateTypeInfo2* iface,
2269 UINT index,
2270 DWORD dwHelpContext)
2271 {
2272 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2273 CyclicList *func;
2274 int *typedata;
2275 int size;
2276
2277 TRACE("(%p,%d,%d)\n", iface, index, dwHelpContext);
2278
2279 if(This->typeinfo->cElement<index)
2280 return TYPE_E_ELEMENTNOTFOUND;
2281
2282 if(This->typeinfo->cElement == index)
2283 func = This->typedata;
2284 else
2285 for(func=This->typedata->next->next; func!=This->typedata; func=func->next)
2286 if(index-- == 0)
2287 break;
2288
2289 typedata = func->u.data;
2290
2291 /* Compute func size without arguments */
2292 size = typedata[0] - typedata[5]*(typedata[4]&0x1000?16:12);
2293
2294 /* Allocate memory for HelpContext if needed */
2295 if(size < 7*sizeof(int)) {
2296 typedata = HeapReAlloc(GetProcessHeap(), 0, typedata, typedata[0]+sizeof(int));
2297 if(!typedata)
2298 return E_OUTOFMEMORY;
2299
2300 memmove(&typedata[7], &typedata[6], typedata[0]-sizeof(int)*6);
2301 typedata[0] += sizeof(int);
2302 This->typedata->next->u.val += sizeof(int);
2303 func->u.data = typedata;
2304 }
2305
2306 typedata[6] = dwHelpContext;
2307 return S_OK;
2308 }
2309
2310 /******************************************************************************
2311 * ICreateTypeInfo2_SetVarHelpContext {OLEAUT32}
2312 *
2313 * See ICreateTypeInfo_SetVarHelpContext.
2314 */
2315 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarHelpContext(
2316 ICreateTypeInfo2* iface,
2317 UINT index,
2318 DWORD dwHelpContext)
2319 {
2320 FIXME("(%p,%d,%d), stub!\n", iface, index, dwHelpContext);
2321 return E_OUTOFMEMORY;
2322 }
2323
2324 /******************************************************************************
2325 * ICreateTypeInfo2_SetMops {OLEAUT32}
2326 *
2327 * See ICreateTypeInfo_SetMops.
2328 */
2329 static HRESULT WINAPI ICreateTypeInfo2_fnSetMops(
2330 ICreateTypeInfo2* iface,
2331 UINT index,
2332 BSTR bstrMops)
2333 {
2334 FIXME("(%p,%d,%p), stub!\n", iface, index, bstrMops);
2335 return E_OUTOFMEMORY;
2336 }
2337
2338 /******************************************************************************
2339 * ICreateTypeInfo2_SetTypeIdldesc {OLEAUT32}
2340 *
2341 * See ICreateTypeInfo_SetTypeIdldesc.
2342 */
2343 static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeIdldesc(
2344 ICreateTypeInfo2* iface,
2345 IDLDESC* pIdlDesc)
2346 {
2347 FIXME("(%p,%p), stub!\n", iface, pIdlDesc);
2348 return E_OUTOFMEMORY;
2349 }
2350
2351 /******************************************************************************
2352 * ICreateTypeInfo2_LayOut {OLEAUT32}
2353 *
2354 * See ICreateTypeInfo_LayOut.
2355 */
2356 static HRESULT WINAPI ICreateTypeInfo2_fnLayOut(
2357 ICreateTypeInfo2* iface)
2358 {
2359 ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2360 CyclicList *iter, *iter2, **typedata;
2361 HREFTYPE hreftype;
2362 HRESULT hres;
2363 unsigned user_vft = 0;
2364 int i;
2365
2366 TRACE("(%p)\n", iface);
2367
2368 /* FIXME: LayOut should be run on all ImplTypes */
2369 if(This->typekind == TKIND_COCLASS)
2370 return S_OK;
2371
2372 /* Validate inheritance */
2373 This->typeinfo->datatype2 = 0;
2374 hreftype = This->typeinfo->datatype1;
2375
2376 /* Process internally defined interfaces */
2377 for(i=0; i<This->typelib->typelib_header.nrtypeinfos; i++) {
2378 MSFT_TypeInfoBase *header;
2379
2380 if(hreftype&1)
2381 break;
2382
2383 header = (MSFT_TypeInfoBase*)&(This->typelib->typelib_segment_data[MSFT_SEG_TYPEINFO][hreftype]);
2384 This->typeinfo->datatype2 += (header->cElement<<16) + 1;
2385 hreftype = header->datatype1;
2386 }
2387 if(i == This->typelib->typelib_header.nrtypeinfos)
2388 return TYPE_E_CIRCULARTYPE;
2389
2390 /* Process externally defined interfaces */
2391 if(hreftype != -1) {
2392 ITypeInfo *cur, *next;
2393 TYPEATTR *typeattr;
2394
2395 hres = ICreateTypeInfo_QueryInterface(iface, &IID_ITypeInfo, (void**)&next);
2396 if(FAILED(hres))
2397 return hres;
2398
2399 hres = ITypeInfo_GetRefTypeInfo(next, hreftype, &cur);
2400 ITypeInfo_Release(next);
2401 if(FAILED(hres))
2402 return hres;
2403
2404
2405 while(1) {
2406 hres = ITypeInfo_GetTypeAttr(cur, &typeattr);
2407 if(FAILED(hres)) {
2408 ITypeInfo_Release(cur);
2409 return hres;
2410 }
2411
2412 if(!memcmp(&typeattr->guid, &IID_IDispatch, sizeof(IDispatch)))
2413 This->typeinfo->flags |= TYPEFLAG_FDISPATCHABLE;
2414
2415 This->typeinfo->datatype2 += (typeattr->cFuncs<<16) + 1;
2416 ITypeInfo_ReleaseTypeAttr(cur, typeattr);
2417
2418 hres = ITypeInfo_GetRefTypeOfImplType(cur, 0, &hreftype);
2419 if(hres == TYPE_E_ELEMENTNOTFOUND)
2420 break;
2421 if(FAILED(hres)) {
2422 ITypeInfo_Release(cur);
2423 return hres;
2424 }
2425
2426 hres = ITypeInfo_GetRefTypeInfo(cur, hreftype, &next);
2427 if(FAILED(hres)) {
2428 ITypeInfo_Release(cur);
2429 return hres;
2430 }
2431
2432 ITypeInfo_Release(cur);
2433 cur = next;
2434 }
2435 ITypeInfo_Release(cur);
2436 }
2437
2438 /* Get cbSizeVft of inherited interface */
2439 /* Makes LayOut running recursively */
2440 if(This->typeinfo->datatype1 != -1) {
2441 ITypeInfo *cur, *inherited;
2442 TYPEATTR *typeattr;
2443
2444 hres = ICreateTypeInfo_QueryInterface(iface, &IID_ITypeInfo, (void**)&cur);
2445 if(FAILED(hres))
2446 return hres;
2447
2448 hres = ITypeInfo_GetRefTypeInfo(cur, This->typeinfo->datatype1, &inherited);
2449 ITypeInfo_Release(cur);
2450 if(FAILED(hres))
2451 return hres;
2452
2453 hres = ITypeInfo_GetTypeAttr(inherited, &typeattr);
2454 if(FAILED(hres)) {
2455 ITypeInfo_Release(inherited);
2456 return hres;
2457 }
2458
2459 This->typeinfo->cbSizeVft = typeattr->cbSizeVft;
2460
2461 ITypeInfo_ReleaseTypeAttr(inherited, typeattr);
2462 ITypeInfo_Release(inherited);
2463 } else
2464 This->typeinfo->cbSizeVft = 0;
2465
2466 if(!This->typedata)
2467 return S_OK;
2468
2469 typedata = HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList*)*(This->typeinfo->cElement&0xffff));
2470 if(!typedata)
2471 return E_OUTOFMEMORY;
2472
2473 /* Assign IDs and VTBL entries */
2474 i = 0;
2475 if(This->typedata->u.data[3]&1)
2476 user_vft = This->typedata->u.data[3]&0xffff;
2477
2478 for(iter=This->typedata->next->next; iter!=This->typedata->next; iter=iter->next) {
2479 /* Assign MEMBERID if MEMBERID_NIL was specified */
2480 if(iter->indice == MEMBERID_NIL) {
2481 iter->indice = 0x60000000 + i + (This->typeinfo->datatype2<<16);
2482
2483 for(iter2=This->typedata->next->next; iter2!=This->typedata->next; iter2=iter2->next) {
2484 if(iter == iter2) continue;
2485 if(iter2->indice == iter->indice) {
2486 iter->indice = 0x5fffffff + This->typeinfo->cElement + i + (This->typeinfo->datatype2<<16);
2487
2488 for(iter2=This->typedata->next->next; iter2!=This->typedata->next; iter2=iter2->next) {
2489 if(iter == iter2) continue;
2490 if(iter2->indice == iter->indice) {
2491 HeapFree(GetProcessHeap(), 0, typedata);
2492 return E_ACCESSDENIED;
2493 }
2494 }
2495
2496 break;
2497 }
2498 }
2499 }
2500
2501 typedata[i] = iter;
2502
2503 iter->u.data[0] = (iter->u.data[0]&0xffff) | (i<<16);
2504
2505 if((iter->u.data[3]&1) != (user_vft&1)) {
2506 HeapFree(GetProcessHeap(), 0, typedata);
2507 return TYPE_E_INVALIDID;
2508 }
2509
2510 if(user_vft&1) {
2511 if(user_vft < (iter->u.data[3]&0xffff))
2512 user_vft = (iter->u.data[3]&0xffff);
2513
2514 if((iter->u.data[3]&0xffff) < This->typeinfo->cbSizeVft) {
2515 HeapFree(GetProcessHeap(), 0, typedata);
2516 return TYPE_E_INVALIDID;
2517 }
2518 } else if(This->typekind != TKIND_MODULE) {
2519 iter->u.data[3] = (iter->u.data[3]&0xffff0000) | This->typeinfo->cbSizeVft;
2520 This->typeinfo->cbSizeVft += 4;
2521 }
2522
2523 /* Construct a list of elements with the same memberid */
2524 iter->u.data[4] = (iter->u.data[4]&0xffff) | (i<<16);
2525 for(iter2=This->typedata->next->next; iter2!=iter; iter2=iter2->next) {
2526 if(iter->indice == iter2->indice) {
2527 int v1, v2;
2528
2529 v1 = iter->u.data[4] >> 16;
2530 v2 = iter2->u.data[4] >> 16;
2531
2532 iter->u.data[4] = (iter->u.data[4]&0xffff) | (v2<<16);
2533 iter2->u.data[4] = (iter2->u.data[4]&0xffff) | (v1<<16);
2534 break;
2535 }
2536 }
2537
2538 i++;
2539 }
2540
2541 if(user_vft)
2542 This->typeinfo->cbSizeVft = user_vft+3;
2543
2544 for(i=0; i<(This->typeinfo->cElement&0xffff); i++) {
2545 if(typedata[i]->u.data[4]>>16 > i) {
2546 int inv;
2547
2548 inv = (typedata[i]->u.data[4]>>3) & 0xf;
2549 i = typedata[i]->u.data[4] >> 16;
2550
2551 while(i > typedata[i]->u.data[4]>>16) {
2552 int invkind = (typedata[i]->u.data[4]>>3) & 0xf;
2553
2554 if(inv & invkind) {
2555 HeapFree(GetProcessHeap(), 0, typedata);
2556 return TYPE_E_DUPLICATEID;
2557 }
2558
2559 i = typedata[i]->u.data[4] >> 16;
2560 inv |= invkind;
2561 }
2562
2563 if(inv & INVOKE_FUNC) {
2564 HeapFree(GetProcessHeap(), 0, typedata);
2565 return TYPE_E_INCONSISTENTPROPFUNCS;
2566 }
2567 }
2568 }
2569
2570 HeapFree(GetProcessHeap(), 0, typedata);
2571 return S_OK;
2572 }
2573
2574 /******************************************************************************
2575 * ICreateTypeInfo2_DeleteFuncDesc {OLEAUT32}
2576 *
2577 * Delete a function description from a type.
2578 *
2579 * RETURNS
2580 *
2581 * Success: S_OK.
2582 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2583 */
2584 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteFuncDesc(
2585 ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete a function. */
2586 UINT index) /* [I] The index of the function to delete. */
2587 {
2588 FIXME("(%p,%d), stub!\n", iface, index);
2589 return E_OUTOFMEMORY;
2590 }
2591
2592 /******************************************************************************
2593 * ICreateTypeInfo2_DeleteFuncDescByMemId {OLEAUT32}
2594 *
2595 * Delete a function description from a type.
2596 *
2597 * RETURNS
2598 *
2599 * Success: S_OK.
2600 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2601 */
2602 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteFuncDescByMemId(
2603 ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete a function. */
2604 MEMBERID memid, /* [I] The member id of the function to delete. */
2605 INVOKEKIND invKind) /* [I] The invocation type of the function to delete. (?) */
2606 {
2607 FIXME("(%p,%d,%d), stub!\n", iface, memid, invKind);
2608 return E_OUTOFMEMORY;
2609 }
2610
2611 /******************************************************************************
2612 * ICreateTypeInfo2_DeleteVarDesc {OLEAUT32}
2613 *
2614 * Delete a variable description from a type.
2615 *
2616 * RETURNS
2617 *
2618 * Success: S_OK.
2619 * Failure: One of E_OUTOFMEMORY, E_INVALIDARG, TYPE_E_IOERROR,
2620 * TYPE_E_INVDATAREAD, TYPE_E_UNSUPFORMAT or TYPE_E_INVALIDSTATE.
2621 */
2622 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteVarDesc(
2623 ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete the variable description. */
2624 UINT index) /* [I] The index of the variable description to delete. */
2625 {
2626 FIXME("(%p,%d), stub!\n", iface, index);
2627 return E_OUTOFMEMORY;
2628 }
2629
2630 /******************************************************************************
2631 * ICreateTypeInfo2_DeleteVarDescByMemId {OLEAUT32}
2632 *
2633 * Delete a variable description from a type.
2634 *
2635 * RETURNS
2636 *
2637 * Success: S_OK.
2638 * Failure: One of E_OUTOFMEMORY, E_INVALIDARG, TYPE_E_IOERROR,
2639 * TYPE_E_INVDATAREAD, TYPE_E_UNSUPFORMAT or TYPE_E_INVALIDSTATE.
2640 */
2641 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteVarDescByMemId(
2642 ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete the variable description. */
2643 MEMBERID memid) /* [I] The member id of the variable description to delete. */
2644 {
2645 FIXME("(%p,%d), stub!\n", iface, memid);
2646 return E_OUTOFMEMORY;
2647 }
2648
2649 /******************************************************************************
2650 * ICreateTypeInfo2_DeleteImplType {OLEAUT32}
2651 *
2652 * Delete an interface implementation from a type. (?)
2653 *
2654 * RETURNS
2655 *
2656 * Success: S_OK.
2657 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2658 */
2659 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteImplType(
2660 ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete. */
2661 UINT index) /* [I] The index of the interface to delete. */
2662 {
2663 FIXME("(%p,%d), stub!\n", iface, index);
2664 return E_OUTOFMEMORY;
2665 }
2666
2667 /******************************************************************************
2668 * ICreateTypeInfo2_SetCustData {OLEAUT32}
2669 *
2670 * Set the custom data for a type.
2671 *
2672 * RETURNS
2673 *
2674 * Success: S_OK.
2675 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2676 */
2677 static HRESULT WINAPI ICreateTypeInfo2_fnSetCustData(
2678 ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
2679 REFGUID guid, /* [I] The GUID used as a key to retrieve the custom data. */
2680 VARIANT* pVarVal) /* [I] The custom data. */
2681 {
2682 FIXME("(%p,%s,%p), stub!\n", iface, debugstr_guid(guid), pVarVal);
2683 return E_OUTOFMEMORY;
2684 }
2685
2686 /******************************************************************************
2687 * ICreateTypeInfo2_SetFuncCustData {OLEAUT32}
2688 *
2689 * Set the custom data for a function.
2690 *
2691 * RETURNS
2692 *
2693 * Success: S_OK.
2694 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2695 */
2696 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncCustData(
2697 ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
2698 UINT index, /* [I] The index of the function for which to set the custom data. */
2699 REFGUID guid, /* [I] The GUID used as a key to retrieve the custom data. */
2700 VARIANT* pVarVal) /* [I] The custom data. */
2701 {
2702 FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
2703 return E_OUTOFMEMORY;
2704 }
2705
2706 /******************************************************************************
2707 * ICreateTypeInfo2_SetParamCustData {OLEAUT32}
2708 *
2709 * Set the custom data for a function parameter.
2710 *
2711 * RETURNS
2712 *
2713 * Success: S_OK.
2714 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2715 */
2716 static HRESULT WINAPI ICreateTypeInfo2_fnSetParamCustData(
2717 ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
2718 UINT indexFunc, /* [I] The index of the function on which the parameter resides. */
2719 UINT indexParam, /* [I] The index of the parameter on which to set the custom data. */
2720 REFGUID guid, /* [I] The GUID used as a key to retrieve the custom data. */
2721 VARIANT* pVarVal) /* [I] The custom data. */
2722 {
2723 FIXME("(%p,%d,%d,%s,%p), stub!\n", iface, indexFunc, indexParam, debugstr_guid(guid), pVarVal);
2724 return E_OUTOFMEMORY;
2725 }
2726
2727 /******************************************************************************
2728 * ICreateTypeInfo2_SetVarCustData {OLEAUT32}
2729 *
2730 * Set the custom data for a variable.
2731 *
2732 * RETURNS
2733 *
2734 * Success: S_OK.
2735 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2736 */
2737 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarCustData(
2738 ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
2739 UINT index, /* [I] The index of the variable on which to set the custom data. */
2740 REFGUID guid, /* [I] The GUID used as a key to retrieve the custom data. */
2741 VARIANT* pVarVal) /* [I] The custom data. */
2742 {
2743 FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
2744 return E_OUTOFMEMORY;
2745 }
2746
2747 /******************************************************************************
2748 * ICreateTypeInfo2_SetImplTypeCustData {OLEAUT32}
2749 *
2750 * Set the custom data for an implemented interface.
2751 *
2752 * RETURNS
2753 *
2754 * Success: S_OK.
2755 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2756 */
2757 static HRESULT WINAPI ICreateTypeInfo2_fnSetImplTypeCustData(
2758 ICreateTypeInfo2* iface, /* [I] The typeinfo on which to set the custom data. */
2759 UINT index, /* [I] The index of the implemented interface on which to set the custom data. */
2760 REFGUID guid, /* [I] The GUID used as a key to retrieve the custom data. */
2761 VARIANT* pVarVal) /* [I] The custom data. */
2762 {
2763 FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
2764 return E_OUTOFMEMORY;
2765 }
2766
2767 /******************************************************************************
2768 * ICreateTypeInfo2_SetHelpStringContext {OLEAUT32}
2769 *
2770 * Set the help string context for the typeinfo.
2771 *
2772 * RETURNS
2773 *
2774 * Success: S_OK.
2775 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2776 */
2777 static HRESULT WINAPI ICreateTypeInfo2_fnSetHelpStringContext(
2778 ICreateTypeInfo2* iface, /* [I] The typeinfo on which to set the help string context. */
2779 ULONG dwHelpStringContext) /* [I] The help string context. */
2780 {
2781 FIXME("(%p,%d), stub!\n", iface, dwHelpStringContext);
2782 return E_OUTOFMEMORY;
2783 }
2784
2785 /******************************************************************************
2786 * ICreateTypeInfo2_SetFuncHelpStringContext {OLEAUT32}
2787 *
2788 * Set the help string context for a function.
2789 *
2790 * RETURNS
2791 *
2792 * Success: S_OK.
2793 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2794 */
2795 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncHelpStringContext(
2796 ICreateTypeInfo2* iface, /* [I] The typeinfo on which to set the help string context. */
2797 UINT index, /* [I] The index for the function on which to set the help string context. */
2798 ULONG dwHelpStringContext) /* [I] The help string context. */
2799 {
2800 FIXME("(%p,%d,%d), stub!\n", iface, index, dwHelpStringContext);
2801 return E_OUTOFMEMORY;
2802 }
2803
2804 /******************************************************************************
2805 * ICreateTypeInfo2_SetVarHelpStringContext {OLEAUT32}
2806 *
2807 * Set the help string context for a variable.
2808 *
2809 * RETURNS
2810 *
2811 * Success: S_OK.
2812 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2813 */
2814 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarHelpStringContext(
2815 ICreateTypeInfo2* iface, /* [I] The typeinfo on which to set the help string context. */
2816 UINT index, /* [I] The index of the variable on which to set the help string context. */
2817 ULONG dwHelpStringContext) /* [I] The help string context */
2818 {
2819 FIXME("(%p,%d,%d), stub!\n", iface, index, dwHelpStringContext);
2820 return E_OUTOFMEMORY;
2821 }
2822
2823 /******************************************************************************
2824 * ICreateTypeInfo2_Invalidate {OLEAUT32}
2825 *
2826 * Undocumented function. (!)
2827 */
2828 static HRESULT WINAPI ICreateTypeInfo2_fnInvalidate(
2829 ICreateTypeInfo2* iface)
2830 {
2831 FIXME("(%p), stub!\n", iface);
2832 return E_OUTOFMEMORY;
2833 }
2834
2835 /******************************************************************************
2836 * ICreateTypeInfo2_SetName {OLEAUT32}
2837 *
2838 * Set the name for a typeinfo.
2839 *
2840 * RETURNS
2841 *
2842 * Success: S_OK.
2843 * Failure: One of STG_E_INSUFFICIENTMEMORY, E_OUTOFMEMORY, E_INVALIDARG or TYPE_E_INVALIDSTATE.
2844 */
2845 static HRESULT WINAPI ICreateTypeInfo2_fnSetName(
2846 ICreateTypeInfo2* iface,
2847 LPOLESTR szName)
2848 {
2849 FIXME("(%p,%s), stub!\n", iface, debugstr_w(szName));
2850 return E_OUTOFMEMORY;
2851 }
2852
2853 /*================== ITypeInfo2 Implementation ===================================*/
2854
2855 /******************************************************************************
2856 * ITypeInfo2_QueryInterface {OLEAUT32}
2857 *
2858 * See IUnknown_QueryInterface.
2859 */
2860 static HRESULT WINAPI ITypeInfo2_fnQueryInterface(ITypeInfo2 * iface, REFIID riid, LPVOID * ppv)
2861 {
2862 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
2863
2864 return ICreateTypeInfo2_QueryInterface((ICreateTypeInfo2 *)This, riid, ppv);
2865 }
2866
2867 /******************************************************************************
2868 * ITypeInfo2_AddRef {OLEAUT32}
2869 *
2870 * See IUnknown_AddRef.
2871 */
2872 static ULONG WINAPI ITypeInfo2_fnAddRef(ITypeInfo2 * iface)
2873 {
2874 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
2875
2876 return ICreateTypeInfo2_AddRef((ICreateTypeInfo2 *)This);
2877 }
2878
2879 /******************************************************************************
2880 * ITypeInfo2_Release {OLEAUT32}
2881 *
2882 * See IUnknown_Release.
2883 */
2884 static ULONG WINAPI ITypeInfo2_fnRelease(ITypeInfo2 * iface)
2885 {
2886 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
2887
2888 return ICreateTypeInfo2_Release((ICreateTypeInfo2 *)This);
2889 }
2890
2891 /******************************************************************************
2892 * ITypeInfo2_GetTypeAttr {OLEAUT32}
2893 *
2894 * See ITypeInfo_GetTypeAttr.
2895 */
2896 static HRESULT WINAPI ITypeInfo2_fnGetTypeAttr(
2897 ITypeInfo2* iface,
2898 TYPEATTR** ppTypeAttr)
2899 {
2900 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
2901 HRESULT hres;
2902
2903 TRACE("(%p,%p)\n", iface, ppTypeAttr);
2904
2905 if(!ppTypeAttr)
2906 return E_INVALIDARG;
2907
2908 hres = ICreateTypeInfo_LayOut((ICreateTypeInfo*)This);
2909 if(FAILED(hres))
2910 return hres;
2911
2912 *ppTypeAttr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(TYPEATTR));
2913 if(!*ppTypeAttr)
2914 return E_OUTOFMEMORY;
2915
2916 if(This->typeinfo->posguid != -1) {
2917 MSFT_GuidEntry *guid;
2918
2919 guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][This->typeinfo->posguid];
2920 (*ppTypeAttr)->guid = guid->guid;
2921 }
2922
2923 (*ppTypeAttr)->lcid = This->typelib->typelib_header.lcid;
2924 (*ppTypeAttr)->cbSizeInstance = This->typeinfo->size;
2925 (*ppTypeAttr)->typekind = This->typekind;
2926 (*ppTypeAttr)->cFuncs = This->typeinfo->cElement&0xffff;
2927 if(This->typeinfo->flags&TYPEFLAG_FDUAL && This->typekind==TKIND_DISPATCH)
2928 (*ppTypeAttr)->cFuncs += 7;
2929 (*ppTypeAttr)->cVars = This->typeinfo->cElement>>16;
2930 (*ppTypeAttr)->cImplTypes = This->typeinfo->cImplTypes;
2931 (*ppTypeAttr)->cbSizeVft = This->typekind==TKIND_DISPATCH ? 28 : This->typeinfo->cbSizeVft;
2932 (*ppTypeAttr)->cbAlignment = (This->typeinfo->typekind>>11) & 0x1f;
2933 (*ppTypeAttr)->wTypeFlags = This->typeinfo->flags;
2934 (*ppTypeAttr)->wMajorVerNum = This->typeinfo->version&0xffff;
2935 (*ppTypeAttr)->wMinorVerNum = This->typeinfo->version>>16;
2936
2937 if((*ppTypeAttr)->typekind == TKIND_ALIAS)
2938 FIXME("TKIND_ALIAS handling not implemented\n");
2939
2940 return S_OK;
2941 }
2942
2943 /******************************************************************************
2944 * ITypeInfo2_GetTypeComp {OLEAUT32}
2945 *
2946 * See ITypeInfo_GetTypeComp.
2947 */
2948 static HRESULT WINAPI ITypeInfo2_fnGetTypeComp(
2949 ITypeInfo2* iface,
2950 ITypeComp** ppTComp)
2951 {
2952 FIXME("(%p,%p), stub!\n", iface, ppTComp);
2953 return E_OUTOFMEMORY;
2954 }
2955
2956 /******************************************************************************
2957 * ITypeInfo2_GetFuncDesc {OLEAUT32}
2958 *
2959 * See ITypeInfo_GetFuncDesc.
2960 */
2961 static HRESULT WINAPI ITypeInfo2_fnGetFuncDesc(
2962 ITypeInfo2* iface,
2963 UINT index,
2964 FUNCDESC** ppFuncDesc)
2965 {
2966 FIXME("(%p,%d,%p), stub!\n", iface, index, ppFuncDesc);
2967 return E_OUTOFMEMORY;
2968 }
2969
2970 /******************************************************************************
2971 * ITypeInfo2_GetVarDesc {OLEAUT32}
2972 *
2973 * See ITypeInfo_GetVarDesc.
2974 */
2975 static HRESULT WINAPI ITypeInfo2_fnGetVarDesc(
2976 ITypeInfo2* iface,
2977 UINT index,
2978 VARDESC** ppVarDesc)
2979 {
2980 FIXME("(%p,%d,%p), stub!\n", iface, index, ppVarDesc);
2981 return E_OUTOFMEMORY;
2982 }
2983
2984 /******************************************************************************
2985 * ITypeInfo2_GetNames {OLEAUT32}
2986 *
2987 * See ITypeInfo_GetNames.
2988 */
2989 static HRESULT WINAPI ITypeInfo2_fnGetNames(
2990 ITypeInfo2* iface,
2991 MEMBERID memid,
2992 BSTR* rgBstrNames,
2993 UINT cMaxNames,
2994 UINT* pcNames)
2995 {
2996 FIXME("(%p,%d,%p,%d,%p), stub!\n", iface, memid, rgBstrNames, cMaxNames, pcNames);
2997 return E_OUTOFMEMORY;
2998 }
2999
3000 /******************************************************************************
3001 * ITypeInfo2_GetRefTypeOfImplType {OLEAUT32}
3002 *
3003 * See ITypeInfo_GetRefTypeOfImplType.
3004 */
3005 static HRESULT WINAPI ITypeInfo2_fnGetRefTypeOfImplType(
3006 ITypeInfo2* iface,
3007 UINT index,
3008 HREFTYPE* pRefType)
3009 {
3010 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3011 MSFT_RefRecord *ref;
3012 int offset;
3013
3014 TRACE("(%p,%d,%p)\n", iface, index, pRefType);
3015
3016 if(!pRefType)
3017 return E_INVALIDARG;
3018
3019 if(This->typeinfo->flags&TYPEFLAG_FDUAL) {
3020 if(index == -1) {
3021 *pRefType = -2;
3022 return S_OK;
3023 }
3024
3025 if(This->typekind == TKIND_DISPATCH)
3026 return ITypeInfo2_GetRefTypeOfImplType((ITypeInfo2*)&This->dual->lpVtblTypeInfo2,
3027 index, pRefType);
3028 }
3029
3030 if(index>=This->typeinfo->cImplTypes)
3031 return TYPE_E_ELEMENTNOTFOUND;
3032
3033 if(This->typekind == TKIND_INTERFACE) {
3034 *pRefType = This->typeinfo->datatype1 + 2;
3035 return S_OK;
3036 }
3037
3038 offset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index);
3039 if(offset == -1)
3040 return TYPE_E_ELEMENTNOTFOUND;
3041
3042 ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
3043 *pRefType = ref->reftype;
3044 return S_OK;
3045 }
3046
3047 /******************************************************************************
3048 * ITypeInfo2_GetImplTypeFlags {OLEAUT32}
3049 *
3050 * See ITypeInfo_GetImplTypeFlags.
3051 */
3052 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeFlags(
3053 ITypeInfo2* iface,
3054 UINT index,
3055 INT* pImplTypeFlags)
3056 {
3057 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3058 int offset;
3059 MSFT_RefRecord *ref;
3060
3061 TRACE("(%p,%d,%p)\n", iface, index, pImplTypeFlags);
3062
3063 if(!pImplTypeFlags)
3064 return E_INVALIDARG;
3065
3066 if(index >= This->typeinfo->cImplTypes)
3067 return TYPE_E_ELEMENTNOTFOUND;
3068
3069 if(This->typekind != TKIND_COCLASS) {
3070 *pImplTypeFlags = 0;
3071 return S_OK;
3072 }
3073
3074 offset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index);
3075 if(offset == -1)
3076 return TYPE_E_ELEMENTNOTFOUND;
3077
3078 ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
3079 *pImplTypeFlags = ref->flags;
3080 return S_OK;
3081 }
3082
3083 /******************************************************************************
3084 * ITypeInfo2_GetIDsOfNames {OLEAUT32}
3085 *
3086 * See ITypeInfo_GetIDsOfNames.
3087 */
3088 static HRESULT WINAPI ITypeInfo2_fnGetIDsOfNames(
3089 ITypeInfo2* iface,
3090 LPOLESTR* rgszNames,
3091 UINT cNames,
3092 MEMBERID* pMemId)
3093 {
3094 FIXME("(%p,%p,%d,%p), stub!\n", iface, rgszNames, cNames, pMemId);
3095 return E_OUTOFMEMORY;
3096 }
3097
3098 /******************************************************************************
3099 * ITypeInfo2_Invoke {OLEAUT32}
3100 *
3101 * See ITypeInfo_Invoke.
3102 */
3103 static HRESULT WINAPI ITypeInfo2_fnInvoke(
3104 ITypeInfo2* iface,
3105 PVOID pvInstance,
3106 MEMBERID memid,
3107 WORD wFlags,
3108 DISPPARAMS* pDispParams,
3109 VARIANT* pVarResult,
3110 EXCEPINFO* pExcepInfo,
3111 UINT* puArgErr)
3112 {
3113 FIXME("(%p,%p,%d,%x,%p,%p,%p,%p), stub!\n", iface, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3114 return E_OUTOFMEMORY;
3115 }
3116
3117 /******************************************************************************
3118 * ITypeInfo2_GetDocumentation {OLEAUT32}
3119 *
3120 * See ITypeInfo_GetDocumentation.
3121 */
3122 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation(
3123 ITypeInfo2* iface,
3124 MEMBERID memid,
3125 BSTR* pBstrName,
3126 BSTR* pBstrDocString,
3127 DWORD* pdwHelpContext,
3128 BSTR* pBstrHelpFile)
3129 {
3130 FIXME("(%p,%d,%p,%p,%p,%p), stub!\n", iface, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
3131 return E_OUTOFMEMORY;
3132 }
3133
3134 /******************************************************************************
3135 * ITypeInfo2_GetDllEntry {OLEAUT32}
3136 *
3137 * See ITypeInfo_GetDllEntry.
3138 */
3139 static HRESULT WINAPI ITypeInfo2_fnGetDllEntry(
3140 ITypeInfo2* iface,
3141 MEMBERID memid,
3142 INVOKEKIND invKind,
3143 BSTR* pBstrDllName,
3144 BSTR* pBstrName,
3145 WORD* pwOrdinal)
3146 {
3147 FIXME("(%p,%d,%d,%p,%p,%p), stub!\n", iface, memid, invKind, pBstrDllName, pBstrName, pwOrdinal);
3148 return E_OUTOFMEMORY;
3149 }
3150
3151 /******************************************************************************
3152 * ITypeInfo2_GetRefTypeInfo {OLEAUT32}
3153 *
3154 * See ITypeInfo_GetRefTypeInfo.
3155 */
3156 static HRESULT WINAPI ITypeInfo2_fnGetRefTypeInfo(
3157 ITypeInfo2* iface,
3158 HREFTYPE hRefType,
3159 ITypeInfo** ppTInfo)
3160 {
3161 ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3162
3163 TRACE("(%p,%d,%p)\n", iface, hRefType, ppTInfo);
3164
3165 if(!ppTInfo)
3166 return E_INVALIDARG;
3167
3168 if(hRefType==-2 && This->dual) {
3169 *ppTInfo = (ITypeInfo*)&This->dual->lpVtblTypeInfo2;
3170 ITypeInfo_AddRef(*ppTInfo);
3171 return S_OK;
3172 }
3173
3174 if(hRefType&1) {
3175 ITypeLib *tl;
3176 MSFT_ImpInfo *impinfo;
3177 MSFT_ImpFile *impfile;
3178 MSFT_GuidEntry *guid;
3179 WCHAR *filename;
3180 HRESULT hres;
3181
3182 if((hRefType&(~0x3)) >= This->typelib->typelib_segdir[MSFT_SEG_IMPORTINFO].length)
3183 return E_FAIL;
3184
3185 impinfo = (MSFT_ImpInfo*)&This->typelib->typelib_segment_data[MSFT_SEG_IMPORTINFO][hRefType&(~0x3)];
3186 impfile = (MSFT_ImpFile*)&This->typelib->typelib_segment_data[MSFT_SEG_IMPORTFILES][impinfo->oImpFile];
3187 guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][impinfo->oGuid];
3188
3189 ctl2_decode_string(impfile->filename, &filename);
3190
3191 hres = LoadTypeLib(filename, &tl);
3192 if(FAILED(hres))
3193 return hres;
3194
3195 hres = ITypeLib_GetTypeInfoOfGuid(tl, &guid->guid, ppTInfo);
3196
3197 ITypeLib_Release(tl);
3198 return hres;
3199 } else {
3200 ICreateTypeInfo2Impl