?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
oleaut32: COM cleanup for internal loading structures.
[wine/wine-gecko.git] / dlls / oleaut32 / typelib.c
blobf13024ef041aa52cd81740ecb1e4381a277d9954
1 /*
2 * TYPELIB
3 *
4 * Copyright 1997 Marcus Meissner
5 * 1999 Rein Klazes
6 * 2000 Francois Jacques
7 * 2001 Huw D M Davies for CodeWeavers
8 * 2005 Robert Shearman, for CodeWeavers
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 *
24 * --------------------------------------------------------------------------------------
25 * Known problems (2000, Francois Jacques)
26 *
27 * - Tested using OLEVIEW (Platform SDK tool) only.
28 *
29 * - dual interface dispinterfaces. vtable-interface ITypeInfo instances are
30 * creating by doing a straight copy of the dispinterface instance and just changing
31 * its typekind. Pointed structures aren't copied - only the address of the pointers.
32 *
33 * - locale stuff is partially implemented but hasn't been tested.
34 *
35 * - typelib file is still read in its entirety, but it is released now.
36 *
37 * --------------------------------------------------------------------------------------
38 * Known problems left from previous implementation (1999, Rein Klazes) :
39 *
40 * -. Data structures are straightforward, but slow for look-ups.
41 * -. (related) nothing is hashed
42 * -. Most error return values are just guessed not checked with windows
43 * behaviour.
44 * -. lousy fatal error handling
45 *
46 */
47
48 #include "config.h"
49 #include "wine/port.h"
50
51 #include <stdlib.h>
52 #include <string.h>
53 #include <stdarg.h>
54 #include <stdio.h>
55 #include <ctype.h>
56
57 #define COBJMACROS
58 #define NONAMELESSUNION
59 #define NONAMELESSSTRUCT
60
61 #include "winerror.h"
62 #include "windef.h"
63 #include "winbase.h"
64 #include "winnls.h"
65 #include "winreg.h"
66 #include "winuser.h"
67 #include "lzexpand.h"
68
69 #include "wine/unicode.h"
70 #include "objbase.h"
71 #include "typelib.h"
72 #include "wine/debug.h"
73 #include "variant.h"
74 #include "wine/list.h"
75
76 WINE_DEFAULT_DEBUG_CHANNEL(ole);
77 WINE_DECLARE_DEBUG_CHANNEL(typelib);
78
79 typedef struct
80 {
81 WORD offset;
82 WORD length;
83 WORD flags;
84 WORD id;
85 WORD handle;
86 WORD usage;
87 } NE_NAMEINFO;
88
89 typedef struct
90 {
91 WORD type_id; /* Type identifier */
92 WORD count; /* Number of resources of this type */
93 DWORD resloader; /* SetResourceHandler() */
94 /*
95 * Name info array.
96 */
97 } NE_TYPEINFO;
98
99 static HRESULT typedescvt_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt);
100 static HRESULT TLB_AllocAndInitVarDesc(const VARDESC *src, VARDESC **dest_ptr);
101
102 /****************************************************************************
103 * FromLExxx
104 *
105 * Takes p_iVal (which is in little endian) and returns it
106 * in the host machine's byte order.
107 */
108 #ifdef WORDS_BIGENDIAN
109 static WORD FromLEWord(WORD p_iVal)
110 {
111 return (((p_iVal & 0x00FF) << 8) |
112 ((p_iVal & 0xFF00) >> 8));
113 }
114
115
116 static DWORD FromLEDWord(DWORD p_iVal)
117 {
118 return (((p_iVal & 0x000000FF) << 24) |
119 ((p_iVal & 0x0000FF00) << 8) |
120 ((p_iVal & 0x00FF0000) >> 8) |
121 ((p_iVal & 0xFF000000) >> 24));
122 }
123 #else
124 #define FromLEWord(X) (X)
125 #define FromLEDWord(X) (X)
126 #endif
127
128 #define DISPATCH_HREF_OFFSET 0x01000000
129 #define DISPATCH_HREF_MASK 0xff000000
130
131 /****************************************************************************
132 * FromLExxx
133 *
134 * Fix byte order in any structure if necessary
135 */
136 #ifdef WORDS_BIGENDIAN
137 static void FromLEWords(void *p_Val, int p_iSize)
138 {
139 WORD *Val = p_Val;
140
141 p_iSize /= sizeof(WORD);
142
143 while (p_iSize) {
144 *Val = FromLEWord(*Val);
145 Val++;
146 p_iSize--;
147 }
148 }
149
150
151 static void FromLEDWords(void *p_Val, int p_iSize)
152 {
153 DWORD *Val = p_Val;
154
155 p_iSize /= sizeof(DWORD);
156
157 while (p_iSize) {
158 *Val = FromLEDWord(*Val);
159 Val++;
160 p_iSize--;
161 }
162 }
163 #else
164 #define FromLEWords(X,Y) /*nothing*/
165 #define FromLEDWords(X,Y) /*nothing*/
166 #endif
167
168 /*
169 * Find a typelib key which matches a requested maj.min version.
170 */
171 static BOOL find_typelib_key( REFGUID guid, WORD *wMaj, WORD *wMin )
172 {
173 static const WCHAR typelibW[] = {'T','y','p','e','l','i','b','\\',0};
174 WCHAR buffer[60];
175 char key_name[16];
176 DWORD len, i;
177 INT best_maj = -1, best_min = -1;
178 HKEY hkey;
179
180 memcpy( buffer, typelibW, sizeof(typelibW) );
181 StringFromGUID2( guid, buffer + strlenW(buffer), 40 );
182
183 if (RegOpenKeyExW( HKEY_CLASSES_ROOT, buffer, 0, KEY_READ, &hkey ) != ERROR_SUCCESS)
184 return FALSE;
185
186 len = sizeof(key_name);
187 i = 0;
188 while (RegEnumKeyExA(hkey, i++, key_name, &len, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
189 {
190 INT v_maj, v_min;
191
192 if (sscanf(key_name, "%x.%x", &v_maj, &v_min) == 2)
193 {
194 TRACE("found %s: %x.%x\n", debugstr_w(buffer), v_maj, v_min);
195
196 if (*wMaj == 0xffff && *wMin == 0xffff)
197 {
198 if (v_maj > best_maj) best_maj = v_maj;
199 if (v_min > best_min) best_min = v_min;
200 }
201 else if (*wMaj == v_maj)
202 {
203 best_maj = v_maj;
204
205 if (*wMin == v_min)
206 {
207 best_min = v_min;
208 break; /* exact match */
209 }
210 if (*wMin != 0xffff && v_min > best_min) best_min = v_min;
211 }
212 }
213 len = sizeof(key_name);
214 }
215 RegCloseKey( hkey );
216
217 TRACE("found best_maj %d, best_min %d\n", best_maj, best_min);
218
219 if (*wMaj == 0xffff && *wMin == 0xffff)
220 {
221 if (best_maj >= 0 && best_min >= 0)
222 {
223 *wMaj = best_maj;
224 *wMin = best_min;
225 return TRUE;
226 }
227 }
228
229 if (*wMaj == best_maj && best_min >= 0)
230 {
231 *wMin = best_min;
232 return TRUE;
233 }
234 return FALSE;
235 }
236
237 /* get the path of a typelib key, in the form "Typelib\\<guid>\\<maj>.<min>" */
238 /* buffer must be at least 60 characters long */
239 static WCHAR *get_typelib_key( REFGUID guid, WORD wMaj, WORD wMin, WCHAR *buffer )
240 {
241 static const WCHAR TypelibW[] = {'T','y','p','e','l','i','b','\\',0};
242 static const WCHAR VersionFormatW[] = {'\\','%','x','.','%','x',0};
243
244 memcpy( buffer, TypelibW, sizeof(TypelibW) );
245 StringFromGUID2( guid, buffer + strlenW(buffer), 40 );
246 sprintfW( buffer + strlenW(buffer), VersionFormatW, wMaj, wMin );
247 return buffer;
248 }
249
250 /* get the path of an interface key, in the form "Interface\\<guid>" */
251 /* buffer must be at least 50 characters long */
252 static WCHAR *get_interface_key( REFGUID guid, WCHAR *buffer )
253 {
254 static const WCHAR InterfaceW[] = {'I','n','t','e','r','f','a','c','e','\\',0};
255
256 memcpy( buffer, InterfaceW, sizeof(InterfaceW) );
257 StringFromGUID2( guid, buffer + strlenW(buffer), 40 );
258 return buffer;
259 }
260
261 /* get the lcid subkey for a typelib, in the form "<lcid>\\<syskind>" */
262 /* buffer must be at least 16 characters long */
263 static WCHAR *get_lcid_subkey( LCID lcid, SYSKIND syskind, WCHAR *buffer )
264 {
265 static const WCHAR LcidFormatW[] = {'%','l','x','\\',0};
266 static const WCHAR win16W[] = {'w','i','n','1','6',0};
267 static const WCHAR win32W[] = {'w','i','n','3','2',0};
268 static const WCHAR win64W[] = {'w','i','n','6','4',0};
269
270 sprintfW( buffer, LcidFormatW, lcid );
271 switch(syskind)
272 {
273 case SYS_WIN16: strcatW( buffer, win16W ); break;
274 case SYS_WIN32: strcatW( buffer, win32W ); break;
275 case SYS_WIN64: strcatW( buffer, win64W ); break;
276 default:
277 TRACE("Typelib is for unsupported syskind %i\n", syskind);
278 return NULL;
279 }
280 return buffer;
281 }
282
283 static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath, ITypeLib2 **ppTypeLib);
284
285
286 /* Get the path to a registered type library. Helper for QueryPathOfRegTypeLib. */
287 static HRESULT query_typelib_path( REFGUID guid, WORD wMaj, WORD wMin,
288 SYSKIND syskind, LCID lcid, LPBSTR path )
289 {
290 HRESULT hr = TYPE_E_LIBNOTREGISTERED;
291 LCID myLCID = lcid;
292 HKEY hkey;
293 WCHAR buffer[60];
294 WCHAR Path[MAX_PATH];
295 LONG res;
296
297 TRACE_(typelib)("(%s, %x.%x, 0x%x, %p)\n", debugstr_guid(guid), wMaj, wMin, lcid, path);
298
299 if (!find_typelib_key( guid, &wMaj, &wMin )) return TYPE_E_LIBNOTREGISTERED;
300 get_typelib_key( guid, wMaj, wMin, buffer );
301
302 res = RegOpenKeyExW( HKEY_CLASSES_ROOT, buffer, 0, KEY_READ, &hkey );
303 if (res == ERROR_FILE_NOT_FOUND)
304 {
305 TRACE_(typelib)("%s not found\n", debugstr_w(buffer));
306 return TYPE_E_LIBNOTREGISTERED;
307 }
308 else if (res != ERROR_SUCCESS)
309 {
310 TRACE_(typelib)("failed to open %s for read access\n", debugstr_w(buffer));
311 return TYPE_E_REGISTRYACCESS;
312 }
313
314 while (hr != S_OK)
315 {
316 LONG dwPathLen = sizeof(Path);
317
318 get_lcid_subkey( myLCID, syskind, buffer );
319
320 if (RegQueryValueW(hkey, buffer, Path, &dwPathLen))
321 {
322 if (!lcid)
323 break;
324 else if (myLCID == lcid)
325 {
326 /* try with sub-langid */
327 myLCID = SUBLANGID(lcid);
328 }
329 else if ((myLCID == SUBLANGID(lcid)) && myLCID)
330 {
331 /* try with system langid */
332 myLCID = 0;
333 }
334 else
335 {
336 break;
337 }
338 }
339 else
340 {
341 *path = SysAllocString( Path );
342 hr = S_OK;
343 }
344 }
345 RegCloseKey( hkey );
346 TRACE_(typelib)("-- 0x%08x\n", hr);
347 return hr;
348 }
349
350 /****************************************************************************
351 * QueryPathOfRegTypeLib [OLEAUT32.164]
352 *
353 * Gets the path to a registered type library.
354 *
355 * PARAMS
356 * guid [I] referenced guid
357 * wMaj [I] major version
358 * wMin [I] minor version
359 * lcid [I] locale id
360 * path [O] path of typelib
361 *
362 * RETURNS
363 * Success: S_OK.
364 * Failure: If the type library is not registered then TYPE_E_LIBNOTREGISTERED
365 * or TYPE_E_REGISTRYACCESS if the type library registration key couldn't be
366 * opened.
367 */
368 HRESULT WINAPI QueryPathOfRegTypeLib( REFGUID guid, WORD wMaj, WORD wMin, LCID lcid, LPBSTR path )
369 {
370 #ifdef _WIN64
371 HRESULT hres = query_typelib_path( guid, wMaj, wMin, SYS_WIN64, lcid, path );
372 if(SUCCEEDED(hres))
373 return hres;
374 #endif
375 return query_typelib_path( guid, wMaj, wMin, SYS_WIN32, lcid, path );
376 }
377
378 /******************************************************************************
379 * CreateTypeLib [OLEAUT32.160] creates a typelib
380 *
381 * RETURNS
382 * Success: S_OK
383 * Failure: Status
384 */
385 HRESULT WINAPI CreateTypeLib(
386 SYSKIND syskind, LPCOLESTR szFile, ICreateTypeLib** ppctlib
387 ) {
388 FIXME("(%d,%s,%p), stub!\n",syskind,debugstr_w(szFile),ppctlib);
389 return E_FAIL;
390 }
391
392 /******************************************************************************
393 * LoadTypeLib [OLEAUT32.161]
394 *
395 * Loads a type library
396 *
397 * PARAMS
398 * szFile [I] Name of file to load from.
399 * pptLib [O] Pointer that receives ITypeLib object on success.
400 *
401 * RETURNS
402 * Success: S_OK
403 * Failure: Status
404 *
405 * SEE
406 * LoadTypeLibEx, LoadRegTypeLib, CreateTypeLib.
407 */
408 HRESULT WINAPI LoadTypeLib(const OLECHAR *szFile, ITypeLib * *pptLib)
409 {
410 TRACE("(%s,%p)\n",debugstr_w(szFile), pptLib);
411 return LoadTypeLibEx(szFile, REGKIND_DEFAULT, pptLib);
412 }
413
414 /******************************************************************************
415 * LoadTypeLibEx [OLEAUT32.183]
416 *
417 * Loads and optionally registers a type library
418 *
419 * RETURNS
420 * Success: S_OK
421 * Failure: Status
422 */
423 HRESULT WINAPI LoadTypeLibEx(
424 LPCOLESTR szFile, /* [in] Name of file to load from */
425 REGKIND regkind, /* [in] Specify kind of registration */
426 ITypeLib **pptLib) /* [out] Pointer to pointer to loaded type library */
427 {
428 WCHAR szPath[MAX_PATH+1];
429 HRESULT res;
430
431 TRACE("(%s,%d,%p)\n",debugstr_w(szFile), regkind, pptLib);
432
433 *pptLib = NULL;
434
435 res = TLB_ReadTypeLib(szFile, szPath, MAX_PATH + 1, (ITypeLib2**)pptLib);
436
437 if (SUCCEEDED(res))
438 switch(regkind)
439 {
440 case REGKIND_DEFAULT:
441 /* don't register typelibs supplied with full path. Experimentation confirms the following */
442 if (((szFile[0] == '\\') && (szFile[1] == '\\')) ||
443 (szFile[0] && (szFile[1] == ':'))) break;
444 /* else fall-through */
445
446 case REGKIND_REGISTER:
447 if (FAILED(res = RegisterTypeLib(*pptLib, szPath, NULL)))
448 {
449 ITypeLib_Release(*pptLib);
450 *pptLib = 0;
451 }
452 break;
453 case REGKIND_NONE:
454 break;
455 }
456
457 TRACE(" returns %08x\n",res);
458 return res;
459 }
460
461 /******************************************************************************
462 * LoadRegTypeLib [OLEAUT32.162]
463 *
464 * Loads a registered type library.
465 *
466 * PARAMS
467 * rguid [I] GUID of the registered type library.
468 * wVerMajor [I] major version.
469 * wVerMinor [I] minor version.
470 * lcid [I] locale ID.
471 * ppTLib [O] pointer that receives an ITypeLib object on success.
472 *
473 * RETURNS
474 * Success: S_OK.
475 * Failure: Any HRESULT code returned from QueryPathOfRegTypeLib or
476 * LoadTypeLib.
477 */
478 HRESULT WINAPI LoadRegTypeLib(
479 REFGUID rguid,
480 WORD wVerMajor,
481 WORD wVerMinor,
482 LCID lcid,
483 ITypeLib **ppTLib)
484 {
485 BSTR bstr=NULL;
486 HRESULT res;
487
488 *ppTLib = NULL;
489
490 res = QueryPathOfRegTypeLib( rguid, wVerMajor, wVerMinor, lcid, &bstr);
491
492 if(SUCCEEDED(res))
493 {
494 res= LoadTypeLib(bstr, ppTLib);
495 SysFreeString(bstr);
496 }
497
498 TRACE("(IID: %s) load %s (%p)\n",debugstr_guid(rguid), SUCCEEDED(res)? "SUCCESS":"FAILED", *ppTLib);
499
500 return res;
501 }
502
503
504 /* some string constants shared between RegisterTypeLib and UnRegisterTypeLib */
505 static const WCHAR TypeLibW[] = {'T','y','p','e','L','i','b',0};
506 static const WCHAR FLAGSW[] = {'F','L','A','G','S',0};
507 static const WCHAR HELPDIRW[] = {'H','E','L','P','D','I','R',0};
508 static const WCHAR ProxyStubClsidW[] = {'P','r','o','x','y','S','t','u','b','C','l','s','i','d',0};
509 static const WCHAR ProxyStubClsid32W[] = {'P','r','o','x','y','S','t','u','b','C','l','s','i','d','3','2',0};
510
511 /******************************************************************************
512 * RegisterTypeLib [OLEAUT32.163]
513 * Adds information about a type library to the System Registry
514 * NOTES
515 * Docs: ITypeLib FAR * ptlib
516 * Docs: OLECHAR FAR* szFullPath
517 * Docs: OLECHAR FAR* szHelpDir
518 *
519 * RETURNS
520 * Success: S_OK
521 * Failure: Status
522 */
523 HRESULT WINAPI RegisterTypeLib(
524 ITypeLib * ptlib, /* [in] Pointer to the library*/
525 OLECHAR * szFullPath, /* [in] full Path of the library*/
526 OLECHAR * szHelpDir) /* [in] dir to the helpfile for the library,
527 may be NULL*/
528 {
529 static const WCHAR PSOA[] = {'{','0','0','0','2','0','4','2','4','-',
530 '0','0','0','0','-','0','0','0','0','-','C','0','0','0','-',
531 '0','0','0','0','0','0','0','0','0','0','4','6','}',0};
532 HRESULT res;
533 TLIBATTR *attr;
534 WCHAR keyName[60];
535 WCHAR tmp[16];
536 HKEY key, subKey;
537 UINT types, tidx;
538 TYPEKIND kind;
539 DWORD disposition;
540
541 if (ptlib == NULL || szFullPath == NULL)
542 return E_INVALIDARG;
543
544 if (FAILED(ITypeLib_GetLibAttr(ptlib, &attr)))
545 return E_FAIL;
546
547 #ifdef _WIN64
548 if (attr->syskind != SYS_WIN64) return TYPE_E_BADMODULEKIND;
549 #else
550 if (attr->syskind != SYS_WIN32 && attr->syskind != SYS_WIN16) return TYPE_E_BADMODULEKIND;
551 #endif
552
553 get_typelib_key( &attr->guid, attr->wMajorVerNum, attr->wMinorVerNum, keyName );
554
555 res = S_OK;
556 if (RegCreateKeyExW(HKEY_CLASSES_ROOT, keyName, 0, NULL, 0,
557 KEY_WRITE, NULL, &key, NULL) == ERROR_SUCCESS)
558 {
559 LPOLESTR doc;
560
561 /* Set the human-readable name of the typelib */
562 if (FAILED(ITypeLib_GetDocumentation(ptlib, -1, NULL, &doc, NULL, NULL)))
563 res = E_FAIL;
564 else if (doc)
565 {
566 if (RegSetValueExW(key, NULL, 0, REG_SZ,
567 (BYTE *)doc, (lstrlenW(doc)+1) * sizeof(OLECHAR)) != ERROR_SUCCESS)
568 res = E_FAIL;
569
570 SysFreeString(doc);
571 }
572
573 /* Make up the name of the typelib path subkey */
574 if (!get_lcid_subkey( attr->lcid, attr->syskind, tmp )) res = E_FAIL;
575
576 /* Create the typelib path subkey */
577 if (res == S_OK && RegCreateKeyExW(key, tmp, 0, NULL, 0,
578 KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS)
579 {
580 if (RegSetValueExW(subKey, NULL, 0, REG_SZ,
581 (BYTE *)szFullPath, (lstrlenW(szFullPath)+1) * sizeof(OLECHAR)) != ERROR_SUCCESS)
582 res = E_FAIL;
583
584 RegCloseKey(subKey);
585 }
586 else
587 res = E_FAIL;
588
589 /* Create the flags subkey */
590 if (res == S_OK && RegCreateKeyExW(key, FLAGSW, 0, NULL, 0,
591 KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS)
592 {
593 /* FIXME: is %u correct? */
594 static const WCHAR formatW[] = {'%','u',0};
595 WCHAR buf[20];
596 sprintfW(buf, formatW, attr->wLibFlags);
597 if (RegSetValueExW(subKey, NULL, 0, REG_SZ,
598 (BYTE *)buf, (strlenW(buf) + 1)*sizeof(WCHAR) ) != ERROR_SUCCESS)
599 res = E_FAIL;
600
601 RegCloseKey(subKey);
602 }
603 else
604 res = E_FAIL;
605
606 /* create the helpdir subkey */
607 if (res == S_OK && RegCreateKeyExW(key, HELPDIRW, 0, NULL, 0,
608 KEY_WRITE, NULL, &subKey, &disposition) == ERROR_SUCCESS)
609 {
610 BOOL freeHelpDir = FALSE;
611 OLECHAR* pIndexStr;
612
613 /* if we created a new key, and helpDir was null, set the helpdir
614 to the directory which contains the typelib. However,
615 if we just opened an existing key, we leave the helpdir alone */
616 if ((disposition == REG_CREATED_NEW_KEY) && (szHelpDir == NULL)) {
617 szHelpDir = SysAllocString(szFullPath);
618 pIndexStr = strrchrW(szHelpDir, '\\');
619 if (pIndexStr) {
620 *pIndexStr = 0;
621 }
622 freeHelpDir = TRUE;
623 }
624
625 /* if we have an szHelpDir, set it! */
626 if (szHelpDir != NULL) {
627 if (RegSetValueExW(subKey, NULL, 0, REG_SZ,
628 (BYTE *)szHelpDir, (lstrlenW(szHelpDir)+1) * sizeof(OLECHAR)) != ERROR_SUCCESS) {
629 res = E_FAIL;
630 }
631 }
632
633 /* tidy up */
634 if (freeHelpDir) SysFreeString(szHelpDir);
635 RegCloseKey(subKey);
636
637 } else {
638 res = E_FAIL;
639 }
640
641 RegCloseKey(key);
642 }
643 else
644 res = E_FAIL;
645
646 /* register OLE Automation-compatible interfaces for this typelib */
647 types = ITypeLib_GetTypeInfoCount(ptlib);
648 for (tidx=0; tidx<types; tidx++) {
649 if (SUCCEEDED(ITypeLib_GetTypeInfoType(ptlib, tidx, &kind))) {
650 LPOLESTR name = NULL;
651 ITypeInfo *tinfo = NULL;
652
653 ITypeLib_GetDocumentation(ptlib, tidx, &name, NULL, NULL, NULL);
654
655 switch (kind) {
656 case TKIND_INTERFACE:
657 TRACE_(typelib)("%d: interface %s\n", tidx, debugstr_w(name));
658 ITypeLib_GetTypeInfo(ptlib, tidx, &tinfo);
659 break;
660
661 case TKIND_DISPATCH:
662 TRACE_(typelib)("%d: dispinterface %s\n", tidx, debugstr_w(name));
663 ITypeLib_GetTypeInfo(ptlib, tidx, &tinfo);
664 break;
665
666 default:
667 TRACE_(typelib)("%d: %s\n", tidx, debugstr_w(name));
668 break;
669 }
670
671 if (tinfo) {
672 TYPEATTR *tattr = NULL;
673 ITypeInfo_GetTypeAttr(tinfo, &tattr);
674
675 if (tattr) {
676 TRACE_(typelib)("guid=%s, flags=%04x (",
677 debugstr_guid(&tattr->guid),
678 tattr->wTypeFlags);
679
680 if (TRACE_ON(typelib)) {
681 #define XX(x) if (TYPEFLAG_##x & tattr->wTypeFlags) MESSAGE(#x"|");
682 XX(FAPPOBJECT);
683 XX(FCANCREATE);
684 XX(FLICENSED);
685 XX(FPREDECLID);
686 XX(FHIDDEN);
687 XX(FCONTROL);
688 XX(FDUAL);
689 XX(FNONEXTENSIBLE);
690 XX(FOLEAUTOMATION);
691 XX(FRESTRICTED);
692 XX(FAGGREGATABLE);
693 XX(FREPLACEABLE);
694 XX(FDISPATCHABLE);
695 XX(FREVERSEBIND);
696 XX(FPROXY);
697 #undef XX
698 MESSAGE("\n");
699 }
700
701 /* Register all dispinterfaces (which includes dual interfaces) and
702 oleautomation interfaces */
703 if ((kind == TKIND_INTERFACE && (tattr->wTypeFlags & TYPEFLAG_FOLEAUTOMATION)) ||
704 kind == TKIND_DISPATCH)
705 {
706 /* register interface<->typelib coupling */
707 get_interface_key( &tattr->guid, keyName );
708 if (RegCreateKeyExW(HKEY_CLASSES_ROOT, keyName, 0, NULL, 0,
709 KEY_WRITE, NULL, &key, NULL) == ERROR_SUCCESS)
710 {
711 if (name)
712 RegSetValueExW(key, NULL, 0, REG_SZ,
713 (BYTE *)name, (strlenW(name)+1) * sizeof(OLECHAR));
714
715 if (RegCreateKeyExW(key, ProxyStubClsidW, 0, NULL, 0,
716 KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS) {
717 RegSetValueExW(subKey, NULL, 0, REG_SZ,
718 (const BYTE *)PSOA, sizeof PSOA);
719 RegCloseKey(subKey);
720 }
721
722 if (RegCreateKeyExW(key, ProxyStubClsid32W, 0, NULL, 0,
723 KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS) {
724 RegSetValueExW(subKey, NULL, 0, REG_SZ,
725 (const BYTE *)PSOA, sizeof PSOA);
726 RegCloseKey(subKey);
727 }
728
729 if (RegCreateKeyExW(key, TypeLibW, 0, NULL, 0,
730 KEY_WRITE, NULL, &subKey, NULL) == ERROR_SUCCESS)
731 {
732 WCHAR buffer[40];
733 static const WCHAR fmtver[] = {'%','x','.','%','x',0 };
734 static const WCHAR VersionW[] = {'V','e','r','s','i','o','n',0};
735
736 StringFromGUID2(&attr->guid, buffer, 40);
737 RegSetValueExW(subKey, NULL, 0, REG_SZ,
738 (BYTE *)buffer, (strlenW(buffer)+1) * sizeof(WCHAR));
739 sprintfW(buffer, fmtver, attr->wMajorVerNum, attr->wMinorVerNum);
740 RegSetValueExW(subKey, VersionW, 0, REG_SZ,
741 (BYTE*)buffer, (strlenW(buffer)+1) * sizeof(WCHAR));
742 RegCloseKey(subKey);
743 }
744
745 RegCloseKey(key);
746 }
747 }
748
749 ITypeInfo_ReleaseTypeAttr(tinfo, tattr);
750 }
751
752 ITypeInfo_Release(tinfo);
753 }
754
755 SysFreeString(name);
756 }
757 }
758
759 ITypeLib_ReleaseTLibAttr(ptlib, attr);
760
761 return res;
762 }
763
764
765 /******************************************************************************
766 * UnRegisterTypeLib [OLEAUT32.186]
767 * Removes information about a type library from the System Registry
768 * NOTES
769 *
770 * RETURNS
771 * Success: S_OK
772 * Failure: Status
773 */
774 HRESULT WINAPI UnRegisterTypeLib(
775 REFGUID libid, /* [in] Guid of the library */
776 WORD wVerMajor, /* [in] major version */
777 WORD wVerMinor, /* [in] minor version */
778 LCID lcid, /* [in] locale id */
779 SYSKIND syskind)
780 {
781 BSTR tlibPath = NULL;
782 DWORD tmpLength;
783 WCHAR keyName[60];
784 WCHAR subKeyName[50];
785 int result = S_OK;
786 DWORD i = 0;
787 BOOL deleteOtherStuff;
788 HKEY key = NULL;
789 HKEY subKey = NULL;
790 TYPEATTR* typeAttr = NULL;
791 TYPEKIND kind;
792 ITypeInfo* typeInfo = NULL;
793 ITypeLib* typeLib = NULL;
794 int numTypes;
795
796 TRACE("(IID: %s)\n",debugstr_guid(libid));
797
798 /* Create the path to the key */
799 get_typelib_key( libid, wVerMajor, wVerMinor, keyName );
800
801 if (syskind != SYS_WIN16 && syskind != SYS_WIN32 && syskind != SYS_WIN64)
802 {
803 TRACE("Unsupported syskind %i\n", syskind);
804 result = E_INVALIDARG;
805 goto end;
806 }
807
808 /* get the path to the typelib on disk */
809 if (query_typelib_path(libid, wVerMajor, wVerMinor, syskind, lcid, &tlibPath) != S_OK) {
810 result = E_INVALIDARG;
811 goto end;
812 }
813
814 /* Try and open the key to the type library. */
815 if (RegOpenKeyExW(HKEY_CLASSES_ROOT, keyName, 0, KEY_READ | KEY_WRITE, &key) != ERROR_SUCCESS) {
816 result = E_INVALIDARG;
817 goto end;
818 }
819
820 /* Try and load the type library */
821 if (LoadTypeLibEx(tlibPath, REGKIND_NONE, &typeLib) != S_OK) {
822 result = TYPE_E_INVALIDSTATE;
823 goto end;
824 }
825
826 /* remove any types registered with this typelib */
827 numTypes = ITypeLib_GetTypeInfoCount(typeLib);
828 for (i=0; i<numTypes; i++) {
829 /* get the kind of type */
830 if (ITypeLib_GetTypeInfoType(typeLib, i, &kind) != S_OK) {
831 goto enddeleteloop;
832 }
833
834 /* skip non-interfaces, and get type info for the type */
835 if ((kind != TKIND_INTERFACE) && (kind != TKIND_DISPATCH)) {
836 goto enddeleteloop;
837 }
838 if (ITypeLib_GetTypeInfo(typeLib, i, &typeInfo) != S_OK) {
839 goto enddeleteloop;
840 }
841 if (ITypeInfo_GetTypeAttr(typeInfo, &typeAttr) != S_OK) {
842 goto enddeleteloop;
843 }
844
845 if ((kind == TKIND_INTERFACE && (typeAttr->wTypeFlags & TYPEFLAG_FOLEAUTOMATION)) ||
846 kind == TKIND_DISPATCH)
847 {
848 /* the path to the type */
849 get_interface_key( &typeAttr->guid, subKeyName );
850
851 /* Delete its bits */
852 if (RegOpenKeyExW(HKEY_CLASSES_ROOT, subKeyName, 0, KEY_WRITE, &subKey) != ERROR_SUCCESS)
853 goto enddeleteloop;
854
855 RegDeleteKeyW(subKey, ProxyStubClsidW);
856 RegDeleteKeyW(subKey, ProxyStubClsid32W);
857 RegDeleteKeyW(subKey, TypeLibW);
858 RegCloseKey(subKey);
859 subKey = NULL;
860 RegDeleteKeyW(HKEY_CLASSES_ROOT, subKeyName);
861 }
862
863 enddeleteloop:
864 if (typeAttr) ITypeInfo_ReleaseTypeAttr(typeInfo, typeAttr);
865 typeAttr = NULL;
866 if (typeInfo) ITypeInfo_Release(typeInfo);
867 typeInfo = NULL;
868 }
869
870 /* Now, delete the type library path subkey */
871 get_lcid_subkey( lcid, syskind, subKeyName );
872 RegDeleteKeyW(key, subKeyName);
873 *strrchrW( subKeyName, '\\' ) = 0; /* remove last path component */
874 RegDeleteKeyW(key, subKeyName);
875
876 /* check if there is anything besides the FLAGS/HELPDIR keys.
877 If there is, we don't delete them */
878 tmpLength = sizeof(subKeyName)/sizeof(WCHAR);
879 deleteOtherStuff = TRUE;
880 i = 0;
881 while(RegEnumKeyExW(key, i++, subKeyName, &tmpLength, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
882 tmpLength = sizeof(subKeyName)/sizeof(WCHAR);
883
884 /* if its not FLAGS or HELPDIR, then we must keep the rest of the key */
885 if (!strcmpW(subKeyName, FLAGSW)) continue;
886 if (!strcmpW(subKeyName, HELPDIRW)) continue;
887 deleteOtherStuff = FALSE;
888 break;
889 }
890
891 /* only delete the other parts of the key if we're absolutely sure */
892 if (deleteOtherStuff) {
893 RegDeleteKeyW(key, FLAGSW);
894 RegDeleteKeyW(key, HELPDIRW);
895 RegCloseKey(key);
896 key = NULL;
897
898 RegDeleteKeyW(HKEY_CLASSES_ROOT, keyName);
899 *strrchrW( keyName, '\\' ) = 0; /* remove last path component */
900 RegDeleteKeyW(HKEY_CLASSES_ROOT, keyName);
901 }
902
903 end:
904 SysFreeString(tlibPath);
905 if (typeLib) ITypeLib_Release(typeLib);
906 if (subKey) RegCloseKey(subKey);
907 if (key) RegCloseKey(key);
908 return result;
909 }
910
911 /******************************************************************************
912 * RegisterTypeLibForUser [OLEAUT32.442]
913 * Adds information about a type library to the user registry
914 * NOTES
915 * Docs: ITypeLib FAR * ptlib
916 * Docs: OLECHAR FAR* szFullPath
917 * Docs: OLECHAR FAR* szHelpDir
918 *
919 * RETURNS
920 * Success: S_OK
921 * Failure: Status
922 */
923 HRESULT WINAPI RegisterTypeLibForUser(
924 ITypeLib * ptlib, /* [in] Pointer to the library*/
925 OLECHAR * szFullPath, /* [in] full Path of the library*/
926 OLECHAR * szHelpDir) /* [in] dir to the helpfile for the library,
927 may be NULL*/
928 {
929 FIXME("(%p, %s, %s) registering the typelib system-wide\n", ptlib,
930 debugstr_w(szFullPath), debugstr_w(szHelpDir));
931 return RegisterTypeLib(ptlib, szFullPath, szHelpDir);
932 }
933
934 /******************************************************************************
935 * UnRegisterTypeLibForUser [OLEAUT32.443]
936 * Removes information about a type library from the user registry
937 *
938 * RETURNS
939 * Success: S_OK
940 * Failure: Status
941 */
942 HRESULT WINAPI UnRegisterTypeLibForUser(
943 REFGUID libid, /* [in] GUID of the library */
944 WORD wVerMajor, /* [in] major version */
945 WORD wVerMinor, /* [in] minor version */
946 LCID lcid, /* [in] locale id */
947 SYSKIND syskind)
948 {
949 FIXME("(%s, %u, %u, %u, %u) unregistering the typelib system-wide\n",
950 debugstr_guid(libid), wVerMajor, wVerMinor, lcid, syskind);
951 return UnRegisterTypeLib(libid, wVerMajor, wVerMinor, lcid, syskind);
952 }
953
954 /*======================= ITypeLib implementation =======================*/
955
956 typedef struct tagTLBCustData
957 {
958 GUID guid;
959 VARIANT data;
960 struct list entry;
961 } TLBCustData;
962
963 /* data structure for import typelibs */
964 typedef struct tagTLBImpLib
965 {
966 int offset; /* offset in the file (MSFT)
967 offset in nametable (SLTG)
968 just used to identify library while reading
969 data from file */
970 GUID guid; /* libid */
971 BSTR name; /* name */
972
973 LCID lcid; /* lcid of imported typelib */
974
975 WORD wVersionMajor; /* major version number */
976 WORD wVersionMinor; /* minor version number */
977
978 struct tagITypeLibImpl *pImpTypeLib; /* pointer to loaded typelib, or
979 NULL if not yet loaded */
980 struct list entry;
981 } TLBImpLib;
982
983 /* internal ITypeLib data */
984 typedef struct tagITypeLibImpl
985 {
986 ITypeLib2 ITypeLib2_iface;
987 ITypeComp ITypeComp_iface;
988 LONG ref;
989 TLIBATTR LibAttr; /* guid,lcid,syskind,version,flags */
990 LCID lcid;
991
992 /* strings can be stored in tlb as multibyte strings BUT they are *always*
993 * exported to the application as a UNICODE string.
994 */
995 BSTR Name;
996 BSTR DocString;
997 BSTR HelpFile;
998 BSTR HelpStringDll;
999 DWORD dwHelpContext;
1000 int TypeInfoCount; /* nr of typeinfo's in librarry */
1001 struct tagITypeInfoImpl **typeinfos;
1002 struct list custdata_list;
1003 struct list implib_list;
1004 int ctTypeDesc; /* number of items in type desc array */
1005 TYPEDESC * pTypeDesc; /* array of TypeDescriptions found in the
1006 library. Only used while reading MSFT
1007 typelibs */
1008 struct list ref_list; /* list of ref types in this typelib */
1009 HREFTYPE dispatch_href; /* reference to IDispatch, -1 if unused */
1010
1011
1012 /* typelibs are cached, keyed by path and index, so store the linked list info within them */
1013 struct list entry;
1014 WCHAR *path;
1015 INT index;
1016 } ITypeLibImpl;
1017
1018 static const ITypeLib2Vtbl tlbvt;
1019 static const ITypeCompVtbl tlbtcvt;
1020
1021 static inline ITypeLibImpl *impl_from_ITypeComp( ITypeComp *iface )
1022 {
1023 return CONTAINING_RECORD(iface, ITypeLibImpl, ITypeComp_iface);
1024 }
1025
1026 /* ITypeLib methods */
1027 static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength);
1028 static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength);
1029
1030 /*======================= ITypeInfo implementation =======================*/
1031
1032 /* data for referenced types */
1033 typedef struct tagTLBRefType
1034 {
1035 INT index; /* Type index for internal ref or for external ref
1036 it the format is SLTG. -2 indicates to
1037 use guid */
1038
1039 GUID guid; /* guid of the referenced type */
1040 /* if index == TLB_REF_USE_GUID */
1041
1042 HREFTYPE reference; /* The href of this ref */
1043 TLBImpLib *pImpTLInfo; /* If ref is external ptr to library data
1044 TLB_REF_INTERNAL for internal refs
1045 TLB_REF_NOT_FOUND for broken refs */
1046
1047 struct list entry;
1048 } TLBRefType;
1049
1050 #define TLB_REF_USE_GUID -2
1051
1052 #define TLB_REF_INTERNAL (void*)-2
1053 #define TLB_REF_NOT_FOUND (void*)-1
1054
1055 /* internal Parameter data */
1056 typedef struct tagTLBParDesc
1057 {
1058 BSTR Name;
1059 struct list custdata_list;
1060 } TLBParDesc;
1061
1062 /* internal Function data */
1063 typedef struct tagTLBFuncDesc
1064 {
1065 FUNCDESC funcdesc; /* lots of info on the function and its attributes. */
1066 BSTR Name; /* the name of this function */
1067 TLBParDesc *pParamDesc; /* array with param names and custom data */
1068 int helpcontext;
1069 int HelpStringContext;
1070 BSTR HelpString;
1071 BSTR Entry; /* if IS_INTRESOURCE true, it's numeric; if -1 it isn't present */
1072 struct list custdata_list;
1073 } TLBFuncDesc;
1074
1075 /* internal Variable data */
1076 typedef struct tagTLBVarDesc
1077 {
1078 VARDESC vardesc; /* lots of info on the variable and its attributes. */
1079 BSTR Name; /* the name of this variable */
1080 int HelpContext;
1081 int HelpStringContext;
1082 BSTR HelpString;
1083 struct list custdata_list;
1084 } TLBVarDesc;
1085
1086 /* internal implemented interface data */
1087 typedef struct tagTLBImplType
1088 {
1089 HREFTYPE hRef; /* hRef of interface */
1090 int implflags; /* IMPLFLAG_*s */
1091 struct list custdata_list;
1092 } TLBImplType;
1093
1094 /* internal TypeInfo data */
1095 typedef struct tagITypeInfoImpl
1096 {
1097 ITypeInfo2 ITypeInfo2_iface;
1098 ITypeComp ITypeComp_iface;
1099 LONG ref;
1100 BOOL not_attached_to_typelib;
1101 TYPEATTR TypeAttr ; /* _lots_ of type information. */
1102 ITypeLibImpl * pTypeLib; /* back pointer to typelib */
1103 int index; /* index in this typelib; */
1104 HREFTYPE hreftype; /* hreftype for app object binding */
1105 /* type libs seem to store the doc strings in ascii
1106 * so why should we do it in unicode?
1107 */
1108 BSTR Name;
1109 BSTR DocString;
1110 BSTR DllName;
1111 DWORD dwHelpContext;
1112 DWORD dwHelpStringContext;
1113
1114 /* functions */
1115 TLBFuncDesc *funcdescs;
1116
1117 /* variables */
1118 TLBVarDesc *vardescs;
1119
1120 /* Implemented Interfaces */
1121 TLBImplType *impltypes;
1122
1123 struct list custdata_list;
1124 } ITypeInfoImpl;
1125
1126 static inline ITypeInfoImpl *info_impl_from_ITypeComp( ITypeComp *iface )
1127 {
1128 return CONTAINING_RECORD(iface, ITypeInfoImpl, ITypeComp_iface);
1129 }
1130
1131 static const ITypeInfo2Vtbl tinfvt;
1132 static const ITypeCompVtbl tcompvt;
1133
1134 static ITypeInfoImpl* ITypeInfoImpl_Constructor(void);
1135 static void ITypeInfoImpl_Destroy(ITypeInfoImpl *This);
1136
1137 typedef struct tagTLBContext
1138 {
1139 unsigned int oStart; /* start of TLB in file */
1140 unsigned int pos; /* current pos */
1141 unsigned int length; /* total length */
1142 void *mapping; /* memory mapping */
1143 MSFT_SegDir * pTblDir;
1144 ITypeLibImpl* pLibInfo;
1145 } TLBContext;
1146
1147
1148 static void MSFT_DoRefType(TLBContext *pcx, ITypeLibImpl *pTL, int offset);
1149
1150 /*
1151 debug
1152 */
1153 static void dump_TypeDesc(const TYPEDESC *pTD,char *szVarType) {
1154 if (pTD->vt & VT_RESERVED)
1155 szVarType += strlen(strcpy(szVarType, "reserved | "));
1156 if (pTD->vt & VT_BYREF)
1157 szVarType += strlen(strcpy(szVarType, "ref to "));
1158 if (pTD->vt & VT_ARRAY)
1159 szVarType += strlen(strcpy(szVarType, "array of "));
1160 if (pTD->vt & VT_VECTOR)
1161 szVarType += strlen(strcpy(szVarType, "vector of "));
1162 switch(pTD->vt & VT_TYPEMASK) {
1163 case VT_UI1: sprintf(szVarType, "VT_UI1"); break;
1164 case VT_I2: sprintf(szVarType, "VT_I2"); break;
1165 case VT_I4: sprintf(szVarType, "VT_I4"); break;
1166 case VT_R4: sprintf(szVarType, "VT_R4"); break;
1167 case VT_R8: sprintf(szVarType, "VT_R8"); break;
1168 case VT_BOOL: sprintf(szVarType, "VT_BOOL"); break;
1169 case VT_ERROR: sprintf(szVarType, "VT_ERROR"); break;
1170 case VT_CY: sprintf(szVarType, "VT_CY"); break;
1171 case VT_DATE: sprintf(szVarType, "VT_DATE"); break;
1172 case VT_BSTR: sprintf(szVarType, "VT_BSTR"); break;
1173 case VT_UNKNOWN: sprintf(szVarType, "VT_UNKNOWN"); break;
1174 case VT_DISPATCH: sprintf(szVarType, "VT_DISPATCH"); break;
1175 case VT_I1: sprintf(szVarType, "VT_I1"); break;
1176 case VT_UI2: sprintf(szVarType, "VT_UI2"); break;
1177 case VT_UI4: sprintf(szVarType, "VT_UI4"); break;
1178 case VT_INT: sprintf(szVarType, "VT_INT"); break;
1179 case VT_UINT: sprintf(szVarType, "VT_UINT"); break;
1180 case VT_VARIANT: sprintf(szVarType, "VT_VARIANT"); break;
1181 case VT_VOID: sprintf(szVarType, "VT_VOID"); break;
1182 case VT_HRESULT: sprintf(szVarType, "VT_HRESULT"); break;
1183 case VT_USERDEFINED: sprintf(szVarType, "VT_USERDEFINED ref = %x",
1184 pTD->u.hreftype); break;
1185 case VT_LPSTR: sprintf(szVarType, "VT_LPSTR"); break;
1186 case VT_LPWSTR: sprintf(szVarType, "VT_LPWSTR"); break;
1187 case VT_PTR: sprintf(szVarType, "ptr to ");
1188 dump_TypeDesc(pTD->u.lptdesc, szVarType + 7);
1189 break;
1190 case VT_SAFEARRAY: sprintf(szVarType, "safearray of ");
1191 dump_TypeDesc(pTD->u.lptdesc, szVarType + 13);
1192 break;
1193 case VT_CARRAY: sprintf(szVarType, "%d dim array of ",
1194 pTD->u.lpadesc->cDims); /* FIXME print out sizes */
1195 dump_TypeDesc(&pTD->u.lpadesc->tdescElem, szVarType + strlen(szVarType));
1196 break;
1197
1198 default: sprintf(szVarType, "unknown(%d)", pTD->vt & VT_TYPEMASK); break;
1199 }
1200 }
1201
1202 static void dump_ELEMDESC(const ELEMDESC *edesc) {
1203 char buf[200];
1204 USHORT flags = edesc->u.paramdesc.wParamFlags;
1205 dump_TypeDesc(&edesc->tdesc,buf);
1206 MESSAGE("\t\ttdesc.vartype %d (%s)\n",edesc->tdesc.vt,buf);
1207 MESSAGE("\t\tu.paramdesc.wParamFlags");
1208 if (!flags) MESSAGE(" PARAMFLAGS_NONE");
1209 if (flags & PARAMFLAG_FIN) MESSAGE(" PARAMFLAG_FIN");
1210 if (flags & PARAMFLAG_FOUT) MESSAGE(" PARAMFLAG_FOUT");
1211 if (flags & PARAMFLAG_FLCID) MESSAGE(" PARAMFLAG_FLCID");
1212 if (flags & PARAMFLAG_FRETVAL) MESSAGE(" PARAMFLAG_FRETVAL");
1213 if (flags & PARAMFLAG_FOPT) MESSAGE(" PARAMFLAG_FOPT");
1214 if (flags & PARAMFLAG_FHASDEFAULT) MESSAGE(" PARAMFLAG_FHASDEFAULT");
1215 if (flags & PARAMFLAG_FHASCUSTDATA) MESSAGE(" PARAMFLAG_FHASCUSTDATA");
1216 MESSAGE("\n\t\tu.paramdesc.lpex %p\n",edesc->u.paramdesc.pparamdescex);
1217 }
1218 static void dump_FUNCDESC(const FUNCDESC *funcdesc) {
1219 int i;
1220 MESSAGE("memid is %08x\n",funcdesc->memid);
1221 for (i=0;i<funcdesc->cParams;i++) {
1222 MESSAGE("Param %d:\n",i);
1223 dump_ELEMDESC(funcdesc->lprgelemdescParam+i);
1224 }
1225 MESSAGE("\tfunckind: %d (",funcdesc->funckind);
1226 switch (funcdesc->funckind) {
1227 case FUNC_VIRTUAL: MESSAGE("virtual");break;
1228 case FUNC_PUREVIRTUAL: MESSAGE("pure virtual");break;
1229 case FUNC_NONVIRTUAL: MESSAGE("nonvirtual");break;
1230 case FUNC_STATIC: MESSAGE("static");break;
1231 case FUNC_DISPATCH: MESSAGE("dispatch");break;
1232 default: MESSAGE("unknown");break;
1233 }
1234 MESSAGE(")\n\tinvkind: %d (",funcdesc->invkind);
1235 switch (funcdesc->invkind) {
1236 case INVOKE_FUNC: MESSAGE("func");break;
1237 case INVOKE_PROPERTYGET: MESSAGE("property get");break;
1238 case INVOKE_PROPERTYPUT: MESSAGE("property put");break;
1239 case INVOKE_PROPERTYPUTREF: MESSAGE("property put ref");break;
1240 }
1241 MESSAGE(")\n\tcallconv: %d (",funcdesc->callconv);
1242 switch (funcdesc->callconv) {
1243 case CC_CDECL: MESSAGE("cdecl");break;
1244 case CC_PASCAL: MESSAGE("pascal");break;
1245 case CC_STDCALL: MESSAGE("stdcall");break;
1246 case CC_SYSCALL: MESSAGE("syscall");break;
1247 default:break;
1248 }
1249 MESSAGE(")\n\toVft: %d\n", funcdesc->oVft);
1250 MESSAGE("\tcParamsOpt: %d\n", funcdesc->cParamsOpt);
1251 MESSAGE("\twFlags: %x\n", funcdesc->wFuncFlags);
1252
1253 MESSAGE("\telemdescFunc (return value type):\n");
1254 dump_ELEMDESC(&funcdesc->elemdescFunc);
1255 }
1256
1257 static const char * const typekind_desc[] =
1258 {
1259 "TKIND_ENUM",
1260 "TKIND_RECORD",
1261 "TKIND_MODULE",
1262 "TKIND_INTERFACE",
1263 "TKIND_DISPATCH",
1264 "TKIND_COCLASS",
1265 "TKIND_ALIAS",
1266 "TKIND_UNION",
1267 "TKIND_MAX"
1268 };
1269
1270 static void dump_TLBFuncDescOne(const TLBFuncDesc * pfd)
1271 {
1272 int i;
1273 MESSAGE("%s(%u)\n", debugstr_w(pfd->Name), pfd->funcdesc.cParams);
1274 for (i=0;i<pfd->funcdesc.cParams;i++)
1275 MESSAGE("\tparm%d: %s\n",i,debugstr_w(pfd->pParamDesc[i].Name));
1276
1277
1278 dump_FUNCDESC(&(pfd->funcdesc));
1279
1280 MESSAGE("\thelpstring: %s\n", debugstr_w(pfd->HelpString));
1281 MESSAGE("\tentry: %s\n", (pfd->Entry == (void *)-1) ? "invalid" : debugstr_w(pfd->Entry));
1282 }
1283 static void dump_TLBFuncDesc(const TLBFuncDesc * pfd, UINT n)
1284 {
1285 while (n)
1286 {
1287 dump_TLBFuncDescOne(pfd);
1288 ++pfd;
1289 --n;
1290 }
1291 }
1292 static void dump_TLBVarDesc(const TLBVarDesc * pvd, UINT n)
1293 {
1294 while (n)
1295 {
1296 TRACE_(typelib)("%s\n", debugstr_w(pvd->Name));
1297 ++pvd;
1298 --n;
1299 }
1300 }
1301
1302 static void dump_TLBImpLib(const TLBImpLib *import)
1303 {
1304 TRACE_(typelib)("%s %s\n", debugstr_guid(&(import->guid)),
1305 debugstr_w(import->name));
1306 TRACE_(typelib)("v%d.%d lcid=%x offset=%x\n", import->wVersionMajor,
1307 import->wVersionMinor, import->lcid, import->offset);
1308 }
1309
1310 static void dump_TLBRefType(const ITypeLibImpl *pTL)
1311 {
1312 TLBRefType *ref;
1313
1314 LIST_FOR_EACH_ENTRY(ref, &pTL->ref_list, TLBRefType, entry)
1315 {
1316 TRACE_(typelib)("href:0x%08x\n", ref->reference);
1317 if(ref->index == -1)
1318 TRACE_(typelib)("%s\n", debugstr_guid(&(ref->guid)));
1319 else
1320 TRACE_(typelib)("type no: %d\n", ref->index);
1321
1322 if(ref->pImpTLInfo != TLB_REF_INTERNAL && ref->pImpTLInfo != TLB_REF_NOT_FOUND)
1323 {
1324 TRACE_(typelib)("in lib\n");
1325 dump_TLBImpLib(ref->pImpTLInfo);
1326 }
1327 }
1328 }
1329
1330 static void dump_TLBImplType(const TLBImplType * impl, UINT n)
1331 {
1332 if(!impl)
1333 return;
1334 while (n) {
1335 TRACE_(typelib)("implementing/inheriting interface hRef = %x implflags %x\n",
1336 impl->hRef, impl->implflags);
1337 ++impl;
1338 --n;
1339 }
1340 }
1341
1342 static void dump_Variant(const VARIANT * pvar)
1343 {
1344 SYSTEMTIME st;
1345
1346 TRACE("%p->{%s%s", pvar, debugstr_VT(pvar), debugstr_VF(pvar));
1347
1348 if (pvar)
1349 {
1350 if (V_ISBYREF(pvar) || V_TYPE(pvar) == VT_UNKNOWN ||
1351 V_TYPE(pvar) == VT_DISPATCH || V_TYPE(pvar) == VT_RECORD)
1352 {
1353 TRACE(",%p", V_BYREF(pvar));
1354 }
1355 else if (V_ISARRAY(pvar) || V_ISVECTOR(pvar))
1356 {
1357 TRACE(",%p", V_ARRAY(pvar));
1358 }
1359 else switch (V_TYPE(pvar))
1360 {
1361 case VT_I1: TRACE(",%d", V_I1(pvar)); break;
1362 case VT_UI1: TRACE(",%d", V_UI1(pvar)); break;
1363 case VT_I2: TRACE(",%d", V_I2(pvar)); break;
1364 case VT_UI2: TRACE(",%d", V_UI2(pvar)); break;
1365 case VT_INT:
1366 case VT_I4: TRACE(",%d", V_I4(pvar)); break;
1367 case VT_UINT:
1368 case VT_UI4: TRACE(",%d", V_UI4(pvar)); break;
1369 case VT_I8: TRACE(",0x%08x,0x%08x", (ULONG)(V_I8(pvar) >> 32),
1370 (ULONG)(V_I8(pvar) & 0xffffffff)); break;
1371 case VT_UI8: TRACE(",0x%08x,0x%08x", (ULONG)(V_UI8(pvar) >> 32),
1372 (ULONG)(V_UI8(pvar) & 0xffffffff)); break;
1373 case VT_R4: TRACE(",%3.3e", V_R4(pvar)); break;
1374 case VT_R8: TRACE(",%3.3e", V_R8(pvar)); break;
1375 case VT_BOOL: TRACE(",%s", V_BOOL(pvar) ? "TRUE" : "FALSE"); break;
1376 case VT_BSTR: TRACE(",%s", debugstr_w(V_BSTR(pvar))); break;
1377 case VT_CY: TRACE(",0x%08x,0x%08x", V_CY(pvar).s.Hi,
1378 V_CY(pvar).s.Lo); break;
1379 case VT_DATE:
1380 if(!VariantTimeToSystemTime(V_DATE(pvar), &st))
1381 TRACE(",<invalid>");
1382 else
1383 TRACE(",%04d/%02d/%02d %02d:%02d:%02d", st.wYear, st.wMonth, st.wDay,
1384 st.wHour, st.wMinute, st.wSecond);
1385 break;
1386 case VT_ERROR:
1387 case VT_VOID:
1388 case VT_USERDEFINED:
1389 case VT_EMPTY:
1390 case VT_NULL: break;
1391 default: TRACE(",?"); break;
1392 }
1393 }
1394 TRACE("}\n");
1395 }
1396
1397 static void dump_DispParms(const DISPPARAMS * pdp)
1398 {
1399 unsigned int index;
1400
1401 TRACE("args=%u named args=%u\n", pdp->cArgs, pdp->cNamedArgs);
1402
1403 if (pdp->cNamedArgs && pdp->rgdispidNamedArgs)
1404 {
1405 TRACE("named args:\n");
1406 for (index = 0; index < pdp->cNamedArgs; index++)
1407 TRACE( "\t0x%x\n", pdp->rgdispidNamedArgs[index] );
1408 }
1409
1410 if (pdp->cArgs && pdp->rgvarg)
1411 {
1412 TRACE("args:\n");
1413 for (index = 0; index < pdp->cArgs; index++)
1414 dump_Variant( &pdp->rgvarg[index] );
1415 }
1416 }
1417
1418 static void dump_TypeInfo(const ITypeInfoImpl * pty)
1419 {
1420 TRACE("%p ref=%u\n", pty, pty->ref);
1421 TRACE("%s %s\n", debugstr_w(pty->Name), debugstr_w(pty->DocString));
1422 TRACE("attr:%s\n", debugstr_guid(&(pty->TypeAttr.guid)));
1423 TRACE("kind:%s\n", typekind_desc[pty->TypeAttr.typekind]);
1424 TRACE("fct:%u var:%u impl:%u\n",
1425 pty->TypeAttr.cFuncs, pty->TypeAttr.cVars, pty->TypeAttr.cImplTypes);
1426 TRACE("wTypeFlags: 0x%04x\n", pty->TypeAttr.wTypeFlags);
1427 TRACE("parent tlb:%p index in TLB:%u\n",pty->pTypeLib, pty->index);
1428 if (pty->TypeAttr.typekind == TKIND_MODULE) TRACE("dllname:%s\n", debugstr_w(pty->DllName));
1429 if (TRACE_ON(ole))
1430 dump_TLBFuncDesc(pty->funcdescs, pty->TypeAttr.cFuncs);
1431 dump_TLBVarDesc(pty->vardescs, pty->TypeAttr.cVars);
1432 dump_TLBImplType(pty->impltypes, pty->TypeAttr.cImplTypes);
1433 }
1434
1435 static void dump_VARDESC(const VARDESC *v)
1436 {
1437 MESSAGE("memid %d\n",v->memid);
1438 MESSAGE("lpstrSchema %s\n",debugstr_w(v->lpstrSchema));
1439 MESSAGE("oInst %d\n",v->u.oInst);
1440 dump_ELEMDESC(&(v->elemdescVar));
1441 MESSAGE("wVarFlags %x\n",v->wVarFlags);
1442 MESSAGE("varkind %d\n",v->varkind);
1443 }
1444
1445 static TYPEDESC std_typedesc[VT_LPWSTR+1] =
1446 {
1447 /* VT_LPWSTR is largest type that, may appear in type description */
1448 {{0}, VT_EMPTY}, {{0}, VT_NULL}, {{0}, VT_I2}, {{0}, VT_I4},
1449 {{0}, VT_R4}, {{0}, VT_R8}, {{0}, VT_CY}, {{0}, VT_DATE},
1450 {{0}, VT_BSTR}, {{0}, VT_DISPATCH}, {{0}, VT_ERROR}, {{0}, VT_BOOL},
1451 {{0}, VT_VARIANT},{{0}, VT_UNKNOWN}, {{0}, VT_DECIMAL}, {{0}, 15}, /* unused in VARENUM */
1452 {{0}, VT_I1}, {{0}, VT_UI1}, {{0}, VT_UI2}, {{0}, VT_UI4},
1453 {{0}, VT_I8}, {{0}, VT_UI8}, {{0}, VT_INT}, {{0}, VT_UINT},
1454 {{0}, VT_VOID}, {{0}, VT_HRESULT}, {{0}, VT_PTR}, {{0}, VT_SAFEARRAY},
1455 {{0}, VT_CARRAY}, {{0}, VT_USERDEFINED}, {{0}, VT_LPSTR}, {{0}, VT_LPWSTR}
1456 };
1457
1458 static void TLB_abort(void)
1459 {
1460 DebugBreak();
1461 }
1462
1463 void* __WINE_ALLOC_SIZE(1) heap_alloc_zero(unsigned size)
1464 {
1465 void *ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
1466 if (!ret) ERR("cannot allocate memory\n");
1467 return ret;
1468 }
1469
1470 void* __WINE_ALLOC_SIZE(1) heap_alloc(unsigned size)
1471 {
1472 void *ret = HeapAlloc(GetProcessHeap(), 0, size);
1473 if (!ret) ERR("cannot allocate memory\n");
1474 return ret;
1475 }
1476
1477 void* __WINE_ALLOC_SIZE(2) heap_realloc(void *ptr, unsigned size)
1478 {
1479 return HeapReAlloc(GetProcessHeap(), 0, ptr, size);
1480 }
1481
1482 void heap_free(void *ptr)
1483 {
1484 HeapFree(GetProcessHeap(), 0, ptr);
1485 }
1486
1487 /* returns the size required for a deep copy of a typedesc into a
1488 * flat buffer */
1489 static SIZE_T TLB_SizeTypeDesc( const TYPEDESC *tdesc, BOOL alloc_initial_space )
1490 {
1491 SIZE_T size = 0;
1492
1493 if (alloc_initial_space)
1494 size += sizeof(TYPEDESC);
1495
1496 switch (tdesc->vt)
1497 {
1498 case VT_PTR:
1499 case VT_SAFEARRAY:
1500 size += TLB_SizeTypeDesc(tdesc->u.lptdesc, TRUE);
1501 break;
1502 case VT_CARRAY:
1503 size += FIELD_OFFSET(ARRAYDESC, rgbounds[tdesc->u.lpadesc->cDims]);
1504 size += TLB_SizeTypeDesc(&tdesc->u.lpadesc->tdescElem, FALSE);
1505 break;
1506 }
1507 return size;
1508 }
1509
1510 /* deep copy a typedesc into a flat buffer */
1511 static void *TLB_CopyTypeDesc( TYPEDESC *dest, const TYPEDESC *src, void *buffer )
1512 {
1513 if (!dest)
1514 {
1515 dest = buffer;
1516 buffer = (char *)buffer + sizeof(TYPEDESC);
1517 }
1518
1519 *dest = *src;
1520
1521 switch (src->vt)
1522 {
1523 case VT_PTR:
1524 case VT_SAFEARRAY:
1525 dest->u.lptdesc = buffer;
1526 buffer = TLB_CopyTypeDesc(NULL, src->u.lptdesc, buffer);
1527 break;
1528 case VT_CARRAY:
1529 dest->u.lpadesc = buffer;
1530 memcpy(dest->u.lpadesc, src->u.lpadesc, FIELD_OFFSET(ARRAYDESC, rgbounds[src->u.lpadesc->cDims]));
1531 buffer = (char *)buffer + FIELD_OFFSET(ARRAYDESC, rgbounds[src->u.lpadesc->cDims]);
1532 buffer = TLB_CopyTypeDesc(&dest->u.lpadesc->tdescElem, &src->u.lpadesc->tdescElem, buffer);
1533 break;
1534 }
1535 return buffer;
1536 }
1537
1538 /* free custom data allocated by MSFT_CustData */
1539 static inline void TLB_FreeCustData(struct list *custdata_list)
1540 {
1541 TLBCustData *cd, *cdn;
1542 LIST_FOR_EACH_ENTRY_SAFE(cd, cdn, custdata_list, TLBCustData, entry)
1543 {
1544 list_remove(&cd->entry);
1545 VariantClear(&cd->data);
1546 heap_free(cd);
1547 }
1548 }
1549
1550 static BSTR TLB_MultiByteToBSTR(const char *ptr)
1551 {
1552 DWORD len;
1553 BSTR ret;
1554
1555 len = MultiByteToWideChar(CP_ACP, 0, ptr, -1, NULL, 0);
1556 ret = SysAllocStringLen(NULL, len - 1);
1557 if (!ret) return ret;
1558 MultiByteToWideChar(CP_ACP, 0, ptr, -1, ret, len);
1559 return ret;
1560 }
1561
1562 static inline TLBFuncDesc *TLB_get_funcdesc_by_memberid(TLBFuncDesc *funcdescs,
1563 UINT n, MEMBERID memid)
1564 {
1565 while(n){
1566 if(funcdescs->funcdesc.memid == memid)
1567 return funcdescs;
1568 ++funcdescs;
1569 --n;
1570 }
1571 return NULL;
1572 }
1573
1574 static inline TLBFuncDesc *TLB_get_funcdesc_by_name(TLBFuncDesc *funcdescs,
1575 UINT n, const OLECHAR *name)
1576 {
1577 while(n){
1578 if(!lstrcmpiW(funcdescs->Name, name))
1579 return funcdescs;
1580 ++funcdescs;
1581 --n;
1582 }
1583 return NULL;
1584 }
1585
1586 static inline TLBVarDesc *TLB_get_vardesc_by_memberid(TLBVarDesc *vardescs,
1587 UINT n, MEMBERID memid)
1588 {
1589 while(n){
1590 if(vardescs->vardesc.memid == memid)
1591 return vardescs;
1592 ++vardescs;
1593 --n;
1594 }
1595 return NULL;
1596 }
1597
1598 static inline TLBVarDesc *TLB_get_vardesc_by_name(TLBVarDesc *vardescs,
1599 UINT n, const OLECHAR *name)
1600 {
1601 while(n){
1602 if(!lstrcmpiW(vardescs->Name, name))
1603 return vardescs;
1604 ++vardescs;
1605 --n;
1606 }
1607 return NULL;
1608 }
1609
1610 static inline TLBCustData *TLB_get_custdata_by_guid(struct list *custdata_list, REFGUID guid)
1611 {
1612 TLBCustData *cust_data;
1613 LIST_FOR_EACH_ENTRY(cust_data, custdata_list, TLBCustData, entry)
1614 if(IsEqualIID(&cust_data->guid, guid))
1615 return cust_data;
1616 return NULL;
1617 }
1618
1619 static TLBVarDesc *TLBVarDesc_Constructor(UINT n)
1620 {
1621 TLBVarDesc *ret;
1622
1623 ret = heap_alloc_zero(sizeof(TLBVarDesc) * n);
1624 if(!ret)
1625 return NULL;
1626
1627 while(n){
1628 list_init(&ret[n-1].custdata_list);
1629 --n;
1630 }
1631
1632 return ret;
1633 }
1634
1635 static TLBParDesc *TLBParDesc_Constructor(UINT n)
1636 {
1637 TLBParDesc *ret;
1638
1639 ret = heap_alloc_zero(sizeof(TLBParDesc) * n);
1640 if(!ret)
1641 return NULL;
1642
1643 while(n){
1644 list_init(&ret[n-1].custdata_list);
1645 --n;
1646 }
1647
1648 return ret;
1649 }
1650
1651 static TLBFuncDesc *TLBFuncDesc_Constructor(UINT n)
1652 {
1653 TLBFuncDesc *ret;
1654
1655 ret = heap_alloc_zero(sizeof(TLBFuncDesc) * n);
1656 if(!ret)
1657 return NULL;
1658
1659 while(n){
1660 list_init(&ret[n-1].custdata_list);
1661 --n;
1662 }
1663
1664 return ret;
1665 }
1666
1667 static TLBImplType *TLBImplType_Constructor(UINT n)
1668 {
1669 TLBImplType *ret;
1670
1671 ret = heap_alloc_zero(sizeof(TLBImplType) * n);
1672 if(!ret)
1673 return NULL;
1674
1675 while(n){
1676 list_init(&ret[n-1].custdata_list);
1677 --n;
1678 }
1679
1680 return ret;
1681 }
1682
1683 /**********************************************************************
1684 *
1685 * Functions for reading MSFT typelibs (those created by CreateTypeLib2)
1686 */
1687 static inline unsigned int MSFT_Tell(const TLBContext *pcx)
1688 {
1689 return pcx->pos;
1690 }
1691
1692 static inline void MSFT_Seek(TLBContext *pcx, LONG where)
1693 {
1694 if (where != DO_NOT_SEEK)
1695 {
1696 where += pcx->oStart;
1697 if (where > pcx->length)
1698 {
1699 /* FIXME */
1700 ERR("seek beyond end (%d/%d)\n", where, pcx->length );
1701 TLB_abort();
1702 }
1703 pcx->pos = where;
1704 }
1705 }
1706
1707 /* read function */
1708 static DWORD MSFT_Read(void *buffer, DWORD count, TLBContext *pcx, LONG where )
1709 {
1710 TRACE_(typelib)("pos=0x%08x len=0x%08x 0x%08x 0x%08x 0x%08x\n",
1711 pcx->pos, count, pcx->oStart, pcx->length, where);
1712
1713 MSFT_Seek(pcx, where);
1714 if (pcx->pos + count > pcx->length) count = pcx->length - pcx->pos;
1715 memcpy( buffer, (char *)pcx->mapping + pcx->pos, count );
1716 pcx->pos += count;
1717 return count;
1718 }
1719
1720 static DWORD MSFT_ReadLEDWords(void *buffer, DWORD count, TLBContext *pcx,
1721 LONG where )
1722 {
1723 DWORD ret;
1724
1725 ret = MSFT_Read(buffer, count, pcx, where);
1726 FromLEDWords(buffer, ret);
1727
1728 return ret;
1729 }
1730
1731 static DWORD MSFT_ReadLEWords(void *buffer, DWORD count, TLBContext *pcx,
1732 LONG where )
1733 {
1734 DWORD ret;
1735
1736 ret = MSFT_Read(buffer, count, pcx, where);
1737 FromLEWords(buffer, ret);
1738
1739 return ret;
1740 }
1741
1742 static void MSFT_ReadGuid( GUID *pGuid, int offset, TLBContext *pcx)
1743 {
1744 if(offset<0 || pcx->pTblDir->pGuidTab.offset <0){
1745 memset(pGuid,0, sizeof(GUID));
1746 return;
1747 }
1748 MSFT_Read(pGuid, sizeof(GUID), pcx, pcx->pTblDir->pGuidTab.offset+offset );
1749 pGuid->Data1 = FromLEDWord(pGuid->Data1);
1750 pGuid->Data2 = FromLEWord(pGuid->Data2);
1751 pGuid->Data3 = FromLEWord(pGuid->Data3);
1752 TRACE_(typelib)("%s\n", debugstr_guid(pGuid));
1753 }
1754
1755 static HREFTYPE MSFT_ReadHreftype( TLBContext *pcx, int offset )
1756 {
1757 MSFT_NameIntro niName;
1758
1759 if (offset < 0)
1760 {
1761 ERR_(typelib)("bad offset %d\n", offset);
1762 return -1;
1763 }
1764
1765 MSFT_ReadLEDWords(&niName, sizeof(niName), pcx,
1766 pcx->pTblDir->pNametab.offset+offset);
1767
1768 return niName.hreftype;
1769 }
1770
1771 static BSTR MSFT_ReadName( TLBContext *pcx, int offset)
1772 {
1773 char * name;
1774 MSFT_NameIntro niName;
1775 int lengthInChars;
1776 BSTR bstrName = NULL;
1777
1778 if (offset < 0)
1779 {
1780 ERR_(typelib)("bad offset %d\n", offset);
1781 return NULL;
1782 }
1783 MSFT_ReadLEDWords(&niName, sizeof(niName), pcx,
1784 pcx->pTblDir->pNametab.offset+offset);
1785 niName.namelen &= 0xFF; /* FIXME: correct ? */
1786 name = heap_alloc_zero((niName.namelen & 0xff) +1);
1787 MSFT_Read(name, (niName.namelen & 0xff), pcx, DO_NOT_SEEK);
1788 name[niName.namelen & 0xff]='\0';
1789
1790 lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
1791 name, -1, NULL, 0);
1792
1793 /* no invalid characters in string */
1794 if (lengthInChars)
1795 {
1796 bstrName = SysAllocStringByteLen(NULL, lengthInChars * sizeof(WCHAR));
1797
1798 /* don't check for invalid character since this has been done previously */
1799 MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, name, -1, bstrName, lengthInChars);
1800 }
1801 heap_free(name);
1802
1803 TRACE_(typelib)("%s %d\n", debugstr_w(bstrName), lengthInChars);
1804 return bstrName;
1805 }
1806
1807 static BSTR MSFT_ReadString( TLBContext *pcx, int offset)
1808 {
1809 char * string;
1810 INT16 length;
1811 int lengthInChars;
1812 BSTR bstr = NULL;
1813
1814 if(offset<0) return NULL;
1815 MSFT_ReadLEWords(&length, sizeof(INT16), pcx, pcx->pTblDir->pStringtab.offset+offset);
1816 if(length <= 0) return 0;
1817 string = heap_alloc_zero(length +1);
1818 MSFT_Read(string, length, pcx, DO_NOT_SEEK);
1819 string[length]='\0';
1820
1821 lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
1822 string, -1, NULL, 0);
1823
1824 /* no invalid characters in string */
1825 if (lengthInChars)
1826 {
1827 bstr = SysAllocStringByteLen(NULL, lengthInChars * sizeof(WCHAR));
1828
1829 /* don't check for invalid character since this has been done previously */
1830 MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, string, -1, bstr, lengthInChars);
1831 }
1832 heap_free(string);
1833
1834 TRACE_(typelib)("%s %d\n", debugstr_w(bstr), lengthInChars);
1835 return bstr;
1836 }
1837 /*
1838 * read a value and fill a VARIANT structure
1839 */
1840 static void MSFT_ReadValue( VARIANT * pVar, int offset, TLBContext *pcx )
1841 {
1842 int size;
1843
1844 TRACE_(typelib)("\n");
1845
1846 if(offset <0) { /* data are packed in here */
1847 V_VT(pVar) = (offset & 0x7c000000 )>> 26;
1848 V_I4(pVar) = offset & 0x3ffffff;
1849 return;
1850 }
1851 MSFT_ReadLEWords(&(V_VT(pVar)), sizeof(VARTYPE), pcx,
1852 pcx->pTblDir->pCustData.offset + offset );
1853 TRACE_(typelib)("Vartype = %x\n", V_VT(pVar));
1854 switch (V_VT(pVar)){
1855 case VT_EMPTY: /* FIXME: is this right? */
1856 case VT_NULL: /* FIXME: is this right? */
1857 case VT_I2 : /* this should not happen */
1858 case VT_I4 :
1859 case VT_R4 :
1860 case VT_ERROR :
1861 case VT_BOOL :
1862 case VT_I1 :
1863 case VT_UI1 :
1864 case VT_UI2 :
1865 case VT_UI4 :
1866 case VT_INT :
1867 case VT_UINT :
1868 case VT_VOID : /* FIXME: is this right? */
1869 case VT_HRESULT :
1870 size=4; break;
1871 case VT_R8 :
1872 case VT_CY :
1873 case VT_DATE :
1874 case VT_I8 :
1875 case VT_UI8 :
1876 case VT_DECIMAL : /* FIXME: is this right? */
1877 case VT_FILETIME :
1878 size=8;break;
1879 /* pointer types with known behaviour */
1880 case VT_BSTR :{
1881 char * ptr;
1882 MSFT_ReadLEDWords(&size, sizeof(INT), pcx, DO_NOT_SEEK );
1883 if(size < 0) {
1884 char next;
1885 DWORD origPos = MSFT_Tell(pcx), nullPos;
1886
1887 do {
1888 MSFT_Read(&next, 1, pcx, DO_NOT_SEEK);
1889 } while (next);
1890 nullPos = MSFT_Tell(pcx);
1891 size = nullPos - origPos;
1892 MSFT_Seek(pcx, origPos);
1893 }
1894 ptr = heap_alloc_zero(size);/* allocate temp buffer */
1895 MSFT_Read(ptr, size, pcx, DO_NOT_SEEK);/* read string (ANSI) */
1896 V_BSTR(pVar)=SysAllocStringLen(NULL,size);
1897 /* FIXME: do we need a AtoW conversion here? */
1898 V_UNION(pVar, bstrVal[size])='\0';
1899 while(size--) V_UNION(pVar, bstrVal[size])=ptr[size];
1900 heap_free(ptr);
1901 }
1902 size=-4; break;
1903 /* FIXME: this will not work AT ALL when the variant contains a pointer */
1904 case VT_DISPATCH :
1905 case VT_VARIANT :
1906 case VT_UNKNOWN :
1907 case VT_PTR :
1908 case VT_SAFEARRAY :
1909 case VT_CARRAY :
1910 case VT_USERDEFINED :
1911 case VT_LPSTR :
1912 case VT_LPWSTR :
1913 case VT_BLOB :
1914 case VT_STREAM :
1915 case VT_STORAGE :
1916 case VT_STREAMED_OBJECT :
1917 case VT_STORED_OBJECT :
1918 case VT_BLOB_OBJECT :
1919 case VT_CF :
1920 case VT_CLSID :
1921 default:
1922 size=0;
1923 FIXME("VARTYPE %d is not supported, setting pointer to NULL\n",
1924 V_VT(pVar));
1925 }
1926
1927 if(size>0) /* (big|small) endian correct? */
1928 MSFT_Read(&(V_I2(pVar)), size, pcx, DO_NOT_SEEK );
1929 return;
1930 }
1931 /*
1932 * create a linked list with custom data
1933 */
1934 static int MSFT_CustData( TLBContext *pcx, int offset, struct list *custdata_list)
1935 {
1936 MSFT_CDGuid entry;
1937 TLBCustData* pNew;
1938 int count=0;
1939
1940 TRACE_(typelib)("\n");
1941
1942 if (pcx->pTblDir->pCDGuids.offset < 0) return 0;
1943
1944 while(offset >=0){
1945 count++;
1946 pNew=heap_alloc_zero(sizeof(TLBCustData));
1947 MSFT_ReadLEDWords(&entry, sizeof(entry), pcx, pcx->pTblDir->pCDGuids.offset+offset);
1948 MSFT_ReadGuid(&(pNew->guid), entry.GuidOffset , pcx);
1949 MSFT_ReadValue(&(pNew->data), entry.DataOffset, pcx);
1950 list_add_head(custdata_list, &pNew->entry);
1951 offset = entry.next;
1952 }
1953 return count;
1954 }
1955
1956 static void MSFT_GetTdesc(TLBContext *pcx, INT type, TYPEDESC *pTd,
1957 ITypeInfoImpl *pTI)
1958 {
1959 if(type <0)
1960 pTd->vt=type & VT_TYPEMASK;
1961 else
1962 *pTd=pcx->pLibInfo->pTypeDesc[type/(2*sizeof(INT))];
1963
1964 if(pTd->vt == VT_USERDEFINED)
1965 MSFT_DoRefType(pcx, pTI->pTypeLib, pTd->u.hreftype);
1966
1967 TRACE_(typelib)("vt type = %X\n", pTd->vt);
1968 }
1969
1970 static void MSFT_ResolveReferencedTypes(TLBContext *pcx, ITypeInfoImpl *pTI, TYPEDESC *lpTypeDesc)
1971 {
1972 /* resolve referenced type if any */
1973 while (lpTypeDesc)
1974 {
1975 switch (lpTypeDesc->vt)
1976 {
1977 case VT_PTR:
1978 lpTypeDesc = lpTypeDesc->u.lptdesc;
1979 break;
1980
1981 case VT_CARRAY:
1982 lpTypeDesc = & (lpTypeDesc->u.lpadesc->tdescElem);
1983 break;
1984
1985 case VT_USERDEFINED:
1986 MSFT_DoRefType(pcx, pTI->pTypeLib,
1987 lpTypeDesc->u.hreftype);
1988
1989 lpTypeDesc = NULL;
1990 break;
1991
1992 default:
1993 lpTypeDesc = NULL;
1994 }
1995 }
1996 }
1997
1998 static void
1999 MSFT_DoFuncs(TLBContext* pcx,
2000 ITypeInfoImpl* pTI,
2001 int cFuncs,
2002 int cVars,
2003 int offset,
2004 TLBFuncDesc** pptfd)
2005 {
2006 /*
2007 * member information is stored in a data structure at offset
2008 * indicated by the memoffset field of the typeinfo structure
2009 * There are several distinctive parts.
2010 * The first part starts with a field that holds the total length
2011 * of this (first) part excluding this field. Then follow the records,
2012 * for each member there is one record.
2013 *
2014 * The first entry is always the length of the record (including this
2015 * length word).
2016 * The rest of the record depends on the type of the member. If there is
2017 * a field indicating the member type (function, variable, interface, etc)
2018 * I have not found it yet. At this time we depend on the information
2019 * in the type info and the usual order how things are stored.
2020 *
2021 * Second follows an array sized nrMEM*sizeof(INT) with a member id
2022 * for each member;
2023 *
2024 * Third is an equal sized array with file offsets to the name entry
2025 * of each member.
2026 *
2027 * The fourth and last (?) part is an array with offsets to the records
2028 * in the first part of this file segment.
2029 */
2030
2031 int infolen, nameoffset, reclength, i;
2032 int recoffset = offset + sizeof(INT);
2033
2034 char *recbuf = heap_alloc(0xffff);
2035 MSFT_FuncRecord *pFuncRec = (MSFT_FuncRecord*)recbuf;
2036 TLBFuncDesc *ptfd_prev = NULL, *ptfd;
2037
2038 TRACE_(typelib)("\n");
2039
2040 MSFT_ReadLEDWords(&infolen, sizeof(INT), pcx, offset);
2041
2042 *pptfd = TLBFuncDesc_Constructor(cFuncs);
2043 ptfd = *pptfd;
2044 for ( i = 0; i < cFuncs ; i++ )
2045 {
2046 int optional;
2047
2048 /* name, eventually add to a hash table */
2049 MSFT_ReadLEDWords(&nameoffset, sizeof(INT), pcx,
2050 offset + infolen + (cFuncs + cVars + i + 1) * sizeof(INT));
2051
2052 /* nameoffset is sometimes -1 on the second half of a propget/propput
2053 * pair of functions */
2054 if ((nameoffset == -1) && (i > 0))
2055 ptfd->Name = SysAllocString(ptfd_prev->Name);
2056 else
2057 ptfd->Name = MSFT_ReadName(pcx, nameoffset);
2058
2059 /* read the function information record */
2060 MSFT_ReadLEDWords(&reclength, sizeof(pFuncRec->Info), pcx, recoffset);
2061
2062 reclength &= 0xffff;
2063
2064 MSFT_ReadLEDWords(&pFuncRec->DataType, reclength - FIELD_OFFSET(MSFT_FuncRecord, DataType), pcx, DO_NOT_SEEK);
2065
2066 /* size without argument data */
2067 optional = reclength - pFuncRec->nrargs*sizeof(MSFT_ParameterInfo);
2068
2069 if (optional > FIELD_OFFSET(MSFT_FuncRecord, HelpContext))
2070 ptfd->helpcontext = pFuncRec->HelpContext;
2071
2072 if (optional > FIELD_OFFSET(MSFT_FuncRecord, oHelpString))
2073 ptfd->HelpString = MSFT_ReadString(pcx, pFuncRec->oHelpString);
2074
2075 if (optional > FIELD_OFFSET(MSFT_FuncRecord, oEntry))
2076 {
2077 if (pFuncRec->FKCCIC & 0x2000 )
2078 {
2079 if (!IS_INTRESOURCE(pFuncRec->oEntry))
2080 ERR("ordinal 0x%08x invalid, IS_INTRESOURCE is false\n", pFuncRec->oEntry);
2081 ptfd->Entry = (BSTR)(DWORD_PTR)LOWORD(pFuncRec->oEntry);
2082 }
2083 else
2084 ptfd->Entry = MSFT_ReadString(pcx, pFuncRec->oEntry);
2085 }
2086 else
2087 ptfd->Entry = (BSTR)-1;
2088
2089 if (optional > FIELD_OFFSET(MSFT_FuncRecord, HelpStringContext))
2090 ptfd->HelpStringContext = pFuncRec->HelpStringContext;
2091
2092 if (optional > FIELD_OFFSET(MSFT_FuncRecord, oCustData) && pFuncRec->FKCCIC & 0x80)
2093 MSFT_CustData(pcx, pFuncRec->oCustData, &ptfd->custdata_list);
2094
2095 /* fill the FuncDesc Structure */
2096 MSFT_ReadLEDWords( & ptfd->funcdesc.memid, sizeof(INT), pcx,
2097 offset + infolen + ( i + 1) * sizeof(INT));
2098
2099 ptfd->funcdesc.funckind = (pFuncRec->FKCCIC) & 0x7;
2100 ptfd->funcdesc.invkind = (pFuncRec->FKCCIC) >> 3 & 0xF;
2101 ptfd->funcdesc.callconv = (pFuncRec->FKCCIC) >> 8 & 0xF;
2102 ptfd->funcdesc.cParams = pFuncRec->nrargs ;
2103 ptfd->funcdesc.cParamsOpt = pFuncRec->nroargs ;
2104 ptfd->funcdesc.oVft = pFuncRec->VtableOffset & ~1;
2105 ptfd->funcdesc.wFuncFlags = LOWORD(pFuncRec->Flags) ;
2106
2107 MSFT_GetTdesc(pcx,
2108 pFuncRec->DataType,
2109 &ptfd->funcdesc.elemdescFunc.tdesc,
2110 pTI);
2111 MSFT_ResolveReferencedTypes(pcx, pTI, &ptfd->funcdesc.elemdescFunc.tdesc);
2112
2113 /* do the parameters/arguments */
2114 if(pFuncRec->nrargs)
2115 {
2116 int j = 0;
2117 MSFT_ParameterInfo paraminfo;
2118
2119 ptfd->funcdesc.lprgelemdescParam =
2120 heap_alloc_zero(pFuncRec->nrargs * sizeof(ELEMDESC));
2121
2122 ptfd->pParamDesc = TLBParDesc_Constructor(pFuncRec->nrargs);
2123
2124 MSFT_ReadLEDWords(&paraminfo, sizeof(paraminfo), pcx,
2125 recoffset + reclength - pFuncRec->nrargs * sizeof(MSFT_ParameterInfo));
2126
2127 for ( j = 0 ; j < pFuncRec->nrargs ; j++ )
2128 {
2129 ELEMDESC *elemdesc = &ptfd->funcdesc.lprgelemdescParam[j];
2130
2131 MSFT_GetTdesc(pcx,
2132 paraminfo.DataType,
2133 &elemdesc->tdesc,
2134 pTI);
2135
2136 elemdesc->u.paramdesc.wParamFlags = paraminfo.Flags;
2137
2138 /* name */
2139 if (paraminfo.oName == -1)
2140 /* this occurs for [propput] or [propget] methods, so
2141 * we should just set the name of the parameter to the
2142 * name of the method. */
2143 ptfd->pParamDesc[j].Name = SysAllocString(ptfd->Name);
2144 else
2145 ptfd->pParamDesc[j].Name =
2146 MSFT_ReadName( pcx, paraminfo.oName );
2147 TRACE_(typelib)("param[%d] = %s\n", j, debugstr_w(ptfd->pParamDesc[j].Name));
2148
2149 MSFT_ResolveReferencedTypes(pcx, pTI, &elemdesc->tdesc);
2150
2151 /* default value */
2152 if ( (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT) &&
2153 (pFuncRec->FKCCIC & 0x1000) )
2154 {
2155 INT* pInt = (INT *)((char *)pFuncRec +
2156 reclength -
2157 (pFuncRec->nrargs * 4) * sizeof(INT) );
2158
2159 PARAMDESC* pParamDesc = &elemdesc->u.paramdesc;
2160
2161 pParamDesc->pparamdescex = heap_alloc_zero(sizeof(PARAMDESCEX));
2162 pParamDesc->pparamdescex->cBytes = sizeof(PARAMDESCEX);
2163
2164 MSFT_ReadValue(&(pParamDesc->pparamdescex->varDefaultValue),
2165 pInt[j], pcx);
2166 }
2167 else
2168 elemdesc->u.paramdesc.pparamdescex = NULL;
2169
2170 /* custom info */
2171 if (optional > (FIELD_OFFSET(MSFT_FuncRecord, oArgCustData) +
2172 j*sizeof(pFuncRec->oArgCustData[0])) &&
2173 pFuncRec->FKCCIC & 0x80 )
2174 {
2175 MSFT_CustData(pcx,
2176 pFuncRec->oArgCustData[j],
2177 &ptfd->pParamDesc[j].custdata_list);
2178 }
2179
2180 /* SEEK value = jump to offset,
2181 * from there jump to the end of record,
2182 * go back by (j-1) arguments
2183 */
2184 MSFT_ReadLEDWords( &paraminfo ,
2185 sizeof(MSFT_ParameterInfo), pcx,
2186 recoffset + reclength - ((pFuncRec->nrargs - j - 1)
2187 * sizeof(MSFT_ParameterInfo)));
2188 }
2189 }
2190
2191 /* scode is not used: archaic win16 stuff FIXME: right? */
2192 ptfd->funcdesc.cScodes = 0 ;
2193 ptfd->funcdesc.lprgscode = NULL ;
2194
2195 ptfd_prev = ptfd;
2196 ++ptfd;
2197 recoffset += reclength;
2198 }
2199 heap_free(recbuf);
2200 }
2201
2202 static void MSFT_DoVars(TLBContext *pcx, ITypeInfoImpl *pTI, int cFuncs,
2203 int cVars, int offset, TLBVarDesc ** pptvd)
2204 {
2205 int infolen, nameoffset, reclength;
2206 char recbuf[256];
2207 MSFT_VarRecord *pVarRec = (MSFT_VarRecord*)recbuf;
2208 TLBVarDesc *ptvd;
2209 int i;
2210 int recoffset;
2211
2212 TRACE_(typelib)("\n");
2213
2214 ptvd = *pptvd = TLBVarDesc_Constructor(cVars);
2215 MSFT_ReadLEDWords(&infolen,sizeof(INT), pcx, offset);
2216 MSFT_ReadLEDWords(&recoffset,sizeof(INT), pcx, offset + infolen +
2217 ((cFuncs+cVars)*2+cFuncs + 1)*sizeof(INT));
2218 recoffset += offset+sizeof(INT);
2219 for(i=0;i<cVars;i++, ++ptvd){
2220 /* name, eventually add to a hash table */
2221 MSFT_ReadLEDWords(&nameoffset, sizeof(INT), pcx,
2222 offset + infolen + (2*cFuncs + cVars + i + 1) * sizeof(INT));
2223 ptvd->Name=MSFT_ReadName(pcx, nameoffset);
2224 /* read the variable information record */
2225 MSFT_ReadLEDWords(&reclength, sizeof(pVarRec->Info), pcx, recoffset);
2226 reclength &= 0xff;
2227 MSFT_ReadLEDWords(&pVarRec->DataType, reclength - FIELD_OFFSET(MSFT_VarRecord, DataType), pcx, DO_NOT_SEEK);
2228
2229 /* optional data */
2230 if(reclength > FIELD_OFFSET(MSFT_VarRecord, HelpContext))
2231 ptvd->HelpContext = pVarRec->HelpContext;
2232
2233 if(reclength > FIELD_OFFSET(MSFT_VarRecord, HelpString))
2234 ptvd->HelpString = MSFT_ReadString(pcx, pVarRec->HelpString);
2235
2236 if(reclength > FIELD_OFFSET(MSFT_VarRecord, HelpStringContext))
2237 ptvd->HelpStringContext = pVarRec->HelpStringContext;
2238
2239 /* fill the VarDesc Structure */
2240 MSFT_ReadLEDWords(&ptvd->vardesc.memid, sizeof(INT), pcx,
2241 offset + infolen + (cFuncs + i + 1) * sizeof(INT));
2242 ptvd->vardesc.varkind = pVarRec->VarKind;
2243 ptvd->vardesc.wVarFlags = pVarRec->Flags;
2244 MSFT_GetTdesc(pcx, pVarRec->DataType,
2245 &ptvd->vardesc.elemdescVar.tdesc, pTI);
2246 /* ptvd->vardesc.lpstrSchema; is reserved (SDK) FIXME?? */
2247 if(pVarRec->VarKind == VAR_CONST ){
2248 ptvd->vardesc.u.lpvarValue = heap_alloc_zero(sizeof(VARIANT));
2249 MSFT_ReadValue(ptvd->vardesc.u.lpvarValue,
2250 pVarRec->OffsValue, pcx);
2251 } else
2252 ptvd->vardesc.u.oInst=pVarRec->OffsValue;
2253 MSFT_ResolveReferencedTypes(pcx, pTI, &ptvd->vardesc.elemdescVar.tdesc);
2254 recoffset += reclength;
2255 }
2256 }
2257
2258 /* fill in data for a hreftype (offset). When the referenced type is contained
2259 * in the typelib, it's just an (file) offset in the type info base dir.
2260 * If comes from import, it's an offset+1 in the ImpInfo table
2261 * */
2262 static void MSFT_DoRefType(TLBContext *pcx, ITypeLibImpl *pTL,
2263 int offset)
2264 {
2265 TLBRefType *ref;
2266
2267 TRACE_(typelib)("TLB context %p, TLB offset %x\n", pcx, offset);
2268
2269 LIST_FOR_EACH_ENTRY(ref, &pTL->ref_list, TLBRefType, entry)
2270 {
2271 if(ref->reference == offset) return;
2272 }
2273
2274 ref = heap_alloc_zero(sizeof(TLBRefType));
2275 list_add_tail(&pTL->ref_list, &ref->entry);
2276
2277 if(!MSFT_HREFTYPE_INTHISFILE( offset)) {
2278 /* external typelib */
2279 MSFT_ImpInfo impinfo;
2280 TLBImpLib *pImpLib;
2281
2282 TRACE_(typelib)("offset %x, masked offset %x\n", offset, offset + (offset & 0xfffffffc));
2283
2284 MSFT_ReadLEDWords(&impinfo, sizeof(impinfo), pcx,
2285 pcx->pTblDir->pImpInfo.offset + (offset & 0xfffffffc));
2286
2287 LIST_FOR_EACH_ENTRY(pImpLib, &pcx->pLibInfo->implib_list, TLBImpLib, entry)
2288 if(pImpLib->offset==impinfo.oImpFile)
2289 break;
2290
2291 if(&pImpLib->entry != &pcx->pLibInfo->implib_list){
2292 ref->reference = offset;
2293 ref->pImpTLInfo = pImpLib;
2294 if(impinfo.flags & MSFT_IMPINFO_OFFSET_IS_GUID) {
2295 MSFT_ReadGuid(&ref->guid, impinfo.oGuid, pcx);
2296 TRACE("importing by guid %s\n", debugstr_guid(&ref->guid));
2297 ref->index = TLB_REF_USE_GUID;
2298 } else
2299 ref->index = impinfo.oGuid;
2300 }else{
2301 ERR("Cannot find a reference\n");
2302 ref->reference = -1;
2303 ref->pImpTLInfo = TLB_REF_NOT_FOUND;
2304 }
2305 }else{
2306 /* in this typelib */
2307 ref->index = MSFT_HREFTYPE_INDEX(offset);
2308 ref->reference = offset;
2309 ref->pImpTLInfo = TLB_REF_INTERNAL;
2310 }
2311 }
2312
2313 /* process Implemented Interfaces of a com class */
2314 static void MSFT_DoImplTypes(TLBContext *pcx, ITypeInfoImpl *pTI, int count,
2315 int offset)
2316 {
2317 int i;
2318 MSFT_RefRecord refrec;
2319 TLBImplType *pImpl;
2320
2321 TRACE_(typelib)("\n");
2322
2323 pTI->impltypes = TLBImplType_Constructor(count);
2324 pImpl = pTI->impltypes;
2325 for(i=0;i<count;i++){
2326 if(offset<0) break; /* paranoia */
2327 MSFT_ReadLEDWords(&refrec,sizeof(refrec),pcx,offset+pcx->pTblDir->pRefTab.offset);
2328 MSFT_DoRefType(pcx, pTI->pTypeLib, refrec.reftype);
2329 pImpl->hRef = refrec.reftype;
2330 pImpl->implflags=refrec.flags;
2331 MSFT_CustData(pcx, refrec.oCustData, &pImpl->custdata_list);
2332 offset=refrec.onext;
2333 ++pImpl;
2334 }
2335 }
2336 /*
2337 * process a typeinfo record
2338 */
2339 static ITypeInfoImpl * MSFT_DoTypeInfo(
2340 TLBContext *pcx,
2341 int count,
2342 ITypeLibImpl * pLibInfo)
2343 {
2344 MSFT_TypeInfoBase tiBase;
2345 ITypeInfoImpl *ptiRet;
2346
2347 TRACE_(typelib)("count=%u\n", count);
2348
2349 ptiRet = ITypeInfoImpl_Constructor();
2350 MSFT_ReadLEDWords(&tiBase, sizeof(tiBase) ,pcx ,
2351 pcx->pTblDir->pTypeInfoTab.offset+count*sizeof(tiBase));
2352
2353 /* this is where we are coming from */
2354 ptiRet->pTypeLib = pLibInfo;
2355 ptiRet->index=count;
2356 /* fill in the typeattr fields */
2357
2358 MSFT_ReadGuid(&ptiRet->TypeAttr.guid, tiBase.posguid, pcx);
2359 ptiRet->TypeAttr.lcid=pLibInfo->LibAttr.lcid; /* FIXME: correct? */
2360 ptiRet->TypeAttr.lpstrSchema=NULL; /* reserved */
2361 ptiRet->TypeAttr.cbSizeInstance=tiBase.size;
2362 ptiRet->TypeAttr.typekind=tiBase.typekind & 0xF;
2363 ptiRet->TypeAttr.cFuncs=LOWORD(tiBase.cElement);
2364 ptiRet->TypeAttr.cVars=HIWORD(tiBase.cElement);
2365 ptiRet->TypeAttr.cbAlignment=(tiBase.typekind >> 11 )& 0x1F; /* there are more flags there */
2366 ptiRet->TypeAttr.wTypeFlags=tiBase.flags;
2367 ptiRet->TypeAttr.wMajorVerNum=LOWORD(tiBase.version);
2368 ptiRet->TypeAttr.wMinorVerNum=HIWORD(tiBase.version);
2369 ptiRet->TypeAttr.cImplTypes=tiBase.cImplTypes;
2370 ptiRet->TypeAttr.cbSizeVft=tiBase.cbSizeVft; /* FIXME: this is only the non inherited part */
2371 if(ptiRet->TypeAttr.typekind == TKIND_ALIAS)
2372 MSFT_GetTdesc(pcx, tiBase.datatype1,
2373 &ptiRet->TypeAttr.tdescAlias, ptiRet);
2374
2375 /* FIXME: */
2376 /* IDLDESC idldescType; *//* never saw this one != zero */
2377
2378 /* name, eventually add to a hash table */
2379 ptiRet->Name=MSFT_ReadName(pcx, tiBase.NameOffset);
2380 ptiRet->hreftype = MSFT_ReadHreftype(pcx, tiBase.NameOffset);
2381 TRACE_(typelib)("reading %s\n", debugstr_w(ptiRet->Name));
2382 /* help info */
2383 ptiRet->DocString=MSFT_ReadString(pcx, tiBase.docstringoffs);
2384 ptiRet->dwHelpStringContext=tiBase.helpstringcontext;
2385 ptiRet->dwHelpContext=tiBase.helpcontext;
2386
2387 if (ptiRet->TypeAttr.typekind == TKIND_MODULE)
2388 ptiRet->DllName = MSFT_ReadString(pcx, tiBase.datatype1);
2389
2390 /* note: InfoType's Help file and HelpStringDll come from the containing
2391 * library. Further HelpString and Docstring appear to be the same thing :(
2392 */
2393 /* functions */
2394 if(ptiRet->TypeAttr.cFuncs >0 )
2395 MSFT_DoFuncs(pcx, ptiRet, ptiRet->TypeAttr.cFuncs,
2396 ptiRet->TypeAttr.cVars,
2397 tiBase.memoffset, &ptiRet->funcdescs);
2398 /* variables */
2399 if(ptiRet->TypeAttr.cVars >0 )
2400 MSFT_DoVars(pcx, ptiRet, ptiRet->TypeAttr.cFuncs,
2401 ptiRet->TypeAttr.cVars,
2402 tiBase.memoffset, &ptiRet->vardescs);
2403 if(ptiRet->TypeAttr.cImplTypes >0 ) {
2404 switch(ptiRet->TypeAttr.typekind)
2405 {
2406 case TKIND_COCLASS:
2407 MSFT_DoImplTypes(pcx, ptiRet, ptiRet->TypeAttr.cImplTypes ,
2408 tiBase.datatype1);
2409 break;
2410 case TKIND_DISPATCH:
2411 /* This is not -1 when the interface is a non-base dual interface or
2412 when a dispinterface wraps an interface, i.e., the idl 'dispinterface x {interface y;};'.
2413 Note however that GetRefTypeOfImplType(0) always returns a ref to IDispatch and
2414 not this interface.
2415 */
2416
2417 if (tiBase.datatype1 != -1)
2418 {
2419 ptiRet->impltypes = TLBImplType_Constructor(1);
2420 ptiRet->impltypes[0].hRef = tiBase.datatype1;
2421 MSFT_DoRefType(pcx, pLibInfo, tiBase.datatype1);
2422 }
2423 break;
2424 default:
2425 ptiRet->impltypes = TLBImplType_Constructor(1);
2426 MSFT_DoRefType(pcx, pLibInfo, tiBase.datatype1);
2427 ptiRet->impltypes[0].hRef = tiBase.datatype1;
2428 break;
2429 }
2430 }
2431 MSFT_CustData(pcx, tiBase.oCustData, &ptiRet->custdata_list);
2432
2433 TRACE_(typelib)("%s guid: %s kind:%s\n",
2434 debugstr_w(ptiRet->Name),
2435 debugstr_guid(&ptiRet->TypeAttr.guid),
2436 typekind_desc[ptiRet->TypeAttr.typekind]);
2437 if (TRACE_ON(typelib))
2438 dump_TypeInfo(ptiRet);
2439
2440 return ptiRet;
2441 }
2442
2443 /* Because type library parsing has some degree of overhead, and some apps repeatedly load the same
2444 * typelibs over and over, we cache them here. According to MSDN Microsoft have a similar scheme in
2445 * place. This will cause a deliberate memory leak, but generally losing RAM for cycles is an acceptable
2446 * tradeoff here.
2447 */
2448 static struct list tlb_cache = LIST_INIT(tlb_cache);
2449 static CRITICAL_SECTION cache_section;
2450 static CRITICAL_SECTION_DEBUG cache_section_debug =
2451 {
2452 0, 0, &cache_section,
2453 { &cache_section_debug.ProcessLocksList, &cache_section_debug.ProcessLocksList },
2454 0, 0, { (DWORD_PTR)(__FILE__ ": typelib loader cache") }
2455 };
2456 static CRITICAL_SECTION cache_section = { &cache_section_debug, -1, 0, 0, 0, 0 };
2457
2458
2459 typedef struct TLB_PEFile
2460 {
2461 IUnknown IUnknown_iface;
2462 LONG refs;
2463 HMODULE dll;
2464 HRSRC typelib_resource;
2465 HGLOBAL typelib_global;
2466 LPVOID typelib_base;
2467 } TLB_PEFile;
2468
2469 static HRESULT WINAPI TLB_PEFile_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
2470 {
2471 if (IsEqualIID(riid, &IID_IUnknown))
2472 {
2473 *ppv = iface;
2474 IUnknown_AddRef(iface);
2475 return S_OK;
2476 }
2477 *ppv = NULL;
2478 return E_NOINTERFACE;
2479 }
2480
2481 static ULONG WINAPI TLB_PEFile_AddRef(IUnknown *iface)
2482 {
2483 TLB_PEFile *This = (TLB_PEFile *)iface;
2484 return InterlockedIncrement(&This->refs);
2485 }
2486
2487 static ULONG WINAPI TLB_PEFile_Release(IUnknown *iface)
2488 {
2489 TLB_PEFile *This = (TLB_PEFile *)iface;
2490 ULONG refs = InterlockedDecrement(&This->refs);
2491 if (!refs)
2492 {
2493 if (This->typelib_global)
2494 FreeResource(This->typelib_global);
2495 if (This->dll)
2496 FreeLibrary(This->dll);
2497 heap_free(This);
2498 }
2499 return refs;
2500 }
2501
2502 static const IUnknownVtbl TLB_PEFile_Vtable =
2503 {
2504 TLB_PEFile_QueryInterface,
2505 TLB_PEFile_AddRef,
2506 TLB_PEFile_Release
2507 };
2508
2509 static HRESULT TLB_PEFile_Open(LPCWSTR path, INT index, LPVOID *ppBase, DWORD *pdwTLBLength, IUnknown **ppFile)
2510 {
2511 TLB_PEFile *This;
2512 HRESULT hr = TYPE_E_CANTLOADLIBRARY;
2513
2514 This = heap_alloc(sizeof(TLB_PEFile));
2515 if (!This)
2516 return E_OUTOFMEMORY;
2517
2518 This->IUnknown_iface.lpVtbl = &TLB_PEFile_Vtable;
2519 This->refs = 1;
2520 This->dll = NULL;
2521 This->typelib_resource = NULL;
2522 This->typelib_global = NULL;
2523 This->typelib_base = NULL;
2524
2525 This->dll = LoadLibraryExW(path, 0, DONT_RESOLVE_DLL_REFERENCES |
2526 LOAD_LIBRARY_AS_DATAFILE | LOAD_WITH_ALTERED_SEARCH_PATH);
2527
2528 if (This->dll)
2529 {
2530 static const WCHAR TYPELIBW[] = {'T','Y','P','E','L','I','B',0};
2531 This->typelib_resource = FindResourceW(This->dll, MAKEINTRESOURCEW(index), TYPELIBW);
2532 if (This->typelib_resource)
2533 {
2534 This->typelib_global = LoadResource(This->dll, This->typelib_resource);
2535 if (This->typelib_global)
2536 {
2537 This->typelib_base = LockResource(This->typelib_global);
2538
2539 if (This->typelib_base)
2540 {
2541 *pdwTLBLength = SizeofResource(This->dll, This->typelib_resource);
2542 *ppBase = This->typelib_base;
2543 *ppFile = &This->IUnknown_iface;
2544 return S_OK;
2545 }
2546 }
2547 }
2548
2549 TRACE("No TYPELIB resource found\n");
2550 hr = E_FAIL;
2551 }
2552
2553 TLB_PEFile_Release(&This->IUnknown_iface);
2554 return hr;
2555 }
2556
2557 typedef struct TLB_NEFile
2558 {
2559 IUnknown IUnknown_iface;
2560 LONG refs;
2561 LPVOID typelib_base;
2562 } TLB_NEFile;
2563
2564 static HRESULT WINAPI TLB_NEFile_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
2565 {
2566 if (IsEqualIID(riid, &IID_IUnknown))
2567 {
2568 *ppv = iface;
2569 IUnknown_AddRef(iface);
2570 return S_OK;
2571 }
2572 *ppv = NULL;
2573 return E_NOINTERFACE;
2574 }
2575
2576 static ULONG WINAPI TLB_NEFile_AddRef(IUnknown *iface)
2577 {
2578 TLB_NEFile *This = (TLB_NEFile *)iface;
2579 return InterlockedIncrement(&This->refs);
2580 }
2581
2582 static ULONG WINAPI TLB_NEFile_Release(IUnknown *iface)
2583 {
2584 TLB_NEFile *This = (TLB_NEFile *)iface;
2585 ULONG refs = InterlockedDecrement(&This->refs);
2586 if (!refs)
2587 {
2588 heap_free(This->typelib_base);
2589 heap_free(This);
2590 }
2591 return refs;
2592 }
2593
2594 static const IUnknownVtbl TLB_NEFile_Vtable =
2595 {
2596 TLB_NEFile_QueryInterface,
2597 TLB_NEFile_AddRef,
2598 TLB_NEFile_Release
2599 };
2600
2601 /***********************************************************************
2602 * read_xx_header [internal]
2603 */
2604 static int read_xx_header( HFILE lzfd )
2605 {
2606 IMAGE_DOS_HEADER mzh;
2607 char magic[3];
2608
2609 LZSeek( lzfd, 0, SEEK_SET );
2610 if ( sizeof(mzh) != LZRead( lzfd, (LPSTR)&mzh, sizeof(mzh) ) )
2611 return 0;
2612 if ( mzh.e_magic != IMAGE_DOS_SIGNATURE )
2613 return 0;
2614
2615 LZSeek( lzfd, mzh.e_lfanew, SEEK_SET );
2616 if ( 2 != LZRead( lzfd, magic, 2 ) )
2617 return 0;
2618
2619 LZSeek( lzfd, mzh.e_lfanew, SEEK_SET );
2620
2621 if ( magic[0] == 'N' && magic[1] == 'E' )
2622 return IMAGE_OS2_SIGNATURE;
2623 if ( magic[0] == 'P' && magic[1] == 'E' )
2624 return IMAGE_NT_SIGNATURE;
2625
2626 magic[2] = '\0';
2627 WARN("Can't handle %s files.\n", magic );
2628 return 0;
2629 }
2630
2631
2632 /***********************************************************************
2633 * find_ne_resource [internal]
2634 */
2635 static BOOL find_ne_resource( HFILE lzfd, LPCSTR typeid, LPCSTR resid,
2636 DWORD *resLen, DWORD *resOff )
2637 {
2638 IMAGE_OS2_HEADER nehd;
2639 NE_TYPEINFO *typeInfo;
2640 NE_NAMEINFO *nameInfo;
2641 DWORD nehdoffset;
2642 LPBYTE resTab;
2643 DWORD resTabSize;
2644 int count;
2645
2646 /* Read in NE header */
2647 nehdoffset = LZSeek( lzfd, 0, SEEK_CUR );
2648 if ( sizeof(nehd) != LZRead( lzfd, (LPSTR)&nehd, sizeof(nehd) ) ) return 0;
2649
2650 resTabSize = nehd.ne_restab - nehd.ne_rsrctab;
2651 if ( !resTabSize )
2652 {
2653 TRACE("No resources in NE dll\n" );
2654 return FALSE;
2655 }
2656
2657 /* Read in resource table */
2658 resTab = heap_alloc( resTabSize );
2659 if ( !resTab ) return FALSE;
2660
2661 LZSeek( lzfd, nehd.ne_rsrctab + nehdoffset, SEEK_SET );
2662 if ( resTabSize != LZRead( lzfd, (char*)resTab, resTabSize ) )
2663 {
2664 heap_free( resTab );
2665 return FALSE;
2666 }
2667
2668 /* Find resource */
2669 typeInfo = (NE_TYPEINFO *)(resTab + 2);
2670
2671 if (!IS_INTRESOURCE(typeid)) /* named type */
2672 {
2673 BYTE len = strlen( typeid );
2674 while (typeInfo->type_id)
2675 {
2676 if (!(typeInfo->type_id & 0x8000))
2677 {
2678 BYTE *p = resTab + typeInfo->type_id;
2679 if ((*p == len) && !strncasecmp( (char*)p+1, typeid, len )) goto found_type;
2680 }
2681 typeInfo = (NE_TYPEINFO *)((char *)(typeInfo + 1) +
2682 typeInfo->count * sizeof(NE_NAMEINFO));
2683 }
2684 }
2685 else /* numeric type id */
2686 {
2687 WORD id = LOWORD(typeid) | 0x8000;
2688 while (typeInfo->type_id)
2689 {
2690 if (typeInfo->type_id == id) goto found_type;
2691 typeInfo = (NE_TYPEINFO *)((char *)(typeInfo + 1) +
2692 typeInfo->count * sizeof(NE_NAMEINFO));
2693 }
2694 }
2695 TRACE("No typeid entry found for %p\n", typeid );
2696 heap_free( resTab );
2697 return FALSE;
2698
2699 found_type:
2700 nameInfo = (NE_NAMEINFO *)(typeInfo + 1);
2701
2702 if (!IS_INTRESOURCE(resid)) /* named resource */
2703 {
2704 BYTE len = strlen( resid );
2705 for (count = typeInfo->count; count > 0; count--, nameInfo++)
2706 {
2707 BYTE *p = resTab + nameInfo->id;
2708 if (nameInfo->id & 0x8000) continue;
2709 if ((*p == len) && !strncasecmp( (char*)p+1, resid, len )) goto found_name;
2710 }
2711 }
2712 else /* numeric resource id */
2713 {
2714 WORD id = LOWORD(resid) | 0x8000;
2715 for (count = typeInfo->count; count > 0; count--, nameInfo++)
2716 if (nameInfo->id == id) goto found_name;
2717 }
2718 TRACE("No resid entry found for %p\n", typeid );
2719 heap_free( resTab );
2720 return FALSE;
2721
2722 found_name:
2723 /* Return resource data */
2724 if ( resLen ) *resLen = nameInfo->length << *(WORD *)resTab;
2725 if ( resOff ) *resOff = nameInfo->offset << *(WORD *)resTab;
2726
2727 heap_free( resTab );
2728 return TRUE;
2729 }
2730
2731 static HRESULT TLB_NEFile_Open(LPCWSTR path, INT index, LPVOID *ppBase, DWORD *pdwTLBLength, IUnknown **ppFile){
2732
2733 HFILE lzfd = -1;
2734 OFSTRUCT ofs;
2735 HRESULT hr = TYPE_E_CANTLOADLIBRARY;
2736 TLB_NEFile *This;
2737
2738 This = heap_alloc(sizeof(TLB_NEFile));
2739 if (!This) return E_OUTOFMEMORY;
2740
2741 This->IUnknown_iface.lpVtbl = &TLB_NEFile_Vtable;
2742 This->refs = 1;
2743 This->typelib_base = NULL;
2744
2745 lzfd = LZOpenFileW( (LPWSTR)path, &ofs, OF_READ );
2746 if ( lzfd >= 0 && read_xx_header( lzfd ) == IMAGE_OS2_SIGNATURE )
2747 {
2748 DWORD reslen, offset;
2749 if( find_ne_resource( lzfd, "TYPELIB", MAKEINTRESOURCEA(index), &reslen, &offset ) )
2750 {
2751 This->typelib_base = heap_alloc(reslen);
2752 if( !This->typelib_base )
2753 hr = E_OUTOFMEMORY;
2754 else
2755 {
2756 LZSeek( lzfd, offset, SEEK_SET );
2757 reslen = LZRead( lzfd, This->typelib_base, reslen );
2758 LZClose( lzfd );
2759 *ppBase = This->typelib_base;
2760 *pdwTLBLength = reslen;
2761 *ppFile = &This->IUnknown_iface;
2762 return S_OK;
2763 }
2764 }
2765 }
2766
2767 if( lzfd >= 0) LZClose( lzfd );
2768 TLB_NEFile_Release(&This->IUnknown_iface);
2769 return hr;
2770 }
2771
2772 typedef struct TLB_Mapping
2773 {
2774 IUnknown IUnknown_iface;
2775 LONG refs;
2776 HANDLE file;
2777 HANDLE mapping;
2778 LPVOID typelib_base;
2779 } TLB_Mapping;
2780
2781 static HRESULT WINAPI TLB_Mapping_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
2782 {
2783 if (IsEqualIID(riid, &IID_IUnknown))
2784 {
2785 *ppv = iface;
2786 IUnknown_AddRef(iface);
2787 return S_OK;
2788 }
2789 *ppv = NULL;
2790 return E_NOINTERFACE;
2791 }
2792
2793 static ULONG WINAPI TLB_Mapping_AddRef(IUnknown *iface)
2794 {
2795 TLB_Mapping *This = (TLB_Mapping *)iface;
2796 return InterlockedIncrement(&This->refs);
2797 }
2798
2799 static ULONG WINAPI TLB_Mapping_Release(IUnknown *iface)
2800 {
2801 TLB_Mapping *This = (TLB_Mapping *)iface;
2802 ULONG refs = InterlockedDecrement(&This->refs);
2803 if (!refs)
2804 {
2805 if (This->typelib_base)
2806 UnmapViewOfFile(This->typelib_base);
2807 if (This->mapping)
2808 CloseHandle(This->mapping);
2809 if (This->file != INVALID_HANDLE_VALUE)
2810 CloseHandle(This->file);
2811 heap_free(This);
2812 }
2813 return refs;
2814 }
2815
2816 static const IUnknownVtbl TLB_Mapping_Vtable =
2817 {
2818 TLB_Mapping_QueryInterface,
2819 TLB_Mapping_AddRef,
2820 TLB_Mapping_Release
2821 };
2822
2823 static HRESULT TLB_Mapping_Open(LPCWSTR path, LPVOID *ppBase, DWORD *pdwTLBLength, IUnknown **ppFile)
2824 {
2825 TLB_Mapping *This;
2826
2827 This = heap_alloc(sizeof(TLB_Mapping));
2828 if (!This)
2829 return E_OUTOFMEMORY;
2830
2831 This->IUnknown_iface.lpVtbl = &TLB_Mapping_Vtable;
2832 This->refs = 1;
2833 This->file = INVALID_HANDLE_VALUE;
2834 This->mapping = NULL;
2835 This->typelib_base = NULL;
2836
2837 This->file = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2838 if (INVALID_HANDLE_VALUE != This->file)
2839 {
2840 This->mapping = CreateFileMappingW(This->file, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
2841 if (This->mapping)
2842 {
2843 This->typelib_base = MapViewOfFile(This->mapping, FILE_MAP_READ, 0, 0, 0);
2844 if(This->typelib_base)
2845 {
2846 /* retrieve file size */
2847 *pdwTLBLength = GetFileSize(This->file, NULL);
2848 *ppBase = This->typelib_base;
2849 *ppFile = &This->IUnknown_iface;
2850 return S_OK;
2851 }
2852 }
2853 }
2854
2855 IUnknown_Release(&This->IUnknown_iface);
2856 return TYPE_E_CANTLOADLIBRARY;
2857 }
2858
2859 /****************************************************************************
2860 * TLB_ReadTypeLib
2861 *
2862 * find the type of the typelib file and map the typelib resource into
2863 * the memory
2864 */
2865
2866 #define SLTG_SIGNATURE 0x47544c53 /* "SLTG" */
2867 static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath, ITypeLib2 **ppTypeLib)
2868 {
2869 ITypeLibImpl *entry;
2870 HRESULT ret;
2871 INT index = 1;
2872 LPWSTR index_str, file = (LPWSTR)pszFileName;
2873 LPVOID pBase = NULL;
2874 DWORD dwTLBLength = 0;
2875 IUnknown *pFile = NULL;
2876
2877 *ppTypeLib = NULL;
2878
2879 index_str = strrchrW(pszFileName, '\\');
2880 if(index_str && *++index_str != '\0')
2881 {
2882 LPWSTR end_ptr;
2883 LONG idx = strtolW(index_str, &end_ptr, 10);
2884 if(*end_ptr == '\0')
2885 {
2886 int str_len = index_str - pszFileName - 1;
2887 index = idx;
2888 file = heap_alloc((str_len + 1) * sizeof(WCHAR));
2889 memcpy(file, pszFileName, str_len * sizeof(WCHAR));
2890 file[str_len] = 0;
2891 }
2892 }
2893
2894 if(!SearchPathW(NULL, file, NULL, cchPath, pszPath, NULL))
2895 {
2896 if(strchrW(file, '\\'))
2897 {
2898 lstrcpyW(pszPath, file);
2899 }
2900 else
2901 {
2902 int len = GetSystemDirectoryW(pszPath, cchPath);
2903 pszPath[len] = '\\';
2904 memcpy(pszPath + len + 1, file, (strlenW(file) + 1) * sizeof(WCHAR));
2905 }
2906 }
2907
2908 if(file != pszFileName) heap_free(file);
2909
2910 TRACE_(typelib)("File %s index %d\n", debugstr_w(pszPath), index);
2911
2912 /* We look the path up in the typelib cache. If found, we just addref it, and return the pointer. */
2913 EnterCriticalSection(&cache_section);
2914 LIST_FOR_EACH_ENTRY(entry, &tlb_cache, ITypeLibImpl, entry)
2915 {
2916 if (!strcmpiW(entry->path, pszPath) && entry->index == index)
2917 {
2918 TRACE("cache hit\n");
2919 *ppTypeLib = &entry->ITypeLib2_iface;
2920 ITypeLib2_AddRef(*ppTypeLib);
2921 LeaveCriticalSection(&cache_section);
2922 return S_OK;
2923 }
2924 }
2925 LeaveCriticalSection(&cache_section);
2926
2927 /* now actually load and parse the typelib */
2928
2929 ret = TLB_PEFile_Open(pszPath, index, &pBase, &dwTLBLength, &pFile);
2930 if (ret == TYPE_E_CANTLOADLIBRARY)
2931 ret = TLB_NEFile_Open(pszPath, index, &pBase, &dwTLBLength, &pFile);
2932 if (ret == TYPE_E_CANTLOADLIBRARY)
2933 ret = TLB_Mapping_Open(pszPath, &pBase, &dwTLBLength, &pFile);
2934 if (SUCCEEDED(ret))
2935 {
2936 if (dwTLBLength >= 4)
2937 {
2938 DWORD dwSignature = FromLEDWord(*((DWORD*) pBase));
2939 if (dwSignature == MSFT_SIGNATURE)
2940 *ppTypeLib = ITypeLib2_Constructor_MSFT(pBase, dwTLBLength);
2941 else if (dwSignature == SLTG_SIGNATURE)
2942 *ppTypeLib = ITypeLib2_Constructor_SLTG(pBase, dwTLBLength);
2943 else
2944 {
2945 FIXME("Header type magic 0x%08x not supported.\n",dwSignature);
2946 ret = TYPE_E_CANTLOADLIBRARY;
2947 }
2948 }
2949 else
2950 ret = TYPE_E_CANTLOADLIBRARY;
2951 IUnknown_Release(pFile);
2952 }
2953
2954 if(*ppTypeLib) {
2955 ITypeLibImpl *impl = (ITypeLibImpl*)*ppTypeLib;
2956
2957 TRACE("adding to cache\n");
2958 impl->path = heap_alloc((strlenW(pszPath)+1) * sizeof(WCHAR));
2959 lstrcpyW(impl->path, pszPath);
2960 /* We should really canonicalise the path here. */
2961 impl->index = index;
2962
2963 /* FIXME: check if it has added already in the meantime */
2964 EnterCriticalSection(&cache_section);
2965 list_add_head(&tlb_cache, &impl->entry);
2966 LeaveCriticalSection(&cache_section);
2967 ret = S_OK;
2968 }
2969 else
2970 {
2971 if(ret != E_FAIL)
2972 ERR("Loading of typelib %s failed with error %d\n", debugstr_w(pszFileName), GetLastError());
2973
2974 ret = TYPE_E_CANTLOADLIBRARY;
2975 }
2976
2977
2978 return ret;
2979 }
2980
2981 /*================== ITypeLib(2) Methods ===================================*/
2982
2983 static ITypeLibImpl* TypeLibImpl_Constructor(void)
2984 {
2985 ITypeLibImpl* pTypeLibImpl;
2986
2987 pTypeLibImpl = heap_alloc_zero(sizeof(ITypeLibImpl));
2988 if (!pTypeLibImpl) return NULL;
2989
2990 pTypeLibImpl->ITypeLib2_iface.lpVtbl = &tlbvt;
2991 pTypeLibImpl->ITypeComp_iface.lpVtbl = &tlbtcvt;
2992 pTypeLibImpl->ref = 1;
2993
2994 list_init(&pTypeLibImpl->implib_list);
2995 list_init(&pTypeLibImpl->custdata_list);
2996 list_init(&pTypeLibImpl->ref_list);
2997 pTypeLibImpl->dispatch_href = -1;
2998
2999 return pTypeLibImpl;
3000 }
3001
3002 /****************************************************************************
3003 * ITypeLib2_Constructor_MSFT
3004 *
3005 * loading an MSFT typelib from an in-memory image
3006 */
3007 static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
3008 {
3009 TLBContext cx;
3010 LONG lPSegDir;
3011 MSFT_Header tlbHeader;
3012 MSFT_SegDir tlbSegDir;
3013 ITypeLibImpl * pTypeLibImpl;
3014
3015 TRACE("%p, TLB length = %d\n", pLib, dwTLBLength);
3016
3017 pTypeLibImpl = TypeLibImpl_Constructor();
3018 if (!pTypeLibImpl) return NULL;
3019
3020 /* get pointer to beginning of typelib data */
3021 cx.pos = 0;
3022 cx.oStart=0;
3023 cx.mapping = pLib;
3024 cx.pLibInfo = pTypeLibImpl;
3025 cx.length = dwTLBLength;
3026
3027 /* read header */
3028 MSFT_ReadLEDWords((void*)&tlbHeader, sizeof(tlbHeader), &cx, 0);
3029 TRACE_(typelib)("header:\n");
3030 TRACE_(typelib)("\tmagic1=0x%08x ,magic2=0x%08x\n",tlbHeader.magic1,tlbHeader.magic2 );
3031 if (tlbHeader.magic1 != MSFT_SIGNATURE) {
3032 FIXME("Header type magic 0x%08x not supported.\n",tlbHeader.magic1);
3033 return NULL;
3034 }
3035 TRACE_(typelib)("\tdispatchpos = 0x%x\n", tlbHeader.dispatchpos);
3036
3037 /* there is a small amount of information here until the next important
3038 * part:
3039 * the segment directory . Try to calculate the amount of data */
3040 lPSegDir = sizeof(tlbHeader) + (tlbHeader.nrtypeinfos)*4 + ((tlbHeader.varflags & HELPDLLFLAG)? 4 :0);
3041
3042 /* now read the segment directory */
3043 TRACE("read segment directory (at %d)\n",lPSegDir);
3044 MSFT_ReadLEDWords(&tlbSegDir, sizeof(tlbSegDir), &cx, lPSegDir);
3045 cx.pTblDir = &tlbSegDir;
3046
3047 /* just check two entries */
3048 if ( tlbSegDir.pTypeInfoTab.res0c != 0x0F || tlbSegDir.pImpInfo.res0c != 0x0F)
3049 {
3050 ERR("cannot find the table directory, ptr=0x%x\n",lPSegDir);
3051 heap_free(pTypeLibImpl);
3052 return NULL;
3053 }
3054
3055 /* now fill our internal data */
3056 /* TLIBATTR fields */
3057 MSFT_ReadGuid(&pTypeLibImpl->LibAttr.guid, tlbHeader.posguid, &cx);
3058
3059 pTypeLibImpl->LibAttr.lcid = tlbHeader.lcid2;
3060 pTypeLibImpl->LibAttr.syskind = tlbHeader.varflags & 0x0f; /* check the mask */
3061 pTypeLibImpl->LibAttr.wMajorVerNum = LOWORD(tlbHeader.version);
3062 pTypeLibImpl->LibAttr.wMinorVerNum = HIWORD(tlbHeader.version);
3063 pTypeLibImpl->LibAttr.wLibFlags = (WORD) tlbHeader.flags & 0xffff;/* check mask */
3064
3065 pTypeLibImpl->lcid = tlbHeader.lcid;
3066
3067 /* name, eventually add to a hash table */
3068 pTypeLibImpl->Name = MSFT_ReadName(&cx, tlbHeader.NameOffset);
3069
3070 /* help info */
3071 pTypeLibImpl->DocString = MSFT_ReadString(&cx, tlbHeader.helpstring);
3072 pTypeLibImpl->HelpFile = MSFT_ReadString(&cx, tlbHeader.helpfile);
3073
3074 if( tlbHeader.varflags & HELPDLLFLAG)
3075 {
3076 int offset;
3077 MSFT_ReadLEDWords(&offset, sizeof(offset), &cx, sizeof(tlbHeader));
3078 pTypeLibImpl->HelpStringDll = MSFT_ReadString(&cx, offset);
3079 }
3080
3081 pTypeLibImpl->dwHelpContext = tlbHeader.helpstringcontext;
3082
3083 /* custom data */
3084 if(tlbHeader.CustomDataOffset >= 0)
3085 {
3086 MSFT_CustData(&cx, tlbHeader.CustomDataOffset, &pTypeLibImpl->custdata_list);
3087 }
3088
3089 /* fill in type descriptions */
3090 if(tlbSegDir.pTypdescTab.length > 0)
3091 {
3092 int i, j, cTD = tlbSegDir.pTypdescTab.length / (2*sizeof(INT));
3093 INT16 td[4];
3094 pTypeLibImpl->ctTypeDesc = cTD;
3095 pTypeLibImpl->pTypeDesc = heap_alloc_zero( cTD * sizeof(TYPEDESC));
3096 MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pTypdescTab.offset);
3097 for(i=0; i<cTD; )
3098 {
3099 /* FIXME: add several sanity checks here */
3100 pTypeLibImpl->pTypeDesc[i].vt = td[0] & VT_TYPEMASK;
3101 if(td[0] == VT_PTR || td[0] == VT_SAFEARRAY)
3102 {
3103 /* FIXME: check safearray */
3104 if(td[3] < 0)
3105 pTypeLibImpl->pTypeDesc[i].u.lptdesc = &std_typedesc[td[2]];
3106 else
3107 pTypeLibImpl->pTypeDesc[i].u.lptdesc = &pTypeLibImpl->pTypeDesc[td[2]/8];
3108 }
3109 else if(td[0] == VT_CARRAY)
3110 {
3111 /* array descr table here */
3112 pTypeLibImpl->pTypeDesc[i].u.lpadesc = (void *)(INT_PTR)td[2]; /* temp store offset in*/
3113 }
3114 else if(td[0] == VT_USERDEFINED)
3115 {
3116 pTypeLibImpl->pTypeDesc[i].u.hreftype = MAKELONG(td[2],td[3]);
3117 }
3118 if(++i<cTD) MSFT_ReadLEWords(td, sizeof(td), &cx, DO_NOT_SEEK);
3119 }
3120
3121 /* second time around to fill the array subscript info */
3122 for(i=0;i<cTD;i++)
3123 {
3124 if(pTypeLibImpl->pTypeDesc[i].vt != VT_CARRAY) continue;
3125 if(tlbSegDir.pArrayDescriptions.offset>0)
3126 {
3127 MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (INT_PTR)pTypeLibImpl->pTypeDesc[i].u.lpadesc);
3128 pTypeLibImpl->pTypeDesc[i].u.lpadesc = heap_alloc_zero(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1));
3129
3130 if(td[1]<0)
3131 pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem.vt = td[0] & VT_TYPEMASK;
3132 else
3133 pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem = cx.pLibInfo->pTypeDesc[td[0]/(2*sizeof(INT))];
3134
3135 pTypeLibImpl->pTypeDesc[i].u.lpadesc->cDims = td[2];
3136
3137 for(j = 0; j<td[2]; j++)
3138 {
3139 MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].cElements,
3140 sizeof(INT), &cx, DO_NOT_SEEK);
3141 MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].lLbound,
3142 sizeof(INT), &cx, DO_NOT_SEEK);
3143 }
3144 }
3145 else
3146 {
3147 pTypeLibImpl->pTypeDesc[i].u.lpadesc = NULL;
3148 ERR("didn't find array description data\n");
3149 }
3150 }
3151 }
3152
3153 /* imported type libs */
3154 if(tlbSegDir.pImpFiles.offset>0)
3155 {
3156 TLBImpLib *pImpLib;
3157 int oGuid, offset = tlbSegDir.pImpFiles.offset;
3158 UINT16 size;
3159
3160 while(offset < tlbSegDir.pImpFiles.offset +tlbSegDir.pImpFiles.length)
3161 {
3162 char *name;
3163
3164 pImpLib = heap_alloc_zero(sizeof(TLBImpLib));
3165 pImpLib->offset = offset - tlbSegDir.pImpFiles.offset;
3166 MSFT_ReadLEDWords(&oGuid, sizeof(INT), &cx, offset);
3167
3168 MSFT_ReadLEDWords(&pImpLib->lcid, sizeof(LCID), &cx, DO_NOT_SEEK);
3169 MSFT_ReadLEWords(&pImpLib->wVersionMajor, sizeof(WORD), &cx, DO_NOT_SEEK);
3170 MSFT_ReadLEWords(&pImpLib->wVersionMinor, sizeof(WORD), &cx, DO_NOT_SEEK);
3171 MSFT_ReadLEWords(& size, sizeof(UINT16), &cx, DO_NOT_SEEK);
3172
3173 size >>= 2;
3174 name = heap_alloc_zero(size+1);
3175 MSFT_Read(name, size, &cx, DO_NOT_SEEK);
3176 pImpLib->name = TLB_MultiByteToBSTR(name);
3177 heap_free(name);
3178
3179 MSFT_ReadGuid(&pImpLib->guid, oGuid, &cx);
3180 offset = (offset + sizeof(INT) + sizeof(DWORD) + sizeof(LCID) + sizeof(UINT16) + size + 3) & ~3;
3181
3182 list_add_tail(&pTypeLibImpl->implib_list, &pImpLib->entry);
3183 }
3184 }
3185
3186 pTypeLibImpl->dispatch_href = tlbHeader.dispatchpos;
3187 if(pTypeLibImpl->dispatch_href != -1)
3188 MSFT_DoRefType(&cx, pTypeLibImpl, pTypeLibImpl->dispatch_href);
3189
3190 /* type infos */
3191 if(tlbHeader.nrtypeinfos >= 0 )
3192 {
3193 ITypeInfoImpl **ppTI;
3194 int i;
3195
3196 ppTI = pTypeLibImpl->typeinfos = heap_alloc_zero(sizeof(ITypeInfoImpl*) * tlbHeader.nrtypeinfos);
3197
3198 for(i = 0; i < tlbHeader.nrtypeinfos; i++)
3199 {
3200 *ppTI = MSFT_DoTypeInfo(&cx, i, pTypeLibImpl);
3201
3202 ++ppTI;
3203 (pTypeLibImpl->TypeInfoCount)++;
3204 }
3205 }
3206
3207 TRACE("(%p)\n", pTypeLibImpl);
3208 return &pTypeLibImpl->ITypeLib2_iface;
3209 }
3210
3211
3212 static BOOL TLB_GUIDFromString(const char *str, GUID *guid)
3213 {
3214 char b[3];
3215 int i;
3216 short s;
3217
3218 if(sscanf(str, "%x-%hx-%hx-%hx", &guid->Data1, &guid->Data2, &guid->Data3, &s) != 4) {
3219 FIXME("Can't parse guid %s\n", debugstr_guid(guid));
3220 return FALSE;
3221 }
3222
3223 guid->Data4[0] = s >> 8;
3224 guid->Data4[1] = s & 0xff;
3225
3226 b[2] = '\0';
3227 for(i = 0; i < 6; i++) {
3228 memcpy(b, str + 24 + 2 * i, 2);
3229 guid->Data4[i + 2] = strtol(b, NULL, 16);
3230 }
3231 return TRUE;
3232 }
3233
3234 static WORD SLTG_ReadString(const char *ptr, BSTR *pBstr)
3235 {
3236 WORD bytelen;
3237 DWORD len;
3238
3239 *pBstr = NULL;
3240 bytelen = *(const WORD*)ptr;
3241 if(bytelen == 0xffff) return 2;
3242 len = MultiByteToWideChar(CP_ACP, 0, ptr + 2, bytelen, NULL, 0);
3243 *pBstr = SysAllocStringLen(NULL, len);
3244 if (*pBstr)
3245 len = MultiByteToWideChar(CP_ACP, 0, ptr + 2, bytelen, *pBstr, len);
3246 return bytelen + 2;
3247 }
3248
3249 static WORD SLTG_ReadStringA(const char *ptr, char **str)
3250 {
3251 WORD bytelen;
3252
3253 *str = NULL;
3254 bytelen = *(const WORD*)ptr;
3255 if(bytelen == 0xffff) return 2;
3256 *str = heap_alloc(bytelen + 1);
3257 memcpy(*str, ptr + 2, bytelen);
3258 (*str)[bytelen] = '\0';
3259 return bytelen + 2;
3260 }
3261
3262 static DWORD SLTG_ReadLibBlk(LPVOID pLibBlk, ITypeLibImpl *pTypeLibImpl)
3263 {
3264 char *ptr = pLibBlk;
3265 WORD w;
3266
3267 if((w = *(WORD*)ptr) != SLTG_LIBBLK_MAGIC) {
3268 FIXME("libblk magic = %04x\n", w);
3269 return 0;
3270 }
3271
3272 ptr += 6;
3273 if((w = *(WORD*)ptr) != 0xffff) {
3274 FIXME("LibBlk.res06 = %04x. Assumung string and skipping\n", w);
3275 ptr += w;
3276 }
3277 ptr += 2;
3278
3279 ptr += SLTG_ReadString(ptr, &pTypeLibImpl->DocString);
3280
3281 ptr += SLTG_ReadString(ptr, &pTypeLibImpl->HelpFile);
3282
3283 pTypeLibImpl->dwHelpContext = *(DWORD*)ptr;
3284 ptr += 4;
3285
3286 pTypeLibImpl->LibAttr.syskind = *(WORD*)ptr;
3287 ptr += 2;
3288
3289 if(SUBLANGID(*(WORD*)ptr) == SUBLANG_NEUTRAL)
3290 pTypeLibImpl->lcid = pTypeLibImpl->LibAttr.lcid = MAKELCID(MAKELANGID(PRIMARYLANGID(*(WORD*)ptr),0),0);
3291 else
3292 pTypeLibImpl->lcid = pTypeLibImpl->LibAttr.lcid = 0;
3293 ptr += 2;
3294
3295 ptr += 4; /* skip res12 */
3296
3297 pTypeLibImpl->LibAttr.wLibFlags = *(WORD*)ptr;
3298 ptr += 2;
3299
3300 pTypeLibImpl->LibAttr.wMajorVerNum = *(WORD*)ptr;
3301 ptr += 2;
3302
3303 pTypeLibImpl->LibAttr.wMinorVerNum = *(WORD*)ptr;
3304 ptr += 2;
3305
3306 memcpy(&pTypeLibImpl->LibAttr.guid, ptr, sizeof(GUID));
3307 ptr += sizeof(GUID);
3308
3309 return ptr - (char*)pLibBlk;
3310 }
3311
3312 /* stores a mapping between the sltg typeinfo's references and the typelib's HREFTYPEs */
3313 typedef struct
3314 {
3315 unsigned int num;
3316 HREFTYPE refs[1];
3317 } sltg_ref_lookup_t;
3318
3319 static HRESULT sltg_get_typelib_ref(const sltg_ref_lookup_t *table, DWORD typeinfo_ref,
3320 HREFTYPE *typelib_ref)
3321 {
3322 if(table && typeinfo_ref < table->num)
3323 {
3324 *typelib_ref = table->refs[typeinfo_ref];
3325 return S_OK;
3326 }
3327
3328 ERR_(typelib)("Unable to find reference\n");
3329 *typelib_ref = -1;
3330 return E_FAIL;
3331 }
3332
3333 static WORD *SLTG_DoType(WORD *pType, char *pBlk, TYPEDESC *pTD, const sltg_ref_lookup_t *ref_lookup)
3334 {
3335 BOOL done = FALSE;
3336
3337 while(!done) {
3338 if((*pType & 0xe00) == 0xe00) {
3339 pTD->vt = VT_PTR;
3340 pTD->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
3341 pTD = pTD->u.lptdesc;
3342 }
3343 switch(*pType & 0x3f) {
3344 case VT_PTR:
3345 pTD->vt = VT_PTR;
3346 pTD->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
3347 pTD = pTD->u.lptdesc;
3348 break;
3349
3350 case VT_USERDEFINED:
3351 pTD->vt = VT_USERDEFINED;
3352 sltg_get_typelib_ref(ref_lookup, *(++pType) / 4, &pTD->u.hreftype);
3353 done = TRUE;
3354 break;
3355
3356 case VT_CARRAY:
3357 {
3358 /* *(pType+1) is offset to a SAFEARRAY, *(pType+2) is type of
3359 array */
3360
3361 SAFEARRAY *pSA = (SAFEARRAY *)(pBlk + *(++pType));
3362
3363 pTD->vt = VT_CARRAY;
3364 pTD->u.lpadesc = heap_alloc_zero(sizeof(ARRAYDESC) + (pSA->cDims - 1) * sizeof(SAFEARRAYBOUND));
3365 pTD->u.lpadesc->cDims = pSA->cDims;
3366 memcpy(pTD->u.lpadesc->rgbounds, pSA->rgsabound,
3367 pSA->cDims * sizeof(SAFEARRAYBOUND));
3368
3369 pTD = &pTD->u.lpadesc->tdescElem;
3370 break;
3371 }
3372
3373 case VT_SAFEARRAY:
3374 {
3375 /* FIXME: *(pType+1) gives an offset to SAFEARRAY, is this
3376 useful? */
3377
3378 pType++;
3379 pTD->vt = VT_SAFEARRAY;
3380 pTD->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
3381 pTD = pTD->u.lptdesc;
3382 break;
3383 }
3384 default:
3385 pTD->vt = *pType & 0x3f;
3386 done = TRUE;
3387 break;
3388 }
3389 pType++;
3390 }
3391 return pType;
3392 }
3393
3394 static WORD *SLTG_DoElem(WORD *pType, char *pBlk,
3395 ELEMDESC *pElem, const sltg_ref_lookup_t *ref_lookup)
3396 {
3397 /* Handle [in/out] first */
3398 if((*pType & 0xc000) == 0xc000)
3399 pElem->u.paramdesc.wParamFlags = PARAMFLAG_NONE;
3400 else if(*pType & 0x8000)
3401 pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN | PARAMFLAG_FOUT;
3402 else if(*pType & 0x4000)
3403 pElem->u.paramdesc.wParamFlags = PARAMFLAG_FOUT;
3404 else
3405 pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN;
3406
3407 if(*pType & 0x2000)
3408 pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FLCID;
3409
3410 if(*pType & 0x80)
3411 pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FRETVAL;
3412
3413 return SLTG_DoType(pType, pBlk, &pElem->tdesc, ref_lookup);
3414 }
3415
3416
3417 static sltg_ref_lookup_t *SLTG_DoRefs(SLTG_RefInfo *pRef, ITypeLibImpl *pTL,
3418 char *pNameTable)
3419 {
3420 unsigned int ref;
3421 char *name;
3422 TLBRefType *ref_type;
3423 sltg_ref_lookup_t *table;
3424 HREFTYPE typelib_ref;
3425
3426 if(pRef->magic != SLTG_REF_MAGIC) {
3427 FIXME("Ref magic = %x\n", pRef->magic);
3428 return NULL;
3429 }
3430 name = ( (char*)pRef->names + pRef->number);
3431
3432 table = heap_alloc(sizeof(*table) + ((pRef->number >> 3) - 1) * sizeof(table->refs[0]));
3433 table->num = pRef->number >> 3;
3434
3435 /* FIXME should scan the existing list and reuse matching refs added by previous typeinfos */
3436
3437 /* We don't want the first href to be 0 */
3438 typelib_ref = (list_count(&pTL->ref_list) + 1) << 2;
3439
3440 for(ref = 0; ref < pRef->number >> 3; ref++) {
3441 char *refname;
3442 unsigned int lib_offs, type_num;
3443
3444 ref_type = heap_alloc_zero(sizeof(TLBRefType));
3445
3446 name += SLTG_ReadStringA(name, &refname);
3447 if(sscanf(refname, "*\\R%x*#%x", &lib_offs, &type_num) != 2)
3448 FIXME_(typelib)("Can't sscanf ref\n");
3449 if(lib_offs != 0xffff) {
3450 TLBImpLib *import;
3451
3452 LIST_FOR_EACH_ENTRY(import, &pTL->implib_list, TLBImpLib, entry)
3453 if(import->offset == lib_offs)
3454 break;
3455
3456 if(&import->entry == &pTL->implib_list) {
3457 char fname[MAX_PATH+1];
3458 int len;
3459
3460 import = heap_alloc_zero(sizeof(*import));
3461 import->offset = lib_offs;
3462 TLB_GUIDFromString( pNameTable + lib_offs + 4,
3463 &import->guid);
3464 if(sscanf(pNameTable + lib_offs + 40, "}#%hd.%hd#%x#%s",
3465 &import->wVersionMajor,
3466 &import->wVersionMinor,
3467 &import->lcid, fname) != 4) {
3468 FIXME_(typelib)("can't sscanf ref %s\n",
3469 pNameTable + lib_offs + 40);
3470 }
3471 len = strlen(fname);
3472 if(fname[len-1] != '#')
3473 FIXME("fname = %s\n", fname);
3474 fname[len-1] = '\0';
3475 import->name = TLB_MultiByteToBSTR(fname);
3476 list_add_tail(&pTL->implib_list, &import->entry);
3477 }
3478 ref_type->pImpTLInfo = import;
3479
3480 /* Store a reference to IDispatch */
3481 if(pTL->dispatch_href == -1 && IsEqualGUID(&import->guid, &IID_StdOle) && type_num == 4)
3482 pTL->dispatch_href = typelib_ref;
3483
3484 } else { /* internal ref */
3485 ref_type->pImpTLInfo = TLB_REF_INTERNAL;
3486 }
3487 ref_type->reference = typelib_ref;
3488 ref_type->index = type_num;
3489
3490 heap_free(refname);
3491 list_add_tail(&pTL->ref_list, &ref_type->entry);
3492
3493 table->refs[ref] = typelib_ref;
3494 typelib_ref += 4;
3495 }
3496 if((BYTE)*name != SLTG_REF_MAGIC)
3497 FIXME_(typelib)("End of ref block magic = %x\n", *name);
3498 dump_TLBRefType(pTL);
3499 return table;
3500 }
3501
3502 static char *SLTG_DoImpls(char *pBlk, ITypeInfoImpl *pTI,
3503 BOOL OneOnly, const sltg_ref_lookup_t *ref_lookup)
3504 {
3505 SLTG_ImplInfo *info;
3506 TLBImplType *pImplType;
3507 /* I don't really get this structure, usually it's 0x16 bytes
3508 long, but iuser.tlb contains some that are 0x18 bytes long.
3509 That's ok because we can use the next ptr to jump to the next
3510 one. But how do we know the length of the last one? The WORD
3511 at offs 0x8 might be the clue. For now I'm just assuming that
3512 the last one is the regular 0x16 bytes. */
3513
3514 info = (SLTG_ImplInfo*)pBlk;
3515 while(1){
3516 pTI->TypeAttr.cImplTypes++;
3517 if(info->next == 0xffff)
3518 break;
3519 info = (SLTG_ImplInfo*)(pBlk + info->next);
3520 }
3521
3522 info = (SLTG_ImplInfo*)pBlk;
3523 pTI->impltypes = TLBImplType_Constructor(pTI->TypeAttr.cImplTypes);
3524 pImplType = pTI->impltypes;
3525 while(1) {
3526 sltg_get_typelib_ref(ref_lookup, info->ref, &pImplType->hRef);
3527 pImplType->implflags = info->impltypeflags;
3528 ++pImplType;
3529
3530 if(info->next == 0xffff)
3531 break;
3532 if(OneOnly)
3533 FIXME_(typelib)("Interface inheriting more than one interface\n");
3534 info = (SLTG_ImplInfo*)(pBlk + info->next);
3535 }
3536 info++; /* see comment at top of function */
3537 return (char*)info;
3538 }
3539
3540 static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsigned short cVars,
3541 const char *pNameTable, const sltg_ref_lookup_t *ref_lookup)
3542 {
3543 TLBVarDesc *pVarDesc;
3544 BSTR bstrPrevName = NULL;
3545 SLTG_Variable *pItem;
3546 unsigned short i;
3547 WORD *pType;
3548
3549 pVarDesc = pTI->vardescs = TLBVarDesc_Constructor(cVars);
3550
3551 for(pItem = (SLTG_Variable *)pFirstItem, i = 0; i < cVars;
3552 pItem = (SLTG_Variable *)(pBlk + pItem->next), i++, ++pVarDesc) {
3553
3554 pVarDesc->vardesc.memid = pItem->memid;
3555
3556 if (pItem->magic != SLTG_VAR_MAGIC &&
3557 pItem->magic != SLTG_VAR_WITH_FLAGS_MAGIC) {
3558 FIXME_(typelib)("var magic = %02x\n", pItem->magic);
3559 return;
3560 }
3561
3562 if (pItem->name == 0xfffe)
3563 pVarDesc->Name = SysAllocString(bstrPrevName);
3564 else
3565 pVarDesc->Name = TLB_MultiByteToBSTR(pItem->name + pNameTable);
3566
3567 TRACE_(typelib)("name: %s\n", debugstr_w(pVarDesc->Name));
3568 TRACE_(typelib)("byte_offs = 0x%x\n", pItem->byte_offs);
3569 TRACE_(typelib)("memid = 0x%x\n", pItem->memid);
3570
3571 if(pItem->flags & 0x02)
3572 pType = &pItem->type;
3573 else
3574 pType = (WORD*)(pBlk + pItem->type);
3575
3576 if (pItem->flags & ~0xda)
3577 FIXME_(typelib)("unhandled flags = %02x\n", pItem->flags & ~0xda);
3578
3579 SLTG_DoElem(pType, pBlk,
3580 &pVarDesc->vardesc.elemdescVar, ref_lookup);
3581
3582 if (TRACE_ON(typelib)) {
3583 char buf[300];
3584 dump_TypeDesc(&pVarDesc->vardesc.elemdescVar.tdesc, buf);
3585 TRACE_(typelib)("elemdescVar: %s\n", buf);
3586 }
3587
3588 if (pItem->flags & 0x40) {
3589 TRACE_(typelib)("VAR_DISPATCH\n");
3590 pVarDesc->vardesc.varkind = VAR_DISPATCH;
3591 }
3592 else if (pItem->flags & 0x10) {
3593 TRACE_(typelib)("VAR_CONST\n");
3594 pVarDesc->vardesc.varkind = VAR_CONST;
3595 pVarDesc->vardesc.u.lpvarValue = heap_alloc(sizeof(VARIANT));
3596 V_VT(pVarDesc->vardesc.u.lpvarValue) = VT_INT;
3597 if (pItem->flags & 0x08)
3598 V_INT(pVarDesc->vardesc.u.lpvarValue) = pItem->byte_offs;
3599 else {
3600 switch (pVarDesc->vardesc.elemdescVar.tdesc.vt)
3601 {
3602 case VT_LPSTR:
3603 case VT_LPWSTR:
3604 case VT_BSTR:
3605 {
3606 WORD len = *(WORD *)(pBlk + pItem->byte_offs);
3607 BSTR str;
3608 TRACE_(typelib)("len = %u\n", len);
3609 if (len == 0xffff) {
3610 str = NULL;
3611 } else {
3612 INT alloc_len = MultiByteToWideChar(CP_ACP, 0, pBlk + pItem->byte_offs + 2, len, NULL, 0);
3613 str = SysAllocStringLen(NULL, alloc_len);
3614 MultiByteToWideChar(CP_ACP, 0, pBlk + pItem->byte_offs + 2, len, str, alloc_len);
3615 }
3616 V_VT(pVarDesc->vardesc.u.lpvarValue) = VT_BSTR;
3617 V_BSTR(pVarDesc->vardesc.u.lpvarValue) = str;
3618 break;
3619 }
3620 case VT_I2:
3621 case VT_UI2:
3622 case VT_I4:
3623 case VT_UI4:
3624 case VT_INT:
3625 case VT_UINT:
3626 V_INT(pVarDesc->vardesc.u.lpvarValue) =
3627 *(INT*)(pBlk + pItem->byte_offs);
3628 break;
3629 default:
3630 FIXME_(typelib)("VAR_CONST unimplemented for type %d\n", pVarDesc->vardesc.elemdescVar.tdesc.vt);
3631 }
3632 }
3633 }
3634 else {
3635 TRACE_(typelib)("VAR_PERINSTANCE\n");
3636 pVarDesc->vardesc.u.oInst = pItem->byte_offs;
3637 pVarDesc->vardesc.varkind = VAR_PERINSTANCE;
3638 }
3639
3640 if (pItem->magic == SLTG_VAR_WITH_FLAGS_MAGIC)
3641 pVarDesc->vardesc.wVarFlags = pItem->varflags;
3642
3643 if (pItem->flags & 0x80)
3644 pVarDesc->vardesc.wVarFlags |= VARFLAG_FREADONLY;
3645
3646 bstrPrevName = pVarDesc->Name;
3647 }
3648 pTI->TypeAttr.cVars = cVars;
3649 }
3650
3651 static void SLTG_DoFuncs(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI,
3652 unsigned short cFuncs, char *pNameTable, const sltg_ref_lookup_t *ref_lookup)
3653 {
3654 SLTG_Function *pFunc;
3655 unsigned short i;
3656 TLBFuncDesc *pFuncDesc;
3657
3658 pTI->funcdescs = TLBFuncDesc_Constructor(cFuncs);
3659
3660 pFuncDesc = pTI->funcdescs;
3661 for(pFunc = (SLTG_Function*)pFirstItem, i = 0; i < cFuncs && pFunc != (SLTG_Function*)0xFFFF;
3662 pFunc = (SLTG_Function*)(pBlk + pFunc->next), i++, ++pFuncDesc) {
3663
3664 int param;
3665 WORD *pType, *pArg;
3666
3667 switch (pFunc->magic & ~SLTG_FUNCTION_FLAGS_PRESENT) {
3668 case SLTG_FUNCTION_MAGIC:
3669 pFuncDesc->funcdesc.funckind = FUNC_PUREVIRTUAL;
3670 break;
3671 case SLTG_DISPATCH_FUNCTION_MAGIC:
3672 pFuncDesc->funcdesc.funckind = FUNC_DISPATCH;
3673 break;
3674 case SLTG_STATIC_FUNCTION_MAGIC:
3675 pFuncDesc->funcdesc.funckind = FUNC_STATIC;
3676 break;
3677 default:
3678 FIXME("unimplemented func magic = %02x\n", pFunc->magic & ~SLTG_FUNCTION_FLAGS_PRESENT);
3679 continue;
3680 }
3681 pFuncDesc->Name = TLB_MultiByteToBSTR(pFunc->name + pNameTable);
3682
3683 pFuncDesc->funcdesc.memid = pFunc->dispid;
3684 pFuncDesc->funcdesc.invkind = pFunc->inv >> 4;
3685 pFuncDesc->funcdesc.callconv = pFunc->nacc & 0x7;
3686 pFuncDesc->funcdesc.cParams = pFunc->nacc >> 3;
3687 pFuncDesc->funcdesc.cParamsOpt = (pFunc->retnextopt & 0x7e) >> 1;
3688 pFuncDesc->funcdesc.oVft = pFunc->vtblpos & ~1;
3689
3690 if(pFunc->magic & SLTG_FUNCTION_FLAGS_PRESENT)
3691 pFuncDesc->funcdesc.wFuncFlags = pFunc->funcflags;
3692
3693 if(pFunc->retnextopt & 0x80)
3694 pType = &pFunc->rettype;
3695 else
3696 pType = (WORD*)(pBlk + pFunc->rettype);
3697
3698 SLTG_DoElem(pType, pBlk, &pFuncDesc->funcdesc.elemdescFunc, ref_lookup);
3699
3700 pFuncDesc->funcdesc.lprgelemdescParam =
3701 heap_alloc_zero(pFuncDesc->funcdesc.cParams * sizeof(ELEMDESC));
3702 pFuncDesc->pParamDesc = TLBParDesc_Constructor(pFuncDesc->funcdesc.cParams);
3703
3704 pArg = (WORD*)(pBlk + pFunc->arg_off);
3705
3706 for(param = 0; param < pFuncDesc->funcdesc.cParams; param++) {
3707 char *paramName = pNameTable + *pArg;
3708 BOOL HaveOffs;
3709 /* If arg type follows then paramName points to the 2nd
3710 letter of the name, else the next WORD is an offset to
3711 the arg type and paramName points to the first letter.
3712 So let's take one char off paramName and see if we're
3713 pointing at an alpha-numeric char. However if *pArg is
3714 0xffff or 0xfffe then the param has no name, the former
3715 meaning that the next WORD is the type, the latter
3716 meaning that the next WORD is an offset to the type. */
3717
3718 HaveOffs = FALSE;
3719 if(*pArg == 0xffff)
3720 paramName = NULL;
3721 else if(*pArg == 0xfffe) {
3722 paramName = NULL;
3723 HaveOffs = TRUE;
3724 }
3725 else if(paramName[-1] && !isalnum(paramName[-1]))
3726 HaveOffs = TRUE;
3727
3728 pArg++;
3729
3730 if(HaveOffs) { /* the next word is an offset to type */
3731 pType = (WORD*)(pBlk + *pArg);
3732 SLTG_DoElem(pType, pBlk,
3733 &pFuncDesc->funcdesc.lprgelemdescParam[param], ref_lookup);
3734 pArg++;
3735 } else {
3736 if(paramName)
3737 paramName--;
3738 pArg = SLTG_DoElem(pArg, pBlk,
3739 &pFuncDesc->funcdesc.lprgelemdescParam[param], ref_lookup);
3740 }
3741
3742 /* Are we an optional param ? */
3743 if(pFuncDesc->funcdesc.cParams - param <=
3744 pFuncDesc->funcdesc.cParamsOpt)
3745 pFuncDesc->funcdesc.lprgelemdescParam[param].u.paramdesc.wParamFlags |= PARAMFLAG_FOPT;
3746
3747 if(paramName) {
3748 pFuncDesc->pParamDesc[param].Name =
3749 TLB_MultiByteToBSTR(paramName);
3750 } else {
3751 pFuncDesc->pParamDesc[param].Name =
3752 SysAllocString(pFuncDesc->Name);
3753 }
3754 }
3755 }
3756 pTI->TypeAttr.cFuncs = cFuncs;
3757 }
3758
3759 static void SLTG_ProcessCoClass(char *pBlk, ITypeInfoImpl *pTI,
3760 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3761 SLTG_TypeInfoTail *pTITail)
3762 {
3763 char *pFirstItem;
3764 sltg_ref_lookup_t *ref_lookup = NULL;
3765
3766 if(pTIHeader->href_table != 0xffffffff) {
3767 ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3768 pNameTable);
3769 }
3770
3771 pFirstItem = pBlk;
3772
3773 if(*(WORD*)pFirstItem == SLTG_IMPL_MAGIC) {
3774 SLTG_DoImpls(pFirstItem, pTI, FALSE, ref_lookup);
3775 }
3776 heap_free(ref_lookup);
3777 }
3778
3779
3780 static void SLTG_ProcessInterface(char *pBlk, ITypeInfoImpl *pTI,
3781 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3782 const SLTG_TypeInfoTail *pTITail)
3783 {
3784 char *pFirstItem;
3785 sltg_ref_lookup_t *ref_lookup = NULL;
3786
3787 if(pTIHeader->href_table != 0xffffffff) {
3788 ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3789 pNameTable);
3790 }
3791
3792 pFirstItem = pBlk;
3793
3794 if(*(WORD*)pFirstItem == SLTG_IMPL_MAGIC) {
3795 SLTG_DoImpls(pFirstItem, pTI, TRUE, ref_lookup);
3796 }
3797
3798 if (pTITail->funcs_off != 0xffff)
3799 SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
3800
3801 heap_free(ref_lookup);
3802
3803 if (TRACE_ON(typelib))
3804 dump_TLBFuncDesc(pTI->funcdescs, pTI->TypeAttr.cFuncs);
3805 }
3806
3807 static void SLTG_ProcessRecord(char *pBlk, ITypeInfoImpl *pTI,
3808 const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3809 const SLTG_TypeInfoTail *pTITail)
3810 {
3811 SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL);
3812 }
3813
3814 static void SLTG_ProcessAlias(char *pBlk, ITypeInfoImpl *pTI,
3815 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3816 const SLTG_TypeInfoTail *pTITail)
3817 {
3818 WORD *pType;
3819 sltg_ref_lookup_t *ref_lookup = NULL;
3820
3821 if (pTITail->simple_alias) {
3822 /* if simple alias, no more processing required */
3823 pTI->TypeAttr.tdescAlias.vt = pTITail->tdescalias_vt;
3824 return;
3825 }
3826
3827 if(pTIHeader->href_table != 0xffffffff) {
3828 ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3829 pNameTable);
3830 }
3831
3832 /* otherwise it is an offset to a type */
3833 pType = (WORD *)(pBlk + pTITail->tdescalias_vt);
3834
3835 SLTG_DoType(pType, pBlk, &pTI->TypeAttr.tdescAlias, ref_lookup);
3836
3837 heap_free(ref_lookup);
3838 }
3839
3840 static void SLTG_ProcessDispatch(char *pBlk, ITypeInfoImpl *pTI,
3841 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3842 const SLTG_TypeInfoTail *pTITail)
3843 {
3844 sltg_ref_lookup_t *ref_lookup = NULL;
3845 if (pTIHeader->href_table != 0xffffffff)
3846 ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3847 pNameTable);
3848
3849 if (pTITail->vars_off != 0xffff)
3850 SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup);
3851
3852 if (pTITail->funcs_off != 0xffff)
3853 SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
3854
3855 if (pTITail->impls_off != 0xffff)
3856 SLTG_DoImpls(pBlk + pTITail->impls_off, pTI, FALSE, ref_lookup);
3857
3858 /* this is necessary to cope with MSFT typelibs that set cFuncs to the number
3859 * of dispinterface functions including the IDispatch ones, so
3860 * ITypeInfo::GetFuncDesc takes the real value for cFuncs from cbSizeVft */
3861 pTI->TypeAttr.cbSizeVft = pTI->TypeAttr.cFuncs * sizeof(void *);
3862
3863 heap_free(ref_lookup);
3864 if (TRACE_ON(typelib))
3865 dump_TLBFuncDesc(pTI->funcdescs, pTI->TypeAttr.cFuncs);
3866 }
3867
3868 static void SLTG_ProcessEnum(char *pBlk, ITypeInfoImpl *pTI,
3869 const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3870 const SLTG_TypeInfoTail *pTITail)
3871 {
3872 SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL);
3873 }
3874
3875 static void SLTG_ProcessModule(char *pBlk, ITypeInfoImpl *pTI,
3876 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3877 const SLTG_TypeInfoTail *pTITail)
3878 {
3879 sltg_ref_lookup_t *ref_lookup = NULL;
3880 if (pTIHeader->href_table != 0xffffffff)
3881 ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3882 pNameTable);
3883
3884 if (pTITail->vars_off != 0xffff)
3885 SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup);
3886
3887 if (pTITail->funcs_off != 0xffff)
3888 SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
3889 heap_free(ref_lookup);
3890 if (TRACE_ON(typelib))
3891 dump_TypeInfo(pTI);
3892 }
3893
3894 /* Because SLTG_OtherTypeInfo is such a painful struct, we make a more
3895 manageable copy of it into this */
3896 typedef struct {
3897 WORD small_no;
3898 char *index_name;
3899 char *other_name;
3900 WORD res1a;
3901 WORD name_offs;
3902 WORD more_bytes;
3903 char *extra;
3904 WORD res20;
3905 DWORD helpcontext;
3906 WORD res26;
3907 GUID uuid;
3908 } SLTG_InternalOtherTypeInfo;
3909
3910 /****************************************************************************
3911 * ITypeLib2_Constructor_SLTG
3912 *
3913 * loading a SLTG typelib from an in-memory image
3914 */
3915 static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
3916 {
3917 ITypeLibImpl *pTypeLibImpl;
3918 SLTG_Header *pHeader;
3919 SLTG_BlkEntry *pBlkEntry;
3920 SLTG_Magic *pMagic;
3921 SLTG_Index *pIndex;
3922 SLTG_Pad9 *pPad9;
3923 LPVOID pBlk, pFirstBlk;
3924 SLTG_LibBlk *pLibBlk;
3925 SLTG_InternalOtherTypeInfo *pOtherTypeInfoBlks;
3926 char *pAfterOTIBlks = NULL;
3927 char *pNameTable, *ptr;
3928 int i;
3929 DWORD len, order;
3930 ITypeInfoImpl **ppTypeInfoImpl;
3931
3932 TRACE_(typelib)("%p, TLB length = %d\n", pLib, dwTLBLength);
3933
3934
3935 pTypeLibImpl = TypeLibImpl_Constructor();
3936 if (!pTypeLibImpl) return NULL;
3937
3938 pHeader = pLib;
3939
3940 TRACE_(typelib)("header:\n");
3941 TRACE_(typelib)("\tmagic=0x%08x, file blocks = %d\n", pHeader->SLTG_magic,
3942 pHeader->nrOfFileBlks );
3943 if (pHeader->SLTG_magic != SLTG_SIGNATURE) {
3944 FIXME_(typelib)("Header type magic 0x%08x not supported.\n",
3945 pHeader->SLTG_magic);
3946 return NULL;
3947 }
3948
3949 /* There are pHeader->nrOfFileBlks - 2 TypeInfo records in this typelib */
3950 pTypeLibImpl->TypeInfoCount = pHeader->nrOfFileBlks - 2;
3951
3952 /* This points to pHeader->nrOfFileBlks - 1 of SLTG_BlkEntry */
3953 pBlkEntry = (SLTG_BlkEntry*)(pHeader + 1);
3954
3955 /* Next we have a magic block */
3956 pMagic = (SLTG_Magic*)(pBlkEntry + pHeader->nrOfFileBlks - 1);
3957
3958 /* Let's see if we're still in sync */
3959 if(memcmp(pMagic->CompObj_magic, SLTG_COMPOBJ_MAGIC,
3960 sizeof(SLTG_COMPOBJ_MAGIC))) {
3961 FIXME_(typelib)("CompObj magic = %s\n", pMagic->CompObj_magic);
3962 return NULL;
3963 }
3964 if(memcmp(pMagic->dir_magic, SLTG_DIR_MAGIC,
3965 sizeof(SLTG_DIR_MAGIC))) {
3966 FIXME_(typelib)("dir magic = %s\n", pMagic->dir_magic);
3967 return NULL;
3968 }
3969
3970 pIndex = (SLTG_Index*)(pMagic+1);
3971
3972 pPad9 = (SLTG_Pad9*)(pIndex + pTypeLibImpl->TypeInfoCount);
3973
3974 pFirstBlk = pPad9 + 1;
3975
3976 /* We'll set up a ptr to the main library block, which is the last one. */
3977
3978 for(pBlk = pFirstBlk, order = pHeader->first_blk - 1, i = 0;
3979 pBlkEntry[order].next != 0;
3980 order = pBlkEntry[order].next - 1, i++) {
3981 pBlk = (char*)pBlk + pBlkEntry[order].len;
3982 }
3983 pLibBlk = pBlk;
3984
3985 len = SLTG_ReadLibBlk(pLibBlk, pTypeLibImpl);
3986
3987 /* Now there's 0x40 bytes of 0xffff with the numbers 0 to TypeInfoCount
3988 interspersed */
3989
3990 len += 0x40;
3991
3992 /* And now TypeInfoCount of SLTG_OtherTypeInfo */
3993
3994 pOtherTypeInfoBlks = heap_alloc_zero(sizeof(*pOtherTypeInfoBlks) * pTypeLibImpl->TypeInfoCount);
3995
3996
3997 ptr = (char*)pLibBlk + len;
3998
3999 for(i = 0; i < pTypeLibImpl->TypeInfoCount; i++) {
4000 WORD w, extra;
4001 len = 0;
4002
4003 pOtherTypeInfoBlks[i].small_no = *(WORD*)ptr;
4004
4005 w = *(WORD*)(ptr + 2);
4006 if(w != 0xffff) {
4007 len += w;
4008 pOtherTypeInfoBlks[i].index_name = heap_alloc(w+1);
4009 memcpy(pOtherTypeInfoBlks[i].index_name, ptr + 4, w);
4010 pOtherTypeInfoBlks[i].index_name[w] = '\0';
4011 }
4012 w = *(WORD*)(ptr + 4 + len);
4013 if(w != 0xffff) {
4014 TRACE_(typelib)("\twith %s\n", debugstr_an(ptr + 6 + len, w));
4015 len += w;
4016 pOtherTypeInfoBlks[i].other_name = heap_alloc(w+1);
4017 memcpy(pOtherTypeInfoBlks[i].other_name, ptr + 6 + len, w);
4018 pOtherTypeInfoBlks[i].other_name[w] = '\0';
4019 }
4020 pOtherTypeInfoBlks[i].res1a = *(WORD*)(ptr + len + 6);
4021 pOtherTypeInfoBlks[i].name_offs = *(WORD*)(ptr + len + 8);
4022 extra = pOtherTypeInfoBlks[i].more_bytes = *(WORD*)(ptr + 10 + len);
4023 if(extra) {
4024 pOtherTypeInfoBlks[i].extra = heap_alloc(extra);
4025 memcpy(pOtherTypeInfoBlks[i].extra, ptr + 12, extra);
4026 len += extra;
4027 }
4028 pOtherTypeInfoBlks[i].res20 = *(WORD*)(ptr + 12 + len);
4029 pOtherTypeInfoBlks[i].helpcontext = *(DWORD*)(ptr + 14 + len);
4030 pOtherTypeInfoBlks[i].res26 = *(WORD*)(ptr + 18 + len);
4031 memcpy(&pOtherTypeInfoBlks[i].uuid, ptr + 20 + len, sizeof(GUID));
4032 len += sizeof(SLTG_OtherTypeInfo);
4033 ptr += len;
4034 }
4035
4036 pAfterOTIBlks = ptr;
4037
4038 /* Skip this WORD and get the next DWORD */
4039 len = *(DWORD*)(pAfterOTIBlks + 2);
4040
4041 /* Now add this to pLibBLk look at what we're pointing at and
4042 possibly add 0x20, then add 0x216, sprinkle a bit a magic
4043 dust and we should be pointing at the beginning of the name
4044 table */
4045
4046 pNameTable = (char*)pLibBlk + len;
4047
4048 switch(*(WORD*)pNameTable) {
4049 case 0xffff:
4050 break;
4051 case 0x0200:
4052 pNameTable += 0x20;
4053 break;
4054 default:
4055 FIXME_(typelib)("pNameTable jump = %x\n", *(WORD*)pNameTable);
4056 break;
4057 }
4058
4059 pNameTable += 0x216;
4060
4061 pNameTable += 2;
4062
4063 TRACE_(typelib)("Library name is %s\n", pNameTable + pLibBlk->name);
4064
4065 pTypeLibImpl->Name = TLB_MultiByteToBSTR(pNameTable + pLibBlk->name);
4066
4067
4068 /* Hopefully we now have enough ptrs set up to actually read in
4069 some TypeInfos. It's not clear which order to do them in, so
4070 I'll just follow the links along the BlkEntry chain and read
4071 them in the order in which they are in the file */
4072
4073 pTypeLibImpl->typeinfos = heap_alloc_zero(pTypeLibImpl->TypeInfoCount * sizeof(ITypeInfoImpl*));
4074 ppTypeInfoImpl = pTypeLibImpl->typeinfos;
4075
4076 for(pBlk = pFirstBlk, order = pHeader->first_blk - 1, i = 0;
4077 pBlkEntry[order].next != 0;
4078 order = pBlkEntry[order].next - 1, i++) {
4079
4080 SLTG_TypeInfoHeader *pTIHeader;
4081 SLTG_TypeInfoTail *pTITail;
4082 SLTG_MemberHeader *pMemHeader;
4083
4084 if(strcmp(pBlkEntry[order].index_string + (char*)pMagic, pOtherTypeInfoBlks[i].index_name)) {
4085 FIXME_(typelib)("Index strings don't match\n");
4086 heap_free(pOtherTypeInfoBlks);
4087 return NULL;
4088 }
4089
4090 pTIHeader = pBlk;
4091 if(pTIHeader->magic != SLTG_TIHEADER_MAGIC) {
4092 FIXME_(typelib)("TypeInfoHeader magic = %04x\n", pTIHeader->magic);
4093 heap_free(pOtherTypeInfoBlks);
4094 return NULL;
4095 }
4096 TRACE_(typelib)("pTIHeader->res06 = %x, pTIHeader->res0e = %x, "
4097 "pTIHeader->res16 = %x, pTIHeader->res1e = %x\n",
4098 pTIHeader->res06, pTIHeader->res0e, pTIHeader->res16, pTIHeader->res1e);
4099
4100 *ppTypeInfoImpl = ITypeInfoImpl_Constructor();
4101 (*ppTypeInfoImpl)->pTypeLib = pTypeLibImpl;
4102 (*ppTypeInfoImpl)->index = i;
4103 (*ppTypeInfoImpl)->Name = TLB_MultiByteToBSTR(
4104 pOtherTypeInfoBlks[i].name_offs +
4105 pNameTable);
4106 (*ppTypeInfoImpl)->dwHelpContext = pOtherTypeInfoBlks[i].helpcontext;
4107 (*ppTypeInfoImpl)->TypeAttr.guid = pOtherTypeInfoBlks[i].uuid;
4108 (*ppTypeInfoImpl)->TypeAttr.typekind = pTIHeader->typekind;
4109 (*ppTypeInfoImpl)->TypeAttr.wMajorVerNum = pTIHeader->major_version;
4110 (*ppTypeInfoImpl)->TypeAttr.wMinorVerNum = pTIHeader->minor_version;
4111 (*ppTypeInfoImpl)->TypeAttr.wTypeFlags =
4112 (pTIHeader->typeflags1 >> 3) | (pTIHeader->typeflags2 << 5);
4113
4114 if((*ppTypeInfoImpl)->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL)
4115 (*ppTypeInfoImpl)->TypeAttr.typekind = TKIND_DISPATCH;
4116
4117 if((pTIHeader->typeflags1 & 7) != 2)
4118 FIXME_(typelib)("typeflags1 = %02x\n", pTIHeader->typeflags1);
4119 if(pTIHeader->typeflags3 != 2)
4120 FIXME_(typelib)("typeflags3 = %02x\n", pTIHeader->typeflags3);
4121
4122 TRACE_(typelib)("TypeInfo %s of kind %s guid %s typeflags %04x\n",
4123 debugstr_w((*ppTypeInfoImpl)->Name),
4124 typekind_desc[pTIHeader->typekind],
4125 debugstr_guid(&(*ppTypeInfoImpl)->TypeAttr.guid),
4126 (*ppTypeInfoImpl)->TypeAttr.wTypeFlags);
4127
4128 pMemHeader = (SLTG_MemberHeader*)((char *)pBlk + pTIHeader->elem_table);
4129
4130 pTITail = (SLTG_TypeInfoTail*)((char *)(pMemHeader + 1) + pMemHeader->cbExtra);
4131
4132 (*ppTypeInfoImpl)->TypeAttr.cbAlignment = pTITail->cbAlignment;
4133 (*ppTypeInfoImpl)->TypeAttr.cbSizeInstance = pTITail->cbSizeInstance;
4134 (*ppTypeInfoImpl)->TypeAttr.cbSizeVft = pTITail->cbSizeVft;
4135
4136 switch(pTIHeader->typekind) {
4137 case TKIND_ENUM:
4138 SLTG_ProcessEnum((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
4139 pTIHeader, pTITail);
4140 break;
4141
4142 case TKIND_RECORD:
4143 SLTG_ProcessRecord((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
4144 pTIHeader, pTITail);
4145 break;
4146
4147 case TKIND_INTERFACE:
4148 SLTG_ProcessInterface((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
4149 pTIHeader, pTITail);
4150 break;
4151
4152 case TKIND_COCLASS:
4153 SLTG_ProcessCoClass((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
4154 pTIHeader, pTITail);
4155 break;
4156
4157 case TKIND_ALIAS:
4158 SLTG_ProcessAlias((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
4159 pTIHeader, pTITail);
4160 break;
4161
4162 case TKIND_DISPATCH:
4163 SLTG_ProcessDispatch((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
4164 pTIHeader, pTITail);
4165 break;
4166
4167 case TKIND_MODULE:
4168 SLTG_ProcessModule((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
4169 pTIHeader, pTITail);
4170 break;
4171
4172 default:
4173 FIXME("Not processing typekind %d\n", pTIHeader->typekind);
4174 break;
4175
4176 }
4177
4178 /* could get cFuncs, cVars and cImplTypes from here
4179 but we've already set those */
4180 #define X(x) TRACE_(typelib)("tt "#x": %x\n",pTITail->res##x);
4181 X(06);
4182 X(16);
4183 X(18);
4184 X(1a);
4185 X(1e);
4186 X(24);
4187 X(26);
4188 X(2a);
4189 X(2c);
4190 X(2e);
4191 X(30);
4192 X(32);
4193 X(34);
4194 #undef X
4195 ++ppTypeInfoImpl;
4196 pBlk = (char*)pBlk + pBlkEntry[order].len;
4197 }
4198
4199 if(i != pTypeLibImpl->TypeInfoCount) {
4200 FIXME("Somehow processed %d TypeInfos\n", i);
4201 heap_free(pOtherTypeInfoBlks);
4202 return NULL;
4203 }
4204
4205 heap_free(pOtherTypeInfoBlks);
4206 return &pTypeLibImpl->ITypeLib2_iface;
4207 }
4208
4209 static inline ITypeLibImpl *impl_from_ITypeLib2(ITypeLib2 *iface)
4210 {
4211 return CONTAINING_RECORD(iface, ITypeLibImpl, ITypeLib2_iface);
4212 }
4213
4214 static HRESULT WINAPI ITypeLib2_fnQueryInterface(ITypeLib2 *iface, REFIID riid, void **ppv)
4215 {
4216 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4217
4218 TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
4219
4220 if(IsEqualIID(riid, &IID_IUnknown) ||
4221 IsEqualIID(riid,&IID_ITypeLib)||
4222 IsEqualIID(riid,&IID_ITypeLib2))
4223 {
4224 *ppv = &This->ITypeLib2_iface;
4225 }
4226 else
4227 {
4228 *ppv = NULL;
4229 TRACE("-- Interface: E_NOINTERFACE\n");
4230 return E_NOINTERFACE;
4231 }
4232
4233 IUnknown_AddRef((IUnknown*)*ppv);
4234 return S_OK;
4235 }
4236
4237 static ULONG WINAPI ITypeLib2_fnAddRef( ITypeLib2 *iface)
4238 {
4239 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4240 ULONG ref = InterlockedIncrement(&This->ref);
4241
4242 TRACE("(%p) ref=%u\n", This, ref);
4243
4244 return ref;
4245 }
4246
4247 static ULONG WINAPI ITypeLib2_fnRelease( ITypeLib2 *iface)
4248 {
4249 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4250 ULONG ref = InterlockedDecrement(&This->ref);
4251
4252 TRACE("(%p) ref=%u\n",This, ref);
4253
4254 if (!ref)
4255 {
4256 TLBImpLib *pImpLib, *pImpLibNext;
4257 TLBRefType *ref_type;
4258 void *cursor2;
4259 int i;
4260
4261 /* remove cache entry */
4262 if(This->path)
4263 {
4264 TRACE("removing from cache list\n");
4265 EnterCriticalSection(&cache_section);
4266 if(This->entry.next)
4267 list_remove(&This->entry);
4268 LeaveCriticalSection(&cache_section);
4269 heap_free(This->path);
4270 }
4271 TRACE(" destroying ITypeLib(%p)\n",This);
4272
4273 SysFreeString(This->Name);
4274 This->Name = NULL;
4275
4276 SysFreeString(This->DocString);
4277 This->DocString = NULL;
4278
4279 SysFreeString(This->HelpFile);
4280 This->HelpFile = NULL;
4281
4282 SysFreeString(This->HelpStringDll);
4283 This->HelpStringDll = NULL;
4284
4285 TLB_FreeCustData(&This->custdata_list);
4286
4287 for (i = 0; i < This->ctTypeDesc; i++)
4288 if (This->pTypeDesc[i].vt == VT_CARRAY)
4289 heap_free(This->pTypeDesc[i].u.lpadesc);
4290
4291 heap_free(This->pTypeDesc);
4292
4293 LIST_FOR_EACH_ENTRY_SAFE(pImpLib, pImpLibNext, &This->implib_list, TLBImpLib, entry)
4294 {
4295 if (pImpLib->pImpTypeLib)
4296 ITypeLib2_Release(&pImpLib->pImpTypeLib->ITypeLib2_iface);
4297 SysFreeString(pImpLib->name);
4298
4299 list_remove(&pImpLib->entry);
4300 heap_free(pImpLib);
4301 }
4302
4303 LIST_FOR_EACH_ENTRY_SAFE(ref_type, cursor2, &This->ref_list, TLBRefType, entry)
4304 {
4305 list_remove(&ref_type->entry);
4306 heap_free(ref_type);
4307 }
4308
4309 for (i = 0; i < This->TypeInfoCount; ++i)
4310 ITypeInfoImpl_Destroy(This->typeinfos[i]);
4311 heap_free(This->typeinfos);
4312 heap_free(This);
4313 return 0;
4314 }
4315
4316 return ref;
4317 }
4318
4319 /* ITypeLib::GetTypeInfoCount
4320 *
4321 * Returns the number of type descriptions in the type library
4322 */
4323 static UINT WINAPI ITypeLib2_fnGetTypeInfoCount( ITypeLib2 *iface)
4324 {
4325 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4326 TRACE("(%p)->count is %d\n",This, This->TypeInfoCount);
4327 return This->TypeInfoCount;
4328 }
4329
4330 /* ITypeLib::GetTypeInfo
4331 *
4332 * retrieves the specified type description in the library.
4333 */
4334 static HRESULT WINAPI ITypeLib2_fnGetTypeInfo(
4335 ITypeLib2 *iface,
4336 UINT index,
4337 ITypeInfo **ppTInfo)
4338 {
4339 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4340
4341 TRACE("%p %u %p\n", This, index, ppTInfo);
4342
4343 if(!ppTInfo)
4344 return E_INVALIDARG;
4345
4346 if(index >= This->TypeInfoCount)
4347 return TYPE_E_ELEMENTNOTFOUND;
4348
4349 *ppTInfo = (ITypeInfo*)This->typeinfos[index];
4350 ITypeInfo_AddRef(*ppTInfo);
4351
4352 return S_OK;
4353 }
4354
4355
4356 /* ITypeLibs::GetTypeInfoType
4357 *
4358 * Retrieves the type of a type description.
4359 */
4360 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoType(
4361 ITypeLib2 *iface,
4362 UINT index,
4363 TYPEKIND *pTKind)
4364 {
4365 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4366
4367 TRACE("(%p, %d, %p)\n", This, index, pTKind);
4368
4369 if(!pTKind)
4370 return E_INVALIDARG;
4371
4372 if(index >= This->TypeInfoCount)
4373 return TYPE_E_ELEMENTNOTFOUND;
4374
4375 *pTKind = This->typeinfos[index]->TypeAttr.typekind;
4376
4377 return S_OK;
4378 }
4379
4380 /* ITypeLib::GetTypeInfoOfGuid
4381 *
4382 * Retrieves the type description that corresponds to the specified GUID.
4383 *
4384 */
4385 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoOfGuid(
4386 ITypeLib2 *iface,
4387 REFGUID guid,
4388 ITypeInfo **ppTInfo)
4389 {
4390 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4391 int i;
4392
4393 TRACE("%p %s %p\n", This, debugstr_guid(guid), ppTInfo);
4394
4395 for(i = 0; i < This->TypeInfoCount; ++i){
4396 if(IsEqualIID(&This->typeinfos[i]->TypeAttr.guid, guid)){
4397 *ppTInfo = (ITypeInfo*)This->typeinfos[i];
4398 ITypeInfo_AddRef(*ppTInfo);
4399 return S_OK;
4400 }
4401 }
4402
4403 return TYPE_E_ELEMENTNOTFOUND;
4404 }
4405
4406 /* ITypeLib::GetLibAttr
4407 *
4408 * Retrieves the structure that contains the library's attributes.
4409 *
4410 */
4411 static HRESULT WINAPI ITypeLib2_fnGetLibAttr(
4412 ITypeLib2 *iface,
4413 LPTLIBATTR *attr)
4414 {
4415 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4416
4417 TRACE("(%p, %p)\n", This, attr);
4418
4419 if (!attr) return E_INVALIDARG;
4420
4421 *attr = heap_alloc(sizeof(**attr));
4422 if (!*attr) return E_OUTOFMEMORY;
4423
4424 **attr = This->LibAttr;
4425 return S_OK;
4426 }
4427
4428 /* ITypeLib::GetTypeComp
4429 *
4430 * Enables a client compiler to bind to a library's types, variables,
4431 * constants, and global functions.
4432 *
4433 */
4434 static HRESULT WINAPI ITypeLib2_fnGetTypeComp(
4435 ITypeLib2 *iface,
4436 ITypeComp **ppTComp)
4437 {
4438 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4439
4440 TRACE("(%p)->(%p)\n",This,ppTComp);
4441 *ppTComp = &This->ITypeComp_iface;
4442 ITypeComp_AddRef(*ppTComp);
4443
4444 return S_OK;
4445 }
4446
4447 /* ITypeLib::GetDocumentation
4448 *
4449 * Retrieves the library's documentation string, the complete Help file name
4450 * and path, and the context identifier for the library Help topic in the Help
4451 * file.
4452 *
4453 * On a successful return all non-null BSTR pointers will have been set,
4454 * possibly to NULL.
4455 */
4456 static HRESULT WINAPI ITypeLib2_fnGetDocumentation(
4457 ITypeLib2 *iface,
4458 INT index,
4459 BSTR *pBstrName,
4460 BSTR *pBstrDocString,
4461 DWORD *pdwHelpContext,
4462 BSTR *pBstrHelpFile)
4463 {
4464 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4465 HRESULT result = E_INVALIDARG;
4466 ITypeInfo *pTInfo;
4467
4468 TRACE("(%p) index %d Name(%p) DocString(%p) HelpContext(%p) HelpFile(%p)\n",
4469 This, index,
4470 pBstrName, pBstrDocString,
4471 pdwHelpContext, pBstrHelpFile);
4472
4473 if(index<0)
4474 {
4475 /* documentation for the typelib */
4476 if(pBstrName)
4477 {
4478 if (This->Name)
4479 {
4480 if(!(*pBstrName = SysAllocString(This->Name)))
4481 goto memerr1;
4482 }
4483 else
4484 *pBstrName = NULL;
4485 }
4486 if(pBstrDocString)
4487 {
4488 if (This->DocString)
4489 {
4490 if(!(*pBstrDocString = SysAllocString(This->DocString)))
4491 goto memerr2;
4492 }
4493 else if (This->Name)
4494 {
4495 if(!(*pBstrDocString = SysAllocString(This->Name)))
4496 goto memerr2;
4497 }
4498 else
4499 *pBstrDocString = NULL;
4500 }
4501 if(pdwHelpContext)
4502 {
4503 *pdwHelpContext = This->dwHelpContext;
4504 }
4505 if(pBstrHelpFile)
4506 {
4507 if (This->HelpFile)
4508 {
4509 if(!(*pBstrHelpFile = SysAllocString(This->HelpFile)))
4510 goto memerr3;
4511 }
4512 else
4513 *pBstrHelpFile = NULL;
4514 }
4515
4516 result = S_OK;
4517 }
4518 else
4519 {
4520 /* for a typeinfo */
4521 result = ITypeLib2_fnGetTypeInfo(iface, index, &pTInfo);
4522
4523 if(SUCCEEDED(result))
4524 {
4525 result = ITypeInfo_GetDocumentation(pTInfo,
4526 MEMBERID_NIL,
4527 pBstrName,
4528 pBstrDocString,
4529 pdwHelpContext, pBstrHelpFile);
4530
4531 ITypeInfo_Release(pTInfo);
4532 }
4533 }
4534 return result;
4535 memerr3:
4536 if (pBstrDocString) SysFreeString (*pBstrDocString);
4537 memerr2:
4538 if (pBstrName) SysFreeString (*pBstrName);
4539 memerr1:
4540 return STG_E_INSUFFICIENTMEMORY;
4541 }
4542
4543 /* ITypeLib::IsName
4544 *
4545 * Indicates whether a passed-in string contains the name of a type or member
4546 * described in the library.
4547 *
4548 */
4549 static HRESULT WINAPI ITypeLib2_fnIsName(
4550 ITypeLib2 *iface,
4551 LPOLESTR szNameBuf,
4552 ULONG lHashVal,
4553 BOOL *pfName)
4554 {
4555 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4556 int tic;
4557 UINT nNameBufLen = (lstrlenW(szNameBuf)+1)*sizeof(WCHAR), fdc, vrc;
4558
4559 TRACE("(%p)->(%s,%08x,%p)\n", This, debugstr_w(szNameBuf), lHashVal,
4560 pfName);
4561
4562 *pfName=TRUE;
4563 for(tic = 0; tic < This->TypeInfoCount; ++tic){
4564 ITypeInfoImpl *pTInfo = This->typeinfos[tic];
4565 if(!memcmp(szNameBuf,pTInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
4566 for(fdc = 0; fdc < pTInfo->TypeAttr.cFuncs; ++fdc) {
4567 TLBFuncDesc *pFInfo = &pTInfo->funcdescs[fdc];
4568 int pc;
4569
4570 if(!memcmp(szNameBuf,pFInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
4571 for(pc=0; pc < pFInfo->funcdesc.cParams; pc++)
4572 if(!memcmp(szNameBuf,pFInfo->pParamDesc[pc].Name, nNameBufLen))
4573 goto ITypeLib2_fnIsName_exit;
4574 }
4575 for(vrc = 0; vrc < pTInfo->TypeAttr.cVars; ++vrc){
4576 TLBVarDesc *pVInfo = &pTInfo->vardescs[vrc];
4577 if(!memcmp(szNameBuf,pVInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
4578 }
4579
4580 }
4581 *pfName=FALSE;
4582
4583 ITypeLib2_fnIsName_exit:
4584 TRACE("(%p)slow! search for %s: %s found!\n", This,
4585 debugstr_w(szNameBuf), *pfName?"NOT":"");
4586
4587 return S_OK;
4588 }
4589
4590 /* ITypeLib::FindName
4591 *
4592 * Finds occurrences of a type description in a type library. This may be used
4593 * to quickly verify that a name exists in a type library.
4594 *
4595 */
4596 static HRESULT WINAPI ITypeLib2_fnFindName(
4597 ITypeLib2 *iface,
4598 LPOLESTR name,
4599 ULONG hash,
4600 ITypeInfo **ppTInfo,
4601 MEMBERID *memid,
4602 UINT16 *found)
4603 {
4604 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4605 int tic;
4606 UINT count = 0;
4607 UINT len;
4608
4609 TRACE("(%p)->(%s %u %p %p %p)\n", This, debugstr_w(name), hash, ppTInfo, memid, found);
4610
4611 if ((!name && hash == 0) || !ppTInfo || !memid || !found)
4612 return E_INVALIDARG;
4613
4614 len = (lstrlenW(name) + 1)*sizeof(WCHAR);
4615 for(tic = 0; tic < This->TypeInfoCount; ++tic) {
4616 ITypeInfoImpl *pTInfo = This->typeinfos[tic];
4617 TLBVarDesc *var;
4618 UINT fdc;
4619
4620 if(!memcmp(name, pTInfo->Name, len)) goto ITypeLib2_fnFindName_exit;
4621 for(fdc = 0; fdc < pTInfo->TypeAttr.cFuncs; ++fdc) {
4622 TLBFuncDesc *func = &pTInfo->funcdescs[fdc];
4623 int pc;
4624
4625 if(!memcmp(name, func->Name, len)) goto ITypeLib2_fnFindName_exit;
4626 for(pc = 0; pc < func->funcdesc.cParams; pc++) {
4627 if(!memcmp(name, func->pParamDesc[pc].Name, len))
4628 goto ITypeLib2_fnFindName_exit;
4629 }
4630 }
4631
4632 var = TLB_get_vardesc_by_name(pTInfo->vardescs, pTInfo->TypeAttr.cVars, name);
4633 if (var)
4634 goto ITypeLib2_fnFindName_exit;
4635
4636 continue;
4637 ITypeLib2_fnFindName_exit:
4638 ITypeInfo_AddRef((ITypeInfo*)pTInfo);
4639 ppTInfo[count]=(LPTYPEINFO)pTInfo;
4640 count++;
4641 }
4642 TRACE("found %d typeinfos\n", count);
4643
4644 *found = count;
4645
4646 return S_OK;
4647 }
4648
4649 /* ITypeLib::ReleaseTLibAttr
4650 *
4651 * Releases the TLIBATTR originally obtained from ITypeLib::GetLibAttr.
4652 *
4653 */
4654 static VOID WINAPI ITypeLib2_fnReleaseTLibAttr(
4655 ITypeLib2 *iface,
4656 TLIBATTR *pTLibAttr)
4657 {
4658 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4659 TRACE("(%p)->(%p)\n", This, pTLibAttr);
4660 heap_free(pTLibAttr);
4661 }
4662
4663 /* ITypeLib2::GetCustData
4664 *
4665 * gets the custom data
4666 */
4667 static HRESULT WINAPI ITypeLib2_fnGetCustData(
4668 ITypeLib2 * iface,
4669 REFGUID guid,
4670 VARIANT *pVarVal)
4671 {
4672 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4673 TLBCustData *pCData;
4674
4675 TRACE("(%p)->(%s %p)\n", This, debugstr_guid(guid), pVarVal);
4676
4677 pCData = TLB_get_custdata_by_guid(&This->custdata_list, guid);
4678 if(!pCData)
4679 return TYPE_E_ELEMENTNOTFOUND;
4680
4681 VariantInit(pVarVal);
4682 VariantCopy(pVarVal, &pCData->data);
4683
4684 return S_OK;
4685 }
4686
4687 /* ITypeLib2::GetLibStatistics
4688 *
4689 * Returns statistics about a type library that are required for efficient
4690 * sizing of hash tables.
4691 *
4692 */
4693 static HRESULT WINAPI ITypeLib2_fnGetLibStatistics(
4694 ITypeLib2 * iface,
4695 ULONG *pcUniqueNames,
4696 ULONG *pcchUniqueNames)
4697 {
4698 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4699
4700 FIXME("(%p): stub!\n", This);
4701
4702 if(pcUniqueNames) *pcUniqueNames=1;
4703 if(pcchUniqueNames) *pcchUniqueNames=1;
4704 return S_OK;
4705 }
4706
4707 /* ITypeLib2::GetDocumentation2
4708 *
4709 * Retrieves the library's documentation string, the complete Help file name
4710 * and path, the localization context to use, and the context ID for the
4711 * library Help topic in the Help file.
4712 *
4713 */
4714 static HRESULT WINAPI ITypeLib2_fnGetDocumentation2(
4715 ITypeLib2 * iface,
4716 INT index,
4717 LCID lcid,
4718 BSTR *pbstrHelpString,
4719 DWORD *pdwHelpStringContext,
4720 BSTR *pbstrHelpStringDll)
4721 {
4722 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4723 HRESULT result;
4724 ITypeInfo *pTInfo;
4725
4726 FIXME("(%p) index %d lcid %d half implemented stub!\n", This, index, lcid);
4727
4728 /* the help string should be obtained from the helpstringdll,
4729 * using the _DLLGetDocumentation function, based on the supplied
4730 * lcid. Nice to do sometime...
4731 */
4732 if(index<0)
4733 {
4734 /* documentation for the typelib */
4735 if(pbstrHelpString)
4736 *pbstrHelpString=SysAllocString(This->DocString);
4737 if(pdwHelpStringContext)
4738 *pdwHelpStringContext=This->dwHelpContext;
4739 if(pbstrHelpStringDll)
4740 *pbstrHelpStringDll=SysAllocString(This->HelpStringDll);
4741
4742 result = S_OK;
4743 }
4744 else
4745 {
4746 /* for a typeinfo */
4747 result=ITypeLib2_GetTypeInfo(iface, index, &pTInfo);
4748
4749 if(SUCCEEDED(result))
4750 {
4751 ITypeInfo2 * pTInfo2;
4752 result = ITypeInfo_QueryInterface(pTInfo,
4753 &IID_ITypeInfo2,
4754 (LPVOID*) &pTInfo2);
4755
4756 if(SUCCEEDED(result))
4757 {
4758 result = ITypeInfo2_GetDocumentation2(pTInfo2,
4759 MEMBERID_NIL,
4760 lcid,
4761 pbstrHelpString,
4762 pdwHelpStringContext,
4763 pbstrHelpStringDll);
4764
4765 ITypeInfo2_Release(pTInfo2);
4766 }
4767
4768 ITypeInfo_Release(pTInfo);
4769 }
4770 }
4771 return result;
4772 }
4773
4774 static HRESULT TLB_copy_all_custdata(struct list *custdata_list, CUSTDATA *pCustData)
4775 {
4776 TLBCustData *pCData;
4777 unsigned int ct;
4778 CUSTDATAITEM *cdi;
4779
4780 ct = list_count(custdata_list);
4781
4782 pCustData->prgCustData = heap_alloc_zero(ct * sizeof(CUSTDATAITEM));
4783 if(!pCustData->prgCustData)
4784 return E_OUTOFMEMORY;
4785
4786 pCustData->cCustData = ct;
4787
4788 cdi = pCustData->prgCustData;
4789 LIST_FOR_EACH_ENTRY(pCData, custdata_list, TLBCustData, entry){
4790 cdi->guid = pCData->guid;
4791 VariantCopy(&cdi->varValue, &pCData->data);
4792 ++cdi;
4793 }
4794
4795 return S_OK;
4796 }
4797
4798
4799 /* ITypeLib2::GetAllCustData
4800 *
4801 * Gets all custom data items for the library.
4802 *
4803 */
4804 static HRESULT WINAPI ITypeLib2_fnGetAllCustData(
4805 ITypeLib2 * iface,
4806 CUSTDATA *pCustData)
4807 {
4808 ITypeLibImpl *This = impl_from_ITypeLib2(iface);
4809 TRACE("(%p)->(%p)\n", This, pCustData);
4810 return TLB_copy_all_custdata(&This->custdata_list, pCustData);
4811 }
4812
4813 static const ITypeLib2Vtbl tlbvt = {
4814 ITypeLib2_fnQueryInterface,
4815 ITypeLib2_fnAddRef,
4816 ITypeLib2_fnRelease,
4817 ITypeLib2_fnGetTypeInfoCount,
4818 ITypeLib2_fnGetTypeInfo,
4819 ITypeLib2_fnGetTypeInfoType,
4820 ITypeLib2_fnGetTypeInfoOfGuid,
4821 ITypeLib2_fnGetLibAttr,
4822 ITypeLib2_fnGetTypeComp,
4823 ITypeLib2_fnGetDocumentation,
4824 ITypeLib2_fnIsName,
4825 ITypeLib2_fnFindName,
4826 ITypeLib2_fnReleaseTLibAttr,
4827
4828 ITypeLib2_fnGetCustData,
4829 ITypeLib2_fnGetLibStatistics,
4830 ITypeLib2_fnGetDocumentation2,
4831 ITypeLib2_fnGetAllCustData
4832 };
4833
4834
4835 static HRESULT WINAPI ITypeLibComp_fnQueryInterface(ITypeComp * iface, REFIID riid, LPVOID * ppv)
4836 {
4837 ITypeLibImpl *This = impl_from_ITypeComp(iface);
4838
4839 return ITypeLib2_QueryInterface(&This->ITypeLib2_iface, riid, ppv);
4840 }
4841
4842 static ULONG WINAPI ITypeLibComp_fnAddRef(ITypeComp * iface)
4843 {
4844 ITypeLibImpl *This = impl_from_ITypeComp(iface);
4845
4846 return ITypeLib2_AddRef(&This->ITypeLib2_iface);
4847 }
4848
4849 static ULONG WINAPI ITypeLibComp_fnRelease(ITypeComp * iface)
4850 {
4851 ITypeLibImpl *This = impl_from_ITypeComp(iface);
4852
4853 return ITypeLib2_Release(&This->ITypeLib2_iface);
4854 }
4855
4856 static HRESULT WINAPI ITypeLibComp_fnBind(
4857 ITypeComp * iface,
4858 OLECHAR * szName,
4859 ULONG lHash,
4860 WORD wFlags,
4861 ITypeInfo ** ppTInfo,
4862 DESCKIND * pDescKind,
4863 BINDPTR * pBindPtr)
4864 {
4865 ITypeLibImpl *This = impl_from_ITypeComp(iface);
4866 int typemismatch=0, i;
4867
4868 TRACE("(%s, 0x%x, 0x%x, %p, %p, %p)\n", debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
4869
4870 *pDescKind = DESCKIND_NONE;
4871 pBindPtr->lptcomp = NULL;
4872 *ppTInfo = NULL;
4873
4874 for(i = 0; i < This->TypeInfoCount; ++i){
4875 ITypeInfoImpl *pTypeInfo = This->typeinfos[i];
4876 TRACE("testing %s\n", debugstr_w(pTypeInfo->Name));
4877
4878 /* FIXME: check wFlags here? */
4879 /* FIXME: we should use a hash table to look this info up using lHash
4880 * instead of an O(n) search */
4881 if ((pTypeInfo->TypeAttr.typekind == TKIND_ENUM) ||
4882 (pTypeInfo->TypeAttr.typekind == TKIND_MODULE))
4883 {
4884 if (pTypeInfo->Name && !strcmpW(pTypeInfo->Name, szName))
4885 {
4886 *pDescKind = DESCKIND_TYPECOMP;
4887 pBindPtr->lptcomp = &pTypeInfo->ITypeComp_iface;
4888 ITypeComp_AddRef(pBindPtr->lptcomp);
4889 TRACE("module or enum: %s\n", debugstr_w(szName));
4890 return S_OK;
4891 }
4892 }
4893
4894 if ((pTypeInfo->TypeAttr.typekind == TKIND_MODULE) ||
4895 (pTypeInfo->TypeAttr.typekind == TKIND_ENUM))
4896 {
4897 ITypeComp *pSubTypeComp = &pTypeInfo->ITypeComp_iface;
4898 HRESULT hr;
4899
4900 hr = ITypeComp_Bind(pSubTypeComp, szName, lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
4901 if (SUCCEEDED(hr) && (*pDescKind != DESCKIND_NONE))
4902 {
4903 TRACE("found in module or in enum: %s\n", debugstr_w(szName));
4904 return S_OK;
4905 }
4906 else if (hr == TYPE_E_TYPEMISMATCH)
4907 typemismatch = 1;
4908 }
4909
4910 if ((pTypeInfo->TypeAttr.typekind == TKIND_COCLASS) &&
4911 (pTypeInfo->TypeAttr.wTypeFlags & TYPEFLAG_FAPPOBJECT))
4912 {
4913 ITypeComp *pSubTypeComp = &pTypeInfo->ITypeComp_iface;
4914 HRESULT hr;
4915 ITypeInfo *subtypeinfo;
4916 BINDPTR subbindptr;
4917 DESCKIND subdesckind;
4918
4919 hr = ITypeComp_Bind(pSubTypeComp, szName, lHash, wFlags,
4920 &subtypeinfo, &subdesckind, &subbindptr);
4921 if (SUCCEEDED(hr) && (subdesckind != DESCKIND_NONE))
4922 {
4923 TYPEDESC tdesc_appobject;
4924 const VARDESC vardesc_appobject =
4925 {
4926 -2, /* memid */
4927 NULL, /* lpstrSchema */
4928 {
4929 0 /* oInst */
4930 },
4931 {
4932 /* ELEMDESC */
4933 {
4934 /* TYPEDESC */
4935 {
4936 &tdesc_appobject
4937 },
4938 VT_PTR
4939 },
4940 },
4941 0, /* wVarFlags */
4942 VAR_STATIC /* varkind */
4943 };
4944
4945 tdesc_appobject.u.hreftype = pTypeInfo->hreftype;
4946 tdesc_appobject.vt = VT_USERDEFINED;
4947
4948 TRACE("found in implicit app object: %s\n", debugstr_w(szName));
4949
4950 /* cleanup things filled in by Bind call so we can put our
4951 * application object data in there instead */
4952 switch (subdesckind)
4953 {
4954 case DESCKIND_FUNCDESC:
4955 ITypeInfo_ReleaseFuncDesc(subtypeinfo, subbindptr.lpfuncdesc);
4956 break;
4957 case DESCKIND_VARDESC:
4958 ITypeInfo_ReleaseVarDesc(subtypeinfo, subbindptr.lpvardesc);
4959 break;
4960 default:
4961 break;
4962 }
4963 if (subtypeinfo) ITypeInfo_Release(subtypeinfo);
4964
4965 if (pTypeInfo->hreftype == -1)
4966 FIXME("no hreftype for interface %p\n", pTypeInfo);
4967
4968 hr = TLB_AllocAndInitVarDesc(&vardesc_appobject, &pBindPtr->lpvardesc);
4969 if (FAILED(hr))
4970 return hr;
4971
4972 *pDescKind = DESCKIND_IMPLICITAPPOBJ;
4973 *ppTInfo = (ITypeInfo *)pTypeInfo;
4974 ITypeInfo_AddRef(*ppTInfo);
4975 return S_OK;
4976 }
4977 else if (hr == TYPE_E_TYPEMISMATCH)
4978 typemismatch = 1;
4979 }
4980 }
4981
4982 if (typemismatch)
4983 {
4984 TRACE("type mismatch %s\n", debugstr_w(szName));
4985 return TYPE_E_TYPEMISMATCH;
4986 }
4987 else
4988 {
4989 TRACE("name not found %s\n", debugstr_w(szName));
4990 return S_OK;
4991 }
4992 }
4993
4994 static HRESULT WINAPI ITypeLibComp_fnBindType(
4995 ITypeComp * iface,
4996 OLECHAR * szName,
4997 ULONG lHash,
4998 ITypeInfo ** ppTInfo,
4999 ITypeComp ** ppTComp)
5000 {
5001 ITypeLibImpl *This = impl_from_ITypeComp(iface);
5002 int i;
5003
5004 TRACE("(%s, %x, %p, %p)\n", debugstr_w(szName), lHash, ppTInfo, ppTComp);
5005
5006 if(!szName || !ppTInfo || !ppTComp)
5007 return E_INVALIDARG;
5008
5009 for(i = 0; i < This->TypeInfoCount; ++i)
5010 {
5011 ITypeInfoImpl *pTypeInfo = This->typeinfos[i];
5012 /* FIXME: should use lHash to do the search */
5013 if (pTypeInfo->Name && !strcmpiW(pTypeInfo->Name, szName))
5014 {
5015 TRACE("returning %p\n", pTypeInfo);
5016 *ppTInfo = (ITypeInfo *)&pTypeInfo->ITypeInfo2_iface;
5017 ITypeInfo_AddRef(*ppTInfo);
5018 *ppTComp = &pTypeInfo->ITypeComp_iface;
5019 ITypeComp_AddRef(*ppTComp);
5020 return S_OK;
5021 }
5022 }
5023
5024 TRACE("not found\n");
5025 *ppTInfo = NULL;
5026 *ppTComp = NULL;
5027 return S_OK;
5028 }
5029
5030 static const ITypeCompVtbl tlbtcvt =
5031 {
5032
5033 ITypeLibComp_fnQueryInterface,
5034 ITypeLibComp_fnAddRef,
5035 ITypeLibComp_fnRelease,
5036
5037 ITypeLibComp_fnBind,
5038 ITypeLibComp_fnBindType
5039 };
5040
5041 /*================== ITypeInfo(2) Methods ===================================*/
5042 static ITypeInfoImpl* ITypeInfoImpl_Constructor(void)
5043 {
5044 ITypeInfoImpl *pTypeInfoImpl;
5045
5046 pTypeInfoImpl = heap_alloc_zero(sizeof(ITypeInfoImpl));
5047 if (pTypeInfoImpl)
5048 {
5049 pTypeInfoImpl->ITypeInfo2_iface.lpVtbl = &tinfvt;
5050 pTypeInfoImpl->ITypeComp_iface.lpVtbl = &tcompvt;
5051 pTypeInfoImpl->ref = 0;
5052 pTypeInfoImpl->hreftype = -1;
5053 pTypeInfoImpl->TypeAttr.memidConstructor = MEMBERID_NIL;
5054 pTypeInfoImpl->TypeAttr.memidDestructor = MEMBERID_NIL;
5055 list_init(&pTypeInfoImpl->custdata_list);
5056 }
5057 TRACE("(%p)\n", pTypeInfoImpl);
5058 return pTypeInfoImpl;
5059 }
5060
5061 /* ITypeInfo::QueryInterface
5062 */
5063 static HRESULT WINAPI ITypeInfo_fnQueryInterface(
5064 ITypeInfo2 *iface,
5065 REFIID riid,
5066 VOID **ppvObject)
5067 {
5068 ITypeLibImpl *This = (ITypeLibImpl *)iface;
5069
5070 TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
5071
5072 *ppvObject=NULL;
5073 if(IsEqualIID(riid, &IID_IUnknown) ||
5074 IsEqualIID(riid,&IID_ITypeInfo)||
5075 IsEqualIID(riid,&IID_ITypeInfo2))
5076 *ppvObject = This;
5077
5078 if(*ppvObject){
5079 ITypeInfo2_AddRef(iface);
5080 TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
5081 return S_OK;
5082 }
5083 TRACE("-- Interface: E_NOINTERFACE\n");
5084 return E_NOINTERFACE;
5085 }
5086
5087 /* ITypeInfo::AddRef
5088 */
5089 static ULONG WINAPI ITypeInfo_fnAddRef( ITypeInfo2 *iface)
5090 {
5091 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5092 ULONG ref = InterlockedIncrement(&This->ref);
5093
5094 TRACE("(%p)->ref is %u\n",This, ref);
5095
5096 if (ref == 1 /* incremented from 0 */)
5097 ITypeLib2_AddRef(&This->pTypeLib->ITypeLib2_iface);
5098
5099 return ref;
5100 }
5101
5102 static void ITypeInfoImpl_Destroy(ITypeInfoImpl *This)
5103 {
5104 UINT i;
5105
5106 TRACE("destroying ITypeInfo(%p)\n",This);
5107
5108 SysFreeString(This->Name);
5109 This->Name = NULL;
5110
5111 SysFreeString(This->DocString);
5112 This->DocString = NULL;
5113
5114 SysFreeString(This->DllName);
5115 This->DllName = NULL;
5116
5117 for (i = 0; i < This->TypeAttr.cFuncs; ++i)
5118 {
5119 int j;
5120 TLBFuncDesc *pFInfo = &This->funcdescs[i];
5121 for(j = 0; j < pFInfo->funcdesc.cParams; j++)
5122 {
5123 ELEMDESC *elemdesc = &pFInfo->funcdesc.lprgelemdescParam[j];
5124 if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
5125 {
5126 VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
5127 heap_free(elemdesc->u.paramdesc.pparamdescex);
5128 }
5129 TLB_FreeCustData(&pFInfo->pParamDesc[j].custdata_list);
5130 SysFreeString(pFInfo->pParamDesc[j].Name);
5131 }
5132 heap_free(pFInfo->funcdesc.lprgelemdescParam);
5133 heap_free(pFInfo->pParamDesc);
5134 TLB_FreeCustData(&pFInfo->custdata_list);
5135 if (!IS_INTRESOURCE(pFInfo->Entry) && pFInfo->Entry != (BSTR)-1)
5136 SysFreeString(pFInfo->Entry);
5137 SysFreeString(pFInfo->HelpString);
5138 SysFreeString(pFInfo->Name);
5139 }
5140 heap_free(This->funcdescs);
5141
5142 for(i = 0; i < This->TypeAttr.cVars; ++i)
5143 {
5144 TLBVarDesc *pVInfo = &This->vardescs[i];
5145 if (pVInfo->vardesc.varkind == VAR_CONST)
5146 {
5147 VariantClear(pVInfo->vardesc.u.lpvarValue);
5148 heap_free(pVInfo->vardesc.u.lpvarValue);
5149 }
5150 TLB_FreeCustData(&pVInfo->custdata_list);
5151 SysFreeString(pVInfo->Name);
5152 SysFreeString(pVInfo->HelpString);
5153 }
5154 heap_free(This->vardescs);
5155
5156 if(This->impltypes){
5157 for (i = 0; i < This->TypeAttr.cImplTypes; ++i){
5158 TLBImplType *pImpl = &This->impltypes[i];
5159 TLB_FreeCustData(&pImpl->custdata_list);
5160 }
5161 heap_free(This->impltypes);
5162 }
5163
5164 TLB_FreeCustData(&This->custdata_list);
5165
5166 heap_free(This);
5167 }
5168
5169 /* ITypeInfo::Release
5170 */
5171 static ULONG WINAPI ITypeInfo_fnRelease(ITypeInfo2 *iface)
5172 {
5173 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5174 ULONG ref = InterlockedDecrement(&This->ref);
5175
5176 TRACE("(%p)->(%u)\n",This, ref);
5177
5178 if (!ref)
5179 {
5180 BOOL not_attached_to_typelib = This->not_attached_to_typelib;
5181 ITypeLib2_Release(&This->pTypeLib->ITypeLib2_iface);
5182 if (not_attached_to_typelib)
5183 heap_free(This);
5184 /* otherwise This will be freed when typelib is freed */
5185 }
5186
5187 return ref;
5188 }
5189
5190 /* ITypeInfo::GetTypeAttr
5191 *
5192 * Retrieves a TYPEATTR structure that contains the attributes of the type
5193 * description.
5194 *
5195 */
5196 static HRESULT WINAPI ITypeInfo_fnGetTypeAttr( ITypeInfo2 *iface,
5197 LPTYPEATTR *ppTypeAttr)
5198 {
5199 const ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5200 SIZE_T size;
5201
5202 TRACE("(%p)\n",This);
5203
5204 size = sizeof(**ppTypeAttr);
5205 if (This->TypeAttr.typekind == TKIND_ALIAS)
5206 size += TLB_SizeTypeDesc(&This->TypeAttr.tdescAlias, FALSE);
5207
5208 *ppTypeAttr = heap_alloc(size);
5209 if (!*ppTypeAttr)
5210 return E_OUTOFMEMORY;
5211
5212 **ppTypeAttr = This->TypeAttr;
5213
5214 if (This->TypeAttr.typekind == TKIND_ALIAS)
5215 TLB_CopyTypeDesc(&(*ppTypeAttr)->tdescAlias,
5216 &This->TypeAttr.tdescAlias, *ppTypeAttr + 1);
5217
5218 if((*ppTypeAttr)->typekind == TKIND_DISPATCH) {
5219 /* This should include all the inherited funcs */
5220 (*ppTypeAttr)->cFuncs = (*ppTypeAttr)->cbSizeVft / sizeof(void *);
5221 /* This is always the size of IDispatch's vtbl */
5222 (*ppTypeAttr)->cbSizeVft = sizeof(IDispatchVtbl);
5223 (*ppTypeAttr)->wTypeFlags &= ~TYPEFLAG_FOLEAUTOMATION;
5224 }
5225 return S_OK;
5226 }
5227
5228 /* ITypeInfo::GetTypeComp
5229 *
5230 * Retrieves the ITypeComp interface for the type description, which enables a
5231 * client compiler to bind to the type description's members.
5232 *
5233 */
5234 static HRESULT WINAPI ITypeInfo_fnGetTypeComp( ITypeInfo2 *iface,
5235 ITypeComp * *ppTComp)
5236 {
5237 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5238
5239 TRACE("(%p)->(%p)\n", This, ppTComp);
5240
5241 *ppTComp = &This->ITypeComp_iface;
5242 ITypeComp_AddRef(*ppTComp);
5243 return S_OK;
5244 }
5245
5246 static SIZE_T TLB_SizeElemDesc( const ELEMDESC *elemdesc )
5247 {
5248 SIZE_T size = TLB_SizeTypeDesc(&elemdesc->tdesc, FALSE);
5249 if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
5250 size += sizeof(*elemdesc->u.paramdesc.pparamdescex);
5251 return size;
5252 }
5253
5254 static HRESULT TLB_CopyElemDesc( const ELEMDESC *src, ELEMDESC *dest, char **buffer )
5255 {
5256 *dest = *src;
5257 *buffer = TLB_CopyTypeDesc(&dest->tdesc, &src->tdesc, *buffer);
5258 if (src->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
5259 {
5260 const PARAMDESCEX *pparamdescex_src = src->u.paramdesc.pparamdescex;
5261 PARAMDESCEX *pparamdescex_dest = dest->u.paramdesc.pparamdescex = (PARAMDESCEX *)*buffer;
5262 *buffer += sizeof(PARAMDESCEX);
5263 *pparamdescex_dest = *pparamdescex_src;
5264 VariantInit(&pparamdescex_dest->varDefaultValue);
5265 return VariantCopy(&pparamdescex_dest->varDefaultValue,
5266 (VARIANTARG *)&pparamdescex_src->varDefaultValue);
5267 }
5268 else
5269 dest->u.paramdesc.pparamdescex = NULL;
5270 return S_OK;
5271 }
5272
5273 static void TLB_FreeElemDesc( ELEMDESC *elemdesc )
5274 {
5275 if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
5276 VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
5277 }
5278
5279 static HRESULT TLB_AllocAndInitFuncDesc( const FUNCDESC *src, FUNCDESC **dest_ptr, BOOL dispinterface )
5280 {
5281 FUNCDESC *dest;
5282 char *buffer;
5283 SIZE_T size = sizeof(*src);
5284 SHORT i;
5285 HRESULT hr;
5286
5287 size += sizeof(*src->lprgscode) * src->cScodes;
5288 size += TLB_SizeElemDesc(&src->elemdescFunc);
5289 for (i = 0; i < src->cParams; i++)
5290 {
5291 size += sizeof(ELEMDESC);
5292 size += TLB_SizeElemDesc(&src->lprgelemdescParam[i]);
5293 }
5294
5295 dest = (FUNCDESC *)SysAllocStringByteLen(NULL, size);
5296 if (!dest) return E_OUTOFMEMORY;
5297
5298 *dest = *src;
5299 if (dispinterface) /* overwrite funckind */
5300 dest->funckind = FUNC_DISPATCH;
5301 buffer = (char *)(dest + 1);
5302
5303 dest->lprgscode = (SCODE *)buffer;
5304 memcpy(dest->lprgscode, src->lprgscode, sizeof(*src->lprgscode) * src->cScodes);
5305 buffer += sizeof(*src->lprgscode) * src->cScodes;
5306
5307 hr = TLB_CopyElemDesc(&src->elemdescFunc, &dest->elemdescFunc, &buffer);
5308 if (FAILED(hr))
5309 {
5310 SysFreeString((BSTR)dest);
5311 return hr;
5312 }
5313
5314 dest->lprgelemdescParam = (ELEMDESC *)buffer;
5315 buffer += sizeof(ELEMDESC) * src->cParams;
5316 for (i = 0; i < src->cParams; i++)
5317 {
5318 hr = TLB_CopyElemDesc(&src->lprgelemdescParam[i], &dest->lprgelemdescParam[i], &buffer);
5319 if (FAILED(hr))
5320 break;
5321 }
5322 if (FAILED(hr))
5323 {
5324 /* undo the above actions */
5325 for (i = i - 1; i >= 0; i--)
5326 TLB_FreeElemDesc(&dest->lprgelemdescParam[i]);
5327 TLB_FreeElemDesc(&dest->elemdescFunc);
5328 SysFreeString((BSTR)dest);
5329 return hr;
5330 }
5331
5332 /* special treatment for dispinterfaces: this makes functions appear
5333 * to return their [retval] value when it is really returning an
5334 * HRESULT */
5335 if (dispinterface && dest->elemdescFunc.tdesc.vt == VT_HRESULT)
5336 {
5337 if (dest->cParams &&
5338 (dest->lprgelemdescParam[dest->cParams - 1].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL))
5339 {
5340 ELEMDESC *elemdesc = &dest->lprgelemdescParam[dest->cParams - 1];
5341 if (elemdesc->tdesc.vt != VT_PTR)
5342 {
5343 ERR("elemdesc should have started with VT_PTR instead of:\n");
5344 if (ERR_ON(ole))
5345 dump_ELEMDESC(elemdesc);
5346 return E_UNEXPECTED;
5347 }
5348
5349 /* copy last parameter to the return value. we are using a flat
5350 * buffer so there is no danger of leaking memory in
5351 * elemdescFunc */
5352 dest->elemdescFunc.tdesc = *elemdesc->tdesc.u.lptdesc;
5353
5354 /* remove the last parameter */
5355 dest->cParams--;
5356 }
5357 else
5358 /* otherwise this function is made to appear to have no return
5359 * value */
5360 dest->elemdescFunc.tdesc.vt = VT_VOID;
5361
5362 }
5363
5364 *dest_ptr = dest;
5365 return S_OK;
5366 }
5367
5368 HRESULT ITypeInfoImpl_GetInternalFuncDesc( ITypeInfo *iface, UINT index, const FUNCDESC **ppFuncDesc )
5369 {
5370 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5371
5372 if (index >= This->TypeAttr.cFuncs)
5373 return TYPE_E_ELEMENTNOTFOUND;
5374
5375 *ppFuncDesc = &This->funcdescs[index].funcdesc;
5376 return S_OK;
5377 }
5378
5379 /* internal function to make the inherited interfaces' methods appear
5380 * part of the interface */
5381 static HRESULT ITypeInfoImpl_GetInternalDispatchFuncDesc( ITypeInfo *iface,
5382 UINT index, const FUNCDESC **ppFuncDesc, UINT *funcs, UINT *hrefoffset)
5383 {
5384 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5385 HRESULT hr;
5386 UINT implemented_funcs = 0;
5387
5388 if (funcs)
5389 *funcs = 0;
5390 else
5391 *hrefoffset = DISPATCH_HREF_OFFSET;
5392
5393 if(This->impltypes)
5394 {
5395 ITypeInfo *pSubTypeInfo;
5396 UINT sub_funcs;
5397
5398 hr = ITypeInfo_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pSubTypeInfo);
5399 if (FAILED(hr))
5400 return hr;
5401
5402 hr = ITypeInfoImpl_GetInternalDispatchFuncDesc(pSubTypeInfo,
5403 index,
5404 ppFuncDesc,
5405 &sub_funcs, hrefoffset);
5406 implemented_funcs += sub_funcs;
5407 ITypeInfo_Release(pSubTypeInfo);
5408 if (SUCCEEDED(hr))
5409 return hr;
5410 *hrefoffset += DISPATCH_HREF_OFFSET;
5411 }
5412
5413 if (funcs)
5414 *funcs = implemented_funcs + This->TypeAttr.cFuncs;
5415 else
5416 *hrefoffset = 0;
5417
5418 if (index < implemented_funcs)
5419 return E_INVALIDARG;
5420 return ITypeInfoImpl_GetInternalFuncDesc(iface, index - implemented_funcs,
5421 ppFuncDesc);
5422 }
5423
5424 static inline void ITypeInfoImpl_ElemDescAddHrefOffset( LPELEMDESC pElemDesc, UINT hrefoffset)
5425 {
5426 TYPEDESC *pTypeDesc = &pElemDesc->tdesc;
5427 while (TRUE)
5428 {
5429 switch (pTypeDesc->vt)
5430 {
5431 case VT_USERDEFINED:
5432 pTypeDesc->u.hreftype += hrefoffset;
5433 return;
5434 case VT_PTR:
5435 case VT_SAFEARRAY:
5436 pTypeDesc = pTypeDesc->u.lptdesc;
5437 break;
5438 case VT_CARRAY:
5439 pTypeDesc = &pTypeDesc->u.lpadesc->tdescElem;
5440 break;
5441 default:
5442 return;
5443 }
5444 }
5445 }
5446
5447 static inline void ITypeInfoImpl_FuncDescAddHrefOffset( LPFUNCDESC pFuncDesc, UINT hrefoffset)
5448 {
5449 SHORT i;
5450 for (i = 0; i < pFuncDesc->cParams; i++)
5451 ITypeInfoImpl_ElemDescAddHrefOffset(&pFuncDesc->lprgelemdescParam[i], hrefoffset);
5452 ITypeInfoImpl_ElemDescAddHrefOffset(&pFuncDesc->elemdescFunc, hrefoffset);
5453 }
5454
5455 /* ITypeInfo::GetFuncDesc
5456 *
5457 * Retrieves the FUNCDESC structure that contains information about a
5458 * specified function.
5459 *
5460 */
5461 static HRESULT WINAPI ITypeInfo_fnGetFuncDesc( ITypeInfo2 *iface, UINT index,
5462 LPFUNCDESC *ppFuncDesc)
5463 {
5464 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5465 const FUNCDESC *internal_funcdesc;
5466 HRESULT hr;
5467 UINT hrefoffset = 0;
5468
5469 TRACE("(%p) index %d\n", This, index);
5470
5471 if (This->TypeAttr.typekind == TKIND_DISPATCH)
5472 hr = ITypeInfoImpl_GetInternalDispatchFuncDesc((ITypeInfo *)iface, index,
5473 &internal_funcdesc, NULL,
5474 &hrefoffset);
5475 else
5476 hr = ITypeInfoImpl_GetInternalFuncDesc((ITypeInfo *)iface, index,
5477 &internal_funcdesc);
5478 if (FAILED(hr))
5479 {
5480 WARN("description for function %d not found\n", index);
5481 return hr;
5482 }
5483
5484 hr = TLB_AllocAndInitFuncDesc(
5485 internal_funcdesc,
5486 ppFuncDesc,
5487 This->TypeAttr.typekind == TKIND_DISPATCH);
5488
5489 if ((This->TypeAttr.typekind == TKIND_DISPATCH) && hrefoffset)
5490 ITypeInfoImpl_FuncDescAddHrefOffset(*ppFuncDesc, hrefoffset);
5491
5492 TRACE("-- 0x%08x\n", hr);
5493 return hr;
5494 }
5495
5496 static HRESULT TLB_AllocAndInitVarDesc( const VARDESC *src, VARDESC **dest_ptr )
5497 {
5498 VARDESC *dest;
5499 char *buffer;
5500 SIZE_T size = sizeof(*src);
5501 HRESULT hr;
5502
5503 if (src->lpstrSchema) size += (strlenW(src->lpstrSchema) + 1) * sizeof(WCHAR);
5504 if (src->varkind == VAR_CONST)
5505 size += sizeof(VARIANT);
5506 size += TLB_SizeElemDesc(&src->elemdescVar);
5507
5508 dest = (VARDESC *)SysAllocStringByteLen(NULL, size);
5509 if (!dest) return E_OUTOFMEMORY;
5510
5511 *dest = *src;
5512 buffer = (char *)(dest + 1);
5513 if (src->lpstrSchema)
5514 {
5515 int len;
5516 dest->lpstrSchema = (LPOLESTR)buffer;
5517 len = strlenW(src->lpstrSchema);
5518 memcpy(dest->lpstrSchema, src->lpstrSchema, (len + 1) * sizeof(WCHAR));
5519 buffer += (len + 1) * sizeof(WCHAR);
5520 }
5521
5522 if (src->varkind == VAR_CONST)
5523 {
5524 HRESULT hr;
5525
5526 dest->u.lpvarValue = (VARIANT *)buffer;
5527 *dest->u.lpvarValue = *src->u.lpvarValue;
5528 buffer += sizeof(VARIANT);
5529 VariantInit(dest->u.lpvarValue);
5530 hr = VariantCopy(dest->u.lpvarValue, src->u.lpvarValue);
5531 if (FAILED(hr))
5532 {
5533 SysFreeString((BSTR)dest);
5534 return hr;
5535 }
5536 }
5537 hr = TLB_CopyElemDesc(&src->elemdescVar, &dest->elemdescVar, &buffer);
5538 if (FAILED(hr))
5539 {
5540 if (src->varkind == VAR_CONST)
5541 VariantClear(dest->u.lpvarValue);
5542 SysFreeString((BSTR)dest);
5543 return hr;
5544 }
5545 *dest_ptr = dest;
5546 return S_OK;
5547 }
5548
5549 /* ITypeInfo::GetVarDesc
5550 *
5551 * Retrieves a VARDESC structure that describes the specified variable.
5552 *
5553 */
5554 static HRESULT WINAPI ITypeInfo_fnGetVarDesc( ITypeInfo2 *iface, UINT index,
5555 LPVARDESC *ppVarDesc)
5556 {
5557 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5558 const TLBVarDesc *pVDesc = &This->vardescs[index];
5559
5560 TRACE("(%p) index %d\n", This, index);
5561
5562 if(index >= This->TypeAttr.cVars)
5563 return TYPE_E_ELEMENTNOTFOUND;
5564
5565 return TLB_AllocAndInitVarDesc(&pVDesc->vardesc, ppVarDesc);
5566 }
5567
5568 /* ITypeInfo_GetNames
5569 *
5570 * Retrieves the variable with the specified member ID (or the name of the
5571 * property or method and its parameters) that correspond to the specified
5572 * function ID.
5573 */
5574 static HRESULT WINAPI ITypeInfo_fnGetNames( ITypeInfo2 *iface, MEMBERID memid,
5575 BSTR *rgBstrNames, UINT cMaxNames, UINT *pcNames)
5576 {
5577 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5578 const TLBFuncDesc *pFDesc;
5579 const TLBVarDesc *pVDesc;
5580 int i;
5581 TRACE("(%p) memid=0x%08x Maxname=%d\n", This, memid, cMaxNames);
5582 pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->TypeAttr.cFuncs, memid);
5583 if(pFDesc)
5584 {
5585 /* function found, now return function and parameter names */
5586 for(i=0; i<cMaxNames && i <= pFDesc->funcdesc.cParams; i++)
5587 {
5588 if(!i)
5589 *rgBstrNames=SysAllocString(pFDesc->Name);
5590 else
5591 rgBstrNames[i]=SysAllocString(pFDesc->pParamDesc[i-1].Name);
5592 }
5593 *pcNames=i;
5594 }
5595 else
5596 {
5597 pVDesc = TLB_get_vardesc_by_memberid(This->vardescs, This->TypeAttr.cVars, memid);
5598 if(pVDesc)
5599 {
5600 *rgBstrNames=SysAllocString(pVDesc->Name);
5601 *pcNames=1;
5602 }
5603 else
5604 {
5605 if(This->impltypes &&
5606 (This->TypeAttr.typekind==TKIND_INTERFACE || This->TypeAttr.typekind==TKIND_DISPATCH)) {
5607 /* recursive search */
5608 ITypeInfo *pTInfo;
5609 HRESULT result;
5610 result = ITypeInfo2_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pTInfo);
5611 if(SUCCEEDED(result))
5612 {
5613 result=ITypeInfo_GetNames(pTInfo, memid, rgBstrNames, cMaxNames, pcNames);
5614 ITypeInfo_Release(pTInfo);
5615 return result;
5616 }
5617 WARN("Could not search inherited interface!\n");
5618 }
5619 else
5620 {
5621 WARN("no names found\n");
5622 }
5623 *pcNames=0;
5624 return TYPE_E_ELEMENTNOTFOUND;
5625 }
5626 }
5627 return S_OK;
5628 }
5629
5630
5631 /* ITypeInfo::GetRefTypeOfImplType
5632 *
5633 * If a type description describes a COM class, it retrieves the type
5634 * description of the implemented interface types. For an interface,
5635 * GetRefTypeOfImplType returns the type information for inherited interfaces,
5636 * if any exist.
5637 *
5638 */
5639 static HRESULT WINAPI ITypeInfo_fnGetRefTypeOfImplType(
5640 ITypeInfo2 *iface,
5641 UINT index,
5642 HREFTYPE *pRefType)
5643 {
5644 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5645 HRESULT hr = S_OK;
5646
5647 TRACE("(%p) index %d\n", This, index);
5648 if (TRACE_ON(ole)) dump_TypeInfo(This);
5649
5650 if(index==(UINT)-1)
5651 {
5652 /* only valid on dual interfaces;
5653 retrieve the associated TKIND_INTERFACE handle for the current TKIND_DISPATCH
5654 */
5655 if( This->TypeAttr.typekind != TKIND_DISPATCH) return E_INVALIDARG;
5656
5657 if (This->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL)
5658 {
5659 *pRefType = -1;
5660 }
5661 else
5662 {
5663 hr = TYPE_E_ELEMENTNOTFOUND;
5664 }
5665 }
5666 else if(index == 0 && This->TypeAttr.typekind == TKIND_DISPATCH)
5667 {
5668 /* All TKIND_DISPATCHs are made to look like they inherit from IDispatch */
5669 *pRefType = This->pTypeLib->dispatch_href;
5670 }
5671 else
5672 {
5673 if(index >= This->TypeAttr.cImplTypes)
5674 hr = TYPE_E_ELEMENTNOTFOUND;
5675 else
5676 *pRefType = This->impltypes[index].hRef;
5677 }
5678
5679 if(TRACE_ON(ole))
5680 {
5681 if(SUCCEEDED(hr))
5682 TRACE("SUCCESS -- hRef = 0x%08x\n", *pRefType );
5683 else
5684 TRACE("FAILURE -- hresult = 0x%08x\n", hr);
5685 }
5686
5687 return hr;
5688 }
5689
5690 /* ITypeInfo::GetImplTypeFlags
5691 *
5692 * Retrieves the IMPLTYPEFLAGS enumeration for one implemented interface
5693 * or base interface in a type description.
5694 */
5695 static HRESULT WINAPI ITypeInfo_fnGetImplTypeFlags( ITypeInfo2 *iface,
5696 UINT index, INT *pImplTypeFlags)
5697 {
5698 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5699
5700 TRACE("(%p) index %d\n", This, index);
5701
5702 if(This->TypeAttr.typekind == TKIND_DISPATCH && index == 0){
5703 *pImplTypeFlags = 0;
5704 return S_OK;
5705 }
5706
5707 if(index >= This->TypeAttr.cImplTypes)
5708 return TYPE_E_ELEMENTNOTFOUND;
5709
5710 *pImplTypeFlags = This->impltypes[index].implflags;
5711
5712 return S_OK;
5713 }
5714
5715 /* GetIDsOfNames
5716 * Maps between member names and member IDs, and parameter names and
5717 * parameter IDs.
5718 */
5719 static HRESULT WINAPI ITypeInfo_fnGetIDsOfNames( ITypeInfo2 *iface,
5720 LPOLESTR *rgszNames, UINT cNames, MEMBERID *pMemId)
5721 {
5722 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5723 const TLBVarDesc *pVDesc;
5724 HRESULT ret=S_OK;
5725 UINT i, fdc;
5726
5727 TRACE("(%p) Name %s cNames %d\n", This, debugstr_w(*rgszNames),
5728 cNames);
5729
5730 /* init out parameters in case of failure */
5731 for (i = 0; i < cNames; i++)
5732 pMemId[i] = MEMBERID_NIL;
5733
5734 for (fdc = 0; fdc < This->TypeAttr.cFuncs; ++fdc) {
5735 int j;
5736 const TLBFuncDesc *pFDesc = &This->funcdescs[fdc];
5737 if(!lstrcmpiW(*rgszNames, pFDesc->Name)) {
5738 if(cNames) *pMemId=pFDesc->funcdesc.memid;
5739 for(i=1; i < cNames; i++){
5740 for(j=0; j<pFDesc->funcdesc.cParams; j++)
5741 if(!lstrcmpiW(rgszNames[i],pFDesc->pParamDesc[j].Name))
5742 break;
5743 if( j<pFDesc->funcdesc.cParams)
5744 pMemId[i]=j;
5745 else
5746 ret=DISP_E_UNKNOWNNAME;
5747 };
5748 TRACE("-- 0x%08x\n", ret);
5749 return ret;
5750 }
5751 }
5752 pVDesc = TLB_get_vardesc_by_name(This->vardescs, This->TypeAttr.cVars, *rgszNames);
5753 if(pVDesc){
5754 if(cNames)
5755 *pMemId = pVDesc->vardesc.memid;
5756 return ret;
5757 }
5758 /* not found, see if it can be found in an inherited interface */
5759 if(This->impltypes) {
5760 /* recursive search */
5761 ITypeInfo *pTInfo;
5762 ret = ITypeInfo2_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pTInfo);
5763 if(SUCCEEDED(ret)){
5764 ret=ITypeInfo_GetIDsOfNames(pTInfo, rgszNames, cNames, pMemId );
5765 ITypeInfo_Release(pTInfo);
5766 return ret;
5767 }
5768 WARN("Could not search inherited interface!\n");
5769 } else
5770 WARN("no names found\n");
5771 return DISP_E_UNKNOWNNAME;
5772 }
5773
5774
5775 #ifdef __i386__
5776
5777 extern LONGLONG call_method( void *func, int nb_args, const DWORD *args, int *stack_offset );
5778 __ASM_GLOBAL_FUNC( call_method,
5779 "pushl %ebp\n\t"
5780 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
5781 __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
5782 "movl %esp,%ebp\n\t"
5783 __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
5784 "pushl %esi\n\t"
5785 __ASM_CFI(".cfi_rel_offset %esi,-4\n\t")
5786 "pushl %edi\n\t"
5787 __ASM_CFI(".cfi_rel_offset %edi,-8\n\t")
5788 "movl 12(%ebp),%edx\n\t"
5789 "movl %esp,%edi\n\t"
5790 "shll $2,%edx\n\t"
5791 "jz 1f\n\t"
5792 "subl %edx,%edi\n\t"
5793 "andl $~15,%edi\n\t"
5794 "movl %edi,%esp\n\t"
5795 "movl 12(%ebp),%ecx\n\t"
5796 "movl 16(%ebp),%esi\n\t"
5797 "cld\n\t"
5798 "rep; movsl\n"
5799 "1:\tcall *8(%ebp)\n\t"
5800 "subl %esp,%edi\n\t"
5801 "movl 20(%ebp),%ecx\n\t"
5802 "movl %edi,(%ecx)\n\t"
5803 "leal -8(%ebp),%esp\n\t"
5804 "popl %edi\n\t"
5805 __ASM_CFI(".cfi_same_value %edi\n\t")
5806 "popl %esi\n\t"
5807 __ASM_CFI(".cfi_same_value %esi\n\t")
5808 "popl %ebp\n\t"
5809 __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
5810 __ASM_CFI(".cfi_same_value %ebp\n\t")
5811 "ret" )
5812
5813 /* same function but returning floating point */
5814 static double (* const call_double_method)(void*,int,const DWORD*,int*) = (void *)call_method;
5815
5816 /* ITypeInfo::Invoke
5817 *
5818 * Invokes a method, or accesses a property of an object, that implements the
5819 * interface described by the type description.
5820 */
5821 DWORD
5822 _invoke(FARPROC func,CALLCONV callconv, int nrargs, DWORD *args) {
5823 DWORD res;
5824 int stack_offset;
5825
5826 if (TRACE_ON(ole)) {
5827 int i;
5828 TRACE("Calling %p(",func);
5829 for (i=0;i<min(nrargs,30);i++) TRACE("%08x,",args[i]);
5830 if (nrargs > 30) TRACE("...");
5831 TRACE(")\n");
5832 }
5833
5834 switch (callconv) {
5835 case CC_STDCALL:
5836 case CC_CDECL:
5837 res = call_method( func, nrargs, args, &stack_offset );
5838 break;
5839 default:
5840 FIXME("unsupported calling convention %d\n",callconv);
5841 res = -1;
5842 break;
5843 }
5844 TRACE("returns %08x\n",res);
5845 return res;
5846 }
5847
5848 #elif defined(__x86_64__)
5849
5850 extern DWORD_PTR CDECL call_method( void *func, int nb_args, const DWORD_PTR *args );
5851 __ASM_GLOBAL_FUNC( call_method,
5852 "pushq %rbp\n\t"
5853 __ASM_CFI(".cfi_adjust_cfa_offset 8\n\t")
5854 __ASM_CFI(".cfi_rel_offset %rbp,0\n\t")
5855 "movq %rsp,%rbp\n\t"
5856 __ASM_CFI(".cfi_def_cfa_register %rbp\n\t")
5857 "pushq %rsi\n\t"
5858 __ASM_CFI(".cfi_rel_offset %rsi,-8\n\t")
5859 "pushq %rdi\n\t"
5860 __ASM_CFI(".cfi_rel_offset %rdi,-16\n\t")
5861 "movq %rcx,%rax\n\t"
5862 "movq $4,%rcx\n\t"
5863 "cmp %rcx,%rdx\n\t"
5864 "cmovgq %rdx,%rcx\n\t"
5865 "leaq 0(,%rcx,8),%rdx\n\t"
5866 "subq %rdx,%rsp\n\t"
5867 "andq $~15,%rsp\n\t"
5868 "movq %rsp,%rdi\n\t"
5869 "movq %r8,%rsi\n\t"
5870 "rep; movsq\n\t"
5871 "movq 0(%rsp),%rcx\n\t"
5872 "movq 8(%rsp),%rdx\n\t"
5873 "movq 16(%rsp),%r8\n\t"
5874 "movq 24(%rsp),%r9\n\t"
5875 "movq %rcx,%xmm0\n\t"
5876 "movq %rdx,%xmm1\n\t"
5877 "movq %r8,%xmm2\n\t"
5878 "movq %r9,%xmm3\n\t"
5879 "callq *%rax\n\t"
5880 "leaq -16(%rbp),%rsp\n\t"
5881 "popq %rdi\n\t"
5882 __ASM_CFI(".cfi_same_value %rdi\n\t")
5883 "popq %rsi\n\t"
5884 __ASM_CFI(".cfi_same_value %rsi\n\t")
5885 __ASM_CFI(".cfi_def_cfa_register %rsp\n\t")
5886 "popq %rbp\n\t"
5887 __ASM_CFI(".cfi_adjust_cfa_offset -8\n\t")
5888 __ASM_CFI(".cfi_same_value %rbp\n\t")
5889 "ret")
5890
5891 /* same function but returning floating point */
5892 static double (CDECL * const call_double_method)(void*,int,const DWORD_PTR*) = (void *)call_method;
5893
5894 #endif /* __x86_64__ */
5895
5896 static HRESULT userdefined_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt)
5897 {
5898 HRESULT hr = S_OK;
5899 ITypeInfo *tinfo2 = NULL;
5900 TYPEATTR *tattr = NULL;
5901
5902 hr = ITypeInfo_GetRefTypeInfo(tinfo, tdesc->u.hreftype, &tinfo2);
5903 if (hr)
5904 {
5905 ERR("Could not get typeinfo of hreftype %x for VT_USERDEFINED, "
5906 "hr = 0x%08x\n",
5907 tdesc->u.hreftype, hr);
5908 return hr;
5909 }
5910 hr = ITypeInfo_GetTypeAttr(tinfo2, &tattr);
5911 if (hr)
5912 {
5913 ERR("ITypeInfo_GetTypeAttr failed, hr = 0x%08x\n", hr);
5914 ITypeInfo_Release(tinfo2);
5915 return hr;
5916 }
5917
5918 switch (tattr->typekind)
5919 {
5920 case TKIND_ENUM:
5921 *vt |= VT_I4;
5922 break;
5923
5924 case TKIND_ALIAS:
5925 tdesc = &tattr->tdescAlias;
5926 hr = typedescvt_to_variantvt(tinfo2, &tattr->tdescAlias, vt);
5927 break;
5928
5929 case TKIND_INTERFACE:
5930 if (tattr->wTypeFlags & TYPEFLAG_FDISPATCHABLE)
5931 *vt |= VT_DISPATCH;
5932 else
5933 *vt |= VT_UNKNOWN;
5934 break;
5935
5936 case TKIND_DISPATCH:
5937 *vt |= VT_DISPATCH;
5938 break;
5939
5940 case TKIND_COCLASS:
5941 *vt |= VT_DISPATCH;
5942 break;
5943
5944 case TKIND_RECORD:
5945 FIXME("TKIND_RECORD unhandled.\n");
5946 hr = E_NOTIMPL;
5947 break;
5948
5949 case TKIND_UNION:
5950 FIXME("TKIND_UNION unhandled.\n");
5951 hr = E_NOTIMPL;
5952 break;
5953
5954 default:
5955 FIXME("TKIND %d unhandled.\n",tattr->typekind);
5956 hr = E_NOTIMPL;
5957 break;
5958 }
5959 ITypeInfo_ReleaseTypeAttr(tinfo2, tattr);
5960 ITypeInfo_Release(tinfo2);
5961 return hr;
5962 }
5963
5964 static HRESULT typedescvt_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt)
5965 {
5966 HRESULT hr = S_OK;
5967
5968 /* enforce only one level of pointer indirection */
5969 if (!(*vt & VT_BYREF) && !(*vt & VT_ARRAY) && (tdesc->vt == VT_PTR))
5970 {
5971 tdesc = tdesc->u.lptdesc;
5972
5973 /* munch VT_PTR -> VT_USERDEFINED(interface) into VT_UNKNOWN or
5974 * VT_DISPATCH and VT_PTR -> VT_PTR -> VT_USERDEFINED(interface) into
5975 * VT_BYREF|VT_DISPATCH or VT_BYREF|VT_UNKNOWN */
5976 if ((tdesc->vt == VT_USERDEFINED) ||
5977 ((tdesc->vt == VT_PTR) && (tdesc->u.lptdesc->vt == VT_USERDEFINED)))
5978 {
5979 VARTYPE vt_userdefined = 0;
5980 const TYPEDESC *tdesc_userdefined = tdesc;
5981 if (tdesc->vt == VT_PTR)
5982 {
5983 vt_userdefined = VT_BYREF;
5984 tdesc_userdefined = tdesc->u.lptdesc;
5985 }
5986 hr = userdefined_to_variantvt(tinfo, tdesc_userdefined, &vt_userdefined);
5987 if ((hr == S_OK) &&
5988 (((vt_userdefined & VT_TYPEMASK) == VT_UNKNOWN) ||
5989 ((vt_userdefined & VT_TYPEMASK) == VT_DISPATCH)))
5990 {
5991 *vt |= vt_userdefined;
5992 return S_OK;
5993 }
5994 }
5995 *vt = VT_BYREF;
5996 }
5997
5998 switch (tdesc->vt)
5999 {
6000 case VT_HRESULT:
6001 *vt |= VT_ERROR;
6002 break;
6003 case VT_USERDEFINED:
6004 hr = userdefined_to_variantvt(tinfo, tdesc, vt);
6005 break;
6006 case VT_VOID:
6007 case VT_CARRAY:
6008 case VT_PTR:
6009 case VT_LPSTR:
6010 case VT_LPWSTR:
6011 ERR("cannot convert type %d into variant VT\n", tdesc->vt);
6012 hr = DISP_E_BADVARTYPE;
6013 break;
6014 case VT_SAFEARRAY:
6015 *vt |= VT_ARRAY;
6016 hr = typedescvt_to_variantvt(tinfo, tdesc->u.lptdesc, vt);
6017 break;
6018 case VT_INT:
6019 *vt |= VT_I4;
6020 break;
6021 case VT_UINT:
6022 *vt |= VT_UI4;
6023 break;
6024 default:
6025 *vt |= tdesc->vt;
6026 break;
6027 }
6028 return hr;
6029 }
6030
6031 static HRESULT get_iface_guid(ITypeInfo *tinfo, const TYPEDESC *tdesc, GUID *guid)
6032 {
6033 ITypeInfo *tinfo2;
6034 TYPEATTR *tattr;
6035 HRESULT hres;
6036
6037 hres = ITypeInfo_GetRefTypeInfo(tinfo, tdesc->u.hreftype, &tinfo2);
6038 if(FAILED(hres))
6039 return hres;
6040
6041 hres = ITypeInfo_GetTypeAttr(tinfo2, &tattr);
6042 if(FAILED(hres)) {
6043 ITypeInfo_Release(tinfo2);
6044 return hres;
6045 }
6046
6047 switch(tattr->typekind) {
6048 case TKIND_ALIAS:
6049 hres = get_iface_guid(tinfo2, &tattr->tdescAlias, guid);
6050 break;
6051
6052 case TKIND_INTERFACE:
6053 case TKIND_DISPATCH:
6054 *guid = tattr->guid;
6055 break;
6056
6057 default:
6058 ERR("Unexpected typekind %d\n", tattr->typekind);
6059 hres = E_UNEXPECTED;
6060 }
6061
6062 ITypeInfo_ReleaseTypeAttr(tinfo2, tattr);
6063 ITypeInfo_Release(tinfo2);
6064 return hres;
6065 }
6066
6067 /***********************************************************************
6068 * DispCallFunc (OLEAUT32.@)
6069 *
6070 * Invokes a function of the specified calling convention, passing the
6071 * specified arguments and returns the result.
6072 *
6073 * PARAMS
6074 * pvInstance [I] Optional pointer to the instance whose function to invoke.
6075 * oVft [I] The offset in the vtable. See notes.
6076 * cc [I] Calling convention of the function to call.
6077 * vtReturn [I] The return type of the function.
6078 * cActuals [I] Number of parameters.
6079 * prgvt [I] The types of the parameters to pass. This is used for sizing only.
6080 * prgpvarg [I] The arguments to pass.
6081 * pvargResult [O] The return value of the function. Can be NULL.
6082 *
6083 * RETURNS
6084 * Success: S_OK.
6085 * Failure: HRESULT code.
6086 *
6087 * NOTES
6088 * The HRESULT return value of this function is not affected by the return
6089 * value of the user supplied function, which is returned in pvargResult.
6090 *
6091 * If pvInstance is NULL then a non-object function is to be called and oVft
6092 * is the address of the function to call.
6093 *
6094 * The cc parameter can be one of the following values:
6095 *|CC_FASTCALL
6096 *|CC_CDECL
6097 *|CC_PASCAL
6098 *|CC_STDCALL
6099 *|CC_FPFASTCALL
6100 *|CC_SYSCALL
6101 *|CC_MPWCDECL
6102 *|CC_MPWPASCAL
6103 *
6104 */
6105 HRESULT WINAPI
6106 DispCallFunc(
6107 void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn, UINT cActuals,
6108 VARTYPE* prgvt, VARIANTARG** prgpvarg, VARIANT* pvargResult)
6109 {
6110 #ifdef __i386__
6111 int argspos, stack_offset;
6112 void *func;
6113 UINT i;
6114 DWORD *args;
6115
6116 TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n",
6117 pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg,
6118 pvargResult, V_VT(pvargResult));
6119
6120 if (cc != CC_STDCALL && cc != CC_CDECL)
6121 {
6122 FIXME("unsupported calling convention %d\n",cc);
6123 return E_INVALIDARG;
6124 }
6125
6126 /* maximum size for an argument is sizeof(VARIANT) */
6127 args = heap_alloc(sizeof(VARIANT) * cActuals + sizeof(DWORD) * 2 );
6128
6129 /* start at 1 in case we need to pass a pointer to the return value as arg 0 */
6130 argspos = 1;
6131 if (pvInstance)
6132 {
6133 const FARPROC *vtable = *(FARPROC **)pvInstance;
6134 func = vtable[oVft/sizeof(void *)];
6135 args[argspos++] = (DWORD)pvInstance; /* the This pointer is always the first parameter */
6136 }
6137 else func = (void *)oVft;
6138
6139 for (i = 0; i < cActuals; i++)
6140 {
6141 VARIANT *arg = prgpvarg[i];
6142
6143 switch (prgvt[i])
6144 {
6145 case VT_EMPTY:
6146 break;
6147 case VT_I8:
6148 case VT_UI8:
6149 case VT_R8:
6150 case VT_DATE:
6151 case VT_CY:
6152 memcpy( &args[argspos], &V_I8(arg), sizeof(V_I8(arg)) );
6153 argspos += sizeof(V_I8(arg)) / sizeof(DWORD);
6154 break;
6155 case VT_DECIMAL:
6156 case VT_VARIANT:
6157 memcpy( &args[argspos], arg, sizeof(*arg) );
6158 argspos += sizeof(*arg) / sizeof(DWORD);
6159 break;
6160 case VT_BOOL: /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */
6161 args[argspos++] = V_BOOL(arg);
6162 break;
6163 default:
6164 args[argspos++] = V_UI4(arg);
6165 break;
6166 }
6167 TRACE("arg %u: type %d\n",i,prgvt[i]);
6168 dump_Variant(arg);
6169 }
6170
6171 switch (vtReturn)
6172 {
6173 case VT_EMPTY:
6174 call_method( func, argspos - 1, args + 1, &stack_offset );
6175 break;
6176 case VT_R4:
6177 V_R4(pvargResult) = call_double_method( func, argspos - 1, args + 1, &stack_offset );
6178 break;
6179 case VT_R8:
6180 case VT_DATE:
6181 V_R8(pvargResult) = call_double_method( func, argspos - 1, args + 1, &stack_offset );
6182 break;
6183 case VT_DECIMAL:
6184 case VT_VARIANT:
6185 args[0] = (DWORD)pvargResult; /* arg 0 is a pointer to the result */
6186 call_method( func, argspos, args, &stack_offset );
6187 break;
6188 case VT_I8:
6189 case VT_UI8:
6190 case VT_CY:
6191 V_UI8(pvargResult) = call_method( func, argspos - 1, args + 1, &stack_offset );
6192 break;
6193 case VT_HRESULT:
6194 WARN("invalid return type %u\n", vtReturn);
6195 heap_free( args );
6196 return E_INVALIDARG;
6197 default:
6198 V_UI4(pvargResult) = call_method( func, argspos - 1, args + 1, &stack_offset );
6199 break;
6200 }
6201 heap_free( args );
6202 if (stack_offset && cc == CC_STDCALL)
6203 {
6204 WARN( "stack pointer off by %d\n", stack_offset );
6205 return DISP_E_BADCALLEE;
6206 }
6207 if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn;
6208 TRACE("retval: "); dump_Variant(pvargResult);
6209 return S_OK;
6210
6211 #elif defined(__x86_64__)
6212 int argspos;
6213 UINT i;
6214 DWORD_PTR *args;
6215 void *func;
6216
6217 TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n",
6218 pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg,
6219 pvargResult, V_VT(pvargResult));
6220
6221 if (cc != CC_STDCALL && cc != CC_CDECL)
6222 {
6223 FIXME("unsupported calling convention %d\n",cc);
6224 return E_INVALIDARG;
6225 }
6226
6227 /* maximum size for an argument is sizeof(DWORD_PTR) */
6228 args = heap_alloc( sizeof(DWORD_PTR) * (cActuals + 2) );
6229
6230 /* start at 1 in case we need to pass a pointer to the return value as arg 0 */
6231 argspos = 1;
6232 if (pvInstance)
6233 {
6234 const FARPROC *vtable = *(FARPROC **)pvInstance;
6235 func = vtable[oVft/sizeof(void *)];
6236 args[argspos++] = (DWORD_PTR)pvInstance; /* the This pointer is always the first parameter */
6237 }
6238 else func = (void *)oVft;
6239
6240 for (i = 0; i < cActuals; i++)
6241 {
6242 VARIANT *arg = prgpvarg[i];
6243
6244 switch (prgvt[i])
6245 {
6246 case VT_DECIMAL:
6247 case VT_VARIANT:
6248 args[argspos++] = (ULONG_PTR)arg;
6249 break;
6250 case VT_BOOL: /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */
6251 args[argspos++] = V_BOOL(arg);
6252 break;
6253 default:
6254 args[argspos++] = V_UI8(arg);
6255 break;
6256 }
6257 TRACE("arg %u: type %d\n",i,prgvt[i]);
6258 dump_Variant(arg);
6259 }
6260
6261 switch (vtReturn)
6262 {
6263 case VT_R4:
6264 V_R4(pvargResult) = call_double_method( func, argspos - 1, args + 1 );
6265 break;
6266 case VT_R8:
6267 case VT_DATE:
6268 V_R8(pvargResult) = call_double_method( func, argspos - 1, args + 1 );
6269 break;
6270 case VT_DECIMAL:
6271 case VT_VARIANT:
6272 args[0] = (DWORD_PTR)pvargResult; /* arg 0 is a pointer to the result */
6273 call_method( func, argspos, args );
6274 break;
6275 case VT_HRESULT:
6276 WARN("invalid return type %u\n", vtReturn);
6277 heap_free( args );
6278 return E_INVALIDARG;
6279 default:
6280 V_UI8(pvargResult) = call_method( func, argspos - 1, args + 1 );
6281 break;
6282 }
6283 heap_free( args );
6284 if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn;
6285 TRACE("retval: "); dump_Variant(pvargResult);
6286 return S_OK;
6287
6288 #else
6289 FIXME( "(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d)): not implemented for this CPU\n",
6290 pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, pvargResult, V_VT(pvargResult));
6291 return E_NOTIMPL;
6292 #endif
6293 }
6294
6295 static inline BOOL func_restricted( const FUNCDESC *desc )
6296 {
6297 return (desc->wFuncFlags & FUNCFLAG_FRESTRICTED) && (desc->memid >= 0);
6298 }
6299
6300 #define INVBUF_ELEMENT_SIZE \
6301 (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *) + sizeof(VARTYPE))
6302 #define INVBUF_GET_ARG_ARRAY(buffer, params) (buffer)
6303 #define INVBUF_GET_MISSING_ARG_ARRAY(buffer, params) \
6304 ((VARIANTARG *)((char *)(buffer) + sizeof(VARIANTARG) * (params)))
6305 #define INVBUF_GET_ARG_PTR_ARRAY(buffer, params) \
6306 ((VARIANTARG **)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG)) * (params)))
6307 #define INVBUF_GET_ARG_TYPE_ARRAY(buffer, params) \
6308 ((VARTYPE *)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *)) * (params)))
6309
6310 static HRESULT WINAPI ITypeInfo_fnInvoke(
6311 ITypeInfo2 *iface,
6312 VOID *pIUnk,
6313 MEMBERID memid,
6314 UINT16 wFlags,
6315 DISPPARAMS *pDispParams,
6316 VARIANT *pVarResult,
6317 EXCEPINFO *pExcepInfo,
6318 UINT *pArgErr)
6319 {
6320 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6321 int i;
6322 unsigned int var_index;
6323 TYPEKIND type_kind;
6324 HRESULT hres;
6325 const TLBFuncDesc *pFuncInfo;
6326 UINT fdc;
6327
6328 TRACE("(%p)(%p,id=%d,flags=0x%08x,%p,%p,%p,%p)\n",
6329 This,pIUnk,memid,wFlags,pDispParams,pVarResult,pExcepInfo,pArgErr
6330 );
6331
6332 if( This->TypeAttr.wTypeFlags & TYPEFLAG_FRESTRICTED )
6333 return DISP_E_MEMBERNOTFOUND;
6334
6335 if (!pDispParams)
6336 {
6337 ERR("NULL pDispParams not allowed\n");
6338 return E_INVALIDARG;
6339 }
6340
6341 dump_DispParms(pDispParams);
6342
6343 if (pDispParams->cNamedArgs > pDispParams->cArgs)
6344 {
6345 ERR("named argument array cannot be bigger than argument array (%d/%d)\n",
6346 pDispParams->cNamedArgs, pDispParams->cArgs);
6347 return E_INVALIDARG;
6348 }
6349
6350 /* we do this instead of using GetFuncDesc since it will return a fake
6351 * FUNCDESC for dispinterfaces and we want the real function description */
6352 for (fdc = 0; fdc < This->TypeAttr.cFuncs; ++fdc){
6353 pFuncInfo = &This->funcdescs[fdc];
6354 if ((memid == pFuncInfo->funcdesc.memid) &&
6355 (wFlags & pFuncInfo->funcdesc.invkind) &&
6356 !func_restricted( &pFuncInfo->funcdesc ))
6357 break;
6358 }
6359
6360 if (fdc < This->TypeAttr.cFuncs) {
6361 const FUNCDESC *func_desc = &pFuncInfo->funcdesc;
6362
6363 if (TRACE_ON(ole))
6364 {
6365 TRACE("invoking:\n");
6366 dump_TLBFuncDescOne(pFuncInfo);
6367 }
6368
6369 switch (func_desc->funckind) {
6370 case FUNC_PUREVIRTUAL:
6371 case FUNC_VIRTUAL: {
6372 void *buffer = heap_alloc_zero(INVBUF_ELEMENT_SIZE * func_desc->cParams);
6373 VARIANT varresult;
6374 VARIANT retval; /* pointer for storing byref retvals in */
6375 VARIANTARG **prgpvarg = INVBUF_GET_ARG_PTR_ARRAY(buffer, func_desc->cParams);
6376 VARIANTARG *rgvarg = INVBUF_GET_ARG_ARRAY(buffer, func_desc->cParams);
6377 VARTYPE *rgvt = INVBUF_GET_ARG_TYPE_ARRAY(buffer, func_desc->cParams);
6378 UINT cNamedArgs = pDispParams->cNamedArgs;
6379 DISPID *rgdispidNamedArgs = pDispParams->rgdispidNamedArgs;
6380 UINT vargs_converted=0;
6381
6382 hres = S_OK;
6383
6384 if (func_desc->invkind & (INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF))
6385 {
6386 if (!cNamedArgs || (rgdispidNamedArgs[0] != DISPID_PROPERTYPUT))
6387 {
6388 ERR("first named arg for property put invocation must be DISPID_PROPERTYPUT\n");
6389 hres = DISP_E_PARAMNOTFOUND;
6390 goto func_fail;
6391 }
6392 }
6393
6394 if (func_desc->cParamsOpt < 0 && cNamedArgs)
6395 {
6396 ERR("functions with the vararg attribute do not support named arguments\n");
6397 hres = DISP_E_NONAMEDARGS;
6398 goto func_fail;
6399 }
6400
6401 for (i = 0; i < func_desc->cParams; i++)
6402 {
6403 TYPEDESC *tdesc = &func_desc->lprgelemdescParam[i].tdesc;
6404 hres = typedescvt_to_variantvt((ITypeInfo *)iface, tdesc, &rgvt[i]);
6405 if (FAILED(hres))
6406 goto func_fail;
6407 }
6408
6409 TRACE("changing args\n");
6410 for (i = 0; i < func_desc->cParams; i++)
6411 {
6412 USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
6413 TYPEDESC *tdesc = &func_desc->lprgelemdescParam[i].tdesc;
6414 VARIANTARG *src_arg;
6415
6416 if (wParamFlags & PARAMFLAG_FLCID)
6417 {
6418 VARIANTARG *arg;
6419 arg = prgpvarg[i] = &rgvarg[i];
6420 V_VT(arg) = VT_I4;
6421 V_I4(arg) = This->pTypeLib->lcid;
6422 continue;
6423 }
6424
6425 src_arg = NULL;
6426
6427 if (cNamedArgs)
6428 {
6429 USHORT j;
6430 for (j = 0; j < cNamedArgs; j++)
6431 if (rgdispidNamedArgs[j] == i || (i == func_desc->cParams-1 && rgdispidNamedArgs[j] == DISPID_PROPERTYPUT))
6432 {
6433 src_arg = &pDispParams->rgvarg[j];
6434 break;
6435 }
6436 }
6437
6438 if (!src_arg && vargs_converted + cNamedArgs < pDispParams->cArgs)
6439 {
6440 src_arg = &pDispParams->rgvarg[pDispParams->cArgs - 1 - vargs_converted];
6441 vargs_converted++;
6442 }
6443
6444 if (wParamFlags & PARAMFLAG_FRETVAL)
6445 {
6446 /* under most conditions the caller is not allowed to
6447 * pass in a dispparam arg in the index of what would be
6448 * the retval parameter. however, there is an exception
6449 * where the extra parameter is used in an extra
6450 * IDispatch::Invoke below */
6451 if ((i < pDispParams->cArgs) &&
6452 ((func_desc->cParams != 1) || !pVarResult ||
6453 !(func_desc->invkind & INVOKE_PROPERTYGET)))
6454 {
6455 hres = DISP_E_BADPARAMCOUNT;
6456 break;
6457 }
6458
6459 /* note: this check is placed so that if the caller passes
6460 * in a VARIANTARG for the retval we just ignore it, like
6461 * native does */
6462 if (i == func_desc->cParams - 1)
6463 {
6464 VARIANTARG *arg;
6465 arg = prgpvarg[i] = &rgvarg[i];
6466 memset(arg, 0, sizeof(*arg));
6467 V_VT(arg) = rgvt[i];
6468 memset(&retval, 0, sizeof(retval));
6469 V_BYREF(arg) = &retval;
6470 }
6471 else
6472 {
6473 ERR("[retval] parameter must be the last parameter of the method (%d/%d)\n", i, func_desc->cParams);
6474 hres = E_UNEXPECTED;
6475 break;
6476 }
6477 }
6478 else if (src_arg)
6479 {
6480 dump_Variant(src_arg);
6481
6482 if(rgvt[i]!=V_VT(src_arg))
6483 {
6484 if (rgvt[i] == VT_VARIANT)
6485 hres = VariantCopy(&rgvarg[i], src_arg);
6486 else if (rgvt[i] == (VT_VARIANT | VT_BYREF))
6487 {
6488 if (rgvt[i] == V_VT(src_arg))
6489 V_VARIANTREF(&rgvarg[i]) = V_VARIANTREF(src_arg);
6490 else
6491 {
6492 VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
6493 if (wParamFlags & PARAMFLAG_FIN)
6494 hres = VariantCopy(&missing_arg[i], src_arg);
6495 V_VARIANTREF(&rgvarg[i]) = &missing_arg[i];
6496 }
6497 V_VT(&rgvarg[i]) = rgvt[i];
6498 }
6499 else if (rgvt[i] == (VT_VARIANT | VT_ARRAY) && func_desc->cParamsOpt < 0 && i == func_desc->cParams-1)
6500 {
6501 SAFEARRAY *a;
6502 SAFEARRAYBOUND bound;
6503 VARIANT *v;
6504 LONG j;
6505 bound.lLbound = 0;
6506 bound.cElements = pDispParams->cArgs-i;
6507 if (!(a = SafeArrayCreate(VT_VARIANT, 1, &bound)))
6508 {
6509 ERR("SafeArrayCreate failed\n");
6510 break;
6511 }
6512 hres = SafeArrayAccessData(a, (LPVOID)&v);
6513 if (hres != S_OK)
6514 {
6515 ERR("SafeArrayAccessData failed with %x\n", hres);
6516 SafeArrayDestroy(a);
6517 break;
6518 }
6519 for (j = 0; j < bound.cElements; j++)
6520 VariantCopy(&v[j], &pDispParams->rgvarg[pDispParams->cArgs - 1 - i - j]);
6521 hres = SafeArrayUnaccessData(a);
6522 if (hres != S_OK)
6523 {
6524 ERR("SafeArrayUnaccessData failed with %x\n", hres);
6525 SafeArrayDestroy(a);
6526 break;
6527 }
6528 V_ARRAY(&rgvarg[i]) = a;
6529 V_VT(&rgvarg[i]) = rgvt[i];
6530 }
6531 else if ((rgvt[i] & VT_BYREF) && !V_ISBYREF(src_arg))
6532 {
6533 VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
6534 if (wParamFlags & PARAMFLAG_FIN)
6535 hres = VariantChangeType(&missing_arg[i], src_arg, 0, rgvt[i] & ~VT_BYREF);
6536 else
6537 V_VT(&missing_arg[i]) = rgvt[i] & ~VT_BYREF;
6538 V_BYREF(&rgvarg[i]) = &V_NONE(&missing_arg[i]);
6539 V_VT(&rgvarg[i]) = rgvt[i];
6540 }
6541 else if ((rgvt[i] & VT_BYREF) && (rgvt[i] == V_VT(src_arg)))
6542 {
6543 V_BYREF(&rgvarg[i]) = V_BYREF(src_arg);
6544 V_VT(&rgvarg[i]) = rgvt[i];
6545 }
6546 else
6547 {
6548 /* FIXME: this doesn't work for VT_BYREF arguments if
6549 * they are not the same type as in the paramdesc */
6550 V_VT(&rgvarg[i]) = V_VT(src_arg);
6551 hres = VariantChangeType(&rgvarg[i], src_arg, 0, rgvt[i]);
6552 V_VT(&rgvarg[i]) = rgvt[i];
6553 }
6554
6555 if (FAILED(hres))
6556 {
6557 ERR("failed to convert param %d to %s%s from %s%s\n", i,
6558 debugstr_vt(rgvt[i]), debugstr_vf(rgvt[i]),
6559 debugstr_VT(src_arg), debugstr_VF(src_arg));
6560 break;
6561 }
6562 prgpvarg[i] = &rgvarg[i];
6563 }
6564 else
6565 {
6566 prgpvarg[i] = src_arg;
6567 }
6568
6569 if((tdesc->vt == VT_USERDEFINED || (tdesc->vt == VT_PTR && tdesc->u.lptdesc->vt == VT_USERDEFINED))
6570 && (V_VT(prgpvarg[i]) == VT_DISPATCH || V_VT(prgpvarg[i]) == VT_UNKNOWN)
6571 && V_UNKNOWN(prgpvarg[i])) {
6572 IUnknown *userdefined_iface;
6573 GUID guid;
6574
6575 hres = get_iface_guid((ITypeInfo*)iface, tdesc->vt == VT_PTR ? tdesc->u.lptdesc : tdesc, &guid);
6576 if(FAILED(hres))
6577 break;
6578
6579 hres = IUnknown_QueryInterface(V_UNKNOWN(prgpvarg[i]), &guid, (void**)&userdefined_iface);
6580 if(FAILED(hres)) {
6581 ERR("argument does not support %s interface\n", debugstr_guid(&guid));
6582 break;
6583 }
6584
6585 IUnknown_Release(V_UNKNOWN(prgpvarg[i]));
6586 V_UNKNOWN(prgpvarg[i]) = userdefined_iface;
6587 }
6588 }
6589 else if (wParamFlags & PARAMFLAG_FOPT)
6590 {
6591 VARIANTARG *arg;
6592 arg = prgpvarg[i] = &rgvarg[i];
6593 if (wParamFlags & PARAMFLAG_FHASDEFAULT)
6594 {
6595 hres = VariantCopy(arg, &func_desc->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue);
6596 if (FAILED(hres))
6597 break;
6598 }
6599 else
6600 {
6601 VARIANTARG *missing_arg;
6602 /* if the function wants a pointer to a variant then
6603 * set that up, otherwise just pass the VT_ERROR in
6604 * the argument by value */
6605 if (rgvt[i] & VT_BYREF)
6606 {
6607 missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams) + i;
6608 V_VT(arg) = VT_VARIANT | VT_BYREF;
6609 V_VARIANTREF(arg) = missing_arg;
6610 }
6611 else
6612 missing_arg = arg;
6613 V_VT(missing_arg) = VT_ERROR;
6614 V_ERROR(missing_arg) = DISP_E_PARAMNOTFOUND;
6615 }
6616 }
6617 else
6618 {
6619 hres = DISP_E_BADPARAMCOUNT;
6620 break;
6621 }
6622 }
6623 if (FAILED(hres)) goto func_fail; /* FIXME: we don't free changed types here */
6624
6625 /* VT_VOID is a special case for return types, so it is not
6626 * handled in the general function */
6627 if (func_desc->elemdescFunc.tdesc.vt == VT_VOID)
6628 V_VT(&varresult) = VT_EMPTY;
6629 else
6630 {
6631 V_VT(&varresult) = 0;
6632 hres = typedescvt_to_variantvt((ITypeInfo *)iface, &func_desc->elemdescFunc.tdesc, &V_VT(&varresult));
6633 if (FAILED(hres)) goto func_fail; /* FIXME: we don't free changed types here */
6634 }
6635
6636 hres = DispCallFunc(pIUnk, func_desc->oVft, func_desc->callconv,
6637 V_VT(&varresult), func_desc->cParams, rgvt,
6638 prgpvarg, &varresult);
6639
6640 vargs_converted = 0;
6641
6642 for (i = 0; i < func_desc->cParams; i++)
6643 {
6644 USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
6645 VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
6646
6647 if (wParamFlags & PARAMFLAG_FLCID)
6648 continue;
6649 else if (wParamFlags & PARAMFLAG_FRETVAL)
6650 {
6651 if (TRACE_ON(ole))
6652 {
6653 TRACE("[retval] value: ");
6654 dump_Variant(prgpvarg[i]);
6655 }
6656
6657 if (pVarResult)
6658 {
6659 VariantInit(pVarResult);
6660 /* deref return value */
6661 hres = VariantCopyInd(pVarResult, prgpvarg[i]);
6662 }
6663
6664 VARIANT_ClearInd(prgpvarg[i]);
6665 }
6666 else if (vargs_converted < pDispParams->cArgs)
6667 {
6668 VARIANTARG *arg = &pDispParams->rgvarg[pDispParams->cArgs - 1 - vargs_converted];
6669 if (wParamFlags & PARAMFLAG_FOUT)
6670 {
6671 if ((rgvt[i] & VT_BYREF) && !(V_VT(arg) & VT_BYREF))
6672 {
6673 hres = VariantChangeType(arg, &rgvarg[i], 0, V_VT(arg));
6674
6675 if (FAILED(hres))
6676 {
6677 ERR("failed to convert param %d to vt %d\n", i,
6678 V_VT(&pDispParams->rgvarg[pDispParams->cArgs - 1 - vargs_converted]));
6679 break;
6680 }
6681 }
6682 }
6683 else if (V_VT(prgpvarg[i]) == (VT_VARIANT | VT_ARRAY) &&
6684 func_desc->cParamsOpt < 0 &&
6685 i == func_desc->cParams-1)
6686 {
6687 SAFEARRAY *a = V_ARRAY(prgpvarg[i]);
6688 LONG j, ubound;
6689 VARIANT *v;
6690 hres = SafeArrayGetUBound(a, 1, &ubound);
6691 if (hres != S_OK)
6692 {
6693 ERR("SafeArrayGetUBound failed with %x\n", hres);
6694 break;
6695 }
6696 hres = SafeArrayAccessData(a, (LPVOID)&v);
6697 if (hres != S_OK)
6698 {
6699 ERR("SafeArrayAccessData failed with %x\n", hres);
6700 break;
6701 }
6702 for (j = 0; j <= ubound; j++)
6703 VariantClear(&v[j]);
6704 hres = SafeArrayUnaccessData(a);
6705 if (hres != S_OK)
6706 {
6707 ERR("SafeArrayUnaccessData failed with %x\n", hres);
6708 break;
6709 }
6710 }
6711 VariantClear(&rgvarg[i]);
6712 vargs_converted++;
6713 }
6714 else if (wParamFlags & PARAMFLAG_FOPT)
6715 {
6716 if (wParamFlags & PARAMFLAG_FHASDEFAULT)
6717 VariantClear(&rgvarg[i]);
6718 }
6719
6720 VariantClear(&missing_arg[i]);
6721 }
6722
6723 if ((V_VT(&varresult) == VT_ERROR) && FAILED(V_ERROR(&varresult)))
6724 {
6725 WARN("invoked function failed with error 0x%08x\n", V_ERROR(&varresult));
6726 hres = DISP_E_EXCEPTION;
6727 if (pExcepInfo)
6728 {
6729 IErrorInfo *pErrorInfo;
6730 pExcepInfo->scode = V_ERROR(&varresult);
6731 if (GetErrorInfo(0, &pErrorInfo) == S_OK)
6732 {
6733 IErrorInfo_GetDescription(pErrorInfo, &pExcepInfo->bstrDescription);
6734 IErrorInfo_GetHelpFile(pErrorInfo, &pExcepInfo->bstrHelpFile);
6735 IErrorInfo_GetSource(pErrorInfo, &pExcepInfo->bstrSource);
6736 IErrorInfo_GetHelpContext(pErrorInfo, &pExcepInfo->dwHelpContext);
6737
6738 IErrorInfo_Release(pErrorInfo);
6739 }
6740 }
6741 }
6742 if (V_VT(&varresult) != VT_ERROR)
6743 {
6744 TRACE("varresult value: ");
6745 dump_Variant(&varresult);
6746
6747 if (pVarResult)
6748 {
6749 VariantClear(pVarResult);
6750 *pVarResult = varresult;
6751 }
6752 else
6753 VariantClear(&varresult);
6754 }
6755
6756 if (SUCCEEDED(hres) && pVarResult && (func_desc->cParams == 1) &&
6757 (func_desc->invkind & INVOKE_PROPERTYGET) &&
6758 (func_desc->lprgelemdescParam[0].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL) &&
6759 (pDispParams->cArgs != 0))
6760 {
6761 if (V_VT(pVarResult) == VT_DISPATCH)
6762 {
6763 IDispatch *pDispatch = V_DISPATCH(pVarResult);
6764 /* Note: not VariantClear; we still need the dispatch
6765 * pointer to be valid */
6766 VariantInit(pVarResult);
6767 hres = IDispatch_Invoke(pDispatch, DISPID_VALUE, &IID_NULL,
6768 GetSystemDefaultLCID(), INVOKE_PROPERTYGET,
6769 pDispParams, pVarResult, pExcepInfo, pArgErr);
6770 IDispatch_Release(pDispatch);
6771 }
6772 else
6773 {
6774 VariantClear(pVarResult);
6775 hres = DISP_E_NOTACOLLECTION;
6776 }
6777 }
6778
6779 func_fail:
6780 heap_free(buffer);
6781 break;
6782 }
6783 case FUNC_DISPATCH: {
6784 IDispatch *disp;
6785
6786 hres = IUnknown_QueryInterface((LPUNKNOWN)pIUnk,&IID_IDispatch,(LPVOID*)&disp);
6787 if (SUCCEEDED(hres)) {
6788 FIXME("Calling Invoke in IDispatch iface. untested!\n");
6789 hres = IDispatch_Invoke(
6790 disp,memid,&IID_NULL,LOCALE_USER_DEFAULT,wFlags,pDispParams,
6791 pVarResult,pExcepInfo,pArgErr
6792 );
6793 if (FAILED(hres))
6794 FIXME("IDispatch::Invoke failed with %08x. (Could be not a real error?)\n", hres);
6795 IDispatch_Release(disp);
6796 } else
6797 FIXME("FUNC_DISPATCH used on object without IDispatch iface?\n");
6798 break;
6799 }
6800 default:
6801 FIXME("Unknown function invocation type %d\n", func_desc->funckind);
6802 hres = E_FAIL;
6803 break;
6804 }
6805
6806 TRACE("-- 0x%08x\n", hres);
6807 return hres;
6808
6809 } else if(SUCCEEDED(hres = ITypeInfo2_GetVarIndexOfMemId(iface, memid, &var_index))) {
6810 VARDESC *var_desc;
6811
6812 hres = ITypeInfo2_GetVarDesc(iface, var_index, &var_desc);
6813 if(FAILED(hres)) return hres;
6814
6815 FIXME("varseek: Found memid, but variable-based invoking not supported\n");
6816 dump_VARDESC(var_desc);
6817 ITypeInfo2_ReleaseVarDesc(iface, var_desc);
6818 return E_NOTIMPL;
6819 }
6820
6821 /* not found, look for it in inherited interfaces */
6822 ITypeInfo2_GetTypeKind(iface, &type_kind);
6823 if(type_kind == TKIND_INTERFACE || type_kind == TKIND_DISPATCH) {
6824 if(This->impltypes) {
6825 /* recursive search */
6826 ITypeInfo *pTInfo;
6827 hres = ITypeInfo2_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pTInfo);
6828 if(SUCCEEDED(hres)){
6829 hres = ITypeInfo_Invoke(pTInfo,pIUnk,memid,wFlags,pDispParams,pVarResult,pExcepInfo,pArgErr);
6830 ITypeInfo_Release(pTInfo);
6831 return hres;
6832 }
6833 WARN("Could not search inherited interface!\n");
6834 }
6835 }
6836 WARN("did not find member id %d, flags 0x%x!\n", memid, wFlags);
6837 return DISP_E_MEMBERNOTFOUND;
6838 }
6839
6840 /* ITypeInfo::GetDocumentation
6841 *
6842 * Retrieves the documentation string, the complete Help file name and path,
6843 * and the context ID for the Help topic for a specified type description.
6844 *
6845 * (Can be tested by the Visual Basic Editor in Word for instance.)
6846 */
6847 static HRESULT WINAPI ITypeInfo_fnGetDocumentation( ITypeInfo2 *iface,
6848 MEMBERID memid, BSTR *pBstrName, BSTR *pBstrDocString,
6849 DWORD *pdwHelpContext, BSTR *pBstrHelpFile)
6850 {
6851 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6852 const TLBFuncDesc *pFDesc;
6853 const TLBVarDesc *pVDesc;
6854 TRACE("(%p) memid %d Name(%p) DocString(%p)"
6855 " HelpContext(%p) HelpFile(%p)\n",
6856 This, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
6857 if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
6858 if(pBstrName)
6859 *pBstrName=SysAllocString(This->Name);
6860 if(pBstrDocString)
6861 *pBstrDocString=SysAllocString(This->DocString);
6862 if(pdwHelpContext)
6863 *pdwHelpContext=This->dwHelpContext;
6864 if(pBstrHelpFile)
6865 *pBstrHelpFile=SysAllocString(This->DocString);/* FIXME */
6866 return S_OK;
6867 }else {/* for a member */
6868 pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->TypeAttr.cFuncs, memid);
6869 if(pFDesc){
6870 if(pBstrName)
6871 *pBstrName = SysAllocString(pFDesc->Name);
6872 if(pBstrDocString)
6873 *pBstrDocString=SysAllocString(pFDesc->HelpString);
6874 if(pdwHelpContext)
6875 *pdwHelpContext=pFDesc->helpcontext;
6876 return S_OK;
6877 }
6878 pVDesc = TLB_get_vardesc_by_memberid(This->vardescs, This->TypeAttr.cVars, memid);
6879 if(pVDesc){
6880 if(pBstrName)
6881 *pBstrName = SysAllocString(pVDesc->Name);
6882 if(pBstrDocString)
6883 *pBstrDocString=SysAllocString(pVDesc->HelpString);
6884 if(pdwHelpContext)
6885 *pdwHelpContext=pVDesc->HelpContext;
6886 return S_OK;
6887 }
6888 }
6889
6890 if(This->impltypes &&
6891 (This->TypeAttr.typekind==TKIND_INTERFACE || This->TypeAttr.typekind==TKIND_DISPATCH)) {
6892 /* recursive search */
6893 ITypeInfo *pTInfo;
6894 HRESULT result;
6895 result = ITypeInfo2_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pTInfo);
6896 if(SUCCEEDED(result)) {
6897 result = ITypeInfo_GetDocumentation(pTInfo, memid, pBstrName,
6898 pBstrDocString, pdwHelpContext, pBstrHelpFile);
6899 ITypeInfo_Release(pTInfo);
6900 return result;
6901 }
6902 WARN("Could not search inherited interface!\n");
6903 }
6904
6905 WARN("member %d not found\n", memid);
6906 return TYPE_E_ELEMENTNOTFOUND;
6907 }
6908
6909 /* ITypeInfo::GetDllEntry
6910 *
6911 * Retrieves a description or specification of an entry point for a function
6912 * in a DLL.
6913 */
6914 static HRESULT WINAPI ITypeInfo_fnGetDllEntry( ITypeInfo2 *iface, MEMBERID memid,
6915 INVOKEKIND invKind, BSTR *pBstrDllName, BSTR *pBstrName,
6916 WORD *pwOrdinal)
6917 {
6918 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6919 const TLBFuncDesc *pFDesc;
6920
6921 TRACE("(%p)->(memid %x, %d, %p, %p, %p)\n", This, memid, invKind, pBstrDllName, pBstrName, pwOrdinal);
6922
6923 if (pBstrDllName) *pBstrDllName = NULL;
6924 if (pBstrName) *pBstrName = NULL;
6925 if (pwOrdinal) *pwOrdinal = 0;
6926
6927 if (This->TypeAttr.typekind != TKIND_MODULE)
6928 return TYPE_E_BADMODULEKIND;
6929
6930 pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->TypeAttr.cFuncs, memid);
6931 if(pFDesc){
6932 dump_TypeInfo(This);
6933 if (TRACE_ON(ole))
6934 dump_TLBFuncDescOne(pFDesc);
6935
6936 if (pBstrDllName)
6937 *pBstrDllName = SysAllocString(This->DllName);
6938
6939 if (!IS_INTRESOURCE(pFDesc->Entry) && (pFDesc->Entry != (void*)-1)) {
6940 if (pBstrName)
6941 *pBstrName = SysAllocString(pFDesc->Entry);
6942 if (pwOrdinal)
6943 *pwOrdinal = -1;
6944 return S_OK;
6945 }
6946 if (pBstrName)
6947 *pBstrName = NULL;
6948 if (pwOrdinal)
6949 *pwOrdinal = LOWORD(pFDesc->Entry);
6950 return S_OK;
6951 }
6952 return TYPE_E_ELEMENTNOTFOUND;
6953 }
6954
6955 /* internal function to make the inherited interfaces' methods appear
6956 * part of the interface */
6957 static HRESULT ITypeInfoImpl_GetDispatchRefTypeInfo( ITypeInfo *iface,
6958 HREFTYPE *hRefType, ITypeInfo **ppTInfo)
6959 {
6960 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6961 HRESULT hr;
6962
6963 TRACE("%p, 0x%x\n", iface, *hRefType);
6964
6965 if (This->impltypes && (*hRefType & DISPATCH_HREF_MASK))
6966 {
6967 ITypeInfo *pSubTypeInfo;
6968
6969 hr = ITypeInfo_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pSubTypeInfo);
6970 if (FAILED(hr))
6971 return hr;
6972
6973 hr = ITypeInfoImpl_GetDispatchRefTypeInfo(pSubTypeInfo,
6974 hRefType, ppTInfo);
6975 ITypeInfo_Release(pSubTypeInfo);
6976 if (SUCCEEDED(hr))
6977 return hr;
6978 }
6979 *hRefType -= DISPATCH_HREF_OFFSET;
6980
6981 if (!(*hRefType & DISPATCH_HREF_MASK))
6982 return ITypeInfo_GetRefTypeInfo(iface, *hRefType, ppTInfo);
6983 else
6984 return E_FAIL;
6985 }
6986
6987 /* ITypeInfo::GetRefTypeInfo
6988 *
6989 * If a type description references other type descriptions, it retrieves
6990 * the referenced type descriptions.
6991 */
6992 static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo(
6993 ITypeInfo2 *iface,
6994 HREFTYPE hRefType,
6995 ITypeInfo **ppTInfo)
6996 {
6997 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6998 HRESULT result = E_FAIL;
6999
7000 if ((This->hreftype != -1) && (This->hreftype == hRefType))
7001 {
7002 *ppTInfo = (ITypeInfo *)&This->ITypeInfo2_iface;
7003 ITypeInfo_AddRef(*ppTInfo);
7004 result = S_OK;
7005 }
7006 else if (hRefType == -1 &&
7007 (This->TypeAttr.typekind == TKIND_DISPATCH) &&
7008 (This->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL))
7009 {
7010 /* when we meet a DUAL dispinterface, we must create the interface
7011 * version of it.
7012 */
7013 ITypeInfoImpl *pTypeInfoImpl = ITypeInfoImpl_Constructor();
7014
7015
7016 /* the interface version contains the same information as the dispinterface
7017 * copy the contents of the structs.
7018 */
7019 *pTypeInfoImpl = *This;
7020 pTypeInfoImpl->ref = 0;
7021
7022 /* change the type to interface */
7023 pTypeInfoImpl->TypeAttr.typekind = TKIND_INTERFACE;
7024
7025 *ppTInfo = (ITypeInfo*) pTypeInfoImpl;
7026
7027 /* the AddRef implicitly adds a reference to the parent typelib, which
7028 * stops the copied data from being destroyed until the new typeinfo's
7029 * refcount goes to zero, but we need to signal to the new instance to
7030 * not free its data structures when it is destroyed */
7031 pTypeInfoImpl->not_attached_to_typelib = TRUE;
7032
7033 ITypeInfo_AddRef(*ppTInfo);
7034
7035 result = S_OK;
7036
7037 } else if ((hRefType != -1) && (hRefType & DISPATCH_HREF_MASK) &&
7038 (This->TypeAttr.typekind == TKIND_DISPATCH))
7039 {
7040 HREFTYPE href_dispatch = hRefType;
7041 result = ITypeInfoImpl_GetDispatchRefTypeInfo((ITypeInfo *)iface, &href_dispatch, ppTInfo);
7042 } else {
7043 TLBRefType *ref_type;
7044 LIST_FOR_EACH_ENTRY(ref_type, &This->pTypeLib->ref_list, TLBRefType, entry)
7045 {
7046 if(ref_type->reference == hRefType)
7047 break;
7048 }
7049 if(&ref_type->entry == &This->pTypeLib->ref_list)
7050 {
7051 FIXME("Can't find pRefType for ref %x\n", hRefType);
7052 goto end;
7053 }
7054 if(hRefType != -1) {
7055 ITypeLib *pTLib = NULL;
7056
7057 if(ref_type->pImpTLInfo == TLB_REF_INTERNAL) {
7058 UINT Index;
7059 result = ITypeInfo2_GetContainingTypeLib(iface, &pTLib, &Index);
7060 } else {
7061 if(ref_type->pImpTLInfo->pImpTypeLib) {
7062 TRACE("typeinfo in imported typelib that is already loaded\n");
7063 pTLib = (ITypeLib*)&ref_type->pImpTLInfo->pImpTypeLib->ITypeLib2_iface;
7064 ITypeLib_AddRef(pTLib);
7065 result = S_OK;
7066 } else {
7067 TRACE("typeinfo in imported typelib that isn't already loaded\n");
7068 result = LoadRegTypeLib( &ref_type->pImpTLInfo->guid,
7069 ref_type->pImpTLInfo->wVersionMajor,
7070 ref_type->pImpTLInfo->wVersionMinor,
7071 ref_type->pImpTLInfo->lcid,
7072 &pTLib);
7073
7074 if(FAILED(result)) {
7075 BSTR libnam=SysAllocString(ref_type->pImpTLInfo->name);
7076 result=LoadTypeLib(libnam, &pTLib);
7077 SysFreeString(libnam);
7078 }
7079 if(SUCCEEDED(result)) {
7080 ref_type->pImpTLInfo->pImpTypeLib = (ITypeLibImpl*)pTLib;
7081 ITypeLib_AddRef(pTLib);
7082 }
7083 }
7084 }
7085 if(SUCCEEDED(result)) {
7086 if(ref_type->index == TLB_REF_USE_GUID)
7087 result = ITypeLib_GetTypeInfoOfGuid(pTLib, &ref_type->guid, ppTInfo);
7088 else
7089 result = ITypeLib_GetTypeInfo(pTLib, ref_type->index, ppTInfo);
7090 }
7091 if (pTLib != NULL)
7092 ITypeLib_Release(pTLib);
7093 }
7094 }
7095
7096 end:
7097 TRACE("(%p) hreftype 0x%04x loaded %s (%p)\n", This, hRefType,
7098 SUCCEEDED(result)? "SUCCESS":"FAILURE", *ppTInfo);
7099 return result;
7100 }
7101
7102 /* ITypeInfo::AddressOfMember
7103 *
7104 * Retrieves the addresses of static functions or variables, such as those
7105 * defined in a DLL.
7106 */
7107 static HRESULT WINAPI ITypeInfo_fnAddressOfMember( ITypeInfo2 *iface,
7108 MEMBERID memid, INVOKEKIND invKind, PVOID *ppv)
7109 {
7110 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7111 HRESULT hr;
7112 BSTR dll, entry;
7113 WORD ordinal;
7114 HMODULE module;
7115
7116 TRACE("(%p)->(0x%x, 0x%x, %p)\n", This, memid, invKind, ppv);
7117
7118 hr = ITypeInfo2_GetDllEntry(iface, memid, invKind, &dll, &entry, &ordinal);
7119 if (FAILED(hr))
7120 return hr;
7121
7122 module = LoadLibraryW(dll);
7123 if (!module)
7124 {
7125 ERR("couldn't load %s\n", debugstr_w(dll));
7126 SysFreeString(dll);
7127 SysFreeString(entry);
7128 return STG_E_FILENOTFOUND;
7129 }
7130 /* FIXME: store library somewhere where we can free it */
7131
7132 if (entry)
7133 {
7134 LPSTR entryA;
7135 INT len = WideCharToMultiByte(CP_ACP, 0, entry, -1, NULL, 0, NULL, NULL);
7136 entryA = heap_alloc(len);
7137 WideCharToMultiByte(CP_ACP, 0, entry, -1, entryA, len, NULL, NULL);
7138
7139 *ppv = GetProcAddress(module, entryA);
7140 if (!*ppv)
7141 ERR("function not found %s\n", debugstr_a(entryA));
7142
7143 heap_free(entryA);
7144 }
7145 else
7146 {
7147 *ppv = GetProcAddress(module, MAKEINTRESOURCEA(ordinal));
7148 if (!*ppv)
7149 ERR("function not found %d\n", ordinal);
7150 }
7151
7152 SysFreeString(dll);
7153 SysFreeString(entry);
7154
7155 if (!*ppv)
7156 return TYPE_E_DLLFUNCTIONNOTFOUND;
7157
7158 return S_OK;
7159 }
7160
7161 /* ITypeInfo::CreateInstance
7162 *
7163 * Creates a new instance of a type that describes a component object class
7164 * (coclass).
7165 */
7166 static HRESULT WINAPI ITypeInfo_fnCreateInstance( ITypeInfo2 *iface,
7167 IUnknown *pOuterUnk, REFIID riid, VOID **ppvObj)
7168 {
7169 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7170 HRESULT hr;
7171 TYPEATTR *pTA;
7172
7173 TRACE("(%p)->(%p, %s, %p)\n", This, pOuterUnk, debugstr_guid(riid), ppvObj);
7174
7175 *ppvObj = NULL;
7176
7177 if(pOuterUnk)
7178 {
7179 WARN("Not able to aggregate\n");
7180 return CLASS_E_NOAGGREGATION;
7181 }
7182
7183 hr = ITypeInfo2_GetTypeAttr(iface, &pTA);
7184 if(FAILED(hr)) return hr;
7185
7186 if(pTA->typekind != TKIND_COCLASS)
7187 {
7188 WARN("CreateInstance on typeinfo of type %x\n", pTA->typekind);
7189 hr = E_INVALIDARG;
7190 goto end;
7191 }
7192
7193 hr = S_FALSE;
7194 if(pTA->wTypeFlags & TYPEFLAG_FAPPOBJECT)
7195 {
7196 IUnknown *pUnk;
7197 hr = GetActiveObject(&pTA->guid, NULL, &pUnk);
7198 TRACE("GetActiveObject rets %08x\n", hr);
7199 if(hr == S_OK)
7200 {
7201 hr = IUnknown_QueryInterface(pUnk, riid, ppvObj);
7202 IUnknown_Release(pUnk);
7203 }
7204 }
7205
7206 if(hr != S_OK)
7207 hr = CoCreateInstance(&pTA->guid, NULL,
7208 CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
7209 riid, ppvObj);
7210
7211 end:
7212 ITypeInfo2_ReleaseTypeAttr(iface, pTA);
7213 return hr;
7214 }
7215
7216 /* ITypeInfo::GetMops
7217 *
7218 * Retrieves marshalling information.
7219 */
7220 static HRESULT WINAPI ITypeInfo_fnGetMops( ITypeInfo2 *iface, MEMBERID memid,
7221 BSTR *pBstrMops)
7222 {
7223 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7224 FIXME("(%p %d) stub!\n", This, memid);
7225 *pBstrMops = NULL;
7226 return S_OK;
7227 }
7228
7229 /* ITypeInfo::GetContainingTypeLib
7230 *
7231 * Retrieves the containing type library and the index of the type description
7232 * within that type library.
7233 */
7234 static HRESULT WINAPI ITypeInfo_fnGetContainingTypeLib( ITypeInfo2 *iface,
7235 ITypeLib * *ppTLib, UINT *pIndex)
7236 {
7237 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7238
7239 /* If a pointer is null, we simply ignore it, the ATL in particular passes pIndex as 0 */
7240 if (pIndex) {
7241 *pIndex=This->index;
7242 TRACE("returning pIndex=%d\n", *pIndex);
7243 }
7244
7245 if (ppTLib) {
7246 *ppTLib=(LPTYPELIB )(This->pTypeLib);
7247 ITypeLib_AddRef(*ppTLib);
7248 TRACE("returning ppTLib=%p\n", *ppTLib);
7249 }
7250
7251 return S_OK;
7252 }
7253
7254 /* ITypeInfo::ReleaseTypeAttr
7255 *
7256 * Releases a TYPEATTR previously returned by GetTypeAttr.
7257 *
7258 */
7259 static void WINAPI ITypeInfo_fnReleaseTypeAttr( ITypeInfo2 *iface,
7260 TYPEATTR* pTypeAttr)
7261 {
7262 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7263 TRACE("(%p)->(%p)\n", This, pTypeAttr);
7264 heap_free(pTypeAttr);
7265 }
7266
7267 /* ITypeInfo::ReleaseFuncDesc
7268 *
7269 * Releases a FUNCDESC previously returned by GetFuncDesc. *
7270 */
7271 static void WINAPI ITypeInfo_fnReleaseFuncDesc(
7272 ITypeInfo2 *iface,
7273 FUNCDESC *pFuncDesc)
7274 {
7275 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7276 SHORT i;
7277
7278 TRACE("(%p)->(%p)\n", This, pFuncDesc);
7279
7280 for (i = 0; i < pFuncDesc->cParams; i++)
7281 TLB_FreeElemDesc(&pFuncDesc->lprgelemdescParam[i]);
7282 TLB_FreeElemDesc(&pFuncDesc->elemdescFunc);
7283
7284 SysFreeString((BSTR)pFuncDesc);
7285 }
7286
7287 /* ITypeInfo::ReleaseVarDesc
7288 *
7289 * Releases a VARDESC previously returned by GetVarDesc.
7290 */
7291 static void WINAPI ITypeInfo_fnReleaseVarDesc( ITypeInfo2 *iface,
7292 VARDESC *pVarDesc)
7293 {
7294 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7295 TRACE("(%p)->(%p)\n", This, pVarDesc);
7296
7297 TLB_FreeElemDesc(&pVarDesc->elemdescVar);
7298 if (pVarDesc->varkind == VAR_CONST)
7299 VariantClear(pVarDesc->u.lpvarValue);
7300 SysFreeString((BSTR)pVarDesc);
7301 }
7302
7303 /* ITypeInfo2::GetTypeKind
7304 *
7305 * Returns the TYPEKIND enumeration quickly, without doing any allocations.
7306 *
7307 */
7308 static HRESULT WINAPI ITypeInfo2_fnGetTypeKind( ITypeInfo2 * iface,
7309 TYPEKIND *pTypeKind)
7310 {
7311 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7312 *pTypeKind=This->TypeAttr.typekind;
7313 TRACE("(%p) type 0x%0x\n", This,*pTypeKind);
7314 return S_OK;
7315 }
7316
7317 /* ITypeInfo2::GetTypeFlags
7318 *
7319 * Returns the type flags without any allocations. This returns a DWORD type
7320 * flag, which expands the type flags without growing the TYPEATTR (type
7321 * attribute).
7322 *
7323 */
7324 static HRESULT WINAPI ITypeInfo2_fnGetTypeFlags( ITypeInfo2 *iface, ULONG *pTypeFlags)
7325 {
7326 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7327 *pTypeFlags=This->TypeAttr.wTypeFlags;
7328 TRACE("(%p) flags 0x%x\n", This,*pTypeFlags);
7329 return S_OK;
7330 }
7331
7332 /* ITypeInfo2::GetFuncIndexOfMemId
7333 * Binds to a specific member based on a known DISPID, where the member name
7334 * is not known (for example, when binding to a default member).
7335 *
7336 */
7337 static HRESULT WINAPI ITypeInfo2_fnGetFuncIndexOfMemId( ITypeInfo2 * iface,
7338 MEMBERID memid, INVOKEKIND invKind, UINT *pFuncIndex)
7339 {
7340 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7341 UINT fdc;
7342 HRESULT result;
7343
7344 for (fdc = 0; fdc < This->TypeAttr.cFuncs; ++fdc){
7345 const TLBFuncDesc *pFuncInfo = &This->funcdescs[fdc];
7346 if(memid == pFuncInfo->funcdesc.memid && (invKind & pFuncInfo->funcdesc.invkind))
7347 break;
7348 }
7349 if(fdc < This->TypeAttr.cFuncs) {
7350 *pFuncIndex = fdc;
7351 result = S_OK;
7352 } else
7353 result = TYPE_E_ELEMENTNOTFOUND;
7354
7355 TRACE("(%p) memid 0x%08x invKind 0x%04x -> %s\n", This,
7356 memid, invKind, SUCCEEDED(result) ? "SUCCESS" : "FAILED");
7357 return result;
7358 }
7359
7360 /* TypeInfo2::GetVarIndexOfMemId
7361 *
7362 * Binds to a specific member based on a known DISPID, where the member name
7363 * is not known (for example, when binding to a default member).
7364 *
7365 */
7366 static HRESULT WINAPI ITypeInfo2_fnGetVarIndexOfMemId( ITypeInfo2 * iface,
7367 MEMBERID memid, UINT *pVarIndex)
7368 {
7369 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7370 TLBVarDesc *pVarInfo;
7371
7372 TRACE("%p %d %p\n", iface, memid, pVarIndex);
7373
7374 pVarInfo = TLB_get_vardesc_by_memberid(This->vardescs, This->TypeAttr.cVars, memid);
7375 if(!pVarInfo)
7376 return TYPE_E_ELEMENTNOTFOUND;
7377
7378 *pVarIndex = (pVarInfo - This->vardescs);
7379
7380 return S_OK;
7381 }
7382
7383 /* ITypeInfo2::GetCustData
7384 *
7385 * Gets the custom data
7386 */
7387 static HRESULT WINAPI ITypeInfo2_fnGetCustData(
7388 ITypeInfo2 * iface,
7389 REFGUID guid,
7390 VARIANT *pVarVal)
7391 {
7392 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7393 TLBCustData *pCData;
7394
7395 TRACE("%p %s %p\n", This, debugstr_guid(guid), pVarVal);
7396
7397 pCData = TLB_get_custdata_by_guid(&This->custdata_list, guid);
7398
7399 VariantInit( pVarVal);
7400 if (pCData)
7401 VariantCopy( pVarVal, &pCData->data);
7402 else
7403 VariantClear( pVarVal );
7404 return S_OK;
7405 }
7406
7407 /* ITypeInfo2::GetFuncCustData
7408 *
7409 * Gets the custom data
7410 */
7411 static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData(
7412 ITypeInfo2 * iface,
7413 UINT index,
7414 REFGUID guid,
7415 VARIANT *pVarVal)
7416 {
7417 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7418 TLBCustData *pCData;
7419 TLBFuncDesc *pFDesc = &This->funcdescs[index];
7420
7421 TRACE("%p %u %s %p\n", This, index, debugstr_guid(guid), pVarVal);
7422
7423 if(index >= This->TypeAttr.cFuncs)
7424 return TYPE_E_ELEMENTNOTFOUND;
7425
7426 pCData = TLB_get_custdata_by_guid(&pFDesc->custdata_list, guid);
7427 if(!pCData)
7428 return TYPE_E_ELEMENTNOTFOUND;
7429
7430 VariantInit(pVarVal);
7431 VariantCopy(pVarVal, &pCData->data);
7432
7433 return S_OK;
7434 }
7435
7436 /* ITypeInfo2::GetParamCustData
7437 *
7438 * Gets the custom data
7439 */
7440 static HRESULT WINAPI ITypeInfo2_fnGetParamCustData(
7441 ITypeInfo2 * iface,
7442 UINT indexFunc,
7443 UINT indexParam,
7444 REFGUID guid,
7445 VARIANT *pVarVal)
7446 {
7447 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7448 TLBCustData *pCData;
7449 TLBFuncDesc *pFDesc = &This->funcdescs[indexFunc];
7450
7451 TRACE("%p %u %u %s %p\n", This, indexFunc, indexParam,
7452 debugstr_guid(guid), pVarVal);
7453
7454 if(indexFunc >= This->TypeAttr.cFuncs)
7455 return TYPE_E_ELEMENTNOTFOUND;
7456
7457 if(indexParam >= pFDesc->funcdesc.cParams)
7458 return TYPE_E_ELEMENTNOTFOUND;
7459
7460 pCData = TLB_get_custdata_by_guid(&pFDesc->pParamDesc[indexParam].custdata_list, guid);
7461 if(!pCData)
7462 return TYPE_E_ELEMENTNOTFOUND;
7463
7464 VariantInit(pVarVal);
7465 VariantCopy(pVarVal, &pCData->data);
7466
7467 return S_OK;
7468 }
7469
7470 /* ITypeInfo2::GetVarCustData
7471 *
7472 * Gets the custom data
7473 */
7474 static HRESULT WINAPI ITypeInfo2_fnGetVarCustData(
7475 ITypeInfo2 * iface,
7476 UINT index,
7477 REFGUID guid,
7478 VARIANT *pVarVal)
7479 {
7480 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7481 TLBCustData *pCData;
7482 TLBVarDesc *pVDesc = &This->vardescs[index];
7483
7484 TRACE("%p %s %p\n", This, debugstr_guid(guid), pVarVal);
7485
7486 if(index >= This->TypeAttr.cVars)
7487 return TYPE_E_ELEMENTNOTFOUND;
7488
7489 pCData = TLB_get_custdata_by_guid(&pVDesc->custdata_list, guid);
7490 if(!pCData)
7491 return TYPE_E_ELEMENTNOTFOUND;
7492
7493 VariantInit(pVarVal);
7494 VariantCopy(pVarVal, &pCData->data);
7495
7496 return S_OK;
7497 }
7498
7499 /* ITypeInfo2::GetImplCustData
7500 *
7501 * Gets the custom data
7502 */
7503 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData(
7504 ITypeInfo2 * iface,
7505 UINT index,
7506 REFGUID guid,
7507 VARIANT *pVarVal)
7508 {
7509 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7510 TLBCustData *pCData;
7511 TLBImplType *pRDesc = &This->impltypes[index];
7512
7513 TRACE("%p %u %s %p\n", This, index, debugstr_guid(guid), pVarVal);
7514
7515 if(index >= This->TypeAttr.cImplTypes)
7516 return TYPE_E_ELEMENTNOTFOUND;
7517
7518 pCData = TLB_get_custdata_by_guid(&pRDesc->custdata_list, guid);
7519 if(!pCData)
7520 return TYPE_E_ELEMENTNOTFOUND;
7521
7522 VariantInit(pVarVal);
7523 VariantCopy(pVarVal, &pCData->data);
7524
7525 return S_OK;
7526 }
7527
7528 /* ITypeInfo2::GetDocumentation2
7529 *
7530 * Retrieves the documentation string, the complete Help file name and path,
7531 * the localization context to use, and the context ID for the library Help
7532 * topic in the Help file.
7533 *
7534 */
7535 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2(
7536 ITypeInfo2 * iface,
7537 MEMBERID memid,
7538 LCID lcid,
7539 BSTR *pbstrHelpString,
7540 DWORD *pdwHelpStringContext,
7541 BSTR *pbstrHelpStringDll)
7542 {
7543 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7544 const TLBFuncDesc *pFDesc;
7545 const TLBVarDesc *pVDesc;
7546 TRACE("(%p) memid %d lcid(0x%x) HelpString(%p) "
7547 "HelpStringContext(%p) HelpStringDll(%p)\n",
7548 This, memid, lcid, pbstrHelpString, pdwHelpStringContext,
7549 pbstrHelpStringDll );
7550 /* the help string should be obtained from the helpstringdll,
7551 * using the _DLLGetDocumentation function, based on the supplied
7552 * lcid. Nice to do sometime...
7553 */
7554 if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
7555 if(pbstrHelpString)
7556 *pbstrHelpString=SysAllocString(This->Name);
7557 if(pdwHelpStringContext)
7558 *pdwHelpStringContext=This->dwHelpStringContext;
7559 if(pbstrHelpStringDll)
7560 *pbstrHelpStringDll=
7561 SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
7562 return S_OK;
7563 }else {/* for a member */
7564 pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->TypeAttr.cFuncs, memid);
7565 if(pFDesc){
7566 if(pbstrHelpString)
7567 *pbstrHelpString=SysAllocString(pFDesc->HelpString);
7568 if(pdwHelpStringContext)
7569 *pdwHelpStringContext=pFDesc->HelpStringContext;
7570 if(pbstrHelpStringDll)
7571 *pbstrHelpStringDll=
7572 SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
7573 return S_OK;
7574 }
7575 pVDesc = TLB_get_vardesc_by_memberid(This->vardescs, This->TypeAttr.cVars, memid);
7576 if(pVDesc){
7577 if(pbstrHelpString)
7578 *pbstrHelpString=SysAllocString(pVDesc->HelpString);
7579 if(pdwHelpStringContext)
7580 *pdwHelpStringContext=pVDesc->HelpStringContext;
7581 if(pbstrHelpStringDll)
7582 *pbstrHelpStringDll=
7583 SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
7584 return S_OK;
7585 }
7586 }
7587 return TYPE_E_ELEMENTNOTFOUND;
7588 }
7589
7590 /* ITypeInfo2::GetAllCustData
7591 *
7592 * Gets all custom data items for the Type info.
7593 *
7594 */
7595 static HRESULT WINAPI ITypeInfo2_fnGetAllCustData(
7596 ITypeInfo2 * iface,
7597 CUSTDATA *pCustData)
7598 {
7599 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7600
7601 TRACE("%p %p\n", This, pCustData);
7602
7603 return TLB_copy_all_custdata(&This->custdata_list, pCustData);
7604 }
7605
7606 /* ITypeInfo2::GetAllFuncCustData
7607 *
7608 * Gets all custom data items for the specified Function
7609 *
7610 */
7611 static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData(
7612 ITypeInfo2 * iface,
7613 UINT index,
7614 CUSTDATA *pCustData)
7615 {
7616 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7617 TLBFuncDesc *pFDesc = &This->funcdescs[index];
7618
7619 TRACE("%p %u %p\n", This, index, pCustData);
7620
7621 if(index >= This->TypeAttr.cFuncs)
7622 return TYPE_E_ELEMENTNOTFOUND;
7623
7624 return TLB_copy_all_custdata(&pFDesc->custdata_list, pCustData);
7625 }
7626
7627 /* ITypeInfo2::GetAllParamCustData
7628 *
7629 * Gets all custom data items for the Functions
7630 *
7631 */
7632 static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData( ITypeInfo2 * iface,
7633 UINT indexFunc, UINT indexParam, CUSTDATA *pCustData)
7634 {
7635 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7636 TLBFuncDesc *pFDesc = &This->funcdescs[indexFunc];
7637
7638 TRACE("%p %u %u %p\n", This, indexFunc, indexParam, pCustData);
7639
7640 if(indexFunc >= This->TypeAttr.cFuncs)
7641 return TYPE_E_ELEMENTNOTFOUND;
7642
7643 if(indexParam >= pFDesc->funcdesc.cParams)
7644 return TYPE_E_ELEMENTNOTFOUND;
7645
7646 return TLB_copy_all_custdata(&pFDesc->pParamDesc[indexParam].custdata_list, pCustData);
7647 }
7648
7649 /* ITypeInfo2::GetAllVarCustData
7650 *
7651 * Gets all custom data items for the specified Variable
7652 *
7653 */
7654 static HRESULT WINAPI ITypeInfo2_fnGetAllVarCustData( ITypeInfo2 * iface,
7655 UINT index, CUSTDATA *pCustData)
7656 {
7657 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7658 TLBVarDesc * pVDesc = &This->vardescs[index];
7659
7660 TRACE("%p %u %p\n", This, index, pCustData);
7661
7662 if(index >= This->TypeAttr.cVars)
7663 return TYPE_E_ELEMENTNOTFOUND;
7664
7665 return TLB_copy_all_custdata(&pVDesc->custdata_list, pCustData);
7666 }
7667
7668 /* ITypeInfo2::GetAllImplCustData
7669 *
7670 * Gets all custom data items for the specified implementation type
7671 *
7672 */
7673 static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData(
7674 ITypeInfo2 * iface,
7675 UINT index,
7676 CUSTDATA *pCustData)
7677 {
7678 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7679 TLBImplType *pRDesc = &This->impltypes[index];
7680
7681 TRACE("%p %u %p\n", This, index, pCustData);
7682
7683 if(index >= This->TypeAttr.cImplTypes)
7684 return TYPE_E_ELEMENTNOTFOUND;
7685
7686 return TLB_copy_all_custdata(&pRDesc->custdata_list, pCustData);
7687 }
7688
7689 static const ITypeInfo2Vtbl tinfvt =
7690 {
7691
7692 ITypeInfo_fnQueryInterface,
7693 ITypeInfo_fnAddRef,
7694 ITypeInfo_fnRelease,
7695
7696 ITypeInfo_fnGetTypeAttr,
7697 ITypeInfo_fnGetTypeComp,
7698 ITypeInfo_fnGetFuncDesc,
7699 ITypeInfo_fnGetVarDesc,
7700 ITypeInfo_fnGetNames,
7701 ITypeInfo_fnGetRefTypeOfImplType,
7702 ITypeInfo_fnGetImplTypeFlags,
7703 ITypeInfo_fnGetIDsOfNames,
7704 ITypeInfo_fnInvoke,
7705 ITypeInfo_fnGetDocumentation,
7706 ITypeInfo_fnGetDllEntry,
7707 ITypeInfo_fnGetRefTypeInfo,
7708 ITypeInfo_fnAddressOfMember,
7709 ITypeInfo_fnCreateInstance,
7710 ITypeInfo_fnGetMops,
7711 ITypeInfo_fnGetContainingTypeLib,
7712 ITypeInfo_fnReleaseTypeAttr,
7713 ITypeInfo_fnReleaseFuncDesc,
7714 ITypeInfo_fnReleaseVarDesc,
7715
7716 ITypeInfo2_fnGetTypeKind,
7717 ITypeInfo2_fnGetTypeFlags,
7718 ITypeInfo2_fnGetFuncIndexOfMemId,
7719 ITypeInfo2_fnGetVarIndexOfMemId,
7720 ITypeInfo2_fnGetCustData,
7721 ITypeInfo2_fnGetFuncCustData,
7722 ITypeInfo2_fnGetParamCustData,
7723 ITypeInfo2_fnGetVarCustData,
7724 ITypeInfo2_fnGetImplTypeCustData,
7725 ITypeInfo2_fnGetDocumentation2,
7726 ITypeInfo2_fnGetAllCustData,
7727 ITypeInfo2_fnGetAllFuncCustData,
7728 ITypeInfo2_fnGetAllParamCustData,
7729 ITypeInfo2_fnGetAllVarCustData,
7730 ITypeInfo2_fnGetAllImplTypeCustData,
7731 };
7732
7733 /******************************************************************************
7734 * CreateDispTypeInfo [OLEAUT32.31]
7735 *
7736 * Build type information for an object so it can be called through an
7737 * IDispatch interface.
7738 *
7739 * RETURNS
7740 * Success: S_OK. pptinfo contains the created ITypeInfo object.
7741 * Failure: E_INVALIDARG, if one or more arguments is invalid.
7742 *
7743 * NOTES
7744 * This call allows an objects methods to be accessed through IDispatch, by
7745 * building an ITypeInfo object that IDispatch can use to call through.
7746 */
7747 HRESULT WINAPI CreateDispTypeInfo(
7748 INTERFACEDATA *pidata, /* [I] Description of the interface to build type info for */
7749 LCID lcid, /* [I] Locale Id */
7750 ITypeInfo **pptinfo) /* [O] Destination for created ITypeInfo object */
7751 {
7752 ITypeInfoImpl *pTIClass, *pTIIface;
7753 ITypeLibImpl *pTypeLibImpl;
7754 unsigned int param, func;
7755 TLBFuncDesc *pFuncDesc;
7756 TLBRefType *ref;
7757
7758 TRACE("\n");
7759 pTypeLibImpl = TypeLibImpl_Constructor();
7760 if (!pTypeLibImpl) return E_FAIL;
7761
7762 pTypeLibImpl->TypeInfoCount = 2;
7763 pTypeLibImpl->typeinfos = heap_alloc_zero(pTypeLibImpl->TypeInfoCount * sizeof(ITypeInfoImpl*));
7764
7765 pTIIface = pTypeLibImpl->typeinfos[0] = ITypeInfoImpl_Constructor();
7766 pTIIface->pTypeLib = pTypeLibImpl;
7767 pTIIface->index = 0;
7768 pTIIface->Name = NULL;
7769 pTIIface->dwHelpContext = -1;
7770 memset(&pTIIface->TypeAttr.guid, 0, sizeof(GUID));
7771 pTIIface->TypeAttr.lcid = lcid;
7772 pTIIface->TypeAttr.typekind = TKIND_INTERFACE;
7773 pTIIface->TypeAttr.wMajorVerNum = 0;
7774 pTIIface->TypeAttr.wMinorVerNum = 0;
7775 pTIIface->TypeAttr.cbAlignment = 2;
7776 pTIIface->TypeAttr.cbSizeInstance = -1;
7777 pTIIface->TypeAttr.cbSizeVft = -1;
7778 pTIIface->TypeAttr.cFuncs = 0;
7779 pTIIface->TypeAttr.cImplTypes = 0;
7780 pTIIface->TypeAttr.cVars = 0;
7781 pTIIface->TypeAttr.wTypeFlags = 0;
7782
7783 pTIIface->funcdescs = TLBFuncDesc_Constructor(pidata->cMembers);
7784 pFuncDesc = pTIIface->funcdescs;
7785 for(func = 0; func < pidata->cMembers; func++) {
7786 METHODDATA *md = pidata->pmethdata + func;
7787 pFuncDesc->Name = SysAllocString(md->szName);
7788 pFuncDesc->funcdesc.memid = md->dispid;
7789 pFuncDesc->funcdesc.lprgscode = NULL;
7790 pFuncDesc->funcdesc.funckind = FUNC_VIRTUAL;
7791 pFuncDesc->funcdesc.invkind = md->wFlags;
7792 pFuncDesc->funcdesc.callconv = md->cc;
7793 pFuncDesc->funcdesc.cParams = md->cArgs;
7794 pFuncDesc->funcdesc.cParamsOpt = 0;
7795 pFuncDesc->funcdesc.oVft = md->iMeth * sizeof(void *);
7796 pFuncDesc->funcdesc.cScodes = 0;
7797 pFuncDesc->funcdesc.wFuncFlags = 0;
7798 pFuncDesc->funcdesc.elemdescFunc.tdesc.vt = md->vtReturn;
7799 pFuncDesc->funcdesc.elemdescFunc.u.paramdesc.wParamFlags = PARAMFLAG_NONE;
7800 pFuncDesc->funcdesc.elemdescFunc.u.paramdesc.pparamdescex = NULL;
7801 pFuncDesc->funcdesc.lprgelemdescParam = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
7802 md->cArgs * sizeof(ELEMDESC));
7803 pFuncDesc->pParamDesc = TLBParDesc_Constructor(md->cArgs);
7804 for(param = 0; param < md->cArgs; param++) {
7805 pFuncDesc->funcdesc.lprgelemdescParam[param].tdesc.vt = md->ppdata[param].vt;
7806 pFuncDesc->pParamDesc[param].Name = SysAllocString(md->ppdata[param].szName);
7807 }
7808 pFuncDesc->helpcontext = 0;
7809 pFuncDesc->HelpStringContext = 0;
7810 pFuncDesc->HelpString = NULL;
7811 pFuncDesc->Entry = NULL;
7812 list_init(&pFuncDesc->custdata_list);
7813 pTIIface->TypeAttr.cFuncs++;
7814 ++pFuncDesc;
7815 }
7816
7817 dump_TypeInfo(pTIIface);
7818
7819 pTIClass = pTypeLibImpl->typeinfos[1] = ITypeInfoImpl_Constructor();
7820 pTIClass->pTypeLib = pTypeLibImpl;
7821 pTIClass->index = 1;
7822 pTIClass->Name = NULL;
7823 pTIClass->dwHelpContext = -1;
7824 memset(&pTIClass->TypeAttr.guid, 0, sizeof(GUID));
7825 pTIClass->TypeAttr.lcid = lcid;
7826 pTIClass->TypeAttr.typekind = TKIND_COCLASS;
7827 pTIClass->TypeAttr.wMajorVerNum = 0;
7828 pTIClass->TypeAttr.wMinorVerNum = 0;
7829 pTIClass->TypeAttr.cbAlignment = 2;
7830 pTIClass->TypeAttr.cbSizeInstance = -1;
7831 pTIClass->TypeAttr.cbSizeVft = -1;
7832 pTIClass->TypeAttr.cFuncs = 0;
7833 pTIClass->TypeAttr.cImplTypes = 1;
7834 pTIClass->TypeAttr.cVars = 0;
7835 pTIClass->TypeAttr.wTypeFlags = 0;
7836
7837 pTIClass->impltypes = TLBImplType_Constructor(1);
7838
7839 ref = heap_alloc_zero(sizeof(*ref));
7840 ref->pImpTLInfo = TLB_REF_INTERNAL;
7841 list_add_head(&pTypeLibImpl->ref_list, &ref->entry);
7842
7843 dump_TypeInfo(pTIClass);
7844
7845 *pptinfo = (ITypeInfo*)pTIClass;
7846
7847 ITypeInfo_AddRef(*pptinfo);
7848 ITypeLib2_Release(&pTypeLibImpl->ITypeLib2_iface);
7849
7850 return S_OK;
7851
7852 }
7853
7854 static HRESULT WINAPI ITypeComp_fnQueryInterface(ITypeComp * iface, REFIID riid, LPVOID * ppv)
7855 {
7856 ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7857
7858 return ITypeInfo_QueryInterface((ITypeInfo *)This, riid, ppv);
7859 }
7860
7861 static ULONG WINAPI ITypeComp_fnAddRef(ITypeComp * iface)
7862 {
7863 ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7864
7865 return ITypeInfo_AddRef((ITypeInfo *)This);
7866 }
7867
7868 static ULONG WINAPI ITypeComp_fnRelease(ITypeComp * iface)
7869 {
7870 ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7871
7872 return ITypeInfo_Release((ITypeInfo *)This);
7873 }
7874
7875 static HRESULT WINAPI ITypeComp_fnBind(
7876 ITypeComp * iface,
7877 OLECHAR * szName,
7878 ULONG lHash,
7879 WORD wFlags,
7880 ITypeInfo ** ppTInfo,
7881 DESCKIND * pDescKind,
7882 BINDPTR * pBindPtr)
7883 {
7884 ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7885 const TLBFuncDesc *pFDesc;
7886 const TLBVarDesc *pVDesc;
7887 HRESULT hr = DISP_E_MEMBERNOTFOUND;
7888 UINT fdc;
7889
7890 TRACE("(%p)->(%s, %x, 0x%x, %p, %p, %p)\n", This, debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
7891
7892 *pDescKind = DESCKIND_NONE;
7893 pBindPtr->lpfuncdesc = NULL;
7894 *ppTInfo = NULL;
7895
7896 for(fdc = 0; fdc < This->TypeAttr.cFuncs; ++fdc){
7897 pFDesc = &This->funcdescs[fdc];
7898 if (!strcmpiW(pFDesc->Name, szName)) {
7899 if (!wFlags || (pFDesc->funcdesc.invkind & wFlags))
7900 break;
7901 else
7902 /* name found, but wrong flags */
7903 hr = TYPE_E_TYPEMISMATCH;
7904 }
7905 }
7906
7907 if (fdc < This->TypeAttr.cFuncs)
7908 {
7909 HRESULT hr = TLB_AllocAndInitFuncDesc(
7910 &pFDesc->funcdesc,
7911 &pBindPtr->lpfuncdesc,
7912 This->TypeAttr.typekind == TKIND_DISPATCH);
7913 if (FAILED(hr))
7914 return hr;
7915 *pDescKind = DESCKIND_FUNCDESC;
7916 *ppTInfo = (ITypeInfo *)&This->ITypeInfo2_iface;
7917 ITypeInfo_AddRef(*ppTInfo);
7918 return S_OK;
7919 } else {
7920 pVDesc = TLB_get_vardesc_by_name(This->vardescs, This->TypeAttr.cVars, szName);
7921 if(pVDesc){
7922 HRESULT hr = TLB_AllocAndInitVarDesc(&pVDesc->vardesc, &pBindPtr->lpvardesc);
7923 if (FAILED(hr))
7924 return hr;
7925 *pDescKind = DESCKIND_VARDESC;
7926 *ppTInfo = (ITypeInfo *)&This->ITypeInfo2_iface;
7927 ITypeInfo_AddRef(*ppTInfo);
7928 return S_OK;
7929 }
7930 }
7931 /* FIXME: search each inherited interface, not just the first */
7932 if (hr == DISP_E_MEMBERNOTFOUND && This->impltypes) {
7933 /* recursive search */
7934 ITypeInfo *pTInfo;
7935 ITypeComp *pTComp;
7936 HRESULT hr;
7937 hr=ITypeInfo2_GetRefTypeInfo(&This->ITypeInfo2_iface, This->impltypes[0].hRef, &pTInfo);
7938 if (SUCCEEDED(hr))
7939 {
7940 hr = ITypeInfo_GetTypeComp(pTInfo,&pTComp);
7941 ITypeInfo_Release(pTInfo);
7942 }
7943 if (SUCCEEDED(hr))
7944 {
7945 hr = ITypeComp_Bind(pTComp, szName, lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
7946 ITypeComp_Release(pTComp);
7947 return hr;
7948 }
7949 WARN("Could not search inherited interface!\n");
7950 }
7951 if (hr == DISP_E_MEMBERNOTFOUND)
7952 hr = S_OK;
7953 TRACE("did not find member with name %s, flags 0x%x\n", debugstr_w(szName), wFlags);
7954 return hr;
7955 }
7956
7957 static HRESULT WINAPI ITypeComp_fnBindType(
7958 ITypeComp * iface,
7959 OLECHAR * szName,
7960 ULONG lHash,
7961 ITypeInfo ** ppTInfo,
7962 ITypeComp ** ppTComp)
7963 {
7964 TRACE("(%s, %x, %p, %p)\n", debugstr_w(szName), lHash, ppTInfo, ppTComp);
7965
7966 /* strange behaviour (does nothing) but like the
7967 * original */
7968
7969 if (!ppTInfo || !ppTComp)
7970 return E_POINTER;
7971
7972 *ppTInfo = NULL;
7973 *ppTComp = NULL;
7974
7975 return S_OK;
7976 }
7977
7978 static const ITypeCompVtbl tcompvt =
7979 {
7980
7981 ITypeComp_fnQueryInterface,
7982 ITypeComp_fnAddRef,
7983 ITypeComp_fnRelease,
7984
7985 ITypeComp_fnBind,
7986 ITypeComp_fnBindType
7987 };
Wine tree for Wine Gecko development