git.m6w6.name Git - m6w6/ext-propro/blob - src/php_propro_api.c

   1 /*
   2     +--------------------------------------------------------------------+
   3     | PECL :: propro                                                     |
   4     +--------------------------------------------------------------------+
   5     | Redistribution and use in source and binary forms, with or without |
   6     | modification, are permitted provided that the conditions mentioned |
   7     | in the accompanying LICENSE file are met.                          |
   8     +--------------------------------------------------------------------+
   9     | Copyright (c) 2013 Michael Wallner <mike@php.net>                  |
  10     +--------------------------------------------------------------------+
  11 */
  12
  13
  14 #ifdef HAVE_CONFIG_H
  15 #       include "config.h"
  16 #endif
  17
  18 #include <php.h>
  19 #include <ext/standard/info.h>
  20
  21 #include "php_propro_api.h"
  22
  23 #define DEBUG_PROPRO 0
  24
  25 static inline zval *get_referenced_zval(zval *ref)
  26 {
  27         while (Z_ISREF_P(ref)) {
  28                 ref = Z_REFVAL_P(ref);
  29         }
  30         return ref;
  31 }
  32
  33 php_property_proxy_t *php_property_proxy_init(zval *container, zend_string *member)
  34 {
  35         php_property_proxy_t *proxy = ecalloc(1, sizeof(*proxy));
  36
  37         ZVAL_COPY(&proxy->container, get_referenced_zval(container));
  38         proxy->member = zend_string_copy(member);
  39
  40         return proxy;
  41 }
  42
  43 void php_property_proxy_free(php_property_proxy_t **proxy)
  44 {
  45         if (*proxy) {
  46                 zval_ptr_dtor(&(*proxy)->container);
  47                 zend_string_release((*proxy)->member);
  48                 efree(*proxy);
  49                 *proxy = NULL;
  50         }
  51 }
  52
  53 static zend_class_entry *php_property_proxy_class_entry;
  54 static zend_object_handlers php_property_proxy_object_handlers;
  55
  56 zend_class_entry *php_property_proxy_get_class_entry(void)
  57 {
  58         return php_property_proxy_class_entry;
  59 }
  60
  61 static inline php_property_proxy_object_t *get_propro(zval *object);
  62 static zval *get_parent_proxied_value(zval *object, zval *return_value);
  63 static zval *get_proxied_value(zval *object, zval *return_value);
  64 static zval *read_dimension(zval *object, zval *offset, int type, zval *return_value);
  65 static ZEND_RESULT_CODE cast_proxied_value(zval *object, zval *return_value, int type);
  66 static void write_dimension(zval *object, zval *offset, zval *value);
  67 static void set_proxied_value(zval *object, zval *value);
  68
  69 #if DEBUG_PROPRO
  70 /* we do not really care about TS when debugging */
  71 static int level = 1;
  72 static const char space[] = "                               ";
  73 static const char *inoutstr[] = {"< return","="," > enter"};
  74
  75 static void _walk(php_property_proxy_object_t *obj)
  76 {
  77         if (obj) {
  78                 if (!Z_ISUNDEF(obj->parent)) {
  79                         _walk(get_propro(&obj->parent));
  80                 }
  81                 if (obj->proxy) {
  82                         fprintf(stderr, ".%s", obj->proxy->member->val);
  83                 }
  84         }
  85 }
  86
  87 static void debug_propro(int inout, const char *f,
  88                 php_property_proxy_object_t *obj, zval *offset, zval *value TSRMLS_DC)
  89 {
  90         fprintf(stderr, "#PP %p %s %s %s ", obj, &space[sizeof(space)-level],
  91                         inoutstr[inout+1], f);
  92
  93         level += inout;
  94
  95         _walk(obj);
  96
  97         if (*f++=='d'
  98         &&      *f++=='i'
  99         &&      *f++=='m'
 100         ) {
 101                 char *offset_str = "[]";
 102                 zval *o = offset;
 103
 104                 if (o) {
 105                         convert_to_string_ex(o);
 106                         offset_str = Z_STRVAL_P(o);
 107                 }
 108
 109                 fprintf(stderr, ".%s", offset_str);
 110
 111                 if (o && o != offset) {
 112                         zval_ptr_dtor(o);
 113                 }
 114         }
 115         if (value && !Z_ISUNDEF_P(value)) {
 116                 const char *t[] = {
 117                                 "UNDEF",
 118                                 "NULL",
 119                                 "FALSE",
 120                                 "TRUE",
 121                                 "int",
 122                                 "float",
 123                                 "string",
 124                                 "Array",
 125                                 "Object",
 126                                 "resource",
 127                                 "reference",
 128                                 "constant",
 129                                 "constant AST",
 130                                 "_BOOL",
 131                                 "callable",
 132                                 "indirect",
 133                                 "---",
 134                                 "pointer"
 135                 };
 136                 fprintf(stderr, " = (%s) ", t[Z_TYPE_P(value)&0xf]);
 137                 if (!Z_ISUNDEF_P(value) && Z_TYPE_P(value) != IS_INDIRECT) {
 138                         zend_print_flat_zval_r(value TSRMLS_CC);
 139                 }
 140         }
 141
 142         fprintf(stderr, "\n");
 143 }
 144 #else
 145 #define debug_propro(l, f, obj, off, val)
 146 #endif
 147
 148 php_property_proxy_object_t *php_property_proxy_object_new_ex(
 149                 zend_class_entry *ce, php_property_proxy_t *proxy)
 150 {
 151         php_property_proxy_object_t *o;
 152
 153         if (!ce) {
 154                 ce = php_property_proxy_class_entry;
 155         }
 156
 157         o = ecalloc(1, sizeof(*o) + sizeof(zval) * (ce->default_properties_count - 1));
 158         zend_object_std_init(&o->zo, ce);
 159         object_properties_init(&o->zo, ce);
 160
 161         o->proxy = proxy;
 162         o->zo.handlers = &php_property_proxy_object_handlers;
 163
 164         debug_propro(0, "init", o, NULL, NULL);
 165
 166         return o;
 167 }
 168
 169 zend_object *php_property_proxy_object_new(zend_class_entry *ce)
 170 {
 171         return &php_property_proxy_object_new_ex(ce, NULL)->zo;
 172 }
 173
 174 static void destroy_obj(zend_object *object)
 175 {
 176         php_property_proxy_object_t *o = PHP_PROPRO_PTR(object);
 177
 178         debug_propro(0, "dtor", o, NULL, NULL);
 179
 180         if (o->proxy) {
 181                 php_property_proxy_free(&o->proxy);
 182         }
 183         if (!Z_ISUNDEF(o->parent)) {
 184                 zval_ptr_dtor(&o->parent);
 185                 ZVAL_UNDEF(&o->parent);
 186         }
 187         zend_object_std_dtor(object);
 188 }
 189
 190 static inline php_property_proxy_object_t *get_propro(zval *object)
 191 {
 192         object = get_referenced_zval(object);
 193         switch (Z_TYPE_P(object)) {
 194         case IS_OBJECT:
 195                 break;
 196
 197         EMPTY_SWITCH_DEFAULT_CASE();
 198         }
 199         return PHP_PROPRO_PTR(Z_OBJ_P(object));
 200 }
 201
 202 static inline zend_bool got_value(zval *container, zval *value)
 203 {
 204         zval identical;
 205
 206         if (!Z_ISUNDEF_P(value)) {
 207                 if (SUCCESS == is_identical_function(&identical, value, container)) {
 208                         if (Z_TYPE(identical) != IS_TRUE) {
 209                                 return 1;
 210                         }
 211                 }
 212         }
 213
 214         return 0;
 215 }
 216
 217 static zval *get_parent_proxied_value(zval *object, zval *return_value)
 218 {
 219         php_property_proxy_object_t *obj;
 220
 221         obj = get_propro(object);
 222         debug_propro(1, "parent_get", obj, NULL, NULL);
 223
 224         if (obj->proxy) {
 225                 if (!Z_ISUNDEF(obj->parent)) {
 226                         get_proxied_value(&obj->parent, return_value);
 227                 }
 228         }
 229
 230         debug_propro(-1, "parent_get", obj, NULL, return_value);
 231
 232         return return_value;
 233 }
 234
 235 static zval *get_proxied_value(zval *object, zval *return_value)
 236 {
 237         zval *hash_value, *ref, prop_tmp;
 238         php_property_proxy_object_t *obj;
 239
 240         obj = get_propro(object);
 241         debug_propro(1, "get", obj, NULL, NULL);
 242
 243         if (obj->proxy) {
 244                 if (!Z_ISUNDEF(obj->parent)) {
 245                         zval parent_value;
 246
 247                         ZVAL_UNDEF(&parent_value);
 248                         get_parent_proxied_value(object, &parent_value);
 249
 250                         if (got_value(&obj->proxy->container, &parent_value)) {
 251                                 zval_ptr_dtor(&obj->proxy->container);
 252                                 ZVAL_COPY(&obj->proxy->container, &parent_value);
 253                         }
 254                 }
 255
 256                 ref = get_referenced_zval(&obj->proxy->container);
 257
 258                 switch (Z_TYPE_P(ref)) {
 259                 case IS_OBJECT:
 260                         RETVAL_ZVAL(zend_read_property(Z_OBJCE_P(ref), ref,
 261                                         obj->proxy->member->val, obj->proxy->member->len, 0, &prop_tmp),
 262                                         0, 0);
 263                         break;
 264
 265                 case IS_ARRAY:
 266                         hash_value = zend_symtable_find(Z_ARRVAL_P(ref), obj->proxy->member);
 267
 268                         if (hash_value) {
 269                                 RETVAL_ZVAL(hash_value, 0, 0);
 270                         }
 271                         break;
 272                 }
 273         }
 274
 275         debug_propro(-1, "get", obj, NULL, return_value);
 276
 277         return return_value;
 278 }
 279
 280 static ZEND_RESULT_CODE cast_proxied_value(zval *object, zval *return_value,
 281                 int type)
 282 {
 283         get_proxied_value(object, return_value);
 284
 285         debug_propro(0, "cast", get_propro(object), NULL, return_value);
 286
 287         if (!Z_ISUNDEF_P(return_value)) {
 288                 convert_to_explicit_type_ex(return_value, type);
 289                 return SUCCESS;
 290         }
 291
 292         return FAILURE;
 293 }
 294
 295 static void set_proxied_value(zval *object, zval *value)
 296 {
 297         php_property_proxy_object_t *obj;
 298         zval *ref;
 299
 300         obj = get_propro(object);
 301         debug_propro(1, "set", obj, NULL, value TSRMLS_CC);
 302
 303         if (obj->proxy) {
 304                 if (!Z_ISUNDEF(obj->parent)) {
 305                         zval parent_value;
 306
 307                         ZVAL_UNDEF(&parent_value);
 308                         get_parent_proxied_value(object, &parent_value);
 309
 310                         if (got_value(&obj->proxy->container, &parent_value)) {
 311                                 zval_ptr_dtor(&obj->proxy->container);
 312                                 ZVAL_COPY(&obj->proxy->container, &parent_value);
 313                         }
 314                 }
 315
 316                 ref = get_referenced_zval(&obj->proxy->container);
 317
 318                 switch (Z_TYPE_P(ref)) {
 319                 case IS_OBJECT:
 320                         zend_update_property(Z_OBJCE_P(ref), ref, obj->proxy->member->val,
 321                                         obj->proxy->member->len, value);
 322                         break;
 323
 324                 default:
 325                         convert_to_array(ref);
 326                         /* no break */
 327
 328                 case IS_ARRAY:
 329                         Z_TRY_ADDREF_P(value);
 330                         zend_symtable_update(Z_ARRVAL_P(ref), obj->proxy->member, value);
 331                         break;
 332                 }
 333
 334                 if (!Z_ISUNDEF(obj->parent)) {
 335                         set_proxied_value(&obj->parent, &obj->proxy->container);
 336                 }
 337         }
 338
 339         debug_propro(-1, "set", obj, NULL, NULL);
 340 }
 341
 342 static zval *read_dimension(zval *object, zval *offset, int type, zval *return_value)
 343 {
 344         zval proxied_value;
 345         zend_string *member = offset ? zval_get_string(offset) : NULL;
 346
 347         debug_propro(1, type == BP_VAR_R ? "dim_read" : "dim_read_ref",
 348                         get_propro(object), offset, NULL);
 349
 350         ZVAL_UNDEF(&proxied_value);
 351         get_proxied_value(object, &proxied_value);
 352
 353         if (BP_VAR_R == type && member && !Z_ISUNDEF(proxied_value)) {
 354                 if (Z_TYPE(proxied_value) == IS_ARRAY) {
 355                         zval *hash_value = zend_symtable_find(Z_ARRVAL(proxied_value),
 356                                         member);
 357
 358                         if (hash_value) {
 359                                 RETVAL_ZVAL(hash_value, 1, 0);
 360                         }
 361                 }
 362         } else {
 363                 php_property_proxy_t *proxy;
 364                 php_property_proxy_object_t *proxy_obj;
 365
 366                 if (!Z_ISUNDEF(proxied_value)) {
 367                         convert_to_array(&proxied_value);
 368                         Z_ADDREF(proxied_value);
 369                 } else {
 370                         array_init(&proxied_value);
 371                         set_proxied_value(object, &proxied_value);
 372                 }
 373
 374                 if (!member) {
 375                         member = zend_long_to_str(zend_hash_next_free_element(
 376                                         Z_ARRVAL(proxied_value)));
 377                 }
 378
 379                 proxy = php_property_proxy_init(&proxied_value, member);
 380                 zval_ptr_dtor(&proxied_value);
 381
 382                 proxy_obj = php_property_proxy_object_new_ex(NULL, proxy);
 383                 ZVAL_COPY(&proxy_obj->parent, object);
 384                 RETVAL_OBJ(&proxy_obj->zo);
 385         }
 386
 387         if (member) {
 388                 zend_string_release(member);
 389         }
 390
 391         debug_propro(-1, type == BP_VAR_R ? "dim_read" : "dim_read_ref",
 392                         get_propro(object), offset, return_value);
 393
 394         return return_value;
 395 }
 396
 397 static int has_dimension(zval *object, zval *offset, int check_empty)
 398 {
 399         zval proxied_value;
 400         int exists = 0;
 401
 402         debug_propro(1, "dim_exists", get_propro(object), offset, NULL);
 403
 404         ZVAL_UNDEF(&proxied_value);
 405         get_proxied_value(object, &proxied_value);
 406         if (Z_ISUNDEF(proxied_value)) {
 407                 exists = 0;
 408         } else {
 409                 zend_string *zs = zval_get_string(offset);
 410
 411                 if (Z_TYPE(proxied_value) == IS_ARRAY) {
 412                         zval *zentry = zend_symtable_find(Z_ARRVAL(proxied_value), zs);
 413
 414                         if (!zentry) {
 415                                 exists = 0;
 416                         } else {
 417                                 if (check_empty) {
 418                                         exists = !Z_ISNULL_P(zentry);
 419                                 } else {
 420                                         exists = 1;
 421                                 }
 422                         }
 423                 }
 424
 425                 zend_string_release(zs);
 426         }
 427
 428         debug_propro(-1, "dim_exists", get_propro(object), offset, NULL);
 429
 430         return exists;
 431 }
 432
 433 static void write_dimension(zval *object, zval *offset, zval *value)
 434 {
 435         zval proxied_value;
 436
 437         debug_propro(1, "dim_write", get_propro(object), offset, value);
 438
 439         ZVAL_UNDEF(&proxied_value);
 440         get_proxied_value(object, &proxied_value);
 441
 442         if (!Z_ISUNDEF(proxied_value)) {
 443                 if (Z_TYPE(proxied_value) == IS_ARRAY) {
 444                         Z_ADDREF(proxied_value);
 445                 } else {
 446                         convert_to_array(&proxied_value);
 447                 }
 448         } else {
 449                 array_init(&proxied_value);
 450         }
 451
 452         SEPARATE_ZVAL(value);
 453         Z_TRY_ADDREF_P(value);
 454
 455         if (offset) {
 456                 zend_string *zs = zval_get_string(offset);
 457                 zend_symtable_update(Z_ARRVAL(proxied_value), zs, value);
 458                 zend_string_release(zs);
 459         } else {
 460                 zend_hash_next_index_insert(Z_ARRVAL(proxied_value), value);
 461         }
 462
 463         set_proxied_value(object, &proxied_value);
 464
 465         debug_propro(-1, "dim_write", get_propro(object), offset, &proxied_value);
 466
 467         zval_ptr_dtor(&proxied_value);
 468 }
 469
 470 static void unset_dimension(zval *object, zval *offset)
 471 {
 472         zval proxied_value;
 473
 474         debug_propro(1, "dim_unset", get_propro(object), offset, NULL);
 475
 476         ZVAL_UNDEF(&proxied_value);
 477         get_proxied_value(object, &proxied_value);
 478
 479         if (Z_TYPE(proxied_value) == IS_ARRAY) {
 480                 zval *o = offset;
 481                 ZEND_RESULT_CODE rv;
 482
 483                 convert_to_string_ex(o);
 484                 rv = zend_symtable_del(Z_ARRVAL(proxied_value), Z_STR_P(o));
 485                 if (SUCCESS == rv) {
 486                         set_proxied_value(object, &proxied_value);
 487                 }
 488
 489                 if (o != offset) {
 490                         zval_ptr_dtor(o);
 491                 }
 492         }
 493
 494         debug_propro(-1, "dim_unset", get_propro(object), offset, &proxied_value);
 495 }
 496
 497 ZEND_BEGIN_ARG_INFO_EX(ai_propro_construct, 0, 0, 2)
 498         ZEND_ARG_INFO(1, object)
 499         ZEND_ARG_INFO(0, member)
 500         ZEND_ARG_OBJ_INFO(0, parent, php\\PropertyProxy, 1)
 501 ZEND_END_ARG_INFO();
 502 static PHP_METHOD(propro, __construct) {
 503         zend_error_handling zeh;
 504         zval *container, *parent = NULL;
 505         zend_string *member;
 506
 507         zend_replace_error_handling(EH_THROW, NULL, &zeh);
 508         if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS(), "zS|O!",
 509                         &container, &member, &parent,
 510                         php_property_proxy_class_entry)) {
 511                 php_property_proxy_object_t *obj;
 512                 zval *ref = get_referenced_zval(container);
 513
 514                 switch (Z_TYPE_P(ref)) {
 515                 case IS_OBJECT:
 516                 case IS_ARRAY:
 517                         break;
 518                 default:
 519                         convert_to_array(ref);
 520                 }
 521                 obj = get_propro(getThis());
 522                 obj->proxy = php_property_proxy_init(container, member);
 523                 if (parent) {
 524                         ZVAL_COPY(&obj->parent, parent);
 525                 }
 526         }
 527         zend_restore_error_handling(&zeh);
 528 }
 529
 530 static const zend_function_entry php_property_proxy_method_entry[] = {
 531         PHP_ME(propro, __construct, ai_propro_construct, ZEND_ACC_PUBLIC)
 532         {0}
 533 };
 534
 535 static PHP_MINIT_FUNCTION(propro)
 536 {
 537         zend_class_entry ce = {0};
 538
 539         INIT_NS_CLASS_ENTRY(ce, "php", "PropertyProxy",
 540                         php_property_proxy_method_entry);
 541         php_property_proxy_class_entry = zend_register_internal_class(&ce);
 542         php_property_proxy_class_entry->create_object = php_property_proxy_object_new;
 543         php_property_proxy_class_entry->ce_flags |= ZEND_ACC_FINAL;
 544
 545         memcpy(&php_property_proxy_object_handlers, zend_get_std_object_handlers(),
 546                         sizeof(zend_object_handlers));
 547         php_property_proxy_object_handlers.offset = XtOffsetOf(php_property_proxy_object_t, zo);
 548         php_property_proxy_object_handlers.free_obj = destroy_obj;
 549         php_property_proxy_object_handlers.set = set_proxied_value;
 550         php_property_proxy_object_handlers.get = get_proxied_value;
 551         php_property_proxy_object_handlers.cast_object = cast_proxied_value;
 552         php_property_proxy_object_handlers.read_dimension = read_dimension;
 553         php_property_proxy_object_handlers.write_dimension = write_dimension;
 554         php_property_proxy_object_handlers.has_dimension = has_dimension;
 555         php_property_proxy_object_handlers.unset_dimension = unset_dimension;
 556
 557         return SUCCESS;
 558 }
 559
 560 PHP_MINFO_FUNCTION(propro)
 561 {
 562         php_info_print_table_start();
 563         php_info_print_table_header(2, "Property proxy support", "enabled");
 564         php_info_print_table_row(2, "Extension version", PHP_PROPRO_VERSION);
 565         php_info_print_table_end();
 566 }
 567
 568 static const zend_function_entry propro_functions[] = {
 569         {0}
 570 };
 571
 572 zend_module_entry propro_module_entry = {
 573         STANDARD_MODULE_HEADER,
 574         "propro",
 575         propro_functions,
 576         PHP_MINIT(propro),
 577         NULL,
 578         NULL,
 579         NULL,
 580         PHP_MINFO(propro),
 581         PHP_PROPRO_VERSION,
 582         STANDARD_MODULE_PROPERTIES
 583 };
 584
 585 #ifdef COMPILE_DL_PROPRO
 586 ZEND_GET_MODULE(propro)
 587 #endif
 588
 589
 590 /*
 591  * Local variables:
 592  * tab-width: 4
 593  * c-basic-offset: 4
 594  * End:
 595  * vim600: noet sw=4 ts=4 fdm=marker
 596  * vim<600: noet sw=4 ts=4
 597  */