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         ICreateTypeLib2_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             return hres;
1588
1589         guid.guid = tlibattr->guid;
1590         guid.hreftype = This->typelib->typelib_guids*12+2;
1591         guid.next_hash = -1;
1592
1593         guid_offset = ctl2_alloc_guid(This->typelib, &guid);
1594         if(guid_offset == -1) {
1595             ITypeLib_ReleaseTLibAttr(container, tlibattr);
1596             return E_OUTOFMEMORY;
1597         }
1598
1599         check_guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][guid_offset];
1600         if(check_guid->hreftype == guid.hreftype)
1601             This->typelib->typelib_guids++;
1602
1603         /* Get import file name */
1604         /* Check HKEY_CLASSES_ROOT\TypeLib\{GUID}\{Ver}\0\win32 */
1605         len = MAX_PATH;
1606         sprintfW(name, regkey, guid.guid.Data1, guid.guid.Data2,
1607                 guid.guid.Data3, guid.guid.Data4[0], guid.guid.Data4[1],
1608                 guid.guid.Data4[2], guid.guid.Data4[3], guid.guid.Data4[4],
1609                 guid.guid.Data4[5], guid.guid.Data4[6], guid.guid.Data4[7],
1610                 tlibattr->wMajorVerNum, tlibattr->wMinorVerNum);
1611
1612         if(RegGetValueW(HKEY_CLASSES_ROOT, name, NULL, RRF_RT_REG_SZ, NULL, name, &len)!=ERROR_SUCCESS
1613             || (p=strrchrW(name, '\\'))==NULL) {
1614             ERR("Error guessing typelib filename\n");
1615             ITypeLib_ReleaseTLibAttr(container, tlibattr);
1616             return E_NOTIMPL;
1617         }
1618         memmove(name, p+1, strlenW(p)*sizeof(WCHAR));
1619
1620         /* Import file */
1621         import_offset = ctl2_alloc_importfile(This->typelib, guid_offset,
1622                 tlibattr->lcid, tlibattr->wMajorVerNum, tlibattr->wMinorVerNum, name);
1623         ITypeLib_ReleaseTLibAttr(container, tlibattr);
1624
1625         if(import_offset == -1)
1626             return E_OUTOFMEMORY;
1627
1628         /* Allocate referenced guid */
1629         hres = ITypeInfo_GetTypeAttr(pTInfo, &typeattr);
1630         if(FAILED(hres))
1631             return hres;
1632
1633         guid.guid = typeattr->guid;
1634         guid.hreftype = This->typelib->typeinfo_guids*12+1;
1635         guid.next_hash = -1;
1636         ITypeInfo_ReleaseTypeAttr(pTInfo, typeattr);
1637
1638         guid_offset = ctl2_alloc_guid(This->typelib, &guid);
1639         if(guid_offset == -1)
1640             return E_OUTOFMEMORY;
1641
1642         check_guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][guid_offset];
1643         if(check_guid->hreftype == guid.hreftype)
1644             This->typelib->typeinfo_guids++;
1645
1646         /* Allocate importinfo */
1647         impinfo.flags = (This->typekind<<24) | MSFT_IMPINFO_OFFSET_IS_GUID;
1648         impinfo.oImpFile = import_offset;
1649         impinfo.oGuid = guid_offset;
1650         *phRefType = ctl2_alloc_importinfo(This->typelib, &impinfo)+1;
1651
1652         if(!memcmp(&guid.guid, &IID_IDispatch, sizeof(GUID)))
1653             This->typelib->typelib_header.dispatchpos = *phRefType;
1654     }
1655
1656     ITypeLib_Release(container);
1657     return S_OK;
1658 }
1659
1660 /******************************************************************************
1661  * ICreateTypeInfo2_AddFuncDesc {OLEAUT32}
1662  *
1663  *  See ICreateTypeInfo_AddFuncDesc.
1664  */
1665 static HRESULT WINAPI ICreateTypeInfo2_fnAddFuncDesc(
1666         ICreateTypeInfo2* iface,
1667         UINT index,
1668         FUNCDESC* pFuncDesc)
1669 {
1670     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1671
1672     CyclicList *iter, *insert;
1673     int *typedata;
1674     int i, num_defaults = 0;
1675     int decoded_size;
1676     HRESULT hres;
1677
1678     TRACE("(%p,%d,%p)\n", iface, index, pFuncDesc);
1679
1680     if(!pFuncDesc || (pFuncDesc->memid>0x7fffffff && pFuncDesc->memid!=MEMBERID_NIL))
1681         return E_INVALIDARG;
1682
1683     TRACE("{%d,%p,%p,%d,%d,%d,%d,%d,%d,%d,{%d},%d}\n", pFuncDesc->memid,
1684             pFuncDesc->lprgscode, pFuncDesc->lprgelemdescParam, pFuncDesc->funckind,
1685             pFuncDesc->invkind, pFuncDesc->callconv, pFuncDesc->cParams,
1686             pFuncDesc->cParamsOpt, pFuncDesc->oVft, pFuncDesc->cScodes,
1687             pFuncDesc->elemdescFunc.tdesc.vt, pFuncDesc->wFuncFlags);
1688
1689     switch(This->typekind) {
1690     case TKIND_MODULE:
1691         if(pFuncDesc->funckind != FUNC_STATIC)
1692             return TYPE_E_BADMODULEKIND;
1693         break;
1694     case TKIND_DISPATCH:
1695         if(pFuncDesc->funckind != FUNC_DISPATCH)
1696             return TYPE_E_BADMODULEKIND;
1697         break;
1698     default:
1699         if(pFuncDesc->funckind != FUNC_PUREVIRTUAL)
1700             return TYPE_E_BADMODULEKIND;
1701     }
1702
1703     if(This->typeinfo->cElement<index)
1704         return TYPE_E_ELEMENTNOTFOUND;
1705
1706     if((pFuncDesc->invkind&(INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF)) &&
1707         !pFuncDesc->cParams)
1708         return TYPE_E_INCONSISTENTPROPFUNCS;
1709
1710     /* get number of arguments with default values specified */
1711     for (i = 0; i < pFuncDesc->cParams; i++)
1712         if(pFuncDesc->lprgelemdescParam[i].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
1713             num_defaults++;
1714
1715     if (!This->typedata) {
1716         This->typedata = HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList));
1717         if(!This->typedata)
1718             return E_OUTOFMEMORY;
1719
1720         This->typedata->next = This->typedata;
1721         This->typedata->u.val = 0;
1722
1723         if(This->dual)
1724             This->dual->typedata = This->typedata;
1725     }
1726
1727     /* allocate type data space for us */
1728     insert = HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList));
1729     if(!insert)
1730         return E_OUTOFMEMORY;
1731     insert->u.data = HeapAlloc(GetProcessHeap(), 0, sizeof(int[6])+sizeof(int[(num_defaults?4:3)])*pFuncDesc->cParams);
1732     if(!insert->u.data) {
1733         HeapFree(GetProcessHeap(), 0, insert);
1734         return E_OUTOFMEMORY;
1735     }
1736
1737     /* fill out the basic type information */
1738     typedata = insert->u.data;
1739     typedata[0] = 0x18 + pFuncDesc->cParams*(num_defaults?16:12);
1740     ctl2_encode_typedesc(This->typelib, &pFuncDesc->elemdescFunc.tdesc, &typedata[1], NULL, NULL, &decoded_size);
1741     typedata[2] = pFuncDesc->wFuncFlags;
1742     typedata[3] = ((sizeof(FUNCDESC) + decoded_size) << 16) | This->typeinfo->cbSizeVft;
1743     typedata[4] = (pFuncDesc->callconv << 8) | (pFuncDesc->invkind << 3) | pFuncDesc->funckind;
1744     if(num_defaults) typedata[4] |= 0x1000;
1745     typedata[5] = pFuncDesc->cParams;
1746
1747     /* NOTE: High word of typedata[3] is total size of FUNCDESC + size of all ELEMDESCs for params + TYPEDESCs for pointer params and return types. */
1748     /* That is, total memory allocation required to reconstitute the FUNCDESC in its entirety. */
1749     typedata[3] += (sizeof(ELEMDESC) * pFuncDesc->cParams) << 16;
1750     typedata[3] += (sizeof(PARAMDESCEX) * num_defaults) << 16;
1751
1752     /* add default values */
1753     if(num_defaults) {
1754         for (i = 0; i < pFuncDesc->cParams; i++)
1755             if(pFuncDesc->lprgelemdescParam[i].u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT) {
1756                 hres = ctl2_add_default_value(This->typelib, typedata+6+i,
1757                         &pFuncDesc->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue,
1758                         pFuncDesc->lprgelemdescParam[i].tdesc.vt);
1759
1760                 if(FAILED(hres)) {
1761                     HeapFree(GetProcessHeap(), 0, insert->u.data);
1762                     HeapFree(GetProcessHeap(), 0, insert);
1763                     return hres;
1764                 }
1765             } else
1766                 typedata[6+i] = 0xffffffff;
1767
1768         num_defaults = pFuncDesc->cParams;
1769     }
1770
1771     /* add arguments */
1772     for (i = 0; i < pFuncDesc->cParams; i++) {
1773         ctl2_encode_typedesc(This->typelib, &pFuncDesc->lprgelemdescParam[i].tdesc,
1774                 &typedata[6+num_defaults+(i*3)], NULL, NULL, &decoded_size);
1775         typedata[7+num_defaults+(i*3)] = -1;
1776         typedata[8+num_defaults+(i*3)] = pFuncDesc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
1777         typedata[3] += decoded_size << 16;
1778     }
1779
1780     /* update the index data */
1781     insert->indice = pFuncDesc->memid;
1782     insert->name = -1;
1783
1784     /* insert type data to list */
1785     if(index == This->typeinfo->cElement) {
1786         insert->next = This->typedata->next;
1787         This->typedata->next = insert;
1788         This->typedata = insert;
1789
1790         if(This->dual)
1791             This->dual->typedata = This->typedata;
1792     } else {
1793         iter = This->typedata->next;
1794         for(i=0; i<index; i++)
1795             iter = iter->next;
1796
1797         insert->next = iter->next;
1798         iter->next = insert;
1799     }
1800
1801     /* update type data size */
1802     This->typedata->next->u.val += 0x18 + pFuncDesc->cParams*(num_defaults?16:12);
1803
1804     /* Increment the number of function elements */
1805     This->typeinfo->cElement += 1;
1806
1807     return S_OK;
1808 }
1809
1810 /******************************************************************************
1811  * ICreateTypeInfo2_AddImplType {OLEAUT32}
1812  *
1813  *  See ICreateTypeInfo_AddImplType.
1814  */
1815 static HRESULT WINAPI ICreateTypeInfo2_fnAddImplType(
1816         ICreateTypeInfo2* iface,
1817         UINT index,
1818         HREFTYPE hRefType)
1819 {
1820     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1821
1822     TRACE("(%p,%d,%d)\n", iface, index, hRefType);
1823
1824     if (This->typekind == TKIND_COCLASS) {
1825         int offset;
1826         MSFT_RefRecord *ref;
1827
1828         if (index == 0) {
1829             if (This->typeinfo->datatype1 != -1) return TYPE_E_ELEMENTNOTFOUND;
1830
1831             offset = ctl2_alloc_segment(This->typelib, MSFT_SEG_REFERENCES, sizeof(MSFT_RefRecord), 0);
1832             if (offset == -1) return E_OUTOFMEMORY;
1833
1834             This->typeinfo->datatype1 = offset;
1835         } else {
1836             int lastoffset;
1837
1838             lastoffset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index - 1);
1839             if (lastoffset == -1) return TYPE_E_ELEMENTNOTFOUND;
1840
1841             ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][lastoffset];
1842             if (ref->onext != -1) return TYPE_E_ELEMENTNOTFOUND;
1843
1844             offset = ctl2_alloc_segment(This->typelib, MSFT_SEG_REFERENCES, sizeof(MSFT_RefRecord), 0);
1845             if (offset == -1) return E_OUTOFMEMORY;
1846
1847             ref->onext = offset;
1848         }
1849
1850         ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
1851
1852         ref->reftype = hRefType;
1853         ref->flags = 0;
1854         ref->oCustData = -1;
1855         ref->onext = -1;
1856     } else if (This->typekind == TKIND_INTERFACE) {
1857         if (This->typeinfo->cImplTypes && index==1)
1858             return TYPE_E_BADMODULEKIND;
1859
1860         if( index != 0)  return TYPE_E_ELEMENTNOTFOUND;
1861
1862         This->typeinfo->datatype1 = hRefType;
1863     } else if (This->typekind == TKIND_DISPATCH) {
1864         FIXME("dispatch case unhandled.\n");
1865     } else {
1866         FIXME("AddImplType unsupported on typekind %d\n", This->typekind);
1867         return E_OUTOFMEMORY;
1868     }
1869
1870     This->typeinfo->cImplTypes++;
1871     return S_OK;
1872 }
1873
1874 /******************************************************************************
1875  * ICreateTypeInfo2_SetImplTypeFlags {OLEAUT32}
1876  *
1877  *  See ICreateTypeInfo_SetImplTypeFlags.
1878  */
1879 static HRESULT WINAPI ICreateTypeInfo2_fnSetImplTypeFlags(
1880         ICreateTypeInfo2* iface,
1881         UINT index,
1882         INT implTypeFlags)
1883 {
1884     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1885     int offset;
1886     MSFT_RefRecord *ref;
1887
1888     TRACE("(%p,%d,0x%x)\n", iface, index, implTypeFlags);
1889
1890     if (This->typekind != TKIND_COCLASS) {
1891         return TYPE_E_BADMODULEKIND;
1892     }
1893
1894     offset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index);
1895     if (offset == -1) return TYPE_E_ELEMENTNOTFOUND;
1896
1897     ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
1898     ref->flags = implTypeFlags;
1899
1900     return S_OK;
1901 }
1902
1903 /******************************************************************************
1904  * ICreateTypeInfo2_SetAlignment {OLEAUT32}
1905  *
1906  *  See ICreateTypeInfo_SetAlignment.
1907  */
1908 static HRESULT WINAPI ICreateTypeInfo2_fnSetAlignment(
1909         ICreateTypeInfo2* iface,
1910         WORD cbAlignment)
1911 {
1912     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1913
1914     TRACE("(%p,%d)\n", iface, cbAlignment);
1915
1916     if (!cbAlignment) return E_INVALIDARG;
1917     if (cbAlignment > 16) return E_INVALIDARG;
1918
1919     This->typeinfo->typekind &= ~0xffc0;
1920     This->typeinfo->typekind |= cbAlignment << 6;
1921
1922     /* FIXME: There's probably some way to simplify this. */
1923     switch (This->typekind) {
1924     case TKIND_ALIAS:
1925     default:
1926         break;
1927
1928     case TKIND_ENUM:
1929     case TKIND_INTERFACE:
1930     case TKIND_DISPATCH:
1931     case TKIND_COCLASS:
1932         if (cbAlignment > 4) cbAlignment = 4;
1933         break;
1934
1935     case TKIND_RECORD:
1936     case TKIND_MODULE:
1937     case TKIND_UNION:
1938         cbAlignment = 1;
1939         break;
1940     }
1941
1942     This->typeinfo->typekind |= cbAlignment << 11;
1943
1944     return S_OK;
1945 }
1946
1947 /******************************************************************************
1948  * ICreateTypeInfo2_SetSchema {OLEAUT32}
1949  *
1950  *  See ICreateTypeInfo_SetSchema.
1951  */
1952 static HRESULT WINAPI ICreateTypeInfo2_fnSetSchema(
1953         ICreateTypeInfo2* iface,
1954         LPOLESTR pStrSchema)
1955 {
1956     FIXME("(%p,%s), stub!\n", iface, debugstr_w(pStrSchema));
1957     return E_OUTOFMEMORY;
1958 }
1959
1960 /******************************************************************************
1961  * ICreateTypeInfo2_AddVarDesc {OLEAUT32}
1962  *
1963  *  See ICreateTypeInfo_AddVarDesc.
1964  */
1965 static HRESULT WINAPI ICreateTypeInfo2_fnAddVarDesc(
1966         ICreateTypeInfo2* iface,
1967         UINT index,
1968         VARDESC* pVarDesc)
1969 {
1970     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
1971
1972     CyclicList *insert;
1973     INT *typedata;
1974     int var_datawidth;
1975     int var_alignment;
1976     int var_type_size;
1977     int alignment;
1978
1979     TRACE("(%p,%d,%p), stub!\n", iface, index, pVarDesc);
1980     TRACE("%d, %p, %d, {{%x, %d}, {%p, %x}}, 0x%x, %d\n", pVarDesc->memid, pVarDesc->lpstrSchema, pVarDesc->u.oInst,
1981           pVarDesc->elemdescVar.tdesc.u.hreftype, pVarDesc->elemdescVar.tdesc.vt,
1982           pVarDesc->elemdescVar.u.paramdesc.pparamdescex, pVarDesc->elemdescVar.u.paramdesc.wParamFlags,
1983           pVarDesc->wVarFlags, pVarDesc->varkind);
1984
1985     if ((This->typeinfo->cElement >> 16) != index) {
1986         TRACE("Out-of-order element.\n");
1987         return TYPE_E_ELEMENTNOTFOUND;
1988     }
1989
1990     if (!This->typedata) {
1991         This->typedata = HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList));
1992         if(!This->typedata)
1993             return E_OUTOFMEMORY;
1994
1995         This->typedata->next = This->typedata;
1996         This->typedata->u.val = 0;
1997
1998         if(This->dual)
1999             This->dual->typedata = This->typedata;
2000     }
2001
2002     /* allocate type data space for us */
2003     insert = HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList));
2004     if(!insert)
2005         return E_OUTOFMEMORY;
2006     insert->u.data = HeapAlloc(GetProcessHeap(), 0, sizeof(int[5]));
2007     if(!insert->u.data) {
2008         HeapFree(GetProcessHeap(), 0, insert);
2009         return E_OUTOFMEMORY;
2010     }
2011
2012     insert->next = This->typedata->next;
2013     This->typedata->next = insert;
2014     This->typedata = insert;
2015
2016     if(This->dual)
2017         This->dual->typedata = This->typedata;
2018
2019     This->typedata->next->u.val += 0x14;
2020     typedata = This->typedata->u.data;
2021
2022     /* fill out the basic type information */
2023     typedata[0] = 0x14 | (index << 16);
2024     typedata[2] = pVarDesc->wVarFlags;
2025     typedata[3] = (sizeof(VARDESC) << 16) | 0;
2026
2027     /* update the index data */
2028     insert->indice = 0x40000000 + index;
2029     insert->name = -1;
2030
2031     /* figure out type widths and whatnot */
2032     ctl2_encode_typedesc(This->typelib, &pVarDesc->elemdescVar.tdesc,
2033                          &typedata[1], &var_datawidth, &var_alignment,
2034                          &var_type_size);
2035
2036     /* pad out starting position to data width */
2037     This->datawidth += var_alignment - 1;
2038     This->datawidth &= ~(var_alignment - 1);
2039     typedata[4] = This->datawidth;
2040
2041     /* add the new variable to the total data width */
2042     This->datawidth += var_datawidth;
2043     if(This->dual)
2044         This->dual->datawidth = This->datawidth;
2045
2046     /* add type description size to total required allocation */
2047     typedata[3] += var_type_size << 16;
2048
2049     /* fix type alignment */
2050     alignment = (This->typeinfo->typekind >> 11) & 0x1f;
2051     if (alignment < var_alignment) {
2052         alignment = var_alignment;
2053         This->typeinfo->typekind &= ~0xf800;
2054         This->typeinfo->typekind |= alignment << 11;
2055     }
2056
2057     /* ??? */
2058     if (!This->typeinfo->res2) This->typeinfo->res2 = 0x1a;
2059     if ((index == 0) || (index == 1) || (index == 2) || (index == 4) || (index == 9)) {
2060         This->typeinfo->res2 <<= 1;
2061     }
2062
2063     /* ??? */
2064     if (This->typeinfo->res3 == -1) This->typeinfo->res3 = 0;
2065     This->typeinfo->res3 += 0x2c;
2066
2067     /* increment the number of variable elements */
2068     This->typeinfo->cElement += 0x10000;
2069
2070     /* pad data width to alignment */
2071     This->typeinfo->size = (This->datawidth + (alignment - 1)) & ~(alignment - 1);
2072
2073     return S_OK;
2074 }
2075
2076 /******************************************************************************
2077  * ICreateTypeInfo2_SetFuncAndParamNames {OLEAUT32}
2078  *
2079  *  See ICreateTypeInfo_SetFuncAndParamNames.
2080  */
2081 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncAndParamNames(
2082         ICreateTypeInfo2* iface,
2083         UINT index,
2084         LPOLESTR* rgszNames,
2085         UINT cNames)
2086 {
2087     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2088     CyclicList *iter = NULL, *iter2;
2089     int offset, len, i=0;
2090     char *namedata;
2091
2092     TRACE("(%p %d %p %d)\n", iface, index, rgszNames, cNames);
2093
2094     if(!rgszNames)
2095         return E_INVALIDARG;
2096
2097     if(index >= This->typeinfo->cElement || !cNames)
2098         return TYPE_E_ELEMENTNOTFOUND;
2099
2100     len = ctl2_encode_name(This->typelib, rgszNames[0], &namedata);
2101     for(iter2=This->typedata->next->next; iter2!=This->typedata->next; iter2=iter2->next) {
2102         if(i == index)
2103             iter = iter2;
2104         else if(iter2->name!=-1 && !memcmp(namedata,
2105                     This->typelib->typelib_segment_data[MSFT_SEG_NAME]+iter2->name+8, len))
2106             return TYPE_E_AMBIGUOUSNAME;
2107
2108         i++;
2109     }
2110
2111     /* cNames == cParams for put or putref accessor, cParams+1 otherwise */
2112     if(cNames != iter->u.data[5] + ((iter->u.data[4]>>3)&(INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF) ? 0 : 1))
2113         return TYPE_E_ELEMENTNOTFOUND;
2114
2115     offset = ctl2_alloc_name(This->typelib, rgszNames[0]);
2116     if(offset == -1)
2117         return E_OUTOFMEMORY;
2118
2119     iter->name = offset;
2120
2121     namedata = This->typelib->typelib_segment_data[MSFT_SEG_NAME] + offset;
2122     *((INT *)namedata) = This->typelib->typelib_typeinfo_offsets[This->typeinfo->typekind >> 16];
2123
2124     if(iter->u.data[4]&0x1000)
2125         len = iter->u.data[5];
2126     else
2127         len = 0;
2128
2129     for (i = 1; i < cNames; i++) {
2130         offset = ctl2_alloc_name(This->typelib, rgszNames[i]);
2131         iter->u.data[(i*3) + 4 + len] = offset;
2132     }
2133
2134     return S_OK;
2135 }
2136
2137 /******************************************************************************
2138  * ICreateTypeInfo2_SetVarName {OLEAUT32}
2139  *
2140  *  See ICreateTypeInfo_SetVarName.
2141  */
2142 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarName(
2143         ICreateTypeInfo2* iface,
2144         UINT index,
2145         LPOLESTR szName)
2146 {
2147     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2148     CyclicList *iter;
2149     int offset, i;
2150     char *namedata;
2151
2152     TRACE("(%p,%d,%s), stub!\n", iface, index, debugstr_w(szName));
2153
2154     if ((This->typeinfo->cElement >> 16) <= index) {
2155         TRACE("Out-of-order element.\n");
2156         return TYPE_E_ELEMENTNOTFOUND;
2157     }
2158
2159     offset = ctl2_alloc_name(This->typelib, szName);
2160     if (offset == -1) return E_OUTOFMEMORY;
2161
2162     namedata = This->typelib->typelib_segment_data[MSFT_SEG_NAME] + offset;
2163     if (*((INT *)namedata) == -1) {
2164         *((INT *)namedata) = This->typelib->typelib_typeinfo_offsets[This->typeinfo->typekind >> 16];
2165         namedata[9] |= 0x10;
2166     }
2167     if (This->typekind == TKIND_ENUM) {
2168         namedata[9] |= 0x20;
2169     }
2170
2171     iter = This->typedata->next->next;
2172     for(i=0; i<index; i++)
2173         iter = iter->next;
2174
2175     iter->name = offset;
2176     return S_OK;
2177 }
2178
2179 /******************************************************************************
2180  * ICreateTypeInfo2_SetTypeDescAlias {OLEAUT32}
2181  *
2182  *  See ICreateTypeInfo_SetTypeDescAlias.
2183  */
2184 static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeDescAlias(
2185         ICreateTypeInfo2* iface,
2186         TYPEDESC* pTDescAlias)
2187 {
2188     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2189
2190     int encoded_typedesc;
2191     int width;
2192
2193     if (This->typekind != TKIND_ALIAS) {
2194         return TYPE_E_WRONGTYPEKIND;
2195     }
2196
2197     FIXME("(%p,%p), hack!\n", iface, pTDescAlias);
2198
2199     if (ctl2_encode_typedesc(This->typelib, pTDescAlias, &encoded_typedesc, &width, NULL, NULL) == -1) {
2200         return E_OUTOFMEMORY;
2201     }
2202
2203     This->typeinfo->size = width;
2204     This->typeinfo->datatype1 = encoded_typedesc;
2205
2206     return S_OK;
2207 }
2208
2209 /******************************************************************************
2210  * ICreateTypeInfo2_DefineFuncAsDllEntry {OLEAUT32}
2211  *
2212  *  See ICreateTypeInfo_DefineFuncAsDllEntry.
2213  */
2214 static HRESULT WINAPI ICreateTypeInfo2_fnDefineFuncAsDllEntry(
2215         ICreateTypeInfo2* iface,
2216         UINT index,
2217         LPOLESTR szDllName,
2218         LPOLESTR szProcName)
2219 {
2220     FIXME("(%p,%d,%s,%s), stub!\n", iface, index, debugstr_w(szDllName), debugstr_w(szProcName));
2221     return E_OUTOFMEMORY;
2222 }
2223
2224 /******************************************************************************
2225  * ICreateTypeInfo2_SetFuncDocString {OLEAUT32}
2226  *
2227  *  See ICreateTypeInfo_SetFuncDocString.
2228  */
2229 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncDocString(
2230         ICreateTypeInfo2* iface,
2231         UINT index,
2232         LPOLESTR szDocString)
2233 {
2234     FIXME("(%p,%d,%s), stub!\n", iface, index, debugstr_w(szDocString));
2235     return E_OUTOFMEMORY;
2236 }
2237
2238 /******************************************************************************
2239  * ICreateTypeInfo2_SetVarDocString {OLEAUT32}
2240  *
2241  *  See ICreateTypeInfo_SetVarDocString.
2242  */
2243 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarDocString(
2244         ICreateTypeInfo2* iface,
2245         UINT index,
2246         LPOLESTR szDocString)
2247 {
2248     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2249
2250     FIXME("(%p,%d,%s), stub!\n", iface, index, debugstr_w(szDocString));
2251
2252     ctl2_alloc_string(This->typelib, szDocString);
2253
2254     return E_OUTOFMEMORY;
2255 }
2256
2257 /******************************************************************************
2258  * ICreateTypeInfo2_SetFuncHelpContext {OLEAUT32}
2259  *
2260  *  See ICreateTypeInfo_SetFuncHelpContext.
2261  */
2262 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncHelpContext(
2263         ICreateTypeInfo2* iface,
2264         UINT index,
2265         DWORD dwHelpContext)
2266 {
2267     FIXME("(%p,%d,%d), stub!\n", iface, index, dwHelpContext);
2268     return E_OUTOFMEMORY;
2269 }
2270
2271 /******************************************************************************
2272  * ICreateTypeInfo2_SetVarHelpContext {OLEAUT32}
2273  *
2274  *  See ICreateTypeInfo_SetVarHelpContext.
2275  */
2276 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarHelpContext(
2277         ICreateTypeInfo2* iface,
2278         UINT index,
2279         DWORD dwHelpContext)
2280 {
2281     FIXME("(%p,%d,%d), stub!\n", iface, index, dwHelpContext);
2282     return E_OUTOFMEMORY;
2283 }
2284
2285 /******************************************************************************
2286  * ICreateTypeInfo2_SetMops {OLEAUT32}
2287  *
2288  *  See ICreateTypeInfo_SetMops.
2289  */
2290 static HRESULT WINAPI ICreateTypeInfo2_fnSetMops(
2291         ICreateTypeInfo2* iface,
2292         UINT index,
2293         BSTR bstrMops)
2294 {
2295     FIXME("(%p,%d,%p), stub!\n", iface, index, bstrMops);
2296     return E_OUTOFMEMORY;
2297 }
2298
2299 /******************************************************************************
2300  * ICreateTypeInfo2_SetTypeIdldesc {OLEAUT32}
2301  *
2302  *  See ICreateTypeInfo_SetTypeIdldesc.
2303  */
2304 static HRESULT WINAPI ICreateTypeInfo2_fnSetTypeIdldesc(
2305         ICreateTypeInfo2* iface,
2306         IDLDESC* pIdlDesc)
2307 {
2308     FIXME("(%p,%p), stub!\n", iface, pIdlDesc);
2309     return E_OUTOFMEMORY;
2310 }
2311
2312 /******************************************************************************
2313  * ICreateTypeInfo2_LayOut {OLEAUT32}
2314  *
2315  *  See ICreateTypeInfo_LayOut.
2316  */
2317 static HRESULT WINAPI ICreateTypeInfo2_fnLayOut(
2318         ICreateTypeInfo2* iface)
2319 {
2320     ICreateTypeInfo2Impl *This = (ICreateTypeInfo2Impl *)iface;
2321     CyclicList *iter, *iter2, **typedata;
2322     HREFTYPE hreftype;
2323     HRESULT hres;
2324     int i;
2325
2326     TRACE("(%p)\n", iface);
2327
2328     if(This->typekind == TKIND_COCLASS)
2329         return S_OK;
2330
2331     /* Validate inheritance */
2332     This->typeinfo->datatype2 = 0;
2333     hreftype = This->typeinfo->datatype1;
2334
2335     /* Process internally defined interfaces */
2336     for(i=0; i<This->typelib->typelib_header.nrtypeinfos; i++) {
2337         MSFT_TypeInfoBase *header;
2338
2339         if(hreftype&1)
2340             break;
2341
2342         header = (MSFT_TypeInfoBase*)&(This->typelib->typelib_segment_data[MSFT_SEG_TYPEINFO][hreftype]);
2343         This->typeinfo->datatype2 += (header->cElement<<16) + 1;
2344         hreftype = header->datatype1;
2345     }
2346     if(i == This->typelib->typelib_header.nrtypeinfos)
2347         return TYPE_E_CIRCULARTYPE;
2348
2349     /* Process externally defined interfaces */
2350     if(hreftype != -1) {
2351         ITypeInfo *cur, *next;
2352         TYPEATTR *typeattr;
2353
2354         hres = ICreateTypeInfo_QueryInterface(iface, &IID_ITypeInfo, (void**)&next);
2355         if(FAILED(hres))
2356             return hres;
2357
2358         hres = ITypeInfo_GetRefTypeInfo(next, hreftype, &cur);
2359         if(FAILED(hres))
2360             return hres;
2361
2362         ITypeInfo_Release(next);
2363
2364         while(1) {
2365             hres = ITypeInfo_GetTypeAttr(cur, &typeattr);
2366             if(FAILED(hres))
2367                 return hres;
2368
2369             if(!memcmp(&typeattr->guid, &IID_IDispatch, sizeof(IDispatch)))
2370                 This->typeinfo->flags |= TYPEFLAG_FDISPATCHABLE;
2371
2372             This->typeinfo->datatype2 += (typeattr->cFuncs<<16) + 1;
2373             ITypeInfo_ReleaseTypeAttr(cur, typeattr);
2374
2375             hres = ITypeInfo_GetRefTypeOfImplType(cur, 0, &hreftype);
2376             if(hres == TYPE_E_ELEMENTNOTFOUND)
2377                 break;
2378             if(FAILED(hres))
2379                 return hres;
2380
2381             hres = ITypeInfo_GetRefTypeInfo(cur, hreftype, &next);
2382             if(FAILED(hres))
2383                 return hres;
2384
2385             ITypeInfo_Release(cur);
2386             cur = next;
2387         }
2388     }
2389
2390     This->typeinfo->cbSizeVft = (This->typeinfo->datatype2>>16) * 4;
2391     if(!This->typedata)
2392         return S_OK;
2393
2394     typedata = HeapAlloc(GetProcessHeap(), 0, sizeof(CyclicList*)*(This->typeinfo->cElement&0xffff));
2395     if(!typedata)
2396         return E_OUTOFMEMORY;
2397
2398     /* Assign IDs and VTBL entries */
2399     i = 0;
2400     for(iter=This->typedata->next->next; iter!=This->typedata->next; iter=iter->next) {
2401         /* Assign MEMBERID if MEMBERID_NIL was specified */
2402         if(iter->indice == MEMBERID_NIL) {
2403             iter->indice = 0x60000000 + i + (This->typeinfo->datatype2<<16);
2404
2405             for(iter2=This->typedata->next->next; iter2!=This->typedata->next; iter2=iter2->next) {
2406                 if(iter == iter2) continue;
2407                 if(iter2->indice == iter->indice) {
2408                     iter->indice = 0x5fffffff + This->typeinfo->cElement + i + (This->typeinfo->datatype2<<16);
2409
2410                     for(iter2=This->typedata->next->next; iter2!=This->typedata->next; iter2=iter2->next) {
2411                         if(iter == iter2) continue;
2412                         if(iter2->indice == iter->indice)
2413                             return E_ACCESSDENIED;
2414                     }
2415
2416                     break;
2417                 }
2418             }
2419         }
2420
2421         typedata[i] = iter;
2422
2423         iter->u.data[0] = (iter->u.data[0]&0xffff) | (i<<16);
2424
2425         if(This->typekind != TKIND_MODULE) {
2426             iter->u.data[3] = (iter->u.data[3]&0xffff0000) | This->typeinfo->cbSizeVft;
2427             This->typeinfo->cbSizeVft += 4;
2428         }
2429
2430         /* Construct a list of elements with the same memberid */
2431         iter->u.data[4] = (iter->u.data[4]&0xffff) | (i<<16);
2432         for(iter2=This->typedata->next->next; iter2!=iter; iter2=iter2->next) {
2433             if(iter->indice == iter2->indice) {
2434                 int v1, v2;
2435
2436                 v1 = iter->u.data[4] >> 16;
2437                 v2 = iter2->u.data[4] >> 16;
2438
2439                 iter->u.data[4] = (iter->u.data[4]&0xffff) | (v2<<16);
2440                 iter2->u.data[4] = (iter2->u.data[4]&0xffff) | (v1<<16);
2441                 break;
2442             }
2443         }
2444
2445         i++;
2446     }
2447
2448     for(i=0; i<(This->typeinfo->cElement&0xffff); i++) {
2449         if(typedata[i]->u.data[4]>>16 > i) {
2450             int inv;
2451
2452             inv = (typedata[i]->u.data[4]>>3) & 0xf;
2453             i = typedata[i]->u.data[4] >> 16;
2454
2455             while(i > typedata[i]->u.data[4]>>16) {
2456                 int invkind = (typedata[i]->u.data[4]>>3) & 0xf;
2457
2458                 if(inv & invkind) {
2459                     HeapFree(GetProcessHeap(), 0, typedata);
2460                     return TYPE_E_DUPLICATEID;
2461                 }
2462
2463                 i = typedata[i]->u.data[4] >> 16;
2464                 inv |= invkind;
2465             }
2466
2467             if(inv & INVOKE_FUNC) {
2468                 HeapFree(GetProcessHeap(), 0, typedata);
2469                 return TYPE_E_INCONSISTENTPROPFUNCS;
2470             }
2471         }
2472     }
2473
2474     HeapFree(GetProcessHeap(), 0, typedata);
2475     return S_OK;
2476 }
2477
2478 /******************************************************************************
2479  * ICreateTypeInfo2_DeleteFuncDesc {OLEAUT32}
2480  *
2481  *  Delete a function description from a type.
2482  *
2483  * RETURNS
2484  *
2485  *  Success: S_OK.
2486  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2487  */
2488 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteFuncDesc(
2489         ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete a function. */
2490         UINT index)              /* [I] The index of the function to delete. */
2491 {
2492     FIXME("(%p,%d), stub!\n", iface, index);
2493     return E_OUTOFMEMORY;
2494 }
2495
2496 /******************************************************************************
2497  * ICreateTypeInfo2_DeleteFuncDescByMemId {OLEAUT32}
2498  *
2499  *  Delete a function description from a type.
2500  *
2501  * RETURNS
2502  *
2503  *  Success: S_OK.
2504  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2505  */
2506 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteFuncDescByMemId(
2507         ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete a function. */
2508         MEMBERID memid,          /* [I] The member id of the function to delete. */
2509         INVOKEKIND invKind)      /* [I] The invocation type of the function to delete. (?) */
2510 {
2511     FIXME("(%p,%d,%d), stub!\n", iface, memid, invKind);
2512     return E_OUTOFMEMORY;
2513 }
2514
2515 /******************************************************************************
2516  * ICreateTypeInfo2_DeleteVarDesc {OLEAUT32}
2517  *
2518  *  Delete a variable description from a type.
2519  *
2520  * RETURNS
2521  *
2522  *  Success: S_OK.
2523  *  Failure: One of E_OUTOFMEMORY, E_INVALIDARG, TYPE_E_IOERROR,
2524  *  TYPE_E_INVDATAREAD, TYPE_E_UNSUPFORMAT or TYPE_E_INVALIDSTATE.
2525  */
2526 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteVarDesc(
2527         ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete the variable description. */
2528         UINT index)              /* [I] The index of the variable description to delete. */
2529 {
2530     FIXME("(%p,%d), stub!\n", iface, index);
2531     return E_OUTOFMEMORY;
2532 }
2533
2534 /******************************************************************************
2535  * ICreateTypeInfo2_DeleteVarDescByMemId {OLEAUT32}
2536  *
2537  *  Delete a variable description from a type.
2538  *
2539  * RETURNS
2540  *
2541  *  Success: S_OK.
2542  *  Failure: One of E_OUTOFMEMORY, E_INVALIDARG, TYPE_E_IOERROR,
2543  *  TYPE_E_INVDATAREAD, TYPE_E_UNSUPFORMAT or TYPE_E_INVALIDSTATE.
2544  */
2545 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteVarDescByMemId(
2546         ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete the variable description. */
2547         MEMBERID memid)          /* [I] The member id of the variable description to delete. */
2548 {
2549     FIXME("(%p,%d), stub!\n", iface, memid);
2550     return E_OUTOFMEMORY;
2551 }
2552
2553 /******************************************************************************
2554  * ICreateTypeInfo2_DeleteImplType {OLEAUT32}
2555  *
2556  *  Delete an interface implementation from a type. (?)
2557  *
2558  * RETURNS
2559  *
2560  *  Success: S_OK.
2561  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2562  */
2563 static HRESULT WINAPI ICreateTypeInfo2_fnDeleteImplType(
2564         ICreateTypeInfo2* iface, /* [I] The typeinfo from which to delete. */
2565         UINT index)              /* [I] The index of the interface to delete. */
2566 {
2567     FIXME("(%p,%d), stub!\n", iface, index);
2568     return E_OUTOFMEMORY;
2569 }
2570
2571 /******************************************************************************
2572  * ICreateTypeInfo2_SetCustData {OLEAUT32}
2573  *
2574  *  Set the custom data for a type.
2575  *
2576  * RETURNS
2577  *
2578  *  Success: S_OK.
2579  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2580  */
2581 static HRESULT WINAPI ICreateTypeInfo2_fnSetCustData(
2582         ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
2583         REFGUID guid,            /* [I] The GUID used as a key to retrieve the custom data. */
2584         VARIANT* pVarVal)        /* [I] The custom data. */
2585 {
2586     FIXME("(%p,%s,%p), stub!\n", iface, debugstr_guid(guid), pVarVal);
2587     return E_OUTOFMEMORY;
2588 }
2589
2590 /******************************************************************************
2591  * ICreateTypeInfo2_SetFuncCustData {OLEAUT32}
2592  *
2593  *  Set the custom data for a function.
2594  *
2595  * RETURNS
2596  *
2597  *  Success: S_OK.
2598  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2599  */
2600 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncCustData(
2601         ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
2602         UINT index,              /* [I] The index of the function for which to set the custom data. */
2603         REFGUID guid,            /* [I] The GUID used as a key to retrieve the custom data. */
2604         VARIANT* pVarVal)        /* [I] The custom data. */
2605 {
2606     FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
2607     return E_OUTOFMEMORY;
2608 }
2609
2610 /******************************************************************************
2611  * ICreateTypeInfo2_SetParamCustData {OLEAUT32}
2612  *
2613  *  Set the custom data for a function parameter.
2614  *
2615  * RETURNS
2616  *
2617  *  Success: S_OK.
2618  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2619  */
2620 static HRESULT WINAPI ICreateTypeInfo2_fnSetParamCustData(
2621         ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
2622         UINT indexFunc,          /* [I] The index of the function on which the parameter resides. */
2623         UINT indexParam,         /* [I] The index of the parameter on which to set the custom data. */
2624         REFGUID guid,            /* [I] The GUID used as a key to retrieve the custom data. */
2625         VARIANT* pVarVal)        /* [I] The custom data. */
2626 {
2627     FIXME("(%p,%d,%d,%s,%p), stub!\n", iface, indexFunc, indexParam, debugstr_guid(guid), pVarVal);
2628     return E_OUTOFMEMORY;
2629 }
2630
2631 /******************************************************************************
2632  * ICreateTypeInfo2_SetVarCustData {OLEAUT32}
2633  *
2634  *  Set the custom data for a variable.
2635  *
2636  * RETURNS
2637  *
2638  *  Success: S_OK.
2639  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2640  */
2641 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarCustData(
2642         ICreateTypeInfo2* iface, /* [I] The typeinfo in which to set the custom data. */
2643         UINT index,              /* [I] The index of the variable on which to set the custom data. */
2644         REFGUID guid,            /* [I] The GUID used as a key to retrieve the custom data. */
2645         VARIANT* pVarVal)        /* [I] The custom data. */
2646 {
2647     FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
2648     return E_OUTOFMEMORY;
2649 }
2650
2651 /******************************************************************************
2652  * ICreateTypeInfo2_SetImplTypeCustData {OLEAUT32}
2653  *
2654  *  Set the custom data for an implemented interface.
2655  *
2656  * RETURNS
2657  *
2658  *  Success: S_OK.
2659  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2660  */
2661 static HRESULT WINAPI ICreateTypeInfo2_fnSetImplTypeCustData(
2662         ICreateTypeInfo2* iface, /* [I] The typeinfo on which to set the custom data. */
2663         UINT index,              /* [I] The index of the implemented interface on which to set the custom data. */
2664         REFGUID guid,            /* [I] The GUID used as a key to retrieve the custom data. */
2665         VARIANT* pVarVal)        /* [I] The custom data. */
2666 {
2667     FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
2668     return E_OUTOFMEMORY;
2669 }
2670
2671 /******************************************************************************
2672  * ICreateTypeInfo2_SetHelpStringContext {OLEAUT32}
2673  *
2674  *  Set the help string context for the typeinfo.
2675  *
2676  * RETURNS
2677  *
2678  *  Success: S_OK.
2679  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2680  */
2681 static HRESULT WINAPI ICreateTypeInfo2_fnSetHelpStringContext(
2682         ICreateTypeInfo2* iface,   /* [I] The typeinfo on which to set the help string context. */
2683         ULONG dwHelpStringContext) /* [I] The help string context. */
2684 {
2685     FIXME("(%p,%d), stub!\n", iface, dwHelpStringContext);
2686     return E_OUTOFMEMORY;
2687 }
2688
2689 /******************************************************************************
2690  * ICreateTypeInfo2_SetFuncHelpStringContext {OLEAUT32}
2691  *
2692  *  Set the help string context for a function.
2693  *
2694  * RETURNS
2695  *
2696  *  Success: S_OK.
2697  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2698  */
2699 static HRESULT WINAPI ICreateTypeInfo2_fnSetFuncHelpStringContext(
2700         ICreateTypeInfo2* iface,   /* [I] The typeinfo on which to set the help string context. */
2701         UINT index,                /* [I] The index for the function on which to set the help string context. */
2702         ULONG dwHelpStringContext) /* [I] The help string context. */
2703 {
2704     FIXME("(%p,%d,%d), stub!\n", iface, index, dwHelpStringContext);
2705     return E_OUTOFMEMORY;
2706 }
2707
2708 /******************************************************************************
2709  * ICreateTypeInfo2_SetVarHelpStringContext {OLEAUT32}
2710  *
2711  *  Set the help string context for a variable.
2712  *
2713  * RETURNS
2714  *
2715  *  Success: S_OK.
2716  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
2717  */
2718 static HRESULT WINAPI ICreateTypeInfo2_fnSetVarHelpStringContext(
2719         ICreateTypeInfo2* iface,   /* [I] The typeinfo on which to set the help string context. */
2720         UINT index,                /* [I] The index of the variable on which to set the help string context. */
2721         ULONG dwHelpStringContext) /* [I] The help string context */
2722 {
2723     FIXME("(%p,%d,%d), stub!\n", iface, index, dwHelpStringContext);
2724     return E_OUTOFMEMORY;
2725 }
2726
2727 /******************************************************************************
2728  * ICreateTypeInfo2_Invalidate {OLEAUT32}
2729  *
2730  *  Undocumented function. (!)
2731  */
2732 static HRESULT WINAPI ICreateTypeInfo2_fnInvalidate(
2733         ICreateTypeInfo2* iface)
2734 {
2735     FIXME("(%p), stub!\n", iface);
2736     return E_OUTOFMEMORY;
2737 }
2738
2739 /******************************************************************************
2740  * ICreateTypeInfo2_SetName {OLEAUT32}
2741  *
2742  *  Set the name for a typeinfo.
2743  *
2744  * RETURNS
2745  *
2746  *  Success: S_OK.
2747  *  Failure: One of STG_E_INSUFFICIENTMEMORY, E_OUTOFMEMORY, E_INVALIDARG or TYPE_E_INVALIDSTATE.
2748  */
2749 static HRESULT WINAPI ICreateTypeInfo2_fnSetName(
2750         ICreateTypeInfo2* iface,
2751         LPOLESTR szName)
2752 {
2753     FIXME("(%p,%s), stub!\n", iface, debugstr_w(szName));
2754     return E_OUTOFMEMORY;
2755 }
2756
2757 /*================== ITypeInfo2 Implementation ===================================*/
2758
2759 /******************************************************************************
2760  * ITypeInfo2_QueryInterface {OLEAUT32}
2761  *
2762  *  See IUnknown_QueryInterface.
2763  */
2764 static HRESULT WINAPI ITypeInfo2_fnQueryInterface(ITypeInfo2 * iface, REFIID riid, LPVOID * ppv)
2765 {
2766     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
2767
2768     return ICreateTypeInfo2_QueryInterface((ICreateTypeInfo2 *)This, riid, ppv);
2769 }
2770
2771 /******************************************************************************
2772  * ITypeInfo2_AddRef {OLEAUT32}
2773  *
2774  *  See IUnknown_AddRef.
2775  */
2776 static ULONG WINAPI ITypeInfo2_fnAddRef(ITypeInfo2 * iface)
2777 {
2778     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
2779
2780     return ICreateTypeInfo2_AddRef((ICreateTypeInfo2 *)This);
2781 }
2782
2783 /******************************************************************************
2784  * ITypeInfo2_Release {OLEAUT32}
2785  *
2786  *  See IUnknown_Release.
2787  */
2788 static ULONG WINAPI ITypeInfo2_fnRelease(ITypeInfo2 * iface)
2789 {
2790     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
2791
2792     return ICreateTypeInfo2_Release((ICreateTypeInfo2 *)This);
2793 }
2794
2795 /******************************************************************************
2796  * ITypeInfo2_GetTypeAttr {OLEAUT32}
2797  *
2798  *  See ITypeInfo_GetTypeAttr.
2799  */
2800 static HRESULT WINAPI ITypeInfo2_fnGetTypeAttr(
2801         ITypeInfo2* iface,
2802         TYPEATTR** ppTypeAttr)
2803 {
2804     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
2805     HRESULT hres;
2806
2807     TRACE("(%p,%p)\n", iface, ppTypeAttr);
2808
2809     if(!ppTypeAttr)
2810         return E_INVALIDARG;
2811
2812     hres = ICreateTypeInfo_LayOut((ICreateTypeInfo*)This);
2813     if(FAILED(hres))
2814         return hres;
2815
2816     *ppTypeAttr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(TYPEATTR));
2817     if(!*ppTypeAttr)
2818         return E_OUTOFMEMORY;
2819
2820     if(This->typeinfo->posguid != -1) {
2821         MSFT_GuidEntry *guid;
2822
2823         guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][This->typeinfo->posguid];
2824         (*ppTypeAttr)->guid = guid->guid;
2825     }
2826
2827     (*ppTypeAttr)->lcid = This->typelib->typelib_header.lcid;
2828     (*ppTypeAttr)->cbSizeInstance = This->typeinfo->size;
2829     (*ppTypeAttr)->typekind = This->typekind;
2830     (*ppTypeAttr)->cFuncs = This->typeinfo->cElement&0xffff;
2831     (*ppTypeAttr)->cVars = This->typeinfo->cElement>>16;
2832     (*ppTypeAttr)->cImplTypes = This->typeinfo->cImplTypes;
2833     (*ppTypeAttr)->cbSizeVft = This->typekind==TKIND_DISPATCH ? 28 : This->typeinfo->cbSizeVft;
2834     (*ppTypeAttr)->cbAlignment = (This->typeinfo->typekind>>11) & 0x1f;
2835     (*ppTypeAttr)->wTypeFlags = This->typeinfo->flags;
2836     (*ppTypeAttr)->wMajorVerNum = This->typeinfo->version&0xffff;
2837     (*ppTypeAttr)->wMinorVerNum = This->typeinfo->version>>16;
2838
2839     if((*ppTypeAttr)->typekind == TKIND_ALIAS)
2840         FIXME("TKIND_ALIAS handling not implemented\n");
2841
2842     return S_OK;
2843 }
2844
2845 /******************************************************************************
2846  * ITypeInfo2_GetTypeComp {OLEAUT32}
2847  *
2848  *  See ITypeInfo_GetTypeComp.
2849  */
2850 static HRESULT WINAPI ITypeInfo2_fnGetTypeComp(
2851         ITypeInfo2* iface,
2852         ITypeComp** ppTComp)
2853 {
2854     FIXME("(%p,%p), stub!\n", iface, ppTComp);
2855     return E_OUTOFMEMORY;
2856 }
2857
2858 /******************************************************************************
2859  * ITypeInfo2_GetFuncDesc {OLEAUT32}
2860  *
2861  *  See ITypeInfo_GetFuncDesc.
2862  */
2863 static HRESULT WINAPI ITypeInfo2_fnGetFuncDesc(
2864         ITypeInfo2* iface,
2865         UINT index,
2866         FUNCDESC** ppFuncDesc)
2867 {
2868     FIXME("(%p,%d,%p), stub!\n", iface, index, ppFuncDesc);
2869     return E_OUTOFMEMORY;
2870 }
2871
2872 /******************************************************************************
2873  * ITypeInfo2_GetVarDesc {OLEAUT32}
2874  *
2875  *  See ITypeInfo_GetVarDesc.
2876  */
2877 static HRESULT WINAPI ITypeInfo2_fnGetVarDesc(
2878         ITypeInfo2* iface,
2879         UINT index,
2880         VARDESC** ppVarDesc)
2881 {
2882     FIXME("(%p,%d,%p), stub!\n", iface, index, ppVarDesc);
2883     return E_OUTOFMEMORY;
2884 }
2885
2886 /******************************************************************************
2887  * ITypeInfo2_GetNames {OLEAUT32}
2888  *
2889  *  See ITypeInfo_GetNames.
2890  */
2891 static HRESULT WINAPI ITypeInfo2_fnGetNames(
2892         ITypeInfo2* iface,
2893         MEMBERID memid,
2894         BSTR* rgBstrNames,
2895         UINT cMaxNames,
2896         UINT* pcNames)
2897 {
2898     FIXME("(%p,%d,%p,%d,%p), stub!\n", iface, memid, rgBstrNames, cMaxNames, pcNames);
2899     return E_OUTOFMEMORY;
2900 }
2901
2902 /******************************************************************************
2903  * ITypeInfo2_GetRefTypeOfImplType {OLEAUT32}
2904  *
2905  *  See ITypeInfo_GetRefTypeOfImplType.
2906  */
2907 static HRESULT WINAPI ITypeInfo2_fnGetRefTypeOfImplType(
2908         ITypeInfo2* iface,
2909         UINT index,
2910         HREFTYPE* pRefType)
2911 {
2912     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
2913     MSFT_RefRecord *ref;
2914     int offset;
2915
2916     TRACE("(%p,%d,%p)\n", iface, index, pRefType);
2917
2918     if(!pRefType)
2919         return E_INVALIDARG;
2920
2921     if(index == -1) {
2922         if((This->typeinfo->typekind&0xf)==TKIND_DISPATCH
2923                 && (This->typeinfo->flags&TYPEFLAG_FDUAL)) {
2924             *pRefType = -2;
2925             return S_OK;
2926         }
2927
2928         return TYPE_E_ELEMENTNOTFOUND;
2929     }
2930
2931     if(index >= This->typeinfo->cImplTypes)
2932         return TYPE_E_ELEMENTNOTFOUND;
2933
2934     if(This->typekind == TKIND_INTERFACE) {
2935         *pRefType = This->typeinfo->datatype1 + 2;
2936         return S_OK;
2937     }
2938
2939     offset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index);
2940     if(offset == -1)
2941         return TYPE_E_ELEMENTNOTFOUND;
2942
2943     ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
2944     *pRefType = ref->reftype;
2945     return S_OK;
2946 }
2947
2948 /******************************************************************************
2949  * ITypeInfo2_GetImplTypeFlags {OLEAUT32}
2950  *
2951  *  See ITypeInfo_GetImplTypeFlags.
2952  */
2953 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeFlags(
2954         ITypeInfo2* iface,
2955         UINT index,
2956         INT* pImplTypeFlags)
2957 {
2958     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
2959     int offset;
2960     MSFT_RefRecord *ref;
2961
2962     TRACE("(%p,%d,%p)\n", iface, index, pImplTypeFlags);
2963
2964     if(!pImplTypeFlags)
2965         return E_INVALIDARG;
2966
2967     if(index >= This->typeinfo->cImplTypes)
2968         return TYPE_E_ELEMENTNOTFOUND;
2969
2970     if(This->typekind != TKIND_COCLASS) {
2971         *pImplTypeFlags = 0;
2972         return S_OK;
2973     }
2974
2975     offset = ctl2_find_nth_reference(This->typelib, This->typeinfo->datatype1, index);
2976     if(offset == -1)
2977         return TYPE_E_ELEMENTNOTFOUND;
2978
2979     ref = (MSFT_RefRecord *)&This->typelib->typelib_segment_data[MSFT_SEG_REFERENCES][offset];
2980     *pImplTypeFlags = ref->flags;
2981     return S_OK;
2982 }
2983
2984 /******************************************************************************
2985  * ITypeInfo2_GetIDsOfNames {OLEAUT32}
2986  *
2987  *  See ITypeInfo_GetIDsOfNames.
2988  */
2989 static HRESULT WINAPI ITypeInfo2_fnGetIDsOfNames(
2990         ITypeInfo2* iface,
2991         LPOLESTR* rgszNames,
2992         UINT cNames,
2993         MEMBERID* pMemId)
2994 {
2995     FIXME("(%p,%p,%d,%p), stub!\n", iface, rgszNames, cNames, pMemId);
2996     return E_OUTOFMEMORY;
2997 }
2998
2999 /******************************************************************************
3000  * ITypeInfo2_Invoke {OLEAUT32}
3001  *
3002  *  See ITypeInfo_Invoke.
3003  */
3004 static HRESULT WINAPI ITypeInfo2_fnInvoke(
3005         ITypeInfo2* iface,
3006         PVOID pvInstance,
3007         MEMBERID memid,
3008         WORD wFlags,
3009         DISPPARAMS* pDispParams,
3010         VARIANT* pVarResult,
3011         EXCEPINFO* pExcepInfo,
3012         UINT* puArgErr)
3013 {
3014     FIXME("(%p,%p,%d,%x,%p,%p,%p,%p), stub!\n", iface, pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
3015     return E_OUTOFMEMORY;
3016 }
3017
3018 /******************************************************************************
3019  * ITypeInfo2_GetDocumentation {OLEAUT32}
3020  *
3021  *  See ITypeInfo_GetDocumentation.
3022  */
3023 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation(
3024         ITypeInfo2* iface,
3025         MEMBERID memid,
3026         BSTR* pBstrName,
3027         BSTR* pBstrDocString,
3028         DWORD* pdwHelpContext,
3029         BSTR* pBstrHelpFile)
3030 {
3031     FIXME("(%p,%d,%p,%p,%p,%p), stub!\n", iface, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
3032     return E_OUTOFMEMORY;
3033 }
3034
3035 /******************************************************************************
3036  * ITypeInfo2_GetDllEntry {OLEAUT32}
3037  *
3038  *  See ITypeInfo_GetDllEntry.
3039  */
3040 static HRESULT WINAPI ITypeInfo2_fnGetDllEntry(
3041         ITypeInfo2* iface,
3042         MEMBERID memid,
3043         INVOKEKIND invKind,
3044         BSTR* pBstrDllName,
3045         BSTR* pBstrName,
3046         WORD* pwOrdinal)
3047 {
3048     FIXME("(%p,%d,%d,%p,%p,%p), stub!\n", iface, memid, invKind, pBstrDllName, pBstrName, pwOrdinal);
3049     return E_OUTOFMEMORY;
3050 }
3051
3052 /******************************************************************************
3053  * ITypeInfo2_GetRefTypeInfo {OLEAUT32}
3054  *
3055  *  See ITypeInfo_GetRefTypeInfo.
3056  */
3057 static HRESULT WINAPI ITypeInfo2_fnGetRefTypeInfo(
3058         ITypeInfo2* iface,
3059         HREFTYPE hRefType,
3060         ITypeInfo** ppTInfo)
3061 {
3062     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3063
3064     TRACE("(%p,%d,%p)\n", iface, hRefType, ppTInfo);
3065
3066     if(!ppTInfo)
3067         return E_INVALIDARG;
3068
3069     if(hRefType==-2 && This->dual) {
3070         *ppTInfo = (ITypeInfo*)&This->dual->lpVtblTypeInfo2;
3071         return S_OK;
3072     }
3073
3074     if(hRefType&1) {
3075         ITypeLib *tl;
3076         MSFT_ImpInfo *impinfo;
3077         MSFT_ImpFile *impfile;
3078         MSFT_GuidEntry *guid;
3079         WCHAR *filename;
3080         HRESULT hres;
3081
3082         if((hRefType&(~0x3)) >= This->typelib->typelib_segdir[MSFT_SEG_IMPORTINFO].length)
3083             return E_FAIL;
3084
3085         impinfo = (MSFT_ImpInfo*)&This->typelib->typelib_segment_data[MSFT_SEG_IMPORTINFO][hRefType&(~0x3)];
3086         impfile = (MSFT_ImpFile*)&This->typelib->typelib_segment_data[MSFT_SEG_IMPORTFILES][impinfo->oImpFile];
3087         guid = (MSFT_GuidEntry*)&This->typelib->typelib_segment_data[MSFT_SEG_GUID][impinfo->oGuid];
3088
3089         ctl2_decode_string(impfile->filename, &filename);
3090
3091         hres = LoadTypeLib(filename, &tl);
3092         if(FAILED(hres))
3093             return hres;
3094
3095         hres = ITypeLib_GetTypeInfoOfGuid(tl, &guid->guid, ppTInfo);
3096
3097         ITypeLib_Release(tl);
3098         return hres;
3099     } else {
3100         ICreateTypeInfo2Impl *iter;
3101         int i = 0;
3102
3103         for(iter=This->typelib->typeinfos; iter; iter=iter->next_typeinfo) {
3104             if(This->typelib->typelib_typeinfo_offsets[i] == (hRefType&(~0x3))) {
3105                 *ppTInfo = (ITypeInfo*)&iter->lpVtblTypeInfo2;
3106
3107                 ITypeLib_AddRef(*ppTInfo);
3108                 return S_OK;
3109             }
3110             i++;
3111         }
3112     }
3113
3114     return E_FAIL;
3115 }
3116
3117 /******************************************************************************
3118  * ITypeInfo2_AddressOfMember {OLEAUT32}
3119  *
3120  *  See ITypeInfo_AddressOfMember.
3121  */
3122 static HRESULT WINAPI ITypeInfo2_fnAddressOfMember(
3123         ITypeInfo2* iface,
3124         MEMBERID memid,
3125         INVOKEKIND invKind,
3126         PVOID* ppv)
3127 {
3128     FIXME("(%p,%d,%d,%p), stub!\n", iface, memid, invKind, ppv);
3129     return E_OUTOFMEMORY;
3130 }
3131
3132 /******************************************************************************
3133  * ITypeInfo2_CreateInstance {OLEAUT32}
3134  *
3135  *  See ITypeInfo_CreateInstance.
3136  */
3137 static HRESULT WINAPI ITypeInfo2_fnCreateInstance(
3138         ITypeInfo2* iface,
3139         IUnknown* pUnkOuter,
3140         REFIID riid,
3141         PVOID* ppvObj)
3142 {
3143     FIXME("(%p,%p,%s,%p), stub!\n", iface, pUnkOuter, debugstr_guid(riid), ppvObj);
3144     return E_OUTOFMEMORY;
3145 }
3146
3147 /******************************************************************************
3148  * ITypeInfo2_GetMops {OLEAUT32}
3149  *
3150  *  See ITypeInfo_GetMops.
3151  */
3152 static HRESULT WINAPI ITypeInfo2_fnGetMops(
3153         ITypeInfo2* iface,
3154         MEMBERID memid,
3155         BSTR* pBstrMops)
3156 {
3157     FIXME("(%p,%d,%p), stub!\n", iface, memid, pBstrMops);
3158     return E_OUTOFMEMORY;
3159 }
3160
3161 /******************************************************************************
3162  * ITypeInfo2_GetContainingTypeLib {OLEAUT32}
3163  *
3164  *  See ITypeInfo_GetContainingTypeLib.
3165  */
3166 static HRESULT WINAPI ITypeInfo2_fnGetContainingTypeLib(
3167         ITypeInfo2* iface,
3168         ITypeLib** ppTLib,
3169         UINT* pIndex)
3170 {
3171     ICreateTypeInfo2Impl *This = impl_from_ITypeInfo2(iface);
3172
3173     TRACE("(%p,%p,%p)\n", iface, ppTLib, pIndex);
3174
3175     *ppTLib = (ITypeLib *)&This->typelib->lpVtblTypeLib2;
3176     This->typelib->ref++;
3177     *pIndex = This->typeinfo->typekind >> 16;
3178
3179     return S_OK;
3180 }
3181
3182 /******************************************************************************
3183  * ITypeInfo2_ReleaseTypeAttr {OLEAUT32}
3184  *
3185  *  See ITypeInfo_ReleaseTypeAttr.
3186  */
3187 static void WINAPI ITypeInfo2_fnReleaseTypeAttr(
3188         ITypeInfo2* iface,
3189         TYPEATTR* pTypeAttr)
3190 {
3191     TRACE("(%p,%p)\n", iface, pTypeAttr);
3192
3193     HeapFree(GetProcessHeap(), 0, pTypeAttr);
3194 }
3195
3196 /******************************************************************************
3197  * ITypeInfo2_ReleaseFuncDesc {OLEAUT32}
3198  *
3199  *  See ITypeInfo_ReleaseFuncDesc.
3200  */
3201 static void WINAPI ITypeInfo2_fnReleaseFuncDesc(
3202         ITypeInfo2* iface,
3203         FUNCDESC* pFuncDesc)
3204 {
3205     FIXME("(%p,%p), stub!\n", iface, pFuncDesc);
3206 }
3207
3208 /******************************************************************************
3209  * ITypeInfo2_ReleaseVarDesc {OLEAUT32}
3210  *
3211  *  See ITypeInfo_ReleaseVarDesc.
3212  */
3213 static void WINAPI ITypeInfo2_fnReleaseVarDesc(
3214         ITypeInfo2* iface,
3215         VARDESC* pVarDesc)
3216 {
3217     FIXME("(%p,%p), stub!\n", iface, pVarDesc);
3218 }
3219
3220 /******************************************************************************
3221  * ITypeInfo2_GetTypeKind {OLEAUT32}
3222  *
3223  *  Get the TYPEKIND value for a TypeInfo.
3224  *
3225  * RETURNS
3226  *
3227  *  Success: S_OK.
3228  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3229  */
3230 static HRESULT WINAPI ITypeInfo2_fnGetTypeKind(
3231         ITypeInfo2* iface,   /* [I] The TypeInfo to obtain the typekind for. */
3232         TYPEKIND* pTypeKind) /* [O] The typekind for this TypeInfo. */
3233 {
3234     FIXME("(%p,%p), stub!\n", iface, pTypeKind);
3235     return E_OUTOFMEMORY;
3236 }
3237
3238 /******************************************************************************
3239  * ITypeInfo2_GetTypeFlags {OLEAUT32}
3240  *
3241  *  Get the Type Flags for a TypeInfo.
3242  *
3243  * RETURNS
3244  *
3245  *  Success: S_OK.
3246  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3247  */
3248 static HRESULT WINAPI ITypeInfo2_fnGetTypeFlags(
3249         ITypeInfo2* iface, /* [I] The TypeInfo to obtain the typeflags for. */
3250         ULONG* pTypeFlags) /* [O] The type flags for this TypeInfo. */
3251 {
3252     FIXME("(%p,%p), stub!\n", iface, pTypeFlags);
3253     return E_OUTOFMEMORY;
3254 }
3255
3256 /******************************************************************************
3257  * ITypeInfo2_GetFuncIndexOfMemId {OLEAUT32}
3258  *
3259  *  Gets the index of a function given its member id.
3260  *
3261  * RETURNS
3262  *
3263  *  Success: S_OK.
3264  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3265  */
3266 static HRESULT WINAPI ITypeInfo2_fnGetFuncIndexOfMemId(
3267         ITypeInfo2* iface,  /* [I] The TypeInfo in which to find the function. */
3268         MEMBERID memid,     /* [I] The member id for the function. */
3269         INVOKEKIND invKind, /* [I] The invocation kind for the function. */
3270         UINT* pFuncIndex)   /* [O] The index of the function. */
3271 {
3272     FIXME("(%p,%d,%d,%p), stub!\n", iface, memid, invKind, pFuncIndex);
3273     return E_OUTOFMEMORY;
3274 }
3275
3276 /******************************************************************************
3277  * ITypeInfo2_GetVarIndexOfMemId {OLEAUT32}
3278  *
3279  *  Gets the index of a variable given its member id.
3280  *
3281  * RETURNS
3282  *
3283  *  Success: S_OK.
3284  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3285  */
3286 static HRESULT WINAPI ITypeInfo2_fnGetVarIndexOfMemId(
3287         ITypeInfo2* iface, /* [I] The TypeInfo in which to find the variable. */
3288         MEMBERID memid,    /* [I] The member id for the variable. */
3289         UINT* pVarIndex)   /* [O] The index of the variable. */
3290 {
3291     FIXME("(%p,%d,%p), stub!\n", iface, memid, pVarIndex);
3292     return E_OUTOFMEMORY;
3293 }
3294
3295 /******************************************************************************
3296  * ITypeInfo2_GetCustData {OLEAUT32}
3297  *
3298  *  Gets a custom data element from a TypeInfo.
3299  *
3300  * RETURNS
3301  *
3302  *  Success: S_OK.
3303  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3304  */
3305 static HRESULT WINAPI ITypeInfo2_fnGetCustData(
3306         ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
3307         REFGUID guid,      /* [I] The GUID under which the custom data is stored. */
3308         VARIANT* pVarVal)  /* [O] The custom data. */
3309 {
3310     FIXME("(%p,%s,%p), stub!\n", iface, debugstr_guid(guid), pVarVal);
3311     return E_OUTOFMEMORY;
3312 }
3313
3314 /******************************************************************************
3315  * ITypeInfo2_GetFuncCustData {OLEAUT32}
3316  *
3317  *  Gets a custom data element from a function.
3318  *
3319  * RETURNS
3320  *
3321  *  Success: S_OK.
3322  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3323  */
3324 static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData(
3325         ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
3326         UINT index,        /* [I] The index of the function for which to retrieve the custom data. */
3327         REFGUID guid,      /* [I] The GUID under which the custom data is stored. */
3328         VARIANT* pVarVal)  /* [O] The custom data. */
3329 {
3330     FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
3331     return E_OUTOFMEMORY;
3332 }
3333
3334 /******************************************************************************
3335  * ITypeInfo2_GetParamCustData {OLEAUT32}
3336  *
3337  *  Gets a custom data element from a parameter.
3338  *
3339  * RETURNS
3340  *
3341  *  Success: S_OK.
3342  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3343  */
3344 static HRESULT WINAPI ITypeInfo2_fnGetParamCustData(
3345         ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
3346         UINT indexFunc,    /* [I] The index of the function for which to retrieve the custom data. */
3347         UINT indexParam,   /* [I] The index of the parameter for which to retrieve the custom data. */
3348         REFGUID guid,      /* [I] The GUID under which the custom data is stored. */
3349         VARIANT* pVarVal)  /* [O] The custom data. */
3350 {
3351     FIXME("(%p,%d,%d,%s,%p), stub!\n", iface, indexFunc, indexParam, debugstr_guid(guid), pVarVal);
3352     return E_OUTOFMEMORY;
3353 }
3354
3355 /******************************************************************************
3356  * ITypeInfo2_GetVarCustData {OLEAUT32}
3357  *
3358  *  Gets a custom data element from a variable.
3359  *
3360  * RETURNS
3361  *
3362  *  Success: S_OK.
3363  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3364  */
3365 static HRESULT WINAPI ITypeInfo2_fnGetVarCustData(
3366         ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
3367         UINT index,        /* [I] The index of the variable for which to retrieve the custom data. */
3368         REFGUID guid,      /* [I] The GUID under which the custom data is stored. */
3369         VARIANT* pVarVal)  /* [O] The custom data. */
3370 {
3371     FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
3372     return E_OUTOFMEMORY;
3373 }
3374
3375 /******************************************************************************
3376  * ITypeInfo2_GetImplTypeCustData {OLEAUT32}
3377  *
3378  *  Gets a custom data element from an implemented type of a TypeInfo.
3379  *
3380  * RETURNS
3381  *
3382  *  Success: S_OK.
3383  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3384  */
3385 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData(
3386         ITypeInfo2* iface, /* [I] The TypeInfo in which to find the custom data. */
3387         UINT index,        /* [I] The index of the implemented type for which to retrieve the custom data. */
3388         REFGUID guid,      /* [I] The GUID under which the custom data is stored. */
3389         VARIANT* pVarVal)  /* [O] The custom data. */
3390 {
3391     FIXME("(%p,%d,%s,%p), stub!\n", iface, index, debugstr_guid(guid), pVarVal);
3392     return E_OUTOFMEMORY;
3393 }
3394
3395 /******************************************************************************
3396  * ITypeInfo2_GetDocumentation2 {OLEAUT32}
3397  *
3398  *  Gets some documentation from a TypeInfo in a locale-aware fashion.
3399  *
3400  * RETURNS
3401  *
3402  *  Success: S_OK.
3403  *  Failure: One of STG_E_INSUFFICIENTMEMORY or E_INVALIDARG.
3404  */
3405 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2(
3406         ITypeInfo2* iface,           /* [I] The TypeInfo to retrieve the documentation from. */
3407         MEMBERID memid,              /* [I] The member id (why?). */
3408         LCID lcid,                   /* [I] The locale (why?). */
3409         BSTR* pbstrHelpString,       /* [O] The help string. */
3410         DWORD* pdwHelpStringContext, /* [O] The help string context. */
3411         BSTR* pbstrHelpStringDll)    /* [O] The help file name. */
3412 {
3413     FIXME("(%p,%d,%d,%p,%p,%p), stub!\n", iface, memid, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll);
3414     return E_OUTOFMEMORY;
3415 }
3416
3417 /******************************************************************************
3418  * ITypeInfo2_GetAllCustData {OLEAUT32}
3419  *
3420  *  Gets all of the custom data associated with a TypeInfo.
3421  *
3422  * RETURNS
3423  *
3424  *  Success: S_OK.
3425  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3426  */
3427 static HRESULT WINAPI ITypeInfo2_fnGetAllCustData(
3428         ITypeInfo2* iface,   /* [I] The TypeInfo in which to find the custom data. */
3429         CUSTDATA* pCustData) /* [O] A pointer to the custom data. */
3430 {
3431     FIXME("(%p,%p), stub!\n", iface, pCustData);
3432     return E_OUTOFMEMORY;
3433 }
3434
3435 /******************************************************************************
3436  * ITypeInfo2_GetAllFuncCustData {OLEAUT32}
3437  *
3438  *  Gets all of the custom data associated with a function.
3439  *
3440  * RETURNS
3441  *
3442  *  Success: S_OK.
3443  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3444  */
3445 static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData(
3446         ITypeInfo2* iface,   /* [I] The TypeInfo in which to find the custom data. */
3447         UINT index,          /* [I] The index of the function for which to retrieve the custom data. */
3448         CUSTDATA* pCustData) /* [O] A pointer to the custom data. */
3449 {
3450     FIXME("(%p,%d,%p), stub!\n", iface, index, pCustData);
3451     return E_OUTOFMEMORY;
3452 }
3453
3454 /******************************************************************************
3455  * ITypeInfo2_GetAllParamCustData {OLEAUT32}
3456  *
3457  *  Gets all of the custom data associated with a parameter.
3458  *
3459  * RETURNS
3460  *
3461  *  Success: S_OK.
3462  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3463  */
3464 static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData(
3465         ITypeInfo2* iface,   /* [I] The TypeInfo in which to find the custom data. */
3466         UINT indexFunc,      /* [I] The index of the function for which to retrieve the custom data. */
3467         UINT indexParam,     /* [I] The index of the parameter for which to retrieve the custom data. */
3468         CUSTDATA* pCustData) /* [O] A pointer to the custom data. */
3469 {
3470     FIXME("(%p,%d,%d,%p), stub!\n", iface, indexFunc, indexParam, pCustData);
3471     return E_OUTOFMEMORY;
3472 }
3473
3474 /******************************************************************************
3475  * ITypeInfo2_GetAllVarCustData {OLEAUT32}
3476  *
3477  *  Gets all of the custom data associated with a variable.
3478  *
3479  * RETURNS
3480  *
3481  *  Success: S_OK.
3482  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3483  */
3484 static HRESULT WINAPI ITypeInfo2_fnGetAllVarCustData(
3485         ITypeInfo2* iface,   /* [I] The TypeInfo in which to find the custom data. */
3486         UINT index,          /* [I] The index of the variable for which to retrieve the custom data. */
3487         CUSTDATA* pCustData) /* [O] A pointer to the custom data. */
3488 {
3489     FIXME("(%p,%d,%p), stub!\n", iface, index, pCustData);
3490     return E_OUTOFMEMORY;
3491 }
3492
3493 /******************************************************************************
3494  * ITypeInfo2_GetAllImplTypeCustData {OLEAUT32}
3495  *
3496  *  Gets all of the custom data associated with an implemented type.
3497  *
3498  * RETURNS
3499  *
3500  *  Success: S_OK.
3501  *  Failure: One of E_OUTOFMEMORY or E_INVALIDARG.
3502  */
3503 static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData(
3504         ITypeInfo2* iface,   /* [I] The TypeInfo in which to find the custom data. */
3505         UINT index,          /* [I] The index of the implemented type for which to retrieve the custom data. */
3506         CUSTDATA* pCustData) /* [O] A pointer to the custom data. */
3507 {
3508     FIXME("(%p,%d,%p), stub!\n", iface, index, pCustData);
3509     return E_OUTOFMEMORY;
3510 }
3511
3512
3513 /*================== ICreateTypeInfo2 & ITypeInfo2 VTABLEs And Creation ===================================*/
3514
3515 static const ICreateTypeInfo2Vtbl ctypeinfo2vt =
3516 {
3517
3518     ICreateTypeInfo2_fnQueryInterface,
3519     ICreateTypeInfo2_fnAddRef,
3520     ICreateTypeInfo2_fnRelease,
3521
3522     ICreateTypeInfo2_fnSetGuid,
3523     ICreateTypeInfo2_fnSetTypeFlags,
3524     ICreateTypeInfo2_fnSetDocString,
3525     ICreateTypeInfo2_fnSetHelpContext,
3526     ICreateTypeInfo2_fnSetVersion,
3527     ICreateTypeInfo2_fnAddRefTypeInfo,
3528     ICreateTypeInfo2_fnAddFuncDesc,
3529     ICreateTypeInfo2_fnAddImplType,
3530     ICreateTypeInfo2_fnSetImplTypeFlags,
3531     ICreateTypeInfo2_fnSetAlignment,
3532     ICreateTypeInfo2_fnSetSchema,
3533     ICreateTypeInfo2_fnAddVarDesc,
3534     ICreateTypeInfo2_fnSetFuncAndParamNames,
3535     ICreateTypeInfo2_fnSetVarName,
3536     ICreateTypeInfo2_fnSetTypeDescAlias,
3537     ICreateTypeInfo2_fnDefineFuncAsDllEntry,
3538     ICreateTypeInfo2_fnSetFuncDocString,
3539     ICreateTypeInfo2_fnSetVarDocString,
3540     ICreateTypeInfo2_fnSetFuncHelpContext,
3541     ICreateTypeInfo2_fnSetVarHelpContext,
3542     ICreateTypeInfo2_fnSetMops,
3543     ICreateTypeInfo2_fnSetTypeIdldesc,
3544     ICreateTypeInfo2_fnLayOut,
3545
3546     ICreateTypeInfo2_fnDeleteFuncDesc,
3547     ICreateTypeInfo2_fnDeleteFuncDescByMemId,
3548     ICreateTypeInfo2_fnDeleteVarDesc,
3549     ICreateTypeInfo2_fnDeleteVarDescByMemId,
3550     ICreateTypeInfo2_fnDeleteImplType,
3551     ICreateTypeInfo2_fnSetCustData,
3552     ICreateTypeInfo2_fnSetFuncCustData,
3553     ICreateTypeInfo2_fnSetParamCustData,
3554     ICreateTypeInfo2_fnSetVarCustData,
3555     ICreateTypeInfo2_fnSetImplTypeCustData,
3556     ICreateTypeInfo2_fnSetHelpStringContext,
3557     ICreateTypeInfo2_fnSetFuncHelpStringContext,
3558     ICreateTypeInfo2_fnSetVarHelpStringContext,
3559     ICreateTypeInfo2_fnInvalidate,
3560     ICreateTypeInfo2_fnSetName
3561 };
3562
3563 static const ITypeInfo2Vtbl typeinfo2vt =
3564 {
3565
3566     ITypeInfo2_fnQueryInterface,
3567     ITypeInfo2_fnAddRef,
3568     ITypeInfo2_fnRelease,
3569
3570     ITypeInfo2_fnGetTypeAttr,
3571     ITypeInfo2_fnGetTypeComp,
3572     ITypeInfo2_fnGetFuncDesc,
3573     ITypeInfo2_fnGetVarDesc,
3574     ITypeInfo2_fnGetNames,
3575     ITypeInfo2_fnGetRefTypeOfImplType,
3576     ITypeInfo2_fnGetImplTypeFlags,
3577     ITypeInfo2_fnGetIDsOfNames,
3578     ITypeInfo2_fnInvoke,
3579     ITypeInfo2_fnGetDocumentation,
3580     ITypeInfo2_fnGetDllEntry,
3581     ITypeInfo2_fnGetRefTypeInfo,
3582     ITypeInfo2_fnAddressOfMember,
3583     ITypeInfo2_fnCreateInstance,
3584     ITypeInfo2_fnGetMops,
3585     ITypeInfo2_fnGetContainingTypeLib,
3586     ITypeInfo2_fnReleaseTypeAttr,
3587     ITypeInfo2_fnReleaseFuncDesc,
3588     ITypeInfo2_fnReleaseVarDesc,
3589
3590     ITypeInfo2_fnGetTypeKind,
3591     ITypeInfo2_fnGetTypeFlags,
3592     ITypeInfo2_fnGetFuncIndexOfMemId,
3593     ITypeInfo2_fnGetVarIndexOfMemId,
3594     ITypeInfo2_fnGetCustData,
3595     ITypeInfo2_fnGetFuncCustData,
3596     ITypeInfo2_fnGetParamCustData,
3597     ITypeInfo2_fnGetVarCustData,
3598     ITypeInfo2_fnGetImplTypeCustData,
3599     ITypeInfo2_fnGetDocumentation2,
3600     ITypeInfo2_fnGetAllCustData,
3601     ITypeInfo2_fnGetAllFuncCustData,
3602     ITypeInfo2_fnGetAllParamCustData,
3603     ITypeInfo2_fnGetAllVarCustData,
3604     ITypeInfo2_fnGetAllImplTypeCustData,
3605 };
3606
3607 static ICreateTypeInfo2 *ICreateTypeInfo2_Constructor(ICreateTypeLib2Impl *typelib, WCHAR *szName, TYPEKIND tkind)
3608 {
3609     ICreateTypeInfo2Impl *pCreateTypeInfo2Impl;
3610
3611     int nameoffset;
3612     int typeinfo_offset;
3613     MSFT_TypeInfoBase *typeinfo;
3614
3615     TRACE("Constructing ICreateTypeInfo2 for %s with tkind %d\n", debugstr_w(szName), tkind);
3616
3617     pCreateTypeInfo2Impl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ICreateTypeInfo2Impl));
3618     if (!pCreateTypeInfo2Impl) return NULL;
3619
3620     pCreateTypeInfo2Impl->lpVtbl = &ctypeinfo2vt;
3621     pCreateTypeInfo2Impl->lpVtblTypeInfo2 = &typeinfo2vt;
3622     pCreateTypeInfo2Impl->ref = 1;
3623
3624     pCreateTypeInfo2Impl->typelib = typelib;
3625     typelib->ref++;
3626
3627     nameoffset = ctl2_alloc_name(typelib, szName);
3628     typeinfo_offset = ctl2_alloc_typeinfo(typelib, nameoffset);
3629     typeinfo = (MSFT_TypeInfoBase *)&typelib->typelib_segment_data[MSFT_SEG_TYPEINFO][typeinfo_offset];
3630
3631     typelib->typelib_segment_data[MSFT_SEG_NAME][nameoffset + 9] = 0x38;
3632     *((int *)&typelib->typelib_segment_data[MSFT_SEG_NAME][nameoffset]) = typeinfo_offset;
3633
3634     pCreateTypeInfo2Impl->typeinfo = typeinfo;
3635
3636     pCreateTypeInfo2Impl->typekind = tkind;
3637     typeinfo->typekind |= tkind | 0x20;
3638     ICreateTypeInfo2_SetAlignment((ICreateTypeInfo2 *)pCreateTypeInfo2Impl, 4);
3639
3640     switch (tkind) {
3641     case TKIND_ENUM:
3642     case TKIND_INTERFACE:
3643     case TKIND_DISPATCH:
3644     case TKIND_COCLASS:
3645         typeinfo->size = 4;
3646         break;
3647
3648     case TKIND_RECORD:
3649     case TKIND_UNION:
3650         typeinfo->size = 0;
3651         break;
3652
3653     case TKIND_MODULE:
3654         typeinfo->size = 2;
3655         break;
3656
3657     case TKIND_ALIAS:
3658         typeinfo->size = -0x75;
3659         break;
3660
3661     default:
3662         FIXME("(%s,%d), unrecognized typekind %d\n", debugstr_w(szName), tkind, tkind);
3663         typeinfo->size = 0xdeadbeef;
3664         break;
3665     }
3666
3667     if (typelib->last_typeinfo) typelib->last_typeinfo->next_typeinfo = pCreateTypeInfo2Impl;
3668     typelib->last_typeinfo = pCreateTypeInfo2Impl;
3669     if (!typelib->typeinfos) typelib->typeinfos = pCreateTypeInfo2Impl;
3670
3671     TRACE(" -- %p\n", pCreateTypeInfo2Impl);
3672
3673     return (ICreateTypeInfo2 *)pCreateTypeInfo2Impl;
3674 }
3675
3676
3677 /*================== ICreateTypeLib2 Implementation ===================================*/
3678
3679 /******************************************************************************
3680  * ICreateTypeLib2_QueryInterface {OLEAUT32}
3681  *
3682  *  See IUnknown_QueryInterface.
3683  */
3684 static HRESULT WINAPI ICreateTypeLib2_fnQueryInterface(
3685         ICreateTypeLib2 * iface,
3686         REFIID riid,
3687         VOID **ppvObject)
3688 {
3689     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3690
3691     TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
3692
3693     *ppvObject=NULL;
3694     if(IsEqualIID(riid, &IID_IUnknown) ||
3695        IsEqualIID(riid,&IID_ICreateTypeLib)||
3696        IsEqualIID(riid,&IID_ICreateTypeLib2))
3697     {
3698         *ppvObject = This;
3699     } else if (IsEqualIID(riid, &IID_ITypeLib) ||
3700                IsEqualIID(riid, &IID_ITypeLib2)) {
3701         *ppvObject = &This->lpVtblTypeLib2;
3702     }
3703
3704     if(*ppvObject)
3705     {
3706         ICreateTypeLib2_AddRef(iface);
3707         TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
3708         return S_OK;
3709     }
3710     TRACE("-- Interface: E_NOINTERFACE\n");
3711     return E_NOINTERFACE;
3712 }
3713
3714 /******************************************************************************
3715  * ICreateTypeLib2_AddRef {OLEAUT32}
3716  *
3717  *  See IUnknown_AddRef.
3718  */
3719 static ULONG WINAPI ICreateTypeLib2_fnAddRef(ICreateTypeLib2 *iface)
3720 {
3721     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3722     ULONG ref = InterlockedIncrement(&This->ref);
3723
3724     TRACE("(%p)->ref was %u\n",This, ref - 1);
3725
3726     return ref;
3727 }
3728
3729 /******************************************************************************
3730  * ICreateTypeLib2_Release {OLEAUT32}
3731  *
3732  *  See IUnknown_Release.
3733  */
3734 static ULONG WINAPI ICreateTypeLib2_fnRelease(ICreateTypeLib2 *iface)
3735 {
3736     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3737     ULONG ref = InterlockedDecrement(&This->ref);
3738
3739     TRACE("(%p)->(%u)\n",This, ref);
3740
3741     if (!ref) {
3742         int i;
3743
3744         for (i = 0; i < MSFT_SEG_MAX; i++) {
3745             HeapFree(GetProcessHeap(), 0, This->typelib_segment_data[i]);
3746             This->typelib_segment_data[i] = NULL;
3747         }
3748
3749         HeapFree(GetProcessHeap(), 0, This->filename);
3750         This->filename = NULL;
3751
3752         while (This->typeinfos) {
3753             ICreateTypeInfo2Impl *typeinfo = This->typeinfos;
3754             This->typeinfos = typeinfo->next_typeinfo;
3755             if(typeinfo->typedata) {
3756                 CyclicList *iter, *rem;
3757
3758                 rem = typeinfo->typedata->next;
3759                 typeinfo->typedata->next = NULL;
3760                 iter = rem->next;
3761                 HeapFree(GetProcessHeap(), 0, rem);
3762
3763                 while(iter) {
3764                     rem = iter;
3765                     iter = iter->next;
3766                     HeapFree(GetProcessHeap(), 0, rem->u.data);
3767                     HeapFree(GetProcessHeap(), 0, rem);
3768                 }
3769             }
3770
3771             if(typeinfo->dual)
3772                 HeapFree(GetProcessHeap(), 0, typeinfo->dual);
3773
3774             HeapFree(GetProcessHeap(), 0, typeinfo);
3775         }
3776
3777         HeapFree(GetProcessHeap(),0,This);
3778         return 0;
3779     }
3780
3781     return ref;
3782 }
3783
3784
3785 /******************************************************************************
3786  * ICreateTypeLib2_CreateTypeInfo {OLEAUT32}
3787  *
3788  *  See ICreateTypeLib_CreateTypeInfo.
3789  */
3790 static HRESULT WINAPI ICreateTypeLib2_fnCreateTypeInfo(
3791         ICreateTypeLib2 * iface,
3792         LPOLESTR szName,
3793         TYPEKIND tkind,
3794         ICreateTypeInfo **ppCTInfo)
3795 {
3796     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3797     char *name;
3798
3799     TRACE("(%p,%s,%d,%p)\n", iface, debugstr_w(szName), tkind, ppCTInfo);
3800
3801     ctl2_encode_name(This, szName, &name);
3802     if(ctl2_find_name(This, name) != -1)
3803         return TYPE_E_NAMECONFLICT;
3804
3805     *ppCTInfo = (ICreateTypeInfo *)ICreateTypeInfo2_Constructor(This, szName, tkind);
3806
3807     if (!*ppCTInfo) return E_OUTOFMEMORY;
3808
3809     return S_OK;
3810 }
3811
3812 /******************************************************************************
3813  * ICreateTypeLib2_SetName {OLEAUT32}
3814  *
3815  *  See ICreateTypeLib_SetName.
3816  */
3817 static HRESULT WINAPI ICreateTypeLib2_fnSetName(
3818         ICreateTypeLib2 * iface,
3819         LPOLESTR szName)
3820 {
3821     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3822
3823     int offset;
3824
3825     TRACE("(%p,%s)\n", iface, debugstr_w(szName));
3826
3827     offset = ctl2_alloc_name(This, szName);
3828     if (offset == -1) return E_OUTOFMEMORY;
3829     This->typelib_header.NameOffset = offset;
3830     return S_OK;
3831 }
3832
3833 /******************************************************************************
3834  * ICreateTypeLib2_SetVersion {OLEAUT32}
3835  *
3836  *  See ICreateTypeLib_SetVersion.
3837  */
3838 static HRESULT WINAPI ICreateTypeLib2_fnSetVersion(ICreateTypeLib2 * iface, WORD wMajorVerNum, WORD wMinorVerNum)
3839 {
3840     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3841
3842     TRACE("(%p,%d,%d)\n", iface, wMajorVerNum, wMinorVerNum);
3843
3844     This->typelib_header.version = wMajorVerNum | (wMinorVerNum << 16);
3845     return S_OK;
3846 }
3847
3848 /******************************************************************************
3849  * ICreateTypeLib2_SetGuid {OLEAUT32}
3850  *
3851  *  See ICreateTypeLib_SetGuid.
3852  */
3853 static HRESULT WINAPI ICreateTypeLib2_fnSetGuid(ICreateTypeLib2 * iface, REFGUID guid)
3854 {
3855     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3856
3857     MSFT_GuidEntry guidentry;
3858     int offset;
3859
3860     TRACE("(%p,%s)\n", iface, debugstr_guid(guid));
3861
3862     guidentry.guid = *guid;
3863     guidentry.hreftype = -2;
3864     guidentry.next_hash = -1;
3865
3866     offset = ctl2_alloc_guid(This, &guidentry);
3867
3868     if (offset == -1) return E_OUTOFMEMORY;
3869
3870     This->typelib_header.posguid = offset;
3871
3872     return S_OK;
3873 }
3874
3875 /******************************************************************************
3876  * ICreateTypeLib2_SetDocString {OLEAUT32}
3877  *
3878  *  See ICreateTypeLib_SetDocString.
3879  */
3880 static HRESULT WINAPI ICreateTypeLib2_fnSetDocString(ICreateTypeLib2 * iface, LPOLESTR szDoc)
3881 {
3882     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3883
3884     int offset;
3885
3886     TRACE("(%p,%s)\n", iface, debugstr_w(szDoc));
3887     if (!szDoc)
3888         return E_INVALIDARG;
3889
3890     offset = ctl2_alloc_string(This, szDoc);
3891     if (offset == -1) return E_OUTOFMEMORY;
3892     This->typelib_header.helpstring = offset;
3893     return S_OK;
3894 }
3895
3896 /******************************************************************************
3897  * ICreateTypeLib2_SetHelpFileName {OLEAUT32}
3898  *
3899  *  See ICreateTypeLib_SetHelpFileName.
3900  */
3901 static HRESULT WINAPI ICreateTypeLib2_fnSetHelpFileName(ICreateTypeLib2 * iface, LPOLESTR szHelpFileName)
3902 {
3903     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3904
3905     int offset;
3906
3907     TRACE("(%p,%s)\n", iface, debugstr_w(szHelpFileName));
3908
3909     offset = ctl2_alloc_string(This, szHelpFileName);
3910     if (offset == -1) return E_OUTOFMEMORY;
3911     This->typelib_header.helpfile = offset;
3912     This->typelib_header.varflags |= 0x10;
3913     return S_OK;
3914 }
3915
3916 /******************************************************************************
3917  * ICreateTypeLib2_SetHelpContext {OLEAUT32}
3918  *
3919  *  See ICreateTypeLib_SetHelpContext.
3920  */
3921 static HRESULT WINAPI ICreateTypeLib2_fnSetHelpContext(ICreateTypeLib2 * iface, DWORD dwHelpContext)
3922 {
3923     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3924
3925     TRACE("(%p,%d)\n", iface, dwHelpContext);
3926     This->typelib_header.helpcontext = dwHelpContext;
3927     return S_OK;
3928 }
3929
3930 /******************************************************************************
3931  * ICreateTypeLib2_SetLcid {OLEAUT32}
3932  *
3933  * Sets both the lcid and lcid2 members in the header to lcid.
3934  *
3935  * As a special case if lcid == LOCALE_NEUTRAL (0), then the first header lcid
3936  * is set to US English while the second one is set to 0.
3937  */
3938 static HRESULT WINAPI ICreateTypeLib2_fnSetLcid(ICreateTypeLib2 * iface, LCID lcid)
3939 {
3940     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3941
3942     TRACE("(%p,%d)\n", iface, lcid);
3943
3944     This->typelib_header.lcid = This->typelib_header.lcid2 = lcid;
3945
3946     if(lcid == LOCALE_NEUTRAL) This->typelib_header.lcid = MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US);
3947
3948     return S_OK;
3949 }
3950
3951 /******************************************************************************
3952  * ICreateTypeLib2_SetLibFlags {OLEAUT32}
3953  *
3954  *  See ICreateTypeLib_SetLibFlags.
3955  */
3956 static HRESULT WINAPI ICreateTypeLib2_fnSetLibFlags(ICreateTypeLib2 * iface, UINT uLibFlags)
3957 {
3958     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
3959
3960     TRACE("(%p,0x%x)\n", iface, uLibFlags);
3961
3962     This->typelib_header.flags = uLibFlags;
3963
3964     return S_OK;
3965 }
3966
3967 static int ctl2_write_chunk(HANDLE hFile, const void *segment, int length)
3968 {
3969     DWORD dwWritten;
3970     if (!WriteFile(hFile, segment, length, &dwWritten, 0)) {
3971         CloseHandle(hFile);
3972         return 0;
3973     }
3974     return -1;
3975 }
3976
3977 static int ctl2_write_segment(ICreateTypeLib2Impl *This, HANDLE hFile, int segment)
3978 {
3979     DWORD dwWritten;
3980     if (!WriteFile(hFile, This->typelib_segment_data[segment],
3981                    This->typelib_segdir[segment].length, &dwWritten, 0)) {
3982         CloseHandle(hFile);
3983         return 0;
3984     }
3985
3986     return -1;
3987 }
3988
3989 static HRESULT ctl2_finalize_typeinfos(ICreateTypeLib2Impl *This, int filesize)
3990 {
3991     ICreateTypeInfo2Impl *typeinfo;
3992     HRESULT hres;
3993
3994     for (typeinfo = This->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
3995         typeinfo->typeinfo->memoffset = filesize;
3996
3997         hres = ICreateTypeInfo2_fnLayOut((ICreateTypeInfo2 *)typeinfo);
3998         if(FAILED(hres))
3999             return hres;
4000
4001         if (typeinfo->typedata)
4002             filesize += typeinfo->typedata->next->u.val
4003                 + ((typeinfo->typeinfo->cElement >> 16) * 12)
4004                 + ((typeinfo->typeinfo->cElement & 0xffff) * 12) + 4;
4005     }
4006
4007     return S_OK;
4008 }
4009
4010 static int ctl2_finalize_segment(ICreateTypeLib2Impl *This, int filepos, int segment)
4011 {
4012     if (This->typelib_segdir[segment].length) {
4013         This->typelib_segdir[segment].offset = filepos;
4014     } else {
4015         This->typelib_segdir[segment].offset = -1;
4016     }
4017
4018     return This->typelib_segdir[segment].length;
4019 }
4020
4021 static void ctl2_write_typeinfos(ICreateTypeLib2Impl *This, HANDLE hFile)
4022 {
4023     ICreateTypeInfo2Impl *typeinfo;
4024
4025     for (typeinfo = This->typeinfos; typeinfo; typeinfo = typeinfo->next_typeinfo) {
4026         CyclicList *iter;
4027         int offset = 0;
4028
4029         if (!typeinfo->typedata) continue;
4030
4031         iter = typeinfo->typedata->next;
4032         ctl2_write_chunk(hFile, &iter->u.val, sizeof(int));
4033         for(iter=iter->next; iter!=typeinfo->typedata->next; iter=iter->next)
4034             ctl2_write_chunk(hFile, iter->u.data, iter->u.data[0] & 0xffff);
4035
4036         for(iter=typeinfo->typedata->next->next; iter!=typeinfo->typedata->next; iter=iter->next)
4037             ctl2_write_chunk(hFile, &iter->indice, sizeof(int));
4038
4039         for(iter=typeinfo->typedata->next->next; iter!=typeinfo->typedata->next; iter=iter->next)
4040             ctl2_write_chunk(hFile, &iter->name, sizeof(int));
4041
4042         for(iter=typeinfo->typedata->next->next; iter!=typeinfo->typedata->next; iter=iter->next) {
4043             ctl2_write_chunk(hFile, &offset, sizeof(int));
4044             offset += iter->u.data[0] & 0xffff;
4045         }
4046     }
4047 }
4048
4049 /******************************************************************************
4050  * ICreateTypeLib2_SaveAllChanges {OLEAUT32}
4051  *
4052  *  See ICreateTypeLib_SaveAllChanges.
4053  */
4054 static HRESULT WINAPI ICreateTypeLib2_fnSaveAllChanges(ICreateTypeLib2 * iface)
4055 {
4056     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
4057
4058     int retval;
4059     int filepos;
4060     HANDLE hFile;
4061     HRESULT hres;
4062
4063     TRACE("(%p)\n", iface);
4064
4065     retval = TYPE_E_IOERROR;
4066
4067     hFile = CreateFileW(This->filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
4068     if (hFile == INVALID_HANDLE_VALUE) return retval;
4069
4070     filepos = sizeof(MSFT_Header) + sizeof(MSFT_SegDir);
4071     filepos += This->typelib_header.nrtypeinfos * 4;
4072
4073     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_TYPEINFO);
4074     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_GUIDHASH);
4075     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_GUID);
4076     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_REFERENCES);
4077     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_IMPORTINFO);
4078     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_IMPORTFILES);
4079     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_NAMEHASH);
4080     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_NAME);
4081     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_STRING);
4082     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_TYPEDESC);
4083     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_ARRAYDESC);
4084     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_CUSTDATA);
4085     filepos += ctl2_finalize_segment(This, filepos, MSFT_SEG_CUSTDATAGUID);
4086
4087     hres = ctl2_finalize_typeinfos(This, filepos);
4088     if(FAILED(hres)) {
4089         CloseHandle(hFile);
4090         return hres;
4091     }
4092
4093     if (!ctl2_write_chunk(hFile, &This->typelib_header, sizeof(This->typelib_header))) return retval;
4094     if (This->typelib_header.varflags & HELPDLLFLAG)
4095         if (!ctl2_write_chunk(hFile, &This->helpStringDll, sizeof(This->helpStringDll))) return retval;
4096     if (!ctl2_write_chunk(hFile, This->typelib_typeinfo_offsets, This->typelib_header.nrtypeinfos * 4)) return retval;
4097     if (!ctl2_write_chunk(hFile, This->typelib_segdir, sizeof(This->typelib_segdir))) return retval;
4098     if (!ctl2_write_segment(This, hFile, MSFT_SEG_TYPEINFO    )) return retval;
4099     if (!ctl2_write_segment(This, hFile, MSFT_SEG_GUIDHASH    )) return retval;
4100     if (!ctl2_write_segment(This, hFile, MSFT_SEG_GUID        )) return retval;
4101     if (!ctl2_write_segment(This, hFile, MSFT_SEG_REFERENCES  )) return retval;
4102     if (!ctl2_write_segment(This, hFile, MSFT_SEG_IMPORTINFO  )) return retval;
4103     if (!ctl2_write_segment(This, hFile, MSFT_SEG_IMPORTFILES )) return retval;
4104     if (!ctl2_write_segment(This, hFile, MSFT_SEG_NAMEHASH    )) return retval;
4105     if (!ctl2_write_segment(This, hFile, MSFT_SEG_NAME        )) return retval;
4106     if (!ctl2_write_segment(This, hFile, MSFT_SEG_STRING      )) return retval;
4107     if (!ctl2_write_segment(This, hFile, MSFT_SEG_TYPEDESC    )) return retval;
4108     if (!ctl2_write_segment(This, hFile, MSFT_SEG_ARRAYDESC   )) return retval;
4109     if (!ctl2_write_segment(This, hFile, MSFT_SEG_CUSTDATA    )) return retval;
4110     if (!ctl2_write_segment(This, hFile, MSFT_SEG_CUSTDATAGUID)) return retval;
4111
4112     ctl2_write_typeinfos(This, hFile);
4113
4114     if (!CloseHandle(hFile)) return retval;
4115
4116     return S_OK;
4117 }
4118
4119
4120 /******************************************************************************
4121  * ICreateTypeLib2_DeleteTypeInfo {OLEAUT32}
4122  *
4123  *  Deletes a named TypeInfo from a type library.
4124  *
4125  * RETURNS
4126  *
4127  *  Success: S_OK
4128  *  Failure: E_OUTOFMEMORY or E_INVALIDARG.
4129  */
4130 static HRESULT WINAPI ICreateTypeLib2_fnDeleteTypeInfo(
4131         ICreateTypeLib2 * iface, /* [I] The type library to delete from. */
4132         LPOLESTR szName)         /* [I] The name of the typeinfo to delete. */
4133 {
4134     FIXME("(%p,%s), stub!\n", iface, debugstr_w(szName));
4135     return E_OUTOFMEMORY;
4136 }
4137
4138 /******************************************************************************
4139  * ICreateTypeLib2_SetCustData {OLEAUT32}
4140  *
4141  *  Sets custom data for a type library.
4142  *
4143  * RETURNS
4144  *
4145  *  Success: S_OK
4146  *  Failure: E_OUTOFMEMORY or E_INVALIDARG.
4147  */
4148 static HRESULT WINAPI ICreateTypeLib2_fnSetCustData(
4149         ICreateTypeLib2 * iface, /* [I] The type library to store the custom data in. */
4150         REFGUID guid,            /* [I] The GUID used as a key to retrieve the custom data. */
4151         VARIANT *pVarVal)        /* [I] The custom data itself. */
4152 {
4153     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
4154
4155     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(guid), pVarVal);
4156
4157     return ctl2_set_custdata(This, guid, pVarVal, &This->typelib_header.CustomDataOffset);
4158 }
4159
4160 /******************************************************************************
4161  * ICreateTypeLib2_SetHelpStringContext {OLEAUT32}
4162  *
4163  *  Sets a context number for the library help string.
4164  *
4165  * PARAMS
4166  *  iface     [I] The type library to set the help string context for.
4167  *  dwContext [I] The help string context.
4168  *
4169  * RETURNS
4170  *  Success: S_OK
4171  *  Failure: E_OUTOFMEMORY or E_INVALIDARG.
4172  */
4173 static
4174 HRESULT WINAPI ICreateTypeLib2_fnSetHelpStringContext(ICreateTypeLib2 * iface,
4175                                                       ULONG dwContext)
4176 {
4177     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
4178
4179     TRACE("(%p,%d)\n", iface, dwContext);
4180
4181     This->typelib_header.helpstringcontext = dwContext;
4182     return S_OK;
4183 }
4184
4185 /******************************************************************************
4186  * ICreateTypeLib2_SetHelpStringDll {OLEAUT32}
4187  *
4188  *  Set the DLL used to look up localized help strings.
4189  *
4190  * PARAMS
4191  *  iface     [I] The type library to set the help DLL for.
4192  *  szDllName [I] The name of the help DLL.
4193  *
4194  * RETURNS
4195  *  Success: S_OK
4196  *  Failure: E_OUTOFMEMORY or E_INVALIDARG.
4197  */
4198 static
4199 HRESULT WINAPI ICreateTypeLib2_fnSetHelpStringDll(ICreateTypeLib2 * iface,
4200                                                   LPOLESTR szDllName)
4201 {
4202     ICreateTypeLib2Impl *This = (ICreateTypeLib2Impl *)iface;
4203     int offset;
4204
4205     TRACE("(%p,%s)\n", iface, debugstr_w(szDllName));
4206     if (!szDllName)
4207         return E_INVALIDARG;
4208
4209     offset = ctl2_alloc_string(This, szDllName);
4210     if (offset == -1)
4211         return E_OUTOFMEMORY;
4212     This->typelib_header.varflags |= HELPDLLFLAG;
4213     This->helpStringDll = offset;
4214     return S_OK;
4215 }
4216
4217 /*================== ITypeLib2 Implementation ===================================*/
4218
4219 /******************************************************************************
4220  * ITypeLib2_QueryInterface {OLEAUT32}
4221  *
4222  *  See IUnknown_QueryInterface.
4223  */
4224 static HRESULT WINAPI ITypeLib2_fnQueryInterface(ITypeLib2 * iface, REFIID riid, LPVOID * ppv)
4225 {
4226     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4227
4228     return ICreateTypeLib2_QueryInterface((ICreateTypeLib2 *)This, riid, ppv);
4229 }
4230
4231 /******************************************************************************
4232  * ITypeLib2_AddRef {OLEAUT32}
4233  *
4234  *  See IUnknown_AddRef.
4235  */
4236 static ULONG WINAPI ITypeLib2_fnAddRef(ITypeLib2 * iface)
4237 {
4238     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4239
4240     return ICreateTypeLib2_AddRef((ICreateTypeLib2 *)This);
4241 }
4242
4243 /******************************************************************************
4244  * ITypeLib2_Release {OLEAUT32}
4245  *
4246  *  See IUnknown_Release.
4247  */
4248 static ULONG WINAPI ITypeLib2_fnRelease(ITypeLib2 * iface)
4249 {
4250     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4251
4252     return ICreateTypeLib2_Release((ICreateTypeLib2 *)This);
4253 }
4254
4255 /******************************************************************************
4256  * ITypeLib2_GetTypeInfoCount {OLEAUT32}
4257  *
4258  *  See ITypeLib_GetTypeInfoCount.
4259  */
4260 static UINT WINAPI ITypeLib2_fnGetTypeInfoCount(
4261         ITypeLib2 * iface)
4262 {
4263     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4264
4265     TRACE("(%p)\n", iface);
4266
4267     return This->typelib_header.nrtypeinfos;
4268 }
4269
4270 /******************************************************************************
4271  * ITypeLib2_GetTypeInfo {OLEAUT32}
4272  *
4273  *  See ITypeLib_GetTypeInfo.
4274  */
4275 static HRESULT WINAPI ITypeLib2_fnGetTypeInfo(
4276         ITypeLib2 * iface,
4277         UINT index,
4278         ITypeInfo** ppTInfo)
4279 {
4280     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4281
4282     TRACE("(%p,%d,%p)\n", iface, index, ppTInfo);
4283
4284     if (index >= This->typelib_header.nrtypeinfos) {
4285         return TYPE_E_ELEMENTNOTFOUND;
4286     }
4287
4288     return ctl2_find_typeinfo_from_offset(This, This->typelib_typeinfo_offsets[index], ppTInfo);
4289 }
4290
4291 /******************************************************************************
4292  * ITypeLib2_GetTypeInfoType {OLEAUT32}
4293  *
4294  *  See ITypeLib_GetTypeInfoType.
4295  */
4296 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoType(
4297         ITypeLib2 * iface,
4298         UINT index,
4299         TYPEKIND* pTKind)
4300 {
4301     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4302
4303     TRACE("(%p,%d,%p)\n", iface, index, pTKind);
4304
4305     if (index >= This->typelib_header.nrtypeinfos) {
4306         return TYPE_E_ELEMENTNOTFOUND;
4307     }
4308
4309     *pTKind = (This->typelib_segment_data[MSFT_SEG_TYPEINFO][This->typelib_typeinfo_offsets[index]]) & 15;
4310
4311     return S_OK;
4312 }
4313
4314 /******************************************************************************
4315  * ITypeLib2_GetTypeInfoOfGuid {OLEAUT32}
4316  *
4317  *  See ITypeLib_GetTypeInfoOfGuid.
4318  */
4319 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoOfGuid(
4320         ITypeLib2 * iface,
4321         REFGUID guid,
4322         ITypeInfo** ppTinfo)
4323 {
4324     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4325
4326     int guidoffset;
4327     int typeinfo;
4328
4329     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(guid), ppTinfo);
4330
4331     guidoffset = ctl2_find_guid(This, ctl2_hash_guid(guid), guid);
4332     if (guidoffset == -1) return TYPE_E_ELEMENTNOTFOUND;
4333
4334     typeinfo = ((MSFT_GuidEntry *)&This->typelib_segment_data[MSFT_SEG_GUID][guidoffset])->hreftype;
4335     if (typeinfo < 0) return TYPE_E_ELEMENTNOTFOUND;
4336
4337     return ctl2_find_typeinfo_from_offset(This, typeinfo, ppTinfo);
4338 }
4339
4340 /******************************************************************************
4341  * ITypeLib2_GetLibAttr {OLEAUT32}
4342  *
4343  *  See ITypeLib_GetLibAttr.
4344  */
4345 static HRESULT WINAPI ITypeLib2_fnGetLibAttr(
4346         ITypeLib2 * iface,
4347         TLIBATTR** ppTLibAttr)
4348 {
4349     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4350
4351     TRACE("(%p,%p)\n", This, ppTLibAttr);
4352
4353     if(!ppTLibAttr)
4354         return E_INVALIDARG;
4355
4356     *ppTLibAttr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(TLIBATTR));
4357     if(!*ppTLibAttr)
4358         return E_OUTOFMEMORY;
4359
4360     if(This->typelib_header.posguid != -1) {
4361         MSFT_GuidEntry *guid;
4362
4363         guid = (MSFT_GuidEntry*)&This->typelib_segment_data[MSFT_SEG_GUID][This->typelib_header.posguid];
4364         (*ppTLibAttr)->guid = guid->guid;
4365     }
4366
4367     (*ppTLibAttr)->lcid = This->typelib_header.lcid;
4368     (*ppTLibAttr)->syskind = This->typelib_header.varflags&0x3;
4369     (*ppTLibAttr)->wMajorVerNum = This->typelib_header.version&0xffff;
4370     (*ppTLibAttr)->wMinorVerNum = This->typelib_header.version>>16;
4371     (*ppTLibAttr)->wLibFlags = This->typelib_header.flags;
4372     return S_OK;
4373 }
4374
4375 /******************************************************************************
4376  * ITypeLib2_GetTypeComp {OLEAUT32}
4377  *
4378  *  See ITypeLib_GetTypeComp.
4379  */
4380 static HRESULT WINAPI ITypeLib2_fnGetTypeComp(
4381         ITypeLib2 * iface,
4382         ITypeComp** ppTComp)
4383 {
4384     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4385
4386     FIXME("(%p,%p), stub!\n", This, ppTComp);
4387
4388     return E_OUTOFMEMORY;
4389 }
4390
4391 /******************************************************************************
4392  * ITypeLib2_GetDocumentation {OLEAUT32}
4393  *
4394  *  See ITypeLib_GetDocumentation.
4395  */
4396 static HRESULT WINAPI ITypeLib2_fnGetDocumentation(
4397         ITypeLib2 * iface,
4398         INT index,
4399         BSTR* pBstrName,
4400         BSTR* pBstrDocString,
4401         DWORD* pdwHelpContext,
4402         BSTR* pBstrHelpFile)
4403 {
4404     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4405     WCHAR *string;
4406
4407     TRACE("(%p,%d,%p,%p,%p,%p)\n", This, index, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
4408
4409     if(index != -1) {
4410         ICreateTypeInfo2Impl *iter;
4411
4412         for(iter=This->typeinfos; iter!=NULL && index!=0; iter=iter->next_typeinfo)
4413             index--;
4414
4415         if(!iter)
4416             return TYPE_E_ELEMENTNOTFOUND;
4417
4418         return ITypeInfo_GetDocumentation((ITypeInfo*)iter->lpVtblTypeInfo2,
4419                 -1, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
4420     }
4421
4422     if(pBstrName) {
4423         if(This->typelib_header.NameOffset == -1)
4424             *pBstrName = NULL;
4425         else {
4426             MSFT_NameIntro *name = (MSFT_NameIntro*)&This->
4427                 typelib_segment_data[MSFT_SEG_NAME][This->typelib_header.NameOffset];
4428
4429             ctl2_decode_name((char*)&name->namelen, &string);
4430
4431             *pBstrName = SysAllocString(string);
4432             if(!*pBstrName)
4433                 return E_OUTOFMEMORY;
4434         }
4435     }
4436
4437     if(pBstrDocString) {
4438         if(This->typelib_header.helpstring == -1)
4439             *pBstrDocString = NULL;
4440         else {
4441             ctl2_decode_string(&This->typelib_segment_data[MSFT_SEG_STRING][This->typelib_header.helpstring], &string);
4442
4443             *pBstrDocString = SysAllocString(string);
4444             if(!*pBstrDocString) {
4445                 if(pBstrName) SysFreeString(*pBstrName);
4446                 return E_OUTOFMEMORY;
4447             }
4448         }
4449     }
4450
4451     if(pdwHelpContext)
4452         *pdwHelpContext = This->typelib_header.helpcontext;
4453
4454     if(pBstrHelpFile) {
4455         if(This->typelib_header.helpfile == -1)
4456             *pBstrHelpFile = NULL;
4457         else {
4458             ctl2_decode_string(&This->typelib_segment_data[MSFT_SEG_STRING][This->typelib_header.helpfile], &string);
4459
4460             *pBstrHelpFile = SysAllocString(string);
4461             if(!*pBstrHelpFile) {
4462                 if(pBstrName) SysFreeString(*pBstrName);
4463                 if(pBstrDocString) SysFreeString(*pBstrDocString);
4464                 return E_OUTOFMEMORY;
4465             }
4466         }
4467     }
4468
4469     return S_OK;
4470 }
4471
4472 /******************************************************************************
4473  * ITypeLib2_IsName {OLEAUT32}
4474  *
4475  *  See ITypeLib_IsName.
4476  */
4477 static HRESULT WINAPI ITypeLib2_fnIsName(
4478         ITypeLib2 * iface,
4479         LPOLESTR szNameBuf,
4480         ULONG lHashVal,
4481         BOOL* pfName)
4482 {
4483     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4484
4485     char *encoded_name;
4486     int nameoffset;
4487     MSFT_NameIntro *nameintro;
4488
4489     TRACE("(%p,%s,%x,%p)\n", iface, debugstr_w(szNameBuf), lHashVal, pfName);
4490
4491     ctl2_encode_name(This, szNameBuf, &encoded_name);
4492     nameoffset = ctl2_find_name(This, encoded_name);
4493
4494     *pfName = 0;
4495
4496     if (nameoffset == -1) return S_OK;
4497
4498     nameintro = (MSFT_NameIntro *)(&This->typelib_segment_data[MSFT_SEG_NAME][nameoffset]);
4499     if (nameintro->hreftype == -1) return S_OK;
4500
4501     *pfName = 1;
4502
4503     FIXME("Should be decoding our copy of the name over szNameBuf.\n");
4504
4505     return S_OK;
4506 }
4507
4508 /******************************************************************************
4509  * ITypeLib2_FindName {OLEAUT32}
4510  *
4511  *  See ITypeLib_FindName.
4512  */
4513 static HRESULT WINAPI ITypeLib2_fnFindName(
4514         ITypeLib2 * iface,
4515         LPOLESTR szNameBuf,
4516         ULONG lHashVal,
4517         ITypeInfo** ppTInfo,
4518         MEMBERID* rgMemId,
4519         USHORT* pcFound)
4520 {
4521     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4522
4523     FIXME("(%p,%s,%x,%p,%p,%p), stub!\n", This, debugstr_w(szNameBuf), lHashVal, ppTInfo, rgMemId, pcFound);
4524
4525     return E_OUTOFMEMORY;
4526 }
4527
4528 /******************************************************************************
4529  * ITypeLib2_ReleaseTLibAttr {OLEAUT32}
4530  *
4531  *  See ITypeLib_ReleaseTLibAttr.
4532  */
4533 static void WINAPI ITypeLib2_fnReleaseTLibAttr(
4534         ITypeLib2 * iface,
4535         TLIBATTR* pTLibAttr)
4536 {
4537     TRACE("(%p,%p)\n", iface, pTLibAttr);
4538
4539     HeapFree(GetProcessHeap(), 0, pTLibAttr);
4540 }
4541
4542 /******************************************************************************
4543  * ICreateTypeLib2_GetCustData {OLEAUT32}
4544  *
4545  *  Retrieves a custom data value stored on a type library.
4546  *
4547  * RETURNS
4548  *
4549  *  Success: S_OK
4550  *  Failure: E_OUTOFMEMORY or E_INVALIDARG.
4551  */
4552 static HRESULT WINAPI ITypeLib2_fnGetCustData(
4553         ITypeLib2 * iface, /* [I] The type library in which to find the custom data. */
4554         REFGUID guid,      /* [I] The GUID under which the custom data is stored. */
4555         VARIANT* pVarVal)  /* [O] The custom data. */
4556 {
4557     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4558
4559     FIXME("(%p,%s,%p), stub!\n", This, debugstr_guid(guid), pVarVal);
4560
4561     return E_OUTOFMEMORY;
4562 }
4563
4564 /******************************************************************************
4565  * ICreateTypeLib2_GetLibStatistics {OLEAUT32}
4566  *
4567  *  Retrieves some statistics about names in a type library, supposedly for
4568  *  hash table optimization purposes.
4569  *
4570  * RETURNS
4571  *
4572  *  Success: S_OK
4573  *  Failure: E_OUTOFMEMORY or E_INVALIDARG.
4574  */
4575 static HRESULT WINAPI ITypeLib2_fnGetLibStatistics(
4576         ITypeLib2 * iface,      /* [I] The type library to get statistics about. */
4577         ULONG* pcUniqueNames,   /* [O] The number of unique names in the type library. */
4578         ULONG* pcchUniqueNames) /* [O] The number of changed (?) characters in names in the type library. */
4579 {
4580     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4581
4582     FIXME("(%p,%p,%p), stub!\n", This, pcUniqueNames, pcchUniqueNames);
4583
4584     return E_OUTOFMEMORY;
4585 }
4586
4587 /******************************************************************************
4588  * ICreateTypeLib2_GetDocumentation2 {OLEAUT32}
4589  *
4590  *  Obtain locale-aware help string information.
4591  *
4592  * RETURNS
4593  *
4594  *  Success: S_OK
4595  *  Failure: STG_E_INSUFFICIENTMEMORY or E_INVALIDARG.
4596  */
4597 static HRESULT WINAPI ITypeLib2_fnGetDocumentation2(
4598         ITypeLib2 * iface,
4599         INT index,
4600         LCID lcid,
4601         BSTR* pbstrHelpString,
4602         DWORD* pdwHelpStringContext,
4603         BSTR* pbstrHelpStringDll)
4604 {
4605     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4606
4607     FIXME("(%p,%d,%d,%p,%p,%p), stub!\n", This, index, lcid, pbstrHelpString, pdwHelpStringContext, pbstrHelpStringDll);
4608
4609     return E_OUTOFMEMORY;
4610 }
4611
4612 /******************************************************************************
4613  * ICreateTypeLib2_GetAllCustData {OLEAUT32}
4614  *
4615  *  Retrieve all of the custom data for a type library.
4616  *
4617  * RETURNS
4618  *
4619  *  Success: S_OK
4620  *  Failure: E_OUTOFMEMORY or E_INVALIDARG.
4621  */
4622 static HRESULT WINAPI ITypeLib2_fnGetAllCustData(
4623         ITypeLib2 * iface,   /* [I] The type library in which to find the custom data. */
4624         CUSTDATA* pCustData) /* [O] The structure in which to place the custom data. */
4625 {
4626     ICreateTypeLib2Impl *This = impl_from_ITypeLib2(iface);
4627
4628     FIXME("(%p,%p), stub!\n", This, pCustData);
4629
4630     return E_OUTOFMEMORY;
4631 }
4632
4633
4634 /*================== ICreateTypeLib2 & ITypeLib2 VTABLEs And Creation ===================================*/
4635
4636 static const ICreateTypeLib2Vtbl ctypelib2vt =
4637 {
4638
4639     ICreateTypeLib2_fnQueryInterface,
4640     ICreateTypeLib2_fnAddRef,
4641     ICreateTypeLib2_fnRelease,
4642
4643     ICreateTypeLib2_fnCreateTypeInfo,
4644     ICreateTypeLib2_fnSetName,
4645     ICreateTypeLib2_fnSetVersion,
4646     ICreateTypeLib2_fnSetGuid,
4647     ICreateTypeLib2_fnSetDocString,
4648     ICreateTypeLib2_fnSetHelpFileName,
4649     ICreateTypeLib2_fnSetHelpContext,
4650     ICreateTypeLib2_fnSetLcid,
4651     ICreateTypeLib2_fnSetLibFlags,
4652     ICreateTypeLib2_fnSaveAllChanges,
4653
4654     ICreateTypeLib2_fnDeleteTypeInfo,
4655     ICreateTypeLib2_fnSetCustData,
4656     ICreateTypeLib2_fnSetHelpStringContext,
4657     ICreateTypeLib2_fnSetHelpStringDll
4658 };
4659
4660 static const ITypeLib2Vtbl typelib2vt =
4661 {
4662
4663     ITypeLib2_fnQueryInterface,
4664     ITypeLib2_fnAddRef,
4665     ITypeLib2_fnRelease,
4666
4667     ITypeLib2_fnGetTypeInfoCount,
4668     ITypeLib2_fnGetTypeInfo,
4669     ITypeLib2_fnGetTypeInfoType,
4670     ITypeLib2_fnGetTypeInfoOfGuid,
4671     ITypeLib2_fnGetLibAttr,
4672     ITypeLib2_fnGetTypeComp,
4673     ITypeLib2_fnGetDocumentation,
4674     ITypeLib2_fnIsName,
4675     ITypeLib2_fnFindName,
4676     ITypeLib2_fnReleaseTLibAttr,
4677
4678     ITypeLib2_fnGetCustData,
4679     ITypeLib2_fnGetLibStatistics,
4680     ITypeLib2_fnGetDocumentation2,
4681     ITypeLib2_fnGetAllCustData,
4682 };
4683
4684 static ICreateTypeLib2 *ICreateTypeLib2_Constructor(SYSKIND syskind, LPCOLESTR szFile)
4685 {
4686     ICreateTypeLib2Impl *pCreateTypeLib2Impl;
4687     int failed = 0;
4688
4689     TRACE("Constructing ICreateTypeLib2 (%d, %s)\n", syskind, debugstr_w(szFile));
4690
4691     pCreateTypeLib2Impl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ICreateTypeLib2Impl));
4692     if (!pCreateTypeLib2Impl) return NULL;
4693
4694     pCreateTypeLib2Impl->filename = HeapAlloc(GetProcessHeap(), 0, (strlenW(szFile) + 1) * sizeof(WCHAR));
4695     if (!pCreateTypeLib2Impl->filename) {
4696         HeapFree(GetProcessHeap(), 0, pCreateTypeLib2Impl);
4697         return NULL;
4698     }
4699     strcpyW(pCreateTypeLib2Impl->filename, szFile);
4700
4701     ctl2_init_header(pCreateTypeLib2Impl);
4702     ctl2_init_segdir(pCreateTypeLib2Impl);
4703
4704     pCreateTypeLib2Impl->typelib_header.varflags |= syskind;
4705
4706     /*
4707      * The following two calls return an offset or -1 if out of memory. We
4708      * specifically need an offset of 0, however, so...
4709      */
4710     if (ctl2_alloc_segment(pCreateTypeLib2Impl, MSFT_SEG_GUIDHASH, 0x80, 0x80)) { failed = 1; }
4711     if (ctl2_alloc_segment(pCreateTypeLib2Impl, MSFT_SEG_NAMEHASH, 0x200, 0x200)) { failed = 1; }
4712
4713     pCreateTypeLib2Impl->typelib_guidhash_segment = (int *)pCreateTypeLib2Impl->typelib_segment_data[MSFT_SEG_GUIDHASH];
4714     pCreateTypeLib2Impl->typelib_namehash_segment = (int *)pCreateTypeLib2Impl->typelib_segment_data[MSFT_SEG_NAMEHASH];
4715
4716     memset(pCreateTypeLib2Impl->typelib_guidhash_segment, 0xff, 0x80);
4717     memset(pCreateTypeLib2Impl->typelib_namehash_segment, 0xff, 0x200);
4718
4719     pCreateTypeLib2Impl->lpVtbl = &ctypelib2vt;
4720     pCreateTypeLib2Impl->lpVtblTypeLib2 = &typelib2vt;
4721     pCreateTypeLib2Impl->ref = 1;
4722
4723     if (failed) {
4724         ICreateTypeLib2_fnRelease((ICreateTypeLib2 *)pCreateTypeLib2Impl);
4725         return 0;
4726     }
4727
4728     return (ICreateTypeLib2 *)pCreateTypeLib2Impl;
4729 }
4730
4731 /******************************************************************************
4732  * CreateTypeLib2 [OLEAUT32.180]
4733  *
4734  *  Obtains an ICreateTypeLib2 object for creating a new-style (MSFT) type
4735  *  library.
4736  *
4737  * NOTES
4738  *
4739  *  See also CreateTypeLib.
4740  *
4741  * RETURNS
4742  *    Success: S_OK
4743  *    Failure: Status
4744  */
4745 HRESULT WINAPI CreateTypeLib2(
4746         SYSKIND syskind,           /* [I] System type library is for */
4747         LPCOLESTR szFile,          /* [I] Type library file name */
4748         ICreateTypeLib2** ppctlib) /* [O] Storage for object returned */
4749 {
4750     TRACE("(%d,%s,%p)\n", syskind, debugstr_w(szFile), ppctlib);
4751
4752     if (!szFile) return E_INVALIDARG;
4753     *ppctlib = ICreateTypeLib2_Constructor(syskind, szFile);
4754     return (*ppctlib)? S_OK: E_OUTOFMEMORY;
4755 }
4756
4757 /******************************************************************************
4758  * ClearCustData (OLEAUT32.171)
4759  *
4760  * Clear a custom data types' data.
4761  *
4762  * PARAMS
4763  *  lpCust [I] The custom data type instance
4764  *
4765  * RETURNS
4766  *  Nothing.
4767  */
4768 void WINAPI ClearCustData(LPCUSTDATA lpCust)
4769 {
4770     if (lpCust && lpCust->cCustData)
4771     {
4772         if (lpCust->prgCustData)
4773         {
4774             DWORD i;
4775
4776             for (i = 0; i < lpCust->cCustData; i++)
4777                 VariantClear(&lpCust->prgCustData[i].varValue);
4778
4779             /* FIXME - Should be using a per-thread IMalloc */
4780             HeapFree(GetProcessHeap(), 0, lpCust->prgCustData);
4781             lpCust->prgCustData = NULL;
4782         }
4783         lpCust->cCustData = 0;
4784     }
4785 }