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