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