?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Repaired shared PE data sections.
[wine/multimedia.git] / dlls / oleaut32 / typelib.c
blobaf4852c12105bbe721f17317d54ec531e1b1ca08
1 /*
2 * TYPELIB
3 *
4 * Copyright 1997 Marcus Meissner
5 * 1999 Rein Klazes
6 * 2000 Francois Jacques
7 * --------------------------------------------------------------------------------------
8 * Known problems (2000, Francois Jacques)
9 *
10 * - Tested using OLEVIEW (Platform SDK tool) only.
11 *
12 * - dual interface dispinterfaces. vtable-interface ITypeInfo instances are
13 * creating by doing a straight copy of the dispinterface instance and just changing
14 * its typekind. Pointed structures aren't copied - only the address of the pointers.
15 * So when you release the dispinterface, you delete the vtable-interface structures
16 * as well... fortunately, clean up of structures is not implemented.
17 *
18 * - locale stuff is partially implemented but hasn't been tested.
19 *
20 * - imported typelib should be stored together in a linked list instead of having
21 * independant TLBImpLib strucutures in each ITypeInfo. This way, imported libraries
22 * are just imported once (major optimization)
23 *
24 * - typelib file is still read it's in entirety, but it is released now.
25 * - some garbage is read from function names on some very rare occasion
26 *
27 * --------------------------------------------------------------------------------------
28 * Known problems left from previous implementation (1999, Rein Klazes) :
29 *
30 * -. Only one format of typelibs is supported
31 * -. Data structures are straightforward, but slow for look-ups.
32 * -. (related) nothing is hashed
33 * -. there are a number of stubs in ITypeLib and ITypeInfo interfaces. Most
34 * of them I don't know yet how to implement them.
35 * -. Most error return values are just guessed not checked with windows
36 * behaviour.
37 * -. didn't bother with a c++ interface
38 * -. lousy fatal error handling
39 * -. some methods just return pointers to internal data structures, this is
40 * partly laziness, partly I want to check how windows does it.
41 *
42 */
43
44 #include <stdlib.h>
45 #include <string.h>
46 #include <stdio.h>
47 #include <ctype.h>
48 #include "winerror.h"
49 #include "winreg.h" /* for HKEY_LOCAL_MACHINE */
50 #include "winnls.h" /* for PRIMARYLANGID */
51 #include "ole.h"
52 #include "heap.h"
53 #include "wine/obj_base.h"
54 #include "debugtools.h"
55 #include "typelib.h"
56
57 DEFAULT_DEBUG_CHANNEL(ole);
58 DECLARE_DEBUG_CHANNEL(typelib);
59
60 /****************************************************************************
61 * QueryPathOfRegTypeLib16 [TYPELIB.14]
62 *
63 * the path is "Classes\Typelib\<guid>\<major>.<minor>\<lcid>\win16\"
64 * RETURNS
65 * path of typelib
66 */
67 HRESULT WINAPI
68 QueryPathOfRegTypeLib16(
69 REFGUID guid, /* [in] referenced guid */
70 WORD wMaj, /* [in] major version */
71 WORD wMin, /* [in] minor version */
72 LCID lcid, /* [in] locale id */
73 LPBSTR16 path /* [out] path of typelib */
74 ) {
75 char xguid[80];
76 char typelibkey[100],pathname[260];
77 DWORD plen;
78
79 TRACE("\n");
80
81 if (HIWORD(guid)) {
82 sprintf( typelibkey, "SOFTWARE\\Classes\\Typelib\\{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\%d.%d\\%lx\\win16",
83 guid->Data1, guid->Data2, guid->Data3,
84 guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
85 guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7],
86 wMaj,wMin,lcid);
87 } else {
88 sprintf(xguid,"<guid 0x%08lx>",(DWORD)guid);
89 FIXME("(%s,%d,%d,0x%04lx,%p),can't handle non-string guids.\n",xguid,wMaj,wMin,(DWORD)lcid,path);
90 return E_FAIL;
91 }
92 plen = sizeof(pathname);
93 if (RegQueryValueA(HKEY_LOCAL_MACHINE,typelibkey,pathname,&plen)) {
94 /* try again without lang specific id */
95 if (SUBLANGID(lcid))
96 return QueryPathOfRegTypeLib16(guid,wMaj,wMin,PRIMARYLANGID(lcid),path);
97 FIXME("key %s not found\n",typelibkey);
98 return E_FAIL;
99 }
100 *path = SysAllocString16(pathname);
101 return S_OK;
102 }
103
104 /****************************************************************************
105 * QueryPathOfRegTypeLib [OLEAUT32.164]
106 * RETURNS
107 * path of typelib
108 */
109 HRESULT WINAPI
110 QueryPathOfRegTypeLib(
111 REFGUID guid, /* [in] referenced guid */
112 WORD wMaj, /* [in] major version */
113 WORD wMin, /* [in] minor version */
114 LCID lcid, /* [in] locale id */
115 LPBSTR path ) /* [out] path of typelib */
116 {
117 /* don't need to ZeroMemory those arrays since sprintf and RegQueryValue add
118 string termination character on output strings */
119
120 HRESULT hr = E_FAIL;
121
122 DWORD dwPathLen = _MAX_PATH;
123 LCID myLCID = lcid;
124
125 char szXGUID[80];
126 char szTypeLibKey[100];
127 char szPath[dwPathLen];
128
129 if ( !HIWORD(guid) )
130 {
131 sprintf(szXGUID,
132 "<guid 0x%08lx>",
133 (DWORD) guid);
134
135 FIXME("(%s,%d,%d,0x%04lx,%p),stub!\n", szXGUID, wMaj, wMin, (DWORD)lcid, path);
136 return E_FAIL;
137 }
138
139 while (hr != S_OK)
140 {
141 sprintf(szTypeLibKey,
142 "SOFTWARE\\Classes\\Typelib\\{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\%d.%d\\%lx\\win32",
143 guid->Data1, guid->Data2, guid->Data3,
144 guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
145 guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7],
146 wMaj,
147 wMin,
148 myLCID);
149
150 if (RegQueryValueA(HKEY_LOCAL_MACHINE, szTypeLibKey, szPath, &dwPathLen))
151 {
152 if (!lcid)
153 break;
154 else if (myLCID == lcid)
155 {
156 /* try with sub-langid */
157 myLCID = SUBLANGID(lcid);
158 }
159 else if ((myLCID == SUBLANGID(lcid)) && myLCID)
160 {
161 /* try with system langid */
162 myLCID = 0;
163 }
164 else
165 {
166 break;
167 }
168 }
169 else
170 {
171 DWORD len = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szPath, dwPathLen, NULL, 0 );
172 BSTR bstrPath = SysAllocStringLen(NULL,len);
173
174 MultiByteToWideChar(CP_ACP,
175 MB_PRECOMPOSED,
176 szPath,
177 dwPathLen,
178 bstrPath,
179 len);
180 *path = bstrPath;
181 hr = S_OK;
182 }
183 }
184
185 if (hr != S_OK)
186 TRACE_(typelib)("%s not found\n", szTypeLibKey);
187
188 return hr;
189 }
190
191 /******************************************************************************
192 * CreateTypeLib [OLEAUT32] creates a typelib
193 *
194 * RETURNS
195 * Success: S_OK
196 * Failure: Status
197 */
198 HRESULT WINAPI CreateTypeLib(
199 SYSKIND syskind, LPCOLESTR szFile, ICreateTypeLib** ppctlib
200 ) {
201 FIXME("(%d,%s,%p), stub!\n",syskind,debugstr_w(szFile),ppctlib);
202 return E_FAIL;
203 }
204 /******************************************************************************
205 * LoadTypeLib [TYPELIB.3] Loads and registers a type library
206 * NOTES
207 * Docs: OLECHAR FAR* szFile
208 * Docs: iTypeLib FAR* FAR* pptLib
209 *
210 * RETURNS
211 * Success: S_OK
212 * Failure: Status
213 */
214 HRESULT WINAPI LoadTypeLib16(
215 LPOLESTR szFile, /* [in] Name of file to load from */
216 ITypeLib** pptLib) /* [out] Pointer to pointer to loaded type library */
217 {
218 FIXME("('%s',%p): stub\n",debugstr_w((LPWSTR)szFile),pptLib);
219
220 if (pptLib!=0)
221 *pptLib=0;
222
223 return E_FAIL;
224 }
225
226 /******************************************************************************
227 * LoadTypeLib [OLEAUT32.161]
228 * Loads and registers a type library
229 * NOTES
230 * Docs: OLECHAR FAR* szFile
231 * Docs: iTypeLib FAR* FAR* pptLib
232 *
233 * RETURNS
234 * Success: S_OK
235 * Failure: Status
236 */
237 int TLB_ReadTypeLib(PCHAR file, ITypeLib2 **ppTypelib);
238
239 HRESULT WINAPI LoadTypeLib(
240 const OLECHAR *szFile,/* [in] Name of file to load from */
241 ITypeLib * *pptLib) /* [out] Pointer to pointer to loaded type library */
242 {
243 TRACE("\n");
244 return LoadTypeLibEx(szFile, REGKIND_DEFAULT, pptLib);
245 }
246
247 /******************************************************************************
248 * LoadTypeLibEx [OLEAUT32.183]
249 * Loads and optionally registers a type library
250 *
251 * RETURNS
252 * Success: S_OK
253 * Failure: Status
254 */
255 HRESULT WINAPI LoadTypeLibEx(
256 LPCOLESTR szFile, /* [in] Name of file to load from */
257 REGKIND regkind, /* [in] Specify kind of registration */
258 ITypeLib **pptLib) /* [out] Pointer to pointer to loaded type library */
259 {
260 LPSTR p;
261 HRESULT res;
262 TRACE("(%s,%d,%p)\n",debugstr_w(szFile), regkind, pptLib);
263
264 p=HEAP_strdupWtoA(GetProcessHeap(),0,szFile);
265
266 if(regkind != REGKIND_NONE)
267 FIXME ("registration of typelibs not supported yet!\n");
268
269 res= TLB_ReadTypeLib(p, (ITypeLib2**)pptLib);
270 HeapFree(GetProcessHeap(),0,p);
271 TRACE(" returns %08lx\n",res);
272
273 return res;
274 }
275
276 /******************************************************************************
277 * LoadRegTypeLib [OLEAUT32.162]
278 */
279 HRESULT WINAPI LoadRegTypeLib(
280 REFGUID rguid, /* [in] referenced guid */
281 WORD wVerMajor, /* [in] major version */
282 WORD wVerMinor, /* [in] minor version */
283 LCID lcid, /* [in] locale id */
284 ITypeLib **ppTLib) /* [out] path of typelib */
285 {
286 BSTR bstr=NULL;
287 HRESULT res=QueryPathOfRegTypeLib( rguid, wVerMajor, wVerMinor, lcid, &bstr);
288
289 if(SUCCEEDED(res))
290 {
291 res= LoadTypeLib(bstr, ppTLib);
292 SysFreeString(bstr);
293 }
294
295 TRACE("(IID: %s) load %s (%p)\n",debugstr_guid(rguid), SUCCEEDED(res)? "SUCCESS":"FAILED", *ppTLib);
296
297 return res;
298 }
299
300
301 /******************************************************************************
302 * RegisterTypeLib [OLEAUT32.163]
303 * Adds information about a type library to the System Registry
304 * NOTES
305 * Docs: ITypeLib FAR * ptlib
306 * Docs: OLECHAR FAR* szFullPath
307 * Docs: OLECHAR FAR* szHelpDir
308 *
309 * RETURNS
310 * Success: S_OK
311 * Failure: Status
312 */
313 HRESULT WINAPI RegisterTypeLib(
314 ITypeLib * ptlib, /* [in] Pointer to the library*/
315 OLECHAR * szFullPath, /* [in] full Path of the library*/
316 OLECHAR * szHelpDir) /* [in] dir to the helpfile for the library,
317 may be NULL*/
318 { FIXME("(%p,%s,%s): stub\n",ptlib, debugstr_w(szFullPath),debugstr_w(szHelpDir));
319 return S_OK; /* FIXME: pretend everything is OK */
320 }
321
322
323 /******************************************************************************
324 * UnRegisterTypeLib [OLEAUT32.186]
325 * Removes information about a type library from the System Registry
326 * NOTES
327 *
328 * RETURNS
329 * Success: S_OK
330 * Failure: Status
331 */
332 HRESULT WINAPI UnRegisterTypeLib(
333 REFGUID libid, /* [in] Guid of the library */
334 WORD wVerMajor, /* [in] major version */
335 WORD wVerMinor, /* [in] minor version */
336 LCID lcid, /* [in] locale id */
337 SYSKIND syskind)
338 {
339 TRACE("(IID: %s): stub\n",debugstr_guid(libid));
340 return S_OK; /* FIXME: pretend everything is OK */
341 }
342
343 /****************************************************************************
344 * OaBuildVersion (TYPELIB.15)
345 *
346 * known TYPELIB.DLL versions:
347 *
348 * OLE 2.01 no OaBuildVersion() avail 1993 -- ---
349 * OLE 2.02 1993-94 02 3002
350 * OLE 2.03 23 730
351 * OLE 2.03 03 3025
352 * OLE 2.03 W98 SE orig. file !! 1993-95 10 3024
353 * OLE 2.1 NT 1993-95 ?? ???
354 * OLE 2.3.1 W95 23 700
355 * OLE2 4.0 NT4SP6 1993-98 40 4277
356 */
357 DWORD WINAPI OaBuildVersion16(void)
358 {
359 /* FIXME: I'd like to return the highest currently known version value
360 * in case the user didn't force a --winver, but I don't know how
361 * to retrieve the "versionForced" info from misc/version.c :(
362 * (this would be useful in other places, too) */
363 FIXME("Please report to a.mohr@mailto.de if you get version error messages !\n");
364 switch(GetVersion() & 0x8000ffff) /* mask off build number */
365 {
366 case 0x80000a03: /* WIN31 */
367 return MAKELONG(3027, 3); /* WfW 3.11 */
368 case 0x80000004: /* WIN95 */
369 return MAKELONG(700, 23); /* Win95A */
370 case 0x80000a04: /* WIN98 */
371 return MAKELONG(3024, 10); /* W98 SE */
372 case 0x00000004: /* NT4 */
373 return MAKELONG(4277, 40); /* NT4 SP6 */
374 default:
375 FIXME("Version value not known yet. Please investigate it !");
376 return 0;
377 }
378 }
379
380 /* for better debugging info leave the static out for the time being */
381 #define static
382
383 /*======================= ITypeLib implementation =======================*/
384
385 typedef struct tagTLBCustData
386 {
387 GUID guid;
388 VARIANT data;
389 struct tagTLBCustData* next;
390 } TLBCustData;
391
392 /* data structure for import typelibs */
393 typedef struct tagTLBImpLib
394 {
395 int offset; /* offset in the file */
396 GUID guid; /* libid */
397 BSTR name; /* name; */
398
399 LCID lcid; /* lcid of imported typelib */
400
401 WORD wVersionMajor; /* major version number */
402 WORD wVersionMinor; /* minor version number */
403
404 struct tagITypeLibImpl *pImpTypeLib; /* pointer to loaded typelib */
405 struct tagTLBImpLib * next;
406 } TLBImpLib;
407
408 /* internal ITypeLib data */
409 typedef struct tagITypeLibImpl
410 {
411 ICOM_VFIELD(ITypeLib2);
412 UINT ref;
413 TLIBATTR LibAttr; /* guid,lcid,syskind,version,flags */
414
415 /* strings can be stored in tlb as multibyte strings BUT they are *always*
416 * exported to the application as a UNICODE string.
417 */
418 BSTR Name;
419 BSTR DocString;
420 BSTR HelpFile;
421 BSTR HelpStringDll;
422 unsigned long dwHelpContext;
423 int TypeInfoCount; /* nr of typeinfo's in librarry */
424 struct tagITypeInfoImpl *pTypeInfo; /* linked list of type info data */
425 int ctCustData; /* number of items in cust data list */
426 TLBCustData * pCustData; /* linked list to cust data; */
427 TLBImpLib * pImpLibs; /* linked list to all imported typelibs */
428 TYPEDESC * pTypeDesc; /* array of TypeDescriptions found in the libary */
429 } ITypeLibImpl;
430
431 static struct ICOM_VTABLE(ITypeLib2) tlbvt;
432
433 /* ITypeLib methods */
434 static ITypeLib2* ITypeLib2_Constructor(LPVOID pLib, DWORD dwTLBLength);
435
436 /*======================= ITypeInfo implementation =======================*/
437
438 /* data for refernced types in a coclass, or an inherited interface */
439 typedef struct tagTLBRefType
440 {
441 GUID guid; /* guid of the referenced type */
442 /* (important if its a imported type) */
443 HREFTYPE reference;
444 int flags;
445 int ctCustData;
446 TLBCustData * pCustData;/* linked list to custom data; */
447 TLBImpLib *pImpTLInfo;
448 struct tagTLBRefType * next;
449 } TLBRefType;
450
451 /* internal Parameter data */
452 typedef struct tagTLBParDesc
453 {
454 BSTR Name;
455 int ctCustData;
456 TLBCustData * pCustData; /* linked list to cust data; */
457 TLBRefType * pRefType; /* linked list to referenced types */
458 } TLBParDesc;
459
460 /* internal Function data */
461 typedef struct tagTLBFuncDesc
462 {
463 FUNCDESC funcdesc; /* lots of info on the function and its attributes. */
464 BSTR Name; /* the name of this function */
465 TLBParDesc *pParamDesc; /* array with name and custom data */
466 int helpcontext;
467 int HelpStringContext;
468 BSTR HelpString;
469 BSTR Entry; /* if its Hiword==0, it numeric; -1 is not present*/
470 int ctCustData;
471 TLBCustData * pCustData; /* linked list to cust data; */
472 struct tagTLBFuncDesc * next;
473 } TLBFuncDesc;
474
475 /* internal Variable data */
476 typedef struct tagTLBVarDesc
477 {
478 VARDESC vardesc; /* lots of info on the variable and its attributes. */
479 BSTR Name; /* the name of this variable */
480 int HelpContext;
481 int HelpStringContext; /* fixme: where? */
482 BSTR HelpString;
483 int ctCustData;
484 TLBCustData * pCustData;/* linked list to cust data; */
485 struct tagTLBVarDesc * next;
486 } TLBVarDesc;
487
488 /* internal TypeInfo data */
489 typedef struct tagITypeInfoImpl
490 {
491 ICOM_VFIELD(ITypeInfo2);
492 UINT ref;
493 TYPEATTR TypeAttr ; /* _lots_ of type information. */
494 ITypeLibImpl * pTypeLib; /* back pointer to typelib */
495 int index; /* index in this typelib; */
496 /* type libs seem to store the doc strings in ascii
497 * so why should we do it in unicode?
498 */
499 BSTR Name;
500 BSTR DocString;
501 unsigned long dwHelpContext;
502 unsigned long dwHelpStringContext;
503
504 /* functions */
505 TLBFuncDesc * funclist; /* linked list with function descriptions */
506
507 /* variables */
508 TLBVarDesc * varlist; /* linked list with variable descriptions */
509
510 /* Implemented Interfaces */
511 TLBRefType * impltypelist;
512 int ctCustData;
513 TLBCustData * pCustData; /* linked list to cust data; */
514 struct tagITypeInfoImpl * next;
515 } ITypeInfoImpl;
516
517 static struct ICOM_VTABLE(ITypeInfo2) tinfvt;
518
519 static ITypeInfo2 * WINAPI ITypeInfo_Constructor();
520
521 typedef struct tagTLBContext
522 {
523 unsigned int oStart; /* start of TLB in file */
524 unsigned int pos; /* current pos */
525 unsigned int length; /* total length */
526 void *mapping; /* memory mapping */
527 TLBSegDir * pTblDir;
528 ITypeLibImpl* pLibInfo;
529 } TLBContext;
530
531
532 static void TLB_DoRefType(TLBContext *pcx, int offset, TLBRefType ** pprtd);
533
534 /*
535 debug
536 */
537 static void dump_TLBFuncDesc(TLBFuncDesc * pfd)
538 {
539 while (pfd)
540 {
541 TRACE_(typelib)("%s(%u)\n", debugstr_w(pfd->Name), pfd->funcdesc.cParams);
542 pfd = pfd->next;
543 };
544 }
545 static void dump_TLBVarDesc(TLBVarDesc * pvd)
546 {
547 while (pvd)
548 {
549 TRACE_(typelib)("%s\n", debugstr_w(pvd->Name));
550 pvd = pvd->next;
551 };
552 }
553 static void dump_TLBRefType(TLBRefType * prt)
554 {
555 while (prt)
556 {
557 TRACE_(typelib)("%s\n", debugstr_guid(&(prt->guid)));
558 TRACE_(typelib)(" href:0x%08lx\n", prt->reference);
559 prt = prt->next;
560 };
561 }
562
563 static void dump_Variant(VARIANT * pvar)
564 {
565 char szVarType[15];
566
567 TRACE("(%p)\n", pvar);
568
569 if (!pvar) return;
570
571 ZeroMemory(szVarType, sizeof(szVarType));
572
573 /* FIXME : we could have better trace here, depending on the VARTYPE
574 * of the variant
575 */
576 switch(V_VT(pvar))
577 {
578 case VT_UI1:
579 sprintf(szVarType, "VT_UI");
580 break;
581
582 case VT_I2:
583 sprintf(szVarType, "VT_I2");
584 break;
585
586 case VT_I4:
587 sprintf(szVarType, "VT_I4");
588 break;
589
590 case VT_R4:
591 sprintf(szVarType, "VT_R4");
592 break;
593
594 case VT_R8:
595 sprintf(szVarType, "VT_R8");
596 break;
597
598 case VT_BOOL:
599 sprintf(szVarType, "VT_BOOL");
600 break;
601
602 case VT_ERROR:
603 sprintf(szVarType, "VT_ERROR");
604 break;
605
606 case VT_CY:
607 sprintf(szVarType, "VT_CY");
608 break;
609
610 case VT_DATE:
611 sprintf(szVarType, "VT_DATE");
612 break;
613
614 case VT_BSTR:
615 sprintf(szVarType, "VT_BSTR");
616 break;
617
618 case VT_BYREF:
619 case VT_UNKNOWN:
620 sprintf(szVarType, "VT_BYREF");
621 break;
622
623 case VT_DISPATCH:
624 sprintf(szVarType, "VT_DISPATCH");
625 break;
626
627 case VT_ARRAY:
628 sprintf(szVarType, "VT_ARRAY");
629 break;
630
631 case VT_I1:
632 sprintf(szVarType, "VT_I2");
633 break;
634
635 case VT_UI2:
636 sprintf(szVarType, "VT_UI2");
637 break;
638
639 case VT_UI4:
640 sprintf(szVarType, "VT_UI4");
641 break;
642
643 case VT_INT:
644 sprintf(szVarType, "VT_INT");
645 break;
646
647 case VT_UINT:
648 sprintf(szVarType, "VT_UINT");
649 break;
650 }
651
652 TRACE("VARTYPE: %s", szVarType);
653
654 switch (V_VT(pvar))
655 {
656 case VT_R4:
657 TRACE("%3.3e\n", V_UNION(pvar, fltVal));
658 break;
659
660 case VT_R8:
661 TRACE("%3.3e\n", V_UNION(pvar, dblVal));
662 break;
663
664 default:
665 TRACE("%ld\n", V_UNION(pvar, lVal));
666 break;
667 }
668
669 if (pvar->vt & VT_BYREF)
670 return dump_Variant(pvar->u.pvarVal);
671 }
672
673 static void dump_DispParms(DISPPARAMS * pdp)
674 {
675 int index = 0;
676
677 TRACE("args=%u named args=%u\n", pdp->cArgs, pdp->cNamedArgs);
678
679 while (index < pdp->cArgs)
680 {
681 dump_Variant( &pdp->rgvarg[index] );
682 ++index;
683 }
684 }
685
686 static char * typekind_desc[] =
687 {
688 "TKIND_ENUM",
689 "TKIND_RECORD",
690 "TKIND_MODULE",
691 "TKIND_INTERFACE",
692 "TKIND_DISPATCH",
693 "TKIND_COCLASS",
694 "TKIND_ALIAS",
695 "TKIND_UNION",
696 "TKIND_MAX"
697 };
698
699 static void dump_TypeInfo(ITypeInfoImpl * pty)
700 {
701 TRACE("%p ref=%u\n", pty, pty->ref);
702 TRACE("attr:%s\n", debugstr_guid(&(pty->TypeAttr.guid)));
703 TRACE("kind:%s\n", typekind_desc[pty->TypeAttr.typekind]);
704 TRACE("fct:%u var:%u impl:%u\n",
705 pty->TypeAttr.cFuncs, pty->TypeAttr.cVars, pty->TypeAttr.cImplTypes);
706 TRACE("parent tlb:%p index in TLB:%u\n",pty->pTypeLib, pty->index);
707 TRACE("%s %s\n", debugstr_w(pty->Name), debugstr_w(pty->DocString));
708 dump_TLBFuncDesc(pty->funclist);
709 dump_TLBVarDesc(pty->varlist);
710 dump_TLBRefType(pty->impltypelist);
711 }
712
713 static TYPEDESC stndTypeDesc[VT_LPWSTR+1]=
714 {
715 /* VT_LPWSTR is largest type that */
716 /* may appear in type description*/
717 {{0}, 0},{{0}, 1},{{0}, 2},{{0}, 3},{{0}, 4},
718 {{0}, 5},{{0}, 6},{{0}, 7},{{0}, 8},{{0}, 9},
719 {{0},10},{{0},11},{{0},12},{{0},13},{{0},14},
720 {{0},15},{{0},16},{{0},17},{{0},18},{{0},19},
721 {{0},20},{{0},21},{{0},22},{{0},23},{{0},24},
722 {{0},25},{{0},26},{{0},27},{{0},28},{{0},29},
723 {{0},30},{{0},31}
724 };
725
726 static void TLB_abort()
727 {
728 DebugBreak();
729 }
730 static void * TLB_Alloc(unsigned size)
731 {
732 void * ret;
733 if((ret=HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,size))==NULL){
734 /* FIXME */
735 ERR("cannot allocate memory\n");
736 }
737 return ret;
738 }
739
740 static void TLB_Free(void * ptr)
741 {
742 HeapFree(GetProcessHeap(), 0, ptr);
743 }
744 /* read function */
745 DWORD TLB_Read(void *buffer, DWORD count, TLBContext *pcx, long where )
746 {
747 TRACE_(typelib)("pos=0x%08x len=0x%08lx 0x%08x 0x%08x 0x%08lx\n",
748 pcx->pos, count, pcx->oStart, pcx->length, where);
749
750 if (where != DO_NOT_SEEK)
751 {
752 where += pcx->oStart;
753 if (where > pcx->length)
754 {
755 /* FIXME */
756 ERR("seek beyond end (%ld/%d)\n", where, pcx->length );
757 TLB_abort();
758 }
759 pcx->pos = where;
760 }
761 if (pcx->pos + count > pcx->length) count = pcx->length - pcx->pos;
762 memcpy( buffer, (char *)pcx->mapping + pcx->pos, count );
763 pcx->pos += count;
764 return count;
765 }
766
767 static void TLB_ReadGuid( GUID *pGuid, int offset, TLBContext *pcx)
768 {
769 TRACE_(typelib)("%s\n", debugstr_guid(pGuid));
770
771 if(offset<0 || pcx->pTblDir->pGuidTab.offset <0){
772 memset(pGuid,0, sizeof(GUID));
773 return;
774 }
775 TLB_Read(pGuid, sizeof(GUID), pcx, pcx->pTblDir->pGuidTab.offset+offset );
776 }
777
778 BSTR TLB_ReadName( TLBContext *pcx, int offset)
779 {
780 char * name;
781 TLBNameIntro niName;
782 int lengthInChars;
783 WCHAR* pwstring = NULL;
784 BSTR bstrName = NULL;
785
786 TLB_Read(&niName, sizeof(niName), pcx,
787 pcx->pTblDir->pNametab.offset+offset);
788 niName.namelen &= 0xFF; /* FIXME: correct ? */
789 name=TLB_Alloc((niName.namelen & 0xff) +1);
790 TLB_Read(name, (niName.namelen & 0xff), pcx, DO_NOT_SEEK);
791 name[niName.namelen & 0xff]='\0';
792
793 lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
794 name, -1, NULL, 0);
795
796 /* no invalid characters in string */
797 if (lengthInChars)
798 {
799 pwstring = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*lengthInChars);
800
801 /* don't check for invalid character since this has been done previously */
802 MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, name, -1, pwstring, lengthInChars);
803
804 bstrName = SysAllocStringLen(pwstring, lengthInChars);
805 lengthInChars = SysStringLen(bstrName);
806 HeapFree(GetProcessHeap(), 0, pwstring);
807 }
808
809 TRACE_(typelib)("%s %d\n", debugstr_w(bstrName), lengthInChars);
810 return bstrName;
811 }
812
813 BSTR TLB_ReadString( TLBContext *pcx, int offset)
814 {
815 char * string;
816 INT16 length;
817 int lengthInChars;
818 BSTR bstr = NULL;
819
820 if(offset<0) return NULL;
821 TLB_Read(&length, sizeof(INT16), pcx, pcx->pTblDir->pStringtab.offset+offset);
822 if(length <= 0) return 0;
823 string=TLB_Alloc(length +1);
824 TLB_Read(string, length, pcx, DO_NOT_SEEK);
825 string[length]='\0';
826
827 lengthInChars = MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS,
828 string, -1, NULL, 0);
829
830 /* no invalid characters in string */
831 if (lengthInChars)
832 {
833 WCHAR* pwstring = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*lengthInChars);
834
835 /* don't check for invalid character since this has been done previously */
836 MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, string, -1, pwstring, lengthInChars);
837
838 bstr = SysAllocStringLen(pwstring, lengthInChars);
839 lengthInChars = SysStringLen(bstr);
840 HeapFree(GetProcessHeap(), 0, pwstring);
841 }
842
843 TRACE_(typelib)("%s %d\n", debugstr_w(bstr), lengthInChars);
844 return bstr;
845 }
846 /*
847 * read a value and fill a VARIANT structure
848 */
849 static void TLB_ReadValue( VARIANT * pVar, int offset, TLBContext *pcx )
850 {
851 int size;
852
853 TRACE_(typelib)("\n");
854
855 if(offset <0) { /* data is packed in here */
856 pVar->vt = (offset & 0x7c000000 )>> 26;
857 V_UNION(pVar, iVal) = offset & 0xffff;
858 return;
859 }
860 TLB_Read(&(pVar->vt), sizeof(VARTYPE), pcx,
861 pcx->pTblDir->pCustData.offset + offset );
862 TRACE_(typelib)("Vartype = %x\n", pVar->vt);
863 switch(pVar->vt){
864 case VT_EMPTY: /* FIXME: is this right? */
865 case VT_NULL: /* FIXME: is this right? */
866 case VT_I2 : /* this should not happen */
867 case VT_I4 :
868 case VT_R4 :
869 case VT_ERROR :
870 case VT_BOOL :
871 case VT_I1 :
872 case VT_UI1 :
873 case VT_UI2 :
874 case VT_UI4 :
875 case VT_INT :
876 case VT_UINT :
877 case VT_VOID : /* FIXME: is this right? */
878 case VT_HRESULT :
879 size=4; break;
880 case VT_R8 :
881 case VT_CY :
882 case VT_DATE :
883 case VT_I8 :
884 case VT_UI8 :
885 case VT_DECIMAL : /* FIXME: is this right? */
886 case VT_FILETIME :
887 size=8;break;
888 /* pointer types with known behaviour */
889 case VT_BSTR :{
890 char * ptr;
891 TLB_Read(&size, sizeof(INT), pcx, DO_NOT_SEEK );
892 if(size <= 0) {
893 FIXME("BSTR length = %d?\n", size);
894 } else {
895 ptr=TLB_Alloc(size);/* allocate temp buffer */
896 TLB_Read(ptr, size, pcx, DO_NOT_SEEK); /* read string (ANSI) */
897 V_UNION(pVar, bstrVal)=SysAllocStringLen(NULL,size);
898 /* FIXME: do we need a AtoW conversion here? */
899 V_UNION(pVar, bstrVal[size])=L'\0';
900 while(size--) V_UNION(pVar, bstrVal[size])=ptr[size];
901 TLB_Free(ptr);
902 }
903 }
904 size=-4; break;
905 /* FIXME: this will not work AT ALL when the variant contains a pointer */
906 case VT_DISPATCH :
907 case VT_VARIANT :
908 case VT_UNKNOWN :
909 case VT_PTR :
910 case VT_SAFEARRAY :
911 case VT_CARRAY :
912 case VT_USERDEFINED :
913 case VT_LPSTR :
914 case VT_LPWSTR :
915 case VT_BLOB :
916 case VT_STREAM :
917 case VT_STORAGE :
918 case VT_STREAMED_OBJECT :
919 case VT_STORED_OBJECT :
920 case VT_BLOB_OBJECT :
921 case VT_CF :
922 case VT_CLSID :
923 default:
924 size=0;
925 FIXME("VARTYPE %d is not supported, setting pointer to NULL\n",
926 pVar->vt);
927 }
928
929 if(size>0) /* (big|small) endian correct? */
930 TLB_Read(&(V_UNION(pVar, iVal)), size, pcx, DO_NOT_SEEK );
931 return;
932 }
933 /*
934 * create a linked list with custom data
935 */
936 static int TLB_CustData( TLBContext *pcx, int offset, TLBCustData** ppCustData )
937 {
938 TLBCDGuid entry;
939 TLBCustData* pNew;
940 int count=0;
941
942 TRACE_(typelib)("\n");
943
944 while(offset >=0){
945 count++;
946 pNew=TLB_Alloc(sizeof(TLBCustData));
947 TLB_Read(&entry, sizeof(entry), pcx,
948 pcx->pTblDir->pCDGuids.offset+offset);
949 TLB_ReadGuid(&(pNew->guid), entry.GuidOffset , pcx);
950 TLB_ReadValue(&(pNew->data), entry.DataOffset, pcx);
951 /* add new custom data at head of the list */
952 pNew->next=*ppCustData;
953 *ppCustData=pNew;
954 offset = entry.next;
955 }
956 return count;
957 }
958
959 static void TLB_GetTdesc(TLBContext *pcx, INT type,TYPEDESC * pTd )
960 {
961 if(type <0)
962 pTd->vt=type & VT_TYPEMASK;
963 else
964 *pTd=pcx->pLibInfo->pTypeDesc[type/(2*sizeof(INT))];
965
966 TRACE_(typelib)("vt type = %X\n", pTd->vt);
967 }
968
969 static void
970 TLB_DoFuncs(TLBContext* pcx,
971 int cFuncs,
972 int cVars,
973 int offset,
974 TLBFuncDesc** pptfd)
975 {
976 /*
977 * member information is stored in a data structure at offset
978 * indicated by the memoffset field of the typeinfo structure
979 * There are several distinctive parts.
980 * the first part starts with a field that holds the total length
981 * of this (first) part excluding this field. Then follow the records,
982 * for each member there is one record.
983 *
984 * First entry is always the length of the record (excluding this
985 * length word).
986 * Rest of the record depends on the type of the member. If there is
987 * a field indicating the member type (function variable intereface etc)
988 * I have not found it yet. At this time we depend on the information
989 * in the type info and the usual order how things are stored.
990 *
991 * Second follows an array sized nrMEM*sizeof(INT) with a memeber id
992 * for each member;
993 *
994 * Third is a equal sized array with file offsets to the name entry
995 * of each member.
996 *
997 * Forth and last (?) part is an array with offsets to the records in the
998 * first part of this file segment.
999 */
1000
1001 int infolen, nameoffset, reclength, nrattributes, i;
1002 int recoffset = offset + sizeof(INT);
1003
1004 char recbuf[512];
1005 TLBFuncRecord * pFuncRec=(TLBFuncRecord *) recbuf;
1006
1007 TRACE_(typelib)("\n");
1008
1009 TLB_Read(&infolen, sizeof(INT), pcx, offset);
1010
1011 for ( i = 0; i < cFuncs ; i++ )
1012 {
1013 *pptfd = TLB_Alloc(sizeof(TLBFuncDesc));
1014
1015 /* name, eventually add to a hash table */
1016 TLB_Read(&nameoffset,
1017 sizeof(INT),
1018 pcx,
1019 offset + infolen + (cFuncs + cVars + i + 1) * sizeof(INT));
1020
1021 (*pptfd)->Name = TLB_ReadName(pcx, nameoffset);
1022
1023 /* read the function information record */
1024 TLB_Read(&reclength, sizeof(INT), pcx, recoffset);
1025
1026 reclength &= 0x1ff;
1027
1028 TLB_Read(pFuncRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK) ;
1029
1030 /* do the attributes */
1031 nrattributes = (reclength - pFuncRec->nrargs * 3 * sizeof(int) - 0x18)
1032 / sizeof(int);
1033
1034 if ( nrattributes > 0 )
1035 {
1036 (*pptfd)->helpcontext = pFuncRec->OptAttr[0] ;
1037
1038 if ( nrattributes > 1 )
1039 {
1040 (*pptfd)->HelpString = TLB_ReadString(pcx,
1041 pFuncRec->OptAttr[1]) ;
1042
1043 if ( nrattributes > 2 )
1044 {
1045 if ( pFuncRec->FKCCIC & 0x2000 )
1046 {
1047 (*pptfd)->Entry = (WCHAR*) pFuncRec->OptAttr[2] ;
1048 }
1049 else
1050 {
1051 (*pptfd)->Entry = TLB_ReadString(pcx,
1052 pFuncRec->OptAttr[2]);
1053 }
1054 if( nrattributes > 5 )
1055 {
1056 (*pptfd)->HelpStringContext = pFuncRec->OptAttr[5] ;
1057
1058 if ( nrattributes > 6 && pFuncRec->FKCCIC & 0x80 )
1059 {
1060 TLB_CustData(pcx,
1061 pFuncRec->OptAttr[6],
1062 &(*pptfd)->pCustData);
1063 }
1064 }
1065 }
1066 }
1067 }
1068
1069 /* fill the FuncDesc Structure */
1070 TLB_Read( & (*pptfd)->funcdesc.memid,
1071 sizeof(INT), pcx,
1072 offset + infolen + ( i + 1) * sizeof(INT));
1073
1074 (*pptfd)->funcdesc.funckind = (pFuncRec->FKCCIC) & 0x7;
1075 (*pptfd)->funcdesc.invkind = (pFuncRec->FKCCIC) >> 3 & 0xF;
1076 (*pptfd)->funcdesc.callconv = (pFuncRec->FKCCIC) >> 8 & 0xF;
1077 (*pptfd)->funcdesc.cParams = pFuncRec->nrargs ;
1078 (*pptfd)->funcdesc.cParamsOpt = pFuncRec->nroargs ;
1079 (*pptfd)->funcdesc.oVft = pFuncRec->VtableOffset ;
1080 (*pptfd)->funcdesc.wFuncFlags = LOWORD(pFuncRec->Flags) ;
1081
1082 TLB_GetTdesc(pcx,
1083 pFuncRec->DataType,
1084 &(*pptfd)->funcdesc.elemdescFunc.tdesc) ;
1085
1086 /* do the parameters/arguments */
1087 if(pFuncRec->nrargs)
1088 {
1089 int j = 0;
1090 TLBParameterInfo paraminfo;
1091
1092 (*pptfd)->funcdesc.lprgelemdescParam =
1093 TLB_Alloc(pFuncRec->nrargs * sizeof(ELEMDESC));
1094
1095 (*pptfd)->pParamDesc =
1096 TLB_Alloc(pFuncRec->nrargs * sizeof(TLBParDesc));
1097
1098 TLB_Read(&paraminfo,
1099 sizeof(paraminfo),
1100 pcx,
1101 recoffset + reclength -
1102 pFuncRec->nrargs * sizeof(TLBParameterInfo));
1103
1104 for ( j = 0 ; j < pFuncRec->nrargs ; j++ )
1105 {
1106 TYPEDESC* lpArgTypeDesc = 0;
1107
1108 TLB_GetTdesc(pcx,
1109 paraminfo.DataType,
1110 &(*pptfd)->funcdesc.lprgelemdescParam[j].tdesc) ;
1111
1112 V_UNION(& ((*pptfd)->funcdesc.lprgelemdescParam[j]),
1113 paramdesc.wParamFlags) = paraminfo.Flags;
1114
1115 (*pptfd)->pParamDesc[j].Name = (void *) paraminfo.oName;
1116
1117 /* SEEK value = jump to offset,
1118 * from there jump to the end of record,
1119 * go back by (j-1) arguments
1120 */
1121 TLB_Read( &paraminfo ,
1122 sizeof(TLBParameterInfo), pcx,
1123 recoffset + reclength - ((pFuncRec->nrargs - j - 1)
1124 * sizeof(TLBParameterInfo)));
1125 lpArgTypeDesc =
1126 & ((*pptfd)->funcdesc.lprgelemdescParam[j].tdesc);
1127
1128 while ( lpArgTypeDesc != NULL )
1129 {
1130 switch ( lpArgTypeDesc->vt )
1131 {
1132 case VT_PTR:
1133 lpArgTypeDesc = lpArgTypeDesc->u.lptdesc;
1134 break;
1135
1136 case VT_CARRAY:
1137 lpArgTypeDesc = & (lpArgTypeDesc->u.lpadesc->tdescElem);
1138 break;
1139
1140 case VT_USERDEFINED:
1141 (*pptfd)->pParamDesc[j].pRefType =
1142 TLB_Alloc(sizeof(TLBRefType));
1143
1144 TLB_DoRefType(pcx,
1145 lpArgTypeDesc->u.hreftype,
1146 & ( (*pptfd)->pParamDesc[j].pRefType ));
1147
1148 lpArgTypeDesc = NULL;
1149 break;
1150
1151 default:
1152 lpArgTypeDesc = NULL;
1153 }
1154 }
1155 }
1156
1157
1158 /* parameter is the return value! */
1159 if ( paraminfo.Flags & PARAMFLAG_FRETVAL )
1160 {
1161 TYPEDESC* lpArgTypeDesc;
1162
1163 (*pptfd)->funcdesc.elemdescFunc =
1164 (*pptfd)->funcdesc.lprgelemdescParam[j];
1165
1166 lpArgTypeDesc = & ((*pptfd)->funcdesc.elemdescFunc.tdesc) ;
1167
1168 while ( lpArgTypeDesc != NULL )
1169 {
1170 switch ( lpArgTypeDesc->vt )
1171 {
1172 case VT_PTR:
1173 lpArgTypeDesc = lpArgTypeDesc->u.lptdesc;
1174 break;
1175 case VT_CARRAY:
1176 lpArgTypeDesc =
1177 & (lpArgTypeDesc->u.lpadesc->tdescElem);
1178
1179 break;
1180
1181 case VT_USERDEFINED:
1182 (*pptfd)->pParamDesc[j].pRefType
1183 = TLB_Alloc(sizeof(TLBRefType));
1184
1185 TLB_DoRefType(pcx,
1186 lpArgTypeDesc->u.hreftype,
1187 &((*pptfd)->pParamDesc[j].pRefType));
1188
1189 lpArgTypeDesc = NULL;
1190 break;
1191
1192 default:
1193 lpArgTypeDesc = NULL;
1194 }
1195 }
1196 }
1197
1198 /* second time around */
1199 for(j=0;j<pFuncRec->nrargs;j++)
1200 {
1201 /* name */
1202 (*pptfd)->pParamDesc[j].Name =
1203 TLB_ReadName( pcx, (int)(*pptfd)->pParamDesc[j].Name );
1204
1205 /* default value */
1206 if ( (PARAMFLAG_FHASDEFAULT &
1207 V_UNION(&((*pptfd)->funcdesc.lprgelemdescParam[j]),
1208 paramdesc.wParamFlags)) &&
1209 ((pFuncRec->FKCCIC) & 0x1000) )
1210 {
1211 INT* pInt = (INT *)((char *)pFuncRec +
1212 reclength -
1213 (pFuncRec->nrargs * 4 + 1) * sizeof(INT) );
1214
1215 PARAMDESC* pParamDesc = &V_UNION(
1216 & ((*pptfd)->funcdesc.lprgelemdescParam[j]),
1217 paramdesc);
1218
1219 pParamDesc->pparamdescex = TLB_Alloc(sizeof(PARAMDESCEX));
1220 pParamDesc->pparamdescex->cBytes = sizeof(PARAMDESCEX);
1221
1222 TLB_ReadValue(&(pParamDesc->pparamdescex->varDefaultValue),
1223 pInt[j], pcx);
1224 }
1225 /* custom info */
1226 if ( nrattributes > 7 + j && pFuncRec->FKCCIC & 0x80 )
1227 {
1228 TLB_CustData(pcx,
1229 pFuncRec->OptAttr[7+j],
1230 &(*pptfd)->pParamDesc[j].pCustData);
1231 }
1232 }
1233 }
1234
1235 /* scode is not used: archaic win16 stuff FIXME: right? */
1236 (*pptfd)->funcdesc.cScodes = 0 ;
1237 (*pptfd)->funcdesc.lprgscode = NULL ;
1238
1239 pptfd = & ((*pptfd)->next);
1240 recoffset += reclength;
1241 }
1242 }
1243 static void TLB_DoVars(TLBContext *pcx, int cFuncs, int cVars,
1244 int offset, TLBVarDesc ** pptvd)
1245 {
1246 int infolen, nameoffset, reclength;
1247 char recbuf[256];
1248 TLBVarRecord * pVarRec=(TLBVarRecord *) recbuf;
1249 int i;
1250 int recoffset;
1251
1252 TRACE_(typelib)("\n");
1253
1254 TLB_Read(&infolen,sizeof(INT), pcx, offset);
1255 TLB_Read(&recoffset,sizeof(INT), pcx, offset + infolen +
1256 ((cFuncs+cVars)*2+cFuncs + 1)*sizeof(INT));
1257 recoffset += offset+sizeof(INT);
1258 for(i=0;i<cVars;i++){
1259 *pptvd=TLB_Alloc(sizeof(TLBVarDesc));
1260 /* name, eventually add to a hash table */
1261 TLB_Read(&nameoffset, sizeof(INT), pcx,
1262 offset + infolen + (cFuncs + cVars + i + 1) * sizeof(INT));
1263 (*pptvd)->Name=TLB_ReadName(pcx, nameoffset);
1264 /* read the variable information record */
1265 TLB_Read(&reclength, sizeof(INT), pcx, recoffset);
1266 reclength &=0xff;
1267 TLB_Read(pVarRec, reclength - sizeof(INT), pcx, DO_NOT_SEEK) ;
1268 /* Optional data */
1269 if(reclength >(6*sizeof(INT)) )
1270 (*pptvd)->HelpContext=pVarRec->HelpContext;
1271 if(reclength >(7*sizeof(INT)) )
1272 (*pptvd)->HelpString = TLB_ReadString(pcx, pVarRec->oHelpString) ;
1273 if(reclength >(8*sizeof(INT)) )
1274 if(reclength >(9*sizeof(INT)) )
1275 (*pptvd)->HelpStringContext=pVarRec->HelpStringContext;
1276 /* fill the VarDesc Structure */
1277 TLB_Read(&(*pptvd)->vardesc.memid, sizeof(INT), pcx,
1278 offset + infolen + ( i + 1) * sizeof(INT));
1279 (*pptvd)->vardesc.varkind = pVarRec->VarKind;
1280 (*pptvd)->vardesc.wVarFlags = pVarRec->Flags;
1281 TLB_GetTdesc(pcx, pVarRec->DataType,
1282 &(*pptvd)->vardesc.elemdescVar.tdesc) ;
1283 /* (*pptvd)->vardesc.lpstrSchema; is reserved (SDK) fixme?? */
1284 if(pVarRec->VarKind == VAR_CONST ){
1285 V_UNION(&((*pptvd)->vardesc),lpvarValue)=TLB_Alloc(sizeof(VARIANT));
1286 TLB_ReadValue(V_UNION(&((*pptvd)->vardesc),lpvarValue),
1287 pVarRec->OffsValue, pcx);
1288 }else
1289 V_UNION(&((*pptvd)->vardesc),oInst)=pVarRec->OffsValue;
1290 pptvd=&((*pptvd)->next);
1291 recoffset += reclength;
1292 }
1293 }
1294 /* fill in data for a hreftype (offset). When the refernced type is contained
1295 * in the typelib, its just an (file) offset in the type info base dir.
1296 * If comes from import, its an offset+1 in the ImpInfo table
1297 * */
1298 static void TLB_DoRefType(TLBContext *pcx,
1299 int offset, TLBRefType ** pprtd)
1300 {
1301 int j;
1302
1303 TRACE_(typelib)("TLB context %p, TLB offset %x\n", pcx, offset);
1304
1305 if(!HREFTYPE_INTHISFILE( offset)) {
1306 /* external typelib */
1307 TLBImpInfo impinfo;
1308 TLBImpLib *pImpLib=(pcx->pLibInfo->pImpLibs);
1309
1310 TRACE_(typelib)("offset %x, masked offset %x\n", offset, offset + (offset & 0xfffffffc));
1311
1312 TLB_Read(&impinfo, sizeof(impinfo), pcx,
1313 pcx->pTblDir->pImpInfo.offset + (offset & 0xfffffffc));
1314 for(j=0;pImpLib;j++){ /* search the known offsets of all import libraries */
1315 if(pImpLib->offset==impinfo.oImpFile) break;
1316 pImpLib=pImpLib->next;
1317 }
1318 if(pImpLib){
1319 (*pprtd)->reference=offset;
1320 (*pprtd)->pImpTLInfo = pImpLib;
1321 TLB_ReadGuid(&(*pprtd)->guid, impinfo.oGuid, pcx);
1322 }else{
1323 ERR("Cannot find a reference\n");
1324 (*pprtd)->reference=-1;
1325 (*pprtd)->pImpTLInfo=(void *)-1;
1326 }
1327 }else{
1328 /* in this typelib */
1329 (*pprtd)->reference=offset;
1330 (*pprtd)->pImpTLInfo=(void *)-2;
1331 }
1332 }
1333
1334 /* process Implemented Interfaces of a com class */
1335 static void TLB_DoImplTypes(TLBContext *pcx, int count,
1336 int offset, TLBRefType ** pprtd)
1337 {
1338 int i;
1339 TLBRefRecord refrec;
1340
1341 TRACE_(typelib)("\n");
1342
1343 for(i=0;i<count;i++){
1344 if(offset<0) break; /* paranoia */
1345 *pprtd=TLB_Alloc(sizeof(TLBRefType));
1346 TLB_Read(&refrec,sizeof(refrec),pcx,offset+pcx->pTblDir->pRefTab.offset);
1347 TLB_DoRefType(pcx, refrec.reftype, pprtd);
1348 (*pprtd)->flags=refrec.flags;
1349 (*pprtd)->ctCustData=
1350 TLB_CustData(pcx, refrec.oCustData, &(*pprtd)->pCustData);
1351 offset=refrec.onext;
1352 pprtd=&((*pprtd)->next);
1353 }
1354 }
1355 /*
1356 * process a typeinfo record
1357 */
1358 ITypeInfoImpl * TLB_DoTypeInfo(
1359 TLBContext *pcx,
1360 int count,
1361 ITypeLibImpl * pLibInfo)
1362 {
1363 TLBTypeInfoBase tiBase;
1364 ITypeInfoImpl *ptiRet;
1365
1366 TRACE_(typelib)("count=%u\n", count);
1367
1368 ptiRet = (ITypeInfoImpl*) ITypeInfo_Constructor();
1369 TLB_Read(&tiBase, sizeof(tiBase) ,pcx ,
1370 pcx->pTblDir->pTypeInfoTab.offset+count*sizeof(tiBase));
1371 /* this is where we are coming from */
1372 ptiRet->pTypeLib = pLibInfo;
1373 ptiRet->index=count;
1374 /* fill in the typeattr fields */
1375 FIXME("Assign constructor/destrutor memid\n");
1376
1377 TLB_ReadGuid(&ptiRet->TypeAttr.guid, tiBase.posguid, pcx);
1378 ptiRet->TypeAttr.lcid=pLibInfo->LibAttr.lcid; /* FIXME: correct? */
1379 ptiRet->TypeAttr.memidConstructor=MEMBERID_NIL ;/* FIXME */
1380 ptiRet->TypeAttr.memidDestructor=MEMBERID_NIL ; /* FIXME */
1381 ptiRet->TypeAttr.lpstrSchema=NULL; /* reserved */
1382 ptiRet->TypeAttr.cbSizeInstance=tiBase.size;
1383 ptiRet->TypeAttr.typekind=tiBase.typekind & 0xF;
1384 ptiRet->TypeAttr.cFuncs=LOWORD(tiBase.cElement);
1385 ptiRet->TypeAttr.cVars=HIWORD(tiBase.cElement);
1386 ptiRet->TypeAttr.cbAlignment=(tiBase.typekind >> 11 )& 0x1F; /* there are more flags there */
1387 ptiRet->TypeAttr.wTypeFlags=tiBase.flags;
1388 ptiRet->TypeAttr.wMajorVerNum=LOWORD(tiBase.version);
1389 ptiRet->TypeAttr.wMinorVerNum=HIWORD(tiBase.version);
1390 ptiRet->TypeAttr.cImplTypes=tiBase.cImplTypes;
1391 ptiRet->TypeAttr.cbSizeVft=tiBase.cbSizeVft; /* FIXME: this is only the non inherited part */
1392 if(ptiRet->TypeAttr.typekind == TKIND_ALIAS)
1393 TLB_GetTdesc(pcx, tiBase.datatype1,
1394 &ptiRet->TypeAttr.tdescAlias) ;
1395
1396 /* FIXME: */
1397 /* IDLDESC idldescType; *//* never saw this one != zero */
1398
1399 /* name, eventually add to a hash table */
1400 ptiRet->Name=TLB_ReadName(pcx, tiBase.NameOffset);
1401 TRACE_(typelib)("reading %s\n", debugstr_w(ptiRet->Name));
1402 /* help info */
1403 ptiRet->DocString=TLB_ReadString(pcx, tiBase.docstringoffs);
1404 ptiRet->dwHelpStringContext=tiBase.helpstringcontext;
1405 ptiRet->dwHelpContext=tiBase.helpcontext;
1406 /* note: InfoType's Help file and HelpStringDll come from the containing
1407 * library. Further HelpString and Docstring appear to be the same thing :(
1408 */
1409 /* functions */
1410 if(ptiRet->TypeAttr.cFuncs >0 )
1411 TLB_DoFuncs(pcx, ptiRet->TypeAttr.cFuncs ,ptiRet->TypeAttr.cVars,
1412 tiBase.memoffset, & ptiRet->funclist);
1413 /* variables */
1414 if(ptiRet->TypeAttr.cVars >0 )
1415 TLB_DoVars(pcx, ptiRet->TypeAttr.cFuncs ,ptiRet->TypeAttr.cVars,
1416 tiBase.memoffset, & ptiRet->varlist);
1417 if(ptiRet->TypeAttr.cImplTypes >0 ){
1418 switch(ptiRet->TypeAttr.typekind)
1419 {
1420 case TKIND_COCLASS:
1421 TLB_DoImplTypes(pcx, ptiRet->TypeAttr.cImplTypes ,
1422 tiBase.datatype1, & ptiRet->impltypelist);
1423 break;
1424 case TKIND_DISPATCH:
1425 ptiRet->impltypelist=TLB_Alloc(sizeof(TLBRefType));
1426
1427 if (tiBase.datatype1 != -1)
1428 {
1429 TLB_DoRefType(pcx, tiBase.datatype1, & ptiRet->impltypelist);
1430 }
1431 else
1432 {
1433 char* szStdOle = "stdole2.tlb\0";
1434 int nStdOleLen = strlen(szStdOle);
1435
1436 ptiRet->impltypelist->guid = IID_IDispatch;
1437 ptiRet->impltypelist->reference = -1;
1438 ptiRet->impltypelist->pImpTLInfo = TLB_Alloc(sizeof(TLBImpLib));
1439 ptiRet->impltypelist->pImpTLInfo->guid = IID_StdOle;
1440 ptiRet->impltypelist->pImpTLInfo->name = SysAllocStringLen(NULL, nStdOleLen + 1);
1441
1442 MultiByteToWideChar(CP_ACP,
1443 MB_PRECOMPOSED,
1444 szStdOle,
1445 -1,
1446 ptiRet->impltypelist->pImpTLInfo->name,
1447 SysStringLen(ptiRet->impltypelist->pImpTLInfo->name));
1448
1449 ptiRet->impltypelist->pImpTLInfo->lcid = 0;
1450 ptiRet->impltypelist->pImpTLInfo->wVersionMajor = 2;
1451 ptiRet->impltypelist->pImpTLInfo->wVersionMinor = 0;
1452 }
1453 break;
1454 default:
1455 ptiRet->impltypelist=TLB_Alloc(sizeof(TLBRefType));
1456 TLB_DoRefType(pcx, tiBase.datatype1, & ptiRet->impltypelist);
1457 break;
1458 }
1459 }
1460 ptiRet->ctCustData=
1461 TLB_CustData(pcx, tiBase.oCustData, &ptiRet->pCustData);
1462
1463 TRACE_(typelib)("%s guid: %s kind:%s\n",
1464 debugstr_w(ptiRet->Name),
1465 debugstr_guid(&ptiRet->TypeAttr.guid),
1466 typekind_desc[ptiRet->TypeAttr.typekind]);
1467
1468 return ptiRet;
1469 }
1470
1471 /****************************************************************************
1472 * TLB_ReadTypeLib
1473 *
1474 * find the type of the typelib file and map the typelib resource into
1475 * the memory
1476 */
1477 #define MSFT_SIGNATURE 0x5446534D /* "MSFT" */
1478 int TLB_ReadTypeLib(LPSTR pszFileName, ITypeLib2 **ppTypeLib)
1479 {
1480 int ret = E_FAIL;
1481 DWORD dwSignature = 0;
1482 HFILE hFile;
1483 int nStrLen = strlen(pszFileName);
1484 int i;
1485
1486 PCHAR pszTypeLibIndex = NULL;
1487 PCHAR pszDllName = NULL;
1488
1489 TRACE_(typelib)("%s\n", pszFileName);
1490
1491 *ppTypeLib = NULL;
1492
1493 /* is it a DLL? */
1494 for (i=0 ; i < nStrLen ; ++i)
1495 {
1496 pszFileName[i] = tolower(pszFileName[i]);
1497 }
1498 pszTypeLibIndex = strstr(pszFileName, ".dll");
1499
1500 /* find if there's a back-slash after .DLL (good sign of the presence of a typelib index) */
1501 if (pszTypeLibIndex)
1502 {
1503 pszTypeLibIndex = strstr(pszTypeLibIndex, "\\");
1504 }
1505
1506 /* is there any thing after trailing back-slash ? */
1507 if (pszTypeLibIndex && pszTypeLibIndex < pszFileName + nStrLen)
1508 {
1509 /* yes -> it's a index! store DLL name, without the trailing back-slash */
1510 size_t nMemToAlloc = pszTypeLibIndex - pszFileName;
1511
1512 pszDllName = HeapAlloc(GetProcessHeap(),
1513 HEAP_ZERO_MEMORY,
1514 nMemToAlloc + 1);
1515
1516 strncpy(pszDllName, pszFileName, nMemToAlloc);
1517
1518 /* move index string pointer pass the backslash */
1519 while (*pszTypeLibIndex == '\\')
1520 ++pszTypeLibIndex;
1521 }
1522 else
1523 {
1524 /* No index, reset variable to 1 */
1525 pszDllName = HeapAlloc(GetProcessHeap(),
1526 HEAP_ZERO_MEMORY,
1527 nStrLen + 1);
1528
1529 strncpy(pszDllName, pszFileName, nStrLen);
1530
1531 pszTypeLibIndex = "1\0";
1532 }
1533
1534 TRACE_(typelib)("File name without index %s\n", pszDllName);
1535 TRACE_(typelib)("Index of typelib %s\n", pszTypeLibIndex);
1536
1537
1538 /* check the signature of the file */
1539 hFile = CreateFileA( pszDllName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1540 if (INVALID_HANDLE_VALUE != hFile)
1541 {
1542 HANDLE hMapping = CreateFileMappingA( hFile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL );
1543 if (hMapping)
1544 {
1545 LPVOID pBase = MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);
1546 if(pBase)
1547 {
1548 /* first try to load as *.tlb */
1549 dwSignature = *((DWORD*) pBase);
1550 if ( dwSignature == MSFT_SIGNATURE)
1551 {
1552 /* retrieve file size */
1553 DWORD dwTLBLength = GetFileSize(hFile, NULL);
1554
1555 *ppTypeLib = ITypeLib2_Constructor(pBase, dwTLBLength);
1556 ITypeLib2_AddRef(*ppTypeLib);
1557 }
1558 UnmapViewOfFile(pBase);
1559 }
1560 CloseHandle(hMapping);
1561 }
1562 CloseHandle(hFile);
1563 }
1564
1565 if( (WORD)dwSignature == IMAGE_DOS_SIGNATURE )
1566 {
1567 /* find the typelibrary resource*/
1568 HINSTANCE hinstDLL = LoadLibraryExA(pszDllName, 0, DONT_RESOLVE_DLL_REFERENCES|
1569 LOAD_LIBRARY_AS_DATAFILE|LOAD_WITH_ALTERED_SEARCH_PATH);
1570 if (hinstDLL)
1571 {
1572 HRSRC hrsrc = FindResourceA(hinstDLL, MAKEINTRESOURCEA(atoi(pszTypeLibIndex)), "TYPELIB");
1573 if (hrsrc)
1574 {
1575 HGLOBAL hGlobal = LoadResource(hinstDLL, hrsrc);
1576 if (hGlobal)
1577 {
1578 LPVOID pBase = LockResource(hGlobal);
1579 DWORD dwTLBLength = SizeofResource(hinstDLL, hrsrc);
1580
1581 if (pBase)
1582 {
1583 /* try to load as incore resource */
1584 dwSignature = *((DWORD*) pBase);
1585 if ( dwSignature == MSFT_SIGNATURE)
1586 {
1587 *ppTypeLib = ITypeLib2_Constructor(pBase, dwTLBLength);
1588 ITypeLib2_AddRef(*ppTypeLib);
1589 }
1590 else
1591 {
1592 FIXME("Header type magic 0x%08lx not supported.\n",dwSignature);
1593 }
1594 }
1595 FreeResource( hGlobal );
1596 }
1597 }
1598 FreeLibrary(hinstDLL);
1599 }
1600 }
1601
1602 HeapFree(GetProcessHeap(), 0, pszDllName);
1603
1604 if(*ppTypeLib)
1605 ret = S_OK;
1606 else
1607 ERR("Loading of typelib %s failed with error 0x%08lx\n", pszFileName, GetLastError());
1608
1609 return ret;
1610 }
1611
1612 /*================== ITypeLib(2) Methods ===================================*/
1613
1614 /****************************************************************************
1615 * ITypeLib2_Constructor
1616 *
1617 * loading a typelib from a in-memory image
1618 */
1619 static ITypeLib2* ITypeLib2_Constructor(LPVOID pLib, DWORD dwTLBLength)
1620 {
1621 TLBContext cx;
1622 long lPSegDir;
1623 TLB2Header tlbHeader;
1624 TLBSegDir tlbSegDir;
1625 ITypeLibImpl * pTypeLibImpl;
1626
1627 TRACE("%p, TLB length = %ld\n", pLib, dwTLBLength);
1628
1629 pTypeLibImpl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ITypeLibImpl));
1630 if (!pTypeLibImpl) return NULL;
1631
1632 ICOM_VTBL(pTypeLibImpl) = &tlbvt;
1633 pTypeLibImpl->ref = 1;
1634
1635 /* get pointer to beginning of typelib data */
1636 cx.pos = 0;
1637 cx.oStart=0;
1638 cx.mapping = pLib;
1639 cx.pLibInfo = pTypeLibImpl;
1640 cx.length = dwTLBLength;
1641
1642 /* read header */
1643 TLB_Read((void*)&tlbHeader, sizeof(tlbHeader), &cx, 0);
1644 TRACE("header:\n");
1645 TRACE("\tmagic1=0x%08x ,magic2=0x%08x\n",tlbHeader.magic1,tlbHeader.magic2 );
1646 if (memcmp(&tlbHeader.magic1,TLBMAGIC2,4)) {
1647 FIXME("Header type magic 0x%08x not supported.\n",tlbHeader.magic1);
1648 return NULL;
1649 }
1650 /* there is a small number of information here until the next important
1651 * part:
1652 * the segment directory . Try to calculate the amount of data */
1653 lPSegDir = sizeof(tlbHeader) + (tlbHeader.nrtypeinfos)*4 + ((tlbHeader.varflags & HELPDLLFLAG)? 4 :0);
1654
1655 /* now read the segment directory */
1656 TRACE("read segment directory (at %ld)\n",lPSegDir);
1657 TLB_Read((void*)&tlbSegDir, sizeof(tlbSegDir), &cx, lPSegDir);
1658 cx.pTblDir = &tlbSegDir;
1659
1660 /* just check two entries */
1661 if ( tlbSegDir.pTypeInfoTab.res0c != 0x0F || tlbSegDir.pImpInfo.res0c != 0x0F)
1662 {
1663 ERR("cannot find the table directory, ptr=0x%lx\n",lPSegDir);
1664 HeapFree(GetProcessHeap(),0,pTypeLibImpl);
1665 return NULL;
1666 }
1667
1668 /* now fill our internal data */
1669 /* TLIBATTR fields */
1670 TLB_ReadGuid(&pTypeLibImpl->LibAttr.guid, tlbHeader.posguid, &cx);
1671 pTypeLibImpl->LibAttr.lcid = tlbHeader.lcid;
1672 pTypeLibImpl->LibAttr.syskind = tlbHeader.varflags & 0x0f; /* check the mask */
1673 pTypeLibImpl->LibAttr.wMajorVerNum = LOWORD(tlbHeader.version);
1674 pTypeLibImpl->LibAttr.wMinorVerNum = HIWORD(tlbHeader.version);
1675 pTypeLibImpl->LibAttr.wLibFlags = (WORD) tlbHeader.flags & 0xffff;/* check mask */
1676
1677 /* name, eventually add to a hash table */
1678 pTypeLibImpl->Name = TLB_ReadName(&cx, tlbHeader.NameOffset);
1679
1680 /* help info */
1681 pTypeLibImpl->DocString = TLB_ReadString(&cx, tlbHeader.helpstring);
1682 pTypeLibImpl->HelpFile = TLB_ReadString(&cx, tlbHeader.helpfile);
1683
1684 if( tlbHeader.varflags & HELPDLLFLAG)
1685 {
1686 int offset;
1687 TLB_Read(&offset, sizeof(offset), &cx, sizeof(tlbHeader));
1688 pTypeLibImpl->HelpStringDll = TLB_ReadString(&cx, offset);
1689 }
1690
1691 pTypeLibImpl->dwHelpContext = tlbHeader.helpstringcontext;
1692
1693 /* custom data */
1694 if(tlbHeader.CustomDataOffset >= 0)
1695 {
1696 pTypeLibImpl->ctCustData = TLB_CustData(&cx, tlbHeader.CustomDataOffset, &pTypeLibImpl->pCustData);
1697 }
1698
1699 /* fill in typedescriptions */
1700 if(tlbSegDir.pTypdescTab.length > 0)
1701 {
1702 int i, j, cTD = tlbSegDir.pTypdescTab.length / (2*sizeof(INT));
1703 INT16 td[4];
1704 pTypeLibImpl->pTypeDesc = TLB_Alloc( cTD * sizeof(TYPEDESC));
1705 TLB_Read(td, sizeof(td), &cx, tlbSegDir.pTypdescTab.offset);
1706 for(i=0; i<cTD; )
1707 {
1708 /* FIXME: add several sanity checks here */
1709 pTypeLibImpl->pTypeDesc[i].vt = td[0] & VT_TYPEMASK;
1710 if(td[0] == VT_PTR || td[0] == VT_SAFEARRAY)
1711 {
1712 /* FIXME: check safearray */
1713 if(td[3] < 0)
1714 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lptdesc)= & stndTypeDesc[td[2]];
1715 else
1716 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lptdesc)= & pTypeLibImpl->pTypeDesc[td[2]/8];
1717 }
1718 else if(td[0] == VT_CARRAY)
1719 {
1720 /* array descr table here */
1721 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc) = (void *)((int) td[2]); /* temp store offset in*/
1722 }
1723 else if(td[0] == VT_USERDEFINED)
1724 {
1725 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),hreftype) = MAKELONG(td[2],td[3]);
1726 }
1727 if(++i<cTD) TLB_Read(td, sizeof(td), &cx, DO_NOT_SEEK);
1728 }
1729
1730 /* second time around to fill the array subscript info */
1731 for(i=0;i<cTD;i++)
1732 {
1733 if(pTypeLibImpl->pTypeDesc[i].vt != VT_CARRAY) continue;
1734 if(tlbSegDir.pArrayDescriptions.offset>0)
1735 {
1736 TLB_Read(td, sizeof(td), &cx, tlbSegDir.pArrayDescriptions.offset + (int) V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc));
1737 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc) = TLB_Alloc(sizeof(ARRAYDESC)+sizeof(SAFEARRAYBOUND)*(td[3]-1));
1738
1739 if(td[1]<0)
1740 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->tdescElem.vt = td[0] & VT_TYPEMASK;
1741 else
1742 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->tdescElem = stndTypeDesc[td[0]/8];
1743
1744 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->cDims = td[2];
1745
1746 for(j = 0; j<td[2]; j++)
1747 {
1748 TLB_Read(& V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->rgbounds[j].cElements,
1749 sizeof(INT), &cx, DO_NOT_SEEK);
1750 TLB_Read(& V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc)->rgbounds[j].lLbound,
1751 sizeof(INT), &cx, DO_NOT_SEEK);
1752 }
1753 }
1754 else
1755 {
1756 V_UNION(&(pTypeLibImpl->pTypeDesc[i]),lpadesc) = NULL;
1757 ERR("didn't find array description data\n");
1758 }
1759 }
1760 }
1761
1762 /* imported type libs */
1763 if(tlbSegDir.pImpFiles.offset>0)
1764 {
1765 TLBImpLib **ppImpLib = &(pTypeLibImpl->pImpLibs);
1766 int oGuid, offset = tlbSegDir.pImpFiles.offset;
1767 UINT16 size;
1768
1769 while(offset < tlbSegDir.pImpFiles.offset +tlbSegDir.pImpFiles.length)
1770 {
1771 *ppImpLib = TLB_Alloc(sizeof(TLBImpLib));
1772 (*ppImpLib)->offset = offset - tlbSegDir.pImpFiles.offset;
1773 TLB_Read(&oGuid, sizeof(INT), &cx, offset);
1774
1775 TLB_Read(&(*ppImpLib)->lcid, sizeof(LCID), &cx, DO_NOT_SEEK);
1776 TLB_Read(&(*ppImpLib)->wVersionMajor, sizeof(WORD), &cx, DO_NOT_SEEK);
1777 TLB_Read(&(*ppImpLib)->wVersionMinor, sizeof(WORD), &cx, DO_NOT_SEEK);
1778 TLB_Read(& size, sizeof(UINT16), &cx, DO_NOT_SEEK);
1779
1780 size >>= 2;
1781 (*ppImpLib)->name = TLB_Alloc(size+1);
1782 TLB_Read((*ppImpLib)->name, size, &cx, DO_NOT_SEEK);
1783 TLB_ReadGuid(&(*ppImpLib)->guid, oGuid, &cx);
1784 offset = (offset + sizeof(INT) + sizeof(DWORD) + sizeof(LCID) + sizeof(UINT16) + size + 3) & 0xfffffffc;
1785
1786 ppImpLib = &(*ppImpLib)->next;
1787 }
1788 }
1789
1790 /* type info's */
1791 if(tlbHeader.nrtypeinfos >= 0 )
1792 {
1793 /*pTypeLibImpl->TypeInfoCount=tlbHeader.nrtypeinfos; */
1794 ITypeInfoImpl **ppTI = &(pTypeLibImpl->pTypeInfo);
1795 int i;
1796
1797 for(i = 0; i<(int)tlbHeader.nrtypeinfos; i++)
1798 {
1799 *ppTI = TLB_DoTypeInfo(&cx, i, pTypeLibImpl);
1800
1801 ITypeInfo_AddRef((ITypeInfo*) *ppTI);
1802 ppTI = &((*ppTI)->next);
1803 (pTypeLibImpl->TypeInfoCount)++;
1804 }
1805 }
1806
1807 TRACE("(%p)\n", pTypeLibImpl);
1808 return (ITypeLib2*) pTypeLibImpl;
1809 }
1810
1811 /* ITypeLib::QueryInterface
1812 */
1813 static HRESULT WINAPI ITypeLib2_fnQueryInterface(
1814 ITypeLib2 * iface,
1815 REFIID riid,
1816 VOID **ppvObject)
1817 {
1818 ICOM_THIS( ITypeLibImpl, iface);
1819
1820 TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
1821
1822 *ppvObject=NULL;
1823 if(IsEqualIID(riid, &IID_IUnknown) ||
1824 IsEqualIID(riid,&IID_ITypeLib)||
1825 IsEqualIID(riid,&IID_ITypeLib2))
1826 {
1827 *ppvObject = This;
1828 }
1829
1830 if(*ppvObject)
1831 {
1832 ITypeLib2_AddRef(iface);
1833 TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
1834 return S_OK;
1835 }
1836 TRACE("-- Interface: E_NOINTERFACE\n");
1837 return E_NOINTERFACE;
1838 }
1839
1840 /* ITypeLib::AddRef
1841 */
1842 static ULONG WINAPI ITypeLib2_fnAddRef( ITypeLib2 *iface)
1843 {
1844 ICOM_THIS( ITypeLibImpl, iface);
1845
1846 TRACE("(%p)->ref is %u\n",This, This->ref);
1847
1848 return ++(This->ref);
1849 }
1850
1851 /* ITypeLib::Release
1852 */
1853 static ULONG WINAPI ITypeLib2_fnRelease( ITypeLib2 *iface)
1854 {
1855 ICOM_THIS( ITypeLibImpl, iface);
1856
1857 --(This->ref);
1858
1859 TRACE("(%p)->(%u)\n",This, This->ref);
1860
1861 if (!This->ref)
1862 {
1863 /* fixme destroy child objects */
1864
1865 TRACE(" destroying ITypeLib(%p)\n",This);
1866
1867 if (This->Name)
1868 {
1869 SysFreeString(This->Name);
1870 This->Name = NULL;
1871 }
1872
1873 if (This->DocString)
1874 {
1875 SysFreeString(This->DocString);
1876 This->DocString = NULL;
1877 }
1878
1879 if (This->HelpFile)
1880 {
1881 SysFreeString(This->HelpFile);
1882 This->HelpFile = NULL;
1883 }
1884
1885 if (This->HelpStringDll)
1886 {
1887 SysFreeString(This->HelpStringDll);
1888 This->HelpStringDll = NULL;
1889 }
1890
1891 ITypeInfo_Release((ITypeInfo*) This->pTypeInfo);
1892 HeapFree(GetProcessHeap(),0,This);
1893 return 0;
1894 }
1895
1896 return This->ref;
1897 }
1898
1899 /* ITypeLib::GetTypeInfoCount
1900 *
1901 * Returns the number of type descriptions in the type library
1902 */
1903 static UINT WINAPI ITypeLib2_fnGetTypeInfoCount( ITypeLib2 *iface)
1904 {
1905 ICOM_THIS( ITypeLibImpl, iface);
1906 TRACE("(%p)->count is %d\n",This, This->TypeInfoCount);
1907 return This->TypeInfoCount;
1908 }
1909
1910 /* ITypeLib::GetTypeInfo
1911 *
1912 * retrieves the specified type description in the library.
1913 */
1914 static HRESULT WINAPI ITypeLib2_fnGetTypeInfo(
1915 ITypeLib2 *iface,
1916 UINT index,
1917 ITypeInfo **ppTInfo)
1918 {
1919 int i;
1920
1921 ICOM_THIS( ITypeLibImpl, iface);
1922 ITypeInfoImpl *pTypeInfo = This->pTypeInfo;
1923
1924 TRACE("(%p)->(index=%d) \n", This, index);
1925
1926 if (!ppTInfo) return E_INVALIDARG;
1927
1928 /* search element n in list */
1929 for(i=0; i < index; i++)
1930 {
1931 pTypeInfo = pTypeInfo->next;
1932 if (!pTypeInfo)
1933 {
1934 TRACE("-- element not found\n");
1935 return TYPE_E_ELEMENTNOTFOUND;
1936 }
1937 }
1938
1939 *ppTInfo = (ITypeInfo *) pTypeInfo;
1940
1941 ITypeInfo_AddRef(*ppTInfo);
1942 TRACE("-- found (%p)\n",*ppTInfo);
1943 return S_OK;
1944 }
1945
1946
1947 /* ITypeLibs::GetTypeInfoType
1948 *
1949 * Retrieves the type of a type description.
1950 */
1951 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoType(
1952 ITypeLib2 *iface,
1953 UINT index,
1954 TYPEKIND *pTKind)
1955 {
1956 ICOM_THIS( ITypeLibImpl, iface);
1957 int i;
1958 ITypeInfoImpl *pTInfo = This->pTypeInfo;
1959
1960 TRACE("(%p) index %d \n",This, index);
1961
1962 if(!pTKind) return E_INVALIDARG;
1963
1964 /* search element n in list */
1965 for(i=0; i < index; i++)
1966 {
1967 if(!pTInfo)
1968 {
1969 TRACE("-- element not found\n");
1970 return TYPE_E_ELEMENTNOTFOUND;
1971 }
1972 pTInfo = pTInfo->next;
1973 }
1974
1975 *pTKind = pTInfo->TypeAttr.typekind;
1976 TRACE("-- found Type (%d)\n", *pTKind);
1977 return S_OK;
1978 }
1979
1980 /* ITypeLib::GetTypeInfoOfGuid
1981 *
1982 * Retrieves the type description that corresponds to the specified GUID.
1983 *
1984 */
1985 static HRESULT WINAPI ITypeLib2_fnGetTypeInfoOfGuid(
1986 ITypeLib2 *iface,
1987 REFGUID guid,
1988 ITypeInfo **ppTInfo)
1989 {
1990 ICOM_THIS( ITypeLibImpl, iface);
1991 ITypeInfoImpl *pTypeInfo = This->pTypeInfo; /* head of list */
1992
1993 TRACE("(%p)\n\tguid:\t%s)\n",This,debugstr_guid(guid));
1994
1995 if (!pTypeInfo) return TYPE_E_ELEMENTNOTFOUND;
1996
1997 /* search linked list for guid */
1998 while( !IsEqualIID(guid,&pTypeInfo->TypeAttr.guid) )
1999 {
2000 pTypeInfo = pTypeInfo->next;
2001
2002 if (!pTypeInfo)
2003 {
2004 /* end of list reached */
2005 TRACE("-- element not found\n");
2006 return TYPE_E_ELEMENTNOTFOUND;
2007 }
2008 }
2009
2010 TRACE("-- found (%p, %s)\n",
2011 pTypeInfo,
2012 debugstr_w(pTypeInfo->Name));
2013
2014 *ppTInfo = (ITypeInfo*)pTypeInfo;
2015 ITypeInfo_AddRef(*ppTInfo);
2016 return S_OK;
2017 }
2018
2019 /* ITypeLib::GetLibAttr
2020 *
2021 * Retrieves the structure that contains the library's attributes.
2022 *
2023 */
2024 static HRESULT WINAPI ITypeLib2_fnGetLibAttr(
2025 ITypeLib2 *iface,
2026 LPTLIBATTR *ppTLibAttr)
2027 {
2028 ICOM_THIS( ITypeLibImpl, iface);
2029 TRACE("(%p)\n",This);
2030 /* FIXME: must do a copy here */
2031 *ppTLibAttr=&This->LibAttr;
2032 return S_OK;
2033 }
2034
2035 /* ITypeLib::GetTypeComp
2036 *
2037 * Enables a client compiler to bind to a library's types, variables,
2038 * constants, and global functions.
2039 *
2040 */
2041 static HRESULT WINAPI ITypeLib2_fnGetTypeComp(
2042 ITypeLib2 *iface,
2043 ITypeComp **ppTComp)
2044 {
2045 ICOM_THIS( ITypeLibImpl, iface);
2046 FIXME("(%p): stub!\n",This);
2047 return E_NOTIMPL;
2048 }
2049
2050 /* ITypeLib::GetDocumentation
2051 *
2052 * Retrieves the library's documentation string, the complete Help file name
2053 * and path, and the context identifier for the library Help topic in the Help
2054 * file.
2055 *
2056 */
2057 static HRESULT WINAPI ITypeLib2_fnGetDocumentation(
2058 ITypeLib2 *iface,
2059 INT index,
2060 BSTR *pBstrName,
2061 BSTR *pBstrDocString,
2062 DWORD *pdwHelpContext,
2063 BSTR *pBstrHelpFile)
2064 {
2065 ICOM_THIS( ITypeLibImpl, iface);
2066
2067 HRESULT result = E_INVALIDARG;
2068
2069 ITypeInfo *pTInfo;
2070
2071
2072 TRACE("(%p) index %d Name(%p) DocString(%p) HelpContext(%p) HelpFile(%p)\n",
2073 This, index,
2074 pBstrName, pBstrDocString,
2075 pdwHelpContext, pBstrHelpFile);
2076
2077 if(index<0)
2078 {
2079 /* documentation for the typelib */
2080 if(pBstrName && This->Name)
2081 {
2082 *pBstrName = SysAllocString(This->Name);
2083
2084 if (!(*pBstrName)) return STG_E_INSUFFICIENTMEMORY;
2085 }
2086 if(pBstrDocString && This->DocString)
2087 {
2088 *pBstrDocString = SysAllocString(This->DocString);
2089
2090 if (!(*pBstrDocString)) return STG_E_INSUFFICIENTMEMORY;
2091 }
2092
2093 if(pdwHelpContext)
2094 {
2095 *pdwHelpContext = This->dwHelpContext;
2096 }
2097 if(pBstrHelpFile && This->HelpFile)
2098 {
2099 *pBstrHelpFile = SysAllocString(This->HelpFile);
2100
2101 if (!(*pBstrHelpFile)) return STG_E_INSUFFICIENTMEMORY;
2102 }
2103
2104 result = S_OK;
2105 }
2106 else
2107 {
2108 /* for a typeinfo */
2109 result = ITypeLib2_fnGetTypeInfo(iface, index, &pTInfo);
2110
2111 if(SUCCEEDED(result))
2112 {
2113 result = ITypeInfo_GetDocumentation(pTInfo,
2114 MEMBERID_NIL,
2115 pBstrName,
2116 pBstrDocString,
2117 pdwHelpContext, pBstrHelpFile);
2118
2119 ITypeInfo_Release(pTInfo);
2120 }
2121 }
2122 return result;
2123 }
2124
2125 /* ITypeLib::IsName
2126 *
2127 * Indicates whether a passed-in string contains the name of a type or member
2128 * described in the library.
2129 *
2130 */
2131 static HRESULT WINAPI ITypeLib2_fnIsName(
2132 ITypeLib2 *iface,
2133 LPOLESTR szNameBuf,
2134 ULONG lHashVal,
2135 BOOL *pfName)
2136 {
2137 ICOM_THIS( ITypeLibImpl, iface);
2138 ITypeInfoImpl *pTInfo;
2139 TLBFuncDesc *pFInfo;
2140 TLBVarDesc *pVInfo;
2141 int i;
2142 UINT nNameBufLen = SysStringLen(szNameBuf);
2143
2144 TRACE("(%p)->(%s,%08lx,%p)\n", This, debugstr_w(szNameBuf), lHashVal,
2145 pfName);
2146
2147 *pfName=TRUE;
2148 for(pTInfo=This->pTypeInfo;pTInfo;pTInfo=pTInfo->next){
2149 if(!memcmp(szNameBuf,pTInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
2150 for(pFInfo=pTInfo->funclist;pFInfo;pFInfo=pFInfo->next) {
2151 if(!memcmp(szNameBuf,pFInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
2152 for(i=0;i<pFInfo->funcdesc.cParams;i++)
2153 if(!memcmp(szNameBuf,pFInfo->pParamDesc[i].Name, nNameBufLen))
2154 goto ITypeLib2_fnIsName_exit;
2155 }
2156 for(pVInfo=pTInfo->varlist;pVInfo;pVInfo=pVInfo->next)
2157 if(!memcmp(szNameBuf,pVInfo->Name, nNameBufLen)) goto ITypeLib2_fnIsName_exit;
2158
2159 }
2160 *pfName=FALSE;
2161
2162 ITypeLib2_fnIsName_exit:
2163 TRACE("(%p)slow! search for %s: %s found!\n", This,
2164 debugstr_w(szNameBuf), *pfName?"NOT":"");
2165
2166 return S_OK;
2167 }
2168
2169 /* ITypeLib::FindName
2170 *
2171 * Finds occurrences of a type description in a type library. This may be used
2172 * to quickly verify that a name exists in a type library.
2173 *
2174 */
2175 static HRESULT WINAPI ITypeLib2_fnFindName(
2176 ITypeLib2 *iface,
2177 LPOLESTR szNameBuf,
2178 ULONG lHashVal,
2179 ITypeInfo **ppTInfo,
2180 MEMBERID *rgMemId,
2181 UINT16 *pcFound)
2182 {
2183 ICOM_THIS( ITypeLibImpl, iface);
2184 ITypeInfoImpl *pTInfo;
2185 TLBFuncDesc *pFInfo;
2186 TLBVarDesc *pVInfo;
2187 int i,j = 0;
2188
2189 UINT nNameBufLen = SysStringLen(szNameBuf);
2190
2191 for(pTInfo=This->pTypeInfo;pTInfo && j<*pcFound; pTInfo=pTInfo->next){
2192 if(!memcmp(szNameBuf,pTInfo->Name, nNameBufLen)) goto ITypeLib2_fnFindName_exit;
2193 for(pFInfo=pTInfo->funclist;pFInfo;pFInfo=pFInfo->next) {
2194 if(!memcmp(szNameBuf,pFInfo->Name,nNameBufLen)) goto ITypeLib2_fnFindName_exit;
2195 for(i=0;i<pFInfo->funcdesc.cParams;i++)
2196 if(!memcmp(szNameBuf,pFInfo->pParamDesc[i].Name,nNameBufLen))
2197 goto ITypeLib2_fnFindName_exit;
2198 }
2199 for(pVInfo=pTInfo->varlist;pVInfo;pVInfo=pVInfo->next)
2200 if(!memcmp(szNameBuf,pVInfo->Name, nNameBufLen)) goto ITypeLib2_fnFindName_exit;
2201 continue;
2202 ITypeLib2_fnFindName_exit:
2203 ITypeInfo_AddRef((ITypeInfo*)pTInfo);
2204 ppTInfo[j]=(LPTYPEINFO)pTInfo;
2205 j++;
2206 }
2207 TRACE("(%p)slow! search for %d with %s: found %d TypeInfo's!\n",
2208 This, *pcFound, debugstr_w(szNameBuf), j);
2209
2210 *pcFound=j;
2211
2212 return S_OK;
2213 }
2214
2215 /* ITypeLib::ReleaseTLibAttr
2216 *
2217 * Releases the TLIBATTR originally obtained from ITypeLib::GetLibAttr.
2218 *
2219 */
2220 static VOID WINAPI ITypeLib2_fnReleaseTLibAttr(
2221 ITypeLib2 *iface,
2222 TLIBATTR *pTLibAttr)
2223 {
2224 ICOM_THIS( ITypeLibImpl, iface);
2225 TRACE("freeing (%p)\n",This);
2226 /* nothing to do */
2227 }
2228
2229 /* ITypeLib2::GetCustData
2230 *
2231 * gets the custom data
2232 */
2233 static HRESULT WINAPI ITypeLib2_fnGetCustData(
2234 ITypeLib2 * iface,
2235 REFGUID guid,
2236 VARIANT *pVarVal)
2237 {
2238 ICOM_THIS( ITypeLibImpl, iface);
2239 TLBCustData *pCData;
2240
2241 for(pCData=This->pCustData; pCData; pCData = pCData->next)
2242 {
2243 if( IsEqualIID(guid, &pCData->guid)) break;
2244 }
2245
2246 TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
2247
2248 if(pCData)
2249 {
2250 VariantInit( pVarVal);
2251 VariantCopy( pVarVal, &pCData->data);
2252 return S_OK;
2253 }
2254 return E_INVALIDARG; /* FIXME: correct? */
2255 }
2256
2257 /* ITypeLib2::GetLibStatistics
2258 *
2259 * Returns statistics about a type library that are required for efficient
2260 * sizing of hash tables.
2261 *
2262 */
2263 static HRESULT WINAPI ITypeLib2_fnGetLibStatistics(
2264 ITypeLib2 * iface,
2265 ULONG *pcUniqueNames,
2266 ULONG *pcchUniqueNames)
2267 {
2268 ICOM_THIS( ITypeLibImpl, iface);
2269
2270 FIXME("(%p): stub!\n", This);
2271
2272 if(pcUniqueNames) *pcUniqueNames=1;
2273 if(pcchUniqueNames) *pcchUniqueNames=1;
2274 return S_OK;
2275 }
2276
2277 /* ITypeLib2::GetDocumentation2
2278 *
2279 * Retrieves the library's documentation string, the complete Help file name
2280 * and path, the localization context to use, and the context ID for the
2281 * library Help topic in the Help file.
2282 *
2283 */
2284 static HRESULT WINAPI ITypeLib2_fnGetDocumentation2(
2285 ITypeLib2 * iface,
2286 INT index,
2287 LCID lcid,
2288 BSTR *pbstrHelpString,
2289 DWORD *pdwHelpStringContext,
2290 BSTR *pbstrHelpStringDll)
2291 {
2292 ICOM_THIS( ITypeLibImpl, iface);
2293 HRESULT result;
2294 ITypeInfo *pTInfo;
2295
2296 FIXME("(%p) index %d lcid %ld half implemented stub!\n", This, index, lcid);
2297
2298 /* the help string should be obtained from the helpstringdll,
2299 * using the _DLLGetDocumentation function, based on the supplied
2300 * lcid. Nice to do sometime...
2301 */
2302 if(index<0)
2303 {
2304 /* documentation for the typelib */
2305 if(pbstrHelpString)
2306 *pbstrHelpString=SysAllocString(This->DocString);
2307 if(pdwHelpStringContext)
2308 *pdwHelpStringContext=This->dwHelpContext;
2309 if(pbstrHelpStringDll)
2310 *pbstrHelpStringDll=SysAllocString(This->HelpStringDll);
2311
2312 result = S_OK;
2313 }
2314 else
2315 {
2316 /* for a typeinfo */
2317 result=ITypeLib2_GetTypeInfo(iface, index, &pTInfo);
2318
2319 if(SUCCEEDED(result))
2320 {
2321 ITypeInfo2 * pTInfo2;
2322 result = ITypeInfo_QueryInterface(pTInfo,
2323 &IID_ITypeInfo2,
2324 (LPVOID*) &pTInfo2);
2325
2326 if(SUCCEEDED(result))
2327 {
2328 result = ITypeInfo2_GetDocumentation2(pTInfo2,
2329 MEMBERID_NIL,
2330 lcid,
2331 pbstrHelpString,
2332 pdwHelpStringContext,
2333 pbstrHelpStringDll);
2334
2335 ITypeInfo2_Release(pTInfo2);
2336 }
2337
2338 ITypeInfo_Release(pTInfo);
2339 }
2340 }
2341 return result;
2342 }
2343
2344 /* ITypeLib2::GetAllCustData
2345 *
2346 * Gets all custom data items for the library.
2347 *
2348 */
2349 static HRESULT WINAPI ITypeLib2_fnGetAllCustData(
2350 ITypeLib2 * iface,
2351 CUSTDATA *pCustData)
2352 {
2353 ICOM_THIS( ITypeLibImpl, iface);
2354 TLBCustData *pCData;
2355 int i;
2356 TRACE("(%p) returning %d items\n", This, This->ctCustData);
2357 pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
2358 if(pCustData->prgCustData ){
2359 pCustData->cCustData=This->ctCustData;
2360 for(i=0, pCData=This->pCustData; pCData; i++, pCData = pCData->next){
2361 pCustData->prgCustData[i].guid=pCData->guid;
2362 VariantCopy(& pCustData->prgCustData[i].varValue, & pCData->data);
2363 }
2364 }else{
2365 ERR(" OUT OF MEMORY! \n");
2366 return E_OUTOFMEMORY;
2367 }
2368 return S_OK;
2369 }
2370
2371 static ICOM_VTABLE(ITypeLib2) tlbvt = {
2372 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2373 ITypeLib2_fnQueryInterface,
2374 ITypeLib2_fnAddRef,
2375 ITypeLib2_fnRelease,
2376 ITypeLib2_fnGetTypeInfoCount,
2377 ITypeLib2_fnGetTypeInfo,
2378 ITypeLib2_fnGetTypeInfoType,
2379 ITypeLib2_fnGetTypeInfoOfGuid,
2380 ITypeLib2_fnGetLibAttr,
2381 ITypeLib2_fnGetTypeComp,
2382 ITypeLib2_fnGetDocumentation,
2383 ITypeLib2_fnIsName,
2384 ITypeLib2_fnFindName,
2385 ITypeLib2_fnReleaseTLibAttr,
2386
2387 ITypeLib2_fnGetCustData,
2388 ITypeLib2_fnGetLibStatistics,
2389 ITypeLib2_fnGetDocumentation2,
2390 ITypeLib2_fnGetAllCustData
2391 };
2392
2393 /*================== ITypeInfo(2) Methods ===================================*/
2394 static ITypeInfo2 * WINAPI ITypeInfo_Constructor(void)
2395 {
2396 ITypeInfoImpl * pTypeInfoImpl;
2397
2398 pTypeInfoImpl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(ITypeInfoImpl));
2399 if (pTypeInfoImpl)
2400 {
2401 ICOM_VTBL(pTypeInfoImpl) = &tinfvt;
2402 pTypeInfoImpl->ref=1;
2403 }
2404 TRACE("(%p)\n", pTypeInfoImpl);
2405 return (ITypeInfo2*) pTypeInfoImpl;
2406 }
2407
2408 /* ITypeInfo::QueryInterface
2409 */
2410 static HRESULT WINAPI ITypeInfo_fnQueryInterface(
2411 ITypeInfo2 *iface,
2412 REFIID riid,
2413 VOID **ppvObject)
2414 {
2415 ICOM_THIS( ITypeLibImpl, iface);
2416
2417 TRACE("(%p)->(IID: %s)\n",This,debugstr_guid(riid));
2418
2419 *ppvObject=NULL;
2420 if(IsEqualIID(riid, &IID_IUnknown) ||
2421 IsEqualIID(riid,&IID_ITypeInfo)||
2422 IsEqualIID(riid,&IID_ITypeInfo2))
2423 *ppvObject = This;
2424
2425 if(*ppvObject){
2426 ITypeInfo_AddRef(iface);
2427 TRACE("-- Interface: (%p)->(%p)\n",ppvObject,*ppvObject);
2428 return S_OK;
2429 }
2430 TRACE("-- Interface: E_NOINTERFACE\n");
2431 return E_NOINTERFACE;
2432 }
2433
2434 /* ITypeInfo::AddRef
2435 */
2436 static ULONG WINAPI ITypeInfo_fnAddRef( ITypeInfo2 *iface)
2437 {
2438 ICOM_THIS( ITypeInfoImpl, iface);
2439
2440 ++(This->ref);
2441
2442 TRACE("(%p)->ref is %u\n",This, This->ref);
2443 return This->ref;
2444 }
2445
2446 /* ITypeInfo::Release
2447 */
2448 static ULONG WINAPI ITypeInfo_fnRelease( ITypeInfo2 *iface)
2449 {
2450 ICOM_THIS( ITypeInfoImpl, iface);
2451
2452 --(This->ref);
2453
2454 TRACE("(%p)->(%u)\n",This, This->ref);
2455
2456 if (!This->ref)
2457 {
2458 FIXME("destroy child objects\n");
2459
2460 TRACE("destroying ITypeInfo(%p)\n",This);
2461 if (This->Name)
2462 {
2463 SysFreeString(This->Name);
2464 This->Name = 0;
2465 }
2466
2467 if (This->DocString)
2468 {
2469 SysFreeString(This->DocString);
2470 This->DocString = 0;
2471 }
2472
2473 if (This->next)
2474 {
2475 ITypeInfo_Release((ITypeInfo*)This->next);
2476 }
2477
2478 HeapFree(GetProcessHeap(),0,This);
2479 return 0;
2480 }
2481 return This->ref;
2482 }
2483
2484 /* ITypeInfo::GetTypeAttr
2485 *
2486 * Retrieves a TYPEATTR structure that contains the attributes of the type
2487 * description.
2488 *
2489 */
2490 static HRESULT WINAPI ITypeInfo_fnGetTypeAttr( ITypeInfo2 *iface,
2491 LPTYPEATTR *ppTypeAttr)
2492 {
2493 ICOM_THIS( ITypeInfoImpl, iface);
2494 TRACE("(%p)\n",This);
2495 /* FIXME: must do a copy here */
2496 *ppTypeAttr=&This->TypeAttr;
2497 return S_OK;
2498 }
2499
2500 /* ITypeInfo::GetTypeComp
2501 *
2502 * Retrieves the ITypeComp interface for the type description, which enables a
2503 * client compiler to bind to the type description's members.
2504 *
2505 */
2506 static HRESULT WINAPI ITypeInfo_fnGetTypeComp( ITypeInfo2 *iface,
2507 ITypeComp * *ppTComp)
2508 {
2509 ICOM_THIS( ITypeInfoImpl, iface);
2510 FIXME("(%p) stub!\n", This);
2511 return S_OK;
2512 }
2513
2514 /* ITypeInfo::GetFuncDesc
2515 *
2516 * Retrieves the FUNCDESC structure that contains information about a
2517 * specified function.
2518 *
2519 */
2520 static HRESULT WINAPI ITypeInfo_fnGetFuncDesc( ITypeInfo2 *iface, UINT index,
2521 LPFUNCDESC *ppFuncDesc)
2522 {
2523 ICOM_THIS( ITypeInfoImpl, iface);
2524 int i;
2525 TLBFuncDesc * pFDesc;
2526 TRACE("(%p) index %d\n", This, index);
2527 for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++, pFDesc=pFDesc->next)
2528 ;
2529 if(pFDesc){
2530 /* FIXME: must do a copy here */
2531 *ppFuncDesc=&pFDesc->funcdesc;
2532 return S_OK;
2533 }
2534 return E_INVALIDARG;
2535 }
2536
2537 /* ITypeInfo::GetVarDesc
2538 *
2539 * Retrieves a VARDESC structure that describes the specified variable.
2540 *
2541 */
2542 static HRESULT WINAPI ITypeInfo_fnGetVarDesc( ITypeInfo2 *iface, UINT index,
2543 LPVARDESC *ppVarDesc)
2544 {
2545 ICOM_THIS( ITypeInfoImpl, iface);
2546 int i;
2547 TLBVarDesc * pVDesc;
2548 TRACE("(%p) index %d\n", This, index);
2549 for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++, pVDesc=pVDesc->next)
2550 ;
2551 if(pVDesc){
2552 /* FIXME: must do a copy here */
2553 *ppVarDesc=&pVDesc->vardesc;
2554 return S_OK;
2555 }
2556 return E_INVALIDARG;
2557 }
2558
2559 /* ITypeInfo_GetNames
2560 *
2561 * Retrieves the variable with the specified member ID (or the name of the
2562 * property or method and its parameters) that correspond to the specified
2563 * function ID.
2564 */
2565 static HRESULT WINAPI ITypeInfo_fnGetNames( ITypeInfo2 *iface, MEMBERID memid,
2566 BSTR *rgBstrNames, UINT cMaxNames, UINT *pcNames)
2567 {
2568 ICOM_THIS( ITypeInfoImpl, iface);
2569 TLBFuncDesc * pFDesc;
2570 TLBVarDesc * pVDesc;
2571 int i;
2572 TRACE("(%p) memid=0x%08lx Maxname=%d\n", This, memid, cMaxNames);
2573 for(pFDesc=This->funclist; pFDesc && pFDesc->funcdesc.memid != memid; pFDesc=pFDesc->next);
2574 if(pFDesc)
2575 {
2576 /* function found, now return function and parameter names */
2577 for(i=0; i<cMaxNames && i <= pFDesc->funcdesc.cParams; i++)
2578 {
2579 if(!i)
2580 *rgBstrNames=SysAllocString(pFDesc->Name);
2581 else
2582 rgBstrNames[i]=SysAllocString(pFDesc->pParamDesc[i-1].Name);
2583 }
2584 *pcNames=i;
2585 }
2586 else
2587 {
2588 for(pVDesc=This->varlist; pVDesc && pVDesc->vardesc.memid != memid; pVDesc=pVDesc->next);
2589 if(pVDesc)
2590 {
2591 *rgBstrNames=SysAllocString(pVDesc->Name);
2592 *pcNames=1;
2593 }
2594 else
2595 {
2596 if(This->TypeAttr.typekind==TKIND_INTERFACE && This->TypeAttr.cImplTypes )
2597 {
2598 /* recursive search */
2599 ITypeInfo *pTInfo;
2600 HRESULT result;
2601 result=ITypeInfo_GetRefTypeInfo(iface, This->impltypelist->reference, &pTInfo);
2602 if(SUCCEEDED(result))
2603 {
2604 result=ITypeInfo_GetNames(pTInfo, memid, rgBstrNames, cMaxNames, pcNames);
2605 ITypeInfo_Release(pTInfo);
2606 return result;
2607 }
2608 WARN("Could not search inherited interface!\n");
2609 }
2610 else
2611 {
2612 WARN("no names found\n");
2613 }
2614 *pcNames=0;
2615 return TYPE_E_ELEMENTNOTFOUND;
2616 }
2617 }
2618 return S_OK;
2619 }
2620
2621
2622 /* ITypeInfo::GetRefTypeOfImplType
2623 *
2624 * If a type description describes a COM class, it retrieves the type
2625 * description of the implemented interface types. For an interface,
2626 * GetRefTypeOfImplType returns the type information for inherited interfaces,
2627 * if any exist.
2628 *
2629 */
2630 static HRESULT WINAPI ITypeInfo_fnGetRefTypeOfImplType(
2631 ITypeInfo2 *iface,
2632 UINT index,
2633 HREFTYPE *pRefType)
2634 {
2635 ICOM_THIS( ITypeInfoImpl, iface);
2636 int(i);
2637 TLBRefType *pIref = This->impltypelist;
2638
2639 TRACE("(%p) index %d\n", This, index);
2640 dump_TypeInfo(This);
2641
2642 if(index==(UINT)-1)
2643 {
2644 /* only valid on dual interfaces;
2645 retrieve the associated TKIND_INTERFACE handle for the current TKIND_DISPATCH
2646 */
2647 if( This->TypeAttr.typekind != TKIND_DISPATCH) return E_INVALIDARG;
2648
2649 if (This->TypeAttr.wTypeFlags & TYPEFLAG_FDISPATCHABLE &&
2650 This->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL )
2651 {
2652 *pRefType = -1;
2653 }
2654 else
2655 {
2656 if (!pIref) return TYPE_E_ELEMENTNOTFOUND;
2657 *pRefType = pIref->reference;
2658 }
2659 }
2660 else
2661 {
2662 /* get element n from linked list */
2663 for(i=0; pIref && i<index; i++)
2664 {
2665 pIref = pIref->next;
2666 }
2667
2668 if (!pIref) return TYPE_E_ELEMENTNOTFOUND;
2669
2670 *pRefType = pIref->reference;
2671
2672 TRACE("-- 0x%08lx %s\n",pIref->reference, debugstr_guid(&pIref->guid) );
2673 }
2674
2675 return S_OK;
2676
2677 }
2678
2679 /* ITypeInfo::GetImplTypeFlags
2680 *
2681 * Retrieves the IMPLTYPEFLAGS enumeration for one implemented interface
2682 * or base interface in a type description.
2683 */
2684 static HRESULT WINAPI ITypeInfo_fnGetImplTypeFlags( ITypeInfo2 *iface,
2685 UINT index, INT *pImplTypeFlags)
2686 {
2687 ICOM_THIS( ITypeInfoImpl, iface);
2688 int(i);
2689 TLBRefType *pIref;
2690 TRACE("(%p) index %d\n", This, index);
2691 for(i=0, pIref=This->impltypelist; i<index && pIref; i++, pIref=pIref->next)
2692 ;
2693 if(i==index && pIref){
2694 *pImplTypeFlags=pIref->flags;
2695 return S_OK;
2696 }
2697 *pImplTypeFlags=0;
2698 return TYPE_E_ELEMENTNOTFOUND;
2699 }
2700
2701 /* GetIDsOfNames
2702 * Maps between member names and member IDs, and parameter names and
2703 * parameter IDs.
2704 */
2705 static HRESULT WINAPI ITypeInfo_fnGetIDsOfNames( ITypeInfo2 *iface,
2706 LPOLESTR *rgszNames, UINT cNames, MEMBERID *pMemId)
2707 {
2708 ICOM_THIS( ITypeInfoImpl, iface);
2709 TLBFuncDesc * pFDesc;
2710 TLBVarDesc * pVDesc;
2711 HRESULT ret=S_OK;
2712 UINT nNameLen = SysStringLen(*rgszNames);
2713
2714 TRACE("(%p) Name %s cNames %d\n", This, debugstr_w(*rgszNames),
2715 cNames);
2716 for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next) {
2717 int i, j;
2718 if( !memcmp(*rgszNames, pFDesc->Name, nNameLen)) {
2719 if(cNames) *pMemId=pFDesc->funcdesc.memid;
2720 for(i=1; i < cNames; i++){
2721 UINT nParamLen = SysStringLen(rgszNames[i]);
2722 for(j=0; j<pFDesc->funcdesc.cParams; j++)
2723 if(memcmp(rgszNames[i],pFDesc->pParamDesc[j].Name, nParamLen))
2724 break;
2725 if( j<pFDesc->funcdesc.cParams)
2726 pMemId[i]=j;
2727 else
2728 ret=DISP_E_UNKNOWNNAME;
2729 };
2730 return ret;
2731 }
2732 }
2733 for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next) {
2734 if( !memcmp(*rgszNames, pVDesc->Name, nNameLen)) {
2735 if(cNames) *pMemId=pVDesc->vardesc.memid;
2736 return ret;
2737 }
2738 }
2739 /* not found, see if this is and interface with an inheritance */
2740 if(This->TypeAttr.typekind==TKIND_INTERFACE &&
2741 This->TypeAttr.cImplTypes ){
2742 /* recursive search */
2743 ITypeInfo *pTInfo;
2744 ret=ITypeInfo_GetRefTypeInfo(iface,
2745 This->impltypelist->reference, &pTInfo);
2746 if(SUCCEEDED(ret)){
2747 ret=ITypeInfo_GetIDsOfNames(pTInfo, rgszNames, cNames, pMemId );
2748 ITypeInfo_Release(pTInfo);
2749 return ret;
2750 }
2751 WARN("Could not search inherited interface!\n");
2752 } else
2753 WARN("no names found\n");
2754 return DISP_E_UNKNOWNNAME;
2755 }
2756
2757 /* ITypeInfo::Invoke
2758 *
2759 * Invokes a method, or accesses a property of an object, that implements the
2760 * interface described by the type description.
2761 */
2762 static HRESULT WINAPI ITypeInfo_fnInvoke(
2763 ITypeInfo2 *iface,
2764 VOID *pIUnk,
2765 MEMBERID memid,
2766 UINT16 dwFlags,
2767 DISPPARAMS *pDispParams,
2768 VARIANT *pVarResult,
2769 EXCEPINFO *pExcepInfo,
2770 UINT *pArgErr)
2771 {
2772 ICOM_THIS( ITypeInfoImpl, iface);
2773 FIXME("(%p)(%p,id=0x%08lx,0x%08x,%p,%p,%p,%p) stub!\n",
2774 This, pIUnk, memid, dwFlags, pDispParams, pVarResult, pExcepInfo, pArgErr );
2775 dump_DispParms(pDispParams);
2776 return S_OK;
2777 }
2778
2779 /* ITypeInfo::GetDocumentation
2780 *
2781 * Retrieves the documentation string, the complete Help file name and path,
2782 * and the context ID for the Help topic for a specified type description.
2783 */
2784 static HRESULT WINAPI ITypeInfo_fnGetDocumentation( ITypeInfo2 *iface,
2785 MEMBERID memid, BSTR *pBstrName, BSTR *pBstrDocString,
2786 DWORD *pdwHelpContext, BSTR *pBstrHelpFile)
2787 {
2788 ICOM_THIS( ITypeInfoImpl, iface);
2789 TLBFuncDesc * pFDesc;
2790 TLBVarDesc * pVDesc;
2791 TRACE("(%p) memid %ld Name(%p) DocString(%p)"
2792 " HelpContext(%p) HelpFile(%p)\n",
2793 This, memid, pBstrName, pBstrDocString, pdwHelpContext, pBstrHelpFile);
2794 if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
2795 if(pBstrName)
2796 *pBstrName=SysAllocString(This->Name);
2797 if(pBstrDocString)
2798 *pBstrDocString=SysAllocString(This->DocString);
2799 if(pdwHelpContext)
2800 *pdwHelpContext=This->dwHelpContext;
2801 if(pBstrHelpFile)
2802 *pBstrHelpFile=SysAllocString(This->DocString);/* FIXME */
2803 return S_OK;
2804 }else {/* for a member */
2805 for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
2806 if(pFDesc->funcdesc.memid==memid){
2807 return S_OK;
2808 }
2809 for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next)
2810 if(pVDesc->vardesc.memid==memid){
2811 return S_OK;
2812 }
2813 }
2814 return TYPE_E_ELEMENTNOTFOUND;
2815 }
2816
2817 /* ITypeInfo::GetDllEntry
2818 *
2819 * Retrieves a description or specification of an entry point for a function
2820 * in a DLL.
2821 */
2822 static HRESULT WINAPI ITypeInfo_fnGetDllEntry( ITypeInfo2 *iface, MEMBERID memid,
2823 INVOKEKIND invKind, BSTR *pBstrDllName, BSTR *pBstrName,
2824 WORD *pwOrdinal)
2825 {
2826 ICOM_THIS( ITypeInfoImpl, iface);
2827 FIXME("(%p) stub!\n", This);
2828 return E_FAIL;
2829 }
2830
2831 /* ITypeInfo::GetRefTypeInfo
2832 *
2833 * If a type description references other type descriptions, it retrieves
2834 * the referenced type descriptions.
2835 */
2836 static HRESULT WINAPI ITypeInfo_fnGetRefTypeInfo(
2837 ITypeInfo2 *iface,
2838 HREFTYPE hRefType,
2839 ITypeInfo **ppTInfo)
2840 {
2841 ICOM_THIS( ITypeInfoImpl, iface);
2842 HRESULT result = E_FAIL;
2843
2844 if(HREFTYPE_INTHISFILE(hRefType))
2845 {
2846 ITypeLib *pTLib;
2847 int Index;
2848 result = ITypeInfo_GetContainingTypeLib(iface, &pTLib, &Index);
2849 if(SUCCEEDED( result ))
2850 {
2851 result=ITypeLib2_GetTypeInfo(pTLib, HREFTYPE_INDEX(hRefType), ppTInfo);
2852 ITypeLib2_Release(pTLib );
2853 }
2854 }
2855 else if (hRefType == -1 &&
2856 (((ITypeInfoImpl*) This)->TypeAttr.typekind == TKIND_DISPATCH) &&
2857 (((ITypeInfoImpl*) This)->TypeAttr.wTypeFlags & TYPEFLAG_FDUAL))
2858 {
2859 /* when we meet a DUAL dispinterface, we must create the interface
2860 * version of it.
2861 */
2862 ITypeInfoImpl* pTypeInfoImpl = (ITypeInfoImpl*) ITypeInfo_Constructor();
2863
2864
2865 /* the interface version contains the same information as the dispinterface
2866 * copy the contents of the structs.
2867 */
2868 *pTypeInfoImpl = *This;
2869 pTypeInfoImpl->ref = 1;
2870
2871 /* change the type to interface */
2872 pTypeInfoImpl->TypeAttr.typekind = TKIND_INTERFACE;
2873
2874 *ppTInfo = (ITypeInfo*) pTypeInfoImpl;
2875
2876 ITypeInfo_AddRef((ITypeInfo*) pTypeInfoImpl);
2877
2878 result = S_OK;
2879 }
2880 else
2881 {
2882 /* imported type lib */
2883 TLBRefType *pRefType = NULL;
2884
2885 /* search in implemented types */
2886 for( pRefType = This->impltypelist;
2887 pRefType && (pRefType->reference != hRefType);
2888 pRefType = pRefType->next);
2889
2890 if(!pRefType)
2891 {
2892 TYPEATTR* pMyTypeAttr = &This->TypeAttr;
2893 unsigned short cFuncs = pMyTypeAttr->cFuncs;
2894 unsigned short cVars = pMyTypeAttr->cVars;
2895
2896 /* search in arguments */
2897 if (cFuncs > 0)
2898 {
2899 unsigned short cFuncIndex = 0;
2900
2901 TLBFuncDesc* pCurrFunc = This->funclist;
2902
2903 for (cFuncIndex = 0; !pRefType && cFuncIndex < cFuncs ; ++cFuncIndex)
2904 {
2905 FUNCDESC* pCurrFuncDesc = &pCurrFunc->funcdesc;
2906
2907 short cParams = pCurrFuncDesc->cParams;
2908 short cParamIndex = 0;
2909
2910 for (cParamIndex = 0 ;
2911 !pRefType && cParamIndex < cParams ;
2912 ++cParamIndex)
2913 {
2914 TLBParDesc* pCurrParamDesc = &(pCurrFunc->pParamDesc[cParamIndex]);
2915
2916 if ( pCurrParamDesc->pRefType && pCurrParamDesc->pRefType->reference == hRefType)
2917 {
2918 pRefType = pCurrParamDesc->pRefType;
2919 break; /* also break from outer loop since pRefType != 0 */
2920 }
2921 }
2922
2923 pCurrFunc = pCurrFunc->next;
2924 }
2925 }
2926 /* search in variables */
2927 else if (cVars > 0)
2928 {
2929 FIXME("search hreftype in variables, if any\n");
2930 result = E_INVALIDARG; // FIXME : correct?
2931 }
2932 }
2933
2934 /* href-referenced typeinfo found! */
2935 if (pRefType || hRefType == -1)
2936 {
2937 ITypeLibImpl *pTypeLib = pRefType->pImpTLInfo->pImpTypeLib;
2938
2939 if(pTypeLib)
2940 {
2941 TRACE("typeinfo in imported typelib that is already loaded\n");
2942
2943 result = ITypeLib2_GetTypeInfoOfGuid((LPTYPELIB)pTypeLib,
2944 &pRefType->guid,
2945 ppTInfo);
2946 }
2947 else
2948 {
2949 result = LoadRegTypeLib( &pRefType->pImpTLInfo->guid,
2950 pRefType->pImpTLInfo->wVersionMajor,
2951 pRefType->pImpTLInfo->wVersionMinor,
2952 pRefType->pImpTLInfo->lcid,
2953 (LPTYPELIB *)&pTypeLib);
2954
2955 if(!SUCCEEDED(result))
2956 {
2957 BSTR libnam=SysAllocString(pRefType->pImpTLInfo->name);
2958 TRACE("typeinfo in imported typelib that isn't already loaded\n");
2959 result=LoadTypeLib(libnam, (LPTYPELIB *)&pTypeLib);
2960 SysFreeString(libnam);
2961 }
2962 if(SUCCEEDED(result))
2963 {
2964 result=ITypeLib2_GetTypeInfoOfGuid((LPTYPELIB)pTypeLib, &pRefType->guid, ppTInfo);
2965 pRefType->pImpTLInfo->pImpTypeLib = pTypeLib;
2966 ITypeLib2_AddRef((ITypeLib*) pTypeLib);
2967 }
2968 }
2969 }
2970 }
2971
2972 TRACE("(%p) hreftype 0x%04lx loaded %s (%p)\n", This, hRefType,
2973 SUCCEEDED(result)? "SUCCESS":"FAILURE", *ppTInfo);
2974 return result;
2975 }
2976
2977 /* ITypeInfo::AddressOfMember
2978 *
2979 * Retrieves the addresses of static functions or variables, such as those
2980 * defined in a DLL.
2981 */
2982 static HRESULT WINAPI ITypeInfo_fnAddressOfMember( ITypeInfo2 *iface,
2983 MEMBERID memid, INVOKEKIND invKind, PVOID *ppv)
2984 {
2985 ICOM_THIS( ITypeInfoImpl, iface);
2986 FIXME("(%p) stub!\n", This);
2987 return S_OK;
2988 }
2989
2990 /* ITypeInfo::CreateInstance
2991 *
2992 * Creates a new instance of a type that describes a component object class
2993 * (coclass).
2994 */
2995 static HRESULT WINAPI ITypeInfo_fnCreateInstance( ITypeInfo2 *iface,
2996 IUnknown *pUnk, REFIID riid, VOID **ppvObj)
2997 {
2998 ICOM_THIS( ITypeInfoImpl, iface);
2999 FIXME("(%p) stub!\n", This);
3000 return S_OK;
3001 }
3002
3003 /* ITypeInfo::GetMops
3004 *
3005 * Retrieves marshaling information.
3006 */
3007 static HRESULT WINAPI ITypeInfo_fnGetMops( ITypeInfo2 *iface, MEMBERID memid,
3008 BSTR *pBstrMops)
3009 {
3010 ICOM_THIS( ITypeInfoImpl, iface);
3011 FIXME("(%p) stub!\n", This);
3012 return S_OK;
3013 }
3014
3015 /* ITypeInfo::GetContainingTypeLib
3016 *
3017 * Retrieves the containing type library and the index of the type description
3018 * within that type library.
3019 */
3020 static HRESULT WINAPI ITypeInfo_fnGetContainingTypeLib( ITypeInfo2 *iface,
3021 ITypeLib * *ppTLib, UINT *pIndex)
3022 {
3023 ICOM_THIS( ITypeInfoImpl, iface);
3024 if (!pIndex)
3025 return E_INVALIDARG;
3026 *ppTLib=(LPTYPELIB )(This->pTypeLib);
3027 *pIndex=This->index;
3028 ITypeLib2_AddRef(*ppTLib);
3029 TRACE("(%p) returns (%p) index %d!\n", This, *ppTLib, *pIndex);
3030 return S_OK;
3031 }
3032
3033 /* ITypeInfo::ReleaseTypeAttr
3034 *
3035 * Releases a TYPEATTR previously returned by GetTypeAttr.
3036 *
3037 */
3038 static HRESULT WINAPI ITypeInfo_fnReleaseTypeAttr( ITypeInfo2 *iface,
3039 TYPEATTR* pTypeAttr)
3040 {
3041 ICOM_THIS( ITypeInfoImpl, iface);
3042 TRACE("(%p)->(%p)\n", This, pTypeAttr);
3043 return S_OK;
3044 }
3045
3046 /* ITypeInfo::ReleaseFuncDesc
3047 *
3048 * Releases a FUNCDESC previously returned by GetFuncDesc. *
3049 */
3050 static HRESULT WINAPI ITypeInfo_fnReleaseFuncDesc(
3051 ITypeInfo2 *iface,
3052 FUNCDESC *pFuncDesc)
3053 {
3054 ICOM_THIS( ITypeInfoImpl, iface);
3055 TRACE("(%p)->(%p)\n", This, pFuncDesc);
3056 return S_OK;
3057 }
3058
3059 /* ITypeInfo::ReleaseVarDesc
3060 *
3061 * Releases a VARDESC previously returned by GetVarDesc.
3062 */
3063 static HRESULT WINAPI ITypeInfo_fnReleaseVarDesc( ITypeInfo2 *iface,
3064 VARDESC *pVarDesc)
3065 {
3066 ICOM_THIS( ITypeInfoImpl, iface);
3067 TRACE("(%p)->(%p)\n", This, pVarDesc);
3068 return S_OK;
3069 }
3070
3071 /* ITypeInfo2::GetTypeKind
3072 *
3073 * Returns the TYPEKIND enumeration quickly, without doing any allocations.
3074 *
3075 */
3076 static HRESULT WINAPI ITypeInfo2_fnGetTypeKind( ITypeInfo2 * iface,
3077 TYPEKIND *pTypeKind)
3078 {
3079 ICOM_THIS( ITypeInfoImpl, iface);
3080 *pTypeKind=This->TypeAttr.typekind;
3081 TRACE("(%p) type 0x%0x\n", This,*pTypeKind);
3082 return S_OK;
3083 }
3084
3085 /* ITypeInfo2::GetTypeFlags
3086 *
3087 * Returns the type flags without any allocations. This returns a DWORD type
3088 * flag, which expands the type flags without growing the TYPEATTR (type
3089 * attribute).
3090 *
3091 */
3092 static HRESULT WINAPI ITypeInfo2_fnGetTypeFlags( ITypeInfo2 * iface,
3093 UINT *pTypeFlags)
3094 {
3095 ICOM_THIS( ITypeInfoImpl, iface);
3096 *pTypeFlags=This->TypeAttr.wTypeFlags;
3097 TRACE("(%p) flags 0x%04x\n", This,*pTypeFlags);
3098 return S_OK;
3099 }
3100
3101 /* ITypeInfo2::GetFuncIndexOfMemId
3102 * Binds to a specific member based on a known DISPID, where the member name
3103 * is not known (for example, when binding to a default member).
3104 *
3105 */
3106 static HRESULT WINAPI ITypeInfo2_fnGetFuncIndexOfMemId( ITypeInfo2 * iface,
3107 MEMBERID memid, INVOKEKIND invKind, UINT *pFuncIndex)
3108 {
3109 ICOM_THIS( ITypeInfoImpl, iface);
3110 TLBFuncDesc *pFuncInfo;
3111 int i;
3112 HRESULT result;
3113 /* FIXME: should check for invKind??? */
3114 for(i=0, pFuncInfo=This->funclist;pFuncInfo &&
3115 memid != pFuncInfo->funcdesc.memid; i++, pFuncInfo=pFuncInfo->next);
3116 if(pFuncInfo){
3117 *pFuncIndex=i;
3118 result= S_OK;
3119 }else{
3120 *pFuncIndex=0;
3121 result=E_INVALIDARG;
3122 }
3123 TRACE("(%p) memid 0x%08lx invKind 0x%04x -> %s\n", This,
3124 memid, invKind, SUCCEEDED(result)? "SUCCES":"FAILED");
3125 return result;
3126 }
3127
3128 /* TypeInfo2::GetVarIndexOfMemId
3129 *
3130 * Binds to a specific member based on a known DISPID, where the member name
3131 * is not known (for example, when binding to a default member).
3132 *
3133 */
3134 static HRESULT WINAPI ITypeInfo2_fnGetVarIndexOfMemId( ITypeInfo2 * iface,
3135 MEMBERID memid, UINT *pVarIndex)
3136 {
3137 ICOM_THIS( ITypeInfoImpl, iface);
3138 TLBVarDesc *pVarInfo;
3139 int i;
3140 HRESULT result;
3141 for(i=0, pVarInfo=This->varlist; pVarInfo &&
3142 memid != pVarInfo->vardesc.memid; i++, pVarInfo=pVarInfo->next)
3143 ;
3144 if(pVarInfo){
3145 *pVarIndex=i;
3146 result= S_OK;
3147 }else{
3148 *pVarIndex=0;
3149 result=E_INVALIDARG;
3150 }
3151 TRACE("(%p) memid 0x%08lx -> %s\n", This,
3152 memid, SUCCEEDED(result)? "SUCCES":"FAILED");
3153 return result;
3154 }
3155
3156 /* ITypeInfo2::GetCustData
3157 *
3158 * Gets the custom data
3159 */
3160 static HRESULT WINAPI ITypeInfo2_fnGetCustData(
3161 ITypeInfo2 * iface,
3162 REFGUID guid,
3163 VARIANT *pVarVal)
3164 {
3165 ICOM_THIS( ITypeInfoImpl, iface);
3166 TLBCustData *pCData;
3167
3168 for(pCData=This->pCustData; pCData; pCData = pCData->next)
3169 if( IsEqualIID(guid, &pCData->guid)) break;
3170
3171 TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
3172
3173 if(pCData)
3174 {
3175 VariantInit( pVarVal);
3176 VariantCopy( pVarVal, &pCData->data);
3177 return S_OK;
3178 }
3179 return E_INVALIDARG; /* FIXME: correct? */
3180 }
3181
3182 /* ITypeInfo2::GetFuncCustData
3183 *
3184 * Gets the custom data
3185 */
3186 static HRESULT WINAPI ITypeInfo2_fnGetFuncCustData(
3187 ITypeInfo2 * iface,
3188 UINT index,
3189 REFGUID guid,
3190 VARIANT *pVarVal)
3191 {
3192 ICOM_THIS( ITypeInfoImpl, iface);
3193 TLBCustData *pCData=NULL;
3194 TLBFuncDesc * pFDesc;
3195 int i;
3196 for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
3197 pFDesc=pFDesc->next);
3198
3199 if(pFDesc)
3200 for(pCData=pFDesc->pCustData; pCData; pCData = pCData->next)
3201 if( IsEqualIID(guid, &pCData->guid)) break;
3202
3203 TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
3204
3205 if(pCData){
3206 VariantInit( pVarVal);
3207 VariantCopy( pVarVal, &pCData->data);
3208 return S_OK;
3209 }
3210 return E_INVALIDARG; /* FIXME: correct? */
3211 }
3212
3213 /* ITypeInfo2::GetParamCustData
3214 *
3215 * Gets the custom data
3216 */
3217 static HRESULT WINAPI ITypeInfo2_fnGetParamCustData(
3218 ITypeInfo2 * iface,
3219 UINT indexFunc,
3220 UINT indexParam,
3221 REFGUID guid,
3222 VARIANT *pVarVal)
3223 {
3224 ICOM_THIS( ITypeInfoImpl, iface);
3225 TLBCustData *pCData=NULL;
3226 TLBFuncDesc * pFDesc;
3227 int i;
3228
3229 for(i=0, pFDesc=This->funclist; i!=indexFunc && pFDesc; i++,pFDesc=pFDesc->next);
3230
3231 if(pFDesc && indexParam >=0 && indexParam<pFDesc->funcdesc.cParams)
3232 for(pCData=pFDesc->pParamDesc[indexParam].pCustData; pCData;
3233 pCData = pCData->next)
3234 if( IsEqualIID(guid, &pCData->guid)) break;
3235
3236 TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
3237
3238 if(pCData)
3239 {
3240 VariantInit( pVarVal);
3241 VariantCopy( pVarVal, &pCData->data);
3242 return S_OK;
3243 }
3244 return E_INVALIDARG; /* FIXME: correct? */
3245 }
3246
3247 /* ITypeInfo2::GetVarcCustData
3248 *
3249 * Gets the custom data
3250 */
3251 static HRESULT WINAPI ITypeInfo2_fnGetVarCustData(
3252 ITypeInfo2 * iface,
3253 UINT index,
3254 REFGUID guid,
3255 VARIANT *pVarVal)
3256 {
3257 ICOM_THIS( ITypeInfoImpl, iface);
3258 TLBCustData *pCData=NULL;
3259 TLBVarDesc * pVDesc;
3260 int i;
3261
3262 for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++, pVDesc=pVDesc->next);
3263
3264 if(pVDesc)
3265 {
3266 for(pCData=pVDesc->pCustData; pCData; pCData = pCData->next)
3267 {
3268 if( IsEqualIID(guid, &pCData->guid)) break;
3269 }
3270 }
3271
3272 TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
3273
3274 if(pCData)
3275 {
3276 VariantInit( pVarVal);
3277 VariantCopy( pVarVal, &pCData->data);
3278 return S_OK;
3279 }
3280 return E_INVALIDARG; /* FIXME: correct? */
3281 }
3282
3283 /* ITypeInfo2::GetImplcCustData
3284 *
3285 * Gets the custom data
3286 */
3287 static HRESULT WINAPI ITypeInfo2_fnGetImplTypeCustData(
3288 ITypeInfo2 * iface,
3289 UINT index,
3290 REFGUID guid,
3291 VARIANT *pVarVal)
3292 {
3293 ICOM_THIS( ITypeInfoImpl, iface);
3294 TLBCustData *pCData=NULL;
3295 TLBRefType * pRDesc;
3296 int i;
3297
3298 for(i=0, pRDesc=This->impltypelist; i!=index && pRDesc; i++, pRDesc=pRDesc->next);
3299
3300 if(pRDesc)
3301 {
3302 for(pCData=pRDesc->pCustData; pCData; pCData = pCData->next)
3303 {
3304 if( IsEqualIID(guid, &pCData->guid)) break;
3305 }
3306 }
3307
3308 TRACE("(%p) guid %s %s found!x)\n", This, debugstr_guid(guid), pCData? "" : "NOT");
3309
3310 if(pCData)
3311 {
3312 VariantInit( pVarVal);
3313 VariantCopy( pVarVal, &pCData->data);
3314 return S_OK;
3315 }
3316 return E_INVALIDARG; /* FIXME: correct? */
3317 }
3318
3319 /* ITypeInfo2::GetDocumentation2
3320 *
3321 * Retrieves the documentation string, the complete Help file name and path,
3322 * the localization context to use, and the context ID for the library Help
3323 * topic in the Help file.
3324 *
3325 */
3326 static HRESULT WINAPI ITypeInfo2_fnGetDocumentation2(
3327 ITypeInfo2 * iface,
3328 MEMBERID memid,
3329 LCID lcid,
3330 BSTR *pbstrHelpString,
3331 DWORD *pdwHelpStringContext,
3332 BSTR *pbstrHelpStringDll)
3333 {
3334 ICOM_THIS( ITypeInfoImpl, iface);
3335 TLBFuncDesc * pFDesc;
3336 TLBVarDesc * pVDesc;
3337 TRACE("(%p) memid %ld lcid(0x%lx) HelpString(%p) "
3338 "HelpStringContext(%p) HelpStringDll(%p)\n",
3339 This, memid, lcid, pbstrHelpString, pdwHelpStringContext,
3340 pbstrHelpStringDll );
3341 /* the help string should be obtained from the helpstringdll,
3342 * using the _DLLGetDocumentation function, based on the supplied
3343 * lcid. Nice to do sometime...
3344 */
3345 if(memid==MEMBERID_NIL){ /* documentation for the typeinfo */
3346 if(pbstrHelpString)
3347 *pbstrHelpString=SysAllocString(This->Name);
3348 if(pdwHelpStringContext)
3349 *pdwHelpStringContext=This->dwHelpStringContext;
3350 if(pbstrHelpStringDll)
3351 *pbstrHelpStringDll=
3352 SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
3353 return S_OK;
3354 }else {/* for a member */
3355 for(pFDesc=This->funclist; pFDesc; pFDesc=pFDesc->next)
3356 if(pFDesc->funcdesc.memid==memid){
3357 if(pbstrHelpString)
3358 *pbstrHelpString=SysAllocString(pFDesc->HelpString);
3359 if(pdwHelpStringContext)
3360 *pdwHelpStringContext=pFDesc->HelpStringContext;
3361 if(pbstrHelpStringDll)
3362 *pbstrHelpStringDll=
3363 SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
3364 return S_OK;
3365 }
3366 for(pVDesc=This->varlist; pVDesc; pVDesc=pVDesc->next)
3367 if(pVDesc->vardesc.memid==memid){
3368 if(pbstrHelpString)
3369 *pbstrHelpString=SysAllocString(pVDesc->HelpString);
3370 if(pdwHelpStringContext)
3371 *pdwHelpStringContext=pVDesc->HelpStringContext;
3372 if(pbstrHelpStringDll)
3373 *pbstrHelpStringDll=
3374 SysAllocString(This->pTypeLib->HelpStringDll);/* FIXME */
3375 return S_OK;
3376 }
3377 }
3378 return TYPE_E_ELEMENTNOTFOUND;
3379 }
3380
3381 /* ITypeInfo2::GetAllCustData
3382 *
3383 * Gets all custom data items for the Type info.
3384 *
3385 */
3386 static HRESULT WINAPI ITypeInfo2_fnGetAllCustData(
3387 ITypeInfo2 * iface,
3388 CUSTDATA *pCustData)
3389 {
3390 ICOM_THIS( ITypeInfoImpl, iface);
3391 TLBCustData *pCData;
3392 int i;
3393
3394 TRACE("(%p) returning %d items\n", This, This->ctCustData);
3395
3396 pCustData->prgCustData = TLB_Alloc(This->ctCustData * sizeof(CUSTDATAITEM));
3397 if(pCustData->prgCustData ){
3398 pCustData->cCustData=This->ctCustData;
3399 for(i=0, pCData=This->pCustData; pCData; i++, pCData = pCData->next){
3400 pCustData->prgCustData[i].guid=pCData->guid;
3401 VariantCopy(& pCustData->prgCustData[i].varValue, & pCData->data);
3402 }
3403 }else{
3404 ERR(" OUT OF MEMORY! \n");
3405 return E_OUTOFMEMORY;
3406 }
3407 return S_OK;
3408 }
3409
3410 /* ITypeInfo2::GetAllFuncCustData
3411 *
3412 * Gets all custom data items for the specified Function
3413 *
3414 */
3415 static HRESULT WINAPI ITypeInfo2_fnGetAllFuncCustData(
3416 ITypeInfo2 * iface,
3417 UINT index,
3418 CUSTDATA *pCustData)
3419 {
3420 ICOM_THIS( ITypeInfoImpl, iface);
3421 TLBCustData *pCData;
3422 TLBFuncDesc * pFDesc;
3423 int i;
3424 TRACE("(%p) index %d\n", This, index);
3425 for(i=0, pFDesc=This->funclist; i!=index && pFDesc; i++,
3426 pFDesc=pFDesc->next)
3427 ;
3428 if(pFDesc){
3429 pCustData->prgCustData =
3430 TLB_Alloc(pFDesc->ctCustData * sizeof(CUSTDATAITEM));
3431 if(pCustData->prgCustData ){
3432 pCustData->cCustData=pFDesc->ctCustData;
3433 for(i=0, pCData=pFDesc->pCustData; pCData; i++,
3434 pCData = pCData->next){
3435 pCustData->prgCustData[i].guid=pCData->guid;
3436 VariantCopy(& pCustData->prgCustData[i].varValue,
3437 & pCData->data);
3438 }
3439 }else{
3440 ERR(" OUT OF MEMORY! \n");
3441 return E_OUTOFMEMORY;
3442 }
3443 return S_OK;
3444 }
3445 return TYPE_E_ELEMENTNOTFOUND;
3446 }
3447
3448 /* ITypeInfo2::GetAllParamCustData
3449 *
3450 * Gets all custom data items for the Functions
3451 *
3452 */
3453 static HRESULT WINAPI ITypeInfo2_fnGetAllParamCustData( ITypeInfo2 * iface,
3454 UINT indexFunc, UINT indexParam, CUSTDATA *pCustData)
3455 {
3456 ICOM_THIS( ITypeInfoImpl, iface);
3457 TLBCustData *pCData=NULL;
3458 TLBFuncDesc * pFDesc;
3459 int i;
3460 TRACE("(%p) index %d\n", This, indexFunc);
3461 for(i=0, pFDesc=This->funclist; i!=indexFunc && pFDesc; i++,
3462 pFDesc=pFDesc->next)
3463 ;
3464 if(pFDesc && indexParam >=0 && indexParam<pFDesc->funcdesc.cParams){
3465 pCustData->prgCustData =
3466 TLB_Alloc(pFDesc->pParamDesc[indexParam].ctCustData *
3467 sizeof(CUSTDATAITEM));
3468 if(pCustData->prgCustData ){
3469 pCustData->cCustData=pFDesc->pParamDesc[indexParam].ctCustData;
3470 for(i=0, pCData=pFDesc->pParamDesc[indexParam].pCustData;
3471 pCData; i++, pCData = pCData->next){
3472 pCustData->prgCustData[i].guid=pCData->guid;
3473 VariantCopy(& pCustData->prgCustData[i].varValue,
3474 & pCData->data);
3475 }
3476 }else{
3477 ERR(" OUT OF MEMORY! \n");
3478 return E_OUTOFMEMORY;
3479 }
3480 return S_OK;
3481 }
3482 return TYPE_E_ELEMENTNOTFOUND;
3483 }
3484
3485 /* ITypeInfo2::GetAllVarCustData
3486 *
3487 * Gets all custom data items for the specified Variable
3488 *
3489 */
3490 static HRESULT WINAPI ITypeInfo2_fnGetAllVarCustData( ITypeInfo2 * iface,
3491 UINT index, CUSTDATA *pCustData)
3492 {
3493 ICOM_THIS( ITypeInfoImpl, iface);
3494 TLBCustData *pCData;
3495 TLBVarDesc * pVDesc;
3496 int i;
3497 TRACE("(%p) index %d\n", This, index);
3498 for(i=0, pVDesc=This->varlist; i!=index && pVDesc; i++,
3499 pVDesc=pVDesc->next)
3500 ;
3501 if(pVDesc){
3502 pCustData->prgCustData =
3503 TLB_Alloc(pVDesc->ctCustData * sizeof(CUSTDATAITEM));
3504 if(pCustData->prgCustData ){
3505 pCustData->cCustData=pVDesc->ctCustData;
3506 for(i=0, pCData=pVDesc->pCustData; pCData; i++,
3507 pCData = pCData->next){
3508 pCustData->prgCustData[i].guid=pCData->guid;
3509 VariantCopy(& pCustData->prgCustData[i].varValue,
3510 & pCData->data);
3511 }
3512 }else{
3513 ERR(" OUT OF MEMORY! \n");
3514 return E_OUTOFMEMORY;
3515 }
3516 return S_OK;
3517 }
3518 return TYPE_E_ELEMENTNOTFOUND;
3519 }
3520
3521 /* ITypeInfo2::GetAllImplCustData
3522 *
3523 * Gets all custom data items for the specified implementation type
3524 *
3525 */
3526 static HRESULT WINAPI ITypeInfo2_fnGetAllImplTypeCustData(
3527 ITypeInfo2 * iface,
3528 UINT index,
3529 CUSTDATA *pCustData)
3530 {
3531 ICOM_THIS( ITypeInfoImpl, iface);
3532 TLBCustData *pCData;
3533 TLBRefType * pRDesc;
3534 int i;
3535 TRACE("(%p) index %d\n", This, index);
3536 for(i=0, pRDesc=This->impltypelist; i!=index && pRDesc; i++,
3537 pRDesc=pRDesc->next)
3538 ;
3539 if(pRDesc){
3540 pCustData->prgCustData =
3541 TLB_Alloc(pRDesc->ctCustData * sizeof(CUSTDATAITEM));
3542 if(pCustData->prgCustData ){
3543 pCustData->cCustData=pRDesc->ctCustData;
3544 for(i=0, pCData=pRDesc->pCustData; pCData; i++,
3545 pCData = pCData->next){
3546 pCustData->prgCustData[i].guid=pCData->guid;
3547 VariantCopy(& pCustData->prgCustData[i].varValue,
3548 & pCData->data);
3549 }
3550 }else{
3551 ERR(" OUT OF MEMORY! \n");
3552 return E_OUTOFMEMORY;
3553 }
3554 return S_OK;
3555 }
3556 return TYPE_E_ELEMENTNOTFOUND;
3557 }
3558
3559 static ICOM_VTABLE(ITypeInfo2) tinfvt =
3560 {
3561 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
3562
3563 ITypeInfo_fnQueryInterface,
3564 ITypeInfo_fnAddRef,
3565 ITypeInfo_fnRelease,
3566
3567 ITypeInfo_fnGetTypeAttr,
3568 ITypeInfo_fnGetTypeComp,
3569 ITypeInfo_fnGetFuncDesc,
3570 ITypeInfo_fnGetVarDesc,
3571 ITypeInfo_fnGetNames,
3572 ITypeInfo_fnGetRefTypeOfImplType,
3573 ITypeInfo_fnGetImplTypeFlags,
3574 ITypeInfo_fnGetIDsOfNames,
3575 ITypeInfo_fnInvoke,
3576 ITypeInfo_fnGetDocumentation,
3577 ITypeInfo_fnGetDllEntry,
3578 ITypeInfo_fnGetRefTypeInfo,
3579 ITypeInfo_fnAddressOfMember,
3580 ITypeInfo_fnCreateInstance,
3581 ITypeInfo_fnGetMops,
3582 ITypeInfo_fnGetContainingTypeLib,
3583 ITypeInfo_fnReleaseTypeAttr,
3584 ITypeInfo_fnReleaseFuncDesc,
3585 ITypeInfo_fnReleaseVarDesc,
3586
3587 ITypeInfo2_fnGetTypeKind,
3588 ITypeInfo2_fnGetTypeFlags,
3589 ITypeInfo2_fnGetFuncIndexOfMemId,
3590 ITypeInfo2_fnGetVarIndexOfMemId,
3591 ITypeInfo2_fnGetCustData,
3592 ITypeInfo2_fnGetFuncCustData,
3593 ITypeInfo2_fnGetParamCustData,
3594 ITypeInfo2_fnGetVarCustData,
3595 ITypeInfo2_fnGetImplTypeCustData,
3596 ITypeInfo2_fnGetDocumentation2,
3597 ITypeInfo2_fnGetAllCustData,
3598 ITypeInfo2_fnGetAllFuncCustData,
3599 ITypeInfo2_fnGetAllParamCustData,
3600 ITypeInfo2_fnGetAllVarCustData,
3601 ITypeInfo2_fnGetAllImplTypeCustData,
3602 };
Maarten's multimedia branch