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