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