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