4 * Copyright 2004 Alastair Bridgewater
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.
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.
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
20 * --------------------------------------------------------------------------------------
25 * Only works on little-endian systems.
30 #include "wine/port.h"
39 #define NONAMELESSUNION
40 #define NONAMELESSSTRUCT
49 #include "wine/unicode.h"
52 #include "wine/debug.h"
54 WINE_DEFAULT_DEBUG_CHANNEL(typelib2
);
55 /* WINE_DEFAULT_DEBUG_CHANNEL(ole); */
58 /******************************************************************************
59 * ICreateTypeLib2 {OLEAUT32}
62 * The ICreateTypeLib2 interface provides an interface whereby one may create
63 * new type library (.tlb) files.
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).
73 /******************************************************************************
74 * ICreateTypeInfo2 {OLEAUT32}
77 * The ICreateTypeInfo2 interface provides an interface whereby one may add
78 * type information to type library (.tlb) files.
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).
88 /******************************************************************************
89 * ITypeLib2 {OLEAUT32}
92 * The ITypeLib2 interface provides an interface whereby one may query MSFT
93 * format type library (.tlb) files.
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).
103 /******************************************************************************
104 * ITypeInfo2 {OLEAUT32}
107 * The ITypeInfo2 interface provides an interface whereby one may query type
108 * information stored in MSFT format type library (.tlb) files.
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).
118 /*================== Implementation Structures ===================================*/
120 /* Used for storing cyclic list. Tail address is kept */
121 typedef struct tagCyclicList
{
122 struct tagCyclicList
*next
;
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 */
151 typedef struct tagMSFT_ImpFile
{
155 char filename
[0]; /* preceded by two bytes of encoded (length << 2) + flags in the low two bits. */
158 typedef struct tagICreateTypeLib2Impl
160 const ICreateTypeLib2Vtbl
*lpVtbl
;
161 const ITypeLib2Vtbl
*lpVtblTypeLib2
;
167 MSFT_Header typelib_header
;
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
];
173 int typelib_guids
; /* Number of defined typelib guids */
174 int typeinfo_guids
; /* Number of defined typeinfo guids */
176 INT typelib_typeinfo_offsets
[0x200]; /* Hope that's enough. */
178 INT
*typelib_namehash_segment
;
179 INT
*typelib_guidhash_segment
;
181 struct tagICreateTypeInfo2Impl
*typeinfos
;
182 struct tagICreateTypeInfo2Impl
*last_typeinfo
;
183 } ICreateTypeLib2Impl
;
185 static inline ICreateTypeLib2Impl
*impl_from_ITypeLib2( ITypeLib2
*iface
)
187 return (ICreateTypeLib2Impl
*)((char*)iface
- FIELD_OFFSET(ICreateTypeLib2Impl
, lpVtblTypeLib2
));
190 typedef struct tagICreateTypeInfo2Impl
192 const ICreateTypeInfo2Vtbl
*lpVtbl
;
193 const ITypeInfo2Vtbl
*lpVtblTypeInfo2
;
197 ICreateTypeLib2Impl
*typelib
;
198 MSFT_TypeInfoBase
*typeinfo
;
200 struct tagCyclicList
*typedata
; /* tail of cyclic list */
205 struct tagICreateTypeInfo2Impl
*next_typeinfo
;
206 struct tagICreateTypeInfo2Impl
*dual
;
207 } ICreateTypeInfo2Impl
;
209 static inline ICreateTypeInfo2Impl
*impl_from_ITypeInfo2( ITypeInfo2
*iface
)
211 return (ICreateTypeInfo2Impl
*)((char*)iface
- FIELD_OFFSET(ICreateTypeInfo2Impl
, lpVtblTypeInfo2
));
214 static ULONG WINAPI
ICreateTypeLib2_fnRelease(ICreateTypeLib2
*iface
);
217 /*================== Internal functions ===================================*/
219 /****************************************************************************
222 * Initializes the type library header of a new typelib.
224 static void ctl2_init_header(
225 ICreateTypeLib2Impl
*This
) /* [I] The typelib to initialize. */
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;
250 /****************************************************************************
253 * Initializes the segment directory of a new typelib.
255 static void ctl2_init_segdir(
256 ICreateTypeLib2Impl
*This
) /* [I] The typelib to initialize. */
261 segdir
= &This
->typelib_segdir
[MSFT_SEG_TYPEINFO
];
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;
271 /****************************************************************************
274 * Generates a hash key from a GUID.
278 * The hash key for the GUID.
280 static int ctl2_hash_guid(
281 REFGUID guid
) /* [I] The guid to find. */
287 for (i
= 0; i
< 8; i
++) {
288 hash
^= ((const short *)guid
)[i
];
294 /****************************************************************************
297 * Locates a guid in a type library.
301 * The offset into the GUID segment of the guid, or -1 if not found.
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. */
309 MSFT_GuidEntry
*guidentry
;
311 offset
= This
->typelib_guidhash_segment
[hash_key
];
312 while (offset
!= -1) {
313 guidentry
= (MSFT_GuidEntry
*)&This
->typelib_segment_data
[MSFT_SEG_GUID
][offset
];
315 if (!memcmp(guidentry
, guid
, sizeof(GUID
))) return offset
;
317 offset
= guidentry
->next_hash
;
323 /****************************************************************************
326 * Locates a name in a type library.
330 * The offset into the NAME segment of the name, or -1 if not found.
334 * The name must be encoded as with ctl2_encode_name().
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. */
343 offset
= This
->typelib_namehash_segment
[name
[2] & 0x7f];
344 while (offset
!= -1) {
345 namestruct
= (int *)&This
->typelib_segment_data
[MSFT_SEG_NAME
][offset
];
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;
352 /* move to next item in hash bucket */
353 offset
= namestruct
[1];
359 /****************************************************************************
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.
367 * The length of the encoded name, including padding and length+hash fields.
371 * Will throw an exception if name or result are NULL. Is not multithread
372 * safe in the slightest.
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. */
380 static char converted_name
[0x104];
384 length
= WideCharToMultiByte(CP_ACP
, 0, name
, strlenW(name
), converted_name
+4, 0x100, NULL
, NULL
);
385 converted_name
[0] = length
& 0xff;
387 converted_name
[length
+ 4] = 0;
389 converted_name
[1] = 0x00;
391 value
= LHashValOfNameSysA(This
->typelib_header
.varflags
& 0x0f, This
->typelib_header
.lcid
, converted_name
+ 4);
393 converted_name
[2] = value
;
394 converted_name
[3] = value
>> 8;
396 for (offset
= (4 - length
) & 3; offset
; offset
--) converted_name
[length
+ offset
+ 3] = 0x57;
398 *result
= converted_name
;
400 return (length
+ 7) & ~3;
403 /****************************************************************************
406 * Converts string stored in typelib data to unicode.
408 static void ctl2_decode_name(
409 char *data
, /* [I] String to be decoded */
410 WCHAR
**string
) /* [O] Decoded string */
413 static WCHAR converted_string
[0x104];
417 for(i
=0; i
<length
; i
++)
418 converted_string
[i
] = data
[i
+4];
419 converted_string
[length
] = '\0';
421 *string
= converted_string
;
424 /****************************************************************************
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.
432 * The length of the encoded string, including padding and length fields.
436 * Will throw an exception if string or result are NULL. Is not multithread
437 * safe in the slightest.
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. */
445 static char converted_string
[0x104];
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;
452 for (offset
= (4 - (length
+ 2)) & 3; offset
; offset
--) converted_string
[length
+ offset
+ 1] = 0x57;
454 *result
= converted_string
;
456 return (length
+ 5) & ~3;
459 /****************************************************************************
462 * Converts string stored in typelib data to unicode.
464 static void ctl2_decode_string(
465 char *data
, /* [I] String to be decoded */
466 WCHAR
**string
) /* [O] Decoded string */
469 static WCHAR converted_string
[0x104];
471 length
= data
[0] + (data
[1]<<8);
472 if((length
&0x3) == 1)
475 for(i
=0; i
<length
; i
++)
476 converted_string
[i
] = data
[i
+2];
477 converted_string
[length
] = '\0';
479 *string
= converted_string
;
482 /****************************************************************************
485 * Allocates memory from a segment in a type library.
489 * Success: The offset within the segment of the new data area.
490 * Failure: -1 (this is invariably an out of memory condition).
494 * Does not (yet) handle the case where the allocated segment memory needs to grow.
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. */
504 if(!This
->typelib_segment_data
[segment
]) {
505 if (!block_size
) block_size
= 0x2000;
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
);
513 while ((This
->typelib_segdir
[segment
].length
+ size
) > This
->typelib_segment_block_length
[segment
]) {
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;
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
;
524 for (typeinfo
= This
->typeinfos
; typeinfo
; typeinfo
= typeinfo
->next_typeinfo
) {
525 typeinfo
->typeinfo
= (void *)&block
[((char *)typeinfo
->typeinfo
) - This
->typelib_segment_data
[segment
]];
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
;
534 offset
= This
->typelib_segdir
[segment
].length
;
535 This
->typelib_segdir
[segment
].length
+= size
;
540 /****************************************************************************
541 * ctl2_alloc_typeinfo
543 * Allocates and initializes a typeinfo structure in a type library.
547 * Success: The offset of the new typeinfo.
548 * Failure: -1 (this is invariably an out of memory condition).
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. */
555 MSFT_TypeInfoBase
*typeinfo
;
557 offset
= ctl2_alloc_segment(This
, MSFT_SEG_TYPEINFO
, sizeof(MSFT_TypeInfoBase
), 0);
558 if (offset
== -1) return -1;
560 This
->typelib_typeinfo_offsets
[This
->typelib_header
.nrtypeinfos
++] = offset
;
562 typeinfo
= (void *)(This
->typelib_segment_data
[MSFT_SEG_TYPEINFO
] + offset
);
564 typeinfo
->typekind
= (This
->typelib_header
.nrtypeinfos
- 1) << 16;
565 typeinfo
->memoffset
= -1; /* should be EOF if no elements */
570 typeinfo
->cElement
= 0;
575 typeinfo
->posguid
= -1;
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;
586 typeinfo
->datatype1
= -1;
587 typeinfo
->datatype2
= 0;
589 typeinfo
->res19
= -1;
594 /****************************************************************************
597 * Allocates and initializes a GUID structure in a type library. Also updates
598 * the GUID hash table as needed.
602 * Success: The offset of the new GUID.
603 * Failure: -1 (this is invariably an out of memory condition).
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. */
610 MSFT_GuidEntry
*guid_space
;
613 hash_key
= ctl2_hash_guid(&guid
->guid
);
615 offset
= ctl2_find_guid(This
, hash_key
, &guid
->guid
);
616 if (offset
!= -1) return offset
;
618 offset
= ctl2_alloc_segment(This
, MSFT_SEG_GUID
, sizeof(MSFT_GuidEntry
), 0);
619 if (offset
== -1) return -1;
621 guid_space
= (void *)(This
->typelib_segment_data
[MSFT_SEG_GUID
] + offset
);
624 guid_space
->next_hash
= This
->typelib_guidhash_segment
[hash_key
];
625 This
->typelib_guidhash_segment
[hash_key
] = offset
;
630 /****************************************************************************
633 * Allocates and initializes a name within a type library. Also updates the
634 * name hash table as needed.
638 * Success: The offset within the segment of the new name.
639 * Failure: -1 (this is invariably an out of memory condition).
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. */
647 MSFT_NameIntro
*name_space
;
650 length
= ctl2_encode_name(This
, name
, &encoded_name
);
652 offset
= ctl2_find_name(This
, encoded_name
);
653 if (offset
!= -1) return offset
;
655 offset
= ctl2_alloc_segment(This
, MSFT_SEG_NAME
, length
+ 8, 0);
656 if (offset
== -1) return -1;
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
);
663 if (This
->typelib_namehash_segment
[encoded_name
[2] & 0x7f] != -1)
664 name_space
->next_hash
= This
->typelib_namehash_segment
[encoded_name
[2] & 0x7f];
666 This
->typelib_namehash_segment
[encoded_name
[2] & 0x7f] = offset
;
668 This
->typelib_header
.nametablecount
+= 1;
669 This
->typelib_header
.nametablechars
+= *encoded_name
;
674 /****************************************************************************
677 * Allocates and initializes a string in a type library.
681 * Success: The offset within the segment of the new string.
682 * Failure: -1 (this is invariably an out of memory condition).
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. */
691 char *encoded_string
;
693 length
= ctl2_encode_string(This
, string
, &encoded_string
);
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
;
701 offset
= ctl2_alloc_segment(This
, MSFT_SEG_STRING
, length
, 0);
702 if (offset
== -1) return -1;
704 string_space
= This
->typelib_segment_data
[MSFT_SEG_STRING
] + offset
;
705 memcpy(string_space
, encoded_string
, length
);
710 /****************************************************************************
711 * ctl2_alloc_importinfo
713 * Allocates and initializes an import information structure in a type library.
717 * Success: The offset of the new importinfo.
718 * Failure: -1 (this is invariably an out of memory condition).
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. */
725 MSFT_ImpInfo
*impinfo_space
;
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
)
737 impinfo
->flags
|= This
->typelib_header
.nimpinfos
++;
739 offset
= ctl2_alloc_segment(This
, MSFT_SEG_IMPORTINFO
, sizeof(MSFT_ImpInfo
), 0);
740 if (offset
== -1) return -1;
742 impinfo_space
= (void *)(This
->typelib_segment_data
[MSFT_SEG_IMPORTINFO
] + offset
);
743 *impinfo_space
= *impinfo
;
748 /****************************************************************************
749 * ctl2_alloc_importfile
751 * Allocates and initializes an import file definition in a type library.
755 * Success: The offset of the new importinfo.
756 * Failure: -1 (this is invariably an out of memory condition).
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. */
768 MSFT_ImpFile
*importfile
;
769 char *encoded_string
;
771 length
= ctl2_encode_string(This
, filename
, &encoded_string
);
773 encoded_string
[0] <<= 2;
774 encoded_string
[0] |= 1;
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
;
782 offset
= ctl2_alloc_segment(This
, MSFT_SEG_IMPORTFILES
, length
+ 0xc, 0);
783 if (offset
== -1) return -1;
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
);
794 /****************************************************************************
795 * ctl2_alloc_custdata
797 * Allocates and initializes a "custom data" value in a type library.
801 * Success: The offset of the new custdata.
805 * -2: Unable to encode VARIANT data (typically a bug).
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. */
813 TRACE("(%p,%p(%d))\n",This
,pVarVal
,V_VT(pVarVal
));
815 switch (V_VT(pVarVal
)) {
817 offset
= ctl2_alloc_segment(This
, MSFT_SEG_CUSTDATA
, 8, 0);
818 if (offset
== -1) return offset
;
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
);
825 FIXME("Unknown variable encoding vt %d.\n", V_VT(pVarVal
));
832 /****************************************************************************
835 * Adds a custom data element to an object in a type library.
840 * Failure: One of E_INVALIDARG or E_OUTOFMEMORY.
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. */
848 MSFT_GuidEntry guidentry
;
854 guidentry
.guid
= *guid
;
856 guidentry
.hreftype
= -1;
857 guidentry
.next_hash
= -1;
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
;
865 custoffset
= ctl2_alloc_segment(This
, MSFT_SEG_CUSTDATAGUID
, 12, 0);
866 if (custoffset
== -1) return E_OUTOFMEMORY
;
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
;
877 /****************************************************************************
878 * ctl2_encode_typedesc
880 * Encodes a type description, storing information in the TYPEDESC and ARRAYDESC
881 * segments as needed.
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. */
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
;
915 *encoded_tdesc
= default_tdesc
;
921 *encoded_tdesc
= 0x80000000 | (VT_I4
<< 16) | VT_INT
;
922 if ((This
->typelib_header
.varflags
& 0x0f) == SYS_WIN16
) {
932 *encoded_tdesc
= 0x80000000 | (VT_UI4
<< 16) | VT_UINT
;
933 if ((This
->typelib_header
.varflags
& 0x0f) == SYS_WIN16
) {
945 *encoded_tdesc
= default_tdesc
;
956 *encoded_tdesc
= default_tdesc
;
962 *encoded_tdesc
= default_tdesc
;
964 *alignment
= 4; /* guess? */
968 *encoded_tdesc
= 0x80000000 | (VT_EMPTY
<< 16) | tdesc
->vt
;
974 /* FIXME: Make with the error checking. */
975 FIXME("PTR vartype, may not work correctly.\n");
977 ctl2_encode_typedesc(This
, tdesc
->u
.lptdesc
, &target_type
, NULL
, NULL
, &child_size
);
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;
984 if (typeoffset
== This
->typelib_segdir
[MSFT_SEG_TYPEDESC
].length
) {
987 if (target_type
& 0x80000000) {
988 mix_field
= ((target_type
>> 16) & 0x3fff) | VT_BYREF
;
990 typedata
= (void *)&This
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][target_type
];
991 mix_field
= ((typedata
[0] >> 16) == 0x7fff)? 0x7fff: 0x7ffe;
994 typeoffset
= ctl2_alloc_segment(This
, MSFT_SEG_TYPEDESC
, 8, 0);
995 typedata
= (void *)&This
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][typeoffset
];
997 typedata
[0] = (mix_field
<< 16) | VT_PTR
;
998 typedata
[1] = target_type
;
1001 *encoded_tdesc
= typeoffset
;
1005 *decoded_size
= sizeof(TYPEDESC
) + child_size
;
1009 /* FIXME: Make with the error checking. */
1010 FIXME("SAFEARRAY vartype, may not work correctly.\n");
1012 ctl2_encode_typedesc(This
, tdesc
->u
.lptdesc
, &target_type
, NULL
, NULL
, &child_size
);
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;
1019 if (typeoffset
== This
->typelib_segdir
[MSFT_SEG_TYPEDESC
].length
) {
1022 if (target_type
& 0x80000000) {
1023 mix_field
= ((target_type
>> 16) & VT_TYPEMASK
) | VT_ARRAY
;
1025 typedata
= (void *)&This
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][target_type
];
1026 mix_field
= ((typedata
[0] >> 16) == 0x7fff)? 0x7fff: 0x7ffe;
1029 typeoffset
= ctl2_alloc_segment(This
, MSFT_SEG_TYPEDESC
, 8, 0);
1030 typedata
= (void *)&This
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][typeoffset
];
1032 typedata
[0] = (mix_field
<< 16) | VT_SAFEARRAY
;
1033 typedata
[1] = target_type
;
1036 *encoded_tdesc
= typeoffset
;
1040 *decoded_size
= sizeof(TYPEDESC
) + child_size
;
1045 /* FIXME: Make with the error checking. */
1046 int num_dims
= tdesc
->u
.lpadesc
->cDims
, elements
= 1, dim
;
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
];
1052 arraydata
[0] = target_type
;
1053 arraydata
[1] = num_dims
;
1054 arraydata
[1] |= ((num_dims
* 2 * sizeof(int)) << 16);
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
;
1063 typeoffset
= ctl2_alloc_segment(This
, MSFT_SEG_TYPEDESC
, 8, 0);
1064 typedata
= (void *)&This
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][typeoffset
];
1066 typedata
[0] = (0x7ffe << 16) | VT_CARRAY
;
1067 typedata
[1] = arrayoffset
;
1069 *encoded_tdesc
= typeoffset
;
1070 *width
= *width
* elements
;
1071 *decoded_size
= sizeof(ARRAYDESC
) + (num_dims
- 1) * sizeof(SAFEARRAYBOUND
);
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;
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
];
1086 typedata
[0] = (0x7fff << 16) | VT_USERDEFINED
;
1087 typedata
[1] = tdesc
->u
.hreftype
;
1090 *encoded_tdesc
= typeoffset
;
1096 FIXME("Unrecognized type %d.\n", tdesc
->vt
);
1097 *encoded_tdesc
= default_tdesc
;
1106 /****************************************************************************
1107 * ctl2_find_nth_reference
1109 * Finds a reference by index into the linked list of reference records.
1113 * Success: Offset of the desired reference record.
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. */
1121 MSFT_RefRecord
*ref
;
1123 for (; index
&& (offset
!= -1); index
--) {
1124 ref
= (MSFT_RefRecord
*)&This
->typelib_segment_data
[MSFT_SEG_REFERENCES
][offset
];
1125 offset
= ref
->onext
;
1131 /****************************************************************************
1132 * ctl2_find_typeinfo_from_offset
1134 * Finds an ITypeInfo given an offset into the TYPEINFO segment.
1139 * Failure: TYPE_E_ELEMENTNOTFOUND.
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. */
1147 ICreateTypeInfo2Impl
*typeinfo
;
1149 typeinfodata
= &This
->typelib_segment_data
[MSFT_SEG_TYPEINFO
][offset
];
1151 for (typeinfo
= This
->typeinfos
; typeinfo
; typeinfo
= typeinfo
->next_typeinfo
) {
1152 if (typeinfo
->typeinfo
== typeinfodata
) {
1153 *ppTinfo
= (ITypeInfo
*)&typeinfo
->lpVtblTypeInfo2
;
1154 ITypeInfo2_AddRef(*ppTinfo
);
1159 ERR("Failed to find typeinfo, invariant varied.\n");
1161 return TYPE_E_ELEMENTNOTFOUND
;
1164 /****************************************************************************
1165 * ctl2_add_default_value
1167 * Adds default value of an argument
1172 * Failure: Error code from winerror.h
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 */
1183 TRACE("%p %d %d\n", This
, V_VT(value
), arg_type
);
1185 if(arg_type
== VT_INT
)
1187 if(arg_type
== VT_UINT
)
1191 if(V_VT(value
) != arg_type
) {
1192 hres
= VariantChangeType(&v
, value
, 0, arg_type
);
1197 /* Check if default value can be stored in encoded_value */
1203 if(V_UI4(&v
)>0x3ffffff)
1214 *encoded_value
= (V_UI4(&v
)&mask
) | ((0x80+0x4*arg_type
)<<24);
1226 /* Construct the data to be allocated */
1228 data
[0] = arg_type
+ (V_UI4(&v
)<<16);
1229 data
[1] = (V_UI4(&v
)>>16) + 0x57570000;
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))
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
;
1242 memcpy(&This
->typelib_segment_data
[MSFT_SEG_CUSTDATA
][*encoded_value
], data
, 8);
1246 /* Construct the data */
1247 int i
, len
= (6+SysStringLen(V_BSTR(&v
))+3) & ~0x3;
1248 char *data
= HeapAlloc(GetProcessHeap(), 0, len
);
1251 return E_OUTOFMEMORY
;
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
];
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
++)
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
);
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
;
1279 memcpy(&This
->typelib_segment_data
[MSFT_SEG_CUSTDATA
][*encoded_value
], data
, len
);
1280 HeapFree(GetProcessHeap(), 0, data
);
1284 FIXME("Argument type not yet handled\n");
1289 /*================== ICreateTypeInfo2 Implementation ===================================*/
1291 /******************************************************************************
1292 * ICreateTypeInfo2_QueryInterface {OLEAUT32}
1294 * See IUnknown_QueryInterface.
1296 static HRESULT WINAPI
ICreateTypeInfo2_fnQueryInterface(
1297 ICreateTypeInfo2
* iface
,
1301 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
1303 TRACE("(%p)->(IID: %s)\n",This
,debugstr_guid(riid
));
1306 if(IsEqualIID(riid
, &IID_IUnknown
) ||
1307 IsEqualIID(riid
,&IID_ICreateTypeInfo
)||
1308 IsEqualIID(riid
,&IID_ICreateTypeInfo2
))
1311 } else if (IsEqualIID(riid
, &IID_ITypeInfo
) ||
1312 IsEqualIID(riid
, &IID_ITypeInfo2
)) {
1313 *ppvObject
= &This
->lpVtblTypeInfo2
;
1318 ICreateTypeInfo2_AddRef(iface
);
1319 TRACE("-- Interface: (%p)->(%p)\n",ppvObject
,*ppvObject
);
1322 TRACE("-- Interface: E_NOINTERFACE\n");
1323 return E_NOINTERFACE
;
1326 /******************************************************************************
1327 * ICreateTypeInfo2_AddRef {OLEAUT32}
1329 * See IUnknown_AddRef.
1331 static ULONG WINAPI
ICreateTypeInfo2_fnAddRef(ICreateTypeInfo2
*iface
)
1333 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
1334 ULONG ref
= InterlockedIncrement(&This
->ref
);
1336 TRACE("(%p)->ref was %u\n",This
, ref
- 1);
1338 if(ref
==1 && This
->typelib
)
1339 ICreateTypeLib2_AddRef((ICreateTypeLib2
*)This
->typelib
);
1344 /******************************************************************************
1345 * ICreateTypeInfo2_Release {OLEAUT32}
1347 * See IUnknown_Release.
1349 static ULONG WINAPI
ICreateTypeInfo2_fnRelease(ICreateTypeInfo2
*iface
)
1351 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
1352 ULONG ref
= InterlockedDecrement(&This
->ref
);
1354 TRACE("(%p)->(%u)\n",This
, 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; */
1363 /* ICreateTypeLib2 frees all ICreateTypeInfos when it releases. */
1364 /* HeapFree(GetProcessHeap(),0,This); */
1372 /******************************************************************************
1373 * ICreateTypeInfo2_SetGuid {OLEAUT32}
1375 * See ICreateTypeInfo_SetGuid.
1377 static HRESULT WINAPI
ICreateTypeInfo2_fnSetGuid(ICreateTypeInfo2
*iface
, REFGUID guid
)
1379 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
1381 MSFT_GuidEntry guidentry
;
1384 TRACE("(%p,%s)\n", iface
, debugstr_guid(guid
));
1386 guidentry
.guid
= *guid
;
1387 guidentry
.hreftype
= This
->typelib
->typelib_typeinfo_offsets
[This
->typeinfo
->typekind
>> 16];
1388 guidentry
.next_hash
= -1;
1390 offset
= ctl2_alloc_guid(This
->typelib
, &guidentry
);
1392 if (offset
== -1) return E_OUTOFMEMORY
;
1394 This
->typeinfo
->posguid
= offset
;
1396 if (IsEqualIID(guid
, &IID_IDispatch
)) {
1397 This
->typelib
->typelib_header
.dispatchpos
= This
->typelib
->typelib_typeinfo_offsets
[This
->typeinfo
->typekind
>> 16];
1403 /******************************************************************************
1404 * ICreateTypeInfo2_SetTypeFlags {OLEAUT32}
1406 * See ICreateTypeInfo_SetTypeFlags.
1408 static HRESULT WINAPI
ICreateTypeInfo2_fnSetTypeFlags(ICreateTypeInfo2
*iface
, UINT uTypeFlags
)
1410 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
1412 TRACE("(%p,0x%x)\n", iface
, uTypeFlags
);
1414 if(uTypeFlags
& TYPEFLAG_FDUAL
) {
1415 This
->typeinfo
->typekind
|= 0x10;
1416 This
->typeinfo
->typekind
&= ~0x0f;
1417 This
->typeinfo
->typekind
|= TKIND_DISPATCH
;
1420 This
->dual
= HeapAlloc(GetProcessHeap(), 0, sizeof(ICreateTypeInfo2Impl
));
1422 return E_OUTOFMEMORY
;
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
;
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
;
1436 if(This
->typelib
->typeinfos
== This
)
1437 This
->typelib
->typeinfos
= This
->dual
;
1439 ICreateTypeInfo2Impl
*iter
;
1441 for(iter
=This
->typelib
->typeinfos
; iter
->next_typeinfo
!=This
; iter
=iter
->next_typeinfo
);
1442 iter
->next_typeinfo
= This
->dual
;
1445 iface
= (ICreateTypeInfo2
*)&This
->dual
->lpVtbl
;
1448 if (uTypeFlags
& (TYPEFLAG_FDISPATCHABLE
|TYPEFLAG_FDUAL
)) {
1449 static const WCHAR stdole2tlb
[] = { 's','t','d','o','l','e','2','.','t','l','b',0 };
1451 ITypeInfo
*dispatch
;
1455 hres
= LoadTypeLib(stdole2tlb
, &stdole
);
1459 hres
= ITypeLib_GetTypeInfoOfGuid(stdole
, &IID_IDispatch
, &dispatch
);
1460 ITypeLib_Release(stdole
);
1464 hres
= ICreateTypeInfo2_AddRefTypeInfo(iface
, dispatch
, &hreftype
);
1465 ITypeInfo_Release(dispatch
);
1470 This
->typeinfo
->flags
= uTypeFlags
;
1474 /******************************************************************************
1475 * ICreateTypeInfo2_SetDocString {OLEAUT32}
1477 * See ICreateTypeInfo_SetDocString.
1479 static HRESULT WINAPI
ICreateTypeInfo2_fnSetDocString(
1480 ICreateTypeInfo2
* iface
,
1483 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
1487 TRACE("(%p,%s)\n", iface
, debugstr_w(pStrDoc
));
1489 return E_INVALIDARG
;
1491 offset
= ctl2_alloc_string(This
->typelib
, pStrDoc
);
1492 if (offset
== -1) return E_OUTOFMEMORY
;
1493 This
->typeinfo
->docstringoffs
= offset
;
1497 /******************************************************************************
1498 * ICreateTypeInfo2_SetHelpContext {OLEAUT32}
1500 * See ICreateTypeInfo_SetHelpContext.
1502 static HRESULT WINAPI
ICreateTypeInfo2_fnSetHelpContext(
1503 ICreateTypeInfo2
* iface
,
1504 DWORD dwHelpContext
)
1506 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
1508 TRACE("(%p,%d)\n", iface
, dwHelpContext
);
1510 This
->typeinfo
->helpcontext
= dwHelpContext
;
1515 /******************************************************************************
1516 * ICreateTypeInfo2_SetVersion {OLEAUT32}
1518 * See ICreateTypeInfo_SetVersion.
1520 static HRESULT WINAPI
ICreateTypeInfo2_fnSetVersion(
1521 ICreateTypeInfo2
* iface
,
1525 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
1527 TRACE("(%p,%d,%d)\n", iface
, wMajorVerNum
, wMinorVerNum
);
1529 This
->typeinfo
->version
= wMajorVerNum
| (wMinorVerNum
<< 16);
1533 /******************************************************************************
1534 * ICreateTypeInfo2_AddRefTypeInfo {OLEAUT32}
1536 * See ICreateTypeInfo_AddRefTypeInfo.
1538 static HRESULT WINAPI
ICreateTypeInfo2_fnAddRefTypeInfo(
1539 ICreateTypeInfo2
* iface
,
1541 HREFTYPE
* phRefType
)
1543 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
1545 ITypeLib
*container
;
1549 TRACE("(%p,%p,%p)\n", iface
, pTInfo
, phRefType
);
1551 if(!pTInfo
|| !phRefType
)
1552 return E_INVALIDARG
;
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...
1559 res
= ITypeInfo_GetContainingTypeLib(pTInfo
, &container
, &index
);
1561 TRACE("failed to find containing typelib.\n");
1565 if (container
== (ITypeLib
*)&This
->typelib
->lpVtblTypeLib2
) {
1566 /* Process locally defined TypeInfo */
1567 *phRefType
= This
->typelib
->typelib_typeinfo_offsets
[index
];
1573 MSFT_GuidEntry guid
, *check_guid
;
1574 MSFT_ImpInfo impinfo
;
1575 int guid_offset
, import_offset
;
1578 /* Allocate container GUID */
1579 hres
= ITypeLib_GetLibAttr(container
, &tlibattr
);
1581 ITypeLib_Release(container
);
1585 guid
.guid
= tlibattr
->guid
;
1586 guid
.hreftype
= This
->typelib
->typelib_guids
*12+2;
1587 guid
.next_hash
= -1;
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
;
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
++;
1600 /* Get import file name */
1601 hres
= QueryPathOfRegTypeLib(&guid
.guid
, tlibattr
->wMajorVerNum
,
1602 tlibattr
->wMinorVerNum
, tlibattr
->lcid
, &name
);
1604 ITypeLib_ReleaseTLibAttr(container
, tlibattr
);
1605 ITypeLib_Release(container
);
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
);
1615 if(import_offset
== -1) {
1616 ITypeLib_Release(container
);
1617 return E_OUTOFMEMORY
;
1620 /* Allocate referenced guid */
1621 hres
= ITypeInfo_GetTypeAttr(pTInfo
, &typeattr
);
1623 ITypeLib_Release(container
);
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
);
1633 guid_offset
= ctl2_alloc_guid(This
->typelib
, &guid
);
1634 if(guid_offset
== -1) {
1635 ITypeLib_Release(container
);
1636 return E_OUTOFMEMORY
;
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
++;
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;
1649 if(!memcmp(&guid
.guid
, &IID_IDispatch
, sizeof(GUID
)))
1650 This
->typelib
->typelib_header
.dispatchpos
= *phRefType
;
1653 ITypeLib_Release(container
);
1657 /******************************************************************************
1658 * ICreateTypeInfo2_AddFuncDesc {OLEAUT32}
1660 * See ICreateTypeInfo_AddFuncDesc.
1662 static HRESULT WINAPI
ICreateTypeInfo2_fnAddFuncDesc(
1663 ICreateTypeInfo2
* iface
,
1665 FUNCDESC
* pFuncDesc
)
1667 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
1669 CyclicList
*iter
, *insert
;
1671 int i
, num_defaults
= 0;
1675 TRACE("(%p,%d,%p)\n", iface
, index
, pFuncDesc
);
1677 if(!pFuncDesc
|| pFuncDesc
->oVft
&3)
1678 return E_INVALIDARG
;
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
);
1686 if(pFuncDesc
->cParamsOpt
|| pFuncDesc
->cScodes
)
1687 FIXME("Unimplemented parameter - created typelib will be incorrect\n");
1689 switch(This
->typekind
) {
1691 if(pFuncDesc
->funckind
!= FUNC_STATIC
)
1692 return TYPE_E_BADMODULEKIND
;
1694 case TKIND_DISPATCH
:
1695 if(pFuncDesc
->funckind
!= FUNC_DISPATCH
)
1696 return TYPE_E_BADMODULEKIND
;
1699 if(pFuncDesc
->funckind
!= FUNC_PUREVIRTUAL
)
1700 return TYPE_E_BADMODULEKIND
;
1703 if(This
->typeinfo
->cElement
<index
)
1704 return TYPE_E_ELEMENTNOTFOUND
;
1706 if((pFuncDesc
->invkind
&(INVOKE_PROPERTYPUT
|INVOKE_PROPERTYPUTREF
)) &&
1707 !pFuncDesc
->cParams
)
1708 return TYPE_E_INCONSISTENTPROPFUNCS
;
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
)
1715 if (!This
->typedata
) {
1716 This
->typedata
= HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList
));
1718 return E_OUTOFMEMORY
;
1720 This
->typedata
->next
= This
->typedata
;
1721 This
->typedata
->u
.val
= 0;
1724 This
->dual
->typedata
= This
->typedata
;
1727 /* allocate type data space for us */
1728 insert
= HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList
));
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
;
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
;
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;
1752 /* add default values */
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
);
1761 HeapFree(GetProcessHeap(), 0, insert
->u
.data
);
1762 HeapFree(GetProcessHeap(), 0, insert
);
1766 typedata
[6+i
] = 0xffffffff;
1768 num_defaults
= pFuncDesc
->cParams
;
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;
1780 /* update the index data */
1781 insert
->indice
= pFuncDesc
->memid
;
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
;
1791 This
->dual
->typedata
= This
->typedata
;
1793 iter
= This
->typedata
->next
;
1794 for(i
=0; i
<index
; i
++)
1797 insert
->next
= iter
->next
;
1798 iter
->next
= insert
;
1801 /* update type data size */
1802 This
->typedata
->next
->u
.val
+= 0x18 + pFuncDesc
->cParams
*(num_defaults
?16:12);
1804 /* Increment the number of function elements */
1805 This
->typeinfo
->cElement
+= 1;
1810 /******************************************************************************
1811 * ICreateTypeInfo2_AddImplType {OLEAUT32}
1813 * See ICreateTypeInfo_AddImplType.
1815 static HRESULT WINAPI
ICreateTypeInfo2_fnAddImplType(
1816 ICreateTypeInfo2
* iface
,
1820 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
1822 TRACE("(%p,%d,%d)\n", iface
, index
, hRefType
);
1824 if (This
->typekind
== TKIND_COCLASS
) {
1826 MSFT_RefRecord
*ref
;
1829 if (This
->typeinfo
->datatype1
!= -1) return TYPE_E_ELEMENTNOTFOUND
;
1831 offset
= ctl2_alloc_segment(This
->typelib
, MSFT_SEG_REFERENCES
, sizeof(MSFT_RefRecord
), 0);
1832 if (offset
== -1) return E_OUTOFMEMORY
;
1834 This
->typeinfo
->datatype1
= offset
;
1838 lastoffset
= ctl2_find_nth_reference(This
->typelib
, This
->typeinfo
->datatype1
, index
- 1);
1839 if (lastoffset
== -1) return TYPE_E_ELEMENTNOTFOUND
;
1841 ref
= (MSFT_RefRecord
*)&This
->typelib
->typelib_segment_data
[MSFT_SEG_REFERENCES
][lastoffset
];
1842 if (ref
->onext
!= -1) return TYPE_E_ELEMENTNOTFOUND
;
1844 offset
= ctl2_alloc_segment(This
->typelib
, MSFT_SEG_REFERENCES
, sizeof(MSFT_RefRecord
), 0);
1845 if (offset
== -1) return E_OUTOFMEMORY
;
1847 ref
->onext
= offset
;
1850 ref
= (MSFT_RefRecord
*)&This
->typelib
->typelib_segment_data
[MSFT_SEG_REFERENCES
][offset
];
1852 ref
->reftype
= hRefType
;
1854 ref
->oCustData
= -1;
1856 } else if (This
->typekind
== TKIND_INTERFACE
) {
1857 if (This
->typeinfo
->cImplTypes
&& index
==1)
1858 return TYPE_E_BADMODULEKIND
;
1860 if( index
!= 0) return TYPE_E_ELEMENTNOTFOUND
;
1862 This
->typeinfo
->datatype1
= hRefType
;
1863 } else if (This
->typekind
== TKIND_DISPATCH
) {
1864 FIXME("dispatch case unhandled.\n");
1866 FIXME("AddImplType unsupported on typekind %d\n", This
->typekind
);
1867 return E_OUTOFMEMORY
;
1870 This
->typeinfo
->cImplTypes
++;
1874 /******************************************************************************
1875 * ICreateTypeInfo2_SetImplTypeFlags {OLEAUT32}
1877 * See ICreateTypeInfo_SetImplTypeFlags.
1879 static HRESULT WINAPI
ICreateTypeInfo2_fnSetImplTypeFlags(
1880 ICreateTypeInfo2
* iface
,
1884 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
1886 MSFT_RefRecord
*ref
;
1888 TRACE("(%p,%d,0x%x)\n", iface
, index
, implTypeFlags
);
1890 if (This
->typekind
!= TKIND_COCLASS
) {
1891 return TYPE_E_BADMODULEKIND
;
1894 offset
= ctl2_find_nth_reference(This
->typelib
, This
->typeinfo
->datatype1
, index
);
1895 if (offset
== -1) return TYPE_E_ELEMENTNOTFOUND
;
1897 ref
= (MSFT_RefRecord
*)&This
->typelib
->typelib_segment_data
[MSFT_SEG_REFERENCES
][offset
];
1898 ref
->flags
= implTypeFlags
;
1903 /******************************************************************************
1904 * ICreateTypeInfo2_SetAlignment {OLEAUT32}
1906 * See ICreateTypeInfo_SetAlignment.
1908 static HRESULT WINAPI
ICreateTypeInfo2_fnSetAlignment(
1909 ICreateTypeInfo2
* iface
,
1912 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
1914 TRACE("(%p,%d)\n", iface
, cbAlignment
);
1916 if (!cbAlignment
) return E_INVALIDARG
;
1917 if (cbAlignment
> 16) return E_INVALIDARG
;
1919 This
->typeinfo
->typekind
&= ~0xffc0;
1920 This
->typeinfo
->typekind
|= cbAlignment
<< 6;
1922 /* FIXME: There's probably some way to simplify this. */
1923 switch (This
->typekind
) {
1929 case TKIND_INTERFACE
:
1930 case TKIND_DISPATCH
:
1932 if (cbAlignment
> 4) cbAlignment
= 4;
1942 This
->typeinfo
->typekind
|= cbAlignment
<< 11;
1947 /******************************************************************************
1948 * ICreateTypeInfo2_SetSchema {OLEAUT32}
1950 * See ICreateTypeInfo_SetSchema.
1952 static HRESULT WINAPI
ICreateTypeInfo2_fnSetSchema(
1953 ICreateTypeInfo2
* iface
,
1954 LPOLESTR pStrSchema
)
1956 FIXME("(%p,%s), stub!\n", iface
, debugstr_w(pStrSchema
));
1957 return E_OUTOFMEMORY
;
1960 /******************************************************************************
1961 * ICreateTypeInfo2_AddVarDesc {OLEAUT32}
1963 * See ICreateTypeInfo_AddVarDesc.
1965 static HRESULT WINAPI
ICreateTypeInfo2_fnAddVarDesc(
1966 ICreateTypeInfo2
* iface
,
1970 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
1979 TRACE("(%p,%d,%p), stub!\n", iface
, index
, pVarDesc
);
1980 TRACE("%d, %p, %d, {{%x, %d}, {%p, %x}}, 0x%x, %d\n", pVarDesc
->memid
, pVarDesc
->lpstrSchema
, pVarDesc
->u
.oInst
,
1981 pVarDesc
->elemdescVar
.tdesc
.u
.hreftype
, pVarDesc
->elemdescVar
.tdesc
.vt
,
1982 pVarDesc
->elemdescVar
.u
.paramdesc
.pparamdescex
, pVarDesc
->elemdescVar
.u
.paramdesc
.wParamFlags
,
1983 pVarDesc
->wVarFlags
, pVarDesc
->varkind
);
1985 if ((This
->typeinfo
->cElement
>> 16) != index
) {
1986 TRACE("Out-of-order element.\n");
1987 return TYPE_E_ELEMENTNOTFOUND
;
1990 if (!This
->typedata
) {
1991 This
->typedata
= HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList
));
1993 return E_OUTOFMEMORY
;
1995 This
->typedata
->next
= This
->typedata
;
1996 This
->typedata
->u
.val
= 0;
1999 This
->dual
->typedata
= This
->typedata
;
2002 /* allocate type data space for us */
2003 insert
= HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList
));
2005 return E_OUTOFMEMORY
;
2006 insert
->u
.data
= HeapAlloc(GetProcessHeap(), 0, sizeof(int[5]));
2007 if(!insert
->u
.data
) {
2008 HeapFree(GetProcessHeap(), 0, insert
);
2009 return E_OUTOFMEMORY
;
2012 insert
->next
= This
->typedata
->next
;
2013 This
->typedata
->next
= insert
;
2014 This
->typedata
= insert
;
2017 This
->dual
->typedata
= This
->typedata
;
2019 This
->typedata
->next
->u
.val
+= 0x14;
2020 typedata
= This
->typedata
->u
.data
;
2022 /* fill out the basic type information */
2023 typedata
[0] = 0x14 | (index
<< 16);
2024 typedata
[2] = pVarDesc
->wVarFlags
;
2025 typedata
[3] = (sizeof(VARDESC
) << 16) | 0;
2027 /* update the index data */
2028 insert
->indice
= 0x40000000 + index
;
2031 /* figure out type widths and whatnot */
2032 ctl2_encode_typedesc(This
->typelib
, &pVarDesc
->elemdescVar
.tdesc
,
2033 &typedata
[1], &var_datawidth
, &var_alignment
,
2036 /* pad out starting position to data width */
2037 This
->datawidth
+= var_alignment
- 1;
2038 This
->datawidth
&= ~(var_alignment
- 1);
2039 typedata
[4] = This
->datawidth
;
2041 /* add the new variable to the total data width */
2042 This
->datawidth
+= var_datawidth
;
2044 This
->dual
->datawidth
= This
->datawidth
;
2046 /* add type description size to total required allocation */
2047 typedata
[3] += var_type_size
<< 16;
2049 /* fix type alignment */
2050 alignment
= (This
->typeinfo
->typekind
>> 11) & 0x1f;
2051 if (alignment
< var_alignment
) {
2052 alignment
= var_alignment
;
2053 This
->typeinfo
->typekind
&= ~0xf800;
2054 This
->typeinfo
->typekind
|= alignment
<< 11;
2058 if (!This
->typeinfo
->res2
) This
->typeinfo
->res2
= 0x1a;
2059 if ((index
== 0) || (index
== 1) || (index
== 2) || (index
== 4) || (index
== 9)) {
2060 This
->typeinfo
->res2
<<= 1;
2064 if (This
->typeinfo
->res3
== -1) This
->typeinfo
->res3
= 0;
2065 This
->typeinfo
->res3
+= 0x2c;
2067 /* increment the number of variable elements */
2068 This
->typeinfo
->cElement
+= 0x10000;
2070 /* pad data width to alignment */
2071 This
->typeinfo
->size
= (This
->datawidth
+ (alignment
- 1)) & ~(alignment
- 1);
2076 /******************************************************************************
2077 * ICreateTypeInfo2_SetFuncAndParamNames {OLEAUT32}
2079 * See ICreateTypeInfo_SetFuncAndParamNames.
2081 static HRESULT WINAPI
ICreateTypeInfo2_fnSetFuncAndParamNames(
2082 ICreateTypeInfo2
* iface
,
2084 LPOLESTR
* rgszNames
,
2087 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
2088 CyclicList
*iter
= NULL
, *iter2
;
2089 int offset
, len
, i
=0;
2092 TRACE("(%p %d %p %d)\n", iface
, index
, rgszNames
, cNames
);
2095 return E_INVALIDARG
;
2097 if(index
>= This
->typeinfo
->cElement
|| !cNames
)
2098 return TYPE_E_ELEMENTNOTFOUND
;
2100 len
= ctl2_encode_name(This
->typelib
, rgszNames
[0], &namedata
);
2101 for(iter2
=This
->typedata
->next
->next
; iter2
!=This
->typedata
->next
; iter2
=iter2
->next
) {
2104 else if(iter2
->name
!=-1 && !memcmp(namedata
,
2105 This
->typelib
->typelib_segment_data
[MSFT_SEG_NAME
]+iter2
->name
+8, len
))
2106 return TYPE_E_AMBIGUOUSNAME
;
2111 /* cNames == cParams for put or putref accessor, cParams+1 otherwise */
2112 if(cNames
!= iter
->u
.data
[5] + ((iter
->u
.data
[4]>>3)&(INVOKE_PROPERTYPUT
|INVOKE_PROPERTYPUTREF
) ? 0 : 1))
2113 return TYPE_E_ELEMENTNOTFOUND
;
2115 offset
= ctl2_alloc_name(This
->typelib
, rgszNames
[0]);
2117 return E_OUTOFMEMORY
;
2119 iter
->name
= offset
;
2121 namedata
= This
->typelib
->typelib_segment_data
[MSFT_SEG_NAME
] + offset
;
2122 *((INT
*)namedata
) = This
->typelib
->typelib_typeinfo_offsets
[This
->typeinfo
->typekind
>> 16];
2124 if(iter
->u
.data
[4]&0x1000)
2125 len
= iter
->u
.data
[5];
2129 for (i
= 1; i
< cNames
; i
++) {
2130 offset
= ctl2_alloc_name(This
->typelib
, rgszNames
[i
]);
2131 iter
->u
.data
[(i
*3) + 4 + len
] = offset
;
2137 /******************************************************************************
2138 * ICreateTypeInfo2_SetVarName {OLEAUT32}
2140 * See ICreateTypeInfo_SetVarName.
2142 static HRESULT WINAPI
ICreateTypeInfo2_fnSetVarName(
2143 ICreateTypeInfo2
* iface
,
2147 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
2152 TRACE("(%p,%d,%s), stub!\n", iface
, index
, debugstr_w(szName
));
2154 if ((This
->typeinfo
->cElement
>> 16) <= index
) {
2155 TRACE("Out-of-order element.\n");
2156 return TYPE_E_ELEMENTNOTFOUND
;
2159 offset
= ctl2_alloc_name(This
->typelib
, szName
);
2160 if (offset
== -1) return E_OUTOFMEMORY
;
2162 namedata
= This
->typelib
->typelib_segment_data
[MSFT_SEG_NAME
] + offset
;
2163 if (*((INT
*)namedata
) == -1) {
2164 *((INT
*)namedata
) = This
->typelib
->typelib_typeinfo_offsets
[This
->typeinfo
->typekind
>> 16];
2165 namedata
[9] |= 0x10;
2167 if (This
->typekind
== TKIND_ENUM
) {
2168 namedata
[9] |= 0x20;
2171 iter
= This
->typedata
->next
->next
;
2172 for(i
=0; i
<index
; i
++)
2175 iter
->name
= offset
;
2179 /******************************************************************************
2180 * ICreateTypeInfo2_SetTypeDescAlias {OLEAUT32}
2182 * See ICreateTypeInfo_SetTypeDescAlias.
2184 static HRESULT WINAPI
ICreateTypeInfo2_fnSetTypeDescAlias(
2185 ICreateTypeInfo2
* iface
,
2186 TYPEDESC
* pTDescAlias
)
2188 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
2190 int encoded_typedesc
;
2193 if (This
->typekind
!= TKIND_ALIAS
) {
2194 return TYPE_E_WRONGTYPEKIND
;
2197 FIXME("(%p,%p), hack!\n", iface
, pTDescAlias
);
2199 if (ctl2_encode_typedesc(This
->typelib
, pTDescAlias
, &encoded_typedesc
, &width
, NULL
, NULL
) == -1) {
2200 return E_OUTOFMEMORY
;
2203 This
->typeinfo
->size
= width
;
2204 This
->typeinfo
->datatype1
= encoded_typedesc
;
2209 /******************************************************************************
2210 * ICreateTypeInfo2_DefineFuncAsDllEntry {OLEAUT32}
2212 * See ICreateTypeInfo_DefineFuncAsDllEntry.
2214 static HRESULT WINAPI
ICreateTypeInfo2_fnDefineFuncAsDllEntry(
2215 ICreateTypeInfo2
* iface
,
2218 LPOLESTR szProcName
)
2220 FIXME("(%p,%d,%s,%s), stub!\n", iface
, index
, debugstr_w(szDllName
), debugstr_w(szProcName
));
2221 return E_OUTOFMEMORY
;
2224 /******************************************************************************
2225 * ICreateTypeInfo2_SetFuncDocString {OLEAUT32}
2227 * See ICreateTypeInfo_SetFuncDocString.
2229 static HRESULT WINAPI
ICreateTypeInfo2_fnSetFuncDocString(
2230 ICreateTypeInfo2
* iface
,
2232 LPOLESTR szDocString
)
2234 FIXME("(%p,%d,%s), stub!\n", iface
, index
, debugstr_w(szDocString
));
2235 return E_OUTOFMEMORY
;
2238 /******************************************************************************
2239 * ICreateTypeInfo2_SetVarDocString {OLEAUT32}
2241 * See ICreateTypeInfo_SetVarDocString.
2243 static HRESULT WINAPI
ICreateTypeInfo2_fnSetVarDocString(
2244 ICreateTypeInfo2
* iface
,
2246 LPOLESTR szDocString
)
2248 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
2250 FIXME("(%p,%d,%s), stub!\n", iface
, index
, debugstr_w(szDocString
));
2252 ctl2_alloc_string(This
->typelib
, szDocString
);
2254 return E_OUTOFMEMORY
;
2257 /******************************************************************************
2258 * ICreateTypeInfo2_SetFuncHelpContext {OLEAUT32}
2260 * See ICreateTypeInfo_SetFuncHelpContext.
2262 static HRESULT WINAPI
ICreateTypeInfo2_fnSetFuncHelpContext(
2263 ICreateTypeInfo2
* iface
,
2265 DWORD dwHelpContext
)
2267 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
2272 TRACE("(%p,%d,%d)\n", iface
, index
, dwHelpContext
);
2274 if(This
->typeinfo
->cElement
<index
)
2275 return TYPE_E_ELEMENTNOTFOUND
;
2277 if(This
->typeinfo
->cElement
== index
)
2278 func
= This
->typedata
;
2280 for(func
=This
->typedata
->next
->next
; func
!=This
->typedata
; func
=func
->next
)
2284 typedata
= func
->u
.data
;
2286 /* Compute func size without arguments */
2287 size
= typedata
[0] - typedata
[5]*(typedata
[4]&0x1000?16:12);
2289 /* Allocate memory for HelpContext if needed */
2290 if(size
< 7*sizeof(int)) {
2291 typedata
= HeapReAlloc(GetProcessHeap(), 0, typedata
, typedata
[0]+sizeof(int));
2293 return E_OUTOFMEMORY
;
2295 memmove(&typedata
[7], &typedata
[6], typedata
[0]-sizeof(int)*6);
2296 typedata
[0] += sizeof(int);
2297 This
->typedata
->next
->u
.val
+= sizeof(int);
2298 func
->u
.data
= typedata
;
2301 typedata
[6] = dwHelpContext
;
2305 /******************************************************************************
2306 * ICreateTypeInfo2_SetVarHelpContext {OLEAUT32}
2308 * See ICreateTypeInfo_SetVarHelpContext.
2310 static HRESULT WINAPI
ICreateTypeInfo2_fnSetVarHelpContext(
2311 ICreateTypeInfo2
* iface
,
2313 DWORD dwHelpContext
)
2315 FIXME("(%p,%d,%d), stub!\n", iface
, index
, dwHelpContext
);
2316 return E_OUTOFMEMORY
;
2319 /******************************************************************************
2320 * ICreateTypeInfo2_SetMops {OLEAUT32}
2322 * See ICreateTypeInfo_SetMops.
2324 static HRESULT WINAPI
ICreateTypeInfo2_fnSetMops(
2325 ICreateTypeInfo2
* iface
,
2329 FIXME("(%p,%d,%p), stub!\n", iface
, index
, bstrMops
);
2330 return E_OUTOFMEMORY
;
2333 /******************************************************************************
2334 * ICreateTypeInfo2_SetTypeIdldesc {OLEAUT32}
2336 * See ICreateTypeInfo_SetTypeIdldesc.
2338 static HRESULT WINAPI
ICreateTypeInfo2_fnSetTypeIdldesc(
2339 ICreateTypeInfo2
* iface
,
2342 FIXME("(%p,%p), stub!\n", iface
, pIdlDesc
);
2343 return E_OUTOFMEMORY
;
2346 /******************************************************************************
2347 * ICreateTypeInfo2_LayOut {OLEAUT32}
2349 * See ICreateTypeInfo_LayOut.
2351 static HRESULT WINAPI
ICreateTypeInfo2_fnLayOut(
2352 ICreateTypeInfo2
* iface
)
2354 ICreateTypeInfo2Impl
*This
= (ICreateTypeInfo2Impl
*)iface
;
2355 CyclicList
*iter
, *iter2
, **typedata
;
2358 unsigned user_vft
= 0;
2361 TRACE("(%p)\n", iface
);
2363 /* FIXME: LayOut should be run on all ImplTypes */
2364 if(This
->typekind
== TKIND_COCLASS
)
2367 /* Validate inheritance */
2368 This
->typeinfo
->datatype2
= 0;
2369 hreftype
= This
->typeinfo
->datatype1
;
2371 /* Process internally defined interfaces */
2372 for(i
=0; i
<This
->typelib
->typelib_header
.nrtypeinfos
; i
++) {
2373 MSFT_TypeInfoBase
*header
;
2378 header
= (MSFT_TypeInfoBase
*)&(This
->typelib
->typelib_segment_data
[MSFT_SEG_TYPEINFO
][hreftype
]);
2379 This
->typeinfo
->datatype2
+= (header
->cElement
<<16) + 1;
2380 hreftype
= header
->datatype1
;
2382 if(i
== This
->typelib
->typelib_header
.nrtypeinfos
)
2383 return TYPE_E_CIRCULARTYPE
;
2385 /* Process externally defined interfaces */
2386 if(hreftype
!= -1) {
2387 ITypeInfo
*cur
, *next
;
2390 hres
= ICreateTypeInfo_QueryInterface(iface
, &IID_ITypeInfo
, (void**)&next
);
2394 hres
= ITypeInfo_GetRefTypeInfo(next
, hreftype
, &cur
);
2395 ITypeInfo_Release(next
);
2401 hres
= ITypeInfo_GetTypeAttr(cur
, &typeattr
);
2403 ITypeInfo_Release(cur
);
2407 if(!memcmp(&typeattr
->guid
, &IID_IDispatch
, sizeof(IDispatch
)))
2408 This
->typeinfo
->flags
|= TYPEFLAG_FDISPATCHABLE
;
2410 This
->typeinfo
->datatype2
+= (typeattr
->cFuncs
<<16) + 1;
2411 ITypeInfo_ReleaseTypeAttr(cur
, typeattr
);
2413 hres
= ITypeInfo_GetRefTypeOfImplType(cur
, 0, &hreftype
);
2414 if(hres
== TYPE_E_ELEMENTNOTFOUND
)
2417 ITypeInfo_Release(cur
);
2421 hres
= ITypeInfo_GetRefTypeInfo(cur
, hreftype
, &next
);
2423 ITypeInfo_Release(cur
);
2427 ITypeInfo_Release(cur
);
2430 ITypeInfo_Release(cur
);
2433 /* Get cbSizeVft of inherited interface */
2434 /* Makes LayOut running recursively */
2435 if(This
->typeinfo
->datatype1
!= -1) {
2436 ITypeInfo
*cur
, *inherited
;
2439 hres
= ICreateTypeInfo_QueryInterface(iface
, &IID_ITypeInfo
, (void**)&cur
);
2443 hres
= ITypeInfo_GetRefTypeInfo(cur
, This
->typeinfo
->datatype1
, &inherited
);
2444 ITypeInfo_Release(cur
);
2448 hres
= ITypeInfo_GetTypeAttr(inherited
, &typeattr
);
2450 ITypeInfo_Release(inherited
);
2454 This
->typeinfo
->cbSizeVft
= typeattr
->cbSizeVft
;
2456 ITypeInfo_ReleaseTypeAttr(inherited
, typeattr
);
2457 ITypeInfo_Release(inherited
);
2459 This
->typeinfo
->cbSizeVft
= 0;
2464 typedata
= HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList
*)*(This
->typeinfo
->cElement
&0xffff));
2466 return E_OUTOFMEMORY
;
2468 /* Assign IDs and VTBL entries */
2470 if(This
->typedata
->u
.data
[3]&1)
2471 user_vft
= This
->typedata
->u
.data
[3]&0xffff;
2473 for(iter
=This
->typedata
->next
->next
; iter
!=This
->typedata
->next
; iter
=iter
->next
) {
2474 /* Assign MEMBERID if MEMBERID_NIL was specified */
2475 if(iter
->indice
== MEMBERID_NIL
) {
2476 iter
->indice
= 0x60000000 + i
+ (This
->typeinfo
->datatype2
<<16);
2478 for(iter2
=This
->typedata
->next
->next
; iter2
!=This
->typedata
->next
; iter2
=iter2
->next
) {
2479 if(iter
== iter2
) continue;
2480 if(iter2
->indice
== iter
->indice
) {
2481 iter
->indice
= 0x5fffffff + This
->typeinfo
->cElement
+ i
+ (This
->typeinfo
->datatype2
<<16);
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 HeapFree(GetProcessHeap(), 0, typedata
);
2487 return E_ACCESSDENIED
;
2498 iter
->u
.data
[0] = (iter
->u
.data
[0]&0xffff) | (i
<<16);
2500 if((iter
->u
.data
[3]&1) != (user_vft
&1)) {
2501 HeapFree(GetProcessHeap(), 0, typedata
);
2502 return TYPE_E_INVALIDID
;
2506 if(user_vft
< (iter
->u
.data
[3]&0xffff))
2507 user_vft
= (iter
->u
.data
[3]&0xffff);
2509 if((iter
->u
.data
[3]&0xffff) < This
->typeinfo
->cbSizeVft
) {
2510 HeapFree(GetProcessHeap(), 0, typedata
);
2511 return TYPE_E_INVALIDID
;
2513 } else if(This
->typekind
!= TKIND_MODULE
) {
2514 iter
->u
.data
[3] = (iter
->u
.data
[3]&0xffff0000) | This
->typeinfo
->cbSizeVft
;
2515 This
->typeinfo
->cbSizeVft
+= 4;
2518 /* Construct a list of elements with the same memberid */
2519 iter
->u
.data
[4] = (iter
->u
.data
[4]&0xffff) | (i
<<16);
2520 for(iter2
=This
->typedata
->next
->next
; iter2
!=iter
; iter2
=iter2
->next
) {
2521 if(iter
->indice
== iter2
->indice
) {
2524 v1
= iter
->u
.data
[4] >> 16;
2525 v2
= iter2
->u
.data
[4] >> 16;
2527 iter
->u
.data
[4] = (iter
->u
.data
[4]&0xffff) | (v2
<<16);
2528 iter2
->u
.data
[4] = (iter2
->u
.data
[4]&0xffff) | (v1
<<16);
2537 This
->typeinfo
->cbSizeVft
= user_vft
+3;
2539 for(i
=0; i
<(This
->typeinfo
->cElement
&0xffff); i
++) {
2540 if(typedata
[i
]->u
.data
[4]>>16 > i
) {
2543 inv
= (typedata
[i
]->u
.data
[4]>>3) & 0xf;
2544 i
= typedata
[i
]->u
.data
[4] >> 16;
2546 while(i
> typedata
[i
]->u
.data
[4]>>16) {
2547 int invkind
= (typedata
[i
]->u
.data
[4]>>3) & 0xf;
2550 HeapFree(GetProcessHeap(), 0, typedata
);
2551 return TYPE_E_DUPLICATEID
;
2554 i
= typedata
[i
]->u
.data
[4] >> 16;
2558 if(inv
& INVOKE_FUNC
) {
2559 HeapFree(GetProcessHeap(), 0, typedata
);
2560 return TYPE_E_INCONSISTENTPROPFUNCS
;
2565 HeapFree(GetProcessHeap(), 0, typedata
);
2569 /******************************************************************************
2570 * ICreateTypeInfo2_DeleteFuncDesc {OLEAUT32}
2572 * Delete a function description from a type.
2577 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2579 static HRESULT WINAPI
ICreateTypeInfo2_fnDeleteFuncDesc(
2580 ICreateTypeInfo2
* iface
, /* [I] The typeinfo from which to delete a function. */
2581 UINT index
) /* [I] The index of the function to delete. */
2583 FIXME("(%p,%d), stub!\n", iface
, index
);
2584 return E_OUTOFMEMORY
;
2587 /******************************************************************************
2588 * ICreateTypeInfo2_DeleteFuncDescByMemId {OLEAUT32}
2590 * Delete a function description from a type.
2595 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2597 static HRESULT WINAPI
ICreateTypeInfo2_fnDeleteFuncDescByMemId(
2598 ICreateTypeInfo2
* iface
, /* [I] The typeinfo from which to delete a function. */
2599 MEMBERID memid
, /* [I] The member id of the function to delete. */
2600 INVOKEKIND invKind
) /* [I] The invocation type of the function to delete. (?) */
2602 FIXME("(%p,%d,%d), stub!\n", iface
, memid
, invKind
);
2603 return E_OUTOFMEMORY
;
2606 /******************************************************************************
2607 * ICreateTypeInfo2_DeleteVarDesc {OLEAUT32}
2609 * Delete a variable description from a type.
2614 * Failure: One of E_OUTOFMEMORY, E_INVALIDARG, TYPE_E_IOERROR,
2615 * TYPE_E_INVDATAREAD, TYPE_E_UNSUPFORMAT or TYPE_E_INVALIDSTATE.
2617 static HRESULT WINAPI
ICreateTypeInfo2_fnDeleteVarDesc(
2618 ICreateTypeInfo2
* iface
, /* [I] The typeinfo from which to delete the variable description. */
2619 UINT index
) /* [I] The index of the variable description to delete. */
2621 FIXME("(%p,%d), stub!\n", iface
, index
);
2622 return E_OUTOFMEMORY
;
2625 /******************************************************************************
2626 * ICreateTypeInfo2_DeleteVarDescByMemId {OLEAUT32}
2628 * Delete a variable description from a type.
2633 * Failure: One of E_OUTOFMEMORY, E_INVALIDARG, TYPE_E_IOERROR,
2634 * TYPE_E_INVDATAREAD, TYPE_E_UNSUPFORMAT or TYPE_E_INVALIDSTATE.
2636 static HRESULT WINAPI
ICreateTypeInfo2_fnDeleteVarDescByMemId(
2637 ICreateTypeInfo2
* iface
, /* [I] The typeinfo from which to delete the variable description. */
2638 MEMBERID memid
) /* [I] The member id of the variable description to delete. */
2640 FIXME("(%p,%d), stub!\n", iface
, memid
);
2641 return E_OUTOFMEMORY
;
2644 /******************************************************************************
2645 * ICreateTypeInfo2_DeleteImplType {OLEAUT32}
2647 * Delete an interface implementation from a type. (?)
2652 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2654 static HRESULT WINAPI
ICreateTypeInfo2_fnDeleteImplType(
2655 ICreateTypeInfo2
* iface
, /* [I] The typeinfo from which to delete. */
2656 UINT index
) /* [I] The index of the interface to delete. */
2658 FIXME("(%p,%d), stub!\n", iface
, index
);
2659 return E_OUTOFMEMORY
;
2662 /******************************************************************************
2663 * ICreateTypeInfo2_SetCustData {OLEAUT32}
2665 * Set the custom data for a type.
2670 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2672 static HRESULT WINAPI
ICreateTypeInfo2_fnSetCustData(
2673 ICreateTypeInfo2
* iface
, /* [I] The typeinfo in which to set the custom data. */
2674 REFGUID guid
, /* [I] The GUID used as a key to retrieve the custom data. */
2675 VARIANT
* pVarVal
) /* [I] The custom data. */
2677 FIXME("(%p,%s,%p), stub!\n", iface
, debugstr_guid(guid
), pVarVal
);
2678 return E_OUTOFMEMORY
;
2681 /******************************************************************************
2682 * ICreateTypeInfo2_SetFuncCustData {OLEAUT32}
2684 * Set the custom data for a function.
2689 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2691 static HRESULT WINAPI
ICreateTypeInfo2_fnSetFuncCustData(
2692 ICreateTypeInfo2
* iface
, /* [I] The typeinfo in which to set the custom data. */
2693 UINT index
, /* [I] The index of the function for which to set the custom data. */
2694 REFGUID guid
, /* [I] The GUID used as a key to retrieve the custom data. */
2695 VARIANT
* pVarVal
) /* [I] The custom data. */
2697 FIXME("(%p,%d,%s,%p), stub!\n", iface
, index
, debugstr_guid(guid
), pVarVal
);
2698 return E_OUTOFMEMORY
;
2701 /******************************************************************************
2702 * ICreateTypeInfo2_SetParamCustData {OLEAUT32}
2704 * Set the custom data for a function parameter.
2709 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2711 static HRESULT WINAPI
ICreateTypeInfo2_fnSetParamCustData(
2712 ICreateTypeInfo2
* iface
, /* [I] The typeinfo in which to set the custom data. */
2713 UINT indexFunc
, /* [I] The index of the function on which the parameter resides. */
2714 UINT indexParam
, /* [I] The index of the parameter on which to set the custom data. */
2715 REFGUID guid
, /* [I] The GUID used as a key to retrieve the custom data. */
2716 VARIANT
* pVarVal
) /* [I] The custom data. */
2718 FIXME("(%p,%d,%d,%s,%p), stub!\n", iface
, indexFunc
, indexParam
, debugstr_guid(guid
), pVarVal
);
2719 return E_OUTOFMEMORY
;
2722 /******************************************************************************
2723 * ICreateTypeInfo2_SetVarCustData {OLEAUT32}
2725 * Set the custom data for a variable.
2730 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2732 static HRESULT WINAPI
ICreateTypeInfo2_fnSetVarCustData(
2733 ICreateTypeInfo2
* iface
, /* [I] The typeinfo in which to set the custom data. */
2734 UINT index
, /* [I] The index of the variable on which to set the custom data. */
2735 REFGUID guid
, /* [I] The GUID used as a key to retrieve the custom data. */
2736 VARIANT
* pVarVal
) /* [I] The custom data. */
2738 FIXME("(%p,%d,%s,%p), stub!\n", iface
, index
, debugstr_guid(guid
), pVarVal
);
2739 return E_OUTOFMEMORY
;
2742 /******************************************************************************
2743 * ICreateTypeInfo2_SetImplTypeCustData {OLEAUT32}
2745 * Set the custom data for an implemented interface.
2750 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2752 static HRESULT WINAPI
ICreateTypeInfo2_fnSetImplTypeCustData(
2753 ICreateTypeInfo2
* iface
, /* [I] The typeinfo on which to set the custom data. */
2754 UINT index
, /* [I] The index of the implemented interface on which to set the custom data. */
2755 REFGUID guid
, /* [I] The GUID used as a key to retrieve the custom data. */
2756 VARIANT
* pVarVal
) /* [I] The custom data. */
2758 FIXME("(%p,%d,%s,%p), stub!\n", iface
, index
, debugstr_guid(guid
), pVarVal
);
2759 return E_OUTOFMEMORY
;
2762 /******************************************************************************
2763 * ICreateTypeInfo2_SetHelpStringContext {OLEAUT32}
2765 * Set the help string context for the typeinfo.
2770 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2772 static HRESULT WINAPI
ICreateTypeInfo2_fnSetHelpStringContext(
2773 ICreateTypeInfo2
* iface
, /* [I] The typeinfo on which to set the help string context. */
2774 ULONG dwHelpStringContext
) /* [I] The help string context. */
2776 FIXME("(%p,%d), stub!\n", iface
, dwHelpStringContext
);
2777 return E_OUTOFMEMORY
;
2780 /******************************************************************************
2781 * ICreateTypeInfo2_SetFuncHelpStringContext {OLEAUT32}
2783 * Set the help string context for a function.
2788 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2790 static HRESULT WINAPI
ICreateTypeInfo2_fnSetFuncHelpStringContext(
2791 ICreateTypeInfo2
* iface
, /* [I] The typeinfo on which to set the help string context. */
2792 UINT index
, /* [I] The index for the function on which to set the help string context. */
2793 ULONG dwHelpStringContext
) /* [I] The help string context. */
2795 FIXME("(%p,%d,%d), stub!\n", iface
, index
, dwHelpStringContext
);
2796 return E_OUTOFMEMORY
;
2799 /******************************************************************************
2800 * ICreateTypeInfo2_SetVarHelpStringContext {OLEAUT32}
2802 * Set the help string context for a variable.
2807 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2809 static HRESULT WINAPI
ICreateTypeInfo2_fnSetVarHelpStringContext(
2810 ICreateTypeInfo2
* iface
, /* [I] The typeinfo on which to set the help string context. */
2811 UINT index
, /* [I] The index of the variable on which to set the help string context. */
2812 ULONG dwHelpStringContext
) /* [I] The help string context */
2814 FIXME("(%p,%d,%d), stub!\n", iface
, index
, dwHelpStringContext
);
2815 return E_OUTOFMEMORY
;
2818 /******************************************************************************
2819 * ICreateTypeInfo2_Invalidate {OLEAUT32}
2821 * Undocumented function. (!)
2823 static HRESULT WINAPI
ICreateTypeInfo2_fnInvalidate(
2824 ICreateTypeInfo2
* iface
)
2826 FIXME("(%p), stub!\n", iface
);
2827 return E_OUTOFMEMORY
;
2830 /******************************************************************************
2831 * ICreateTypeInfo2_SetName {OLEAUT32}
2833 * Set the name for a typeinfo.
2838 * Failure: One of STG_E_INSUFFICIENTMEMORY, E_OUTOFMEMORY, E_INVALIDARG or TYPE_E_INVALIDSTATE.
2840 static HRESULT WINAPI
ICreateTypeInfo2_fnSetName(
2841 ICreateTypeInfo2
* iface
,
2844 FIXME("(%p,%s), stub!\n", iface
, debugstr_w(szName
));
2845 return E_OUTOFMEMORY
;
2848 /*================== ITypeInfo2 Implementation ===================================*/
2850 /******************************************************************************
2851 * ITypeInfo2_QueryInterface {OLEAUT32}
2853 * See IUnknown_QueryInterface.
2855 static HRESULT WINAPI
ITypeInfo2_fnQueryInterface(ITypeInfo2
* iface
, REFIID riid
, LPVOID
* ppv
)
2857 ICreateTypeInfo2Impl
*This
= impl_from_ITypeInfo2(iface
);
2859 return ICreateTypeInfo2_QueryInterface((ICreateTypeInfo2
*)This
, riid
, ppv
);
2862 /******************************************************************************
2863 * ITypeInfo2_AddRef {OLEAUT32}
2865 * See IUnknown_AddRef.
2867 static ULONG WINAPI
ITypeInfo2_fnAddRef(ITypeInfo2
* iface
)
2869 ICreateTypeInfo2Impl
*This
= impl_from_ITypeInfo2(iface
);
2871 return ICreateTypeInfo2_AddRef((ICreateTypeInfo2
*)This
);
2874 /******************************************************************************
2875 * ITypeInfo2_Release {OLEAUT32}
2877 * See IUnknown_Release.
2879 static ULONG WINAPI
ITypeInfo2_fnRelease(ITypeInfo2
* iface
)
2881 ICreateTypeInfo2Impl
*This
= impl_from_ITypeInfo2(iface
);
2883 return ICreateTypeInfo2_Release((ICreateTypeInfo2
*)This
);
2886 /******************************************************************************
2887 * ITypeInfo2_GetTypeAttr {OLEAUT32}
2889 * See ITypeInfo_GetTypeAttr.
2891 static HRESULT WINAPI
ITypeInfo2_fnGetTypeAttr(
2893 TYPEATTR
** ppTypeAttr
)
2895 ICreateTypeInfo2Impl
*This
= impl_from_ITypeInfo2(iface
);
2898 TRACE("(%p,%p)\n", iface
, ppTypeAttr
);
2901 return E_INVALIDARG
;
2903 hres
= ICreateTypeInfo_LayOut((ICreateTypeInfo
*)This
);
2907 *ppTypeAttr
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(TYPEATTR
));
2909 return E_OUTOFMEMORY
;
2911 if(This
->typeinfo
->posguid
!= -1) {
2912 MSFT_GuidEntry
*guid
;
2914 guid
= (MSFT_GuidEntry
*)&This
->typelib
->typelib_segment_data
[MSFT_SEG_GUID
][This
->typeinfo
->posguid
];
2915 (*ppTypeAttr
)->guid
= guid
->guid
;
2918 (*ppTypeAttr
)->lcid
= This
->typelib
->typelib_header
.lcid
;
2919 (*ppTypeAttr
)->cbSizeInstance
= This
->typeinfo
->size
;
2920 (*ppTypeAttr
)->typekind
= This
->typekind
;
2921 (*ppTypeAttr
)->cFuncs
= This
->typeinfo
->cElement
&0xffff;
2922 (*ppTypeAttr
)->cVars
= This
->typeinfo
->cElement
>>16;
2923 (*ppTypeAttr
)->cImplTypes
= This
->typeinfo
->cImplTypes
;
2924 (*ppTypeAttr
)->cbSizeVft
= This
->typekind
==TKIND_DISPATCH
? 28 : This
->typeinfo
->cbSizeVft
;
2925 (*ppTypeAttr
)->cbAlignment
= (This
->typeinfo
->typekind
>>11) & 0x1f;
2926 (*ppTypeAttr
)->wTypeFlags
= This
->typeinfo
->flags
;
2927 (*ppTypeAttr
)->wMajorVerNum
= This
->typeinfo
->version
&0xffff;
2928 (*ppTypeAttr
)->wMinorVerNum
= This
->typeinfo
->version
>>16;
2930 if((*ppTypeAttr
)->typekind
== TKIND_ALIAS
)
2931 FIXME("TKIND_ALIAS handling not implemented\n");
2936 /******************************************************************************
2937 * ITypeInfo2_GetTypeComp {OLEAUT32}
2939 * See ITypeInfo_GetTypeComp.
2941 static HRESULT WINAPI
ITypeInfo2_fnGetTypeComp(
2943 ITypeComp
** ppTComp
)
2945 FIXME("(%p,%p), stub!\n", iface
, ppTComp
);
2946 return E_OUTOFMEMORY
;
2949 /******************************************************************************
2950 * ITypeInfo2_GetFuncDesc {OLEAUT32}
2952 * See ITypeInfo_GetFuncDesc.
2954 static HRESULT WINAPI
ITypeInfo2_fnGetFuncDesc(
2957 FUNCDESC
** ppFuncDesc
)
2959 FIXME("(%p,%d,%p), stub!\n", iface
, index
, ppFuncDesc
);
2960 return E_OUTOFMEMORY
;
2963 /******************************************************************************
2964 * ITypeInfo2_GetVarDesc {OLEAUT32}
2966 * See ITypeInfo_GetVarDesc.
2968 static HRESULT WINAPI
ITypeInfo2_fnGetVarDesc(
2971 VARDESC
** ppVarDesc
)
2973 FIXME("(%p,%d,%p), stub!\n", iface
, index
, ppVarDesc
);
2974 return E_OUTOFMEMORY
;
2977 /******************************************************************************
2978 * ITypeInfo2_GetNames {OLEAUT32}
2980 * See ITypeInfo_GetNames.
2982 static HRESULT WINAPI
ITypeInfo2_fnGetNames(
2989 FIXME("(%p,%d,%p,%d,%p), stub!\n", iface
, memid
, rgBstrNames
, cMaxNames
, pcNames
);
2990 return E_OUTOFMEMORY
;
2993 /******************************************************************************
2994 * ITypeInfo2_GetRefTypeOfImplType {OLEAUT32}
2996 * See ITypeInfo_GetRefTypeOfImplType.
2998 static HRESULT WINAPI
ITypeInfo2_fnGetRefTypeOfImplType(
3003 ICreateTypeInfo2Impl
*This
= impl_from_ITypeInfo2(iface
);
3004 MSFT_RefRecord
*ref
;
3007 TRACE("(%p,%d,%p)\n", iface
, index
, pRefType
);
3010 return E_INVALIDARG
;
3013 if((This
->typeinfo
->typekind
&0xf)==TKIND_DISPATCH
3014 && (This
->typeinfo
->flags
&TYPEFLAG_FDUAL
)) {
3019 return TYPE_E_ELEMENTNOTFOUND
;
3022 if(index
>= This
->typeinfo
->cImplTypes
)
3023 return TYPE_E_ELEMENTNOTFOUND
;
3025 if(This
->typekind
== TKIND_INTERFACE
) {
3026 *pRefType
= This
->typeinfo
->datatype1
+ 2;
3030 offset
= ctl2_find_nth_reference(This
->typelib
, This
->typeinfo
->datatype1
, index
);
3032 return TYPE_E_ELEMENTNOTFOUND
;
3034 ref
= (MSFT_RefRecord
*)&This
->typelib
->typelib_segment_data
[MSFT_SEG_REFERENCES
][offset
];
3035 *pRefType
= ref
->reftype
;
3039 /******************************************************************************
3040 * ITypeInfo2_GetImplTypeFlags {OLEAUT32}
3042 * See ITypeInfo_GetImplTypeFlags.
3044 static HRESULT WINAPI
ITypeInfo2_fnGetImplTypeFlags(
3047 INT
* pImplTypeFlags
)
3049 ICreateTypeInfo2Impl
*This
= impl_from_ITypeInfo2(iface
);
3051 MSFT_RefRecord
*ref
;
3053 TRACE("(%p,%d,%p)\n", iface
, index
, pImplTypeFlags
);
3056 return E_INVALIDARG
;
3058 if(index
>= This
->typeinfo
->cImplTypes
)
3059 return TYPE_E_ELEMENTNOTFOUND
;
3061 if(This
->typekind
!= TKIND_COCLASS
) {
3062 *pImplTypeFlags
= 0;
3066 offset
= ctl2_find_nth_reference(This
->typelib
, This
->typeinfo
->datatype1
, index
);
3068 return TYPE_E_ELEMENTNOTFOUND
;
3070 ref
= (MSFT_RefRecord
*)&This
->typelib
->typelib_segment_data
[MSFT_SEG_REFERENCES
][offset
];
3071 *pImplTypeFlags
= ref
->flags
;
3075 /******************************************************************************
3076 * ITypeInfo2_GetIDsOfNames {OLEAUT32}
3078 * See ITypeInfo_GetIDsOfNames.
3080 static HRESULT WINAPI
ITypeInfo2_fnGetIDsOfNames(
3082 LPOLESTR
* rgszNames
,
3086 FIXME("(%p,%p,%d,%p), stub!\n", iface
, rgszNames
, cNames
, pMemId
);
3087 return E_OUTOFMEMORY
;
3090 /******************************************************************************
3091 * ITypeInfo2_Invoke {OLEAUT32}
3093 * See ITypeInfo_Invoke.
3095 static HRESULT WINAPI
ITypeInfo2_fnInvoke(
3100 DISPPARAMS
* pDispParams
,
3101 VARIANT
* pVarResult
,
3102 EXCEPINFO
* pExcepInfo
,
3105 FIXME("(%p,%p,%d,%x,%p,%p,%p,%p), stub!\n", iface
, pvInstance
, memid
, wFlags
, pDispParams
, pVarResult
, pExcepInfo
, puArgErr
);
3106 return E_OUTOFMEMORY
;
3109 /******************************************************************************
3110 * ITypeInfo2_GetDocumentation {OLEAUT32}
3112 * See ITypeInfo_GetDocumentation.
3114 static HRESULT WINAPI
ITypeInfo2_fnGetDocumentation(
3118 BSTR
* pBstrDocString
,
3119 DWORD
* pdwHelpContext
,
3120 BSTR
* pBstrHelpFile
)
3122 FIXME("(%p,%d,%p,%p,%p,%p), stub!\n", iface
, memid
, pBstrName
, pBstrDocString
, pdwHelpContext
, pBstrHelpFile
);
3123 return E_OUTOFMEMORY
;
3126 /******************************************************************************
3127 * ITypeInfo2_GetDllEntry {OLEAUT32}
3129 * See ITypeInfo_GetDllEntry.
3131 static HRESULT WINAPI
ITypeInfo2_fnGetDllEntry(
3139 FIXME("(%p,%d,%d,%p,%p,%p), stub!\n", iface
, memid
, invKind
, pBstrDllName
, pBstrName
, pwOrdinal
);
3140 return E_OUTOFMEMORY
;
3143 /******************************************************************************
3144 * ITypeInfo2_GetRefTypeInfo {OLEAUT32}
3146 * See ITypeInfo_GetRefTypeInfo.
3148 static HRESULT WINAPI
ITypeInfo2_fnGetRefTypeInfo(
3151 ITypeInfo
** ppTInfo
)
3153 ICreateTypeInfo2Impl
*This
= impl_from_ITypeInfo2(iface
);
3155 TRACE("(%p,%d,%p)\n", iface
, hRefType
, ppTInfo
);
3158 return E_INVALIDARG
;
3160 if(hRefType
==-2 && This
->dual
) {
3161 *ppTInfo
= (ITypeInfo
*)&This
->dual
->lpVtblTypeInfo2
;
3162 ITypeInfo_AddRef(*ppTInfo
);
3168 MSFT_ImpInfo
*impinfo
;
3169 MSFT_ImpFile
*impfile
;
3170 MSFT_GuidEntry
*guid
;
3174 if((hRefType
&(~0x3)) >= This
->typelib
->typelib_segdir
[MSFT_SEG_IMPORTINFO
].length
)
3177 impinfo
= (MSFT_ImpInfo
*)&This
->typelib
->typelib_segment_data
[MSFT_SEG_IMPORTINFO
][hRefType
&(~0x3)];
3178 impfile
= (MSFT_ImpFile
*)&This
->typelib
->typelib_segment_data
[MSFT_SEG_IMPORTFILES
][impinfo
->oImpFile
];
3179 guid
= (MSFT_GuidEntry
*)&This
->typelib
->typelib_segment_data
[MSFT_SEG_GUID
][impinfo
->oGuid
];
3181 ctl2_decode_string(impfile
->filename
, &filename
);
3183 hres
= LoadTypeLib(filename
, &tl
);
3187 hres
= ITypeLib_GetTypeInfoOfGuid(tl
, &guid
->guid
, ppTInfo
);
3189 ITypeLib_Release(tl
);
3192 ICreateTypeInfo2Impl
*iter
;
3195 for(iter
=This
->typelib
->typeinfos
; iter
; iter
=iter
->next_typeinfo
) {
3196 if(This
->typelib
->typelib_typeinfo_offsets
[i
] == (hRefType
&(~0x3))) {
3197 *ppTInfo
= (ITypeInfo
*)&iter
->lpVtblTypeInfo2
;
3199 ITypeLib_AddRef(*ppTInfo
);
3209 /******************************************************************************
3210 * ITypeInfo2_AddressOfMember {OLEAUT32}
3212 * See ITypeInfo_AddressOfMember.
3214 static HRESULT WINAPI
ITypeInfo2_fnAddressOfMember(
3220 FIXME("(%p,%d,%d,%p), stub!\n", iface
, memid
, invKind
, ppv
);
3221 return E_OUTOFMEMORY
;
3224 /******************************************************************************
3225 * ITypeInfo2_CreateInstance {OLEAUT32}
3227 * See ITypeInfo_CreateInstance.
3229 static HRESULT WINAPI
ITypeInfo2_fnCreateInstance(
3231 IUnknown
* pUnkOuter
,
3235 FIXME("(%p,%p,%s,%p), stub!\n", iface
, pUnkOuter
, debugstr_guid(riid
), ppvObj
);
3236 return E_OUTOFMEMORY
;
3239 /******************************************************************************
3240 * ITypeInfo2_GetMops {OLEAUT32}
3242 * See ITypeInfo_GetMops.
3244 static HRESULT WINAPI
ITypeInfo2_fnGetMops(
3249 FIXME("(%p,%d,%p), stub!\n", iface
, memid
, pBstrMops
);
3250 return E_OUTOFMEMORY
;
3253 /******************************************************************************
3254 * ITypeInfo2_GetContainingTypeLib {OLEAUT32}
3256 * See ITypeInfo_GetContainingTypeLib.
3258 static HRESULT WINAPI
ITypeInfo2_fnGetContainingTypeLib(
3263 ICreateTypeInfo2Impl
*This
= impl_from_ITypeInfo2(iface
);
3265 TRACE("(%p,%p,%p)\n", iface
, ppTLib
, pIndex
);
3267 *ppTLib
= (ITypeLib
*)&This
->typelib
->lpVtblTypeLib2
;
3268 ICreateTypeLib_AddRef((ICreateTypeLib
*)This
->typelib
);
3269 *pIndex
= This
->typeinfo
->typekind
>> 16;
3274 /******************************************************************************
3275 * ITypeInfo2_ReleaseTypeAttr {OLEAUT32}
3277 * See ITypeInfo_ReleaseTypeAttr.
3279 static void WINAPI
ITypeInfo2_fnReleaseTypeAttr(
3281 TYPEATTR
* pTypeAttr
)
3283 TRACE("(%p,%p)\n", iface
, pTypeAttr
);
3285 HeapFree(GetProcessHeap(), 0, pTypeAttr
);
3288 /******************************************************************************
3289 * ITypeInfo2_ReleaseFuncDesc {OLEAUT32}
3291 * See ITypeInfo_ReleaseFuncDesc.
3293 static void WINAPI
ITypeInfo2_fnReleaseFuncDesc(
3295 FUNCDESC
* pFuncDesc
)
3297 FIXME("(%p,%p), stub!\n", iface
, pFuncDesc
);
3300 /******************************************************************************
3301 * ITypeInfo2_ReleaseVarDesc {OLEAUT32}
3303 * See ITypeInfo_ReleaseVarDesc.
3305 static void WINAPI
ITypeInfo2_fnReleaseVarDesc(
3309 FIXME("(%p,%p), stub!\n", iface
, pVarDesc
);
3312 /******************************************************************************
3313 * ITypeInfo2_GetTypeKind {OLEAUT32}
3315 * Get the TYPEKIND value for a TypeInfo.
3320 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3322 static HRESULT WINAPI
ITypeInfo2_fnGetTypeKind(
3323 ITypeInfo2
* iface
, /* [I] The TypeInfo to obtain the typekind for. */
3324 TYPEKIND
* pTypeKind
) /* [O] The typekind for this TypeInfo. */
3326 FIXME("(%p,%p), stub!\n", iface
, pTypeKind
);
3327 return E_OUTOFMEMORY
;
3330 /******************************************************************************
3331 * ITypeInfo2_GetTypeFlags {OLEAUT32}
3333 * Get the Type Flags for a TypeInfo.
3338 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3340 static HRESULT WINAPI
ITypeInfo2_fnGetTypeFlags(
3341 ITypeInfo2
* iface
, /* [I] The TypeInfo to obtain the typeflags for. */
3342 ULONG
* pTypeFlags
) /* [O] The type flags for this TypeInfo. */
3344 FIXME("(%p,%p), stub!\n", iface
, pTypeFlags
);
3345 return E_OUTOFMEMORY
;
3348 /******************************************************************************
3349 * ITypeInfo2_GetFuncIndexOfMemId {OLEAUT32}
3351 * Gets the index of a function given its member id.
3356 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3358 static HRESULT WINAPI
ITypeInfo2_fnGetFuncIndexOfMemId(
3359 ITypeInfo2
* iface
, /* [I] The TypeInfo in which to find the function. */
3360 MEMBERID memid
, /* [I] The member id for the function. */
3361 INVOKEKIND invKind
, /* [I] The invocation kind for the function. */
3362 UINT
* pFuncIndex
) /* [O] The index of the function. */
3364 FIXME("(%p,%d,%d,%p), stub!\n", iface
, memid
, invKind
, pFuncIndex
);
3365 return E_OUTOFMEMORY
;
3368 /******************************************************************************
3369 * ITypeInfo2_GetVarIndexOfMemId {OLEAUT32}
3371 * Gets the index of a variable given its member id.
3376 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3378 static HRESULT WINAPI
ITypeInfo2_fnGetVarIndexOfMemId(
3379 ITypeInfo2
* iface
, /* [I] The TypeInfo in which to find the variable. */
3380 MEMBERID memid
, /* [I] The member id for the variable. */
3381 UINT
* pVarIndex
) /* [O] The index of the variable. */
3383 FIXME("(%p,%d,%p), stub!\n", iface
, memid
, pVarIndex
);
3384 return E_OUTOFMEMORY
;
3387 /******************************************************************************
3388 * ITypeInfo2_GetCustData {OLEAUT32}
3390 * Gets a custom data element from a TypeInfo.
3395 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3397 static HRESULT WINAPI
ITypeInfo2_fnGetCustData(
3398 ITypeInfo2
* iface
, /* [I] The TypeInfo in which to find the custom data. */
3399 REFGUID guid
, /* [I] The GUID under which the custom data is stored. */
3400 VARIANT
* pVarVal
) /* [O] The custom data. */
3402 FIXME("(%p,%s,%p), stub!\n", iface
, debugstr_guid(guid
), pVarVal
);
3403 return E_OUTOFMEMORY
;
3406 /******************************************************************************
3407 * ITypeInfo2_GetFuncCustData {OLEAUT32}
3409 * Gets a custom data element from a function.
3414 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3416 static HRESULT WINAPI
ITypeInfo2_fnGetFuncCustData(
3417 ITypeInfo2
* iface
, /* [I] The TypeInfo in which to find the custom data. */
3418 UINT index
, /* [I] The index of the function for which to retrieve the custom data. */
3419 REFGUID guid
, /* [I] The GUID under which the custom data is stored. */
3420 VARIANT
* pVarVal
) /* [O] The custom data. */
3422 FIXME("(%p,%d,%s,%p), stub!\n", iface
, index
, debugstr_guid(guid
), pVarVal
);
3423 return E_OUTOFMEMORY
;
3426 /******************************************************************************
3427 * ITypeInfo2_GetParamCustData {OLEAUT32}
3429 * Gets a custom data element from a parameter.
3434 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3436 static HRESULT WINAPI
ITypeInfo2_fnGetParamCustData(
3437 ITypeInfo2
* iface
, /* [I] The TypeInfo in which to find the custom data. */
3438 UINT indexFunc
, /* [I] The index of the function for which to retrieve the custom data. */
3439 UINT indexParam
, /* [I] The index of the parameter for which to retrieve the custom data. */
3440 REFGUID guid
, /* [I] The GUID under which the custom data is stored. */
3441 VARIANT
* pVarVal
) /* [O] The custom data. */
3443 FIXME("(%p,%d,%d,%s,%p), stub!\n", iface
, indexFunc
, indexParam
, debugstr_guid(guid
), pVarVal
);
3444 return E_OUTOFMEMORY
;
3447 /******************************************************************************
3448 * ITypeInfo2_GetVarCustData {OLEAUT32}
3450 * Gets a custom data element from a variable.
3455 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3457 static HRESULT WINAPI
ITypeInfo2_fnGetVarCustData(
3458 ITypeInfo2
* iface
, /* [I] The TypeInfo in which to find the custom data. */
3459 UINT index
, /* [I] The index of the variable for which to retrieve the custom data. */
3460 REFGUID guid
, /* [I] The GUID under which the custom data is stored. */
3461 VARIANT
* pVarVal
) /* [O] The custom data. */
3463 FIXME("(%p,%d,%s,%p), stub!\n", iface
, index
, debugstr_guid(guid
), pVarVal
);
3464 return E_OUTOFMEMORY
;
3467 /******************************************************************************
3468 * ITypeInfo2_GetImplTypeCustData {OLEAUT32}
3470 * Gets a custom data element from an implemented type of a TypeInfo.
3475 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3477 static HRESULT WINAPI
ITypeInfo2_fnGetImplTypeCustData(
3478 ITypeInfo2
* iface
, /* [I] The TypeInfo in which to find the custom data. */
3479 UINT index
, /* [I] The index of the implemented type for which to retrieve the custom data. */
3480 REFGUID guid
, /* [I] The GUID under which the custom data is stored. */
3481 VARIANT
* pVarVal
) /* [O] The custom data. */
3483 FIXME("(%p,%d,%s,%p), stub!\n", iface
, index
, debugstr_guid(guid
), pVarVal
);
3484 return E_OUTOFMEMORY
;
3487 /******************************************************************************
3488 * ITypeInfo2_GetDocumentation2 {OLEAUT32}
3490 * Gets some documentation from a TypeInfo in a locale-aware fashion.
3495 * Failure: One of STG_E_INSUFFICIENTMEMORY or E_INVALIDARG.
3497 static HRESULT WINAPI
ITypeInfo2_fnGetDocumentation2(
3498 ITypeInfo2
* iface
, /* [I] The TypeInfo to retrieve the documentation from. */
3499 MEMBERID memid
, /* [I] The member id (why?). */
3500 LCID lcid
, /* [I] The locale (why?). */
3501 BSTR
* pbstrHelpString
, /* [O] The help string. */
3502 DWORD
* pdwHelpStringContext
, /* [O] The help string context. */
3503 BSTR
* pbstrHelpStringDll
) /* [O] The help file name. */
3505 FIXME("(%p,%d,%d,%p,%p,%p), stub!\n", iface
, memid
, lcid
, pbstrHelpString
, pdwHelpStringContext
, pbstrHelpStringDll
);
3506 return E_OUTOFMEMORY
;
3509 /******************************************************************************
3510 * ITypeInfo2_GetAllCustData {OLEAUT32}
3512 * Gets all of the custom data associated with a TypeInfo.
3517 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3519 static HRESULT WINAPI
ITypeInfo2_fnGetAllCustData(
3520 ITypeInfo2
* iface
, /* [I] The TypeInfo in which to find the custom data. */
3521 CUSTDATA
* pCustData
) /* [O] A pointer to the custom data. */
3523 FIXME("(%p,%p), stub!\n", iface
, pCustData
);
3524 return E_OUTOFMEMORY
;
3527 /******************************************************************************
3528 * ITypeInfo2_GetAllFuncCustData {OLEAUT32}
3530 * Gets all of the custom data associated with a function.
3535 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3537 static HRESULT WINAPI
ITypeInfo2_fnGetAllFuncCustData(
3538 ITypeInfo2
* iface
, /* [I] The TypeInfo in which to find the custom data. */
3539 UINT index
, /* [I] The index of the function for which to retrieve the custom data. */
3540 CUSTDATA
* pCustData
) /* [O] A pointer to the custom data. */
3542 FIXME("(%p,%d,%p), stub!\n", iface
, index
, pCustData
);
3543 return E_OUTOFMEMORY
;
3546 /******************************************************************************
3547 * ITypeInfo2_GetAllParamCustData {OLEAUT32}
3549 * Gets all of the custom data associated with a parameter.
3554 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3556 static HRESULT WINAPI
ITypeInfo2_fnGetAllParamCustData(
3557 ITypeInfo2
* iface
, /* [I] The TypeInfo in which to find the custom data. */
3558 UINT indexFunc
, /* [I] The index of the function for which to retrieve the custom data. */
3559 UINT indexParam
, /* [I] The index of the parameter for which to retrieve the custom data. */
3560 CUSTDATA
* pCustData
) /* [O] A pointer to the custom data. */
3562 FIXME("(%p,%d,%d,%p), stub!\n", iface
, indexFunc
, indexParam
, pCustData
);
3563 return E_OUTOFMEMORY
;
3566 /******************************************************************************
3567 * ITypeInfo2_GetAllVarCustData {OLEAUT32}
3569 * Gets all of the custom data associated with a variable.
3574 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3576 static HRESULT WINAPI
ITypeInfo2_fnGetAllVarCustData(
3577 ITypeInfo2
* iface
, /* [I] The TypeInfo in which to find the custom data. */
3578 UINT index
, /* [I] The index of the variable for which to retrieve the custom data. */
3579 CUSTDATA
* pCustData
) /* [O] A pointer to the custom data. */
3581 FIXME("(%p,%d,%p), stub!\n", iface
, index
, pCustData
);
3582 return E_OUTOFMEMORY
;
3585 /******************************************************************************
3586 * ITypeInfo2_GetAllImplTypeCustData {OLEAUT32}
3588 * Gets all of the custom data associated with an implemented type.
3593 * Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3595 static HRESULT WINAPI
ITypeInfo2_fnGetAllImplTypeCustData(
3596 ITypeInfo2
* iface
, /* [I] The TypeInfo in which to find the custom data. */
3597 UINT index
, /* [I] The index of the implemented type for which to retrieve the custom data. */
3598 CUSTDATA
* pCustData
) /* [O] A pointer to the custom data. */
3600 FIXME("(%p,%d,%p), stub!\n", iface
, index
, pCustData
);
3601 return E_OUTOFMEMORY
;
3605 /*================== ICreateTypeInfo2 & ITypeInfo2 VTABLEs And Creation ===================================*/
3607 static const ICreateTypeInfo2Vtbl ctypeinfo2vt
=
3610 ICreateTypeInfo2_fnQueryInterface
,
3611 ICreateTypeInfo2_fnAddRef
,
3612 ICreateTypeInfo2_fnRelease
,
3614 ICreateTypeInfo2_fnSetGuid
,
3615 ICreateTypeInfo2_fnSetTypeFlags
,
3616 ICreateTypeInfo2_fnSetDocString
,
3617 ICreateTypeInfo2_fnSetHelpContext
,
3618 ICreateTypeInfo2_fnSetVersion
,
3619 ICreateTypeInfo2_fnAddRefTypeInfo
,
3620 ICreateTypeInfo2_fnAddFuncDesc
,
3621 ICreateTypeInfo2_fnAddImplType
,
3622 ICreateTypeInfo2_fnSetImplTypeFlags
,
3623 ICreateTypeInfo2_fnSetAlignment
,
3624 ICreateTypeInfo2_fnSetSchema
,
3625 ICreateTypeInfo2_fnAddVarDesc
,
3626 ICreateTypeInfo2_fnSetFuncAndParamNames
,
3627 ICreateTypeInfo2_fnSetVarName
,
3628 ICreateTypeInfo2_fnSetTypeDescAlias
,
3629 ICreateTypeInfo2_fnDefineFuncAsDllEntry
,
3630 ICreateTypeInfo2_fnSetFuncDocString
,
3631 ICreateTypeInfo2_fnSetVarDocString
,
3632 ICreateTypeInfo2_fnSetFuncHelpContext
,
3633 ICreateTypeInfo2_fnSetVarHelpContext
,
3634 ICreateTypeInfo2_fnSetMops
,
3635 ICreateTypeInfo2_fnSetTypeIdldesc
,
3636 ICreateTypeInfo2_fnLayOut
,
3638 ICreateTypeInfo2_fnDeleteFuncDesc
,
3639 ICreateTypeInfo2_fnDeleteFuncDescByMemId
,
3640 ICreateTypeInfo2_fnDeleteVarDesc
,
3641 ICreateTypeInfo2_fnDeleteVarDescByMemId
,
3642 ICreateTypeInfo2_fnDeleteImplType
,
3643 ICreateTypeInfo2_fnSetCustData
,
3644 ICreateTypeInfo2_fnSetFuncCustData
,
3645 ICreateTypeInfo2_fnSetParamCustData
,
3646 ICreateTypeInfo2_fnSetVarCustData
,
3647 ICreateTypeInfo2_fnSetImplTypeCustData
,
3648 ICreateTypeInfo2_fnSetHelpStringContext
,
3649 ICreateTypeInfo2_fnSetFuncHelpStringContext
,
3650 ICreateTypeInfo2_fnSetVarHelpStringContext
,
3651 ICreateTypeInfo2_fnInvalidate
,
3652 ICreateTypeInfo2_fnSetName
3655 static const ITypeInfo2Vtbl typeinfo2vt
=
3658 ITypeInfo2_fnQueryInterface
,
3659 ITypeInfo2_fnAddRef
,
3660 ITypeInfo2_fnRelease
,
3662 ITypeInfo2_fnGetTypeAttr
,
3663 ITypeInfo2_fnGetTypeComp
,
3664 ITypeInfo2_fnGetFuncDesc
,
3665 ITypeInfo2_fnGetVarDesc
,
3666 ITypeInfo2_fnGetNames
,
3667 ITypeInfo2_fnGetRefTypeOfImplType
,
3668 ITypeInfo2_fnGetImplTypeFlags
,
3669 ITypeInfo2_fnGetIDsOfNames
,
3670 ITypeInfo2_fnInvoke
,
3671 ITypeInfo2_fnGetDocumentation
,
3672 ITypeInfo2_fnGetDllEntry
,
3673 ITypeInfo2_fnGetRefTypeInfo
,
3674 ITypeInfo2_fnAddressOfMember
,
3675 ITypeInfo2_fnCreateInstance
,
3676 ITypeInfo2_fnGetMops
,
3677 ITypeInfo2_fnGetContainingTypeLib
,
3678 ITypeInfo2_fnReleaseTypeAttr
,
3679 ITypeInfo2_fnReleaseFuncDesc
,
3680 ITypeInfo2_fnReleaseVarDesc
,
3682 ITypeInfo2_fnGetTypeKind
,
3683 ITypeInfo2_fnGetTypeFlags
,
3684 ITypeInfo2_fnGetFuncIndexOfMemId
,
3685 ITypeInfo2_fnGetVarIndexOfMemId
,
3686 ITypeInfo2_fnGetCustData
,
3687 ITypeInfo2_fnGetFuncCustData
,
3688 ITypeInfo2_fnGetParamCustData
,
3689 ITypeInfo2_fnGetVarCustData
,
3690 ITypeInfo2_fnGetImplTypeCustData
,
3691 ITypeInfo2_fnGetDocumentation2
,
3692 ITypeInfo2_fnGetAllCustData
,
3693 ITypeInfo2_fnGetAllFuncCustData
,
3694 ITypeInfo2_fnGetAllParamCustData
,
3695 ITypeInfo2_fnGetAllVarCustData
,
3696 ITypeInfo2_fnGetAllImplTypeCustData
,
3699 static ICreateTypeInfo2
*ICreateTypeInfo2_Constructor(ICreateTypeLib2Impl
*typelib
, WCHAR
*szName
, TYPEKIND tkind
)
3701 ICreateTypeInfo2Impl
*pCreateTypeInfo2Impl
;
3704 int typeinfo_offset
;
3705 MSFT_TypeInfoBase
*typeinfo
;
3707 TRACE("Constructing ICreateTypeInfo2 for %s with tkind %d\n", debugstr_w(szName
), tkind
);
3709 pCreateTypeInfo2Impl
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(ICreateTypeInfo2Impl
));
3710 if (!pCreateTypeInfo2Impl
) return NULL
;
3712 pCreateTypeInfo2Impl
->lpVtbl
= &ctypeinfo2vt
;
3713 pCreateTypeInfo2Impl
->lpVtblTypeInfo2
= &typeinfo2vt
;
3714 pCreateTypeInfo2Impl
->ref
= 1;
3716 pCreateTypeInfo2Impl
->typelib
= typelib
;
3717 ICreateTypeLib_AddRef((ICreateTypeLib
*)typelib
);
3719 nameoffset
= ctl2_alloc_name(typelib
, szName
);
3720 typeinfo_offset
= ctl2_alloc_typeinfo(typelib
, nameoffset
);
3721 typeinfo
= (MSFT_TypeInfoBase
*)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEINFO
][typeinfo_offset
];
3723 typelib
->typelib_segment_data
[MSFT_SEG_NAME
][nameoffset
+ 9] = 0x38;
3724 *((int *)&typelib
->typelib_segment_data
[MSFT_SEG_NAME
][nameoffset
]) = typeinfo_offset
;
3726 pCreateTypeInfo2Impl
->typeinfo
= typeinfo
;
3728 pCreateTypeInfo2Impl
->typekind
= tkind
;
3729 typeinfo
->typekind
|= tkind
| 0x20;
3730 ICreateTypeInfo2_SetAlignment((ICreateTypeInfo2
*)pCreateTypeInfo2Impl
, 4);
3734 case TKIND_INTERFACE
:
3735 case TKIND_DISPATCH
:
3750 typeinfo
->size
= -0x75;
3754 FIXME("(%s,%d), unrecognized typekind %d\n", debugstr_w(szName
), tkind
, tkind
);
3755 typeinfo
->size
= 0xdeadbeef;
3759 if (typelib
->last_typeinfo
) typelib
->last_typeinfo
->next_typeinfo
= pCreateTypeInfo2Impl
;
3760 typelib
->last_typeinfo
= pCreateTypeInfo2Impl
;
3761 if (!typelib
->typeinfos
) typelib
->typeinfos
= pCreateTypeInfo2Impl
;
3763 TRACE(" -- %p\n", pCreateTypeInfo2Impl
);
3765 return (ICreateTypeInfo2
*)pCreateTypeInfo2Impl
;
3769 /*================== ICreateTypeLib2 Implementation ===================================*/
3771 /******************************************************************************
3772 * ICreateTypeLib2_QueryInterface {OLEAUT32}
3774 * See IUnknown_QueryInterface.
3776 static HRESULT WINAPI
ICreateTypeLib2_fnQueryInterface(
3777 ICreateTypeLib2
* iface
,
3781 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
3783 TRACE("(%p)->(IID: %s)\n",This
,debugstr_guid(riid
));
3786 if(IsEqualIID(riid
, &IID_IUnknown
) ||
3787 IsEqualIID(riid
,&IID_ICreateTypeLib
)||
3788 IsEqualIID(riid
,&IID_ICreateTypeLib2
))
3791 } else if (IsEqualIID(riid
, &IID_ITypeLib
) ||
3792 IsEqualIID(riid
, &IID_ITypeLib2
)) {
3793 *ppvObject
= &This
->lpVtblTypeLib2
;
3798 ICreateTypeLib2_AddRef(iface
);
3799 TRACE("-- Interface: (%p)->(%p)\n",ppvObject
,*ppvObject
);
3802 TRACE("-- Interface: E_NOINTERFACE\n");
3803 return E_NOINTERFACE
;
3806 /******************************************************************************
3807 * ICreateTypeLib2_AddRef {OLEAUT32}
3809 * See IUnknown_AddRef.
3811 static ULONG WINAPI
ICreateTypeLib2_fnAddRef(ICreateTypeLib2
*iface
)
3813 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
3814 ULONG ref
= InterlockedIncrement(&This
->ref
);
3816 TRACE("(%p)->ref was %u\n",This
, ref
- 1);
3821 /******************************************************************************
3822 * ICreateTypeLib2_Release {OLEAUT32}
3824 * See IUnknown_Release.
3826 static ULONG WINAPI
ICreateTypeLib2_fnRelease(ICreateTypeLib2
*iface
)
3828 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
3829 ULONG ref
= InterlockedDecrement(&This
->ref
);
3831 TRACE("(%p)->(%u)\n",This
, ref
);
3836 for (i
= 0; i
< MSFT_SEG_MAX
; i
++) {
3837 HeapFree(GetProcessHeap(), 0, This
->typelib_segment_data
[i
]);
3838 This
->typelib_segment_data
[i
] = NULL
;
3841 HeapFree(GetProcessHeap(), 0, This
->filename
);
3842 This
->filename
= NULL
;
3844 while (This
->typeinfos
) {
3845 ICreateTypeInfo2Impl
*typeinfo
= This
->typeinfos
;
3846 This
->typeinfos
= typeinfo
->next_typeinfo
;
3847 if(typeinfo
->typedata
) {
3848 CyclicList
*iter
, *rem
;
3850 rem
= typeinfo
->typedata
->next
;
3851 typeinfo
->typedata
->next
= NULL
;
3853 HeapFree(GetProcessHeap(), 0, rem
);
3858 HeapFree(GetProcessHeap(), 0, rem
->u
.data
);
3859 HeapFree(GetProcessHeap(), 0, rem
);
3863 HeapFree(GetProcessHeap(), 0, typeinfo
->dual
);
3864 HeapFree(GetProcessHeap(), 0, typeinfo
);
3867 HeapFree(GetProcessHeap(),0,This
);
3875 /******************************************************************************
3876 * ICreateTypeLib2_CreateTypeInfo {OLEAUT32}
3878 * See ICreateTypeLib_CreateTypeInfo.
3880 static HRESULT WINAPI
ICreateTypeLib2_fnCreateTypeInfo(
3881 ICreateTypeLib2
* iface
,
3884 ICreateTypeInfo
**ppCTInfo
)
3886 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
3889 TRACE("(%p,%s,%d,%p)\n", iface
, debugstr_w(szName
), tkind
, ppCTInfo
);
3891 ctl2_encode_name(This
, szName
, &name
);
3892 if(ctl2_find_name(This
, name
) != -1)
3893 return TYPE_E_NAMECONFLICT
;
3895 *ppCTInfo
= (ICreateTypeInfo
*)ICreateTypeInfo2_Constructor(This
, szName
, tkind
);
3897 if (!*ppCTInfo
) return E_OUTOFMEMORY
;
3902 /******************************************************************************
3903 * ICreateTypeLib2_SetName {OLEAUT32}
3905 * See ICreateTypeLib_SetName.
3907 static HRESULT WINAPI
ICreateTypeLib2_fnSetName(
3908 ICreateTypeLib2
* iface
,
3911 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
3915 TRACE("(%p,%s)\n", iface
, debugstr_w(szName
));
3917 offset
= ctl2_alloc_name(This
, szName
);
3918 if (offset
== -1) return E_OUTOFMEMORY
;
3919 This
->typelib_header
.NameOffset
= offset
;
3923 /******************************************************************************
3924 * ICreateTypeLib2_SetVersion {OLEAUT32}
3926 * See ICreateTypeLib_SetVersion.
3928 static HRESULT WINAPI
ICreateTypeLib2_fnSetVersion(ICreateTypeLib2
* iface
, WORD wMajorVerNum
, WORD wMinorVerNum
)
3930 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
3932 TRACE("(%p,%d,%d)\n", iface
, wMajorVerNum
, wMinorVerNum
);
3934 This
->typelib_header
.version
= wMajorVerNum
| (wMinorVerNum
<< 16);
3938 /******************************************************************************
3939 * ICreateTypeLib2_SetGuid {OLEAUT32}
3941 * See ICreateTypeLib_SetGuid.
3943 static HRESULT WINAPI
ICreateTypeLib2_fnSetGuid(ICreateTypeLib2
* iface
, REFGUID guid
)
3945 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
3947 MSFT_GuidEntry guidentry
;
3950 TRACE("(%p,%s)\n", iface
, debugstr_guid(guid
));
3952 guidentry
.guid
= *guid
;
3953 guidentry
.hreftype
= -2;
3954 guidentry
.next_hash
= -1;
3956 offset
= ctl2_alloc_guid(This
, &guidentry
);
3958 if (offset
== -1) return E_OUTOFMEMORY
;
3960 This
->typelib_header
.posguid
= offset
;
3965 /******************************************************************************
3966 * ICreateTypeLib2_SetDocString {OLEAUT32}
3968 * See ICreateTypeLib_SetDocString.
3970 static HRESULT WINAPI
ICreateTypeLib2_fnSetDocString(ICreateTypeLib2
* iface
, LPOLESTR szDoc
)
3972 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
3976 TRACE("(%p,%s)\n", iface
, debugstr_w(szDoc
));
3978 return E_INVALIDARG
;
3980 offset
= ctl2_alloc_string(This
, szDoc
);
3981 if (offset
== -1) return E_OUTOFMEMORY
;
3982 This
->typelib_header
.helpstring
= offset
;
3986 /******************************************************************************
3987 * ICreateTypeLib2_SetHelpFileName {OLEAUT32}
3989 * See ICreateTypeLib_SetHelpFileName.
3991 static HRESULT WINAPI
ICreateTypeLib2_fnSetHelpFileName(ICreateTypeLib2
* iface
, LPOLESTR szHelpFileName
)
3993 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
3997 TRACE("(%p,%s)\n", iface
, debugstr_w(szHelpFileName
));
3999 offset
= ctl2_alloc_string(This
, szHelpFileName
);
4000 if (offset
== -1) return E_OUTOFMEMORY
;
4001 This
->typelib_header
.helpfile
= offset
;
4002 This
->typelib_header
.varflags
|= 0x10;
4006 /******************************************************************************
4007 * ICreateTypeLib2_SetHelpContext {OLEAUT32}
4009 * See ICreateTypeLib_SetHelpContext.
4011 static HRESULT WINAPI
ICreateTypeLib2_fnSetHelpContext(ICreateTypeLib2
* iface
, DWORD dwHelpContext
)
4013 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
4015 TRACE("(%p,%d)\n", iface
, dwHelpContext
);
4016 This
->typelib_header
.helpcontext
= dwHelpContext
;
4020 /******************************************************************************
4021 * ICreateTypeLib2_SetLcid {OLEAUT32}
4023 * Sets both the lcid and lcid2 members in the header to lcid.
4025 * As a special case if lcid == LOCALE_NEUTRAL (0), then the first header lcid
4026 * is set to US English while the second one is set to 0.
4028 static HRESULT WINAPI
ICreateTypeLib2_fnSetLcid(ICreateTypeLib2
* iface
, LCID lcid
)
4030 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
4032 TRACE("(%p,%d)\n", iface
, lcid
);
4034 This
->typelib_header
.lcid
= This
->typelib_header
.lcid2
= lcid
;
4036 if(lcid
== LOCALE_NEUTRAL
) This
->typelib_header
.lcid
= MAKELANGID(LANG_ENGLISH
, SUBLANG_ENGLISH_US
);
4041 /******************************************************************************
4042 * ICreateTypeLib2_SetLibFlags {OLEAUT32}
4044 * See ICreateTypeLib_SetLibFlags.
4046 static HRESULT WINAPI
ICreateTypeLib2_fnSetLibFlags(ICreateTypeLib2
* iface
, UINT uLibFlags
)
4048 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
4050 TRACE("(%p,0x%x)\n", iface
, uLibFlags
);
4052 This
->typelib_header
.flags
= uLibFlags
;
4057 static int ctl2_write_chunk(HANDLE hFile
, const void *segment
, int length
)
4060 if (!WriteFile(hFile
, segment
, length
, &dwWritten
, 0)) {
4067 static int ctl2_write_segment(ICreateTypeLib2Impl
*This
, HANDLE hFile
, int segment
)
4070 if (!WriteFile(hFile
, This
->typelib_segment_data
[segment
],
4071 This
->typelib_segdir
[segment
].length
, &dwWritten
, 0)) {
4079 static HRESULT
ctl2_finalize_typeinfos(ICreateTypeLib2Impl
*This
, int filesize
)
4081 ICreateTypeInfo2Impl
*typeinfo
;
4084 for (typeinfo
= This
->typeinfos
; typeinfo
; typeinfo
= typeinfo
->next_typeinfo
) {
4085 typeinfo
->typeinfo
->memoffset
= filesize
;
4087 hres
= ICreateTypeInfo2_fnLayOut((ICreateTypeInfo2
*)typeinfo
);
4091 if (typeinfo
->typedata
)
4092 filesize
+= typeinfo
->typedata
->next
->u
.val
4093 + ((typeinfo
->typeinfo
->cElement
>> 16) * 12)
4094 + ((typeinfo
->typeinfo
->cElement
& 0xffff) * 12) + 4;
4100 static int ctl2_finalize_segment(ICreateTypeLib2Impl
*This
, int filepos
, int segment
)
4102 if (This
->typelib_segdir
[segment
].length
) {
4103 This
->typelib_segdir
[segment
].offset
= filepos
;
4105 This
->typelib_segdir
[segment
].offset
= -1;
4108 return This
->typelib_segdir
[segment
].length
;
4111 static void ctl2_write_typeinfos(ICreateTypeLib2Impl
*This
, HANDLE hFile
)
4113 ICreateTypeInfo2Impl
*typeinfo
;
4115 for (typeinfo
= This
->typeinfos
; typeinfo
; typeinfo
= typeinfo
->next_typeinfo
) {
4119 if (!typeinfo
->typedata
) continue;
4121 iter
= typeinfo
->typedata
->next
;
4122 ctl2_write_chunk(hFile
, &iter
->u
.val
, sizeof(int));
4123 for(iter
=iter
->next
; iter
!=typeinfo
->typedata
->next
; iter
=iter
->next
)
4124 ctl2_write_chunk(hFile
, iter
->u
.data
, iter
->u
.data
[0] & 0xffff);
4126 for(iter
=typeinfo
->typedata
->next
->next
; iter
!=typeinfo
->typedata
->next
; iter
=iter
->next
)
4127 ctl2_write_chunk(hFile
, &iter
->indice
, sizeof(int));
4129 for(iter
=typeinfo
->typedata
->next
->next
; iter
!=typeinfo
->typedata
->next
; iter
=iter
->next
)
4130 ctl2_write_chunk(hFile
, &iter
->name
, sizeof(int));
4132 for(iter
=typeinfo
->typedata
->next
->next
; iter
!=typeinfo
->typedata
->next
; iter
=iter
->next
) {
4133 ctl2_write_chunk(hFile
, &offset
, sizeof(int));
4134 offset
+= iter
->u
.data
[0] & 0xffff;
4139 /******************************************************************************
4140 * ICreateTypeLib2_SaveAllChanges {OLEAUT32}
4142 * See ICreateTypeLib_SaveAllChanges.
4144 static HRESULT WINAPI
ICreateTypeLib2_fnSaveAllChanges(ICreateTypeLib2
* iface
)
4146 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
4153 TRACE("(%p)\n", iface
);
4155 retval
= TYPE_E_IOERROR
;
4157 hFile
= CreateFileW(This
->filename
, GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, 0);
4158 if (hFile
== INVALID_HANDLE_VALUE
) return retval
;
4160 filepos
= sizeof(MSFT_Header
) + sizeof(MSFT_SegDir
);
4161 filepos
+= This
->typelib_header
.nrtypeinfos
* 4;
4163 filepos
+= ctl2_finalize_segment(This
, filepos
, MSFT_SEG_TYPEINFO
);
4164 filepos
+= ctl2_finalize_segment(This
, filepos
, MSFT_SEG_GUIDHASH
);
4165 filepos
+= ctl2_finalize_segment(This
, filepos
, MSFT_SEG_GUID
);
4166 filepos
+= ctl2_finalize_segment(This
, filepos
, MSFT_SEG_REFERENCES
);
4167 filepos
+= ctl2_finalize_segment(This
, filepos
, MSFT_SEG_IMPORTINFO
);
4168 filepos
+= ctl2_finalize_segment(This
, filepos
, MSFT_SEG_IMPORTFILES
);
4169 filepos
+= ctl2_finalize_segment(This
, filepos
, MSFT_SEG_NAMEHASH
);
4170 filepos
+= ctl2_finalize_segment(This
, filepos
, MSFT_SEG_NAME
);
4171 filepos
+= ctl2_finalize_segment(This
, filepos
, MSFT_SEG_STRING
);
4172 filepos
+= ctl2_finalize_segment(This
, filepos
, MSFT_SEG_TYPEDESC
);
4173 filepos
+= ctl2_finalize_segment(This
, filepos
, MSFT_SEG_ARRAYDESC
);
4174 filepos
+= ctl2_finalize_segment(This
, filepos
, MSFT_SEG_CUSTDATA
);
4175 filepos
+= ctl2_finalize_segment(This
, filepos
, MSFT_SEG_CUSTDATAGUID
);
4177 hres
= ctl2_finalize_typeinfos(This
, filepos
);
4183 if (!ctl2_write_chunk(hFile
, &This
->typelib_header
, sizeof(This
->typelib_header
))) return retval
;
4184 if (This
->typelib_header
.varflags
& HELPDLLFLAG
)
4185 if (!ctl2_write_chunk(hFile
, &This
->helpStringDll
, sizeof(This
->helpStringDll
))) return retval
;
4186 if (!ctl2_write_chunk(hFile
, This
->typelib_typeinfo_offsets
, This
->typelib_header
.nrtypeinfos
* 4)) return retval
;
4187 if (!ctl2_write_chunk(hFile
, This
->typelib_segdir
, sizeof(This
->typelib_segdir
))) return retval
;
4188 if (!ctl2_write_segment(This
, hFile
, MSFT_SEG_TYPEINFO
)) return retval
;
4189 if (!ctl2_write_segment(This
, hFile
, MSFT_SEG_GUIDHASH
)) return retval
;
4190 if (!ctl2_write_segment(This
, hFile
, MSFT_SEG_GUID
)) return retval
;
4191 if (!ctl2_write_segment(This
, hFile
, MSFT_SEG_REFERENCES
)) return retval
;
4192 if (!ctl2_write_segment(This
, hFile
, MSFT_SEG_IMPORTINFO
)) return retval
;
4193 if (!ctl2_write_segment(This
, hFile
, MSFT_SEG_IMPORTFILES
)) return retval
;
4194 if (!ctl2_write_segment(This
, hFile
, MSFT_SEG_NAMEHASH
)) return retval
;
4195 if (!ctl2_write_segment(This
, hFile
, MSFT_SEG_NAME
)) return retval
;
4196 if (!ctl2_write_segment(This
, hFile
, MSFT_SEG_STRING
)) return retval
;
4197 if (!ctl2_write_segment(This
, hFile
, MSFT_SEG_TYPEDESC
)) return retval
;
4198 if (!ctl2_write_segment(This
, hFile
, MSFT_SEG_ARRAYDESC
)) return retval
;
4199 if (!ctl2_write_segment(This
, hFile
, MSFT_SEG_CUSTDATA
)) return retval
;
4200 if (!ctl2_write_segment(This
, hFile
, MSFT_SEG_CUSTDATAGUID
)) return retval
;
4202 ctl2_write_typeinfos(This
, hFile
);
4204 if (!CloseHandle(hFile
)) return retval
;
4210 /******************************************************************************
4211 * ICreateTypeLib2_DeleteTypeInfo {OLEAUT32}
4213 * Deletes a named TypeInfo from a type library.
4218 * Failure: E_OUTOFMEMORY or E_INVALIDARG.
4220 static HRESULT WINAPI
ICreateTypeLib2_fnDeleteTypeInfo(
4221 ICreateTypeLib2
* iface
, /* [I] The type library to delete from. */
4222 LPOLESTR szName
) /* [I] The name of the typeinfo to delete. */
4224 FIXME("(%p,%s), stub!\n", iface
, debugstr_w(szName
));
4225 return E_OUTOFMEMORY
;
4228 /******************************************************************************
4229 * ICreateTypeLib2_SetCustData {OLEAUT32}
4231 * Sets custom data for a type library.
4236 * Failure: E_OUTOFMEMORY or E_INVALIDARG.
4238 static HRESULT WINAPI
ICreateTypeLib2_fnSetCustData(
4239 ICreateTypeLib2
* iface
, /* [I] The type library to store the custom data in. */
4240 REFGUID guid
, /* [I] The GUID used as a key to retrieve the custom data. */
4241 VARIANT
*pVarVal
) /* [I] The custom data itself. */
4243 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
4245 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(guid
), pVarVal
);
4247 return ctl2_set_custdata(This
, guid
, pVarVal
, &This
->typelib_header
.CustomDataOffset
);
4250 /******************************************************************************
4251 * ICreateTypeLib2_SetHelpStringContext {OLEAUT32}
4253 * Sets a context number for the library help string.
4256 * iface [I] The type library to set the help string context for.
4257 * dwContext [I] The help string context.
4261 * Failure: E_OUTOFMEMORY or E_INVALIDARG.
4264 HRESULT WINAPI
ICreateTypeLib2_fnSetHelpStringContext(ICreateTypeLib2
* iface
,
4267 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
4269 TRACE("(%p,%d)\n", iface
, dwContext
);
4271 This
->typelib_header
.helpstringcontext
= dwContext
;
4275 /******************************************************************************
4276 * ICreateTypeLib2_SetHelpStringDll {OLEAUT32}
4278 * Set the DLL used to look up localized help strings.
4281 * iface [I] The type library to set the help DLL for.
4282 * szDllName [I] The name of the help DLL.
4286 * Failure: E_OUTOFMEMORY or E_INVALIDARG.
4289 HRESULT WINAPI
ICreateTypeLib2_fnSetHelpStringDll(ICreateTypeLib2
* iface
,
4292 ICreateTypeLib2Impl
*This
= (ICreateTypeLib2Impl
*)iface
;
4295 TRACE("(%p,%s)\n", iface
, debugstr_w(szDllName
));
4297 return E_INVALIDARG
;
4299 offset
= ctl2_alloc_string(This
, szDllName
);
4301 return E_OUTOFMEMORY
;
4302 This
->typelib_header
.varflags
|= HELPDLLFLAG
;
4303 This
->helpStringDll
= offset
;
4307 /*================== ITypeLib2 Implementation ===================================*/
4309 /******************************************************************************
4310 * ITypeLib2_QueryInterface {OLEAUT32}
4312 * See IUnknown_QueryInterface.
4314 static HRESULT WINAPI
ITypeLib2_fnQueryInterface(ITypeLib2
* iface
, REFIID riid
, LPVOID
* ppv
)
4316 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4318 return ICreateTypeLib2_QueryInterface((ICreateTypeLib2
*)This
, riid
, ppv
);
4321 /******************************************************************************
4322 * ITypeLib2_AddRef {OLEAUT32}
4324 * See IUnknown_AddRef.
4326 static ULONG WINAPI
ITypeLib2_fnAddRef(ITypeLib2
* iface
)
4328 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4330 return ICreateTypeLib2_AddRef((ICreateTypeLib2
*)This
);
4333 /******************************************************************************
4334 * ITypeLib2_Release {OLEAUT32}
4336 * See IUnknown_Release.
4338 static ULONG WINAPI
ITypeLib2_fnRelease(ITypeLib2
* iface
)
4340 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4342 return ICreateTypeLib2_Release((ICreateTypeLib2
*)This
);
4345 /******************************************************************************
4346 * ITypeLib2_GetTypeInfoCount {OLEAUT32}
4348 * See ITypeLib_GetTypeInfoCount.
4350 static UINT WINAPI
ITypeLib2_fnGetTypeInfoCount(
4353 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4355 TRACE("(%p)\n", iface
);
4357 return This
->typelib_header
.nrtypeinfos
;
4360 /******************************************************************************
4361 * ITypeLib2_GetTypeInfo {OLEAUT32}
4363 * See ITypeLib_GetTypeInfo.
4365 static HRESULT WINAPI
ITypeLib2_fnGetTypeInfo(
4368 ITypeInfo
** ppTInfo
)
4370 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4372 TRACE("(%p,%d,%p)\n", iface
, index
, ppTInfo
);
4374 if (index
>= This
->typelib_header
.nrtypeinfos
) {
4375 return TYPE_E_ELEMENTNOTFOUND
;
4378 return ctl2_find_typeinfo_from_offset(This
, This
->typelib_typeinfo_offsets
[index
], ppTInfo
);
4381 /******************************************************************************
4382 * ITypeLib2_GetTypeInfoType {OLEAUT32}
4384 * See ITypeLib_GetTypeInfoType.
4386 static HRESULT WINAPI
ITypeLib2_fnGetTypeInfoType(
4391 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4393 TRACE("(%p,%d,%p)\n", iface
, index
, pTKind
);
4395 if (index
>= This
->typelib_header
.nrtypeinfos
) {
4396 return TYPE_E_ELEMENTNOTFOUND
;
4399 *pTKind
= (This
->typelib_segment_data
[MSFT_SEG_TYPEINFO
][This
->typelib_typeinfo_offsets
[index
]]) & 15;
4404 /******************************************************************************
4405 * ITypeLib2_GetTypeInfoOfGuid {OLEAUT32}
4407 * See ITypeLib_GetTypeInfoOfGuid.
4409 static HRESULT WINAPI
ITypeLib2_fnGetTypeInfoOfGuid(
4412 ITypeInfo
** ppTinfo
)
4414 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4419 TRACE("(%p,%s,%p)\n", iface
, debugstr_guid(guid
), ppTinfo
);
4421 guidoffset
= ctl2_find_guid(This
, ctl2_hash_guid(guid
), guid
);
4422 if (guidoffset
== -1) return TYPE_E_ELEMENTNOTFOUND
;
4424 typeinfo
= ((MSFT_GuidEntry
*)&This
->typelib_segment_data
[MSFT_SEG_GUID
][guidoffset
])->hreftype
;
4425 if (typeinfo
< 0) return TYPE_E_ELEMENTNOTFOUND
;
4427 return ctl2_find_typeinfo_from_offset(This
, typeinfo
, ppTinfo
);
4430 /******************************************************************************
4431 * ITypeLib2_GetLibAttr {OLEAUT32}
4433 * See ITypeLib_GetLibAttr.
4435 static HRESULT WINAPI
ITypeLib2_fnGetLibAttr(
4437 TLIBATTR
** ppTLibAttr
)
4439 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4441 TRACE("(%p,%p)\n", This
, ppTLibAttr
);
4444 return E_INVALIDARG
;
4446 *ppTLibAttr
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(TLIBATTR
));
4448 return E_OUTOFMEMORY
;
4450 if(This
->typelib_header
.posguid
!= -1) {
4451 MSFT_GuidEntry
*guid
;
4453 guid
= (MSFT_GuidEntry
*)&This
->typelib_segment_data
[MSFT_SEG_GUID
][This
->typelib_header
.posguid
];
4454 (*ppTLibAttr
)->guid
= guid
->guid
;
4457 (*ppTLibAttr
)->lcid
= This
->typelib_header
.lcid
;
4458 (*ppTLibAttr
)->syskind
= This
->typelib_header
.varflags
&0x3;
4459 (*ppTLibAttr
)->wMajorVerNum
= This
->typelib_header
.version
&0xffff;
4460 (*ppTLibAttr
)->wMinorVerNum
= This
->typelib_header
.version
>>16;
4461 (*ppTLibAttr
)->wLibFlags
= This
->typelib_header
.flags
;
4465 /******************************************************************************
4466 * ITypeLib2_GetTypeComp {OLEAUT32}
4468 * See ITypeLib_GetTypeComp.
4470 static HRESULT WINAPI
ITypeLib2_fnGetTypeComp(
4472 ITypeComp
** ppTComp
)
4474 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4476 FIXME("(%p,%p), stub!\n", This
, ppTComp
);
4478 return E_OUTOFMEMORY
;
4481 /******************************************************************************
4482 * ITypeLib2_GetDocumentation {OLEAUT32}
4484 * See ITypeLib_GetDocumentation.
4486 static HRESULT WINAPI
ITypeLib2_fnGetDocumentation(
4490 BSTR
* pBstrDocString
,
4491 DWORD
* pdwHelpContext
,
4492 BSTR
* pBstrHelpFile
)
4494 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4497 TRACE("(%p,%d,%p,%p,%p,%p)\n", This
, index
, pBstrName
, pBstrDocString
, pdwHelpContext
, pBstrHelpFile
);
4500 ICreateTypeInfo2Impl
*iter
;
4502 for(iter
=This
->typeinfos
; iter
!=NULL
&& index
!=0; iter
=iter
->next_typeinfo
)
4506 return TYPE_E_ELEMENTNOTFOUND
;
4508 return ITypeInfo_GetDocumentation((ITypeInfo
*)iter
->lpVtblTypeInfo2
,
4509 -1, pBstrName
, pBstrDocString
, pdwHelpContext
, pBstrHelpFile
);
4513 if(This
->typelib_header
.NameOffset
== -1)
4516 MSFT_NameIntro
*name
= (MSFT_NameIntro
*)&This
->
4517 typelib_segment_data
[MSFT_SEG_NAME
][This
->typelib_header
.NameOffset
];
4519 ctl2_decode_name((char*)&name
->namelen
, &string
);
4521 *pBstrName
= SysAllocString(string
);
4523 return E_OUTOFMEMORY
;
4527 if(pBstrDocString
) {
4528 if(This
->typelib_header
.helpstring
== -1)
4529 *pBstrDocString
= NULL
;
4531 ctl2_decode_string(&This
->typelib_segment_data
[MSFT_SEG_STRING
][This
->typelib_header
.helpstring
], &string
);
4533 *pBstrDocString
= SysAllocString(string
);
4534 if(!*pBstrDocString
) {
4535 if(pBstrName
) SysFreeString(*pBstrName
);
4536 return E_OUTOFMEMORY
;
4542 *pdwHelpContext
= This
->typelib_header
.helpcontext
;
4545 if(This
->typelib_header
.helpfile
== -1)
4546 *pBstrHelpFile
= NULL
;
4548 ctl2_decode_string(&This
->typelib_segment_data
[MSFT_SEG_STRING
][This
->typelib_header
.helpfile
], &string
);
4550 *pBstrHelpFile
= SysAllocString(string
);
4551 if(!*pBstrHelpFile
) {
4552 if(pBstrName
) SysFreeString(*pBstrName
);
4553 if(pBstrDocString
) SysFreeString(*pBstrDocString
);
4554 return E_OUTOFMEMORY
;
4562 /******************************************************************************
4563 * ITypeLib2_IsName {OLEAUT32}
4565 * See ITypeLib_IsName.
4567 static HRESULT WINAPI
ITypeLib2_fnIsName(
4573 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4577 MSFT_NameIntro
*nameintro
;
4579 TRACE("(%p,%s,%x,%p)\n", iface
, debugstr_w(szNameBuf
), lHashVal
, pfName
);
4581 ctl2_encode_name(This
, szNameBuf
, &encoded_name
);
4582 nameoffset
= ctl2_find_name(This
, encoded_name
);
4586 if (nameoffset
== -1) return S_OK
;
4588 nameintro
= (MSFT_NameIntro
*)(&This
->typelib_segment_data
[MSFT_SEG_NAME
][nameoffset
]);
4589 if (nameintro
->hreftype
== -1) return S_OK
;
4593 FIXME("Should be decoding our copy of the name over szNameBuf.\n");
4598 /******************************************************************************
4599 * ITypeLib2_FindName {OLEAUT32}
4601 * See ITypeLib_FindName.
4603 static HRESULT WINAPI
ITypeLib2_fnFindName(
4607 ITypeInfo
** ppTInfo
,
4611 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4613 FIXME("(%p,%s,%x,%p,%p,%p), stub!\n", This
, debugstr_w(szNameBuf
), lHashVal
, ppTInfo
, rgMemId
, pcFound
);
4615 return E_OUTOFMEMORY
;
4618 /******************************************************************************
4619 * ITypeLib2_ReleaseTLibAttr {OLEAUT32}
4621 * See ITypeLib_ReleaseTLibAttr.
4623 static void WINAPI
ITypeLib2_fnReleaseTLibAttr(
4625 TLIBATTR
* pTLibAttr
)
4627 TRACE("(%p,%p)\n", iface
, pTLibAttr
);
4629 HeapFree(GetProcessHeap(), 0, pTLibAttr
);
4632 /******************************************************************************
4633 * ICreateTypeLib2_GetCustData {OLEAUT32}
4635 * Retrieves a custom data value stored on a type library.
4640 * Failure: E_OUTOFMEMORY or E_INVALIDARG.
4642 static HRESULT WINAPI
ITypeLib2_fnGetCustData(
4643 ITypeLib2
* iface
, /* [I] The type library in which to find the custom data. */
4644 REFGUID guid
, /* [I] The GUID under which the custom data is stored. */
4645 VARIANT
* pVarVal
) /* [O] The custom data. */
4647 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4649 FIXME("(%p,%s,%p), stub!\n", This
, debugstr_guid(guid
), pVarVal
);
4651 return E_OUTOFMEMORY
;
4654 /******************************************************************************
4655 * ICreateTypeLib2_GetLibStatistics {OLEAUT32}
4657 * Retrieves some statistics about names in a type library, supposedly for
4658 * hash table optimization purposes.
4663 * Failure: E_OUTOFMEMORY or E_INVALIDARG.
4665 static HRESULT WINAPI
ITypeLib2_fnGetLibStatistics(
4666 ITypeLib2
* iface
, /* [I] The type library to get statistics about. */
4667 ULONG
* pcUniqueNames
, /* [O] The number of unique names in the type library. */
4668 ULONG
* pcchUniqueNames
) /* [O] The number of changed (?) characters in names in the type library. */
4670 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4672 FIXME("(%p,%p,%p), stub!\n", This
, pcUniqueNames
, pcchUniqueNames
);
4674 return E_OUTOFMEMORY
;
4677 /******************************************************************************
4678 * ICreateTypeLib2_GetDocumentation2 {OLEAUT32}
4680 * Obtain locale-aware help string information.
4685 * Failure: STG_E_INSUFFICIENTMEMORY or E_INVALIDARG.
4687 static HRESULT WINAPI
ITypeLib2_fnGetDocumentation2(
4691 BSTR
* pbstrHelpString
,
4692 DWORD
* pdwHelpStringContext
,
4693 BSTR
* pbstrHelpStringDll
)
4695 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4697 FIXME("(%p,%d,%d,%p,%p,%p), stub!\n", This
, index
, lcid
, pbstrHelpString
, pdwHelpStringContext
, pbstrHelpStringDll
);
4699 return E_OUTOFMEMORY
;
4702 /******************************************************************************
4703 * ICreateTypeLib2_GetAllCustData {OLEAUT32}
4705 * Retrieve all of the custom data for a type library.
4710 * Failure: E_OUTOFMEMORY or E_INVALIDARG.
4712 static HRESULT WINAPI
ITypeLib2_fnGetAllCustData(
4713 ITypeLib2
* iface
, /* [I] The type library in which to find the custom data. */
4714 CUSTDATA
* pCustData
) /* [O] The structure in which to place the custom data. */
4716 ICreateTypeLib2Impl
*This
= impl_from_ITypeLib2(iface
);
4718 FIXME("(%p,%p), stub!\n", This
, pCustData
);
4720 return E_OUTOFMEMORY
;
4724 /*================== ICreateTypeLib2 & ITypeLib2 VTABLEs And Creation ===================================*/
4726 static const ICreateTypeLib2Vtbl ctypelib2vt
=
4729 ICreateTypeLib2_fnQueryInterface
,
4730 ICreateTypeLib2_fnAddRef
,
4731 ICreateTypeLib2_fnRelease
,
4733 ICreateTypeLib2_fnCreateTypeInfo
,
4734 ICreateTypeLib2_fnSetName
,
4735 ICreateTypeLib2_fnSetVersion
,
4736 ICreateTypeLib2_fnSetGuid
,
4737 ICreateTypeLib2_fnSetDocString
,
4738 ICreateTypeLib2_fnSetHelpFileName
,
4739 ICreateTypeLib2_fnSetHelpContext
,
4740 ICreateTypeLib2_fnSetLcid
,
4741 ICreateTypeLib2_fnSetLibFlags
,
4742 ICreateTypeLib2_fnSaveAllChanges
,
4744 ICreateTypeLib2_fnDeleteTypeInfo
,
4745 ICreateTypeLib2_fnSetCustData
,
4746 ICreateTypeLib2_fnSetHelpStringContext
,
4747 ICreateTypeLib2_fnSetHelpStringDll
4750 static const ITypeLib2Vtbl typelib2vt
=
4753 ITypeLib2_fnQueryInterface
,
4755 ITypeLib2_fnRelease
,
4757 ITypeLib2_fnGetTypeInfoCount
,
4758 ITypeLib2_fnGetTypeInfo
,
4759 ITypeLib2_fnGetTypeInfoType
,
4760 ITypeLib2_fnGetTypeInfoOfGuid
,
4761 ITypeLib2_fnGetLibAttr
,
4762 ITypeLib2_fnGetTypeComp
,
4763 ITypeLib2_fnGetDocumentation
,
4765 ITypeLib2_fnFindName
,
4766 ITypeLib2_fnReleaseTLibAttr
,
4768 ITypeLib2_fnGetCustData
,
4769 ITypeLib2_fnGetLibStatistics
,
4770 ITypeLib2_fnGetDocumentation2
,
4771 ITypeLib2_fnGetAllCustData
,
4774 static ICreateTypeLib2
*ICreateTypeLib2_Constructor(SYSKIND syskind
, LPCOLESTR szFile
)
4776 ICreateTypeLib2Impl
*pCreateTypeLib2Impl
;
4779 TRACE("Constructing ICreateTypeLib2 (%d, %s)\n", syskind
, debugstr_w(szFile
));
4781 pCreateTypeLib2Impl
= HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,sizeof(ICreateTypeLib2Impl
));
4782 if (!pCreateTypeLib2Impl
) return NULL
;
4784 pCreateTypeLib2Impl
->filename
= HeapAlloc(GetProcessHeap(), 0, (strlenW(szFile
) + 1) * sizeof(WCHAR
));
4785 if (!pCreateTypeLib2Impl
->filename
) {
4786 HeapFree(GetProcessHeap(), 0, pCreateTypeLib2Impl
);
4789 strcpyW(pCreateTypeLib2Impl
->filename
, szFile
);
4791 ctl2_init_header(pCreateTypeLib2Impl
);
4792 ctl2_init_segdir(pCreateTypeLib2Impl
);
4794 pCreateTypeLib2Impl
->typelib_header
.varflags
|= syskind
;
4797 * The following two calls return an offset or -1 if out of memory. We
4798 * specifically need an offset of 0, however, so...
4800 if (ctl2_alloc_segment(pCreateTypeLib2Impl
, MSFT_SEG_GUIDHASH
, 0x80, 0x80)) { failed
= 1; }
4801 if (ctl2_alloc_segment(pCreateTypeLib2Impl
, MSFT_SEG_NAMEHASH
, 0x200, 0x200)) { failed
= 1; }
4803 pCreateTypeLib2Impl
->typelib_guidhash_segment
= (int *)pCreateTypeLib2Impl
->typelib_segment_data
[MSFT_SEG_GUIDHASH
];
4804 pCreateTypeLib2Impl
->typelib_namehash_segment
= (int *)pCreateTypeLib2Impl
->typelib_segment_data
[MSFT_SEG_NAMEHASH
];
4806 memset(pCreateTypeLib2Impl
->typelib_guidhash_segment
, 0xff, 0x80);
4807 memset(pCreateTypeLib2Impl
->typelib_namehash_segment
, 0xff, 0x200);
4809 pCreateTypeLib2Impl
->lpVtbl
= &ctypelib2vt
;
4810 pCreateTypeLib2Impl
->lpVtblTypeLib2
= &typelib2vt
;
4811 pCreateTypeLib2Impl
->ref
= 1;
4814 ICreateTypeLib2_fnRelease((ICreateTypeLib2
*)pCreateTypeLib2Impl
);
4818 return (ICreateTypeLib2
*)pCreateTypeLib2Impl
;
4821 /******************************************************************************
4822 * CreateTypeLib2 [OLEAUT32.180]
4824 * Obtains an ICreateTypeLib2 object for creating a new-style (MSFT) type
4829 * See also CreateTypeLib.
4835 HRESULT WINAPI
CreateTypeLib2(
4836 SYSKIND syskind
, /* [I] System type library is for */
4837 LPCOLESTR szFile
, /* [I] Type library file name */
4838 ICreateTypeLib2
** ppctlib
) /* [O] Storage for object returned */
4840 TRACE("(%d,%s,%p)\n", syskind
, debugstr_w(szFile
), ppctlib
);
4842 if (!szFile
) return E_INVALIDARG
;
4843 *ppctlib
= ICreateTypeLib2_Constructor(syskind
, szFile
);
4844 return (*ppctlib
)? S_OK
: E_OUTOFMEMORY
;
4847 /******************************************************************************
4848 * ClearCustData (OLEAUT32.171)
4850 * Clear a custom data types' data.
4853 * lpCust [I] The custom data type instance
4858 void WINAPI
ClearCustData(LPCUSTDATA lpCust
)
4860 if (lpCust
&& lpCust
->cCustData
)
4862 if (lpCust
->prgCustData
)
4866 for (i
= 0; i
< lpCust
->cCustData
; i
++)
4867 VariantClear(&lpCust
->prgCustData
[i
].varValue
);
4869 /* FIXME - Should be using a per-thread IMalloc */
4870 HeapFree(GetProcessHeap(), 0, lpCust
->prgCustData
);
4871 lpCust
->prgCustData
= NULL
;
4873 lpCust
->cCustData
= 0;