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