![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to com_wrapper.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / com_dotnet|
Return to com_wrapper.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / com_dotnet |
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
1.1.1.3 ! misho 5: | Copyright (c) 1997-2013 The PHP Group |
1.1 misho 6: +----------------------------------------------------------------------+
7: | This source file is subject to version 3.01 of the PHP license, |
8: | that is bundled with this package in the file LICENSE, and is |
9: | available through the world-wide-web at the following url: |
10: | http://www.php.net/license/3_01.txt |
11: | If you did not receive a copy of the PHP license and are unable to |
12: | obtain it through the world-wide-web, please send a note to |
13: | license@php.net so we can mail you a copy immediately. |
14: +----------------------------------------------------------------------+
15: | Author: Wez Furlong <wez@thebrainroom.com> |
16: +----------------------------------------------------------------------+
17: */
18:
1.1.1.2 misho 19: /* $Id$ */
1.1 misho 20:
21: /* This module exports a PHP object as a COM object by wrapping it
22: * using IDispatchEx */
23:
24: #ifdef HAVE_CONFIG_H
25: #include "config.h"
26: #endif
27:
28: #include "php.h"
29: #include "php_ini.h"
30: #include "ext/standard/info.h"
31: #include "php_com_dotnet.h"
32: #include "php_com_dotnet_internal.h"
33:
34: typedef struct {
35: /* This first part MUST match the declaration
36: * of interface IDispatchEx */
37: CONST_VTBL struct IDispatchExVtbl *lpVtbl;
38:
39: /* now the PHP stuff */
40:
41: DWORD engine_thread; /* for sanity checking */
42: zval *object; /* the object exported */
43: LONG refcount; /* COM reference count */
44:
45: HashTable *dispid_to_name; /* keep track of dispid -> name mappings */
46: HashTable *name_to_dispid; /* keep track of name -> dispid mappings */
47:
48: GUID sinkid; /* iid that we "implement" for event sinking */
49:
50: int id;
51: } php_dispatchex;
52:
53: static int le_dispatch;
54:
1.1.1.2 misho 55: static void disp_destructor(php_dispatchex *disp TSRMLS_DC);
1.1 misho 56:
57: static void dispatch_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
58: {
59: php_dispatchex *disp = (php_dispatchex *)rsrc->ptr;
1.1.1.2 misho 60: disp_destructor(disp TSRMLS_CC);
1.1 misho 61: }
62:
63: int php_com_wrapper_minit(INIT_FUNC_ARGS)
64: {
65: le_dispatch = zend_register_list_destructors_ex(dispatch_dtor,
66: NULL, "com_dotnet_dispatch_wrapper", module_number);
67: return le_dispatch;
68: }
69:
70:
71: /* {{{ trace */
72: static inline void trace(char *fmt, ...)
73: {
74: va_list ap;
75: char buf[4096];
76:
77: snprintf(buf, sizeof(buf), "T=%08x ", GetCurrentThreadId());
78: OutputDebugString(buf);
79:
80: va_start(ap, fmt);
81: vsnprintf(buf, sizeof(buf), fmt, ap);
82:
83: OutputDebugString(buf);
84:
85: va_end(ap);
86: }
87: /* }}} */
88:
89: #define FETCH_DISP(methname) \
90: php_dispatchex *disp = (php_dispatchex*)This; \
1.1.1.2 misho 91: TSRMLS_FETCH(); \
1.1 misho 92: if (COMG(rshutdown_started)) { \
93: trace(" PHP Object:%p (name:unknown) %s\n", disp->object, methname); \
94: } else { \
95: trace(" PHP Object:%p (name:%s) %s\n", disp->object, Z_OBJCE_P(disp->object)->name, methname); \
96: } \
97: if (GetCurrentThreadId() != disp->engine_thread) { \
98: return RPC_E_WRONG_THREAD; \
99: }
100:
101: static HRESULT STDMETHODCALLTYPE disp_queryinterface(
102: IDispatchEx *This,
103: /* [in] */ REFIID riid,
104: /* [iid_is][out] */ void **ppvObject)
105: {
106: FETCH_DISP("QueryInterface");
107:
108: if (IsEqualGUID(&IID_IUnknown, riid) ||
109: IsEqualGUID(&IID_IDispatch, riid) ||
110: IsEqualGUID(&IID_IDispatchEx, riid) ||
111: IsEqualGUID(&disp->sinkid, riid)) {
112: *ppvObject = This;
113: InterlockedIncrement(&disp->refcount);
114: return S_OK;
115: }
116:
117: *ppvObject = NULL;
118: return E_NOINTERFACE;
119: }
120:
121: static ULONG STDMETHODCALLTYPE disp_addref(IDispatchEx *This)
122: {
123: FETCH_DISP("AddRef");
124:
125: return InterlockedIncrement(&disp->refcount);
126: }
127:
128: static ULONG STDMETHODCALLTYPE disp_release(IDispatchEx *This)
129: {
130: ULONG ret;
131: FETCH_DISP("Release");
132:
133: ret = InterlockedDecrement(&disp->refcount);
134: trace("-- refcount now %d\n", ret);
135: if (ret == 0) {
136: /* destroy it */
137: if (disp->id)
138: zend_list_delete(disp->id);
139: }
140: return ret;
141: }
142:
143: static HRESULT STDMETHODCALLTYPE disp_gettypeinfocount(
144: IDispatchEx *This,
145: /* [out] */ UINT *pctinfo)
146: {
147: FETCH_DISP("GetTypeInfoCount");
148:
149: *pctinfo = 0;
150: return S_OK;
151: }
152:
153: static HRESULT STDMETHODCALLTYPE disp_gettypeinfo(
154: IDispatchEx *This,
155: /* [in] */ UINT iTInfo,
156: /* [in] */ LCID lcid,
157: /* [out] */ ITypeInfo **ppTInfo)
158: {
159: FETCH_DISP("GetTypeInfo");
160:
161: *ppTInfo = NULL;
162: return DISP_E_BADINDEX;
163: }
164:
165: static HRESULT STDMETHODCALLTYPE disp_getidsofnames(
166: IDispatchEx *This,
167: /* [in] */ REFIID riid,
168: /* [size_is][in] */ LPOLESTR *rgszNames,
169: /* [in] */ UINT cNames,
170: /* [in] */ LCID lcid,
171: /* [size_is][out] */ DISPID *rgDispId)
172: {
173: UINT i;
174: HRESULT ret = S_OK;
175: FETCH_DISP("GetIDsOfNames");
176:
177: for (i = 0; i < cNames; i++) {
178: char *name;
179: unsigned int namelen;
180: zval **tmp;
181:
182: name = php_com_olestring_to_string(rgszNames[i], &namelen, COMG(code_page) TSRMLS_CC);
183:
184: /* Lookup the name in the hash */
185: if (zend_hash_find(disp->name_to_dispid, name, namelen+1, (void**)&tmp) == FAILURE) {
186: ret = DISP_E_UNKNOWNNAME;
187: rgDispId[i] = 0;
188: } else {
189: rgDispId[i] = Z_LVAL_PP(tmp);
190: }
191:
192: efree(name);
193:
194: }
195:
196: return ret;
197: }
198:
199: static HRESULT STDMETHODCALLTYPE disp_invoke(
200: IDispatchEx *This,
201: /* [in] */ DISPID dispIdMember,
202: /* [in] */ REFIID riid,
203: /* [in] */ LCID lcid,
204: /* [in] */ WORD wFlags,
205: /* [out][in] */ DISPPARAMS *pDispParams,
206: /* [out] */ VARIANT *pVarResult,
207: /* [out] */ EXCEPINFO *pExcepInfo,
208: /* [out] */ UINT *puArgErr)
209: {
210: return This->lpVtbl->InvokeEx(This, dispIdMember,
211: lcid, wFlags, pDispParams,
212: pVarResult, pExcepInfo, NULL);
213: }
214:
215: static HRESULT STDMETHODCALLTYPE disp_getdispid(
216: IDispatchEx *This,
217: /* [in] */ BSTR bstrName,
218: /* [in] */ DWORD grfdex,
219: /* [out] */ DISPID *pid)
220: {
221: HRESULT ret = DISP_E_UNKNOWNNAME;
222: char *name;
223: unsigned int namelen;
224: zval **tmp;
225: FETCH_DISP("GetDispID");
226:
227: name = php_com_olestring_to_string(bstrName, &namelen, COMG(code_page) TSRMLS_CC);
228:
229: trace("Looking for %s, namelen=%d in %p\n", name, namelen, disp->name_to_dispid);
230:
231: /* Lookup the name in the hash */
232: if (zend_hash_find(disp->name_to_dispid, name, namelen+1, (void**)&tmp) == SUCCESS) {
233: trace("found it\n");
234: *pid = Z_LVAL_PP(tmp);
235: ret = S_OK;
236: }
237:
238: efree(name);
239:
240: return ret;
241: }
242:
243: static HRESULT STDMETHODCALLTYPE disp_invokeex(
244: IDispatchEx *This,
245: /* [in] */ DISPID id,
246: /* [in] */ LCID lcid,
247: /* [in] */ WORD wFlags,
248: /* [in] */ DISPPARAMS *pdp,
249: /* [out] */ VARIANT *pvarRes,
250: /* [out] */ EXCEPINFO *pei,
251: /* [unique][in] */ IServiceProvider *pspCaller)
252: {
253: zval **name;
254: UINT i;
255: zval *retval = NULL;
256: zval ***params = NULL;
257: HRESULT ret = DISP_E_MEMBERNOTFOUND;
258: FETCH_DISP("InvokeEx");
259:
260: if (SUCCESS == zend_hash_index_find(disp->dispid_to_name, id, (void**)&name)) {
261: /* TODO: add support for overloaded objects */
262:
263: trace("-- Invoke: %d %20s [%d] flags=%08x args=%d\n", id, Z_STRVAL_PP(name), Z_STRLEN_PP(name), wFlags, pdp->cArgs);
264:
265: /* convert args into zvals.
266: * Args are in reverse order */
267: if (pdp->cArgs) {
268: params = (zval ***)safe_emalloc(sizeof(zval **), pdp->cArgs, 0);
269: for (i = 0; i < pdp->cArgs; i++) {
270: VARIANT *arg;
271: zval *zarg;
272:
273: arg = &pdp->rgvarg[ pdp->cArgs - 1 - i];
274:
275: trace("alloc zval for arg %d VT=%08x\n", i, V_VT(arg));
276:
277: ALLOC_INIT_ZVAL(zarg);
278: php_com_wrap_variant(zarg, arg, COMG(code_page) TSRMLS_CC);
279: params[i] = (zval**)emalloc(sizeof(zval**));
280: *params[i] = zarg;
281: }
282: }
283:
284: trace("arguments processed, prepare to do some work\n");
285:
286: /* TODO: if PHP raises an exception here, we should catch it
287: * and expose it as a COM exception */
288:
289: if (wFlags & DISPATCH_PROPERTYGET) {
290: retval = zend_read_property(Z_OBJCE_P(disp->object), disp->object, Z_STRVAL_PP(name), Z_STRLEN_PP(name)+1, 1 TSRMLS_CC);
291: } else if (wFlags & DISPATCH_PROPERTYPUT) {
292: zend_update_property(Z_OBJCE_P(disp->object), disp->object, Z_STRVAL_PP(name), Z_STRLEN_PP(name)+1, *params[0] TSRMLS_CC);
293: } else if (wFlags & DISPATCH_METHOD) {
294: zend_try {
295: if (SUCCESS == call_user_function_ex(EG(function_table), &disp->object, *name,
296: &retval, pdp->cArgs, params, 1, NULL TSRMLS_CC)) {
297: ret = S_OK;
298: trace("function called ok\n");
299:
300: /* Copy any modified values to callers copy of variant*/
301: for (i = 0; i < pdp->cArgs; i++) {
302: php_com_dotnet_object *obj = CDNO_FETCH(*params[i]);
303: VARIANT *srcvar = &obj->v;
304: VARIANT *dstvar = &pdp->rgvarg[ pdp->cArgs - 1 - i];
305: if ((V_VT(dstvar) & VT_BYREF) && obj->modified ) {
306: trace("percolate modified value for arg %d VT=%08x\n", i, V_VT(dstvar));
307: php_com_copy_variant(dstvar, srcvar TSRMLS_CC);
308: }
309: }
310: } else {
311: trace("failed to call func\n");
312: ret = DISP_E_EXCEPTION;
313: }
314: } zend_catch {
315: trace("something blew up\n");
316: ret = DISP_E_EXCEPTION;
317: } zend_end_try();
318: } else {
319: trace("Don't know how to handle this invocation %08x\n", wFlags);
320: }
321:
322: /* release arguments */
323: if (params) {
324: for (i = 0; i < pdp->cArgs; i++) {
325: zval_ptr_dtor(params[i]);
326: efree(params[i]);
327: }
328: efree(params);
329: }
330:
331: /* return value */
332: if (retval) {
333: if (pvarRes) {
334: VariantInit(pvarRes);
335: php_com_variant_from_zval(pvarRes, retval, COMG(code_page) TSRMLS_CC);
336: }
337: zval_ptr_dtor(&retval);
338: } else if (pvarRes) {
339: VariantInit(pvarRes);
340: }
341:
342: } else {
343: trace("InvokeEx: I don't support DISPID=%d\n", id);
344: }
345:
346: return ret;
347: }
348:
349: static HRESULT STDMETHODCALLTYPE disp_deletememberbyname(
350: IDispatchEx *This,
351: /* [in] */ BSTR bstrName,
352: /* [in] */ DWORD grfdex)
353: {
354: FETCH_DISP("DeleteMemberByName");
355:
356: /* TODO: unset */
357:
358: return S_FALSE;
359: }
360:
361: static HRESULT STDMETHODCALLTYPE disp_deletememberbydispid(
362: IDispatchEx *This,
363: /* [in] */ DISPID id)
364: {
365: FETCH_DISP("DeleteMemberByDispID");
366:
367: /* TODO: unset */
368:
369: return S_FALSE;
370: }
371:
372: static HRESULT STDMETHODCALLTYPE disp_getmemberproperties(
373: IDispatchEx *This,
374: /* [in] */ DISPID id,
375: /* [in] */ DWORD grfdexFetch,
376: /* [out] */ DWORD *pgrfdex)
377: {
378: FETCH_DISP("GetMemberProperties");
379:
380: return DISP_E_UNKNOWNNAME;
381: }
382:
383: static HRESULT STDMETHODCALLTYPE disp_getmembername(
384: IDispatchEx *This,
385: /* [in] */ DISPID id,
386: /* [out] */ BSTR *pbstrName)
387: {
388: zval *name;
389: FETCH_DISP("GetMemberName");
390:
391: if (SUCCESS == zend_hash_index_find(disp->dispid_to_name, id, (void**)&name)) {
392: OLECHAR *olestr = php_com_string_to_olestring(Z_STRVAL_P(name), Z_STRLEN_P(name), COMG(code_page) TSRMLS_CC);
393: *pbstrName = SysAllocString(olestr);
394: efree(olestr);
395: return S_OK;
396: } else {
397: return DISP_E_UNKNOWNNAME;
398: }
399: }
400:
401: static HRESULT STDMETHODCALLTYPE disp_getnextdispid(
402: IDispatchEx *This,
403: /* [in] */ DWORD grfdex,
404: /* [in] */ DISPID id,
405: /* [out] */ DISPID *pid)
406: {
407: ulong next = id+1;
408: FETCH_DISP("GetNextDispID");
409:
410: while(!zend_hash_index_exists(disp->dispid_to_name, next))
411: next++;
412:
413: if (zend_hash_index_exists(disp->dispid_to_name, next)) {
414: *pid = next;
415: return S_OK;
416: }
417: return S_FALSE;
418: }
419:
420: static HRESULT STDMETHODCALLTYPE disp_getnamespaceparent(
421: IDispatchEx *This,
422: /* [out] */ IUnknown **ppunk)
423: {
424: FETCH_DISP("GetNameSpaceParent");
425:
426: *ppunk = NULL;
427: return E_NOTIMPL;
428: }
429:
430: static struct IDispatchExVtbl php_dispatch_vtbl = {
431: disp_queryinterface,
432: disp_addref,
433: disp_release,
434: disp_gettypeinfocount,
435: disp_gettypeinfo,
436: disp_getidsofnames,
437: disp_invoke,
438: disp_getdispid,
439: disp_invokeex,
440: disp_deletememberbyname,
441: disp_deletememberbydispid,
442: disp_getmemberproperties,
443: disp_getmembername,
444: disp_getnextdispid,
445: disp_getnamespaceparent
446: };
447:
448:
449: /* enumerate functions and properties of the object and assign
450: * dispatch ids */
451: static void generate_dispids(php_dispatchex *disp TSRMLS_DC)
452: {
453: HashPosition pos;
454: char *name = NULL;
455: zval *tmp;
456: int namelen;
457: int keytype;
458: ulong pid;
459:
460: if (disp->dispid_to_name == NULL) {
461: ALLOC_HASHTABLE(disp->dispid_to_name);
462: ALLOC_HASHTABLE(disp->name_to_dispid);
463: zend_hash_init(disp->name_to_dispid, 0, NULL, ZVAL_PTR_DTOR, 0);
464: zend_hash_init(disp->dispid_to_name, 0, NULL, ZVAL_PTR_DTOR, 0);
465: }
466:
467: /* properties */
468: if (Z_OBJPROP_P(disp->object)) {
469: zend_hash_internal_pointer_reset_ex(Z_OBJPROP_P(disp->object), &pos);
470: while (HASH_KEY_NON_EXISTANT != (keytype =
471: zend_hash_get_current_key_ex(Z_OBJPROP_P(disp->object), &name,
472: &namelen, &pid, 0, &pos))) {
473: char namebuf[32];
474: if (keytype == HASH_KEY_IS_LONG) {
475: snprintf(namebuf, sizeof(namebuf), "%d", pid);
476: name = namebuf;
477: namelen = strlen(namebuf)+1;
478: }
479:
480: zend_hash_move_forward_ex(Z_OBJPROP_P(disp->object), &pos);
481:
482: /* Find the existing id */
483: if (zend_hash_find(disp->name_to_dispid, name, namelen, (void**)&tmp) == SUCCESS)
484: continue;
485:
486: /* add the mappings */
487: MAKE_STD_ZVAL(tmp);
488: ZVAL_STRINGL(tmp, name, namelen-1, 1);
489: pid = zend_hash_next_free_element(disp->dispid_to_name);
490: zend_hash_index_update(disp->dispid_to_name, pid, (void*)&tmp, sizeof(zval *), NULL);
491:
492: MAKE_STD_ZVAL(tmp);
493: ZVAL_LONG(tmp, pid);
494: zend_hash_update(disp->name_to_dispid, name, namelen, (void*)&tmp, sizeof(zval *), NULL);
495: }
496: }
497:
498: /* functions */
499: if (Z_OBJCE_P(disp->object)) {
500: zend_hash_internal_pointer_reset_ex(&Z_OBJCE_P(disp->object)->function_table, &pos);
501: while (HASH_KEY_NON_EXISTANT != (keytype =
502: zend_hash_get_current_key_ex(&Z_OBJCE_P(disp->object)->function_table,
503: &name, &namelen, &pid, 0, &pos))) {
504:
505: char namebuf[32];
506: if (keytype == HASH_KEY_IS_LONG) {
507: snprintf(namebuf, sizeof(namebuf), "%d", pid);
508: name = namebuf;
509: namelen = strlen(namebuf) + 1;
510: }
511:
512: zend_hash_move_forward_ex(Z_OBJPROP_P(disp->object), &pos);
513:
514: /* Find the existing id */
515: if (zend_hash_find(disp->name_to_dispid, name, namelen, (void**)&tmp) == SUCCESS)
516: continue;
517:
518: /* add the mappings */
519: MAKE_STD_ZVAL(tmp);
520: ZVAL_STRINGL(tmp, name, namelen-1, 1);
521: pid = zend_hash_next_free_element(disp->dispid_to_name);
522: zend_hash_index_update(disp->dispid_to_name, pid, (void*)&tmp, sizeof(zval *), NULL);
523:
524: MAKE_STD_ZVAL(tmp);
525: ZVAL_LONG(tmp, pid);
526: zend_hash_update(disp->name_to_dispid, name, namelen, (void*)&tmp, sizeof(zval *), NULL);
527: }
528: }
529: }
530:
531: static php_dispatchex *disp_constructor(zval *object TSRMLS_DC)
532: {
533: php_dispatchex *disp = (php_dispatchex*)CoTaskMemAlloc(sizeof(php_dispatchex));
534:
535: trace("constructing a COM wrapper for PHP object %p (%s)\n", object, Z_OBJCE_P(object)->name);
536:
537: if (disp == NULL)
538: return NULL;
539:
540: memset(disp, 0, sizeof(php_dispatchex));
541:
542: disp->engine_thread = GetCurrentThreadId();
543: disp->lpVtbl = &php_dispatch_vtbl;
544: disp->refcount = 1;
545:
546:
547: if (object)
548: Z_ADDREF_P(object);
549: disp->object = object;
550:
1.1.1.2 misho 551: disp->id = zend_list_insert(disp, le_dispatch TSRMLS_CC);
1.1 misho 552:
553: return disp;
554: }
555:
1.1.1.2 misho 556: static void disp_destructor(php_dispatchex *disp TSRMLS_DC)
557: {
1.1 misho 558: /* Object store not available during request shutdown */
559: if (COMG(rshutdown_started)) {
560: trace("destroying COM wrapper for PHP object %p (name:unknown)\n", disp->object);
561: } else {
562: trace("destroying COM wrapper for PHP object %p (name:%s)\n", disp->object, Z_OBJCE_P(disp->object)->name);
563: }
564:
565: disp->id = 0;
566:
567: if (disp->refcount > 0)
568: CoDisconnectObject((IUnknown*)disp, 0);
569:
570: zend_hash_destroy(disp->dispid_to_name);
571: zend_hash_destroy(disp->name_to_dispid);
572: FREE_HASHTABLE(disp->dispid_to_name);
573: FREE_HASHTABLE(disp->name_to_dispid);
574:
575: if (disp->object)
576: zval_ptr_dtor(&disp->object);
577:
578: CoTaskMemFree(disp);
579: }
580:
1.1.1.3 ! misho 581: PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export_as_sink(zval *val, GUID *sinkid,
1.1 misho 582: HashTable *id_to_name TSRMLS_DC)
583: {
584: php_dispatchex *disp = disp_constructor(val TSRMLS_CC);
585: HashPosition pos;
586: char *name = NULL;
587: zval *tmp, **ntmp;
588: int namelen;
589: int keytype;
590: ulong pid;
591:
592: disp->dispid_to_name = id_to_name;
593:
594: memcpy(&disp->sinkid, sinkid, sizeof(disp->sinkid));
595:
596: /* build up the reverse mapping */
597: ALLOC_HASHTABLE(disp->name_to_dispid);
598: zend_hash_init(disp->name_to_dispid, 0, NULL, ZVAL_PTR_DTOR, 0);
599:
600: zend_hash_internal_pointer_reset_ex(id_to_name, &pos);
601: while (HASH_KEY_NON_EXISTANT != (keytype =
602: zend_hash_get_current_key_ex(id_to_name, &name, &namelen, &pid, 0, &pos))) {
603:
604: if (keytype == HASH_KEY_IS_LONG) {
605:
606: zend_hash_get_current_data_ex(id_to_name, (void**)&ntmp, &pos);
607:
608: MAKE_STD_ZVAL(tmp);
609: ZVAL_LONG(tmp, pid);
610: zend_hash_update(disp->name_to_dispid, Z_STRVAL_PP(ntmp),
611: Z_STRLEN_PP(ntmp)+1, (void*)&tmp, sizeof(zval *), NULL);
612: }
613:
614: zend_hash_move_forward_ex(id_to_name, &pos);
615: }
616:
617: return (IDispatch*)disp;
618: }
619:
1.1.1.3 ! misho 620: PHP_COM_DOTNET_API IDispatch *php_com_wrapper_export(zval *val TSRMLS_DC)
1.1 misho 621: {
622: php_dispatchex *disp = NULL;
623:
624: if (Z_TYPE_P(val) != IS_OBJECT) {
625: return NULL;
626: }
627:
628: if (php_com_is_valid_object(val TSRMLS_CC)) {
629: /* pass back its IDispatch directly */
630: php_com_dotnet_object *obj = CDNO_FETCH(val);
631:
632: if (obj == NULL)
633: return NULL;
634:
635: if (V_VT(&obj->v) == VT_DISPATCH && V_DISPATCH(&obj->v)) {
636: IDispatch_AddRef(V_DISPATCH(&obj->v));
637: return V_DISPATCH(&obj->v);
638: }
639:
640: return NULL;
641: }
642:
643: disp = disp_constructor(val TSRMLS_CC);
644: generate_dispids(disp TSRMLS_CC);
645:
646: return (IDispatch*)disp;
647: }
648:
649: