wordpad: Update Korean resource.
[wine] / 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 #ifdef HAVE_UNISTD_H
30 # include <unistd.h>
31 #endif
32 #include <string.h>
33 #include <ctype.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 #include "typetree.h"
49
50 static typelib_t *typelib;
51
52 int is_ptr(const type_t *t)
53 {
54     return type_get_type(t) == TYPE_POINTER;
55 }
56
57 int is_array(const type_t *t)
58 {
59     return type_get_type(t) == TYPE_ARRAY;
60 }
61
62 /* List of oleauto types that should be recognized by name.
63  * (most of) these seem to be intrinsic types in mktyplib.
64  * This table MUST be alphabetically sorted on the kw field.
65  */
66 static const struct oatype {
67   const char *kw;
68   unsigned short vt;
69 } oatypes[] = {
70   {"BSTR",          VT_BSTR},
71   {"CURRENCY",      VT_CY},
72   {"DATE",          VT_DATE},
73   {"DECIMAL",       VT_DECIMAL},
74   {"HRESULT",       VT_HRESULT},
75   {"LPSTR",         VT_LPSTR},
76   {"LPWSTR",        VT_LPWSTR},
77   {"SCODE",         VT_ERROR},
78   {"VARIANT",       VT_VARIANT},
79   {"VARIANT_BOOL",  VT_BOOL}
80 };
81 #define NTYPES (sizeof(oatypes)/sizeof(oatypes[0]))
82 #define KWP(p) ((const struct oatype *)(p))
83
84 static int kw_cmp_func(const void *s1, const void *s2)
85 {
86         return strcmp(KWP(s1)->kw, KWP(s2)->kw);
87 }
88
89 static unsigned short builtin_vt(const type_t *t)
90 {
91   const char *kw = t->name;
92   struct oatype key;
93   const struct oatype *kwp;
94   key.kw = kw;
95 #ifdef KW_BSEARCH
96   kwp = bsearch(&key, oatypes, NTYPES, sizeof(oatypes[0]), kw_cmp_func);
97 #else
98   {
99     unsigned int i;
100     for (kwp=NULL, i=0; i < NTYPES; i++)
101       if (!kw_cmp_func(&key, &oatypes[i])) {
102         kwp = &oatypes[i];
103         break;
104       }
105   }
106 #endif
107   if (kwp) {
108     return kwp->vt;
109   }
110   if (is_string_type (t->attrs, t))
111   {
112     const type_t *elem_type;
113     if (is_array(t))
114       elem_type = type_array_get_element(t);
115     else
116       elem_type = type_pointer_get_ref(t);
117     if (type_get_type(elem_type) == TYPE_BASIC)
118     {
119       switch (type_basic_get_type(elem_type))
120       {
121       case TYPE_BASIC_CHAR: return VT_LPSTR;
122       case TYPE_BASIC_WCHAR: return VT_LPWSTR;
123       default: break;
124       }
125     }
126   }
127   return 0;
128 }
129
130 static int match(const char*n, const char*m)
131 {
132   if (!n) return 0;
133   return !strcmp(n, m);
134 }
135
136 unsigned short get_type_vt(type_t *t)
137 {
138   unsigned short vt;
139
140   chat("get_type_vt: %p type->name %s\n", t, t->name);
141   if (t->name) {
142     vt = builtin_vt(t);
143     if (vt) return vt;
144   }
145
146   if (type_is_alias(t) && is_attr(t->attrs, ATTR_PUBLIC))
147     return VT_USERDEFINED;
148
149   switch (type_get_type(t)) {
150   case TYPE_BASIC:
151     switch (type_basic_get_type(t)) {
152     case TYPE_BASIC_BYTE:
153       return VT_UI1;
154     case TYPE_BASIC_CHAR:
155     case TYPE_BASIC_INT8:
156       if (type_basic_get_sign(t) > 0)
157         return VT_UI1;
158       else
159         return VT_I1;
160     case TYPE_BASIC_WCHAR:
161       return VT_I2; /* mktyplib seems to parse wchar_t as short */
162     case TYPE_BASIC_INT16:
163       if (type_basic_get_sign(t) > 0)
164         return VT_UI2;
165       else
166         return VT_I2;
167     case TYPE_BASIC_INT:
168       if (type_basic_get_sign(t) > 0)
169         return VT_UINT;
170       else
171         return VT_INT;
172     case TYPE_BASIC_INT32:
173     case TYPE_BASIC_ERROR_STATUS_T:
174       if (type_basic_get_sign(t) > 0)
175         return VT_UI4;
176       else
177         return VT_I4;
178     case TYPE_BASIC_INT64:
179     case TYPE_BASIC_HYPER:
180       if (type_basic_get_sign(t) > 0)
181         return VT_UI8;
182       else
183         return VT_I8;
184     case TYPE_BASIC_INT3264:
185       if (typelib_kind == SYS_WIN64)
186       {
187         if (type_basic_get_sign(t) > 0)
188           return VT_UI8;
189         else
190           return VT_I8;
191       }
192       else
193       {
194         if (type_basic_get_sign(t) > 0)
195           return VT_UI4;
196         else
197           return VT_I4;
198       }
199     case TYPE_BASIC_FLOAT:
200       return VT_R4;
201     case TYPE_BASIC_DOUBLE:
202       return VT_R8;
203     case TYPE_BASIC_HANDLE:
204       error("handles can't be used in typelibs\n");
205     }
206     break;
207
208   case TYPE_POINTER:
209     return VT_PTR;
210
211   case TYPE_ARRAY:
212     if (type_array_is_decl_as_ptr(t))
213     {
214       if (match(type_array_get_element(t)->name, "SAFEARRAY"))
215         return VT_SAFEARRAY;
216     }
217     else
218       error("get_type_vt: array types not supported\n");
219     return VT_PTR;
220
221   case TYPE_INTERFACE:
222     if(match(t->name, "IUnknown"))
223       return VT_UNKNOWN;
224     if(match(t->name, "IDispatch"))
225       return VT_DISPATCH;
226     return VT_USERDEFINED;
227
228   case TYPE_ENUM:
229   case TYPE_STRUCT:
230   case TYPE_COCLASS:
231   case TYPE_MODULE:
232   case TYPE_UNION:
233   case TYPE_ENCAPSULATED_UNION:
234     return VT_USERDEFINED;
235
236   case TYPE_VOID:
237     return VT_VOID;
238
239   case TYPE_ALIAS:
240     /* aliases should be filtered out by the type_get_type call above */
241     assert(0);
242     break;
243
244   case TYPE_FUNCTION:
245     error("get_type_vt: functions not supported\n");
246     break;
247
248   case TYPE_BITFIELD:
249     error("get_type_vt: bitfields not supported\n");
250     break;
251   }
252   return 0;
253 }
254
255 void start_typelib(typelib_t *typelib_type)
256 {
257     if (!do_typelib) return;
258
259     typelib = typelib_type;
260     typelib->filename = xstrdup(typelib_name);
261 }
262
263 void end_typelib(void)
264 {
265     if (!typelib) return;
266
267     create_msft_typelib(typelib);
268 }
269
270 static void tlb_read(int fd, void *buf, int count)
271 {
272     if(read(fd, buf, count) < count)
273         error("error while reading importlib.\n");
274 }
275
276 static void tlb_lseek(int fd, off_t offset)
277 {
278     if(lseek(fd, offset, SEEK_SET) == -1)
279         error("lseek failed\n");
280 }
281
282 static void msft_read_guid(int fd, MSFT_SegDir *segdir, int offset, GUID *guid)
283 {
284     tlb_lseek(fd, segdir->pGuidTab.offset+offset);
285     tlb_read(fd, guid, sizeof(GUID));
286 }
287
288 static void read_msft_importlib(importlib_t *importlib, int fd)
289 {
290     MSFT_Header header;
291     MSFT_SegDir segdir;
292     int *typeinfo_offs;
293     int i;
294
295     importlib->allocated = 0;
296
297     tlb_lseek(fd, 0);
298     tlb_read(fd, &header, sizeof(header));
299
300     importlib->version = header.version;
301
302     typeinfo_offs = xmalloc(header.nrtypeinfos*sizeof(INT));
303     tlb_read(fd, typeinfo_offs, header.nrtypeinfos*sizeof(INT));
304     tlb_read(fd, &segdir, sizeof(segdir));
305
306     msft_read_guid(fd, &segdir, header.posguid, &importlib->guid);
307
308     importlib->ntypeinfos = header.nrtypeinfos;
309     importlib->importinfos = xmalloc(importlib->ntypeinfos*sizeof(importinfo_t));
310
311     for(i=0; i < importlib->ntypeinfos; i++) {
312         MSFT_TypeInfoBase base;
313         MSFT_NameIntro nameintro;
314         int len;
315
316         tlb_lseek(fd, sizeof(MSFT_Header) + header.nrtypeinfos*sizeof(INT) + sizeof(MSFT_SegDir)
317                  + typeinfo_offs[i]);
318         tlb_read(fd, &base, sizeof(base));
319
320         importlib->importinfos[i].importlib = importlib;
321         importlib->importinfos[i].flags = (base.typekind&0xf)<<24;
322         importlib->importinfos[i].offset = -1;
323         importlib->importinfos[i].id = i;
324
325         if(base.posguid != -1) {
326             importlib->importinfos[i].flags |= MSFT_IMPINFO_OFFSET_IS_GUID;
327             msft_read_guid(fd, &segdir, base.posguid, &importlib->importinfos[i].guid);
328         }
329         else memset( &importlib->importinfos[i].guid, 0, sizeof(importlib->importinfos[i].guid));
330
331         tlb_lseek(fd, segdir.pNametab.offset + base.NameOffset);
332         tlb_read(fd, &nameintro, sizeof(nameintro));
333
334         len = nameintro.namelen & 0xff;
335
336         importlib->importinfos[i].name = xmalloc(len+1);
337         tlb_read(fd, importlib->importinfos[i].name, len);
338         importlib->importinfos[i].name[len] = 0;
339     }
340
341     free(typeinfo_offs);
342 }
343
344 static void read_importlib(importlib_t *importlib)
345 {
346     int fd;
347     INT magic;
348     char *file_name;
349
350     file_name = wpp_find_include(importlib->name, NULL);
351     if(file_name) {
352         fd = open(file_name, O_RDONLY | O_BINARY );
353         free(file_name);
354     }else {
355         fd = open(importlib->name, O_RDONLY | O_BINARY );
356     }
357
358     if(fd < 0)
359         error("Could not open importlib %s.\n", importlib->name);
360
361     tlb_read(fd, &magic, sizeof(magic));
362
363     switch(magic) {
364     case MSFT_MAGIC:
365         read_msft_importlib(importlib, fd);
366         break;
367     default:
368         error("Wrong or unsupported typelib magic %x\n", magic);
369     };
370
371     close(fd);
372 }
373
374 void add_importlib(const char *name)
375 {
376     importlib_t *importlib;
377
378     if(!typelib) return;
379
380     LIST_FOR_EACH_ENTRY( importlib, &typelib->importlibs, importlib_t, entry )
381         if(!strcmp(name, importlib->name))
382             return;
383
384     chat("add_importlib: %s\n", name);
385
386     importlib = xmalloc(sizeof(*importlib));
387     memset( importlib, 0, sizeof(*importlib) );
388     importlib->name = xstrdup(name);
389
390     read_importlib(importlib);
391     list_add_head( &typelib->importlibs, &importlib->entry );
392 }