tools/widl/typelib.c

   1 /*
   2  * IDL Compiler
   3  *
   4  * Copyright 2004 Ove Kaaven
   5  * Copyright 2006 Jacek Caban for CodeWeavers
   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
  22 #include "config.h"
  23 #include "wine/port.h"
  24 #include "wine/wpp.h"
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <stdarg.h>
  29 #include <unistd.h>
  30 #include <string.h>
  31 #include <assert.h>
  32 #include <ctype.h>
  33 #include <signal.h>
  34
  35 #define NONAMELESSUNION
  36 #define NONAMELESSSTRUCT
  37
  38 #include "windef.h"
  39 #include "winbase.h"
  40
  41 #include "widl.h"
  42 #include "utils.h"
  43 #include "parser.h"
  44 #include "header.h"
  45 #include "typelib.h"
  46 #include "widltypes.h"
  47 #include "typelib_struct.h"
  48
  49 int in_typelib = 0;
  50
  51 static typelib_t *typelib;
  52
  53 type_t *duptype(type_t *t, int dupname)
  54 {
  55   type_t *d = xmalloc(sizeof *d);
  56
  57   *d = *t;
  58   if (dupname && t->name)
  59     d->name = xstrdup(t->name);
  60
  61   d->orig = t;
  62   return d;
  63 }
  64
  65 type_t *alias(type_t *t, const char *name)
  66 {
  67   type_t *a = duptype(t, 0);
  68
  69   a->name = xstrdup(name);
  70   a->kind = TKIND_ALIAS;
  71   a->attrs = NULL;
  72
  73   return a;
  74 }
  75
  76 /* List of oleauto types that should be recognized by name.
  77  * (most of) these seem to be intrinsic types in mktyplib. */
  78
  79 static struct oatype {
  80   const char *kw;
  81   unsigned short vt;
  82 } oatypes[] = {
  83   {"BSTR",          VT_BSTR},
  84   {"CURRENCY",      VT_CY},
  85   {"DATE",          VT_DATE},
  86   {"DECIMAL",       VT_DECIMAL},
  87   {"HRESULT",       VT_HRESULT},
  88   {"LPSTR",         VT_LPSTR},
  89   {"LPWSTR",        VT_LPWSTR},
  90   {"SCODE",         VT_ERROR},
  91   {"VARIANT",       VT_VARIANT},
  92   {"VARIANT_BOOL",  VT_BOOL}
  93 };
  94 #define NTYPES (sizeof(oatypes)/sizeof(oatypes[0]))
  95 #define KWP(p) ((const struct oatype *)(p))
  96
  97 static int kw_cmp_func(const void *s1, const void *s2)
  98 {
  99         return strcmp(KWP(s1)->kw, KWP(s2)->kw);
 100 }
 101
 102 static unsigned short builtin_vt(const char *kw)
 103 {
 104   struct oatype key, *kwp;
 105   key.kw = kw;
 106 #ifdef KW_BSEARCH
 107   kwp = bsearch(&key, oatypes, NTYPES, sizeof(oatypes[0]), kw_cmp_func);
 108 #else
 109   {
 110     unsigned int i;
 111     for (kwp=NULL, i=0; i < NTYPES; i++)
 112       if (!kw_cmp_func(&key, &oatypes[i])) {
 113         kwp = &oatypes[i];
 114         break;
 115       }
 116   }
 117 #endif
 118   if (kwp) {
 119     return kwp->vt;
 120   }
 121   return 0;
 122 }
 123
 124 static int match(const char*n, const char*m)
 125 {
 126   if (!n) return 0;
 127   return !strcmp(n, m);
 128 }
 129
 130 unsigned short get_type_vt(type_t *t)
 131 {
 132   unsigned short vt;
 133
 134   chat("get_type_vt: %p type->name %s\n", t, t->name);
 135   if (t->name) {
 136     vt = builtin_vt(t->name);
 137     if (vt) return vt;
 138   }
 139
 140   switch (t->type) {
 141   case RPC_FC_BYTE:
 142   case RPC_FC_USMALL:
 143     return VT_UI1;
 144   case RPC_FC_CHAR:
 145   case RPC_FC_SMALL:
 146     return VT_I1;
 147   case RPC_FC_WCHAR:
 148     return VT_I2; /* mktyplib seems to parse wchar_t as short */
 149   case RPC_FC_SHORT:
 150     return VT_I2;
 151   case RPC_FC_USHORT:
 152     return VT_UI2;
 153   case RPC_FC_LONG:
 154     if (match(t->name, "int")) return VT_INT;
 155     return VT_I4;
 156   case RPC_FC_ULONG:
 157     if (match(t->name, "int")) return VT_UINT;
 158     return VT_UI4;
 159   case RPC_FC_HYPER:
 160     if (t->sign < 0) return VT_UI8;
 161     if (match(t->name, "MIDL_uhyper")) return VT_UI8;
 162     return VT_I8;
 163   case RPC_FC_FLOAT:
 164     return VT_R4;
 165   case RPC_FC_DOUBLE:
 166     return VT_R8;
 167   case RPC_FC_RP:
 168   case RPC_FC_UP:
 169   case RPC_FC_OP:
 170   case RPC_FC_FP:
 171     if(t->ref)
 172       return VT_PTR;
 173
 174     error("get_type_vt: unknown-deref-type: %d\n", t->ref->type);
 175     break;
 176   case RPC_FC_IP:
 177     if(match(t->name, "IUnknown"))
 178       return VT_UNKNOWN;
 179     if(match(t->name, "IDispatch"))
 180       return VT_DISPATCH;
 181     return VT_USERDEFINED;
 182
 183   case RPC_FC_ENUM16:
 184   case RPC_FC_STRUCT:
 185   case RPC_FC_PSTRUCT:
 186   case RPC_FC_CSTRUCT:
 187   case RPC_FC_CPSTRUCT:
 188   case RPC_FC_CVSTRUCT:
 189   case RPC_FC_BOGUS_STRUCT:
 190     return VT_USERDEFINED;
 191   case 0:
 192     if(t->attrs)
 193         return VT_USERDEFINED;
 194     return 0;
 195   default:
 196     error("get_type_vt: unknown type: 0x%02x\n", t->type);
 197   }
 198   return 0;
 199 }
 200
 201 unsigned short get_var_vt(var_t *v)
 202 {
 203   unsigned short vt;
 204
 205   chat("get_var_vt: %p tname %s\n", v, v->tname);
 206   if (v->tname) {
 207     vt = builtin_vt(v->tname);
 208     if (vt) return vt;
 209   }
 210
 211   return get_type_vt(v->type);
 212 }
 213
 214 void start_typelib(char *name, attr_t *attrs)
 215 {
 216     in_typelib++;
 217     if (!do_typelib) return;
 218
 219     typelib = xmalloc(sizeof(*typelib));
 220     typelib->name = xstrdup(name);
 221     typelib->filename = xstrdup(typelib_name);
 222     typelib->attrs = attrs;
 223     typelib->entry = NULL;
 224     typelib->importlibs = NULL;
 225 }
 226
 227 void end_typelib(void)
 228 {
 229     in_typelib--;
 230     if (!typelib) return;
 231
 232     create_msft_typelib(typelib);
 233     return;
 234 }
 235
 236 void add_interface(type_t *iface)
 237 {
 238     typelib_entry_t *entry;
 239     if (!typelib) return;
 240
 241     chat("add interface: %s\n", iface->name);
 242     entry = xmalloc(sizeof(*entry));
 243     entry->kind = TKIND_INTERFACE;
 244     entry->u.interface = iface;
 245     LINK(entry, typelib->entry);
 246     typelib->entry = entry;
 247 }
 248
 249 void add_coclass(type_t *cls)
 250 {
 251     typelib_entry_t *entry;
 252
 253     if (!typelib) return;
 254
 255     chat("add coclass: %s\n", cls->name);
 256
 257     entry = xmalloc(sizeof(*entry));
 258     entry->kind = TKIND_COCLASS;
 259     entry->u.class = cls;
 260     LINK(entry, typelib->entry);
 261     typelib->entry = entry;
 262 }
 263
 264 void add_module(type_t *module)
 265 {
 266     typelib_entry_t *entry;
 267     if (!typelib) return;
 268
 269     chat("add module: %s\n", module->name);
 270     entry = xmalloc(sizeof(*entry));
 271     entry->kind = TKIND_MODULE;
 272     entry->u.module = module;
 273     LINK(entry, typelib->entry);
 274     typelib->entry = entry;
 275 }
 276
 277 void add_struct(type_t *structure)
 278 {
 279      typelib_entry_t *entry;
 280      if (!typelib) return;
 281
 282      chat("add struct: %s\n", structure->name);
 283      entry = xmalloc(sizeof(*entry));
 284      entry->kind = TKIND_RECORD;
 285      entry->u.structure = structure;
 286      LINK(entry, typelib->entry);
 287      typelib->entry = entry;
 288 }
 289
 290 void add_enum(type_t *enumeration)
 291 {
 292      typelib_entry_t *entry;
 293      if (!typelib) return;
 294
 295      chat("add enum: %s\n", enumeration->name);
 296      entry = xmalloc(sizeof(*entry));
 297      entry->kind = TKIND_ENUM;
 298      entry->u.enumeration = enumeration;
 299      LINK(entry, typelib->entry);
 300      typelib->entry = entry;
 301 }
 302
 303 void add_typedef(type_t *tdef, var_t *name)
 304 {
 305      typelib_entry_t *entry;
 306      if (!typelib) return;
 307
 308      chat("add typedef: %s\n", name->name);
 309      entry = xmalloc(sizeof(*entry));
 310      entry->kind = TKIND_ALIAS;
 311      entry->u.tdef = xmalloc(sizeof(*entry->u.tdef));
 312      memcpy(entry->u.tdef, name, sizeof(*name));
 313      entry->u.tdef->type = tdef;
 314      entry->u.tdef->name = xstrdup(name->name);
 315      LINK(entry, typelib->entry);
 316      typelib->entry = entry;
 317 }
 318
 319 static void tlb_read(int fd, void *buf, size_t count)
 320 {
 321     if(read(fd, buf, count) < count)
 322         error("error while reading importlib.\n");
 323 }
 324
 325 static void tlb_lseek(int fd, off_t offset)
 326 {
 327     if(lseek(fd, offset, SEEK_SET) == -1)
 328         error("lseek failed\n");
 329 }
 330
 331 static void msft_read_guid(int fd, MSFT_SegDir *segdir, int offset, GUID *guid)
 332 {
 333     tlb_lseek(fd, segdir->pGuidTab.offset+offset);
 334     tlb_read(fd, guid, sizeof(GUID));
 335 }
 336
 337 static void read_msft_importlib(importlib_t *importlib, int fd)
 338 {
 339     MSFT_Header header;
 340     MSFT_SegDir segdir;
 341     int *typeinfo_offs;
 342     int i;
 343
 344     importlib->allocated = 0;
 345
 346     tlb_lseek(fd, 0);
 347     tlb_read(fd, &header, sizeof(header));
 348
 349     importlib->version = header.version;
 350
 351     typeinfo_offs = xmalloc(header.nrtypeinfos*sizeof(INT));
 352     tlb_read(fd, typeinfo_offs, header.nrtypeinfos*sizeof(INT));
 353     tlb_read(fd, &segdir, sizeof(segdir));
 354
 355     msft_read_guid(fd, &segdir, header.posguid, &importlib->guid);
 356
 357     importlib->ntypeinfos = header.nrtypeinfos;
 358     importlib->importinfos = xmalloc(importlib->ntypeinfos*sizeof(importinfo_t));
 359
 360     for(i=0; i < importlib->ntypeinfos; i++) {
 361         MSFT_TypeInfoBase base;
 362         MSFT_NameIntro nameintro;
 363         int len;
 364
 365         tlb_lseek(fd, sizeof(MSFT_Header) + header.nrtypeinfos*sizeof(INT) + sizeof(MSFT_SegDir)
 366                  + typeinfo_offs[i]);
 367         tlb_read(fd, &base, sizeof(base));
 368
 369         importlib->importinfos[i].importlib = importlib;
 370         importlib->importinfos[i].flags = (base.typekind&0xf)<<24;
 371         importlib->importinfos[i].offset = -1;
 372         importlib->importinfos[i].id = i;
 373
 374         if(base.posguid != -1) {
 375             importlib->importinfos[i].flags |= MSFT_IMPINFO_OFFSET_IS_GUID;
 376             msft_read_guid(fd, &segdir, base.posguid, &importlib->importinfos[i].guid);
 377         }
 378         else memset( &importlib->importinfos[i].guid, 0, sizeof(importlib->importinfos[i].guid));
 379
 380         tlb_lseek(fd, segdir.pNametab.offset + base.NameOffset);
 381         tlb_read(fd, &nameintro, sizeof(nameintro));
 382
 383         len = nameintro.namelen & 0xff;
 384
 385         importlib->importinfos[i].name = xmalloc(len+1);
 386         tlb_read(fd, importlib->importinfos[i].name, len);
 387         importlib->importinfos[i].name[len] = 0;
 388     }
 389
 390     free(typeinfo_offs);
 391 }
 392
 393 static void read_importlib(importlib_t *importlib)
 394 {
 395     int fd;
 396     INT magic;
 397     char *file_name;
 398
 399     file_name = wpp_find_include(importlib->name, NULL);
 400     if(file_name) {
 401         fd = open(file_name, O_RDONLY);
 402         free(file_name);
 403     }else {
 404         fd = open(importlib->name, O_RDONLY);
 405     }
 406
 407     if(fd < 0)
 408         error("Could not open importlib %s.\n", importlib->name);
 409
 410     tlb_read(fd, &magic, sizeof(magic));
 411
 412     switch(magic) {
 413     case MSFT_MAGIC:
 414         read_msft_importlib(importlib, fd);
 415         break;
 416     default:
 417         error("Wrong or unsupported typelib magic %x\n", magic);
 418     };
 419
 420     close(fd);
 421 }
 422
 423 void add_importlib(const char *name)
 424 {
 425     importlib_t *importlib;
 426
 427     if(!typelib) return;
 428
 429     for(importlib = typelib->importlibs; importlib; importlib = NEXT_LINK(importlib)) {
 430         if(!strcmp(name, importlib->name))
 431             return;
 432     }
 433
 434     chat("add_importlib: %s\n", name);
 435
 436     importlib = xmalloc(sizeof(*importlib));
 437     memset( importlib, 0, sizeof(*importlib) );
 438     importlib->name = xstrdup(name);
 439
 440     read_importlib(importlib);
 441
 442     LINK(importlib, typelib->importlibs);
 443     typelib->importlibs = importlib;
 444 }