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