git.oblomov.eu Git - wine/blob - tools/widl/write_msft.c

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