?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
oleaut32: helpcontext is not an offset.
[wine.git] / dlls / oleaut32 / typelib.c
blobcb179f9bc74a7b8929d251507d48f10c66c36148
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 const ITypeLib2Vtbl *lpVtbl;
987 const ITypeCompVtbl *lpVtblTypeComp;
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 (ITypeLibImpl *)((char*)iface - FIELD_OFFSET(ITypeLibImpl, lpVtblTypeComp));
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 const ITypeInfo2Vtbl *lpVtbl;
1098 const ITypeCompVtbl *lpVtblTypeComp;
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 (ITypeInfoImpl *)((char*)iface - FIELD_OFFSET(ITypeInfoImpl, lpVtblTypeComp));
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 const IUnknownVtbl *lpvtbl;
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
2513 This = heap_alloc(sizeof(TLB_PEFile));
2514 if (!This)
2515 return E_OUTOFMEMORY;
2516
2517 This->lpvtbl = &TLB_PEFile_Vtable;
2518 This->refs = 1;
2519 This->dll = NULL;
2520 This->typelib_resource = NULL;
2521 This->typelib_global = NULL;
2522 This->typelib_base = NULL;
2523
2524 This->dll = LoadLibraryExW(path, 0, DONT_RESOLVE_DLL_REFERENCES |
2525 LOAD_LIBRARY_AS_DATAFILE | LOAD_WITH_ALTERED_SEARCH_PATH);
2526
2527 if (This->dll)
2528 {
2529 static const WCHAR TYPELIBW[] = {'T','Y','P','E','L','I','B',0};
2530 This->typelib_resource = FindResourceW(This->dll, MAKEINTRESOURCEW(index), TYPELIBW);
2531 if (This->typelib_resource)
2532 {
2533 This->typelib_global = LoadResource(This->dll, This->typelib_resource);
2534 if (This->typelib_global)
2535 {
2536 This->typelib_base = LockResource(This->typelib_global);
2537
2538 if (This->typelib_base)
2539 {
2540 *pdwTLBLength = SizeofResource(This->dll, This->typelib_resource);
2541 *ppBase = This->typelib_base;
2542 *ppFile = (IUnknown *)&This->lpvtbl;
2543 return S_OK;
2544 }
2545 }
2546 }
2547 }
2548
2549 TLB_PEFile_Release((IUnknown *)&This->lpvtbl);
2550 return TYPE_E_CANTLOADLIBRARY;
2551 }
2552
2553 typedef struct TLB_NEFile
2554 {
2555 const IUnknownVtbl *lpvtbl;
2556 LONG refs;
2557 LPVOID typelib_base;
2558 } TLB_NEFile;
2559
2560 static HRESULT WINAPI TLB_NEFile_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
2561 {
2562 if (IsEqualIID(riid, &IID_IUnknown))
2563 {
2564 *ppv = iface;
2565 IUnknown_AddRef(iface);
2566 return S_OK;
2567 }
2568 *ppv = NULL;
2569 return E_NOINTERFACE;
2570 }
2571
2572 static ULONG WINAPI TLB_NEFile_AddRef(IUnknown *iface)
2573 {
2574 TLB_NEFile *This = (TLB_NEFile *)iface;
2575 return InterlockedIncrement(&This->refs);
2576 }
2577
2578 static ULONG WINAPI TLB_NEFile_Release(IUnknown *iface)
2579 {
2580 TLB_NEFile *This = (TLB_NEFile *)iface;
2581 ULONG refs = InterlockedDecrement(&This->refs);
2582 if (!refs)
2583 {
2584 heap_free(This->typelib_base);
2585 heap_free(This);
2586 }
2587 return refs;
2588 }
2589
2590 static const IUnknownVtbl TLB_NEFile_Vtable =
2591 {
2592 TLB_NEFile_QueryInterface,
2593 TLB_NEFile_AddRef,
2594 TLB_NEFile_Release
2595 };
2596
2597 /***********************************************************************
2598 * read_xx_header [internal]
2599 */
2600 static int read_xx_header( HFILE lzfd )
2601 {
2602 IMAGE_DOS_HEADER mzh;
2603 char magic[3];
2604
2605 LZSeek( lzfd, 0, SEEK_SET );
2606 if ( sizeof(mzh) != LZRead( lzfd, (LPSTR)&mzh, sizeof(mzh) ) )
2607 return 0;
2608 if ( mzh.e_magic != IMAGE_DOS_SIGNATURE )
2609 return 0;
2610
2611 LZSeek( lzfd, mzh.e_lfanew, SEEK_SET );
2612 if ( 2 != LZRead( lzfd, magic, 2 ) )
2613 return 0;
2614
2615 LZSeek( lzfd, mzh.e_lfanew, SEEK_SET );
2616
2617 if ( magic[0] == 'N' && magic[1] == 'E' )
2618 return IMAGE_OS2_SIGNATURE;
2619 if ( magic[0] == 'P' && magic[1] == 'E' )
2620 return IMAGE_NT_SIGNATURE;
2621
2622 magic[2] = '\0';
2623 WARN("Can't handle %s files.\n", magic );
2624 return 0;
2625 }
2626
2627
2628 /***********************************************************************
2629 * find_ne_resource [internal]
2630 */
2631 static BOOL find_ne_resource( HFILE lzfd, LPCSTR typeid, LPCSTR resid,
2632 DWORD *resLen, DWORD *resOff )
2633 {
2634 IMAGE_OS2_HEADER nehd;
2635 NE_TYPEINFO *typeInfo;
2636 NE_NAMEINFO *nameInfo;
2637 DWORD nehdoffset;
2638 LPBYTE resTab;
2639 DWORD resTabSize;
2640 int count;
2641
2642 /* Read in NE header */
2643 nehdoffset = LZSeek( lzfd, 0, SEEK_CUR );
2644 if ( sizeof(nehd) != LZRead( lzfd, (LPSTR)&nehd, sizeof(nehd) ) ) return 0;
2645
2646 resTabSize = nehd.ne_restab - nehd.ne_rsrctab;
2647 if ( !resTabSize )
2648 {
2649 TRACE("No resources in NE dll\n" );
2650 return FALSE;
2651 }
2652
2653 /* Read in resource table */
2654 resTab = heap_alloc( resTabSize );
2655 if ( !resTab ) return FALSE;
2656
2657 LZSeek( lzfd, nehd.ne_rsrctab + nehdoffset, SEEK_SET );
2658 if ( resTabSize != LZRead( lzfd, (char*)resTab, resTabSize ) )
2659 {
2660 heap_free( resTab );
2661 return FALSE;
2662 }
2663
2664 /* Find resource */
2665 typeInfo = (NE_TYPEINFO *)(resTab + 2);
2666
2667 if (!IS_INTRESOURCE(typeid)) /* named type */
2668 {
2669 BYTE len = strlen( typeid );
2670 while (typeInfo->type_id)
2671 {
2672 if (!(typeInfo->type_id & 0x8000))
2673 {
2674 BYTE *p = resTab + typeInfo->type_id;
2675 if ((*p == len) && !strncasecmp( (char*)p+1, typeid, len )) goto found_type;
2676 }
2677 typeInfo = (NE_TYPEINFO *)((char *)(typeInfo + 1) +
2678 typeInfo->count * sizeof(NE_NAMEINFO));
2679 }
2680 }
2681 else /* numeric type id */
2682 {
2683 WORD id = LOWORD(typeid) | 0x8000;
2684 while (typeInfo->type_id)
2685 {
2686 if (typeInfo->type_id == id) goto found_type;
2687 typeInfo = (NE_TYPEINFO *)((char *)(typeInfo + 1) +
2688 typeInfo->count * sizeof(NE_NAMEINFO));
2689 }
2690 }
2691 TRACE("No typeid entry found for %p\n", typeid );
2692 heap_free( resTab );
2693 return FALSE;
2694
2695 found_type:
2696 nameInfo = (NE_NAMEINFO *)(typeInfo + 1);
2697
2698 if (!IS_INTRESOURCE(resid)) /* named resource */
2699 {
2700 BYTE len = strlen( resid );
2701 for (count = typeInfo->count; count > 0; count--, nameInfo++)
2702 {
2703 BYTE *p = resTab + nameInfo->id;
2704 if (nameInfo->id & 0x8000) continue;
2705 if ((*p == len) && !strncasecmp( (char*)p+1, resid, len )) goto found_name;
2706 }
2707 }
2708 else /* numeric resource id */
2709 {
2710 WORD id = LOWORD(resid) | 0x8000;
2711 for (count = typeInfo->count; count > 0; count--, nameInfo++)
2712 if (nameInfo->id == id) goto found_name;
2713 }
2714 TRACE("No resid entry found for %p\n", typeid );
2715 heap_free( resTab );
2716 return FALSE;
2717
2718 found_name:
2719 /* Return resource data */
2720 if ( resLen ) *resLen = nameInfo->length << *(WORD *)resTab;
2721 if ( resOff ) *resOff = nameInfo->offset << *(WORD *)resTab;
2722
2723 heap_free( resTab );
2724 return TRUE;
2725 }
2726
2727 static HRESULT TLB_NEFile_Open(LPCWSTR path, INT index, LPVOID *ppBase, DWORD *pdwTLBLength, IUnknown **ppFile){
2728
2729 HFILE lzfd = -1;
2730 OFSTRUCT ofs;
2731 HRESULT hr = TYPE_E_CANTLOADLIBRARY;
2732 TLB_NEFile *This;
2733
2734 This = heap_alloc(sizeof(TLB_NEFile));
2735 if (!This) return E_OUTOFMEMORY;
2736
2737 This->lpvtbl = &TLB_NEFile_Vtable;
2738 This->refs = 1;
2739 This->typelib_base = NULL;
2740
2741 lzfd = LZOpenFileW( (LPWSTR)path, &ofs, OF_READ );
2742 if ( lzfd >= 0 && read_xx_header( lzfd ) == IMAGE_OS2_SIGNATURE )
2743 {
2744 DWORD reslen, offset;
2745 if( find_ne_resource( lzfd, "TYPELIB", MAKEINTRESOURCEA(index), &reslen, &offset ) )
2746 {
2747 This->typelib_base = heap_alloc(reslen);
2748 if( !This->typelib_base )
2749 hr = E_OUTOFMEMORY;
2750 else
2751 {
2752 LZSeek( lzfd, offset, SEEK_SET );
2753 reslen = LZRead( lzfd, This->typelib_base, reslen );
2754 LZClose( lzfd );
2755 *ppBase = This->typelib_base;
2756 *pdwTLBLength = reslen;
2757 *ppFile = (IUnknown *)&This->lpvtbl;
2758 return S_OK;
2759 }
2760 }
2761 }
2762
2763 if( lzfd >= 0) LZClose( lzfd );
2764 TLB_NEFile_Release((IUnknown *)&This->lpvtbl);
2765 return hr;
2766 }
2767
2768 typedef struct TLB_Mapping
2769 {
2770 const IUnknownVtbl *lpvtbl;
2771 LONG refs;
2772 HANDLE file;
2773 HANDLE mapping;
2774 LPVOID typelib_base;
2775 } TLB_Mapping;
2776
2777 static HRESULT WINAPI TLB_Mapping_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
2778 {
2779 if (IsEqualIID(riid, &IID_IUnknown))
2780 {
2781 *ppv = iface;
2782 IUnknown_AddRef(iface);
2783 return S_OK;
2784 }
2785 *ppv = NULL;
2786 return E_NOINTERFACE;
2787 }
2788
2789 static ULONG WINAPI TLB_Mapping_AddRef(IUnknown *iface)
2790 {
2791 TLB_Mapping *This = (TLB_Mapping *)iface;
2792 return InterlockedIncrement(&This->refs);
2793 }
2794
2795 static ULONG WINAPI TLB_Mapping_Release(IUnknown *iface)
2796 {
2797 TLB_Mapping *This = (TLB_Mapping *)iface;
2798 ULONG refs = InterlockedDecrement(&This->refs);
2799 if (!refs)
2800 {
2801 if (This->typelib_base)
2802 UnmapViewOfFile(This->typelib_base);
2803 if (This->mapping)
2804 CloseHandle(This->mapping);
2805 if (This->file != INVALID_HANDLE_VALUE)
2806 CloseHandle(This->file);
2807 heap_free(This);
2808 }
2809 return refs;
2810 }
2811
2812 static const IUnknownVtbl TLB_Mapping_Vtable =
2813 {
2814 TLB_Mapping_QueryInterface,
2815 TLB_Mapping_AddRef,
2816 TLB_Mapping_Release
2817 };
2818
2819 static HRESULT TLB_Mapping_Open(LPCWSTR path, LPVOID *ppBase, DWORD *pdwTLBLength, IUnknown **ppFile)
2820 {
2821 TLB_Mapping *This;
2822
2823 This = heap_alloc(sizeof(TLB_Mapping));
2824 if (!This)
2825 return E_OUTOFMEMORY;
2826
2827 This->lpvtbl = &TLB_Mapping_Vtable;
2828 This->refs = 1;
2829 This->file = INVALID_HANDLE_VALUE;
2830 This->mapping = NULL;
2831 This->typelib_base = NULL;
2832
2833 This->file = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
2834 if (INVALID_HANDLE_VALUE != This->file)
2835 {
2836 This->mapping = CreateFileMappingW(This->file, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
2837 if (This->mapping)
2838 {
2839 This->typelib_base = MapViewOfFile(This->mapping, FILE_MAP_READ, 0, 0, 0);
2840 if(This->typelib_base)
2841 {
2842 /* retrieve file size */
2843 *pdwTLBLength = GetFileSize(This->file, NULL);
2844 *ppBase = This->typelib_base;
2845 *ppFile = (IUnknown *)&This->lpvtbl;
2846 return S_OK;
2847 }
2848 }
2849 }
2850
2851 IUnknown_Release((IUnknown *)&This->lpvtbl);
2852 return TYPE_E_CANTLOADLIBRARY;
2853 }
2854
2855 /****************************************************************************
2856 * TLB_ReadTypeLib
2857 *
2858 * find the type of the typelib file and map the typelib resource into
2859 * the memory
2860 */
2861
2862 #define SLTG_SIGNATURE 0x47544c53 /* "SLTG" */
2863 static HRESULT TLB_ReadTypeLib(LPCWSTR pszFileName, LPWSTR pszPath, UINT cchPath, ITypeLib2 **ppTypeLib)
2864 {
2865 ITypeLibImpl *entry;
2866 HRESULT ret;
2867 INT index = 1;
2868 LPWSTR index_str, file = (LPWSTR)pszFileName;
2869 LPVOID pBase = NULL;
2870 DWORD dwTLBLength = 0;
2871 IUnknown *pFile = NULL;
2872
2873 *ppTypeLib = NULL;
2874
2875 index_str = strrchrW(pszFileName, '\\');
2876 if(index_str && *++index_str != '\0')
2877 {
2878 LPWSTR end_ptr;
2879 LONG idx = strtolW(index_str, &end_ptr, 10);
2880 if(*end_ptr == '\0')
2881 {
2882 int str_len = index_str - pszFileName - 1;
2883 index = idx;
2884 file = heap_alloc((str_len + 1) * sizeof(WCHAR));
2885 memcpy(file, pszFileName, str_len * sizeof(WCHAR));
2886 file[str_len] = 0;
2887 }
2888 }
2889
2890 if(!SearchPathW(NULL, file, NULL, cchPath, pszPath, NULL))
2891 {
2892 if(strchrW(file, '\\'))
2893 {
2894 lstrcpyW(pszPath, file);
2895 }
2896 else
2897 {
2898 int len = GetSystemDirectoryW(pszPath, cchPath);
2899 pszPath[len] = '\\';
2900 memcpy(pszPath + len + 1, file, (strlenW(file) + 1) * sizeof(WCHAR));
2901 }
2902 }
2903
2904 if(file != pszFileName) heap_free(file);
2905
2906 TRACE_(typelib)("File %s index %d\n", debugstr_w(pszPath), index);
2907
2908 /* We look the path up in the typelib cache. If found, we just addref it, and return the pointer. */
2909 EnterCriticalSection(&cache_section);
2910 LIST_FOR_EACH_ENTRY(entry, &tlb_cache, ITypeLibImpl, entry)
2911 {
2912 if (!strcmpiW(entry->path, pszPath) && entry->index == index)
2913 {
2914 TRACE("cache hit\n");
2915 *ppTypeLib = (ITypeLib2*)entry;
2916 ITypeLib2_AddRef(*ppTypeLib);
2917 LeaveCriticalSection(&cache_section);
2918 return S_OK;
2919 }
2920 }
2921 LeaveCriticalSection(&cache_section);
2922
2923 /* now actually load and parse the typelib */
2924
2925 ret = TLB_PEFile_Open(pszPath, index, &pBase, &dwTLBLength, &pFile);
2926 if (ret == TYPE_E_CANTLOADLIBRARY)
2927 ret = TLB_NEFile_Open(pszPath, index, &pBase, &dwTLBLength, &pFile);
2928 if (ret == TYPE_E_CANTLOADLIBRARY)
2929 ret = TLB_Mapping_Open(pszPath, &pBase, &dwTLBLength, &pFile);
2930 if (SUCCEEDED(ret))
2931 {
2932 if (dwTLBLength >= 4)
2933 {
2934 DWORD dwSignature = FromLEDWord(*((DWORD*) pBase));
2935 if (dwSignature == MSFT_SIGNATURE)
2936 *ppTypeLib = ITypeLib2_Constructor_MSFT(pBase, dwTLBLength);
2937 else if (dwSignature == SLTG_SIGNATURE)
2938 *ppTypeLib = ITypeLib2_Constructor_SLTG(pBase, dwTLBLength);
2939 else
2940 {
2941 FIXME("Header type magic 0x%08x not supported.\n",dwSignature);
2942 ret = TYPE_E_CANTLOADLIBRARY;
2943 }
2944 }
2945 else
2946 ret = TYPE_E_CANTLOADLIBRARY;
2947 IUnknown_Release(pFile);
2948 }
2949
2950 if(*ppTypeLib) {
2951 ITypeLibImpl *impl = (ITypeLibImpl*)*ppTypeLib;
2952
2953 TRACE("adding to cache\n");
2954 impl->path = heap_alloc((strlenW(pszPath)+1) * sizeof(WCHAR));
2955 lstrcpyW(impl->path, pszPath);
2956 /* We should really canonicalise the path here. */
2957 impl->index = index;
2958
2959 /* FIXME: check if it has added already in the meantime */
2960 EnterCriticalSection(&cache_section);
2961 list_add_head(&tlb_cache, &impl->entry);
2962 LeaveCriticalSection(&cache_section);
2963 ret = S_OK;
2964 } else
2965 ERR("Loading of typelib %s failed with error %d\n", debugstr_w(pszFileName), GetLastError());
2966
2967 return ret;
2968 }
2969
2970 /*================== ITypeLib(2) Methods ===================================*/
2971
2972 static ITypeLibImpl* TypeLibImpl_Constructor(void)
2973 {
2974 ITypeLibImpl* pTypeLibImpl;
2975
2976 pTypeLibImpl = heap_alloc_zero(sizeof(ITypeLibImpl));
2977 if (!pTypeLibImpl) return NULL;
2978
2979 pTypeLibImpl->lpVtbl = &tlbvt;
2980 pTypeLibImpl->lpVtblTypeComp = &tlbtcvt;
2981 pTypeLibImpl->ref = 1;
2982
2983 list_init(&pTypeLibImpl->implib_list);
2984 list_init(&pTypeLibImpl->custdata_list);
2985 list_init(&pTypeLibImpl->ref_list);
2986 pTypeLibImpl->dispatch_href = -1;
2987
2988 return pTypeLibImpl;
2989 }
2990
2991 /****************************************************************************
2992 * ITypeLib2_Constructor_MSFT
2993 *
2994 * loading an MSFT typelib from an in-memory image
2995 */
2996 static ITypeLib2* ITypeLib2_Constructor_MSFT(LPVOID pLib, DWORD dwTLBLength)
2997 {
2998 TLBContext cx;
2999 LONG lPSegDir;
3000 MSFT_Header tlbHeader;
3001 MSFT_SegDir tlbSegDir;
3002 ITypeLibImpl * pTypeLibImpl;
3003
3004 TRACE("%p, TLB length = %d\n", pLib, dwTLBLength);
3005
3006 pTypeLibImpl = TypeLibImpl_Constructor();
3007 if (!pTypeLibImpl) return NULL;
3008
3009 /* get pointer to beginning of typelib data */
3010 cx.pos = 0;
3011 cx.oStart=0;
3012 cx.mapping = pLib;
3013 cx.pLibInfo = pTypeLibImpl;
3014 cx.length = dwTLBLength;
3015
3016 /* read header */
3017 MSFT_ReadLEDWords((void*)&tlbHeader, sizeof(tlbHeader), &cx, 0);
3018 TRACE_(typelib)("header:\n");
3019 TRACE_(typelib)("\tmagic1=0x%08x ,magic2=0x%08x\n",tlbHeader.magic1,tlbHeader.magic2 );
3020 if (tlbHeader.magic1 != MSFT_SIGNATURE) {
3021 FIXME("Header type magic 0x%08x not supported.\n",tlbHeader.magic1);
3022 return NULL;
3023 }
3024 TRACE_(typelib)("\tdispatchpos = 0x%x\n", tlbHeader.dispatchpos);
3025
3026 /* there is a small amount of information here until the next important
3027 * part:
3028 * the segment directory . Try to calculate the amount of data */
3029 lPSegDir = sizeof(tlbHeader) + (tlbHeader.nrtypeinfos)*4 + ((tlbHeader.varflags & HELPDLLFLAG)? 4 :0);
3030
3031 /* now read the segment directory */
3032 TRACE("read segment directory (at %d)\n",lPSegDir);
3033 MSFT_ReadLEDWords(&tlbSegDir, sizeof(tlbSegDir), &cx, lPSegDir);
3034 cx.pTblDir = &tlbSegDir;
3035
3036 /* just check two entries */
3037 if ( tlbSegDir.pTypeInfoTab.res0c != 0x0F || tlbSegDir.pImpInfo.res0c != 0x0F)
3038 {
3039 ERR("cannot find the table directory, ptr=0x%x\n",lPSegDir);
3040 heap_free(pTypeLibImpl);
3041 return NULL;
3042 }
3043
3044 /* now fill our internal data */
3045 /* TLIBATTR fields */
3046 MSFT_ReadGuid(&pTypeLibImpl->LibAttr.guid, tlbHeader.posguid, &cx);
3047
3048 pTypeLibImpl->LibAttr.lcid = tlbHeader.lcid2;
3049 pTypeLibImpl->LibAttr.syskind = tlbHeader.varflags & 0x0f; /* check the mask */
3050 pTypeLibImpl->LibAttr.wMajorVerNum = LOWORD(tlbHeader.version);
3051 pTypeLibImpl->LibAttr.wMinorVerNum = HIWORD(tlbHeader.version);
3052 pTypeLibImpl->LibAttr.wLibFlags = (WORD) tlbHeader.flags & 0xffff;/* check mask */
3053
3054 pTypeLibImpl->lcid = tlbHeader.lcid;
3055
3056 /* name, eventually add to a hash table */
3057 pTypeLibImpl->Name = MSFT_ReadName(&cx, tlbHeader.NameOffset);
3058
3059 /* help info */
3060 pTypeLibImpl->DocString = MSFT_ReadString(&cx, tlbHeader.helpstring);
3061 pTypeLibImpl->HelpFile = MSFT_ReadString(&cx, tlbHeader.helpfile);
3062
3063 if( tlbHeader.varflags & HELPDLLFLAG)
3064 {
3065 int offset;
3066 MSFT_ReadLEDWords(&offset, sizeof(offset), &cx, sizeof(tlbHeader));
3067 pTypeLibImpl->HelpStringDll = MSFT_ReadString(&cx, offset);
3068 }
3069
3070 pTypeLibImpl->dwHelpContext = tlbHeader.helpstringcontext;
3071
3072 /* custom data */
3073 if(tlbHeader.CustomDataOffset >= 0)
3074 {
3075 MSFT_CustData(&cx, tlbHeader.CustomDataOffset, &pTypeLibImpl->custdata_list);
3076 }
3077
3078 /* fill in type descriptions */
3079 if(tlbSegDir.pTypdescTab.length > 0)
3080 {
3081 int i, j, cTD = tlbSegDir.pTypdescTab.length / (2*sizeof(INT));
3082 INT16 td[4];
3083 pTypeLibImpl->ctTypeDesc = cTD;
3084 pTypeLibImpl->pTypeDesc = heap_alloc_zero( cTD * sizeof(TYPEDESC));
3085 MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pTypdescTab.offset);
3086 for(i=0; i<cTD; )
3087 {
3088 /* FIXME: add several sanity checks here */
3089 pTypeLibImpl->pTypeDesc[i].vt = td[0] & VT_TYPEMASK;
3090 if(td[0] == VT_PTR || td[0] == VT_SAFEARRAY)
3091 {
3092 /* FIXME: check safearray */
3093 if(td[3] < 0)
3094 pTypeLibImpl->pTypeDesc[i].u.lptdesc = &std_typedesc[td[2]];
3095 else
3096 pTypeLibImpl->pTypeDesc[i].u.lptdesc = &pTypeLibImpl->pTypeDesc[td[2]/8];
3097 }
3098 else if(td[0] == VT_CARRAY)
3099 {
3100 /* array descr table here */
3101 pTypeLibImpl->pTypeDesc[i].u.lpadesc = (void *)(INT_PTR)td[2]; /* temp store offset in*/
3102 }
3103 else if(td[0] == VT_USERDEFINED)
3104 {
3105 pTypeLibImpl->pTypeDesc[i].u.hreftype = MAKELONG(td[2],td[3]);
3106 }
3107 if(++i<cTD) MSFT_ReadLEWords(td, sizeof(td), &cx, DO_NOT_SEEK);
3108 }
3109
3110 /* second time around to fill the array subscript info */
3111 for(i=0;i<cTD;i++)
3112 {
3113 if(pTypeLibImpl->pTypeDesc[i].vt != VT_CARRAY) continue;
3114 if(tlbSegDir.pArrayDescriptions.offset>0)
3115 {
3116 MSFT_ReadLEWords(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (INT_PTR)pTypeLibImpl->pTypeDesc[i].u.lpadesc);
3117 pTypeLibImpl->pTypeDesc[i].u.lpadesc = heap_alloc_zero(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1));
3118
3119 if(td[1]<0)
3120 pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem.vt = td[0] & VT_TYPEMASK;
3121 else
3122 pTypeLibImpl->pTypeDesc[i].u.lpadesc->tdescElem = cx.pLibInfo->pTypeDesc[td[0]/(2*sizeof(INT))];
3123
3124 pTypeLibImpl->pTypeDesc[i].u.lpadesc->cDims = td[2];
3125
3126 for(j = 0; j<td[2]; j++)
3127 {
3128 MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].cElements,
3129 sizeof(INT), &cx, DO_NOT_SEEK);
3130 MSFT_ReadLEDWords(& pTypeLibImpl->pTypeDesc[i].u.lpadesc->rgbounds[j].lLbound,
3131 sizeof(INT), &cx, DO_NOT_SEEK);
3132 }
3133 }
3134 else
3135 {
3136 pTypeLibImpl->pTypeDesc[i].u.lpadesc = NULL;
3137 ERR("didn't find array description data\n");
3138 }
3139 }
3140 }
3141
3142 /* imported type libs */
3143 if(tlbSegDir.pImpFiles.offset>0)
3144 {
3145 TLBImpLib *pImpLib;
3146 int oGuid, offset = tlbSegDir.pImpFiles.offset;
3147 UINT16 size;
3148
3149 while(offset < tlbSegDir.pImpFiles.offset +tlbSegDir.pImpFiles.length)
3150 {
3151 char *name;
3152
3153 pImpLib = heap_alloc_zero(sizeof(TLBImpLib));
3154 pImpLib->offset = offset - tlbSegDir.pImpFiles.offset;
3155 MSFT_ReadLEDWords(&oGuid, sizeof(INT), &cx, offset);
3156
3157 MSFT_ReadLEDWords(&pImpLib->lcid, sizeof(LCID), &cx, DO_NOT_SEEK);
3158 MSFT_ReadLEWords(&pImpLib->wVersionMajor, sizeof(WORD), &cx, DO_NOT_SEEK);
3159 MSFT_ReadLEWords(&pImpLib->wVersionMinor, sizeof(WORD), &cx, DO_NOT_SEEK);
3160 MSFT_ReadLEWords(& size, sizeof(UINT16), &cx, DO_NOT_SEEK);
3161
3162 size >>= 2;
3163 name = heap_alloc_zero(size+1);
3164 MSFT_Read(name, size, &cx, DO_NOT_SEEK);
3165 pImpLib->name = TLB_MultiByteToBSTR(name);
3166 heap_free(name);
3167
3168 MSFT_ReadGuid(&pImpLib->guid, oGuid, &cx);
3169 offset = (offset + sizeof(INT) + sizeof(DWORD) + sizeof(LCID) + sizeof(UINT16) + size + 3) & ~3;
3170
3171 list_add_tail(&pTypeLibImpl->implib_list, &pImpLib->entry);
3172 }
3173 }
3174
3175 pTypeLibImpl->dispatch_href = tlbHeader.dispatchpos;
3176 if(pTypeLibImpl->dispatch_href != -1)
3177 MSFT_DoRefType(&cx, pTypeLibImpl, pTypeLibImpl->dispatch_href);
3178
3179 /* type infos */
3180 if(tlbHeader.nrtypeinfos >= 0 )
3181 {
3182 ITypeInfoImpl **ppTI;
3183 int i;
3184
3185 ppTI = pTypeLibImpl->typeinfos = heap_alloc_zero(sizeof(ITypeInfoImpl*) * tlbHeader.nrtypeinfos);
3186
3187 for(i = 0; i < tlbHeader.nrtypeinfos; i++)
3188 {
3189 *ppTI = MSFT_DoTypeInfo(&cx, i, pTypeLibImpl);
3190
3191 ++ppTI;
3192 (pTypeLibImpl->TypeInfoCount)++;
3193 }
3194 }
3195
3196 TRACE("(%p)\n", pTypeLibImpl);
3197 return (ITypeLib2*) pTypeLibImpl;
3198 }
3199
3200
3201 static BOOL TLB_GUIDFromString(const char *str, GUID *guid)
3202 {
3203 char b[3];
3204 int i;
3205 short s;
3206
3207 if(sscanf(str, "%x-%hx-%hx-%hx", &guid->Data1, &guid->Data2, &guid->Data3, &s) != 4) {
3208 FIXME("Can't parse guid %s\n", debugstr_guid(guid));
3209 return FALSE;
3210 }
3211
3212 guid->Data4[0] = s >> 8;
3213 guid->Data4[1] = s & 0xff;
3214
3215 b[2] = '\0';
3216 for(i = 0; i < 6; i++) {
3217 memcpy(b, str + 24 + 2 * i, 2);
3218 guid->Data4[i + 2] = strtol(b, NULL, 16);
3219 }
3220 return TRUE;
3221 }
3222
3223 static WORD SLTG_ReadString(const char *ptr, BSTR *pBstr)
3224 {
3225 WORD bytelen;
3226 DWORD len;
3227
3228 *pBstr = NULL;
3229 bytelen = *(const WORD*)ptr;
3230 if(bytelen == 0xffff) return 2;
3231 len = MultiByteToWideChar(CP_ACP, 0, ptr + 2, bytelen, NULL, 0);
3232 *pBstr = SysAllocStringLen(NULL, len);
3233 if (*pBstr)
3234 len = MultiByteToWideChar(CP_ACP, 0, ptr + 2, bytelen, *pBstr, len);
3235 return bytelen + 2;
3236 }
3237
3238 static WORD SLTG_ReadStringA(const char *ptr, char **str)
3239 {
3240 WORD bytelen;
3241
3242 *str = NULL;
3243 bytelen = *(const WORD*)ptr;
3244 if(bytelen == 0xffff) return 2;
3245 *str = heap_alloc(bytelen + 1);
3246 memcpy(*str, ptr + 2, bytelen);
3247 (*str)[bytelen] = '\0';
3248 return bytelen + 2;
3249 }
3250
3251 static DWORD SLTG_ReadLibBlk(LPVOID pLibBlk, ITypeLibImpl *pTypeLibImpl)
3252 {
3253 char *ptr = pLibBlk;
3254 WORD w;
3255
3256 if((w = *(WORD*)ptr) != SLTG_LIBBLK_MAGIC) {
3257 FIXME("libblk magic = %04x\n", w);
3258 return 0;
3259 }
3260
3261 ptr += 6;
3262 if((w = *(WORD*)ptr) != 0xffff) {
3263 FIXME("LibBlk.res06 = %04x. Assumung string and skipping\n", w);
3264 ptr += w;
3265 }
3266 ptr += 2;
3267
3268 ptr += SLTG_ReadString(ptr, &pTypeLibImpl->DocString);
3269
3270 ptr += SLTG_ReadString(ptr, &pTypeLibImpl->HelpFile);
3271
3272 pTypeLibImpl->dwHelpContext = *(DWORD*)ptr;
3273 ptr += 4;
3274
3275 pTypeLibImpl->LibAttr.syskind = *(WORD*)ptr;
3276 ptr += 2;
3277
3278 if(SUBLANGID(*(WORD*)ptr) == SUBLANG_NEUTRAL)
3279 pTypeLibImpl->lcid = pTypeLibImpl->LibAttr.lcid = MAKELCID(MAKELANGID(PRIMARYLANGID(*(WORD*)ptr),0),0);
3280 else
3281 pTypeLibImpl->lcid = pTypeLibImpl->LibAttr.lcid = 0;
3282 ptr += 2;
3283
3284 ptr += 4; /* skip res12 */
3285
3286 pTypeLibImpl->LibAttr.wLibFlags = *(WORD*)ptr;
3287 ptr += 2;
3288
3289 pTypeLibImpl->LibAttr.wMajorVerNum = *(WORD*)ptr;
3290 ptr += 2;
3291
3292 pTypeLibImpl->LibAttr.wMinorVerNum = *(WORD*)ptr;
3293 ptr += 2;
3294
3295 memcpy(&pTypeLibImpl->LibAttr.guid, ptr, sizeof(GUID));
3296 ptr += sizeof(GUID);
3297
3298 return ptr - (char*)pLibBlk;
3299 }
3300
3301 /* stores a mapping between the sltg typeinfo's references and the typelib's HREFTYPEs */
3302 typedef struct
3303 {
3304 unsigned int num;
3305 HREFTYPE refs[1];
3306 } sltg_ref_lookup_t;
3307
3308 static HRESULT sltg_get_typelib_ref(const sltg_ref_lookup_t *table, DWORD typeinfo_ref,
3309 HREFTYPE *typelib_ref)
3310 {
3311 if(table && typeinfo_ref < table->num)
3312 {
3313 *typelib_ref = table->refs[typeinfo_ref];
3314 return S_OK;
3315 }
3316
3317 ERR_(typelib)("Unable to find reference\n");
3318 *typelib_ref = -1;
3319 return E_FAIL;
3320 }
3321
3322 static WORD *SLTG_DoType(WORD *pType, char *pBlk, TYPEDESC *pTD, const sltg_ref_lookup_t *ref_lookup)
3323 {
3324 BOOL done = FALSE;
3325
3326 while(!done) {
3327 if((*pType & 0xe00) == 0xe00) {
3328 pTD->vt = VT_PTR;
3329 pTD->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
3330 pTD = pTD->u.lptdesc;
3331 }
3332 switch(*pType & 0x3f) {
3333 case VT_PTR:
3334 pTD->vt = VT_PTR;
3335 pTD->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
3336 pTD = pTD->u.lptdesc;
3337 break;
3338
3339 case VT_USERDEFINED:
3340 pTD->vt = VT_USERDEFINED;
3341 sltg_get_typelib_ref(ref_lookup, *(++pType) / 4, &pTD->u.hreftype);
3342 done = TRUE;
3343 break;
3344
3345 case VT_CARRAY:
3346 {
3347 /* *(pType+1) is offset to a SAFEARRAY, *(pType+2) is type of
3348 array */
3349
3350 SAFEARRAY *pSA = (SAFEARRAY *)(pBlk + *(++pType));
3351
3352 pTD->vt = VT_CARRAY;
3353 pTD->u.lpadesc = heap_alloc_zero(sizeof(ARRAYDESC) + (pSA->cDims - 1) * sizeof(SAFEARRAYBOUND));
3354 pTD->u.lpadesc->cDims = pSA->cDims;
3355 memcpy(pTD->u.lpadesc->rgbounds, pSA->rgsabound,
3356 pSA->cDims * sizeof(SAFEARRAYBOUND));
3357
3358 pTD = &pTD->u.lpadesc->tdescElem;
3359 break;
3360 }
3361
3362 case VT_SAFEARRAY:
3363 {
3364 /* FIXME: *(pType+1) gives an offset to SAFEARRAY, is this
3365 useful? */
3366
3367 pType++;
3368 pTD->vt = VT_SAFEARRAY;
3369 pTD->u.lptdesc = heap_alloc_zero(sizeof(TYPEDESC));
3370 pTD = pTD->u.lptdesc;
3371 break;
3372 }
3373 default:
3374 pTD->vt = *pType & 0x3f;
3375 done = TRUE;
3376 break;
3377 }
3378 pType++;
3379 }
3380 return pType;
3381 }
3382
3383 static WORD *SLTG_DoElem(WORD *pType, char *pBlk,
3384 ELEMDESC *pElem, const sltg_ref_lookup_t *ref_lookup)
3385 {
3386 /* Handle [in/out] first */
3387 if((*pType & 0xc000) == 0xc000)
3388 pElem->u.paramdesc.wParamFlags = PARAMFLAG_NONE;
3389 else if(*pType & 0x8000)
3390 pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN | PARAMFLAG_FOUT;
3391 else if(*pType & 0x4000)
3392 pElem->u.paramdesc.wParamFlags = PARAMFLAG_FOUT;
3393 else
3394 pElem->u.paramdesc.wParamFlags = PARAMFLAG_FIN;
3395
3396 if(*pType & 0x2000)
3397 pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FLCID;
3398
3399 if(*pType & 0x80)
3400 pElem->u.paramdesc.wParamFlags |= PARAMFLAG_FRETVAL;
3401
3402 return SLTG_DoType(pType, pBlk, &pElem->tdesc, ref_lookup);
3403 }
3404
3405
3406 static sltg_ref_lookup_t *SLTG_DoRefs(SLTG_RefInfo *pRef, ITypeLibImpl *pTL,
3407 char *pNameTable)
3408 {
3409 unsigned int ref;
3410 char *name;
3411 TLBRefType *ref_type;
3412 sltg_ref_lookup_t *table;
3413 HREFTYPE typelib_ref;
3414
3415 if(pRef->magic != SLTG_REF_MAGIC) {
3416 FIXME("Ref magic = %x\n", pRef->magic);
3417 return NULL;
3418 }
3419 name = ( (char*)pRef->names + pRef->number);
3420
3421 table = heap_alloc(sizeof(*table) + ((pRef->number >> 3) - 1) * sizeof(table->refs[0]));
3422 table->num = pRef->number >> 3;
3423
3424 /* FIXME should scan the existing list and reuse matching refs added by previous typeinfos */
3425
3426 /* We don't want the first href to be 0 */
3427 typelib_ref = (list_count(&pTL->ref_list) + 1) << 2;
3428
3429 for(ref = 0; ref < pRef->number >> 3; ref++) {
3430 char *refname;
3431 unsigned int lib_offs, type_num;
3432
3433 ref_type = heap_alloc_zero(sizeof(TLBRefType));
3434
3435 name += SLTG_ReadStringA(name, &refname);
3436 if(sscanf(refname, "*\\R%x*#%x", &lib_offs, &type_num) != 2)
3437 FIXME_(typelib)("Can't sscanf ref\n");
3438 if(lib_offs != 0xffff) {
3439 TLBImpLib *import;
3440
3441 LIST_FOR_EACH_ENTRY(import, &pTL->implib_list, TLBImpLib, entry)
3442 if(import->offset == lib_offs)
3443 break;
3444
3445 if(&import->entry == &pTL->implib_list) {
3446 char fname[MAX_PATH+1];
3447 int len;
3448
3449 import = heap_alloc_zero(sizeof(*import));
3450 import->offset = lib_offs;
3451 TLB_GUIDFromString( pNameTable + lib_offs + 4,
3452 &import->guid);
3453 if(sscanf(pNameTable + lib_offs + 40, "}#%hd.%hd#%x#%s",
3454 &import->wVersionMajor,
3455 &import->wVersionMinor,
3456 &import->lcid, fname) != 4) {
3457 FIXME_(typelib)("can't sscanf ref %s\n",
3458 pNameTable + lib_offs + 40);
3459 }
3460 len = strlen(fname);
3461 if(fname[len-1] != '#')
3462 FIXME("fname = %s\n", fname);
3463 fname[len-1] = '\0';
3464 import->name = TLB_MultiByteToBSTR(fname);
3465 list_add_tail(&pTL->implib_list, &import->entry);
3466 }
3467 ref_type->pImpTLInfo = import;
3468
3469 /* Store a reference to IDispatch */
3470 if(pTL->dispatch_href == -1 && IsEqualGUID(&import->guid, &IID_StdOle) && type_num == 4)
3471 pTL->dispatch_href = typelib_ref;
3472
3473 } else { /* internal ref */
3474 ref_type->pImpTLInfo = TLB_REF_INTERNAL;
3475 }
3476 ref_type->reference = typelib_ref;
3477 ref_type->index = type_num;
3478
3479 heap_free(refname);
3480 list_add_tail(&pTL->ref_list, &ref_type->entry);
3481
3482 table->refs[ref] = typelib_ref;
3483 typelib_ref += 4;
3484 }
3485 if((BYTE)*name != SLTG_REF_MAGIC)
3486 FIXME_(typelib)("End of ref block magic = %x\n", *name);
3487 dump_TLBRefType(pTL);
3488 return table;
3489 }
3490
3491 static char *SLTG_DoImpls(char *pBlk, ITypeInfoImpl *pTI,
3492 BOOL OneOnly, const sltg_ref_lookup_t *ref_lookup)
3493 {
3494 SLTG_ImplInfo *info;
3495 TLBImplType *pImplType;
3496 /* I don't really get this structure, usually it's 0x16 bytes
3497 long, but iuser.tlb contains some that are 0x18 bytes long.
3498 That's ok because we can use the next ptr to jump to the next
3499 one. But how do we know the length of the last one? The WORD
3500 at offs 0x8 might be the clue. For now I'm just assuming that
3501 the last one is the regular 0x16 bytes. */
3502
3503 info = (SLTG_ImplInfo*)pBlk;
3504 while(1){
3505 pTI->TypeAttr.cImplTypes++;
3506 if(info->next == 0xffff)
3507 break;
3508 info = (SLTG_ImplInfo*)(pBlk + info->next);
3509 }
3510
3511 info = (SLTG_ImplInfo*)pBlk;
3512 pTI->impltypes = TLBImplType_Constructor(pTI->TypeAttr.cImplTypes);
3513 pImplType = pTI->impltypes;
3514 while(1) {
3515 sltg_get_typelib_ref(ref_lookup, info->ref, &pImplType->hRef);
3516 pImplType->implflags = info->impltypeflags;
3517 ++pImplType;
3518
3519 if(info->next == 0xffff)
3520 break;
3521 if(OneOnly)
3522 FIXME_(typelib)("Interface inheriting more than one interface\n");
3523 info = (SLTG_ImplInfo*)(pBlk + info->next);
3524 }
3525 info++; /* see comment at top of function */
3526 return (char*)info;
3527 }
3528
3529 static void SLTG_DoVars(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI, unsigned short cVars,
3530 const char *pNameTable, const sltg_ref_lookup_t *ref_lookup)
3531 {
3532 TLBVarDesc *pVarDesc;
3533 BSTR bstrPrevName = NULL;
3534 SLTG_Variable *pItem;
3535 unsigned short i;
3536 WORD *pType;
3537
3538 pVarDesc = pTI->vardescs = TLBVarDesc_Constructor(cVars);
3539
3540 for(pItem = (SLTG_Variable *)pFirstItem, i = 0; i < cVars;
3541 pItem = (SLTG_Variable *)(pBlk + pItem->next), i++, ++pVarDesc) {
3542
3543 pVarDesc->vardesc.memid = pItem->memid;
3544
3545 if (pItem->magic != SLTG_VAR_MAGIC &&
3546 pItem->magic != SLTG_VAR_WITH_FLAGS_MAGIC) {
3547 FIXME_(typelib)("var magic = %02x\n", pItem->magic);
3548 return;
3549 }
3550
3551 if (pItem->name == 0xfffe)
3552 pVarDesc->Name = SysAllocString(bstrPrevName);
3553 else
3554 pVarDesc->Name = TLB_MultiByteToBSTR(pItem->name + pNameTable);
3555
3556 TRACE_(typelib)("name: %s\n", debugstr_w(pVarDesc->Name));
3557 TRACE_(typelib)("byte_offs = 0x%x\n", pItem->byte_offs);
3558 TRACE_(typelib)("memid = 0x%x\n", pItem->memid);
3559
3560 if(pItem->flags & 0x02)
3561 pType = &pItem->type;
3562 else
3563 pType = (WORD*)(pBlk + pItem->type);
3564
3565 if (pItem->flags & ~0xda)
3566 FIXME_(typelib)("unhandled flags = %02x\n", pItem->flags & ~0xda);
3567
3568 SLTG_DoElem(pType, pBlk,
3569 &pVarDesc->vardesc.elemdescVar, ref_lookup);
3570
3571 if (TRACE_ON(typelib)) {
3572 char buf[300];
3573 dump_TypeDesc(&pVarDesc->vardesc.elemdescVar.tdesc, buf);
3574 TRACE_(typelib)("elemdescVar: %s\n", buf);
3575 }
3576
3577 if (pItem->flags & 0x40) {
3578 TRACE_(typelib)("VAR_DISPATCH\n");
3579 pVarDesc->vardesc.varkind = VAR_DISPATCH;
3580 }
3581 else if (pItem->flags & 0x10) {
3582 TRACE_(typelib)("VAR_CONST\n");
3583 pVarDesc->vardesc.varkind = VAR_CONST;
3584 pVarDesc->vardesc.u.lpvarValue = heap_alloc(sizeof(VARIANT));
3585 V_VT(pVarDesc->vardesc.u.lpvarValue) = VT_INT;
3586 if (pItem->flags & 0x08)
3587 V_INT(pVarDesc->vardesc.u.lpvarValue) = pItem->byte_offs;
3588 else {
3589 switch (pVarDesc->vardesc.elemdescVar.tdesc.vt)
3590 {
3591 case VT_LPSTR:
3592 case VT_LPWSTR:
3593 case VT_BSTR:
3594 {
3595 WORD len = *(WORD *)(pBlk + pItem->byte_offs);
3596 BSTR str;
3597 TRACE_(typelib)("len = %u\n", len);
3598 if (len == 0xffff) {
3599 str = NULL;
3600 } else {
3601 INT alloc_len = MultiByteToWideChar(CP_ACP, 0, pBlk + pItem->byte_offs + 2, len, NULL, 0);
3602 str = SysAllocStringLen(NULL, alloc_len);
3603 MultiByteToWideChar(CP_ACP, 0, pBlk + pItem->byte_offs + 2, len, str, alloc_len);
3604 }
3605 V_VT(pVarDesc->vardesc.u.lpvarValue) = VT_BSTR;
3606 V_BSTR(pVarDesc->vardesc.u.lpvarValue) = str;
3607 break;
3608 }
3609 case VT_I2:
3610 case VT_UI2:
3611 case VT_I4:
3612 case VT_UI4:
3613 case VT_INT:
3614 case VT_UINT:
3615 V_INT(pVarDesc->vardesc.u.lpvarValue) =
3616 *(INT*)(pBlk + pItem->byte_offs);
3617 break;
3618 default:
3619 FIXME_(typelib)("VAR_CONST unimplemented for type %d\n", pVarDesc->vardesc.elemdescVar.tdesc.vt);
3620 }
3621 }
3622 }
3623 else {
3624 TRACE_(typelib)("VAR_PERINSTANCE\n");
3625 pVarDesc->vardesc.u.oInst = pItem->byte_offs;
3626 pVarDesc->vardesc.varkind = VAR_PERINSTANCE;
3627 }
3628
3629 if (pItem->magic == SLTG_VAR_WITH_FLAGS_MAGIC)
3630 pVarDesc->vardesc.wVarFlags = pItem->varflags;
3631
3632 if (pItem->flags & 0x80)
3633 pVarDesc->vardesc.wVarFlags |= VARFLAG_FREADONLY;
3634
3635 bstrPrevName = pVarDesc->Name;
3636 }
3637 pTI->TypeAttr.cVars = cVars;
3638 }
3639
3640 static void SLTG_DoFuncs(char *pBlk, char *pFirstItem, ITypeInfoImpl *pTI,
3641 unsigned short cFuncs, char *pNameTable, const sltg_ref_lookup_t *ref_lookup)
3642 {
3643 SLTG_Function *pFunc;
3644 unsigned short i;
3645 TLBFuncDesc *pFuncDesc;
3646
3647 pTI->funcdescs = TLBFuncDesc_Constructor(cFuncs);
3648
3649 pFuncDesc = pTI->funcdescs;
3650 for(pFunc = (SLTG_Function*)pFirstItem, i = 0; i < cFuncs && pFunc != (SLTG_Function*)0xFFFF;
3651 pFunc = (SLTG_Function*)(pBlk + pFunc->next), i++, ++pFuncDesc) {
3652
3653 int param;
3654 WORD *pType, *pArg;
3655
3656 switch (pFunc->magic & ~SLTG_FUNCTION_FLAGS_PRESENT) {
3657 case SLTG_FUNCTION_MAGIC:
3658 pFuncDesc->funcdesc.funckind = FUNC_PUREVIRTUAL;
3659 break;
3660 case SLTG_DISPATCH_FUNCTION_MAGIC:
3661 pFuncDesc->funcdesc.funckind = FUNC_DISPATCH;
3662 break;
3663 case SLTG_STATIC_FUNCTION_MAGIC:
3664 pFuncDesc->funcdesc.funckind = FUNC_STATIC;
3665 break;
3666 default:
3667 FIXME("unimplemented func magic = %02x\n", pFunc->magic & ~SLTG_FUNCTION_FLAGS_PRESENT);
3668 continue;
3669 }
3670 pFuncDesc->Name = TLB_MultiByteToBSTR(pFunc->name + pNameTable);
3671
3672 pFuncDesc->funcdesc.memid = pFunc->dispid;
3673 pFuncDesc->funcdesc.invkind = pFunc->inv >> 4;
3674 pFuncDesc->funcdesc.callconv = pFunc->nacc & 0x7;
3675 pFuncDesc->funcdesc.cParams = pFunc->nacc >> 3;
3676 pFuncDesc->funcdesc.cParamsOpt = (pFunc->retnextopt & 0x7e) >> 1;
3677 pFuncDesc->funcdesc.oVft = pFunc->vtblpos & ~1;
3678
3679 if(pFunc->magic & SLTG_FUNCTION_FLAGS_PRESENT)
3680 pFuncDesc->funcdesc.wFuncFlags = pFunc->funcflags;
3681
3682 if(pFunc->retnextopt & 0x80)
3683 pType = &pFunc->rettype;
3684 else
3685 pType = (WORD*)(pBlk + pFunc->rettype);
3686
3687 SLTG_DoElem(pType, pBlk, &pFuncDesc->funcdesc.elemdescFunc, ref_lookup);
3688
3689 pFuncDesc->funcdesc.lprgelemdescParam =
3690 heap_alloc_zero(pFuncDesc->funcdesc.cParams * sizeof(ELEMDESC));
3691 pFuncDesc->pParamDesc = TLBParDesc_Constructor(pFuncDesc->funcdesc.cParams);
3692
3693 pArg = (WORD*)(pBlk + pFunc->arg_off);
3694
3695 for(param = 0; param < pFuncDesc->funcdesc.cParams; param++) {
3696 char *paramName = pNameTable + *pArg;
3697 BOOL HaveOffs;
3698 /* If arg type follows then paramName points to the 2nd
3699 letter of the name, else the next WORD is an offset to
3700 the arg type and paramName points to the first letter.
3701 So let's take one char off paramName and see if we're
3702 pointing at an alpha-numeric char. However if *pArg is
3703 0xffff or 0xfffe then the param has no name, the former
3704 meaning that the next WORD is the type, the latter
3705 meaning that the next WORD is an offset to the type. */
3706
3707 HaveOffs = FALSE;
3708 if(*pArg == 0xffff)
3709 paramName = NULL;
3710 else if(*pArg == 0xfffe) {
3711 paramName = NULL;
3712 HaveOffs = TRUE;
3713 }
3714 else if(paramName[-1] && !isalnum(paramName[-1]))
3715 HaveOffs = TRUE;
3716
3717 pArg++;
3718
3719 if(HaveOffs) { /* the next word is an offset to type */
3720 pType = (WORD*)(pBlk + *pArg);
3721 SLTG_DoElem(pType, pBlk,
3722 &pFuncDesc->funcdesc.lprgelemdescParam[param], ref_lookup);
3723 pArg++;
3724 } else {
3725 if(paramName)
3726 paramName--;
3727 pArg = SLTG_DoElem(pArg, pBlk,
3728 &pFuncDesc->funcdesc.lprgelemdescParam[param], ref_lookup);
3729 }
3730
3731 /* Are we an optional param ? */
3732 if(pFuncDesc->funcdesc.cParams - param <=
3733 pFuncDesc->funcdesc.cParamsOpt)
3734 pFuncDesc->funcdesc.lprgelemdescParam[param].u.paramdesc.wParamFlags |= PARAMFLAG_FOPT;
3735
3736 if(paramName) {
3737 pFuncDesc->pParamDesc[param].Name =
3738 TLB_MultiByteToBSTR(paramName);
3739 } else {
3740 pFuncDesc->pParamDesc[param].Name =
3741 SysAllocString(pFuncDesc->Name);
3742 }
3743 }
3744 }
3745 pTI->TypeAttr.cFuncs = cFuncs;
3746 }
3747
3748 static void SLTG_ProcessCoClass(char *pBlk, ITypeInfoImpl *pTI,
3749 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3750 SLTG_TypeInfoTail *pTITail)
3751 {
3752 char *pFirstItem;
3753 sltg_ref_lookup_t *ref_lookup = NULL;
3754
3755 if(pTIHeader->href_table != 0xffffffff) {
3756 ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3757 pNameTable);
3758 }
3759
3760 pFirstItem = pBlk;
3761
3762 if(*(WORD*)pFirstItem == SLTG_IMPL_MAGIC) {
3763 SLTG_DoImpls(pFirstItem, pTI, FALSE, ref_lookup);
3764 }
3765 heap_free(ref_lookup);
3766 }
3767
3768
3769 static void SLTG_ProcessInterface(char *pBlk, ITypeInfoImpl *pTI,
3770 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3771 const SLTG_TypeInfoTail *pTITail)
3772 {
3773 char *pFirstItem;
3774 sltg_ref_lookup_t *ref_lookup = NULL;
3775
3776 if(pTIHeader->href_table != 0xffffffff) {
3777 ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3778 pNameTable);
3779 }
3780
3781 pFirstItem = pBlk;
3782
3783 if(*(WORD*)pFirstItem == SLTG_IMPL_MAGIC) {
3784 SLTG_DoImpls(pFirstItem, pTI, TRUE, ref_lookup);
3785 }
3786
3787 if (pTITail->funcs_off != 0xffff)
3788 SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
3789
3790 heap_free(ref_lookup);
3791
3792 if (TRACE_ON(typelib))
3793 dump_TLBFuncDesc(pTI->funcdescs, pTI->TypeAttr.cFuncs);
3794 }
3795
3796 static void SLTG_ProcessRecord(char *pBlk, ITypeInfoImpl *pTI,
3797 const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3798 const SLTG_TypeInfoTail *pTITail)
3799 {
3800 SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL);
3801 }
3802
3803 static void SLTG_ProcessAlias(char *pBlk, ITypeInfoImpl *pTI,
3804 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3805 const SLTG_TypeInfoTail *pTITail)
3806 {
3807 WORD *pType;
3808 sltg_ref_lookup_t *ref_lookup = NULL;
3809
3810 if (pTITail->simple_alias) {
3811 /* if simple alias, no more processing required */
3812 pTI->TypeAttr.tdescAlias.vt = pTITail->tdescalias_vt;
3813 return;
3814 }
3815
3816 if(pTIHeader->href_table != 0xffffffff) {
3817 ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3818 pNameTable);
3819 }
3820
3821 /* otherwise it is an offset to a type */
3822 pType = (WORD *)(pBlk + pTITail->tdescalias_vt);
3823
3824 SLTG_DoType(pType, pBlk, &pTI->TypeAttr.tdescAlias, ref_lookup);
3825
3826 heap_free(ref_lookup);
3827 }
3828
3829 static void SLTG_ProcessDispatch(char *pBlk, ITypeInfoImpl *pTI,
3830 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3831 const SLTG_TypeInfoTail *pTITail)
3832 {
3833 sltg_ref_lookup_t *ref_lookup = NULL;
3834 if (pTIHeader->href_table != 0xffffffff)
3835 ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3836 pNameTable);
3837
3838 if (pTITail->vars_off != 0xffff)
3839 SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup);
3840
3841 if (pTITail->funcs_off != 0xffff)
3842 SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
3843
3844 if (pTITail->impls_off != 0xffff)
3845 SLTG_DoImpls(pBlk + pTITail->impls_off, pTI, FALSE, ref_lookup);
3846
3847 /* this is necessary to cope with MSFT typelibs that set cFuncs to the number
3848 * of dispinterface functions including the IDispatch ones, so
3849 * ITypeInfo::GetFuncDesc takes the real value for cFuncs from cbSizeVft */
3850 pTI->TypeAttr.cbSizeVft = pTI->TypeAttr.cFuncs * sizeof(void *);
3851
3852 heap_free(ref_lookup);
3853 if (TRACE_ON(typelib))
3854 dump_TLBFuncDesc(pTI->funcdescs, pTI->TypeAttr.cFuncs);
3855 }
3856
3857 static void SLTG_ProcessEnum(char *pBlk, ITypeInfoImpl *pTI,
3858 const char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3859 const SLTG_TypeInfoTail *pTITail)
3860 {
3861 SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, NULL);
3862 }
3863
3864 static void SLTG_ProcessModule(char *pBlk, ITypeInfoImpl *pTI,
3865 char *pNameTable, SLTG_TypeInfoHeader *pTIHeader,
3866 const SLTG_TypeInfoTail *pTITail)
3867 {
3868 sltg_ref_lookup_t *ref_lookup = NULL;
3869 if (pTIHeader->href_table != 0xffffffff)
3870 ref_lookup = SLTG_DoRefs((SLTG_RefInfo*)((char *)pTIHeader + pTIHeader->href_table), pTI->pTypeLib,
3871 pNameTable);
3872
3873 if (pTITail->vars_off != 0xffff)
3874 SLTG_DoVars(pBlk, pBlk + pTITail->vars_off, pTI, pTITail->cVars, pNameTable, ref_lookup);
3875
3876 if (pTITail->funcs_off != 0xffff)
3877 SLTG_DoFuncs(pBlk, pBlk + pTITail->funcs_off, pTI, pTITail->cFuncs, pNameTable, ref_lookup);
3878 heap_free(ref_lookup);
3879 if (TRACE_ON(typelib))
3880 dump_TypeInfo(pTI);
3881 }
3882
3883 /* Because SLTG_OtherTypeInfo is such a painful struct, we make a more
3884 manageable copy of it into this */
3885 typedef struct {
3886 WORD small_no;
3887 char *index_name;
3888 char *other_name;
3889 WORD res1a;
3890 WORD name_offs;
3891 WORD more_bytes;
3892 char *extra;
3893 WORD res20;
3894 DWORD helpcontext;
3895 WORD res26;
3896 GUID uuid;
3897 } SLTG_InternalOtherTypeInfo;
3898
3899 /****************************************************************************
3900 * ITypeLib2_Constructor_SLTG
3901 *
3902 * loading a SLTG typelib from an in-memory image
3903 */
3904 static ITypeLib2* ITypeLib2_Constructor_SLTG(LPVOID pLib, DWORD dwTLBLength)
3905 {
3906 ITypeLibImpl *pTypeLibImpl;
3907 SLTG_Header *pHeader;
3908 SLTG_BlkEntry *pBlkEntry;
3909 SLTG_Magic *pMagic;
3910 SLTG_Index *pIndex;
3911 SLTG_Pad9 *pPad9;
3912 LPVOID pBlk, pFirstBlk;
3913 SLTG_LibBlk *pLibBlk;
3914 SLTG_InternalOtherTypeInfo *pOtherTypeInfoBlks;
3915 char *pAfterOTIBlks = NULL;
3916 char *pNameTable, *ptr;
3917 int i;
3918 DWORD len, order;
3919 ITypeInfoImpl **ppTypeInfoImpl;
3920
3921 TRACE_(typelib)("%p, TLB length = %d\n", pLib, dwTLBLength);
3922
3923
3924 pTypeLibImpl = TypeLibImpl_Constructor();
3925 if (!pTypeLibImpl) return NULL;
3926
3927 pHeader = pLib;
3928
3929 TRACE_(typelib)("header:\n");
3930 TRACE_(typelib)("\tmagic=0x%08x, file blocks = %d\n", pHeader->SLTG_magic,
3931 pHeader->nrOfFileBlks );
3932 if (pHeader->SLTG_magic != SLTG_SIGNATURE) {
3933 FIXME_(typelib)("Header type magic 0x%08x not supported.\n",
3934 pHeader->SLTG_magic);
3935 return NULL;
3936 }
3937
3938 /* There are pHeader->nrOfFileBlks - 2 TypeInfo records in this typelib */
3939 pTypeLibImpl->TypeInfoCount = pHeader->nrOfFileBlks - 2;
3940
3941 /* This points to pHeader->nrOfFileBlks - 1 of SLTG_BlkEntry */
3942 pBlkEntry = (SLTG_BlkEntry*)(pHeader + 1);
3943
3944 /* Next we have a magic block */
3945 pMagic = (SLTG_Magic*)(pBlkEntry + pHeader->nrOfFileBlks - 1);
3946
3947 /* Let's see if we're still in sync */
3948 if(memcmp(pMagic->CompObj_magic, SLTG_COMPOBJ_MAGIC,
3949 sizeof(SLTG_COMPOBJ_MAGIC))) {
3950 FIXME_(typelib)("CompObj magic = %s\n", pMagic->CompObj_magic);
3951 return NULL;
3952 }
3953 if(memcmp(pMagic->dir_magic, SLTG_DIR_MAGIC,
3954 sizeof(SLTG_DIR_MAGIC))) {
3955 FIXME_(typelib)("dir magic = %s\n", pMagic->dir_magic);
3956 return NULL;
3957 }
3958
3959 pIndex = (SLTG_Index*)(pMagic+1);
3960
3961 pPad9 = (SLTG_Pad9*)(pIndex + pTypeLibImpl->TypeInfoCount);
3962
3963 pFirstBlk = pPad9 + 1;
3964
3965 /* We'll set up a ptr to the main library block, which is the last one. */
3966
3967 for(pBlk = pFirstBlk, order = pHeader->first_blk - 1, i = 0;
3968 pBlkEntry[order].next != 0;
3969 order = pBlkEntry[order].next - 1, i++) {
3970 pBlk = (char*)pBlk + pBlkEntry[order].len;
3971 }
3972 pLibBlk = pBlk;
3973
3974 len = SLTG_ReadLibBlk(pLibBlk, pTypeLibImpl);
3975
3976 /* Now there's 0x40 bytes of 0xffff with the numbers 0 to TypeInfoCount
3977 interspersed */
3978
3979 len += 0x40;
3980
3981 /* And now TypeInfoCount of SLTG_OtherTypeInfo */
3982
3983 pOtherTypeInfoBlks = heap_alloc_zero(sizeof(*pOtherTypeInfoBlks) * pTypeLibImpl->TypeInfoCount);
3984
3985
3986 ptr = (char*)pLibBlk + len;
3987
3988 for(i = 0; i < pTypeLibImpl->TypeInfoCount; i++) {
3989 WORD w, extra;
3990 len = 0;
3991
3992 pOtherTypeInfoBlks[i].small_no = *(WORD*)ptr;
3993
3994 w = *(WORD*)(ptr + 2);
3995 if(w != 0xffff) {
3996 len += w;
3997 pOtherTypeInfoBlks[i].index_name = heap_alloc(w+1);
3998 memcpy(pOtherTypeInfoBlks[i].index_name, ptr + 4, w);
3999 pOtherTypeInfoBlks[i].index_name[w] = '\0';
4000 }
4001 w = *(WORD*)(ptr + 4 + len);
4002 if(w != 0xffff) {
4003 TRACE_(typelib)("\twith %s\n", debugstr_an(ptr + 6 + len, w));
4004 len += w;
4005 pOtherTypeInfoBlks[i].other_name = heap_alloc(w+1);
4006 memcpy(pOtherTypeInfoBlks[i].other_name, ptr + 6 + len, w);
4007 pOtherTypeInfoBlks[i].other_name[w] = '\0';
4008 }
4009 pOtherTypeInfoBlks[i].res1a = *(WORD*)(ptr + len + 6);
4010 pOtherTypeInfoBlks[i].name_offs = *(WORD*)(ptr + len + 8);
4011 extra = pOtherTypeInfoBlks[i].more_bytes = *(WORD*)(ptr + 10 + len);
4012 if(extra) {
4013 pOtherTypeInfoBlks[i].extra = heap_alloc(extra);
4014 memcpy(pOtherTypeInfoBlks[i].extra, ptr + 12, extra);
4015 len += extra;
4016 }
4017 pOtherTypeInfoBlks[i].res20 = *(WORD*)(ptr + 12 + len);
4018 pOtherTypeInfoBlks[i].helpcontext = *(DWORD*)(ptr + 14 + len);
4019 pOtherTypeInfoBlks[i].res26 = *(WORD*)(ptr + 18 + len);
4020 memcpy(&pOtherTypeInfoBlks[i].uuid, ptr + 20 + len, sizeof(GUID));
4021 len += sizeof(SLTG_OtherTypeInfo);
4022 ptr += len;
4023 }
4024
4025 pAfterOTIBlks = ptr;
4026
4027 /* Skip this WORD and get the next DWORD */
4028 len = *(DWORD*)(pAfterOTIBlks + 2);
4029
4030 /* Now add this to pLibBLk look at what we're pointing at and
4031 possibly add 0x20, then add 0x216, sprinkle a bit a magic
4032 dust and we should be pointing at the beginning of the name
4033 table */
4034
4035 pNameTable = (char*)pLibBlk + len;
4036
4037 switch(*(WORD*)pNameTable) {
4038 case 0xffff:
4039 break;
4040 case 0x0200:
4041 pNameTable += 0x20;
4042 break;
4043 default:
4044 FIXME_(typelib)("pNameTable jump = %x\n", *(WORD*)pNameTable);
4045 break;
4046 }
4047
4048 pNameTable += 0x216;
4049
4050 pNameTable += 2;
4051
4052 TRACE_(typelib)("Library name is %s\n", pNameTable + pLibBlk->name);
4053
4054 pTypeLibImpl->Name = TLB_MultiByteToBSTR(pNameTable + pLibBlk->name);
4055
4056
4057 /* Hopefully we now have enough ptrs set up to actually read in
4058 some TypeInfos. It's not clear which order to do them in, so
4059 I'll just follow the links along the BlkEntry chain and read
4060 them in the order in which they are in the file */
4061
4062 pTypeLibImpl->typeinfos = heap_alloc_zero(pTypeLibImpl->TypeInfoCount * sizeof(ITypeInfoImpl*));
4063 ppTypeInfoImpl = pTypeLibImpl->typeinfos;
4064
4065 for(pBlk = pFirstBlk, order = pHeader->first_blk - 1, i = 0;
4066 pBlkEntry[order].next != 0;
4067 order = pBlkEntry[order].next - 1, i++) {
4068
4069 SLTG_TypeInfoHeader *pTIHeader;
4070 SLTG_TypeInfoTail *pTITail;
4071 SLTG_MemberHeader *pMemHeader;
4072
4073 if(strcmp(pBlkEntry[order].index_string + (char*)pMagic, pOtherTypeInfoBlks[i].index_name)) {
4074 FIXME_(typelib)("Index strings don't match\n");
4075 heap_free(pOtherTypeInfoBlks);
4076 return NULL;
4077 }
4078
4079 pTIHeader = pBlk;
4080 if(pTIHeader->magic != SLTG_TIHEADER_MAGIC) {
4081 FIXME_(typelib)("TypeInfoHeader magic = %04x\n", pTIHeader->magic);
4082 return NULL;
4083 }
4084 TRACE_(typelib)("pTIHeader->res06 = %x, pTIHeader->res0e = %x, "
4085 "pTIHeader->res16 = %x, pTIHeader->res1e = %x\n",
4086 pTIHeader->res06, pTIHeader->res0e, pTIHeader->res16, pTIHeader->res1e);
4087
4088 *ppTypeInfoImpl = ITypeInfoImpl_Constructor();
4089 (*ppTypeInfoImpl)->pTypeLib = pTypeLibImpl;
4090 (*ppTypeInfoImpl)->index = i;
4091 (*ppTypeInfoImpl)->Name = TLB_MultiByteToBSTR(
4092 pOtherTypeInfoBlks[i].name_offs +
4093 pNameTable);
4094 (*ppTypeInfoImpl)->dwHelpContext = pOtherTypeInfoBlks[i].helpcontext;
4095 (*ppTypeInfoImpl)->TypeAttr.guid = pOtherTypeInfoBlks[i].uuid;
4096 (*ppTypeInfoImpl)->TypeAttr.typekind = pTIHeader->typekind;
4097 (*ppTypeInfoImpl)->TypeAttr.wMajorVerNum = pTIHeader->major_version;
4098 (*ppTypeInfoImpl)->TypeAttr.wMinorVerNum = pTIHeader->minor_version;
4099 (*ppTypeInfoImpl)->TypeAttr.wTypeFlags =
4100 (pTIHeader->typeflags1 >> 3) | (pTIHeader->typeflags2 << 5);
4101
4102 if((*ppTypeInfoImpl)->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL)
4103 (*ppTypeInfoImpl)->TypeAttr.typekind = TKIND_DISPATCH;
4104
4105 if((pTIHeader->typeflags1 & 7) != 2)
4106 FIXME_(typelib)("typeflags1 = %02x\n", pTIHeader->typeflags1);
4107 if(pTIHeader->typeflags3 != 2)
4108 FIXME_(typelib)("typeflags3 = %02x\n", pTIHeader->typeflags3);
4109
4110 TRACE_(typelib)("TypeInfo %s of kind %s guid %s typeflags %04x\n",
4111 debugstr_w((*ppTypeInfoImpl)->Name),
4112 typekind_desc[pTIHeader->typekind],
4113 debugstr_guid(&(*ppTypeInfoImpl)->TypeAttr.guid),
4114 (*ppTypeInfoImpl)->TypeAttr.wTypeFlags);
4115
4116 pMemHeader = (SLTG_MemberHeader*)((char *)pBlk + pTIHeader->elem_table);
4117
4118 pTITail = (SLTG_TypeInfoTail*)((char *)(pMemHeader + 1) + pMemHeader->cbExtra);
4119
4120 (*ppTypeInfoImpl)->TypeAttr.cbAlignment = pTITail->cbAlignment;
4121 (*ppTypeInfoImpl)->TypeAttr.cbSizeInstance = pTITail->cbSizeInstance;
4122 (*ppTypeInfoImpl)->TypeAttr.cbSizeVft = pTITail->cbSizeVft;
4123
4124 switch(pTIHeader->typekind) {
4125 case TKIND_ENUM:
4126 SLTG_ProcessEnum((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
4127 pTIHeader, pTITail);
4128 break;
4129
4130 case TKIND_RECORD:
4131 SLTG_ProcessRecord((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
4132 pTIHeader, pTITail);
4133 break;
4134
4135 case TKIND_INTERFACE:
4136 SLTG_ProcessInterface((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
4137 pTIHeader, pTITail);
4138 break;
4139
4140 case TKIND_COCLASS:
4141 SLTG_ProcessCoClass((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
4142 pTIHeader, pTITail);
4143 break;
4144
4145 case TKIND_ALIAS:
4146 SLTG_ProcessAlias((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
4147 pTIHeader, pTITail);
4148 break;
4149
4150 case TKIND_DISPATCH:
4151 SLTG_ProcessDispatch((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
4152 pTIHeader, pTITail);
4153 break;
4154
4155 case TKIND_MODULE:
4156 SLTG_ProcessModule((char *)(pMemHeader + 1), *ppTypeInfoImpl, pNameTable,
4157 pTIHeader, pTITail);
4158 break;
4159
4160 default:
4161 FIXME("Not processing typekind %d\n", pTIHeader->typekind);
4162 break;
4163
4164 }
4165
4166 /* could get cFuncs, cVars and cImplTypes from here
4167 but we've already set those */
4168 #define X(x) TRACE_(typelib)("tt "#x": %x\n",pTITail->res##x);
4169 X(06);
4170 X(16);
4171 X(18);
4172 X(1a);
4173 X(1e);
4174 X(24);
4175 X(26);
4176 X(2a);
4177 X(2c);
4178 X(2e);
4179 X(30);
4180 X(32);
4181 X(34);
4182 #undef X
4183 ++ppTypeInfoImpl;
4184 pBlk = (char*)pBlk + pBlkEntry[order].len;
4185 }
4186
4187 if(i != pTypeLibImpl->TypeInfoCount) {
4188 FIXME("Somehow processed %d TypeInfos\n", i);
4189 heap_free(pOtherTypeInfoBlks);
4190 return NULL;
4191 }
4192
4193 heap_free(pOtherTypeInfoBlks);
4194 return (ITypeLib2*)pTypeLibImpl;
4195 }
4196
4197 /* ITypeLib::QueryInterface
4198 */
4199 static HRESULT WINAPI ITypeLib2_fnQueryInterface(
4200 ITypeLib2 * iface,
4201 REFIID riid,
4202 VOID **ppvObject)
4203 {
4204 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4205
4206 TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
4207
4208 *ppvObject=NULL;
4209 if(IsEqualIID(riid, &IID_IUnknown) ||
4210 IsEqualIID(riid,&IID_ITypeLib)||
4211 IsEqualIID(riid,&IID_ITypeLib2))
4212 {
4213 *ppvObject = This;
4214 }
4215
4216 if(*ppvObject)
4217 {
4218 ITypeLib2_AddRef(iface);
4219 TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
4220 return S_OK;
4221 }
4222 TRACE("-- Interface: E_NOINTERFACE\n");
4223 return E_NOINTERFACE;
4224 }
4225
4226 /* ITypeLib::AddRef
4227 */
4228 static ULONG WINAPI ITypeLib2_fnAddRef( ITypeLib2 *iface)
4229 {
4230 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4231 ULONG ref = InterlockedIncrement(&This->ref);
4232
4233 TRACE("(%p)->ref was %u\n",This, ref - 1);
4234
4235 return ref;
4236 }
4237
4238 /* ITypeLib::Release
4239 */
4240 static ULONG WINAPI ITypeLib2_fnRelease( ITypeLib2 *iface)
4241 {
4242 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4243 ULONG ref = InterlockedDecrement(&This->ref);
4244
4245 TRACE("(%p)->(%u)\n",This, ref);
4246
4247 if (!ref)
4248 {
4249 TLBImpLib *pImpLib, *pImpLibNext;
4250 TLBRefType *ref_type;
4251 void *cursor2;
4252 int i;
4253
4254 /* remove cache entry */
4255 if(This->path)
4256 {
4257 TRACE("removing from cache list\n");
4258 EnterCriticalSection(&cache_section);
4259 if(This->entry.next)
4260 list_remove(&This->entry);
4261 LeaveCriticalSection(&cache_section);
4262 heap_free(This->path);
4263 }
4264 TRACE(" destroying ITypeLib(%p)\n",This);
4265
4266 SysFreeString(This->Name);
4267 This->Name = NULL;
4268
4269 SysFreeString(This->DocString);
4270 This->DocString = NULL;
4271
4272 SysFreeString(This->HelpFile);
4273 This->HelpFile = NULL;
4274
4275 SysFreeString(This->HelpStringDll);
4276 This->HelpStringDll = NULL;
4277
4278 TLB_FreeCustData(&This->custdata_list);
4279
4280 for (i = 0; i < This->ctTypeDesc; i++)
4281 if (This->pTypeDesc[i].vt == VT_CARRAY)
4282 heap_free(This->pTypeDesc[i].u.lpadesc);
4283
4284 heap_free(This->pTypeDesc);
4285
4286 LIST_FOR_EACH_ENTRY_SAFE(pImpLib, pImpLibNext, &This->implib_list, TLBImpLib, entry)
4287 {
4288 if (pImpLib->pImpTypeLib)
4289 ITypeLib_Release((ITypeLib *)pImpLib->pImpTypeLib);
4290 SysFreeString(pImpLib->name);
4291
4292 list_remove(&pImpLib->entry);
4293 heap_free(pImpLib);
4294 }
4295
4296 LIST_FOR_EACH_ENTRY_SAFE(ref_type, cursor2, &This->ref_list, TLBRefType, entry)
4297 {
4298 list_remove(&ref_type->entry);
4299 heap_free(ref_type);
4300 }
4301
4302 for (i = 0; i < This->TypeInfoCount; ++i)
4303 ITypeInfoImpl_Destroy(This->typeinfos[i]);
4304 heap_free(This->typeinfos);
4305 heap_free(This);
4306 return 0;
4307 }
4308
4309 return ref;
4310 }
4311
4312 /* ITypeLib::GetTypeInfoCount
4313 *
4314 * Returns the number of type descriptions in the type library
4315 */
4316 static UINT WINAPI ITypeLib2_fnGetTypeInfoCount( ITypeLib2 *iface)
4317 {
4318 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4319 TRACE("(%p)->count is %d\n",This, This->TypeInfoCount);
4320 return This->TypeInfoCount;
4321 }
4322
4323 /* ITypeLib::GetTypeInfo
4324 *
4325 * retrieves the specified type description in the library.
4326 */
4327 static HRESULT WINAPI ITypeLib2_fnGetTypeInfo(
4328 ITypeLib2 *iface,
4329 UINT index,
4330 ITypeInfo **ppTInfo)
4331 {
4332 ITypeLibImpl *This = (ITypeLibImpl*)iface;
4333
4334 TRACE("%p %u %p\n", This, index, ppTInfo);
4335
4336 if(!ppTInfo)
4337 return E_INVALIDARG;
4338
4339 if(index >= This->TypeInfoCount)
4340 return TYPE_E_ELEMENTNOTFOUND;
4341
4342 *ppTInfo = (ITypeInfo*)This->typeinfos[index];
4343 ITypeInfo_AddRef(*ppTInfo);
4344
4345 return S_OK;
4346 }
4347
4348
4349 /* ITypeLibs::GetTypeInfoType
4350 *
4351 * Retrieves the type of a type description.
4352 */
4353 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoType(
4354 ITypeLib2 *iface,
4355 UINT index,
4356 TYPEKIND *pTKind)
4357 {
4358 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4359
4360 TRACE("(%p, %d, %p)\n", This, index, pTKind);
4361
4362 if(!pTKind)
4363 return E_INVALIDARG;
4364
4365 if(index >= This->TypeInfoCount)
4366 return TYPE_E_ELEMENTNOTFOUND;
4367
4368 *pTKind = This->typeinfos[index]->TypeAttr.typekind;
4369
4370 return S_OK;
4371 }
4372
4373 /* ITypeLib::GetTypeInfoOfGuid
4374 *
4375 * Retrieves the type description that corresponds to the specified GUID.
4376 *
4377 */
4378 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoOfGuid(
4379 ITypeLib2 *iface,
4380 REFGUID guid,
4381 ITypeInfo **ppTInfo)
4382 {
4383 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4384 UINT i;
4385
4386 TRACE("%p %s %p\n", This, debugstr_guid(guid), ppTInfo);
4387
4388 for(i = 0; i < This->TypeInfoCount; ++i){
4389 if(IsEqualIID(&This->typeinfos[i]->TypeAttr.guid, guid)){
4390 *ppTInfo = (ITypeInfo*)This->typeinfos[i];
4391 ITypeInfo_AddRef(*ppTInfo);
4392 return S_OK;
4393 }
4394 }
4395
4396 return TYPE_E_ELEMENTNOTFOUND;
4397 }
4398
4399 /* ITypeLib::GetLibAttr
4400 *
4401 * Retrieves the structure that contains the library's attributes.
4402 *
4403 */
4404 static HRESULT WINAPI ITypeLib2_fnGetLibAttr(
4405 ITypeLib2 *iface,
4406 LPTLIBATTR *attr)
4407 {
4408 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4409
4410 TRACE("(%p, %p)\n", This, attr);
4411
4412 if (!attr) return E_INVALIDARG;
4413
4414 *attr = heap_alloc(sizeof(**attr));
4415 if (!*attr) return E_OUTOFMEMORY;
4416
4417 **attr = This->LibAttr;
4418 return S_OK;
4419 }
4420
4421 /* ITypeLib::GetTypeComp
4422 *
4423 * Enables a client compiler to bind to a library's types, variables,
4424 * constants, and global functions.
4425 *
4426 */
4427 static HRESULT WINAPI ITypeLib2_fnGetTypeComp(
4428 ITypeLib2 *iface,
4429 ITypeComp **ppTComp)
4430 {
4431 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4432
4433 TRACE("(%p)->(%p)\n",This,ppTComp);
4434 *ppTComp = (ITypeComp *)&This->lpVtblTypeComp;
4435 ITypeComp_AddRef(*ppTComp);
4436
4437 return S_OK;
4438 }
4439
4440 /* ITypeLib::GetDocumentation
4441 *
4442 * Retrieves the library's documentation string, the complete Help file name
4443 * and path, and the context identifier for the library Help topic in the Help
4444 * file.
4445 *
4446 * On a successful return all non-null BSTR pointers will have been set,
4447 * possibly to NULL.
4448 */
4449 static HRESULT WINAPI ITypeLib2_fnGetDocumentation(
4450 ITypeLib2 *iface,
4451 INT index,
4452 BSTR *pBstrName,
4453 BSTR *pBstrDocString,
4454 DWORD *pdwHelpContext,
4455 BSTR *pBstrHelpFile)
4456 {
4457 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4458
4459 HRESULT result = E_INVALIDARG;
4460
4461 ITypeInfo *pTInfo;
4462
4463
4464 TRACE("(%p) index %d Name(%p) DocString(%p) HelpContext(%p) HelpFile(%p)\n",
4465 This, index,
4466 pBstrName, pBstrDocString,
4467 pdwHelpContext, pBstrHelpFile);
4468
4469 if(index<0)
4470 {
4471 /* documentation for the typelib */
4472 if(pBstrName)
4473 {
4474 if (This->Name)
4475 {
4476 if(!(*pBstrName = SysAllocString(This->Name)))
4477 goto memerr1;
4478 }
4479 else
4480 *pBstrName = NULL;
4481 }
4482 if(pBstrDocString)
4483 {
4484 if (This->DocString)
4485 {
4486 if(!(*pBstrDocString = SysAllocString(This->DocString)))
4487 goto memerr2;
4488 }
4489 else if (This->Name)
4490 {
4491 if(!(*pBstrDocString = SysAllocString(This->Name)))
4492 goto memerr2;
4493 }
4494 else
4495 *pBstrDocString = NULL;
4496 }
4497 if(pdwHelpContext)
4498 {
4499 *pdwHelpContext = This->dwHelpContext;
4500 }
4501 if(pBstrHelpFile)
4502 {
4503 if (This->HelpFile)
4504 {
4505 if(!(*pBstrHelpFile = SysAllocString(This->HelpFile)))
4506 goto memerr3;
4507 }
4508 else
4509 *pBstrHelpFile = NULL;
4510 }
4511
4512 result = S_OK;
4513 }
4514 else
4515 {
4516 /* for a typeinfo */
4517 result = ITypeLib2_fnGetTypeInfo(iface, index, &pTInfo);
4518
4519 if(SUCCEEDED(result))
4520 {
4521 result = ITypeInfo_GetDocumentation(pTInfo,
4522 MEMBERID_NIL,
4523 pBstrName,
4524 pBstrDocString,
4525 pdwHelpContext, pBstrHelpFile);
4526
4527 ITypeInfo_Release(pTInfo);
4528 }
4529 }
4530 return result;
4531 memerr3:
4532 if (pBstrDocString) SysFreeString (*pBstrDocString);
4533 memerr2:
4534 if (pBstrName) SysFreeString (*pBstrName);
4535 memerr1:
4536 return STG_E_INSUFFICIENTMEMORY;
4537 }
4538
4539 /* ITypeLib::IsName
4540 *
4541 * Indicates whether a passed-in string contains the name of a type or member
4542 * described in the library.
4543 *
4544 */
4545 static HRESULT WINAPI ITypeLib2_fnIsName(
4546 ITypeLib2 *iface,
4547 LPOLESTR szNameBuf,
4548 ULONG lHashVal,
4549 BOOL *pfName)
4550 {
4551 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4552 UINT nNameBufLen = (lstrlenW(szNameBuf)+1)*sizeof(WCHAR), tic, fdc, vrc, pc;
4553
4554 TRACE("(%p)->(%s,%08x,%p)\n", This, debugstr_w(szNameBuf), lHashVal,
4555 pfName);
4556
4557 *pfName=TRUE;
4558 for(tic = 0; tic < This->TypeInfoCount; ++tic){
4559 ITypeInfoImpl *pTInfo = This->typeinfos[tic];
4560 if(!memcmp(szNameBuf,pTInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
4561 for(fdc = 0; fdc < pTInfo->TypeAttr.cFuncs; ++fdc) {
4562 TLBFuncDesc *pFInfo = &pTInfo->funcdescs[fdc];
4563 if(!memcmp(szNameBuf,pFInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
4564 for(pc=0; pc < pFInfo->funcdesc.cParams; pc++)
4565 if(!memcmp(szNameBuf,pFInfo->pParamDesc[pc].Name, nNameBufLen))
4566 goto ITypeLib2_fnIsName_exit;
4567 }
4568 for(vrc = 0; vrc < pTInfo->TypeAttr.cVars; ++vrc){
4569 TLBVarDesc *pVInfo = &pTInfo->vardescs[vrc];
4570 if(!memcmp(szNameBuf,pVInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
4571 }
4572
4573 }
4574 *pfName=FALSE;
4575
4576 ITypeLib2_fnIsName_exit:
4577 TRACE("(%p)slow! search for %s: %s found!\n", This,
4578 debugstr_w(szNameBuf), *pfName?"NOT":"");
4579
4580 return S_OK;
4581 }
4582
4583 /* ITypeLib::FindName
4584 *
4585 * Finds occurrences of a type description in a type library. This may be used
4586 * to quickly verify that a name exists in a type library.
4587 *
4588 */
4589 static HRESULT WINAPI ITypeLib2_fnFindName(
4590 ITypeLib2 *iface,
4591 LPOLESTR name,
4592 ULONG hash,
4593 ITypeInfo **ppTInfo,
4594 MEMBERID *memid,
4595 UINT16 *found)
4596 {
4597 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4598 UINT tic, count = 0;
4599 UINT len;
4600
4601 TRACE("(%p)->(%s %u %p %p %p)\n", This, debugstr_w(name), hash, ppTInfo, memid, found);
4602
4603 if ((!name && hash == 0) || !ppTInfo || !memid || !found)
4604 return E_INVALIDARG;
4605
4606 len = (lstrlenW(name) + 1)*sizeof(WCHAR);
4607 for(tic = 0; tic < This->TypeInfoCount; ++tic) {
4608 ITypeInfoImpl *pTInfo = This->typeinfos[tic];
4609 TLBVarDesc *var;
4610 UINT fdc;
4611
4612 if(!memcmp(name, pTInfo->Name, len)) goto ITypeLib2_fnFindName_exit;
4613 for(fdc = 0; fdc < pTInfo->TypeAttr.cFuncs; ++fdc) {
4614 TLBFuncDesc *func = &pTInfo->funcdescs[fdc];
4615 UINT pc;
4616
4617 if(!memcmp(name, func->Name, len)) goto ITypeLib2_fnFindName_exit;
4618 for(pc = 0; pc < func->funcdesc.cParams; pc++) {
4619 if(!memcmp(name, func->pParamDesc[pc].Name, len))
4620 goto ITypeLib2_fnFindName_exit;
4621 }
4622 }
4623
4624 var = TLB_get_vardesc_by_name(pTInfo->vardescs, pTInfo->TypeAttr.cVars, name);
4625 if (var)
4626 goto ITypeLib2_fnFindName_exit;
4627
4628 continue;
4629 ITypeLib2_fnFindName_exit:
4630 ITypeInfo_AddRef((ITypeInfo*)pTInfo);
4631 ppTInfo[count]=(LPTYPEINFO)pTInfo;
4632 count++;
4633 }
4634 TRACE("found %d typeinfos\n", count);
4635
4636 *found = count;
4637
4638 return S_OK;
4639 }
4640
4641 /* ITypeLib::ReleaseTLibAttr
4642 *
4643 * Releases the TLIBATTR originally obtained from ITypeLib::GetLibAttr.
4644 *
4645 */
4646 static VOID WINAPI ITypeLib2_fnReleaseTLibAttr(
4647 ITypeLib2 *iface,
4648 TLIBATTR *pTLibAttr)
4649 {
4650 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4651 TRACE("freeing (%p)\n",This);
4652 heap_free(pTLibAttr);
4653
4654 }
4655
4656 /* ITypeLib2::GetCustData
4657 *
4658 * gets the custom data
4659 */
4660 static HRESULT WINAPI ITypeLib2_fnGetCustData(
4661 ITypeLib2 * iface,
4662 REFGUID guid,
4663 VARIANT *pVarVal)
4664 {
4665 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4666 TLBCustData *pCData;
4667
4668 TRACE("%p %s %p\n", This, debugstr_guid(guid), pVarVal);
4669
4670 pCData = TLB_get_custdata_by_guid(&This->custdata_list, guid);
4671 if(!pCData)
4672 return TYPE_E_ELEMENTNOTFOUND;
4673
4674 VariantInit(pVarVal);
4675 VariantCopy(pVarVal, &pCData->data);
4676
4677 return S_OK;
4678 }
4679
4680 /* ITypeLib2::GetLibStatistics
4681 *
4682 * Returns statistics about a type library that are required for efficient
4683 * sizing of hash tables.
4684 *
4685 */
4686 static HRESULT WINAPI ITypeLib2_fnGetLibStatistics(
4687 ITypeLib2 * iface,
4688 ULONG *pcUniqueNames,
4689 ULONG *pcchUniqueNames)
4690 {
4691 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4692
4693 FIXME("(%p): stub!\n", This);
4694
4695 if(pcUniqueNames) *pcUniqueNames=1;
4696 if(pcchUniqueNames) *pcchUniqueNames=1;
4697 return S_OK;
4698 }
4699
4700 /* ITypeLib2::GetDocumentation2
4701 *
4702 * Retrieves the library's documentation string, the complete Help file name
4703 * and path, the localization context to use, and the context ID for the
4704 * library Help topic in the Help file.
4705 *
4706 */
4707 static HRESULT WINAPI ITypeLib2_fnGetDocumentation2(
4708 ITypeLib2 * iface,
4709 INT index,
4710 LCID lcid,
4711 BSTR *pbstrHelpString,
4712 DWORD *pdwHelpStringContext,
4713 BSTR *pbstrHelpStringDll)
4714 {
4715 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4716 HRESULT result;
4717 ITypeInfo *pTInfo;
4718
4719 FIXME("(%p) index %d lcid %d half implemented stub!\n", This, index, lcid);
4720
4721 /* the help string should be obtained from the helpstringdll,
4722 * using the _DLLGetDocumentation function, based on the supplied
4723 * lcid. Nice to do sometime...
4724 */
4725 if(index<0)
4726 {
4727 /* documentation for the typelib */
4728 if(pbstrHelpString)
4729 *pbstrHelpString=SysAllocString(This->DocString);
4730 if(pdwHelpStringContext)
4731 *pdwHelpStringContext=This->dwHelpContext;
4732 if(pbstrHelpStringDll)
4733 *pbstrHelpStringDll=SysAllocString(This->HelpStringDll);
4734
4735 result = S_OK;
4736 }
4737 else
4738 {
4739 /* for a typeinfo */
4740 result=ITypeLib2_GetTypeInfo(iface, index, &pTInfo);
4741
4742 if(SUCCEEDED(result))
4743 {
4744 ITypeInfo2 * pTInfo2;
4745 result = ITypeInfo_QueryInterface(pTInfo,
4746 &IID_ITypeInfo2,
4747 (LPVOID*) &pTInfo2);
4748
4749 if(SUCCEEDED(result))
4750 {
4751 result = ITypeInfo2_GetDocumentation2(pTInfo2,
4752 MEMBERID_NIL,
4753 lcid,
4754 pbstrHelpString,
4755 pdwHelpStringContext,
4756 pbstrHelpStringDll);
4757
4758 ITypeInfo2_Release(pTInfo2);
4759 }
4760
4761 ITypeInfo_Release(pTInfo);
4762 }
4763 }
4764 return result;
4765 }
4766
4767 static HRESULT TLB_copy_all_custdata(struct list *custdata_list, CUSTDATA *pCustData)
4768 {
4769 TLBCustData *pCData;
4770 unsigned int ct;
4771 CUSTDATAITEM *cdi;
4772
4773 ct = list_count(custdata_list);
4774
4775 pCustData->prgCustData = heap_alloc_zero(ct * sizeof(CUSTDATAITEM));
4776 if(!pCustData->prgCustData)
4777 return E_OUTOFMEMORY;
4778
4779 pCustData->cCustData = ct;
4780
4781 cdi = pCustData->prgCustData;
4782 LIST_FOR_EACH_ENTRY(pCData, custdata_list, TLBCustData, entry){
4783 cdi->guid = pCData->guid;
4784 VariantCopy(&cdi->varValue, &pCData->data);
4785 ++cdi;
4786 }
4787
4788 return S_OK;
4789 }
4790
4791
4792 /* ITypeLib2::GetAllCustData
4793 *
4794 * Gets all custom data items for the library.
4795 *
4796 */
4797 static HRESULT WINAPI ITypeLib2_fnGetAllCustData(
4798 ITypeLib2 * iface,
4799 CUSTDATA *pCustData)
4800 {
4801 ITypeLibImpl *This = (ITypeLibImpl *)iface;
4802 TRACE("%p %p\n", iface, pCustData);
4803 return TLB_copy_all_custdata(&This->custdata_list, pCustData);
4804 }
4805
4806 static const ITypeLib2Vtbl tlbvt = {
4807 ITypeLib2_fnQueryInterface,
4808 ITypeLib2_fnAddRef,
4809 ITypeLib2_fnRelease,
4810 ITypeLib2_fnGetTypeInfoCount,
4811 ITypeLib2_fnGetTypeInfo,
4812 ITypeLib2_fnGetTypeInfoType,
4813 ITypeLib2_fnGetTypeInfoOfGuid,
4814 ITypeLib2_fnGetLibAttr,
4815 ITypeLib2_fnGetTypeComp,
4816 ITypeLib2_fnGetDocumentation,
4817 ITypeLib2_fnIsName,
4818 ITypeLib2_fnFindName,
4819 ITypeLib2_fnReleaseTLibAttr,
4820
4821 ITypeLib2_fnGetCustData,
4822 ITypeLib2_fnGetLibStatistics,
4823 ITypeLib2_fnGetDocumentation2,
4824 ITypeLib2_fnGetAllCustData
4825 };
4826
4827
4828 static HRESULT WINAPI ITypeLibComp_fnQueryInterface(ITypeComp * iface, REFIID riid, LPVOID * ppv)
4829 {
4830 ITypeLibImpl *This = impl_from_ITypeComp(iface);
4831
4832 return ITypeLib2_QueryInterface((ITypeLib2 *)This, riid, ppv);
4833 }
4834
4835 static ULONG WINAPI ITypeLibComp_fnAddRef(ITypeComp * iface)
4836 {
4837 ITypeLibImpl *This = impl_from_ITypeComp(iface);
4838
4839 return ITypeLib2_AddRef((ITypeLib2 *)This);
4840 }
4841
4842 static ULONG WINAPI ITypeLibComp_fnRelease(ITypeComp * iface)
4843 {
4844 ITypeLibImpl *This = impl_from_ITypeComp(iface);
4845
4846 return ITypeLib2_Release((ITypeLib2 *)This);
4847 }
4848
4849 static HRESULT WINAPI ITypeLibComp_fnBind(
4850 ITypeComp * iface,
4851 OLECHAR * szName,
4852 ULONG lHash,
4853 WORD wFlags,
4854 ITypeInfo ** ppTInfo,
4855 DESCKIND * pDescKind,
4856 BINDPTR * pBindPtr)
4857 {
4858 ITypeLibImpl *This = impl_from_ITypeComp(iface);
4859 int typemismatch=0, i;
4860
4861 TRACE("(%s, 0x%x, 0x%x, %p, %p, %p)\n", debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
4862
4863 *pDescKind = DESCKIND_NONE;
4864 pBindPtr->lptcomp = NULL;
4865 *ppTInfo = NULL;
4866
4867 for(i = 0; i < This->TypeInfoCount; ++i){
4868 ITypeInfoImpl *pTypeInfo = This->typeinfos[i];
4869 TRACE("testing %s\n", debugstr_w(pTypeInfo->Name));
4870
4871 /* FIXME: check wFlags here? */
4872 /* FIXME: we should use a hash table to look this info up using lHash
4873 * instead of an O(n) search */
4874 if ((pTypeInfo->TypeAttr.typekind == TKIND_ENUM) ||
4875 (pTypeInfo->TypeAttr.typekind == TKIND_MODULE))
4876 {
4877 if (pTypeInfo->Name && !strcmpW(pTypeInfo->Name, szName))
4878 {
4879 *pDescKind = DESCKIND_TYPECOMP;
4880 pBindPtr->lptcomp = (ITypeComp *)&pTypeInfo->lpVtblTypeComp;
4881 ITypeComp_AddRef(pBindPtr->lptcomp);
4882 TRACE("module or enum: %s\n", debugstr_w(szName));
4883 return S_OK;
4884 }
4885 }
4886
4887 if ((pTypeInfo->TypeAttr.typekind == TKIND_MODULE) ||
4888 (pTypeInfo->TypeAttr.typekind == TKIND_ENUM))
4889 {
4890 ITypeComp *pSubTypeComp = (ITypeComp *)&pTypeInfo->lpVtblTypeComp;
4891 HRESULT hr;
4892
4893 hr = ITypeComp_Bind(pSubTypeComp, szName, lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
4894 if (SUCCEEDED(hr) && (*pDescKind != DESCKIND_NONE))
4895 {
4896 TRACE("found in module or in enum: %s\n", debugstr_w(szName));
4897 return S_OK;
4898 }
4899 else if (hr == TYPE_E_TYPEMISMATCH)
4900 typemismatch = 1;
4901 }
4902
4903 if ((pTypeInfo->TypeAttr.typekind == TKIND_COCLASS) &&
4904 (pTypeInfo->TypeAttr.wTypeFlags & TYPEFLAG_FAPPOBJECT))
4905 {
4906 ITypeComp *pSubTypeComp = (ITypeComp *)&pTypeInfo->lpVtblTypeComp;
4907 HRESULT hr;
4908 ITypeInfo *subtypeinfo;
4909 BINDPTR subbindptr;
4910 DESCKIND subdesckind;
4911
4912 hr = ITypeComp_Bind(pSubTypeComp, szName, lHash, wFlags,
4913 &subtypeinfo, &subdesckind, &subbindptr);
4914 if (SUCCEEDED(hr) && (subdesckind != DESCKIND_NONE))
4915 {
4916 TYPEDESC tdesc_appobject;
4917 const VARDESC vardesc_appobject =
4918 {
4919 -2, /* memid */
4920 NULL, /* lpstrSchema */
4921 {
4922 0 /* oInst */
4923 },
4924 {
4925 /* ELEMDESC */
4926 {
4927 /* TYPEDESC */
4928 {
4929 &tdesc_appobject
4930 },
4931 VT_PTR
4932 },
4933 },
4934 0, /* wVarFlags */
4935 VAR_STATIC /* varkind */
4936 };
4937
4938 tdesc_appobject.u.hreftype = pTypeInfo->hreftype;
4939 tdesc_appobject.vt = VT_USERDEFINED;
4940
4941 TRACE("found in implicit app object: %s\n", debugstr_w(szName));
4942
4943 /* cleanup things filled in by Bind call so we can put our
4944 * application object data in there instead */
4945 switch (subdesckind)
4946 {
4947 case DESCKIND_FUNCDESC:
4948 ITypeInfo_ReleaseFuncDesc(subtypeinfo, subbindptr.lpfuncdesc);
4949 break;
4950 case DESCKIND_VARDESC:
4951 ITypeInfo_ReleaseVarDesc(subtypeinfo, subbindptr.lpvardesc);
4952 break;
4953 default:
4954 break;
4955 }
4956 if (subtypeinfo) ITypeInfo_Release(subtypeinfo);
4957
4958 if (pTypeInfo->hreftype == -1)
4959 FIXME("no hreftype for interface %p\n", pTypeInfo);
4960
4961 hr = TLB_AllocAndInitVarDesc(&vardesc_appobject, &pBindPtr->lpvardesc);
4962 if (FAILED(hr))
4963 return hr;
4964
4965 *pDescKind = DESCKIND_IMPLICITAPPOBJ;
4966 *ppTInfo = (ITypeInfo *)pTypeInfo;
4967 ITypeInfo_AddRef(*ppTInfo);
4968 return S_OK;
4969 }
4970 else if (hr == TYPE_E_TYPEMISMATCH)
4971 typemismatch = 1;
4972 }
4973 }
4974
4975 if (typemismatch)
4976 {
4977 TRACE("type mismatch %s\n", debugstr_w(szName));
4978 return TYPE_E_TYPEMISMATCH;
4979 }
4980 else
4981 {
4982 TRACE("name not found %s\n", debugstr_w(szName));
4983 return S_OK;
4984 }
4985 }
4986
4987 static HRESULT WINAPI ITypeLibComp_fnBindType(
4988 ITypeComp * iface,
4989 OLECHAR * szName,
4990 ULONG lHash,
4991 ITypeInfo ** ppTInfo,
4992 ITypeComp ** ppTComp)
4993 {
4994 ITypeLibImpl *This = impl_from_ITypeComp(iface);
4995 UINT i;
4996
4997 TRACE("(%s, %x, %p, %p)\n", debugstr_w(szName), lHash, ppTInfo, ppTComp);
4998
4999 if(!szName || !ppTInfo || !ppTComp)
5000 return E_INVALIDARG;
5001
5002 for(i = 0; i < This->TypeInfoCount; ++i)
5003 {
5004 ITypeInfoImpl *pTypeInfo = This->typeinfos[i];
5005 /* FIXME: should use lHash to do the search */
5006 if (pTypeInfo->Name && !strcmpiW(pTypeInfo->Name, szName))
5007 {
5008 TRACE("returning %p\n", pTypeInfo);
5009 *ppTInfo = (ITypeInfo *)&pTypeInfo->lpVtbl;
5010 ITypeInfo_AddRef(*ppTInfo);
5011 *ppTComp = (ITypeComp *)&pTypeInfo->lpVtblTypeComp;
5012 ITypeComp_AddRef(*ppTComp);
5013 return S_OK;
5014 }
5015 }
5016
5017 TRACE("not found\n");
5018 *ppTInfo = NULL;
5019 *ppTComp = NULL;
5020 return S_OK;
5021 }
5022
5023 static const ITypeCompVtbl tlbtcvt =
5024 {
5025
5026 ITypeLibComp_fnQueryInterface,
5027 ITypeLibComp_fnAddRef,
5028 ITypeLibComp_fnRelease,
5029
5030 ITypeLibComp_fnBind,
5031 ITypeLibComp_fnBindType
5032 };
5033
5034 /*================== ITypeInfo(2) Methods ===================================*/
5035 static ITypeInfoImpl* ITypeInfoImpl_Constructor(void)
5036 {
5037 ITypeInfoImpl *pTypeInfoImpl;
5038
5039 pTypeInfoImpl = heap_alloc_zero(sizeof(ITypeInfoImpl));
5040 if (pTypeInfoImpl)
5041 {
5042 pTypeInfoImpl->lpVtbl = &tinfvt;
5043 pTypeInfoImpl->lpVtblTypeComp = &tcompvt;
5044 pTypeInfoImpl->ref = 0;
5045 pTypeInfoImpl->hreftype = -1;
5046 pTypeInfoImpl->TypeAttr.memidConstructor = MEMBERID_NIL;
5047 pTypeInfoImpl->TypeAttr.memidDestructor = MEMBERID_NIL;
5048 list_init(&pTypeInfoImpl->custdata_list);
5049 }
5050 TRACE("(%p)\n", pTypeInfoImpl);
5051 return pTypeInfoImpl;
5052 }
5053
5054 /* ITypeInfo::QueryInterface
5055 */
5056 static HRESULT WINAPI ITypeInfo_fnQueryInterface(
5057 ITypeInfo2 *iface,
5058 REFIID riid,
5059 VOID **ppvObject)
5060 {
5061 ITypeLibImpl *This = (ITypeLibImpl *)iface;
5062
5063 TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
5064
5065 *ppvObject=NULL;
5066 if(IsEqualIID(riid, &IID_IUnknown) ||
5067 IsEqualIID(riid,&IID_ITypeInfo)||
5068 IsEqualIID(riid,&IID_ITypeInfo2))
5069 *ppvObject = This;
5070
5071 if(*ppvObject){
5072 ITypeInfo2_AddRef(iface);
5073 TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
5074 return S_OK;
5075 }
5076 TRACE("-- Interface: E_NOINTERFACE\n");
5077 return E_NOINTERFACE;
5078 }
5079
5080 /* ITypeInfo::AddRef
5081 */
5082 static ULONG WINAPI ITypeInfo_fnAddRef( ITypeInfo2 *iface)
5083 {
5084 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5085 ULONG ref = InterlockedIncrement(&This->ref);
5086
5087 TRACE("(%p)->ref is %u\n",This, ref);
5088
5089 if (ref == 1 /* incremented from 0 */)
5090 ITypeLib2_AddRef((ITypeLib2*)This->pTypeLib);
5091
5092 return ref;
5093 }
5094
5095 static void ITypeInfoImpl_Destroy(ITypeInfoImpl *This)
5096 {
5097 UINT i, j;
5098
5099 TRACE("destroying ITypeInfo(%p)\n",This);
5100
5101 SysFreeString(This->Name);
5102 This->Name = NULL;
5103
5104 SysFreeString(This->DocString);
5105 This->DocString = NULL;
5106
5107 SysFreeString(This->DllName);
5108 This->DllName = NULL;
5109
5110 for (i = 0; i < This->TypeAttr.cFuncs; ++i)
5111 {
5112 TLBFuncDesc *pFInfo = &This->funcdescs[i];
5113 for(j = 0; j < pFInfo->funcdesc.cParams; j++)
5114 {
5115 ELEMDESC *elemdesc = &pFInfo->funcdesc.lprgelemdescParam[j];
5116 if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
5117 {
5118 VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
5119 heap_free(elemdesc->u.paramdesc.pparamdescex);
5120 }
5121 TLB_FreeCustData(&pFInfo->pParamDesc[j].custdata_list);
5122 SysFreeString(pFInfo->pParamDesc[j].Name);
5123 }
5124 heap_free(pFInfo->funcdesc.lprgelemdescParam);
5125 heap_free(pFInfo->pParamDesc);
5126 TLB_FreeCustData(&pFInfo->custdata_list);
5127 if (!IS_INTRESOURCE(pFInfo->Entry) && pFInfo->Entry != (BSTR)-1)
5128 SysFreeString(pFInfo->Entry);
5129 SysFreeString(pFInfo->HelpString);
5130 SysFreeString(pFInfo->Name);
5131 }
5132 heap_free(This->funcdescs);
5133
5134 for(i = 0; i < This->TypeAttr.cVars; ++i)
5135 {
5136 TLBVarDesc *pVInfo = &This->vardescs[i];
5137 if (pVInfo->vardesc.varkind == VAR_CONST)
5138 {
5139 VariantClear(pVInfo->vardesc.u.lpvarValue);
5140 heap_free(pVInfo->vardesc.u.lpvarValue);
5141 }
5142 TLB_FreeCustData(&pVInfo->custdata_list);
5143 SysFreeString(pVInfo->Name);
5144 SysFreeString(pVInfo->HelpString);
5145 }
5146 heap_free(This->vardescs);
5147
5148 if(This->impltypes){
5149 for (i = 0; i < This->TypeAttr.cImplTypes; ++i){
5150 TLBImplType *pImpl = &This->impltypes[i];
5151 TLB_FreeCustData(&pImpl->custdata_list);
5152 }
5153 heap_free(This->impltypes);
5154 }
5155
5156 TLB_FreeCustData(&This->custdata_list);
5157
5158 heap_free(This);
5159 }
5160
5161 /* ITypeInfo::Release
5162 */
5163 static ULONG WINAPI ITypeInfo_fnRelease(ITypeInfo2 *iface)
5164 {
5165 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5166 ULONG ref = InterlockedDecrement(&This->ref);
5167
5168 TRACE("(%p)->(%u)\n",This, ref);
5169
5170 if (!ref)
5171 {
5172 BOOL not_attached_to_typelib = This->not_attached_to_typelib;
5173 ITypeLib2_Release((ITypeLib2*)This->pTypeLib);
5174 if (not_attached_to_typelib)
5175 heap_free(This);
5176 /* otherwise This will be freed when typelib is freed */
5177 }
5178
5179 return ref;
5180 }
5181
5182 /* ITypeInfo::GetTypeAttr
5183 *
5184 * Retrieves a TYPEATTR structure that contains the attributes of the type
5185 * description.
5186 *
5187 */
5188 static HRESULT WINAPI ITypeInfo_fnGetTypeAttr( ITypeInfo2 *iface,
5189 LPTYPEATTR *ppTypeAttr)
5190 {
5191 const ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5192 SIZE_T size;
5193
5194 TRACE("(%p)\n",This);
5195
5196 size = sizeof(**ppTypeAttr);
5197 if (This->TypeAttr.typekind == TKIND_ALIAS)
5198 size += TLB_SizeTypeDesc(&This->TypeAttr.tdescAlias, FALSE);
5199
5200 *ppTypeAttr = heap_alloc(size);
5201 if (!*ppTypeAttr)
5202 return E_OUTOFMEMORY;
5203
5204 **ppTypeAttr = This->TypeAttr;
5205
5206 if (This->TypeAttr.typekind == TKIND_ALIAS)
5207 TLB_CopyTypeDesc(&(*ppTypeAttr)->tdescAlias,
5208 &This->TypeAttr.tdescAlias, *ppTypeAttr + 1);
5209
5210 if((*ppTypeAttr)->typekind == TKIND_DISPATCH) {
5211 /* This should include all the inherited funcs */
5212 (*ppTypeAttr)->cFuncs = (*ppTypeAttr)->cbSizeVft / sizeof(void *);
5213 /* This is always the size of IDispatch's vtbl */
5214 (*ppTypeAttr)->cbSizeVft = sizeof(IDispatchVtbl);
5215 (*ppTypeAttr)->wTypeFlags &= ~TYPEFLAG_FOLEAUTOMATION;
5216 }
5217 return S_OK;
5218 }
5219
5220 /* ITypeInfo::GetTypeComp
5221 *
5222 * Retrieves the ITypeComp interface for the type description, which enables a
5223 * client compiler to bind to the type description's members.
5224 *
5225 */
5226 static HRESULT WINAPI ITypeInfo_fnGetTypeComp( ITypeInfo2 *iface,
5227 ITypeComp * *ppTComp)
5228 {
5229 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5230
5231 TRACE("(%p)->(%p)\n", This, ppTComp);
5232
5233 *ppTComp = (ITypeComp *)&This->lpVtblTypeComp;
5234 ITypeComp_AddRef(*ppTComp);
5235 return S_OK;
5236 }
5237
5238 static SIZE_T TLB_SizeElemDesc( const ELEMDESC *elemdesc )
5239 {
5240 SIZE_T size = TLB_SizeTypeDesc(&elemdesc->tdesc, FALSE);
5241 if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
5242 size += sizeof(*elemdesc->u.paramdesc.pparamdescex);
5243 return size;
5244 }
5245
5246 static HRESULT TLB_CopyElemDesc( const ELEMDESC *src, ELEMDESC *dest, char **buffer )
5247 {
5248 *dest = *src;
5249 *buffer = TLB_CopyTypeDesc(&dest->tdesc, &src->tdesc, *buffer);
5250 if (src->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
5251 {
5252 const PARAMDESCEX *pparamdescex_src = src->u.paramdesc.pparamdescex;
5253 PARAMDESCEX *pparamdescex_dest = dest->u.paramdesc.pparamdescex = (PARAMDESCEX *)*buffer;
5254 *buffer += sizeof(PARAMDESCEX);
5255 *pparamdescex_dest = *pparamdescex_src;
5256 VariantInit(&pparamdescex_dest->varDefaultValue);
5257 return VariantCopy(&pparamdescex_dest->varDefaultValue,
5258 (VARIANTARG *)&pparamdescex_src->varDefaultValue);
5259 }
5260 else
5261 dest->u.paramdesc.pparamdescex = NULL;
5262 return S_OK;
5263 }
5264
5265 static void TLB_FreeElemDesc( ELEMDESC *elemdesc )
5266 {
5267 if (elemdesc->u.paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
5268 VariantClear(&elemdesc->u.paramdesc.pparamdescex->varDefaultValue);
5269 }
5270
5271 static HRESULT TLB_AllocAndInitFuncDesc( const FUNCDESC *src, FUNCDESC **dest_ptr, BOOL dispinterface )
5272 {
5273 FUNCDESC *dest;
5274 char *buffer;
5275 SIZE_T size = sizeof(*src);
5276 SHORT i;
5277 HRESULT hr;
5278
5279 size += sizeof(*src->lprgscode) * src->cScodes;
5280 size += TLB_SizeElemDesc(&src->elemdescFunc);
5281 for (i = 0; i < src->cParams; i++)
5282 {
5283 size += sizeof(ELEMDESC);
5284 size += TLB_SizeElemDesc(&src->lprgelemdescParam[i]);
5285 }
5286
5287 dest = (FUNCDESC *)SysAllocStringByteLen(NULL, size);
5288 if (!dest) return E_OUTOFMEMORY;
5289
5290 *dest = *src;
5291 if (dispinterface) /* overwrite funckind */
5292 dest->funckind = FUNC_DISPATCH;
5293 buffer = (char *)(dest + 1);
5294
5295 dest->lprgscode = (SCODE *)buffer;
5296 memcpy(dest->lprgscode, src->lprgscode, sizeof(*src->lprgscode) * src->cScodes);
5297 buffer += sizeof(*src->lprgscode) * src->cScodes;
5298
5299 hr = TLB_CopyElemDesc(&src->elemdescFunc, &dest->elemdescFunc, &buffer);
5300 if (FAILED(hr))
5301 {
5302 SysFreeString((BSTR)dest);
5303 return hr;
5304 }
5305
5306 dest->lprgelemdescParam = (ELEMDESC *)buffer;
5307 buffer += sizeof(ELEMDESC) * src->cParams;
5308 for (i = 0; i < src->cParams; i++)
5309 {
5310 hr = TLB_CopyElemDesc(&src->lprgelemdescParam[i], &dest->lprgelemdescParam[i], &buffer);
5311 if (FAILED(hr))
5312 break;
5313 }
5314 if (FAILED(hr))
5315 {
5316 /* undo the above actions */
5317 for (i = i - 1; i >= 0; i--)
5318 TLB_FreeElemDesc(&dest->lprgelemdescParam[i]);
5319 TLB_FreeElemDesc(&dest->elemdescFunc);
5320 SysFreeString((BSTR)dest);
5321 return hr;
5322 }
5323
5324 /* special treatment for dispinterfaces: this makes functions appear
5325 * to return their [retval] value when it is really returning an
5326 * HRESULT */
5327 if (dispinterface && dest->elemdescFunc.tdesc.vt == VT_HRESULT)
5328 {
5329 if (dest->cParams &&
5330 (dest->lprgelemdescParam[dest->cParams - 1].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL))
5331 {
5332 ELEMDESC *elemdesc = &dest->lprgelemdescParam[dest->cParams - 1];
5333 if (elemdesc->tdesc.vt != VT_PTR)
5334 {
5335 ERR("elemdesc should have started with VT_PTR instead of:\n");
5336 if (ERR_ON(ole))
5337 dump_ELEMDESC(elemdesc);
5338 return E_UNEXPECTED;
5339 }
5340
5341 /* copy last parameter to the return value. we are using a flat
5342 * buffer so there is no danger of leaking memory in
5343 * elemdescFunc */
5344 dest->elemdescFunc.tdesc = *elemdesc->tdesc.u.lptdesc;
5345
5346 /* remove the last parameter */
5347 dest->cParams--;
5348 }
5349 else
5350 /* otherwise this function is made to appear to have no return
5351 * value */
5352 dest->elemdescFunc.tdesc.vt = VT_VOID;
5353
5354 }
5355
5356 *dest_ptr = dest;
5357 return S_OK;
5358 }
5359
5360 HRESULT ITypeInfoImpl_GetInternalFuncDesc( ITypeInfo *iface, UINT index, const FUNCDESC **ppFuncDesc )
5361 {
5362 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5363
5364 if (index >= This->TypeAttr.cFuncs)
5365 return TYPE_E_ELEMENTNOTFOUND;
5366
5367 *ppFuncDesc = &This->funcdescs[index].funcdesc;
5368 return S_OK;
5369 }
5370
5371 /* internal function to make the inherited interfaces' methods appear
5372 * part of the interface */
5373 static HRESULT ITypeInfoImpl_GetInternalDispatchFuncDesc( ITypeInfo *iface,
5374 UINT index, const FUNCDESC **ppFuncDesc, UINT *funcs, UINT *hrefoffset)
5375 {
5376 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5377 HRESULT hr;
5378 UINT implemented_funcs = 0;
5379
5380 if (funcs)
5381 *funcs = 0;
5382 else
5383 *hrefoffset = DISPATCH_HREF_OFFSET;
5384
5385 if(This->impltypes)
5386 {
5387 ITypeInfo *pSubTypeInfo;
5388 UINT sub_funcs;
5389
5390 hr = ITypeInfo_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pSubTypeInfo);
5391 if (FAILED(hr))
5392 return hr;
5393
5394 hr = ITypeInfoImpl_GetInternalDispatchFuncDesc(pSubTypeInfo,
5395 index,
5396 ppFuncDesc,
5397 &sub_funcs, hrefoffset);
5398 implemented_funcs += sub_funcs;
5399 ITypeInfo_Release(pSubTypeInfo);
5400 if (SUCCEEDED(hr))
5401 return hr;
5402 *hrefoffset += DISPATCH_HREF_OFFSET;
5403 }
5404
5405 if (funcs)
5406 *funcs = implemented_funcs + This->TypeAttr.cFuncs;
5407 else
5408 *hrefoffset = 0;
5409
5410 if (index < implemented_funcs)
5411 return E_INVALIDARG;
5412 return ITypeInfoImpl_GetInternalFuncDesc(iface, index - implemented_funcs,
5413 ppFuncDesc);
5414 }
5415
5416 static inline void ITypeInfoImpl_ElemDescAddHrefOffset( LPELEMDESC pElemDesc, UINT hrefoffset)
5417 {
5418 TYPEDESC *pTypeDesc = &pElemDesc->tdesc;
5419 while (TRUE)
5420 {
5421 switch (pTypeDesc->vt)
5422 {
5423 case VT_USERDEFINED:
5424 pTypeDesc->u.hreftype += hrefoffset;
5425 return;
5426 case VT_PTR:
5427 case VT_SAFEARRAY:
5428 pTypeDesc = pTypeDesc->u.lptdesc;
5429 break;
5430 case VT_CARRAY:
5431 pTypeDesc = &pTypeDesc->u.lpadesc->tdescElem;
5432 break;
5433 default:
5434 return;
5435 }
5436 }
5437 }
5438
5439 static inline void ITypeInfoImpl_FuncDescAddHrefOffset( LPFUNCDESC pFuncDesc, UINT hrefoffset)
5440 {
5441 SHORT i;
5442 for (i = 0; i < pFuncDesc->cParams; i++)
5443 ITypeInfoImpl_ElemDescAddHrefOffset(&pFuncDesc->lprgelemdescParam[i], hrefoffset);
5444 ITypeInfoImpl_ElemDescAddHrefOffset(&pFuncDesc->elemdescFunc, hrefoffset);
5445 }
5446
5447 /* ITypeInfo::GetFuncDesc
5448 *
5449 * Retrieves the FUNCDESC structure that contains information about a
5450 * specified function.
5451 *
5452 */
5453 static HRESULT WINAPI ITypeInfo_fnGetFuncDesc( ITypeInfo2 *iface, UINT index,
5454 LPFUNCDESC *ppFuncDesc)
5455 {
5456 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5457 const FUNCDESC *internal_funcdesc;
5458 HRESULT hr;
5459 UINT hrefoffset = 0;
5460
5461 TRACE("(%p) index %d\n", This, index);
5462
5463 if (This->TypeAttr.typekind == TKIND_DISPATCH)
5464 hr = ITypeInfoImpl_GetInternalDispatchFuncDesc((ITypeInfo *)iface, index,
5465 &internal_funcdesc, NULL,
5466 &hrefoffset);
5467 else
5468 hr = ITypeInfoImpl_GetInternalFuncDesc((ITypeInfo *)iface, index,
5469 &internal_funcdesc);
5470 if (FAILED(hr))
5471 {
5472 WARN("description for function %d not found\n", index);
5473 return hr;
5474 }
5475
5476 hr = TLB_AllocAndInitFuncDesc(
5477 internal_funcdesc,
5478 ppFuncDesc,
5479 This->TypeAttr.typekind == TKIND_DISPATCH);
5480
5481 if ((This->TypeAttr.typekind == TKIND_DISPATCH) && hrefoffset)
5482 ITypeInfoImpl_FuncDescAddHrefOffset(*ppFuncDesc, hrefoffset);
5483
5484 TRACE("-- 0x%08x\n", hr);
5485 return hr;
5486 }
5487
5488 static HRESULT TLB_AllocAndInitVarDesc( const VARDESC *src, VARDESC **dest_ptr )
5489 {
5490 VARDESC *dest;
5491 char *buffer;
5492 SIZE_T size = sizeof(*src);
5493 HRESULT hr;
5494
5495 if (src->lpstrSchema) size += (strlenW(src->lpstrSchema) + 1) * sizeof(WCHAR);
5496 if (src->varkind == VAR_CONST)
5497 size += sizeof(VARIANT);
5498 size += TLB_SizeElemDesc(&src->elemdescVar);
5499
5500 dest = (VARDESC *)SysAllocStringByteLen(NULL, size);
5501 if (!dest) return E_OUTOFMEMORY;
5502
5503 *dest = *src;
5504 buffer = (char *)(dest + 1);
5505 if (src->lpstrSchema)
5506 {
5507 int len;
5508 dest->lpstrSchema = (LPOLESTR)buffer;
5509 len = strlenW(src->lpstrSchema);
5510 memcpy(dest->lpstrSchema, src->lpstrSchema, (len + 1) * sizeof(WCHAR));
5511 buffer += (len + 1) * sizeof(WCHAR);
5512 }
5513
5514 if (src->varkind == VAR_CONST)
5515 {
5516 HRESULT hr;
5517
5518 dest->u.lpvarValue = (VARIANT *)buffer;
5519 *dest->u.lpvarValue = *src->u.lpvarValue;
5520 buffer += sizeof(VARIANT);
5521 VariantInit(dest->u.lpvarValue);
5522 hr = VariantCopy(dest->u.lpvarValue, src->u.lpvarValue);
5523 if (FAILED(hr))
5524 {
5525 SysFreeString((BSTR)dest);
5526 return hr;
5527 }
5528 }
5529 hr = TLB_CopyElemDesc(&src->elemdescVar, &dest->elemdescVar, &buffer);
5530 if (FAILED(hr))
5531 {
5532 if (src->varkind == VAR_CONST)
5533 VariantClear(dest->u.lpvarValue);
5534 SysFreeString((BSTR)dest);
5535 return hr;
5536 }
5537 *dest_ptr = dest;
5538 return S_OK;
5539 }
5540
5541 /* ITypeInfo::GetVarDesc
5542 *
5543 * Retrieves a VARDESC structure that describes the specified variable.
5544 *
5545 */
5546 static HRESULT WINAPI ITypeInfo_fnGetVarDesc( ITypeInfo2 *iface, UINT index,
5547 LPVARDESC *ppVarDesc)
5548 {
5549 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5550 const TLBVarDesc *pVDesc = &This->vardescs[index];
5551
5552 TRACE("(%p) index %d\n", This, index);
5553
5554 if(index >= This->TypeAttr.cVars)
5555 return TYPE_E_ELEMENTNOTFOUND;
5556
5557 return TLB_AllocAndInitVarDesc(&pVDesc->vardesc, ppVarDesc);
5558 }
5559
5560 /* ITypeInfo_GetNames
5561 *
5562 * Retrieves the variable with the specified member ID (or the name of the
5563 * property or method and its parameters) that correspond to the specified
5564 * function ID.
5565 */
5566 static HRESULT WINAPI ITypeInfo_fnGetNames( ITypeInfo2 *iface, MEMBERID memid,
5567 BSTR *rgBstrNames, UINT cMaxNames, UINT *pcNames)
5568 {
5569 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5570 const TLBFuncDesc *pFDesc;
5571 const TLBVarDesc *pVDesc;
5572 int i;
5573 TRACE("(%p) memid=0x%08x Maxname=%d\n", This, memid, cMaxNames);
5574 pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->TypeAttr.cFuncs, memid);
5575 if(pFDesc)
5576 {
5577 /* function found, now return function and parameter names */
5578 for(i=0; i<cMaxNames && i <= pFDesc->funcdesc.cParams; i++)
5579 {
5580 if(!i)
5581 *rgBstrNames=SysAllocString(pFDesc->Name);
5582 else
5583 rgBstrNames[i]=SysAllocString(pFDesc->pParamDesc[i-1].Name);
5584 }
5585 *pcNames=i;
5586 }
5587 else
5588 {
5589 pVDesc = TLB_get_vardesc_by_memberid(This->vardescs, This->TypeAttr.cVars, memid);
5590 if(pVDesc)
5591 {
5592 *rgBstrNames=SysAllocString(pVDesc->Name);
5593 *pcNames=1;
5594 }
5595 else
5596 {
5597 if(This->impltypes &&
5598 (This->TypeAttr.typekind==TKIND_INTERFACE || This->TypeAttr.typekind==TKIND_DISPATCH)) {
5599 /* recursive search */
5600 ITypeInfo *pTInfo;
5601 HRESULT result;
5602 result = ITypeInfo2_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pTInfo);
5603 if(SUCCEEDED(result))
5604 {
5605 result=ITypeInfo_GetNames(pTInfo, memid, rgBstrNames, cMaxNames, pcNames);
5606 ITypeInfo_Release(pTInfo);
5607 return result;
5608 }
5609 WARN("Could not search inherited interface!\n");
5610 }
5611 else
5612 {
5613 WARN("no names found\n");
5614 }
5615 *pcNames=0;
5616 return TYPE_E_ELEMENTNOTFOUND;
5617 }
5618 }
5619 return S_OK;
5620 }
5621
5622
5623 /* ITypeInfo::GetRefTypeOfImplType
5624 *
5625 * If a type description describes a COM class, it retrieves the type
5626 * description of the implemented interface types. For an interface,
5627 * GetRefTypeOfImplType returns the type information for inherited interfaces,
5628 * if any exist.
5629 *
5630 */
5631 static HRESULT WINAPI ITypeInfo_fnGetRefTypeOfImplType(
5632 ITypeInfo2 *iface,
5633 UINT index,
5634 HREFTYPE *pRefType)
5635 {
5636 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5637 HRESULT hr = S_OK;
5638
5639 TRACE("(%p) index %d\n", This, index);
5640 if (TRACE_ON(ole)) dump_TypeInfo(This);
5641
5642 if(index==(UINT)-1)
5643 {
5644 /* only valid on dual interfaces;
5645 retrieve the associated TKIND_INTERFACE handle for the current TKIND_DISPATCH
5646 */
5647 if( This->TypeAttr.typekind != TKIND_DISPATCH) return E_INVALIDARG;
5648
5649 if (This->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL)
5650 {
5651 *pRefType = -1;
5652 }
5653 else
5654 {
5655 hr = TYPE_E_ELEMENTNOTFOUND;
5656 }
5657 }
5658 else if(index == 0 && This->TypeAttr.typekind == TKIND_DISPATCH)
5659 {
5660 /* All TKIND_DISPATCHs are made to look like they inherit from IDispatch */
5661 *pRefType = This->pTypeLib->dispatch_href;
5662 }
5663 else
5664 {
5665 if(index >= This->TypeAttr.cImplTypes)
5666 hr = TYPE_E_ELEMENTNOTFOUND;
5667 else
5668 *pRefType = This->impltypes[index].hRef;
5669 }
5670
5671 if(TRACE_ON(ole))
5672 {
5673 if(SUCCEEDED(hr))
5674 TRACE("SUCCESS -- hRef = 0x%08x\n", *pRefType );
5675 else
5676 TRACE("FAILURE -- hresult = 0x%08x\n", hr);
5677 }
5678
5679 return hr;
5680 }
5681
5682 /* ITypeInfo::GetImplTypeFlags
5683 *
5684 * Retrieves the IMPLTYPEFLAGS enumeration for one implemented interface
5685 * or base interface in a type description.
5686 */
5687 static HRESULT WINAPI ITypeInfo_fnGetImplTypeFlags( ITypeInfo2 *iface,
5688 UINT index, INT *pImplTypeFlags)
5689 {
5690 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5691
5692 TRACE("(%p) index %d\n", This, index);
5693
5694 if(This->TypeAttr.typekind == TKIND_DISPATCH && index == 0){
5695 *pImplTypeFlags = 0;
5696 return S_OK;
5697 }
5698
5699 if(index >= This->TypeAttr.cImplTypes)
5700 return TYPE_E_ELEMENTNOTFOUND;
5701
5702 *pImplTypeFlags = This->impltypes[index].implflags;
5703
5704 return S_OK;
5705 }
5706
5707 /* GetIDsOfNames
5708 * Maps between member names and member IDs, and parameter names and
5709 * parameter IDs.
5710 */
5711 static HRESULT WINAPI ITypeInfo_fnGetIDsOfNames( ITypeInfo2 *iface,
5712 LPOLESTR *rgszNames, UINT cNames, MEMBERID *pMemId)
5713 {
5714 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
5715 const TLBVarDesc *pVDesc;
5716 HRESULT ret=S_OK;
5717 UINT i, fdc;
5718
5719 TRACE("(%p) Name %s cNames %d\n", This, debugstr_w(*rgszNames),
5720 cNames);
5721
5722 /* init out parameters in case of failure */
5723 for (i = 0; i < cNames; i++)
5724 pMemId[i] = MEMBERID_NIL;
5725
5726 for (fdc = 0; fdc < This->TypeAttr.cFuncs; ++fdc) {
5727 int j;
5728 const TLBFuncDesc *pFDesc = &This->funcdescs[fdc];
5729 if(!lstrcmpiW(*rgszNames, pFDesc->Name)) {
5730 if(cNames) *pMemId=pFDesc->funcdesc.memid;
5731 for(i=1; i < cNames; i++){
5732 for(j=0; j<pFDesc->funcdesc.cParams; j++)
5733 if(!lstrcmpiW(rgszNames[i],pFDesc->pParamDesc[j].Name))
5734 break;
5735 if( j<pFDesc->funcdesc.cParams)
5736 pMemId[i]=j;
5737 else
5738 ret=DISP_E_UNKNOWNNAME;
5739 };
5740 TRACE("-- 0x%08x\n", ret);
5741 return ret;
5742 }
5743 }
5744 pVDesc = TLB_get_vardesc_by_name(This->vardescs, This->TypeAttr.cVars, *rgszNames);
5745 if(pVDesc){
5746 if(cNames)
5747 *pMemId = pVDesc->vardesc.memid;
5748 return ret;
5749 }
5750 /* not found, see if it can be found in an inherited interface */
5751 if(This->impltypes) {
5752 /* recursive search */
5753 ITypeInfo *pTInfo;
5754 ret = ITypeInfo2_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pTInfo);
5755 if(SUCCEEDED(ret)){
5756 ret=ITypeInfo_GetIDsOfNames(pTInfo, rgszNames, cNames, pMemId );
5757 ITypeInfo_Release(pTInfo);
5758 return ret;
5759 }
5760 WARN("Could not search inherited interface!\n");
5761 } else
5762 WARN("no names found\n");
5763 return DISP_E_UNKNOWNNAME;
5764 }
5765
5766
5767 #ifdef __i386__
5768
5769 extern LONGLONG call_method( void *func, int nb_args, const DWORD *args, int *stack_offset );
5770 __ASM_GLOBAL_FUNC( call_method,
5771 "pushl %ebp\n\t"
5772 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
5773 __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
5774 "movl %esp,%ebp\n\t"
5775 __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
5776 "pushl %esi\n\t"
5777 __ASM_CFI(".cfi_rel_offset %esi,-4\n\t")
5778 "pushl %edi\n\t"
5779 __ASM_CFI(".cfi_rel_offset %edi,-8\n\t")
5780 "movl 12(%ebp),%edx\n\t"
5781 "movl %esp,%edi\n\t"
5782 "shll $2,%edx\n\t"
5783 "jz 1f\n\t"
5784 "subl %edx,%edi\n\t"
5785 "andl $~15,%edi\n\t"
5786 "movl %edi,%esp\n\t"
5787 "movl 12(%ebp),%ecx\n\t"
5788 "movl 16(%ebp),%esi\n\t"
5789 "cld\n\t"
5790 "rep; movsl\n"
5791 "1:\tcall *8(%ebp)\n\t"
5792 "subl %esp,%edi\n\t"
5793 "movl 20(%ebp),%ecx\n\t"
5794 "movl %edi,(%ecx)\n\t"
5795 "leal -8(%ebp),%esp\n\t"
5796 "popl %edi\n\t"
5797 __ASM_CFI(".cfi_same_value %edi\n\t")
5798 "popl %esi\n\t"
5799 __ASM_CFI(".cfi_same_value %esi\n\t")
5800 "popl %ebp\n\t"
5801 __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
5802 __ASM_CFI(".cfi_same_value %ebp\n\t")
5803 "ret" )
5804
5805 /* same function but returning floating point */
5806 static double (* const call_double_method)(void*,int,const DWORD*,int*) = (void *)call_method;
5807
5808 /* ITypeInfo::Invoke
5809 *
5810 * Invokes a method, or accesses a property of an object, that implements the
5811 * interface described by the type description.
5812 */
5813 DWORD
5814 _invoke(FARPROC func,CALLCONV callconv, int nrargs, DWORD *args) {
5815 DWORD res;
5816 int stack_offset;
5817
5818 if (TRACE_ON(ole)) {
5819 int i;
5820 TRACE("Calling %p(",func);
5821 for (i=0;i<min(nrargs,30);i++) TRACE("%08x,",args[i]);
5822 if (nrargs > 30) TRACE("...");
5823 TRACE(")\n");
5824 }
5825
5826 switch (callconv) {
5827 case CC_STDCALL:
5828 case CC_CDECL:
5829 res = call_method( func, nrargs, args, &stack_offset );
5830 break;
5831 default:
5832 FIXME("unsupported calling convention %d\n",callconv);
5833 res = -1;
5834 break;
5835 }
5836 TRACE("returns %08x\n",res);
5837 return res;
5838 }
5839
5840 #elif defined(__x86_64__)
5841
5842 extern DWORD_PTR CDECL call_method( void *func, int nb_args, const DWORD_PTR *args );
5843 __ASM_GLOBAL_FUNC( call_method,
5844 "pushq %rbp\n\t"
5845 __ASM_CFI(".cfi_adjust_cfa_offset 8\n\t")
5846 __ASM_CFI(".cfi_rel_offset %rbp,0\n\t")
5847 "movq %rsp,%rbp\n\t"
5848 __ASM_CFI(".cfi_def_cfa_register %rbp\n\t")
5849 "pushq %rsi\n\t"
5850 __ASM_CFI(".cfi_rel_offset %rsi,-8\n\t")
5851 "pushq %rdi\n\t"
5852 __ASM_CFI(".cfi_rel_offset %rdi,-16\n\t")
5853 "movq %rcx,%rax\n\t"
5854 "movq $4,%rcx\n\t"
5855 "cmp %rcx,%rdx\n\t"
5856 "cmovgq %rdx,%rcx\n\t"
5857 "leaq 0(,%rcx,8),%rdx\n\t"
5858 "subq %rdx,%rsp\n\t"
5859 "andq $~15,%rsp\n\t"
5860 "movq %rsp,%rdi\n\t"
5861 "movq %r8,%rsi\n\t"
5862 "rep; movsq\n\t"
5863 "movq 0(%rsp),%rcx\n\t"
5864 "movq 8(%rsp),%rdx\n\t"
5865 "movq 16(%rsp),%r8\n\t"
5866 "movq 24(%rsp),%r9\n\t"
5867 "movq %rcx,%xmm0\n\t"
5868 "movq %rdx,%xmm1\n\t"
5869 "movq %r8,%xmm2\n\t"
5870 "movq %r9,%xmm3\n\t"
5871 "callq *%rax\n\t"
5872 "leaq -16(%rbp),%rsp\n\t"
5873 "popq %rdi\n\t"
5874 __ASM_CFI(".cfi_same_value %rdi\n\t")
5875 "popq %rsi\n\t"
5876 __ASM_CFI(".cfi_same_value %rsi\n\t")
5877 __ASM_CFI(".cfi_def_cfa_register %rsp\n\t")
5878 "popq %rbp\n\t"
5879 __ASM_CFI(".cfi_adjust_cfa_offset -8\n\t")
5880 __ASM_CFI(".cfi_same_value %rbp\n\t")
5881 "ret")
5882
5883 /* same function but returning floating point */
5884 static double (CDECL * const call_double_method)(void*,int,const DWORD_PTR*) = (void *)call_method;
5885
5886 #endif /* __x86_64__ */
5887
5888 static HRESULT userdefined_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt)
5889 {
5890 HRESULT hr = S_OK;
5891 ITypeInfo *tinfo2 = NULL;
5892 TYPEATTR *tattr = NULL;
5893
5894 hr = ITypeInfo_GetRefTypeInfo(tinfo, tdesc->u.hreftype, &tinfo2);
5895 if (hr)
5896 {
5897 ERR("Could not get typeinfo of hreftype %x for VT_USERDEFINED, "
5898 "hr = 0x%08x\n",
5899 tdesc->u.hreftype, hr);
5900 return hr;
5901 }
5902 hr = ITypeInfo_GetTypeAttr(tinfo2, &tattr);
5903 if (hr)
5904 {
5905 ERR("ITypeInfo_GetTypeAttr failed, hr = 0x%08x\n", hr);
5906 ITypeInfo_Release(tinfo2);
5907 return hr;
5908 }
5909
5910 switch (tattr->typekind)
5911 {
5912 case TKIND_ENUM:
5913 *vt |= VT_I4;
5914 break;
5915
5916 case TKIND_ALIAS:
5917 tdesc = &tattr->tdescAlias;
5918 hr = typedescvt_to_variantvt(tinfo2, &tattr->tdescAlias, vt);
5919 break;
5920
5921 case TKIND_INTERFACE:
5922 if (tattr->wTypeFlags & TYPEFLAG_FDISPATCHABLE)
5923 *vt |= VT_DISPATCH;
5924 else
5925 *vt |= VT_UNKNOWN;
5926 break;
5927
5928 case TKIND_DISPATCH:
5929 *vt |= VT_DISPATCH;
5930 break;
5931
5932 case TKIND_COCLASS:
5933 *vt |= VT_DISPATCH;
5934 break;
5935
5936 case TKIND_RECORD:
5937 FIXME("TKIND_RECORD unhandled.\n");
5938 hr = E_NOTIMPL;
5939 break;
5940
5941 case TKIND_UNION:
5942 FIXME("TKIND_UNION unhandled.\n");
5943 hr = E_NOTIMPL;
5944 break;
5945
5946 default:
5947 FIXME("TKIND %d unhandled.\n",tattr->typekind);
5948 hr = E_NOTIMPL;
5949 break;
5950 }
5951 ITypeInfo_ReleaseTypeAttr(tinfo2, tattr);
5952 ITypeInfo_Release(tinfo2);
5953 return hr;
5954 }
5955
5956 static HRESULT typedescvt_to_variantvt(ITypeInfo *tinfo, const TYPEDESC *tdesc, VARTYPE *vt)
5957 {
5958 HRESULT hr = S_OK;
5959
5960 /* enforce only one level of pointer indirection */
5961 if (!(*vt & VT_BYREF) && !(*vt & VT_ARRAY) && (tdesc->vt == VT_PTR))
5962 {
5963 tdesc = tdesc->u.lptdesc;
5964
5965 /* munch VT_PTR -> VT_USERDEFINED(interface) into VT_UNKNOWN or
5966 * VT_DISPATCH and VT_PTR -> VT_PTR -> VT_USERDEFINED(interface) into
5967 * VT_BYREF|VT_DISPATCH or VT_BYREF|VT_UNKNOWN */
5968 if ((tdesc->vt == VT_USERDEFINED) ||
5969 ((tdesc->vt == VT_PTR) && (tdesc->u.lptdesc->vt == VT_USERDEFINED)))
5970 {
5971 VARTYPE vt_userdefined = 0;
5972 const TYPEDESC *tdesc_userdefined = tdesc;
5973 if (tdesc->vt == VT_PTR)
5974 {
5975 vt_userdefined = VT_BYREF;
5976 tdesc_userdefined = tdesc->u.lptdesc;
5977 }
5978 hr = userdefined_to_variantvt(tinfo, tdesc_userdefined, &vt_userdefined);
5979 if ((hr == S_OK) &&
5980 (((vt_userdefined & VT_TYPEMASK) == VT_UNKNOWN) ||
5981 ((vt_userdefined & VT_TYPEMASK) == VT_DISPATCH)))
5982 {
5983 *vt |= vt_userdefined;
5984 return S_OK;
5985 }
5986 }
5987 *vt = VT_BYREF;
5988 }
5989
5990 switch (tdesc->vt)
5991 {
5992 case VT_HRESULT:
5993 *vt |= VT_ERROR;
5994 break;
5995 case VT_USERDEFINED:
5996 hr = userdefined_to_variantvt(tinfo, tdesc, vt);
5997 break;
5998 case VT_VOID:
5999 case VT_CARRAY:
6000 case VT_PTR:
6001 case VT_LPSTR:
6002 case VT_LPWSTR:
6003 ERR("cannot convert type %d into variant VT\n", tdesc->vt);
6004 hr = DISP_E_BADVARTYPE;
6005 break;
6006 case VT_SAFEARRAY:
6007 *vt |= VT_ARRAY;
6008 hr = typedescvt_to_variantvt(tinfo, tdesc->u.lptdesc, vt);
6009 break;
6010 case VT_INT:
6011 *vt |= VT_I4;
6012 break;
6013 case VT_UINT:
6014 *vt |= VT_UI4;
6015 break;
6016 default:
6017 *vt |= tdesc->vt;
6018 break;
6019 }
6020 return hr;
6021 }
6022
6023 static HRESULT get_iface_guid(ITypeInfo *tinfo, const TYPEDESC *tdesc, GUID *guid)
6024 {
6025 ITypeInfo *tinfo2;
6026 TYPEATTR *tattr;
6027 HRESULT hres;
6028
6029 hres = ITypeInfo_GetRefTypeInfo(tinfo, tdesc->u.hreftype, &tinfo2);
6030 if(FAILED(hres))
6031 return hres;
6032
6033 hres = ITypeInfo_GetTypeAttr(tinfo2, &tattr);
6034 if(FAILED(hres)) {
6035 ITypeInfo_Release(tinfo2);
6036 return hres;
6037 }
6038
6039 switch(tattr->typekind) {
6040 case TKIND_ALIAS:
6041 hres = get_iface_guid(tinfo2, &tattr->tdescAlias, guid);
6042 break;
6043
6044 case TKIND_INTERFACE:
6045 case TKIND_DISPATCH:
6046 *guid = tattr->guid;
6047 break;
6048
6049 default:
6050 ERR("Unexpected typekind %d\n", tattr->typekind);
6051 hres = E_UNEXPECTED;
6052 }
6053
6054 ITypeInfo_ReleaseTypeAttr(tinfo2, tattr);
6055 ITypeInfo_Release(tinfo2);
6056 return hres;
6057 }
6058
6059 /***********************************************************************
6060 * DispCallFunc (OLEAUT32.@)
6061 *
6062 * Invokes a function of the specified calling convention, passing the
6063 * specified arguments and returns the result.
6064 *
6065 * PARAMS
6066 * pvInstance [I] Optional pointer to the instance whose function to invoke.
6067 * oVft [I] The offset in the vtable. See notes.
6068 * cc [I] Calling convention of the function to call.
6069 * vtReturn [I] The return type of the function.
6070 * cActuals [I] Number of parameters.
6071 * prgvt [I] The types of the parameters to pass. This is used for sizing only.
6072 * prgpvarg [I] The arguments to pass.
6073 * pvargResult [O] The return value of the function. Can be NULL.
6074 *
6075 * RETURNS
6076 * Success: S_OK.
6077 * Failure: HRESULT code.
6078 *
6079 * NOTES
6080 * The HRESULT return value of this function is not affected by the return
6081 * value of the user supplied function, which is returned in pvargResult.
6082 *
6083 * If pvInstance is NULL then a non-object function is to be called and oVft
6084 * is the address of the function to call.
6085 *
6086 * The cc parameter can be one of the following values:
6087 *|CC_FASTCALL
6088 *|CC_CDECL
6089 *|CC_PASCAL
6090 *|CC_STDCALL
6091 *|CC_FPFASTCALL
6092 *|CC_SYSCALL
6093 *|CC_MPWCDECL
6094 *|CC_MPWPASCAL
6095 *
6096 */
6097 HRESULT WINAPI
6098 DispCallFunc(
6099 void* pvInstance, ULONG_PTR oVft, CALLCONV cc, VARTYPE vtReturn, UINT cActuals,
6100 VARTYPE* prgvt, VARIANTARG** prgpvarg, VARIANT* pvargResult)
6101 {
6102 #ifdef __i386__
6103 int argspos, stack_offset;
6104 void *func;
6105 UINT i;
6106 DWORD *args;
6107
6108 TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n",
6109 pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg,
6110 pvargResult, V_VT(pvargResult));
6111
6112 if (cc != CC_STDCALL && cc != CC_CDECL)
6113 {
6114 FIXME("unsupported calling convention %d\n",cc);
6115 return E_INVALIDARG;
6116 }
6117
6118 /* maximum size for an argument is sizeof(VARIANT) */
6119 args = heap_alloc(sizeof(VARIANT) * cActuals + sizeof(DWORD) * 2 );
6120
6121 /* start at 1 in case we need to pass a pointer to the return value as arg 0 */
6122 argspos = 1;
6123 if (pvInstance)
6124 {
6125 const FARPROC *vtable = *(FARPROC **)pvInstance;
6126 func = vtable[oVft/sizeof(void *)];
6127 args[argspos++] = (DWORD)pvInstance; /* the This pointer is always the first parameter */
6128 }
6129 else func = (void *)oVft;
6130
6131 for (i = 0; i < cActuals; i++)
6132 {
6133 VARIANT *arg = prgpvarg[i];
6134
6135 switch (prgvt[i])
6136 {
6137 case VT_EMPTY:
6138 break;
6139 case VT_I8:
6140 case VT_UI8:
6141 case VT_R8:
6142 case VT_DATE:
6143 case VT_CY:
6144 memcpy( &args[argspos], &V_I8(arg), sizeof(V_I8(arg)) );
6145 argspos += sizeof(V_I8(arg)) / sizeof(DWORD);
6146 break;
6147 case VT_DECIMAL:
6148 case VT_VARIANT:
6149 memcpy( &args[argspos], arg, sizeof(*arg) );
6150 argspos += sizeof(*arg) / sizeof(DWORD);
6151 break;
6152 case VT_BOOL: /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */
6153 args[argspos++] = V_BOOL(arg);
6154 break;
6155 default:
6156 args[argspos++] = V_UI4(arg);
6157 break;
6158 }
6159 TRACE("arg %u: type %d\n",i,prgvt[i]);
6160 dump_Variant(arg);
6161 }
6162
6163 switch (vtReturn)
6164 {
6165 case VT_EMPTY:
6166 call_method( func, argspos - 1, args + 1, &stack_offset );
6167 break;
6168 case VT_R4:
6169 V_R4(pvargResult) = call_double_method( func, argspos - 1, args + 1, &stack_offset );
6170 break;
6171 case VT_R8:
6172 case VT_DATE:
6173 V_R8(pvargResult) = call_double_method( func, argspos - 1, args + 1, &stack_offset );
6174 break;
6175 case VT_DECIMAL:
6176 case VT_VARIANT:
6177 args[0] = (DWORD)pvargResult; /* arg 0 is a pointer to the result */
6178 call_method( func, argspos, args, &stack_offset );
6179 break;
6180 case VT_I8:
6181 case VT_UI8:
6182 case VT_CY:
6183 V_UI8(pvargResult) = call_method( func, argspos - 1, args + 1, &stack_offset );
6184 break;
6185 default:
6186 V_UI4(pvargResult) = call_method( func, argspos - 1, args + 1, &stack_offset );
6187 break;
6188 }
6189 heap_free( args );
6190 if (stack_offset && cc == CC_STDCALL)
6191 {
6192 WARN( "stack pointer off by %d\n", stack_offset );
6193 return DISP_E_BADCALLEE;
6194 }
6195 if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn;
6196 TRACE("retval: "); dump_Variant(pvargResult);
6197 return S_OK;
6198
6199 #elif defined(__x86_64__)
6200 int argspos;
6201 UINT i;
6202 DWORD_PTR *args;
6203 void *func;
6204
6205 TRACE("(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d))\n",
6206 pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg,
6207 pvargResult, V_VT(pvargResult));
6208
6209 if (cc != CC_STDCALL && cc != CC_CDECL)
6210 {
6211 FIXME("unsupported calling convention %d\n",cc);
6212 return E_INVALIDARG;
6213 }
6214
6215 /* maximum size for an argument is sizeof(DWORD_PTR) */
6216 args = heap_alloc( sizeof(DWORD_PTR) * (cActuals + 2) );
6217
6218 /* start at 1 in case we need to pass a pointer to the return value as arg 0 */
6219 argspos = 1;
6220 if (pvInstance)
6221 {
6222 const FARPROC *vtable = *(FARPROC **)pvInstance;
6223 func = vtable[oVft/sizeof(void *)];
6224 args[argspos++] = (DWORD_PTR)pvInstance; /* the This pointer is always the first parameter */
6225 }
6226 else func = (void *)oVft;
6227
6228 for (i = 0; i < cActuals; i++)
6229 {
6230 VARIANT *arg = prgpvarg[i];
6231
6232 switch (prgvt[i])
6233 {
6234 case VT_DECIMAL:
6235 case VT_VARIANT:
6236 args[argspos++] = (ULONG_PTR)arg;
6237 break;
6238 case VT_BOOL: /* VT_BOOL is 16-bit but BOOL is 32-bit, needs to be extended */
6239 args[argspos++] = V_BOOL(arg);
6240 break;
6241 default:
6242 args[argspos++] = V_UI8(arg);
6243 break;
6244 }
6245 TRACE("arg %u: type %d\n",i,prgvt[i]);
6246 dump_Variant(arg);
6247 }
6248
6249 switch (vtReturn)
6250 {
6251 case VT_R4:
6252 V_R4(pvargResult) = call_double_method( func, argspos - 1, args + 1 );
6253 break;
6254 case VT_R8:
6255 case VT_DATE:
6256 V_R8(pvargResult) = call_double_method( func, argspos - 1, args + 1 );
6257 break;
6258 case VT_DECIMAL:
6259 case VT_VARIANT:
6260 args[0] = (DWORD_PTR)pvargResult; /* arg 0 is a pointer to the result */
6261 call_method( func, argspos, args );
6262 break;
6263 default:
6264 V_UI8(pvargResult) = call_method( func, argspos - 1, args + 1 );
6265 break;
6266 }
6267 heap_free( args );
6268 if (vtReturn != VT_VARIANT) V_VT(pvargResult) = vtReturn;
6269 TRACE("retval: "); dump_Variant(pvargResult);
6270 return S_OK;
6271
6272 #else
6273 FIXME( "(%p, %ld, %d, %d, %d, %p, %p, %p (vt=%d)): not implemented for this CPU\n",
6274 pvInstance, oVft, cc, vtReturn, cActuals, prgvt, prgpvarg, pvargResult, V_VT(pvargResult));
6275 return E_NOTIMPL;
6276 #endif
6277 }
6278
6279 static inline BOOL func_restricted( const FUNCDESC *desc )
6280 {
6281 return (desc->wFuncFlags & FUNCFLAG_FRESTRICTED) && (desc->memid >= 0);
6282 }
6283
6284 #define INVBUF_ELEMENT_SIZE \
6285 (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *) + sizeof(VARTYPE))
6286 #define INVBUF_GET_ARG_ARRAY(buffer, params) (buffer)
6287 #define INVBUF_GET_MISSING_ARG_ARRAY(buffer, params) \
6288 ((VARIANTARG *)((char *)(buffer) + sizeof(VARIANTARG) * (params)))
6289 #define INVBUF_GET_ARG_PTR_ARRAY(buffer, params) \
6290 ((VARIANTARG **)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG)) * (params)))
6291 #define INVBUF_GET_ARG_TYPE_ARRAY(buffer, params) \
6292 ((VARTYPE *)((char *)(buffer) + (sizeof(VARIANTARG) + sizeof(VARIANTARG) + sizeof(VARIANTARG *)) * (params)))
6293
6294 static HRESULT WINAPI ITypeInfo_fnInvoke(
6295 ITypeInfo2 *iface,
6296 VOID *pIUnk,
6297 MEMBERID memid,
6298 UINT16 wFlags,
6299 DISPPARAMS *pDispParams,
6300 VARIANT *pVarResult,
6301 EXCEPINFO *pExcepInfo,
6302 UINT *pArgErr)
6303 {
6304 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6305 int i;
6306 unsigned int var_index;
6307 TYPEKIND type_kind;
6308 HRESULT hres;
6309 const TLBFuncDesc *pFuncInfo;
6310 UINT fdc;
6311
6312 TRACE("(%p)(%p,id=%d,flags=0x%08x,%p,%p,%p,%p)\n",
6313 This,pIUnk,memid,wFlags,pDispParams,pVarResult,pExcepInfo,pArgErr
6314 );
6315
6316 if( This->TypeAttr.wTypeFlags & TYPEFLAG_FRESTRICTED )
6317 return DISP_E_MEMBERNOTFOUND;
6318
6319 if (!pDispParams)
6320 {
6321 ERR("NULL pDispParams not allowed\n");
6322 return E_INVALIDARG;
6323 }
6324
6325 dump_DispParms(pDispParams);
6326
6327 if (pDispParams->cNamedArgs > pDispParams->cArgs)
6328 {
6329 ERR("named argument array cannot be bigger than argument array (%d/%d)\n",
6330 pDispParams->cNamedArgs, pDispParams->cArgs);
6331 return E_INVALIDARG;
6332 }
6333
6334 /* we do this instead of using GetFuncDesc since it will return a fake
6335 * FUNCDESC for dispinterfaces and we want the real function description */
6336 for (fdc = 0; fdc < This->TypeAttr.cFuncs; ++fdc){
6337 pFuncInfo = &This->funcdescs[fdc];
6338 if ((memid == pFuncInfo->funcdesc.memid) &&
6339 (wFlags & pFuncInfo->funcdesc.invkind) &&
6340 !func_restricted( &pFuncInfo->funcdesc ))
6341 break;
6342 }
6343
6344 if (fdc < This->TypeAttr.cFuncs) {
6345 const FUNCDESC *func_desc = &pFuncInfo->funcdesc;
6346
6347 if (TRACE_ON(ole))
6348 {
6349 TRACE("invoking:\n");
6350 dump_TLBFuncDescOne(pFuncInfo);
6351 }
6352
6353 switch (func_desc->funckind) {
6354 case FUNC_PUREVIRTUAL:
6355 case FUNC_VIRTUAL: {
6356 void *buffer = heap_alloc_zero(INVBUF_ELEMENT_SIZE * func_desc->cParams);
6357 VARIANT varresult;
6358 VARIANT retval; /* pointer for storing byref retvals in */
6359 VARIANTARG **prgpvarg = INVBUF_GET_ARG_PTR_ARRAY(buffer, func_desc->cParams);
6360 VARIANTARG *rgvarg = INVBUF_GET_ARG_ARRAY(buffer, func_desc->cParams);
6361 VARTYPE *rgvt = INVBUF_GET_ARG_TYPE_ARRAY(buffer, func_desc->cParams);
6362 UINT cNamedArgs = pDispParams->cNamedArgs;
6363 DISPID *rgdispidNamedArgs = pDispParams->rgdispidNamedArgs;
6364 UINT vargs_converted=0;
6365
6366 hres = S_OK;
6367
6368 if (func_desc->invkind & (INVOKE_PROPERTYPUT|INVOKE_PROPERTYPUTREF))
6369 {
6370 if (!cNamedArgs || (rgdispidNamedArgs[0] != DISPID_PROPERTYPUT))
6371 {
6372 ERR("first named arg for property put invocation must be DISPID_PROPERTYPUT\n");
6373 hres = DISP_E_PARAMNOTFOUND;
6374 goto func_fail;
6375 }
6376 }
6377
6378 if (func_desc->cParamsOpt < 0 && cNamedArgs)
6379 {
6380 ERR("functions with the vararg attribute do not support named arguments\n");
6381 hres = DISP_E_NONAMEDARGS;
6382 goto func_fail;
6383 }
6384
6385 for (i = 0; i < func_desc->cParams; i++)
6386 {
6387 TYPEDESC *tdesc = &func_desc->lprgelemdescParam[i].tdesc;
6388 hres = typedescvt_to_variantvt((ITypeInfo *)iface, tdesc, &rgvt[i]);
6389 if (FAILED(hres))
6390 goto func_fail;
6391 }
6392
6393 TRACE("changing args\n");
6394 for (i = 0; i < func_desc->cParams; i++)
6395 {
6396 USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
6397 TYPEDESC *tdesc = &func_desc->lprgelemdescParam[i].tdesc;
6398 VARIANTARG *src_arg;
6399
6400 if (wParamFlags & PARAMFLAG_FLCID)
6401 {
6402 VARIANTARG *arg;
6403 arg = prgpvarg[i] = &rgvarg[i];
6404 V_VT(arg) = VT_I4;
6405 V_I4(arg) = This->pTypeLib->lcid;
6406 continue;
6407 }
6408
6409 src_arg = NULL;
6410
6411 if (cNamedArgs)
6412 {
6413 USHORT j;
6414 for (j = 0; j < cNamedArgs; j++)
6415 if (rgdispidNamedArgs[j] == i || (i == func_desc->cParams-1 && rgdispidNamedArgs[j] == DISPID_PROPERTYPUT))
6416 {
6417 src_arg = &pDispParams->rgvarg[j];
6418 break;
6419 }
6420 }
6421
6422 if (!src_arg && vargs_converted + cNamedArgs < pDispParams->cArgs)
6423 {
6424 src_arg = &pDispParams->rgvarg[pDispParams->cArgs - 1 - vargs_converted];
6425 vargs_converted++;
6426 }
6427
6428 if (wParamFlags & PARAMFLAG_FRETVAL)
6429 {
6430 /* under most conditions the caller is not allowed to
6431 * pass in a dispparam arg in the index of what would be
6432 * the retval parameter. however, there is an exception
6433 * where the extra parameter is used in an extra
6434 * IDispatch::Invoke below */
6435 if ((i < pDispParams->cArgs) &&
6436 ((func_desc->cParams != 1) || !pVarResult ||
6437 !(func_desc->invkind & INVOKE_PROPERTYGET)))
6438 {
6439 hres = DISP_E_BADPARAMCOUNT;
6440 break;
6441 }
6442
6443 /* note: this check is placed so that if the caller passes
6444 * in a VARIANTARG for the retval we just ignore it, like
6445 * native does */
6446 if (i == func_desc->cParams - 1)
6447 {
6448 VARIANTARG *arg;
6449 arg = prgpvarg[i] = &rgvarg[i];
6450 memset(arg, 0, sizeof(*arg));
6451 V_VT(arg) = rgvt[i];
6452 memset(&retval, 0, sizeof(retval));
6453 V_BYREF(arg) = &retval;
6454 }
6455 else
6456 {
6457 ERR("[retval] parameter must be the last parameter of the method (%d/%d)\n", i, func_desc->cParams);
6458 hres = E_UNEXPECTED;
6459 break;
6460 }
6461 }
6462 else if (src_arg)
6463 {
6464 dump_Variant(src_arg);
6465
6466 if(rgvt[i]!=V_VT(src_arg))
6467 {
6468 if (rgvt[i] == VT_VARIANT)
6469 hres = VariantCopy(&rgvarg[i], src_arg);
6470 else if (rgvt[i] == (VT_VARIANT | VT_BYREF))
6471 {
6472 if (rgvt[i] == V_VT(src_arg))
6473 V_VARIANTREF(&rgvarg[i]) = V_VARIANTREF(src_arg);
6474 else
6475 {
6476 VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
6477 if (wParamFlags & PARAMFLAG_FIN)
6478 hres = VariantCopy(&missing_arg[i], src_arg);
6479 V_VARIANTREF(&rgvarg[i]) = &missing_arg[i];
6480 }
6481 V_VT(&rgvarg[i]) = rgvt[i];
6482 }
6483 else if (rgvt[i] == (VT_VARIANT | VT_ARRAY) && func_desc->cParamsOpt < 0 && i == func_desc->cParams-1)
6484 {
6485 SAFEARRAY *a;
6486 SAFEARRAYBOUND bound;
6487 VARIANT *v;
6488 LONG j;
6489 bound.lLbound = 0;
6490 bound.cElements = pDispParams->cArgs-i;
6491 if (!(a = SafeArrayCreate(VT_VARIANT, 1, &bound)))
6492 {
6493 ERR("SafeArrayCreate failed\n");
6494 break;
6495 }
6496 hres = SafeArrayAccessData(a, (LPVOID)&v);
6497 if (hres != S_OK)
6498 {
6499 ERR("SafeArrayAccessData failed with %x\n", hres);
6500 SafeArrayDestroy(a);
6501 break;
6502 }
6503 for (j = 0; j < bound.cElements; j++)
6504 VariantCopy(&v[j], &pDispParams->rgvarg[pDispParams->cArgs - 1 - i - j]);
6505 hres = SafeArrayUnaccessData(a);
6506 if (hres != S_OK)
6507 {
6508 ERR("SafeArrayUnaccessData failed with %x\n", hres);
6509 SafeArrayDestroy(a);
6510 break;
6511 }
6512 V_ARRAY(&rgvarg[i]) = a;
6513 V_VT(&rgvarg[i]) = rgvt[i];
6514 }
6515 else if ((rgvt[i] & VT_BYREF) && !V_ISBYREF(src_arg))
6516 {
6517 VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
6518 if (wParamFlags & PARAMFLAG_FIN)
6519 hres = VariantChangeType(&missing_arg[i], src_arg, 0, rgvt[i] & ~VT_BYREF);
6520 else
6521 V_VT(&missing_arg[i]) = rgvt[i] & ~VT_BYREF;
6522 V_BYREF(&rgvarg[i]) = &V_NONE(&missing_arg[i]);
6523 V_VT(&rgvarg[i]) = rgvt[i];
6524 }
6525 else if ((rgvt[i] & VT_BYREF) && (rgvt[i] == V_VT(src_arg)))
6526 {
6527 V_BYREF(&rgvarg[i]) = V_BYREF(src_arg);
6528 V_VT(&rgvarg[i]) = rgvt[i];
6529 }
6530 else
6531 {
6532 /* FIXME: this doesn't work for VT_BYREF arguments if
6533 * they are not the same type as in the paramdesc */
6534 V_VT(&rgvarg[i]) = V_VT(src_arg);
6535 hres = VariantChangeType(&rgvarg[i], src_arg, 0, rgvt[i]);
6536 V_VT(&rgvarg[i]) = rgvt[i];
6537 }
6538
6539 if (FAILED(hres))
6540 {
6541 ERR("failed to convert param %d to %s%s from %s%s\n", i,
6542 debugstr_vt(rgvt[i]), debugstr_vf(rgvt[i]),
6543 debugstr_VT(src_arg), debugstr_VF(src_arg));
6544 break;
6545 }
6546 prgpvarg[i] = &rgvarg[i];
6547 }
6548 else
6549 {
6550 prgpvarg[i] = src_arg;
6551 }
6552
6553 if((tdesc->vt == VT_USERDEFINED || (tdesc->vt == VT_PTR && tdesc->u.lptdesc->vt == VT_USERDEFINED))
6554 && (V_VT(prgpvarg[i]) == VT_DISPATCH || V_VT(prgpvarg[i]) == VT_UNKNOWN)
6555 && V_UNKNOWN(prgpvarg[i])) {
6556 IUnknown *userdefined_iface;
6557 GUID guid;
6558
6559 hres = get_iface_guid((ITypeInfo*)iface, tdesc->vt == VT_PTR ? tdesc->u.lptdesc : tdesc, &guid);
6560 if(FAILED(hres))
6561 break;
6562
6563 hres = IUnknown_QueryInterface(V_UNKNOWN(prgpvarg[i]), &guid, (void**)&userdefined_iface);
6564 if(FAILED(hres)) {
6565 ERR("argument does not support %s interface\n", debugstr_guid(&guid));
6566 break;
6567 }
6568
6569 IUnknown_Release(V_UNKNOWN(prgpvarg[i]));
6570 V_UNKNOWN(prgpvarg[i]) = userdefined_iface;
6571 }
6572 }
6573 else if (wParamFlags & PARAMFLAG_FOPT)
6574 {
6575 VARIANTARG *arg;
6576 arg = prgpvarg[i] = &rgvarg[i];
6577 if (wParamFlags & PARAMFLAG_FHASDEFAULT)
6578 {
6579 hres = VariantCopy(arg, &func_desc->lprgelemdescParam[i].u.paramdesc.pparamdescex->varDefaultValue);
6580 if (FAILED(hres))
6581 break;
6582 }
6583 else
6584 {
6585 VARIANTARG *missing_arg;
6586 /* if the function wants a pointer to a variant then
6587 * set that up, otherwise just pass the VT_ERROR in
6588 * the argument by value */
6589 if (rgvt[i] & VT_BYREF)
6590 {
6591 missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams) + i;
6592 V_VT(arg) = VT_VARIANT | VT_BYREF;
6593 V_VARIANTREF(arg) = missing_arg;
6594 }
6595 else
6596 missing_arg = arg;
6597 V_VT(missing_arg) = VT_ERROR;
6598 V_ERROR(missing_arg) = DISP_E_PARAMNOTFOUND;
6599 }
6600 }
6601 else
6602 {
6603 hres = DISP_E_BADPARAMCOUNT;
6604 break;
6605 }
6606 }
6607 if (FAILED(hres)) goto func_fail; /* FIXME: we don't free changed types here */
6608
6609 /* VT_VOID is a special case for return types, so it is not
6610 * handled in the general function */
6611 if (func_desc->elemdescFunc.tdesc.vt == VT_VOID)
6612 V_VT(&varresult) = VT_EMPTY;
6613 else
6614 {
6615 V_VT(&varresult) = 0;
6616 hres = typedescvt_to_variantvt((ITypeInfo *)iface, &func_desc->elemdescFunc.tdesc, &V_VT(&varresult));
6617 if (FAILED(hres)) goto func_fail; /* FIXME: we don't free changed types here */
6618 }
6619
6620 hres = DispCallFunc(pIUnk, func_desc->oVft, func_desc->callconv,
6621 V_VT(&varresult), func_desc->cParams, rgvt,
6622 prgpvarg, &varresult);
6623
6624 vargs_converted = 0;
6625
6626 for (i = 0; i < func_desc->cParams; i++)
6627 {
6628 USHORT wParamFlags = func_desc->lprgelemdescParam[i].u.paramdesc.wParamFlags;
6629 VARIANTARG *missing_arg = INVBUF_GET_MISSING_ARG_ARRAY(buffer, func_desc->cParams);
6630
6631 if (wParamFlags & PARAMFLAG_FLCID)
6632 continue;
6633 else if (wParamFlags & PARAMFLAG_FRETVAL)
6634 {
6635 if (TRACE_ON(ole))
6636 {
6637 TRACE("[retval] value: ");
6638 dump_Variant(prgpvarg[i]);
6639 }
6640
6641 if (pVarResult)
6642 {
6643 VariantInit(pVarResult);
6644 /* deref return value */
6645 hres = VariantCopyInd(pVarResult, prgpvarg[i]);
6646 }
6647
6648 VARIANT_ClearInd(prgpvarg[i]);
6649 }
6650 else if (vargs_converted < pDispParams->cArgs)
6651 {
6652 VARIANTARG *arg = &pDispParams->rgvarg[pDispParams->cArgs - 1 - vargs_converted];
6653 if (wParamFlags & PARAMFLAG_FOUT)
6654 {
6655 if ((rgvt[i] & VT_BYREF) && !(V_VT(arg) & VT_BYREF))
6656 {
6657 hres = VariantChangeType(arg, &rgvarg[i], 0, V_VT(arg));
6658
6659 if (FAILED(hres))
6660 {
6661 ERR("failed to convert param %d to vt %d\n", i,
6662 V_VT(&pDispParams->rgvarg[pDispParams->cArgs - 1 - vargs_converted]));
6663 break;
6664 }
6665 }
6666 }
6667 else if (V_VT(prgpvarg[i]) == (VT_VARIANT | VT_ARRAY) &&
6668 func_desc->cParamsOpt < 0 &&
6669 i == func_desc->cParams-1)
6670 {
6671 SAFEARRAY *a = V_ARRAY(prgpvarg[i]);
6672 LONG j, ubound;
6673 VARIANT *v;
6674 hres = SafeArrayGetUBound(a, 1, &ubound);
6675 if (hres != S_OK)
6676 {
6677 ERR("SafeArrayGetUBound failed with %x\n", hres);
6678 break;
6679 }
6680 hres = SafeArrayAccessData(a, (LPVOID)&v);
6681 if (hres != S_OK)
6682 {
6683 ERR("SafeArrayAccessData failed with %x\n", hres);
6684 break;
6685 }
6686 for (j = 0; j <= ubound; j++)
6687 VariantClear(&v[j]);
6688 hres = SafeArrayUnaccessData(a);
6689 if (hres != S_OK)
6690 {
6691 ERR("SafeArrayUnaccessData failed with %x\n", hres);
6692 break;
6693 }
6694 }
6695 VariantClear(&rgvarg[i]);
6696 vargs_converted++;
6697 }
6698 else if (wParamFlags & PARAMFLAG_FOPT)
6699 {
6700 if (wParamFlags & PARAMFLAG_FHASDEFAULT)
6701 VariantClear(&rgvarg[i]);
6702 }
6703
6704 VariantClear(&missing_arg[i]);
6705 }
6706
6707 if ((V_VT(&varresult) == VT_ERROR) && FAILED(V_ERROR(&varresult)))
6708 {
6709 WARN("invoked function failed with error 0x%08x\n", V_ERROR(&varresult));
6710 hres = DISP_E_EXCEPTION;
6711 if (pExcepInfo)
6712 {
6713 IErrorInfo *pErrorInfo;
6714 pExcepInfo->scode = V_ERROR(&varresult);
6715 if (GetErrorInfo(0, &pErrorInfo) == S_OK)
6716 {
6717 IErrorInfo_GetDescription(pErrorInfo, &pExcepInfo->bstrDescription);
6718 IErrorInfo_GetHelpFile(pErrorInfo, &pExcepInfo->bstrHelpFile);
6719 IErrorInfo_GetSource(pErrorInfo, &pExcepInfo->bstrSource);
6720 IErrorInfo_GetHelpContext(pErrorInfo, &pExcepInfo->dwHelpContext);
6721
6722 IErrorInfo_Release(pErrorInfo);
6723 }
6724 }
6725 }
6726 if (V_VT(&varresult) != VT_ERROR)
6727 {
6728 TRACE("varresult value: ");
6729 dump_Variant(&varresult);
6730
6731 if (pVarResult)
6732 {
6733 VariantClear(pVarResult);
6734 *pVarResult = varresult;
6735 }
6736 else
6737 VariantClear(&varresult);
6738 }
6739
6740 if (SUCCEEDED(hres) && pVarResult && (func_desc->cParams == 1) &&
6741 (func_desc->invkind & INVOKE_PROPERTYGET) &&
6742 (func_desc->lprgelemdescParam[0].u.paramdesc.wParamFlags & PARAMFLAG_FRETVAL) &&
6743 (pDispParams->cArgs != 0))
6744 {
6745 if (V_VT(pVarResult) == VT_DISPATCH)
6746 {
6747 IDispatch *pDispatch = V_DISPATCH(pVarResult);
6748 /* Note: not VariantClear; we still need the dispatch
6749 * pointer to be valid */
6750 VariantInit(pVarResult);
6751 hres = IDispatch_Invoke(pDispatch, DISPID_VALUE, &IID_NULL,
6752 GetSystemDefaultLCID(), INVOKE_PROPERTYGET,
6753 pDispParams, pVarResult, pExcepInfo, pArgErr);
6754 IDispatch_Release(pDispatch);
6755 }
6756 else
6757 {
6758 VariantClear(pVarResult);
6759 hres = DISP_E_NOTACOLLECTION;
6760 }
6761 }
6762
6763 func_fail:
6764 heap_free(buffer);
6765 break;
6766 }
6767 case FUNC_DISPATCH: {
6768 IDispatch *disp;
6769
6770 hres = IUnknown_QueryInterface((LPUNKNOWN)pIUnk,&IID_IDispatch,(LPVOID*)&disp);
6771 if (SUCCEEDED(hres)) {
6772 FIXME("Calling Invoke in IDispatch iface. untested!\n");
6773 hres = IDispatch_Invoke(
6774 disp,memid,&IID_NULL,LOCALE_USER_DEFAULT,wFlags,pDispParams,
6775 pVarResult,pExcepInfo,pArgErr
6776 );
6777 if (FAILED(hres))
6778 FIXME("IDispatch::Invoke failed with %08x. (Could be not a real error?)\n", hres);
6779 IDispatch_Release(disp);
6780 } else
6781 FIXME("FUNC_DISPATCH used on object without IDispatch iface?\n");
6782 break;
6783 }
6784 default:
6785 FIXME("Unknown function invocation type %d\n", func_desc->funckind);
6786 hres = E_FAIL;
6787 break;
6788 }
6789
6790 TRACE("-- 0x%08x\n", hres);
6791 return hres;
6792
6793 } else if(SUCCEEDED(hres = ITypeInfo2_GetVarIndexOfMemId(iface, memid, &var_index))) {
6794 VARDESC *var_desc;
6795
6796 hres = ITypeInfo2_GetVarDesc(iface, var_index, &var_desc);
6797 if(FAILED(hres)) return hres;
6798
6799 FIXME("varseek: Found memid, but variable-based invoking not supported\n");
6800 dump_VARDESC(var_desc);
6801 ITypeInfo2_ReleaseVarDesc(iface, var_desc);
6802 return E_NOTIMPL;
6803 }
6804
6805 /* not found, look for it in inherited interfaces */
6806 ITypeInfo2_GetTypeKind(iface, &type_kind);
6807 if(type_kind == TKIND_INTERFACE || type_kind == TKIND_DISPATCH) {
6808 if(This->impltypes) {
6809 /* recursive search */
6810 ITypeInfo *pTInfo;
6811 hres = ITypeInfo2_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pTInfo);
6812 if(SUCCEEDED(hres)){
6813 hres = ITypeInfo_Invoke(pTInfo,pIUnk,memid,wFlags,pDispParams,pVarResult,pExcepInfo,pArgErr);
6814 ITypeInfo_Release(pTInfo);
6815 return hres;
6816 }
6817 WARN("Could not search inherited interface!\n");
6818 }
6819 }
6820 WARN("did not find member id %d, flags 0x%x!\n", memid, wFlags);
6821 return DISP_E_MEMBERNOTFOUND;
6822 }
6823
6824 /* ITypeInfo::GetDocumentation
6825 *
6826 * Retrieves the documentation string, the complete Help file name and path,
6827 * and the context ID for the Help topic for a specified type description.
6828 *
6829 * (Can be tested by the Visual Basic Editor in Word for instance.)
6830 */
6831 static HRESULT WINAPI ITypeInfo_fnGetDocumentation( ITypeInfo2 *iface,
6832 MEMBERID memid, BSTR *pBstrName, BSTR *pBstrDocString,
6833 DWORD *pdwHelpContext, BSTR *pBstrHelpFile)
6834 {
6835 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6836 const TLBFuncDesc *pFDesc;
6837 const TLBVarDesc *pVDesc;
6838 TRACE("(%p) memid %d Name(%p) DocString(%p)"
6839 " HelpContext(%p) HelpFile(%p)\n",
6840 This, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
6841 if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
6842 if(pBstrName)
6843 *pBstrName=SysAllocString(This->Name);
6844 if(pBstrDocString)
6845 *pBstrDocString=SysAllocString(This->DocString);
6846 if(pdwHelpContext)
6847 *pdwHelpContext=This->dwHelpContext;
6848 if(pBstrHelpFile)
6849 *pBstrHelpFile=SysAllocString(This->DocString);/* FIXME */
6850 return S_OK;
6851 }else {/* for a member */
6852 pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->TypeAttr.cFuncs, memid);
6853 if(pFDesc){
6854 if(pBstrName)
6855 *pBstrName = SysAllocString(pFDesc->Name);
6856 if(pBstrDocString)
6857 *pBstrDocString=SysAllocString(pFDesc->HelpString);
6858 if(pdwHelpContext)
6859 *pdwHelpContext=pFDesc->helpcontext;
6860 return S_OK;
6861 }
6862 pVDesc = TLB_get_vardesc_by_memberid(This->vardescs, This->TypeAttr.cVars, memid);
6863 if(pVDesc){
6864 if(pBstrName)
6865 *pBstrName = SysAllocString(pVDesc->Name);
6866 if(pBstrDocString)
6867 *pBstrDocString=SysAllocString(pVDesc->HelpString);
6868 if(pdwHelpContext)
6869 *pdwHelpContext=pVDesc->HelpContext;
6870 return S_OK;
6871 }
6872 }
6873
6874 if(This->impltypes &&
6875 (This->TypeAttr.typekind==TKIND_INTERFACE || This->TypeAttr.typekind==TKIND_DISPATCH)) {
6876 /* recursive search */
6877 ITypeInfo *pTInfo;
6878 HRESULT result;
6879 result = ITypeInfo2_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pTInfo);
6880 if(SUCCEEDED(result)) {
6881 result = ITypeInfo_GetDocumentation(pTInfo, memid, pBstrName,
6882 pBstrDocString, pdwHelpContext, pBstrHelpFile);
6883 ITypeInfo_Release(pTInfo);
6884 return result;
6885 }
6886 WARN("Could not search inherited interface!\n");
6887 }
6888
6889 WARN("member %d not found\n", memid);
6890 return TYPE_E_ELEMENTNOTFOUND;
6891 }
6892
6893 /* ITypeInfo::GetDllEntry
6894 *
6895 * Retrieves a description or specification of an entry point for a function
6896 * in a DLL.
6897 */
6898 static HRESULT WINAPI ITypeInfo_fnGetDllEntry( ITypeInfo2 *iface, MEMBERID memid,
6899 INVOKEKIND invKind, BSTR *pBstrDllName, BSTR *pBstrName,
6900 WORD *pwOrdinal)
6901 {
6902 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6903 const TLBFuncDesc *pFDesc;
6904
6905 TRACE("(%p)->(memid %x, %d, %p, %p, %p)\n", This, memid, invKind, pBstrDllName, pBstrName, pwOrdinal);
6906
6907 if (pBstrDllName) *pBstrDllName = NULL;
6908 if (pBstrName) *pBstrName = NULL;
6909 if (pwOrdinal) *pwOrdinal = 0;
6910
6911 if (This->TypeAttr.typekind != TKIND_MODULE)
6912 return TYPE_E_BADMODULEKIND;
6913
6914 pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->TypeAttr.cFuncs, memid);
6915 if(pFDesc){
6916 dump_TypeInfo(This);
6917 if (TRACE_ON(ole))
6918 dump_TLBFuncDescOne(pFDesc);
6919
6920 if (pBstrDllName)
6921 *pBstrDllName = SysAllocString(This->DllName);
6922
6923 if (!IS_INTRESOURCE(pFDesc->Entry) && (pFDesc->Entry != (void*)-1)) {
6924 if (pBstrName)
6925 *pBstrName = SysAllocString(pFDesc->Entry);
6926 if (pwOrdinal)
6927 *pwOrdinal = -1;
6928 return S_OK;
6929 }
6930 if (pBstrName)
6931 *pBstrName = NULL;
6932 if (pwOrdinal)
6933 *pwOrdinal = LOWORD(pFDesc->Entry);
6934 return S_OK;
6935 }
6936 return TYPE_E_ELEMENTNOTFOUND;
6937 }
6938
6939 /* internal function to make the inherited interfaces' methods appear
6940 * part of the interface */
6941 static HRESULT ITypeInfoImpl_GetDispatchRefTypeInfo( ITypeInfo *iface,
6942 HREFTYPE *hRefType, ITypeInfo **ppTInfo)
6943 {
6944 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6945 HRESULT hr;
6946
6947 TRACE("%p, 0x%x\n", iface, *hRefType);
6948
6949 if (This->impltypes && (*hRefType & DISPATCH_HREF_MASK))
6950 {
6951 ITypeInfo *pSubTypeInfo;
6952
6953 hr = ITypeInfo_GetRefTypeInfo(iface, This->impltypes[0].hRef, &pSubTypeInfo);
6954 if (FAILED(hr))
6955 return hr;
6956
6957 hr = ITypeInfoImpl_GetDispatchRefTypeInfo(pSubTypeInfo,
6958 hRefType, ppTInfo);
6959 ITypeInfo_Release(pSubTypeInfo);
6960 if (SUCCEEDED(hr))
6961 return hr;
6962 }
6963 *hRefType -= DISPATCH_HREF_OFFSET;
6964
6965 if (!(*hRefType & DISPATCH_HREF_MASK))
6966 return ITypeInfo_GetRefTypeInfo(iface, *hRefType, ppTInfo);
6967 else
6968 return E_FAIL;
6969 }
6970
6971 /* ITypeInfo::GetRefTypeInfo
6972 *
6973 * If a type description references other type descriptions, it retrieves
6974 * the referenced type descriptions.
6975 */
6976 static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo(
6977 ITypeInfo2 *iface,
6978 HREFTYPE hRefType,
6979 ITypeInfo **ppTInfo)
6980 {
6981 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
6982 HRESULT result = E_FAIL;
6983
6984 if ((This->hreftype != -1) && (This->hreftype == hRefType))
6985 {
6986 *ppTInfo = (ITypeInfo *)&This->lpVtbl;
6987 ITypeInfo_AddRef(*ppTInfo);
6988 result = S_OK;
6989 }
6990 else if (hRefType == -1 &&
6991 (This->TypeAttr.typekind == TKIND_DISPATCH) &&
6992 (This->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL))
6993 {
6994 /* when we meet a DUAL dispinterface, we must create the interface
6995 * version of it.
6996 */
6997 ITypeInfoImpl *pTypeInfoImpl = ITypeInfoImpl_Constructor();
6998
6999
7000 /* the interface version contains the same information as the dispinterface
7001 * copy the contents of the structs.
7002 */
7003 *pTypeInfoImpl = *This;
7004 pTypeInfoImpl->ref = 0;
7005
7006 /* change the type to interface */
7007 pTypeInfoImpl->TypeAttr.typekind = TKIND_INTERFACE;
7008
7009 *ppTInfo = (ITypeInfo*) pTypeInfoImpl;
7010
7011 /* the AddRef implicitly adds a reference to the parent typelib, which
7012 * stops the copied data from being destroyed until the new typeinfo's
7013 * refcount goes to zero, but we need to signal to the new instance to
7014 * not free its data structures when it is destroyed */
7015 pTypeInfoImpl->not_attached_to_typelib = TRUE;
7016
7017 ITypeInfo_AddRef(*ppTInfo);
7018
7019 result = S_OK;
7020
7021 } else if ((hRefType != -1) && (hRefType & DISPATCH_HREF_MASK) &&
7022 (This->TypeAttr.typekind == TKIND_DISPATCH))
7023 {
7024 HREFTYPE href_dispatch = hRefType;
7025 result = ITypeInfoImpl_GetDispatchRefTypeInfo((ITypeInfo *)iface, &href_dispatch, ppTInfo);
7026 } else {
7027 TLBRefType *ref_type;
7028 LIST_FOR_EACH_ENTRY(ref_type, &This->pTypeLib->ref_list, TLBRefType, entry)
7029 {
7030 if(ref_type->reference == hRefType)
7031 break;
7032 }
7033 if(&ref_type->entry == &This->pTypeLib->ref_list)
7034 {
7035 FIXME("Can't find pRefType for ref %x\n", hRefType);
7036 goto end;
7037 }
7038 if(hRefType != -1) {
7039 ITypeLib *pTLib = NULL;
7040
7041 if(ref_type->pImpTLInfo == TLB_REF_INTERNAL) {
7042 UINT Index;
7043 result = ITypeInfo2_GetContainingTypeLib(iface, &pTLib, &Index);
7044 } else {
7045 if(ref_type->pImpTLInfo->pImpTypeLib) {
7046 TRACE("typeinfo in imported typelib that is already loaded\n");
7047 pTLib = (ITypeLib*)ref_type->pImpTLInfo->pImpTypeLib;
7048 ITypeLib_AddRef(pTLib);
7049 result = S_OK;
7050 } else {
7051 TRACE("typeinfo in imported typelib that isn't already loaded\n");
7052 result = LoadRegTypeLib( &ref_type->pImpTLInfo->guid,
7053 ref_type->pImpTLInfo->wVersionMajor,
7054 ref_type->pImpTLInfo->wVersionMinor,
7055 ref_type->pImpTLInfo->lcid,
7056 &pTLib);
7057
7058 if(FAILED(result)) {
7059 BSTR libnam=SysAllocString(ref_type->pImpTLInfo->name);
7060 result=LoadTypeLib(libnam, &pTLib);
7061 SysFreeString(libnam);
7062 }
7063 if(SUCCEEDED(result)) {
7064 ref_type->pImpTLInfo->pImpTypeLib = (ITypeLibImpl*)pTLib;
7065 ITypeLib_AddRef(pTLib);
7066 }
7067 }
7068 }
7069 if(SUCCEEDED(result)) {
7070 if(ref_type->index == TLB_REF_USE_GUID)
7071 result = ITypeLib_GetTypeInfoOfGuid(pTLib, &ref_type->guid, ppTInfo);
7072 else
7073 result = ITypeLib_GetTypeInfo(pTLib, ref_type->index, ppTInfo);
7074 }
7075 if (pTLib != NULL)
7076 ITypeLib_Release(pTLib);
7077 }
7078 }
7079
7080 end:
7081 TRACE("(%p) hreftype 0x%04x loaded %s (%p)\n", This, hRefType,
7082 SUCCEEDED(result)? "SUCCESS":"FAILURE", *ppTInfo);
7083 return result;
7084 }
7085
7086 /* ITypeInfo::AddressOfMember
7087 *
7088 * Retrieves the addresses of static functions or variables, such as those
7089 * defined in a DLL.
7090 */
7091 static HRESULT WINAPI ITypeInfo_fnAddressOfMember( ITypeInfo2 *iface,
7092 MEMBERID memid, INVOKEKIND invKind, PVOID *ppv)
7093 {
7094 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7095 HRESULT hr;
7096 BSTR dll, entry;
7097 WORD ordinal;
7098 HMODULE module;
7099
7100 TRACE("(%p)->(0x%x, 0x%x, %p)\n", This, memid, invKind, ppv);
7101
7102 hr = ITypeInfo2_GetDllEntry(iface, memid, invKind, &dll, &entry, &ordinal);
7103 if (FAILED(hr))
7104 return hr;
7105
7106 module = LoadLibraryW(dll);
7107 if (!module)
7108 {
7109 ERR("couldn't load %s\n", debugstr_w(dll));
7110 SysFreeString(dll);
7111 SysFreeString(entry);
7112 return STG_E_FILENOTFOUND;
7113 }
7114 /* FIXME: store library somewhere where we can free it */
7115
7116 if (entry)
7117 {
7118 LPSTR entryA;
7119 INT len = WideCharToMultiByte(CP_ACP, 0, entry, -1, NULL, 0, NULL, NULL);
7120 entryA = heap_alloc(len);
7121 WideCharToMultiByte(CP_ACP, 0, entry, -1, entryA, len, NULL, NULL);
7122
7123 *ppv = GetProcAddress(module, entryA);
7124 if (!*ppv)
7125 ERR("function not found %s\n", debugstr_a(entryA));
7126
7127 heap_free(entryA);
7128 }
7129 else
7130 {
7131 *ppv = GetProcAddress(module, MAKEINTRESOURCEA(ordinal));
7132 if (!*ppv)
7133 ERR("function not found %d\n", ordinal);
7134 }
7135
7136 SysFreeString(dll);
7137 SysFreeString(entry);
7138
7139 if (!*ppv)
7140 return TYPE_E_DLLFUNCTIONNOTFOUND;
7141
7142 return S_OK;
7143 }
7144
7145 /* ITypeInfo::CreateInstance
7146 *
7147 * Creates a new instance of a type that describes a component object class
7148 * (coclass).
7149 */
7150 static HRESULT WINAPI ITypeInfo_fnCreateInstance( ITypeInfo2 *iface,
7151 IUnknown *pOuterUnk, REFIID riid, VOID **ppvObj)
7152 {
7153 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7154 HRESULT hr;
7155 TYPEATTR *pTA;
7156
7157 TRACE("(%p)->(%p, %s, %p)\n", This, pOuterUnk, debugstr_guid(riid), ppvObj);
7158
7159 *ppvObj = NULL;
7160
7161 if(pOuterUnk)
7162 {
7163 WARN("Not able to aggregate\n");
7164 return CLASS_E_NOAGGREGATION;
7165 }
7166
7167 hr = ITypeInfo2_GetTypeAttr(iface, &pTA);
7168 if(FAILED(hr)) return hr;
7169
7170 if(pTA->typekind != TKIND_COCLASS)
7171 {
7172 WARN("CreateInstance on typeinfo of type %x\n", pTA->typekind);
7173 hr = E_INVALIDARG;
7174 goto end;
7175 }
7176
7177 hr = S_FALSE;
7178 if(pTA->wTypeFlags & TYPEFLAG_FAPPOBJECT)
7179 {
7180 IUnknown *pUnk;
7181 hr = GetActiveObject(&pTA->guid, NULL, &pUnk);
7182 TRACE("GetActiveObject rets %08x\n", hr);
7183 if(hr == S_OK)
7184 {
7185 hr = IUnknown_QueryInterface(pUnk, riid, ppvObj);
7186 IUnknown_Release(pUnk);
7187 }
7188 }
7189
7190 if(hr != S_OK)
7191 hr = CoCreateInstance(&pTA->guid, NULL,
7192 CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
7193 riid, ppvObj);
7194
7195 end:
7196 ITypeInfo2_ReleaseTypeAttr(iface, pTA);
7197 return hr;
7198 }
7199
7200 /* ITypeInfo::GetMops
7201 *
7202 * Retrieves marshalling information.
7203 */
7204 static HRESULT WINAPI ITypeInfo_fnGetMops( ITypeInfo2 *iface, MEMBERID memid,
7205 BSTR *pBstrMops)
7206 {
7207 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7208 FIXME("(%p %d) stub!\n", This, memid);
7209 *pBstrMops = NULL;
7210 return S_OK;
7211 }
7212
7213 /* ITypeInfo::GetContainingTypeLib
7214 *
7215 * Retrieves the containing type library and the index of the type description
7216 * within that type library.
7217 */
7218 static HRESULT WINAPI ITypeInfo_fnGetContainingTypeLib( ITypeInfo2 *iface,
7219 ITypeLib * *ppTLib, UINT *pIndex)
7220 {
7221 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7222
7223 /* If a pointer is null, we simply ignore it, the ATL in particular passes pIndex as 0 */
7224 if (pIndex) {
7225 *pIndex=This->index;
7226 TRACE("returning pIndex=%d\n", *pIndex);
7227 }
7228
7229 if (ppTLib) {
7230 *ppTLib=(LPTYPELIB )(This->pTypeLib);
7231 ITypeLib_AddRef(*ppTLib);
7232 TRACE("returning ppTLib=%p\n", *ppTLib);
7233 }
7234
7235 return S_OK;
7236 }
7237
7238 /* ITypeInfo::ReleaseTypeAttr
7239 *
7240 * Releases a TYPEATTR previously returned by GetTypeAttr.
7241 *
7242 */
7243 static void WINAPI ITypeInfo_fnReleaseTypeAttr( ITypeInfo2 *iface,
7244 TYPEATTR* pTypeAttr)
7245 {
7246 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7247 TRACE("(%p)->(%p)\n", This, pTypeAttr);
7248 heap_free(pTypeAttr);
7249 }
7250
7251 /* ITypeInfo::ReleaseFuncDesc
7252 *
7253 * Releases a FUNCDESC previously returned by GetFuncDesc. *
7254 */
7255 static void WINAPI ITypeInfo_fnReleaseFuncDesc(
7256 ITypeInfo2 *iface,
7257 FUNCDESC *pFuncDesc)
7258 {
7259 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7260 SHORT i;
7261
7262 TRACE("(%p)->(%p)\n", This, pFuncDesc);
7263
7264 for (i = 0; i < pFuncDesc->cParams; i++)
7265 TLB_FreeElemDesc(&pFuncDesc->lprgelemdescParam[i]);
7266 TLB_FreeElemDesc(&pFuncDesc->elemdescFunc);
7267
7268 SysFreeString((BSTR)pFuncDesc);
7269 }
7270
7271 /* ITypeInfo::ReleaseVarDesc
7272 *
7273 * Releases a VARDESC previously returned by GetVarDesc.
7274 */
7275 static void WINAPI ITypeInfo_fnReleaseVarDesc( ITypeInfo2 *iface,
7276 VARDESC *pVarDesc)
7277 {
7278 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7279 TRACE("(%p)->(%p)\n", This, pVarDesc);
7280
7281 TLB_FreeElemDesc(&pVarDesc->elemdescVar);
7282 if (pVarDesc->varkind == VAR_CONST)
7283 VariantClear(pVarDesc->u.lpvarValue);
7284 SysFreeString((BSTR)pVarDesc);
7285 }
7286
7287 /* ITypeInfo2::GetTypeKind
7288 *
7289 * Returns the TYPEKIND enumeration quickly, without doing any allocations.
7290 *
7291 */
7292 static HRESULT WINAPI ITypeInfo2_fnGetTypeKind( ITypeInfo2 * iface,
7293 TYPEKIND *pTypeKind)
7294 {
7295 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7296 *pTypeKind=This->TypeAttr.typekind;
7297 TRACE("(%p) type 0x%0x\n", This,*pTypeKind);
7298 return S_OK;
7299 }
7300
7301 /* ITypeInfo2::GetTypeFlags
7302 *
7303 * Returns the type flags without any allocations. This returns a DWORD type
7304 * flag, which expands the type flags without growing the TYPEATTR (type
7305 * attribute).
7306 *
7307 */
7308 static HRESULT WINAPI ITypeInfo2_fnGetTypeFlags( ITypeInfo2 *iface, ULONG *pTypeFlags)
7309 {
7310 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7311 *pTypeFlags=This->TypeAttr.wTypeFlags;
7312 TRACE("(%p) flags 0x%x\n", This,*pTypeFlags);
7313 return S_OK;
7314 }
7315
7316 /* ITypeInfo2::GetFuncIndexOfMemId
7317 * Binds to a specific member based on a known DISPID, where the member name
7318 * is not known (for example, when binding to a default member).
7319 *
7320 */
7321 static HRESULT WINAPI ITypeInfo2_fnGetFuncIndexOfMemId( ITypeInfo2 * iface,
7322 MEMBERID memid, INVOKEKIND invKind, UINT *pFuncIndex)
7323 {
7324 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7325 UINT fdc;
7326 HRESULT result;
7327
7328 for (fdc = 0; fdc < This->TypeAttr.cFuncs; ++fdc){
7329 const TLBFuncDesc *pFuncInfo = &This->funcdescs[fdc];
7330 if(memid == pFuncInfo->funcdesc.memid && (invKind & pFuncInfo->funcdesc.invkind))
7331 break;
7332 }
7333 if(fdc < This->TypeAttr.cFuncs) {
7334 *pFuncIndex = fdc;
7335 result = S_OK;
7336 } else
7337 result = TYPE_E_ELEMENTNOTFOUND;
7338
7339 TRACE("(%p) memid 0x%08x invKind 0x%04x -> %s\n", This,
7340 memid, invKind, SUCCEEDED(result) ? "SUCCESS" : "FAILED");
7341 return result;
7342 }
7343
7344 /* TypeInfo2::GetVarIndexOfMemId
7345 *
7346 * Binds to a specific member based on a known DISPID, where the member name
7347 * is not known (for example, when binding to a default member).
7348 *
7349 */
7350 static HRESULT WINAPI ITypeInfo2_fnGetVarIndexOfMemId( ITypeInfo2 * iface,
7351 MEMBERID memid, UINT *pVarIndex)
7352 {
7353 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7354 TLBVarDesc *pVarInfo;
7355
7356 TRACE("%p %d %p\n", iface, memid, pVarIndex);
7357
7358 pVarInfo = TLB_get_vardesc_by_memberid(This->vardescs, This->TypeAttr.cVars, memid);
7359 if(!pVarInfo)
7360 return TYPE_E_ELEMENTNOTFOUND;
7361
7362 *pVarIndex = (pVarInfo - This->vardescs);
7363
7364 return S_OK;
7365 }
7366
7367 /* ITypeInfo2::GetCustData
7368 *
7369 * Gets the custom data
7370 */
7371 static HRESULT WINAPI ITypeInfo2_fnGetCustData(
7372 ITypeInfo2 * iface,
7373 REFGUID guid,
7374 VARIANT *pVarVal)
7375 {
7376 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7377 TLBCustData *pCData;
7378
7379 TRACE("%p %s %p\n", This, debugstr_guid(guid), pVarVal);
7380
7381 pCData = TLB_get_custdata_by_guid(&This->custdata_list, guid);
7382
7383 VariantInit( pVarVal);
7384 if (pCData)
7385 VariantCopy( pVarVal, &pCData->data);
7386 else
7387 VariantClear( pVarVal );
7388 return S_OK;
7389 }
7390
7391 /* ITypeInfo2::GetFuncCustData
7392 *
7393 * Gets the custom data
7394 */
7395 static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData(
7396 ITypeInfo2 * iface,
7397 UINT index,
7398 REFGUID guid,
7399 VARIANT *pVarVal)
7400 {
7401 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7402 TLBCustData *pCData;
7403 TLBFuncDesc *pFDesc = &This->funcdescs[index];
7404
7405 TRACE("%p %u %s %p\n", This, index, debugstr_guid(guid), pVarVal);
7406
7407 if(index >= This->TypeAttr.cFuncs)
7408 return TYPE_E_ELEMENTNOTFOUND;
7409
7410 pCData = TLB_get_custdata_by_guid(&pFDesc->custdata_list, guid);
7411 if(!pCData)
7412 return TYPE_E_ELEMENTNOTFOUND;
7413
7414 VariantInit(pVarVal);
7415 VariantCopy(pVarVal, &pCData->data);
7416
7417 return S_OK;
7418 }
7419
7420 /* ITypeInfo2::GetParamCustData
7421 *
7422 * Gets the custom data
7423 */
7424 static HRESULT WINAPI ITypeInfo2_fnGetParamCustData(
7425 ITypeInfo2 * iface,
7426 UINT indexFunc,
7427 UINT indexParam,
7428 REFGUID guid,
7429 VARIANT *pVarVal)
7430 {
7431 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7432 TLBCustData *pCData;
7433 TLBFuncDesc *pFDesc = &This->funcdescs[indexFunc];
7434
7435 TRACE("%p %u %u %s %p\n", This, indexFunc, indexParam,
7436 debugstr_guid(guid), pVarVal);
7437
7438 if(indexFunc >= This->TypeAttr.cFuncs)
7439 return TYPE_E_ELEMENTNOTFOUND;
7440
7441 if(indexParam >= pFDesc->funcdesc.cParams)
7442 return TYPE_E_ELEMENTNOTFOUND;
7443
7444 pCData = TLB_get_custdata_by_guid(&pFDesc->pParamDesc[indexParam].custdata_list, guid);
7445 if(!pCData)
7446 return TYPE_E_ELEMENTNOTFOUND;
7447
7448 VariantInit(pVarVal);
7449 VariantCopy(pVarVal, &pCData->data);
7450
7451 return S_OK;
7452 }
7453
7454 /* ITypeInfo2::GetVarCustData
7455 *
7456 * Gets the custom data
7457 */
7458 static HRESULT WINAPI ITypeInfo2_fnGetVarCustData(
7459 ITypeInfo2 * iface,
7460 UINT index,
7461 REFGUID guid,
7462 VARIANT *pVarVal)
7463 {
7464 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7465 TLBCustData *pCData;
7466 TLBVarDesc *pVDesc = &This->vardescs[index];
7467
7468 TRACE("%p %s %p\n", This, debugstr_guid(guid), pVarVal);
7469
7470 if(index >= This->TypeAttr.cVars)
7471 return TYPE_E_ELEMENTNOTFOUND;
7472
7473 pCData = TLB_get_custdata_by_guid(&pVDesc->custdata_list, guid);
7474 if(!pCData)
7475 return TYPE_E_ELEMENTNOTFOUND;
7476
7477 VariantInit(pVarVal);
7478 VariantCopy(pVarVal, &pCData->data);
7479
7480 return S_OK;
7481 }
7482
7483 /* ITypeInfo2::GetImplCustData
7484 *
7485 * Gets the custom data
7486 */
7487 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData(
7488 ITypeInfo2 * iface,
7489 UINT index,
7490 REFGUID guid,
7491 VARIANT *pVarVal)
7492 {
7493 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7494 TLBCustData *pCData;
7495 TLBImplType *pRDesc = &This->impltypes[index];
7496
7497 TRACE("%p %u %s %p\n", This, index, debugstr_guid(guid), pVarVal);
7498
7499 if(index >= This->TypeAttr.cImplTypes)
7500 return TYPE_E_ELEMENTNOTFOUND;
7501
7502 pCData = TLB_get_custdata_by_guid(&pRDesc->custdata_list, guid);
7503 if(!pCData)
7504 return TYPE_E_ELEMENTNOTFOUND;
7505
7506 VariantInit(pVarVal);
7507 VariantCopy(pVarVal, &pCData->data);
7508
7509 return S_OK;
7510 }
7511
7512 /* ITypeInfo2::GetDocumentation2
7513 *
7514 * Retrieves the documentation string, the complete Help file name and path,
7515 * the localization context to use, and the context ID for the library Help
7516 * topic in the Help file.
7517 *
7518 */
7519 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2(
7520 ITypeInfo2 * iface,
7521 MEMBERID memid,
7522 LCID lcid,
7523 BSTR *pbstrHelpString,
7524 DWORD *pdwHelpStringContext,
7525 BSTR *pbstrHelpStringDll)
7526 {
7527 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7528 const TLBFuncDesc *pFDesc;
7529 const TLBVarDesc *pVDesc;
7530 TRACE("(%p) memid %d lcid(0x%x) HelpString(%p) "
7531 "HelpStringContext(%p) HelpStringDll(%p)\n",
7532 This, memid, lcid, pbstrHelpString, pdwHelpStringContext,
7533 pbstrHelpStringDll );
7534 /* the help string should be obtained from the helpstringdll,
7535 * using the _DLLGetDocumentation function, based on the supplied
7536 * lcid. Nice to do sometime...
7537 */
7538 if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
7539 if(pbstrHelpString)
7540 *pbstrHelpString=SysAllocString(This->Name);
7541 if(pdwHelpStringContext)
7542 *pdwHelpStringContext=This->dwHelpStringContext;
7543 if(pbstrHelpStringDll)
7544 *pbstrHelpStringDll=
7545 SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
7546 return S_OK;
7547 }else {/* for a member */
7548 pFDesc = TLB_get_funcdesc_by_memberid(This->funcdescs, This->TypeAttr.cFuncs, memid);
7549 if(pFDesc){
7550 if(pbstrHelpString)
7551 *pbstrHelpString=SysAllocString(pFDesc->HelpString);
7552 if(pdwHelpStringContext)
7553 *pdwHelpStringContext=pFDesc->HelpStringContext;
7554 if(pbstrHelpStringDll)
7555 *pbstrHelpStringDll=
7556 SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
7557 return S_OK;
7558 }
7559 pVDesc = TLB_get_vardesc_by_memberid(This->vardescs, This->TypeAttr.cVars, memid);
7560 if(pVDesc){
7561 if(pbstrHelpString)
7562 *pbstrHelpString=SysAllocString(pVDesc->HelpString);
7563 if(pdwHelpStringContext)
7564 *pdwHelpStringContext=pVDesc->HelpStringContext;
7565 if(pbstrHelpStringDll)
7566 *pbstrHelpStringDll=
7567 SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
7568 return S_OK;
7569 }
7570 }
7571 return TYPE_E_ELEMENTNOTFOUND;
7572 }
7573
7574 /* ITypeInfo2::GetAllCustData
7575 *
7576 * Gets all custom data items for the Type info.
7577 *
7578 */
7579 static HRESULT WINAPI ITypeInfo2_fnGetAllCustData(
7580 ITypeInfo2 * iface,
7581 CUSTDATA *pCustData)
7582 {
7583 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7584
7585 TRACE("%p %p\n", This, pCustData);
7586
7587 return TLB_copy_all_custdata(&This->custdata_list, pCustData);
7588 }
7589
7590 /* ITypeInfo2::GetAllFuncCustData
7591 *
7592 * Gets all custom data items for the specified Function
7593 *
7594 */
7595 static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData(
7596 ITypeInfo2 * iface,
7597 UINT index,
7598 CUSTDATA *pCustData)
7599 {
7600 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7601 TLBFuncDesc *pFDesc = &This->funcdescs[index];
7602
7603 TRACE("%p %u %p\n", This, index, pCustData);
7604
7605 if(index >= This->TypeAttr.cFuncs)
7606 return TYPE_E_ELEMENTNOTFOUND;
7607
7608 return TLB_copy_all_custdata(&pFDesc->custdata_list, pCustData);
7609 }
7610
7611 /* ITypeInfo2::GetAllParamCustData
7612 *
7613 * Gets all custom data items for the Functions
7614 *
7615 */
7616 static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData( ITypeInfo2 * iface,
7617 UINT indexFunc, UINT indexParam, CUSTDATA *pCustData)
7618 {
7619 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7620 TLBFuncDesc *pFDesc = &This->funcdescs[indexFunc];
7621
7622 TRACE("%p %u %u %p\n", This, indexFunc, indexParam, pCustData);
7623
7624 if(indexFunc >= This->TypeAttr.cFuncs)
7625 return TYPE_E_ELEMENTNOTFOUND;
7626
7627 if(indexParam >= pFDesc->funcdesc.cParams)
7628 return TYPE_E_ELEMENTNOTFOUND;
7629
7630 return TLB_copy_all_custdata(&pFDesc->pParamDesc[indexParam].custdata_list, pCustData);
7631 }
7632
7633 /* ITypeInfo2::GetAllVarCustData
7634 *
7635 * Gets all custom data items for the specified Variable
7636 *
7637 */
7638 static HRESULT WINAPI ITypeInfo2_fnGetAllVarCustData( ITypeInfo2 * iface,
7639 UINT index, CUSTDATA *pCustData)
7640 {
7641 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7642 TLBVarDesc * pVDesc = &This->vardescs[index];
7643
7644 TRACE("%p %u %p\n", This, index, pCustData);
7645
7646 if(index >= This->TypeAttr.cVars)
7647 return TYPE_E_ELEMENTNOTFOUND;
7648
7649 return TLB_copy_all_custdata(&pVDesc->custdata_list, pCustData);
7650 }
7651
7652 /* ITypeInfo2::GetAllImplCustData
7653 *
7654 * Gets all custom data items for the specified implementation type
7655 *
7656 */
7657 static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData(
7658 ITypeInfo2 * iface,
7659 UINT index,
7660 CUSTDATA *pCustData)
7661 {
7662 ITypeInfoImpl *This = (ITypeInfoImpl *)iface;
7663 TLBImplType *pRDesc = &This->impltypes[index];
7664
7665 TRACE("%p %u %p\n", This, index, pCustData);
7666
7667 if(index >= This->TypeAttr.cImplTypes)
7668 return TYPE_E_ELEMENTNOTFOUND;
7669
7670 return TLB_copy_all_custdata(&pRDesc->custdata_list, pCustData);
7671 }
7672
7673 static const ITypeInfo2Vtbl tinfvt =
7674 {
7675
7676 ITypeInfo_fnQueryInterface,
7677 ITypeInfo_fnAddRef,
7678 ITypeInfo_fnRelease,
7679
7680 ITypeInfo_fnGetTypeAttr,
7681 ITypeInfo_fnGetTypeComp,
7682 ITypeInfo_fnGetFuncDesc,
7683 ITypeInfo_fnGetVarDesc,
7684 ITypeInfo_fnGetNames,
7685 ITypeInfo_fnGetRefTypeOfImplType,
7686 ITypeInfo_fnGetImplTypeFlags,
7687 ITypeInfo_fnGetIDsOfNames,
7688 ITypeInfo_fnInvoke,
7689 ITypeInfo_fnGetDocumentation,
7690 ITypeInfo_fnGetDllEntry,
7691 ITypeInfo_fnGetRefTypeInfo,
7692 ITypeInfo_fnAddressOfMember,
7693 ITypeInfo_fnCreateInstance,
7694 ITypeInfo_fnGetMops,
7695 ITypeInfo_fnGetContainingTypeLib,
7696 ITypeInfo_fnReleaseTypeAttr,
7697 ITypeInfo_fnReleaseFuncDesc,
7698 ITypeInfo_fnReleaseVarDesc,
7699
7700 ITypeInfo2_fnGetTypeKind,
7701 ITypeInfo2_fnGetTypeFlags,
7702 ITypeInfo2_fnGetFuncIndexOfMemId,
7703 ITypeInfo2_fnGetVarIndexOfMemId,
7704 ITypeInfo2_fnGetCustData,
7705 ITypeInfo2_fnGetFuncCustData,
7706 ITypeInfo2_fnGetParamCustData,
7707 ITypeInfo2_fnGetVarCustData,
7708 ITypeInfo2_fnGetImplTypeCustData,
7709 ITypeInfo2_fnGetDocumentation2,
7710 ITypeInfo2_fnGetAllCustData,
7711 ITypeInfo2_fnGetAllFuncCustData,
7712 ITypeInfo2_fnGetAllParamCustData,
7713 ITypeInfo2_fnGetAllVarCustData,
7714 ITypeInfo2_fnGetAllImplTypeCustData,
7715 };
7716
7717 /******************************************************************************
7718 * CreateDispTypeInfo [OLEAUT32.31]
7719 *
7720 * Build type information for an object so it can be called through an
7721 * IDispatch interface.
7722 *
7723 * RETURNS
7724 * Success: S_OK. pptinfo contains the created ITypeInfo object.
7725 * Failure: E_INVALIDARG, if one or more arguments is invalid.
7726 *
7727 * NOTES
7728 * This call allows an objects methods to be accessed through IDispatch, by
7729 * building an ITypeInfo object that IDispatch can use to call through.
7730 */
7731 HRESULT WINAPI CreateDispTypeInfo(
7732 INTERFACEDATA *pidata, /* [I] Description of the interface to build type info for */
7733 LCID lcid, /* [I] Locale Id */
7734 ITypeInfo **pptinfo) /* [O] Destination for created ITypeInfo object */
7735 {
7736 ITypeInfoImpl *pTIClass, *pTIIface;
7737 ITypeLibImpl *pTypeLibImpl;
7738 unsigned int param, func;
7739 TLBFuncDesc *pFuncDesc;
7740 TLBRefType *ref;
7741
7742 TRACE("\n");
7743 pTypeLibImpl = TypeLibImpl_Constructor();
7744 if (!pTypeLibImpl) return E_FAIL;
7745
7746 pTypeLibImpl->TypeInfoCount = 2;
7747 pTypeLibImpl->typeinfos = heap_alloc_zero(pTypeLibImpl->TypeInfoCount * sizeof(ITypeInfoImpl*));
7748
7749 pTIIface = pTypeLibImpl->typeinfos[0] = ITypeInfoImpl_Constructor();
7750 pTIIface->pTypeLib = pTypeLibImpl;
7751 pTIIface->index = 0;
7752 pTIIface->Name = NULL;
7753 pTIIface->dwHelpContext = -1;
7754 memset(&pTIIface->TypeAttr.guid, 0, sizeof(GUID));
7755 pTIIface->TypeAttr.lcid = lcid;
7756 pTIIface->TypeAttr.typekind = TKIND_INTERFACE;
7757 pTIIface->TypeAttr.wMajorVerNum = 0;
7758 pTIIface->TypeAttr.wMinorVerNum = 0;
7759 pTIIface->TypeAttr.cbAlignment = 2;
7760 pTIIface->TypeAttr.cbSizeInstance = -1;
7761 pTIIface->TypeAttr.cbSizeVft = -1;
7762 pTIIface->TypeAttr.cFuncs = 0;
7763 pTIIface->TypeAttr.cImplTypes = 0;
7764 pTIIface->TypeAttr.cVars = 0;
7765 pTIIface->TypeAttr.wTypeFlags = 0;
7766
7767 pTIIface->funcdescs = TLBFuncDesc_Constructor(pidata->cMembers);
7768 pFuncDesc = pTIIface->funcdescs;
7769 for(func = 0; func < pidata->cMembers; func++) {
7770 METHODDATA *md = pidata->pmethdata + func;
7771 pFuncDesc->Name = SysAllocString(md->szName);
7772 pFuncDesc->funcdesc.memid = md->dispid;
7773 pFuncDesc->funcdesc.lprgscode = NULL;
7774 pFuncDesc->funcdesc.funckind = FUNC_VIRTUAL;
7775 pFuncDesc->funcdesc.invkind = md->wFlags;
7776 pFuncDesc->funcdesc.callconv = md->cc;
7777 pFuncDesc->funcdesc.cParams = md->cArgs;
7778 pFuncDesc->funcdesc.cParamsOpt = 0;
7779 pFuncDesc->funcdesc.oVft = md->iMeth * sizeof(void *);
7780 pFuncDesc->funcdesc.cScodes = 0;
7781 pFuncDesc->funcdesc.wFuncFlags = 0;
7782 pFuncDesc->funcdesc.elemdescFunc.tdesc.vt = md->vtReturn;
7783 pFuncDesc->funcdesc.elemdescFunc.u.paramdesc.wParamFlags = PARAMFLAG_NONE;
7784 pFuncDesc->funcdesc.elemdescFunc.u.paramdesc.pparamdescex = NULL;
7785 pFuncDesc->funcdesc.lprgelemdescParam = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
7786 md->cArgs * sizeof(ELEMDESC));
7787 pFuncDesc->pParamDesc = TLBParDesc_Constructor(md->cArgs);
7788 for(param = 0; param < md->cArgs; param++) {
7789 pFuncDesc->funcdesc.lprgelemdescParam[param].tdesc.vt = md->ppdata[param].vt;
7790 pFuncDesc->pParamDesc[param].Name = SysAllocString(md->ppdata[param].szName);
7791 }
7792 pFuncDesc->helpcontext = 0;
7793 pFuncDesc->HelpStringContext = 0;
7794 pFuncDesc->HelpString = NULL;
7795 pFuncDesc->Entry = NULL;
7796 list_init(&pFuncDesc->custdata_list);
7797 pTIIface->TypeAttr.cFuncs++;
7798 ++pFuncDesc;
7799 }
7800
7801 dump_TypeInfo(pTIIface);
7802
7803 pTIClass = pTypeLibImpl->typeinfos[1] = ITypeInfoImpl_Constructor();
7804 pTIClass->pTypeLib = pTypeLibImpl;
7805 pTIClass->index = 1;
7806 pTIClass->Name = NULL;
7807 pTIClass->dwHelpContext = -1;
7808 memset(&pTIClass->TypeAttr.guid, 0, sizeof(GUID));
7809 pTIClass->TypeAttr.lcid = lcid;
7810 pTIClass->TypeAttr.typekind = TKIND_COCLASS;
7811 pTIClass->TypeAttr.wMajorVerNum = 0;
7812 pTIClass->TypeAttr.wMinorVerNum = 0;
7813 pTIClass->TypeAttr.cbAlignment = 2;
7814 pTIClass->TypeAttr.cbSizeInstance = -1;
7815 pTIClass->TypeAttr.cbSizeVft = -1;
7816 pTIClass->TypeAttr.cFuncs = 0;
7817 pTIClass->TypeAttr.cImplTypes = 1;
7818 pTIClass->TypeAttr.cVars = 0;
7819 pTIClass->TypeAttr.wTypeFlags = 0;
7820
7821 pTIClass->impltypes = TLBImplType_Constructor(1);
7822
7823 ref = heap_alloc_zero(sizeof(*ref));
7824 ref->pImpTLInfo = TLB_REF_INTERNAL;
7825 list_add_head(&pTypeLibImpl->ref_list, &ref->entry);
7826
7827 dump_TypeInfo(pTIClass);
7828
7829 *pptinfo = (ITypeInfo*)pTIClass;
7830
7831 ITypeInfo_AddRef(*pptinfo);
7832 ITypeLib_Release((ITypeLib *)&pTypeLibImpl->lpVtbl);
7833
7834 return S_OK;
7835
7836 }
7837
7838 static HRESULT WINAPI ITypeComp_fnQueryInterface(ITypeComp * iface, REFIID riid, LPVOID * ppv)
7839 {
7840 ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7841
7842 return ITypeInfo_QueryInterface((ITypeInfo *)This, riid, ppv);
7843 }
7844
7845 static ULONG WINAPI ITypeComp_fnAddRef(ITypeComp * iface)
7846 {
7847 ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7848
7849 return ITypeInfo_AddRef((ITypeInfo *)This);
7850 }
7851
7852 static ULONG WINAPI ITypeComp_fnRelease(ITypeComp * iface)
7853 {
7854 ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7855
7856 return ITypeInfo_Release((ITypeInfo *)This);
7857 }
7858
7859 static HRESULT WINAPI ITypeComp_fnBind(
7860 ITypeComp * iface,
7861 OLECHAR * szName,
7862 ULONG lHash,
7863 WORD wFlags,
7864 ITypeInfo ** ppTInfo,
7865 DESCKIND * pDescKind,
7866 BINDPTR * pBindPtr)
7867 {
7868 ITypeInfoImpl *This = info_impl_from_ITypeComp(iface);
7869 const TLBFuncDesc *pFDesc;
7870 const TLBVarDesc *pVDesc;
7871 HRESULT hr = DISP_E_MEMBERNOTFOUND;
7872 UINT fdc;
7873
7874 TRACE("(%p)->(%s, %x, 0x%x, %p, %p, %p)\n", This, debugstr_w(szName), lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
7875
7876 *pDescKind = DESCKIND_NONE;
7877 pBindPtr->lpfuncdesc = NULL;
7878 *ppTInfo = NULL;
7879
7880 for(fdc = 0; fdc < This->TypeAttr.cFuncs; ++fdc){
7881 pFDesc = &This->funcdescs[fdc];
7882 if (!strcmpiW(pFDesc->Name, szName)) {
7883 if (!wFlags || (pFDesc->funcdesc.invkind & wFlags))
7884 break;
7885 else
7886 /* name found, but wrong flags */
7887 hr = TYPE_E_TYPEMISMATCH;
7888 }
7889 }
7890
7891 if (fdc < This->TypeAttr.cFuncs)
7892 {
7893 HRESULT hr = TLB_AllocAndInitFuncDesc(
7894 &pFDesc->funcdesc,
7895 &pBindPtr->lpfuncdesc,
7896 This->TypeAttr.typekind == TKIND_DISPATCH);
7897 if (FAILED(hr))
7898 return hr;
7899 *pDescKind = DESCKIND_FUNCDESC;
7900 *ppTInfo = (ITypeInfo *)&This->lpVtbl;
7901 ITypeInfo_AddRef(*ppTInfo);
7902 return S_OK;
7903 } else {
7904 pVDesc = TLB_get_vardesc_by_name(This->vardescs, This->TypeAttr.cVars, szName);
7905 if(pVDesc){
7906 HRESULT hr = TLB_AllocAndInitVarDesc(&pVDesc->vardesc, &pBindPtr->lpvardesc);
7907 if (FAILED(hr))
7908 return hr;
7909 *pDescKind = DESCKIND_VARDESC;
7910 *ppTInfo = (ITypeInfo *)&This->lpVtbl;
7911 ITypeInfo_AddRef(*ppTInfo);
7912 return S_OK;
7913 }
7914 }
7915 /* FIXME: search each inherited interface, not just the first */
7916 if (hr == DISP_E_MEMBERNOTFOUND && This->impltypes) {
7917 /* recursive search */
7918 ITypeInfo *pTInfo;
7919 ITypeComp *pTComp;
7920 HRESULT hr;
7921 hr=ITypeInfo_GetRefTypeInfo((ITypeInfo *)&This->lpVtbl, This->impltypes[0].hRef, &pTInfo);
7922 if (SUCCEEDED(hr))
7923 {
7924 hr = ITypeInfo_GetTypeComp(pTInfo,&pTComp);
7925 ITypeInfo_Release(pTInfo);
7926 }
7927 if (SUCCEEDED(hr))
7928 {
7929 hr = ITypeComp_Bind(pTComp, szName, lHash, wFlags, ppTInfo, pDescKind, pBindPtr);
7930 ITypeComp_Release(pTComp);
7931 return hr;
7932 }
7933 WARN("Could not search inherited interface!\n");
7934 }
7935 if (hr == DISP_E_MEMBERNOTFOUND)
7936 hr = S_OK;
7937 TRACE("did not find member with name %s, flags 0x%x\n", debugstr_w(szName), wFlags);
7938 return hr;
7939 }
7940
7941 static HRESULT WINAPI ITypeComp_fnBindType(
7942 ITypeComp * iface,
7943 OLECHAR * szName,
7944 ULONG lHash,
7945 ITypeInfo ** ppTInfo,
7946 ITypeComp ** ppTComp)
7947 {
7948 TRACE("(%s, %x, %p, %p)\n", debugstr_w(szName), lHash, ppTInfo, ppTComp);
7949
7950 /* strange behaviour (does nothing) but like the
7951 * original */
7952
7953 if (!ppTInfo || !ppTComp)
7954 return E_POINTER;
7955
7956 *ppTInfo = NULL;
7957 *ppTComp = NULL;
7958
7959 return S_OK;
7960 }
7961
7962 static const ITypeCompVtbl tcompvt =
7963 {
7964
7965 ITypeComp_fnQueryInterface,
7966 ITypeComp_fnAddRef,
7967 ITypeComp_fnRelease,
7968
7969 ITypeComp_fnBind,
7970 ITypeComp_fnBindType
7971 };
Windows API implementation