Annotation of embedaddon/php/ext/standard/var.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | PHP Version 5 |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1997-2012 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: | Authors: Jani Lehtimäki <jkl@njet.net> |
! 16: | Thies C. Arntzen <thies@thieso.net> |
! 17: | Sascha Schumann <sascha@schumann.cx> |
! 18: +----------------------------------------------------------------------+
! 19: */
! 20:
! 21: /* $Id: var.c 321634 2012-01-01 13:15:04Z felipe $ */
! 22:
! 23: /* {{{ includes
! 24: */
! 25: #include <stdio.h>
! 26: #include <stdlib.h>
! 27: #include <errno.h>
! 28: #include "php.h"
! 29: #include "php_string.h"
! 30: #include "php_var.h"
! 31: #include "php_smart_str.h"
! 32: #include "basic_functions.h"
! 33: #include "php_incomplete_class.h"
! 34:
! 35: #define COMMON (Z_ISREF_PP(struc) ? "&" : "")
! 36: /* }}} */
! 37:
! 38: static int php_array_element_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
! 39: {
! 40: int level;
! 41:
! 42: level = va_arg(args, int);
! 43:
! 44: if (hash_key->nKeyLength == 0) { /* numeric key */
! 45: php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
! 46: } else { /* string key */
! 47: php_printf("%*c[\"", level + 1, ' ');
! 48: PHPWRITE(hash_key->arKey, hash_key->nKeyLength - 1);
! 49: php_printf("\"]=>\n");
! 50: }
! 51: php_var_dump(zv, level + 2 TSRMLS_CC);
! 52: return 0;
! 53: }
! 54: /* }}} */
! 55:
! 56: static int php_object_property_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
! 57: {
! 58: int level;
! 59: char *prop_name, *class_name;
! 60:
! 61: level = va_arg(args, int);
! 62:
! 63: if (hash_key->nKeyLength == 0) { /* numeric key */
! 64: php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
! 65: } else { /* string key */
! 66: int unmangle = zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1, &class_name, &prop_name);
! 67: php_printf("%*c[", level + 1, ' ');
! 68:
! 69: if (class_name && unmangle == SUCCESS) {
! 70: if (class_name[0] == '*') {
! 71: php_printf("\"%s\":protected", prop_name);
! 72: } else {
! 73: php_printf("\"%s\":\"%s\":private", prop_name, class_name);
! 74: }
! 75: } else {
! 76: php_printf("\"");
! 77: PHPWRITE(hash_key->arKey, hash_key->nKeyLength - 1);
! 78: php_printf("\"");
! 79: }
! 80: ZEND_PUTS("]=>\n");
! 81: }
! 82: php_var_dump(zv, level + 2 TSRMLS_CC);
! 83: return 0;
! 84: }
! 85: /* }}} */
! 86:
! 87: PHPAPI void php_var_dump(zval **struc, int level TSRMLS_DC) /* {{{ */
! 88: {
! 89: HashTable *myht;
! 90: char *class_name;
! 91: zend_uint class_name_len;
! 92: int (*php_element_dump_func)(zval** TSRMLS_DC, int, va_list, zend_hash_key*);
! 93: int is_temp;
! 94:
! 95: if (level > 1) {
! 96: php_printf("%*c", level - 1, ' ');
! 97: }
! 98:
! 99: switch (Z_TYPE_PP(struc)) {
! 100: case IS_BOOL:
! 101: php_printf("%sbool(%s)\n", COMMON, Z_LVAL_PP(struc) ? "true" : "false");
! 102: break;
! 103: case IS_NULL:
! 104: php_printf("%sNULL\n", COMMON);
! 105: break;
! 106: case IS_LONG:
! 107: php_printf("%sint(%ld)\n", COMMON, Z_LVAL_PP(struc));
! 108: break;
! 109: case IS_DOUBLE:
! 110: php_printf("%sfloat(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_PP(struc));
! 111: break;
! 112: case IS_STRING:
! 113: php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_PP(struc));
! 114: PHPWRITE(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc));
! 115: PUTS("\"\n");
! 116: break;
! 117: case IS_ARRAY:
! 118: myht = Z_ARRVAL_PP(struc);
! 119: if (++myht->nApplyCount > 1) {
! 120: PUTS("*RECURSION*\n");
! 121: --myht->nApplyCount;
! 122: return;
! 123: }
! 124: php_printf("%sarray(%d) {\n", COMMON, zend_hash_num_elements(myht));
! 125: php_element_dump_func = php_array_element_dump;
! 126: is_temp = 0;
! 127: goto head_done;
! 128: case IS_OBJECT:
! 129: myht = Z_OBJDEBUG_PP(struc, is_temp);
! 130: if (myht && ++myht->nApplyCount > 1) {
! 131: PUTS("*RECURSION*\n");
! 132: --myht->nApplyCount;
! 133: return;
! 134: }
! 135:
! 136: Z_OBJ_HANDLER(**struc, get_class_name)(*struc, &class_name, &class_name_len, 0 TSRMLS_CC);
! 137: php_printf("%sobject(%s)#%d (%d) {\n", COMMON, class_name, Z_OBJ_HANDLE_PP(struc), myht ? zend_hash_num_elements(myht) : 0);
! 138: efree(class_name);
! 139: php_element_dump_func = php_object_property_dump;
! 140: head_done:
! 141: if (myht) {
! 142: zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_element_dump_func, 1, level);
! 143: --myht->nApplyCount;
! 144: if (is_temp) {
! 145: zend_hash_destroy(myht);
! 146: efree(myht);
! 147: }
! 148: }
! 149: if (level > 1) {
! 150: php_printf("%*c", level-1, ' ');
! 151: }
! 152: PUTS("}\n");
! 153: break;
! 154: case IS_RESOURCE: {
! 155: char *type_name;
! 156:
! 157: type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(struc) TSRMLS_CC);
! 158: php_printf("%sresource(%ld) of type (%s)\n", COMMON, Z_LVAL_PP(struc), type_name ? type_name : "Unknown");
! 159: break;
! 160: }
! 161: default:
! 162: php_printf("%sUNKNOWN:0\n", COMMON);
! 163: break;
! 164: }
! 165: }
! 166: /* }}} */
! 167:
! 168: /* {{{ proto void var_dump(mixed var)
! 169: Dumps a string representation of variable to output */
! 170: PHP_FUNCTION(var_dump)
! 171: {
! 172: zval ***args;
! 173: int argc;
! 174: int i;
! 175:
! 176: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) {
! 177: return;
! 178: }
! 179:
! 180: for (i = 0; i < argc; i++) {
! 181: php_var_dump(args[i], 1 TSRMLS_CC);
! 182: }
! 183: efree(args);
! 184: }
! 185: /* }}} */
! 186:
! 187: static int zval_array_element_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
! 188: {
! 189: int level;
! 190:
! 191: level = va_arg(args, int);
! 192:
! 193: if (hash_key->nKeyLength == 0) { /* numeric key */
! 194: php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
! 195: } else { /* string key */
! 196: /* XXX: perphaps when we are inside the class we should permit access to
! 197: * private & protected values
! 198: */
! 199: if (va_arg(args, int) && hash_key->arKey[0] == '\0') {
! 200: return 0;
! 201: }
! 202: php_printf("%*c[\"", level + 1, ' ');
! 203: PHPWRITE(hash_key->arKey, hash_key->nKeyLength - 1);
! 204: php_printf("\"]=>\n");
! 205: }
! 206: php_debug_zval_dump(zv, level + 2 TSRMLS_CC);
! 207: return 0;
! 208: }
! 209: /* }}} */
! 210:
! 211: static int zval_object_property_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
! 212: {
! 213: int level;
! 214: char *prop_name, *class_name;
! 215:
! 216: level = va_arg(args, int);
! 217:
! 218: if (hash_key->nKeyLength == 0) { /* numeric key */
! 219: php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
! 220: } else { /* string key */
! 221: zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1, &class_name, &prop_name);
! 222: php_printf("%*c[", level + 1, ' ');
! 223:
! 224: if (class_name) {
! 225: if (class_name[0] == '*') {
! 226: php_printf("\"%s\":protected", prop_name);
! 227: } else {
! 228: php_printf("\"%s\":\"%s\":private", prop_name, class_name);
! 229: }
! 230: } else {
! 231: php_printf("\"%s\"", prop_name);
! 232: }
! 233: ZEND_PUTS("]=>\n");
! 234: }
! 235: php_debug_zval_dump(zv, level + 2 TSRMLS_CC);
! 236: return 0;
! 237: }
! 238: /* }}} */
! 239:
! 240: PHPAPI void php_debug_zval_dump(zval **struc, int level TSRMLS_DC) /* {{{ */
! 241: {
! 242: HashTable *myht = NULL;
! 243: char *class_name;
! 244: zend_uint class_name_len;
! 245: int (*zval_element_dump_func)(zval** TSRMLS_DC, int, va_list, zend_hash_key*);
! 246: int is_temp = 0;
! 247:
! 248: if (level > 1) {
! 249: php_printf("%*c", level - 1, ' ');
! 250: }
! 251:
! 252: switch (Z_TYPE_PP(struc)) {
! 253: case IS_BOOL:
! 254: php_printf("%sbool(%s) refcount(%u)\n", COMMON, Z_LVAL_PP(struc)?"true":"false", Z_REFCOUNT_PP(struc));
! 255: break;
! 256: case IS_NULL:
! 257: php_printf("%sNULL refcount(%u)\n", COMMON, Z_REFCOUNT_PP(struc));
! 258: break;
! 259: case IS_LONG:
! 260: php_printf("%slong(%ld) refcount(%u)\n", COMMON, Z_LVAL_PP(struc), Z_REFCOUNT_PP(struc));
! 261: break;
! 262: case IS_DOUBLE:
! 263: php_printf("%sdouble(%.*G) refcount(%u)\n", COMMON, (int) EG(precision), Z_DVAL_PP(struc), Z_REFCOUNT_PP(struc));
! 264: break;
! 265: case IS_STRING:
! 266: php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_PP(struc));
! 267: PHPWRITE(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc));
! 268: php_printf("\" refcount(%u)\n", Z_REFCOUNT_PP(struc));
! 269: break;
! 270: case IS_ARRAY:
! 271: myht = Z_ARRVAL_PP(struc);
! 272: if (myht->nApplyCount > 1) {
! 273: PUTS("*RECURSION*\n");
! 274: return;
! 275: }
! 276: php_printf("%sarray(%d) refcount(%u){\n", COMMON, zend_hash_num_elements(myht), Z_REFCOUNT_PP(struc));
! 277: zval_element_dump_func = zval_array_element_dump;
! 278: goto head_done;
! 279: case IS_OBJECT:
! 280: myht = Z_OBJDEBUG_PP(struc, is_temp);
! 281: if (myht && myht->nApplyCount > 1) {
! 282: PUTS("*RECURSION*\n");
! 283: return;
! 284: }
! 285: if (Z_OBJ_HANDLER_PP(struc, get_class_name)) {
! 286: Z_OBJ_HANDLER_PP(struc, get_class_name)(*struc, &class_name, &class_name_len, 0 TSRMLS_CC);
! 287: php_printf("%sobject(%s)#%d (%d) refcount(%u){\n", COMMON, class_name, Z_OBJ_HANDLE_PP(struc), myht ? zend_hash_num_elements(myht) : 0, Z_REFCOUNT_PP(struc));
! 288: efree(class_name);
! 289: } else {
! 290: php_printf("%sobject(unknown class)#%d (%d) refcount(%u){\n", COMMON, Z_OBJ_HANDLE_PP(struc), myht ? zend_hash_num_elements(myht) : 0, Z_REFCOUNT_PP(struc));
! 291: }
! 292: zval_element_dump_func = zval_object_property_dump;
! 293: head_done:
! 294: if (myht) {
! 295: zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) zval_element_dump_func, 1, level, (Z_TYPE_PP(struc) == IS_ARRAY ? 0 : 1));
! 296: if (is_temp) {
! 297: zend_hash_destroy(myht);
! 298: efree(myht);
! 299: }
! 300: }
! 301: if (level > 1) {
! 302: php_printf("%*c", level - 1, ' ');
! 303: }
! 304: PUTS("}\n");
! 305: break;
! 306: case IS_RESOURCE: {
! 307: char *type_name;
! 308:
! 309: type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(struc) TSRMLS_CC);
! 310: php_printf("%sresource(%ld) of type (%s) refcount(%u)\n", COMMON, Z_LVAL_PP(struc), type_name ? type_name : "Unknown", Z_REFCOUNT_PP(struc));
! 311: break;
! 312: }
! 313: default:
! 314: php_printf("%sUNKNOWN:0\n", COMMON);
! 315: break;
! 316: }
! 317: }
! 318: /* }}} */
! 319:
! 320: /* {{{ proto void debug_zval_dump(mixed var)
! 321: Dumps a string representation of an internal zend value to output. */
! 322: PHP_FUNCTION(debug_zval_dump)
! 323: {
! 324: zval ***args;
! 325: int argc;
! 326: int i;
! 327:
! 328: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) {
! 329: return;
! 330: }
! 331:
! 332: for (i = 0; i < argc; i++) {
! 333: php_debug_zval_dump(args[i], 1 TSRMLS_CC);
! 334: }
! 335: efree(args);
! 336: }
! 337: /* }}} */
! 338:
! 339: #define buffer_append_spaces(buf, num_spaces) \
! 340: do { \
! 341: char *tmp_spaces; \
! 342: int tmp_spaces_len; \
! 343: tmp_spaces_len = spprintf(&tmp_spaces, 0,"%*c", num_spaces, ' '); \
! 344: smart_str_appendl(buf, tmp_spaces, tmp_spaces_len); \
! 345: efree(tmp_spaces); \
! 346: } while(0);
! 347:
! 348: static int php_array_element_export(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
! 349: {
! 350: int level;
! 351: smart_str *buf;
! 352:
! 353: level = va_arg(args, int);
! 354: buf = va_arg(args, smart_str *);
! 355:
! 356: if (hash_key->nKeyLength == 0) { /* numeric key */
! 357: buffer_append_spaces(buf, level+1);
! 358: smart_str_append_long(buf, (long) hash_key->h);
! 359: smart_str_appendl(buf, " => ", 4);
! 360: } else { /* string key */
! 361: char *key, *tmp_str;
! 362: int key_len, tmp_len;
! 363: key = php_addcslashes(hash_key->arKey, hash_key->nKeyLength - 1, &key_len, 0, "'\\", 2 TSRMLS_CC);
! 364: tmp_str = php_str_to_str_ex(key, key_len, "\0", 1, "' . \"\\0\" . '", 12, &tmp_len, 0, NULL);
! 365:
! 366: buffer_append_spaces(buf, level + 1);
! 367:
! 368: smart_str_appendc(buf, '\'');
! 369: smart_str_appendl(buf, tmp_str, tmp_len);
! 370: smart_str_appendl(buf, "' => ", 5);
! 371:
! 372: efree(key);
! 373: efree(tmp_str);
! 374: }
! 375: php_var_export_ex(zv, level + 2, buf TSRMLS_CC);
! 376:
! 377: smart_str_appendc(buf, ',');
! 378: smart_str_appendc(buf, '\n');
! 379:
! 380: return 0;
! 381: }
! 382: /* }}} */
! 383:
! 384: static int php_object_element_export(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
! 385: {
! 386: int level;
! 387: smart_str *buf;
! 388:
! 389: level = va_arg(args, int);
! 390: buf = va_arg(args, smart_str *);
! 391:
! 392: buffer_append_spaces(buf, level + 2);
! 393: if (hash_key->nKeyLength != 0) {
! 394: char *class_name, /* ignored, but must be passed to unmangle */
! 395: *pname,
! 396: *pname_esc;
! 397: int pname_esc_len;
! 398:
! 399: zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1,
! 400: &class_name, &pname);
! 401: pname_esc = php_addcslashes(pname, strlen(pname), &pname_esc_len, 0,
! 402: "'\\", 2 TSRMLS_CC);
! 403:
! 404: smart_str_appendc(buf, '\'');
! 405: smart_str_appendl(buf, pname_esc, pname_esc_len);
! 406: smart_str_appendc(buf, '\'');
! 407: efree(pname_esc);
! 408: } else {
! 409: smart_str_append_long(buf, hash_key->h);
! 410: }
! 411:
! 412: smart_str_appendl(buf, " => ", 4);
! 413: php_var_export_ex(zv, level + 2, buf TSRMLS_CC);
! 414: smart_str_appendc(buf, ',');
! 415: smart_str_appendc(buf, '\n');
! 416:
! 417: return 0;
! 418: }
! 419: /* }}} */
! 420:
! 421: PHPAPI void php_var_export_ex(zval **struc, int level, smart_str *buf TSRMLS_DC) /* {{{ */
! 422: {
! 423: HashTable *myht;
! 424: char *tmp_str, *tmp_str2;
! 425: int tmp_len, tmp_len2;
! 426: char *class_name;
! 427: zend_uint class_name_len;
! 428:
! 429: switch (Z_TYPE_PP(struc)) {
! 430: case IS_BOOL:
! 431: if (Z_LVAL_PP(struc)) {
! 432: smart_str_appendl(buf, "true", 4);
! 433: } else {
! 434: smart_str_appendl(buf, "false", 5);
! 435: }
! 436: break;
! 437: case IS_NULL:
! 438: smart_str_appendl(buf, "NULL", 4);
! 439: break;
! 440: case IS_LONG:
! 441: smart_str_append_long(buf, Z_LVAL_PP(struc));
! 442: break;
! 443: case IS_DOUBLE:
! 444: tmp_len = spprintf(&tmp_str, 0,"%.*H", (int) EG(precision), Z_DVAL_PP(struc));
! 445: smart_str_appendl(buf, tmp_str, tmp_len);
! 446: efree(tmp_str);
! 447: break;
! 448: case IS_STRING:
! 449: tmp_str = php_addcslashes(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc), &tmp_len, 0, "'\\", 2 TSRMLS_CC);
! 450: tmp_str2 = php_str_to_str_ex(tmp_str, tmp_len, "\0", 1, "' . \"\\0\" . '", 12, &tmp_len2, 0, NULL);
! 451:
! 452: smart_str_appendc(buf, '\'');
! 453: smart_str_appendl(buf, tmp_str2, tmp_len2);
! 454: smart_str_appendc(buf, '\'');
! 455:
! 456: efree(tmp_str2);
! 457: efree(tmp_str);
! 458: break;
! 459: case IS_ARRAY:
! 460: myht = Z_ARRVAL_PP(struc);
! 461: if (level > 1) {
! 462: smart_str_appendc(buf, '\n');
! 463: buffer_append_spaces(buf, level - 1);
! 464: }
! 465: smart_str_appendl(buf, "array (\n", 8);
! 466: zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_array_element_export, 2, level, buf);
! 467:
! 468: if (level > 1) {
! 469: buffer_append_spaces(buf, level - 1);
! 470: }
! 471: smart_str_appendc(buf, ')');
! 472:
! 473: break;
! 474: case IS_OBJECT:
! 475: myht = Z_OBJPROP_PP(struc);
! 476: if (level > 1) {
! 477: smart_str_appendc(buf, '\n');
! 478: buffer_append_spaces(buf, level - 1);
! 479: }
! 480: Z_OBJ_HANDLER(**struc, get_class_name)(*struc, &class_name, &class_name_len, 0 TSRMLS_CC);
! 481:
! 482: smart_str_appendl(buf, class_name, class_name_len);
! 483: smart_str_appendl(buf, "::__set_state(array(\n", 21);
! 484:
! 485: efree(class_name);
! 486: if (myht) {
! 487: zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_object_element_export, 2, level, buf);
! 488: }
! 489: if (level > 1) {
! 490: buffer_append_spaces(buf, level - 1);
! 491: }
! 492: smart_str_appendl(buf, "))", 2);
! 493:
! 494: break;
! 495: default:
! 496: smart_str_appendl(buf, "NULL", 4);
! 497: break;
! 498: }
! 499: }
! 500: /* }}} */
! 501:
! 502: /* FOR BC reasons, this will always perform and then print */
! 503: PHPAPI void php_var_export(zval **struc, int level TSRMLS_DC) /* {{{ */
! 504: {
! 505: smart_str buf = {0};
! 506: php_var_export_ex(struc, level, &buf TSRMLS_CC);
! 507: smart_str_0 (&buf);
! 508: PHPWRITE(buf.c, buf.len);
! 509: smart_str_free(&buf);
! 510: }
! 511: /* }}} */
! 512:
! 513: /* {{{ proto mixed var_export(mixed var [, bool return])
! 514: Outputs or returns a string representation of a variable */
! 515: PHP_FUNCTION(var_export)
! 516: {
! 517: zval *var;
! 518: zend_bool return_output = 0;
! 519: smart_str buf = {0};
! 520:
! 521: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|b", &var, &return_output) == FAILURE) {
! 522: return;
! 523: }
! 524:
! 525: php_var_export_ex(&var, 1, &buf TSRMLS_CC);
! 526: smart_str_0 (&buf);
! 527:
! 528: if (return_output) {
! 529: RETVAL_STRINGL(buf.c, buf.len, 1);
! 530: } else {
! 531: PHPWRITE(buf.c, buf.len);
! 532: }
! 533: smart_str_free(&buf);
! 534: }
! 535: /* }}} */
! 536:
! 537: static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var_hash TSRMLS_DC);
! 538:
! 539: static inline int php_add_var_hash(HashTable *var_hash, zval *var, void *var_old TSRMLS_DC) /* {{{ */
! 540: {
! 541: ulong var_no;
! 542: char id[32], *p;
! 543: register int len;
! 544:
! 545: /* relies on "(long)" being a perfect hash function for data pointers,
! 546: * however the actual identity of an object has had to be determined
! 547: * by its object handle and the class entry since 5.0. */
! 548: if ((Z_TYPE_P(var) == IS_OBJECT) && Z_OBJ_HT_P(var)->get_class_entry) {
! 549: p = smart_str_print_long(id + sizeof(id) - 1,
! 550: (((size_t)Z_OBJCE_P(var) << 5)
! 551: | ((size_t)Z_OBJCE_P(var) >> (sizeof(long) * 8 - 5)))
! 552: + (long) Z_OBJ_HANDLE_P(var));
! 553: *(--p) = 'O';
! 554: len = id + sizeof(id) - 1 - p;
! 555: } else {
! 556: p = smart_str_print_long(id + sizeof(id) - 1, (long) var);
! 557: len = id + sizeof(id) - 1 - p;
! 558: }
! 559:
! 560: if (var_old && zend_hash_find(var_hash, p, len, var_old) == SUCCESS) {
! 561: if (!Z_ISREF_P(var)) {
! 562: /* we still need to bump up the counter, since non-refs will
! 563: * be counted separately by unserializer */
! 564: var_no = -1;
! 565: zend_hash_next_index_insert(var_hash, &var_no, sizeof(var_no), NULL);
! 566: }
! 567: return FAILURE;
! 568: }
! 569:
! 570: /* +1 because otherwise hash will think we are trying to store NULL pointer */
! 571: var_no = zend_hash_num_elements(var_hash) + 1;
! 572: zend_hash_add(var_hash, p, len, &var_no, sizeof(var_no), NULL);
! 573: return SUCCESS;
! 574: }
! 575: /* }}} */
! 576:
! 577: static inline void php_var_serialize_long(smart_str *buf, long val) /* {{{ */
! 578: {
! 579: smart_str_appendl(buf, "i:", 2);
! 580: smart_str_append_long(buf, val);
! 581: smart_str_appendc(buf, ';');
! 582: }
! 583: /* }}} */
! 584:
! 585: static inline void php_var_serialize_string(smart_str *buf, char *str, int len) /* {{{ */
! 586: {
! 587: smart_str_appendl(buf, "s:", 2);
! 588: smart_str_append_long(buf, len);
! 589: smart_str_appendl(buf, ":\"", 2);
! 590: smart_str_appendl(buf, str, len);
! 591: smart_str_appendl(buf, "\";", 2);
! 592: }
! 593: /* }}} */
! 594:
! 595: static inline zend_bool php_var_serialize_class_name(smart_str *buf, zval *struc TSRMLS_DC) /* {{{ */
! 596: {
! 597: PHP_CLASS_ATTRIBUTES;
! 598:
! 599: PHP_SET_CLASS_ATTRIBUTES(struc);
! 600: smart_str_appendl(buf, "O:", 2);
! 601: smart_str_append_long(buf, (int)name_len);
! 602: smart_str_appendl(buf, ":\"", 2);
! 603: smart_str_appendl(buf, class_name, name_len);
! 604: smart_str_appendl(buf, "\":", 2);
! 605: PHP_CLEANUP_CLASS_ATTRIBUTES();
! 606: return incomplete_class;
! 607: }
! 608: /* }}} */
! 609:
! 610: static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_ptr, HashTable *var_hash TSRMLS_DC) /* {{{ */
! 611: {
! 612: int count;
! 613: zend_bool incomplete_class;
! 614:
! 615: incomplete_class = php_var_serialize_class_name(buf, struc TSRMLS_CC);
! 616: /* count after serializing name, since php_var_serialize_class_name
! 617: * changes the count if the variable is incomplete class */
! 618: count = zend_hash_num_elements(HASH_OF(retval_ptr));
! 619: if (incomplete_class) {
! 620: --count;
! 621: }
! 622: smart_str_append_long(buf, count);
! 623: smart_str_appendl(buf, ":{", 2);
! 624:
! 625: if (count > 0) {
! 626: char *key;
! 627: zval **d, **name;
! 628: ulong index;
! 629: HashPosition pos;
! 630: int i;
! 631: zval nval, *nvalp;
! 632:
! 633: ZVAL_NULL(&nval);
! 634: nvalp = &nval;
! 635:
! 636: zend_hash_internal_pointer_reset_ex(HASH_OF(retval_ptr), &pos);
! 637:
! 638: for (;; zend_hash_move_forward_ex(HASH_OF(retval_ptr), &pos)) {
! 639: i = zend_hash_get_current_key_ex(HASH_OF(retval_ptr), &key, NULL, &index, 0, &pos);
! 640:
! 641: if (i == HASH_KEY_NON_EXISTANT) {
! 642: break;
! 643: }
! 644:
! 645: if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) {
! 646: continue;
! 647: }
! 648: zend_hash_get_current_data_ex(HASH_OF(retval_ptr), (void **) &name, &pos);
! 649:
! 650: if (Z_TYPE_PP(name) != IS_STRING) {
! 651: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "__sleep should return an array only containing the names of instance-variables to serialize.");
! 652: /* we should still add element even if it's not OK,
! 653: * since we already wrote the length of the array before */
! 654: smart_str_appendl(buf,"N;", 2);
! 655: continue;
! 656: }
! 657: if (zend_hash_find(Z_OBJPROP_P(struc), Z_STRVAL_PP(name), Z_STRLEN_PP(name) + 1, (void *) &d) == SUCCESS) {
! 658: php_var_serialize_string(buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
! 659: php_var_serialize_intern(buf, *d, var_hash TSRMLS_CC);
! 660: } else {
! 661: zend_class_entry *ce;
! 662: ce = zend_get_class_entry(struc TSRMLS_CC);
! 663: if (ce) {
! 664: char *prot_name, *priv_name;
! 665: int prop_name_length;
! 666:
! 667: do {
! 668: zend_mangle_property_name(&priv_name, &prop_name_length, ce->name, ce->name_length, Z_STRVAL_PP(name), Z_STRLEN_PP(name), ce->type & ZEND_INTERNAL_CLASS);
! 669: if (zend_hash_find(Z_OBJPROP_P(struc), priv_name, prop_name_length + 1, (void *) &d) == SUCCESS) {
! 670: php_var_serialize_string(buf, priv_name, prop_name_length);
! 671: pefree(priv_name, ce->type & ZEND_INTERNAL_CLASS);
! 672: php_var_serialize_intern(buf, *d, var_hash TSRMLS_CC);
! 673: break;
! 674: }
! 675: pefree(priv_name, ce->type & ZEND_INTERNAL_CLASS);
! 676: zend_mangle_property_name(&prot_name, &prop_name_length, "*", 1, Z_STRVAL_PP(name), Z_STRLEN_PP(name), ce->type & ZEND_INTERNAL_CLASS);
! 677: if (zend_hash_find(Z_OBJPROP_P(struc), prot_name, prop_name_length + 1, (void *) &d) == SUCCESS) {
! 678: php_var_serialize_string(buf, prot_name, prop_name_length);
! 679: pefree(prot_name, ce->type & ZEND_INTERNAL_CLASS);
! 680: php_var_serialize_intern(buf, *d, var_hash TSRMLS_CC);
! 681: break;
! 682: }
! 683: pefree(prot_name, ce->type & ZEND_INTERNAL_CLASS);
! 684: php_var_serialize_string(buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
! 685: php_var_serialize_intern(buf, nvalp, var_hash TSRMLS_CC);
! 686: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "\"%s\" returned as member variable from __sleep() but does not exist", Z_STRVAL_PP(name));
! 687: } while (0);
! 688: } else {
! 689: php_var_serialize_string(buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
! 690: php_var_serialize_intern(buf, nvalp, var_hash TSRMLS_CC);
! 691: }
! 692: }
! 693: }
! 694: }
! 695: smart_str_appendc(buf, '}');
! 696: }
! 697: /* }}} */
! 698:
! 699: static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var_hash TSRMLS_DC) /* {{{ */
! 700: {
! 701: int i;
! 702: ulong *var_already;
! 703: HashTable *myht;
! 704:
! 705: if (var_hash && php_add_var_hash(var_hash, struc, (void *) &var_already TSRMLS_CC) == FAILURE) {
! 706: if (Z_ISREF_P(struc)) {
! 707: smart_str_appendl(buf, "R:", 2);
! 708: smart_str_append_long(buf, (long)*var_already);
! 709: smart_str_appendc(buf, ';');
! 710: return;
! 711: } else if (Z_TYPE_P(struc) == IS_OBJECT) {
! 712: smart_str_appendl(buf, "r:", 2);
! 713: smart_str_append_long(buf, (long)*var_already);
! 714: smart_str_appendc(buf, ';');
! 715: return;
! 716: }
! 717: }
! 718:
! 719: switch (Z_TYPE_P(struc)) {
! 720: case IS_BOOL:
! 721: smart_str_appendl(buf, "b:", 2);
! 722: smart_str_append_long(buf, Z_LVAL_P(struc));
! 723: smart_str_appendc(buf, ';');
! 724: return;
! 725:
! 726: case IS_NULL:
! 727: smart_str_appendl(buf, "N;", 2);
! 728: return;
! 729:
! 730: case IS_LONG:
! 731: php_var_serialize_long(buf, Z_LVAL_P(struc));
! 732: return;
! 733:
! 734: case IS_DOUBLE: {
! 735: char *s;
! 736:
! 737: smart_str_appendl(buf, "d:", 2);
! 738: s = (char *) safe_emalloc(PG(serialize_precision), 1, MAX_LENGTH_OF_DOUBLE + 1);
! 739: php_gcvt(Z_DVAL_P(struc), PG(serialize_precision), '.', 'E', s);
! 740: smart_str_appends(buf, s);
! 741: smart_str_appendc(buf, ';');
! 742: efree(s);
! 743: return;
! 744: }
! 745:
! 746: case IS_STRING:
! 747: php_var_serialize_string(buf, Z_STRVAL_P(struc), Z_STRLEN_P(struc));
! 748: return;
! 749:
! 750: case IS_OBJECT: {
! 751: zval *retval_ptr = NULL;
! 752: zval fname;
! 753: int res;
! 754: zend_class_entry *ce = NULL;
! 755:
! 756: if (Z_OBJ_HT_P(struc)->get_class_entry) {
! 757: ce = Z_OBJCE_P(struc);
! 758: }
! 759:
! 760: if (ce && ce->serialize != NULL) {
! 761: /* has custom handler */
! 762: unsigned char *serialized_data = NULL;
! 763: zend_uint serialized_length;
! 764:
! 765: if (ce->serialize(struc, &serialized_data, &serialized_length, (zend_serialize_data *)var_hash TSRMLS_CC) == SUCCESS) {
! 766: smart_str_appendl(buf, "C:", 2);
! 767: smart_str_append_long(buf, (int)Z_OBJCE_P(struc)->name_length);
! 768: smart_str_appendl(buf, ":\"", 2);
! 769: smart_str_appendl(buf, Z_OBJCE_P(struc)->name, Z_OBJCE_P(struc)->name_length);
! 770: smart_str_appendl(buf, "\":", 2);
! 771:
! 772: smart_str_append_long(buf, (int)serialized_length);
! 773: smart_str_appendl(buf, ":{", 2);
! 774: smart_str_appendl(buf, serialized_data, serialized_length);
! 775: smart_str_appendc(buf, '}');
! 776: } else {
! 777: smart_str_appendl(buf, "N;", 2);
! 778: }
! 779: if (serialized_data) {
! 780: efree(serialized_data);
! 781: }
! 782: return;
! 783: }
! 784:
! 785: if (ce && ce != PHP_IC_ENTRY && zend_hash_exists(&ce->function_table, "__sleep", sizeof("__sleep"))) {
! 786: INIT_PZVAL(&fname);
! 787: ZVAL_STRINGL(&fname, "__sleep", sizeof("__sleep") - 1, 0);
! 788: res = call_user_function_ex(CG(function_table), &struc, &fname, &retval_ptr, 0, 0, 1, NULL TSRMLS_CC);
! 789:
! 790: if (res == SUCCESS && !EG(exception)) {
! 791: if (retval_ptr) {
! 792: if (HASH_OF(retval_ptr)) {
! 793: php_var_serialize_class(buf, struc, retval_ptr, var_hash TSRMLS_CC);
! 794: } else {
! 795: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "__sleep should return an array only containing the names of instance-variables to serialize");
! 796: /* we should still add element even if it's not OK,
! 797: * since we already wrote the length of the array before */
! 798: smart_str_appendl(buf,"N;", 2);
! 799: }
! 800: zval_ptr_dtor(&retval_ptr);
! 801: }
! 802: return;
! 803: }
! 804: }
! 805:
! 806: if (retval_ptr) {
! 807: zval_ptr_dtor(&retval_ptr);
! 808: }
! 809: /* fall-through */
! 810: }
! 811: case IS_ARRAY: {
! 812: zend_bool incomplete_class = 0;
! 813: if (Z_TYPE_P(struc) == IS_ARRAY) {
! 814: smart_str_appendl(buf, "a:", 2);
! 815: myht = HASH_OF(struc);
! 816: } else {
! 817: incomplete_class = php_var_serialize_class_name(buf, struc TSRMLS_CC);
! 818: myht = Z_OBJPROP_P(struc);
! 819: }
! 820: /* count after serializing name, since php_var_serialize_class_name
! 821: * changes the count if the variable is incomplete class */
! 822: i = myht ? zend_hash_num_elements(myht) : 0;
! 823: if (i > 0 && incomplete_class) {
! 824: --i;
! 825: }
! 826: smart_str_append_long(buf, i);
! 827: smart_str_appendl(buf, ":{", 2);
! 828: if (i > 0) {
! 829: char *key;
! 830: zval **data;
! 831: ulong index;
! 832: uint key_len;
! 833: HashPosition pos;
! 834:
! 835: zend_hash_internal_pointer_reset_ex(myht, &pos);
! 836: for (;; zend_hash_move_forward_ex(myht, &pos)) {
! 837: i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos);
! 838: if (i == HASH_KEY_NON_EXISTANT) {
! 839: break;
! 840: }
! 841: if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) {
! 842: continue;
! 843: }
! 844:
! 845: switch (i) {
! 846: case HASH_KEY_IS_LONG:
! 847: php_var_serialize_long(buf, index);
! 848: break;
! 849: case HASH_KEY_IS_STRING:
! 850: php_var_serialize_string(buf, key, key_len - 1);
! 851: break;
! 852: }
! 853:
! 854: /* we should still add element even if it's not OK,
! 855: * since we already wrote the length of the array before */
! 856: if (zend_hash_get_current_data_ex(myht, (void **) &data, &pos) != SUCCESS
! 857: || !data
! 858: || data == &struc
! 859: || (Z_TYPE_PP(data) == IS_ARRAY && Z_ARRVAL_PP(data)->nApplyCount > 1)
! 860: ) {
! 861: smart_str_appendl(buf, "N;", 2);
! 862: } else {
! 863: if (Z_TYPE_PP(data) == IS_ARRAY) {
! 864: Z_ARRVAL_PP(data)->nApplyCount++;
! 865: }
! 866: php_var_serialize_intern(buf, *data, var_hash TSRMLS_CC);
! 867: if (Z_TYPE_PP(data) == IS_ARRAY) {
! 868: Z_ARRVAL_PP(data)->nApplyCount--;
! 869: }
! 870: }
! 871: }
! 872: }
! 873: smart_str_appendc(buf, '}');
! 874: return;
! 875: }
! 876: default:
! 877: smart_str_appendl(buf, "i:0;", 4);
! 878: return;
! 879: }
! 880: }
! 881: /* }}} */
! 882:
! 883: PHPAPI void php_var_serialize(smart_str *buf, zval **struc, HashTable *var_hash TSRMLS_DC) /* {{{ */
! 884: {
! 885: php_var_serialize_intern(buf, *struc, var_hash TSRMLS_CC);
! 886: smart_str_0(buf);
! 887: }
! 888: /* }}} */
! 889:
! 890: /* {{{ proto string serialize(mixed variable)
! 891: Returns a string representation of variable (which can later be unserialized) */
! 892: PHP_FUNCTION(serialize)
! 893: {
! 894: zval **struc;
! 895: php_serialize_data_t var_hash;
! 896: smart_str buf = {0};
! 897:
! 898: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &struc) == FAILURE) {
! 899: return;
! 900: }
! 901:
! 902: Z_TYPE_P(return_value) = IS_STRING;
! 903: Z_STRVAL_P(return_value) = NULL;
! 904: Z_STRLEN_P(return_value) = 0;
! 905:
! 906: PHP_VAR_SERIALIZE_INIT(var_hash);
! 907: php_var_serialize(&buf, struc, &var_hash TSRMLS_CC);
! 908: PHP_VAR_SERIALIZE_DESTROY(var_hash);
! 909:
! 910: if (buf.c) {
! 911: RETURN_STRINGL(buf.c, buf.len, 0);
! 912: } else {
! 913: RETURN_NULL();
! 914: }
! 915: }
! 916: /* }}} */
! 917:
! 918: /* {{{ proto mixed unserialize(string variable_representation)
! 919: Takes a string representation of variable and recreates it */
! 920: PHP_FUNCTION(unserialize)
! 921: {
! 922: char *buf = NULL;
! 923: int buf_len;
! 924: const unsigned char *p;
! 925: php_unserialize_data_t var_hash;
! 926:
! 927: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &buf, &buf_len) == FAILURE) {
! 928: RETURN_FALSE;
! 929: }
! 930:
! 931: if (buf_len == 0) {
! 932: RETURN_FALSE;
! 933: }
! 934:
! 935: p = (const unsigned char*) buf;
! 936: PHP_VAR_UNSERIALIZE_INIT(var_hash);
! 937: if (!php_var_unserialize(&return_value, &p, p + buf_len, &var_hash TSRMLS_CC)) {
! 938: PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
! 939: zval_dtor(return_value);
! 940: php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Error at offset %ld of %d bytes", (long)((char*)p - buf), buf_len);
! 941: RETURN_FALSE;
! 942: }
! 943: PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
! 944: }
! 945: /* }}} */
! 946:
! 947: /* {{{ proto int memory_get_usage([real_usage])
! 948: Returns the allocated by PHP memory */
! 949: PHP_FUNCTION(memory_get_usage) {
! 950: zend_bool real_usage = 0;
! 951:
! 952: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &real_usage) == FAILURE) {
! 953: RETURN_FALSE;
! 954: }
! 955:
! 956: RETURN_LONG(zend_memory_usage(real_usage TSRMLS_CC));
! 957: }
! 958: /* }}} */
! 959:
! 960: /* {{{ proto int memory_get_peak_usage([real_usage])
! 961: Returns the peak allocated by PHP memory */
! 962: PHP_FUNCTION(memory_get_peak_usage) {
! 963: zend_bool real_usage = 0;
! 964:
! 965: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &real_usage) == FAILURE) {
! 966: RETURN_FALSE;
! 967: }
! 968:
! 969: RETURN_LONG(zend_memory_peak_usage(real_usage TSRMLS_CC));
! 970: }
! 971: /* }}} */
! 972:
! 973: /*
! 974: * Local variables:
! 975: * tab-width: 4
! 976: * c-basic-offset: 4
! 977: * End:
! 978: * vim600: sw=4 ts=4 fdm=marker
! 979: * vim<600: sw=4 ts=4
! 980: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to var.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / standard