dll/win32/oleaut32/typelib2.c

   1 /*
   2  *      TYPELIB2
   3  *
   4  *      Copyright 2004  Alastair Bridgewater
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  * --------------------------------------------------------------------------------------
  21  *  Known problems:
  22  *
  23  *    Badly incomplete.
  24  *
  25  *    Only works on little-endian systems.
  26  *
  27  */
  28
  29 #include "config.h"
  30 #include "wine/port.h"
  31
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <stdarg.h>
  35 #include <stdio.h>
  36 #include <ctype.h>
  37
  38 #define COBJMACROS
  39 #define NONAMELESSUNION
  40 #define NONAMELESSSTRUCT
  41
  42 #include "winerror.h"
  43 #include "windef.h"
  44 #include "winbase.h"
  45 #include "winnls.h"
  46 #include "winreg.h"
  47 #include "winuser.h"
  48
  49 #include "wine/unicode.h"
  50 #include "objbase.h"
  51 #include "typelib.h"
  52 #include "wine/debug.h"
  53
  54 WINE_DEFAULT_DEBUG_CHANNEL(typelib2);
  55 /* WINE_DEFAULT_DEBUG_CHANNEL(ole); */
  56
  57
  58 /******************************************************************************
  59  * ICreateTypeLib2 {OLEAUT32}
  60  *
  61  * NOTES
  62  *  The ICreateTypeLib2 interface provides an interface whereby one may create
  63  *  new type library (.tlb) files.
  64  *
  65  *  This interface inherits from ICreateTypeLib, and can be freely cast back
  66  *  and forth between an ICreateTypeLib and an ICreateTypeLib2 on local clients.
  67  *  This dispensation applies only to ICreateTypeLib objects obtained on MSFT
  68  *  format type libraries (those made through CreateTypeLib2).
  69  *
  70  * METHODS
  71  */
  72
  73 /******************************************************************************
  74  * ICreateTypeInfo2 {OLEAUT32}
  75  *
  76  * NOTES
  77  *  The ICreateTypeInfo2 interface provides an interface whereby one may add
  78  *  type information to type library (.tlb) files.
  79  *
  80  *  This interface inherits from ICreateTypeInfo, and can be freely cast back
  81  *  and forth between an ICreateTypeInfo and an ICreateTypeInfo2 on local clients.
  82  *  This dispensation applies only to ICreateTypeInfo objects obtained on MSFT
  83  *  format type libraries (those made through CreateTypeLib2).
  84  *
  85  * METHODS
  86  */
  87
  88 /******************************************************************************
  89  * ITypeLib2 {OLEAUT32}
  90  *
  91  * NOTES
  92  *  The ITypeLib2 interface provides an interface whereby one may query MSFT
  93  *  format type library (.tlb) files.
  94  *
  95  *  This interface inherits from ITypeLib, and can be freely cast back and
  96  *  forth between an ITypeLib and an ITypeLib2 on local clients. This
  97  *  dispensation applies only to ITypeLib objects obtained on MSFT format type
  98  *  libraries (those made through CreateTypeLib2).
  99  *
 100  * METHODS
 101  */
 102
 103 /******************************************************************************
 104  * ITypeInfo2 {OLEAUT32}
 105  *
 106  * NOTES
 107  *  The ITypeInfo2 interface provides an interface whereby one may query type
 108  *  information stored in MSFT format type library (.tlb) files.
 109  *
 110  *  This interface inherits from ITypeInfo, and can be freely cast back and
 111  *  forth between an ITypeInfo and an ITypeInfo2 on local clients. This
 112  *  dispensation applies only to ITypeInfo objects obtained on MSFT format type
 113  *  libraries (those made through CreateTypeLib2).
 114  *
 115  * METHODS
 116  */
 117
 118 /*================== Implementation Structures ===================================*/
 119
 120 /* Used for storing cyclic list. Tail address is kept */
 121 typedef struct tagCyclicList {
 122     struct tagCyclicList *next;
 123     int indice;
 124     int name;
 125
 126     union {
 127         int val;
 128         int *data;
 129     }u;
 130 } CyclicList;
 131
 132 enum MSFT_segment_index {
 133     MSFT_SEG_TYPEINFO = 0,  /* type information */
 134     MSFT_SEG_IMPORTINFO,    /* import information */
 135     MSFT_SEG_IMPORTFILES,   /* import filenames */
 136     MSFT_SEG_REFERENCES,    /* references (?) */
 137     MSFT_SEG_GUIDHASH,      /* hash table for guids? */
 138     MSFT_SEG_GUID,          /* guid storage */
 139     MSFT_SEG_NAMEHASH,      /* hash table for names */
 140     MSFT_SEG_NAME,          /* name storage */
 141     MSFT_SEG_STRING,        /* string storage */
 142     MSFT_SEG_TYPEDESC,      /* type descriptions */
 143     MSFT_SEG_ARRAYDESC,     /* array descriptions */
 144     MSFT_SEG_CUSTDATA,      /* custom data */
 145     MSFT_SEG_CUSTDATAGUID,  /* custom data guids */
 146     MSFT_SEG_UNKNOWN,       /* ??? */
 147     MSFT_SEG_UNKNOWN2,      /* ??? */
 148     MSFT_SEG_MAX            /* total number of segments */
 149 };
 150
 151 typedef struct tagMSFT_ImpFile {
 152     int guid;
 153     LCID lcid;
 154     int version;
 155     char filename[0]; /* preceded by two bytes of encoded (length << 2) + flags in the low two bits. */
 156 } MSFT_ImpFile;
 157
 158 typedef struct tagICreateTypeLib2Impl
 159 {
 160     const ICreateTypeLib2Vtbl *lpVtbl;
 161     const ITypeLib2Vtbl       *lpVtblTypeLib2;
 162
 163     LONG ref;
 164
 165     WCHAR *filename;
 166
 167     MSFT_Header typelib_header;
 168     INT helpStringDll;
 169     MSFT_pSeg typelib_segdir[MSFT_SEG_MAX];
 170     char *typelib_segment_data[MSFT_SEG_MAX];
 171     int typelib_segment_block_length[MSFT_SEG_MAX];
 172
 173     int typelib_guids; /* Number of defined typelib guids */
 174     int typeinfo_guids; /* Number of defined typeinfo guids */
 175
 176     INT typelib_typeinfo_offsets[0x200]; /* Hope that's enough. */
 177
 178     INT *typelib_namehash_segment;
 179     INT *typelib_guidhash_segment;
 180
 181     struct tagICreateTypeInfo2Impl *typeinfos;
 182     struct tagICreateTypeInfo2Impl *last_typeinfo;
 183 } ICreateTypeLib2Impl;
 184
 185 static inline ICreateTypeLib2Impl *impl_from_ITypeLib2( ITypeLib2 *iface )
 186 {
 187     return (ICreateTypeLib2Impl *)((char*)iface - FIELD_OFFSET(ICreateTypeLib2Impl, lpVtblTypeLib2));
 188 }
 189
 190 typedef struct tagICreateTypeInfo2Impl
 191 {
 192     const ICreateTypeInfo2Vtbl *lpVtbl;
 193     const ITypeInfo2Vtbl       *lpVtblTypeInfo2;
 194
 195     LONG ref;
 196
 197     ICreateTypeLib2Impl *typelib;
 198     MSFT_TypeInfoBase *typeinfo;
 199
 200     struct tagCyclicList *typedata; /* tail of cyclic list */
 201
 202     TYPEKIND typekind;
 203     int datawidth;
 204
 205     struct tagICreateTypeInfo2Impl *next_typeinfo;
 206     struct tagICreateTypeInfo2Impl *dual;
 207 } ICreateTypeInfo2Impl;
 208
 209 static inline ICreateTypeInfo2Impl *impl_from_ITypeInfo2( ITypeInfo2 *iface )
 210 {
 211     return (ICreateTypeInfo2Impl *)((char*)iface - FIELD_OFFSET(ICreateTypeInfo2Impl, lpVtblTypeInfo2));
 212 }
 213
 214 static ULONG WINAPI ICreateTypeLib2_fnRelease(ICreateTypeLib2 *iface);
 215
 216
 217 /*================== Internal functions ===================================*/
 218
 219 /****************************************************************************
 220  *      ctl2_init_header
 221  *
 222  *  Initializes the type library header of a new typelib.
 223  */
 224 static void ctl2_init_header(
 225         ICreateTypeLib2Impl *This) /* [I] The typelib to initialize. */
 226 {
 227     This->typelib_header.magic1 = 0x5446534d;
 228     This->typelib_header.magic2 = 0x00010002;
 229     This->typelib_header.posguid = -1;
 230     This->typelib_header.lcid = This->typelib_header.lcid2 = GetUserDefaultLCID();
 231     This->typelib_header.varflags = 0x40;
 232     This->typelib_header.version = 0;
 233     This->typelib_header.flags = 0;
 234     This->typelib_header.nrtypeinfos = 0;
 235     This->typelib_header.helpstring = -1;
 236     This->typelib_header.helpstringcontext = 0;
 237     This->typelib_header.helpcontext = 0;
 238     This->typelib_header.nametablecount = 0;
 239     This->typelib_header.nametablechars = 0;
 240     This->typelib_header.NameOffset = -1;
 241     This->typelib_header.helpfile = -1;
 242     This->typelib_header.CustomDataOffset = -1;
 243     This->typelib_header.res44 = 0x20;
 244     This->typelib_header.res48 = 0x80;
 245     This->typelib_header.dispatchpos = -1;
 246     This->typelib_header.nimpinfos = 0;
 247     This->helpStringDll = -1;
 248 }
 249
 250 /****************************************************************************
 251  *      ctl2_init_segdir
 252  *
 253  *  Initializes the segment directory of a new typelib.
 254  */
 255 static void ctl2_init_segdir(
 256         ICreateTypeLib2Impl *This) /* [I] The typelib to initialize. */
 257 {
 258     int i;
 259     MSFT_pSeg *segdir;
 260
 261     segdir = &This->typelib_segdir[MSFT_SEG_TYPEINFO];
 262
 263     for (i = 0; i < 15; i++) {
 264         segdir[i].offset = -1;
 265         segdir[i].length = 0;
 266         segdir[i].res08 = -1;
 267         segdir[i].res0c = 0x0f;
 268     }
 269 }
 270
 271 /****************************************************************************
 272  *      ctl2_hash_guid
 273  *
 274  *  Generates a hash key from a GUID.
 275  *
 276  * RETURNS
 277  *
 278  *  The hash key for the GUID.
 279  */
 280 static int ctl2_hash_guid(
 281         REFGUID guid)                /* [I] The guid to find. */
 282 {
 283     int hash;
 284     int i;
 285
 286     hash = 0;
 287     for (i = 0; i < 8; i ++) {
 288         hash ^= ((const short *)guid)[i];
 289     }
 290
 291     return hash & 0x1f;
 292 }
 293
 294 /****************************************************************************
 295  *      ctl2_find_guid
 296  *
 297  *  Locates a guid in a type library.
 298  *
 299  * RETURNS
 300  *
 301  *  The offset into the GUID segment of the guid, or -1 if not found.
 302  */
 303 static int ctl2_find_guid(
 304         ICreateTypeLib2Impl *This, /* [I] The typelib to operate against. */
 305         int hash_key,              /* [I] The hash key for the guid. */
 306         REFGUID guid)                /* [I] The guid to find. */
 307 {
 308     int offset;
 309     MSFT_GuidEntry *guidentry;
 310
 311     offset = This->typelib_guidhash_segment[hash_key];
 312     while (offset != -1) {
 313         guidentry = (MSFT_GuidEntry *)&This->typelib_segment_data[MSFT_SEG_GUID][offset];
 314
 315         if (!memcmp(guidentry, guid, sizeof(GUID))) return offset;
 316
 317         offset = guidentry->next_hash;
 318     }
 319
 320     return offset;
 321 }
 322
 323 /****************************************************************************
 324  *      ctl2_find_name
 325  *
 326  *  Locates a name in a type library.
 327  *
 328  * RETURNS
 329  *
 330  *  The offset into the NAME segment of the name, or -1 if not found.
 331  *
 332  * NOTES
 333  *
 334  *  The name must be encoded as with ctl2_encode_name().
 335  */
 336 static int ctl2_find_name(
 337         ICreateTypeLib2Impl *This, /* [I] The typelib to operate against. */
 338         const char *name)          /* [I] The encoded name to find. */
 339 {
 340     int offset;
 341     int *namestruct;
 342
 343     offset = This->typelib_namehash_segment[name[2] & 0x7f];
 344     while (offset != -1) {
 345         namestruct = (int *)&This->typelib_segment_data[MSFT_SEG_NAME][offset];
 346
 347         if (!((namestruct[2] ^ *((const int *)name)) & 0xffff00ff)) {
 348             /* hash codes and lengths match, final test */
 349             if (!strncasecmp(name+4, (void *)(namestruct+3), name[0])) break;
 350         }
 351
 352         /* move to next item in hash bucket */
 353         offset = namestruct[1];
 354     }
 355
 356     return offset;
 357 }
 358
 359 /****************************************************************************
 360  *      ctl2_encode_name
 361  *
 362  *  Encodes a name string to a form suitable for storing into a type library
 363  *  or comparing to a name stored in a type library.
 364  *
 365  * RETURNS
 366  *
 367  *  The length of the encoded name, including padding and length+hash fields.
 368  *
 369  * NOTES
 370  *
 371  *  Will throw an exception if name or result are NULL. Is not multithread
 372  *  safe in the slightest.
 373  */
 374 static int ctl2_encode_name(
 375         ICreateTypeLib2Impl *This, /* [I] The typelib to operate against (used for LCID only). */
 376         const WCHAR *name,         /* [I] The name string to encode. */
 377         char **result)             /* [O] A pointer to a pointer to receive the encoded name. */
 378 {
 379     int length;
 380     static char converted_name[0x104];
 381     int offset;
 382     int value;
 383
 384     length = WideCharToMultiByte(CP_ACP, 0, name, strlenW(name), converted_name+4, 0x100, NULL, NULL);
 385     converted_name[0] = length & 0xff;
 386
 387     converted_name[length + 4] = 0;
 388
 389     converted_name[1] = 0x00;
 390
 391     value = LHashValOfNameSysA(This->typelib_header.varflags & 0x0f, This->typelib_header.lcid, converted_name + 4);
 392
 393     converted_name[2] = value;
 394     converted_name[3] = value >> 8;
 395
 396     for (offset = (4 - length) & 3; offset; offset--) converted_name[length + offset + 3] = 0x57;
 397
 398     *result = converted_name;
 399
 400     return (length + 7) & ~3;
 401 }
 402
 403 /****************************************************************************
 404  *      ctl2_decode_name
 405  *
 406  * Converts string stored in typelib data to unicode.
 407  */
 408 static void ctl2_decode_name(
 409         char *data,         /* [I] String to be decoded */
 410         WCHAR **string)     /* [O] Decoded string */
 411 {
 412     int i, length;
 413     static WCHAR converted_string[0x104];
 414
 415     length = data[0];
 416
 417     for(i=0; i<length; i++)
 418         converted_string[i] = data[i+4];
 419     converted_string[length] = '\0';
 420
 421     *string = converted_string;
 422 }
 423
 424 /****************************************************************************
 425  *      ctl2_encode_string
 426  *
 427  *  Encodes a string to a form suitable for storing into a type library or
 428  *  comparing to a string stored in a type library.
 429  *
 430  * RETURNS
 431  *
 432  *  The length of the encoded string, including padding and length fields.
 433  *
 434  * NOTES
 435  *
 436  *  Will throw an exception if string or result are NULL. Is not multithread
 437  *  safe in the slightest.
 438  */
 439 static int ctl2_encode_string(
 440         ICreateTypeLib2Impl *This, /* [I] The typelib to operate against (not used?). */
 441         const WCHAR *string,       /* [I] The string to encode. */
 442         char **result)             /* [O] A pointer to a pointer to receive the encoded string. */
 443 {
 444     int length;
 445     static char converted_string[0x104];
 446     int offset;
 447
 448     length = WideCharToMultiByte(CP_ACP, 0, string, strlenW(string), converted_string+2, 0x102, NULL, NULL);
 449     converted_string[0] = length & 0xff;
 450     converted_string[1] = (length >> 8) & 0xff;
 451
 452     for (offset = (4 - (length + 2)) & 3; offset; offset--) converted_string[length + offset + 1] = 0x57;
 453
 454     *result = converted_string;
 455
 456     return (length + 5) & ~3;
 457 }
 458
 459 /****************************************************************************
 460  *      ctl2_decode_string
 461  *
 462  * Converts string stored in typelib data to unicode.
 463  */
 464 static void ctl2_decode_string(
 465         char *data,         /* [I] String to be decoded */
 466         WCHAR **string)     /* [O] Decoded string */
 467 {
 468     int i, length;
 469     static WCHAR converted_string[0x104];
 470
 471     length = data[0] + (data[1]<<8);
 472     if((length&0x3) == 1)
 473         length >>= 2;
 474
 475     for(i=0; i<length; i++)
 476         converted_string[i] = data[i+2];
 477     converted_string[length] = '\0';
 478
 479     *string = converted_string;
 480 }
 481
 482 /****************************************************************************
 483  *      ctl2_alloc_segment
 484  *
 485  *  Allocates memory from a segment in a type library.
 486  *
 487  * RETURNS
 488  *
 489  *  Success: The offset within the segment of the new data area.
 490  *  Failure: -1 (this is invariably an out of memory condition).
 491  *
 492  * BUGS
 493  *
 494  *  Does not (yet) handle the case where the allocated segment memory needs to grow.
 495  */
 496 static int ctl2_alloc_segment(
 497         ICreateTypeLib2Impl *This,       /* [I] The type library in which to allocate. */
 498         enum MSFT_segment_index segment, /* [I] The segment in which to allocate. */
 499         int size,                        /* [I] The amount to allocate. */
 500         int block_size)                  /* [I] Initial allocation block size, or 0 for default. */
 501 {
 502     int offset;
 503
 504     if(!This->typelib_segment_data[segment]) {
 505         if (!block_size) block_size = 0x2000;
 506
 507         This->typelib_segment_block_length[segment] = block_size;
 508         This->typelib_segment_data[segment] = HeapAlloc(GetProcessHeap(), 0, block_size);
 509         if (!This->typelib_segment_data[segment]) return -1;
 510         memset(This->typelib_segment_data[segment], 0x57, block_size);
 511     }
 512
 513     while ((This->typelib_segdir[segment].length + size) > This->typelib_segment_block_length[segment]) {
 514         char *block;
 515
 516         block_size = This->typelib_segment_block_length[segment];
 517         block = HeapReAlloc(GetProcessHeap(), 0, This->typelib_segment_data[segment], block_size << 1);
 518         if (!block) return -1;
 519
 520         if (segment == MSFT_SEG_TYPEINFO) {
 521             /* TypeInfos have a direct pointer to their memory space, so we have to fix them up. */
 522             ICreateTypeInfo2Impl *typeinfo;
 523
 524             for (typeinfo = This->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
 525                 typeinfo->typeinfo = (void *)&block[((char *)typeinfo->typeinfo) - This->typelib_segment_data[segment]];
 526             }
 527         }
 528
 529         memset(block + block_size, 0x57, block_size);
 530         This->typelib_segment_block_length[segment] = block_size << 1;
 531         This->typelib_segment_data[segment] = block;
 532     }
 533
 534     offset = This->typelib_segdir[segment].length;
 535     This->typelib_segdir[segment].length += size;
 536
 537     return offset;
 538 }
 539
 540 /****************************************************************************
 541  *      ctl2_alloc_typeinfo
 542  *
 543  *  Allocates and initializes a typeinfo structure in a type library.
 544  *
 545  * RETURNS
 546  *
 547  *  Success: The offset of the new typeinfo.
 548  *  Failure: -1 (this is invariably an out of memory condition).
 549  */
 550 static int ctl2_alloc_typeinfo(
 551         ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
 552         int nameoffset)            /* [I] The offset of the name for this typeinfo. */
 553 {
 554     int offset;
 555     MSFT_TypeInfoBase *typeinfo;
 556
 557     offset = ctl2_alloc_segment(This, MSFT_SEG_TYPEINFO, sizeof(MSFT_TypeInfoBase), 0);
 558     if (offset == -1) return -1;
 559
 560     This->typelib_typeinfo_offsets[This->typelib_header.nrtypeinfos++] = offset;
 561
 562     typeinfo = (void *)(This->typelib_segment_data[MSFT_SEG_TYPEINFO] + offset);
 563
 564     typeinfo->typekind = (This->typelib_header.nrtypeinfos - 1) << 16;
 565     typeinfo->memoffset = -1; /* should be EOF if no elements */
 566     typeinfo->res2 = 0;
 567     typeinfo->res3 = 0;
 568     typeinfo->res4 = 3;
 569     typeinfo->res5 = 0;
 570     typeinfo->cElement = 0;
 571     typeinfo->res7 = 0;
 572     typeinfo->res8 = 0;
 573     typeinfo->res9 = 0;
 574     typeinfo->resA = 0;
 575     typeinfo->posguid = -1;
 576     typeinfo->flags = 0;
 577     typeinfo->NameOffset = nameoffset;
 578     typeinfo->version = 0;
 579     typeinfo->docstringoffs = -1;
 580     typeinfo->helpstringcontext = 0;
 581     typeinfo->helpcontext = 0;
 582     typeinfo->oCustData = -1;
 583     typeinfo->cbSizeVft = 0;
 584     typeinfo->cImplTypes = 0;
 585     typeinfo->size = 0;
 586     typeinfo->datatype1 = -1;
 587     typeinfo->datatype2 = 0;
 588     typeinfo->res18 = 0;
 589     typeinfo->res19 = -1;
 590
 591     return offset;
 592 }
 593
 594 /****************************************************************************
 595  *      ctl2_alloc_guid
 596  *
 597  *  Allocates and initializes a GUID structure in a type library. Also updates
 598  *  the GUID hash table as needed.
 599  *
 600  * RETURNS
 601  *
 602  *  Success: The offset of the new GUID.
 603  *  Failure: -1 (this is invariably an out of memory condition).
 604  */
 605 static int ctl2_alloc_guid(
 606         ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
 607         MSFT_GuidEntry *guid)      /* [I] The GUID to store. */
 608 {
 609     int offset;
 610     MSFT_GuidEntry *guid_space;
 611     int hash_key;
 612
 613     hash_key = ctl2_hash_guid(&guid->guid);
 614
 615     offset = ctl2_find_guid(This, hash_key, &guid->guid);
 616     if (offset != -1) return offset;
 617
 618     offset = ctl2_alloc_segment(This, MSFT_SEG_GUID, sizeof(MSFT_GuidEntry), 0);
 619     if (offset == -1) return -1;
 620
 621     guid_space = (void *)(This->typelib_segment_data[MSFT_SEG_GUID] + offset);
 622     *guid_space = *guid;
 623
 624     guid_space->next_hash = This->typelib_guidhash_segment[hash_key];
 625     This->typelib_guidhash_segment[hash_key] = offset;
 626
 627     return offset;
 628 }
 629
 630 /****************************************************************************
 631  *      ctl2_alloc_name
 632  *
 633  *  Allocates and initializes a name within a type library. Also updates the
 634  *  name hash table as needed.
 635  *
 636  * RETURNS
 637  *
 638  *  Success: The offset within the segment of the new name.
 639  *  Failure: -1 (this is invariably an out of memory condition).
 640  */
 641 static int ctl2_alloc_name(
 642         ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
 643         const WCHAR *name)         /* [I] The name to store. */
 644 {
 645     int length;
 646     int offset;
 647     MSFT_NameIntro *name_space;
 648     char *encoded_name;
 649
 650     length = ctl2_encode_name(This, name, &encoded_name);
 651
 652     offset = ctl2_find_name(This, encoded_name);
 653     if (offset != -1) return offset;
 654
 655     offset = ctl2_alloc_segment(This, MSFT_SEG_NAME, length + 8, 0);
 656     if (offset == -1) return -1;
 657
 658     name_space = (void *)(This->typelib_segment_data[MSFT_SEG_NAME] + offset);
 659     name_space->hreftype = -1;
 660     name_space->next_hash = -1;
 661     memcpy(&name_space->namelen, encoded_name, length);
 662
 663     if (This->typelib_namehash_segment[encoded_name[2] & 0x7f] != -1)
 664         name_space->next_hash = This->typelib_namehash_segment[encoded_name[2] & 0x7f];
 665
 666     This->typelib_namehash_segment[encoded_name[2] & 0x7f] = offset;
 667
 668     This->typelib_header.nametablecount += 1;
 669     This->typelib_header.nametablechars += *encoded_name;
 670
 671     return offset;
 672 }
 673
 674 /****************************************************************************
 675  *      ctl2_alloc_string
 676  *
 677  *  Allocates and initializes a string in a type library.
 678  *
 679  * RETURNS
 680  *
 681  *  Success: The offset within the segment of the new string.
 682  *  Failure: -1 (this is invariably an out of memory condition).
 683  */
 684 static int ctl2_alloc_string(
 685         ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
 686         const WCHAR *string)       /* [I] The string to store. */
 687 {
 688     int length;
 689     int offset;
 690     char *string_space;
 691     char *encoded_string;
 692
 693     length = ctl2_encode_string(This, string, &encoded_string);
 694
 695     for (offset = 0; offset < This->typelib_segdir[MSFT_SEG_STRING].length;
 696          offset += ((((This->typelib_segment_data[MSFT_SEG_STRING][offset + 1] << 8) & 0xff)
 697              | (This->typelib_segment_data[MSFT_SEG_STRING][offset + 0] & 0xff)) + 5) & ~3) {
 698         if (!memcmp(encoded_string, This->typelib_segment_data[MSFT_SEG_STRING] + offset, length)) return offset;
 699     }
 700
 701     offset = ctl2_alloc_segment(This, MSFT_SEG_STRING, length, 0);
 702     if (offset == -1) return -1;
 703
 704     string_space = This->typelib_segment_data[MSFT_SEG_STRING] + offset;
 705     memcpy(string_space, encoded_string, length);
 706
 707     return offset;
 708 }
 709
 710 /****************************************************************************
 711  *      ctl2_alloc_importinfo
 712  *
 713  *  Allocates and initializes an import information structure in a type library.
 714  *
 715  * RETURNS
 716  *
 717  *  Success: The offset of the new importinfo.
 718  *  Failure: -1 (this is invariably an out of memory condition).
 719  */
 720 static int ctl2_alloc_importinfo(
 721         ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
 722         MSFT_ImpInfo *impinfo)     /* [I] The import information to store. */
 723 {
 724     int offset;
 725     MSFT_ImpInfo *impinfo_space;
 726
 727     impinfo_space = (MSFT_ImpInfo*)&This->typelib_segment_data[MSFT_SEG_IMPORTINFO][0];
 728     for (offset=0; offset<This->typelib_segdir[MSFT_SEG_IMPORTINFO].length;
 729             offset+=sizeof(MSFT_ImpInfo)) {
 730         if(impinfo_space->oImpFile == impinfo->oImpFile
 731                 && impinfo_space->oGuid == impinfo->oGuid)
 732             return offset;
 733
 734         impinfo_space += 1;
 735     }
 736
 737     impinfo->flags |= This->typelib_header.nimpinfos++;
 738
 739     offset = ctl2_alloc_segment(This, MSFT_SEG_IMPORTINFO, sizeof(MSFT_ImpInfo), 0);
 740     if (offset == -1) return -1;
 741
 742     impinfo_space = (void *)(This->typelib_segment_data[MSFT_SEG_IMPORTINFO] + offset);
 743     *impinfo_space = *impinfo;
 744
 745     return offset;
 746 }
 747
 748 /****************************************************************************
 749  *      ctl2_alloc_importfile
 750  *
 751  *  Allocates and initializes an import file definition in a type library.
 752  *
 753  * RETURNS
 754  *
 755  *  Success: The offset of the new importinfo.
 756  *  Failure: -1 (this is invariably an out of memory condition).
 757  */
 758 static int ctl2_alloc_importfile(
 759         ICreateTypeLib2Impl *This, /* [I] The type library to allocate in. */
 760         int guidoffset,            /* [I] The offset to the GUID for the imported library. */
 761         LCID lcid,                 /* [I] The LCID of imported library. */
 762         int major_version,         /* [I] The major version number of the imported library. */
 763         int minor_version,         /* [I] The minor version number of the imported library. */
 764         const WCHAR *filename)     /* [I] The filename of the imported library. */
 765 {
 766     int length;
 767     int offset;
 768     MSFT_ImpFile *importfile;
 769     char *encoded_string;
 770
 771     length = ctl2_encode_string(This, filename, &encoded_string);
 772
 773     encoded_string[0] <<= 2;
 774     encoded_string[0] |= 1;
 775
 776     for (offset = 0; offset < This->typelib_segdir[MSFT_SEG_IMPORTFILES].length;
 777          offset += ((((This->typelib_segment_data[MSFT_SEG_IMPORTFILES][offset + 0xd] << 8) & 0xff)
 778              | (This->typelib_segment_data[MSFT_SEG_IMPORTFILES][offset + 0xc] & 0xff)) >> 2) + 0xc) {
 779         if (!memcmp(encoded_string, This->typelib_segment_data[MSFT_SEG_IMPORTFILES] + offset + 0xc, length)) return offset;
 780     }
 781
 782     offset = ctl2_alloc_segment(This, MSFT_SEG_IMPORTFILES, length + 0xc, 0);
 783     if (offset == -1) return -1;
 784
 785     importfile = (MSFT_ImpFile *)&This->typelib_segment_data[MSFT_SEG_IMPORTFILES][offset];
 786     importfile->guid = guidoffset;
 787     importfile->lcid = lcid;
 788     importfile->version = major_version | (minor_version << 16);
 789     memcpy(importfile->filename, encoded_string, length);
 790
 791     return offset;
 792 }
 793
 794 /****************************************************************************
 795  *      ctl2_alloc_custdata
 796  *
 797  *  Allocates and initializes a "custom data" value in a type library.
 798  *
 799  * RETURNS
 800  *
 801  *  Success: The offset of the new custdata.
 802  *  Failure:
 803  *
 804  *    -1: Out of memory.
 805  *    -2: Unable to encode VARIANT data (typically a bug).
 806  */
 807 static int ctl2_alloc_custdata(
 808         ICreateTypeLib2Impl *This, /* [I] The type library in which to encode the value. */
 809         VARIANT *pVarVal)          /* [I] The value to encode. */
 810 {
 811     int offset;
 812
 813     TRACE("(%p,%p(%d))\n",This,pVarVal,V_VT(pVarVal));
 814
 815     switch (V_VT(pVarVal)) {
 816     case VT_UI4:
 817         offset = ctl2_alloc_segment(This, MSFT_SEG_CUSTDATA, 8, 0);
 818         if (offset == -1) return offset;
 819
 820         *((unsigned short *)&This->typelib_segment_data[MSFT_SEG_CUSTDATA][offset]) = VT_UI4;
 821         *((unsigned int *)&This->typelib_segment_data[MSFT_SEG_CUSTDATA][offset+2]) = V_UI4(pVarVal);
 822         break;
 823
 824     default:
 825         FIXME("Unknown variable encoding vt %d.\n", V_VT(pVarVal));
 826         return -2;
 827     }
 828
 829     return offset;
 830 }
 831
 832 /****************************************************************************
 833  *      ctl2_set_custdata
 834  *
 835  *  Adds a custom data element to an object in a type library.
 836  *
 837  * RETURNS
 838  *
 839  *  Success: S_OK.
 840  *  Failure: One of E_INVALIDARG or E_OUTOFMEMORY.
 841  */
 842 static HRESULT ctl2_set_custdata(
 843         ICreateTypeLib2Impl *This, /* [I] The type library to store the custom data in. */
 844         REFGUID guid,              /* [I] The GUID used as a key to retrieve the custom data. */
 845         VARIANT *pVarVal,          /* [I] The custom data itself. */
 846         int *offset)               /* [I/O] The list of custom data to prepend to. */
 847 {
 848     MSFT_GuidEntry guidentry;
 849     int dataoffset;
 850     int guidoffset;
 851     int custoffset;
 852     int *custdata;
 853
 854     guidentry.guid = *guid;
 855
 856     guidentry.hreftype = -1;
 857     guidentry.next_hash = -1;
 858
 859     guidoffset = ctl2_alloc_guid(This, &guidentry);
 860     if (guidoffset == -1) return E_OUTOFMEMORY;
 861     dataoffset = ctl2_alloc_custdata(This, pVarVal);
 862     if (dataoffset == -1) return E_OUTOFMEMORY;
 863     if (dataoffset == -2) return E_INVALIDARG;
 864
 865     custoffset = ctl2_alloc_segment(This, MSFT_SEG_CUSTDATAGUID, 12, 0);
 866     if (custoffset == -1) return E_OUTOFMEMORY;
 867
 868     custdata = (int *)&This->typelib_segment_data[MSFT_SEG_CUSTDATAGUID][custoffset];
 869     custdata[0] = guidoffset;
 870     custdata[1] = dataoffset;
 871     custdata[2] = *offset;
 872     *offset = custoffset;
 873
 874     return S_OK;
 875 }
 876
 877 /****************************************************************************
 878  *      ctl2_encode_typedesc
 879  *
 880  *  Encodes a type description, storing information in the TYPEDESC and ARRAYDESC
 881  *  segments as needed.
 882  *
 883  * RETURNS
 884  *
 885  *  Success: 0.
 886  *  Failure: -1.
 887  */
 888 static int ctl2_encode_typedesc(
 889         ICreateTypeLib2Impl *This, /* [I] The type library in which to encode the TYPEDESC. */
 890         const TYPEDESC *tdesc,     /* [I] The type description to encode. */
 891         int *encoded_tdesc,        /* [O] The encoded type description. */
 892         int *width,                /* [O] The width of the type, or NULL. */
 893         int *alignment,            /* [O] The alignment of the type, or NULL. */
 894         int *decoded_size)         /* [O] The total size of the unencoded TYPEDESCs, including nested descs. */
 895 {
 896     int default_tdesc;
 897     int scratch;
 898     int typeoffset;
 899     int arrayoffset;
 900     int *typedata;
 901     int *arraydata;
 902     int target_type;
 903     int child_size;
 904
 905     default_tdesc = 0x80000000 | (tdesc->vt << 16) | tdesc->vt;
 906     if (!width) width = &scratch;
 907     if (!alignment) alignment = &scratch;
 908     if (!decoded_size) decoded_size = &scratch;
 909
 910     *decoded_size = 0;
 911
 912     switch (tdesc->vt) {
 913     case VT_UI1:
 914     case VT_I1:
 915         *encoded_tdesc = default_tdesc;
 916         *width = 1;
 917         *alignment = 1;
 918         break;
 919
 920     case VT_INT:
 921         *encoded_tdesc = 0x80000000 | (VT_I4 << 16) | VT_INT;
 922         if ((This->typelib_header.varflags & 0x0f) == SYS_WIN16) {
 923             *width = 2;
 924             *alignment = 2;
 925         } else {
 926             *width = 4;
 927             *alignment = 4;
 928         }
 929         break;
 930
 931     case VT_UINT:
 932         *encoded_tdesc = 0x80000000 | (VT_UI4 << 16) | VT_UINT;
 933         if ((This->typelib_header.varflags & 0x0f) == SYS_WIN16) {
 934             *width = 2;
 935             *alignment = 2;
 936         } else {
 937             *width = 4;
 938             *alignment = 4;
 939         }
 940         break;
 941
 942     case VT_UI2:
 943     case VT_I2:
 944     case VT_BOOL:
 945         *encoded_tdesc = default_tdesc;
 946         *width = 2;
 947         *alignment = 2;
 948         break;
 949
 950     case VT_I4:
 951     case VT_UI4:
 952     case VT_R4:
 953     case VT_ERROR:
 954     case VT_BSTR:
 955     case VT_HRESULT:
 956         *encoded_tdesc = default_tdesc;
 957         *width = 4;
 958         *alignment = 4;
 959         break;
 960
 961     case VT_CY:
 962         *encoded_tdesc = default_tdesc;
 963         *width = 8;
 964         *alignment = 4; /* guess? */
 965         break;
 966
 967     case VT_VOID:
 968         *encoded_tdesc = 0x80000000 | (VT_EMPTY << 16) | tdesc->vt;
 969         *width = 0;
 970         *alignment = 1;
 971         break;
 972
 973     case VT_PTR:
 974         /* FIXME: Make with the error checking. */
 975         FIXME("PTR vartype, may not work correctly.\n");
 976
 977         ctl2_encode_typedesc(This, tdesc->u.lptdesc, &target_type, NULL, NULL, &child_size);
 978
 979         for (typeoffset = 0; typeoffset < This->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
 980             typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
 981             if (((typedata[0] & 0xffff) == VT_PTR) && (typedata[1] == target_type)) break;
 982         }
 983
 984         if (typeoffset == This->typelib_segdir[MSFT_SEG_TYPEDESC].length) {
 985             int mix_field;
 986
 987             if (target_type & 0x80000000) {
 988                 mix_field = ((target_type >> 16) & 0x3fff) | VT_BYREF;
 989             } else {
 990                 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][target_type];
 991                 mix_field = ((typedata[0] >> 16) == 0x7fff)? 0x7fff: 0x7ffe;
 992             }
 993
 994             typeoffset = ctl2_alloc_segment(This, MSFT_SEG_TYPEDESC, 8, 0);
 995             typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
 996
 997             typedata[0] = (mix_field << 16) | VT_PTR;
 998             typedata[1] = target_type;
 999         }
1000
1001         *encoded_tdesc = typeoffset;
1002
1003         *width = 4;
1004         *alignment = 4;
1005         *decoded_size = sizeof(TYPEDESC) + child_size;
1006         break;
1007
1008     case VT_SAFEARRAY:
1009         /* FIXME: Make with the error checking. */
1010         FIXME("SAFEARRAY vartype, may not work correctly.\n");
1011
1012         ctl2_encode_typedesc(This, tdesc->u.lptdesc, &target_type, NULL, NULL, &child_size);
1013
1014         for (typeoffset = 0; typeoffset < This->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
1015             typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1016             if (((typedata[0] & 0xffff) == VT_SAFEARRAY) && (typedata[1] == target_type)) break;
1017         }
1018
1019         if (typeoffset == This->typelib_segdir[MSFT_SEG_TYPEDESC].length) {
1020             int mix_field;
1021
1022             if (target_type & 0x80000000) {
1023                 mix_field = ((target_type >> 16) & VT_TYPEMASK) | VT_ARRAY;
1024             } else {
1025                 typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][target_type];
1026                 mix_field = ((typedata[0] >> 16) == 0x7fff)? 0x7fff: 0x7ffe;
1027             }
1028
1029             typeoffset = ctl2_alloc_segment(This, MSFT_SEG_TYPEDESC, 8, 0);
1030             typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1031
1032             typedata[0] = (mix_field << 16) | VT_SAFEARRAY;
1033             typedata[1] = target_type;
1034         }
1035
1036         *encoded_tdesc = typeoffset;
1037
1038         *width = 4;
1039         *alignment = 4;
1040         *decoded_size = sizeof(TYPEDESC) + child_size;
1041         break;
1042
1043     case VT_CARRAY:
1044       {
1045         /* FIXME: Make with the error checking. */
1046         int num_dims = tdesc->u.lpadesc->cDims, elements = 1, dim;
1047
1048         ctl2_encode_typedesc(This, &tdesc->u.lpadesc->tdescElem, &target_type, width, alignment, NULL);
1049         arrayoffset = ctl2_alloc_segment(This, MSFT_SEG_ARRAYDESC, (2 + 2 * num_dims) * sizeof(int), 0);
1050         arraydata = (void *)&This->typelib_segment_data[MSFT_SEG_ARRAYDESC][arrayoffset];
1051
1052         arraydata[0] = target_type;
1053         arraydata[1] = num_dims;
1054         arraydata[1] |= ((num_dims * 2 * sizeof(int)) << 16);
1055         arraydata += 2;
1056
1057         for(dim = 0; dim < num_dims; dim++) {
1058             arraydata[0] = tdesc->u.lpadesc->rgbounds[dim].cElements;
1059             arraydata[1] = tdesc->u.lpadesc->rgbounds[dim].lLbound;
1060             elements *= tdesc->u.lpadesc->rgbounds[dim].cElements;
1061             arraydata += 2;
1062         }
1063         typeoffset = ctl2_alloc_segment(This, MSFT_SEG_TYPEDESC, 8, 0);
1064         typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1065
1066         typedata[0] = (0x7ffe << 16) | VT_CARRAY;
1067         typedata[1] = arrayoffset;
1068
1069         *encoded_tdesc = typeoffset;
1070         *width = *width * elements;
1071         *decoded_size = sizeof(ARRAYDESC) + (num_dims - 1) * sizeof(SAFEARRAYBOUND);
1072
1073         break;
1074       }
1075     case VT_USERDEFINED:
1076         TRACE("USERDEFINED.\n");
1077         for (typeoffset = 0; typeoffset < This->typelib_segdir[MSFT_SEG_TYPEDESC].length; typeoffset += 8) {
1078             typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1079             if ((typedata[0] == ((0x7fff << 16) | VT_USERDEFINED)) && (typedata[1] == tdesc->u.hreftype)) break;
1080         }
1081
1082         if (typeoffset == This->typelib_segdir[MSFT_SEG_TYPEDESC].length) {
1083             typeoffset = ctl2_alloc_segment(This, MSFT_SEG_TYPEDESC, 8, 0);
1084             typedata = (void *)&This->typelib_segment_data[MSFT_SEG_TYPEDESC][typeoffset];
1085
1086             typedata[0] = (0x7fff << 16) | VT_USERDEFINED;
1087             typedata[1] = tdesc->u.hreftype;
1088         }
1089
1090         *encoded_tdesc = typeoffset;
1091         *width = 0;
1092         *alignment = 1;
1093         break;
1094
1095     default:
1096         FIXME("Unrecognized type %d.\n", tdesc->vt);
1097         *encoded_tdesc = default_tdesc;
1098         *width = 0;
1099         *alignment = 1;
1100         break;
1101     }
1102
1103     return 0;
1104 }
1105
1106 /****************************************************************************
1107  *      ctl2_find_nth_reference
1108  *
1109  *  Finds a reference by index into the linked list of reference records.
1110  *
1111  * RETURNS
1112  *
1113  *  Success: Offset of the desired reference record.
1114  *  Failure: -1.
1115  */
1116 static int ctl2_find_nth_reference(
1117         ICreateTypeLib2Impl *This, /* [I] The type library in which to search. */
1118         int offset,                /* [I] The starting offset of the reference list. */
1119         int index)                 /* [I] The index of the reference to find. */
1120 {
1121     MSFT_RefRecord *ref;
1122
1123     for (; index && (offset != -1); index--) {
1124         ref = (MSFT_RefRecord *)&This->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
1125         offset = ref->onext;
1126     }
1127
1128     return offset;
1129 }
1130
1131 /****************************************************************************
1132  *      ctl2_find_typeinfo_from_offset
1133  *
1134  *  Finds an ITypeInfo given an offset into the TYPEINFO segment.
1135  *
1136  * RETURNS
1137  *
1138  *  Success: S_OK.
1139  *  Failure: TYPE_E_ELEMENTNOTFOUND.
1140  */
1141 static HRESULT ctl2_find_typeinfo_from_offset(
1142         ICreateTypeLib2Impl *This, /* [I] The typelib to find the typeinfo in. */
1143         int offset,                /* [I] The offset of the desired typeinfo. */
1144         ITypeInfo **ppTinfo)       /* [I] The typeinfo found. */
1145 {
1146     void *typeinfodata;
1147     ICreateTypeInfo2Impl *typeinfo;
1148
1149     typeinfodata = &This->typelib_segment_data[MSFT_SEG_TYPEINFO][offset];
1150
1151     for (typeinfo = This->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
1152         if (typeinfo->typeinfo == typeinfodata) {
1153             *ppTinfo = (ITypeInfo *)&typeinfo->lpVtblTypeInfo2;
1154             ITypeInfo2_AddRef(*ppTinfo);
1155             return S_OK;
1156         }
1157     }
1158
1159     ERR("Failed to find typeinfo, invariant varied.\n");
1160
1161     return TYPE_E_ELEMENTNOTFOUND;
1162 }
1163
1164 /****************************************************************************
1165  *      ctl2_add_default_value
1166  *
1167  *  Adds default value of an argument
1168  *
1169  * RETURNS
1170  *
1171  *  Success: S_OK
1172  *  Failure: Error code from winerror.h
1173  */
1174 static HRESULT ctl2_add_default_value(
1175         ICreateTypeLib2Impl *This, /* [I] The typelib to allocate data in */
1176         int *encoded_value,        /* [O] The encoded default value or data offset */
1177         VARIANT *value,            /* [I] Default value to be encoded */
1178         VARTYPE arg_type)          /* [I] Argument type */
1179 {
1180     VARIANT v;
1181     HRESULT hres;
1182     int mask = 0;
1183
1184     TRACE("%p %d %d\n", This, V_VT(value), arg_type);
1185
1186     if(arg_type == VT_INT)
1187         arg_type = VT_I4;
1188     if(arg_type == VT_UINT)
1189         arg_type = VT_UI4;
1190
1191     v = *value;
1192     if(V_VT(value) != arg_type) {
1193         hres = VariantChangeType(&v, value, 0, arg_type);
1194         if(FAILED(hres))
1195             return hres;
1196     }
1197
1198     /* Check if default value can be stored in encoded_value */
1199     switch(arg_type) {
1200     case VT_I4:
1201     case VT_UI4:
1202         mask = 0x3ffffff;
1203         if(V_UI4(&v)>0x3ffffff)
1204             break;
1205     case VT_I1:
1206     case VT_UI1:
1207     case VT_BOOL:
1208          if(!mask)
1209              mask = 0xff;
1210     case VT_I2:
1211     case VT_UI2:
1212         if(!mask)
1213             mask = 0xffff;
1214         *encoded_value = (V_UI4(&v)&mask) | ((0x80+0x4*arg_type)<<24);
1215         return S_OK;
1216     }
1217
1218     switch(arg_type) {
1219     case VT_I4:
1220     case VT_R4:
1221     case VT_UI4:
1222     case VT_INT:
1223     case VT_UINT:
1224     case VT_HRESULT:
1225     case VT_PTR: {
1226         /* Construct the data to be allocated */
1227         int data[2];
1228         data[0] = arg_type + (V_UI4(&v)<<16);
1229         data[1] = (V_UI4(&v)>>16) + 0x57570000;
1230
1231         /* Check if the data was already allocated */
1232         /* Currently the structures doesn't allow to do it in a nice way */
1233         for(*encoded_value=0; *encoded_value<=This->typelib_segdir[MSFT_SEG_CUSTDATA].length-8; *encoded_value+=4)
1234             if(!memcmp(&This->typelib_segment_data[MSFT_SEG_CUSTDATA][*encoded_value], data, 8))
1235                 return S_OK;
1236
1237         /* Allocate the data */
1238         *encoded_value = ctl2_alloc_segment(This, MSFT_SEG_CUSTDATA, 8, 0);
1239         if(*encoded_value == -1)
1240             return E_OUTOFMEMORY;
1241
1242         memcpy(&This->typelib_segment_data[MSFT_SEG_CUSTDATA][*encoded_value], data, 8);
1243         return S_OK;
1244     }
1245     case VT_BSTR: {
1246         /* Construct the data */
1247         int i, len = (6+SysStringLen(V_BSTR(&v))+3) & ~0x3;
1248         char *data = HeapAlloc(GetProcessHeap(), 0, len);
1249
1250         if(!data)
1251             return E_OUTOFMEMORY;
1252
1253         *((unsigned short*)data) = arg_type;
1254         *((unsigned*)(data+2)) = SysStringLen(V_BSTR(&v));
1255         for(i=0; i<SysStringLen(V_BSTR(&v)); i++) {
1256             if(V_BSTR(&v)[i] <= 0x7f)
1257                 data[i+6] = V_BSTR(&v)[i];
1258             else
1259                 data[i+6] = '?';
1260         }
1261         WideCharToMultiByte(CP_ACP, 0, V_BSTR(&v), SysStringLen(V_BSTR(&v)), &data[6], len-6, NULL, NULL);
1262         for(i=6+SysStringLen(V_BSTR(&v)); i<len; i++)
1263             data[i] = 0x57;
1264
1265         /* Check if the data was already allocated */
1266         for(*encoded_value=0; *encoded_value<=This->typelib_segdir[MSFT_SEG_CUSTDATA].length-len; *encoded_value+=4)
1267             if(!memcmp(&This->typelib_segment_data[MSFT_SEG_CUSTDATA][*encoded_value], data, len)) {
1268                 HeapFree(GetProcessHeap(), 0, data);
1269                 return S_OK;
1270             }
1271
1272         /* Allocate the data */
1273         *encoded_value = ctl2_alloc_segment(This, MSFT_SEG_CUSTDATA, len, 0);
1274         if(*encoded_value == -1) {
1275             HeapFree(GetProcessHeap(), 0, data);
1276             return E_OUTOFMEMORY;
1277         }
1278
1279         memcpy(&This->typelib_segment_data[MSFT_SEG_CUSTDATA][*encoded_value], data, len);
1280         HeapFree(GetProcessHeap(), 0, data);
1281         return S_OK;
1282     }
1283     default:
1284         FIXME("Argument type not yet handled\n");
1285         return E_NOTIMPL;
1286     }
1287 }
1288
1289 /*================== ICreateTypeInfo2 Implementation ===================================*/
1290
1291 /******************************************************************************
1292  * ICreateTypeInfo2_QueryInterface {OLEAUT32}
1293  *
1294  *  See IUnknown_QueryInterface.
1295  */
1296 static HRESULT WINAPI ICreateTypeInfo2_fnQueryInterface(
1297         ICreateTypeInfo2 * iface,
1298         REFIID riid,
1299         VOID **ppvObject)
1300 {
1301     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1302
1303     TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
1304
1305     *ppvObject=NULL;
1306     if(IsEqualIID(riid, &IID_IUnknown) ||
1307        IsEqualIID(riid,&IID_ICreateTypeInfo)||
1308        IsEqualIID(riid,&IID_ICreateTypeInfo2))
1309     {
1310         *ppvObject = This;
1311     } else if (IsEqualIID(riid, &IID_ITypeInfo) ||
1312                IsEqualIID(riid, &IID_ITypeInfo2)) {
1313         *ppvObject = &This->lpVtblTypeInfo2;
1314     }
1315
1316     if(*ppvObject)
1317     {
1318         ICreateTypeInfo2_AddRef(iface);
1319         TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
1320         return S_OK;
1321     }
1322     TRACE("-- Interface: E_NOINTERFACE\n");
1323     return E_NOINTERFACE;
1324 }
1325
1326 /******************************************************************************
1327  * ICreateTypeInfo2_AddRef {OLEAUT32}
1328  *
1329  *  See IUnknown_AddRef.
1330  */
1331 static ULONG WINAPI ICreateTypeInfo2_fnAddRef(ICreateTypeInfo2 *iface)
1332 {
1333     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1334     ULONG ref = InterlockedIncrement(&This->ref);
1335
1336     TRACE("(%p)->ref was %u\n",This, ref - 1);
1337
1338     if(ref==1 && This->typelib)
1339         ICreateTypeLib2_AddRef((ICreateTypeLib2 *)This->typelib);
1340
1341     return ref;
1342 }
1343
1344 /******************************************************************************
1345  * ICreateTypeInfo2_Release {OLEAUT32}
1346  *
1347  *  See IUnknown_Release.
1348  */
1349 static ULONG WINAPI ICreateTypeInfo2_fnRelease(ICreateTypeInfo2 *iface)
1350 {
1351     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1352     ULONG ref = InterlockedDecrement(&This->ref);
1353
1354     TRACE("(%p)->(%u)\n",This, ref);
1355
1356     if (!ref) {
1357         if (This->typelib) {
1358             ICreateTypeLib2_fnRelease((ICreateTypeLib2 *)This->typelib);
1359             /* Keep This->typelib reference to make stored ICreateTypeInfo structure valid */
1360             /* This->typelib = NULL; */
1361         }
1362
1363         /* ICreateTypeLib2 frees all ICreateTypeInfos when it releases. */
1364         /* HeapFree(GetProcessHeap(),0,This); */
1365         return 0;
1366     }
1367
1368     return ref;
1369 }
1370
1371
1372 /******************************************************************************
1373  * ICreateTypeInfo2_SetGuid {OLEAUT32}
1374  *
1375  *  See ICreateTypeInfo_SetGuid.
1376  */
1377 static HRESULT WINAPI ICreateTypeInfo2_fnSetGuid(ICreateTypeInfo2 *iface, REFGUID guid)
1378 {
1379     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1380
1381     MSFT_GuidEntry guidentry;
1382     int offset;
1383
1384     TRACE("(%p,%s)\n", iface, debugstr_guid(guid));
1385
1386     guidentry.guid = *guid;
1387     guidentry.hreftype = This->typelib->typelib_typeinfo_offsets[This->typeinfo->typekind >> 16];
1388     guidentry.next_hash = -1;
1389
1390     offset = ctl2_alloc_guid(This->typelib, &guidentry);
1391
1392     if (offset == -1) return E_OUTOFMEMORY;
1393
1394     This->typeinfo->posguid = offset;
1395
1396     if (IsEqualIID(guid, &IID_IDispatch)) {
1397         This->typelib->typelib_header.dispatchpos = This->typelib->typelib_typeinfo_offsets[This->typeinfo->typekind >> 16];
1398     }
1399
1400     return S_OK;
1401 }
1402
1403 /******************************************************************************
1404  * ICreateTypeInfo2_SetTypeFlags {OLEAUT32}
1405  *
1406  *  See ICreateTypeInfo_SetTypeFlags.
1407  */
1408 static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeFlags(ICreateTypeInfo2 *iface, UINT uTypeFlags)
1409 {
1410     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1411
1412     TRACE("(%p,0x%x)\n", iface, uTypeFlags);
1413
1414     if(uTypeFlags & TYPEFLAG_FDUAL) {
1415         This->typeinfo->typekind |= 0x10;
1416         This->typeinfo->typekind &= ~0x0f;
1417         This->typeinfo->typekind |= TKIND_DISPATCH;
1418
1419         if(!This->dual) {
1420             This->dual = HeapAlloc(GetProcessHeap(), 0, sizeof(ICreateTypeInfo2Impl));
1421             if(!This->dual)
1422                 return E_OUTOFMEMORY;
1423
1424             memcpy(This->dual, This, sizeof(ICreateTypeInfo2Impl));
1425             This->dual->ref = 0;
1426             This->dual->typekind = This->typekind==TKIND_DISPATCH ?
1427                 TKIND_INTERFACE : TKIND_DISPATCH;
1428             This->dual->dual = This;
1429         }
1430
1431         /* Make sure dispatch is in typeinfos queue */
1432         if(This->typekind != TKIND_DISPATCH) {
1433             if(This->typelib->last_typeinfo == This)
1434                 This->typelib->last_typeinfo = This->dual;
1435
1436             if(This->typelib->typeinfos == This)
1437                 This->typelib->typeinfos = This->dual;
1438             else {
1439                 ICreateTypeInfo2Impl *iter;
1440
1441                 for(iter=This->typelib->typeinfos; iter->next_typeinfo!=This; iter=iter->next_typeinfo);
1442                 iter->next_typeinfo = This->dual;
1443             }
1444         } else
1445             iface = (ICreateTypeInfo2*)&This->dual->lpVtbl;
1446     }
1447
1448     if (uTypeFlags & (TYPEFLAG_FDISPATCHABLE|TYPEFLAG_FDUAL)) {
1449         static const WCHAR stdole2tlb[] = { 's','t','d','o','l','e','2','.','t','l','b',0 };
1450         ITypeLib *stdole;
1451         ITypeInfo *dispatch;
1452         HREFTYPE hreftype;
1453         HRESULT hres;
1454
1455         hres = LoadTypeLib(stdole2tlb, &stdole);
1456         if(FAILED(hres))
1457             return hres;
1458
1459         hres = ITypeLib_GetTypeInfoOfGuid(stdole, &IID_IDispatch, &dispatch);
1460         ITypeLib_Release(stdole);
1461         if(FAILED(hres))
1462             return hres;
1463
1464         hres = ICreateTypeInfo2_AddRefTypeInfo(iface, dispatch, &hreftype);
1465         ITypeInfo_Release(dispatch);
1466         if(FAILED(hres))
1467             return hres;
1468     }
1469
1470     This->typeinfo->flags = uTypeFlags;
1471     return S_OK;
1472 }
1473
1474 /******************************************************************************
1475  * ICreateTypeInfo2_SetDocString {OLEAUT32}
1476  *
1477  *  See ICreateTypeInfo_SetDocString.
1478  */
1479 static HRESULT WINAPI ICreateTypeInfo2_fnSetDocString(
1480         ICreateTypeInfo2* iface,
1481         LPOLESTR pStrDoc)
1482 {
1483     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1484
1485     int offset;
1486
1487     TRACE("(%p,%s)\n", iface, debugstr_w(pStrDoc));
1488     if (!pStrDoc)
1489         return E_INVALIDARG;
1490
1491     offset = ctl2_alloc_string(This->typelib, pStrDoc);
1492     if (offset == -1) return E_OUTOFMEMORY;
1493     This->typeinfo->docstringoffs = offset;
1494     return S_OK;
1495 }
1496
1497 /******************************************************************************
1498  * ICreateTypeInfo2_SetHelpContext {OLEAUT32}
1499  *
1500  *  See ICreateTypeInfo_SetHelpContext.
1501  */
1502 static HRESULT WINAPI ICreateTypeInfo2_fnSetHelpContext(
1503         ICreateTypeInfo2* iface,
1504         DWORD dwHelpContext)
1505 {
1506     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1507
1508     TRACE("(%p,%d)\n", iface, dwHelpContext);
1509
1510     This->typeinfo->helpcontext = dwHelpContext;
1511
1512     return S_OK;
1513 }
1514
1515 /******************************************************************************
1516  * ICreateTypeInfo2_SetVersion {OLEAUT32}
1517  *
1518  *  See ICreateTypeInfo_SetVersion.
1519  */
1520 static HRESULT WINAPI ICreateTypeInfo2_fnSetVersion(
1521         ICreateTypeInfo2* iface,
1522         WORD wMajorVerNum,
1523         WORD wMinorVerNum)
1524 {
1525     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1526
1527     TRACE("(%p,%d,%d)\n", iface, wMajorVerNum, wMinorVerNum);
1528
1529     This->typeinfo->version = wMajorVerNum | (wMinorVerNum << 16);
1530     return S_OK;
1531 }
1532
1533 /******************************************************************************
1534  * ICreateTypeInfo2_AddRefTypeInfo {OLEAUT32}
1535  *
1536  *  See ICreateTypeInfo_AddRefTypeInfo.
1537  */
1538 static HRESULT WINAPI ICreateTypeInfo2_fnAddRefTypeInfo(
1539         ICreateTypeInfo2* iface,
1540         ITypeInfo* pTInfo,
1541         HREFTYPE* phRefType)
1542 {
1543     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1544
1545     ITypeLib *container;
1546     UINT index;
1547     HRESULT res;
1548
1549     TRACE("(%p,%p,%p)\n", iface, pTInfo, phRefType);
1550
1551     if(!pTInfo || !phRefType)
1552         return E_INVALIDARG;
1553
1554     /*
1555      * Unfortunately, we can't rely on the passed-in TypeInfo even having the
1556      * same internal structure as one of ours. It could be from another
1557      * implementation of ITypeInfo. So we need to do the following...
1558      */
1559     res = ITypeInfo_GetContainingTypeLib(pTInfo, &container, &index);
1560     if (FAILED(res)) {
1561         TRACE("failed to find containing typelib.\n");
1562         return res;
1563     }
1564
1565     if (container == (ITypeLib *)&This->typelib->lpVtblTypeLib2) {
1566         /* Process locally defined TypeInfo */
1567         *phRefType = This->typelib->typelib_typeinfo_offsets[index];
1568     } else {
1569         BSTR name;
1570         TLIBATTR *tlibattr;
1571         TYPEATTR *typeattr;
1572         TYPEKIND typekind;
1573         MSFT_GuidEntry guid, *check_guid;
1574         MSFT_ImpInfo impinfo;
1575         int guid_offset, import_offset;
1576         HRESULT hres;
1577
1578         /* Allocate container GUID */
1579         hres = ITypeLib_GetLibAttr(container, &tlibattr);
1580         if(FAILED(hres)) {
1581             ITypeLib_Release(container);
1582             return hres;
1583         }
1584
1585         guid.guid = tlibattr->guid;
1586         guid.hreftype = This->typelib->typelib_guids*12+2;
1587         guid.next_hash = -1;
1588
1589         guid_offset = ctl2_alloc_guid(This->typelib, &guid);
1590         if(guid_offset == -1) {
1591             ITypeLib_ReleaseTLibAttr(container, tlibattr);
1592             ITypeLib_Release(container);
1593             return E_OUTOFMEMORY;
1594         }
1595
1596         check_guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][guid_offset];
1597         if(check_guid->hreftype == guid.hreftype)
1598             This->typelib->typelib_guids++;
1599
1600         /* Get import file name */
1601         hres = QueryPathOfRegTypeLib(&guid.guid, tlibattr->wMajorVerNum,
1602                 tlibattr->wMinorVerNum, tlibattr->lcid, &name);
1603         if(FAILED(hres)) {
1604             ITypeLib_ReleaseTLibAttr(container, tlibattr);
1605             ITypeLib_Release(container);
1606             return hres;
1607         }
1608
1609         /* Import file */
1610         import_offset = ctl2_alloc_importfile(This->typelib, guid_offset, tlibattr->lcid,
1611                 tlibattr->wMajorVerNum, tlibattr->wMinorVerNum, strrchrW(name, '\\')+1);
1612         ITypeLib_ReleaseTLibAttr(container, tlibattr);
1613         SysFreeString(name);
1614
1615         if(import_offset == -1) {
1616             ITypeLib_Release(container);
1617             return E_OUTOFMEMORY;
1618         }
1619
1620         /* Allocate referenced guid */
1621         hres = ITypeInfo_GetTypeAttr(pTInfo, &typeattr);
1622         if(FAILED(hres)) {
1623             ITypeLib_Release(container);
1624             return hres;
1625         }
1626
1627         guid.guid = typeattr->guid;
1628         guid.hreftype = This->typelib->typeinfo_guids*12+1;
1629         guid.next_hash = -1;
1630         typekind = typeattr->typekind;
1631         ITypeInfo_ReleaseTypeAttr(pTInfo, typeattr);
1632
1633         guid_offset = ctl2_alloc_guid(This->typelib, &guid);
1634         if(guid_offset == -1) {
1635             ITypeLib_Release(container);
1636             return E_OUTOFMEMORY;
1637         }
1638
1639         check_guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][guid_offset];
1640         if(check_guid->hreftype == guid.hreftype)
1641             This->typelib->typeinfo_guids++;
1642
1643         /* Allocate importinfo */
1644         impinfo.flags = (typekind<<24) | MSFT_IMPINFO_OFFSET_IS_GUID;
1645         impinfo.oImpFile = import_offset;
1646         impinfo.oGuid = guid_offset;
1647         *phRefType = ctl2_alloc_importinfo(This->typelib, &impinfo)+1;
1648
1649         if(!memcmp(&guid.guid, &IID_IDispatch, sizeof(GUID)))
1650             This->typelib->typelib_header.dispatchpos = *phRefType;
1651     }
1652
1653     ITypeLib_Release(container);
1654     return S_OK;
1655 }
1656
1657 /******************************************************************************
1658  * ICreateTypeInfo2_AddFuncDesc {OLEAUT32}
1659  *
1660  *  See ICreateTypeInfo_AddFuncDesc.
1661  */
1662 static HRESULT WINAPI ICreateTypeInfo2_fnAddFuncDesc(
1663         ICreateTypeInfo2* iface,
1664         UINT index,
1665         FUNCDESC* pFuncDesc)
1666 {
1667     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1668
1669     CyclicList *iter, *insert;
1670     int *typedata;
1671     int i, num_defaults = 0;
1672     int decoded_size;
1673     HRESULT hres;
1674
1675     TRACE("(%p,%d,%p)\n", iface, index, pFuncDesc);
1676
1677     if(!pFuncDesc || pFuncDesc->oVft&3)
1678         return E_INVALIDARG;
1679
1680     TRACE("{%d,%p,%p,%d,%d,%d,%d,%d,%d,%d,{%d},%d}\n", pFuncDesc->memid,
1681             pFuncDesc->lprgscode, pFuncDesc->lprgelemdescParam, pFuncDesc->funckind,
1682             pFuncDesc->invkind, pFuncDesc->callconv, pFuncDesc->cParams,
1683             pFuncDesc->cParamsOpt, pFuncDesc->oVft, pFuncDesc->cScodes,
1684             pFuncDesc->elemdescFunc.tdesc.vt, pFuncDesc->wFuncFlags);
1685
1686     if(pFuncDesc->cParamsOpt || pFuncDesc->cScodes)
1687         FIXME("Unimplemented parameter - created typelib will be incorrect\n");
1688
1689     switch(This->typekind) {
1690     case TKIND_MODULE:
1691         if(pFuncDesc->funckind != FUNC_STATIC)
1692             return TYPE_E_BADMODULEKIND;
1693         break;
1694     case TKIND_DISPATCH:
1695         if(pFuncDesc->funckind != FUNC_DISPATCH)
1696             return TYPE_E_BADMODULEKIND;
1697         break;
1698     default:
1699         if(pFuncDesc->funckind != FUNC_PUREVIRTUAL)
1700             return TYPE_E_BADMODULEKIND;
1701     }
1702
1703     if(This->typeinfo->cElement<index)
1704         return TYPE_E_ELEMENTNOTFOUND;
1705
1706     if((pFuncDesc->invkind&(INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF)) &&
1707         !pFuncDesc->cParams)
1708         return TYPE_E_INCONSISTENTPROPFUNCS;
1709
1710     /* get number of arguments with default values specified */
1711     for (i = 0; i < pFuncDesc->cParams; i++)
1712         if(pFuncDesc->lprgelemdescParam[i].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
1713             num_defaults++;
1714
1715     if (!This->typedata) {
1716         This->typedata = HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList));
1717         if(!This->typedata)
1718             return E_OUTOFMEMORY;
1719
1720         This->typedata->next = This->typedata;
1721         This->typedata->u.val = 0;
1722
1723         if(This->dual)
1724             This->dual->typedata = This->typedata;
1725     }
1726
1727     /* allocate type data space for us */
1728     insert = HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList));
1729     if(!insert)
1730         return E_OUTOFMEMORY;
1731     insert->u.data = HeapAlloc(GetProcessHeap(), 0, sizeof(int[6])+sizeof(int[(num_defaults?4:3)])*pFuncDesc->cParams);
1732     if(!insert->u.data) {
1733         HeapFree(GetProcessHeap(), 0, insert);
1734         return E_OUTOFMEMORY;
1735     }
1736
1737     /* fill out the basic type information */
1738     typedata = insert->u.data;
1739     typedata[0] = 0x18 + pFuncDesc->cParams*(num_defaults?16:12);
1740     ctl2_encode_typedesc(This->typelib, &pFuncDesc->elemdescFunc.tdesc, &typedata[1], NULL, NULL, &decoded_size);
1741     typedata[2] = pFuncDesc->wFuncFlags;
1742     typedata[3] = ((sizeof(FUNCDESC) + decoded_size) << 16) | (unsigned short)(pFuncDesc->oVft?pFuncDesc->oVft+1:0);
1743     typedata[4] = (pFuncDesc->callconv << 8) | (pFuncDesc->invkind << 3) | pFuncDesc->funckind;
1744     if(num_defaults) typedata[4] |= 0x1000;
1745     typedata[5] = pFuncDesc->cParams;
1746
1747     /* NOTE: High word of typedata[3] is total size of FUNCDESC + size of all ELEMDESCs for params + TYPEDESCs for pointer params and return types. */
1748     /* That is, total memory allocation required to reconstitute the FUNCDESC in its entirety. */
1749     typedata[3] += (sizeof(ELEMDESC) * pFuncDesc->cParams) << 16;
1750     typedata[3] += (sizeof(PARAMDESCEX) * num_defaults) << 16;
1751
1752     /* add default values */
1753     if(num_defaults) {
1754         for (i = 0; i < pFuncDesc->cParams; i++)
1755             if(pFuncDesc->lprgelemdescParam[i].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT) {
1756                 hres = ctl2_add_default_value(This->typelib, typedata+6+i,
1757                         &pFuncDesc->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue,
1758                         pFuncDesc->lprgelemdescParam[i].tdesc.vt);
1759
1760                 if(FAILED(hres)) {
1761                     HeapFree(GetProcessHeap(), 0, insert->u.data);
1762                     HeapFree(GetProcessHeap(), 0, insert);
1763                     return hres;
1764                 }
1765             } else
1766                 typedata[6+i] = 0xffffffff;
1767
1768         num_defaults = pFuncDesc->cParams;
1769     }
1770
1771     /* add arguments */
1772     for (i = 0; i < pFuncDesc->cParams; i++) {
1773         ctl2_encode_typedesc(This->typelib, &pFuncDesc->lprgelemdescParam[i].tdesc,
1774                 &typedata[6+num_defaults+(i*3)], NULL, NULL, &decoded_size);
1775         typedata[7+num_defaults+(i*3)] = -1;
1776         typedata[8+num_defaults+(i*3)] = pFuncDesc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
1777         typedata[3] += decoded_size << 16;
1778     }
1779
1780     /* update the index data */
1781     insert->indice = pFuncDesc->memid;
1782     insert->name = -1;
1783
1784     /* insert type data to list */
1785     if(index == This->typeinfo->cElement) {
1786         insert->next = This->typedata->next;
1787         This->typedata->next = insert;
1788         This->typedata = insert;
1789
1790         if(This->dual)
1791             This->dual->typedata = This->typedata;
1792     } else {
1793         iter = This->typedata->next;
1794         for(i=0; i<index; i++)
1795             iter = iter->next;
1796
1797         insert->next = iter->next;
1798         iter->next = insert;
1799     }
1800
1801     /* update type data size */
1802     This->typedata->next->u.val += 0x18 + pFuncDesc->cParams*(num_defaults?16:12);
1803
1804     /* Increment the number of function elements */
1805     This->typeinfo->cElement += 1;
1806
1807     return S_OK;
1808 }
1809
1810 /******************************************************************************
1811  * ICreateTypeInfo2_AddImplType {OLEAUT32}
1812  *
1813  *  See ICreateTypeInfo_AddImplType.
1814  */
1815 static HRESULT WINAPI ICreateTypeInfo2_fnAddImplType(
1816         ICreateTypeInfo2* iface,
1817         UINT index,
1818         HREFTYPE hRefType)
1819 {
1820     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1821
1822     TRACE("(%p,%d,%d)\n", iface, index, hRefType);
1823
1824     if (This->typekind == TKIND_COCLASS) {
1825         int offset;
1826         MSFT_RefRecord *ref;
1827
1828         if (index == 0) {
1829             if (This->typeinfo->datatype1 != -1) return TYPE_E_ELEMENTNOTFOUND;
1830
1831             offset = ctl2_alloc_segment(This->typelib, MSFT_SEG_REFERENCES, sizeof(MSFT_RefRecord), 0);
1832             if (offset == -1) return E_OUTOFMEMORY;
1833
1834             This->typeinfo->datatype1 = offset;
1835         } else {
1836             int lastoffset;
1837
1838             lastoffset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index - 1);
1839             if (lastoffset == -1) return TYPE_E_ELEMENTNOTFOUND;
1840
1841             ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][lastoffset];
1842             if (ref->onext != -1) return TYPE_E_ELEMENTNOTFOUND;
1843
1844             offset = ctl2_alloc_segment(This->typelib, MSFT_SEG_REFERENCES, sizeof(MSFT_RefRecord), 0);
1845             if (offset == -1) return E_OUTOFMEMORY;
1846
1847             ref->onext = offset;
1848         }
1849
1850         ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
1851
1852         ref->reftype = hRefType;
1853         ref->flags = 0;
1854         ref->oCustData = -1;
1855         ref->onext = -1;
1856         This->typeinfo->cImplTypes++;
1857     } else if (This->typekind == TKIND_INTERFACE) {
1858         if (This->typeinfo->cImplTypes && index==1)
1859             return TYPE_E_BADMODULEKIND;
1860
1861         if( index != 0)  return TYPE_E_ELEMENTNOTFOUND;
1862
1863         This->typeinfo->datatype1 = hRefType;
1864         This->typeinfo->cImplTypes = 1;
1865     } else if (This->typekind == TKIND_DISPATCH) {
1866         if(index != 0) return TYPE_E_ELEMENTNOTFOUND;
1867
1868         /* FIXME: Check if referenced typeinfo is IDispatch */
1869         This->typeinfo->flags |= TYPEFLAG_FDISPATCHABLE;
1870         This->typeinfo->cImplTypes = 1;
1871     } else {
1872         FIXME("AddImplType unsupported on typekind %d\n", This->typekind);
1873         return E_OUTOFMEMORY;
1874     }
1875
1876     return S_OK;
1877 }
1878
1879 /******************************************************************************
1880  * ICreateTypeInfo2_SetImplTypeFlags {OLEAUT32}
1881  *
1882  *  See ICreateTypeInfo_SetImplTypeFlags.
1883  */
1884 static HRESULT WINAPI ICreateTypeInfo2_fnSetImplTypeFlags(
1885         ICreateTypeInfo2* iface,
1886         UINT index,
1887         INT implTypeFlags)
1888 {
1889     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1890     int offset;
1891     MSFT_RefRecord *ref;
1892
1893     TRACE("(%p,%d,0x%x)\n", iface, index, implTypeFlags);
1894
1895     if (This->typekind != TKIND_COCLASS) {
1896         return TYPE_E_BADMODULEKIND;
1897     }
1898
1899     offset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index);
1900     if (offset == -1) return TYPE_E_ELEMENTNOTFOUND;
1901
1902     ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
1903     ref->flags = implTypeFlags;
1904
1905     return S_OK;
1906 }
1907
1908 /******************************************************************************
1909  * ICreateTypeInfo2_SetAlignment {OLEAUT32}
1910  *
1911  *  See ICreateTypeInfo_SetAlignment.
1912  */
1913 static HRESULT WINAPI ICreateTypeInfo2_fnSetAlignment(
1914         ICreateTypeInfo2* iface,
1915         WORD cbAlignment)
1916 {
1917     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1918
1919     TRACE("(%p,%d)\n", iface, cbAlignment);
1920
1921     if (!cbAlignment) return E_INVALIDARG;
1922     if (cbAlignment > 16) return E_INVALIDARG;
1923
1924     This->typeinfo->typekind &= ~0xffc0;
1925     This->typeinfo->typekind |= cbAlignment << 6;
1926
1927     /* FIXME: There's probably some way to simplify this. */
1928     switch (This->typekind) {
1929     case TKIND_ALIAS:
1930     default:
1931         break;
1932
1933     case TKIND_ENUM:
1934     case TKIND_INTERFACE:
1935     case TKIND_DISPATCH:
1936     case TKIND_COCLASS:
1937         if (cbAlignment > 4) cbAlignment = 4;
1938         break;
1939
1940     case TKIND_RECORD:
1941     case TKIND_MODULE:
1942     case TKIND_UNION:
1943         cbAlignment = 1;
1944         break;
1945     }
1946
1947     This->typeinfo->typekind |= cbAlignment << 11;
1948
1949     return S_OK;
1950 }
1951
1952 /******************************************************************************
1953  * ICreateTypeInfo2_SetSchema {OLEAUT32}
1954  *
1955  *  See ICreateTypeInfo_SetSchema.
1956  */
1957 static HRESULT WINAPI ICreateTypeInfo2_fnSetSchema(
1958         ICreateTypeInfo2* iface,
1959         LPOLESTR pStrSchema)
1960 {
1961     FIXME("(%p,%s), stub!\n", iface, debugstr_w(pStrSchema));
1962     return E_OUTOFMEMORY;
1963 }
1964
1965 /******************************************************************************
1966  * ICreateTypeInfo2_AddVarDesc {OLEAUT32}
1967  *
1968  *  See ICreateTypeInfo_AddVarDesc.
1969  */
1970 static HRESULT WINAPI ICreateTypeInfo2_fnAddVarDesc(
1971         ICreateTypeInfo2* iface,
1972         UINT index,
1973         VARDESC* pVarDesc)
1974 {
1975     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1976
1977     CyclicList *insert;
1978     INT *typedata;
1979     int var_datawidth;
1980     int var_alignment;
1981     int var_type_size;
1982     int alignment;
1983
1984     TRACE("(%p,%d,%p), stub!\n", iface, index, pVarDesc);
1985     TRACE("%d, %p, %d, {{%x, %d}, {%p, %x}}, 0x%x, %d\n", pVarDesc->memid, pVarDesc->lpstrSchema, pVarDesc->u.oInst,
1986           pVarDesc->elemdescVar.tdesc.u.hreftype, pVarDesc->elemdescVar.tdesc.vt,
1987           pVarDesc->elemdescVar.u.paramdesc.pparamdescex, pVarDesc->elemdescVar.u.paramdesc.wParamFlags,
1988           pVarDesc->wVarFlags, pVarDesc->varkind);
1989
1990     if ((This->typeinfo->cElement >> 16) != index) {
1991         TRACE("Out-of-order element.\n");
1992         return TYPE_E_ELEMENTNOTFOUND;
1993     }
1994
1995     if (!This->typedata) {
1996         This->typedata = HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList));
1997         if(!This->typedata)
1998             return E_OUTOFMEMORY;
1999
2000         This->typedata->next = This->typedata;
2001         This->typedata->u.val = 0;
2002
2003         if(This->dual)
2004             This->dual->typedata = This->typedata;
2005     }
2006
2007     /* allocate type data space for us */
2008     insert = HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList));
2009     if(!insert)
2010         return E_OUTOFMEMORY;
2011     insert->u.data = HeapAlloc(GetProcessHeap(), 0, sizeof(int[5]));
2012     if(!insert->u.data) {
2013         HeapFree(GetProcessHeap(), 0, insert);
2014         return E_OUTOFMEMORY;
2015     }
2016
2017     insert->next = This->typedata->next;
2018     This->typedata->next = insert;
2019     This->typedata = insert;
2020
2021     if(This->dual)
2022         This->dual->typedata = This->typedata;
2023
2024     This->typedata->next->u.val += 0x14;
2025     typedata = This->typedata->u.data;
2026
2027     /* fill out the basic type information */
2028     typedata[0] = 0x14 | (index << 16);
2029     typedata[2] = pVarDesc->wVarFlags;
2030     typedata[3] = (sizeof(VARDESC) << 16) | 0;
2031
2032     /* update the index data */
2033     insert->indice = 0x40000000 + index;
2034     insert->name = -1;
2035
2036     /* figure out type widths and whatnot */
2037     ctl2_encode_typedesc(This->typelib, &pVarDesc->elemdescVar.tdesc,
2038                          &typedata[1], &var_datawidth, &var_alignment,
2039                          &var_type_size);
2040
2041     /* pad out starting position to data width */
2042     This->datawidth += var_alignment - 1;
2043     This->datawidth &= ~(var_alignment - 1);
2044     typedata[4] = This->datawidth;
2045
2046     /* add the new variable to the total data width */
2047     This->datawidth += var_datawidth;
2048     if(This->dual)
2049         This->dual->datawidth = This->datawidth;
2050
2051     /* add type description size to total required allocation */
2052     typedata[3] += var_type_size << 16;
2053
2054     /* fix type alignment */
2055     alignment = (This->typeinfo->typekind >> 11) & 0x1f;
2056     if (alignment < var_alignment) {
2057         alignment = var_alignment;
2058         This->typeinfo->typekind &= ~0xf800;
2059         This->typeinfo->typekind |= alignment << 11;
2060     }
2061
2062     /* ??? */
2063     if (!This->typeinfo->res2) This->typeinfo->res2 = 0x1a;
2064     if ((index == 0) || (index == 1) || (index == 2) || (index == 4) || (index == 9)) {
2065         This->typeinfo->res2 <<= 1;
2066     }
2067
2068     /* ??? */
2069     if (This->typeinfo->res3 == -1) This->typeinfo->res3 = 0;
2070     This->typeinfo->res3 += 0x2c;
2071
2072     /* increment the number of variable elements */
2073     This->typeinfo->cElement += 0x10000;
2074
2075     /* pad data width to alignment */
2076     This->typeinfo->size = (This->datawidth + (alignment - 1)) & ~(alignment - 1);
2077
2078     return S_OK;
2079 }
2080
2081 /******************************************************************************
2082  * ICreateTypeInfo2_SetFuncAndParamNames {OLEAUT32}
2083  *
2084  *  See ICreateTypeInfo_SetFuncAndParamNames.
2085  */
2086 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncAndParamNames(
2087         ICreateTypeInfo2* iface,
2088         UINT index,
2089         LPOLESTR* rgszNames,
2090         UINT cNames)
2091 {
2092     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2093     CyclicList *iter = NULL, *iter2;
2094     int offset, len, i=0;
2095     char *namedata;
2096
2097     TRACE("(%p %d %p %d)\n", iface, index, rgszNames, cNames);
2098
2099     if(!rgszNames)
2100         return E_INVALIDARG;
2101
2102     if(index >= This->typeinfo->cElement || !cNames)
2103         return TYPE_E_ELEMENTNOTFOUND;
2104
2105     len = ctl2_encode_name(This->typelib, rgszNames[0], &namedata);
2106     for(iter2=This->typedata->next->next; iter2!=This->typedata->next; iter2=iter2->next) {
2107         if(i == index)
2108             iter = iter2;
2109         else if(iter2->name!=-1 && !memcmp(namedata,
2110                     This->typelib->typelib_segment_data[MSFT_SEG_NAME]+iter2->name+8, len))
2111             return TYPE_E_AMBIGUOUSNAME;
2112
2113         i++;
2114     }
2115
2116     /* cNames == cParams for put or putref accessor, cParams+1 otherwise */
2117     if(cNames != iter->u.data[5] + ((iter->u.data[4]>>3)&(INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF) ? 0 : 1))
2118         return TYPE_E_ELEMENTNOTFOUND;
2119
2120     offset = ctl2_alloc_name(This->typelib, rgszNames[0]);
2121     if(offset == -1)
2122         return E_OUTOFMEMORY;
2123
2124     iter->name = offset;
2125
2126     namedata = This->typelib->typelib_segment_data[MSFT_SEG_NAME] + offset;
2127     *((INT *)namedata) = This->typelib->typelib_typeinfo_offsets[This->typeinfo->typekind >> 16];
2128
2129     if(iter->u.data[4]&0x1000)
2130         len = iter->u.data[5];
2131     else
2132         len = 0;
2133
2134     for (i = 1; i < cNames; i++) {
2135         offset = ctl2_alloc_name(This->typelib, rgszNames[i]);
2136         iter->u.data[(i*3) + 4 + len] = offset;
2137     }
2138
2139     return S_OK;
2140 }
2141
2142 /******************************************************************************
2143  * ICreateTypeInfo2_SetVarName {OLEAUT32}
2144  *
2145  *  See ICreateTypeInfo_SetVarName.
2146  */
2147 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarName(
2148         ICreateTypeInfo2* iface,
2149         UINT index,
2150         LPOLESTR szName)
2151 {
2152     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2153     CyclicList *iter;
2154     int offset, i;
2155     char *namedata;
2156
2157     TRACE("(%p,%d,%s), stub!\n", iface, index, debugstr_w(szName));
2158
2159     if ((This->typeinfo->cElement >> 16) <= index) {
2160         TRACE("Out-of-order element.\n");
2161         return TYPE_E_ELEMENTNOTFOUND;
2162     }
2163
2164     offset = ctl2_alloc_name(This->typelib, szName);
2165     if (offset == -1) return E_OUTOFMEMORY;
2166
2167     namedata = This->typelib->typelib_segment_data[MSFT_SEG_NAME] + offset;
2168     if (*((INT *)namedata) == -1) {
2169         *((INT *)namedata) = This->typelib->typelib_typeinfo_offsets[This->typeinfo->typekind >> 16];
2170         namedata[9] |= 0x10;
2171     }
2172     if (This->typekind == TKIND_ENUM) {
2173         namedata[9] |= 0x20;
2174     }
2175
2176     iter = This->typedata->next->next;
2177     for(i=0; i<index; i++)
2178         iter = iter->next;
2179
2180     iter->name = offset;
2181     return S_OK;
2182 }
2183
2184 /******************************************************************************
2185  * ICreateTypeInfo2_SetTypeDescAlias {OLEAUT32}
2186  *
2187  *  See ICreateTypeInfo_SetTypeDescAlias.
2188  */
2189 static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeDescAlias(
2190         ICreateTypeInfo2* iface,
2191         TYPEDESC* pTDescAlias)
2192 {
2193     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2194
2195     int encoded_typedesc;
2196     int width;
2197
2198     if (This->typekind != TKIND_ALIAS) {
2199         return TYPE_E_WRONGTYPEKIND;
2200     }
2201
2202     FIXME("(%p,%p), hack!\n", iface, pTDescAlias);
2203
2204     if (ctl2_encode_typedesc(This->typelib, pTDescAlias, &encoded_typedesc, &width, NULL, NULL) == -1) {
2205         return E_OUTOFMEMORY;
2206     }
2207
2208     This->typeinfo->size = width;
2209     This->typeinfo->datatype1 = encoded_typedesc;
2210
2211     return S_OK;
2212 }
2213
2214 /******************************************************************************
2215  * ICreateTypeInfo2_DefineFuncAsDllEntry {OLEAUT32}
2216  *
2217  *  See ICreateTypeInfo_DefineFuncAsDllEntry.
2218  */
2219 static HRESULT WINAPI ICreateTypeInfo2_fnDefineFuncAsDllEntry(
2220         ICreateTypeInfo2* iface,
2221         UINT index,
2222         LPOLESTR szDllName,
2223         LPOLESTR szProcName)
2224 {
2225     FIXME("(%p,%d,%s,%s), stub!\n", iface, index, debugstr_w(szDllName), debugstr_w(szProcName));
2226     return E_OUTOFMEMORY;
2227 }
2228
2229 /******************************************************************************
2230  * ICreateTypeInfo2_SetFuncDocString {OLEAUT32}
2231  *
2232  *  See ICreateTypeInfo_SetFuncDocString.
2233  */
2234 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncDocString(
2235         ICreateTypeInfo2* iface,
2236         UINT index,
2237         LPOLESTR szDocString)
2238 {
2239     FIXME("(%p,%d,%s), stub!\n", iface, index, debugstr_w(szDocString));
2240     return E_OUTOFMEMORY;
2241 }
2242
2243 /******************************************************************************
2244  * ICreateTypeInfo2_SetVarDocString {OLEAUT32}
2245  *
2246  *  See ICreateTypeInfo_SetVarDocString.
2247  */
2248 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarDocString(
2249         ICreateTypeInfo2* iface,
2250         UINT index,
2251         LPOLESTR szDocString)
2252 {
2253     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2254
2255     FIXME("(%p,%d,%s), stub!\n", iface, index, debugstr_w(szDocString));
2256
2257     ctl2_alloc_string(This->typelib, szDocString);
2258
2259     return E_OUTOFMEMORY;
2260 }
2261
2262 /******************************************************************************
2263  * ICreateTypeInfo2_SetFuncHelpContext {OLEAUT32}
2264  *
2265  *  See ICreateTypeInfo_SetFuncHelpContext.
2266  */
2267 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncHelpContext(
2268         ICreateTypeInfo2* iface,
2269         UINT index,
2270         DWORD dwHelpContext)
2271 {
2272     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2273     CyclicList *func;
2274     int *typedata;
2275     int size;
2276
2277     TRACE("(%p,%d,%d)\n", iface, index, dwHelpContext);
2278
2279     if(This->typeinfo->cElement<index)
2280         return TYPE_E_ELEMENTNOTFOUND;
2281
2282     if(This->typeinfo->cElement == index)
2283         func = This->typedata;
2284     else
2285         for(func=This->typedata->next->next; func!=This->typedata; func=func->next)
2286             if(index-- == 0)
2287                 break;
2288
2289     typedata = func->u.data;
2290
2291     /* Compute func size without arguments */
2292     size = typedata[0] - typedata[5]*(typedata[4]&0x1000?16:12);
2293
2294     /* Allocate memory for HelpContext if needed */
2295     if(size < 7*sizeof(int)) {
2296         typedata = HeapReAlloc(GetProcessHeap(), 0, typedata, typedata[0]+sizeof(int));
2297         if(!typedata)
2298             return E_OUTOFMEMORY;
2299
2300         memmove(&typedata[7], &typedata[6], typedata[0]-sizeof(int)*6);
2301         typedata[0] += sizeof(int);
2302         This->typedata->next->u.val += sizeof(int);
2303         func->u.data = typedata;
2304     }
2305
2306     typedata[6] = dwHelpContext;
2307     return S_OK;
2308 }
2309
2310 /******************************************************************************
2311  * ICreateTypeInfo2_SetVarHelpContext {OLEAUT32}
2312  *
2313  *  See ICreateTypeInfo_SetVarHelpContext.
2314  */
2315 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarHelpContext(
2316         ICreateTypeInfo2* iface,
2317         UINT index,
2318         DWORD dwHelpContext)
2319 {
2320     FIXME("(%p,%d,%d), stub!\n", iface, index, dwHelpContext);
2321     return E_OUTOFMEMORY;
2322 }
2323
2324 /******************************************************************************
2325  * ICreateTypeInfo2_SetMops {OLEAUT32}
2326  *
2327  *  See ICreateTypeInfo_SetMops.
2328  */
2329 static HRESULT WINAPI ICreateTypeInfo2_fnSetMops(
2330         ICreateTypeInfo2* iface,
2331         UINT index,
2332         BSTR bstrMops)
2333 {
2334     FIXME("(%p,%d,%p), stub!\n", iface, index, bstrMops);
2335     return E_OUTOFMEMORY;
2336 }
2337
2338 /******************************************************************************
2339  * ICreateTypeInfo2_SetTypeIdldesc {OLEAUT32}
2340  *
2341  *  See ICreateTypeInfo_SetTypeIdldesc.
2342  */
2343 static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeIdldesc(
2344         ICreateTypeInfo2* iface,
2345         IDLDESC* pIdlDesc)
2346 {
2347     FIXME("(%p,%p), stub!\n", iface, pIdlDesc);
2348     return E_OUTOFMEMORY;
2349 }
2350
2351 /******************************************************************************
2352  * ICreateTypeInfo2_LayOut {OLEAUT32}
2353  *
2354  *  See ICreateTypeInfo_LayOut.
2355  */
2356 static HRESULT WINAPI ICreateTypeInfo2_fnLayOut(
2357         ICreateTypeInfo2* iface)
2358 {
2359     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2360     CyclicList *iter, *iter2, **typedata;
2361     HREFTYPE hreftype;
2362     HRESULT hres;
2363     unsigned user_vft = 0;
2364     int i;
2365
2366     TRACE("(%p)\n", iface);
2367
2368     /* FIXME: LayOut should be run on all ImplTypes */
2369     if(This->typekind == TKIND_COCLASS)
2370         return S_OK;
2371
2372     /* Validate inheritance */
2373     This->typeinfo->datatype2 = 0;
2374     hreftype = This->typeinfo->datatype1;
2375
2376     /* Process internally defined interfaces */
2377     for(i=0; i<This->typelib->typelib_header.nrtypeinfos; i++) {
2378         MSFT_TypeInfoBase *header;
2379
2380         if(hreftype&1)
2381             break;
2382
2383         header = (MSFT_TypeInfoBase*)&(This->typelib->typelib_segment_data[MSFT_SEG_TYPEINFO][hreftype]);
2384         This->typeinfo->datatype2 += (header->cElement<<16) + 1;
2385         hreftype = header->datatype1;
2386     }
2387     if(i == This->typelib->typelib_header.nrtypeinfos)
2388         return TYPE_E_CIRCULARTYPE;
2389
2390     /* Process externally defined interfaces */
2391     if(hreftype != -1) {
2392         ITypeInfo *cur, *next;
2393         TYPEATTR *typeattr;
2394
2395         hres = ICreateTypeInfo_QueryInterface(iface, &IID_ITypeInfo, (void**)&next);
2396         if(FAILED(hres))
2397             return hres;
2398
2399         hres = ITypeInfo_GetRefTypeInfo(next, hreftype, &cur);
2400         ITypeInfo_Release(next);
2401         if(FAILED(hres))
2402             return hres;
2403
2404
2405         while(1) {
2406             hres = ITypeInfo_GetTypeAttr(cur, &typeattr);
2407             if(FAILED(hres)) {
2408                 ITypeInfo_Release(cur);
2409                 return hres;
2410             }
2411
2412             if(!memcmp(&typeattr->guid, &IID_IDispatch, sizeof(IDispatch)))
2413                 This->typeinfo->flags |= TYPEFLAG_FDISPATCHABLE;
2414
2415             This->typeinfo->datatype2 += (typeattr->cFuncs<<16) + 1;
2416             ITypeInfo_ReleaseTypeAttr(cur, typeattr);
2417
2418             hres = ITypeInfo_GetRefTypeOfImplType(cur, 0, &hreftype);
2419             if(hres == TYPE_E_ELEMENTNOTFOUND)
2420                 break;
2421             if(FAILED(hres)) {
2422                 ITypeInfo_Release(cur);
2423                 return hres;
2424             }
2425
2426             hres = ITypeInfo_GetRefTypeInfo(cur, hreftype, &next);
2427             if(FAILED(hres)) {
2428                 ITypeInfo_Release(cur);
2429                 return hres;
2430             }
2431
2432             ITypeInfo_Release(cur);
2433             cur = next;
2434         }
2435         ITypeInfo_Release(cur);
2436     }
2437
2438     /* Get cbSizeVft of inherited interface */
2439     /* Makes LayOut running recursively */
2440     if(This->typeinfo->datatype1 != -1) {
2441         ITypeInfo *cur, *inherited;
2442         TYPEATTR *typeattr;
2443
2444         hres = ICreateTypeInfo_QueryInterface(iface, &IID_ITypeInfo, (void**)&cur);
2445         if(FAILED(hres))
2446             return hres;
2447
2448         hres = ITypeInfo_GetRefTypeInfo(cur, This->typeinfo->datatype1, &inherited);
2449         ITypeInfo_Release(cur);
2450         if(FAILED(hres))
2451             return hres;
2452
2453         hres = ITypeInfo_GetTypeAttr(inherited, &typeattr);
2454         if(FAILED(hres)) {
2455             ITypeInfo_Release(inherited);
2456             return hres;
2457         }
2458
2459         This->typeinfo->cbSizeVft = typeattr->cbSizeVft;
2460
2461         ITypeInfo_ReleaseTypeAttr(inherited, typeattr);
2462         ITypeInfo_Release(inherited);
2463     } else
2464         This->typeinfo->cbSizeVft = 0;
2465
2466     if(!This->typedata)
2467         return S_OK;
2468
2469     typedata = HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList*)*(This->typeinfo->cElement&0xffff));
2470     if(!typedata)
2471         return E_OUTOFMEMORY;
2472
2473     /* Assign IDs and VTBL entries */
2474     i = 0;
2475     if(This->typedata->u.data[3]&1)
2476         user_vft = This->typedata->u.data[3]&0xffff;
2477
2478     for(iter=This->typedata->next->next; iter!=This->typedata->next; iter=iter->next) {
2479         /* Assign MEMBERID if MEMBERID_NIL was specified */
2480         if(iter->indice == MEMBERID_NIL) {
2481             iter->indice = 0x60000000 + i + (This->typeinfo->datatype2<<16);
2482
2483             for(iter2=This->typedata->next->next; iter2!=This->typedata->next; iter2=iter2->next) {
2484                 if(iter == iter2) continue;
2485                 if(iter2->indice == iter->indice) {
2486                     iter->indice = 0x5fffffff + This->typeinfo->cElement + i + (This->typeinfo->datatype2<<16);
2487
2488                     for(iter2=This->typedata->next->next; iter2!=This->typedata->next; iter2=iter2->next) {
2489                         if(iter == iter2) continue;
2490                         if(iter2->indice == iter->indice) {
2491                             HeapFree(GetProcessHeap(), 0, typedata);
2492                             return E_ACCESSDENIED;
2493                         }
2494                     }
2495
2496                     break;
2497                 }
2498             }
2499         }
2500
2501         typedata[i] = iter;
2502
2503         iter->u.data[0] = (iter->u.data[0]&0xffff) | (i<<16);
2504
2505         if((iter->u.data[3]&1) != (user_vft&1)) {
2506             HeapFree(GetProcessHeap(), 0, typedata);
2507             return TYPE_E_INVALIDID;
2508         }
2509
2510         if(user_vft&1) {
2511             if(user_vft < (iter->u.data[3]&0xffff))
2512                 user_vft = (iter->u.data[3]&0xffff);
2513
2514             if((iter->u.data[3]&0xffff) < This->typeinfo->cbSizeVft) {
2515                 HeapFree(GetProcessHeap(), 0, typedata);
2516                 return TYPE_E_INVALIDID;
2517             }
2518         } else if(This->typekind != TKIND_MODULE) {
2519             iter->u.data[3] = (iter->u.data[3]&0xffff0000) | This->typeinfo->cbSizeVft;
2520             This->typeinfo->cbSizeVft += 4;
2521         }
2522
2523         /* Construct a list of elements with the same memberid */
2524         iter->u.data[4] = (iter->u.data[4]&0xffff) | (i<<16);
2525         for(iter2=This->typedata->next->next; iter2!=iter; iter2=iter2->next) {
2526             if(iter->indice == iter2->indice) {
2527                 int v1, v2;
2528
2529                 v1 = iter->u.data[4] >> 16;
2530                 v2 = iter2->u.data[4] >> 16;
2531
2532                 iter->u.data[4] = (iter->u.data[4]&0xffff) | (v2<<16);
2533                 iter2->u.data[4] = (iter2->u.data[4]&0xffff) | (v1<<16);
2534                 break;
2535             }
2536         }
2537
2538         i++;
2539     }
2540
2541     if(user_vft)
2542         This->typeinfo->cbSizeVft = user_vft+3;
2543
2544     for(i=0; i<(This->typeinfo->cElement&0xffff); i++) {
2545         if(typedata[i]->u.data[4]>>16 > i) {
2546             int inv;
2547
2548             inv = (typedata[i]->u.data[4]>>3) & 0xf;
2549             i = typedata[i]->u.data[4] >> 16;
2550
2551             while(i > typedata[i]->u.data[4]>>16) {
2552                 int invkind = (typedata[i]->u.data[4]>>3) & 0xf;
2553
2554                 if(inv & invkind) {
2555                     HeapFree(GetProcessHeap(), 0, typedata);
2556                     return TYPE_E_DUPLICATEID;
2557                 }
2558
2559                 i = typedata[i]->u.data[4] >> 16;
2560                 inv |= invkind;
2561             }
2562
2563             if(inv & INVOKE_FUNC) {
2564                 HeapFree(GetProcessHeap(), 0, typedata);
2565                 return TYPE_E_INCONSISTENTPROPFUNCS;
2566             }
2567         }
2568     }
2569
2570     HeapFree(GetProcessHeap(), 0, typedata);
2571     return S_OK;
2572 }
2573
2574 /******************************************************************************
2575  * ICreateTypeInfo2_DeleteFuncDesc {OLEAUT32}
2576  *
2577  *  Delete a function description from a type.
2578  *
2579  * RETURNS
2580  *
2581  *  Success: S_OK.
2582  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2583  */
2584 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteFuncDesc(
2585         ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete a function. */
2586         UINT index)              /* [I] The index of the function to delete. */
2587 {
2588     FIXME("(%p,%d), stub!\n", iface, index);
2589     return E_OUTOFMEMORY;
2590 }
2591
2592 /******************************************************************************
2593  * ICreateTypeInfo2_DeleteFuncDescByMemId {OLEAUT32}
2594  *
2595  *  Delete a function description from a type.
2596  *
2597  * RETURNS
2598  *
2599  *  Success: S_OK.
2600  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2601  */
2602 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteFuncDescByMemId(
2603         ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete a function. */
2604         MEMBERID memid,          /* [I] The member id of the function to delete. */
2605         INVOKEKIND invKind)      /* [I] The invocation type of the function to delete. (?) */
2606 {
2607     FIXME("(%p,%d,%d), stub!\n", iface, memid, invKind);
2608     return E_OUTOFMEMORY;
2609 }
2610
2611 /******************************************************************************
2612  * ICreateTypeInfo2_DeleteVarDesc {OLEAUT32}
2613  *
2614  *  Delete a variable description from a type.
2615  *
2616  * RETURNS
2617  *
2618  *  Success: S_OK.
2619  *  Failure: One of E_OUTOFMEMORY, E_INVALIDARG, TYPE_E_IOERROR,
2620  *  TYPE_E_INVDATAREAD, TYPE_E_UNSUPFORMAT or TYPE_E_INVALIDSTATE.
2621  */
2622 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteVarDesc(
2623         ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete the variable description. */
2624         UINT index)              /* [I] The index of the variable description to delete. */
2625 {
2626     FIXME("(%p,%d), stub!\n", iface, index);
2627     return E_OUTOFMEMORY;
2628 }
2629
2630 /******************************************************************************
2631  * ICreateTypeInfo2_DeleteVarDescByMemId {OLEAUT32}
2632  *
2633  *  Delete a variable description from a type.
2634  *
2635  * RETURNS
2636  *
2637  *  Success: S_OK.
2638  *  Failure: One of E_OUTOFMEMORY, E_INVALIDARG, TYPE_E_IOERROR,
2639  *  TYPE_E_INVDATAREAD, TYPE_E_UNSUPFORMAT or TYPE_E_INVALIDSTATE.
2640  */
2641 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteVarDescByMemId(
2642         ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete the variable description. */
2643         MEMBERID memid)          /* [I] The member id of the variable description to delete. */
2644 {
2645     FIXME("(%p,%d), stub!\n", iface, memid);
2646     return E_OUTOFMEMORY;
2647 }
2648
2649 /******************************************************************************
2650  * ICreateTypeInfo2_DeleteImplType {OLEAUT32}
2651  *
2652  *  Delete an interface implementation from a type. (?)
2653  *
2654  * RETURNS
2655  *
2656  *  Success: S_OK.
2657  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2658  */
2659 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteImplType(
2660         ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete. */
2661         UINT index)              /* [I] The index of the interface to delete. */
2662 {
2663     FIXME("(%p,%d), stub!\n", iface, index);
2664     return E_OUTOFMEMORY;
2665 }
2666
2667 /******************************************************************************
2668  * ICreateTypeInfo2_SetCustData {OLEAUT32}
2669  *
2670  *  Set the custom data for a type.
2671  *
2672  * RETURNS
2673  *
2674  *  Success: S_OK.
2675  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2676  */
2677 static HRESULT WINAPI ICreateTypeInfo2_fnSetCustData(
2678         ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
2679         REFGUID guid,            /* [I] The GUID used as a key to retrieve the custom data. */
2680         VARIANT* pVarVal)        /* [I] The custom data. */
2681 {
2682     FIXME("(%p,%s,%p), stub!\n", iface, debugstr_guid(guid), pVarVal);
2683     return E_OUTOFMEMORY;
2684 }
2685
2686 /******************************************************************************
2687  * ICreateTypeInfo2_SetFuncCustData {OLEAUT32}
2688  *
2689  *  Set the custom data for a function.
2690  *
2691  * RETURNS
2692  *
2693  *  Success: S_OK.
2694  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2695  */
2696 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncCustData(
2697         ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
2698         UINT index,              /* [I] The index of the function for which to set the custom data. */
2699         REFGUID guid,            /* [I] The GUID used as a key to retrieve the custom data. */
2700         VARIANT* pVarVal)        /* [I] The custom data. */
2701 {
2702     FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
2703     return E_OUTOFMEMORY;
2704 }
2705
2706 /******************************************************************************
2707  * ICreateTypeInfo2_SetParamCustData {OLEAUT32}
2708  *
2709  *  Set the custom data for a function parameter.
2710  *
2711  * RETURNS
2712  *
2713  *  Success: S_OK.
2714  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2715  */
2716 static HRESULT WINAPI ICreateTypeInfo2_fnSetParamCustData(
2717         ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
2718         UINT indexFunc,          /* [I] The index of the function on which the parameter resides. */
2719         UINT indexParam,         /* [I] The index of the parameter on which to set the custom data. */
2720         REFGUID guid,            /* [I] The GUID used as a key to retrieve the custom data. */
2721         VARIANT* pVarVal)        /* [I] The custom data. */
2722 {
2723     FIXME("(%p,%d,%d,%s,%p), stub!\n", iface, indexFunc, indexParam, debugstr_guid(guid), pVarVal);
2724     return E_OUTOFMEMORY;
2725 }
2726
2727 /******************************************************************************
2728  * ICreateTypeInfo2_SetVarCustData {OLEAUT32}
2729  *
2730  *  Set the custom data for a variable.
2731  *
2732  * RETURNS
2733  *
2734  *  Success: S_OK.
2735  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2736  */
2737 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarCustData(
2738         ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
2739         UINT index,              /* [I] The index of the variable on which to set the custom data. */
2740         REFGUID guid,            /* [I] The GUID used as a key to retrieve the custom data. */
2741         VARIANT* pVarVal)        /* [I] The custom data. */
2742 {
2743     FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
2744     return E_OUTOFMEMORY;
2745 }
2746
2747 /******************************************************************************
2748  * ICreateTypeInfo2_SetImplTypeCustData {OLEAUT32}
2749  *
2750  *  Set the custom data for an implemented interface.
2751  *
2752  * RETURNS
2753  *
2754  *  Success: S_OK.
2755  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2756  */
2757 static HRESULT WINAPI ICreateTypeInfo2_fnSetImplTypeCustData(
2758         ICreateTypeInfo2* iface, /* [I] The typeinfo on which to set the custom data. */
2759         UINT index,              /* [I] The index of the implemented interface on which to set the custom data. */
2760         REFGUID guid,            /* [I] The GUID used as a key to retrieve the custom data. */
2761         VARIANT* pVarVal)        /* [I] The custom data. */
2762 {
2763     FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
2764     return E_OUTOFMEMORY;
2765 }
2766
2767 /******************************************************************************
2768  * ICreateTypeInfo2_SetHelpStringContext {OLEAUT32}
2769  *
2770  *  Set the help string context for the typeinfo.
2771  *
2772  * RETURNS
2773  *
2774  *  Success: S_OK.
2775  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2776  */
2777 static HRESULT WINAPI ICreateTypeInfo2_fnSetHelpStringContext(
2778         ICreateTypeInfo2* iface,   /* [I] The typeinfo on which to set the help string context. */
2779         ULONG dwHelpStringContext) /* [I] The help string context. */
2780 {
2781     FIXME("(%p,%d), stub!\n", iface, dwHelpStringContext);
2782     return E_OUTOFMEMORY;
2783 }
2784
2785 /******************************************************************************
2786  * ICreateTypeInfo2_SetFuncHelpStringContext {OLEAUT32}
2787  *
2788  *  Set the help string context for a function.
2789  *
2790  * RETURNS
2791  *
2792  *  Success: S_OK.
2793  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2794  */
2795 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncHelpStringContext(
2796         ICreateTypeInfo2* iface,   /* [I] The typeinfo on which to set the help string context. */
2797         UINT index,                /* [I] The index for the function on which to set the help string context. */
2798         ULONG dwHelpStringContext) /* [I] The help string context. */
2799 {
2800     FIXME("(%p,%d,%d), stub!\n", iface, index, dwHelpStringContext);
2801     return E_OUTOFMEMORY;
2802 }
2803
2804 /******************************************************************************
2805  * ICreateTypeInfo2_SetVarHelpStringContext {OLEAUT32}
2806  *
2807  *  Set the help string context for a variable.
2808  *
2809  * RETURNS
2810  *
2811  *  Success: S_OK.
2812  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2813  */
2814 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarHelpStringContext(
2815         ICreateTypeInfo2* iface,   /* [I] The typeinfo on which to set the help string context. */
2816         UINT index,                /* [I] The index of the variable on which to set the help string context. */
2817         ULONG dwHelpStringContext) /* [I] The help string context */
2818 {
2819     FIXME("(%p,%d,%d), stub!\n", iface, index, dwHelpStringContext);
2820     return E_OUTOFMEMORY;
2821 }
2822
2823 /******************************************************************************
2824  * ICreateTypeInfo2_Invalidate {OLEAUT32}
2825  *
2826  *  Undocumented function. (!)
2827  */
2828 static HRESULT WINAPI ICreateTypeInfo2_fnInvalidate(
2829         ICreateTypeInfo2* iface)
2830 {
2831     FIXME("(%p), stub!\n", iface);
2832     return E_OUTOFMEMORY;
2833 }
2834
2835 /******************************************************************************
2836  * ICreateTypeInfo2_SetName {OLEAUT32}
2837  *
2838  *  Set the name for a typeinfo.
2839  *
2840  * RETURNS
2841  *
2842  *  Success: S_OK.
2843  *  Failure: One of STG_E_INSUFFICIENTMEMORY, E_OUTOFMEMORY, E_INVALIDARG or TYPE_E_INVALIDSTATE.
2844  */
2845 static HRESULT WINAPI ICreateTypeInfo2_fnSetName(
2846         ICreateTypeInfo2* iface,
2847         LPOLESTR szName)
2848 {
2849     FIXME("(%p,%s), stub!\n", iface, debugstr_w(szName));
2850     return E_OUTOFMEMORY;
2851 }
2852
2853 /*================== ITypeInfo2 Implementation ===================================*/
2854
2855 /******************************************************************************
2856  * ITypeInfo2_QueryInterface {OLEAUT32}
2857  *
2858  *  See IUnknown_QueryInterface.
2859  */
2860 static HRESULT WINAPI ITypeInfo2_fnQueryInterface(ITypeInfo2 * iface, REFIID riid, LPVOID * ppv)
2861 {
2862     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
2863
2864     return ICreateTypeInfo2_QueryInterface((ICreateTypeInfo2 *)This, riid, ppv);
2865 }
2866
2867 /******************************************************************************
2868  * ITypeInfo2_AddRef {OLEAUT32}
2869  *
2870  *  See IUnknown_AddRef.
2871  */
2872 static ULONG WINAPI ITypeInfo2_fnAddRef(ITypeInfo2 * iface)
2873 {
2874     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
2875
2876     return ICreateTypeInfo2_AddRef((ICreateTypeInfo2 *)This);
2877 }
2878
2879 /******************************************************************************
2880  * ITypeInfo2_Release {OLEAUT32}
2881  *
2882  *  See IUnknown_Release.
2883  */
2884 static ULONG WINAPI ITypeInfo2_fnRelease(ITypeInfo2 * iface)
2885 {
2886     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
2887
2888     return ICreateTypeInfo2_Release((ICreateTypeInfo2 *)This);
2889 }
2890
2891 /******************************************************************************
2892  * ITypeInfo2_GetTypeAttr {OLEAUT32}
2893  *
2894  *  See ITypeInfo_GetTypeAttr.
2895  */
2896 static HRESULT WINAPI ITypeInfo2_fnGetTypeAttr(
2897         ITypeInfo2* iface,
2898         TYPEATTR** ppTypeAttr)
2899 {
2900     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
2901     HRESULT hres;
2902
2903     TRACE("(%p,%p)\n", iface, ppTypeAttr);
2904
2905     if(!ppTypeAttr)
2906         return E_INVALIDARG;
2907
2908     hres = ICreateTypeInfo_LayOut((ICreateTypeInfo*)This);
2909     if(FAILED(hres))
2910         return hres;
2911
2912     *ppTypeAttr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(TYPEATTR));
2913     if(!*ppTypeAttr)
2914         return E_OUTOFMEMORY;
2915
2916     if(This->typeinfo->posguid != -1) {
2917         MSFT_GuidEntry *guid;
2918
2919         guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][This->typeinfo->posguid];
2920         (*ppTypeAttr)->guid = guid->guid;
2921     }
2922
2923     (*ppTypeAttr)->lcid = This->typelib->typelib_header.lcid;
2924     (*ppTypeAttr)->cbSizeInstance = This->typeinfo->size;
2925     (*ppTypeAttr)->typekind = This->typekind;
2926     (*ppTypeAttr)->cFuncs = This->typeinfo->cElement&0xffff;
2927     if(This->typeinfo->flags&TYPEFLAG_FDUAL && This->typekind==TKIND_DISPATCH)
2928         (*ppTypeAttr)->cFuncs += 7;
2929     (*ppTypeAttr)->cVars = This->typeinfo->cElement>>16;
2930     (*ppTypeAttr)->cImplTypes = This->typeinfo->cImplTypes;
2931     (*ppTypeAttr)->cbSizeVft = This->typekind==TKIND_DISPATCH ? 28 : This->typeinfo->cbSizeVft;
2932     (*ppTypeAttr)->cbAlignment = (This->typeinfo->typekind>>11) & 0x1f;
2933     (*ppTypeAttr)->wTypeFlags = This->typeinfo->flags;
2934     (*ppTypeAttr)->wMajorVerNum = This->typeinfo->version&0xffff;
2935     (*ppTypeAttr)->wMinorVerNum = This->typeinfo->version>>16;
2936
2937     if((*ppTypeAttr)->typekind == TKIND_ALIAS)
2938         FIXME("TKIND_ALIAS handling not implemented\n");
2939
2940     return S_OK;
2941 }
2942
2943 /******************************************************************************
2944  * ITypeInfo2_GetTypeComp {OLEAUT32}
2945  *
2946  *  See ITypeInfo_GetTypeComp.
2947  */
2948 static HRESULT WINAPI ITypeInfo2_fnGetTypeComp(
2949         ITypeInfo2* iface,
2950         ITypeComp** ppTComp)
2951 {
2952     FIXME("(%p,%p), stub!\n", iface, ppTComp);
2953     return E_OUTOFMEMORY;
2954 }
2955
2956 /******************************************************************************
2957  * ITypeInfo2_GetFuncDesc {OLEAUT32}
2958  *
2959  *  See ITypeInfo_GetFuncDesc.
2960  */
2961 static HRESULT WINAPI ITypeInfo2_fnGetFuncDesc(
2962         ITypeInfo2* iface,
2963         UINT index,
2964         FUNCDESC** ppFuncDesc)
2965 {
2966     FIXME("(%p,%d,%p), stub!\n", iface, index, ppFuncDesc);
2967     return E_OUTOFMEMORY;
2968 }
2969
2970 /******************************************************************************
2971  * ITypeInfo2_GetVarDesc {OLEAUT32}
2972  *
2973  *  See ITypeInfo_GetVarDesc.
2974  */
2975 static HRESULT WINAPI ITypeInfo2_fnGetVarDesc(
2976         ITypeInfo2* iface,
2977         UINT index,
2978         VARDESC** ppVarDesc)
2979 {
2980     FIXME("(%p,%d,%p), stub!\n", iface, index, ppVarDesc);
2981     return E_OUTOFMEMORY;
2982 }
2983
2984 /******************************************************************************
2985  * ITypeInfo2_GetNames {OLEAUT32}
2986  *
2987  *  See ITypeInfo_GetNames.
2988  */
2989 static HRESULT WINAPI ITypeInfo2_fnGetNames(
2990         ITypeInfo2* iface,
2991         MEMBERID memid,
2992         BSTR* rgBstrNames,
2993         UINT cMaxNames,
2994         UINT* pcNames)
2995 {
2996     FIXME("(%p,%d,%p,%d,%p), stub!\n", iface, memid, rgBstrNames, cMaxNames, pcNames);
2997     return E_OUTOFMEMORY;
2998 }
2999
3000 /******************************************************************************
3001  * ITypeInfo2_GetRefTypeOfImplType {OLEAUT32}
3002  *
3003  *  See ITypeInfo_GetRefTypeOfImplType.
3004  */
3005 static HRESULT WINAPI ITypeInfo2_fnGetRefTypeOfImplType(
3006         ITypeInfo2* iface,
3007         UINT index,
3008         HREFTYPE* pRefType)
3009 {
3010     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3011     MSFT_RefRecord *ref;
3012     int offset;
3013
3014     TRACE("(%p,%d,%p)\n", iface, index, pRefType);
3015
3016     if(!pRefType)
3017         return E_INVALIDARG;
3018
3019     if(This->typeinfo->flags&TYPEFLAG_FDUAL) {
3020         if(index == -1) {
3021             *pRefType = -2;
3022             return S_OK;
3023         }
3024
3025         if(This->typekind == TKIND_DISPATCH)
3026             return ITypeInfo2_GetRefTypeOfImplType((ITypeInfo2*)&This->dual->lpVtblTypeInfo2,
3027                     index, pRefType);
3028     }
3029
3030     if(index>=This->typeinfo->cImplTypes)
3031         return TYPE_E_ELEMENTNOTFOUND;
3032
3033     if(This->typekind == TKIND_INTERFACE) {
3034         *pRefType = This->typeinfo->datatype1 + 2;
3035         return S_OK;
3036     }
3037
3038     offset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index);
3039     if(offset == -1)
3040         return TYPE_E_ELEMENTNOTFOUND;
3041
3042     ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
3043     *pRefType = ref->reftype;
3044     return S_OK;
3045 }
3046
3047 /******************************************************************************
3048  * ITypeInfo2_GetImplTypeFlags {OLEAUT32}
3049  *
3050  *  See ITypeInfo_GetImplTypeFlags.
3051  */
3052 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeFlags(
3053         ITypeInfo2* iface,
3054         UINT index,
3055         INT* pImplTypeFlags)
3056 {
3057     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3058     int offset;
3059     MSFT_RefRecord *ref;
3060
3061     TRACE("(%p,%d,%p)\n", iface, index, pImplTypeFlags);
3062
3063     if(!pImplTypeFlags)
3064         return E_INVALIDARG;
3065
3066     if(index >= This->typeinfo->cImplTypes)
3067         return TYPE_E_ELEMENTNOTFOUND;
3068
3069     if(This->typekind != TKIND_COCLASS) {
3070         *pImplTypeFlags = 0;
3071         return S_OK;
3072     }
3073
3074     offset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index);
3075     if(offset == -1)
3076         return TYPE_E_ELEMENTNOTFOUND;
3077
3078     ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
3079     *pImplTypeFlags = ref->flags;
3080     return S_OK;
3081 }
3082
3083 /******************************************************************************
3084  * ITypeInfo2_GetIDsOfNames {OLEAUT32}
3085  *
3086  *  See ITypeInfo_GetIDsOfNames.
3087  */
3088 static HRESULT WINAPI ITypeInfo2_fnGetIDsOfNames(
3089         ITypeInfo2* iface,
3090         LPOLESTR* rgszNames,
3091         UINT cNames,
3092         MEMBERID* pMemId)
3093 {
3094     FIXME("(%p,%p,%d,%p), stub!\n", iface, rgszNames, cNames, pMemId);
3095     return E_OUTOFMEMORY;
3096 }
3097
3098 /******************************************************************************
3099  * ITypeInfo2_Invoke {OLEAUT32}
3100  *
3101  *  See ITypeInfo_Invoke.
3102  */
3103 static HRESULT WINAPI ITypeInfo2_fnInvoke(
3104         ITypeInfo2* iface,
3105         PVOID pvInstance,
3106         MEMBERID memid,
3107         WORD wFlags,
3108         DISPPARAMS* pDispParams,
3109         VARIANT* pVarResult,
3110         EXCEPINFO* pExcepInfo,
3111         UINT* puArgErr)
3112 {
3113     FIXME("(%p,%p,%d,%x,%p,%p,%p,%p), stub!\n", iface, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3114     return E_OUTOFMEMORY;
3115 }
3116
3117 /******************************************************************************
3118  * ITypeInfo2_GetDocumentation {OLEAUT32}
3119  *
3120  *  See ITypeInfo_GetDocumentation.
3121  */
3122 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation(
3123         ITypeInfo2* iface,
3124         MEMBERID memid,
3125         BSTR* pBstrName,
3126         BSTR* pBstrDocString,
3127         DWORD* pdwHelpContext,
3128         BSTR* pBstrHelpFile)
3129 {
3130     FIXME("(%p,%d,%p,%p,%p,%p), stub!\n", iface, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
3131     return E_OUTOFMEMORY;
3132 }
3133
3134 /******************************************************************************
3135  * ITypeInfo2_GetDllEntry {OLEAUT32}
3136  *
3137  *  See ITypeInfo_GetDllEntry.
3138  */
3139 static HRESULT WINAPI ITypeInfo2_fnGetDllEntry(
3140         ITypeInfo2* iface,
3141         MEMBERID memid,
3142         INVOKEKIND invKind,
3143         BSTR* pBstrDllName,
3144         BSTR* pBstrName,
3145         WORD* pwOrdinal)
3146 {
3147     FIXME("(%p,%d,%d,%p,%p,%p), stub!\n", iface, memid, invKind, pBstrDllName, pBstrName, pwOrdinal);
3148     return E_OUTOFMEMORY;
3149 }
3150
3151 /******************************************************************************
3152  * ITypeInfo2_GetRefTypeInfo {OLEAUT32}
3153  *
3154  *  See ITypeInfo_GetRefTypeInfo.
3155  */
3156 static HRESULT WINAPI ITypeInfo2_fnGetRefTypeInfo(
3157         ITypeInfo2* iface,
3158         HREFTYPE hRefType,
3159         ITypeInfo** ppTInfo)
3160 {
3161     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3162
3163     TRACE("(%p,%d,%p)\n", iface, hRefType, ppTInfo);
3164
3165     if(!ppTInfo)
3166         return E_INVALIDARG;
3167
3168     if(hRefType==-2 && This->dual) {
3169         *ppTInfo = (ITypeInfo*)&This->dual->lpVtblTypeInfo2;
3170         ITypeInfo_AddRef(*ppTInfo);
3171         return S_OK;
3172     }
3173
3174     if(hRefType&1) {
3175         ITypeLib *tl;
3176         MSFT_ImpInfo *impinfo;
3177         MSFT_ImpFile *impfile;
3178         MSFT_GuidEntry *guid;
3179         WCHAR *filename;
3180         HRESULT hres;
3181
3182         if((hRefType&(~0x3)) >= This->typelib->typelib_segdir[MSFT_SEG_IMPORTINFO].length)
3183             return E_FAIL;
3184
3185         impinfo = (MSFT_ImpInfo*)&This->typelib->typelib_segment_data[MSFT_SEG_IMPORTINFO][hRefType&(~0x3)];
3186         impfile = (MSFT_ImpFile*)&This->typelib->typelib_segment_data[MSFT_SEG_IMPORTFILES][impinfo->oImpFile];
3187         guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][impinfo->oGuid];
3188
3189         ctl2_decode_string(impfile->filename, &filename);
3190
3191         hres = LoadTypeLib(filename, &tl);
3192         if(FAILED(hres))
3193             return hres;
3194
3195         hres = ITypeLib_GetTypeInfoOfGuid(tl, &guid->guid, ppTInfo);
3196
3197         ITypeLib_Release(tl);
3198         return hres;
3199     } else {
3200         ICreateTypeInfo2Impl *iter;
3201         int i = 0;
3202
3203         for(iter=This->typelib->typeinfos; iter; iter=iter->next_typeinfo) {
3204             if(This->typelib->typelib_typeinfo_offsets[i] == (hRefType&(~0x3))) {
3205                 *ppTInfo = (ITypeInfo*)&iter->lpVtblTypeInfo2;
3206
3207                 ITypeLib_AddRef(*ppTInfo);
3208                 return S_OK;
3209             }
3210             i++;
3211         }
3212     }
3213
3214     return E_FAIL;
3215 }
3216
3217 /******************************************************************************
3218  * ITypeInfo2_AddressOfMember {OLEAUT32}
3219  *
3220  *  See ITypeInfo_AddressOfMember.
3221  */
3222 static HRESULT WINAPI ITypeInfo2_fnAddressOfMember(
3223         ITypeInfo2* iface,
3224         MEMBERID memid,
3225         INVOKEKIND invKind,
3226         PVOID* ppv)
3227 {
3228     FIXME("(%p,%d,%d,%p), stub!\n", iface, memid, invKind, ppv);
3229     return E_OUTOFMEMORY;
3230 }
3231
3232 /******************************************************************************
3233  * ITypeInfo2_CreateInstance {OLEAUT32}
3234  *
3235  *  See ITypeInfo_CreateInstance.
3236  */
3237 static HRESULT WINAPI ITypeInfo2_fnCreateInstance(
3238         ITypeInfo2* iface,
3239         IUnknown* pUnkOuter,
3240         REFIID riid,
3241         PVOID* ppvObj)
3242 {
3243     FIXME("(%p,%p,%s,%p), stub!\n", iface, pUnkOuter, debugstr_guid(riid), ppvObj);
3244     return E_OUTOFMEMORY;
3245 }
3246
3247 /******************************************************************************
3248  * ITypeInfo2_GetMops {OLEAUT32}
3249  *
3250  *  See ITypeInfo_GetMops.
3251  */
3252 static HRESULT WINAPI ITypeInfo2_fnGetMops(
3253         ITypeInfo2* iface,
3254         MEMBERID memid,
3255         BSTR* pBstrMops)
3256 {
3257     FIXME("(%p,%d,%p), stub!\n", iface, memid, pBstrMops);
3258     return E_OUTOFMEMORY;
3259 }
3260
3261 /******************************************************************************
3262  * ITypeInfo2_GetContainingTypeLib {OLEAUT32}
3263  *
3264  *  See ITypeInfo_GetContainingTypeLib.
3265  */
3266 static HRESULT WINAPI ITypeInfo2_fnGetContainingTypeLib(
3267         ITypeInfo2* iface,
3268         ITypeLib** ppTLib,
3269         UINT* pIndex)
3270 {
3271     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3272
3273     TRACE("(%p,%p,%p)\n", iface, ppTLib, pIndex);
3274
3275     *ppTLib = (ITypeLib *)&This->typelib->lpVtblTypeLib2;
3276     ICreateTypeLib_AddRef((ICreateTypeLib*)This->typelib);
3277     *pIndex = This->typeinfo->typekind >> 16;
3278
3279     return S_OK;
3280 }
3281
3282 /******************************************************************************
3283  * ITypeInfo2_ReleaseTypeAttr {OLEAUT32}
3284  *
3285  *  See ITypeInfo_ReleaseTypeAttr.
3286  */
3287 static void WINAPI ITypeInfo2_fnReleaseTypeAttr(
3288         ITypeInfo2* iface,
3289         TYPEATTR* pTypeAttr)
3290 {
3291     TRACE("(%p,%p)\n", iface, pTypeAttr);
3292
3293     HeapFree(GetProcessHeap(), 0, pTypeAttr);
3294 }
3295
3296 /******************************************************************************
3297  * ITypeInfo2_ReleaseFuncDesc {OLEAUT32}
3298  *
3299  *  See ITypeInfo_ReleaseFuncDesc.
3300  */
3301 static void WINAPI ITypeInfo2_fnReleaseFuncDesc(
3302         ITypeInfo2* iface,
3303         FUNCDESC* pFuncDesc)
3304 {
3305     FIXME("(%p,%p), stub!\n", iface, pFuncDesc);
3306 }
3307
3308 /******************************************************************************
3309  * ITypeInfo2_ReleaseVarDesc {OLEAUT32}
3310  *
3311  *  See ITypeInfo_ReleaseVarDesc.
3312  */
3313 static void WINAPI ITypeInfo2_fnReleaseVarDesc(
3314         ITypeInfo2* iface,
3315         VARDESC* pVarDesc)
3316 {
3317     FIXME("(%p,%p), stub!\n", iface, pVarDesc);
3318 }
3319
3320 /******************************************************************************
3321  * ITypeInfo2_GetTypeKind {OLEAUT32}
3322  *
3323  *  Get the TYPEKIND value for a TypeInfo.
3324  *
3325  * RETURNS
3326  *
3327  *  Success: S_OK.
3328  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3329  */
3330 static HRESULT WINAPI ITypeInfo2_fnGetTypeKind(
3331         ITypeInfo2* iface,   /* [I] The TypeInfo to obtain the typekind for. */
3332         TYPEKIND* pTypeKind) /* [O] The typekind for this TypeInfo. */
3333 {
3334     FIXME("(%p,%p), stub!\n", iface, pTypeKind);
3335     return E_OUTOFMEMORY;
3336 }
3337
3338 /******************************************************************************
3339  * ITypeInfo2_GetTypeFlags {OLEAUT32}
3340  *
3341  *  Get the Type Flags for a TypeInfo.
3342  *
3343  * RETURNS
3344  *
3345  *  Success: S_OK.
3346  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3347  */
3348 static HRESULT WINAPI ITypeInfo2_fnGetTypeFlags(
3349         ITypeInfo2* iface, /* [I] The TypeInfo to obtain the typeflags for. */
3350         ULONG* pTypeFlags) /* [O] The type flags for this TypeInfo. */
3351 {
3352     FIXME("(%p,%p), stub!\n", iface, pTypeFlags);
3353     return E_OUTOFMEMORY;
3354 }
3355
3356 /******************************************************************************
3357  * ITypeInfo2_GetFuncIndexOfMemId {OLEAUT32}
3358  *
3359  *  Gets the index of a function given its member id.
3360  *
3361  * RETURNS
3362  *
3363  *  Success: S_OK.
3364  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3365  */
3366 static HRESULT WINAPI ITypeInfo2_fnGetFuncIndexOfMemId(
3367         ITypeInfo2* iface,  /* [I] The TypeInfo in which to find the function. */
3368         MEMBERID memid,     /* [I] The member id for the function. */
3369         INVOKEKIND invKind, /* [I] The invocation kind for the function. */
3370         UINT* pFuncIndex)   /* [O] The index of the function. */
3371 {
3372     FIXME("(%p,%d,%d,%p), stub!\n", iface, memid, invKind, pFuncIndex);
3373     return E_OUTOFMEMORY;
3374 }
3375
3376 /******************************************************************************
3377  * ITypeInfo2_GetVarIndexOfMemId {OLEAUT32}
3378  *
3379  *  Gets the index of a variable given its member id.
3380  *
3381  * RETURNS
3382  *
3383  *  Success: S_OK.
3384  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3385  */
3386 static HRESULT WINAPI ITypeInfo2_fnGetVarIndexOfMemId(
3387         ITypeInfo2* iface, /* [I] The TypeInfo in which to find the variable. */
3388         MEMBERID memid,    /* [I] The member id for the variable. */
3389         UINT* pVarIndex)   /* [O] The index of the variable. */
3390 {
3391     FIXME("(%p,%d,%p), stub!\n", iface, memid, pVarIndex);
3392     return E_OUTOFMEMORY;
3393 }
3394
3395 /******************************************************************************
3396  * ITypeInfo2_GetCustData {OLEAUT32}
3397  *
3398  *  Gets a custom data element from a TypeInfo.
3399  *
3400  * RETURNS
3401  *
3402  *  Success: S_OK.
3403  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3404  */
3405 static HRESULT WINAPI ITypeInfo2_fnGetCustData(
3406         ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
3407         REFGUID guid,      /* [I] The GUID under which the custom data is stored. */
3408         VARIANT* pVarVal)  /* [O] The custom data. */
3409 {
3410     FIXME("(%p,%s,%p), stub!\n", iface, debugstr_guid(guid), pVarVal);
3411     return E_OUTOFMEMORY;
3412 }
3413
3414 /******************************************************************************
3415  * ITypeInfo2_GetFuncCustData {OLEAUT32}
3416  *
3417  *  Gets a custom data element from a function.
3418  *
3419  * RETURNS
3420  *
3421  *  Success: S_OK.
3422  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3423  */
3424 static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData(
3425         ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
3426         UINT index,        /* [I] The index of the function for which to retrieve the custom data. */
3427         REFGUID guid,      /* [I] The GUID under which the custom data is stored. */
3428         VARIANT* pVarVal)  /* [O] The custom data. */
3429 {
3430     FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
3431     return E_OUTOFMEMORY;
3432 }
3433
3434 /******************************************************************************
3435  * ITypeInfo2_GetParamCustData {OLEAUT32}
3436  *
3437  *  Gets a custom data element from a parameter.
3438  *
3439  * RETURNS
3440  *
3441  *  Success: S_OK.
3442  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3443  */
3444 static HRESULT WINAPI ITypeInfo2_fnGetParamCustData(
3445         ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
3446         UINT indexFunc,    /* [I] The index of the function for which to retrieve the custom data. */
3447         UINT indexParam,   /* [I] The index of the parameter for which to retrieve the custom data. */
3448         REFGUID guid,      /* [I] The GUID under which the custom data is stored. */
3449         VARIANT* pVarVal)  /* [O] The custom data. */
3450 {
3451     FIXME("(%p,%d,%d,%s,%p), stub!\n", iface, indexFunc, indexParam, debugstr_guid(guid), pVarVal);
3452     return E_OUTOFMEMORY;
3453 }
3454
3455 /******************************************************************************
3456  * ITypeInfo2_GetVarCustData {OLEAUT32}
3457  *
3458  *  Gets a custom data element from a variable.
3459  *
3460  * RETURNS
3461  *
3462  *  Success: S_OK.
3463  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3464  */
3465 static HRESULT WINAPI ITypeInfo2_fnGetVarCustData(
3466         ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
3467         UINT index,        /* [I] The index of the variable for which to retrieve the custom data. */
3468         REFGUID guid,      /* [I] The GUID under which the custom data is stored. */
3469         VARIANT* pVarVal)  /* [O] The custom data. */
3470 {
3471     FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
3472     return E_OUTOFMEMORY;
3473 }
3474
3475 /******************************************************************************
3476  * ITypeInfo2_GetImplTypeCustData {OLEAUT32}
3477  *
3478  *  Gets a custom data element from an implemented type of a TypeInfo.
3479  *
3480  * RETURNS
3481  *
3482  *  Success: S_OK.
3483  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3484  */
3485 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData(
3486         ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
3487         UINT index,        /* [I] The index of the implemented type for which to retrieve the custom data. */
3488         REFGUID guid,      /* [I] The GUID under which the custom data is stored. */
3489         VARIANT* pVarVal)  /* [O] The custom data. */
3490 {
3491     FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
3492     return E_OUTOFMEMORY;
3493 }
3494
3495 /******************************************************************************
3496  * ITypeInfo2_GetDocumentation2 {OLEAUT32}
3497  *
3498  *  Gets some documentation from a TypeInfo in a locale-aware fashion.
3499  *
3500  * RETURNS
3501  *
3502  *  Success: S_OK.
3503  *  Failure: One of STG_E_INSUFFICIENTMEMORY or E_INVALIDARG.
3504  */
3505 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2(
3506         ITypeInfo2* iface,           /* [I] The TypeInfo to retrieve the documentation from. */
3507         MEMBERID memid,              /* [I] The member id (why?). */
3508         LCID lcid,                   /* [I] The locale (why?). */
3509         BSTR* pbstrHelpString,       /* [O] The help string. */
3510         DWORD* pdwHelpStringContext, /* [O] The help string context. */
3511         BSTR* pbstrHelpStringDll)    /* [O] The help file name. */
3512 {
3513     FIXME("(%p,%d,%d,%p,%p,%p), stub!\n", iface, memid, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll);
3514     return E_OUTOFMEMORY;
3515 }
3516
3517 /******************************************************************************
3518  * ITypeInfo2_GetAllCustData {OLEAUT32}
3519  *
3520  *  Gets all of the custom data associated with a TypeInfo.
3521  *
3522  * RETURNS
3523  *
3524  *  Success: S_OK.
3525  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3526  */
3527 static HRESULT WINAPI ITypeInfo2_fnGetAllCustData(
3528         ITypeInfo2* iface,   /* [I] The TypeInfo in which to find the custom data. */
3529         CUSTDATA* pCustData) /* [O] A pointer to the custom data. */
3530 {
3531     FIXME("(%p,%p), stub!\n", iface, pCustData);
3532     return E_OUTOFMEMORY;
3533 }
3534
3535 /******************************************************************************
3536  * ITypeInfo2_GetAllFuncCustData {OLEAUT32}
3537  *
3538  *  Gets all of the custom data associated with a function.
3539  *
3540  * RETURNS
3541  *
3542  *  Success: S_OK.
3543  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3544  */
3545 static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData(
3546         ITypeInfo2* iface,   /* [I] The TypeInfo in which to find the custom data. */
3547         UINT index,          /* [I] The index of the function for which to retrieve the custom data. */
3548         CUSTDATA* pCustData) /* [O] A pointer to the custom data. */
3549 {
3550     FIXME("(%p,%d,%p), stub!\n", iface, index, pCustData);
3551     return E_OUTOFMEMORY;
3552 }
3553
3554 /******************************************************************************
3555  * ITypeInfo2_GetAllParamCustData {OLEAUT32}
3556  *
3557  *  Gets all of the custom data associated with a parameter.
3558  *
3559  * RETURNS
3560  *
3561  *  Success: S_OK.
3562  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3563  */
3564 static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData(
3565         ITypeInfo2* iface,   /* [I] The TypeInfo in which to find the custom data. */
3566         UINT indexFunc,      /* [I] The index of the function for which to retrieve the custom data. */
3567         UINT indexParam,     /* [I] The index of the parameter for which to retrieve the custom data. */
3568         CUSTDATA* pCustData) /* [O] A pointer to the custom data. */
3569 {
3570     FIXME("(%p,%d,%d,%p), stub!\n", iface, indexFunc, indexParam, pCustData);
3571     return E_OUTOFMEMORY;
3572 }
3573
3574 /******************************************************************************
3575  * ITypeInfo2_GetAllVarCustData {OLEAUT32}
3576  *
3577  *  Gets all of the custom data associated with a variable.
3578  *
3579  * RETURNS
3580  *
3581  *  Success: S_OK.
3582  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3583  */
3584 static HRESULT WINAPI ITypeInfo2_fnGetAllVarCustData(
3585         ITypeInfo2* iface,   /* [I] The TypeInfo in which to find the custom data. */
3586         UINT index,          /* [I] The index of the variable for which to retrieve the custom data. */
3587         CUSTDATA* pCustData) /* [O] A pointer to the custom data. */
3588 {
3589     FIXME("(%p,%d,%p), stub!\n", iface, index, pCustData);
3590     return E_OUTOFMEMORY;
3591 }
3592
3593 /******************************************************************************
3594  * ITypeInfo2_GetAllImplTypeCustData {OLEAUT32}
3595  *
3596  *  Gets all of the custom data associated with an implemented type.
3597  *
3598  * RETURNS
3599  *
3600  *  Success: S_OK.
3601  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3602  */
3603 static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData(
3604         ITypeInfo2* iface,   /* [I] The TypeInfo in which to find the custom data. */
3605         UINT index,          /* [I] The index of the implemented type for which to retrieve the custom data. */
3606         CUSTDATA* pCustData) /* [O] A pointer to the custom data. */
3607 {
3608     FIXME("(%p,%d,%p), stub!\n", iface, index, pCustData);
3609     return E_OUTOFMEMORY;
3610 }
3611
3612
3613 /*================== ICreateTypeInfo2 & ITypeInfo2 VTABLEs And Creation ===================================*/
3614
3615 static const ICreateTypeInfo2Vtbl ctypeinfo2vt =
3616 {
3617
3618     ICreateTypeInfo2_fnQueryInterface,
3619     ICreateTypeInfo2_fnAddRef,
3620     ICreateTypeInfo2_fnRelease,
3621
3622     ICreateTypeInfo2_fnSetGuid,
3623     ICreateTypeInfo2_fnSetTypeFlags,
3624     ICreateTypeInfo2_fnSetDocString,
3625     ICreateTypeInfo2_fnSetHelpContext,
3626     ICreateTypeInfo2_fnSetVersion,
3627     ICreateTypeInfo2_fnAddRefTypeInfo,
3628     ICreateTypeInfo2_fnAddFuncDesc,
3629     ICreateTypeInfo2_fnAddImplType,
3630     ICreateTypeInfo2_fnSetImplTypeFlags,
3631     ICreateTypeInfo2_fnSetAlignment,
3632     ICreateTypeInfo2_fnSetSchema,
3633     ICreateTypeInfo2_fnAddVarDesc,
3634     ICreateTypeInfo2_fnSetFuncAndParamNames,
3635     ICreateTypeInfo2_fnSetVarName,
3636     ICreateTypeInfo2_fnSetTypeDescAlias,
3637     ICreateTypeInfo2_fnDefineFuncAsDllEntry,
3638     ICreateTypeInfo2_fnSetFuncDocString,
3639     ICreateTypeInfo2_fnSetVarDocString,
3640     ICreateTypeInfo2_fnSetFuncHelpContext,
3641     ICreateTypeInfo2_fnSetVarHelpContext,
3642     ICreateTypeInfo2_fnSetMops,
3643     ICreateTypeInfo2_fnSetTypeIdldesc,
3644     ICreateTypeInfo2_fnLayOut,
3645
3646     ICreateTypeInfo2_fnDeleteFuncDesc,
3647     ICreateTypeInfo2_fnDeleteFuncDescByMemId,
3648     ICreateTypeInfo2_fnDeleteVarDesc,
3649     ICreateTypeInfo2_fnDeleteVarDescByMemId,
3650     ICreateTypeInfo2_fnDeleteImplType,
3651     ICreateTypeInfo2_fnSetCustData,
3652     ICreateTypeInfo2_fnSetFuncCustData,
3653     ICreateTypeInfo2_fnSetParamCustData,
3654     ICreateTypeInfo2_fnSetVarCustData,
3655     ICreateTypeInfo2_fnSetImplTypeCustData,
3656     ICreateTypeInfo2_fnSetHelpStringContext,
3657     ICreateTypeInfo2_fnSetFuncHelpStringContext,
3658     ICreateTypeInfo2_fnSetVarHelpStringContext,
3659     ICreateTypeInfo2_fnInvalidate,
3660     ICreateTypeInfo2_fnSetName
3661 };
3662
3663 static const ITypeInfo2Vtbl typeinfo2vt =
3664 {
3665
3666     ITypeInfo2_fnQueryInterface,
3667     ITypeInfo2_fnAddRef,
3668     ITypeInfo2_fnRelease,
3669
3670     ITypeInfo2_fnGetTypeAttr,
3671     ITypeInfo2_fnGetTypeComp,
3672     ITypeInfo2_fnGetFuncDesc,
3673     ITypeInfo2_fnGetVarDesc,
3674     ITypeInfo2_fnGetNames,
3675     ITypeInfo2_fnGetRefTypeOfImplType,
3676     ITypeInfo2_fnGetImplTypeFlags,
3677     ITypeInfo2_fnGetIDsOfNames,
3678     ITypeInfo2_fnInvoke,
3679     ITypeInfo2_fnGetDocumentation,
3680     ITypeInfo2_fnGetDllEntry,
3681     ITypeInfo2_fnGetRefTypeInfo,
3682     ITypeInfo2_fnAddressOfMember,
3683     ITypeInfo2_fnCreateInstance,
3684     ITypeInfo2_fnGetMops,
3685     ITypeInfo2_fnGetContainingTypeLib,
3686     ITypeInfo2_fnReleaseTypeAttr,
3687     ITypeInfo2_fnReleaseFuncDesc,
3688     ITypeInfo2_fnReleaseVarDesc,
3689
3690     ITypeInfo2_fnGetTypeKind,
3691     ITypeInfo2_fnGetTypeFlags,
3692     ITypeInfo2_fnGetFuncIndexOfMemId,
3693     ITypeInfo2_fnGetVarIndexOfMemId,
3694     ITypeInfo2_fnGetCustData,
3695     ITypeInfo2_fnGetFuncCustData,
3696     ITypeInfo2_fnGetParamCustData,
3697     ITypeInfo2_fnGetVarCustData,
3698     ITypeInfo2_fnGetImplTypeCustData,
3699     ITypeInfo2_fnGetDocumentation2,
3700     ITypeInfo2_fnGetAllCustData,
3701     ITypeInfo2_fnGetAllFuncCustData,
3702     ITypeInfo2_fnGetAllParamCustData,
3703     ITypeInfo2_fnGetAllVarCustData,
3704     ITypeInfo2_fnGetAllImplTypeCustData,
3705 };
3706
3707 static ICreateTypeInfo2 *ICreateTypeInfo2_Constructor(ICreateTypeLib2Impl *typelib, WCHAR *szName, TYPEKIND tkind)
3708 {
3709     ICreateTypeInfo2Impl *pCreateTypeInfo2Impl;
3710
3711     int nameoffset;
3712     int typeinfo_offset;
3713     MSFT_TypeInfoBase *typeinfo;
3714
3715     TRACE("Constructing ICreateTypeInfo2 for %s with tkind %d\n", debugstr_w(szName), tkind);
3716
3717     pCreateTypeInfo2Impl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ICreateTypeInfo2Impl));
3718     if (!pCreateTypeInfo2Impl) return NULL;
3719
3720     pCreateTypeInfo2Impl->lpVtbl = &ctypeinfo2vt;
3721     pCreateTypeInfo2Impl->lpVtblTypeInfo2 = &typeinfo2vt;
3722     pCreateTypeInfo2Impl->ref = 1;
3723
3724     pCreateTypeInfo2Impl->typelib = typelib;
3725     ICreateTypeLib_AddRef((ICreateTypeLib*)typelib);
3726
3727     nameoffset = ctl2_alloc_name(typelib, szName);
3728     typeinfo_offset = ctl2_alloc_typeinfo(typelib, nameoffset);
3729     typeinfo = (MSFT_TypeInfoBase *)&typelib->typelib_segment_data[MSFT_SEG_TYPEINFO][typeinfo_offset];
3730
3731     typelib->typelib_segment_data[MSFT_SEG_NAME][nameoffset + 9] = 0x38;
3732     *((int *)&typelib->typelib_segment_data[MSFT_SEG_NAME][nameoffset]) = typeinfo_offset;
3733
3734     pCreateTypeInfo2Impl->typeinfo = typeinfo;
3735
3736     pCreateTypeInfo2Impl->typekind = tkind;
3737     typeinfo->typekind |= tkind | 0x20;
3738     ICreateTypeInfo2_SetAlignment((ICreateTypeInfo2 *)pCreateTypeInfo2Impl, 4);
3739
3740     switch (tkind) {
3741     case TKIND_ENUM:
3742     case TKIND_INTERFACE:
3743     case TKIND_DISPATCH:
3744     case TKIND_COCLASS:
3745         typeinfo->size = 4;
3746         break;
3747
3748     case TKIND_RECORD:
3749     case TKIND_UNION:
3750         typeinfo->size = 0;
3751         break;
3752
3753     case TKIND_MODULE:
3754         typeinfo->size = 2;
3755         break;
3756
3757     case TKIND_ALIAS:
3758         typeinfo->size = -0x75;
3759         break;
3760
3761     default:
3762         FIXME("(%s,%d), unrecognized typekind %d\n", debugstr_w(szName), tkind, tkind);
3763         typeinfo->size = 0xdeadbeef;
3764         break;
3765     }
3766
3767     if (typelib->last_typeinfo) typelib->last_typeinfo->next_typeinfo = pCreateTypeInfo2Impl;
3768     typelib->last_typeinfo = pCreateTypeInfo2Impl;
3769     if (!typelib->typeinfos) typelib->typeinfos = pCreateTypeInfo2Impl;
3770
3771     TRACE(" -- %p\n", pCreateTypeInfo2Impl);
3772
3773     return (ICreateTypeInfo2 *)pCreateTypeInfo2Impl;
3774 }
3775
3776
3777 /*================== ICreateTypeLib2 Implementation ===================================*/
3778
3779 /******************************************************************************
3780  * ICreateTypeLib2_QueryInterface {OLEAUT32}
3781  *
3782  *  See IUnknown_QueryInterface.
3783  */
3784 static HRESULT WINAPI ICreateTypeLib2_fnQueryInterface(
3785         ICreateTypeLib2 * iface,
3786         REFIID riid,
3787         VOID **ppvObject)
3788 {
3789     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3790
3791     TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
3792
3793     *ppvObject=NULL;
3794     if(IsEqualIID(riid, &IID_IUnknown) ||
3795        IsEqualIID(riid,&IID_ICreateTypeLib)||
3796        IsEqualIID(riid,&IID_ICreateTypeLib2))
3797     {
3798         *ppvObject = This;
3799     } else if (IsEqualIID(riid, &IID_ITypeLib) ||
3800                IsEqualIID(riid, &IID_ITypeLib2)) {
3801         *ppvObject = &This->lpVtblTypeLib2;
3802     }
3803
3804     if(*ppvObject)
3805     {
3806         ICreateTypeLib2_AddRef(iface);
3807         TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
3808         return S_OK;
3809     }
3810     TRACE("-- Interface: E_NOINTERFACE\n");
3811     return E_NOINTERFACE;
3812 }
3813
3814 /******************************************************************************
3815  * ICreateTypeLib2_AddRef {OLEAUT32}
3816  *
3817  *  See IUnknown_AddRef.
3818  */
3819 static ULONG WINAPI ICreateTypeLib2_fnAddRef(ICreateTypeLib2 *iface)
3820 {
3821     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3822     ULONG ref = InterlockedIncrement(&This->ref);
3823
3824     TRACE("(%p)->ref was %u\n",This, ref - 1);
3825
3826     return ref;
3827 }
3828
3829 /******************************************************************************
3830  * ICreateTypeLib2_Release {OLEAUT32}
3831  *
3832  *  See IUnknown_Release.
3833  */
3834 static ULONG WINAPI ICreateTypeLib2_fnRelease(ICreateTypeLib2 *iface)
3835 {
3836     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3837     ULONG ref = InterlockedDecrement(&This->ref);
3838
3839     TRACE("(%p)->(%u)\n",This, ref);
3840
3841     if (!ref) {
3842         int i;
3843
3844         for (i = 0; i < MSFT_SEG_MAX; i++) {
3845             HeapFree(GetProcessHeap(), 0, This->typelib_segment_data[i]);
3846             This->typelib_segment_data[i] = NULL;
3847         }
3848
3849         HeapFree(GetProcessHeap(), 0, This->filename);
3850         This->filename = NULL;
3851
3852         while (This->typeinfos) {
3853             ICreateTypeInfo2Impl *typeinfo = This->typeinfos;
3854             This->typeinfos = typeinfo->next_typeinfo;
3855             if(typeinfo->typedata) {
3856                 CyclicList *iter, *rem;
3857
3858                 rem = typeinfo->typedata->next;
3859                 typeinfo->typedata->next = NULL;
3860                 iter = rem->next;
3861                 HeapFree(GetProcessHeap(), 0, rem);
3862
3863                 while(iter) {
3864                     rem = iter;
3865                     iter = iter->next;
3866                     HeapFree(GetProcessHeap(), 0, rem->u.data);
3867                     HeapFree(GetProcessHeap(), 0, rem);
3868                 }
3869             }
3870
3871             HeapFree(GetProcessHeap(), 0, typeinfo->dual);
3872             HeapFree(GetProcessHeap(), 0, typeinfo);
3873         }
3874
3875         HeapFree(GetProcessHeap(),0,This);
3876         return 0;
3877     }
3878
3879     return ref;
3880 }
3881
3882
3883 /******************************************************************************
3884  * ICreateTypeLib2_CreateTypeInfo {OLEAUT32}
3885  *
3886  *  See ICreateTypeLib_CreateTypeInfo.
3887  */
3888 static HRESULT WINAPI ICreateTypeLib2_fnCreateTypeInfo(
3889         ICreateTypeLib2 * iface,
3890         LPOLESTR szName,
3891         TYPEKIND tkind,
3892         ICreateTypeInfo **ppCTInfo)
3893 {
3894     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3895     char *name;
3896
3897     TRACE("(%p,%s,%d,%p)\n", iface, debugstr_w(szName), tkind, ppCTInfo);
3898
3899     ctl2_encode_name(This, szName, &name);
3900     if(ctl2_find_name(This, name) != -1)
3901         return TYPE_E_NAMECONFLICT;
3902
3903     *ppCTInfo = (ICreateTypeInfo *)ICreateTypeInfo2_Constructor(This, szName, tkind);
3904
3905     if (!*ppCTInfo) return E_OUTOFMEMORY;
3906
3907     return S_OK;
3908 }
3909
3910 /******************************************************************************
3911  * ICreateTypeLib2_SetName {OLEAUT32}
3912  *
3913  *  See ICreateTypeLib_SetName.
3914  */
3915 static HRESULT WINAPI ICreateTypeLib2_fnSetName(
3916         ICreateTypeLib2 * iface,
3917         LPOLESTR szName)
3918 {
3919     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3920
3921     int offset;
3922
3923     TRACE("(%p,%s)\n", iface, debugstr_w(szName));
3924
3925     offset = ctl2_alloc_name(This, szName);
3926     if (offset == -1) return E_OUTOFMEMORY;
3927     This->typelib_header.NameOffset = offset;
3928     return S_OK;
3929 }
3930
3931 /******************************************************************************
3932  * ICreateTypeLib2_SetVersion {OLEAUT32}
3933  *
3934  *  See ICreateTypeLib_SetVersion.
3935  */
3936 static HRESULT WINAPI ICreateTypeLib2_fnSetVersion(ICreateTypeLib2 * iface, WORD wMajorVerNum, WORD wMinorVerNum)
3937 {
3938     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3939
3940     TRACE("(%p,%d,%d)\n", iface, wMajorVerNum, wMinorVerNum);
3941
3942     This->typelib_header.version = wMajorVerNum | (wMinorVerNum << 16);
3943     return S_OK;
3944 }
3945
3946 /******************************************************************************
3947  * ICreateTypeLib2_SetGuid {OLEAUT32}
3948  *
3949  *  See ICreateTypeLib_SetGuid.
3950  */
3951 static HRESULT WINAPI ICreateTypeLib2_fnSetGuid(ICreateTypeLib2 * iface, REFGUID guid)
3952 {
3953     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3954
3955     MSFT_GuidEntry guidentry;
3956     int offset;
3957
3958     TRACE("(%p,%s)\n", iface, debugstr_guid(guid));
3959
3960     guidentry.guid = *guid;
3961     guidentry.hreftype = -2;
3962     guidentry.next_hash = -1;
3963
3964     offset = ctl2_alloc_guid(This, &guidentry);
3965
3966     if (offset == -1) return E_OUTOFMEMORY;
3967
3968     This->typelib_header.posguid = offset;
3969
3970     return S_OK;
3971 }
3972
3973 /******************************************************************************
3974  * ICreateTypeLib2_SetDocString {OLEAUT32}
3975  *
3976  *  See ICreateTypeLib_SetDocString.
3977  */
3978 static HRESULT WINAPI ICreateTypeLib2_fnSetDocString(ICreateTypeLib2 * iface, LPOLESTR szDoc)
3979 {
3980     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3981
3982     int offset;
3983
3984     TRACE("(%p,%s)\n", iface, debugstr_w(szDoc));
3985     if (!szDoc)
3986         return E_INVALIDARG;
3987
3988     offset = ctl2_alloc_string(This, szDoc);
3989     if (offset == -1) return E_OUTOFMEMORY;
3990     This->typelib_header.helpstring = offset;
3991     return S_OK;
3992 }
3993
3994 /******************************************************************************
3995  * ICreateTypeLib2_SetHelpFileName {OLEAUT32}
3996  *
3997  *  See ICreateTypeLib_SetHelpFileName.
3998  */
3999 static HRESULT WINAPI ICreateTypeLib2_fnSetHelpFileName(ICreateTypeLib2 * iface, LPOLESTR szHelpFileName)
4000 {
4001     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
4002
4003     int offset;
4004
4005     TRACE("(%p,%s)\n", iface, debugstr_w(szHelpFileName));
4006
4007     offset = ctl2_alloc_string(This, szHelpFileName);
4008     if (offset == -1) return E_OUTOFMEMORY;
4009     This->typelib_header.helpfile = offset;
4010     This->typelib_header.varflags |= 0x10;
4011     return S_OK;
4012 }
4013
4014 /******************************************************************************
4015  * ICreateTypeLib2_SetHelpContext {OLEAUT32}
4016  *
4017  *  See ICreateTypeLib_SetHelpContext.
4018  */
4019 static HRESULT WINAPI ICreateTypeLib2_fnSetHelpContext(ICreateTypeLib2 * iface, DWORD dwHelpContext)
4020 {
4021     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
4022
4023     TRACE("(%p,%d)\n", iface, dwHelpContext);
4024     This->typelib_header.helpcontext = dwHelpContext;
4025     return S_OK;
4026 }
4027
4028 /******************************************************************************
4029  * ICreateTypeLib2_SetLcid {OLEAUT32}
4030  *
4031  * Sets both the lcid and lcid2 members in the header to lcid.
4032  *
4033  * As a special case if lcid == LOCALE_NEUTRAL (0), then the first header lcid
4034  * is set to US English while the second one is set to 0.
4035  */
4036 static HRESULT WINAPI ICreateTypeLib2_fnSetLcid(ICreateTypeLib2 * iface, LCID lcid)
4037 {
4038     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
4039
4040     TRACE("(%p,%d)\n", iface, lcid);
4041
4042     This->typelib_header.lcid = This->typelib_header.lcid2 = lcid;
4043
4044     if(lcid == LOCALE_NEUTRAL) This->typelib_header.lcid = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
4045
4046     return S_OK;
4047 }
4048
4049 /******************************************************************************
4050  * ICreateTypeLib2_SetLibFlags {OLEAUT32}
4051  *
4052  *  See ICreateTypeLib_SetLibFlags.
4053  */
4054 static HRESULT WINAPI ICreateTypeLib2_fnSetLibFlags(ICreateTypeLib2 * iface, UINT uLibFlags)
4055 {
4056     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
4057
4058     TRACE("(%p,0x%x)\n", iface, uLibFlags);
4059
4060     This->typelib_header.flags = uLibFlags;
4061
4062     return S_OK;
4063 }
4064
4065 static int ctl2_write_chunk(HANDLE hFile, const void *segment, int length)
4066 {
4067     DWORD dwWritten;
4068     if (!WriteFile(hFile, segment, length, &dwWritten, 0)) {
4069         CloseHandle(hFile);
4070         return 0;
4071     }
4072     return -1;
4073 }
4074
4075 static int ctl2_write_segment(ICreateTypeLib2Impl *This, HANDLE hFile, int segment)
4076 {
4077     DWORD dwWritten;
4078     if (!WriteFile(hFile, This->typelib_segment_data[segment],
4079                    This->typelib_segdir[segment].length, &dwWritten, 0)) {
4080         CloseHandle(hFile);
4081         return 0;
4082     }
4083
4084     return -1;
4085 }
4086
4087 static HRESULT ctl2_finalize_typeinfos(ICreateTypeLib2Impl *This, int filesize)
4088 {
4089     ICreateTypeInfo2Impl *typeinfo;
4090     HRESULT hres;
4091
4092     for (typeinfo = This->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
4093         typeinfo->typeinfo->memoffset = filesize;
4094
4095         hres = ICreateTypeInfo2_fnLayOut((ICreateTypeInfo2 *)typeinfo);
4096         if(FAILED(hres))
4097             return hres;
4098
4099         if (typeinfo->typedata)
4100             filesize += typeinfo->typedata->next->u.val
4101                 + ((typeinfo->typeinfo->cElement >> 16) * 12)
4102                 + ((typeinfo->typeinfo->cElement & 0xffff) * 12) + 4;
4103     }
4104
4105     return S_OK;
4106 }
4107
4108 static int ctl2_finalize_segment(ICreateTypeLib2Impl *This, int filepos, int segment)
4109 {
4110     if (This->typelib_segdir[segment].length) {
4111         This->typelib_segdir[segment].offset = filepos;
4112     } else {
4113         This->typelib_segdir[segment].offset = -1;
4114     }
4115
4116     return This->typelib_segdir[segment].length;
4117 }
4118
4119 static void ctl2_write_typeinfos(ICreateTypeLib2Impl *This, HANDLE hFile)
4120 {
4121     ICreateTypeInfo2Impl *typeinfo;
4122
4123     for (typeinfo = This->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
4124         CyclicList *iter;
4125         int offset = 0;
4126
4127         if (!typeinfo->typedata) continue;
4128
4129         iter = typeinfo->typedata->next;
4130         ctl2_write_chunk(hFile, &iter->u.val, sizeof(int));
4131         for(iter=iter->next; iter!=typeinfo->typedata->next; iter=iter->next)
4132             ctl2_write_chunk(hFile, iter->u.data, iter->u.data[0] & 0xffff);
4133
4134         for(iter=typeinfo->typedata->next->next; iter!=typeinfo->typedata->next; iter=iter->next)
4135             ctl2_write_chunk(hFile, &iter->indice, sizeof(int));
4136
4137         for(iter=typeinfo->typedata->next->next; iter!=typeinfo->typedata->next; iter=iter->next)
4138             ctl2_write_chunk(hFile, &iter->name, sizeof(int));
4139
4140         for(iter=typeinfo->typedata->next->next; iter!=typeinfo->typedata->next; iter=iter->next) {
4141             ctl2_write_chunk(hFile, &offset, sizeof(int));
4142             offset += iter->u.data[0] & 0xffff;
4143         }
4144     }
4145 }
4146
4147 /******************************************************************************
4148  * ICreateTypeLib2_SaveAllChanges {OLEAUT32}
4149  *
4150  *  See ICreateTypeLib_SaveAllChanges.
4151  */
4152 static HRESULT WINAPI ICreateTypeLib2_fnSaveAllChanges(ICreateTypeLib2 * iface)
4153 {
4154     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
4155
4156     int retval;
4157     int filepos;
4158     HANDLE hFile;
4159     HRESULT hres;
4160
4161     TRACE("(%p)\n", iface);
4162
4163     retval = TYPE_E_IOERROR;
4164
4165     hFile = CreateFileW(This->filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
4166     if (hFile == INVALID_HANDLE_VALUE) return retval;
4167
4168     filepos = sizeof(MSFT_Header) + sizeof(MSFT_SegDir);
4169     filepos += This->typelib_header.nrtypeinfos * 4;
4170
4171     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_TYPEINFO);
4172     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_GUIDHASH);
4173     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_GUID);
4174     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_REFERENCES);
4175     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_IMPORTINFO);
4176     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_IMPORTFILES);
4177     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_NAMEHASH);
4178     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_NAME);
4179     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_STRING);
4180     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_TYPEDESC);
4181     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_ARRAYDESC);
4182     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_CUSTDATA);
4183     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_CUSTDATAGUID);
4184
4185     hres = ctl2_finalize_typeinfos(This, filepos);
4186     if(FAILED(hres)) {
4187         CloseHandle(hFile);
4188         return hres;
4189     }
4190
4191     if (!ctl2_write_chunk(hFile, &This->typelib_header, sizeof(This->typelib_header))) return retval;
4192     if (This->typelib_header.varflags & HELPDLLFLAG)
4193         if (!ctl2_write_chunk(hFile, &This->helpStringDll, sizeof(This->helpStringDll))) return retval;
4194     if (!ctl2_write_chunk(hFile, This->typelib_typeinfo_offsets, This->typelib_header.nrtypeinfos * 4)) return retval;
4195     if (!ctl2_write_chunk(hFile, This->typelib_segdir, sizeof(This->typelib_segdir))) return retval;
4196     if (!ctl2_write_segment(This, hFile, MSFT_SEG_TYPEINFO    )) return retval;
4197     if (!ctl2_write_segment(This, hFile, MSFT_SEG_GUIDHASH    )) return retval;
4198     if (!ctl2_write_segment(This, hFile, MSFT_SEG_GUID        )) return retval;
4199     if (!ctl2_write_segment(This, hFile, MSFT_SEG_REFERENCES  )) return retval;
4200     if (!ctl2_write_segment(This, hFile, MSFT_SEG_IMPORTINFO  )) return retval;
4201     if (!ctl2_write_segment(This, hFile, MSFT_SEG_IMPORTFILES )) return retval;
4202     if (!ctl2_write_segment(This, hFile, MSFT_SEG_NAMEHASH    )) return retval;
4203     if (!ctl2_write_segment(This, hFile, MSFT_SEG_NAME        )) return retval;
4204     if (!ctl2_write_segment(This, hFile, MSFT_SEG_STRING      )) return retval;
4205     if (!ctl2_write_segment(This, hFile, MSFT_SEG_TYPEDESC    )) return retval;
4206     if (!ctl2_write_segment(This, hFile, MSFT_SEG_ARRAYDESC   )) return retval;
4207     if (!ctl2_write_segment(This, hFile, MSFT_SEG_CUSTDATA    )) return retval;
4208     if (!ctl2_write_segment(This, hFile, MSFT_SEG_CUSTDATAGUID)) return retval;
4209
4210     ctl2_write_typeinfos(This, hFile);
4211
4212     if (!CloseHandle(hFile)) return retval;
4213
4214     return S_OK;
4215 }
4216
4217
4218 /******************************************************************************
4219  * ICreateTypeLib2_DeleteTypeInfo {OLEAUT32}
4220  *
4221  *  Deletes a named TypeInfo from a type library.
4222  *
4223  * RETURNS
4224  *
4225  *  Success: S_OK
4226  *  Failure: E_OUTOFMEMORY or E_INVALIDARG.
4227  */
4228 static HRESULT WINAPI ICreateTypeLib2_fnDeleteTypeInfo(
4229         ICreateTypeLib2 * iface, /* [I] The type library to delete from. */
4230         LPOLESTR szName)         /* [I] The name of the typeinfo to delete. */
4231 {
4232     FIXME("(%p,%s), stub!\n", iface, debugstr_w(szName));
4233     return E_OUTOFMEMORY;
4234 }
4235
4236 /******************************************************************************
4237  * ICreateTypeLib2_SetCustData {OLEAUT32}
4238  *
4239  *  Sets custom data for a type library.
4240  *
4241  * RETURNS
4242  *
4243  *  Success: S_OK
4244  *  Failure: E_OUTOFMEMORY or E_INVALIDARG.
4245  */
4246 static HRESULT WINAPI ICreateTypeLib2_fnSetCustData(
4247         ICreateTypeLib2 * iface, /* [I] The type library to store the custom data in. */
4248         REFGUID guid,            /* [I] The GUID used as a key to retrieve the custom data. */
4249         VARIANT *pVarVal)        /* [I] The custom data itself. */
4250 {
4251     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
4252
4253     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(guid), pVarVal);
4254
4255     return ctl2_set_custdata(This, guid, pVarVal, &This->typelib_header.CustomDataOffset);
4256 }
4257
4258 /******************************************************************************
4259  * ICreateTypeLib2_SetHelpStringContext {OLEAUT32}
4260  *
4261  *  Sets a context number for the library help string.
4262  *
4263  * PARAMS
4264  *  iface     [I] The type library to set the help string context for.
4265  *  dwContext [I] The help string context.
4266  *
4267  * RETURNS
4268  *  Success: S_OK
4269  *  Failure: E_OUTOFMEMORY or E_INVALIDARG.
4270  */
4271 static
4272 HRESULT WINAPI ICreateTypeLib2_fnSetHelpStringContext(ICreateTypeLib2 * iface,
4273                                                       ULONG dwContext)
4274 {
4275     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
4276
4277     TRACE("(%p,%d)\n", iface, dwContext);
4278
4279     This->typelib_header.helpstringcontext = dwContext;
4280     return S_OK;
4281 }
4282
4283 /******************************************************************************
4284  * ICreateTypeLib2_SetHelpStringDll {OLEAUT32}
4285  *
4286  *  Set the DLL used to look up localized help strings.
4287  *
4288  * PARAMS
4289  *  iface     [I] The type library to set the help DLL for.
4290  *  szDllName [I] The name of the help DLL.
4291  *
4292  * RETURNS
4293  *  Success: S_OK
4294  *  Failure: E_OUTOFMEMORY or E_INVALIDARG.
4295  */
4296 static
4297 HRESULT WINAPI ICreateTypeLib2_fnSetHelpStringDll(ICreateTypeLib2 * iface,
4298                                                   LPOLESTR szDllName)
4299 {
4300     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
4301     int offset;
4302
4303     TRACE("(%p,%s)\n", iface, debugstr_w(szDllName));
4304     if (!szDllName)
4305         return E_INVALIDARG;
4306
4307     offset = ctl2_alloc_string(This, szDllName);
4308     if (offset == -1)
4309         return E_OUTOFMEMORY;
4310     This->typelib_header.varflags |= HELPDLLFLAG;
4311     This->helpStringDll = offset;
4312     return S_OK;
4313 }
4314
4315 /*================== ITypeLib2 Implementation ===================================*/
4316
4317 /******************************************************************************
4318  * ITypeLib2_QueryInterface {OLEAUT32}
4319  *
4320  *  See IUnknown_QueryInterface.
4321  */
4322 static HRESULT WINAPI ITypeLib2_fnQueryInterface(ITypeLib2 * iface, REFIID riid, LPVOID * ppv)
4323 {
4324     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4325
4326     return ICreateTypeLib2_QueryInterface((ICreateTypeLib2 *)This, riid, ppv);
4327 }
4328
4329 /******************************************************************************
4330  * ITypeLib2_AddRef {OLEAUT32}
4331  *
4332  *  See IUnknown_AddRef.
4333  */
4334 static ULONG WINAPI ITypeLib2_fnAddRef(ITypeLib2 * iface)
4335 {
4336     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4337
4338     return ICreateTypeLib2_AddRef((ICreateTypeLib2 *)This);
4339 }
4340
4341 /******************************************************************************
4342  * ITypeLib2_Release {OLEAUT32}
4343  *
4344  *  See IUnknown_Release.
4345  */
4346 static ULONG WINAPI ITypeLib2_fnRelease(ITypeLib2 * iface)
4347 {
4348     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4349
4350     return ICreateTypeLib2_Release((ICreateTypeLib2 *)This);
4351 }
4352
4353 /******************************************************************************
4354  * ITypeLib2_GetTypeInfoCount {OLEAUT32}
4355  *
4356  *  See ITypeLib_GetTypeInfoCount.
4357  */
4358 static UINT WINAPI ITypeLib2_fnGetTypeInfoCount(
4359         ITypeLib2 * iface)
4360 {
4361     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4362
4363     TRACE("(%p)\n", iface);
4364
4365     return This->typelib_header.nrtypeinfos;
4366 }
4367
4368 /******************************************************************************
4369  * ITypeLib2_GetTypeInfo {OLEAUT32}
4370  *
4371  *  See ITypeLib_GetTypeInfo.
4372  */
4373 static HRESULT WINAPI ITypeLib2_fnGetTypeInfo(
4374         ITypeLib2 * iface,
4375         UINT index,
4376         ITypeInfo** ppTInfo)
4377 {
4378     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4379
4380     TRACE("(%p,%d,%p)\n", iface, index, ppTInfo);
4381
4382     if (index >= This->typelib_header.nrtypeinfos) {
4383         return TYPE_E_ELEMENTNOTFOUND;
4384     }
4385
4386     return ctl2_find_typeinfo_from_offset(This, This->typelib_typeinfo_offsets[index], ppTInfo);
4387 }
4388
4389 /******************************************************************************
4390  * ITypeLib2_GetTypeInfoType {OLEAUT32}
4391  *
4392  *  See ITypeLib_GetTypeInfoType.
4393  */
4394 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoType(
4395         ITypeLib2 * iface,
4396         UINT index,
4397         TYPEKIND* pTKind)
4398 {
4399     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4400
4401     TRACE("(%p,%d,%p)\n", iface, index, pTKind);
4402
4403     if (index >= This->typelib_header.nrtypeinfos) {
4404         return TYPE_E_ELEMENTNOTFOUND;
4405     }
4406
4407     *pTKind = (This->typelib_segment_data[MSFT_SEG_TYPEINFO][This->typelib_typeinfo_offsets[index]]) & 15;
4408
4409     return S_OK;
4410 }
4411
4412 /******************************************************************************
4413  * ITypeLib2_GetTypeInfoOfGuid {OLEAUT32}
4414  *
4415  *  See ITypeLib_GetTypeInfoOfGuid.
4416  */
4417 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoOfGuid(
4418         ITypeLib2 * iface,
4419         REFGUID guid,
4420         ITypeInfo** ppTinfo)
4421 {
4422     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4423
4424     int guidoffset;
4425     int typeinfo;
4426
4427     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(guid), ppTinfo);
4428
4429     guidoffset = ctl2_find_guid(This, ctl2_hash_guid(guid), guid);
4430     if (guidoffset == -1) return TYPE_E_ELEMENTNOTFOUND;
4431
4432     typeinfo = ((MSFT_GuidEntry *)&This->typelib_segment_data[MSFT_SEG_GUID][guidoffset])->hreftype;
4433     if (typeinfo < 0) return TYPE_E_ELEMENTNOTFOUND;
4434
4435     return ctl2_find_typeinfo_from_offset(This, typeinfo, ppTinfo);
4436 }
4437
4438 /******************************************************************************
4439  * ITypeLib2_GetLibAttr {OLEAUT32}
4440  *
4441  *  See ITypeLib_GetLibAttr.
4442  */
4443 static HRESULT WINAPI ITypeLib2_fnGetLibAttr(
4444         ITypeLib2 * iface,
4445         TLIBATTR** ppTLibAttr)
4446 {
4447     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4448
4449     TRACE("(%p,%p)\n", This, ppTLibAttr);
4450
4451     if(!ppTLibAttr)
4452         return E_INVALIDARG;
4453
4454     *ppTLibAttr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(TLIBATTR));
4455     if(!*ppTLibAttr)
4456         return E_OUTOFMEMORY;
4457
4458     if(This->typelib_header.posguid != -1) {
4459         MSFT_GuidEntry *guid;
4460
4461         guid = (MSFT_GuidEntry*)&This->typelib_segment_data[MSFT_SEG_GUID][This->typelib_header.posguid];
4462         (*ppTLibAttr)->guid = guid->guid;
4463     }
4464
4465     (*ppTLibAttr)->lcid = This->typelib_header.lcid;
4466     (*ppTLibAttr)->syskind = This->typelib_header.varflags&0x3;
4467     (*ppTLibAttr)->wMajorVerNum = This->typelib_header.version&0xffff;
4468     (*ppTLibAttr)->wMinorVerNum = This->typelib_header.version>>16;
4469     (*ppTLibAttr)->wLibFlags = This->typelib_header.flags;
4470     return S_OK;
4471 }
4472
4473 /******************************************************************************
4474  * ITypeLib2_GetTypeComp {OLEAUT32}
4475  *
4476  *  See ITypeLib_GetTypeComp.
4477  */
4478 static HRESULT WINAPI ITypeLib2_fnGetTypeComp(
4479         ITypeLib2 * iface,
4480         ITypeComp** ppTComp)
4481 {
4482     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4483
4484     FIXME("(%p,%p), stub!\n", This, ppTComp);
4485
4486     return E_OUTOFMEMORY;
4487 }
4488
4489 /******************************************************************************
4490  * ITypeLib2_GetDocumentation {OLEAUT32}
4491  *
4492  *  See ITypeLib_GetDocumentation.
4493  */
4494 static HRESULT WINAPI ITypeLib2_fnGetDocumentation(
4495         ITypeLib2 * iface,
4496         INT index,
4497         BSTR* pBstrName,
4498         BSTR* pBstrDocString,
4499         DWORD* pdwHelpContext,
4500         BSTR* pBstrHelpFile)
4501 {
4502     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4503     WCHAR *string;
4504
4505     TRACE("(%p,%d,%p,%p,%p,%p)\n", This, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
4506
4507     if(index != -1) {
4508         ICreateTypeInfo2Impl *iter;
4509
4510         for(iter=This->typeinfos; iter!=NULL && index!=0; iter=iter->next_typeinfo)
4511             index--;
4512
4513         if(!iter)
4514             return TYPE_E_ELEMENTNOTFOUND;
4515
4516         return ITypeInfo_GetDocumentation((ITypeInfo*)iter->lpVtblTypeInfo2,
4517                 -1, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
4518     }
4519
4520     if(pBstrName) {
4521         if(This->typelib_header.NameOffset == -1)
4522             *pBstrName = NULL;
4523         else {
4524             MSFT_NameIntro *name = (MSFT_NameIntro*)&This->
4525                 typelib_segment_data[MSFT_SEG_NAME][This->typelib_header.NameOffset];
4526
4527             ctl2_decode_name((char*)&name->namelen, &string);
4528
4529             *pBstrName = SysAllocString(string);
4530             if(!*pBstrName)
4531                 return E_OUTOFMEMORY;
4532         }
4533     }
4534
4535     if(pBstrDocString) {
4536         if(This->typelib_header.helpstring == -1)
4537             *pBstrDocString = NULL;
4538         else {
4539             ctl2_decode_string(&This->typelib_segment_data[MSFT_SEG_STRING][This->typelib_header.helpstring], &string);
4540
4541             *pBstrDocString = SysAllocString(string);
4542             if(!*pBstrDocString) {
4543                 if(pBstrName) SysFreeString(*pBstrName);
4544                 return E_OUTOFMEMORY;
4545             }
4546         }
4547     }
4548
4549     if(pdwHelpContext)
4550         *pdwHelpContext = This->typelib_header.helpcontext;
4551
4552     if(pBstrHelpFile) {
4553         if(This->typelib_header.helpfile == -1)
4554             *pBstrHelpFile = NULL;
4555         else {
4556             ctl2_decode_string(&This->typelib_segment_data[MSFT_SEG_STRING][This->typelib_header.helpfile], &string);
4557
4558             *pBstrHelpFile = SysAllocString(string);
4559             if(!*pBstrHelpFile) {
4560                 if(pBstrName) SysFreeString(*pBstrName);
4561                 if(pBstrDocString) SysFreeString(*pBstrDocString);
4562                 return E_OUTOFMEMORY;
4563             }
4564         }
4565     }
4566
4567     return S_OK;
4568 }
4569
4570 /******************************************************************************
4571  * ITypeLib2_IsName {OLEAUT32}
4572  *
4573  *  See ITypeLib_IsName.
4574  */
4575 static HRESULT WINAPI ITypeLib2_fnIsName(
4576         ITypeLib2 * iface,
4577         LPOLESTR szNameBuf,
4578         ULONG lHashVal,
4579         BOOL* pfName)
4580 {
4581     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4582
4583     char *encoded_name;
4584     int nameoffset;
4585     MSFT_NameIntro *nameintro;
4586
4587     TRACE("(%p,%s,%x,%p)\n", iface, debugstr_w(szNameBuf), lHashVal, pfName);
4588
4589     ctl2_encode_name(This, szNameBuf, &encoded_name);
4590     nameoffset = ctl2_find_name(This, encoded_name);
4591
4592     *pfName = 0;
4593
4594     if (nameoffset == -1) return S_OK;
4595
4596     nameintro = (MSFT_NameIntro *)(&This->typelib_segment_data[MSFT_SEG_NAME][nameoffset]);
4597     if (nameintro->hreftype == -1) return S_OK;
4598
4599     *pfName = 1;
4600
4601     FIXME("Should be decoding our copy of the name over szNameBuf.\n");
4602
4603     return S_OK;
4604 }
4605
4606 /******************************************************************************
4607  * ITypeLib2_FindName {OLEAUT32}
4608  *
4609  *  See ITypeLib_FindName.
4610  */
4611 static HRESULT WINAPI ITypeLib2_fnFindName(
4612         ITypeLib2 * iface,
4613         LPOLESTR szNameBuf,
4614         ULONG lHashVal,
4615         ITypeInfo** ppTInfo,
4616         MEMBERID* rgMemId,
4617         USHORT* pcFound)
4618 {
4619     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4620
4621     FIXME("(%p,%s,%x,%p,%p,%p), stub!\n", This, debugstr_w(szNameBuf), lHashVal, ppTInfo, rgMemId, pcFound);
4622
4623     return E_OUTOFMEMORY;
4624 }
4625
4626 /******************************************************************************
4627  * ITypeLib2_ReleaseTLibAttr {OLEAUT32}
4628  *
4629  *  See ITypeLib_ReleaseTLibAttr.
4630  */
4631 static void WINAPI ITypeLib2_fnReleaseTLibAttr(
4632         ITypeLib2 * iface,
4633         TLIBATTR* pTLibAttr)
4634 {
4635     TRACE("(%p,%p)\n", iface, pTLibAttr);
4636
4637     HeapFree(GetProcessHeap(), 0, pTLibAttr);
4638 }
4639
4640 /******************************************************************************
4641  * ICreateTypeLib2_GetCustData {OLEAUT32}
4642  *
4643  *  Retrieves a custom data value stored on a type library.
4644  *
4645  * RETURNS
4646  *
4647  *  Success: S_OK
4648  *  Failure: E_OUTOFMEMORY or E_INVALIDARG.
4649  */
4650 static HRESULT WINAPI ITypeLib2_fnGetCustData(
4651         ITypeLib2 * iface, /* [I] The type library in which to find the custom data. */
4652         REFGUID guid,      /* [I] The GUID under which the custom data is stored. */
4653         VARIANT* pVarVal)  /* [O] The custom data. */
4654 {
4655     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4656
4657     FIXME("(%p,%s,%p), stub!\n", This, debugstr_guid(guid), pVarVal);
4658
4659     return E_OUTOFMEMORY;
4660 }
4661
4662 /******************************************************************************
4663  * ICreateTypeLib2_GetLibStatistics {OLEAUT32}
4664  *
4665  *  Retrieves some statistics about names in a type library, supposedly for
4666  *  hash table optimization purposes.
4667  *
4668  * RETURNS
4669  *
4670  *  Success: S_OK
4671  *  Failure: E_OUTOFMEMORY or E_INVALIDARG.
4672  */
4673 static HRESULT WINAPI ITypeLib2_fnGetLibStatistics(
4674         ITypeLib2 * iface,      /* [I] The type library to get statistics about. */
4675         ULONG* pcUniqueNames,   /* [O] The number of unique names in the type library. */
4676         ULONG* pcchUniqueNames) /* [O] The number of changed (?) characters in names in the type library. */
4677 {
4678     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4679
4680     FIXME("(%p,%p,%p), stub!\n", This, pcUniqueNames, pcchUniqueNames);
4681
4682     return E_OUTOFMEMORY;
4683 }
4684
4685 /******************************************************************************
4686  * ICreateTypeLib2_GetDocumentation2 {OLEAUT32}
4687  *
4688  *  Obtain locale-aware help string information.
4689  *
4690  * RETURNS
4691  *
4692  *  Success: S_OK
4693  *  Failure: STG_E_INSUFFICIENTMEMORY or E_INVALIDARG.
4694  */
4695 static HRESULT WINAPI ITypeLib2_fnGetDocumentation2(
4696         ITypeLib2 * iface,
4697         INT index,
4698         LCID lcid,
4699         BSTR* pbstrHelpString,
4700         DWORD* pdwHelpStringContext,
4701         BSTR* pbstrHelpStringDll)
4702 {
4703     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4704
4705     FIXME("(%p,%d,%d,%p,%p,%p), stub!\n", This, index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll);
4706
4707     return E_OUTOFMEMORY;
4708 }
4709
4710 /******************************************************************************
4711  * ICreateTypeLib2_GetAllCustData {OLEAUT32}
4712  *
4713  *  Retrieve all of the custom data for a type library.
4714  *
4715  * RETURNS
4716  *
4717  *  Success: S_OK
4718  *  Failure: E_OUTOFMEMORY or E_INVALIDARG.
4719  */
4720 static HRESULT WINAPI ITypeLib2_fnGetAllCustData(
4721         ITypeLib2 * iface,   /* [I] The type library in which to find the custom data. */
4722         CUSTDATA* pCustData) /* [O] The structure in which to place the custom data. */
4723 {
4724     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4725
4726     FIXME("(%p,%p), stub!\n", This, pCustData);
4727
4728     return E_OUTOFMEMORY;
4729 }
4730
4731
4732 /*================== ICreateTypeLib2 & ITypeLib2 VTABLEs And Creation ===================================*/
4733
4734 static const ICreateTypeLib2Vtbl ctypelib2vt =
4735 {
4736
4737     ICreateTypeLib2_fnQueryInterface,
4738     ICreateTypeLib2_fnAddRef,
4739     ICreateTypeLib2_fnRelease,
4740
4741     ICreateTypeLib2_fnCreateTypeInfo,
4742     ICreateTypeLib2_fnSetName,
4743     ICreateTypeLib2_fnSetVersion,
4744     ICreateTypeLib2_fnSetGuid,
4745     ICreateTypeLib2_fnSetDocString,
4746     ICreateTypeLib2_fnSetHelpFileName,
4747     ICreateTypeLib2_fnSetHelpContext,
4748     ICreateTypeLib2_fnSetLcid,
4749     ICreateTypeLib2_fnSetLibFlags,
4750     ICreateTypeLib2_fnSaveAllChanges,
4751
4752     ICreateTypeLib2_fnDeleteTypeInfo,
4753     ICreateTypeLib2_fnSetCustData,
4754     ICreateTypeLib2_fnSetHelpStringContext,
4755     ICreateTypeLib2_fnSetHelpStringDll
4756 };
4757
4758 static const ITypeLib2Vtbl typelib2vt =
4759 {
4760
4761     ITypeLib2_fnQueryInterface,
4762     ITypeLib2_fnAddRef,
4763     ITypeLib2_fnRelease,
4764
4765     ITypeLib2_fnGetTypeInfoCount,
4766     ITypeLib2_fnGetTypeInfo,
4767     ITypeLib2_fnGetTypeInfoType,
4768     ITypeLib2_fnGetTypeInfoOfGuid,
4769     ITypeLib2_fnGetLibAttr,
4770     ITypeLib2_fnGetTypeComp,
4771     ITypeLib2_fnGetDocumentation,
4772     ITypeLib2_fnIsName,
4773     ITypeLib2_fnFindName,
4774     ITypeLib2_fnReleaseTLibAttr,
4775
4776     ITypeLib2_fnGetCustData,
4777     ITypeLib2_fnGetLibStatistics,
4778     ITypeLib2_fnGetDocumentation2,
4779     ITypeLib2_fnGetAllCustData,
4780 };
4781
4782 static ICreateTypeLib2 *ICreateTypeLib2_Constructor(SYSKIND syskind, LPCOLESTR szFile)
4783 {
4784     ICreateTypeLib2Impl *pCreateTypeLib2Impl;
4785     int failed = 0;
4786
4787     TRACE("Constructing ICreateTypeLib2 (%d, %s)\n", syskind, debugstr_w(szFile));
4788
4789     pCreateTypeLib2Impl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ICreateTypeLib2Impl));
4790     if (!pCreateTypeLib2Impl) return NULL;
4791
4792     pCreateTypeLib2Impl->filename = HeapAlloc(GetProcessHeap(), 0, (strlenW(szFile) + 1) * sizeof(WCHAR));
4793     if (!pCreateTypeLib2Impl->filename) {
4794         HeapFree(GetProcessHeap(), 0, pCreateTypeLib2Impl);
4795         return NULL;
4796     }
4797     strcpyW(pCreateTypeLib2Impl->filename, szFile);
4798
4799     ctl2_init_header(pCreateTypeLib2Impl);
4800     ctl2_init_segdir(pCreateTypeLib2Impl);
4801
4802     pCreateTypeLib2Impl->typelib_header.varflags |= syskind;
4803
4804     /*
4805      * The following two calls return an offset or -1 if out of memory. We
4806      * specifically need an offset of 0, however, so...
4807      */
4808     if (ctl2_alloc_segment(pCreateTypeLib2Impl, MSFT_SEG_GUIDHASH, 0x80, 0x80)) { failed = 1; }
4809     if (ctl2_alloc_segment(pCreateTypeLib2Impl, MSFT_SEG_NAMEHASH, 0x200, 0x200)) { failed = 1; }
4810
4811     pCreateTypeLib2Impl->typelib_guidhash_segment = (int *)pCreateTypeLib2Impl->typelib_segment_data[MSFT_SEG_GUIDHASH];
4812     pCreateTypeLib2Impl->typelib_namehash_segment = (int *)pCreateTypeLib2Impl->typelib_segment_data[MSFT_SEG_NAMEHASH];
4813
4814     memset(pCreateTypeLib2Impl->typelib_guidhash_segment, 0xff, 0x80);
4815     memset(pCreateTypeLib2Impl->typelib_namehash_segment, 0xff, 0x200);
4816
4817     pCreateTypeLib2Impl->lpVtbl = &ctypelib2vt;
4818     pCreateTypeLib2Impl->lpVtblTypeLib2 = &typelib2vt;
4819     pCreateTypeLib2Impl->ref = 1;
4820
4821     if (failed) {
4822         ICreateTypeLib2_fnRelease((ICreateTypeLib2 *)pCreateTypeLib2Impl);
4823         return 0;
4824     }
4825
4826     return (ICreateTypeLib2 *)pCreateTypeLib2Impl;
4827 }
4828
4829 /******************************************************************************
4830  * CreateTypeLib2 [OLEAUT32.180]
4831  *
4832  *  Obtains an ICreateTypeLib2 object for creating a new-style (MSFT) type
4833  *  library.
4834  *
4835  * NOTES
4836  *
4837  *  See also CreateTypeLib.
4838  *
4839  * RETURNS
4840  *    Success: S_OK
4841  *    Failure: Status
4842  */
4843 HRESULT WINAPI CreateTypeLib2(
4844         SYSKIND syskind,           /* [I] System type library is for */
4845         LPCOLESTR szFile,          /* [I] Type library file name */
4846         ICreateTypeLib2** ppctlib) /* [O] Storage for object returned */
4847 {
4848     TRACE("(%d,%s,%p)\n", syskind, debugstr_w(szFile), ppctlib);
4849
4850     if (!szFile) return E_INVALIDARG;
4851     *ppctlib = ICreateTypeLib2_Constructor(syskind, szFile);
4852     return (*ppctlib)? S_OK: E_OUTOFMEMORY;
4853 }
4854
4855 /******************************************************************************
4856  * ClearCustData (OLEAUT32.171)
4857  *
4858  * Clear a custom data types' data.
4859  *
4860  * PARAMS
4861  *  lpCust [I] The custom data type instance
4862  *
4863  * RETURNS
4864  *  Nothing.
4865  */
4866 void WINAPI ClearCustData(LPCUSTDATA lpCust)
4867 {
4868     if (lpCust && lpCust->cCustData)
4869     {
4870         if (lpCust->prgCustData)
4871         {
4872             DWORD i;
4873
4874             for (i = 0; i < lpCust->cCustData; i++)
4875                 VariantClear(&lpCust->prgCustData[i].varValue);
4876
4877             /* FIXME - Should be using a per-thread IMalloc */
4878             HeapFree(GetProcessHeap(), 0, lpCust->prgCustData);
4879             lpCust->prgCustData = NULL;
4880         }
4881         lpCust->cCustData = 0;
4882     }
4883 }