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