1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 5 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1997-2014 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
31 /* create an automation SafeArray from a PHP array.
32 * Only creates a single-dimensional array of variants.
33 * The keys of the PHP hash MUST be numeric. If the array
34 * is sparse, then the gaps will be filled with NULL variants */
safe_array_from_zval(VARIANT * v,zval * z,int codepage TSRMLS_DC)35 static void safe_array_from_zval(VARIANT *v, zval *z, int codepage TSRMLS_DC)
36 {
37 SAFEARRAY *sa = NULL;
38 SAFEARRAYBOUND bound;
39 HashPosition pos;
40 int keytype;
41 char *strindex;
42 int strindexlen;
43 long intindex = -1;
44 long max_index = 0;
45 VARIANT *va;
46 zval **item;
47
48 /* find the largest array index, and assert that all keys are integers */
49 zend_hash_internal_pointer_reset_ex(HASH_OF(z), &pos);
50 for (;; zend_hash_move_forward_ex(HASH_OF(z), &pos)) {
51
52 keytype = zend_hash_get_current_key_ex(HASH_OF(z), &strindex, &strindexlen, &intindex, 0, &pos);
53
54 if (HASH_KEY_IS_STRING == keytype) {
55 goto bogus;
56 } else if (HASH_KEY_NON_EXISTANT == keytype) {
57 break;
58 }
59 if (intindex > max_index) {
60 max_index = intindex;
61 }
62 }
63
64 /* allocate the structure */
65 bound.lLbound = 0;
66 bound.cElements = intindex + 1;
67 sa = SafeArrayCreate(VT_VARIANT, 1, &bound);
68
69 /* get a lock on the array itself */
70 SafeArrayAccessData(sa, &va);
71 va = (VARIANT*)sa->pvData;
72
73 /* now fill it in */
74 zend_hash_internal_pointer_reset_ex(HASH_OF(z), &pos);
75 for (;; zend_hash_move_forward_ex(HASH_OF(z), &pos)) {
76 if (FAILURE == zend_hash_get_current_data_ex(HASH_OF(z), (void**)&item, &pos)) {
77 break;
78 }
79 zend_hash_get_current_key_ex(HASH_OF(z), &strindex, &strindexlen, &intindex, 0, &pos);
80 php_com_variant_from_zval(&va[intindex], *item, codepage TSRMLS_CC);
81 }
82
83 /* Unlock it and stuff it into our variant */
84 SafeArrayUnaccessData(sa);
85 V_VT(v) = VT_ARRAY|VT_VARIANT;
86 V_ARRAY(v) = sa;
87
88 return;
89
90 bogus:
91 php_error_docref(NULL TSRMLS_CC, E_WARNING, "COM: converting from PHP array to VARIANT array; only arrays with numeric keys are allowed");
92
93 V_VT(v) = VT_NULL;
94
95 if (sa) {
96 SafeArrayUnlock(sa);
97 SafeArrayDestroy(sa);
98 }
99 }
100
php_com_variant_from_zval(VARIANT * v,zval * z,int codepage TSRMLS_DC)101 PHP_COM_DOTNET_API void php_com_variant_from_zval(VARIANT *v, zval *z, int codepage TSRMLS_DC)
102 {
103 OLECHAR *olestring;
104 php_com_dotnet_object *obj;
105 zend_uchar ztype = (z == NULL ? IS_NULL : Z_TYPE_P(z));
106
107 switch (ztype) {
108 case IS_NULL:
109 V_VT(v) = VT_NULL;
110 break;
111
112 case IS_BOOL:
113 V_VT(v) = VT_BOOL;
114 V_BOOL(v) = Z_BVAL_P(z) ? VARIANT_TRUE : VARIANT_FALSE;
115 break;
116
117 case IS_OBJECT:
118 if (php_com_is_valid_object(z TSRMLS_CC)) {
119 obj = CDNO_FETCH(z);
120 if (V_VT(&obj->v) == VT_DISPATCH) {
121 /* pass the underlying object */
122 V_VT(v) = VT_DISPATCH;
123 if (V_DISPATCH(&obj->v)) {
124 IDispatch_AddRef(V_DISPATCH(&obj->v));
125 }
126 V_DISPATCH(v) = V_DISPATCH(&obj->v);
127 } else {
128 /* pass the variant by reference */
129 V_VT(v) = VT_VARIANT | VT_BYREF;
130 V_VARIANTREF(v) = &obj->v;
131 }
132 } else {
133 /* export the PHP object using our COM wrapper */
134 V_VT(v) = VT_DISPATCH;
135 V_DISPATCH(v) = php_com_wrapper_export(z TSRMLS_CC);
136 }
137 break;
138
139 case IS_ARRAY:
140 /* map as safe array */
141 safe_array_from_zval(v, z, codepage TSRMLS_CC);
142 break;
143
144 case IS_LONG:
145 V_VT(v) = VT_I4;
146 V_I4(v) = Z_LVAL_P(z);
147 break;
148
149 case IS_DOUBLE:
150 V_VT(v) = VT_R8;
151 V_R8(v) = Z_DVAL_P(z);
152 break;
153
154 case IS_STRING:
155 V_VT(v) = VT_BSTR;
156 olestring = php_com_string_to_olestring(Z_STRVAL_P(z), Z_STRLEN_P(z), codepage TSRMLS_CC);
157 if (CP_UTF8 == codepage) {
158 V_BSTR(v) = SysAllocStringByteLen((char*)olestring, wcslen(olestring) * sizeof(OLECHAR));
159 } else {
160 V_BSTR(v) = SysAllocStringByteLen((char*)olestring, Z_STRLEN_P(z) * sizeof(OLECHAR));
161 }
162 efree(olestring);
163 break;
164
165 case IS_RESOURCE:
166 case IS_CONSTANT:
167 case IS_CONSTANT_ARRAY:
168 default:
169 V_VT(v) = VT_NULL;
170 break;
171 }
172 }
173
php_com_zval_from_variant(zval * z,VARIANT * v,int codepage TSRMLS_DC)174 PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepage TSRMLS_DC)
175 {
176 OLECHAR *olestring = NULL;
177 int ret = SUCCESS;
178
179 switch (V_VT(v)) {
180 case VT_EMPTY:
181 case VT_NULL:
182 case VT_VOID:
183 ZVAL_NULL(z);
184 break;
185 case VT_UI1:
186 ZVAL_LONG(z, (long)V_UI1(v));
187 break;
188 case VT_I1:
189 ZVAL_LONG(z, (long)V_I1(v));
190 break;
191 case VT_UI2:
192 ZVAL_LONG(z, (long)V_UI2(v));
193 break;
194 case VT_I2:
195 ZVAL_LONG(z, (long)V_I2(v));
196 break;
197 case VT_UI4: /* TODO: promote to double if large? */
198 ZVAL_LONG(z, (long)V_UI4(v));
199 break;
200 case VT_I4:
201 ZVAL_LONG(z, (long)V_I4(v));
202 break;
203 case VT_INT:
204 ZVAL_LONG(z, V_INT(v));
205 break;
206 case VT_UINT: /* TODO: promote to double if large? */
207 ZVAL_LONG(z, (long)V_UINT(v));
208 break;
209 case VT_R4:
210 ZVAL_DOUBLE(z, (double)V_R4(v));
211 break;
212 case VT_R8:
213 ZVAL_DOUBLE(z, V_R8(v));
214 break;
215 case VT_BOOL:
216 ZVAL_BOOL(z, V_BOOL(v) ? 1 : 0);
217 break;
218 case VT_BSTR:
219 olestring = V_BSTR(v);
220 if (olestring) {
221 Z_TYPE_P(z) = IS_STRING;
222 Z_STRVAL_P(z) = php_com_olestring_to_string(olestring,
223 &Z_STRLEN_P(z), codepage TSRMLS_CC);
224 olestring = NULL;
225 }
226 break;
227 case VT_UNKNOWN:
228 if (V_UNKNOWN(v) != NULL) {
229 IDispatch *disp;
230
231 if (SUCCEEDED(IUnknown_QueryInterface(V_UNKNOWN(v), &IID_IDispatch, &disp))) {
232 php_com_wrap_dispatch(z, disp, codepage TSRMLS_CC);
233 IDispatch_Release(disp);
234 } else {
235 ret = FAILURE;
236 }
237 }
238 break;
239
240 case VT_DISPATCH:
241 if (V_DISPATCH(v) != NULL) {
242 php_com_wrap_dispatch(z, V_DISPATCH(v), codepage TSRMLS_CC);
243 }
244 break;
245
246 case VT_VARIANT:
247 /* points to another variant */
248 return php_com_zval_from_variant(z, V_VARIANTREF(v), codepage TSRMLS_CC);
249
250 default:
251 php_com_wrap_variant(z, v, codepage TSRMLS_CC);
252 }
253
254 if (olestring) {
255 efree(olestring);
256 }
257
258 if (ret == FAILURE) {
259 php_error_docref(NULL TSRMLS_CC, E_WARNING, "variant->zval: conversion from 0x%x ret=%d", V_VT(v), ret);
260 }
261
262 return ret;
263 }
264
265
php_com_copy_variant(VARIANT * dstvar,VARIANT * srcvar TSRMLS_DC)266 PHP_COM_DOTNET_API int php_com_copy_variant(VARIANT *dstvar, VARIANT *srcvar TSRMLS_DC)
267 {
268 int ret = SUCCESS;
269
270 switch (V_VT(dstvar) & ~VT_BYREF) {
271 case VT_EMPTY:
272 case VT_NULL:
273 case VT_VOID:
274 /* should not be possible */
275 break;
276
277 case VT_UI1:
278 if (V_VT(dstvar) & VT_BYREF) {
279 *V_UI1REF(dstvar) = V_UI1(srcvar);
280 } else {
281 V_UI1(dstvar) = V_UI1(srcvar);
282 }
283 break;
284
285 case VT_I1:
286 if (V_VT(dstvar) & VT_BYREF) {
287 *V_I1REF(dstvar) = V_I1(srcvar);
288 } else {
289 V_I1(dstvar) = V_I1(srcvar);
290 }
291 break;
292
293 case VT_UI2:
294 if (V_VT(dstvar) & VT_BYREF) {
295 *V_UI2REF(dstvar) = V_UI2(srcvar);
296 } else {
297 V_UI2(dstvar) = V_UI2(srcvar);
298 }
299 break;
300
301 case VT_I2:
302 if (V_VT(dstvar) & VT_BYREF) {
303 *V_I2REF(dstvar) = V_I2(srcvar);
304 } else {
305 V_I2(dstvar) = V_I2(srcvar);
306 }
307 break;
308
309 case VT_UI4:
310 if (V_VT(dstvar) & VT_BYREF) {
311 *V_UI4REF(dstvar) = V_UI4(srcvar);
312 } else {
313 V_UI4(dstvar) = V_UI4(srcvar);
314 }
315 break;
316
317 case VT_I4:
318 if (V_VT(dstvar) & VT_BYREF) {
319 *V_I4REF(dstvar) = V_I4(srcvar);
320 } else {
321 V_I4(dstvar) = V_I4(srcvar);
322 }
323 break;
324
325 case VT_INT:
326 if (V_VT(dstvar) & VT_BYREF) {
327 *V_INTREF(dstvar) = V_INT(srcvar);
328 } else {
329 V_INT(dstvar) = V_INT(srcvar);
330 }
331 break;
332
333 case VT_UINT:
334 if (V_VT(dstvar) & VT_BYREF) {
335 *V_UINTREF(dstvar) = V_UINT(srcvar);
336 } else {
337 V_UINT(dstvar) = V_UINT(srcvar);
338 }
339 break;
340
341 case VT_R4:
342 if (V_VT(dstvar) & VT_BYREF) {
343 *V_R4REF(dstvar) = V_R4(srcvar);
344 } else {
345 V_R4(dstvar) = V_R4(srcvar);
346 }
347 break;
348
349 case VT_R8:
350 if (V_VT(dstvar) & VT_BYREF) {
351 *V_R8REF(dstvar) = V_R8(srcvar);
352 } else {
353 V_R8(dstvar) = V_R8(srcvar);
354 }
355 break;
356
357 case VT_BOOL:
358 if (V_VT(dstvar) & VT_BYREF) {
359 *V_BOOLREF(dstvar) = V_BOOL(srcvar);
360 } else {
361 V_BOOL(dstvar) = V_BOOL(srcvar);
362 }
363 break;
364
365 case VT_BSTR:
366 if (V_VT(dstvar) & VT_BYREF) {
367 *V_BSTRREF(dstvar) = V_BSTR(srcvar);
368 } else {
369 V_BSTR(dstvar) = V_BSTR(srcvar);
370 }
371 break;
372
373 case VT_UNKNOWN:
374 if (V_VT(dstvar) & VT_BYREF) {
375 *V_UNKNOWNREF(dstvar) = V_UNKNOWN(srcvar);
376 } else {
377 V_UNKNOWN(dstvar) = V_UNKNOWN(srcvar);
378 }
379 break;
380
381 case VT_DISPATCH:
382 if (V_VT(dstvar) & VT_BYREF) {
383 *V_DISPATCHREF(dstvar) = V_DISPATCH(srcvar);
384 } else {
385 V_DISPATCH(dstvar) = V_DISPATCH(srcvar);
386 }
387 break;
388
389 case VT_VARIANT:
390 return php_com_copy_variant(V_VARIANTREF(dstvar), srcvar TSRMLS_CC);
391
392 default:
393 php_error_docref(NULL TSRMLS_CC, E_WARNING, "variant->variant: failed to copy from 0x%x to 0x%x", V_VT(dstvar), V_VT(srcvar));
394 ret = FAILURE;
395 }
396 return ret;
397 }
398
399 /* {{{ com_variant_create_instance - ctor for new VARIANT() */
PHP_FUNCTION(com_variant_create_instance)400 PHP_FUNCTION(com_variant_create_instance)
401 {
402 /* VARTYPE == unsigned short */ long vt = VT_EMPTY;
403 long codepage = CP_ACP;
404 zval *object = getThis();
405 php_com_dotnet_object *obj;
406 zval *zvalue = NULL;
407 HRESULT res;
408
409 if (ZEND_NUM_ARGS() == 0) {
410 /* just leave things as-is - an empty variant */
411 return;
412 }
413
414 obj = CDNO_FETCH(object);
415
416 if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
417 "z!|ll", &zvalue, &vt, &codepage)) {
418 php_com_throw_exception(E_INVALIDARG, "Invalid arguments" TSRMLS_CC);
419 return;
420 }
421
422 php_com_initialize(TSRMLS_C);
423 if (ZEND_NUM_ARGS() == 3) {
424 obj->code_page = codepage;
425 }
426
427 if (zvalue) {
428 php_com_variant_from_zval(&obj->v, zvalue, obj->code_page TSRMLS_CC);
429 }
430
431 /* Only perform conversion if variant not already of type passed */
432 if ((ZEND_NUM_ARGS() >= 2) && (vt != V_VT(&obj->v))) {
433
434 /* If already an array and VT_ARRAY is passed then:
435 - if only VT_ARRAY passed then do not perform a conversion
436 - if VT_ARRAY plus other type passed then perform conversion
437 but will probably fail (original behavior)
438 */
439 if ((vt & VT_ARRAY) && (V_VT(&obj->v) & VT_ARRAY)) {
440 long orig_vt = vt;
441
442 vt &= ~VT_ARRAY;
443 if (vt) {
444 vt = orig_vt;
445 }
446 }
447
448 if (vt) {
449 res = VariantChangeType(&obj->v, &obj->v, 0, (VARTYPE)vt);
450
451 if (FAILED(res)) {
452 char *werr, *msg;
453
454 werr = php_win32_error_to_msg(res);
455 spprintf(&msg, 0, "Variant type conversion failed: %s", werr);
456 LocalFree(werr);
457
458 php_com_throw_exception(res, msg TSRMLS_CC);
459 efree(msg);
460 }
461 }
462 }
463
464 if (V_VT(&obj->v) != VT_DISPATCH && obj->typeinfo) {
465 ITypeInfo_Release(obj->typeinfo);
466 obj->typeinfo = NULL;
467 }
468 }
469 /* }}} */
470
471 /* {{{ proto void variant_set(object variant, mixed value)
472 Assigns a new value for a variant object */
PHP_FUNCTION(variant_set)473 PHP_FUNCTION(variant_set)
474 {
475 zval *zobj, *zvalue = NULL;
476 php_com_dotnet_object *obj;
477
478 if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
479 "Oz!", &zobj, php_com_variant_class_entry, &zvalue)) {
480 return;
481 }
482
483 obj = CDNO_FETCH(zobj);
484
485 /* dtor the old value */
486 if (obj->typeinfo) {
487 ITypeInfo_Release(obj->typeinfo);
488 obj->typeinfo = NULL;
489 }
490 if (obj->sink_dispatch) {
491 php_com_object_enable_event_sink(obj, FALSE TSRMLS_CC);
492 IDispatch_Release(obj->sink_dispatch);
493 obj->sink_dispatch = NULL;
494 }
495
496 VariantClear(&obj->v);
497
498 php_com_variant_from_zval(&obj->v, zvalue, obj->code_page TSRMLS_CC);
499 /* remember we modified this variant */
500 obj->modified = 1;
501 }
502 /* }}} */
503
504 enum variant_binary_opcode {
505 VOP_ADD, VOP_CAT, VOP_SUB, VOP_MUL, VOP_AND, VOP_DIV,
506 VOP_EQV, VOP_IDIV, VOP_IMP, VOP_MOD, VOP_OR, VOP_POW,
507 VOP_XOR
508 };
509
510 enum variant_unary_opcode {
511 VOP_ABS, VOP_FIX, VOP_INT, VOP_NEG, VOP_NOT
512 };
513
variant_binary_operation(enum variant_binary_opcode op,INTERNAL_FUNCTION_PARAMETERS)514 static void variant_binary_operation(enum variant_binary_opcode op, INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
515 {
516 VARIANT vres;
517 VARIANT left_val, right_val;
518 VARIANT *vleft = NULL, *vright = NULL;
519 zval *zleft = NULL, *zright = NULL;
520 php_com_dotnet_object *obj;
521 HRESULT result;
522 int codepage = CP_ACP;
523
524 VariantInit(&left_val);
525 VariantInit(&right_val);
526 VariantInit(&vres);
527
528 if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
529 ZEND_NUM_ARGS() TSRMLS_CC, "OO", &zleft, php_com_variant_class_entry,
530 &zright, php_com_variant_class_entry)) {
531 obj = CDNO_FETCH(zleft);
532 vleft = &obj->v;
533 obj = CDNO_FETCH(zright);
534 vright = &obj->v;
535 } else if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
536 ZEND_NUM_ARGS() TSRMLS_CC, "Oz!", &zleft, php_com_variant_class_entry,
537 &zright)) {
538 obj = CDNO_FETCH(zleft);
539 vleft = &obj->v;
540 vright = &right_val;
541 php_com_variant_from_zval(vright, zright, codepage TSRMLS_CC);
542 } else if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
543 ZEND_NUM_ARGS() TSRMLS_CC, "z!O", &zleft, &zright, php_com_variant_class_entry)) {
544 obj = CDNO_FETCH(zright);
545 vright = &obj->v;
546 vleft = &left_val;
547 php_com_variant_from_zval(vleft, zleft, codepage TSRMLS_CC);
548 } else if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
549 "z!z!", &zleft, &zright)) {
550
551 vleft = &left_val;
552 php_com_variant_from_zval(vleft, zleft, codepage TSRMLS_CC);
553
554 vright = &right_val;
555 php_com_variant_from_zval(vright, zright, codepage TSRMLS_CC);
556
557 } else {
558 return;
559 }
560
561 switch (op) {
562 case VOP_ADD:
563 result = VarAdd(vleft, vright, &vres);
564 break;
565 case VOP_CAT:
566 result = VarCat(vleft, vright, &vres);
567 break;
568 case VOP_SUB:
569 result = VarSub(vleft, vright, &vres);
570 break;
571 case VOP_MUL:
572 result = VarMul(vleft, vright, &vres);
573 break;
574 case VOP_AND:
575 result = VarAnd(vleft, vright, &vres);
576 break;
577 case VOP_DIV:
578 result = VarDiv(vleft, vright, &vres);
579 break;
580 case VOP_EQV:
581 result = VarEqv(vleft, vright, &vres);
582 break;
583 case VOP_IDIV:
584 result = VarIdiv(vleft, vright, &vres);
585 break;
586 case VOP_IMP:
587 result = VarImp(vleft, vright, &vres);
588 break;
589 case VOP_MOD:
590 result = VarMod(vleft, vright, &vres);
591 break;
592 case VOP_OR:
593 result = VarOr(vleft, vright, &vres);
594 break;
595 case VOP_POW:
596 result = VarPow(vleft, vright, &vres);
597 break;
598 case VOP_XOR:
599 result = VarXor(vleft, vright, &vres);
600 break;
601 /*Let say it fails as no valid op has been given */
602 default:
603 result = E_INVALIDARG;
604 }
605
606 if (SUCCEEDED(result)) {
607 php_com_wrap_variant(return_value, &vres, codepage TSRMLS_CC);
608 } else {
609 php_com_throw_exception(result, NULL TSRMLS_CC);
610 }
611
612 VariantClear(&vres);
613 VariantClear(&left_val);
614 VariantClear(&right_val);
615 }
616 /* }}} */
617
618 /* {{{ proto mixed variant_add(mixed left, mixed right)
619 "Adds" two variant values together and returns the result */
PHP_FUNCTION(variant_add)620 PHP_FUNCTION(variant_add)
621 {
622 variant_binary_operation(VOP_ADD, INTERNAL_FUNCTION_PARAM_PASSTHRU);
623 }
624 /* }}} */
625
626 /* {{{ proto mixed variant_cat(mixed left, mixed right)
627 concatenates two variant values together and returns the result */
PHP_FUNCTION(variant_cat)628 PHP_FUNCTION(variant_cat)
629 {
630 variant_binary_operation(VOP_CAT, INTERNAL_FUNCTION_PARAM_PASSTHRU);
631 }
632 /* }}} */
633
634 /* {{{ proto mixed variant_sub(mixed left, mixed right)
635 subtracts the value of the right variant from the left variant value and returns the result */
PHP_FUNCTION(variant_sub)636 PHP_FUNCTION(variant_sub)
637 {
638 variant_binary_operation(VOP_SUB, INTERNAL_FUNCTION_PARAM_PASSTHRU);
639 }
640 /* }}} */
641
642 /* {{{ proto mixed variant_mul(mixed left, mixed right)
643 multiplies the values of the two variants and returns the result */
PHP_FUNCTION(variant_mul)644 PHP_FUNCTION(variant_mul)
645 {
646 variant_binary_operation(VOP_MUL, INTERNAL_FUNCTION_PARAM_PASSTHRU);
647 }
648 /* }}} */
649
650 /* {{{ proto mixed variant_and(mixed left, mixed right)
651 performs a bitwise AND operation between two variants and returns the result */
PHP_FUNCTION(variant_and)652 PHP_FUNCTION(variant_and)
653 {
654 variant_binary_operation(VOP_AND, INTERNAL_FUNCTION_PARAM_PASSTHRU);
655 }
656 /* }}} */
657
658 /* {{{ proto mixed variant_div(mixed left, mixed right)
659 Returns the result from dividing two variants */
PHP_FUNCTION(variant_div)660 PHP_FUNCTION(variant_div)
661 {
662 variant_binary_operation(VOP_DIV, INTERNAL_FUNCTION_PARAM_PASSTHRU);
663 }
664 /* }}} */
665
666 /* {{{ proto mixed variant_eqv(mixed left, mixed right)
667 Performs a bitwise equivalence on two variants */
PHP_FUNCTION(variant_eqv)668 PHP_FUNCTION(variant_eqv)
669 {
670 variant_binary_operation(VOP_EQV, INTERNAL_FUNCTION_PARAM_PASSTHRU);
671 }
672 /* }}} */
673
674 /* {{{ proto mixed variant_idiv(mixed left, mixed right)
675 Converts variants to integers and then returns the result from dividing them */
PHP_FUNCTION(variant_idiv)676 PHP_FUNCTION(variant_idiv)
677 {
678 variant_binary_operation(VOP_IDIV, INTERNAL_FUNCTION_PARAM_PASSTHRU);
679 }
680 /* }}} */
681
682 /* {{{ proto mixed variant_imp(mixed left, mixed right)
683 Performs a bitwise implication on two variants */
PHP_FUNCTION(variant_imp)684 PHP_FUNCTION(variant_imp)
685 {
686 variant_binary_operation(VOP_IMP, INTERNAL_FUNCTION_PARAM_PASSTHRU);
687 }
688 /* }}} */
689
690 /* {{{ proto mixed variant_mod(mixed left, mixed right)
691 Divides two variants and returns only the remainder */
PHP_FUNCTION(variant_mod)692 PHP_FUNCTION(variant_mod)
693 {
694 variant_binary_operation(VOP_MOD, INTERNAL_FUNCTION_PARAM_PASSTHRU);
695 }
696 /* }}} */
697
698 /* {{{ proto mixed variant_or(mixed left, mixed right)
699 Performs a logical disjunction on two variants */
PHP_FUNCTION(variant_or)700 PHP_FUNCTION(variant_or)
701 {
702 variant_binary_operation(VOP_OR, INTERNAL_FUNCTION_PARAM_PASSTHRU);
703 }
704 /* }}} */
705
706 /* {{{ proto mixed variant_pow(mixed left, mixed right)
707 Returns the result of performing the power function with two variants */
PHP_FUNCTION(variant_pow)708 PHP_FUNCTION(variant_pow)
709 {
710 variant_binary_operation(VOP_POW, INTERNAL_FUNCTION_PARAM_PASSTHRU);
711 }
712 /* }}} */
713
714 /* {{{ proto mixed variant_xor(mixed left, mixed right)
715 Performs a logical exclusion on two variants */
PHP_FUNCTION(variant_xor)716 PHP_FUNCTION(variant_xor)
717 {
718 variant_binary_operation(VOP_XOR, INTERNAL_FUNCTION_PARAM_PASSTHRU);
719 }
720 /* }}} */
721
variant_unary_operation(enum variant_unary_opcode op,INTERNAL_FUNCTION_PARAMETERS)722 static void variant_unary_operation(enum variant_unary_opcode op, INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
723 {
724 VARIANT vres;
725 VARIANT left_val;
726 VARIANT *vleft = NULL;
727 zval *zleft = NULL;
728 php_com_dotnet_object *obj;
729 HRESULT result;
730 int codepage = CP_ACP;
731
732 VariantInit(&left_val);
733 VariantInit(&vres);
734
735 if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
736 ZEND_NUM_ARGS() TSRMLS_CC, "O", &zleft, php_com_variant_class_entry)) {
737 obj = CDNO_FETCH(zleft);
738 vleft = &obj->v;
739 } else if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
740 "z!", &zleft)) {
741 vleft = &left_val;
742 php_com_variant_from_zval(vleft, zleft, codepage TSRMLS_CC);
743 } else {
744 return;
745 }
746
747 switch (op) {
748 case VOP_ABS:
749 result = VarAbs(vleft, &vres);
750 break;
751 case VOP_FIX:
752 result = VarFix(vleft, &vres);
753 break;
754 case VOP_INT:
755 result = VarInt(vleft, &vres);
756 break;
757 case VOP_NEG:
758 result = VarNeg(vleft, &vres);
759 break;
760 case VOP_NOT:
761 result = VarNot(vleft, &vres);
762 break;
763 default:
764 result = E_INVALIDARG;
765 }
766
767 if (SUCCEEDED(result)) {
768 php_com_wrap_variant(return_value, &vres, codepage TSRMLS_CC);
769 } else {
770 php_com_throw_exception(result, NULL TSRMLS_CC);
771 }
772
773 VariantClear(&vres);
774 VariantClear(&left_val);
775 }
776 /* }}} */
777
778 /* {{{ proto mixed variant_abs(mixed left)
779 Returns the absolute value of a variant */
PHP_FUNCTION(variant_abs)780 PHP_FUNCTION(variant_abs)
781 {
782 variant_unary_operation(VOP_ABS, INTERNAL_FUNCTION_PARAM_PASSTHRU);
783 }
784 /* }}} */
785
786 /* {{{ proto mixed variant_fix(mixed left)
787 Returns the integer part ? of a variant */
PHP_FUNCTION(variant_fix)788 PHP_FUNCTION(variant_fix)
789 {
790 variant_unary_operation(VOP_FIX, INTERNAL_FUNCTION_PARAM_PASSTHRU);
791 }
792 /* }}} */
793
794 /* {{{ proto mixed variant_int(mixed left)
795 Returns the integer portion of a variant */
PHP_FUNCTION(variant_int)796 PHP_FUNCTION(variant_int)
797 {
798 variant_unary_operation(VOP_INT, INTERNAL_FUNCTION_PARAM_PASSTHRU);
799 }
800 /* }}} */
801
802 /* {{{ proto mixed variant_neg(mixed left)
803 Performs logical negation on a variant */
PHP_FUNCTION(variant_neg)804 PHP_FUNCTION(variant_neg)
805 {
806 variant_unary_operation(VOP_NEG, INTERNAL_FUNCTION_PARAM_PASSTHRU);
807 }
808 /* }}} */
809
810 /* {{{ proto mixed variant_not(mixed left)
811 Performs bitwise not negation on a variant */
PHP_FUNCTION(variant_not)812 PHP_FUNCTION(variant_not)
813 {
814 variant_unary_operation(VOP_NOT, INTERNAL_FUNCTION_PARAM_PASSTHRU);
815 }
816 /* }}} */
817
818 /* {{{ proto mixed variant_round(mixed left, int decimals)
819 Rounds a variant to the specified number of decimal places */
PHP_FUNCTION(variant_round)820 PHP_FUNCTION(variant_round)
821 {
822 VARIANT vres;
823 VARIANT left_val;
824 VARIANT *vleft = NULL;
825 zval *zleft = NULL;
826 php_com_dotnet_object *obj;
827 int codepage = CP_ACP;
828 long decimals = 0;
829
830 VariantInit(&left_val);
831 VariantInit(&vres);
832
833 if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
834 ZEND_NUM_ARGS() TSRMLS_CC, "Ol", &zleft, php_com_variant_class_entry, &decimals)) {
835 obj = CDNO_FETCH(zleft);
836 vleft = &obj->v;
837 } else if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
838 "z!l", &zleft, &decimals)) {
839 vleft = &left_val;
840 php_com_variant_from_zval(vleft, zleft, codepage TSRMLS_CC);
841 } else {
842 return;
843 }
844
845 if (SUCCEEDED(VarRound(vleft, decimals, &vres))) {
846 php_com_wrap_variant(return_value, &vres, codepage TSRMLS_CC);
847 }
848
849 VariantClear(&vres);
850 VariantClear(&left_val);
851 }
852 /* }}} */
853
854 /* {{{ proto int variant_cmp(mixed left, mixed right [, int lcid [, int flags]])
855 Compares two variants */
PHP_FUNCTION(variant_cmp)856 PHP_FUNCTION(variant_cmp)
857 {
858 VARIANT left_val, right_val;
859 VARIANT *vleft = NULL, *vright = NULL;
860 zval *zleft = NULL, *zright = NULL;
861 php_com_dotnet_object *obj;
862 int codepage = CP_ACP;
863 long lcid = LOCALE_SYSTEM_DEFAULT;
864 long flags = 0;
865 /* it is safe to ignore the warning for this line; see the comments in com_handlers.c */
866 STDAPI VarCmp(LPVARIANT pvarLeft, LPVARIANT pvarRight, LCID lcid, DWORD flags);
867
868 VariantInit(&left_val);
869 VariantInit(&right_val);
870
871 if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
872 ZEND_NUM_ARGS() TSRMLS_CC, "OO|ll", &zleft, php_com_variant_class_entry,
873 &zright, php_com_variant_class_entry, &lcid, &flags)) {
874 obj = CDNO_FETCH(zleft);
875 vleft = &obj->v;
876 obj = CDNO_FETCH(zright);
877 vright = &obj->v;
878 } else if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
879 ZEND_NUM_ARGS() TSRMLS_CC, "Oz!|ll", &zleft, php_com_variant_class_entry,
880 &zright, &lcid, &flags)) {
881 obj = CDNO_FETCH(zleft);
882 vleft = &obj->v;
883 vright = &right_val;
884 php_com_variant_from_zval(vright, zright, codepage TSRMLS_CC);
885 } else if (SUCCESS == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET,
886 ZEND_NUM_ARGS() TSRMLS_CC, "z!O|ll", &zleft, &zright, php_com_variant_class_entry,
887 &lcid, &flags)) {
888 obj = CDNO_FETCH(zright);
889 vright = &obj->v;
890 vleft = &left_val;
891 php_com_variant_from_zval(vleft, zleft, codepage TSRMLS_CC);
892 } else if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
893 "z!z!|ll", &zleft, &zright, &lcid, &flags)) {
894
895 vleft = &left_val;
896 php_com_variant_from_zval(vleft, zleft, codepage TSRMLS_CC);
897
898 vright = &right_val;
899 php_com_variant_from_zval(vright, zright, codepage TSRMLS_CC);
900
901 } else {
902 return;
903 }
904
905 ZVAL_LONG(return_value, VarCmp(vleft, vright, lcid, flags));
906
907 VariantClear(&left_val);
908 VariantClear(&right_val);
909 }
910 /* }}} */
911
912 /* {{{ proto int variant_date_to_timestamp(object variant)
913 Converts a variant date/time value to unix timestamp */
PHP_FUNCTION(variant_date_to_timestamp)914 PHP_FUNCTION(variant_date_to_timestamp)
915 {
916 VARIANT vres;
917 zval *zleft = NULL;
918 php_com_dotnet_object *obj;
919
920 VariantInit(&vres);
921
922 if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
923 "O", &zleft, php_com_variant_class_entry)) {
924 return;
925 }
926 obj = CDNO_FETCH(zleft);
927
928 if (SUCCEEDED(VariantChangeType(&vres, &obj->v, 0, VT_DATE))) {
929 SYSTEMTIME systime;
930 struct tm tmv;
931
932 VariantTimeToSystemTime(V_DATE(&vres), &systime);
933
934 memset(&tmv, 0, sizeof(tmv));
935 tmv.tm_year = systime.wYear - 1900;
936 tmv.tm_mon = systime.wMonth - 1;
937 tmv.tm_mday = systime.wDay;
938 tmv.tm_hour = systime.wHour;
939 tmv.tm_min = systime.wMinute;
940 tmv.tm_sec = systime.wSecond;
941 tmv.tm_isdst = -1;
942
943 tzset();
944 RETVAL_LONG(mktime(&tmv));
945 }
946
947 VariantClear(&vres);
948 }
949 /* }}} */
950
951 /* {{{ proto object variant_date_from_timestamp(int timestamp)
952 Returns a variant date representation of a unix timestamp */
PHP_FUNCTION(variant_date_from_timestamp)953 PHP_FUNCTION(variant_date_from_timestamp)
954 {
955 long timestamp;
956 time_t ttstamp;
957 SYSTEMTIME systime;
958 struct tm *tmv;
959 VARIANT res;
960
961 if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",
962 ×tamp)) {
963 return;
964 }
965
966 if (timestamp < 0) {
967 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Timestamp value must be a positive value.");
968 RETURN_FALSE;
969 }
970
971 VariantInit(&res);
972 tzset();
973 ttstamp = timestamp;
974 tmv = localtime(&ttstamp);
975 memset(&systime, 0, sizeof(systime));
976
977 systime.wDay = tmv->tm_mday;
978 systime.wHour = tmv->tm_hour;
979 systime.wMinute = tmv->tm_min;
980 systime.wMonth = tmv->tm_mon + 1;
981 systime.wSecond = tmv->tm_sec;
982 systime.wYear = tmv->tm_year + 1900;
983
984 V_VT(&res) = VT_DATE;
985 SystemTimeToVariantTime(&systime, &V_DATE(&res));
986
987 php_com_wrap_variant(return_value, &res, CP_ACP TSRMLS_CC);
988
989 VariantClear(&res);
990 }
991 /* }}} */
992
993 /* {{{ proto int variant_get_type(object variant)
994 Returns the VT_XXX type code for a variant */
PHP_FUNCTION(variant_get_type)995 PHP_FUNCTION(variant_get_type)
996 {
997 zval *zobj;
998 php_com_dotnet_object *obj;
999
1000 if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
1001 "O", &zobj, php_com_variant_class_entry)) {
1002 return;
1003 }
1004 obj = CDNO_FETCH(zobj);
1005
1006 RETURN_LONG(V_VT(&obj->v));
1007 }
1008 /* }}} */
1009
1010 /* {{{ proto void variant_set_type(object variant, int type)
1011 Convert a variant into another type. Variant is modified "in-place" */
PHP_FUNCTION(variant_set_type)1012 PHP_FUNCTION(variant_set_type)
1013 {
1014 zval *zobj;
1015 php_com_dotnet_object *obj;
1016 /* VARTYPE == unsigned short */ long vt;
1017 HRESULT res;
1018
1019 if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
1020 "Ol", &zobj, php_com_variant_class_entry, &vt)) {
1021 return;
1022 }
1023 obj = CDNO_FETCH(zobj);
1024
1025 res = VariantChangeType(&obj->v, &obj->v, 0, (VARTYPE)vt);
1026
1027 if (SUCCEEDED(res)) {
1028 if (vt != VT_DISPATCH && obj->typeinfo) {
1029 ITypeInfo_Release(obj->typeinfo);
1030 obj->typeinfo = NULL;
1031 }
1032 } else {
1033 char *werr, *msg;
1034
1035 werr = php_win32_error_to_msg(res);
1036 spprintf(&msg, 0, "Variant type conversion failed: %s", werr);
1037 LocalFree(werr);
1038
1039 php_com_throw_exception(res, msg TSRMLS_CC);
1040 efree(msg);
1041 }
1042 }
1043 /* }}} */
1044
1045 /* {{{ proto object variant_cast(object variant, int type)
1046 Convert a variant into a new variant object of another type */
PHP_FUNCTION(variant_cast)1047 PHP_FUNCTION(variant_cast)
1048 {
1049 zval *zobj;
1050 php_com_dotnet_object *obj;
1051 /* VARTYPE == unsigned short */ long vt;
1052 VARIANT vres;
1053 HRESULT res;
1054
1055 if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC,
1056 "Ol", &zobj, php_com_variant_class_entry, &vt)) {
1057 return;
1058 }
1059 obj = CDNO_FETCH(zobj);
1060
1061 VariantInit(&vres);
1062 res = VariantChangeType(&vres, &obj->v, 0, (VARTYPE)vt);
1063
1064 if (SUCCEEDED(res)) {
1065 php_com_wrap_variant(return_value, &vres, obj->code_page TSRMLS_CC);
1066 } else {
1067 char *werr, *msg;
1068
1069 werr = php_win32_error_to_msg(res);
1070 spprintf(&msg, 0, "Variant type conversion failed: %s", werr);
1071 LocalFree(werr);
1072
1073 php_com_throw_exception(res, msg TSRMLS_CC);
1074 efree(msg);
1075 }
1076
1077 VariantClear(&vres);
1078 }
1079 /* }}} */
1080
1081
