?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Remove redunant braces.
[wine/testsucceed.git] / tools / widl / write_msft.c
blob8a5b8ce7254c94f445eb7a183e02142dcc07d0f0
1 /*
2 * Typelib v2 (MSFT) generation
3 *
4 * Copyright 2004 Alastair Bridgewater
5 * 2004, 2005 Huw Davies
6 *
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.
11 *
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.
16 *
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * --------------------------------------------------------------------------------------
22 * Known problems:
23 *
24 * Badly incomplete.
25 *
26 * Only works on little-endian systems.
27 *
28 */
29
30 #include "config.h"
31 #include "wine/port.h"
32
33 #include <stdlib.h>
34 #include <string.h>
35 #include <stdarg.h>
36 #include <stdio.h>
37 #include <ctype.h>
38 #include <time.h>
39
40 #define NONAMELESSUNION
41 #define NONAMELESSSTRUCT
42
43 #include "winerror.h"
44 #include "windef.h"
45 #include "winbase.h"
46 #include "winnls.h"
47
48 #include "wine/unicode.h"
49
50 #include "widltypes.h"
51 #include "typelib.h"
52 #include "typelib_struct.h"
53 #include "utils.h"
54 #include "hash.h"
55
56 enum MSFT_segment_index {
57 MSFT_SEG_TYPEINFO = 0, /* type information */
58 MSFT_SEG_IMPORTINFO, /* import information */
59 MSFT_SEG_IMPORTFILES, /* import filenames */
60 MSFT_SEG_REFERENCES, /* references (?) */
61 MSFT_SEG_GUIDHASH, /* hash table for guids? */
62 MSFT_SEG_GUID, /* guid storage */
63 MSFT_SEG_NAMEHASH, /* hash table for names */
64 MSFT_SEG_NAME, /* name storage */
65 MSFT_SEG_STRING, /* string storage */
66 MSFT_SEG_TYPEDESC, /* type descriptions */
67 MSFT_SEG_ARRAYDESC, /* array descriptions */
68 MSFT_SEG_CUSTDATA, /* custom data */
69 MSFT_SEG_CUSTDATAGUID, /* custom data guids */
70 MSFT_SEG_UNKNOWN, /* ??? */
71 MSFT_SEG_UNKNOWN2, /* ??? */
72 MSFT_SEG_MAX /* total number of segments */
73 };
74
75 typedef struct tagMSFT_ImpFile {
76 int guid;
77 LCID lcid;
78 int version;
79 char filename[0]; /* preceded by two bytes of encoded (length << 2) + flags in the low two bits. */
80 } MSFT_ImpFile;
81
82 typedef struct _msft_typelib_t
83 {
84 typelib_t *typelib;
85 MSFT_Header typelib_header;
86 MSFT_pSeg typelib_segdir[MSFT_SEG_MAX];
87 char *typelib_segment_data[MSFT_SEG_MAX];
88 int typelib_segment_block_length[MSFT_SEG_MAX];
89
90 INT typelib_typeinfo_offsets[0x200]; /* Hope that's enough. */
91
92 INT *typelib_namehash_segment;
93 INT *typelib_guidhash_segment;
94
95 INT help_string_dll_offset;
96
97 struct _msft_typeinfo_t *typeinfos;
98 struct _msft_typeinfo_t *last_typeinfo;
99 } msft_typelib_t;
100
101 typedef struct _msft_typeinfo_t
102 {
103 msft_typelib_t *typelib;
104 MSFT_TypeInfoBase *typeinfo;
105
106 unsigned int var_data_allocated;
107 int *var_data;
108
109 unsigned int func_data_allocated;
110 int *func_data;
111
112 int vars_allocated;
113 int *var_indices;
114 int *var_names;
115 int *var_offsets;
116
117 int funcs_allocated;
118 int *func_indices;
119 int *func_names;
120 int *func_offsets;
121
122 int datawidth;
123
124 struct _msft_typeinfo_t *next_typeinfo;
125 } msft_typeinfo_t;
126
127
128
129 /*================== Internal functions ===================================*/
130
131 /****************************************************************************
132 * ctl2_init_header
133 *
134 * Initializes the type library header of a new typelib.
135 */
136 static void ctl2_init_header(
137 msft_typelib_t *typelib) /* [I] The typelib to initialize. */
138 {
139 typelib->typelib_header.magic1 = 0x5446534d;
140 typelib->typelib_header.magic2 = 0x00010002;
141 typelib->typelib_header.posguid = -1;
142 typelib->typelib_header.lcid = 0x0409; /* or do we use the current one? */
143 typelib->typelib_header.lcid2 = 0x0;
144 typelib->typelib_header.varflags = 0x40;
145 typelib->typelib_header.version = 0;
146 typelib->typelib_header.flags = 0;
147 typelib->typelib_header.nrtypeinfos = 0;
148 typelib->typelib_header.helpstring = -1;
149 typelib->typelib_header.helpstringcontext = 0;
150 typelib->typelib_header.helpcontext = 0;
151 typelib->typelib_header.nametablecount = 0;
152 typelib->typelib_header.nametablechars = 0;
153 typelib->typelib_header.NameOffset = -1;
154 typelib->typelib_header.helpfile = -1;
155 typelib->typelib_header.CustomDataOffset = -1;
156 typelib->typelib_header.res44 = 0x20;
157 typelib->typelib_header.res48 = 0x80;
158 typelib->typelib_header.dispatchpos = -1;
159 typelib->typelib_header.res50 = 0;
160 }
161
162 /****************************************************************************
163 * ctl2_init_segdir
164 *
165 * Initializes the segment directory of a new typelib.
166 */
167 static void ctl2_init_segdir(
168 msft_typelib_t *typelib) /* [I] The typelib to initialize. */
169 {
170 int i;
171 MSFT_pSeg *segdir;
172
173 segdir = &typelib->typelib_segdir[MSFT_SEG_TYPEINFO];
174
175 for (i = 0; i < 15; i++) {
176 segdir[i].offset = -1;
177 segdir[i].length = 0;
178 segdir[i].res08 = -1;
179 segdir[i].res0c = 0x0f;
180 }
181 }
182
183 /****************************************************************************
184 * ctl2_hash_guid
185 *
186 * Generates a hash key from a GUID.
187 *
188 * RETURNS
189 *
190 * The hash key for the GUID.
191 */
192 static int ctl2_hash_guid(
193 REFGUID guid) /* [I] The guid to hash. */
194 {
195 int hash;
196 int i;
197
198 hash = 0;
199 for (i = 0; i < 8; i ++) {
200 hash ^= ((const short *)guid)[i];
201 }
202
203 return hash & 0x1f;
204 }
205
206 /****************************************************************************
207 * ctl2_find_guid
208 *
209 * Locates a guid in a type library.
210 *
211 * RETURNS
212 *
213 * The offset into the GUID segment of the guid, or -1 if not found.
214 */
215 static int ctl2_find_guid(
216 msft_typelib_t *typelib, /* [I] The typelib to operate against. */
217 int hash_key, /* [I] The hash key for the guid. */
218 REFGUID guid) /* [I] The guid to find. */
219 {
220 int offset;
221 MSFT_GuidEntry *guidentry;
222
223 offset = typelib->typelib_guidhash_segment[hash_key];
224 while (offset != -1) {
225 guidentry = (MSFT_GuidEntry *)&typelib->typelib_segment_data[MSFT_SEG_GUID][offset];
226
227 if (!memcmp(guidentry, guid, sizeof(GUID))) return offset;
228
229 offset = guidentry->next_hash;
230 }
231
232 return offset;
233 }
234
235 /****************************************************************************
236 * ctl2_find_name
237 *
238 * Locates a name in a type library.
239 *
240 * RETURNS
241 *
242 * The offset into the NAME segment of the name, or -1 if not found.
243 *
244 * NOTES
245 *
246 * The name must be encoded as with ctl2_encode_name().
247 */
248 static int ctl2_find_name(
249 msft_typelib_t *typelib, /* [I] The typelib to operate against. */
250 char *name) /* [I] The encoded name to find. */
251 {
252 int offset;
253 int *namestruct;
254
255 offset = typelib->typelib_namehash_segment[name[2] & 0x7f];
256 while (offset != -1) {
257 namestruct = (int *)&typelib->typelib_segment_data[MSFT_SEG_NAME][offset];
258
259 if (!((namestruct[2] ^ *((int *)name)) & 0xffff00ff)) {
260 /* hash codes and lengths match, final test */
261 if (!strncasecmp(name+4, (void *)(namestruct+3), name[0])) break;
262 }
263
264 /* move to next item in hash bucket */
265 offset = namestruct[1];
266 }
267
268 return offset;
269 }
270
271 /****************************************************************************
272 * ctl2_encode_name
273 *
274 * Encodes a name string to a form suitable for storing into a type library
275 * or comparing to a name stored in a type library.
276 *
277 * RETURNS
278 *
279 * The length of the encoded name, including padding and length+hash fields.
280 *
281 * NOTES
282 *
283 * Will throw an exception if name or result are NULL. Is not multithread
284 * safe in the slightest.
285 */
286 static int ctl2_encode_name(
287 msft_typelib_t *typelib, /* [I] The typelib to operate against (used for LCID only). */
288 const char *name, /* [I] The name string to encode. */
289 char **result) /* [O] A pointer to a pointer to receive the encoded name. */
290 {
291 int length;
292 static char converted_name[0x104];
293 int offset;
294 int value;
295
296 length = strlen(name);
297 memcpy(converted_name + 4, name, length);
298 converted_name[0] = length & 0xff;
299
300 converted_name[length + 4] = 0;
301
302 converted_name[1] = 0x00;
303
304 value = lhash_val_of_name_sys(typelib->typelib_header.varflags & 0x0f, typelib->typelib_header.lcid, converted_name + 4);
305
306 converted_name[2] = value;
307 converted_name[3] = value >> 8;
308
309 for (offset = (4 - length) & 3; offset; offset--) converted_name[length + offset + 3] = 0x57;
310
311 *result = converted_name;
312
313 return (length + 7) & ~3;
314 }
315
316 /****************************************************************************
317 * ctl2_encode_string
318 *
319 * Encodes a string to a form suitable for storing into a type library or
320 * comparing to a string stored in a type library.
321 *
322 * RETURNS
323 *
324 * The length of the encoded string, including padding and length fields.
325 *
326 * NOTES
327 *
328 * Will throw an exception if string or result are NULL. Is not multithread
329 * safe in the slightest.
330 */
331 static int ctl2_encode_string(
332 msft_typelib_t *typelib, /* [I] The typelib to operate against (not used?). */
333 const char *string, /* [I] The string to encode. */
334 char **result) /* [O] A pointer to a pointer to receive the encoded string. */
335 {
336 int length;
337 static char converted_string[0x104];
338 int offset;
339
340 length = strlen(string);
341 memcpy(converted_string + 2, string, length);
342 converted_string[0] = length & 0xff;
343 converted_string[1] = (length >> 8) & 0xff;
344
345 if(length < 3) { /* strings of this length are padded with upto 8 bytes incl the 2 byte length */
346 for(offset = 0; offset < 4; offset++)
347 converted_string[length + offset + 2] = 0x57;
348 length += 4;
349 }
350 for (offset = (4 - (length + 2)) & 3; offset; offset--) converted_string[length + offset + 1] = 0x57;
351
352 *result = converted_string;
353
354 return (length + 5) & ~3;
355 }
356
357 /****************************************************************************
358 * ctl2_alloc_segment
359 *
360 * Allocates memory from a segment in a type library.
361 *
362 * RETURNS
363 *
364 * Success: The offset within the segment of the new data area.
365 * Failure: -1 (this is invariably an out of memory condition).
366 *
367 * BUGS
368 *
369 * Does not (yet) handle the case where the allocated segment memory needs to grow.
370 */
371 static int ctl2_alloc_segment(
372 msft_typelib_t *typelib, /* [I] The type library in which to allocate. */
373 enum MSFT_segment_index segment, /* [I] The segment in which to allocate. */
374 int size, /* [I] The amount to allocate. */
375 int block_size) /* [I] Initial allocation block size, or 0 for default. */
376 {
377 int offset;
378
379 if(!typelib->typelib_segment_data[segment]) {
380 if (!block_size) block_size = 0x2000;
381
382 typelib->typelib_segment_block_length[segment] = block_size;
383 typelib->typelib_segment_data[segment] = xmalloc(block_size);
384 if (!typelib->typelib_segment_data[segment]) return -1;
385 memset(typelib->typelib_segment_data[segment], 0x57, block_size);
386 }
387
388 while ((typelib->typelib_segdir[segment].length + size) > typelib->typelib_segment_block_length[segment]) {
389 char *block;
390
391 block_size = typelib->typelib_segment_block_length[segment];
392 block = realloc(typelib->typelib_segment_data[segment], block_size << 1);
393 if (!block) return -1;
394
395 if (segment == MSFT_SEG_TYPEINFO) {
396 /* TypeInfos have a direct pointer to their memory space, so we have to fix them up. */
397 msft_typeinfo_t *typeinfo;
398
399 for (typeinfo = typelib->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
400 typeinfo->typeinfo = (void *)&block[((char *)typeinfo->typeinfo) - typelib->typelib_segment_data[segment]];
401 }
402 }
403
404 memset(block + block_size, 0x57, block_size);
405 typelib->typelib_segment_block_length[segment] = block_size << 1;
406 typelib->typelib_segment_data[segment] = block;
407 }
408
409 offset = typelib->typelib_segdir[segment].length;
410 typelib->typelib_segdir[segment].length += size;
411
412 return offset;
413 }
414
415 /****************************************************************************
416 * ctl2_alloc_typeinfo
417 *
418 * Allocates and initializes a typeinfo structure in a type library.
419 *
420 * RETURNS
421 *
422 * Success: The offset of the new typeinfo.
423 * Failure: -1 (this is invariably an out of memory condition).
424 */
425 static int ctl2_alloc_typeinfo(
426 msft_typelib_t *typelib, /* [I] The type library to allocate in. */
427 int nameoffset) /* [I] The offset of the name for this typeinfo. */
428 {
429 int offset;
430 MSFT_TypeInfoBase *typeinfo;
431
432 offset = ctl2_alloc_segment(typelib, MSFT_SEG_TYPEINFO, sizeof(MSFT_TypeInfoBase), 0);
433 if (offset == -1) return -1;
434
435 typelib->typelib_typeinfo_offsets[typelib->typelib_header.nrtypeinfos++] = offset;
436
437 typeinfo = (void *)(typelib->typelib_segment_data[MSFT_SEG_TYPEINFO] + offset);
438
439 typeinfo->typekind = (typelib->typelib_header.nrtypeinfos - 1) << 16;
440 typeinfo->memoffset = -1; /* should be EOF if no elements */
441 typeinfo->res2 = 0;
442 typeinfo->res3 = -1;
443 typeinfo->res4 = 3;
444 typeinfo->res5 = 0;
445 typeinfo->cElement = 0;
446 typeinfo->res7 = 0;
447 typeinfo->res8 = 0;
448 typeinfo->res9 = 0;
449 typeinfo->resA = 0;
450 typeinfo->posguid = -1;
451 typeinfo->flags = 0;
452 typeinfo->NameOffset = nameoffset;
453 typeinfo->version = 0;
454 typeinfo->docstringoffs = -1;
455 typeinfo->helpstringcontext = 0;
456 typeinfo->helpcontext = 0;
457 typeinfo->oCustData = -1;
458 typeinfo->cbSizeVft = 0;
459 typeinfo->cImplTypes = 0;
460 typeinfo->size = 0;
461 typeinfo->datatype1 = -1;
462 typeinfo->datatype2 = 0;
463 typeinfo->res18 = 0;
464 typeinfo->res19 = -1;
465
466 return offset;
467 }
468
469 /****************************************************************************
470 * ctl2_alloc_guid
471 *
472 * Allocates and initializes a GUID structure in a type library. Also updates
473 * the GUID hash table as needed.
474 *
475 * RETURNS
476 *
477 * Success: The offset of the new GUID.
478 * Failure: -1 (this is invariably an out of memory condition).
479 */
480 static int ctl2_alloc_guid(
481 msft_typelib_t *typelib, /* [I] The type library to allocate in. */
482 MSFT_GuidEntry *guid) /* [I] The GUID to store. */
483 {
484 int offset;
485 MSFT_GuidEntry *guid_space;
486 int hash_key;
487
488 hash_key = ctl2_hash_guid(&guid->guid);
489
490 offset = ctl2_find_guid(typelib, hash_key, &guid->guid);
491 if (offset != -1) return offset;
492
493 offset = ctl2_alloc_segment(typelib, MSFT_SEG_GUID, sizeof(MSFT_GuidEntry), 0);
494 if (offset == -1) return -1;
495
496 guid_space = (void *)(typelib->typelib_segment_data[MSFT_SEG_GUID] + offset);
497 *guid_space = *guid;
498
499 guid_space->next_hash = typelib->typelib_guidhash_segment[hash_key];
500 typelib->typelib_guidhash_segment[hash_key] = offset;
501
502 return offset;
503 }
504
505 /****************************************************************************
506 * ctl2_alloc_name
507 *
508 * Allocates and initializes a name within a type library. Also updates the
509 * name hash table as needed.
510 *
511 * RETURNS
512 *
513 * Success: The offset within the segment of the new name.
514 * Failure: -1 (this is invariably an out of memory condition).
515 */
516 static int ctl2_alloc_name(
517 msft_typelib_t *typelib, /* [I] The type library to allocate in. */
518 const char *name) /* [I] The name to store. */
519 {
520 int length;
521 int offset;
522 MSFT_NameIntro *name_space;
523 char *encoded_name;
524
525 length = ctl2_encode_name(typelib, name, &encoded_name);
526
527 offset = ctl2_find_name(typelib, encoded_name);
528 if (offset != -1) return offset;
529
530 offset = ctl2_alloc_segment(typelib, MSFT_SEG_NAME, length + 8, 0);
531 if (offset == -1) return -1;
532
533 name_space = (void *)(typelib->typelib_segment_data[MSFT_SEG_NAME] + offset);
534 name_space->hreftype = -1;
535 name_space->next_hash = -1;
536 memcpy(&name_space->namelen, encoded_name, length);
537
538 if (typelib->typelib_namehash_segment[encoded_name[2] & 0x7f] != -1)
539 name_space->next_hash = typelib->typelib_namehash_segment[encoded_name[2] & 0x7f];
540
541 typelib->typelib_namehash_segment[encoded_name[2] & 0x7f] = offset;
542
543 typelib->typelib_header.nametablecount += 1;
544 typelib->typelib_header.nametablechars += *encoded_name;
545
546 return offset;
547 }
548
549 /****************************************************************************
550 * ctl2_alloc_string
551 *
552 * Allocates and initializes a string in a type library.
553 *
554 * RETURNS
555 *
556 * Success: The offset within the segment of the new string.
557 * Failure: -1 (this is invariably an out of memory condition).
558 */
559 static int ctl2_alloc_string(
560 msft_typelib_t *typelib, /* [I] The type library to allocate in. */
561 const char *string) /* [I] The string to store. */
562 {
563 int length;
564 int offset;
565 char *string_space;
566 char *encoded_string;
567
568 length = ctl2_encode_string(typelib, string, &encoded_string);
569
570 for (offset = 0; offset < typelib->typelib_segdir[MSFT_SEG_STRING].length;
571 offset += ((((typelib->typelib_segment_data[MSFT_SEG_STRING][offset + 1] << 8) & 0xff)
572 | (typelib->typelib_segment_data[MSFT_SEG_STRING][offset + 0] & 0xff)) + 5) & ~3) {
573 if (!memcmp(encoded_string, typelib->typelib_segment_data[MSFT_SEG_STRING] + offset, length)) return offset;
574 }
575
576 offset = ctl2_alloc_segment(typelib, MSFT_SEG_STRING, length, 0);
577 if (offset == -1) return -1;
578
579 string_space = typelib->typelib_segment_data[MSFT_SEG_STRING] + offset;
580 memcpy(string_space, encoded_string, length);
581
582 return offset;
583 }
584
585 /****************************************************************************
586 * alloc_importinfo
587 *
588 * Allocates and initializes an import information structure in a type library.
589 *
590 * RETURNS
591 *
592 * Success: The offset of the new importinfo.
593 * Failure: -1 (this is invariably an out of memory condition).
594 */
595 static int alloc_importinfo(
596 msft_typelib_t *typelib, /* [I] The type library to allocate in. */
597 MSFT_ImpInfo *impinfo) /* [I] The import information to store. */
598 {
599 int offset;
600 MSFT_ImpInfo *impinfo_space;
601
602 for (offset = 0;
603 offset < typelib->typelib_segdir[MSFT_SEG_IMPORTINFO].length;
604 offset += sizeof(MSFT_ImpInfo)) {
605 if (!memcmp(&(typelib->typelib_segment_data[MSFT_SEG_IMPORTINFO][offset]),
606 impinfo, sizeof(MSFT_ImpInfo))) {
607 return offset;
608 }
609 }
610
611 offset = ctl2_alloc_segment(typelib, MSFT_SEG_IMPORTINFO, sizeof(MSFT_ImpInfo), 0);
612 if (offset == -1) return -1;
613
614 impinfo_space = (void *)(typelib->typelib_segment_data[MSFT_SEG_IMPORTINFO] + offset);
615 *impinfo_space = *impinfo;
616
617 return offset;
618 }
619
620 /****************************************************************************
621 * alloc_importfile
622 *
623 * Allocates and initializes an import file definition in a type library.
624 *
625 * RETURNS
626 *
627 * Success: The offset of the new importinfo.
628 * Failure: -1 (this is invariably an out of memory condition).
629 */
630 static int alloc_importfile(
631 msft_typelib_t *typelib, /* [I] The type library to allocate in. */
632 int guidoffset, /* [I] The offset to the GUID for the imported library. */
633 int major_version, /* [I] The major version number of the imported library. */
634 int minor_version, /* [I] The minor version number of the imported library. */
635 const char *filename) /* [I] The filename of the imported library. */
636 {
637 int length;
638 int offset;
639 MSFT_ImpFile *importfile;
640 char *encoded_string;
641
642 length = ctl2_encode_string(typelib, filename, &encoded_string);
643
644 encoded_string[0] <<= 2;
645 encoded_string[0] |= 1;
646
647 for (offset = 0; offset < typelib->typelib_segdir[MSFT_SEG_IMPORTFILES].length;
648 offset += ((((typelib->typelib_segment_data[MSFT_SEG_IMPORTFILES][offset + 0xd] << 8) & 0xff)
649 | (typelib->typelib_segment_data[MSFT_SEG_IMPORTFILES][offset + 0xc] & 0xff)) >> 2) + 0xc) {
650 if (!memcmp(encoded_string, typelib->typelib_segment_data[MSFT_SEG_IMPORTFILES] + offset + 0xc, length)) return offset;
651 }
652
653 offset = ctl2_alloc_segment(typelib, MSFT_SEG_IMPORTFILES, length + 0xc, 0);
654 if (offset == -1) return -1;
655
656 importfile = (MSFT_ImpFile *)&typelib->typelib_segment_data[MSFT_SEG_IMPORTFILES][offset];
657 importfile->guid = guidoffset;
658 importfile->lcid = typelib->typelib_header.lcid2;
659 importfile->version = major_version | (minor_version << 16);
660 memcpy(&importfile->filename, encoded_string, length);
661
662 return offset;
663 }
664
665 static void add_structure_typeinfo(msft_typelib_t *typelib, type_t *structure);
666 static void add_interface_typeinfo(msft_typelib_t *typelib, type_t *interface);
667
668 /****************************************************************************
669 * encode_type
670 *
671 * Encodes a type, storing information in the TYPEDESC and ARRAYDESC
672 * segments as needed.
673 *
674 * RETURNS
675 *
676 * Success: 0.
677 * Failure: -1.
678 */
679 static int encode_type(
680 msft_typelib_t *typelib, /* [I] The type library in which to encode the TYPEDESC. */
681 int vt, /* [I] vt to encode */
682 type_t *type, /* [I] type */
683 int *encoded_type, /* [O] The encoded type description. */
684 int *width, /* [O] The width of the type, or NULL. */
685 int *alignment, /* [O] The alignment of the type, or NULL. */
686 int *decoded_size) /* [O] The total size of the unencoded TYPEDESCs, including nested descs. */
687 {
688 int default_type;
689 int scratch;
690 int typeoffset;
691 int *typedata;
692 int target_type;
693 int child_size = 0;
694
695 chat("encode_type vt %d type %p\n", vt, type);
696
697 default_type = 0x80000000 | (vt << 16) | vt;
698 if (!width) width = &scratch;
699 if (!alignment) alignment = &scratch;
700 if (!decoded_size) decoded_size = &scratch;
701
702
703 switch (vt) {
704 case VT_I1:
705 case VT_UI1:
706 *encoded_type = default_type;
707 *width = 1;
708 *alignment = 1;
709 break;
710
711 case VT_INT:
712 *encoded_type = 0x80000000 | (VT_I4 << 16) | VT_INT;
713 if ((typelib->typelib_header.varflags & 0x0f) == SYS_WIN16) {
714 *width = 2;
715 *alignment = 2;
716 } else {
717 *width = 4;
718 *alignment = 4;
719 }
720 break;
721
722 case VT_UINT:
723 *encoded_type = 0x80000000 | (VT_UI4 << 16) | VT_UINT;
724 if ((typelib->typelib_header.varflags & 0x0f) == SYS_WIN16) {
725 *width = 2;
726 *alignment = 2;
727 } else {
728 *width = 4;
729 *alignment = 4;
730 }
731 break;
732
733 case VT_UI2:
734 case VT_I2:
735 case VT_BOOL:
736 *encoded_type = default_type;
737 *width = 2;
738 *alignment = 2;
739 break;
740
741 case VT_I4:
742 case VT_UI4:
743 case VT_R4:
744 case VT_ERROR:
745 case VT_BSTR:
746 case VT_HRESULT:
747 *encoded_type = default_type;
748 *width = 4;
749 *alignment = 4;
750 break;
751
752 case VT_R8:
753 *encoded_type = default_type;
754 *width = 8;
755 *alignment = 8;
756 break;
757
758 case VT_CY:
759 *encoded_type = default_type;
760 *width = 8;
761 *alignment = 8;
762 break;
763
764 case VT_VOID:
765 *encoded_type = 0x80000000 | (VT_EMPTY << 16) | vt;
766 *width = 0;
767 *alignment = 1;
768 break;
769
770 case VT_UNKNOWN:
771 case VT_DISPATCH:
772 *encoded_type = default_type;
773 *width = 4;
774 *alignment = 4;
775 break;
776
777 case VT_VARIANT:
778 *encoded_type = default_type;
779 break;
780
781 case VT_PTR:
782 {
783 int next_vt;
784 while((next_vt = get_type_vt(type->ref)) == 0) {
785 if(type->ref == NULL) {
786 next_vt = VT_VOID;
787 break;
788 }
789 type = type->ref;
790 }
791
792 encode_type(typelib, next_vt, type->ref, &target_type, NULL, NULL, &child_size);
793 if(type->ref->type == RPC_FC_IP) {
794 chat("encode_type: skipping ptr\n");
795 *encoded_type = target_type;
796 *width = 4;
797 *alignment = 4;
798 *decoded_size = child_size;
799 break;
800 }
801
802 for (typeoffset = 0; typeoffset < typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
803 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
804 if (((typedata[0] & 0xffff) == VT_PTR) && (typedata[1] == target_type)) break;
805 }
806
807 if (typeoffset == typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length) {
808 int mix_field;
809
810 if (target_type & 0x80000000) {
811 mix_field = ((target_type >> 16) & 0x3fff) | VT_BYREF;
812 } else {
813 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][target_type];
814 mix_field = ((typedata[0] >> 16) == 0x7fff)? 0x7fff: 0x7ffe;
815 }
816
817 typeoffset = ctl2_alloc_segment(typelib, MSFT_SEG_TYPEDESC, 8, 0);
818 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
819
820 typedata[0] = (mix_field << 16) | VT_PTR;
821 typedata[1] = target_type;
822 }
823
824 *encoded_type = typeoffset;
825
826 *width = 4;
827 *alignment = 4;
828 *decoded_size = 8 /*sizeof(TYPEDESC)*/ + child_size;
829 break;
830 }
831 #if 0
832
833
834 case VT_SAFEARRAY:
835 /* FIXME: Make with the error checking. */
836 FIXME("SAFEARRAY vartype, may not work correctly.\n");
837
838 ctl2_encode_typedesc(typelib, tdesc->u.lptdesc, &target_type, NULL, NULL, &child_size);
839
840 for (typeoffset = 0; typeoffset < typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
841 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
842 if (((typedata[0] & 0xffff) == VT_SAFEARRAY) && (typedata[1] == target_type)) break;
843 }
844
845 if (typeoffset == typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length) {
846 int mix_field;
847
848 if (target_type & 0x80000000) {
849 mix_field = ((target_type >> 16) & VT_TYPEMASK) | VT_ARRAY;
850 } else {
851 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][target_type];
852 mix_field = ((typedata[0] >> 16) == 0x7fff)? 0x7fff: 0x7ffe;
853 }
854
855 typeoffset = ctl2_alloc_segment(typelib, MSFT_SEG_TYPEDESC, 8, 0);
856 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
857
858 typedata[0] = (mix_field << 16) | VT_SAFEARRAY;
859 typedata[1] = target_type;
860 }
861
862 *encoded_tdesc = typeoffset;
863
864 *width = 4;
865 *alignment = 4;
866 *decoded_size = sizeof(TYPEDESC) + child_size;
867 break;
868
869
870 #endif
871
872 case VT_USERDEFINED:
873 {
874 int typeinfo_offset;
875 chat("encode_type: VT_USERDEFINED - type %p name = %s type->type %d idx %d\n", type,
876 type->name, type->type, type->typelib_idx);
877
878 if(type->typelib_idx == -1) {
879 chat("encode_type: trying to ref not added type\n");
880 switch(type->type) {
881 case RPC_FC_STRUCT:
882 case RPC_FC_PSTRUCT:
883 case RPC_FC_CSTRUCT:
884 case RPC_FC_CPSTRUCT:
885 case RPC_FC_CVSTRUCT:
886 case RPC_FC_BOGUS_STRUCT:
887 add_structure_typeinfo(typelib, type);
888 break;
889 case RPC_FC_IP:
890 add_interface_typeinfo(typelib, type);
891 break;
892 case 0:
893 error("encode_type: VT_USERDEFINED - can't yet add typedef's on the fly\n");
894 default:
895 error("encode_type: VT_USERDEFINED - unhandled type %d\n", type->type);
896 }
897 }
898
899 typeinfo_offset = typelib->typelib_typeinfo_offsets[type->typelib_idx];
900 for (typeoffset = 0; typeoffset < typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
901 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
902 if ((typedata[0] == ((0x7fff << 16) | VT_USERDEFINED)) && (typedata[1] == typeinfo_offset)) break;
903 }
904
905 if (typeoffset == typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length) {
906 typeoffset = ctl2_alloc_segment(typelib, MSFT_SEG_TYPEDESC, 8, 0);
907 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
908
909 typedata[0] = (0x7fff << 16) | VT_USERDEFINED;
910 typedata[1] = typeinfo_offset;
911 }
912
913 *encoded_type = typeoffset;
914 *width = 0;
915 *alignment = 1;
916
917 if(type->type == RPC_FC_IP) {
918 for (typeoffset = 0; typeoffset < typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
919 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
920 if ((typedata[0] == ((0x7fff << 16) | VT_PTR)) && (typedata[1] == *encoded_type)) break;
921 }
922 if (typeoffset == typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length) {
923 typeoffset = ctl2_alloc_segment(typelib, MSFT_SEG_TYPEDESC, 8, 0);
924 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
925
926 typedata[0] = (0x7fff << 16) | VT_PTR;
927 typedata[1] = *encoded_type;
928 }
929 *encoded_type = typeoffset;
930 *width = 4;
931 *alignment = 4;
932 *decoded_size += 8;
933 }
934 break;
935 }
936
937 default:
938 error("encode_type: unrecognized type %d.\n", vt);
939 *encoded_type = default_type;
940 *width = 0;
941 *alignment = 1;
942 break;
943 }
944
945 return 0;
946 }
947
948 static void dump_type(type_t *t)
949 {
950 chat("dump_type: %p name %s type %d ref %p rname %s attrs %p\n", t, t->name, t->type, t->ref, t->rname, t->attrs);
951 if(t->ref) dump_type(t->ref);
952 }
953
954 static int encode_var(
955 msft_typelib_t *typelib, /* [I] The type library in which to encode the TYPEDESC. */
956 var_t *var, /* [I] The type description to encode. */
957 int *encoded_type, /* [O] The encoded type description. */
958 int *width, /* [O] The width of the type, or NULL. */
959 int *alignment, /* [O] The alignment of the type, or NULL. */
960 int *decoded_size) /* [O] The total size of the unencoded TYPEDESCs, including nested descs. */
961 {
962 int typeoffset;
963 int *typedata;
964 int target_type;
965 int child_size;
966 int vt;
967 int scratch;
968 type_t *type;
969
970 if (!width) width = &scratch;
971 if (!alignment) alignment = &scratch;
972 if (!decoded_size) decoded_size = &scratch;
973 *decoded_size = 0;
974
975 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);
976 if(var->ptr_level) {
977 int skip_ptr;
978 var->ptr_level--;
979 skip_ptr = encode_var(typelib, var, &target_type, NULL, NULL, &child_size);
980 var->ptr_level++;
981
982 if(skip_ptr == 2) {
983 chat("encode_var: skipping ptr\n");
984 *encoded_type = target_type;
985 *decoded_size = child_size;
986 *width = 4;
987 *alignment = 4;
988 return 0;
989 }
990
991 for (typeoffset = 0; typeoffset < typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
992 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
993 if (((typedata[0] & 0xffff) == VT_PTR) && (typedata[1] == target_type)) break;
994 }
995
996 if (typeoffset == typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length) {
997 int mix_field;
998
999 if (target_type & 0x80000000) {
1000 mix_field = ((target_type >> 16) & 0x3fff) | VT_BYREF;
1001 } else {
1002 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][target_type];
1003 mix_field = ((typedata[0] >> 16) == 0x7fff)? 0x7fff: 0x7ffe;
1004 }
1005
1006 typeoffset = ctl2_alloc_segment(typelib, MSFT_SEG_TYPEDESC, 8, 0);
1007 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1008
1009 typedata[0] = (mix_field << 16) | VT_PTR;
1010 typedata[1] = target_type;
1011 }
1012
1013 *encoded_type = typeoffset;
1014
1015 *width = 4;
1016 *alignment = 4;
1017 *decoded_size = 8 /*sizeof(TYPEDESC)*/ + child_size;
1018 return 0;
1019 }
1020
1021 if(var->array) {
1022 expr_t *dim = var->array;
1023 expr_t *array_save;
1024 int num_dims = 1, elements = 1, arrayoffset;
1025 int *arraydata;
1026
1027 while(NEXT_LINK(dim)) {
1028 dim = NEXT_LINK(dim);
1029 num_dims++;
1030 }
1031 chat("array with %d dimensions\n", num_dims);
1032 array_save = var->array;
1033 var->array = NULL;
1034 encode_var(typelib, var, &target_type, width, alignment, NULL);
1035 var->array = array_save;
1036 arrayoffset = ctl2_alloc_segment(typelib, MSFT_SEG_ARRAYDESC, (2 + 2 * num_dims) * sizeof(long), 0);
1037 arraydata = (void *)&typelib->typelib_segment_data[MSFT_SEG_ARRAYDESC][arrayoffset];
1038
1039 arraydata[0] = target_type;
1040 arraydata[1] = num_dims;
1041 arraydata[1] |= ((num_dims * 2 * sizeof(long)) << 16);
1042
1043 arraydata += 2;
1044 while(dim) {
1045 arraydata[0] = dim->cval;
1046 arraydata[1] = 0;
1047 arraydata += 2;
1048 elements *= dim->cval;
1049 dim = PREV_LINK(dim);
1050 }
1051
1052 typeoffset = ctl2_alloc_segment(typelib, MSFT_SEG_TYPEDESC, 8, 0);
1053 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1054
1055 typedata[0] = (0x7ffe << 16) | VT_CARRAY;
1056 typedata[1] = arrayoffset;
1057
1058 *encoded_type = typeoffset;
1059 *width = *width * elements;
1060 *decoded_size = 20 /*sizeof(ARRAYDESC)*/ + (num_dims - 1) * 8 /*sizeof(SAFEARRAYBOUND)*/;
1061 return 0;
1062 }
1063 dump_type(var->type);
1064
1065 vt = get_var_vt(var);
1066 type = var->type;
1067 while(!vt) {
1068 if(type->ref == NULL) {
1069 vt = VT_VOID;
1070 break;
1071 }
1072 type = type->ref;
1073 vt = get_type_vt(type);
1074 }
1075 encode_type(typelib, vt, type, encoded_type, width, alignment, decoded_size);
1076 if(type->type == RPC_FC_IP) return 2;
1077 return 0;
1078 }
1079
1080
1081 static void write_value(msft_typelib_t* typelib, int *out, int vt, void *value)
1082 {
1083 switch(vt) {
1084 case VT_I2:
1085 case VT_I4:
1086 case VT_R4:
1087 case VT_BOOL:
1088 case VT_I1:
1089 case VT_UI1:
1090 case VT_UI2:
1091 case VT_UI4:
1092 case VT_INT:
1093 case VT_UINT:
1094 case VT_HRESULT:
1095 {
1096 unsigned long *lv = value;
1097 if((*lv & 0x3ffffff) == *lv) {
1098 *out = 0x80000000;
1099 *out |= vt << 26;
1100 *out |= *lv;
1101 } else {
1102 int offset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATA, 8, 0);
1103 *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset]) = vt;
1104 memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+2], value, 4);
1105 *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+6]) = 0x5757;
1106 *out = offset;
1107 }
1108 return;
1109 }
1110 case VT_BSTR:
1111 {
1112 char *s = (char *) value;
1113 int len = strlen(s), seg_len = (len + 6 + 3) & ~0x3;
1114 int offset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATA, seg_len, 0);
1115 *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset]) = vt;
1116 *((unsigned int *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+2]) = len;
1117 memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+6], value, len);
1118 len += 6;
1119 while(len < seg_len) {
1120 *((char *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+len]) = 0x57;
1121 len++;
1122 }
1123 *out = offset;
1124 return;
1125 }
1126
1127 default:
1128 warning("can't write value of type %d yet\n", vt);
1129 }
1130 return;
1131 }
1132
1133 static HRESULT set_custdata(msft_typelib_t *typelib, REFGUID guid,
1134 int vt, void *value, int *offset)
1135 {
1136 MSFT_GuidEntry guidentry;
1137 int guidoffset;
1138 int custoffset;
1139 int *custdata;
1140 int data_out;
1141
1142 guidentry.guid = *guid;
1143
1144 guidentry.hreftype = -1;
1145 guidentry.next_hash = -1;
1146
1147 guidoffset = ctl2_alloc_guid(typelib, &guidentry);
1148 if (guidoffset == -1) return E_OUTOFMEMORY;
1149 write_value(typelib, &data_out, vt, value);
1150
1151 custoffset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATAGUID, 12, 0);
1152 if (custoffset == -1) return E_OUTOFMEMORY;
1153
1154 custdata = (int *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATAGUID][custoffset];
1155 custdata[0] = guidoffset;
1156 custdata[1] = data_out;
1157 custdata[2] = *offset;
1158 *offset = custoffset;
1159
1160 return S_OK;
1161 }
1162
1163 static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, func_t *func, int index)
1164 {
1165 int offset, name_offset;
1166 int *typedata, typedata_size;
1167 int i, id, next_idx;
1168 int decoded_size, extra_attr = 0;
1169 int num_params = 0, num_defaults = 0;
1170 var_t *arg, *last_arg = NULL;
1171 char *namedata;
1172 attr_t *attr;
1173 unsigned int funcflags = 0, callconv = 4 /* CC_STDCALL */;
1174 unsigned int funckind, invokekind = 1 /* INVOKE_FUNC */;
1175 int help_context = 0, help_string_context = 0, help_string_offset = -1;
1176 int entry = -1, entry_is_ord = 0;
1177
1178 chat("add_func_desc(%p,%d)\n", typeinfo, index);
1179
1180 id = ((0x6000 | (typeinfo->typeinfo->datatype2 & 0xffff)) << 16) | index;
1181
1182 switch(typeinfo->typeinfo->typekind & 15) {
1183 case TKIND_DISPATCH:
1184 funckind = 0x4; /* FUNC_DISPATCH */
1185 break;
1186 case TKIND_MODULE:
1187 funckind = 0x3; /* FUNC_STATIC */
1188 break;
1189 default:
1190 funckind = 0x1; /* FUNC_PUREVIRTUAL */
1191 break;
1192 }
1193
1194 for(attr = func->def->attrs; attr; attr = NEXT_LINK(attr)) {
1195 if(attr->type == ATTR_LOCAL) {
1196 chat("add_func_desc: skipping local function\n");
1197 return S_FALSE;
1198 }
1199 }
1200
1201 for(arg = func->args; arg; arg = NEXT_LINK(arg)) {
1202 last_arg = arg;
1203 num_params++;
1204 for(attr = arg->attrs; attr; attr = NEXT_LINK(attr)) {
1205 if(attr->type == ATTR_DEFAULTVALUE_EXPR || attr->type == ATTR_DEFAULTVALUE_STRING) {
1206 num_defaults++;
1207 break;
1208 }
1209 }
1210 }
1211
1212 chat("add_func_desc: num of params %d\n", num_params);
1213
1214 name_offset = ctl2_alloc_name(typeinfo->typelib, func->def->name);
1215
1216 for(attr = func->def->attrs; attr; attr = NEXT_LINK(attr)) {
1217 expr_t *expr = attr->u.pval;
1218 switch(attr->type) {
1219 case ATTR_ENTRY_ORDINAL:
1220 extra_attr = max(extra_attr, 3);
1221 entry = expr->cval;
1222 entry_is_ord = 1;
1223 break;
1224 case ATTR_ENTRY_STRING:
1225 extra_attr = max(extra_attr, 3);
1226 entry = ctl2_alloc_string(typeinfo->typelib, attr->u.pval);
1227 break;
1228 case ATTR_HELPCONTEXT:
1229 extra_attr = max(extra_attr, 1);
1230 help_context = expr->u.lval;
1231 break;
1232 case ATTR_HELPSTRING:
1233 extra_attr = max(extra_attr, 2);
1234 help_string_offset = ctl2_alloc_string(typeinfo->typelib, attr->u.pval);
1235 break;
1236 case ATTR_HELPSTRINGCONTEXT:
1237 extra_attr = max(extra_attr, 6);
1238 help_string_context = expr->u.lval;
1239 break;
1240 case ATTR_HIDDEN:
1241 funcflags |= 0x40; /* FUNCFLAG_FHIDDEN */
1242 break;
1243 case ATTR_ID:
1244 id = expr->u.lval;
1245 break;
1246 case ATTR_OUT:
1247 break;
1248 case ATTR_PROPGET:
1249 invokekind = 0x2; /* INVOKE_PROPERTYGET */
1250 break;
1251 case ATTR_PROPPUT:
1252 invokekind = 0x4; /* INVOKE_PROPERTYPUT */
1253 break;
1254 case ATTR_PROPPUTREF:
1255 invokekind = 0x8; /* INVOKE_PROPERTYPUTREF */
1256 break;
1257 case ATTR_RESTRICTED:
1258 funcflags |= 0x1; /* FUNCFLAG_FRESTRICTED */
1259 break;
1260 default:
1261 warning("add_func_desc: ignoring attr %d\n", attr->type);
1262 break;
1263 }
1264 }
1265
1266 switch(invokekind) {
1267 case 0x2: /* INVOKE_PROPERTYGET */
1268 if((num_params != 0 && (typeinfo->typeinfo->typekind & 15) == TKIND_DISPATCH)
1269 || (num_params != 1 && (typeinfo->typeinfo->typekind & 15) == TKIND_INTERFACE)) {
1270 error("expecting no args on a propget func\n");
1271 return S_FALSE;
1272 }
1273 break;
1274 case 0x4: /* INVOKE_PROPERTYPUT */
1275 case 0x8: /* INVOKE_PROPERTYPUTREF */
1276 if(num_params != 1) {
1277 error("expecting one arg on a propput func\n");
1278 return S_FALSE;
1279 }
1280 break;
1281 default:
1282 break;
1283 }
1284
1285 /* allocate type data space for us */
1286 typedata_size = 0x18 + extra_attr * sizeof(int) + (num_params * (num_defaults ? 16 : 12));
1287
1288 if (!typeinfo->func_data) {
1289 typeinfo->func_data = xmalloc(0x100);
1290 typeinfo->func_data_allocated = 0x100;
1291 typeinfo->func_data[0] = 0;
1292 }
1293
1294 if(typeinfo->func_data[0] + typedata_size + sizeof(int) > typeinfo->func_data_allocated) {
1295 typeinfo->func_data_allocated = max(typeinfo->func_data_allocated * 2,
1296 typeinfo->func_data[0] + typedata_size + sizeof(int));
1297 typeinfo->func_data = xrealloc(typeinfo->func_data, typeinfo->func_data_allocated);
1298 }
1299
1300 offset = typeinfo->func_data[0];
1301 typeinfo->func_data[0] += typedata_size;
1302 typedata = typeinfo->func_data + (offset >> 2) + 1;
1303
1304
1305 /* find func with the same name - if it exists use its id */
1306 for(i = 0; i < (typeinfo->typeinfo->cElement & 0xffff); i++) {
1307 if(name_offset == typeinfo->func_names[i]) {
1308 id = typeinfo->func_indices[i];
1309 break;
1310 }
1311 }
1312
1313 /* find the first func with the same id and link via the hiword of typedata[4] */
1314 next_idx = index;
1315 for(i = 0; i < (typeinfo->typeinfo->cElement & 0xffff); i++) {
1316 if(id == typeinfo->func_indices[i]) {
1317 next_idx = typeinfo->func_data[(typeinfo->func_offsets[i] >> 2) + 1 + 4] >> 16;
1318 typeinfo->func_data[(typeinfo->func_offsets[i] >> 2) + 1 + 4] &= 0xffff;
1319 typeinfo->func_data[(typeinfo->func_offsets[i] >> 2) + 1 + 4] |= (index << 16);
1320 break;
1321 }
1322 }
1323
1324 /* fill out the basic type information */
1325 typedata[0] = typedata_size | (index << 16);
1326 encode_var(typeinfo->typelib, func->def, &typedata[1], NULL, NULL, &decoded_size);
1327 typedata[2] = funcflags;
1328 typedata[3] = ((52 /*sizeof(FUNCDESC)*/ + decoded_size) << 16) | typeinfo->typeinfo->cbSizeVft;
1329 typedata[4] = (next_idx << 16) | (callconv << 8) | (invokekind << 3) | funckind;
1330 if(num_defaults) typedata[4] |= 0x1000;
1331 if(entry_is_ord) typedata[4] |= 0x2000;
1332 typedata[5] = num_params;
1333
1334 /* NOTE: High word of typedata[3] is total size of FUNCDESC + size of all ELEMDESCs for params + TYPEDESCs for pointer params and return types. */
1335 /* That is, total memory allocation required to reconstitute the FUNCDESC in its entirety. */
1336 typedata[3] += (16 /*sizeof(ELEMDESC)*/ * num_params) << 16;
1337 typedata[3] += (24 /*sizeof(PARAMDESCEX)*/ * num_defaults) << 16;
1338
1339 switch(extra_attr) {
1340 case 6: typedata[11] = help_string_context;
1341 case 5: typedata[10] = -1;
1342 case 4: typedata[9] = -1;
1343 case 3: typedata[8] = entry;
1344 case 2: typedata[7] = help_string_offset;
1345 case 1: typedata[6] = help_context;
1346 case 0:
1347 break;
1348 default:
1349 warning("unknown number of optional attrs\n");
1350 }
1351
1352 for (arg = last_arg, i = 0; arg; arg = PREV_LINK(arg), i++) {
1353 attr_t *attr;
1354 int paramflags = 0;
1355 int *paramdata = typedata + 6 + extra_attr + (num_defaults ? num_params : 0) + i * 3;
1356 int *defaultdata = num_defaults ? typedata + 6 + extra_attr + i : NULL;
1357
1358 if(defaultdata) *defaultdata = -1;
1359
1360 encode_var(typeinfo->typelib, arg, paramdata, NULL, NULL, &decoded_size);
1361 for(attr = arg->attrs; attr; attr = NEXT_LINK(attr)) {
1362 switch(attr->type) {
1363 case ATTR_DEFAULTVALUE_EXPR:
1364 {
1365 expr_t *expr = (expr_t *)attr->u.pval;
1366 paramflags |= 0x30; /* PARAMFLAG_FHASDEFAULT | PARAMFLAG_FOPT */
1367 chat("default value %ld\n", expr->cval);
1368 write_value(typeinfo->typelib, defaultdata, (*paramdata >> 16) & 0x1ff, &expr->cval);
1369 break;
1370 }
1371 case ATTR_DEFAULTVALUE_STRING:
1372 {
1373 char *s = (char *)attr->u.pval;
1374 paramflags |= 0x30; /* PARAMFLAG_FHASDEFAULT | PARAMFLAG_FOPT */
1375 chat("default value '%s'\n", s);
1376 write_value(typeinfo->typelib, defaultdata, (*paramdata >> 16) & 0x1ff, s);
1377 break;
1378 }
1379 case ATTR_IN:
1380 paramflags |= 0x01; /* PARAMFLAG_FIN */
1381 break;
1382 case ATTR_OPTIONAL:
1383 paramflags |= 0x10; /* PARAMFLAG_FOPT */
1384 break;
1385 case ATTR_OUT:
1386 paramflags |= 0x02; /* PARAMFLAG_FOUT */
1387 break;
1388 case ATTR_RETVAL:
1389 paramflags |= 0x08; /* PARAMFLAG_FRETVAL */
1390 typedata[4] |= 0x4000;
1391 break;
1392 default:
1393 chat("unhandled param attr %d\n", attr->type);
1394 break;
1395 }
1396 }
1397 paramdata[1] = -1;
1398 paramdata[2] = paramflags;
1399 typedata[3] += decoded_size << 16;
1400 }
1401
1402 if(typeinfo->funcs_allocated == 0) {
1403 typeinfo->funcs_allocated = 10;
1404 typeinfo->func_indices = xmalloc(typeinfo->funcs_allocated * sizeof(int));
1405 typeinfo->func_names = xmalloc(typeinfo->funcs_allocated * sizeof(int));
1406 typeinfo->func_offsets = xmalloc(typeinfo->funcs_allocated * sizeof(int));
1407 }
1408 if(typeinfo->funcs_allocated == (typeinfo->typeinfo->cElement & 0xffff)) {
1409 typeinfo->funcs_allocated *= 2;
1410 typeinfo->func_indices = xrealloc(typeinfo->func_indices, typeinfo->funcs_allocated * sizeof(int));
1411 typeinfo->func_names = xrealloc(typeinfo->func_names, typeinfo->funcs_allocated * sizeof(int));
1412 typeinfo->func_offsets = xrealloc(typeinfo->func_offsets, typeinfo->funcs_allocated * sizeof(int));
1413 }
1414
1415 /* update the index data */
1416 typeinfo->func_indices[typeinfo->typeinfo->cElement & 0xffff] = id;
1417 typeinfo->func_offsets[typeinfo->typeinfo->cElement & 0xffff] = offset;
1418 typeinfo->func_names[typeinfo->typeinfo->cElement & 0xffff] = name_offset;
1419
1420 /* ??? */
1421 if (!typeinfo->typeinfo->res2) typeinfo->typeinfo->res2 = 0x20;
1422 typeinfo->typeinfo->res2 <<= 1;
1423 /* ??? */
1424 if (index < 2) typeinfo->typeinfo->res2 += num_params << 4;
1425
1426 if (typeinfo->typeinfo->res3 == -1) typeinfo->typeinfo->res3 = 0;
1427 typeinfo->typeinfo->res3 += 0x38 + num_params * 0x10;
1428 if(num_defaults) typeinfo->typeinfo->res3 += num_params * 0x4;
1429
1430 /* adjust size of VTBL */
1431 if(funckind != 0x3 /* FUNC_STATIC */)
1432 typeinfo->typeinfo->cbSizeVft += 4;
1433
1434 /* Increment the number of function elements */
1435 typeinfo->typeinfo->cElement += 1;
1436
1437 namedata = typeinfo->typelib->typelib_segment_data[MSFT_SEG_NAME] + name_offset;
1438 if (*((INT *)namedata) == -1) {
1439 *((INT *)namedata) = typeinfo->typelib->typelib_typeinfo_offsets[typeinfo->typeinfo->typekind >> 16];
1440 if((typeinfo->typeinfo->typekind & 15) == TKIND_MODULE)
1441 namedata[9] |= 0x10;
1442 } else
1443 namedata[9] &= ~0x10;
1444
1445 if((typeinfo->typeinfo->typekind & 15) == TKIND_MODULE)
1446 namedata[9] |= 0x20;
1447
1448 if(invokekind != 0x4 /* INVOKE_PROPERTYPUT */ && invokekind != 0x8 /* INVOKE_PROPERTYPUTREF */) {
1449 /* don't give the arg of a [propput*] func a name */
1450 for (arg = last_arg, i = 0; arg; arg = PREV_LINK(arg), i++) {
1451 int *paramdata = typedata + 6 + extra_attr + (num_defaults ? num_params : 0) + i * 3;
1452 offset = ctl2_alloc_name(typeinfo->typelib, arg->name);
1453 paramdata[1] = offset;
1454 }
1455 }
1456 return S_OK;
1457 }
1458
1459 static HRESULT add_var_desc(msft_typeinfo_t *typeinfo, UINT index, var_t* var)
1460 {
1461 int offset, id;
1462 unsigned int typedata_size;
1463 INT *typedata;
1464 int var_datawidth;
1465 int var_alignment;
1466 int var_type_size, var_kind = 0 /* VAR_PERINSTANCE */;
1467 int alignment;
1468 int varflags = 0;
1469 attr_t *attr;
1470 char *namedata;
1471 int var_num = (typeinfo->typeinfo->cElement >> 16) & 0xffff;
1472
1473 chat("add_var_desc(%d,%s) array %p\n", index, var->name, var->array);
1474
1475 id = 0x40000000 + index;
1476
1477 for(attr = var->attrs; attr; attr = NEXT_LINK(attr)) {
1478 expr_t *expr = attr->u.pval;
1479 switch(attr->type) {
1480 case ATTR_HIDDEN:
1481 varflags |= 0x40; /* VARFLAG_FHIDDEN */
1482 break;
1483 case ATTR_ID:
1484 id = expr->u.lval;
1485 break;
1486 case ATTR_READONLY:
1487 varflags |= 0x01; /* VARFLAG_FREADONLY */
1488 break;
1489 case ATTR_RESTRICTED:
1490 varflags |= 0x80; /* VARFLAG_FRESTRICTED */
1491 break;
1492 case ATTR_SOURCE:
1493 varflags |= 0x02; /* VARFLAG_FSOURCE */
1494 break;
1495 default:
1496 warning("AddVarDesc: unhandled attr type %d\n", attr->type);
1497 break;
1498 }
1499 }
1500
1501 /* allocate type data space for us */
1502 typedata_size = 0x14;
1503
1504 if (!typeinfo->var_data) {
1505 typeinfo->var_data = xmalloc(0x100);
1506 typeinfo->var_data_allocated = 0x100;
1507 typeinfo->var_data[0] = 0;
1508 }
1509
1510 if(typeinfo->var_data[0] + typedata_size + sizeof(int) > typeinfo->var_data_allocated) {
1511 typeinfo->var_data_allocated = max(typeinfo->var_data_allocated * 2,
1512 typeinfo->var_data[0] + typedata_size + sizeof(int));
1513 typeinfo->var_data = xrealloc(typeinfo->var_data, typeinfo->var_data_allocated);
1514 }
1515
1516 offset = typeinfo->var_data[0];
1517 typeinfo->var_data[0] += typedata_size;
1518 typedata = typeinfo->var_data + (offset >> 2) + 1;
1519
1520 /* fill out the basic type information */
1521 typedata[0] = typedata_size | (index << 16);
1522 typedata[2] = varflags;
1523 typedata[3] = (36 /*sizeof(VARDESC)*/ << 16) | 0;
1524
1525 if(typeinfo->vars_allocated == 0) {
1526 typeinfo->vars_allocated = 10;
1527 typeinfo->var_indices = xmalloc(typeinfo->vars_allocated * sizeof(int));
1528 typeinfo->var_names = xmalloc(typeinfo->vars_allocated * sizeof(int));
1529 typeinfo->var_offsets = xmalloc(typeinfo->vars_allocated * sizeof(int));
1530 }
1531 if(typeinfo->vars_allocated == var_num) {
1532 typeinfo->vars_allocated *= 2;
1533 typeinfo->var_indices = xrealloc(typeinfo->var_indices, typeinfo->vars_allocated * sizeof(int));
1534 typeinfo->var_names = xrealloc(typeinfo->var_names, typeinfo->vars_allocated * sizeof(int));
1535 typeinfo->var_offsets = xrealloc(typeinfo->var_offsets, typeinfo->vars_allocated * sizeof(int));
1536 }
1537 /* update the index data */
1538 typeinfo->var_indices[var_num] = id;
1539 typeinfo->var_names[var_num] = -1;
1540 typeinfo->var_offsets[var_num] = offset;
1541
1542 /* figure out type widths and whatnot */
1543 encode_var(typeinfo->typelib, var, &typedata[1], &var_datawidth,
1544 &var_alignment, &var_type_size);
1545
1546 /* pad out starting position to data width */
1547 typeinfo->datawidth += var_alignment - 1;
1548 typeinfo->datawidth &= ~(var_alignment - 1);
1549
1550 switch(typeinfo->typeinfo->typekind & 0xf) {
1551 case TKIND_ENUM:
1552 write_value(typeinfo->typelib, &typedata[4], VT_I4, &var->lval);
1553 var_kind = 2; /* VAR_CONST */
1554 var_type_size += 16; /* sizeof(VARIANT) */
1555 typeinfo->datawidth = var_datawidth;
1556 break;
1557 case TKIND_RECORD:
1558 typedata[4] = typeinfo->datawidth;
1559 typeinfo->datawidth += var_datawidth;
1560 break;
1561 case TKIND_DISPATCH:
1562 var_kind = 3; /* VAR_DISPATCH */
1563 typeinfo->datawidth = 4;
1564 var_alignment = 4;
1565 break;
1566 default:
1567 error("add_var_desc: unhandled type kind %d\n", typeinfo->typeinfo->typekind & 0xf);
1568 break;
1569 }
1570
1571 /* add type description size to total required allocation */
1572 typedata[3] += var_type_size << 16 | var_kind;
1573
1574 /* fix type alignment */
1575 alignment = (typeinfo->typeinfo->typekind >> 11) & 0x1f;
1576 if (alignment < var_alignment) {
1577 alignment = var_alignment;
1578 typeinfo->typeinfo->typekind &= ~0xffc0;
1579 typeinfo->typeinfo->typekind |= alignment << 11 | alignment << 6;
1580 }
1581
1582 /* ??? */
1583 if (!typeinfo->typeinfo->res2) typeinfo->typeinfo->res2 = 0x1a;
1584 if ((index == 0) || (index == 1) || (index == 2) || (index == 4) || (index == 9)) {
1585 typeinfo->typeinfo->res2 <<= 1;
1586 }
1587
1588 /* ??? */
1589 if (typeinfo->typeinfo->res3 == -1) typeinfo->typeinfo->res3 = 0;
1590 typeinfo->typeinfo->res3 += 0x2c;
1591
1592 /* increment the number of variable elements */
1593 typeinfo->typeinfo->cElement += 0x10000;
1594
1595 /* pad data width to alignment */
1596 typeinfo->typeinfo->size = (typeinfo->datawidth + (alignment - 1)) & ~(alignment - 1);
1597
1598 offset = ctl2_alloc_name(typeinfo->typelib, var->name);
1599 if (offset == -1) return E_OUTOFMEMORY;
1600
1601 namedata = typeinfo->typelib->typelib_segment_data[MSFT_SEG_NAME] + offset;
1602 if (*((INT *)namedata) == -1) {
1603 *((INT *)namedata) = typeinfo->typelib->typelib_typeinfo_offsets[typeinfo->typeinfo->typekind >> 16];
1604 if((typeinfo->typeinfo->typekind & 15) != TKIND_DISPATCH)
1605 namedata[9] |= 0x10;
1606 } else
1607 namedata[9] &= ~0x10;
1608
1609 if ((typeinfo->typeinfo->typekind & 15) == TKIND_ENUM) {
1610 namedata[9] |= 0x20;
1611 }
1612 typeinfo->var_names[var_num] = offset;
1613
1614 return S_OK;
1615 }
1616
1617 static HRESULT add_impl_type(msft_typeinfo_t *typeinfo, type_t *ref)
1618 {
1619 if(ref->typelib_idx == -1)
1620 add_interface_typeinfo(typeinfo->typelib, ref);
1621 if(ref->typelib_idx == -1)
1622 error("add_impl_type: unable to add inherited interface\n");
1623
1624 typeinfo->typeinfo->datatype1 = typeinfo->typelib->typelib_typeinfo_offsets[ref->typelib_idx];
1625 typeinfo->typeinfo->cImplTypes++;
1626 return S_OK;
1627 }
1628
1629 static msft_typeinfo_t *create_msft_typeinfo(msft_typelib_t *typelib, enum type_kind kind,
1630 char *name, attr_t *attr, int idx)
1631 {
1632 msft_typeinfo_t *msft_typeinfo;
1633 int nameoffset;
1634 int typeinfo_offset;
1635 MSFT_TypeInfoBase *typeinfo;
1636 MSFT_GuidEntry guidentry;
1637
1638 chat("create_msft_typeinfo: name %s kind %d\n", name, kind);
1639
1640 msft_typeinfo = xmalloc(sizeof(*msft_typeinfo));
1641
1642 msft_typeinfo->typelib = typelib;
1643
1644 nameoffset = ctl2_alloc_name(typelib, name);
1645 typeinfo_offset = ctl2_alloc_typeinfo(typelib, nameoffset);
1646 typeinfo = (MSFT_TypeInfoBase *)&typelib->typelib_segment_data[MSFT_SEG_TYPEINFO][typeinfo_offset];
1647
1648 typelib->typelib_segment_data[MSFT_SEG_NAME][nameoffset + 9] = 0x38;
1649 *((int *)&typelib->typelib_segment_data[MSFT_SEG_NAME][nameoffset]) = typeinfo_offset;
1650
1651 msft_typeinfo->typeinfo = typeinfo;
1652
1653 typeinfo->typekind |= kind | 0x20;
1654
1655 if(kind == TKIND_COCLASS)
1656 typeinfo->flags |= 0x2; /* TYPEFLAG_FCANCREATE */
1657
1658 for( ; attr; attr = NEXT_LINK(attr)) {
1659 switch(attr->type) {
1660 case ATTR_DISPINTERFACE:
1661 break;
1662
1663 case ATTR_DLLNAME:
1664 {
1665 int offset = ctl2_alloc_string(typelib, attr->u.pval);
1666 typeinfo->datatype1 = offset;
1667 break;
1668 }
1669 case ATTR_HELPCONTEXT:
1670 {
1671 expr_t *expr = (expr_t*)attr->u.pval;
1672 typeinfo->helpcontext = expr->cval;
1673 break;
1674 }
1675 case ATTR_HELPSTRING:
1676 {
1677 int offset = ctl2_alloc_string(typelib, attr->u.pval);
1678 if (offset == -1) break;
1679 typeinfo->docstringoffs = offset;
1680 break;
1681 }
1682 case ATTR_HELPSTRINGCONTEXT:
1683 {
1684 expr_t *expr = (expr_t*)attr->u.pval;
1685 typeinfo->helpstringcontext = expr->cval;
1686 break;
1687 }
1688 case ATTR_HIDDEN:
1689 typeinfo->flags |= 0x10; /* TYPEFLAG_FHIDDEN */
1690 break;
1691
1692 case ATTR_NONCREATABLE:
1693 typeinfo->flags &= ~0x2; /* TYPEFLAG_FCANCREATE */
1694 break;
1695
1696 case ATTR_ODL:
1697 break;
1698
1699 case ATTR_PUBLIC:
1700 break;
1701
1702 case ATTR_RESTRICTED:
1703 typeinfo->flags |= 0x200; /* TYPEFLAG_FRESTRICTED */
1704 break;
1705
1706 case ATTR_UUID:
1707 guidentry.guid = *(GUID*)attr->u.pval;
1708 guidentry.hreftype = typelib->typelib_typeinfo_offsets[typeinfo->typekind >> 16];
1709 guidentry.next_hash = -1;
1710 typeinfo->posguid = ctl2_alloc_guid(typelib, &guidentry);
1711 #if 0
1712 if (IsEqualIID(guid, &IID_IDispatch)) {
1713 typelib->typelib_header.dispatchpos = typelib->typelib_typeinfo_offsets[typeinfo->typekind >> 16];
1714 }
1715 #endif
1716 break;
1717
1718 case ATTR_VERSION:
1719 typeinfo->version = attr->u.ival;
1720 break;
1721
1722 default:
1723 warning("create_msft_typeinfo: ignoring attr %d\n", attr->type);
1724 break;
1725 }
1726 }
1727
1728 if (typelib->last_typeinfo) typelib->last_typeinfo->next_typeinfo = msft_typeinfo;
1729 typelib->last_typeinfo = msft_typeinfo;
1730 if (!typelib->typeinfos) typelib->typeinfos = msft_typeinfo;
1731
1732
1733 return msft_typeinfo;
1734 }
1735
1736 static void add_dispatch(msft_typelib_t *typelib)
1737 {
1738 int guid_offset, impfile_offset;
1739 MSFT_GuidEntry guidentry;
1740 MSFT_ImpInfo impinfo;
1741 GUID stdole = {0x00020430,0x0000,0x0000,{0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
1742 GUID iid_idispatch = {0x00020400,0x0000,0x0000,{0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
1743
1744 if(typelib->typelib_header.dispatchpos != -1) return;
1745
1746 guidentry.guid = stdole;
1747 guidentry.hreftype = 2;
1748 guidentry.next_hash = -1;
1749 guid_offset = ctl2_alloc_guid(typelib, &guidentry);
1750 impfile_offset = alloc_importfile(typelib, guid_offset, 2, 0, "stdole2.tlb");
1751
1752 guidentry.guid = iid_idispatch;
1753 guidentry.hreftype = 1;
1754 guidentry.next_hash = -1;
1755 impinfo.flags = TKIND_INTERFACE << 24 | MSFT_IMPINFO_OFFSET_IS_GUID;
1756 impinfo.oImpFile = impfile_offset;
1757 impinfo.oGuid = ctl2_alloc_guid(typelib, &guidentry);
1758 typelib->typelib_header.dispatchpos = alloc_importinfo(typelib, &impinfo) | 0x01;
1759
1760 typelib->typelib_header.res50 = 1;
1761
1762 }
1763
1764 static void add_dispinterface_typeinfo(msft_typelib_t *typelib, type_t *dispinterface)
1765 {
1766 int idx = 0;
1767 func_t *func;
1768 var_t *var;
1769 msft_typeinfo_t *msft_typeinfo;
1770
1771 dispinterface->typelib_idx = typelib->typelib_header.nrtypeinfos;
1772 msft_typeinfo = create_msft_typeinfo(typelib, TKIND_DISPATCH, dispinterface->name,
1773 dispinterface->attrs, typelib->typelib_header.nrtypeinfos);
1774
1775 msft_typeinfo->typeinfo->size = 4;
1776 msft_typeinfo->typeinfo->typekind |= 0x2100;
1777
1778 msft_typeinfo->typeinfo->flags |= 0x1000; /* TYPEFLAG_FDISPATCHABLE */
1779 add_dispatch(typelib);
1780 msft_typeinfo->typeinfo->cImplTypes = 1;
1781
1782 /* count the no of funcs, as the variable indicies come after the funcs */
1783 if((func = dispinterface->funcs)) {
1784 idx++;
1785 while(NEXT_LINK(func)) {
1786 func = NEXT_LINK(func);
1787 idx++;
1788 }
1789 }
1790
1791 if((var = dispinterface->fields)) {
1792 while(NEXT_LINK(var)) var = NEXT_LINK(var);
1793 while(var) {
1794 add_var_desc(msft_typeinfo, idx, var);
1795 idx++;
1796 var = PREV_LINK(var);
1797 }
1798 }
1799
1800 idx = 0;
1801 /* the func count above has already left us pointing at the first func */
1802 while(func) {
1803 if(add_func_desc(msft_typeinfo, func, idx) == S_OK)
1804 idx++;
1805 func = PREV_LINK(func);
1806 }
1807 }
1808
1809 static void add_interface_typeinfo(msft_typelib_t *typelib, type_t *interface)
1810 {
1811 int idx = 0;
1812 func_t *func;
1813 type_t *ref;
1814 msft_typeinfo_t *msft_typeinfo;
1815 int num_parents = 0, num_funcs = 0;
1816 attr_t *attr;
1817
1818 for(attr = interface->attrs; attr; attr = NEXT_LINK(attr))
1819 if(attr->type == ATTR_DISPINTERFACE)
1820 return add_dispinterface_typeinfo(typelib, interface);
1821
1822 /* midl adds the parent interface first, unless the parent itself
1823 has no parent (i.e. it stops before IUnknown). */
1824
1825 if(interface->ref && interface->ref->ref && interface->ref->typelib_idx == -1)
1826 add_interface_typeinfo(typelib, interface->ref);
1827
1828 interface->typelib_idx = typelib->typelib_header.nrtypeinfos;
1829 msft_typeinfo = create_msft_typeinfo(typelib, TKIND_INTERFACE, interface->name, interface->attrs,
1830 typelib->typelib_header.nrtypeinfos);
1831 msft_typeinfo->typeinfo->size = 4;
1832 msft_typeinfo->typeinfo->typekind |= 0x2200;
1833
1834 if(interface->ref)
1835 add_impl_type(msft_typeinfo, interface->ref);
1836
1837 /* count the number of inherited interfaces and non-local functions */
1838 for(ref = interface->ref; ref; ref = ref->ref) {
1839 num_parents++;
1840 for(func = ref->funcs; func; func = NEXT_LINK(func)) {
1841 attr_t *attr;
1842 for(attr = func->def->attrs; attr; attr = NEXT_LINK(attr))
1843 if(attr->type == ATTR_LOCAL)
1844 break;
1845 if(!attr)
1846 num_funcs++;
1847 }
1848 }
1849 msft_typeinfo->typeinfo->datatype2 = num_funcs << 16 | num_parents;
1850 msft_typeinfo->typeinfo->cbSizeVft = num_funcs * 4;
1851
1852 if((func = interface->funcs)) {
1853 while(NEXT_LINK(func)) func = NEXT_LINK(func);
1854 while(func) {
1855 if(add_func_desc(msft_typeinfo, func, idx) == S_OK)
1856 idx++;
1857 func = PREV_LINK(func);
1858 }
1859 }
1860 }
1861
1862 static void add_structure_typeinfo(msft_typelib_t *typelib, type_t *structure)
1863 {
1864 int idx = 0;
1865 var_t *cur = structure->fields;
1866 msft_typeinfo_t *msft_typeinfo;
1867
1868 structure->typelib_idx = typelib->typelib_header.nrtypeinfos;
1869 msft_typeinfo = create_msft_typeinfo(typelib, TKIND_RECORD, structure->name, structure->attrs,
1870 typelib->typelib_header.nrtypeinfos);
1871 msft_typeinfo->typeinfo->size = 0;
1872
1873 while(NEXT_LINK(cur)) cur = NEXT_LINK(cur);
1874 while(cur) {
1875 add_var_desc(msft_typeinfo, idx, cur);
1876 idx++;
1877 cur = PREV_LINK(cur);
1878 }
1879 }
1880
1881 static void add_enum_typeinfo(msft_typelib_t *typelib, type_t *enumeration)
1882 {
1883 int idx = 0;
1884 var_t *cur = enumeration->fields;
1885 msft_typeinfo_t *msft_typeinfo;
1886
1887 enumeration->typelib_idx = typelib->typelib_header.nrtypeinfos;
1888 msft_typeinfo = create_msft_typeinfo(typelib, TKIND_ENUM, enumeration->name, enumeration->attrs,
1889 typelib->typelib_header.nrtypeinfos);
1890 msft_typeinfo->typeinfo->size = 0;
1891
1892 while(NEXT_LINK(cur)) cur = NEXT_LINK(cur);
1893 while(cur) {
1894 add_var_desc(msft_typeinfo, idx, cur);
1895 idx++;
1896 cur = PREV_LINK(cur);
1897 }
1898 }
1899
1900 static void add_typedef_typeinfo(msft_typelib_t *typelib, var_t *tdef)
1901 {
1902 msft_typeinfo_t *msft_typeinfo;
1903 int alignment;
1904 attr_t *attrs;
1905
1906 tdef->type->typelib_idx = typelib->typelib_header.nrtypeinfos;
1907 msft_typeinfo = create_msft_typeinfo(typelib, TKIND_ALIAS, tdef->name, tdef->type->attrs,
1908 typelib->typelib_header.nrtypeinfos);
1909 attrs = tdef->type->attrs;
1910 tdef->type->attrs = NULL;
1911 encode_var(typelib, tdef, &msft_typeinfo->typeinfo->datatype1, &msft_typeinfo->typeinfo->size,
1912 &alignment, &msft_typeinfo->typeinfo->datatype2);
1913 tdef->type->attrs = attrs;
1914 msft_typeinfo->typeinfo->typekind |= (alignment << 11 | alignment << 6);
1915 }
1916
1917 static void add_coclass_typeinfo(msft_typelib_t *typelib, class_t *cls)
1918 {
1919 msft_typeinfo_t *msft_typeinfo;
1920 ifref_t *iref;
1921 int num_ifaces = 0, offset, i;
1922 MSFT_RefRecord *ref, *first = NULL, *first_source = NULL;
1923 int have_default = 0, have_default_source = 0;
1924 attr_t *attr;
1925
1926 msft_typeinfo = create_msft_typeinfo(typelib, TKIND_COCLASS, cls->name, cls->attrs,
1927 typelib->typelib_header.nrtypeinfos);
1928
1929 if((iref = cls->ifaces)) {
1930 num_ifaces++;
1931 while(NEXT_LINK(iref)) {
1932 iref = NEXT_LINK(iref);
1933 num_ifaces++;
1934 }
1935 }
1936
1937 offset = msft_typeinfo->typeinfo->datatype1 = ctl2_alloc_segment(typelib, MSFT_SEG_REFERENCES,
1938 num_ifaces * sizeof(*ref), 0);
1939 for(i = 0; i < num_ifaces; i++) {
1940 if(iref->iface->typelib_idx == -1)
1941 add_interface_typeinfo(typelib, iref->iface);
1942 ref = (MSFT_RefRecord*) (typelib->typelib_segment_data[MSFT_SEG_REFERENCES] + offset + i * sizeof(*ref));
1943 ref->reftype = typelib->typelib_typeinfo_offsets[iref->iface->typelib_idx];
1944 ref->flags = 0;
1945 ref->oCustData = -1;
1946 ref->onext = -1;
1947 if(i < num_ifaces - 1)
1948 ref->onext = offset + (i + 1) * sizeof(*ref);
1949
1950 for(attr = iref->attrs; attr; attr = NEXT_LINK(attr)) {
1951 switch(attr->type) {
1952 case ATTR_DEFAULT:
1953 ref->flags |= 0x1; /* IMPLTYPEFLAG_FDEFAULT */
1954 break;
1955 case ATTR_RESTRICTED:
1956 ref->flags |= 0x4; /* IMPLTYPEFLAG_FRESTRICTED */
1957 break;
1958 case ATTR_SOURCE:
1959 ref->flags |= 0x2; /* IMPLTYPEFLAG_FSOURCE */
1960 break;
1961 default:
1962 warning("add_coclass_typeinfo: unhandled attr %d\n", attr->type);
1963 }
1964 }
1965 if(ref->flags & 0x1) { /* IMPLTYPEFLAG_FDEFAULT */
1966 if(ref->flags & 0x2) /* IMPLTYPEFLAG_SOURCE */
1967 have_default_source = 1;
1968 else
1969 have_default = 1;
1970 }
1971
1972 /* If the interface is non-restricted and we haven't already had one then
1973 remember it so that we can use it as a default later */
1974 if((ref->flags & 0x4) == 0) { /* IMPLTYPEFLAG_FRESTRICTED */
1975 if(ref->flags & 0x2) { /* IMPLTYPEFLAG_FSOURCE */
1976 if(!first_source)
1977 first_source = ref;
1978 }
1979 else if(!first)
1980 first = ref;
1981 }
1982 iref = PREV_LINK(iref);
1983 }
1984
1985 /* If we haven't had a default interface, then set the default flags on the
1986 first ones */
1987 if(!have_default && first)
1988 first->flags |= 0x1;
1989 if(!have_default_source && first_source)
1990 first_source->flags |= 0x1;
1991
1992 msft_typeinfo->typeinfo->cImplTypes = num_ifaces;
1993 msft_typeinfo->typeinfo->size = 4;
1994 msft_typeinfo->typeinfo->typekind |= 0x2200;
1995 }
1996
1997 static void add_module_typeinfo(msft_typelib_t *typelib, type_t *module)
1998 {
1999 int idx = 0;
2000 func_t *func;
2001 msft_typeinfo_t *msft_typeinfo;
2002
2003 module->typelib_idx = typelib->typelib_header.nrtypeinfos;
2004 msft_typeinfo = create_msft_typeinfo(typelib, TKIND_MODULE, module->name, module->attrs,
2005 typelib->typelib_header.nrtypeinfos);
2006 msft_typeinfo->typeinfo->typekind |= 0x0a00;
2007
2008 if((func = module->funcs)) {
2009 while(NEXT_LINK(func)) func = NEXT_LINK(func);
2010 while(func) {
2011 if(add_func_desc(msft_typeinfo, func, idx) == S_OK)
2012 idx++;
2013 func = PREV_LINK(func);
2014 }
2015 }
2016 msft_typeinfo->typeinfo->size = idx;
2017 }
2018
2019 static void add_entry(msft_typelib_t *typelib, typelib_entry_t *entry)
2020 {
2021 switch(entry->kind) {
2022 case TKIND_INTERFACE:
2023 add_interface_typeinfo(typelib, entry->u.interface);
2024 break;
2025
2026 case TKIND_RECORD:
2027 add_structure_typeinfo(typelib, entry->u.structure);
2028 break;
2029
2030 case TKIND_ENUM:
2031 add_enum_typeinfo(typelib, entry->u.enumeration);
2032 break;
2033
2034 case TKIND_ALIAS:
2035 add_typedef_typeinfo(typelib, entry->u.tdef);
2036 break;
2037
2038 case TKIND_COCLASS:
2039 add_coclass_typeinfo(typelib, entry->u.class);
2040 break;
2041
2042 case TKIND_MODULE:
2043 add_module_typeinfo(typelib, entry->u.module);
2044 break;
2045
2046 default:
2047 error("add_entry: unhandled type %d\n", entry->kind);
2048 break;
2049 }
2050 }
2051
2052 static void set_name(msft_typelib_t *typelib)
2053 {
2054 int offset;
2055
2056 offset = ctl2_alloc_name(typelib, typelib->typelib->name);
2057 if (offset == -1) return;
2058 typelib->typelib_header.NameOffset = offset;
2059 return;
2060 }
2061
2062 static void set_version(msft_typelib_t *typelib)
2063 {
2064 long version = MAKELONG(0,0);
2065 attr_t *attr;
2066
2067 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
2068 if(attr->type == ATTR_VERSION) {
2069 version = attr->u.ival;
2070 }
2071 }
2072 typelib->typelib_header.version = version;
2073 return;
2074 }
2075
2076 static void set_guid(msft_typelib_t *typelib)
2077 {
2078 MSFT_GuidEntry guidentry;
2079 int offset;
2080 attr_t *attr;
2081 GUID guid = {0,0,0,{0,0,0,0,0,0}};
2082
2083 guidentry.guid = guid;
2084 guidentry.hreftype = -2;
2085 guidentry.next_hash = -1;
2086
2087 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
2088 if(attr->type == ATTR_UUID) {
2089 guidentry.guid = *(GUID*)(attr->u.pval);
2090 }
2091 }
2092
2093 offset = ctl2_alloc_guid(typelib, &guidentry);
2094
2095 if (offset == -1) return;
2096
2097 typelib->typelib_header.posguid = offset;
2098
2099 return;
2100 }
2101
2102 static void set_doc_string(msft_typelib_t *typelib)
2103 {
2104 attr_t *attr;
2105 int offset;
2106
2107 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
2108 if(attr->type == ATTR_HELPSTRING) {
2109 offset = ctl2_alloc_string(typelib, attr->u.pval);
2110 if (offset == -1) return;
2111 typelib->typelib_header.helpstring = offset;
2112 }
2113 }
2114 return;
2115 }
2116
2117 static void set_help_file_name(msft_typelib_t *typelib)
2118 {
2119 int offset;
2120 attr_t *attr;
2121 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
2122 if(attr->type == ATTR_HELPFILE) {
2123 offset = ctl2_alloc_string(typelib, attr->u.pval);
2124 if (offset == -1) return;
2125 typelib->typelib_header.helpfile = offset;
2126 typelib->typelib_header.varflags |= 0x10;
2127 }
2128 }
2129 return;
2130 }
2131
2132 static void set_help_context(msft_typelib_t *typelib)
2133 {
2134 attr_t *attr;
2135 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
2136 if(attr->type == ATTR_HELPCONTEXT) {
2137 expr_t *expr = (expr_t *)attr->u.pval;
2138 typelib->typelib_header.helpcontext = expr->cval;
2139 }
2140 }
2141 return;
2142 }
2143
2144 static void set_help_string_dll(msft_typelib_t *typelib)
2145 {
2146 int offset;
2147 attr_t *attr;
2148 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
2149 if(attr->type == ATTR_HELPSTRINGDLL) {
2150 offset = ctl2_alloc_string(typelib, attr->u.pval);
2151 if (offset == -1) return;
2152 typelib->help_string_dll_offset = offset;
2153 typelib->typelib_header.varflags |= 0x100;
2154 }
2155 }
2156 return;
2157 }
2158
2159 static void set_help_string_context(msft_typelib_t *typelib)
2160 {
2161 attr_t *attr;
2162 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
2163 if(attr->type == ATTR_HELPSTRINGCONTEXT) {
2164 expr_t *expr = (expr_t *)attr->u.pval;
2165 typelib->typelib_header.helpstringcontext = expr->cval;
2166 }
2167 }
2168 return;
2169 }
2170
2171 static void set_lcid(msft_typelib_t *typelib)
2172 {
2173 typelib->typelib_header.lcid2 = 0x0;
2174 return;
2175 }
2176
2177 static void set_lib_flags(msft_typelib_t *typelib)
2178 {
2179 attr_t *attr;
2180
2181 typelib->typelib_header.flags = 0;
2182 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
2183 switch(attr->type) {
2184 case ATTR_CONTROL:
2185 typelib->typelib_header.flags |= 0x02; /* LIBFLAG_FCONTROL */
2186 break;
2187 case ATTR_HIDDEN:
2188 typelib->typelib_header.flags |= 0x04; /* LIBFLAG_FHIDDEN */
2189 break;
2190 case ATTR_RESTRICTED:
2191 typelib->typelib_header.flags |= 0x01; /* LIBFLAG_FRESTRICTED */
2192 break;
2193 default:
2194 break;
2195 }
2196 }
2197 return;
2198 }
2199
2200 static int ctl2_write_chunk(int fd, void *segment, int length)
2201 {
2202 if (write(fd, segment, length) != length) {
2203 close(fd);
2204 return 0;
2205 }
2206 return -1;
2207 }
2208
2209 static int ctl2_write_segment(msft_typelib_t *typelib, int fd, int segment)
2210 {
2211 if (write(fd, typelib->typelib_segment_data[segment], typelib->typelib_segdir[segment].length)
2212 != typelib->typelib_segdir[segment].length) {
2213 close(fd);
2214 return 0;
2215 }
2216
2217 return -1;
2218 }
2219
2220 static void ctl2_finalize_typeinfos(msft_typelib_t *typelib, int filesize)
2221 {
2222 msft_typeinfo_t *typeinfo;
2223
2224 for (typeinfo = typelib->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
2225 typeinfo->typeinfo->memoffset = filesize;
2226 if (typeinfo->func_data)
2227 filesize += typeinfo->func_data[0] + ((typeinfo->typeinfo->cElement & 0xffff) * 12);
2228 if (typeinfo->var_data)
2229 filesize += typeinfo->var_data[0] + (((typeinfo->typeinfo->cElement >> 16) & 0xffff) * 12);
2230 if (typeinfo->func_data || typeinfo->var_data)
2231 filesize += 4;
2232 }
2233 }
2234
2235 static int ctl2_finalize_segment(msft_typelib_t *typelib, int filepos, int segment)
2236 {
2237 if (typelib->typelib_segdir[segment].length) {
2238 typelib->typelib_segdir[segment].offset = filepos;
2239 } else {
2240 typelib->typelib_segdir[segment].offset = -1;
2241 }
2242
2243 return typelib->typelib_segdir[segment].length;
2244 }
2245
2246
2247 static void ctl2_write_typeinfos(msft_typelib_t *typelib, int fd)
2248 {
2249 msft_typeinfo_t *typeinfo;
2250 int typedata_size;
2251
2252 for (typeinfo = typelib->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
2253 if (!typeinfo->func_data && !typeinfo->var_data) continue;
2254 typedata_size = 0;
2255 if (typeinfo->func_data)
2256 typedata_size = typeinfo->func_data[0];
2257 if (typeinfo->var_data)
2258 typedata_size += typeinfo->var_data[0];
2259 ctl2_write_chunk(fd, &typedata_size, sizeof(int));
2260 if (typeinfo->func_data)
2261 ctl2_write_chunk(fd, typeinfo->func_data + 1, typeinfo->func_data[0]);
2262 if (typeinfo->var_data)
2263 ctl2_write_chunk(fd, typeinfo->var_data + 1, typeinfo->var_data[0]);
2264 if (typeinfo->func_indices)
2265 ctl2_write_chunk(fd, typeinfo->func_indices, (typeinfo->typeinfo->cElement & 0xffff) * 4);
2266 if (typeinfo->var_indices)
2267 ctl2_write_chunk(fd, typeinfo->var_indices, (typeinfo->typeinfo->cElement >> 16) * 4);
2268 if (typeinfo->func_names)
2269 ctl2_write_chunk(fd, typeinfo->func_names, (typeinfo->typeinfo->cElement & 0xffff) * 4);
2270 if (typeinfo->var_names)
2271 ctl2_write_chunk(fd, typeinfo->var_names, (typeinfo->typeinfo->cElement >> 16) * 4);
2272 if (typeinfo->func_offsets)
2273 ctl2_write_chunk(fd, typeinfo->func_offsets, (typeinfo->typeinfo->cElement & 0xffff) * 4);
2274 if (typeinfo->var_offsets) {
2275 int add = 0, i, offset;
2276 if(typeinfo->func_data)
2277 add = typeinfo->func_data[0];
2278 for(i = 0; i < (typeinfo->typeinfo->cElement >> 16); i++) {
2279 offset = typeinfo->var_offsets[i];
2280 offset += add;
2281 ctl2_write_chunk(fd, &offset, 4);
2282 }
2283 }
2284 }
2285 }
2286
2287 static int save_all_changes(msft_typelib_t *typelib)
2288 {
2289 int retval;
2290 int filepos;
2291 int fd;
2292
2293 chat("save_all_changes(%p)\n", typelib);
2294
2295 retval = TYPE_E_IOERROR;
2296
2297 fd = creat(typelib->typelib->filename, 0666);
2298 if (fd == -1) return retval;
2299
2300 filepos = sizeof(MSFT_Header) + sizeof(MSFT_SegDir);
2301 if(typelib->typelib_header.varflags & 0x100) filepos += 4; /* helpstringdll */
2302 filepos += typelib->typelib_header.nrtypeinfos * 4;
2303
2304 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_TYPEINFO);
2305 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_GUIDHASH);
2306 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_GUID);
2307 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_IMPORTINFO);
2308 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_IMPORTFILES);
2309 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_REFERENCES);
2310 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_NAMEHASH);
2311 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_NAME);
2312 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_STRING);
2313 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_TYPEDESC);
2314 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_ARRAYDESC);
2315 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_CUSTDATA);
2316 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_CUSTDATAGUID);
2317
2318 ctl2_finalize_typeinfos(typelib, filepos);
2319
2320 if (!ctl2_write_chunk(fd, &typelib->typelib_header, sizeof(typelib->typelib_header))) return retval;
2321 if(typelib->typelib_header.varflags & 0x100)
2322 if (!ctl2_write_chunk(fd, &typelib->help_string_dll_offset, sizeof(typelib->help_string_dll_offset)))
2323 return retval;
2324
2325 if (!ctl2_write_chunk(fd, typelib->typelib_typeinfo_offsets, typelib->typelib_header.nrtypeinfos * 4)) return retval;
2326 if (!ctl2_write_chunk(fd, &typelib->typelib_segdir, sizeof(typelib->typelib_segdir))) return retval;
2327 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_TYPEINFO )) return retval;
2328 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_GUIDHASH )) return retval;
2329 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_GUID )) return retval;
2330 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_IMPORTINFO )) return retval;
2331 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_IMPORTFILES )) return retval;
2332 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_REFERENCES )) return retval;
2333 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_NAMEHASH )) return retval;
2334 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_NAME )) return retval;
2335 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_STRING )) return retval;
2336 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_TYPEDESC )) return retval;
2337 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_ARRAYDESC )) return retval;
2338 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_CUSTDATA )) return retval;
2339 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_CUSTDATAGUID)) return retval;
2340
2341 ctl2_write_typeinfos(typelib, fd);
2342
2343 if (close(fd) == -1) return retval;
2344
2345 retval = S_OK;
2346 return retval;
2347 }
2348
2349 int create_msft_typelib(typelib_t *typelib)
2350 {
2351 msft_typelib_t *msft;
2352 int failed = 0;
2353 typelib_entry_t *entry;
2354 time_t cur_time;
2355 unsigned int version = 5 << 24 | 1 << 16 | 164; /* 5.01.0164 */
2356 GUID midl_time_guid = {0xde77ba63,0x517c,0x11d1,{0xa2,0xda,0x00,0x00,0xf8,0x77,0x3c,0xe9}};
2357 GUID midl_version_guid = {0xde77ba64,0x517c,0x11d1,{0xa2,0xda,0x00,0x00,0xf8,0x77,0x3c,0xe9}};
2358
2359 msft = malloc(sizeof(*msft));
2360 if (!msft) return 0;
2361 memset(msft, 0, sizeof(*msft));
2362 msft->typelib = typelib;
2363
2364 ctl2_init_header(msft);
2365 ctl2_init_segdir(msft);
2366
2367 msft->typelib_header.varflags |= SYS_WIN32;
2368
2369 /*
2370 * The following two calls return an offset or -1 if out of memory. We
2371 * specifically need an offset of 0, however, so...
2372 */
2373 if (ctl2_alloc_segment(msft, MSFT_SEG_GUIDHASH, 0x80, 0x80)) { failed = 1; }
2374 if (ctl2_alloc_segment(msft, MSFT_SEG_NAMEHASH, 0x200, 0x200)) { failed = 1; }
2375
2376 if(failed) return 0;
2377
2378 msft->typelib_guidhash_segment = (int *)msft->typelib_segment_data[MSFT_SEG_GUIDHASH];
2379 msft->typelib_namehash_segment = (int *)msft->typelib_segment_data[MSFT_SEG_NAMEHASH];
2380
2381 memset(msft->typelib_guidhash_segment, 0xff, 0x80);
2382 memset(msft->typelib_namehash_segment, 0xff, 0x200);
2383
2384 set_lib_flags(msft);
2385 set_lcid(msft);
2386 set_help_file_name(msft);
2387 set_doc_string(msft);
2388 set_guid(msft);
2389 set_version(msft);
2390 set_name(msft);
2391 set_help_context(msft);
2392 set_help_string_dll(msft);
2393 set_help_string_context(msft);
2394
2395 /* midl adds two sets of custom data to the library: the current unix time
2396 and midl's version number */
2397 cur_time = time(NULL);
2398 set_custdata(msft, &midl_time_guid, VT_UI4, &cur_time, &msft->typelib_header.CustomDataOffset);
2399 set_custdata(msft, &midl_version_guid, VT_UI4, &version, &msft->typelib_header.CustomDataOffset);
2400
2401 for(entry = typelib->entry; entry && NEXT_LINK(entry); entry = NEXT_LINK(entry))
2402 ;
2403
2404 for( ; entry; entry = PREV_LINK(entry))
2405 add_entry(msft, entry);
2406
2407 save_all_changes(msft);
2408 return 1;
2409 }
Quick hack tree for wine patches julliard doesn't want to commit