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