Annotation of embedaddon/php/Zend/zend_object_handlers.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | Zend Engine |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1998-2012 Zend Technologies Ltd. (http://www.zend.com) |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 2.00 of the Zend 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.zend.com/license/2_00.txt. |
! 11: | If you did not receive a copy of the Zend license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@zend.com so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Authors: Andi Gutmans <andi@zend.com> |
! 16: | Zeev Suraski <zeev@zend.com> |
! 17: +----------------------------------------------------------------------+
! 18: */
! 19:
! 20: /* $Id: zend_object_handlers.c 321634 2012-01-01 13:15:04Z felipe $ */
! 21:
! 22: #include "zend.h"
! 23: #include "zend_globals.h"
! 24: #include "zend_variables.h"
! 25: #include "zend_API.h"
! 26: #include "zend_objects.h"
! 27: #include "zend_objects_API.h"
! 28: #include "zend_object_handlers.h"
! 29: #include "zend_interfaces.h"
! 30: #include "zend_closures.h"
! 31: #include "zend_compile.h"
! 32:
! 33: #define DEBUG_OBJECT_HANDLERS 0
! 34:
! 35: #define Z_OBJ_P(zval_p) zend_objects_get_address(zval_p TSRMLS_CC)
! 36:
! 37: /*
! 38: __X accessors explanation:
! 39:
! 40: if we have __get and property that is not part of the properties array is
! 41: requested, we call __get handler. If it fails, we return uninitialized.
! 42:
! 43: if we have __set and property that is not part of the properties array is
! 44: set, we call __set handler. If it fails, we do not change the array.
! 45:
! 46: for both handlers above, when we are inside __get/__set, no further calls for
! 47: __get/__set for this property of this object will be made, to prevent endless
! 48: recursion and enable accessors to change properties array.
! 49:
! 50: if we have __call and method which is not part of the class function table is
! 51: called, we cal __call handler.
! 52: */
! 53:
! 54: ZEND_API HashTable *zend_std_get_properties(zval *object TSRMLS_DC) /* {{{ */
! 55: {
! 56: zend_object *zobj;
! 57: zobj = Z_OBJ_P(object);
! 58: return zobj->properties;
! 59: }
! 60: /* }}} */
! 61:
! 62: ZEND_API HashTable *zend_std_get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
! 63: {
! 64: *is_temp = 0;
! 65: return zend_std_get_properties(object TSRMLS_CC);
! 66: }
! 67: /* }}} */
! 68:
! 69: static zval *zend_std_call_getter(zval *object, zval *member TSRMLS_DC) /* {{{ */
! 70: {
! 71: zval *retval = NULL;
! 72: zend_class_entry *ce = Z_OBJCE_P(object);
! 73:
! 74: /* __get handler is called with one argument:
! 75: property name
! 76:
! 77: it should return whether the call was successfull or not
! 78: */
! 79:
! 80: SEPARATE_ARG_IF_REF(member);
! 81:
! 82: zend_call_method_with_1_params(&object, ce, &ce->__get, ZEND_GET_FUNC_NAME, &retval, member);
! 83:
! 84: zval_ptr_dtor(&member);
! 85:
! 86: if (retval) {
! 87: Z_DELREF_P(retval);
! 88: }
! 89:
! 90: return retval;
! 91: }
! 92: /* }}} */
! 93:
! 94: static int zend_std_call_setter(zval *object, zval *member, zval *value TSRMLS_DC) /* {{{ */
! 95: {
! 96: zval *retval = NULL;
! 97: int result;
! 98: zend_class_entry *ce = Z_OBJCE_P(object);
! 99:
! 100: SEPARATE_ARG_IF_REF(member);
! 101: Z_ADDREF_P(value);
! 102:
! 103: /* __set handler is called with two arguments:
! 104: property name
! 105: value to be set
! 106:
! 107: it should return whether the call was successfull or not
! 108: */
! 109: zend_call_method_with_2_params(&object, ce, &ce->__set, ZEND_SET_FUNC_NAME, &retval, member, value);
! 110:
! 111: zval_ptr_dtor(&member);
! 112: zval_ptr_dtor(&value);
! 113:
! 114: if (retval) {
! 115: result = i_zend_is_true(retval) ? SUCCESS : FAILURE;
! 116: zval_ptr_dtor(&retval);
! 117: return result;
! 118: } else {
! 119: return FAILURE;
! 120: }
! 121: }
! 122: /* }}} */
! 123:
! 124: static void zend_std_call_unsetter(zval *object, zval *member TSRMLS_DC) /* {{{ */
! 125: {
! 126: zend_class_entry *ce = Z_OBJCE_P(object);
! 127:
! 128: /* __unset handler is called with one argument:
! 129: property name
! 130: */
! 131:
! 132: SEPARATE_ARG_IF_REF(member);
! 133:
! 134: zend_call_method_with_1_params(&object, ce, &ce->__unset, ZEND_UNSET_FUNC_NAME, NULL, member);
! 135:
! 136: zval_ptr_dtor(&member);
! 137: }
! 138: /* }}} */
! 139:
! 140: static zval *zend_std_call_issetter(zval *object, zval *member TSRMLS_DC) /* {{{ */
! 141: {
! 142: zval *retval = NULL;
! 143: zend_class_entry *ce = Z_OBJCE_P(object);
! 144:
! 145: /* __isset handler is called with one argument:
! 146: property name
! 147:
! 148: it should return whether the property is set or not
! 149: */
! 150:
! 151: SEPARATE_ARG_IF_REF(member);
! 152:
! 153: zend_call_method_with_1_params(&object, ce, &ce->__isset, ZEND_ISSET_FUNC_NAME, &retval, member);
! 154:
! 155: zval_ptr_dtor(&member);
! 156:
! 157: return retval;
! 158: }
! 159: /* }}} */
! 160:
! 161: static int zend_verify_property_access(zend_property_info *property_info, zend_class_entry *ce TSRMLS_DC) /* {{{ */
! 162: {
! 163: switch (property_info->flags & ZEND_ACC_PPP_MASK) {
! 164: case ZEND_ACC_PUBLIC:
! 165: return 1;
! 166: case ZEND_ACC_PROTECTED:
! 167: return zend_check_protected(property_info->ce, EG(scope));
! 168: case ZEND_ACC_PRIVATE:
! 169: if ((ce==EG(scope) || property_info->ce == EG(scope)) && EG(scope)) {
! 170: return 1;
! 171: } else {
! 172: return 0;
! 173: }
! 174: break;
! 175: }
! 176: return 0;
! 177: }
! 178: /* }}} */
! 179:
! 180: static inline zend_bool is_derived_class(zend_class_entry *child_class, zend_class_entry *parent_class) /* {{{ */
! 181: {
! 182: child_class = child_class->parent;
! 183: while (child_class) {
! 184: if (child_class == parent_class) {
! 185: return 1;
! 186: }
! 187: child_class = child_class->parent;
! 188: }
! 189:
! 190: return 0;
! 191: }
! 192: /* }}} */
! 193:
! 194: ZEND_API struct _zend_property_info *zend_get_property_info(zend_class_entry *ce, zval *member, int silent TSRMLS_DC) /* {{{ */
! 195: {
! 196: zend_property_info *property_info = NULL;
! 197: zend_property_info *scope_property_info;
! 198: zend_bool denied_access = 0;
! 199: ulong h;
! 200:
! 201: if (Z_STRVAL_P(member)[0] == '\0') {
! 202: if (!silent) {
! 203: if (Z_STRLEN_P(member) == 0) {
! 204: zend_error(E_ERROR, "Cannot access empty property");
! 205: } else {
! 206: zend_error(E_ERROR, "Cannot access property started with '\\0'");
! 207: }
! 208: }
! 209: return NULL;
! 210: }
! 211: h = zend_get_hash_value(Z_STRVAL_P(member), Z_STRLEN_P(member) + 1);
! 212: if (zend_hash_quick_find(&ce->properties_info, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, h, (void **) &property_info)==SUCCESS) {
! 213: if(property_info->flags & ZEND_ACC_SHADOW) {
! 214: /* if it's a shadow - go to access it's private */
! 215: property_info = NULL;
! 216: } else {
! 217: if (zend_verify_property_access(property_info, ce TSRMLS_CC)) {
! 218: if (property_info->flags & ZEND_ACC_CHANGED
! 219: && !(property_info->flags & ZEND_ACC_PRIVATE)) {
! 220: /* We still need to make sure that we're not in a context
! 221: * where the right property is a different 'statically linked' private
! 222: * continue checking below...
! 223: */
! 224: } else {
! 225: if (!silent && (property_info->flags & ZEND_ACC_STATIC)) {
! 226: zend_error(E_STRICT, "Accessing static property %s::$%s as non static", ce->name, Z_STRVAL_P(member));
! 227: }
! 228: return property_info;
! 229: }
! 230: } else {
! 231: /* Try to look in the scope instead */
! 232: denied_access = 1;
! 233: }
! 234: }
! 235: }
! 236: if (EG(scope) != ce
! 237: && is_derived_class(ce, EG(scope))
! 238: && EG(scope)
! 239: && zend_hash_quick_find(&EG(scope)->properties_info, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, h, (void **) &scope_property_info)==SUCCESS
! 240: && scope_property_info->flags & ZEND_ACC_PRIVATE) {
! 241: return scope_property_info;
! 242: } else if (property_info) {
! 243: if (denied_access) {
! 244: /* Information was available, but we were denied access. Error out. */
! 245: if (silent) {
! 246: return NULL;
! 247: }
! 248: zend_error(E_ERROR, "Cannot access %s property %s::$%s", zend_visibility_string(property_info->flags), ce->name, Z_STRVAL_P(member));
! 249: } else {
! 250: /* fall through, return property_info... */
! 251: }
! 252: } else {
! 253: EG(std_property_info).flags = ZEND_ACC_PUBLIC;
! 254: EG(std_property_info).name = Z_STRVAL_P(member);
! 255: EG(std_property_info).name_length = Z_STRLEN_P(member);
! 256: EG(std_property_info).h = h;
! 257: EG(std_property_info).ce = ce;
! 258: property_info = &EG(std_property_info);
! 259: }
! 260: return property_info;
! 261: }
! 262: /* }}} */
! 263:
! 264: ZEND_API int zend_check_property_access(zend_object *zobj, char *prop_info_name, int prop_info_name_len TSRMLS_DC) /* {{{ */
! 265: {
! 266: zend_property_info *property_info;
! 267: char *class_name, *prop_name;
! 268: zval member;
! 269:
! 270: zend_unmangle_property_name(prop_info_name, prop_info_name_len, &class_name, &prop_name);
! 271: ZVAL_STRING(&member, prop_name, 0);
! 272: property_info = zend_get_property_info(zobj->ce, &member, 1 TSRMLS_CC);
! 273: if (!property_info) {
! 274: return FAILURE;
! 275: }
! 276: if (class_name && class_name[0] != '*') {
! 277: if (!(property_info->flags & ZEND_ACC_PRIVATE)) {
! 278: /* we we're looking for a private prop but found a non private one of the same name */
! 279: return FAILURE;
! 280: } else if (strcmp(prop_info_name+1, property_info->name+1)) {
! 281: /* we we're looking for a private prop but found a private one of the same name but another class */
! 282: return FAILURE;
! 283: }
! 284: }
! 285: return zend_verify_property_access(property_info, zobj->ce TSRMLS_CC) ? SUCCESS : FAILURE;
! 286: }
! 287: /* }}} */
! 288:
! 289: static int zend_get_property_guard(zend_object *zobj, zend_property_info *property_info, zval *member, zend_guard **pguard) /* {{{ */
! 290: {
! 291: zend_property_info info;
! 292: zend_guard stub;
! 293:
! 294: if (!property_info) {
! 295: property_info = &info;
! 296: info.name = Z_STRVAL_P(member);
! 297: info.name_length = Z_STRLEN_P(member);
! 298: info.h = zend_get_hash_value(Z_STRVAL_P(member), Z_STRLEN_P(member) + 1);
! 299: }
! 300: if (!zobj->guards) {
! 301: ALLOC_HASHTABLE(zobj->guards);
! 302: zend_hash_init(zobj->guards, 0, NULL, NULL, 0);
! 303: } else if (zend_hash_quick_find(zobj->guards, property_info->name, property_info->name_length+1, property_info->h, (void **) pguard) == SUCCESS) {
! 304: return SUCCESS;
! 305: }
! 306: stub.in_get = 0;
! 307: stub.in_set = 0;
! 308: stub.in_unset = 0;
! 309: stub.in_isset = 0;
! 310: return zend_hash_quick_add(zobj->guards, property_info->name, property_info->name_length+1, property_info->h, (void**)&stub, sizeof(stub), (void**) pguard);
! 311: }
! 312: /* }}} */
! 313:
! 314: zval *zend_std_read_property(zval *object, zval *member, int type TSRMLS_DC) /* {{{ */
! 315: {
! 316: zend_object *zobj;
! 317: zval *tmp_member = NULL;
! 318: zval **retval;
! 319: zval *rv = NULL;
! 320: zend_property_info *property_info;
! 321: int silent;
! 322:
! 323: silent = (type == BP_VAR_IS);
! 324: zobj = Z_OBJ_P(object);
! 325:
! 326: if (Z_TYPE_P(member) != IS_STRING) {
! 327: ALLOC_ZVAL(tmp_member);
! 328: *tmp_member = *member;
! 329: INIT_PZVAL(tmp_member);
! 330: zval_copy_ctor(tmp_member);
! 331: convert_to_string(tmp_member);
! 332: member = tmp_member;
! 333: }
! 334:
! 335: #if DEBUG_OBJECT_HANDLERS
! 336: fprintf(stderr, "Read object #%d property: %s\n", Z_OBJ_HANDLE_P(object), Z_STRVAL_P(member));
! 337: #endif
! 338:
! 339: /* make zend_get_property_info silent if we have getter - we may want to use it */
! 340: property_info = zend_get_property_info(zobj->ce, member, (zobj->ce->__get != NULL) TSRMLS_CC);
! 341:
! 342: if (!property_info || zend_hash_quick_find(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, (void **) &retval) == FAILURE) {
! 343: zend_guard *guard = NULL;
! 344:
! 345: if (zobj->ce->__get &&
! 346: zend_get_property_guard(zobj, property_info, member, &guard) == SUCCESS &&
! 347: !guard->in_get) {
! 348: /* have getter - try with it! */
! 349: Z_ADDREF_P(object);
! 350: if (PZVAL_IS_REF(object)) {
! 351: SEPARATE_ZVAL(&object);
! 352: }
! 353: guard->in_get = 1; /* prevent circular getting */
! 354: rv = zend_std_call_getter(object, member TSRMLS_CC);
! 355: guard->in_get = 0;
! 356:
! 357: if (rv) {
! 358: retval = &rv;
! 359: if (!Z_ISREF_P(rv) &&
! 360: (type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET)) {
! 361: if (Z_REFCOUNT_P(rv) > 0) {
! 362: zval *tmp = rv;
! 363:
! 364: ALLOC_ZVAL(rv);
! 365: *rv = *tmp;
! 366: zval_copy_ctor(rv);
! 367: Z_UNSET_ISREF_P(rv);
! 368: Z_SET_REFCOUNT_P(rv, 0);
! 369: }
! 370: if (Z_TYPE_P(rv) != IS_OBJECT) {
! 371: zend_error(E_NOTICE, "Indirect modification of overloaded property %s::$%s has no effect", zobj->ce->name, Z_STRVAL_P(member));
! 372: }
! 373: }
! 374: } else {
! 375: retval = &EG(uninitialized_zval_ptr);
! 376: }
! 377: if (EXPECTED(*retval != object)) {
! 378: zval_ptr_dtor(&object);
! 379: } else {
! 380: Z_DELREF_P(object);
! 381: }
! 382: } else {
! 383: if (zobj->ce->__get && guard && guard->in_get == 1) {
! 384: if (Z_STRVAL_P(member)[0] == '\0') {
! 385: if (Z_STRLEN_P(member) == 0) {
! 386: zend_error(E_ERROR, "Cannot access empty property");
! 387: } else {
! 388: zend_error(E_ERROR, "Cannot access property started with '\\0'");
! 389: }
! 390: }
! 391: }
! 392: if (!silent) {
! 393: zend_error(E_NOTICE,"Undefined property: %s::$%s", zobj->ce->name, Z_STRVAL_P(member));
! 394: }
! 395: retval = &EG(uninitialized_zval_ptr);
! 396: }
! 397: }
! 398: if (tmp_member) {
! 399: Z_ADDREF_PP(retval);
! 400: zval_ptr_dtor(&tmp_member);
! 401: Z_DELREF_PP(retval);
! 402: }
! 403: return *retval;
! 404: }
! 405: /* }}} */
! 406:
! 407: static void zend_std_write_property(zval *object, zval *member, zval *value TSRMLS_DC) /* {{{ */
! 408: {
! 409: zend_object *zobj;
! 410: zval *tmp_member = NULL;
! 411: zval **variable_ptr;
! 412: zend_property_info *property_info;
! 413:
! 414: zobj = Z_OBJ_P(object);
! 415:
! 416: if (Z_TYPE_P(member) != IS_STRING) {
! 417: ALLOC_ZVAL(tmp_member);
! 418: *tmp_member = *member;
! 419: INIT_PZVAL(tmp_member);
! 420: zval_copy_ctor(tmp_member);
! 421: convert_to_string(tmp_member);
! 422: member = tmp_member;
! 423: }
! 424:
! 425: property_info = zend_get_property_info(zobj->ce, member, (zobj->ce->__set != NULL) TSRMLS_CC);
! 426:
! 427: if (property_info && zend_hash_quick_find(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, (void **) &variable_ptr) == SUCCESS) {
! 428: /* if we already have this value there, we don't actually need to do anything */
! 429: if (*variable_ptr != value) {
! 430: /* if we are assigning reference, we shouldn't move it, but instead assign variable
! 431: to the same pointer */
! 432: if (PZVAL_IS_REF(*variable_ptr)) {
! 433: zval garbage = **variable_ptr; /* old value should be destroyed */
! 434:
! 435: /* To check: can't *variable_ptr be some system variable like error_zval here? */
! 436: Z_TYPE_PP(variable_ptr) = Z_TYPE_P(value);
! 437: (*variable_ptr)->value = value->value;
! 438: if (Z_REFCOUNT_P(value) > 0) {
! 439: zval_copy_ctor(*variable_ptr);
! 440: }
! 441: zval_dtor(&garbage);
! 442: } else {
! 443: zval *garbage = *variable_ptr;
! 444:
! 445: /* if we assign referenced variable, we should separate it */
! 446: Z_ADDREF_P(value);
! 447: if (PZVAL_IS_REF(value)) {
! 448: SEPARATE_ZVAL(&value);
! 449: }
! 450: *variable_ptr = value;
! 451: zval_ptr_dtor(&garbage);
! 452: }
! 453: }
! 454: } else {
! 455: zend_guard *guard = NULL;
! 456:
! 457: if (zobj->ce->__set &&
! 458: zend_get_property_guard(zobj, property_info, member, &guard) == SUCCESS &&
! 459: !guard->in_set) {
! 460: Z_ADDREF_P(object);
! 461: if (PZVAL_IS_REF(object)) {
! 462: SEPARATE_ZVAL(&object);
! 463: }
! 464: guard->in_set = 1; /* prevent circular setting */
! 465: if (zend_std_call_setter(object, member, value TSRMLS_CC) != SUCCESS) {
! 466: /* for now, just ignore it - __set should take care of warnings, etc. */
! 467: }
! 468: guard->in_set = 0;
! 469: zval_ptr_dtor(&object);
! 470: } else if (property_info) {
! 471: zval **foo;
! 472:
! 473: /* if we assign referenced variable, we should separate it */
! 474: Z_ADDREF_P(value);
! 475: if (PZVAL_IS_REF(value)) {
! 476: SEPARATE_ZVAL(&value);
! 477: }
! 478: zend_hash_quick_update(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, &value, sizeof(zval *), (void **) &foo);
! 479: } else if (zobj->ce->__set && guard && guard->in_set == 1) {
! 480: if (Z_STRVAL_P(member)[0] == '\0') {
! 481: if (Z_STRLEN_P(member) == 0) {
! 482: zend_error(E_ERROR, "Cannot access empty property");
! 483: } else {
! 484: zend_error(E_ERROR, "Cannot access property started with '\\0'");
! 485: }
! 486: }
! 487: }
! 488: }
! 489:
! 490: if (tmp_member) {
! 491: zval_ptr_dtor(&tmp_member);
! 492: }
! 493: }
! 494: /* }}} */
! 495:
! 496: zval *zend_std_read_dimension(zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */
! 497: {
! 498: zend_class_entry *ce = Z_OBJCE_P(object);
! 499: zval *retval;
! 500:
! 501: if (instanceof_function_ex(ce, zend_ce_arrayaccess, 1 TSRMLS_CC)) {
! 502: if(offset == NULL) {
! 503: /* [] construct */
! 504: ALLOC_INIT_ZVAL(offset);
! 505: } else {
! 506: SEPARATE_ARG_IF_REF(offset);
! 507: }
! 508: zend_call_method_with_1_params(&object, ce, NULL, "offsetget", &retval, offset);
! 509:
! 510: zval_ptr_dtor(&offset);
! 511:
! 512: if (!retval) {
! 513: if (!EG(exception)) {
! 514: zend_error(E_ERROR, "Undefined offset for object of type %s used as array", ce->name);
! 515: }
! 516: return 0;
! 517: }
! 518:
! 519: /* Undo PZVAL_LOCK() */
! 520: Z_DELREF_P(retval);
! 521:
! 522: return retval;
! 523: } else {
! 524: zend_error(E_ERROR, "Cannot use object of type %s as array", ce->name);
! 525: return 0;
! 526: }
! 527: }
! 528: /* }}} */
! 529:
! 530: static void zend_std_write_dimension(zval *object, zval *offset, zval *value TSRMLS_DC) /* {{{ */
! 531: {
! 532: zend_class_entry *ce = Z_OBJCE_P(object);
! 533:
! 534: if (instanceof_function_ex(ce, zend_ce_arrayaccess, 1 TSRMLS_CC)) {
! 535: if (!offset) {
! 536: ALLOC_INIT_ZVAL(offset);
! 537: } else {
! 538: SEPARATE_ARG_IF_REF(offset);
! 539: }
! 540: zend_call_method_with_2_params(&object, ce, NULL, "offsetset", NULL, offset, value);
! 541: zval_ptr_dtor(&offset);
! 542: } else {
! 543: zend_error(E_ERROR, "Cannot use object of type %s as array", ce->name);
! 544: }
! 545: }
! 546: /* }}} */
! 547:
! 548: static int zend_std_has_dimension(zval *object, zval *offset, int check_empty TSRMLS_DC) /* {{{ */
! 549: {
! 550: zend_class_entry *ce = Z_OBJCE_P(object);
! 551: zval *retval;
! 552: int result;
! 553:
! 554: if (instanceof_function_ex(ce, zend_ce_arrayaccess, 1 TSRMLS_CC)) {
! 555: SEPARATE_ARG_IF_REF(offset);
! 556: zend_call_method_with_1_params(&object, ce, NULL, "offsetexists", &retval, offset);
! 557: if (retval) {
! 558: result = i_zend_is_true(retval);
! 559: zval_ptr_dtor(&retval);
! 560: if (check_empty && result && !EG(exception)) {
! 561: zend_call_method_with_1_params(&object, ce, NULL, "offsetget", &retval, offset);
! 562: if (retval) {
! 563: result = i_zend_is_true(retval);
! 564: zval_ptr_dtor(&retval);
! 565: }
! 566: }
! 567: } else {
! 568: result = 0;
! 569: }
! 570: zval_ptr_dtor(&offset);
! 571: } else {
! 572: zend_error(E_ERROR, "Cannot use object of type %s as array", ce->name);
! 573: return 0;
! 574: }
! 575: return result;
! 576: }
! 577: /* }}} */
! 578:
! 579: static zval **zend_std_get_property_ptr_ptr(zval *object, zval *member TSRMLS_DC) /* {{{ */
! 580: {
! 581: zend_object *zobj;
! 582: zval tmp_member;
! 583: zval **retval;
! 584: zend_property_info *property_info;
! 585:
! 586: zobj = Z_OBJ_P(object);
! 587:
! 588: if (Z_TYPE_P(member) != IS_STRING) {
! 589: tmp_member = *member;
! 590: zval_copy_ctor(&tmp_member);
! 591: convert_to_string(&tmp_member);
! 592: member = &tmp_member;
! 593: }
! 594:
! 595: #if DEBUG_OBJECT_HANDLERS
! 596: fprintf(stderr, "Ptr object #%d property: %s\n", Z_OBJ_HANDLE_P(object), Z_STRVAL_P(member));
! 597: #endif
! 598:
! 599: property_info = zend_get_property_info(zobj->ce, member, (zobj->ce->__get != NULL) TSRMLS_CC);
! 600:
! 601: if (!property_info || zend_hash_quick_find(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, (void **) &retval) == FAILURE) {
! 602: zval *new_zval;
! 603: zend_guard *guard;
! 604:
! 605: if (!zobj->ce->__get ||
! 606: zend_get_property_guard(zobj, property_info, member, &guard) != SUCCESS ||
! 607: (property_info && guard->in_get)) {
! 608: /* we don't have access controls - will just add it */
! 609: new_zval = &EG(uninitialized_zval);
! 610:
! 611: /* zend_error(E_NOTICE, "Undefined property: %s", Z_STRVAL_P(member)); */
! 612: Z_ADDREF_P(new_zval);
! 613: zend_hash_quick_update(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, &new_zval, sizeof(zval *), (void **) &retval);
! 614: } else {
! 615: /* we do have getter - fail and let it try again with usual get/set */
! 616: retval = NULL;
! 617: }
! 618: }
! 619: if (member == &tmp_member) {
! 620: zval_dtor(member);
! 621: }
! 622: return retval;
! 623: }
! 624: /* }}} */
! 625:
! 626: static void zend_std_unset_property(zval *object, zval *member TSRMLS_DC) /* {{{ */
! 627: {
! 628: zend_object *zobj;
! 629: zval *tmp_member = NULL;
! 630: zend_property_info *property_info;
! 631:
! 632: zobj = Z_OBJ_P(object);
! 633:
! 634: if (Z_TYPE_P(member) != IS_STRING) {
! 635: ALLOC_ZVAL(tmp_member);
! 636: *tmp_member = *member;
! 637: INIT_PZVAL(tmp_member);
! 638: zval_copy_ctor(tmp_member);
! 639: convert_to_string(tmp_member);
! 640: member = tmp_member;
! 641: }
! 642:
! 643: property_info = zend_get_property_info(zobj->ce, member, (zobj->ce->__unset != NULL) TSRMLS_CC);
! 644:
! 645: if (!property_info || zend_hash_quick_del(zobj->properties, property_info->name, property_info->name_length+1, property_info->h) == FAILURE) {
! 646: zend_guard *guard = NULL;
! 647:
! 648: if (zobj->ce->__unset &&
! 649: zend_get_property_guard(zobj, property_info, member, &guard) == SUCCESS &&
! 650: !guard->in_unset) {
! 651: /* have unseter - try with it! */
! 652: Z_ADDREF_P(object);
! 653: if (PZVAL_IS_REF(object)) {
! 654: SEPARATE_ZVAL(&object);
! 655: }
! 656: guard->in_unset = 1; /* prevent circular unsetting */
! 657: zend_std_call_unsetter(object, member TSRMLS_CC);
! 658: guard->in_unset = 0;
! 659: zval_ptr_dtor(&object);
! 660: } else if (zobj->ce->__unset && guard && guard->in_unset == 1) {
! 661: if (Z_STRVAL_P(member)[0] == '\0') {
! 662: if (Z_STRLEN_P(member) == 0) {
! 663: zend_error(E_ERROR, "Cannot access empty property");
! 664: } else {
! 665: zend_error(E_ERROR, "Cannot access property started with '\\0'");
! 666: }
! 667: }
! 668: }
! 669: }
! 670:
! 671: if (tmp_member) {
! 672: zval_ptr_dtor(&tmp_member);
! 673: }
! 674: }
! 675: /* }}} */
! 676:
! 677: static void zend_std_unset_dimension(zval *object, zval *offset TSRMLS_DC) /* {{{ */
! 678: {
! 679: zend_class_entry *ce = Z_OBJCE_P(object);
! 680:
! 681: if (instanceof_function_ex(ce, zend_ce_arrayaccess, 1 TSRMLS_CC)) {
! 682: SEPARATE_ARG_IF_REF(offset);
! 683: zend_call_method_with_1_params(&object, ce, NULL, "offsetunset", NULL, offset);
! 684: zval_ptr_dtor(&offset);
! 685: } else {
! 686: zend_error(E_ERROR, "Cannot use object of type %s as array", ce->name);
! 687: }
! 688: }
! 689: /* }}} */
! 690:
! 691: ZEND_API void zend_std_call_user_call(INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
! 692: {
! 693: zend_internal_function *func = (zend_internal_function *)EG(current_execute_data)->function_state.function;
! 694: zval *method_name_ptr, *method_args_ptr;
! 695: zval *method_result_ptr = NULL;
! 696: zend_class_entry *ce = Z_OBJCE_P(this_ptr);
! 697:
! 698: ALLOC_ZVAL(method_args_ptr);
! 699: INIT_PZVAL(method_args_ptr);
! 700: array_init_size(method_args_ptr, ZEND_NUM_ARGS());
! 701:
! 702: if (zend_copy_parameters_array(ZEND_NUM_ARGS(), method_args_ptr TSRMLS_CC) == FAILURE) {
! 703: zval_dtor(method_args_ptr);
! 704: zend_error(E_ERROR, "Cannot get arguments for __call");
! 705: RETURN_FALSE;
! 706: }
! 707:
! 708: ALLOC_ZVAL(method_name_ptr);
! 709: INIT_PZVAL(method_name_ptr);
! 710: ZVAL_STRING(method_name_ptr, func->function_name, 0); /* no dup - it's a copy */
! 711:
! 712: /* __call handler is called with two arguments:
! 713: method name
! 714: array of method parameters
! 715:
! 716: */
! 717: zend_call_method_with_2_params(&this_ptr, ce, &ce->__call, ZEND_CALL_FUNC_NAME, &method_result_ptr, method_name_ptr, method_args_ptr);
! 718:
! 719: if (method_result_ptr) {
! 720: if (Z_ISREF_P(method_result_ptr) || Z_REFCOUNT_P(method_result_ptr) > 1) {
! 721: RETVAL_ZVAL(method_result_ptr, 1, 1);
! 722: } else {
! 723: RETVAL_ZVAL(method_result_ptr, 0, 1);
! 724: }
! 725: }
! 726:
! 727: /* now destruct all auxiliaries */
! 728: zval_ptr_dtor(&method_args_ptr);
! 729: zval_ptr_dtor(&method_name_ptr);
! 730:
! 731: /* destruct the function also, then - we have allocated it in get_method */
! 732: efree(func);
! 733: }
! 734: /* }}} */
! 735:
! 736: /* Ensures that we're allowed to call a private method.
! 737: * Returns the function address that should be called, or NULL
! 738: * if no such function exists.
! 739: */
! 740: static inline zend_function *zend_check_private_int(zend_function *fbc, zend_class_entry *ce, char *function_name_strval, int function_name_strlen TSRMLS_DC) /* {{{ */
! 741: {
! 742: if (!ce) {
! 743: return 0;
! 744: }
! 745:
! 746: /* We may call a private function if:
! 747: * 1. The class of our object is the same as the scope, and the private
! 748: * function (EX(fbc)) has the same scope.
! 749: * 2. One of our parent classes are the same as the scope, and it contains
! 750: * a private function with the same name that has the same scope.
! 751: */
! 752: if (fbc->common.scope == ce && EG(scope) == ce) {
! 753: /* rule #1 checks out ok, allow the function call */
! 754: return fbc;
! 755: }
! 756:
! 757:
! 758: /* Check rule #2 */
! 759: ce = ce->parent;
! 760: while (ce) {
! 761: if (ce == EG(scope)) {
! 762: if (zend_hash_find(&ce->function_table, function_name_strval, function_name_strlen+1, (void **) &fbc)==SUCCESS
! 763: && fbc->op_array.fn_flags & ZEND_ACC_PRIVATE
! 764: && fbc->common.scope == EG(scope)) {
! 765: return fbc;
! 766: }
! 767: break;
! 768: }
! 769: ce = ce->parent;
! 770: }
! 771: return NULL;
! 772: }
! 773: /* }}} */
! 774:
! 775: ZEND_API int zend_check_private(zend_function *fbc, zend_class_entry *ce, char *function_name_strval, int function_name_strlen TSRMLS_DC) /* {{{ */
! 776: {
! 777: return zend_check_private_int(fbc, ce, function_name_strval, function_name_strlen TSRMLS_CC) != NULL;
! 778: }
! 779: /* }}} */
! 780:
! 781: /* Ensures that we're allowed to call a protected method.
! 782: */
! 783: ZEND_API int zend_check_protected(zend_class_entry *ce, zend_class_entry *scope) /* {{{ */
! 784: {
! 785: zend_class_entry *fbc_scope = ce;
! 786:
! 787: /* Is the context that's calling the function, the same as one of
! 788: * the function's parents?
! 789: */
! 790: while (fbc_scope) {
! 791: if (fbc_scope==scope) {
! 792: return 1;
! 793: }
! 794: fbc_scope = fbc_scope->parent;
! 795: }
! 796:
! 797: /* Is the function's scope the same as our current object context,
! 798: * or any of the parents of our context?
! 799: */
! 800: while (scope) {
! 801: if (scope==ce) {
! 802: return 1;
! 803: }
! 804: scope = scope->parent;
! 805: }
! 806: return 0;
! 807: }
! 808: /* }}} */
! 809:
! 810: static inline zend_class_entry * zend_get_function_root_class(zend_function *fbc) /* {{{ */
! 811: {
! 812: return fbc->common.prototype ? fbc->common.prototype->common.scope : fbc->common.scope;
! 813: }
! 814: /* }}} */
! 815:
! 816: static inline union _zend_function *zend_get_user_call_function(zend_class_entry *ce, const char *method_name, int method_len) /* {{{ */
! 817: {
! 818: zend_internal_function *call_user_call = emalloc(sizeof(zend_internal_function));
! 819: call_user_call->type = ZEND_INTERNAL_FUNCTION;
! 820: call_user_call->module = ce->module;
! 821: call_user_call->handler = zend_std_call_user_call;
! 822: call_user_call->arg_info = NULL;
! 823: call_user_call->num_args = 0;
! 824: call_user_call->scope = ce;
! 825: call_user_call->fn_flags = ZEND_ACC_CALL_VIA_HANDLER;
! 826: call_user_call->function_name = estrndup(method_name, method_len);
! 827: call_user_call->pass_rest_by_reference = 0;
! 828: call_user_call->return_reference = ZEND_RETURN_VALUE;
! 829:
! 830: return (union _zend_function *)call_user_call;
! 831: }
! 832: /* }}} */
! 833:
! 834: static union _zend_function *zend_std_get_method(zval **object_ptr, char *method_name, int method_len TSRMLS_DC) /* {{{ */
! 835: {
! 836: zend_object *zobj;
! 837: zend_function *fbc;
! 838: char *lc_method_name;
! 839: zval *object = *object_ptr;
! 840: ALLOCA_FLAG(use_heap)
! 841:
! 842: lc_method_name = do_alloca(method_len+1, use_heap);
! 843: /* Create a zend_copy_str_tolower(dest, src, src_length); */
! 844: zend_str_tolower_copy(lc_method_name, method_name, method_len);
! 845:
! 846: zobj = Z_OBJ_P(object);
! 847: if (zend_hash_find(&zobj->ce->function_table, lc_method_name, method_len+1, (void **)&fbc) == FAILURE) {
! 848: free_alloca(lc_method_name, use_heap);
! 849: if (zobj->ce->__call) {
! 850: return zend_get_user_call_function(zobj->ce, method_name, method_len);
! 851: } else {
! 852: return NULL;
! 853: }
! 854: }
! 855:
! 856: /* Check access level */
! 857: if (fbc->op_array.fn_flags & ZEND_ACC_PRIVATE) {
! 858: zend_function *updated_fbc;
! 859:
! 860: /* Ensure that if we're calling a private function, we're allowed to do so.
! 861: * If we're not and __call() handler exists, invoke it, otherwise error out.
! 862: */
! 863: updated_fbc = zend_check_private_int(fbc, Z_OBJ_HANDLER_P(object, get_class_entry)(object TSRMLS_CC), lc_method_name, method_len TSRMLS_CC);
! 864: if (updated_fbc) {
! 865: fbc = updated_fbc;
! 866: } else {
! 867: if (zobj->ce->__call) {
! 868: fbc = zend_get_user_call_function(zobj->ce, method_name, method_len);
! 869: } else {
! 870: zend_error(E_ERROR, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), method_name, EG(scope) ? EG(scope)->name : "");
! 871: }
! 872: }
! 873: } else {
! 874: /* Ensure that we haven't overridden a private function and end up calling
! 875: * the overriding public function...
! 876: */
! 877: if (EG(scope) &&
! 878: is_derived_class(fbc->common.scope, EG(scope)) &&
! 879: fbc->op_array.fn_flags & ZEND_ACC_CHANGED) {
! 880: zend_function *priv_fbc;
! 881:
! 882: if (zend_hash_find(&EG(scope)->function_table, lc_method_name, method_len+1, (void **) &priv_fbc)==SUCCESS
! 883: && priv_fbc->common.fn_flags & ZEND_ACC_PRIVATE
! 884: && priv_fbc->common.scope == EG(scope)) {
! 885: fbc = priv_fbc;
! 886: }
! 887: }
! 888: if ((fbc->common.fn_flags & ZEND_ACC_PROTECTED)) {
! 889: /* Ensure that if we're calling a protected function, we're allowed to do so.
! 890: * If we're not and __call() handler exists, invoke it, otherwise error out.
! 891: */
! 892: if (!zend_check_protected(zend_get_function_root_class(fbc), EG(scope))) {
! 893: if (zobj->ce->__call) {
! 894: fbc = zend_get_user_call_function(zobj->ce, method_name, method_len);
! 895: } else {
! 896: zend_error(E_ERROR, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), method_name, EG(scope) ? EG(scope)->name : "");
! 897: }
! 898: }
! 899: }
! 900: }
! 901:
! 902: free_alloca(lc_method_name, use_heap);
! 903: return fbc;
! 904: }
! 905: /* }}} */
! 906:
! 907: ZEND_API void zend_std_callstatic_user_call(INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
! 908: {
! 909: zend_internal_function *func = (zend_internal_function *)EG(current_execute_data)->function_state.function;
! 910: zval *method_name_ptr, *method_args_ptr;
! 911: zval *method_result_ptr = NULL;
! 912: zend_class_entry *ce = EG(scope);
! 913:
! 914: ALLOC_ZVAL(method_args_ptr);
! 915: INIT_PZVAL(method_args_ptr);
! 916: array_init_size(method_args_ptr, ZEND_NUM_ARGS());
! 917:
! 918: if (zend_copy_parameters_array(ZEND_NUM_ARGS(), method_args_ptr TSRMLS_CC) == FAILURE) {
! 919: zval_dtor(method_args_ptr);
! 920: zend_error(E_ERROR, "Cannot get arguments for " ZEND_CALLSTATIC_FUNC_NAME);
! 921: RETURN_FALSE;
! 922: }
! 923:
! 924: ALLOC_ZVAL(method_name_ptr);
! 925: INIT_PZVAL(method_name_ptr);
! 926: ZVAL_STRING(method_name_ptr, func->function_name, 0); /* no dup - it's a copy */
! 927:
! 928: /* __callStatic handler is called with two arguments:
! 929: method name
! 930: array of method parameters
! 931: */
! 932: zend_call_method_with_2_params(NULL, ce, &ce->__callstatic, ZEND_CALLSTATIC_FUNC_NAME, &method_result_ptr, method_name_ptr, method_args_ptr);
! 933:
! 934: if (method_result_ptr) {
! 935: if (Z_ISREF_P(method_result_ptr) || Z_REFCOUNT_P(method_result_ptr) > 1) {
! 936: RETVAL_ZVAL(method_result_ptr, 1, 1);
! 937: } else {
! 938: RETVAL_ZVAL(method_result_ptr, 0, 1);
! 939: }
! 940: }
! 941:
! 942: /* now destruct all auxiliaries */
! 943: zval_ptr_dtor(&method_args_ptr);
! 944: zval_ptr_dtor(&method_name_ptr);
! 945:
! 946: /* destruct the function also, then - we have allocated it in get_method */
! 947: efree(func);
! 948: }
! 949: /* }}} */
! 950:
! 951: static inline union _zend_function *zend_get_user_callstatic_function(zend_class_entry *ce, const char *method_name, int method_len) /* {{{ */
! 952: {
! 953: zend_internal_function *callstatic_user_call = emalloc(sizeof(zend_internal_function));
! 954: callstatic_user_call->type = ZEND_INTERNAL_FUNCTION;
! 955: callstatic_user_call->module = ce->module;
! 956: callstatic_user_call->handler = zend_std_callstatic_user_call;
! 957: callstatic_user_call->arg_info = NULL;
! 958: callstatic_user_call->num_args = 0;
! 959: callstatic_user_call->scope = ce;
! 960: callstatic_user_call->fn_flags = ZEND_ACC_STATIC | ZEND_ACC_PUBLIC | ZEND_ACC_CALL_VIA_HANDLER;
! 961: callstatic_user_call->function_name = estrndup(method_name, method_len);
! 962: callstatic_user_call->pass_rest_by_reference = 0;
! 963: callstatic_user_call->return_reference = ZEND_RETURN_VALUE;
! 964:
! 965: return (zend_function *)callstatic_user_call;
! 966: }
! 967: /* }}} */
! 968:
! 969: /* This is not (yet?) in the API, but it belongs in the built-in objects callbacks */
! 970:
! 971: ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, char *function_name_strval, int function_name_strlen TSRMLS_DC) /* {{{ */
! 972: {
! 973: zend_function *fbc = NULL;
! 974: char *lc_class_name, *lc_function_name = NULL;
! 975:
! 976: lc_function_name = zend_str_tolower_dup(function_name_strval, function_name_strlen);
! 977:
! 978: if (function_name_strlen == ce->name_length && ce->constructor) {
! 979: lc_class_name = zend_str_tolower_dup(ce->name, ce->name_length);
! 980: /* Only change the method to the constructor if the constructor isn't called __construct
! 981: * we check for __ so we can be binary safe for lowering, we should use ZEND_CONSTRUCTOR_FUNC_NAME
! 982: */
! 983: if (!memcmp(lc_class_name, lc_function_name, function_name_strlen) && memcmp(ce->constructor->common.function_name, "__", sizeof("__") - 1)) {
! 984: fbc = ce->constructor;
! 985: }
! 986: efree(lc_class_name);
! 987: }
! 988: if (!fbc && zend_hash_find(&ce->function_table, lc_function_name, function_name_strlen+1, (void **) &fbc)==FAILURE) {
! 989: efree(lc_function_name);
! 990:
! 991: if (ce->__call &&
! 992: EG(This) &&
! 993: Z_OBJ_HT_P(EG(This))->get_class_entry &&
! 994: instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
! 995: return zend_get_user_call_function(ce, function_name_strval, function_name_strlen);
! 996: } else if (ce->__callstatic) {
! 997: return zend_get_user_callstatic_function(ce, function_name_strval, function_name_strlen);
! 998: } else {
! 999: return NULL;
! 1000: }
! 1001: }
! 1002: efree(lc_function_name);
! 1003:
! 1004: #if MBO_0
! 1005: /* right now this function is used for non static method lookup too */
! 1006: /* Is the function static */
! 1007: if (!(fbc->common.fn_flags & ZEND_ACC_STATIC)) {
! 1008: zend_error(E_ERROR, "Cannot call non static method %s::%s() without object", ZEND_FN_SCOPE_NAME(fbc), fbc->common.function_name);
! 1009: }
! 1010: #endif
! 1011: if (fbc->op_array.fn_flags & ZEND_ACC_PUBLIC) {
! 1012: /* No further checks necessary, most common case */
! 1013: } else if (fbc->op_array.fn_flags & ZEND_ACC_PRIVATE) {
! 1014: zend_function *updated_fbc;
! 1015:
! 1016: /* Ensure that if we're calling a private function, we're allowed to do so.
! 1017: */
! 1018: updated_fbc = zend_check_private_int(fbc, EG(scope), function_name_strval, function_name_strlen TSRMLS_CC);
! 1019: if (updated_fbc) {
! 1020: fbc = updated_fbc;
! 1021: } else {
! 1022: if (ce->__callstatic) {
! 1023: return zend_get_user_callstatic_function(ce, function_name_strval, function_name_strlen);
! 1024: }
! 1025: zend_error(E_ERROR, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), function_name_strval, EG(scope) ? EG(scope)->name : "");
! 1026: }
! 1027: } else if ((fbc->common.fn_flags & ZEND_ACC_PROTECTED)) {
! 1028: /* Ensure that if we're calling a protected function, we're allowed to do so.
! 1029: */
! 1030: if (!zend_check_protected(zend_get_function_root_class(fbc), EG(scope))) {
! 1031: if (ce->__callstatic) {
! 1032: return zend_get_user_callstatic_function(ce, function_name_strval, function_name_strlen);
! 1033: }
! 1034: zend_error(E_ERROR, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), function_name_strval, EG(scope) ? EG(scope)->name : "");
! 1035: }
! 1036: }
! 1037:
! 1038: return fbc;
! 1039: }
! 1040: /* }}} */
! 1041:
! 1042: ZEND_API zval **zend_std_get_static_property(zend_class_entry *ce, char *property_name, int property_name_len, zend_bool silent TSRMLS_DC) /* {{{ */
! 1043: {
! 1044: zval **retval = NULL;
! 1045: zend_class_entry *tmp_ce = ce;
! 1046: zend_property_info *property_info;
! 1047: zend_property_info std_property_info;
! 1048:
! 1049: if (zend_hash_find(&ce->properties_info, property_name, property_name_len+1, (void **) &property_info)==FAILURE) {
! 1050: std_property_info.flags = ZEND_ACC_PUBLIC;
! 1051: std_property_info.name = property_name;
! 1052: std_property_info.name_length = property_name_len;
! 1053: std_property_info.h = zend_get_hash_value(std_property_info.name, std_property_info.name_length+1);
! 1054: std_property_info.ce = ce;
! 1055: property_info = &std_property_info;
! 1056: }
! 1057:
! 1058: #if DEBUG_OBJECT_HANDLERS
! 1059: zend_printf("Access type for %s::%s is %s\n", ce->name, property_name, zend_visibility_string(property_info->flags));
! 1060: #endif
! 1061:
! 1062: if (!zend_verify_property_access(property_info, ce TSRMLS_CC)) {
! 1063: if (!silent) {
! 1064: zend_error(E_ERROR, "Cannot access %s property %s::$%s", zend_visibility_string(property_info->flags), ce->name, property_name);
! 1065: }
! 1066: return NULL;
! 1067: }
! 1068:
! 1069: zend_update_class_constants(tmp_ce TSRMLS_CC);
! 1070:
! 1071: zend_hash_quick_find(CE_STATIC_MEMBERS(tmp_ce), property_info->name, property_info->name_length+1, property_info->h, (void **) &retval);
! 1072:
! 1073: if (!retval) {
! 1074: if (silent) {
! 1075: return NULL;
! 1076: } else {
! 1077: zend_error(E_ERROR, "Access to undeclared static property: %s::$%s", ce->name, property_name);
! 1078: }
! 1079: }
! 1080:
! 1081: return retval;
! 1082: }
! 1083: /* }}} */
! 1084:
! 1085: ZEND_API zend_bool zend_std_unset_static_property(zend_class_entry *ce, char *property_name, int property_name_len TSRMLS_DC) /* {{{ */
! 1086: {
! 1087: zend_error(E_ERROR, "Attempt to unset static property %s::$%s", ce->name, property_name);
! 1088: return 0;
! 1089: }
! 1090: /* }}} */
! 1091:
! 1092: ZEND_API union _zend_function *zend_std_get_constructor(zval *object TSRMLS_DC) /* {{{ */
! 1093: {
! 1094: zend_object *zobj = Z_OBJ_P(object);
! 1095: zend_function *constructor = zobj->ce->constructor;
! 1096:
! 1097: if (constructor) {
! 1098: if (constructor->op_array.fn_flags & ZEND_ACC_PUBLIC) {
! 1099: /* No further checks necessary */
! 1100: } else if (constructor->op_array.fn_flags & ZEND_ACC_PRIVATE) {
! 1101: /* Ensure that if we're calling a private function, we're allowed to do so.
! 1102: */
! 1103: if (constructor->common.scope != EG(scope)) {
! 1104: if (EG(scope)) {
! 1105: zend_error(E_ERROR, "Call to private %s::%s() from context '%s'", constructor->common.scope->name, constructor->common.function_name, EG(scope)->name);
! 1106: } else {
! 1107: zend_error(E_ERROR, "Call to private %s::%s() from invalid context", constructor->common.scope->name, constructor->common.function_name);
! 1108: }
! 1109: }
! 1110: } else if ((constructor->common.fn_flags & ZEND_ACC_PROTECTED)) {
! 1111: /* Ensure that if we're calling a protected function, we're allowed to do so.
! 1112: * Constructors only have prototype if they are defined by an interface but
! 1113: * it is the compilers responsibility to take care of the prototype.
! 1114: */
! 1115: if (!zend_check_protected(zend_get_function_root_class(constructor), EG(scope))) {
! 1116: if (EG(scope)) {
! 1117: zend_error(E_ERROR, "Call to protected %s::%s() from context '%s'", constructor->common.scope->name, constructor->common.function_name, EG(scope)->name);
! 1118: } else {
! 1119: zend_error(E_ERROR, "Call to protected %s::%s() from invalid context", constructor->common.scope->name, constructor->common.function_name);
! 1120: }
! 1121: }
! 1122: }
! 1123: }
! 1124:
! 1125: return constructor;
! 1126: }
! 1127: /* }}} */
! 1128:
! 1129: int zend_compare_symbol_tables_i(HashTable *ht1, HashTable *ht2 TSRMLS_DC);
! 1130:
! 1131: static int zend_std_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
! 1132: {
! 1133: zend_object *zobj1, *zobj2;
! 1134:
! 1135: zobj1 = Z_OBJ_P(o1);
! 1136: zobj2 = Z_OBJ_P(o2);
! 1137:
! 1138: if (zobj1->ce != zobj2->ce) {
! 1139: return 1; /* different classes */
! 1140: }
! 1141: return zend_compare_symbol_tables_i(zobj1->properties, zobj2->properties TSRMLS_CC);
! 1142: }
! 1143: /* }}} */
! 1144:
! 1145: static int zend_std_has_property(zval *object, zval *member, int has_set_exists TSRMLS_DC) /* {{{ */
! 1146: {
! 1147: zend_object *zobj;
! 1148: int result;
! 1149: zval **value;
! 1150: zval *tmp_member = NULL;
! 1151: zend_property_info *property_info;
! 1152:
! 1153: zobj = Z_OBJ_P(object);
! 1154:
! 1155: if (Z_TYPE_P(member) != IS_STRING) {
! 1156: ALLOC_ZVAL(tmp_member);
! 1157: *tmp_member = *member;
! 1158: INIT_PZVAL(tmp_member);
! 1159: zval_copy_ctor(tmp_member);
! 1160: convert_to_string(tmp_member);
! 1161: member = tmp_member;
! 1162: }
! 1163:
! 1164: #if DEBUG_OBJECT_HANDLERS
! 1165: fprintf(stderr, "Read object #%d property: %s\n", Z_OBJ_HANDLE_P(object), Z_STRVAL_P(member));
! 1166: #endif
! 1167:
! 1168: property_info = zend_get_property_info(zobj->ce, member, 1 TSRMLS_CC);
! 1169:
! 1170: if (!property_info || zend_hash_quick_find(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, (void **) &value) == FAILURE) {
! 1171: zend_guard *guard;
! 1172:
! 1173: result = 0;
! 1174: if ((has_set_exists != 2) &&
! 1175: zobj->ce->__isset &&
! 1176: zend_get_property_guard(zobj, property_info, member, &guard) == SUCCESS &&
! 1177: !guard->in_isset) {
! 1178: zval *rv;
! 1179:
! 1180: /* have issetter - try with it! */
! 1181: Z_ADDREF_P(object);
! 1182: if (PZVAL_IS_REF(object)) {
! 1183: SEPARATE_ZVAL(&object);
! 1184: }
! 1185: guard->in_isset = 1; /* prevent circular getting */
! 1186: rv = zend_std_call_issetter(object, member TSRMLS_CC);
! 1187: if (rv) {
! 1188: result = zend_is_true(rv);
! 1189: zval_ptr_dtor(&rv);
! 1190: if (has_set_exists && result) {
! 1191: if (!EG(exception) && zobj->ce->__get && !guard->in_get) {
! 1192: guard->in_get = 1;
! 1193: rv = zend_std_call_getter(object, member TSRMLS_CC);
! 1194: guard->in_get = 0;
! 1195: if (rv) {
! 1196: Z_ADDREF_P(rv);
! 1197: result = i_zend_is_true(rv);
! 1198: zval_ptr_dtor(&rv);
! 1199: } else {
! 1200: result = 0;
! 1201: }
! 1202: } else {
! 1203: result = 0;
! 1204: }
! 1205: }
! 1206: }
! 1207: guard->in_isset = 0;
! 1208: zval_ptr_dtor(&object);
! 1209: }
! 1210: } else {
! 1211: switch (has_set_exists) {
! 1212: case 0:
! 1213: result = (Z_TYPE_PP(value) != IS_NULL);
! 1214: break;
! 1215: default:
! 1216: result = zend_is_true(*value);
! 1217: break;
! 1218: case 2:
! 1219: result = 1;
! 1220: break;
! 1221: }
! 1222: }
! 1223:
! 1224: if (tmp_member) {
! 1225: zval_ptr_dtor(&tmp_member);
! 1226: }
! 1227: return result;
! 1228: }
! 1229: /* }}} */
! 1230:
! 1231: zend_class_entry *zend_std_object_get_class(const zval *object TSRMLS_DC) /* {{{ */
! 1232: {
! 1233: zend_object *zobj;
! 1234: zobj = Z_OBJ_P(object);
! 1235:
! 1236: return zobj->ce;
! 1237: }
! 1238: /* }}} */
! 1239:
! 1240: int zend_std_object_get_class_name(const zval *object, char **class_name, zend_uint *class_name_len, int parent TSRMLS_DC) /* {{{ */
! 1241: {
! 1242: zend_object *zobj;
! 1243: zend_class_entry *ce;
! 1244: zobj = Z_OBJ_P(object);
! 1245:
! 1246: if (parent) {
! 1247: if (!zobj->ce->parent) {
! 1248: return FAILURE;
! 1249: }
! 1250: ce = zobj->ce->parent;
! 1251: } else {
! 1252: ce = zobj->ce;
! 1253: }
! 1254:
! 1255: *class_name_len = ce->name_length;
! 1256: *class_name = estrndup(ce->name, ce->name_length);
! 1257: return SUCCESS;
! 1258: }
! 1259: /* }}} */
! 1260:
! 1261: ZEND_API int zend_std_cast_object_tostring(zval *readobj, zval *writeobj, int type TSRMLS_DC) /* {{{ */
! 1262: {
! 1263: zval *retval;
! 1264: zend_class_entry *ce;
! 1265:
! 1266: switch (type) {
! 1267: case IS_STRING:
! 1268: ce = Z_OBJCE_P(readobj);
! 1269: if (ce->__tostring &&
! 1270: (zend_call_method_with_0_params(&readobj, ce, &ce->__tostring, "__tostring", &retval) || EG(exception))) {
! 1271: if (EG(exception)) {
! 1272: if (retval) {
! 1273: zval_ptr_dtor(&retval);
! 1274: }
! 1275: zend_error(E_ERROR, "Method %s::__toString() must not throw an exception", ce->name);
! 1276: return FAILURE;
! 1277: }
! 1278: if (Z_TYPE_P(retval) == IS_STRING) {
! 1279: INIT_PZVAL(writeobj);
! 1280: if (readobj == writeobj) {
! 1281: zval_dtor(readobj);
! 1282: }
! 1283: ZVAL_ZVAL(writeobj, retval, 1, 1);
! 1284: if (Z_TYPE_P(writeobj) != type) {
! 1285: convert_to_explicit_type(writeobj, type);
! 1286: }
! 1287: return SUCCESS;
! 1288: } else {
! 1289: zval_ptr_dtor(&retval);
! 1290: INIT_PZVAL(writeobj);
! 1291: if (readobj == writeobj) {
! 1292: zval_dtor(readobj);
! 1293: }
! 1294: ZVAL_EMPTY_STRING(writeobj);
! 1295: zend_error(E_RECOVERABLE_ERROR, "Method %s::__toString() must return a string value", ce->name);
! 1296: return SUCCESS;
! 1297: }
! 1298: }
! 1299: return FAILURE;
! 1300: case IS_BOOL:
! 1301: INIT_PZVAL(writeobj);
! 1302: ZVAL_BOOL(writeobj, 1);
! 1303: return SUCCESS;
! 1304: case IS_LONG:
! 1305: ce = Z_OBJCE_P(readobj);
! 1306: zend_error(E_NOTICE, "Object of class %s could not be converted to int", ce->name);
! 1307: INIT_PZVAL(writeobj);
! 1308: if (readobj == writeobj) {
! 1309: zval_dtor(readobj);
! 1310: }
! 1311: ZVAL_LONG(writeobj, 1);
! 1312: return SUCCESS;
! 1313: case IS_DOUBLE:
! 1314: ce = Z_OBJCE_P(readobj);
! 1315: zend_error(E_NOTICE, "Object of class %s could not be converted to double", ce->name);
! 1316: INIT_PZVAL(writeobj);
! 1317: if (readobj == writeobj) {
! 1318: zval_dtor(readobj);
! 1319: }
! 1320: ZVAL_DOUBLE(writeobj, 1);
! 1321: return SUCCESS;
! 1322: default:
! 1323: INIT_PZVAL(writeobj);
! 1324: Z_TYPE_P(writeobj) = IS_NULL;
! 1325: break;
! 1326: }
! 1327: return FAILURE;
! 1328: }
! 1329: /* }}} */
! 1330:
! 1331: int zend_std_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zval **zobj_ptr TSRMLS_DC) /* {{{ */
! 1332: {
! 1333: zend_class_entry *ce;
! 1334: if (Z_TYPE_P(obj) != IS_OBJECT) {
! 1335: return FAILURE;
! 1336: }
! 1337:
! 1338: ce = Z_OBJCE_P(obj);
! 1339:
! 1340: if (zend_hash_find(&ce->function_table, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME), (void**)fptr_ptr) == FAILURE) {
! 1341: return FAILURE;
! 1342: }
! 1343:
! 1344: *ce_ptr = ce;
! 1345: if ((*fptr_ptr)->common.fn_flags & ZEND_ACC_STATIC) {
! 1346: if (zobj_ptr) {
! 1347: *zobj_ptr = NULL;
! 1348: }
! 1349: } else {
! 1350: if (zobj_ptr) {
! 1351: *zobj_ptr = obj;
! 1352: }
! 1353: }
! 1354: return SUCCESS;
! 1355: }
! 1356: /* }}} */
! 1357:
! 1358: ZEND_API zend_object_handlers std_object_handlers = {
! 1359: zend_objects_store_add_ref, /* add_ref */
! 1360: zend_objects_store_del_ref, /* del_ref */
! 1361: zend_objects_clone_obj, /* clone_obj */
! 1362:
! 1363: zend_std_read_property, /* read_property */
! 1364: zend_std_write_property, /* write_property */
! 1365: zend_std_read_dimension, /* read_dimension */
! 1366: zend_std_write_dimension, /* write_dimension */
! 1367: zend_std_get_property_ptr_ptr, /* get_property_ptr_ptr */
! 1368: NULL, /* get */
! 1369: NULL, /* set */
! 1370: zend_std_has_property, /* has_property */
! 1371: zend_std_unset_property, /* unset_property */
! 1372: zend_std_has_dimension, /* has_dimension */
! 1373: zend_std_unset_dimension, /* unset_dimension */
! 1374: zend_std_get_properties, /* get_properties */
! 1375: zend_std_get_method, /* get_method */
! 1376: NULL, /* call_method */
! 1377: zend_std_get_constructor, /* get_constructor */
! 1378: zend_std_object_get_class, /* get_class_entry */
! 1379: zend_std_object_get_class_name, /* get_class_name */
! 1380: zend_std_compare_objects, /* compare_objects */
! 1381: zend_std_cast_object_tostring, /* cast_object */
! 1382: NULL, /* count_elements */
! 1383: NULL, /* get_debug_info */
! 1384: zend_std_get_closure, /* get_closure */
! 1385: };
! 1386:
! 1387: /*
! 1388: * Local variables:
! 1389: * tab-width: 4
! 1390: * c-basic-offset: 4
! 1391: * indent-tabs-mode: t
! 1392: * End:
! 1393: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zend_object_handlers.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 / Zend