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