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