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