2 * Typelib v2 (MSFT) generation
4 * Copyright 2004 Alastair Bridgewater
5 * 2004, 2005 Huw Davies
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 * --------------------------------------------------------------------------------------
26 * Only works on little-endian systems.
31 #include "wine/port.h"
40 #define NONAMELESSUNION
41 #define NONAMELESSSTRUCT
48 #include "widltypes.h"
50 #include "typelib_struct.h"
55 enum MSFT_segment_index
{
56 MSFT_SEG_TYPEINFO
= 0, /* type information */
57 MSFT_SEG_IMPORTINFO
, /* import information */
58 MSFT_SEG_IMPORTFILES
, /* import filenames */
59 MSFT_SEG_REFERENCES
, /* references (?) */
60 MSFT_SEG_GUIDHASH
, /* hash table for guids? */
61 MSFT_SEG_GUID
, /* guid storage */
62 MSFT_SEG_NAMEHASH
, /* hash table for names */
63 MSFT_SEG_NAME
, /* name storage */
64 MSFT_SEG_STRING
, /* string storage */
65 MSFT_SEG_TYPEDESC
, /* type descriptions */
66 MSFT_SEG_ARRAYDESC
, /* array descriptions */
67 MSFT_SEG_CUSTDATA
, /* custom data */
68 MSFT_SEG_CUSTDATAGUID
, /* custom data guids */
69 MSFT_SEG_UNKNOWN
, /* ??? */
70 MSFT_SEG_UNKNOWN2
, /* ??? */
71 MSFT_SEG_MAX
/* total number of segments */
74 typedef struct tagMSFT_ImpFile
{
78 char filename
[0]; /* preceded by two bytes of encoded (length << 2) + flags in the low two bits. */
81 typedef struct _msft_typelib_t
84 MSFT_Header typelib_header
;
85 MSFT_pSeg typelib_segdir
[MSFT_SEG_MAX
];
86 char *typelib_segment_data
[MSFT_SEG_MAX
];
87 int typelib_segment_block_length
[MSFT_SEG_MAX
];
89 INT typelib_typeinfo_offsets
[0x200]; /* Hope that's enough. */
91 INT
*typelib_namehash_segment
;
92 INT
*typelib_guidhash_segment
;
94 INT help_string_dll_offset
;
96 struct _msft_typeinfo_t
*typeinfos
;
97 struct _msft_typeinfo_t
*last_typeinfo
;
100 typedef struct _msft_typeinfo_t
102 msft_typelib_t
*typelib
;
103 MSFT_TypeInfoBase
*typeinfo
;
107 unsigned int var_data_allocated
;
110 unsigned int func_data_allocated
;
125 struct _msft_typeinfo_t
*next_typeinfo
;
130 /*================== Internal functions ===================================*/
132 /****************************************************************************
135 * Initializes the type library header of a new typelib.
137 static void ctl2_init_header(
138 msft_typelib_t
*typelib
) /* [I] The typelib to initialize. */
140 typelib
->typelib_header
.magic1
= 0x5446534d;
141 typelib
->typelib_header
.magic2
= 0x00010002;
142 typelib
->typelib_header
.posguid
= -1;
143 typelib
->typelib_header
.lcid
= 0x0409; /* or do we use the current one? */
144 typelib
->typelib_header
.lcid2
= 0x0;
145 typelib
->typelib_header
.varflags
= 0x40;
146 typelib
->typelib_header
.version
= 0;
147 typelib
->typelib_header
.flags
= 0;
148 typelib
->typelib_header
.nrtypeinfos
= 0;
149 typelib
->typelib_header
.helpstring
= -1;
150 typelib
->typelib_header
.helpstringcontext
= 0;
151 typelib
->typelib_header
.helpcontext
= 0;
152 typelib
->typelib_header
.nametablecount
= 0;
153 typelib
->typelib_header
.nametablechars
= 0;
154 typelib
->typelib_header
.NameOffset
= -1;
155 typelib
->typelib_header
.helpfile
= -1;
156 typelib
->typelib_header
.CustomDataOffset
= -1;
157 typelib
->typelib_header
.res44
= 0x20;
158 typelib
->typelib_header
.res48
= 0x80;
159 typelib
->typelib_header
.dispatchpos
= -1;
160 typelib
->typelib_header
.nimpinfos
= 0;
163 /****************************************************************************
166 * Initializes the segment directory of a new typelib.
168 static void ctl2_init_segdir(
169 msft_typelib_t
*typelib
) /* [I] The typelib to initialize. */
174 segdir
= &typelib
->typelib_segdir
[MSFT_SEG_TYPEINFO
];
176 for (i
= 0; i
< 15; i
++) {
177 segdir
[i
].offset
= -1;
178 segdir
[i
].length
= 0;
179 segdir
[i
].res08
= -1;
180 segdir
[i
].res0c
= 0x0f;
184 /****************************************************************************
187 * Generates a hash key from a GUID.
191 * The hash key for the GUID.
193 static int ctl2_hash_guid(
194 REFGUID guid
) /* [I] The guid to hash. */
200 for (i
= 0; i
< 8; i
++) {
201 hash
^= ((const short *)guid
)[i
];
207 /****************************************************************************
210 * Locates a guid in a type library.
214 * The offset into the GUID segment of the guid, or -1 if not found.
216 static int ctl2_find_guid(
217 msft_typelib_t
*typelib
, /* [I] The typelib to operate against. */
218 int hash_key
, /* [I] The hash key for the guid. */
219 REFGUID guid
) /* [I] The guid to find. */
222 MSFT_GuidEntry
*guidentry
;
224 offset
= typelib
->typelib_guidhash_segment
[hash_key
];
225 while (offset
!= -1) {
226 guidentry
= (MSFT_GuidEntry
*)&typelib
->typelib_segment_data
[MSFT_SEG_GUID
][offset
];
228 if (!memcmp(guidentry
, guid
, sizeof(GUID
))) return offset
;
230 offset
= guidentry
->next_hash
;
236 /****************************************************************************
239 * Locates a name in a type library.
243 * The offset into the NAME segment of the name, or -1 if not found.
247 * The name must be encoded as with ctl2_encode_name().
249 static int ctl2_find_name(
250 msft_typelib_t
*typelib
, /* [I] The typelib to operate against. */
251 char *name
) /* [I] The encoded name to find. */
256 offset
= typelib
->typelib_namehash_segment
[name
[2] & 0x7f];
257 while (offset
!= -1) {
258 namestruct
= (int *)&typelib
->typelib_segment_data
[MSFT_SEG_NAME
][offset
];
260 if (!((namestruct
[2] ^ *((int *)name
)) & 0xffff00ff)) {
261 /* hash codes and lengths match, final test */
262 if (!strncasecmp(name
+4, (void *)(namestruct
+3), name
[0])) break;
265 /* move to next item in hash bucket */
266 offset
= namestruct
[1];
272 /****************************************************************************
275 * Encodes a name string to a form suitable for storing into a type library
276 * or comparing to a name stored in a type library.
280 * The length of the encoded name, including padding and length+hash fields.
284 * Will throw an exception if name or result are NULL. Is not multithread
285 * safe in the slightest.
287 static int ctl2_encode_name(
288 msft_typelib_t
*typelib
, /* [I] The typelib to operate against (used for LCID only). */
289 const char *name
, /* [I] The name string to encode. */
290 char **result
) /* [O] A pointer to a pointer to receive the encoded name. */
293 static char converted_name
[0x104];
297 length
= strlen(name
);
298 memcpy(converted_name
+ 4, name
, length
);
299 converted_name
[0] = length
& 0xff;
301 converted_name
[length
+ 4] = 0;
303 converted_name
[1] = 0x00;
305 value
= lhash_val_of_name_sys(typelib
->typelib_header
.varflags
& 0x0f, typelib
->typelib_header
.lcid
, converted_name
+ 4);
307 converted_name
[2] = value
;
308 converted_name
[3] = value
>> 8;
310 for (offset
= (4 - length
) & 3; offset
; offset
--) converted_name
[length
+ offset
+ 3] = 0x57;
312 *result
= converted_name
;
314 return (length
+ 7) & ~3;
317 /****************************************************************************
320 * Encodes a string to a form suitable for storing into a type library or
321 * comparing to a string stored in a type library.
325 * The length of the encoded string, including padding and length fields.
329 * Will throw an exception if string or result are NULL. Is not multithread
330 * safe in the slightest.
332 static int ctl2_encode_string(
333 const char *string
, /* [I] The string to encode. */
334 char **result
) /* [O] A pointer to a pointer to receive the encoded string. */
337 static char converted_string
[0x104];
340 length
= strlen(string
);
341 memcpy(converted_string
+ 2, string
, length
);
342 converted_string
[0] = length
& 0xff;
343 converted_string
[1] = (length
>> 8) & 0xff;
345 if(length
< 3) { /* strings of this length are padded with up to 8 bytes incl the 2 byte length */
346 for(offset
= 0; offset
< 4; offset
++)
347 converted_string
[length
+ offset
+ 2] = 0x57;
350 for (offset
= (4 - (length
+ 2)) & 3; offset
; offset
--) converted_string
[length
+ offset
+ 1] = 0x57;
352 *result
= converted_string
;
354 return (length
+ 5) & ~3;
357 /****************************************************************************
360 * Allocates memory from a segment in a type library.
364 * Success: The offset within the segment of the new data area.
368 * Does not (yet) handle the case where the allocated segment memory needs to grow.
370 static int ctl2_alloc_segment(
371 msft_typelib_t
*typelib
, /* [I] The type library in which to allocate. */
372 enum MSFT_segment_index segment
, /* [I] The segment in which to allocate. */
373 int size
, /* [I] The amount to allocate. */
374 int block_size
) /* [I] Initial allocation block size, or 0 for default. */
378 if(!typelib
->typelib_segment_data
[segment
]) {
379 if (!block_size
) block_size
= 0x2000;
381 typelib
->typelib_segment_block_length
[segment
] = block_size
;
382 typelib
->typelib_segment_data
[segment
] = xmalloc(block_size
);
383 if (!typelib
->typelib_segment_data
[segment
]) return -1;
384 memset(typelib
->typelib_segment_data
[segment
], 0x57, block_size
);
387 while ((typelib
->typelib_segdir
[segment
].length
+ size
) > typelib
->typelib_segment_block_length
[segment
]) {
390 block_size
= typelib
->typelib_segment_block_length
[segment
];
391 block
= xrealloc(typelib
->typelib_segment_data
[segment
], block_size
<< 1);
393 if (segment
== MSFT_SEG_TYPEINFO
) {
394 /* TypeInfos have a direct pointer to their memory space, so we have to fix them up. */
395 msft_typeinfo_t
*typeinfo
;
397 for (typeinfo
= typelib
->typeinfos
; typeinfo
; typeinfo
= typeinfo
->next_typeinfo
) {
398 typeinfo
->typeinfo
= (void *)&block
[((char *)typeinfo
->typeinfo
) - typelib
->typelib_segment_data
[segment
]];
402 memset(block
+ block_size
, 0x57, block_size
);
403 typelib
->typelib_segment_block_length
[segment
] = block_size
<< 1;
404 typelib
->typelib_segment_data
[segment
] = block
;
407 offset
= typelib
->typelib_segdir
[segment
].length
;
408 typelib
->typelib_segdir
[segment
].length
+= size
;
413 /****************************************************************************
414 * ctl2_alloc_typeinfo
416 * Allocates and initializes a typeinfo structure in a type library.
420 * Success: The offset of the new typeinfo.
421 * Failure: -1 (this is invariably an out of memory condition).
423 static int ctl2_alloc_typeinfo(
424 msft_typelib_t
*typelib
, /* [I] The type library to allocate in. */
425 int nameoffset
) /* [I] The offset of the name for this typeinfo. */
428 MSFT_TypeInfoBase
*typeinfo
;
430 offset
= ctl2_alloc_segment(typelib
, MSFT_SEG_TYPEINFO
, sizeof(MSFT_TypeInfoBase
), 0);
432 typelib
->typelib_typeinfo_offsets
[typelib
->typelib_header
.nrtypeinfos
++] = offset
;
434 typeinfo
= (void *)(typelib
->typelib_segment_data
[MSFT_SEG_TYPEINFO
] + offset
);
436 typeinfo
->typekind
= (typelib
->typelib_header
.nrtypeinfos
- 1) << 16;
437 typeinfo
->memoffset
= -1; /* should be EOF if no elements */
442 typeinfo
->cElement
= 0;
447 typeinfo
->posguid
= -1;
449 typeinfo
->NameOffset
= nameoffset
;
450 typeinfo
->version
= 0;
451 typeinfo
->docstringoffs
= -1;
452 typeinfo
->helpstringcontext
= 0;
453 typeinfo
->helpcontext
= 0;
454 typeinfo
->oCustData
= -1;
455 typeinfo
->cbSizeVft
= 0;
456 typeinfo
->cImplTypes
= 0;
458 typeinfo
->datatype1
= -1;
459 typeinfo
->datatype2
= 0;
461 typeinfo
->res19
= -1;
466 /****************************************************************************
469 * Allocates and initializes a GUID structure in a type library. Also updates
470 * the GUID hash table as needed.
474 * Success: The offset of the new GUID.
476 static int ctl2_alloc_guid(
477 msft_typelib_t
*typelib
, /* [I] The type library to allocate in. */
478 MSFT_GuidEntry
*guid
) /* [I] The GUID to store. */
481 MSFT_GuidEntry
*guid_space
;
484 hash_key
= ctl2_hash_guid(&guid
->guid
);
486 offset
= ctl2_find_guid(typelib
, hash_key
, &guid
->guid
);
487 if (offset
!= -1) return offset
;
489 offset
= ctl2_alloc_segment(typelib
, MSFT_SEG_GUID
, sizeof(MSFT_GuidEntry
), 0);
491 guid_space
= (void *)(typelib
->typelib_segment_data
[MSFT_SEG_GUID
] + offset
);
494 guid_space
->next_hash
= typelib
->typelib_guidhash_segment
[hash_key
];
495 typelib
->typelib_guidhash_segment
[hash_key
] = offset
;
500 /****************************************************************************
503 * Allocates and initializes a name within a type library. Also updates the
504 * name hash table as needed.
508 * Success: The offset within the segment of the new name.
509 * Failure: -1 (this is invariably an out of memory condition).
511 static int ctl2_alloc_name(
512 msft_typelib_t
*typelib
, /* [I] The type library to allocate in. */
513 const char *name
) /* [I] The name to store. */
517 MSFT_NameIntro
*name_space
;
520 length
= ctl2_encode_name(typelib
, name
, &encoded_name
);
522 offset
= ctl2_find_name(typelib
, encoded_name
);
523 if (offset
!= -1) return offset
;
525 offset
= ctl2_alloc_segment(typelib
, MSFT_SEG_NAME
, length
+ 8, 0);
527 name_space
= (void *)(typelib
->typelib_segment_data
[MSFT_SEG_NAME
] + offset
);
528 name_space
->hreftype
= -1;
529 name_space
->next_hash
= -1;
530 memcpy(&name_space
->namelen
, encoded_name
, length
);
532 if (typelib
->typelib_namehash_segment
[encoded_name
[2] & 0x7f] != -1)
533 name_space
->next_hash
= typelib
->typelib_namehash_segment
[encoded_name
[2] & 0x7f];
535 typelib
->typelib_namehash_segment
[encoded_name
[2] & 0x7f] = offset
;
537 typelib
->typelib_header
.nametablecount
+= 1;
538 typelib
->typelib_header
.nametablechars
+= *encoded_name
;
543 /****************************************************************************
546 * Allocates and initializes a string in a type library.
550 * Success: The offset within the segment of the new string.
551 * Failure: -1 (this is invariably an out of memory condition).
553 static int ctl2_alloc_string(
554 msft_typelib_t
*typelib
, /* [I] The type library to allocate in. */
555 const char *string
) /* [I] The string to store. */
560 char *encoded_string
;
562 length
= ctl2_encode_string(string
, &encoded_string
);
564 for (offset
= 0; offset
< typelib
->typelib_segdir
[MSFT_SEG_STRING
].length
;
565 offset
+= ((((typelib
->typelib_segment_data
[MSFT_SEG_STRING
][offset
+ 1] << 8) & 0xff)
566 | (typelib
->typelib_segment_data
[MSFT_SEG_STRING
][offset
+ 0] & 0xff)) + 5) & ~3) {
567 if (!memcmp(encoded_string
, typelib
->typelib_segment_data
[MSFT_SEG_STRING
] + offset
, length
)) return offset
;
570 offset
= ctl2_alloc_segment(typelib
, MSFT_SEG_STRING
, length
, 0);
572 string_space
= typelib
->typelib_segment_data
[MSFT_SEG_STRING
] + offset
;
573 memcpy(string_space
, encoded_string
, length
);
578 /****************************************************************************
579 * alloc_msft_importinfo
581 * Allocates and initializes an import information structure in a type library.
585 * Success: The offset of the new importinfo.
586 * Failure: -1 (this is invariably an out of memory condition).
588 static int alloc_msft_importinfo(
589 msft_typelib_t
*typelib
, /* [I] The type library to allocate in. */
590 MSFT_ImpInfo
*impinfo
) /* [I] The import information to store. */
593 MSFT_ImpInfo
*impinfo_space
;
596 offset
< typelib
->typelib_segdir
[MSFT_SEG_IMPORTINFO
].length
;
597 offset
+= sizeof(MSFT_ImpInfo
)) {
598 if (!memcmp(&(typelib
->typelib_segment_data
[MSFT_SEG_IMPORTINFO
][offset
]),
599 impinfo
, sizeof(MSFT_ImpInfo
))) {
604 impinfo
->flags
|= typelib
->typelib_header
.nimpinfos
++;
606 offset
= ctl2_alloc_segment(typelib
, MSFT_SEG_IMPORTINFO
, sizeof(MSFT_ImpInfo
), 0);
608 impinfo_space
= (void *)(typelib
->typelib_segment_data
[MSFT_SEG_IMPORTINFO
] + offset
);
609 *impinfo_space
= *impinfo
;
614 /****************************************************************************
617 * Allocates and initializes an import file definition in a type library.
621 * Success: The offset of the new importinfo.
622 * Failure: -1 (this is invariably an out of memory condition).
624 static int alloc_importfile(
625 msft_typelib_t
*typelib
, /* [I] The type library to allocate in. */
626 int guidoffset
, /* [I] The offset to the GUID for the imported library. */
627 int major_version
, /* [I] The major version number of the imported library. */
628 int minor_version
, /* [I] The minor version number of the imported library. */
629 const char *filename
) /* [I] The filename of the imported library. */
633 MSFT_ImpFile
*importfile
;
634 char *encoded_string
;
636 length
= ctl2_encode_string(filename
, &encoded_string
);
638 encoded_string
[0] <<= 2;
639 encoded_string
[0] |= 1;
641 for (offset
= 0; offset
< typelib
->typelib_segdir
[MSFT_SEG_IMPORTFILES
].length
;
642 offset
+= ((((typelib
->typelib_segment_data
[MSFT_SEG_IMPORTFILES
][offset
+ 0xd] << 8) & 0xff)
643 | (typelib
->typelib_segment_data
[MSFT_SEG_IMPORTFILES
][offset
+ 0xc] & 0xff)) >> 2) + 0xc) {
644 if (!memcmp(encoded_string
, typelib
->typelib_segment_data
[MSFT_SEG_IMPORTFILES
] + offset
+ 0xc, length
)) return offset
;
647 offset
= ctl2_alloc_segment(typelib
, MSFT_SEG_IMPORTFILES
, length
+ 0xc, 0);
649 importfile
= (MSFT_ImpFile
*)&typelib
->typelib_segment_data
[MSFT_SEG_IMPORTFILES
][offset
];
650 importfile
->guid
= guidoffset
;
651 importfile
->lcid
= typelib
->typelib_header
.lcid2
;
652 importfile
->version
= major_version
| (minor_version
<< 16);
653 memcpy(&importfile
->filename
, encoded_string
, length
);
658 static void alloc_importinfo(msft_typelib_t
*typelib
, importinfo_t
*importinfo
)
660 importlib_t
*importlib
= importinfo
->importlib
;
662 chat("alloc_importinfo: %s\n", importinfo
->name
);
664 if(!importlib
->allocated
) {
668 chat("allocating importlib %s\n", importlib
->name
);
670 importlib
->allocated
= -1;
672 memcpy(&guid
.guid
, &importlib
->guid
, sizeof(GUID
));
675 guid_idx
= ctl2_alloc_guid(typelib
, &guid
);
677 alloc_importfile(typelib
, guid_idx
, importlib
->version
&0xffff,
678 importlib
->version
>>16, importlib
->name
);
681 if(importinfo
->offset
== -1 || !(importinfo
->flags
& MSFT_IMPINFO_OFFSET_IS_GUID
)) {
682 MSFT_ImpInfo impinfo
;
684 impinfo
.flags
= importinfo
->flags
;
685 impinfo
.oImpFile
= 0;
687 if(importinfo
->flags
& MSFT_IMPINFO_OFFSET_IS_GUID
) {
691 memcpy(&guid
.guid
, &importinfo
->guid
, sizeof(GUID
));
693 impinfo
.oGuid
= ctl2_alloc_guid(typelib
, &guid
);
695 importinfo
->offset
= alloc_msft_importinfo(typelib
, &impinfo
);
697 typelib
->typelib_segment_data
[MSFT_SEG_GUID
][impinfo
.oGuid
+sizeof(GUID
)]
698 = importinfo
->offset
+1;
700 if(!strcmp(importinfo
->name
, "IDispatch"))
701 typelib
->typelib_header
.dispatchpos
= importinfo
->offset
+1;
703 impinfo
.oGuid
= importinfo
->id
;
704 importinfo
->offset
= alloc_msft_importinfo(typelib
, &impinfo
);
709 static importinfo_t
*find_importinfo(msft_typelib_t
*typelib
, const char *name
)
711 importlib_t
*importlib
;
714 chat("search importlib %s\n", name
);
719 LIST_FOR_EACH_ENTRY( importlib
, &typelib
->typelib
->importlibs
, importlib_t
, entry
)
721 for(i
=0; i
< importlib
->ntypeinfos
; i
++) {
722 if(!strcmp(name
, importlib
->importinfos
[i
].name
)) {
723 chat("Found %s in importlib.\n", name
);
724 return importlib
->importinfos
+i
;
732 static void add_structure_typeinfo(msft_typelib_t
*typelib
, type_t
*structure
);
733 static void add_interface_typeinfo(msft_typelib_t
*typelib
, type_t
*interface
);
734 static void add_enum_typeinfo(msft_typelib_t
*typelib
, type_t
*enumeration
);
735 static void add_coclass_typeinfo(msft_typelib_t
*typelib
, type_t
*cls
);
738 /****************************************************************************
741 * Encodes a type, storing information in the TYPEDESC and ARRAYDESC
742 * segments as needed.
749 static int encode_type(
750 msft_typelib_t
*typelib
, /* [I] The type library in which to encode the TYPEDESC. */
751 int vt
, /* [I] vt to encode */
752 type_t
*type
, /* [I] type */
753 int *encoded_type
, /* [O] The encoded type description. */
754 int *width
, /* [O] The width of the type, or NULL. */
755 int *alignment
, /* [O] The alignment of the type, or NULL. */
756 int *decoded_size
) /* [O] The total size of the unencoded TYPEDESCs, including nested descs. */
765 chat("encode_type vt %d type %p\n", vt
, type
);
767 default_type
= 0x80000000 | (vt
<< 16) | vt
;
768 if (!width
) width
= &scratch
;
769 if (!alignment
) alignment
= &scratch
;
770 if (!decoded_size
) decoded_size
= &scratch
;
776 *encoded_type
= default_type
;
782 *encoded_type
= 0x80000000 | (VT_I4
<< 16) | VT_INT
;
783 if ((typelib
->typelib_header
.varflags
& 0x0f) == SYS_WIN16
) {
793 *encoded_type
= 0x80000000 | (VT_UI4
<< 16) | VT_UINT
;
794 if ((typelib
->typelib_header
.varflags
& 0x0f) == SYS_WIN16
) {
806 *encoded_type
= default_type
;
817 *encoded_type
= default_type
;
825 *encoded_type
= default_type
;
832 *encoded_type
= default_type
;
838 *encoded_type
= 0x80000000 | (VT_EMPTY
<< 16) | vt
;
845 *encoded_type
= default_type
;
851 *encoded_type
= default_type
;
857 for(next_vt
= 0; type
->ref
; type
= type
->ref
) {
858 next_vt
= get_type_vt(type
->ref
);
862 /* if no type found then it must be void */
866 encode_type(typelib
, next_vt
, type
->ref
, &target_type
, NULL
, NULL
, &child_size
);
867 if(type
->ref
&& (type
->ref
->type
== RPC_FC_IP
)) {
868 chat("encode_type: skipping ptr\n");
869 *encoded_type
= target_type
;
872 *decoded_size
= child_size
;
876 for (typeoffset
= 0; typeoffset
< typelib
->typelib_segdir
[MSFT_SEG_TYPEDESC
].length
; typeoffset
+= 8) {
877 typedata
= (void *)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][typeoffset
];
878 if (((typedata
[0] & 0xffff) == VT_PTR
) && (typedata
[1] == target_type
)) break;
881 if (typeoffset
== typelib
->typelib_segdir
[MSFT_SEG_TYPEDESC
].length
) {
884 if (target_type
& 0x80000000) {
885 mix_field
= ((target_type
>> 16) & 0x3fff) | VT_BYREF
;
887 typedata
= (void *)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][target_type
];
888 mix_field
= ((typedata
[0] >> 16) == 0x7fff)? 0x7fff: 0x7ffe;
891 typeoffset
= ctl2_alloc_segment(typelib
, MSFT_SEG_TYPEDESC
, 8, 0);
892 typedata
= (void *)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][typeoffset
];
894 typedata
[0] = (mix_field
<< 16) | VT_PTR
;
895 typedata
[1] = target_type
;
898 *encoded_type
= typeoffset
;
902 *decoded_size
= 8 /*sizeof(TYPEDESC)*/ + child_size
;
909 /* FIXME: Make with the error checking. */
910 FIXME("SAFEARRAY vartype, may not work correctly.\n");
912 ctl2_encode_typedesc(typelib
, tdesc
->u
.lptdesc
, &target_type
, NULL
, NULL
, &child_size
);
914 for (typeoffset
= 0; typeoffset
< typelib
->typelib_segdir
[MSFT_SEG_TYPEDESC
].length
; typeoffset
+= 8) {
915 typedata
= (void *)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][typeoffset
];
916 if (((typedata
[0] & 0xffff) == VT_SAFEARRAY
) && (typedata
[1] == target_type
)) break;
919 if (typeoffset
== typelib
->typelib_segdir
[MSFT_SEG_TYPEDESC
].length
) {
922 if (target_type
& 0x80000000) {
923 mix_field
= ((target_type
>> 16) & VT_TYPEMASK
) | VT_ARRAY
;
925 typedata
= (void *)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][target_type
];
926 mix_field
= ((typedata
[0] >> 16) == 0x7fff)? 0x7fff: 0x7ffe;
929 typeoffset
= ctl2_alloc_segment(typelib
, MSFT_SEG_TYPEDESC
, 8, 0);
930 typedata
= (void *)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][typeoffset
];
932 typedata
[0] = (mix_field
<< 16) | VT_SAFEARRAY
;
933 typedata
[1] = target_type
;
936 *encoded_tdesc
= typeoffset
;
940 *decoded_size
= sizeof(TYPEDESC
) + child_size
;
950 /* typedef'd types without attributes aren't included in the typelib */
951 while (type
->typelib_idx
< 0 && type
->kind
== TKIND_ALIAS
&& ! type
->attrs
)
954 chat("encode_type: VT_USERDEFINED - type %p name = %s type->type %d idx %d\n", type
,
955 type
->name
, type
->type
, type
->typelib_idx
);
957 if(type
->typelib_idx
== -1) {
958 chat("encode_type: trying to ref not added type\n");
963 case RPC_FC_CPSTRUCT
:
964 case RPC_FC_CVSTRUCT
:
965 case RPC_FC_BOGUS_STRUCT
:
966 add_structure_typeinfo(typelib
, type
);
969 add_interface_typeinfo(typelib
, type
);
972 add_enum_typeinfo(typelib
, type
);
975 if (type
->kind
== TKIND_COCLASS
)
976 add_coclass_typeinfo(typelib
, type
);
978 error("encode_type: VT_USERDEFINED - can't yet add typedef's on the fly\n");
981 error("encode_type: VT_USERDEFINED - unhandled type %d\n", type
->type
);
985 typeinfo_offset
= typelib
->typelib_typeinfo_offsets
[type
->typelib_idx
];
986 for (typeoffset
= 0; typeoffset
< typelib
->typelib_segdir
[MSFT_SEG_TYPEDESC
].length
; typeoffset
+= 8) {
987 typedata
= (void *)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][typeoffset
];
988 if ((typedata
[0] == ((0x7fff << 16) | VT_USERDEFINED
)) && (typedata
[1] == typeinfo_offset
)) break;
991 if (typeoffset
== typelib
->typelib_segdir
[MSFT_SEG_TYPEDESC
].length
) {
992 typeoffset
= ctl2_alloc_segment(typelib
, MSFT_SEG_TYPEDESC
, 8, 0);
993 typedata
= (void *)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][typeoffset
];
995 typedata
[0] = (0x7fff << 16) | VT_USERDEFINED
;
996 typedata
[1] = typeinfo_offset
;
999 *encoded_type
= typeoffset
;
1003 if(type
->type
== RPC_FC_IP
) {
1004 for (typeoffset
= 0; typeoffset
< typelib
->typelib_segdir
[MSFT_SEG_TYPEDESC
].length
; typeoffset
+= 8) {
1005 typedata
= (void *)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][typeoffset
];
1006 if ((typedata
[0] == ((0x7fff << 16) | VT_PTR
)) && (typedata
[1] == *encoded_type
)) break;
1008 if (typeoffset
== typelib
->typelib_segdir
[MSFT_SEG_TYPEDESC
].length
) {
1009 typeoffset
= ctl2_alloc_segment(typelib
, MSFT_SEG_TYPEDESC
, 8, 0);
1010 typedata
= (void *)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][typeoffset
];
1012 typedata
[0] = (0x7fff << 16) | VT_PTR
;
1013 typedata
[1] = *encoded_type
;
1015 *encoded_type
= typeoffset
;
1024 error("encode_type: unrecognized type %d.\n", vt
);
1025 *encoded_type
= default_type
;
1034 static void dump_type(type_t
*t
)
1036 chat("dump_type: %p name %s type %d ref %p attrs %p\n", t
, t
->name
, t
->type
, t
->ref
, t
->attrs
);
1037 if(t
->ref
) dump_type(t
->ref
);
1040 static int encode_var(
1041 msft_typelib_t
*typelib
, /* [I] The type library in which to encode the TYPEDESC. */
1042 var_t
*var
, /* [I] The type description to encode. */
1043 int *encoded_type
, /* [O] The encoded type description. */
1044 int *width
, /* [O] The width of the type, or NULL. */
1045 int *alignment
, /* [O] The alignment of the type, or NULL. */
1046 int *decoded_size
) /* [O] The total size of the unencoded TYPEDESCs, including nested descs. */
1056 if (!width
) width
= &scratch
;
1057 if (!alignment
) alignment
= &scratch
;
1058 if (!decoded_size
) decoded_size
= &scratch
;
1061 chat("encode_var: var %p var->tname %s var->type %p var->ptr_level %d var->type->ref %p\n", var
, var
->tname
, var
->type
, var
->ptr_level
, var
->type
->ref
);
1062 if(var
->ptr_level
) {
1065 skip_ptr
= encode_var(typelib
, var
, &target_type
, NULL
, NULL
, &child_size
);
1069 chat("encode_var: skipping ptr\n");
1070 *encoded_type
= target_type
;
1071 *decoded_size
= child_size
;
1077 for (typeoffset
= 0; typeoffset
< typelib
->typelib_segdir
[MSFT_SEG_TYPEDESC
].length
; typeoffset
+= 8) {
1078 typedata
= (void *)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][typeoffset
];
1079 if (((typedata
[0] & 0xffff) == VT_PTR
) && (typedata
[1] == target_type
)) break;
1082 if (typeoffset
== typelib
->typelib_segdir
[MSFT_SEG_TYPEDESC
].length
) {
1085 if (target_type
& 0x80000000) {
1086 mix_field
= ((target_type
>> 16) & 0x3fff) | VT_BYREF
;
1088 typedata
= (void *)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][target_type
];
1089 mix_field
= ((typedata
[0] >> 16) == 0x7fff)? 0x7fff: 0x7ffe;
1092 typeoffset
= ctl2_alloc_segment(typelib
, MSFT_SEG_TYPEDESC
, 8, 0);
1093 typedata
= (void *)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][typeoffset
];
1095 typedata
[0] = (mix_field
<< 16) | VT_PTR
;
1096 typedata
[1] = target_type
;
1099 *encoded_type
= typeoffset
;
1103 *decoded_size
= 8 /*sizeof(TYPEDESC)*/ + child_size
;
1109 array_dims_t
*array_save
;
1110 int num_dims
= list_count( var
->array
), elements
= 1, arrayoffset
;
1113 chat("array with %d dimensions\n", num_dims
);
1114 array_save
= var
->array
;
1116 encode_var(typelib
, var
, &target_type
, width
, alignment
, NULL
);
1117 var
->array
= array_save
;
1118 arrayoffset
= ctl2_alloc_segment(typelib
, MSFT_SEG_ARRAYDESC
, (2 + 2 * num_dims
) * sizeof(long), 0);
1119 arraydata
= (void *)&typelib
->typelib_segment_data
[MSFT_SEG_ARRAYDESC
][arrayoffset
];
1121 arraydata
[0] = target_type
;
1122 arraydata
[1] = num_dims
;
1123 arraydata
[1] |= ((num_dims
* 2 * sizeof(long)) << 16);
1126 LIST_FOR_EACH_ENTRY( dim
, var
->array
, expr_t
, entry
)
1128 arraydata
[0] = dim
->cval
;
1131 elements
*= dim
->cval
;
1134 typeoffset
= ctl2_alloc_segment(typelib
, MSFT_SEG_TYPEDESC
, 8, 0);
1135 typedata
= (void *)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEDESC
][typeoffset
];
1137 typedata
[0] = (0x7ffe << 16) | VT_CARRAY
;
1138 typedata
[1] = arrayoffset
;
1140 *encoded_type
= typeoffset
;
1141 *width
= *width
* elements
;
1142 *decoded_size
= 20 /*sizeof(ARRAYDESC)*/ + (num_dims
- 1) * 8 /*sizeof(SAFEARRAYBOUND)*/;
1145 dump_type(var
->type
);
1147 vt
= get_var_vt(var
);
1150 if(type
->ref
== NULL
) {
1155 vt
= get_type_vt(type
);
1157 encode_type(typelib
, vt
, type
, encoded_type
, width
, alignment
, decoded_size
);
1158 if(type
->type
== RPC_FC_IP
) return 2;
1163 static void write_value(msft_typelib_t
* typelib
, int *out
, int vt
, void *value
)
1178 unsigned long *lv
= value
;
1179 if((*lv
& 0x3ffffff) == *lv
) {
1184 int offset
= ctl2_alloc_segment(typelib
, MSFT_SEG_CUSTDATA
, 8, 0);
1185 *((unsigned short *)&typelib
->typelib_segment_data
[MSFT_SEG_CUSTDATA
][offset
]) = vt
;
1186 memcpy(&typelib
->typelib_segment_data
[MSFT_SEG_CUSTDATA
][offset
+2], value
, 4);
1187 *((unsigned short *)&typelib
->typelib_segment_data
[MSFT_SEG_CUSTDATA
][offset
+6]) = 0x5757;
1194 char *s
= (char *) value
;
1195 int len
= strlen(s
), seg_len
= (len
+ 6 + 3) & ~0x3;
1196 int offset
= ctl2_alloc_segment(typelib
, MSFT_SEG_CUSTDATA
, seg_len
, 0);
1197 *((unsigned short *)&typelib
->typelib_segment_data
[MSFT_SEG_CUSTDATA
][offset
]) = vt
;
1198 *((unsigned int *)&typelib
->typelib_segment_data
[MSFT_SEG_CUSTDATA
][offset
+2]) = len
;
1199 memcpy(&typelib
->typelib_segment_data
[MSFT_SEG_CUSTDATA
][offset
+6], value
, len
);
1201 while(len
< seg_len
) {
1202 *((char *)&typelib
->typelib_segment_data
[MSFT_SEG_CUSTDATA
][offset
+len
]) = 0x57;
1210 warning("can't write value of type %d yet\n", vt
);
1215 static HRESULT
set_custdata(msft_typelib_t
*typelib
, REFGUID guid
,
1216 int vt
, void *value
, int *offset
)
1218 MSFT_GuidEntry guidentry
;
1224 guidentry
.guid
= *guid
;
1226 guidentry
.hreftype
= -1;
1227 guidentry
.next_hash
= -1;
1229 guidoffset
= ctl2_alloc_guid(typelib
, &guidentry
);
1230 write_value(typelib
, &data_out
, vt
, value
);
1232 custoffset
= ctl2_alloc_segment(typelib
, MSFT_SEG_CUSTDATAGUID
, 12, 0);
1234 custdata
= (int *)&typelib
->typelib_segment_data
[MSFT_SEG_CUSTDATAGUID
][custoffset
];
1235 custdata
[0] = guidoffset
;
1236 custdata
[1] = data_out
;
1237 custdata
[2] = *offset
;
1238 *offset
= custoffset
;
1243 static HRESULT
add_func_desc(msft_typeinfo_t
* typeinfo
, const func_t
*func
, int index
)
1245 int offset
, name_offset
;
1246 int *typedata
, typedata_size
;
1247 int i
, id
, next_idx
;
1248 int decoded_size
, extra_attr
= 0;
1249 int num_params
= 0, num_defaults
= 0;
1253 unsigned int funcflags
= 0, callconv
= 4 /* CC_STDCALL */;
1254 unsigned int funckind
, invokekind
= 1 /* INVOKE_FUNC */;
1255 int help_context
= 0, help_string_context
= 0, help_string_offset
= -1;
1256 int entry
= -1, entry_is_ord
= 0;
1258 chat("add_func_desc(%p,%d)\n", typeinfo
, index
);
1260 id
= ((0x6000 | (typeinfo
->typeinfo
->datatype2
& 0xffff)) << 16) | index
;
1262 switch(typeinfo
->typekind
) {
1263 case TKIND_DISPATCH
:
1264 funckind
= 0x4; /* FUNC_DISPATCH */
1267 funckind
= 0x3; /* FUNC_STATIC */
1270 funckind
= 0x1; /* FUNC_PUREVIRTUAL */
1274 if (is_local( func
->def
->attrs
)) {
1275 chat("add_func_desc: skipping local function\n");
1280 LIST_FOR_EACH_ENTRY( arg
, func
->args
, var_t
, entry
)
1283 if (arg
->attrs
) LIST_FOR_EACH_ENTRY( attr
, arg
->attrs
, const attr_t
, entry
) {
1284 if(attr
->type
== ATTR_DEFAULTVALUE_EXPR
|| attr
->type
== ATTR_DEFAULTVALUE_STRING
) {
1291 chat("add_func_desc: num of params %d\n", num_params
);
1293 name_offset
= ctl2_alloc_name(typeinfo
->typelib
, func
->def
->name
);
1295 if (func
->def
->attrs
) LIST_FOR_EACH_ENTRY( attr
, func
->def
->attrs
, const attr_t
, entry
) {
1296 expr_t
*expr
= attr
->u
.pval
;
1297 switch(attr
->type
) {
1298 case ATTR_ENTRY_ORDINAL
:
1299 extra_attr
= max(extra_attr
, 3);
1303 case ATTR_ENTRY_STRING
:
1304 extra_attr
= max(extra_attr
, 3);
1305 entry
= ctl2_alloc_string(typeinfo
->typelib
, attr
->u
.pval
);
1307 case ATTR_HELPCONTEXT
:
1308 extra_attr
= max(extra_attr
, 1);
1309 help_context
= expr
->u
.lval
;
1311 case ATTR_HELPSTRING
:
1312 extra_attr
= max(extra_attr
, 2);
1313 help_string_offset
= ctl2_alloc_string(typeinfo
->typelib
, attr
->u
.pval
);
1315 case ATTR_HELPSTRINGCONTEXT
:
1316 extra_attr
= max(extra_attr
, 6);
1317 help_string_context
= expr
->u
.lval
;
1320 funcflags
|= 0x40; /* FUNCFLAG_FHIDDEN */
1328 invokekind
= 0x2; /* INVOKE_PROPERTYGET */
1331 invokekind
= 0x4; /* INVOKE_PROPERTYPUT */
1333 case ATTR_PROPPUTREF
:
1334 invokekind
= 0x8; /* INVOKE_PROPERTYPUTREF */
1336 case ATTR_RESTRICTED
:
1337 funcflags
|= 0x1; /* FUNCFLAG_FRESTRICTED */
1340 funcflags
|= 0x4; /* FUNCFLAG_BINDABLE */
1343 warning("add_func_desc: ignoring attr %d\n", attr
->type
);
1348 switch(invokekind
) {
1349 case 0x2: /* INVOKE_PROPERTYGET */
1350 if((num_params
!= 0 && typeinfo
->typekind
== TKIND_DISPATCH
)
1351 || (num_params
!= 1 && typeinfo
->typekind
== TKIND_INTERFACE
)) {
1352 error("expecting no args on a propget func\n");
1356 case 0x4: /* INVOKE_PROPERTYPUT */
1357 case 0x8: /* INVOKE_PROPERTYPUTREF */
1358 if(num_params
!= 1) {
1359 error("expecting one arg on a propput func\n");
1367 /* allocate type data space for us */
1368 typedata_size
= 0x18 + extra_attr
* sizeof(int) + (num_params
* (num_defaults
? 16 : 12));
1370 if (!typeinfo
->func_data
) {
1371 typeinfo
->func_data
= xmalloc(0x100);
1372 typeinfo
->func_data_allocated
= 0x100;
1373 typeinfo
->func_data
[0] = 0;
1376 if(typeinfo
->func_data
[0] + typedata_size
+ sizeof(int) > typeinfo
->func_data_allocated
) {
1377 typeinfo
->func_data_allocated
= max(typeinfo
->func_data_allocated
* 2,
1378 typeinfo
->func_data
[0] + typedata_size
+ sizeof(int));
1379 typeinfo
->func_data
= xrealloc(typeinfo
->func_data
, typeinfo
->func_data_allocated
);
1382 offset
= typeinfo
->func_data
[0];
1383 typeinfo
->func_data
[0] += typedata_size
;
1384 typedata
= typeinfo
->func_data
+ (offset
>> 2) + 1;
1387 /* find func with the same name - if it exists use its id */
1388 for(i
= 0; i
< (typeinfo
->typeinfo
->cElement
& 0xffff); i
++) {
1389 if(name_offset
== typeinfo
->func_names
[i
]) {
1390 id
= typeinfo
->func_indices
[i
];
1395 /* find the first func with the same id and link via the hiword of typedata[4] */
1397 for(i
= 0; i
< (typeinfo
->typeinfo
->cElement
& 0xffff); i
++) {
1398 if(id
== typeinfo
->func_indices
[i
]) {
1399 next_idx
= typeinfo
->func_data
[(typeinfo
->func_offsets
[i
] >> 2) + 1 + 4] >> 16;
1400 typeinfo
->func_data
[(typeinfo
->func_offsets
[i
] >> 2) + 1 + 4] &= 0xffff;
1401 typeinfo
->func_data
[(typeinfo
->func_offsets
[i
] >> 2) + 1 + 4] |= (index
<< 16);
1406 /* fill out the basic type information */
1407 typedata
[0] = typedata_size
| (index
<< 16);
1408 encode_var(typeinfo
->typelib
, func
->def
, &typedata
[1], NULL
, NULL
, &decoded_size
);
1409 typedata
[2] = funcflags
;
1410 typedata
[3] = ((52 /*sizeof(FUNCDESC)*/ + decoded_size
) << 16) | typeinfo
->typeinfo
->cbSizeVft
;
1411 typedata
[4] = (next_idx
<< 16) | (callconv
<< 8) | (invokekind
<< 3) | funckind
;
1412 if(num_defaults
) typedata
[4] |= 0x1000;
1413 if(entry_is_ord
) typedata
[4] |= 0x2000;
1414 typedata
[5] = num_params
;
1416 /* NOTE: High word of typedata[3] is total size of FUNCDESC + size of all ELEMDESCs for params + TYPEDESCs for pointer params and return types. */
1417 /* That is, total memory allocation required to reconstitute the FUNCDESC in its entirety. */
1418 typedata
[3] += (16 /*sizeof(ELEMDESC)*/ * num_params
) << 16;
1419 typedata
[3] += (24 /*sizeof(PARAMDESCEX)*/ * num_defaults
) << 16;
1421 switch(extra_attr
) {
1422 case 6: typedata
[11] = help_string_context
;
1423 case 5: typedata
[10] = -1;
1424 case 4: typedata
[9] = -1;
1425 case 3: typedata
[8] = entry
;
1426 case 2: typedata
[7] = help_string_offset
;
1427 case 1: typedata
[6] = help_context
;
1431 warning("unknown number of optional attrs\n");
1437 LIST_FOR_EACH_ENTRY( arg
, func
->args
, var_t
, entry
)
1441 int *paramdata
= typedata
+ 6 + extra_attr
+ (num_defaults
? num_params
: 0) + i
* 3;
1442 int *defaultdata
= num_defaults
? typedata
+ 6 + extra_attr
+ i
: NULL
;
1444 if(defaultdata
) *defaultdata
= -1;
1446 encode_var(typeinfo
->typelib
, arg
, paramdata
, NULL
, NULL
, &decoded_size
);
1447 if (arg
->attrs
) LIST_FOR_EACH_ENTRY( attr
, arg
->attrs
, const attr_t
, entry
) {
1448 switch(attr
->type
) {
1449 case ATTR_DEFAULTVALUE_EXPR
:
1452 expr_t
*expr
= (expr_t
*)attr
->u
.pval
;
1453 if (arg
->type
->type
== RPC_FC_ENUM16
)
1456 vt
= get_var_vt(arg
);
1457 paramflags
|= 0x30; /* PARAMFLAG_FHASDEFAULT | PARAMFLAG_FOPT */
1458 chat("default value %ld\n", expr
->cval
);
1459 write_value(typeinfo
->typelib
, defaultdata
, vt
, &expr
->cval
);
1462 case ATTR_DEFAULTVALUE_STRING
:
1464 char *s
= (char *)attr
->u
.pval
;
1466 if (arg
->type
->type
== RPC_FC_ENUM16
)
1469 vt
= get_var_vt(arg
);
1470 paramflags
|= 0x30; /* PARAMFLAG_FHASDEFAULT | PARAMFLAG_FOPT */
1471 chat("default value '%s'\n", s
);
1472 write_value(typeinfo
->typelib
, defaultdata
, vt
, s
);
1476 paramflags
|= 0x01; /* PARAMFLAG_FIN */
1479 paramflags
|= 0x10; /* PARAMFLAG_FOPT */
1482 paramflags
|= 0x02; /* PARAMFLAG_FOUT */
1485 paramflags
|= 0x08; /* PARAMFLAG_FRETVAL */
1486 typedata
[4] |= 0x4000;
1489 chat("unhandled param attr %d\n", attr
->type
);
1494 paramdata
[2] = paramflags
;
1495 typedata
[3] += decoded_size
<< 16;
1500 if(typeinfo
->funcs_allocated
== 0) {
1501 typeinfo
->funcs_allocated
= 10;
1502 typeinfo
->func_indices
= xmalloc(typeinfo
->funcs_allocated
* sizeof(int));
1503 typeinfo
->func_names
= xmalloc(typeinfo
->funcs_allocated
* sizeof(int));
1504 typeinfo
->func_offsets
= xmalloc(typeinfo
->funcs_allocated
* sizeof(int));
1506 if(typeinfo
->funcs_allocated
== (typeinfo
->typeinfo
->cElement
& 0xffff)) {
1507 typeinfo
->funcs_allocated
*= 2;
1508 typeinfo
->func_indices
= xrealloc(typeinfo
->func_indices
, typeinfo
->funcs_allocated
* sizeof(int));
1509 typeinfo
->func_names
= xrealloc(typeinfo
->func_names
, typeinfo
->funcs_allocated
* sizeof(int));
1510 typeinfo
->func_offsets
= xrealloc(typeinfo
->func_offsets
, typeinfo
->funcs_allocated
* sizeof(int));
1513 /* update the index data */
1514 typeinfo
->func_indices
[typeinfo
->typeinfo
->cElement
& 0xffff] = id
;
1515 typeinfo
->func_offsets
[typeinfo
->typeinfo
->cElement
& 0xffff] = offset
;
1516 typeinfo
->func_names
[typeinfo
->typeinfo
->cElement
& 0xffff] = name_offset
;
1519 if (!typeinfo
->typeinfo
->res2
) typeinfo
->typeinfo
->res2
= 0x20;
1520 typeinfo
->typeinfo
->res2
<<= 1;
1522 if (index
< 2) typeinfo
->typeinfo
->res2
+= num_params
<< 4;
1524 if (typeinfo
->typeinfo
->res3
== -1) typeinfo
->typeinfo
->res3
= 0;
1525 typeinfo
->typeinfo
->res3
+= 0x38 + num_params
* 0x10;
1526 if(num_defaults
) typeinfo
->typeinfo
->res3
+= num_params
* 0x4;
1528 /* adjust size of VTBL */
1529 if(funckind
!= 0x3 /* FUNC_STATIC */)
1530 typeinfo
->typeinfo
->cbSizeVft
+= 4;
1532 /* Increment the number of function elements */
1533 typeinfo
->typeinfo
->cElement
+= 1;
1535 namedata
= typeinfo
->typelib
->typelib_segment_data
[MSFT_SEG_NAME
] + name_offset
;
1536 if (*((INT
*)namedata
) == -1) {
1537 *((INT
*)namedata
) = typeinfo
->typelib
->typelib_typeinfo_offsets
[typeinfo
->typeinfo
->typekind
>> 16];
1538 if(typeinfo
->typekind
== TKIND_MODULE
)
1539 namedata
[9] |= 0x10;
1541 namedata
[9] &= ~0x10;
1543 if(typeinfo
->typekind
== TKIND_MODULE
)
1544 namedata
[9] |= 0x20;
1546 if(invokekind
!= 0x4 /* INVOKE_PROPERTYPUT */ && invokekind
!= 0x8 /* INVOKE_PROPERTYPUTREF */) {
1547 /* don't give the arg of a [propput*] func a name */
1551 LIST_FOR_EACH_ENTRY( arg
, func
->args
, var_t
, entry
)
1553 int *paramdata
= typedata
+ 6 + extra_attr
+ (num_defaults
? num_params
: 0) + i
* 3;
1554 offset
= ctl2_alloc_name(typeinfo
->typelib
, arg
->name
);
1555 paramdata
[1] = offset
;
1563 static HRESULT
add_var_desc(msft_typeinfo_t
*typeinfo
, UINT index
, var_t
* var
)
1566 unsigned int typedata_size
;
1570 int var_type_size
, var_kind
= 0 /* VAR_PERINSTANCE */;
1575 int var_num
= (typeinfo
->typeinfo
->cElement
>> 16) & 0xffff;
1577 chat("add_var_desc(%d,%s) array %p\n", index
, var
->name
, var
->array
);
1579 id
= 0x40000000 + index
;
1581 if (var
->attrs
) LIST_FOR_EACH_ENTRY( attr
, var
->attrs
, const attr_t
, entry
) {
1582 expr_t
*expr
= attr
->u
.pval
;
1583 switch(attr
->type
) {
1585 varflags
|= 0x40; /* VARFLAG_FHIDDEN */
1591 varflags
|= 0x01; /* VARFLAG_FREADONLY */
1593 case ATTR_RESTRICTED
:
1594 varflags
|= 0x80; /* VARFLAG_FRESTRICTED */
1597 varflags
|= 0x02; /* VARFLAG_FSOURCE */
1600 warning("AddVarDesc: unhandled attr type %d\n", attr
->type
);
1605 /* allocate type data space for us */
1606 typedata_size
= 0x14;
1608 if (!typeinfo
->var_data
) {
1609 typeinfo
->var_data
= xmalloc(0x100);
1610 typeinfo
->var_data_allocated
= 0x100;
1611 typeinfo
->var_data
[0] = 0;
1614 if(typeinfo
->var_data
[0] + typedata_size
+ sizeof(int) > typeinfo
->var_data_allocated
) {
1615 typeinfo
->var_data_allocated
= max(typeinfo
->var_data_allocated
* 2,
1616 typeinfo
->var_data
[0] + typedata_size
+ sizeof(int));
1617 typeinfo
->var_data
= xrealloc(typeinfo
->var_data
, typeinfo
->var_data_allocated
);
1620 offset
= typeinfo
->var_data
[0];
1621 typeinfo
->var_data
[0] += typedata_size
;
1622 typedata
= typeinfo
->var_data
+ (offset
>> 2) + 1;
1624 /* fill out the basic type information */
1625 typedata
[0] = typedata_size
| (index
<< 16);
1626 typedata
[2] = varflags
;
1627 typedata
[3] = (36 /*sizeof(VARDESC)*/ << 16) | 0;
1629 if(typeinfo
->vars_allocated
== 0) {
1630 typeinfo
->vars_allocated
= 10;
1631 typeinfo
->var_indices
= xmalloc(typeinfo
->vars_allocated
* sizeof(int));
1632 typeinfo
->var_names
= xmalloc(typeinfo
->vars_allocated
* sizeof(int));
1633 typeinfo
->var_offsets
= xmalloc(typeinfo
->vars_allocated
* sizeof(int));
1635 if(typeinfo
->vars_allocated
== var_num
) {
1636 typeinfo
->vars_allocated
*= 2;
1637 typeinfo
->var_indices
= xrealloc(typeinfo
->var_indices
, typeinfo
->vars_allocated
* sizeof(int));
1638 typeinfo
->var_names
= xrealloc(typeinfo
->var_names
, typeinfo
->vars_allocated
* sizeof(int));
1639 typeinfo
->var_offsets
= xrealloc(typeinfo
->var_offsets
, typeinfo
->vars_allocated
* sizeof(int));
1641 /* update the index data */
1642 typeinfo
->var_indices
[var_num
] = id
;
1643 typeinfo
->var_names
[var_num
] = -1;
1644 typeinfo
->var_offsets
[var_num
] = offset
;
1646 /* figure out type widths and whatnot */
1647 encode_var(typeinfo
->typelib
, var
, &typedata
[1], &var_datawidth
,
1648 &var_alignment
, &var_type_size
);
1650 /* pad out starting position to data width */
1651 typeinfo
->datawidth
+= var_alignment
- 1;
1652 typeinfo
->datawidth
&= ~(var_alignment
- 1);
1654 switch(typeinfo
->typekind
) {
1656 write_value(typeinfo
->typelib
, &typedata
[4], VT_I4
, &var
->eval
->cval
);
1657 var_kind
= 2; /* VAR_CONST */
1658 var_type_size
+= 16; /* sizeof(VARIANT) */
1659 typeinfo
->datawidth
= var_datawidth
;
1662 typedata
[4] = typeinfo
->datawidth
;
1663 typeinfo
->datawidth
+= var_datawidth
;
1665 case TKIND_DISPATCH
:
1666 var_kind
= 3; /* VAR_DISPATCH */
1667 typeinfo
->datawidth
= 4;
1671 error("add_var_desc: unhandled type kind %d\n", typeinfo
->typekind
);
1675 /* add type description size to total required allocation */
1676 typedata
[3] += var_type_size
<< 16 | var_kind
;
1678 /* fix type alignment */
1679 alignment
= (typeinfo
->typeinfo
->typekind
>> 11) & 0x1f;
1680 if (alignment
< var_alignment
) {
1681 alignment
= var_alignment
;
1682 typeinfo
->typeinfo
->typekind
&= ~0xffc0;
1683 typeinfo
->typeinfo
->typekind
|= alignment
<< 11 | alignment
<< 6;
1687 if (!typeinfo
->typeinfo
->res2
) typeinfo
->typeinfo
->res2
= 0x1a;
1688 if ((index
== 0) || (index
== 1) || (index
== 2) || (index
== 4) || (index
== 9)) {
1689 typeinfo
->typeinfo
->res2
<<= 1;
1693 if (typeinfo
->typeinfo
->res3
== -1) typeinfo
->typeinfo
->res3
= 0;
1694 typeinfo
->typeinfo
->res3
+= 0x2c;
1696 /* increment the number of variable elements */
1697 typeinfo
->typeinfo
->cElement
+= 0x10000;
1699 /* pad data width to alignment */
1700 typeinfo
->typeinfo
->size
= (typeinfo
->datawidth
+ (alignment
- 1)) & ~(alignment
- 1);
1702 offset
= ctl2_alloc_name(typeinfo
->typelib
, var
->name
);
1703 if (offset
== -1) return E_OUTOFMEMORY
;
1705 namedata
= typeinfo
->typelib
->typelib_segment_data
[MSFT_SEG_NAME
] + offset
;
1706 if (*((INT
*)namedata
) == -1) {
1707 *((INT
*)namedata
) = typeinfo
->typelib
->typelib_typeinfo_offsets
[typeinfo
->typeinfo
->typekind
>> 16];
1708 if(typeinfo
->typekind
!= TKIND_DISPATCH
)
1709 namedata
[9] |= 0x10;
1711 namedata
[9] &= ~0x10;
1713 if (typeinfo
->typekind
== TKIND_ENUM
) {
1714 namedata
[9] |= 0x20;
1716 typeinfo
->var_names
[var_num
] = offset
;
1721 static HRESULT
add_impl_type(msft_typeinfo_t
*typeinfo
, type_t
*ref
, importinfo_t
*importinfo
)
1724 alloc_importinfo(typeinfo
->typelib
, importinfo
);
1725 typeinfo
->typeinfo
->datatype1
= importinfo
->offset
+1;
1727 if(ref
->typelib_idx
== -1)
1728 add_interface_typeinfo(typeinfo
->typelib
, ref
);
1729 if(ref
->typelib_idx
== -1)
1730 error("add_impl_type: unable to add inherited interface\n");
1732 typeinfo
->typeinfo
->datatype1
= typeinfo
->typelib
->typelib_typeinfo_offsets
[ref
->typelib_idx
];
1735 typeinfo
->typeinfo
->cImplTypes
++;
1739 static msft_typeinfo_t
*create_msft_typeinfo(msft_typelib_t
*typelib
, enum type_kind kind
,
1740 const char *name
, const attr_list_t
*attrs
)
1743 msft_typeinfo_t
*msft_typeinfo
;
1745 int typeinfo_offset
;
1746 MSFT_TypeInfoBase
*typeinfo
;
1747 MSFT_GuidEntry guidentry
;
1749 chat("create_msft_typeinfo: name %s kind %d\n", name
, kind
);
1751 msft_typeinfo
= xmalloc(sizeof(*msft_typeinfo
));
1752 memset( msft_typeinfo
, 0, sizeof(*msft_typeinfo
) );
1754 msft_typeinfo
->typelib
= typelib
;
1756 nameoffset
= ctl2_alloc_name(typelib
, name
);
1757 typeinfo_offset
= ctl2_alloc_typeinfo(typelib
, nameoffset
);
1758 typeinfo
= (MSFT_TypeInfoBase
*)&typelib
->typelib_segment_data
[MSFT_SEG_TYPEINFO
][typeinfo_offset
];
1760 typelib
->typelib_segment_data
[MSFT_SEG_NAME
][nameoffset
+ 9] = 0x38;
1761 *((int *)&typelib
->typelib_segment_data
[MSFT_SEG_NAME
][nameoffset
]) = typeinfo_offset
;
1763 msft_typeinfo
->typekind
= kind
;
1764 msft_typeinfo
->typeinfo
= typeinfo
;
1766 typeinfo
->typekind
|= kind
| 0x20;
1768 if(kind
== TKIND_COCLASS
)
1769 typeinfo
->flags
|= 0x2; /* TYPEFLAG_FCANCREATE */
1771 if (attrs
) LIST_FOR_EACH_ENTRY( attr
, attrs
, const attr_t
, entry
) {
1772 switch(attr
->type
) {
1773 case ATTR_AGGREGATABLE
:
1774 if (kind
== TKIND_COCLASS
)
1775 typeinfo
->flags
|= 0x400; /* TYPEFLAG_FAGGREGATABLE */
1778 case ATTR_APPOBJECT
:
1779 if (kind
== TKIND_COCLASS
)
1780 typeinfo
->flags
|= 0x1; /* TYPEFLAG_FAPPOBJECT */
1784 if (kind
== TKIND_COCLASS
)
1785 typeinfo
->flags
|= 0x20; /* TYPEFLAG_FCONTROL */
1788 case ATTR_DISPINTERFACE
:
1793 int offset
= ctl2_alloc_string(typelib
, attr
->u
.pval
);
1794 typeinfo
->datatype1
= offset
;
1799 /* FIXME: check interface is compatible */
1800 typeinfo
->typekind
= (typeinfo
->typekind
& ~0xff) | 0x34;
1801 typeinfo
->flags
|= 0x140; /* TYPEFLAG_FDUAL | TYPEFLAG_FOLEAUTOMATION */
1804 case ATTR_HELPCONTEXT
:
1806 expr_t
*expr
= (expr_t
*)attr
->u
.pval
;
1807 typeinfo
->helpcontext
= expr
->cval
;
1810 case ATTR_HELPSTRING
:
1812 int offset
= ctl2_alloc_string(typelib
, attr
->u
.pval
);
1813 if (offset
== -1) break;
1814 typeinfo
->docstringoffs
= offset
;
1817 case ATTR_HELPSTRINGCONTEXT
:
1819 expr_t
*expr
= (expr_t
*)attr
->u
.pval
;
1820 typeinfo
->helpstringcontext
= expr
->cval
;
1824 typeinfo
->flags
|= 0x10; /* TYPEFLAG_FHIDDEN */
1827 case ATTR_NONCREATABLE
:
1828 typeinfo
->flags
&= ~0x2; /* TYPEFLAG_FCANCREATE */
1831 case ATTR_NONEXTENSIBLE
:
1832 typeinfo
->flags
|= 0x80; /* TYPEFLAG_FNONEXTENSIBLE */
1841 case ATTR_OLEAUTOMATION
:
1842 typeinfo
->flags
|= 0x100; /* TYPEFLAG_FOLEAUTOMATION */
1848 case ATTR_RESTRICTED
:
1849 typeinfo
->flags
|= 0x200; /* TYPEFLAG_FRESTRICTED */
1853 guidentry
.guid
= *(GUID
*)attr
->u
.pval
;
1854 guidentry
.hreftype
= typelib
->typelib_typeinfo_offsets
[typeinfo
->typekind
>> 16];
1855 guidentry
.next_hash
= -1;
1856 typeinfo
->posguid
= ctl2_alloc_guid(typelib
, &guidentry
);
1858 if (IsEqualIID(guid
, &IID_IDispatch
)) {
1859 typelib
->typelib_header
.dispatchpos
= typelib
->typelib_typeinfo_offsets
[typeinfo
->typekind
>> 16];
1865 typeinfo
->version
= attr
->u
.ival
;
1869 warning("create_msft_typeinfo: ignoring attr %d\n", attr
->type
);
1874 if (typelib
->last_typeinfo
) typelib
->last_typeinfo
->next_typeinfo
= msft_typeinfo
;
1875 typelib
->last_typeinfo
= msft_typeinfo
;
1876 if (!typelib
->typeinfos
) typelib
->typeinfos
= msft_typeinfo
;
1879 return msft_typeinfo
;
1882 static void add_dispatch(msft_typelib_t
*typelib
)
1884 int guid_offset
, impfile_offset
;
1885 MSFT_GuidEntry guidentry
;
1886 MSFT_ImpInfo impinfo
;
1887 GUID stdole
= {0x00020430,0x0000,0x0000,{0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
1888 GUID iid_idispatch
= {0x00020400,0x0000,0x0000,{0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
1890 if(typelib
->typelib_header
.dispatchpos
!= -1) return;
1892 guidentry
.guid
= stdole
;
1893 guidentry
.hreftype
= 2;
1894 guidentry
.next_hash
= -1;
1895 guid_offset
= ctl2_alloc_guid(typelib
, &guidentry
);
1896 impfile_offset
= alloc_importfile(typelib
, guid_offset
, 2, 0, "stdole2.tlb");
1898 guidentry
.guid
= iid_idispatch
;
1899 guidentry
.hreftype
= 1;
1900 guidentry
.next_hash
= -1;
1901 impinfo
.flags
= TKIND_INTERFACE
<< 24 | MSFT_IMPINFO_OFFSET_IS_GUID
;
1902 impinfo
.oImpFile
= impfile_offset
;
1903 impinfo
.oGuid
= ctl2_alloc_guid(typelib
, &guidentry
);
1904 typelib
->typelib_header
.dispatchpos
= alloc_msft_importinfo(typelib
, &impinfo
) | 0x01;
1907 static void add_dispinterface_typeinfo(msft_typelib_t
*typelib
, type_t
*dispinterface
)
1912 msft_typeinfo_t
*msft_typeinfo
;
1914 if (-1 < dispinterface
->typelib_idx
)
1917 dispinterface
->typelib_idx
= typelib
->typelib_header
.nrtypeinfos
;
1918 msft_typeinfo
= create_msft_typeinfo(typelib
, TKIND_DISPATCH
, dispinterface
->name
,
1919 dispinterface
->attrs
);
1921 msft_typeinfo
->typeinfo
->size
= 4;
1922 msft_typeinfo
->typeinfo
->typekind
|= 0x2100;
1924 msft_typeinfo
->typeinfo
->flags
|= 0x1000; /* TYPEFLAG_FDISPATCHABLE */
1925 add_dispatch(typelib
);
1926 msft_typeinfo
->typeinfo
->cImplTypes
= 1;
1928 /* count the no of funcs, as the variable indices come after the funcs */
1929 if (dispinterface
->funcs
)
1930 LIST_FOR_EACH_ENTRY( func
, dispinterface
->funcs
, const func_t
, entry
) idx
++;
1932 if (dispinterface
->fields
)
1933 LIST_FOR_EACH_ENTRY( var
, dispinterface
->fields
, var_t
, entry
)
1934 add_var_desc(msft_typeinfo
, idx
++, var
);
1936 if (dispinterface
->funcs
)
1939 LIST_FOR_EACH_ENTRY( func
, dispinterface
->funcs
, const func_t
, entry
)
1940 if(add_func_desc(msft_typeinfo
, func
, idx
) == S_OK
)
1945 static void add_interface_typeinfo(msft_typelib_t
*typelib
, type_t
*interface
)
1950 msft_typeinfo_t
*msft_typeinfo
;
1951 importinfo_t
*ref_importinfo
= NULL
;
1952 int num_parents
= 0, num_funcs
= 0;
1953 const type_t
*derived
;
1955 if (-1 < interface
->typelib_idx
)
1958 if (is_attr(interface
->attrs
, ATTR_DISPINTERFACE
))
1959 return add_dispinterface_typeinfo(typelib
, interface
);
1961 /* midl adds the parent interface first, unless the parent itself
1962 has no parent (i.e. it stops before IUnknown). */
1964 if(interface
->ref
) {
1965 ref_importinfo
= find_importinfo(typelib
, interface
->ref
->name
);
1967 if(!ref_importinfo
&& interface
->ref
->ref
&& interface
->ref
->typelib_idx
== -1)
1968 add_interface_typeinfo(typelib
, interface
->ref
);
1971 interface
->typelib_idx
= typelib
->typelib_header
.nrtypeinfos
;
1972 msft_typeinfo
= create_msft_typeinfo(typelib
, TKIND_INTERFACE
, interface
->name
, interface
->attrs
);
1973 msft_typeinfo
->typeinfo
->size
= 4;
1974 msft_typeinfo
->typeinfo
->typekind
|= 0x2200;
1976 for (derived
= interface
->ref
; derived
; derived
= derived
->ref
)
1977 if (derived
->name
&& !strcmp(derived
->name
, "IDispatch"))
1978 msft_typeinfo
->typeinfo
->flags
|= 0x1000; /* TYPEFLAG_FDISPATCHABLE */
1980 /* can't be dual if it doesn't derive from IDispatch */
1981 if (!(msft_typeinfo
->typeinfo
->flags
& 0x1000)) /* TYPEFLAG_FDISPATCHABLE */
1982 msft_typeinfo
->typeinfo
->flags
&= ~0x40; /* TYPEFLAG_FDUAL */
1985 add_impl_type(msft_typeinfo
, interface
->ref
, ref_importinfo
);
1987 /* count the number of inherited interfaces and non-local functions */
1988 for(ref
= interface
->ref
; ref
; ref
= ref
->ref
) {
1991 LIST_FOR_EACH_ENTRY( func
, ref
->funcs
, const func_t
, entry
)
1992 if (!is_local(func
->def
->attrs
)) num_funcs
++;
1994 msft_typeinfo
->typeinfo
->datatype2
= num_funcs
<< 16 | num_parents
;
1995 msft_typeinfo
->typeinfo
->cbSizeVft
= num_funcs
* 4;
1997 if (interface
->funcs
)
1998 LIST_FOR_EACH_ENTRY( func
, interface
->funcs
, const func_t
, entry
)
1999 if(add_func_desc(msft_typeinfo
, func
, idx
) == S_OK
)
2003 static void add_structure_typeinfo(msft_typelib_t
*typelib
, type_t
*structure
)
2007 msft_typeinfo_t
*msft_typeinfo
;
2009 if (-1 < structure
->typelib_idx
)
2012 structure
->typelib_idx
= typelib
->typelib_header
.nrtypeinfos
;
2013 msft_typeinfo
= create_msft_typeinfo(typelib
, TKIND_RECORD
, structure
->name
, structure
->attrs
);
2014 msft_typeinfo
->typeinfo
->size
= 0;
2016 if (structure
->fields
)
2017 LIST_FOR_EACH_ENTRY( cur
, structure
->fields
, var_t
, entry
)
2018 add_var_desc(msft_typeinfo
, idx
++, cur
);
2021 static void add_enum_typeinfo(msft_typelib_t
*typelib
, type_t
*enumeration
)
2025 msft_typeinfo_t
*msft_typeinfo
;
2027 enumeration
->typelib_idx
= typelib
->typelib_header
.nrtypeinfos
;
2028 msft_typeinfo
= create_msft_typeinfo(typelib
, TKIND_ENUM
, enumeration
->name
, enumeration
->attrs
);
2029 msft_typeinfo
->typeinfo
->size
= 0;
2031 if (enumeration
->fields
)
2032 LIST_FOR_EACH_ENTRY( cur
, enumeration
->fields
, var_t
, entry
)
2033 add_var_desc(msft_typeinfo
, idx
++, cur
);
2036 static void add_typedef_typeinfo(msft_typelib_t
*typelib
, type_t
*tdef
)
2038 msft_typeinfo_t
*msft_typeinfo
;
2041 if (-1 < tdef
->typelib_idx
)
2044 tdef
->typelib_idx
= typelib
->typelib_header
.nrtypeinfos
;
2045 msft_typeinfo
= create_msft_typeinfo(typelib
, TKIND_ALIAS
, tdef
->name
, tdef
->attrs
);
2046 encode_type(typelib
, get_type_vt(tdef
->orig
), tdef
->orig
, &msft_typeinfo
->typeinfo
->datatype1
, &msft_typeinfo
->typeinfo
->size
,
2047 &alignment
, &msft_typeinfo
->typeinfo
->datatype2
);
2048 msft_typeinfo
->typeinfo
->typekind
|= (alignment
<< 11 | alignment
<< 6);
2051 static void add_coclass_typeinfo(msft_typelib_t
*typelib
, type_t
*cls
)
2053 msft_typeinfo_t
*msft_typeinfo
;
2055 int num_ifaces
= 0, offset
, i
;
2056 MSFT_RefRecord
*ref
, *first
= NULL
, *first_source
= NULL
;
2057 int have_default
= 0, have_default_source
= 0;
2060 if (-1 < cls
->typelib_idx
)
2063 cls
->typelib_idx
= typelib
->typelib_header
.nrtypeinfos
;
2064 msft_typeinfo
= create_msft_typeinfo(typelib
, TKIND_COCLASS
, cls
->name
, cls
->attrs
);
2066 if (cls
->ifaces
) LIST_FOR_EACH_ENTRY( iref
, cls
->ifaces
, ifref_t
, entry
) num_ifaces
++;
2068 offset
= msft_typeinfo
->typeinfo
->datatype1
= ctl2_alloc_segment(typelib
, MSFT_SEG_REFERENCES
,
2069 num_ifaces
* sizeof(*ref
), 0);
2072 if (cls
->ifaces
) LIST_FOR_EACH_ENTRY( iref
, cls
->ifaces
, ifref_t
, entry
) {
2073 if(iref
->iface
->typelib_idx
== -1)
2074 add_interface_typeinfo(typelib
, iref
->iface
);
2075 ref
= (MSFT_RefRecord
*) (typelib
->typelib_segment_data
[MSFT_SEG_REFERENCES
] + offset
+ i
* sizeof(*ref
));
2076 ref
->reftype
= typelib
->typelib_typeinfo_offsets
[iref
->iface
->typelib_idx
];
2078 ref
->oCustData
= -1;
2080 if(i
< num_ifaces
- 1)
2081 ref
->onext
= offset
+ (i
+ 1) * sizeof(*ref
);
2083 if (iref
->attrs
) LIST_FOR_EACH_ENTRY( attr
, iref
->attrs
, const attr_t
, entry
) {
2084 switch(attr
->type
) {
2086 ref
->flags
|= 0x1; /* IMPLTYPEFLAG_FDEFAULT */
2088 case ATTR_RESTRICTED
:
2089 ref
->flags
|= 0x4; /* IMPLTYPEFLAG_FRESTRICTED */
2092 ref
->flags
|= 0x2; /* IMPLTYPEFLAG_FSOURCE */
2095 warning("add_coclass_typeinfo: unhandled attr %d\n", attr
->type
);
2098 if(ref
->flags
& 0x1) { /* IMPLTYPEFLAG_FDEFAULT */
2099 if(ref
->flags
& 0x2) /* IMPLTYPEFLAG_SOURCE */
2100 have_default_source
= 1;
2105 /* If the interface is non-restricted and we haven't already had one then
2106 remember it so that we can use it as a default later */
2107 if((ref
->flags
& 0x4) == 0) { /* IMPLTYPEFLAG_FRESTRICTED */
2108 if(ref
->flags
& 0x2) { /* IMPLTYPEFLAG_FSOURCE */
2118 /* If we haven't had a default interface, then set the default flags on the
2120 if(!have_default
&& first
)
2121 first
->flags
|= 0x1;
2122 if(!have_default_source
&& first_source
)
2123 first_source
->flags
|= 0x1;
2125 msft_typeinfo
->typeinfo
->cImplTypes
= num_ifaces
;
2126 msft_typeinfo
->typeinfo
->size
= 4;
2127 msft_typeinfo
->typeinfo
->typekind
|= 0x2200;
2130 static void add_module_typeinfo(msft_typelib_t
*typelib
, type_t
*module
)
2134 msft_typeinfo_t
*msft_typeinfo
;
2136 if (-1 < module
->typelib_idx
)
2139 module
->typelib_idx
= typelib
->typelib_header
.nrtypeinfos
;
2140 msft_typeinfo
= create_msft_typeinfo(typelib
, TKIND_MODULE
, module
->name
, module
->attrs
);
2141 msft_typeinfo
->typeinfo
->typekind
|= 0x0a00;
2144 LIST_FOR_EACH_ENTRY( func
, module
->funcs
, const func_t
, entry
)
2145 if(add_func_desc(msft_typeinfo
, func
, idx
) == S_OK
)
2148 msft_typeinfo
->typeinfo
->size
= idx
;
2151 static void add_entry(msft_typelib_t
*typelib
, typelib_entry_t
*entry
)
2153 switch(entry
->type
->kind
) {
2154 case TKIND_INTERFACE
:
2155 case TKIND_DISPATCH
:
2156 add_interface_typeinfo(typelib
, entry
->type
);
2160 add_structure_typeinfo(typelib
, entry
->type
);
2164 add_enum_typeinfo(typelib
, entry
->type
);
2168 add_typedef_typeinfo(typelib
, entry
->type
);
2172 add_coclass_typeinfo(typelib
, entry
->type
);
2176 add_module_typeinfo(typelib
, entry
->type
);
2180 error("add_entry: unhandled type %d\n", entry
->type
->kind
);
2185 static void set_name(msft_typelib_t
*typelib
)
2189 offset
= ctl2_alloc_name(typelib
, typelib
->typelib
->name
);
2190 if (offset
== -1) return;
2191 typelib
->typelib_header
.NameOffset
= offset
;
2195 static void set_version(msft_typelib_t
*typelib
)
2197 typelib
->typelib_header
.version
= get_attrv( typelib
->typelib
->attrs
, ATTR_VERSION
);
2200 static void set_guid(msft_typelib_t
*typelib
)
2202 MSFT_GuidEntry guidentry
;
2205 GUID guid
= {0,0,0,{0,0,0,0,0,0}};
2207 guidentry
.guid
= guid
;
2208 guidentry
.hreftype
= -2;
2209 guidentry
.next_hash
= -1;
2211 ptr
= get_attrp( typelib
->typelib
->attrs
, ATTR_UUID
);
2212 if (ptr
) guidentry
.guid
= *(GUID
*)ptr
;
2214 offset
= ctl2_alloc_guid(typelib
, &guidentry
);
2215 typelib
->typelib_header
.posguid
= offset
;
2220 static void set_doc_string(msft_typelib_t
*typelib
)
2222 char *str
= get_attrp( typelib
->typelib
->attrs
, ATTR_HELPSTRING
);
2226 int offset
= ctl2_alloc_string(typelib
, str
);
2227 if (offset
!= -1) typelib
->typelib_header
.helpstring
= offset
;
2231 static void set_help_file_name(msft_typelib_t
*typelib
)
2233 char *str
= get_attrp( typelib
->typelib
->attrs
, ATTR_HELPFILE
);
2237 int offset
= ctl2_alloc_string(typelib
, str
);
2240 typelib
->typelib_header
.helpfile
= offset
;
2241 typelib
->typelib_header
.varflags
|= 0x10;
2246 static void set_help_context(msft_typelib_t
*typelib
)
2248 const expr_t
*expr
= get_attrp( typelib
->typelib
->attrs
, ATTR_HELPCONTEXT
);
2249 if (expr
) typelib
->typelib_header
.helpcontext
= expr
->cval
;
2252 static void set_help_string_dll(msft_typelib_t
*typelib
)
2254 char *str
= get_attrp( typelib
->typelib
->attrs
, ATTR_HELPSTRINGDLL
);
2258 int offset
= ctl2_alloc_string(typelib
, str
);
2261 typelib
->help_string_dll_offset
= offset
;
2262 typelib
->typelib_header
.varflags
|= 0x100;
2267 static void set_help_string_context(msft_typelib_t
*typelib
)
2269 const expr_t
*expr
= get_attrp( typelib
->typelib
->attrs
, ATTR_HELPSTRINGCONTEXT
);
2270 if (expr
) typelib
->typelib_header
.helpstringcontext
= expr
->cval
;
2273 static void set_lcid(msft_typelib_t
*typelib
)
2275 typelib
->typelib_header
.lcid2
= 0x0;
2279 static void set_lib_flags(msft_typelib_t
*typelib
)
2283 typelib
->typelib_header
.flags
= 0;
2284 if (!typelib
->typelib
->attrs
) return;
2285 LIST_FOR_EACH_ENTRY( attr
, typelib
->typelib
->attrs
, const attr_t
, entry
)
2287 switch(attr
->type
) {
2289 typelib
->typelib_header
.flags
|= 0x02; /* LIBFLAG_FCONTROL */
2292 typelib
->typelib_header
.flags
|= 0x04; /* LIBFLAG_FHIDDEN */
2294 case ATTR_RESTRICTED
:
2295 typelib
->typelib_header
.flags
|= 0x01; /* LIBFLAG_FRESTRICTED */
2304 static int ctl2_write_chunk(int fd
, void *segment
, int length
)
2306 if (write(fd
, segment
, length
) != length
) {
2313 static int ctl2_write_segment(msft_typelib_t
*typelib
, int fd
, int segment
)
2315 if (write(fd
, typelib
->typelib_segment_data
[segment
], typelib
->typelib_segdir
[segment
].length
)
2316 != typelib
->typelib_segdir
[segment
].length
) {
2324 static void ctl2_finalize_typeinfos(msft_typelib_t
*typelib
, int filesize
)
2326 msft_typeinfo_t
*typeinfo
;
2328 for (typeinfo
= typelib
->typeinfos
; typeinfo
; typeinfo
= typeinfo
->next_typeinfo
) {
2329 typeinfo
->typeinfo
->memoffset
= filesize
;
2330 if (typeinfo
->func_data
)
2331 filesize
+= typeinfo
->func_data
[0] + ((typeinfo
->typeinfo
->cElement
& 0xffff) * 12);
2332 if (typeinfo
->var_data
)
2333 filesize
+= typeinfo
->var_data
[0] + (((typeinfo
->typeinfo
->cElement
>> 16) & 0xffff) * 12);
2334 if (typeinfo
->func_data
|| typeinfo
->var_data
)
2339 static int ctl2_finalize_segment(msft_typelib_t
*typelib
, int filepos
, int segment
)
2341 if (typelib
->typelib_segdir
[segment
].length
) {
2342 typelib
->typelib_segdir
[segment
].offset
= filepos
;
2344 typelib
->typelib_segdir
[segment
].offset
= -1;
2347 return typelib
->typelib_segdir
[segment
].length
;
2351 static void ctl2_write_typeinfos(msft_typelib_t
*typelib
, int fd
)
2353 msft_typeinfo_t
*typeinfo
;
2356 for (typeinfo
= typelib
->typeinfos
; typeinfo
; typeinfo
= typeinfo
->next_typeinfo
) {
2357 if (!typeinfo
->func_data
&& !typeinfo
->var_data
) continue;
2359 if (typeinfo
->func_data
)
2360 typedata_size
= typeinfo
->func_data
[0];
2361 if (typeinfo
->var_data
)
2362 typedata_size
+= typeinfo
->var_data
[0];
2363 ctl2_write_chunk(fd
, &typedata_size
, sizeof(int));
2364 if (typeinfo
->func_data
)
2365 ctl2_write_chunk(fd
, typeinfo
->func_data
+ 1, typeinfo
->func_data
[0]);
2366 if (typeinfo
->var_data
)
2367 ctl2_write_chunk(fd
, typeinfo
->var_data
+ 1, typeinfo
->var_data
[0]);
2368 if (typeinfo
->func_indices
)
2369 ctl2_write_chunk(fd
, typeinfo
->func_indices
, (typeinfo
->typeinfo
->cElement
& 0xffff) * 4);
2370 if (typeinfo
->var_indices
)
2371 ctl2_write_chunk(fd
, typeinfo
->var_indices
, (typeinfo
->typeinfo
->cElement
>> 16) * 4);
2372 if (typeinfo
->func_names
)
2373 ctl2_write_chunk(fd
, typeinfo
->func_names
, (typeinfo
->typeinfo
->cElement
& 0xffff) * 4);
2374 if (typeinfo
->var_names
)
2375 ctl2_write_chunk(fd
, typeinfo
->var_names
, (typeinfo
->typeinfo
->cElement
>> 16) * 4);
2376 if (typeinfo
->func_offsets
)
2377 ctl2_write_chunk(fd
, typeinfo
->func_offsets
, (typeinfo
->typeinfo
->cElement
& 0xffff) * 4);
2378 if (typeinfo
->var_offsets
) {
2379 int add
= 0, i
, offset
;
2380 if(typeinfo
->func_data
)
2381 add
= typeinfo
->func_data
[0];
2382 for(i
= 0; i
< (typeinfo
->typeinfo
->cElement
>> 16); i
++) {
2383 offset
= typeinfo
->var_offsets
[i
];
2385 ctl2_write_chunk(fd
, &offset
, 4);
2391 static int save_all_changes(msft_typelib_t
*typelib
)
2397 chat("save_all_changes(%p)\n", typelib
);
2399 retval
= TYPE_E_IOERROR
;
2401 fd
= creat(typelib
->typelib
->filename
, 0666);
2402 if (fd
== -1) return retval
;
2404 filepos
= sizeof(MSFT_Header
) + sizeof(MSFT_SegDir
);
2405 if(typelib
->typelib_header
.varflags
& 0x100) filepos
+= 4; /* helpstringdll */
2406 filepos
+= typelib
->typelib_header
.nrtypeinfos
* 4;
2408 filepos
+= ctl2_finalize_segment(typelib
, filepos
, MSFT_SEG_TYPEINFO
);
2409 filepos
+= ctl2_finalize_segment(typelib
, filepos
, MSFT_SEG_GUIDHASH
);
2410 filepos
+= ctl2_finalize_segment(typelib
, filepos
, MSFT_SEG_GUID
);
2411 filepos
+= ctl2_finalize_segment(typelib
, filepos
, MSFT_SEG_REFERENCES
);
2412 filepos
+= ctl2_finalize_segment(typelib
, filepos
, MSFT_SEG_IMPORTINFO
);
2413 filepos
+= ctl2_finalize_segment(typelib
, filepos
, MSFT_SEG_IMPORTFILES
);
2414 filepos
+= ctl2_finalize_segment(typelib
, filepos
, MSFT_SEG_NAMEHASH
);
2415 filepos
+= ctl2_finalize_segment(typelib
, filepos
, MSFT_SEG_NAME
);
2416 filepos
+= ctl2_finalize_segment(typelib
, filepos
, MSFT_SEG_STRING
);
2417 filepos
+= ctl2_finalize_segment(typelib
, filepos
, MSFT_SEG_TYPEDESC
);
2418 filepos
+= ctl2_finalize_segment(typelib
, filepos
, MSFT_SEG_ARRAYDESC
);
2419 filepos
+= ctl2_finalize_segment(typelib
, filepos
, MSFT_SEG_CUSTDATA
);
2420 filepos
+= ctl2_finalize_segment(typelib
, filepos
, MSFT_SEG_CUSTDATAGUID
);
2422 ctl2_finalize_typeinfos(typelib
, filepos
);
2424 if (!ctl2_write_chunk(fd
, &typelib
->typelib_header
, sizeof(typelib
->typelib_header
))) return retval
;
2425 if(typelib
->typelib_header
.varflags
& 0x100)
2426 if (!ctl2_write_chunk(fd
, &typelib
->help_string_dll_offset
, sizeof(typelib
->help_string_dll_offset
)))
2429 if (!ctl2_write_chunk(fd
, typelib
->typelib_typeinfo_offsets
, typelib
->typelib_header
.nrtypeinfos
* 4)) return retval
;
2430 if (!ctl2_write_chunk(fd
, &typelib
->typelib_segdir
, sizeof(typelib
->typelib_segdir
))) return retval
;
2431 if (!ctl2_write_segment(typelib
, fd
, MSFT_SEG_TYPEINFO
)) return retval
;
2432 if (!ctl2_write_segment(typelib
, fd
, MSFT_SEG_GUIDHASH
)) return retval
;
2433 if (!ctl2_write_segment(typelib
, fd
, MSFT_SEG_GUID
)) return retval
;
2434 if (!ctl2_write_segment(typelib
, fd
, MSFT_SEG_REFERENCES
)) return retval
;
2435 if (!ctl2_write_segment(typelib
, fd
, MSFT_SEG_IMPORTINFO
)) return retval
;
2436 if (!ctl2_write_segment(typelib
, fd
, MSFT_SEG_IMPORTFILES
)) return retval
;
2437 if (!ctl2_write_segment(typelib
, fd
, MSFT_SEG_NAMEHASH
)) return retval
;
2438 if (!ctl2_write_segment(typelib
, fd
, MSFT_SEG_NAME
)) return retval
;
2439 if (!ctl2_write_segment(typelib
, fd
, MSFT_SEG_STRING
)) return retval
;
2440 if (!ctl2_write_segment(typelib
, fd
, MSFT_SEG_TYPEDESC
)) return retval
;
2441 if (!ctl2_write_segment(typelib
, fd
, MSFT_SEG_ARRAYDESC
)) return retval
;
2442 if (!ctl2_write_segment(typelib
, fd
, MSFT_SEG_CUSTDATA
)) return retval
;
2443 if (!ctl2_write_segment(typelib
, fd
, MSFT_SEG_CUSTDATAGUID
)) return retval
;
2445 ctl2_write_typeinfos(typelib
, fd
);
2447 if (close(fd
) == -1) return retval
;
2453 int create_msft_typelib(typelib_t
*typelib
)
2455 msft_typelib_t
*msft
;
2457 typelib_entry_t
*entry
;
2459 unsigned int version
= 5 << 24 | 1 << 16 | 164; /* 5.01.0164 */
2460 GUID midl_time_guid
= {0xde77ba63,0x517c,0x11d1,{0xa2,0xda,0x00,0x00,0xf8,0x77,0x3c,0xe9}};
2461 GUID midl_version_guid
= {0xde77ba64,0x517c,0x11d1,{0xa2,0xda,0x00,0x00,0xf8,0x77,0x3c,0xe9}};
2463 msft
= xmalloc(sizeof(*msft
));
2464 memset(msft
, 0, sizeof(*msft
));
2465 msft
->typelib
= typelib
;
2467 ctl2_init_header(msft
);
2468 ctl2_init_segdir(msft
);
2470 msft
->typelib_header
.varflags
|= SYS_WIN32
;
2473 * The following two calls return an offset or -1 if out of memory. We
2474 * specifically need an offset of 0, however, so...
2476 if (ctl2_alloc_segment(msft
, MSFT_SEG_GUIDHASH
, 0x80, 0x80)) { failed
= 1; }
2477 if (ctl2_alloc_segment(msft
, MSFT_SEG_NAMEHASH
, 0x200, 0x200)) { failed
= 1; }
2485 msft
->typelib_guidhash_segment
= (int *)msft
->typelib_segment_data
[MSFT_SEG_GUIDHASH
];
2486 msft
->typelib_namehash_segment
= (int *)msft
->typelib_segment_data
[MSFT_SEG_NAMEHASH
];
2488 memset(msft
->typelib_guidhash_segment
, 0xff, 0x80);
2489 memset(msft
->typelib_namehash_segment
, 0xff, 0x200);
2491 set_lib_flags(msft
);
2493 set_help_file_name(msft
);
2494 set_doc_string(msft
);
2498 set_help_context(msft
);
2499 set_help_string_dll(msft
);
2500 set_help_string_context(msft
);
2502 /* midl adds two sets of custom data to the library: the current unix time
2503 and midl's version number */
2504 cur_time
= time(NULL
);
2505 set_custdata(msft
, &midl_time_guid
, VT_UI4
, &cur_time
, &msft
->typelib_header
.CustomDataOffset
);
2506 set_custdata(msft
, &midl_version_guid
, VT_UI4
, &version
, &msft
->typelib_header
.CustomDataOffset
);
2508 LIST_FOR_EACH_ENTRY( entry
, &typelib
->entries
, typelib_entry_t
, entry
)
2509 add_entry(msft
, entry
);
2511 save_all_changes(msft
);