xref: /PHP-7.1/ext/com_dotnet/com_handlers.c (revision ccd4716e)
1 /*
2    +----------------------------------------------------------------------+
3    | PHP Version 7                                                        |
4    +----------------------------------------------------------------------+
5    | Copyright (c) 1997-2018 The PHP Group                                |
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 
19 /* $Id$ */
20 
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24 
25 #include "php.h"
26 #include "php_ini.h"
27 #include "ext/standard/info.h"
28 #include "php_com_dotnet.h"
29 #include "php_com_dotnet_internal.h"
30 #include "Zend/zend_exceptions.h"
31 
com_property_read(zval * object,zval * member,int type,void ** cahce_slot,zval * rv)32 static zval *com_property_read(zval *object, zval *member, int type, void **cahce_slot, zval *rv)
33 {
34 	php_com_dotnet_object *obj;
35 	VARIANT v;
36 	HRESULT res;
37 
38 	ZVAL_NULL(rv);
39 
40 	obj = CDNO_FETCH(object);
41 
42 	if (V_VT(&obj->v) == VT_DISPATCH) {
43 		VariantInit(&v);
44 
45 		convert_to_string_ex(member);
46 
47 		res = php_com_do_invoke(obj, Z_STRVAL_P(member), Z_STRLEN_P(member),
48 				DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, 0, NULL, 1);
49 
50 		if (res == SUCCESS) {
51 			php_com_zval_from_variant(rv, &v, obj->code_page);
52 			VariantClear(&v);
53 		} else if (res == DISP_E_BADPARAMCOUNT) {
54 			php_com_saproxy_create(object, rv, member);
55 		}
56 	} else {
57 		php_com_throw_exception(E_INVALIDARG, "this variant has no properties");
58 	}
59 
60 	return rv;
61 }
62 
com_property_write(zval * object,zval * member,zval * value,void ** cache_slot)63 static void com_property_write(zval *object, zval *member, zval *value, void **cache_slot)
64 {
65 	php_com_dotnet_object *obj;
66 	VARIANT v;
67 
68 	obj = CDNO_FETCH(object);
69 
70 	if (V_VT(&obj->v) == VT_DISPATCH) {
71 		VariantInit(&v);
72 
73 		convert_to_string_ex(member);
74 		if (SUCCESS == php_com_do_invoke(obj, Z_STRVAL_P(member), Z_STRLEN_P(member),
75 				DISPATCH_PROPERTYPUT|DISPATCH_PROPERTYPUTREF, &v, 1, value, 0)) {
76 			VariantClear(&v);
77 		}
78 	} else {
79 		php_com_throw_exception(E_INVALIDARG, "this variant has no properties");
80 	}
81 }
82 
com_read_dimension(zval * object,zval * offset,int type,zval * rv)83 static zval *com_read_dimension(zval *object, zval *offset, int type, zval *rv)
84 {
85 	php_com_dotnet_object *obj;
86 	VARIANT v;
87 
88 	ZVAL_NULL(rv);
89 
90 	obj = CDNO_FETCH(object);
91 
92 	if (V_VT(&obj->v) == VT_DISPATCH) {
93 		VariantInit(&v);
94 
95 		if (SUCCESS == php_com_do_invoke_by_id(obj, DISPID_VALUE,
96 				DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, 1, offset, 0, 0)) {
97 			php_com_zval_from_variant(rv, &v, obj->code_page);
98 			VariantClear(&v);
99 		}
100 	} else if (V_ISARRAY(&obj->v)) {
101 		convert_to_long(offset);
102 
103 		if (SafeArrayGetDim(V_ARRAY(&obj->v)) == 1) {
104 			if (php_com_safearray_get_elem(&obj->v, &v, (LONG)Z_LVAL_P(offset))) {
105 				php_com_wrap_variant(rv, &v, obj->code_page);
106 				VariantClear(&v);
107 			}
108 		} else {
109 			php_com_saproxy_create(object, rv, offset);
110 		}
111 
112 	} else {
113 		php_com_throw_exception(E_INVALIDARG, "this variant is not an array type");
114 	}
115 
116 	return rv;
117 }
118 
com_write_dimension(zval * object,zval * offset,zval * value)119 static void com_write_dimension(zval *object, zval *offset, zval *value)
120 {
121 	php_com_dotnet_object *obj;
122 	zval args[2];
123 	VARIANT v;
124 	HRESULT res;
125 
126 	obj = CDNO_FETCH(object);
127 
128 	if (V_VT(&obj->v) == VT_DISPATCH) {
129 		ZVAL_COPY_VALUE(&args[0], offset);
130 		ZVAL_COPY_VALUE(&args[1], value);
131 
132 		VariantInit(&v);
133 
134 		if (SUCCESS == php_com_do_invoke_by_id(obj, DISPID_VALUE,
135 				DISPATCH_METHOD|DISPATCH_PROPERTYPUT, &v, 2, args, 0, 0)) {
136 			VariantClear(&v);
137 		}
138 	} else if (V_ISARRAY(&obj->v)) {
139 		LONG indices = 0;
140 		VARTYPE vt;
141 
142 		if (SafeArrayGetDim(V_ARRAY(&obj->v)) == 1) {
143 			if (FAILED(SafeArrayGetVartype(V_ARRAY(&obj->v), &vt)) || vt == VT_EMPTY) {
144 				vt = V_VT(&obj->v) & ~VT_ARRAY;
145 			}
146 
147 			convert_to_long(offset);
148 			indices = (LONG)Z_LVAL_P(offset);
149 
150 			VariantInit(&v);
151 			php_com_variant_from_zval(&v, value, obj->code_page);
152 
153 			if (V_VT(&v) != vt) {
154 				VariantChangeType(&v, &v, 0, vt);
155 			}
156 
157 			if (vt == VT_VARIANT) {
158 				res = SafeArrayPutElement(V_ARRAY(&obj->v), &indices, &v);
159 			} else {
160 				res = SafeArrayPutElement(V_ARRAY(&obj->v), &indices, &v.lVal);
161 			}
162 
163 			VariantClear(&v);
164 
165 			if (FAILED(res)) {
166 				php_com_throw_exception(res, NULL);
167 			}
168 
169 		} else {
170 			php_com_throw_exception(DISP_E_BADINDEX, "this variant has multiple dimensions; you can't set a new value without specifying *all* dimensions");
171 		}
172 
173 	} else {
174 		php_com_throw_exception(E_INVALIDARG, "this variant is not an array type");
175 	}
176 }
177 
178 #if 0
179 static void com_object_set(zval **property, zval *value)
180 {
181 	/* Not yet implemented in the engine */
182 }
183 
184 static zval *com_object_get(zval *property)
185 {
186 	/* Not yet implemented in the engine */
187 	return NULL;
188 }
189 #endif
190 
com_property_exists(zval * object,zval * member,int check_empty,void ** cache_slot)191 static int com_property_exists(zval *object, zval *member, int check_empty, void **cache_slot)
192 {
193 	DISPID dispid;
194 	php_com_dotnet_object *obj;
195 
196 	obj = CDNO_FETCH(object);
197 
198 	if (V_VT(&obj->v) == VT_DISPATCH) {
199 		convert_to_string_ex(member);
200 		if (SUCCEEDED(php_com_get_id_of_name(obj, Z_STRVAL_P(member), Z_STRLEN_P(member), &dispid))) {
201 			/* TODO: distinguish between property and method! */
202 			return 1;
203 		}
204 	} else {
205 		/* TODO: check for safearray */
206 	}
207 
208 	return 0;
209 }
210 
com_dimension_exists(zval * object,zval * member,int check_empty)211 static int com_dimension_exists(zval *object, zval *member, int check_empty)
212 {
213 	php_error_docref(NULL, E_WARNING, "Operation not yet supported on a COM object");
214 	return 0;
215 }
216 
com_property_delete(zval * object,zval * member,void ** cache_slot)217 static void com_property_delete(zval *object, zval *member, void **cache_slot)
218 {
219 	php_error_docref(NULL, E_WARNING, "Cannot delete properties from a COM object");
220 }
221 
com_dimension_delete(zval * object,zval * offset)222 static void com_dimension_delete(zval *object, zval *offset)
223 {
224 	php_error_docref(NULL, E_WARNING, "Cannot delete properties from a COM object");
225 }
226 
com_properties_get(zval * object)227 static HashTable *com_properties_get(zval *object)
228 {
229 	/* TODO: use type-info to get all the names and values ?
230 	 * DANGER: if we do that, there is a strong possibility for
231 	 * infinite recursion when the hash is displayed via var_dump().
232 	 * Perhaps it is best to leave it un-implemented.
233 	 */
234 	return NULL;
235 }
236 
function_dtor(zval * zv)237 static void function_dtor(zval *zv)
238 {
239 	zend_internal_function *f = (zend_internal_function*)Z_PTR_P(zv);
240 
241 	zend_string_release(f->function_name);
242 	if (f->arg_info) {
243 		efree(f->arg_info);
244 	}
245 	efree(f);
246 }
247 
PHP_FUNCTION(com_method_handler)248 static PHP_FUNCTION(com_method_handler)
249 {
250 	zval *object = getThis();
251 
252 	Z_OBJ_HANDLER_P(object, call_method)(
253 			((zend_internal_function*)EX(func))->function_name,
254 			Z_OBJ_P(object),
255 			INTERNAL_FUNCTION_PARAM_PASSTHRU);
256 }
257 
com_method_get(zend_object ** object_ptr,zend_string * name,const zval * key)258 static union _zend_function *com_method_get(zend_object **object_ptr, zend_string *name, const zval *key)
259 {
260 	zend_internal_function f, *fptr = NULL;
261 	union _zend_function *func;
262 	DISPID dummy;
263 	php_com_dotnet_object *obj = (php_com_dotnet_object*)*object_ptr;
264 
265 	if (V_VT(&obj->v) != VT_DISPATCH) {
266 		return NULL;
267 	}
268 
269 	if (FAILED(php_com_get_id_of_name(obj, name->val, name->len, &dummy))) {
270 		return NULL;
271 	}
272 
273 	/* check cache */
274 	if (obj->method_cache == NULL || NULL == (fptr = zend_hash_find_ptr(obj->method_cache, name))) {
275 		f.type = ZEND_OVERLOADED_FUNCTION;
276 		f.num_args = 0;
277 		f.arg_info = NULL;
278 		f.scope = obj->ce;
279 		f.fn_flags = ZEND_ACC_CALL_VIA_HANDLER;
280 		f.function_name = zend_string_copy(name);
281 		f.handler = PHP_FN(com_method_handler);
282 
283 		fptr = &f;
284 
285 		if (obj->typeinfo) {
286 			/* look for byref params */
287 			ITypeComp *comp;
288 			ITypeInfo *TI = NULL;
289 			DESCKIND kind;
290 			BINDPTR bindptr;
291 			OLECHAR *olename;
292 			ULONG lhash;
293 			int i;
294 
295 			if (SUCCEEDED(ITypeInfo_GetTypeComp(obj->typeinfo, &comp))) {
296 				olename = php_com_string_to_olestring(name->val, name->len, obj->code_page);
297 				lhash = LHashValOfNameSys(SYS_WIN32, LOCALE_SYSTEM_DEFAULT, olename);
298 
299 				if (SUCCEEDED(ITypeComp_Bind(comp, olename, lhash, INVOKE_FUNC, &TI, &kind, &bindptr))) {
300 					switch (kind) {
301 						case DESCKIND_FUNCDESC:
302 							f.arg_info = ecalloc(bindptr.lpfuncdesc->cParams, sizeof(zend_arg_info));
303 
304 							for (i = 0; i < bindptr.lpfuncdesc->cParams; i++) {
305 								f.arg_info[i].allow_null = 1;
306 								if (bindptr.lpfuncdesc->lprgelemdescParam[i].paramdesc.wParamFlags & PARAMFLAG_FOUT) {
307 									f.arg_info[i].pass_by_reference = ZEND_SEND_BY_REF;
308 								}
309 							}
310 
311 							f.num_args = bindptr.lpfuncdesc->cParams;
312 
313 							ITypeInfo_ReleaseFuncDesc(TI, bindptr.lpfuncdesc);
314 							break;
315 
316 							/* these should not happen, but *might* happen if the user
317 							 * screws up; lets avoid a leak in that case */
318 						case DESCKIND_VARDESC:
319 							ITypeInfo_ReleaseVarDesc(TI, bindptr.lpvardesc);
320 							break;
321 						case DESCKIND_TYPECOMP:
322 							ITypeComp_Release(bindptr.lptcomp);
323 							break;
324 
325 						case DESCKIND_NONE:
326 							break;
327 					}
328 					if (TI) {
329 						ITypeInfo_Release(TI);
330 					}
331 				}
332 				ITypeComp_Release(comp);
333 				efree(olename);
334 			}
335 		}
336 
337 		zend_set_function_arg_flags((zend_function*)&f);
338 		/* save this method in the cache */
339 		if (!obj->method_cache) {
340 			ALLOC_HASHTABLE(obj->method_cache);
341 			zend_hash_init(obj->method_cache, 2, NULL, function_dtor, 0);
342 		}
343 
344 		zend_hash_update_mem(obj->method_cache, name, &f, sizeof(f));
345 	}
346 
347 	if (fptr) {
348 		/* duplicate this into a new chunk of emalloc'd memory,
349 		 * since the engine will efree it */
350 		func = emalloc(sizeof(*fptr));
351 		memcpy(func, fptr, sizeof(*fptr));
352 
353 		return func;
354 	}
355 
356 	return NULL;
357 }
358 
com_call_method(zend_string * method,zend_object * object,INTERNAL_FUNCTION_PARAMETERS)359 static int com_call_method(zend_string *method, zend_object *object, INTERNAL_FUNCTION_PARAMETERS)
360 {
361 	zval *args = NULL;
362 	php_com_dotnet_object *obj = (php_com_dotnet_object*)object;
363 	int nargs;
364 	VARIANT v;
365 	int ret = FAILURE;
366 
367 	if (V_VT(&obj->v) != VT_DISPATCH) {
368 		return FAILURE;
369 	}
370 
371 	nargs = ZEND_NUM_ARGS();
372 
373 	if (nargs) {
374 		args = (zval *)safe_emalloc(sizeof(zval), nargs, 0);
375 		zend_get_parameters_array_ex(nargs, args);
376 	}
377 
378 	VariantInit(&v);
379 
380 	if (SUCCESS == php_com_do_invoke_byref(obj, (zend_internal_function*)EX(func), DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, nargs, args)) {
381 		php_com_zval_from_variant(return_value, &v, obj->code_page);
382 		ret = SUCCESS;
383 		VariantClear(&v);
384 	}
385 
386 	if (args) {
387 		efree(args);
388 	}
389 
390 	return ret;
391 }
392 
com_constructor_get(zend_object * object)393 static union _zend_function *com_constructor_get(zend_object *object)
394 {
395 	php_com_dotnet_object *obj = (php_com_dotnet_object *) object;
396 	static zend_internal_function c, d, v;
397 
398 #define POPULATE_CTOR(f, fn)	\
399 	f.type = ZEND_INTERNAL_FUNCTION; \
400 	f.function_name = obj->ce->name; \
401 	f.scope = obj->ce; \
402 	f.arg_info = NULL; \
403 	f.num_args = 0; \
404 	f.fn_flags = 0; \
405 	f.handler = ZEND_FN(fn); \
406 	return (union _zend_function*)&f;
407 
408 	switch (obj->ce->name->val[0]) {
409 #if HAVE_MSCOREE_H
410 		case 'd':
411 			POPULATE_CTOR(d, com_dotnet_create_instance);
412 #endif
413 
414 		case 'c':
415 			POPULATE_CTOR(c, com_create_instance);
416 
417 		case 'v':
418 			POPULATE_CTOR(v, com_variant_create_instance);
419 
420 		default:
421 			return NULL;
422 	}
423 }
424 
com_class_name_get(const zend_object * object)425 static zend_string* com_class_name_get(const zend_object *object)
426 {
427 	php_com_dotnet_object *obj = (php_com_dotnet_object *)object;
428 
429 	return zend_string_copy(obj->ce->name);
430 }
431 
432 /* This compares two variants for equality */
com_objects_compare(zval * object1,zval * object2)433 static int com_objects_compare(zval *object1, zval *object2)
434 {
435 	php_com_dotnet_object *obja, *objb;
436 	int ret;
437 	/* strange header bug problem here... the headers define the proto without the
438 	 * flags parameter.  However, the MSDN docs state that there is a flags parameter,
439 	 * and my VC6 won't link unless the code uses the version with 4 parameters.
440 	 * So, we have this declaration here to fix it */
441 	STDAPI VarCmp(LPVARIANT pvarLeft, LPVARIANT pvarRight, LCID lcid, DWORD flags);
442 
443 	obja = CDNO_FETCH(object1);
444 	objb = CDNO_FETCH(object2);
445 
446 	switch (VarCmp(&obja->v, &objb->v, LOCALE_SYSTEM_DEFAULT, 0)) {
447 		case VARCMP_LT:
448 			ret = -1;
449 			break;
450 		case VARCMP_GT:
451 			ret = 1;
452 			break;
453 		case VARCMP_EQ:
454 			ret = 0;
455 			break;
456 		default:
457 			/* either or both operands are NULL...
458 			 * not 100% sure how to handle this */
459 			ret = -2;
460 	}
461 
462 	return ret;
463 }
464 
com_object_cast(zval * readobj,zval * writeobj,int type)465 static int com_object_cast(zval *readobj, zval *writeobj, int type)
466 {
467 	php_com_dotnet_object *obj;
468 	VARIANT v;
469 	VARTYPE vt = VT_EMPTY;
470 	HRESULT res = S_OK;
471 
472 	obj = CDNO_FETCH(readobj);
473 	ZVAL_NULL(writeobj);
474 	VariantInit(&v);
475 
476 	if (V_VT(&obj->v) == VT_DISPATCH) {
477 		if (SUCCESS != php_com_do_invoke_by_id(obj, DISPID_VALUE,
478 				DISPATCH_METHOD|DISPATCH_PROPERTYGET, &v, 0, NULL, 1, 0)) {
479 			VariantCopy(&v, &obj->v);
480 		}
481 	} else {
482 		VariantCopy(&v, &obj->v);
483 	}
484 
485 	switch(type) {
486 		case IS_LONG:
487 			vt = VT_INT;
488 			break;
489 		case IS_DOUBLE:
490 			vt = VT_R8;
491 			break;
492 		case IS_FALSE:
493 		case IS_TRUE:
494 		case _IS_BOOL:
495 			vt = VT_BOOL;
496 			break;
497 		case IS_STRING:
498 			vt = VT_BSTR;
499 			break;
500 		default:
501 			;
502 	}
503 
504 	if (vt != VT_EMPTY && vt != V_VT(&v)) {
505 		res = VariantChangeType(&v, &v, 0, vt);
506 	}
507 
508 	if (SUCCEEDED(res)) {
509 		php_com_zval_from_variant(writeobj, &v, obj->code_page);
510 	}
511 
512 	VariantClear(&v);
513 
514 	if (SUCCEEDED(res)) {
515 		return SUCCESS;
516 	}
517 
518 	return zend_std_cast_object_tostring(readobj, writeobj, type);
519 }
520 
com_object_count(zval * object,zend_long * count)521 static int com_object_count(zval *object, zend_long *count)
522 {
523 	php_com_dotnet_object *obj;
524 	LONG ubound = 0, lbound = 0;
525 
526 	obj = CDNO_FETCH(object);
527 
528 	if (!V_ISARRAY(&obj->v)) {
529 		return FAILURE;
530 	}
531 
532 	SafeArrayGetLBound(V_ARRAY(&obj->v), 1, &lbound);
533 	SafeArrayGetUBound(V_ARRAY(&obj->v), 1, &ubound);
534 
535 	*count = ubound - lbound + 1;
536 
537 	return SUCCESS;
538 }
539 
540 zend_object_handlers php_com_object_handlers = {
541 	0,
542 	php_com_object_free_storage,
543 	zend_objects_destroy_object,
544 	php_com_object_clone,
545 	com_property_read,
546 	com_property_write,
547 	com_read_dimension,
548 	com_write_dimension,
549 	NULL,
550 	NULL, /* com_object_get, */
551 	NULL, /* com_object_set, */
552 	com_property_exists,
553 	com_property_delete,
554 	com_dimension_exists,
555 	com_dimension_delete,
556 	com_properties_get,
557 	com_method_get,
558 	com_call_method,
559 	com_constructor_get,
560 	com_class_name_get,
561 	com_objects_compare,
562 	com_object_cast,
563 	com_object_count,
564 	NULL,									/* get_debug_info */
565 	NULL,									/* get_closure */
566 	NULL,									/* get_gc */
567 };
568 
php_com_object_enable_event_sink(php_com_dotnet_object * obj,int enable)569 void php_com_object_enable_event_sink(php_com_dotnet_object *obj, int enable)
570 {
571 	if (obj->sink_dispatch) {
572 		IConnectionPointContainer *cont;
573 		IConnectionPoint *point;
574 
575 		if (SUCCEEDED(IDispatch_QueryInterface(V_DISPATCH(&obj->v),
576 				&IID_IConnectionPointContainer, (void**)&cont))) {
577 
578 			if (SUCCEEDED(IConnectionPointContainer_FindConnectionPoint(cont,
579 					&obj->sink_id, &point))) {
580 
581 				if (enable) {
582 					IConnectionPoint_Advise(point, (IUnknown*)obj->sink_dispatch, &obj->sink_cookie);
583 				} else {
584 					IConnectionPoint_Unadvise(point, obj->sink_cookie);
585 				}
586 				IConnectionPoint_Release(point);
587 			}
588 			IConnectionPointContainer_Release(cont);
589 		}
590 	}
591 }
592 
php_com_object_free_storage(zend_object * object)593 void php_com_object_free_storage(zend_object *object)
594 {
595 	php_com_dotnet_object *obj = (php_com_dotnet_object*)object;
596 
597 	if (obj->typeinfo) {
598 		ITypeInfo_Release(obj->typeinfo);
599 		obj->typeinfo = NULL;
600 	}
601 
602 	if (obj->sink_dispatch) {
603 		php_com_object_enable_event_sink(obj, FALSE);
604 		IDispatch_Release(obj->sink_dispatch);
605 		obj->sink_dispatch = NULL;
606 	}
607 
608 	VariantClear(&obj->v);
609 
610 	if (obj->method_cache) {
611 		zend_hash_destroy(obj->method_cache);
612 		FREE_HASHTABLE(obj->method_cache);
613 	}
614 	if (obj->id_of_name_cache) {
615 		zend_hash_destroy(obj->id_of_name_cache);
616 		FREE_HASHTABLE(obj->id_of_name_cache);
617 	}
618 }
619 
php_com_object_clone(zval * object)620 zend_object* php_com_object_clone(zval *object)
621 {
622 	php_com_dotnet_object *cloneobj, *origobject;
623 
624 	origobject = (php_com_dotnet_object*)Z_OBJ_P(object);
625 	cloneobj = (php_com_dotnet_object*)emalloc(sizeof(php_com_dotnet_object));
626 
627 	memcpy(cloneobj, origobject, sizeof(*cloneobj));
628 
629 	/* VariantCopy will perform VariantClear; we don't want to clobber
630 	 * the IDispatch that we memcpy'd, so we init a new variant in the
631 	 * clone structure */
632 	VariantInit(&cloneobj->v);
633 	/* We use the Indirection-following version of the API since we
634 	 * want to clone as much as possible */
635 	VariantCopyInd(&cloneobj->v, &origobject->v);
636 
637 	if (cloneobj->typeinfo) {
638 		ITypeInfo_AddRef(cloneobj->typeinfo);
639 	}
640 
641 	return (zend_object*)cloneobj;
642 }
643 
php_com_object_new(zend_class_entry * ce)644 zend_object* php_com_object_new(zend_class_entry *ce)
645 {
646 	php_com_dotnet_object *obj;
647 
648 	php_com_initialize();
649 	obj = emalloc(sizeof(*obj));
650 	memset(obj, 0, sizeof(*obj));
651 
652 	VariantInit(&obj->v);
653 	obj->code_page = CP_ACP;
654 	obj->ce = ce;
655 
656 	zend_object_std_init(&obj->zo, ce);
657 	obj->zo.handlers = &php_com_object_handlers;
658 
659 	obj->typeinfo = NULL;
660 
661 	return (zend_object*)obj;
662 }
663