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