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