tools/widl/typelib_struct.h

   1 /*
   2  * typelib_struct.h  internal wine data structures
   3  * used to decode typelib's
   4  *
   5  * Copyright 1999 Rein KLazes
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21 #ifndef _WIDL_TYPELIB_STRUCT_H
  22 #define _WIDL_TYPELIB_STRUCT_H
  23
  24 #define HELPDLLFLAG (0x0100)
  25 #define DO_NOT_SEEK (-1)
  26
  27 #define MSFT_HREFTYPE_INTHISFILE(href) (!((href) & 3))
  28 #define MSFT_HREFTYPE_INDEX(href) ((href) /sizeof(MSFT_TypeInfoBase))
  29
  30 /*-------------------------FILE STRUCTURES-----------------------------------*/
  31
  32 /* There are two known file formats, those created with ICreateTypeLib
  33  * have the signature "SLTG" as their first four bytes, while those created
  34  * with ICreateTypeLib2 have "MSFT".
  35  */
  36
  37 #define MSFT_MAGIC 0x5446534d
  38
  39 /*****************************************************
  40  *                MSFT typelibs
  41  *
  42  * These are TypeLibs created with ICreateTypeLib2
  43  *
  44  */
  45
  46 /*
  47  * structure of the typelib type2 header
  48  * it is at the beginning of a type lib file
  49  *
  50  */
  51 typedef struct tagMSFT_Header {
  52 /*0x00*/int   magic1;       /* 0x5446534D "MSFT" */
  53         int   magic2;       /* 0x00010002 version nr? */
  54         int   posguid;      /* position of libid in guid table  */
  55                             /* (should be,  else -1) */
  56         int   lcid;         /* locale id */
  57 /*0x10*/int   lcid2;
  58         int   varflags;     /* (largely) unknown flags */
  59                             /* the lower nibble is syskind */
  60                             /* 0x40 always seems to be set */
  61                             /* 0x10 set with a helpfile defined */
  62                             /* 0x100 set with a helpstringdll defined - in this
  63                                   case the offset to the name in the stringtable
  64                                   appears right after this struct, before the
  65                                   typeinfo offsets */
  66         int   version;      /* set with SetVersion() */
  67         int   flags;        /* set with SetFlags() */
  68 /*0x20*/int   nrtypeinfos;  /* number of typeinfo's (till so far) */
  69         int   helpstring;   /* position of help string in stringtable */
  70         int   helpstringcontext;
  71         int   helpcontext;
  72 /*0x30*/int   nametablecount;   /* number of names in name table */
  73         int   nametablechars;   /* nr of characters in name table */
  74         int   NameOffset;       /* offset of name in name table */
  75         int   helpfile;         /* position of helpfile in stringtable */
  76 /*0x40*/int   CustomDataOffset; /* if -1 no custom data, else it is offset */
  77                                 /* in customer data/guid offset table */
  78         int   res44;            /* unknown always: 0x20 (guid hash size?) */
  79         int   res48;            /* unknown always: 0x80 (name hash size?) */
  80         int   dispatchpos;      /* HREFTYPE to IDispatch, or -1 if no IDispatch */
  81 /*0x50*/int   nimpinfos;        /* number of impinfos */
  82 } MSFT_Header;
  83
  84 /* segments in the type lib file have a structure like this: */
  85 typedef struct tagMSFT_pSeg {
  86         int   offset;       /* absolute offset in file */
  87         int   length;       /* length of segment */
  88         int   res08;        /* unknown always -1 */
  89         int   res0c;        /* unknown always 0x0f in the header */
  90                             /* 0x03 in the typeinfo_data */
  91 } MSFT_pSeg;
  92
  93 /* layout of the main segment directory */
  94 typedef struct tagMSFT_SegDir {
  95 /*1*/MSFT_pSeg pTypeInfoTab; /* each typeinfo gets an entry of 0x64 bytes */
  96                              /* (25 ints) */
  97 /*2*/MSFT_pSeg pImpInfo;     /* table with info for imported types */
  98 /*3*/MSFT_pSeg pImpFiles;    /* import libraries */
  99 /*4*/MSFT_pSeg pRefTab;      /* References table */
 100 /*5*/MSFT_pSeg pGuidHashTab; /* always exists, always same size (0x80) */
 101                              /* hash table with offsets to guid */
 102 /*6*/MSFT_pSeg pGuidTab;     /* all guids are stored here together with  */
 103                              /* offset in some table???? */
 104 /*7*/MSFT_pSeg pNameHashTab; /* always created, always same size (0x200) */
 105                              /* hash table with offsets to names */
 106 /*8*/MSFT_pSeg pNametab;     /* name tables */
 107 /*9*/MSFT_pSeg pStringtab;   /* string table */
 108 /*A*/MSFT_pSeg pTypdescTab;  /* table with type descriptors */
 109 /*B*/MSFT_pSeg pArrayDescriptions;
 110 /*C*/MSFT_pSeg pCustData;    /* data table, used for custom data and default */
 111                              /* parameter values */
 112 /*D*/MSFT_pSeg pCDGuids;     /* table with offsets for the guids and into */
 113                              /* the customer data table */
 114 /*E*/MSFT_pSeg res0e;        /* unknown */
 115 /*F*/MSFT_pSeg res0f;        /* unknown  */
 116 } MSFT_SegDir;
 117
 118
 119 /* base type info data */
 120 typedef struct tagMSFT_TypeInfoBase {
 121 /*000*/ int   typekind;             /*  it is the TKIND_xxx */
 122                                     /* some byte alignment stuff */
 123         int     memoffset;          /* points past the file, if no elements */
 124         int     res2;               /* zero if no element, N*0x40 */
 125         int     res3;               /* -1 if no element, (N-1)*0x38 */
 126 /*010*/ int     res4;               /* always? 3 */
 127         int     res5;               /* always? zero */
 128         int     cElement;           /* counts elements, HI=cVars, LO=cFuncs */
 129         int     res7;               /* always? zero */
 130 /*020*/ int     res8;               /* always? zero */
 131         int     res9;               /* always? zero */
 132         int     resA;               /* always? zero */
 133         int     posguid;            /* position in guid table */
 134 /*030*/ int     flags;              /* Typeflags */
 135         int     NameOffset;         /* offset in name table */
 136         int     version;            /* element version */
 137         int     docstringoffs;      /* offset of docstring in string tab */
 138 /*040*/ int     helpstringcontext;  /*  */
 139         int     helpcontext;    /* */
 140         int     oCustData;          /* offset in customer data table */
 141         short   cImplTypes;     /* nr of implemented interfaces */
 142         short   cbSizeVft;      /* virtual table size, including inherits */
 143 /*050*/ int     size;           /* size in bytes, at least for structures */
 144         /* FIXME: name of this field */
 145         int     datatype1;      /* position in type description table */
 146                                 /* or in base interfaces */
 147                                 /* if coclass: offset in reftable */
 148                                 /* if interface: reference to inherited if */
 149         int     datatype2;      /* for interfaces: hiword is num of inherited funcs */
 150                                 /*                 loword is num of inherited interfaces */
 151         int     res18;          /* always? 0 */
 152 /*060*/ int     res19;          /* always? -1 */
 153 } MSFT_TypeInfoBase;
 154
 155 /* layout of an entry with information on imported types */
 156 typedef struct tagMSFT_ImpInfo {
 157     int     flags;          /* bits 0 - 15:  count */
 158                             /* bit  16:      if set oGuid is an offset to Guid */
 159                             /*               if clear oGuid is a typeinfo index in the specified typelib */
 160                             /* bits 24 - 31: TKIND of reference */
 161     int     oImpFile;       /* offset in the Import File table */
 162     int     oGuid;          /* offset in Guid table or typeinfo index (see bit 16 of flags) */
 163 } MSFT_ImpInfo;
 164
 165 #define MSFT_IMPINFO_OFFSET_IS_GUID 0x00010000
 166
 167 /* function description data */
 168 typedef struct {
 169 /*  int   recsize;       record size including some extra stuff */
 170     int   DataType;     /* data type of the member, eg return of function */
 171     int   Flags;        /* something to do with attribute flags (LOWORD) */
 172     short VtableOffset; /* offset in vtable */
 173     short funcdescsize; /* size of reconstituted FUNCDESC and related structs */
 174     int   FKCCIC;       /* bit string with the following  */
 175                         /* meaning (bit 0 is the lsb): */
 176                         /* bits 0 - 2: FUNCKIND */
 177                         /* bits 3 - 6: INVOKEKIND */
 178                         /* bit  7: custom data present */
 179                         /* bits 8 - 11: CALLCONV */
 180                         /* bit  12: parameters have default values */
 181                         /* bit  13: oEntry is numeric */
 182                         /* bit  14: has retval param */
 183                         /* bits 16 - 31: index of next function with same id */
 184     short nrargs;       /* number of arguments (including optional ????) */
 185     short nroargs;      /* nr of optional arguments */
 186     /* optional attribute fields, the number of them is variable */
 187     int   OptAttr[1];
 188 /*
 189 0*  int   helpcontext;
 190 1*  int   oHelpString;
 191 2*  int   oEntry;       // either offset in string table or numeric as it is (see bit 13 of FKCCIC) //
 192 3*  int   res9;         // unknown (-1) //
 193 4*  int   resA;         // unknown (-1) //
 194 5*  int   HelpStringContext;
 195     // these are controlled by a bit set in the FKCCIC field  //
 196 6*  int   oCustData;        // custom data for function //
 197 7*  int   oArgCustData[1];  // custom data per argument //
 198 */
 199 } MSFT_FuncRecord;
 200
 201 /* after this may follow an array with default value pointers if the
 202  * appropriate bit in the FKCCIC field has been set:
 203  * int   oDefaultValue[nrargs];
 204  */
 205
 206     /* Parameter info one per argument*/
 207 typedef struct {
 208         int   DataType;
 209         int   oName;
 210         int   Flags;
 211     } MSFT_ParameterInfo;
 212
 213 /* Variable description data */
 214 typedef struct {
 215 /*  int   recsize;      // record size including some extra stuff */
 216     int   DataType;     /* data type of the variable */
 217     int   Flags;        /* VarFlags (LOWORD) */
 218     short VarKind;      /* VarKind */
 219     short vardescsize;  /* size of reconstituted VARDESC and related structs */
 220     int   OffsValue;    /* value of the variable or the offset  */
 221                         /* in the data structure */
 222     /* optional attribute fields, the number of them is variable */
 223     /* controlled by record length */
 224     int   HelpContext;
 225     int   oHelpString;
 226     int   res9;         /* unknown (-1) */
 227     int   oCustData;        /* custom data for variable */
 228     int   HelpStringContext;
 229
 230 } MSFT_VarRecord;
 231
 232 /* Structure of the reference data  */
 233 typedef struct {
 234     int   reftype;  /* either offset in type info table, then it's */
 235                     /* a multiple of 64 */
 236                     /* or offset in the external reference table */
 237                     /* with an offset of 1 */
 238     int   flags;
 239     int   oCustData;    /* custom data */
 240     int   onext;    /* next offset, -1 if last */
 241 } MSFT_RefRecord;
 242
 243 /* this is how a guid is stored */
 244 typedef struct {
 245     struct uuid guid;
 246     int   hreftype;     /* -2 for the typelib guid, typeinfo offset
 247                            for typeinfo guid, low two bits are 01 if
 248                            this is an imported typeinfo, low two bits
 249                            are 10 if this is an imported typelib (used
 250                            by imported typeinfos) */
 251     int   next_hash;    /* offset to next guid in the hash bucket */
 252 } MSFT_GuidEntry;
 253 /* some data preceding entries in the name table */
 254 typedef struct {
 255     int   hreftype;     /* is -1 if name is for neither a typeinfo,
 256                            a variable, or a function (that is, name
 257                            is for a typelib or a function parameter).
 258                            otherwise is the offset of the first
 259                            typeinfo that this name refers to (either
 260                            to the typeinfo itself or to a member of
 261                            the typeinfo */
 262     int   next_hash;    /* offset to next name in the hash bucket */
 263     int   namelen;      /* only lower 8 bits are valid */
 264                         /* 0x1000 if name is only used once as a variable name */
 265                         /* 0x2000 if name is a variable in an enumeration */
 266                         /* 0x3800 if name is typeinfo name */
 267                         /* upper 16 bits are hash code */
 268 } MSFT_NameIntro;
 269 /* the custom data table directory has entries like this */
 270 typedef struct {
 271     int   GuidOffset;
 272     int   DataOffset;
 273     int   next;     /* next offset in the table, -1 if it's the last */
 274 } MSFT_CDGuid;
 275
 276
 277 /***********************************************************
 278  *
 279  *                SLTG typelibs.
 280  *
 281  * These are created with ICreateTypeLib
 282  *
 283  */
 284
 285 #include "pshpack1.h"
 286
 287 typedef struct {
 288 /*00*/  unsigned int   SLTG_magic;      /* 0x47544c53  == "SLTG" */
 289 /*04*/  unsigned short nrOfFileBlks;    /* no of SLTG_BlkEntry's + 1 */
 290 /*06*/  unsigned short res06;           /* ?? always 9 */
 291 /*08*/  unsigned short res08;           /* some kind of len/offset ?? */
 292 /*0a*/  unsigned short first_blk;       /* 1 based index into blk entries that
 293                                            corresponds to first block in file */
 294 /*0c*/  unsigned int   res0c;           /* always 0x000204ff */
 295 /*10*/  unsigned int   res10;           /* always 0x00000000 */
 296 /*14*/  unsigned int   res14;           /* always 0x000000c0 */
 297 /*18*/  unsigned int   res18;           /* always 0x46000000 */
 298 /*1c*/  unsigned int   res1c;           /* always 0x00000044 */
 299 /*20*/  unsigned int   res20;           /* always 0xffff0000 */
 300 } SLTG_Header;
 301
 302 /* This gets followed by a list of block entries */
 303 typedef struct {
 304 /*00*/  unsigned int len;
 305 /*04*/  unsigned short index_string; /* offs from start of SLTG_Magic to index string */
 306 /*06*/  unsigned short next;
 307 } SLTG_BlkEntry;
 308
 309 /* The order of the blocks in the file is given by starting at Block
 310    entry first_blk and stepping through using the next pointer */
 311
 312 /* These then get followed by this magic */
 313 typedef struct {
 314 /*00*/ unsigned char res00;             /* always 0x01 */
 315 /*01*/ char          CompObj_magic[8];  /* always "CompObj" */
 316 /*09*/ char          dir_magic[4];      /* always "dir" */
 317 } SLTG_Magic;
 318
 319 #define SLTG_COMPOBJ_MAGIC "CompObj"
 320 #define SLTG_DIR_MAGIC "dir"
 321
 322 /* Next we have SLTG_Header.nrOfFileBlks - 2 of Index strings.  These
 323 are presumably unique to within the file and look something like
 324 "AAAAAAAAAA" with the first character incremented from 'A' to ensure
 325 uniqueness.  I guess successive chars increment when we need to wrap
 326 the first one. */
 327
 328 typedef struct {
 329 /*00*/ char string[11];
 330 } SLTG_Index;
 331
 332
 333 /* This is followed by SLTG_pad9 */
 334 typedef struct {
 335 /*00*/ char pad[9];     /* 9 '\0's */
 336 } SLTG_Pad9;
 337
 338
 339 /* Now we have the noOfFileBlks - 1 worth of blocks. The length of
 340 each block is given by its entry in SLTG_BlkEntry. */
 341
 342 /* type SLTG_NAME in rather like a BSTR except that the length in
 343 bytes is given by the first WORD and the string contains 8bit chars */
 344
 345 typedef unsigned short SLTG_Name;
 346
 347 /* The main library block looks like this.  This one seems to come last */
 348
 349 typedef struct {
 350 /*00*/  unsigned short magic;           /* 0x51cc */
 351 /*02*/  unsigned short res02;           /* 0x0003, 0x0004 */
 352 /*04*/  unsigned short name;            /* offset to name in name table */
 353 /*06*/  SLTG_Name      res06;           /* maybe this is just WORD == 0xffff */
 354         SLTG_Name      helpstring;
 355         SLTG_Name      helpfile;
 356         unsigned int   helpcontext;
 357         unsigned short syskind;         /* == 1 for win32, 0 for win16 */
 358         unsigned short lcid;            /* == 0x409, 0x809 etc */
 359         unsigned int   res12;           /* == 0 */
 360         unsigned short libflags;        /* LIBFLAG_* */
 361         unsigned short maj_vers;
 362         unsigned short min_vers;
 363         struct uuid uuid;
 364 } SLTG_LibBlk;
 365
 366 #define SLTG_LIBBLK_MAGIC 0x51cc
 367
 368 /* we then get 0x40 bytes worth of 0xffff or small numbers followed by
 369    nrOfFileBlks - 2 of these */
 370 typedef struct {
 371     unsigned short small_no;
 372     SLTG_Name      index_name; /* This refers to a name in the directory */
 373     SLTG_Name      other_name; /* Another one of these weird names */
 374     unsigned short res1a;          /* 0xffff */
 375     unsigned short name_offs;  /* offset to name in name table */
 376     unsigned short more_bytes; /* if this is non-zero we get this many
 377                                   bytes before the next element, which seem
 378                                   to reference the docstring of the type ? */
 379     unsigned short res20;      /* 0xffff */
 380     unsigned int   helpcontext;
 381     unsigned short res26;      /* 0xffff */
 382     struct uuid uuid;
 383 } SLTG_OtherTypeInfo;
 384
 385 /* Next we get WORD 0x0003 followed by a DWORD which if we add to
 386 0x216 gives the offset to the name table from the start of the LibBlk
 387 struct */
 388
 389 typedef struct {
 390 /*00*/  unsigned short magic;           /* 0x0501 */
 391 /*02*/  unsigned int   href_table;      /* if not 0xffffffff, then byte offset from
 392                                            beginning of struct to href table */
 393 /*06*/  unsigned int   res06;           /* 0xffffffff */
 394 /*0a*/  unsigned int   elem_table;      /* offset to members */
 395 /*0e*/  unsigned int   res0e;           /* 0xffffffff */
 396 /*12*/  unsigned short major_version;   /* major version number */
 397 /*14*/  unsigned short minor_version;   /* minor version number */
 398 /*16*/  unsigned int   res16;   /* 0xfffe0000 */
 399 /*1a*/  unsigned char typeflags1;/* 0x02 | top 5 bits hold l5sbs of TYPEFLAGS */
 400 /*1b*/  unsigned char typeflags2;/* TYPEFLAGS >> 5 */
 401 /*1c*/  unsigned char typeflags3;/* 0x02*/
 402 /*1d*/  unsigned char typekind; /* 0x03 == TKIND_INTERFACE etc. */
 403 /*1e*/  unsigned int   res1e;   /* 0x00000000 or 0xffffffff */
 404 } SLTG_TypeInfoHeader;
 405
 406 #define SLTG_TIHEADER_MAGIC 0x0501
 407
 408 typedef struct {
 409 /*00*/  unsigned short cFuncs;
 410 /*02*/  unsigned short cVars;
 411 /*04*/  unsigned short cImplTypes;
 412 /*06*/  unsigned short res06;
 413 /*08*/  unsigned short res08;
 414 /*0a*/  unsigned short res0a;
 415 /*0c*/  unsigned short res0c;
 416 /*0e*/  unsigned short res0e;
 417 /*10*/  unsigned short res10;
 418 /*12*/  unsigned short res12;
 419 /*14*/  unsigned short tdescalias_vt; /* for TKIND_ALIAS */
 420 /*16*/  unsigned short res16;
 421 /*18*/  unsigned short res18;
 422 /*1a*/  unsigned short res1a;
 423 /*1c*/  unsigned short res1c;
 424 /*1e*/  unsigned short res1e;
 425 /*20*/  unsigned short cbSizeInstance;
 426 /*22*/  unsigned short cbAlignment;
 427 /*24*/  unsigned short res24;
 428 /*26*/  unsigned short res26;
 429 /*28*/  unsigned short cbSizeVft;
 430 /*2a*/  unsigned short res2a;
 431 /*2c*/  unsigned short res2c;
 432 /*2e*/  unsigned short res2e;
 433 /*30*/  unsigned short res30;
 434 /*32*/  unsigned short res32;
 435 /*34*/  unsigned short res34;
 436 } SLTG_TypeInfoTail;
 437
 438 typedef struct {
 439 /*00*/ unsigned short res00; /* 0x0001 sometimes 0x0003 ?? */
 440 /*02*/ unsigned short res02; /* 0xffff */
 441 /*04*/ unsigned char res04; /* 0x01 */
 442 /*05*/ unsigned int cbExtra; /* No of bytes that follow */
 443 } SLTG_MemberHeader;
 444
 445 typedef struct {
 446 /*00*/  unsigned short magic;   /* 0x120a */
 447 /*02*/  unsigned short next;    /* offset in bytes to next block from start of block
 448                                    group, 0xffff if last item */
 449 /*04*/  unsigned short name;    /* offset to name within name table */
 450 /*06*/  unsigned short value;   /* offset to value from start of block group */
 451 /*08*/  unsigned short res08;   /* 0x56 */
 452 /*0a*/  unsigned int   memid;   /* memid */
 453 /*0e*/  unsigned short helpcontext;/* 0xfffe == no context, 0x0001 == stored in EnumInfo struct, else offset
 454                                     to value from start of block group */
 455 /*10*/  unsigned short helpstring;/* offset from start of block group to string offset */
 456 } SLTG_EnumItem;
 457
 458 #define SLTG_ENUMITEM_MAGIC 0x120a
 459
 460 typedef struct {
 461 /*00*/  unsigned short vt;      /* vartype, 0xffff marks end. */
 462 /*02*/  unsigned short res02;   /* ?, 0xffff marks end */
 463 } SLTG_AliasItem;
 464
 465 #define SLTG_ALIASITEM_MAGIC 0x001d
 466
 467
 468 typedef struct {
 469         unsigned char  magic;   /* 0x4c or 0x6c */
 470         unsigned char  inv;     /* high nibble is INVOKE_KIND, low nibble = 2 */
 471         unsigned short next;    /* byte offset from beginning of group to next fn */
 472         unsigned short name;    /* Offset within name table to name */
 473         unsigned int   dispid;  /* dispid */
 474         unsigned short helpcontext; /* helpcontext (again 1 is special) */
 475         unsigned short helpstring;/* helpstring offset to offset */
 476         unsigned short arg_off; /* offset to args from start of block */
 477         unsigned char  nacc;    /* lowest 3bits are CALLCONV, rest are no of args */
 478         unsigned char  retnextopt;/* if 0x80 bit set ret type follows else next WORD
 479                            is offset to ret type. No of optional args is
 480                            middle 6 bits */
 481         unsigned short rettype; /* return type VT_?? or offset to ret type */
 482         unsigned short vtblpos; /* position in vtbl? */
 483         unsigned short funcflags; /* present if magic == 0x6c */
 484 /* Param list starts, repeat next two as required */
 485 #if 0
 486         unsigned short name;    /* offset to 2nd letter of name */
 487         unsigned short+ type;   /* VT_ of param */
 488 #endif
 489 } SLTG_Function;
 490
 491 #define SLTG_FUNCTION_MAGIC 0x4c
 492 #define SLTG_FUNCTION_WITH_FLAGS_MAGIC 0x6c
 493
 494 typedef struct {
 495 /*00*/  unsigned char  magic;           /* 0xdf */
 496 /*01*/  unsigned char  res01;           /* 0x00 */
 497 /*02*/  unsigned int   res02;           /* 0xffffffff */
 498 /*06*/  unsigned int   res06;           /* 0xffffffff */
 499 /*0a*/  unsigned int   res0a;           /* 0xffffffff */
 500 /*0e*/  unsigned int   res0e;           /* 0xffffffff */
 501 /*12*/  unsigned int   res12;           /* 0xffffffff */
 502 /*16*/  unsigned int   res16;           /* 0xffffffff */
 503 /*1a*/  unsigned int   res1a;           /* 0xffffffff */
 504 /*1e*/  unsigned int   res1e;           /* 0xffffffff */
 505 /*22*/  unsigned int   res22;           /* 0xffffffff */
 506 /*26*/  unsigned int   res26;           /* 0xffffffff */
 507 /*2a*/  unsigned int   res2a;           /* 0xffffffff */
 508 /*2e*/  unsigned int   res2e;           /* 0xffffffff */
 509 /*32*/  unsigned int   res32;           /* 0xffffffff */
 510 /*36*/  unsigned int   res36;           /* 0xffffffff */
 511 /*3a*/  unsigned int   res3a;           /* 0xffffffff */
 512 /*3e*/  unsigned int   res3e;           /* 0xffffffff */
 513 /*42*/  unsigned short res42;           /* 0xffff */
 514 /*44*/  unsigned int   number;          /* this is 8 times the number of refs */
 515 /*48*/  /* Now we have number bytes (8 for each ref) of SLTG_UnknownRefInfo */
 516
 517 /*50*/  unsigned short res50;           /* 0xffff */
 518 /*52*/  unsigned char  res52;           /* 0x01 */
 519 /*53*/  unsigned int   res53;           /* 0x00000000 */
 520 /*57*/  SLTG_Name      names[1];
 521   /*    Now we have number/8 SLTG_Names (first WORD is no of bytes in the ascii
 522    *    string).  Strings look like "*\Rxxxx*#n".  If xxxx == ffff then the
 523    *    ref refers to the nth type listed in this library (0 based).  Else
 524    *    the xxxx (which maybe fewer than 4 digits) is the offset into the name
 525    *    table to a string "*\G{<guid>}#1.0#0#C:\WINNT\System32\stdole32.tlb#"
 526    *    The guid is the typelib guid; the ref again refers to the nth type of
 527    *    the imported typelib.
 528    */
 529
 530 /*xx*/  unsigned char  resxx;           /* 0xdf */
 531
 532 } SLTG_RefInfo;
 533
 534 #define SLTG_REF_MAGIC 0xdf
 535
 536 typedef struct {
 537         unsigned short res00;   /* 0x0001 */
 538         unsigned char  res02;   /* 0x02 */
 539         unsigned char  res03;   /* 0x40 if internal ref, 0x00 if external ? */
 540         unsigned short res04;   /* 0xffff */
 541         unsigned short res06;   /* 0x0000, 0x0013 or 0xffff ?? */
 542 } SLTG_UnknownRefInfo;
 543
 544 typedef struct {
 545     unsigned short res00; /* 0x004a */
 546     unsigned short next;  /* byte offs to next interface */
 547     unsigned short res04; /* 0xffff */
 548     unsigned char  impltypeflags; /* IMPLTYPEFLAG_* */
 549     unsigned char  res07; /* 0x80 */
 550     unsigned short res08; /* 0x0012, 0x0028 ?? */
 551     unsigned short ref;   /* number in ref table ? */
 552     unsigned short res0c; /* 0x4000 */
 553     unsigned short res0e; /* 0xfffe */
 554     unsigned short res10; /* 0xffff */
 555     unsigned short res12; /* 0x001d */
 556     unsigned short pos_in_table; /* 0x0, 0x4, ? */
 557 } SLTG_ImplInfo;
 558
 559 #define SLTG_IMPL_MAGIC 0x004a
 560
 561 typedef struct {
 562     unsigned char  magic; /* 0x0a */
 563     unsigned char  typepos;
 564     unsigned short next;
 565     unsigned short name;
 566     unsigned short byte_offs; /* pos in struct */
 567     unsigned short type; /* if typepos == 0x02 this is the type, else offset to type */
 568     unsigned int   memid;
 569     unsigned short helpcontext; /* ?? */
 570     unsigned short helpstring; /* ?? */
 571 } SLTG_RecordItem;
 572
 573 #define SLTG_RECORD_MAGIC 0x0a
 574
 575
 576 /* CARRAYs look like this
 577 WORD type == VT_CARRAY
 578 WORD offset from start of block to SAFEARRAY
 579 WORD typeofarray
 580 */
 581
 582 #include "poppack.h"
 583
 584 /*---------------------------END--------------------------------------------*/
 585 #endif