?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add support for dispinterfaces (slightly hacked because we force the
[wine/multimedia.git] / tools / widl / write_msft.c
bloba61b8c417956895cea10397700fb0fa5bb77a084
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]; /* preceeded 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 int var_data_allocated;
107 int *var_data;
108
109 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 = 4; /* guess? */
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 add_structure_typeinfo(typelib, type);
883 break;
884 case RPC_FC_IP:
885 add_interface_typeinfo(typelib, type);
886 break;
887 default:
888 error("encode_type: VT_USERDEFINED - unhandled type %d\n", type->type);
889 }
890 }
891
892 typeinfo_offset = typelib->typelib_typeinfo_offsets[type->typelib_idx];
893 for (typeoffset = 0; typeoffset < typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
894 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
895 if ((typedata[0] == ((0x7fff << 16) | VT_USERDEFINED)) && (typedata[1] == typeinfo_offset)) break;
896 }
897
898 if (typeoffset == typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length) {
899 typeoffset = ctl2_alloc_segment(typelib, MSFT_SEG_TYPEDESC, 8, 0);
900 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
901
902 typedata[0] = (0x7fff << 16) | VT_USERDEFINED;
903 typedata[1] = typeinfo_offset;
904 }
905
906 *encoded_type = typeoffset;
907 *width = 0;
908 *alignment = 1;
909
910 if(type->type == RPC_FC_IP) {
911 typeoffset = ctl2_alloc_segment(typelib, MSFT_SEG_TYPEDESC, 8, 0);
912 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
913
914 typedata[0] = (0x7fff << 16) | VT_PTR;
915 typedata[1] = *encoded_type;
916 *encoded_type = typeoffset;
917 *width = 4;
918 *alignment = 4;
919 *decoded_size += 8;
920 }
921 break;
922 }
923
924 default:
925 error("encode_type: unrecognized type %d.\n", vt);
926 *encoded_type = default_type;
927 *width = 0;
928 *alignment = 1;
929 break;
930 }
931
932 return 0;
933 }
934
935 static void dump_type(type_t *t)
936 {
937 chat("dump_type: %p name %s type %d ref %p rname %s\n", t, t->name, t->type, t->ref, t->rname);
938 if(t->ref) dump_type(t->ref);
939 }
940
941 static int encode_var(
942 msft_typelib_t *typelib, /* [I] The type library in which to encode the TYPEDESC. */
943 var_t *var, /* [I] The type description to encode. */
944 int *encoded_type, /* [O] The encoded type description. */
945 int *width, /* [O] The width of the type, or NULL. */
946 int *alignment, /* [O] The alignment of the type, or NULL. */
947 int *decoded_size) /* [O] The total size of the unencoded TYPEDESCs, including nested descs. */
948 {
949 int typeoffset;
950 int *typedata;
951 int target_type;
952 int child_size;
953 int vt;
954 int scratch;
955 type_t *type;
956
957 if (!width) width = &scratch;
958 if (!alignment) alignment = &scratch;
959 if (!decoded_size) decoded_size = &scratch;
960 *decoded_size = 0;
961
962 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);
963 if(var->ptr_level) {
964 int skip_ptr;
965 var->ptr_level--;
966 skip_ptr = encode_var(typelib, var, &target_type, NULL, NULL, &child_size);
967 var->ptr_level++;
968
969 if(skip_ptr == 2) {
970 chat("encode_var: skipping ptr\n");
971 *encoded_type = target_type;
972 *decoded_size = child_size;
973 *width = 4;
974 *alignment = 4;
975 return 0;
976 }
977
978 for (typeoffset = 0; typeoffset < typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
979 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
980 if (((typedata[0] & 0xffff) == VT_PTR) && (typedata[1] == target_type)) break;
981 }
982
983 if (typeoffset == typelib->typelib_segdir[MSFT_SEG_TYPEDESC].length) {
984 int mix_field;
985
986 if (target_type & 0x80000000) {
987 mix_field = ((target_type >> 16) & 0x3fff) | VT_BYREF;
988 } else {
989 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][target_type];
990 mix_field = ((typedata[0] >> 16) == 0x7fff)? 0x7fff: 0x7ffe;
991 }
992
993 typeoffset = ctl2_alloc_segment(typelib, MSFT_SEG_TYPEDESC, 8, 0);
994 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
995
996 typedata[0] = (mix_field << 16) | VT_PTR;
997 typedata[1] = target_type;
998 }
999
1000 *encoded_type = typeoffset;
1001
1002 *width = 4;
1003 *alignment = 4;
1004 *decoded_size = 8 /*sizeof(TYPEDESC)*/ + child_size;
1005 return 0;
1006 }
1007
1008 if(var->array) {
1009 expr_t *dim = var->array;
1010 expr_t *array_save;
1011 int num_dims = 1, elements = 1, arrayoffset;
1012 int *arraydata;
1013
1014 while(NEXT_LINK(dim)) {
1015 dim = NEXT_LINK(dim);
1016 num_dims++;
1017 }
1018 chat("array with %d dimensions\n", num_dims);
1019 array_save = var->array;
1020 var->array = NULL;
1021 encode_var(typelib, var, &target_type, width, alignment, NULL);
1022 var->array = array_save;
1023 arrayoffset = ctl2_alloc_segment(typelib, MSFT_SEG_ARRAYDESC, (2 + 2 * num_dims) * sizeof(long), 0);
1024 arraydata = (void *)&typelib->typelib_segment_data[MSFT_SEG_ARRAYDESC][arrayoffset];
1025
1026 arraydata[0] = target_type;
1027 arraydata[1] = num_dims;
1028 arraydata[1] |= ((num_dims * 2 * sizeof(long)) << 16);
1029
1030 arraydata += 2;
1031 while(dim) {
1032 arraydata[0] = dim->cval;
1033 arraydata[1] = 0;
1034 arraydata += 2;
1035 elements *= dim->cval;
1036 dim = PREV_LINK(dim);
1037 }
1038
1039 typeoffset = ctl2_alloc_segment(typelib, MSFT_SEG_TYPEDESC, 8, 0);
1040 typedata = (void *)&typelib->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1041
1042 typedata[0] = (0x7ffe << 16) | VT_CARRAY;
1043 typedata[1] = arrayoffset;
1044
1045 *encoded_type = typeoffset;
1046 *width = *width * elements;
1047 *decoded_size = 20 /*sizeof(ARRAYDESC)*/ + (num_dims - 1) * 8 /*sizeof(SAFEARRAYBOUND)*/;
1048 return 0;
1049 }
1050 dump_type(var->type);
1051
1052 vt = get_var_vt(var);
1053 type = var->type;
1054 while(!vt) {
1055 if(type->ref == NULL) {
1056 vt = VT_VOID;
1057 break;
1058 }
1059 type = type->ref;
1060 vt = get_type_vt(type);
1061 }
1062 encode_type(typelib, vt, type, encoded_type, width, alignment, decoded_size);
1063 if(type->type == RPC_FC_IP) return 2;
1064 return 0;
1065 }
1066
1067
1068 static void write_value(msft_typelib_t* typelib, int *out, int vt, void *value)
1069 {
1070 switch(vt) {
1071 case VT_I2:
1072 case VT_I4:
1073 case VT_R4:
1074 case VT_BOOL:
1075 case VT_I1:
1076 case VT_UI1:
1077 case VT_UI2:
1078 case VT_UI4:
1079 case VT_INT:
1080 case VT_UINT:
1081 case VT_HRESULT:
1082 {
1083 unsigned long *lv = value;
1084 if((*lv & 0x3ffffff) == *lv) {
1085 *out = 0x80000000;
1086 *out |= vt << 26;
1087 *out |= *lv;
1088 } else {
1089 int offset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATA, 8, 0);
1090 *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset]) = vt;
1091 memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+2], value, 4);
1092 *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+6]) = 0x5757;
1093 *out = offset;
1094 }
1095 return;
1096 }
1097 case VT_BSTR:
1098 {
1099 char *s = (char *) value;
1100 int len = strlen(s), seg_len = (len + 6 + 3) & ~0x3;
1101 int offset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATA, seg_len, 0);
1102 *((unsigned short *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset]) = vt;
1103 *((unsigned int *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+2]) = len;
1104 memcpy(&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+6], value, len);
1105 len += 6;
1106 while(len < seg_len) {
1107 *((char *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+len]) = 0x57;
1108 len++;
1109 }
1110 *out = offset;
1111 return;
1112 }
1113
1114 default:
1115 warning("can't write value of type %d yet\n", vt);
1116 }
1117 return;
1118 }
1119
1120 static HRESULT set_custdata(msft_typelib_t *typelib, REFGUID guid,
1121 int vt, void *value, int *offset)
1122 {
1123 MSFT_GuidEntry guidentry;
1124 int guidoffset;
1125 int custoffset;
1126 int *custdata;
1127 int data_out;
1128
1129 guidentry.guid = *guid;
1130
1131 guidentry.hreftype = -1;
1132 guidentry.next_hash = -1;
1133
1134 guidoffset = ctl2_alloc_guid(typelib, &guidentry);
1135 if (guidoffset == -1) return E_OUTOFMEMORY;
1136 write_value(typelib, &data_out, vt, value);
1137
1138 custoffset = ctl2_alloc_segment(typelib, MSFT_SEG_CUSTDATAGUID, 12, 0);
1139 if (custoffset == -1) return E_OUTOFMEMORY;
1140
1141 custdata = (int *)&typelib->typelib_segment_data[MSFT_SEG_CUSTDATAGUID][custoffset];
1142 custdata[0] = guidoffset;
1143 custdata[1] = data_out;
1144 custdata[2] = *offset;
1145 *offset = custoffset;
1146
1147 return S_OK;
1148 }
1149
1150 static HRESULT add_func_desc(msft_typeinfo_t* typeinfo, func_t *func, int index)
1151 {
1152 int offset;
1153 int *typedata, typedata_size;
1154 int i, id, next_idx;
1155 int decoded_size, extra_attr = 0;
1156 int num_params = 0, num_defaults = 0;
1157 var_t *arg, *last_arg = NULL;
1158 char *namedata;
1159 attr_t *attr;
1160 unsigned int funcflags = 0, callconv = 4 /* CC_STDCALL */;
1161 unsigned int funckind = 1 /* FUNC_PUREVIRTUAL */, invokekind = 1 /* INVOKE_FUNC */;
1162 int help_context = 0, help_string_context = 0, help_string_offset = -1;
1163
1164 id = ((0x6000 | (typeinfo->typeinfo->datatype2 & 0xffff)) << 16) | index;
1165
1166 if((typeinfo->typeinfo->typekind & 15) == TKIND_DISPATCH)
1167 funckind = 0x4; /* FUNC_DISPATCH */
1168
1169 chat("add_func_desc(%p,%d)\n", typeinfo, index);
1170
1171 for(attr = func->def->attrs; attr; attr = NEXT_LINK(attr)) {
1172 if(attr->type == ATTR_LOCAL) {
1173 chat("add_func_desc: skipping local function\n");
1174 return S_FALSE;
1175 }
1176 }
1177
1178 for(arg = func->args; arg; arg = NEXT_LINK(arg)) {
1179 last_arg = arg;
1180 num_params++;
1181 for(attr = arg->attrs; attr; attr = NEXT_LINK(attr)) {
1182 if(attr->type == ATTR_DEFAULTVALUE_EXPR || attr->type == ATTR_DEFAULTVALUE_STRING) {
1183 num_defaults++;
1184 break;
1185 }
1186 }
1187 }
1188
1189 chat("add_func_desc: num of params %d\n", num_params);
1190
1191 for(attr = func->def->attrs; attr; attr = NEXT_LINK(attr)) {
1192 expr_t *expr = attr->u.pval;
1193 switch(attr->type) {
1194 case ATTR_HELPCONTEXT:
1195 extra_attr = 1;
1196 help_context = expr->u.lval;
1197 break;
1198 case ATTR_HELPSTRING:
1199 extra_attr = 2;
1200 help_string_offset = ctl2_alloc_string(typeinfo->typelib, attr->u.pval);
1201 break;
1202 case ATTR_HELPSTRINGCONTEXT:
1203 extra_attr = 6;
1204 help_string_context = expr->u.lval;
1205 break;
1206 case ATTR_HIDDEN:
1207 funcflags |= 0x40; /* FUNCFLAG_FHIDDEN */
1208 break;
1209 case ATTR_ID:
1210 id = expr->u.lval;
1211 break;
1212 case ATTR_OUT:
1213 break;
1214 case ATTR_PROPGET:
1215 invokekind = 0x2; /* INVOKE_PROPERTYGET */
1216 break;
1217 case ATTR_PROPPUT:
1218 invokekind = 0x4; /* INVOKE_PROPERTYPUT */
1219 break;
1220 case ATTR_PROPPUTREF:
1221 invokekind = 0x8; /* INVOKE_PROPERTYPUTREF */
1222 break;
1223 case ATTR_RESTRICTED:
1224 funcflags |= 0x1; /* FUNCFLAG_FRESTRICTED */
1225 break;
1226 default:
1227 warning("add_func_desc: ignoring attr %d\n", attr->type);
1228 break;
1229 }
1230 }
1231
1232 switch(invokekind) {
1233 case 0x2: /* INVOKE_PROPERTYGET */
1234 if(num_params != 0) {
1235 error("expecting no args on a propget func\n");
1236 return S_FALSE;
1237 }
1238 break;
1239 case 0x4: /* INVOKE_PROPERTYPUT */
1240 case 0x8: /* INVOKE_PROPERTYPUTREF */
1241 if(num_params != 1) {
1242 error("expecting one arg on a propput func\n");
1243 return S_FALSE;
1244 }
1245 break;
1246 default:
1247 break;
1248 }
1249
1250 /* allocate type data space for us */
1251 typedata_size = 0x18 + extra_attr * sizeof(int) + (num_params * (num_defaults ? 16 : 12));
1252
1253 if (!typeinfo->func_data) {
1254 typeinfo->func_data = xmalloc(0x100);
1255 typeinfo->func_data_allocated = 0x100;
1256 typeinfo->func_data[0] = 0;
1257 }
1258
1259 if(typeinfo->func_data[0] + typedata_size + sizeof(int) > typeinfo->func_data_allocated) {
1260 typeinfo->func_data_allocated = max(typeinfo->func_data_allocated * 2,
1261 typeinfo->func_data[0] + typedata_size + sizeof(int));
1262 typeinfo->func_data = xrealloc(typeinfo->func_data, typeinfo->func_data_allocated);
1263 }
1264
1265 offset = typeinfo->func_data[0];
1266 typeinfo->func_data[0] += typedata_size;
1267 typedata = typeinfo->func_data + (offset >> 2) + 1;
1268
1269 /* find the first func with the same id and link via the hiword of typedata[4] */
1270 next_idx = index;
1271 for(i = 0; i < (typeinfo->typeinfo->cElement & 0xffff); i++) {
1272 if(id == typeinfo->func_indices[i]) {
1273 next_idx = typeinfo->func_data[(typeinfo->func_offsets[i] >> 2) + 1 + 4] >> 16;
1274 typeinfo->func_data[(typeinfo->func_offsets[i] >> 2) + 1 + 4] &= 0xffff;
1275 typeinfo->func_data[(typeinfo->func_offsets[i] >> 2) + 1 + 4] |= (index << 16);
1276 break;
1277 }
1278 }
1279
1280 /* fill out the basic type information */
1281 typedata[0] = typedata_size | (index << 16);
1282 encode_var(typeinfo->typelib, func->def, &typedata[1], NULL, NULL, &decoded_size);
1283 typedata[2] = funcflags;
1284 typedata[3] = ((52 /*sizeof(FUNCDESC)*/ + decoded_size) << 16) | typeinfo->typeinfo->cbSizeVft;
1285 typedata[4] = (next_idx << 16) | (callconv << 8) | (invokekind << 3) | funckind;
1286 if(num_defaults) typedata[4] |= 0x1000;
1287 typedata[5] = num_params;
1288
1289 /* NOTE: High word of typedata[3] is total size of FUNCDESC + size of all ELEMDESCs for params + TYPEDESCs for pointer params and return types. */
1290 /* That is, total memory allocation required to reconstitute the FUNCDESC in its entirety. */
1291 typedata[3] += (16 /*sizeof(ELEMDESC)*/ * num_params) << 16;
1292 typedata[3] += (24 /*sizeof(PARAMDESCEX)*/ * num_defaults) << 16;
1293
1294 switch(extra_attr) {
1295 case 6: typedata[11] = help_string_context;
1296 case 5: typedata[10] = -1;
1297 case 4: typedata[9] = -1;
1298 case 3: typedata[8] = -1;
1299 case 2: typedata[7] = help_string_offset;
1300 case 1: typedata[6] = help_context;
1301 case 0:
1302 break;
1303 default:
1304 warning("unknown number of optional attrs\n");
1305 }
1306
1307 for (arg = last_arg, i = 0; arg; arg = PREV_LINK(arg), i++) {
1308 attr_t *attr;
1309 int paramflags = 0;
1310 int *paramdata = typedata + 6 + extra_attr + (num_defaults ? num_params : 0) + i * 3;
1311 int *defaultdata = num_defaults ? typedata + 6 + extra_attr + i : NULL;
1312
1313 if(defaultdata) *defaultdata = -1;
1314
1315 encode_var(typeinfo->typelib, arg, paramdata, NULL, NULL, &decoded_size);
1316 for(attr = arg->attrs; attr; attr = NEXT_LINK(attr)) {
1317 switch(attr->type) {
1318 case ATTR_DEFAULTVALUE_EXPR:
1319 {
1320 expr_t *expr = (expr_t *)attr->u.pval;
1321 paramflags |= 0x30; /* PARAMFLAG_FHASDEFAULT | PARAMFLAG_FOPT */
1322 chat("default value %ld\n", expr->cval);
1323 write_value(typeinfo->typelib, defaultdata, (*paramdata >> 16) & 0x1ff, &expr->cval);
1324 break;
1325 }
1326 case ATTR_DEFAULTVALUE_STRING:
1327 {
1328 char *s = (char *)attr->u.pval;
1329 paramflags |= 0x30; /* PARAMFLAG_FHASDEFAULT | PARAMFLAG_FOPT */
1330 chat("default value '%s'\n", s);
1331 write_value(typeinfo->typelib, defaultdata, (*paramdata >> 16) & 0x1ff, s);
1332 break;
1333 }
1334 case ATTR_IN:
1335 paramflags |= 0x01; /* PARAMFLAG_FIN */
1336 break;
1337 case ATTR_OPTIONAL:
1338 paramflags |= 0x10; /* PARAMFLAG_FOPT */
1339 break;
1340 case ATTR_OUT:
1341 paramflags |= 0x02; /* PARAMFLAG_FOUT */
1342 break;
1343 case ATTR_RETVAL:
1344 paramflags |= 0x08; /* PARAMFLAG_FRETVAL */
1345 break;
1346 default:
1347 chat("unhandled param attr %d\n", attr->type);
1348 break;
1349 }
1350 }
1351 paramdata[1] = -1;
1352 paramdata[2] = paramflags;
1353 typedata[3] += decoded_size << 16;
1354 }
1355
1356 if(typeinfo->funcs_allocated == 0) {
1357 typeinfo->funcs_allocated = 10;
1358 typeinfo->func_indices = xmalloc(typeinfo->funcs_allocated * sizeof(int));
1359 typeinfo->func_names = xmalloc(typeinfo->funcs_allocated * sizeof(int));
1360 typeinfo->func_offsets = xmalloc(typeinfo->funcs_allocated * sizeof(int));
1361 }
1362 if(typeinfo->funcs_allocated == (typeinfo->typeinfo->cElement & 0xffff)) {
1363 typeinfo->funcs_allocated *= 2;
1364 typeinfo->func_indices = xrealloc(typeinfo->func_indices, typeinfo->funcs_allocated * sizeof(int));
1365 typeinfo->func_names = xrealloc(typeinfo->func_names, typeinfo->funcs_allocated * sizeof(int));
1366 typeinfo->func_offsets = xrealloc(typeinfo->func_offsets, typeinfo->funcs_allocated * sizeof(int));
1367 }
1368
1369 /* update the index data */
1370 typeinfo->func_indices[typeinfo->typeinfo->cElement & 0xffff] = id;
1371 typeinfo->func_offsets[typeinfo->typeinfo->cElement & 0xffff] = offset;
1372
1373 offset = ctl2_alloc_name(typeinfo->typelib, func->def->name);
1374 typeinfo->func_names[typeinfo->typeinfo->cElement & 0xffff] = offset;
1375
1376 /* ??? */
1377 if (!typeinfo->typeinfo->res2) typeinfo->typeinfo->res2 = 0x20;
1378 typeinfo->typeinfo->res2 <<= 1;
1379 /* ??? */
1380 if (index < 2) typeinfo->typeinfo->res2 += num_params << 4;
1381
1382 if (typeinfo->typeinfo->res3 == -1) typeinfo->typeinfo->res3 = 0;
1383 typeinfo->typeinfo->res3 += 0x38 + num_params * 0x10;
1384 if(num_defaults) typeinfo->typeinfo->res3 += num_params * 0x4;
1385
1386 /* adjust size of VTBL */
1387 typeinfo->typeinfo->cbSizeVft += 4;
1388
1389 /* Increment the number of function elements */
1390 typeinfo->typeinfo->cElement += 1;
1391
1392 namedata = typeinfo->typelib->typelib_segment_data[MSFT_SEG_NAME] + offset;
1393 if (*((INT *)namedata) == -1) {
1394 *((INT *)namedata) = typeinfo->typelib->typelib_typeinfo_offsets[typeinfo->typeinfo->typekind >> 16];
1395 namedata[9] &= ~0x10;
1396 }
1397
1398 if(invokekind == 0x1 /* INVOKE_FUNC */) { /* don't give the arg of a [prop*] func a name */
1399 for (arg = last_arg, i = 0; arg; arg = PREV_LINK(arg), i++) {
1400 int *paramdata = typedata + 6 + extra_attr + (num_defaults ? num_params : 0) + i * 3;
1401 offset = ctl2_alloc_name(typeinfo->typelib, arg->name);
1402 paramdata[1] = offset;
1403 }
1404 }
1405 return S_OK;
1406 }
1407
1408 static HRESULT add_var_desc(msft_typeinfo_t *typeinfo, UINT index, var_t* var)
1409 {
1410 int offset, typedata_size, id;
1411 INT *typedata;
1412 int var_datawidth;
1413 int var_alignment;
1414 int var_type_size, var_kind = 0 /* VAR_PERINSTANCE */;
1415 int alignment;
1416 int varflags = 0;
1417 attr_t *attr;
1418 char *namedata;
1419 int var_num = (typeinfo->typeinfo->cElement >> 16) & 0xffff;
1420
1421 chat("add_var_desc(%d,%s) array %p\n", index, var->name, var->array);
1422
1423 id = 0x40000000 + index;
1424
1425 for(attr = var->attrs; attr; attr = NEXT_LINK(attr)) {
1426 expr_t *expr = attr->u.pval;
1427 switch(attr->type) {
1428 case ATTR_ID:
1429 id = expr->u.lval;
1430 break;
1431 default:
1432 warning("AddVarDesc: unhandled attr type %d\n", attr->type);
1433 break;
1434 }
1435 }
1436
1437 /* allocate type data space for us */
1438 typedata_size = 0x14;
1439
1440 if (!typeinfo->var_data) {
1441 typeinfo->var_data = xmalloc(0x100);
1442 typeinfo->var_data_allocated = 0x100;
1443 typeinfo->var_data[0] = 0;
1444 }
1445
1446 if(typeinfo->var_data[0] + typedata_size + sizeof(int) > typeinfo->var_data_allocated) {
1447 typeinfo->var_data_allocated = max(typeinfo->var_data_allocated * 2,
1448 typeinfo->var_data[0] + typedata_size + sizeof(int));
1449 typeinfo->var_data = xrealloc(typeinfo->var_data, typeinfo->var_data_allocated);
1450 }
1451
1452 offset = typeinfo->var_data[0];
1453 typeinfo->var_data[0] += typedata_size;
1454 typedata = typeinfo->var_data + (offset >> 2) + 1;
1455
1456 /* fill out the basic type information */
1457 typedata[0] = typedata_size | (index << 16);
1458 typedata[2] = varflags;
1459 typedata[3] = (36 /*sizeof(VARDESC)*/ << 16) | 0;
1460
1461 if(typeinfo->vars_allocated == 0) {
1462 typeinfo->vars_allocated = 10;
1463 typeinfo->var_indices = xmalloc(typeinfo->vars_allocated * sizeof(int));
1464 typeinfo->var_names = xmalloc(typeinfo->vars_allocated * sizeof(int));
1465 typeinfo->var_offsets = xmalloc(typeinfo->vars_allocated * sizeof(int));
1466 }
1467 if(typeinfo->vars_allocated == var_num) {
1468 typeinfo->vars_allocated *= 2;
1469 typeinfo->var_indices = xrealloc(typeinfo->var_indices, typeinfo->vars_allocated * sizeof(int));
1470 typeinfo->var_names = xrealloc(typeinfo->var_names, typeinfo->vars_allocated * sizeof(int));
1471 typeinfo->var_offsets = xrealloc(typeinfo->var_offsets, typeinfo->vars_allocated * sizeof(int));
1472 }
1473 /* update the index data */
1474 typeinfo->var_indices[var_num] = id;
1475 typeinfo->var_names[var_num] = -1;
1476 typeinfo->var_offsets[var_num] = offset;
1477
1478 /* figure out type widths and whatnot */
1479 encode_var(typeinfo->typelib, var, &typedata[1], &var_datawidth,
1480 &var_alignment, &var_type_size);
1481
1482 /* pad out starting position to data width */
1483 typeinfo->datawidth += var_alignment - 1;
1484 typeinfo->datawidth &= ~(var_alignment - 1);
1485
1486 switch(typeinfo->typeinfo->typekind & 0xf) {
1487 case TKIND_ENUM:
1488 write_value(typeinfo->typelib, &typedata[4], VT_I4, &var->lval);
1489 var_kind = 2; /* VAR_CONST */
1490 var_type_size += 16; /* sizeof(VARIANT) */
1491 typeinfo->datawidth = var_datawidth;
1492 break;
1493 case TKIND_RECORD:
1494 typedata[4] = typeinfo->datawidth;
1495 typeinfo->datawidth += var_datawidth;
1496 break;
1497 case TKIND_DISPATCH:
1498 var_kind = 3; /* VAR_DISPATCH */
1499 typeinfo->datawidth = 4;
1500 var_alignment = 4;
1501 break;
1502 default:
1503 error("add_var_desc: unhandled type kind %d\n", typeinfo->typeinfo->typekind & 0xf);
1504 break;
1505 }
1506
1507 /* add type description size to total required allocation */
1508 typedata[3] += var_type_size << 16 | var_kind;
1509
1510 /* fix type alignment */
1511 alignment = (typeinfo->typeinfo->typekind >> 11) & 0x1f;
1512 if (alignment < var_alignment) {
1513 alignment = var_alignment;
1514 typeinfo->typeinfo->typekind &= ~0xffc0;
1515 typeinfo->typeinfo->typekind |= alignment << 11 | alignment << 6;
1516 }
1517
1518 /* ??? */
1519 if (!typeinfo->typeinfo->res2) typeinfo->typeinfo->res2 = 0x1a;
1520 if ((index == 0) || (index == 1) || (index == 2) || (index == 4) || (index == 9)) {
1521 typeinfo->typeinfo->res2 <<= 1;
1522 }
1523
1524 /* ??? */
1525 if (typeinfo->typeinfo->res3 == -1) typeinfo->typeinfo->res3 = 0;
1526 typeinfo->typeinfo->res3 += 0x2c;
1527
1528 /* increment the number of variable elements */
1529 typeinfo->typeinfo->cElement += 0x10000;
1530
1531 /* pad data width to alignment */
1532 typeinfo->typeinfo->size = (typeinfo->datawidth + (alignment - 1)) & ~(alignment - 1);
1533
1534 offset = ctl2_alloc_name(typeinfo->typelib, var->name);
1535 if (offset == -1) return E_OUTOFMEMORY;
1536
1537 namedata = typeinfo->typelib->typelib_segment_data[MSFT_SEG_NAME] + offset;
1538 if (*((INT *)namedata) == -1) {
1539 *((INT *)namedata) = typeinfo->typelib->typelib_typeinfo_offsets[typeinfo->typeinfo->typekind >> 16];
1540 if((typeinfo->typeinfo->typekind & 15) != TKIND_DISPATCH)
1541 namedata[9] |= 0x10;
1542 } else
1543 namedata[9] &= ~0x10;
1544
1545 if ((typeinfo->typeinfo->typekind & 15) == TKIND_ENUM) {
1546 namedata[9] |= 0x20;
1547 }
1548 typeinfo->var_names[var_num] = offset;
1549
1550 return S_OK;
1551 }
1552
1553 static HRESULT add_impl_type(msft_typeinfo_t *typeinfo, type_t *ref)
1554 {
1555 if(ref->typelib_idx == -1)
1556 add_interface_typeinfo(typeinfo->typelib, ref);
1557 if(ref->typelib_idx == -1)
1558 error("add_impl_type: unable to add inherited interface\n");
1559
1560 typeinfo->typeinfo->datatype1 = typeinfo->typelib->typelib_typeinfo_offsets[ref->typelib_idx];
1561 typeinfo->typeinfo->cImplTypes++;
1562 return S_OK;
1563 }
1564
1565 static msft_typeinfo_t *create_msft_typeinfo(msft_typelib_t *typelib, enum type_kind kind,
1566 char *name, attr_t *attr, int idx)
1567 {
1568 msft_typeinfo_t *msft_typeinfo;
1569 int nameoffset;
1570 int typeinfo_offset;
1571 MSFT_TypeInfoBase *typeinfo;
1572 MSFT_GuidEntry guidentry;
1573
1574 chat("create_msft_typeinfo: name %s kind %d\n", name, kind);
1575
1576 msft_typeinfo = xmalloc(sizeof(*msft_typeinfo));
1577
1578 msft_typeinfo->typelib = typelib;
1579
1580 nameoffset = ctl2_alloc_name(typelib, name);
1581 typeinfo_offset = ctl2_alloc_typeinfo(typelib, nameoffset);
1582 typeinfo = (MSFT_TypeInfoBase *)&typelib->typelib_segment_data[MSFT_SEG_TYPEINFO][typeinfo_offset];
1583
1584 typelib->typelib_segment_data[MSFT_SEG_NAME][nameoffset + 9] = 0x38;
1585 *((int *)&typelib->typelib_segment_data[MSFT_SEG_NAME][nameoffset]) = typeinfo_offset;
1586
1587 msft_typeinfo->typeinfo = typeinfo;
1588
1589 typeinfo->typekind |= kind | 0x20;
1590
1591 for( ; attr; attr = NEXT_LINK(attr)) {
1592 switch(attr->type) {
1593 case ATTR_HELPCONTEXT:
1594 {
1595 expr_t *expr = (expr_t*)attr->u.pval;
1596 typeinfo->helpcontext = expr->cval;
1597 break;
1598 }
1599 case ATTR_HELPSTRING:
1600 {
1601 int offset = ctl2_alloc_string(typelib, attr->u.pval);
1602 if (offset == -1) break;
1603 typeinfo->docstringoffs = offset;
1604 break;
1605 }
1606 case ATTR_HELPSTRINGCONTEXT:
1607 {
1608 expr_t *expr = (expr_t*)attr->u.pval;
1609 typeinfo->helpstringcontext = expr->cval;
1610 break;
1611 }
1612 case ATTR_HIDDEN:
1613 typeinfo->flags |= 0x10; /* TYPEFLAG_FHIDDEN */
1614 break;
1615
1616 case ATTR_ODL:
1617 break;
1618
1619 case ATTR_RESTRICTED:
1620 typeinfo->flags |= 0x200; /* TYPEFLAG_FRESTRICTED */
1621 break;
1622
1623 case ATTR_UUID:
1624 guidentry.guid = *(GUID*)attr->u.pval;
1625 guidentry.hreftype = typelib->typelib_typeinfo_offsets[typeinfo->typekind >> 16];
1626 guidentry.next_hash = -1;
1627 typeinfo->posguid = ctl2_alloc_guid(typelib, &guidentry);
1628 #if 0
1629 if (IsEqualIID(guid, &IID_IDispatch)) {
1630 typelib->typelib_header.dispatchpos = typelib->typelib_typeinfo_offsets[typeinfo->typekind >> 16];
1631 }
1632 #endif
1633 break;
1634
1635 case ATTR_VERSION:
1636 typeinfo->version = attr->u.ival;
1637 break;
1638
1639 default:
1640 warning("create_msft_typeinfo: ignoring attr %d\n", attr->type);
1641 break;
1642 }
1643 }
1644
1645 if (typelib->last_typeinfo) typelib->last_typeinfo->next_typeinfo = msft_typeinfo;
1646 typelib->last_typeinfo = msft_typeinfo;
1647 if (!typelib->typeinfos) typelib->typeinfos = msft_typeinfo;
1648
1649
1650 return msft_typeinfo;
1651 }
1652
1653 static void add_dispatch(msft_typelib_t *typelib)
1654 {
1655 int guid_offset, impfile_offset;
1656 MSFT_GuidEntry guidentry;
1657 MSFT_ImpInfo impinfo;
1658 GUID stdole = {0x00020430,0x0000,0x0000,{0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
1659 GUID iid_idispatch = {0x00020400,0x0000,0x0000,{0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}};
1660
1661 if(typelib->typelib_header.dispatchpos != -1) return;
1662
1663 guidentry.guid = stdole;
1664 guidentry.hreftype = 2;
1665 guidentry.next_hash = -1;
1666 guid_offset = ctl2_alloc_guid(typelib, &guidentry);
1667 impfile_offset = alloc_importfile(typelib, guid_offset, 2, 0, "stdole2.tlb");
1668
1669 guidentry.guid = iid_idispatch;
1670 guidentry.hreftype = 1;
1671 guidentry.next_hash = -1;
1672 impinfo.res0 = 0x301 << 16;
1673 impinfo.oImpFile = impfile_offset;
1674 impinfo.oGuid = ctl2_alloc_guid(typelib, &guidentry);
1675 typelib->typelib_header.dispatchpos = alloc_importinfo(typelib, &impinfo) | 0x01;
1676
1677 typelib->typelib_header.res50 = 1;
1678
1679 }
1680
1681 static void add_dispinterface_typeinfo(msft_typelib_t *typelib, type_t *dispinterface)
1682 {
1683 int idx = 0;
1684 func_t *func;
1685 var_t *var;
1686 msft_typeinfo_t *msft_typeinfo;
1687
1688 msft_typeinfo = create_msft_typeinfo(typelib, TKIND_DISPATCH, dispinterface->name,
1689 dispinterface->attrs, typelib->typelib_header.nrtypeinfos);
1690
1691 msft_typeinfo->typeinfo->size = 4;
1692 msft_typeinfo->typeinfo->typekind |= 0x2100;
1693
1694 msft_typeinfo->typeinfo->flags |= 0x1000; /* TYPEFLAG_FDISPATCHABLE */
1695 add_dispatch(typelib);
1696 msft_typeinfo->typeinfo->cImplTypes = 1;
1697
1698 /* count the no of funcs, as the variable indicies come after the funcs */
1699 if((func = dispinterface->funcs)) {
1700 idx++;
1701 while(NEXT_LINK(func)) {
1702 func = NEXT_LINK(func);
1703 idx++;
1704 }
1705 }
1706
1707 if((var = dispinterface->fields)) {
1708 while(NEXT_LINK(var)) var = NEXT_LINK(var);
1709 while(var) {
1710 add_var_desc(msft_typeinfo, idx, var);
1711 idx++;
1712 var = PREV_LINK(var);
1713 }
1714 }
1715
1716 idx = 0;
1717 /* the func count above has already left us pointing at the first func */
1718 while(func) {
1719 if(add_func_desc(msft_typeinfo, func, idx) == S_OK)
1720 idx++;
1721 func = PREV_LINK(func);
1722 }
1723 }
1724
1725 static void add_interface_typeinfo(msft_typelib_t *typelib, type_t *interface)
1726 {
1727 int idx = 0;
1728 func_t *func;
1729 type_t *ref;
1730 msft_typeinfo_t *msft_typeinfo;
1731 int num_parents = 0, num_funcs = 0;
1732 attr_t *attr;
1733
1734 for(attr = interface->attrs; attr; attr = NEXT_LINK(attr))
1735 if(attr->type == ATTR_DISPINTERFACE)
1736 return add_dispinterface_typeinfo(typelib, interface);
1737
1738 /* midl adds the parent interface first, unless the parent itself
1739 has no parent (i.e. it stops before IUnknown). */
1740
1741 if(interface->ref && interface->ref->ref && interface->ref->typelib_idx == -1)
1742 add_interface_typeinfo(typelib, interface->ref);
1743
1744 interface->typelib_idx = typelib->typelib_header.nrtypeinfos;
1745 msft_typeinfo = create_msft_typeinfo(typelib, TKIND_INTERFACE, interface->name, interface->attrs,
1746 typelib->typelib_header.nrtypeinfos);
1747 msft_typeinfo->typeinfo->size = 4;
1748 msft_typeinfo->typeinfo->typekind |= 0x2200;
1749
1750 if(interface->ref)
1751 add_impl_type(msft_typeinfo, interface->ref);
1752
1753 /* count the number of inherited interfaces and non-local functions */
1754 for(ref = interface->ref; ref; ref = ref->ref) {
1755 num_parents++;
1756 for(func = ref->funcs; func; func = NEXT_LINK(func)) {
1757 attr_t *attr;
1758 for(attr = func->def->attrs; attr; attr = NEXT_LINK(attr))
1759 if(attr->type == ATTR_LOCAL)
1760 break;
1761 if(!attr)
1762 num_funcs++;
1763 }
1764 }
1765 msft_typeinfo->typeinfo->datatype2 = num_funcs << 16 | num_parents;
1766 msft_typeinfo->typeinfo->cbSizeVft = num_funcs * 4;
1767
1768 if((func = interface->funcs)) {
1769 while(NEXT_LINK(func)) func = NEXT_LINK(func);
1770 while(func) {
1771 if(add_func_desc(msft_typeinfo, func, idx) == S_OK)
1772 idx++;
1773 func = PREV_LINK(func);
1774 }
1775 }
1776 }
1777
1778 static void add_structure_typeinfo(msft_typelib_t *typelib, type_t *structure)
1779 {
1780 int idx = 0;
1781 var_t *cur = structure->fields;
1782 msft_typeinfo_t *msft_typeinfo;
1783
1784 structure->typelib_idx = typelib->typelib_header.nrtypeinfos;
1785 msft_typeinfo = create_msft_typeinfo(typelib, TKIND_RECORD, structure->name, structure->attrs,
1786 typelib->typelib_header.nrtypeinfos);
1787 msft_typeinfo->typeinfo->size = 0;
1788
1789 while(NEXT_LINK(cur)) cur = NEXT_LINK(cur);
1790 while(cur) {
1791 add_var_desc(msft_typeinfo, idx, cur);
1792 idx++;
1793 cur = PREV_LINK(cur);
1794 }
1795 }
1796
1797 static void add_enum_typeinfo(msft_typelib_t *typelib, type_t *enumeration)
1798 {
1799 int idx = 0;
1800 var_t *cur = enumeration->fields;
1801 msft_typeinfo_t *msft_typeinfo;
1802
1803 enumeration->typelib_idx = typelib->typelib_header.nrtypeinfos;
1804 msft_typeinfo = create_msft_typeinfo(typelib, TKIND_ENUM, enumeration->name, enumeration->attrs,
1805 typelib->typelib_header.nrtypeinfos);
1806 msft_typeinfo->typeinfo->size = 0;
1807
1808 while(NEXT_LINK(cur)) cur = NEXT_LINK(cur);
1809 while(cur) {
1810 add_var_desc(msft_typeinfo, idx, cur);
1811 idx++;
1812 cur = PREV_LINK(cur);
1813 }
1814 }
1815
1816 static void add_entry(msft_typelib_t *typelib, typelib_entry_t *entry)
1817 {
1818 switch(entry->kind) {
1819 case TKIND_INTERFACE:
1820 add_interface_typeinfo(typelib, entry->u.interface);
1821 break;
1822
1823 case TKIND_RECORD:
1824 add_structure_typeinfo(typelib, entry->u.structure);
1825 break;
1826
1827 case TKIND_ENUM:
1828 add_enum_typeinfo(typelib, entry->u.enumeration);
1829 break;
1830
1831 default:
1832 error("add_entry: unhandled type %d\n", entry->kind);
1833 break;
1834 }
1835 }
1836
1837 static void set_name(msft_typelib_t *typelib)
1838 {
1839 int offset;
1840
1841 offset = ctl2_alloc_name(typelib, typelib->typelib->name);
1842 if (offset == -1) return;
1843 typelib->typelib_header.NameOffset = offset;
1844 return;
1845 }
1846
1847 static void set_version(msft_typelib_t *typelib)
1848 {
1849 long version = MAKELONG(0,0);
1850 attr_t *attr;
1851
1852 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
1853 if(attr->type == ATTR_VERSION) {
1854 version = attr->u.ival;
1855 }
1856 }
1857 typelib->typelib_header.version = version;
1858 return;
1859 }
1860
1861 static void set_guid(msft_typelib_t *typelib)
1862 {
1863 MSFT_GuidEntry guidentry;
1864 int offset;
1865 attr_t *attr;
1866 GUID guid = {0,0,0,{0,0,0,0,0,0}};
1867
1868 guidentry.guid = guid;
1869 guidentry.hreftype = -2;
1870 guidentry.next_hash = -1;
1871
1872 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
1873 if(attr->type == ATTR_UUID) {
1874 guidentry.guid = *(GUID*)(attr->u.pval);
1875 }
1876 }
1877
1878 offset = ctl2_alloc_guid(typelib, &guidentry);
1879
1880 if (offset == -1) return;
1881
1882 typelib->typelib_header.posguid = offset;
1883
1884 return;
1885 }
1886
1887 static void set_doc_string(msft_typelib_t *typelib)
1888 {
1889 attr_t *attr;
1890 int offset;
1891
1892 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
1893 if(attr->type == ATTR_HELPSTRING) {
1894 offset = ctl2_alloc_string(typelib, attr->u.pval);
1895 if (offset == -1) return;
1896 typelib->typelib_header.helpstring = offset;
1897 }
1898 }
1899 return;
1900 }
1901
1902 static void set_help_file_name(msft_typelib_t *typelib)
1903 {
1904 int offset;
1905 attr_t *attr;
1906 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
1907 if(attr->type == ATTR_HELPFILE) {
1908 offset = ctl2_alloc_string(typelib, attr->u.pval);
1909 if (offset == -1) return;
1910 typelib->typelib_header.helpfile = offset;
1911 typelib->typelib_header.varflags |= 0x10;
1912 }
1913 }
1914 return;
1915 }
1916
1917 static void set_help_context(msft_typelib_t *typelib)
1918 {
1919 attr_t *attr;
1920 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
1921 if(attr->type == ATTR_HELPCONTEXT) {
1922 expr_t *expr = (expr_t *)attr->u.pval;
1923 typelib->typelib_header.helpcontext = expr->cval;
1924 }
1925 }
1926 return;
1927 }
1928
1929 static void set_help_string_dll(msft_typelib_t *typelib)
1930 {
1931 int offset;
1932 attr_t *attr;
1933 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
1934 if(attr->type == ATTR_HELPSTRINGDLL) {
1935 offset = ctl2_alloc_string(typelib, attr->u.pval);
1936 if (offset == -1) return;
1937 typelib->help_string_dll_offset = offset;
1938 typelib->typelib_header.varflags |= 0x100;
1939 }
1940 }
1941 return;
1942 }
1943
1944 static void set_help_string_context(msft_typelib_t *typelib)
1945 {
1946 attr_t *attr;
1947 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
1948 if(attr->type == ATTR_HELPSTRINGCONTEXT) {
1949 expr_t *expr = (expr_t *)attr->u.pval;
1950 typelib->typelib_header.helpstringcontext = expr->cval;
1951 }
1952 }
1953 return;
1954 }
1955
1956 static void set_lcid(msft_typelib_t *typelib)
1957 {
1958 typelib->typelib_header.lcid2 = 0x0;
1959 return;
1960 }
1961
1962 static void set_lib_flags(msft_typelib_t *typelib)
1963 {
1964 attr_t *attr;
1965
1966 typelib->typelib_header.flags = 0;
1967 for(attr = typelib->typelib->attrs; attr; attr = NEXT_LINK(attr)) {
1968 switch(attr->type) {
1969 case ATTR_CONTROL:
1970 typelib->typelib_header.flags |= 0x02; /* LIBFLAG_FCONTROL */
1971 break;
1972 case ATTR_HIDDEN:
1973 typelib->typelib_header.flags |= 0x04; /* LIBFLAG_FHIDDEN */
1974 break;
1975 case ATTR_RESTRICTED:
1976 typelib->typelib_header.flags |= 0x01; /* LIBFLAG_FRESTRICTED */
1977 break;
1978 default:
1979 break;
1980 }
1981 }
1982 return;
1983 }
1984
1985 static int ctl2_write_chunk(int fd, void *segment, int length)
1986 {
1987 if (write(fd, segment, length) != length) {
1988 close(fd);
1989 return 0;
1990 }
1991 return -1;
1992 }
1993
1994 static int ctl2_write_segment(msft_typelib_t *typelib, int fd, int segment)
1995 {
1996 if (write(fd, typelib->typelib_segment_data[segment], typelib->typelib_segdir[segment].length)
1997 != typelib->typelib_segdir[segment].length) {
1998 close(fd);
1999 return 0;
2000 }
2001
2002 return -1;
2003 }
2004
2005 static void ctl2_finalize_typeinfos(msft_typelib_t *typelib, int filesize)
2006 {
2007 msft_typeinfo_t *typeinfo;
2008
2009 for (typeinfo = typelib->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
2010 typeinfo->typeinfo->memoffset = filesize;
2011 if (typeinfo->func_data)
2012 filesize += typeinfo->func_data[0] + ((typeinfo->typeinfo->cElement & 0xffff) * 12);
2013 if (typeinfo->var_data)
2014 filesize += typeinfo->var_data[0] + (((typeinfo->typeinfo->cElement >> 16) & 0xffff) * 12);
2015 if (typeinfo->func_data || typeinfo->var_data)
2016 filesize += 4;
2017 }
2018 }
2019
2020 static int ctl2_finalize_segment(msft_typelib_t *typelib, int filepos, int segment)
2021 {
2022 if (typelib->typelib_segdir[segment].length) {
2023 typelib->typelib_segdir[segment].offset = filepos;
2024 } else {
2025 typelib->typelib_segdir[segment].offset = -1;
2026 }
2027
2028 return typelib->typelib_segdir[segment].length;
2029 }
2030
2031
2032 static void ctl2_write_typeinfos(msft_typelib_t *typelib, int fd)
2033 {
2034 msft_typeinfo_t *typeinfo;
2035 int typedata_size;
2036
2037 for (typeinfo = typelib->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
2038 if (!typeinfo->func_data && !typeinfo->var_data) continue;
2039 typedata_size = 0;
2040 if (typeinfo->func_data)
2041 typedata_size = typeinfo->func_data[0];
2042 if (typeinfo->var_data)
2043 typedata_size += typeinfo->var_data[0];
2044 ctl2_write_chunk(fd, &typedata_size, sizeof(int));
2045 if (typeinfo->func_data)
2046 ctl2_write_chunk(fd, typeinfo->func_data + 1, typeinfo->func_data[0]);
2047 if (typeinfo->var_data)
2048 ctl2_write_chunk(fd, typeinfo->var_data + 1, typeinfo->var_data[0]);
2049 if (typeinfo->func_indices)
2050 ctl2_write_chunk(fd, typeinfo->func_indices, (typeinfo->typeinfo->cElement & 0xffff) * 4);
2051 if (typeinfo->var_indices)
2052 ctl2_write_chunk(fd, typeinfo->var_indices, (typeinfo->typeinfo->cElement >> 16) * 4);
2053 if (typeinfo->func_names)
2054 ctl2_write_chunk(fd, typeinfo->func_names, (typeinfo->typeinfo->cElement & 0xffff) * 4);
2055 if (typeinfo->var_names)
2056 ctl2_write_chunk(fd, typeinfo->var_names, (typeinfo->typeinfo->cElement >> 16) * 4);
2057 if (typeinfo->func_offsets)
2058 ctl2_write_chunk(fd, typeinfo->func_offsets, (typeinfo->typeinfo->cElement & 0xffff) * 4);
2059 if (typeinfo->var_offsets) {
2060 int add = 0, i, offset;
2061 if(typeinfo->func_data)
2062 add = typeinfo->func_data[0];
2063 for(i = 0; i < (typeinfo->typeinfo->cElement >> 16); i++) {
2064 offset = typeinfo->var_offsets[i];
2065 offset += add;
2066 ctl2_write_chunk(fd, &offset, 4);
2067 }
2068 }
2069 }
2070 }
2071
2072 static int save_all_changes(msft_typelib_t *typelib)
2073 {
2074 int retval;
2075 int filepos;
2076 int fd;
2077
2078 chat("save_all_changes(%p)\n", typelib);
2079
2080 retval = TYPE_E_IOERROR;
2081
2082 fd = creat(typelib->typelib->filename, 0666);
2083 if (fd == -1) return retval;
2084
2085 filepos = sizeof(MSFT_Header) + sizeof(MSFT_SegDir);
2086 if(typelib->typelib_header.varflags & 0x100) filepos += 4; /* helpstringdll */
2087 filepos += typelib->typelib_header.nrtypeinfos * 4;
2088
2089 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_TYPEINFO);
2090 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_GUIDHASH);
2091 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_GUID);
2092 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_IMPORTINFO);
2093 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_IMPORTFILES);
2094 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_REFERENCES);
2095 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_NAMEHASH);
2096 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_NAME);
2097 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_STRING);
2098 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_TYPEDESC);
2099 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_ARRAYDESC);
2100 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_CUSTDATA);
2101 filepos += ctl2_finalize_segment(typelib, filepos, MSFT_SEG_CUSTDATAGUID);
2102
2103 ctl2_finalize_typeinfos(typelib, filepos);
2104
2105 if (!ctl2_write_chunk(fd, &typelib->typelib_header, sizeof(typelib->typelib_header))) return retval;
2106 if(typelib->typelib_header.varflags & 0x100)
2107 if (!ctl2_write_chunk(fd, &typelib->help_string_dll_offset, sizeof(typelib->help_string_dll_offset)))
2108 return retval;
2109
2110 if (!ctl2_write_chunk(fd, typelib->typelib_typeinfo_offsets, typelib->typelib_header.nrtypeinfos * 4)) return retval;
2111 if (!ctl2_write_chunk(fd, &typelib->typelib_segdir, sizeof(typelib->typelib_segdir))) return retval;
2112 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_TYPEINFO )) return retval;
2113 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_GUIDHASH )) return retval;
2114 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_GUID )) return retval;
2115 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_IMPORTINFO )) return retval;
2116 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_IMPORTFILES )) return retval;
2117 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_REFERENCES )) return retval;
2118 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_NAMEHASH )) return retval;
2119 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_NAME )) return retval;
2120 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_STRING )) return retval;
2121 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_TYPEDESC )) return retval;
2122 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_ARRAYDESC )) return retval;
2123 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_CUSTDATA )) return retval;
2124 if (!ctl2_write_segment(typelib, fd, MSFT_SEG_CUSTDATAGUID)) return retval;
2125
2126 ctl2_write_typeinfos(typelib, fd);
2127
2128 if (close(fd) == -1) return retval;
2129
2130 retval = S_OK;
2131 return retval;
2132 }
2133
2134 int create_msft_typelib(typelib_t *typelib)
2135 {
2136 msft_typelib_t *msft;
2137 int failed = 0;
2138 typelib_entry_t *entry;
2139 time_t cur_time;
2140 unsigned int version = 5 << 24 | 1 << 16 | 164; /* 5.01.0164 */
2141 GUID midl_time_guid = {0xde77ba63,0x517c,0x11d1,{0xa2,0xda,0x00,0x00,0xf8,0x77,0x3c,0xe9}};
2142 GUID midl_version_guid = {0xde77ba64,0x517c,0x11d1,{0xa2,0xda,0x00,0x00,0xf8,0x77,0x3c,0xe9}};
2143
2144 msft = malloc(sizeof(*msft));
2145 if (!msft) return 0;
2146 memset(msft, 0, sizeof(*msft));
2147 msft->typelib = typelib;
2148
2149 ctl2_init_header(msft);
2150 ctl2_init_segdir(msft);
2151
2152 msft->typelib_header.varflags |= SYS_WIN32;
2153
2154 /*
2155 * The following two calls return an offset or -1 if out of memory. We
2156 * specifically need an offset of 0, however, so...
2157 */
2158 if (ctl2_alloc_segment(msft, MSFT_SEG_GUIDHASH, 0x80, 0x80)) { failed = 1; }
2159 if (ctl2_alloc_segment(msft, MSFT_SEG_NAMEHASH, 0x200, 0x200)) { failed = 1; }
2160
2161 if(failed) return 0;
2162
2163 msft->typelib_guidhash_segment = (int *)msft->typelib_segment_data[MSFT_SEG_GUIDHASH];
2164 msft->typelib_namehash_segment = (int *)msft->typelib_segment_data[MSFT_SEG_NAMEHASH];
2165
2166 memset(msft->typelib_guidhash_segment, 0xff, 0x80);
2167 memset(msft->typelib_namehash_segment, 0xff, 0x200);
2168
2169 set_lib_flags(msft);
2170 set_lcid(msft);
2171 set_help_file_name(msft);
2172 set_doc_string(msft);
2173 set_guid(msft);
2174 set_version(msft);
2175 set_name(msft);
2176 set_help_context(msft);
2177 set_help_string_dll(msft);
2178 set_help_string_context(msft);
2179
2180 /* midl adds two sets of custom data to the library: the current unix time
2181 and midl's version number */
2182 cur_time = time(NULL);
2183 set_custdata(msft, &midl_time_guid, VT_UI4, &cur_time, &msft->typelib_header.CustomDataOffset);
2184 set_custdata(msft, &midl_version_guid, VT_UI4, &version, &msft->typelib_header.CustomDataOffset);
2185
2186 for(entry = typelib->entry; entry && NEXT_LINK(entry); entry = NEXT_LINK(entry))
2187 ;
2188
2189 for( ; entry; entry = PREV_LINK(entry))
2190 add_entry(msft, entry);
2191
2192 save_all_changes(msft);
2193 return 1;
2194 }
Maarten's multimedia branch