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