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