PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/standard - var.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 455 492 92.5 %
Date: 2016-08-24 Functions: 23 25 92.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 7                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2016 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$ */
      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 "zend_smart_str.h"
      32             : #include "basic_functions.h"
      33             : #include "php_incomplete_class.h"
      34             : /* }}} */
      35             : 
      36             : #define COMMON (is_ref ? "&" : "")
      37             : 
      38       65540 : static void php_array_element_dump(zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
      39             : {
      40       65540 :         if (key == NULL) { /* numeric key */
      41       46033 :                 php_printf("%*c[" ZEND_LONG_FMT "]=>\n", level + 1, ' ', index);
      42             :         } else { /* string key */
      43       19507 :                 php_printf("%*c[\"", level + 1, ' ');
      44       19507 :                 PHPWRITE(ZSTR_VAL(key), ZSTR_LEN(key));
      45       19507 :                 php_printf("\"]=>\n");
      46             :         }
      47       65540 :         php_var_dump(zv, level + 2);
      48       65540 : }
      49             : /* }}} */
      50             : 
      51        7290 : static void php_object_property_dump(zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
      52             : {
      53             :         const char *prop_name, *class_name;
      54             : 
      55        7290 :         if (key == NULL) { /* numeric key */
      56         112 :                 php_printf("%*c[" ZEND_LONG_FMT "]=>\n", level + 1, ' ', index);
      57             :         } else { /* string key */
      58        7178 :                 int unmangle = zend_unmangle_property_name(key, &class_name, &prop_name);
      59        7178 :                 php_printf("%*c[", level + 1, ' ');
      60             : 
      61        8242 :                 if (class_name && unmangle == SUCCESS) {
      62        1064 :                         if (class_name[0] == '*') {
      63         333 :                                 php_printf("\"%s\":protected", prop_name);
      64             :                         } else {
      65         731 :                                 php_printf("\"%s\":\"%s\":private", prop_name, class_name);
      66             :                         }
      67             :                 } else {
      68        6114 :                         php_printf("\"");
      69        6114 :                         PHPWRITE(ZSTR_VAL(key), ZSTR_LEN(key));
      70        6114 :                         php_printf("\"");
      71             :                 }
      72        7178 :                 ZEND_PUTS("]=>\n");
      73             :         }
      74        7290 :         php_var_dump(zv, level + 2);
      75        7290 : }
      76             : /* }}} */
      77             : 
      78      228288 : PHPAPI void php_var_dump(zval *struc, int level) /* {{{ */
      79             : {
      80             :         HashTable *myht;
      81             :         zend_string *class_name;
      82             :         int is_temp;
      83      228288 :         int is_ref = 0;
      84             :         zend_ulong num;
      85             :         zend_string *key;
      86             :         zval *val;
      87             :         uint32_t count;
      88             : 
      89      228288 :         if (level > 1) {
      90       72830 :                 php_printf("%*c", level - 1, ' ');
      91             :         }
      92             : 
      93             : again:
      94      229389 :         switch (Z_TYPE_P(struc)) {
      95             :                 case IS_FALSE:
      96       30768 :                         php_printf("%sbool(false)\n", COMMON);
      97       30768 :                         break;
      98             :                 case IS_TRUE:
      99       15271 :                         php_printf("%sbool(true)\n", COMMON);
     100       15271 :                         break;
     101             :                 case IS_NULL:
     102       14051 :                         php_printf("%sNULL\n", COMMON);
     103       14051 :                         break;
     104             :                 case IS_LONG:
     105       66378 :                         php_printf("%sint(" ZEND_LONG_FMT ")\n", COMMON, Z_LVAL_P(struc));
     106       66377 :                         break;
     107             :                 case IS_DOUBLE:
     108        6320 :                         php_printf("%sfloat(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_P(struc));
     109        6320 :                         break;
     110             :                 case IS_STRING:
     111       68416 :                         php_printf("%sstring(%zd) \"", COMMON, Z_STRLEN_P(struc));
     112       68416 :                         PHPWRITE(Z_STRVAL_P(struc), Z_STRLEN_P(struc));
     113       68416 :                         PUTS("\"\n");
     114       68416 :                         break;
     115             :                 case IS_ARRAY:
     116       22092 :                         myht = Z_ARRVAL_P(struc);
     117       22092 :                         if (level > 1 && ZEND_HASH_APPLY_PROTECTION(myht) && ++myht->u.v.nApplyCount > 1) {
     118          64 :                                 PUTS("*RECURSION*\n");
     119          64 :                                 --myht->u.v.nApplyCount;
     120          64 :                                 return;
     121             :                         }
     122       22028 :                         count = zend_array_count(myht);
     123       22028 :                         php_printf("%sarray(%d) {\n", COMMON, count);
     124       22028 :                         is_temp = 0;
     125             : 
     126      224933 :                         ZEND_HASH_FOREACH_KEY_VAL_IND(myht, num, key, val) {
     127       65540 :                                 php_array_element_dump(val, num, key, level);
     128             :                         } ZEND_HASH_FOREACH_END();
     129       22028 :                         if (level > 1 && ZEND_HASH_APPLY_PROTECTION(myht)) {
     130        5084 :                                 --myht->u.v.nApplyCount;
     131             :                         }
     132       22028 :                         if (is_temp) {
     133           0 :                                 zend_hash_destroy(myht);
     134           0 :                                 efree(myht);
     135             :                         }
     136       22028 :                         if (level > 1) {
     137        5084 :                                 php_printf("%*c", level-1, ' ');
     138             :                         }
     139       22028 :                         PUTS("}\n");
     140       22028 :                         break;
     141             :                 case IS_OBJECT:
     142        4044 :                         if (Z_OBJ_APPLY_COUNT_P(struc) > 0) {
     143          62 :                                 PUTS("*RECURSION*\n");
     144          62 :                                 return;
     145             :                         }
     146        3982 :                         Z_OBJ_INC_APPLY_COUNT_P(struc);
     147             : 
     148        3982 :                         myht = Z_OBJDEBUG_P(struc, is_temp);
     149        3972 :                         class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(Z_OBJ_P(struc));
     150        3972 :                         php_printf("%sobject(%s)#%d (%d) {\n", COMMON, ZSTR_VAL(class_name), Z_OBJ_HANDLE_P(struc), myht ? zend_array_count(myht) : 0);
     151             :                         zend_string_release(class_name);
     152             : 
     153        3972 :                         if (myht) {
     154             :                                 zend_ulong num;
     155             :                                 zend_string *key;
     156             :                                 zval *val;
     157             : 
     158       25968 :                                 ZEND_HASH_FOREACH_KEY_VAL_IND(myht, num, key, val) {
     159        7290 :                                         php_object_property_dump(val, num, key, level);
     160             :                                 } ZEND_HASH_FOREACH_END();
     161        3972 :                                 if (is_temp) {
     162         590 :                                         zend_hash_destroy(myht);
     163         590 :                                         efree(myht);
     164             :                                 }
     165             :                         }
     166        3972 :                         if (level > 1) {
     167        1395 :                                 php_printf("%*c", level-1, ' ');
     168             :                         }
     169        3972 :                         PUTS("}\n");
     170        3972 :                         Z_OBJ_DEC_APPLY_COUNT_P(struc);
     171        3972 :                         break;
     172             :                 case IS_RESOURCE: {
     173         948 :                         const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(struc));
     174         948 :                         php_printf("%sresource(%d) of type (%s)\n", COMMON, Z_RES_P(struc)->handle, type_name ? type_name : "Unknown");
     175         948 :                         break;
     176             :                 }
     177             :                 case IS_REFERENCE:
     178             :                         //??? hide references with refcount==1 (for compatibility)
     179        1101 :                         if (Z_REFCOUNT_P(struc) > 1) {
     180         823 :                                 is_ref = 1;
     181             :                         }
     182        1101 :                         struc = Z_REFVAL_P(struc);
     183        1101 :                         goto again;
     184             :                         break;
     185             :                 default:
     186           0 :                         php_printf("%sUNKNOWN:0\n", COMMON);
     187             :                         break;
     188             :         }
     189             : }
     190             : /* }}} */
     191             : 
     192             : /* {{{ proto void var_dump(mixed var)
     193             :    Dumps a string representation of variable to output */
     194      153432 : PHP_FUNCTION(var_dump)
     195             : {
     196             :         zval *args;
     197             :         int argc;
     198             :         int     i;
     199             : 
     200      153432 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "+", &args, &argc) == FAILURE) {
     201           1 :                 return;
     202             :         }
     203             : 
     204      308878 :         for (i = 0; i < argc; i++) {
     205      155458 :                 php_var_dump(&args[i], 1);
     206             :         }
     207             : }
     208             : /* }}} */
     209             : 
     210         169 : static void zval_array_element_dump(zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
     211             : {
     212         169 :         if (key == NULL) { /* numeric key */
     213          59 :                 php_printf("%*c[" ZEND_LONG_FMT "]=>\n", level + 1, ' ', index);
     214             :         } else { /* string key */
     215         110 :                 php_printf("%*c[\"", level + 1, ' ');
     216         110 :                 PHPWRITE(ZSTR_VAL(key), ZSTR_LEN(key));
     217         110 :                 php_printf("\"]=>\n");
     218             :         }
     219         169 :         php_debug_zval_dump(zv, level + 2);
     220         169 : }
     221             : /* }}} */
     222             : 
     223         242 : static void zval_object_property_dump(zval *zv, zend_ulong index, zend_string *key, int level) /* {{{ */
     224             : {
     225             :         const char *prop_name, *class_name;
     226             : 
     227         242 :         if (key == NULL) { /* numeric key */
     228           0 :                 php_printf("%*c[" ZEND_LONG_FMT "]=>\n", level + 1, ' ', index);
     229             :         } else { /* string key */
     230         242 :                 zend_unmangle_property_name(key, &class_name, &prop_name);
     231         242 :                 php_printf("%*c[", level + 1, ' ');
     232             : 
     233         242 :                 if (class_name) {
     234          78 :                         if (class_name[0] == '*') {
     235          39 :                                 php_printf("\"%s\":protected", prop_name);
     236             :                         } else {
     237          39 :                                 php_printf("\"%s\":\"%s\":private", prop_name, class_name);
     238             :                         }
     239             :                 } else {
     240         164 :                         php_printf("\"%s\"", prop_name);
     241             :                 }
     242         242 :                 ZEND_PUTS("]=>\n");
     243             :         }
     244         242 :         php_debug_zval_dump(zv, level + 2);
     245         242 : }
     246             : /* }}} */
     247             : 
     248         670 : PHPAPI void php_debug_zval_dump(zval *struc, int level) /* {{{ */
     249             : {
     250         670 :         HashTable *myht = NULL;
     251             :         zend_string *class_name;
     252         670 :         int is_temp = 0;
     253         670 :         int is_ref = 0;
     254             :         zend_ulong index;
     255             :         zend_string *key;
     256             :         zval *val;
     257             :         uint32_t count;
     258             : 
     259         670 :         if (level > 1) {
     260         411 :                 php_printf("%*c", level - 1, ' ');
     261             :         }
     262             : 
     263             : again:
     264         696 :         switch (Z_TYPE_P(struc)) {
     265             :         case IS_FALSE:
     266           4 :                 php_printf("%sbool(false)\n", COMMON);
     267           4 :                 break;
     268             :         case IS_TRUE:
     269           3 :                 php_printf("%sbool(true)\n", COMMON);
     270           3 :                 break;
     271             :         case IS_NULL:
     272          22 :                 php_printf("%sNULL\n", COMMON);
     273          22 :                 break;
     274             :         case IS_LONG:
     275         374 :                 php_printf("%sint(" ZEND_LONG_FMT ")\n", COMMON, Z_LVAL_P(struc));
     276         374 :                 break;
     277             :         case IS_DOUBLE:
     278          19 :                 php_printf("%sfloat(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_P(struc));
     279          19 :                 break;
     280             :         case IS_STRING:
     281          82 :                 php_printf("%sstring(%zd) \"", COMMON, Z_STRLEN_P(struc));
     282          82 :                 PHPWRITE(Z_STRVAL_P(struc), Z_STRLEN_P(struc));
     283         126 :                 php_printf("\" refcount(%u)\n", Z_REFCOUNTED_P(struc) ? Z_REFCOUNT_P(struc) : 1);
     284          82 :                 break;
     285             :         case IS_ARRAY:
     286          96 :                 myht = Z_ARRVAL_P(struc);
     287          96 :                 if (level > 1 && ZEND_HASH_APPLY_PROTECTION(myht) && myht->u.v.nApplyCount++ > 1) {
     288           2 :                         myht->u.v.nApplyCount--;
     289           2 :                         PUTS("*RECURSION*\n");
     290           2 :                         return;
     291             :                 }
     292          94 :                 count = zend_array_count(myht);
     293         188 :                 php_printf("%sarray(%d) refcount(%u){\n", COMMON, count, Z_REFCOUNTED_P(struc) ? Z_REFCOUNT_P(struc) : 1);
     294         607 :                 ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
     295         169 :                         zval_array_element_dump(val, index, key, level);
     296             :                 } ZEND_HASH_FOREACH_END();
     297          94 :                 if (level > 1 && ZEND_HASH_APPLY_PROTECTION(myht)) {
     298          59 :                         myht->u.v.nApplyCount--;
     299             :                 }
     300          94 :                 if (is_temp) {
     301           0 :                         zend_hash_destroy(myht);
     302           0 :                         efree(myht);
     303             :                 }
     304          94 :                 if (level > 1) {
     305          59 :                         php_printf("%*c", level - 1, ' ');
     306             :                 }
     307          94 :                 PUTS("}\n");
     308          94 :                 break;
     309             :         case IS_OBJECT:
     310          69 :                 myht = Z_OBJDEBUG_P(struc, is_temp);
     311          69 :                 if (myht) {
     312          69 :                         if (myht->u.v.nApplyCount > 1) {
     313          24 :                                 PUTS("*RECURSION*\n");
     314          24 :                                 return;
     315             :                         } else {
     316          45 :                                 myht->u.v.nApplyCount++;
     317             :                         }
     318             :                 }
     319          45 :                 class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(Z_OBJ_P(struc));
     320          45 :                 php_printf("%sobject(%s)#%d (%d) refcount(%u){\n", COMMON, ZSTR_VAL(class_name), Z_OBJ_HANDLE_P(struc), myht ? zend_array_count(myht) : 0, Z_REFCOUNT_P(struc));
     321             :                 zend_string_release(class_name);
     322          45 :                 if (myht) {
     323         771 :                         ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
     324         242 :                                 zval_object_property_dump(val, index, key, level);
     325             :                         } ZEND_HASH_FOREACH_END();
     326          45 :                         myht->u.v.nApplyCount--;
     327          45 :                         if (is_temp) {
     328           1 :                                 zend_hash_destroy(myht);
     329           1 :                                 efree(myht);
     330             :                         }
     331             :                 }
     332          45 :                 if (level > 1) {
     333          34 :                         php_printf("%*c", level - 1, ' ');
     334             :                 }
     335          45 :                 PUTS("}\n");
     336          45 :                 break;
     337             :         case IS_RESOURCE: {
     338           1 :                 const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(struc));
     339           1 :                 php_printf("%sresource(%d) of type (%s) refcount(%u)\n", COMMON, Z_RES_P(struc)->handle, type_name ? type_name : "Unknown", Z_REFCOUNT_P(struc));
     340           1 :                 break;
     341             :         }
     342             :         case IS_REFERENCE:
     343             :                 //??? hide references with refcount==1 (for compatibility)
     344          26 :                 if (Z_REFCOUNT_P(struc) > 1) {
     345          20 :                         is_ref = 1;
     346             :                 }
     347          26 :                 struc = Z_REFVAL_P(struc);
     348          26 :                 goto again;
     349             :         default:
     350           0 :                 php_printf("%sUNKNOWN:0\n", COMMON);
     351             :                 break;
     352             :         }
     353             : }
     354             : /* }}} */
     355             : 
     356             : /* {{{ proto void debug_zval_dump(mixed var)
     357             :    Dumps a string representation of an internal zend value to output. */
     358         165 : PHP_FUNCTION(debug_zval_dump)
     359             : {
     360             :         zval *args;
     361             :         int argc;
     362             :         int     i;
     363             : 
     364         165 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "+", &args, &argc) == FAILURE) {
     365           1 :                 return;
     366             :         }
     367             : 
     368         423 :         for (i = 0; i < argc; i++) {
     369         259 :                 php_debug_zval_dump(&args[i], 1);
     370             :         }
     371             : }
     372             : /* }}} */
     373             : 
     374             : #define buffer_append_spaces(buf, num_spaces) \
     375             :         do { \
     376             :                 char *tmp_spaces; \
     377             :                 size_t tmp_spaces_len; \
     378             :                 tmp_spaces_len = spprintf(&tmp_spaces, 0,"%*c", num_spaces, ' '); \
     379             :                 smart_str_appendl(buf, tmp_spaces, tmp_spaces_len); \
     380             :                 efree(tmp_spaces); \
     381             :         } while(0);
     382             : 
     383        1182 : static void php_array_element_export(zval *zv, zend_ulong index, zend_string *key, int level, smart_str *buf) /* {{{ */
     384             : {
     385        1182 :         if (key == NULL) { /* numeric key */
     386        2106 :                 buffer_append_spaces(buf, level+1);
     387        1053 :                 smart_str_append_long(buf, (zend_long) index);
     388             :                 smart_str_appendl(buf, " => ", 4);
     389             : 
     390             :         } else { /* string key */
     391             :                 zend_string *tmp_str;
     392         129 :                 zend_string *ckey = php_addcslashes(key, 0, "'\\", 2);
     393         129 :                 tmp_str = php_str_to_str(ZSTR_VAL(ckey), ZSTR_LEN(ckey), "\0", 1, "' . \"\\0\" . '", 12);
     394             : 
     395         258 :                 buffer_append_spaces(buf, level + 1);
     396             : 
     397             :                 smart_str_appendc(buf, '\'');
     398             :                 smart_str_append(buf, tmp_str);
     399             :                 smart_str_appendl(buf, "' => ", 5);
     400             : 
     401             :                 zend_string_free(ckey);
     402             :                 zend_string_free(tmp_str);
     403             :         }
     404        1182 :         php_var_export_ex(zv, level + 2, buf);
     405             : 
     406             :         smart_str_appendc(buf, ',');
     407             :         smart_str_appendc(buf, '\n');
     408        1182 : }
     409             : /* }}} */
     410             : 
     411         395 : static void php_object_element_export(zval *zv, zend_ulong index, zend_string *key, int level, smart_str *buf) /* {{{ */
     412             : {
     413         790 :         buffer_append_spaces(buf, level + 2);
     414         395 :         if (key != NULL) {
     415             :                 const char *class_name, *prop_name;
     416             :                 size_t prop_name_len;
     417             :                 zend_string *pname_esc;
     418             : 
     419         392 :                 zend_unmangle_property_name_ex(key, &class_name, &prop_name, &prop_name_len);
     420         784 :                 pname_esc = php_addcslashes(zend_string_init(prop_name, prop_name_len, 0), 1, "'\\", 2);
     421             : 
     422             :                 smart_str_appendc(buf, '\'');
     423             :                 smart_str_append(buf, pname_esc);
     424             :                 smart_str_appendc(buf, '\'');
     425             :                 zend_string_release(pname_esc);
     426             :         } else {
     427           3 :                 smart_str_append_long(buf, (zend_long) index);
     428             :         }
     429             :         smart_str_appendl(buf, " => ", 4);
     430         395 :         php_var_export_ex(zv, level + 2, buf);
     431             :         smart_str_appendc(buf, ',');
     432             :         smart_str_appendc(buf, '\n');
     433         395 : }
     434             : /* }}} */
     435             : 
     436        3266 : PHPAPI void php_var_export_ex(zval *struc, int level, smart_str *buf) /* {{{ */
     437             : {
     438             :         HashTable *myht;
     439             :         char tmp_str[PHP_DOUBLE_MAX_LENGTH];
     440             :         zend_string *ztmp, *ztmp2;
     441             :         zend_ulong index;
     442             :         zend_string *key;
     443             :         zval *val;
     444             : 
     445             : again:
     446        3266 :         switch (Z_TYPE_P(struc)) {
     447             :                 case IS_FALSE:
     448             :                         smart_str_appendl(buf, "false", 5);
     449          39 :                         break;
     450             :                 case IS_TRUE:
     451             :                         smart_str_appendl(buf, "true", 4);
     452         114 :                         break;
     453             :                 case IS_NULL:
     454             :                         smart_str_appendl(buf, "NULL", 4);
     455         179 :                         break;
     456             :                 case IS_LONG:
     457         653 :                         smart_str_append_long(buf, Z_LVAL_P(struc));
     458         653 :                         break;
     459             :                 case IS_DOUBLE:
     460         206 :                         php_gcvt(Z_DVAL_P(struc), (int)PG(serialize_precision), '.', 'E', tmp_str);
     461         206 :                         smart_str_appends(buf, tmp_str);
     462             :                         /* Without a decimal point, PHP treats a number literal as an int.
     463             :                          * This check even works for scientific notation, because the
     464             :                          * mantissa always contains a decimal point.
     465             :                          * We need to check for finiteness, because INF, -INF and NAN
     466             :                          * must not have a decimal point added.
     467             :                          */
     468         206 :                         if (zend_finite(Z_DVAL_P(struc)) && NULL == strchr(tmp_str, '.')) {
     469             :                                 smart_str_appendl(buf, ".0", 2);
     470             :                         }
     471         206 :                         break;
     472             :                 case IS_STRING:
     473        1315 :                         ztmp = php_addcslashes(Z_STR_P(struc), 0, "'\\", 2);
     474        1315 :                         ztmp2 = php_str_to_str(ZSTR_VAL(ztmp), ZSTR_LEN(ztmp), "\0", 1, "' . \"\\0\" . '", 12);
     475             : 
     476             :                         smart_str_appendc(buf, '\'');
     477             :                         smart_str_append(buf, ztmp2);
     478             :                         smart_str_appendc(buf, '\'');
     479             : 
     480             :                         zend_string_free(ztmp);
     481             :                         zend_string_free(ztmp2);
     482        1315 :                         break;
     483             :                 case IS_ARRAY:
     484         451 :                         myht = Z_ARRVAL_P(struc);
     485         451 :                         if (ZEND_HASH_APPLY_PROTECTION(myht) && myht->u.v.nApplyCount++ > 0) {
     486           1 :                                 myht->u.v.nApplyCount--;
     487             :                                 smart_str_appendl(buf, "NULL", 4);
     488           1 :                                 zend_error(E_WARNING, "var_export does not handle circular references");
     489           1 :                                 return;
     490             :                         }
     491         450 :                         if (level > 1) {
     492             :                                 smart_str_appendc(buf, '\n');
     493          80 :                                 buffer_append_spaces(buf, level - 1);
     494             :                         }
     495             :                         smart_str_appendl(buf, "array (\n", 8);
     496        4017 :                         ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
     497        1182 :                                 php_array_element_export(val, index, key, level, buf);
     498             :                         } ZEND_HASH_FOREACH_END();
     499         450 :                         if (ZEND_HASH_APPLY_PROTECTION(myht)) {
     500         450 :                                 myht->u.v.nApplyCount--;
     501             :                         }
     502         450 :                         if (level > 1) {
     503          80 :                                 buffer_append_spaces(buf, level - 1);
     504             :                         }
     505             :                         smart_str_appendc(buf, ')');
     506             : 
     507         450 :                         break;
     508             : 
     509             :                 case IS_OBJECT:
     510         247 :                         myht = Z_OBJPROP_P(struc);
     511         247 :                         if (myht) {
     512         247 :                                 if (myht->u.v.nApplyCount > 0) {
     513             :                                         smart_str_appendl(buf, "NULL", 4);
     514           1 :                                         zend_error(E_WARNING, "var_export does not handle circular references");
     515           1 :                                         return;
     516             :                                 } else {
     517         246 :                                         myht->u.v.nApplyCount++;
     518             :                                 }
     519             :                         }
     520         246 :                         if (level > 1) {
     521             :                                 smart_str_appendc(buf, '\n');
     522         284 :                                 buffer_append_spaces(buf, level - 1);
     523             :                         }
     524             : 
     525         246 :                         smart_str_append(buf, Z_OBJCE_P(struc)->name);
     526             :                         smart_str_appendl(buf, "::__set_state(array(\n", 21);
     527             : 
     528         246 :                         if (myht) {
     529        1431 :                                 ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
     530         395 :                                         php_object_element_export(val, index, key, level, buf);
     531             :                                 } ZEND_HASH_FOREACH_END();
     532         246 :                                 myht->u.v.nApplyCount--;
     533             :                         }
     534         246 :                         if (level > 1) {
     535         284 :                                 buffer_append_spaces(buf, level - 1);
     536             :                         }
     537             :                         smart_str_appendl(buf, "))", 2);
     538             : 
     539         246 :                         break;
     540             :                 case IS_REFERENCE:
     541          62 :                         struc = Z_REFVAL_P(struc);
     542          62 :                         goto again;
     543             :                         break;
     544             :                 default:
     545             :                         smart_str_appendl(buf, "NULL", 4);
     546             :                         break;
     547             :         }
     548             : }
     549             : /* }}} */
     550             : 
     551             : /* FOR BC reasons, this will always perform and then print */
     552           0 : PHPAPI void php_var_export(zval *struc, int level) /* {{{ */
     553             : {
     554           0 :         smart_str buf = {0};
     555           0 :         php_var_export_ex(struc, level, &buf);
     556             :         smart_str_0(&buf);
     557           0 :         PHPWRITE(ZSTR_VAL(buf.s), ZSTR_LEN(buf.s));
     558             :         smart_str_free(&buf);
     559           0 : }
     560             : /* }}} */
     561             : 
     562             : /* {{{ proto mixed var_export(mixed var [, bool return])
     563             :    Outputs or returns a string representation of a variable */
     564        1631 : PHP_FUNCTION(var_export)
     565             : {
     566             :         zval *var;
     567        1631 :         zend_bool return_output = 0;
     568        1631 :         smart_str buf = {0};
     569             : 
     570        1631 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|b", &var, &return_output) == FAILURE) {
     571           4 :                 return;
     572             :         }
     573             : 
     574        1627 :         php_var_export_ex(var, 1, &buf);
     575             :         smart_str_0 (&buf);
     576             : 
     577        1627 :         if (return_output) {
     578        1219 :                 RETURN_NEW_STR(buf.s);
     579             :         } else {
     580         408 :                 PHPWRITE(ZSTR_VAL(buf.s), ZSTR_LEN(buf.s));
     581             :                 smart_str_free(&buf);
     582             :         }
     583             : }
     584             : /* }}} */
     585             : 
     586             : static void php_var_serialize_intern(smart_str *buf, zval *struc, php_serialize_data_t var_hash);
     587             : 
     588      261287 : static inline zend_long php_add_var_hash(php_serialize_data_t data, zval *var) /* {{{ */
     589             : {
     590             :         zval *zv;
     591             :         zend_ulong key;
     592      261287 :         zend_bool is_ref = Z_ISREF_P(var);
     593             : 
     594      261287 :         data->n += 1;
     595             : 
     596      522063 :         if (!is_ref && Z_TYPE_P(var) != IS_OBJECT) {
     597      107880 :                 return 0;
     598             :         }
     599             : 
     600             :         /* References to objects are treated as if the reference didn't exist */
     601      153918 :         if (is_ref && Z_TYPE_P(Z_REFVAL_P(var)) == IS_OBJECT) {
     602          16 :                 var = Z_REFVAL_P(var);
     603             :         }
     604             : 
     605             :         /* Index for the variable is stored using the numeric value of the pointer to
     606             :          * the zend_refcounted struct */
     607      153407 :         key = (zend_ulong) (zend_uintptr_t) Z_COUNTED_P(var);
     608      153407 :         zv = zend_hash_index_find(&data->ht, key);
     609             : 
     610      153407 :         if (zv) {
     611             :                 /* References are only counted once, undo the data->n increment above */
     612       10345 :                 if (is_ref) {
     613         261 :                         data->n -= 1;
     614             :                 }
     615             : 
     616       10345 :                 return Z_LVAL_P(zv);
     617             :         } else {
     618             :                 zval zv_n;
     619      143062 :                 ZVAL_LONG(&zv_n, data->n);
     620      143062 :                 zend_hash_index_add_new(&data->ht, key, &zv_n);
     621             : 
     622             :                 /* Additionally to the index, we also store the variable, to ensure that it is
     623             :                  * not destroyed during serialization and its pointer reused. The variable is
     624             :                  * stored at the numeric value of the pointer + 1, which cannot be the location
     625             :                  * of another zend_refcounted structure. */
     626      143062 :                 zend_hash_index_add_new(&data->ht, key + 1, var);
     627             :                 Z_ADDREF_P(var);
     628             : 
     629      143062 :                 return 0;
     630             :         }
     631             : }
     632             : /* }}} */
     633             : 
     634      151965 : static inline void php_var_serialize_long(smart_str *buf, zend_long val) /* {{{ */
     635             : {
     636             :         smart_str_appendl(buf, "i:", 2);
     637             :         smart_str_append_long(buf, val);
     638             :         smart_str_appendc(buf, ';');
     639      151965 : }
     640             : /* }}} */
     641             : 
     642       44333 : static inline void php_var_serialize_string(smart_str *buf, char *str, size_t len) /* {{{ */
     643             : {
     644             :         smart_str_appendl(buf, "s:", 2);
     645             :         smart_str_append_unsigned(buf, len);
     646             :         smart_str_appendl(buf, ":\"", 2);
     647             :         smart_str_appendl(buf, str, len);
     648             :         smart_str_appendl(buf, "\";", 2);
     649       44333 : }
     650             : /* }}} */
     651             : 
     652      142746 : static inline zend_bool php_var_serialize_class_name(smart_str *buf, zval *struc) /* {{{ */
     653             : {
     654      142746 :         PHP_CLASS_ATTRIBUTES;
     655             : 
     656      285490 :         PHP_SET_CLASS_ATTRIBUTES(struc);
     657             :         smart_str_appendl(buf, "O:", 2);
     658      142746 :         smart_str_append_unsigned(buf, ZSTR_LEN(class_name));
     659             :         smart_str_appendl(buf, ":\"", 2);
     660             :         smart_str_append(buf, class_name);
     661             :         smart_str_appendl(buf, "\":", 2);
     662             :         PHP_CLEANUP_CLASS_ATTRIBUTES();
     663      142746 :         return incomplete_class;
     664             : }
     665             : /* }}} */
     666             : 
     667           9 : static HashTable *php_var_serialize_collect_names(HashTable *src, uint32_t count, zend_bool incomplete) /* {{{ */ {
     668             :         zval *val;
     669             :         HashTable *ht;
     670             :         zend_string *key, *name;
     671             : 
     672           9 :         ALLOC_HASHTABLE(ht);
     673           9 :         zend_hash_init(ht, count, NULL, NULL, 0);
     674          49 :         ZEND_HASH_FOREACH_STR_KEY_VAL(src, key, val) {
     675          20 :                 if (incomplete && strcmp(ZSTR_VAL(key), MAGIC_MEMBER) == 0) {
     676           0 :                         continue;
     677             :                 }
     678          20 :                 if (Z_TYPE_P(val) != IS_STRING) {
     679           1 :                         php_error_docref(NULL, E_NOTICE,
     680             :                                         "__sleep should return an array only containing the names of instance-variables to serialize.");
     681             :                 }
     682          20 :                 name = zval_get_string(val);
     683          20 :                 if (zend_hash_exists(ht, name)) {
     684           1 :                         php_error_docref(NULL, E_NOTICE,
     685             :                                         "\"%s\" is returned from __sleep multiple times", ZSTR_VAL(name));
     686             :                         zend_string_release(name);
     687           1 :                         continue;
     688             :                 }
     689          19 :                 zend_hash_add_empty_element(ht, name);
     690             :                 zend_string_release(name);
     691             :         } ZEND_HASH_FOREACH_END();
     692             : 
     693           9 :         return ht;
     694             : }
     695             : /* }}} */
     696             : 
     697          11 : static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_ptr, php_serialize_data_t var_hash) /* {{{ */
     698             : {
     699             :         uint32_t count;
     700             :         zend_bool incomplete_class;
     701             :         HashTable *ht;
     702             : 
     703          11 :         incomplete_class = php_var_serialize_class_name(buf, struc);
     704             :         /* count after serializing name, since php_var_serialize_class_name
     705             :          * changes the count if the variable is incomplete class */
     706          11 :         if (Z_TYPE_P(retval_ptr) == IS_ARRAY) {
     707          11 :                 ht = Z_ARRVAL_P(retval_ptr);
     708          11 :                 count = zend_array_count(ht);
     709           0 :         } else if (Z_TYPE_P(retval_ptr) == IS_OBJECT) {
     710           0 :                 ht = Z_OBJPROP_P(retval_ptr);
     711           0 :                 count = zend_array_count(ht);
     712           0 :                 if (incomplete_class) {
     713           0 :                         --count;
     714             :                 }
     715             :         } else {
     716           0 :                 count = 0;
     717           0 :                 ht = NULL;
     718             :         }
     719             : 
     720          11 :         if (count > 0) {
     721             :                 zval *d;
     722             :                 zval nval, *nvalp;
     723             :                 zend_string *name;
     724             :                 HashTable *names, *propers;
     725             : 
     726           9 :                 names = php_var_serialize_collect_names(ht, count, incomplete_class);
     727             : 
     728           9 :                 smart_str_append_unsigned(buf, zend_hash_num_elements(names));
     729             :                 smart_str_appendl(buf, ":{", 2);
     730             : 
     731           9 :                 ZVAL_NULL(&nval);
     732           9 :                 nvalp = &nval;
     733           9 :                 propers = Z_OBJPROP_P(struc);
     734             : 
     735          47 :                 ZEND_HASH_FOREACH_STR_KEY(names, name) {
     736          19 :                         if ((d = zend_hash_find(propers, name)) != NULL) {
     737          10 :                                 if (Z_TYPE_P(d) == IS_INDIRECT) {
     738           9 :                                         d = Z_INDIRECT_P(d);
     739           9 :                                         if (Z_TYPE_P(d) == IS_UNDEF) {
     740           0 :                                                 continue;
     741             :                                         }
     742             :                                 }
     743          10 :                                 php_var_serialize_string(buf, ZSTR_VAL(name), ZSTR_LEN(name));
     744          10 :                                 php_var_serialize_intern(buf, d, var_hash);
     745             :                         } else {
     746           9 :                                 zend_class_entry *ce = Z_OBJ_P(struc)->ce;
     747           9 :                                 if (ce) {
     748             :                                         zend_string *prot_name, *priv_name;
     749             : 
     750             :                                         do {
     751          27 :                                                 priv_name = zend_mangle_property_name(
     752          18 :                                                                 ZSTR_VAL(ce->name), ZSTR_LEN(ce->name), ZSTR_VAL(name), ZSTR_LEN(name), ce->type & ZEND_INTERNAL_CLASS);
     753           9 :                                                 if ((d = zend_hash_find(propers, priv_name)) != NULL) {
     754           2 :                                                         if (Z_TYPE_P(d) == IS_INDIRECT) {
     755           2 :                                                                 d = Z_INDIRECT_P(d);
     756           2 :                                                                 if (Z_ISUNDEF_P(d)) {
     757           0 :                                                                         break;
     758             :                                                                 }
     759             :                                                         }
     760           2 :                                                         php_var_serialize_string(buf, ZSTR_VAL(priv_name), ZSTR_LEN(priv_name));
     761             :                                                         zend_string_free(priv_name);
     762           2 :                                                         php_var_serialize_intern(buf, d, var_hash);
     763           2 :                                                         break;
     764             :                                                 }
     765             :                                                 zend_string_free(priv_name);
     766           7 :                                                 prot_name = zend_mangle_property_name(
     767             :                                                                 "*", 1, ZSTR_VAL(name), ZSTR_LEN(name), ce->type & ZEND_INTERNAL_CLASS);
     768           7 :                                                 if ((d = zend_hash_find(propers, prot_name)) != NULL) {
     769           2 :                                                         if (Z_TYPE_P(d) == IS_INDIRECT) {
     770           2 :                                                                 d = Z_INDIRECT_P(d);
     771           2 :                                                                 if (Z_TYPE_P(d) == IS_UNDEF) {
     772             :                                                                         zend_string_free(prot_name);
     773           0 :                                                                         break;
     774             :                                                                 }
     775             :                                                         }
     776           2 :                                                         php_var_serialize_string(buf, ZSTR_VAL(prot_name), ZSTR_LEN(prot_name));
     777             :                                                         zend_string_free(prot_name);
     778           2 :                                                         php_var_serialize_intern(buf, d, var_hash);
     779           2 :                                                         break;
     780             :                                                 }
     781             :                                                 zend_string_free(prot_name);
     782           5 :                                                 php_var_serialize_string(buf, ZSTR_VAL(name), ZSTR_LEN(name));
     783           5 :                                                 php_var_serialize_intern(buf, nvalp, var_hash);
     784           5 :                                                 php_error_docref(NULL, E_NOTICE,
     785             :                                                                 "\"%s\" returned as member variable from __sleep() but does not exist", ZSTR_VAL(name));
     786             :                                         } while (0);
     787             :                                 } else {
     788           0 :                                         php_var_serialize_string(buf, ZSTR_VAL(name), ZSTR_LEN(name));
     789           0 :                                         php_var_serialize_intern(buf, nvalp, var_hash);
     790             :                                 }
     791             :                         }
     792             :                 } ZEND_HASH_FOREACH_END();
     793             :                 smart_str_appendc(buf, '}');
     794             : 
     795           9 :                 zend_hash_destroy(names);
     796           9 :                 FREE_HASHTABLE(names);
     797             :         } else {
     798             :                 smart_str_appendl(buf, "0:{}", 4);
     799             :         }
     800          11 : }
     801             : /* }}} */
     802             : 
     803      261288 : static void php_var_serialize_intern(smart_str *buf, zval *struc, php_serialize_data_t var_hash) /* {{{ */
     804             : {
     805             :         zend_long var_already;
     806             :         HashTable *myht;
     807             : 
     808      261288 :         if (EG(exception)) {
     809           1 :                 return;
     810             :         }
     811             : 
     812      261287 :         if (var_hash && (var_already = php_add_var_hash(var_hash, struc))) {
     813       10345 :                 if (Z_ISREF_P(struc)) {
     814             :                         smart_str_appendl(buf, "R:", 2);
     815             :                         smart_str_append_long(buf, var_already);
     816             :                         smart_str_appendc(buf, ';');
     817         261 :                         return;
     818       10084 :                 } else if (Z_TYPE_P(struc) == IS_OBJECT) {
     819             :                         smart_str_appendl(buf, "r:", 2);
     820             :                         smart_str_append_long(buf, var_already);
     821             :                         smart_str_appendc(buf, ';');
     822       10084 :                         return;
     823             :                 }
     824             :         }
     825             : 
     826             : again:
     827      251192 :         switch (Z_TYPE_P(struc)) {
     828             :                 case IS_FALSE:
     829             :                         smart_str_appendl(buf, "b:0;", 4);
     830          46 :                         return;
     831             : 
     832             :                 case IS_TRUE:
     833             :                         smart_str_appendl(buf, "b:1;", 4);
     834          58 :                         return;
     835             : 
     836             :                 case IS_NULL:
     837             :                         smart_str_appendl(buf, "N;", 2);
     838       10107 :                         return;
     839             : 
     840             :                 case IS_LONG:
     841        6900 :                         php_var_serialize_long(buf, Z_LVAL_P(struc));
     842        6900 :                         return;
     843             : 
     844             :                 case IS_DOUBLE: {
     845             :                         char tmp_str[PHP_DOUBLE_MAX_LENGTH];
     846             :                         smart_str_appendl(buf, "d:", 2);
     847         105 :                         php_gcvt(Z_DVAL_P(struc), (int)PG(serialize_precision), '.', 'E', tmp_str);
     848         105 :                         smart_str_appends(buf, tmp_str);
     849             :                         smart_str_appendc(buf, ';');
     850         105 :                         return;
     851             :                 }
     852             : 
     853             :                 case IS_STRING:
     854       15500 :                         php_var_serialize_string(buf, Z_STRVAL_P(struc), Z_STRLEN_P(struc));
     855       15500 :                         return;
     856             : 
     857             :                 case IS_OBJECT: {
     858             :                                 zval retval;
     859             :                                 zval fname;
     860             :                                 int res;
     861      142816 :                                 zend_class_entry *ce = Z_OBJCE_P(struc);
     862             : 
     863      142816 :                                 if (ce->serialize != NULL) {
     864             :                                         /* has custom handler */
     865          62 :                                         unsigned char *serialized_data = NULL;
     866             :                                         size_t serialized_length;
     867             : 
     868          62 :                                         if (ce->serialize(struc, &serialized_data, &serialized_length, (zend_serialize_data *)var_hash) == SUCCESS) {
     869             :                                                 smart_str_appendl(buf, "C:", 2);
     870          54 :                                                 smart_str_append_unsigned(buf, ZSTR_LEN(Z_OBJCE_P(struc)->name));
     871             :                                                 smart_str_appendl(buf, ":\"", 2);
     872          54 :                                                 smart_str_append(buf, Z_OBJCE_P(struc)->name);
     873             :                                                 smart_str_appendl(buf, "\":", 2);
     874             : 
     875          54 :                                                 smart_str_append_unsigned(buf, serialized_length);
     876             :                                                 smart_str_appendl(buf, ":{", 2);
     877          54 :                                                 smart_str_appendl(buf, (char *) serialized_data, serialized_length);
     878             :                                                 smart_str_appendc(buf, '}');
     879             :                                         } else {
     880             :                                                 smart_str_appendl(buf, "N;", 2);
     881             :                                         }
     882          62 :                                         if (serialized_data) {
     883          54 :                                                 efree(serialized_data);
     884             :                                         }
     885          62 :                                         return;
     886             :                                 }
     887             : 
     888      142754 :                                 if (ce != PHP_IC_ENTRY && zend_hash_str_exists(&ce->function_table, "__sleep", sizeof("__sleep")-1)) {
     889          38 :                                         ZVAL_STRINGL(&fname, "__sleep", sizeof("__sleep") - 1);
     890          19 :                                         BG(serialize_lock)++;
     891          19 :                                         res = call_user_function_ex(CG(function_table), struc, &fname, &retval, 0, 0, 1, NULL);
     892          19 :                                         BG(serialize_lock)--;
     893             :                                         zval_dtor(&fname);
     894             : 
     895          19 :                                         if (EG(exception)) {
     896           7 :                                                 zval_ptr_dtor(&retval);
     897           7 :                                                 return;
     898             :                                         }
     899             : 
     900          12 :                                         if (res == SUCCESS) {
     901          12 :                                                 if (Z_TYPE(retval) != IS_UNDEF) {
     902          13 :                                                         if (HASH_OF(&retval)) {
     903          11 :                                                                 php_var_serialize_class(buf, struc, &retval, var_hash);
     904             :                                                         } else {
     905           1 :                                                                 php_error_docref(NULL, E_NOTICE, "__sleep should return an array only containing the names of instance-variables to serialize");
     906             :                                                                 /* we should still add element even if it's not OK,
     907             :                                                                  * since we already wrote the length of the array before */
     908             :                                                                 smart_str_appendl(buf,"N;", 2);
     909             :                                                         }
     910          12 :                                                         zval_ptr_dtor(&retval);
     911             :                                                 }
     912          12 :                                                 return;
     913             :                                         }
     914           0 :                                         zval_ptr_dtor(&retval);
     915             :                                 }
     916             : 
     917             :                                 /* fall-through */
     918             :                         }
     919             :                 case IS_ARRAY: {
     920             :                         uint32_t i;
     921      218140 :                         zend_bool incomplete_class = 0;
     922      218140 :                         if (Z_TYPE_P(struc) == IS_ARRAY) {
     923             :                                 smart_str_appendl(buf, "a:", 2);
     924       75405 :                                 myht = Z_ARRVAL_P(struc);
     925       75405 :                                 i = zend_array_count(myht);
     926             :                         } else {
     927      142735 :                                 incomplete_class = php_var_serialize_class_name(buf, struc);
     928      142735 :                                 myht = Z_OBJPROP_P(struc);
     929             :                                 /* count after serializing name, since php_var_serialize_class_name
     930             :                                  * changes the count if the variable is incomplete class */
     931      142735 :                                 i = zend_array_count(myht);
     932      142735 :                                 if (i > 0 && incomplete_class) {
     933           2 :                                         --i;
     934             :                                 }
     935             :                         }
     936      218140 :                         smart_str_append_unsigned(buf, i);
     937             :                         smart_str_appendl(buf, ":{", 2);
     938      218140 :                         if (i > 0) {
     939             :                                 zend_string *key;
     940             :                                 zval *data;
     941             :                                 zend_ulong index;
     942             : 
     943      597591 :                                 ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, data) {
     944             : 
     945      173879 :                                         if (incomplete_class && strcmp(ZSTR_VAL(key), MAGIC_MEMBER) == 0) {
     946           0 :                                                 continue;
     947             :                                         }
     948             : 
     949      173879 :                                         if (!key) {
     950      145065 :                                                 php_var_serialize_long(buf, index);
     951             :                                         } else {
     952       28814 :                                                 php_var_serialize_string(buf, ZSTR_VAL(key), ZSTR_LEN(key));
     953             :                                         }
     954             : 
     955      174576 :                                         if (Z_ISREF_P(data) && Z_REFCOUNT_P(data) == 1) {
     956         193 :                                                 data = Z_REFVAL_P(data);
     957             :                                         }
     958             : 
     959             :                                         /* we should still add element even if it's not OK,
     960             :                                          * since we already wrote the length of the array before */
     961      365503 :                                         if ((Z_TYPE_P(data) == IS_ARRAY && Z_TYPE_P(struc) == IS_ARRAY && Z_ARR_P(data) == Z_ARR_P(struc))
     962        8872 :                                                 || (Z_TYPE_P(data) == IS_ARRAY && Z_ARRVAL_P(data)->u.v.nApplyCount > 1)
     963             :                                         ) {
     964             :                                                 smart_str_appendl(buf, "N;", 2);
     965             :                                         } else {
     966      173878 :                                                 if (Z_TYPE_P(data) == IS_ARRAY && ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(data))) {
     967        8872 :                                                         Z_ARRVAL_P(data)->u.v.nApplyCount++;
     968             :                                                 }
     969      173878 :                                                 php_var_serialize_intern(buf, data, var_hash);
     970      173878 :                                                 if (Z_TYPE_P(data) == IS_ARRAY && ZEND_HASH_APPLY_PROTECTION(Z_ARRVAL_P(data))) {
     971        8872 :                                                         Z_ARRVAL_P(data)->u.v.nApplyCount--;
     972             :                                                 }
     973             :                                         }
     974             :                                 } ZEND_HASH_FOREACH_END();
     975             :                         }
     976             :                         smart_str_appendc(buf, '}');
     977      218140 :                         return;
     978             :                 }
     979             :                 case IS_REFERENCE:
     980         250 :                         struc = Z_REFVAL_P(struc);
     981         250 :                         goto again;
     982             :                 default:
     983             :                         smart_str_appendl(buf, "i:0;", 4);
     984           5 :                         return;
     985             :         }
     986             : }
     987             : /* }}} */
     988             : 
     989       87391 : PHPAPI void php_var_serialize(smart_str *buf, zval *struc, php_serialize_data_t *data) /* {{{ */
     990             : {
     991       87391 :         php_var_serialize_intern(buf, struc, *data);
     992             :         smart_str_0(buf);
     993       87391 : }
     994             : /* }}} */
     995             : 
     996             : /* {{{ proto string serialize(mixed variable)
     997             :    Returns a string representation of variable (which can later be unserialized) */
     998       66751 : PHP_FUNCTION(serialize)
     999             : {
    1000             :         zval *struc;
    1001             :         php_serialize_data_t var_hash;
    1002       66751 :         smart_str buf = {0};
    1003             : 
    1004       66751 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &struc) == FAILURE) {
    1005           2 :                 return;
    1006             :         }
    1007             : 
    1008       66749 :         PHP_VAR_SERIALIZE_INIT(var_hash);
    1009       66749 :         php_var_serialize(&buf, struc, &var_hash);
    1010       66749 :         PHP_VAR_SERIALIZE_DESTROY(var_hash);
    1011             : 
    1012       66749 :         if (EG(exception)) {
    1013             :                 smart_str_free(&buf);
    1014          13 :                 RETURN_FALSE;
    1015             :         }
    1016             : 
    1017       66736 :         if (buf.s) {
    1018       66736 :                 RETURN_NEW_STR(buf.s);
    1019             :         } else {
    1020           0 :                 RETURN_NULL();
    1021             :         }
    1022             : }
    1023             : /* }}} */
    1024             : 
    1025             : /* {{{ proto mixed unserialize(string variable_representation[, array allowed_classes])
    1026             :    Takes a string representation of variable and recreates it */
    1027       66592 : PHP_FUNCTION(unserialize)
    1028             : {
    1029       66592 :         char *buf = NULL;
    1030             :         size_t buf_len;
    1031             :         const unsigned char *p;
    1032             :         php_unserialize_data_t var_hash;
    1033       66592 :         zval *options = NULL, *classes = NULL;
    1034       66592 :         HashTable *class_hash = NULL;
    1035             : 
    1036       66592 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|a", &buf, &buf_len, &options) == FAILURE) {
    1037           2 :                 RETURN_FALSE;
    1038             :         }
    1039             : 
    1040       66590 :         if (buf_len == 0) {
    1041           0 :                 RETURN_FALSE;
    1042             :         }
    1043             : 
    1044       66590 :         p = (const unsigned char*) buf;
    1045       66590 :         PHP_VAR_UNSERIALIZE_INIT(var_hash);
    1046       66590 :         if(options != NULL) {
    1047          12 :                 classes = zend_hash_str_find(Z_ARRVAL_P(options), "allowed_classes", sizeof("allowed_classes")-1);
    1048          24 :                 if(classes && (Z_TYPE_P(classes) == IS_ARRAY || !zend_is_true(classes))) {
    1049          10 :                         ALLOC_HASHTABLE(class_hash);
    1050          10 :                         zend_hash_init(class_hash, (Z_TYPE_P(classes) == IS_ARRAY)?zend_hash_num_elements(Z_ARRVAL_P(classes)):0, NULL, NULL, 0);
    1051             :                 }
    1052          22 :                 if(class_hash && Z_TYPE_P(classes) == IS_ARRAY) {
    1053             :                         zval *entry;
    1054             :                         zend_string *lcname;
    1055             : 
    1056          23 :                         ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(classes), entry) {
    1057           8 :                                 convert_to_string_ex(entry);
    1058           8 :                                 lcname = zend_string_tolower(Z_STR_P(entry));
    1059           8 :                                 zend_hash_add_empty_element(class_hash, lcname);
    1060             :                         zend_string_release(lcname);
    1061             :                         } ZEND_HASH_FOREACH_END();
    1062             :                 }
    1063             :         }
    1064             : 
    1065       66590 :         if (!php_var_unserialize_ex(return_value, &p, p + buf_len, &var_hash, class_hash)) {
    1066          45 :                 PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
    1067          45 :                 if (class_hash) {
    1068           0 :                         zend_hash_destroy(class_hash);
    1069           0 :                         FREE_HASHTABLE(class_hash);
    1070             :                 }
    1071          45 :                 zval_ptr_dtor(return_value);
    1072          45 :                 if (!EG(exception)) {
    1073          27 :                         php_error_docref(NULL, E_NOTICE, "Error at offset " ZEND_LONG_FMT " of %zd bytes",
    1074             :                                 (zend_long)((char*)p - buf), buf_len);
    1075             :                 }
    1076          45 :                 RETURN_FALSE;
    1077             :         }
    1078             :         /* We should keep an reference to return_value to prevent it from being dtor
    1079             :            in case nesting calls to unserialize */
    1080       66545 :         var_push_dtor(&var_hash, return_value);
    1081             : 
    1082             :         /* Ensure return value is a value */
    1083       66545 :         if (Z_ISREF_P(return_value)) {
    1084             :                 zend_unwrap_reference(return_value);
    1085             :         }
    1086             : 
    1087       66545 :         PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
    1088       66545 :         if (class_hash) {
    1089          10 :                 zend_hash_destroy(class_hash);
    1090          10 :                 FREE_HASHTABLE(class_hash);
    1091             :         }
    1092             : }
    1093             : /* }}} */
    1094             : 
    1095             : /* {{{ proto int memory_get_usage([bool real_usage])
    1096             :    Returns the allocated by PHP memory */
    1097        1016 : PHP_FUNCTION(memory_get_usage) {
    1098        1016 :         zend_bool real_usage = 0;
    1099             : 
    1100        1016 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &real_usage) == FAILURE) {
    1101           0 :                 RETURN_FALSE;
    1102             :         }
    1103             : 
    1104        1016 :         RETURN_LONG(zend_memory_usage(real_usage));
    1105             : }
    1106             : /* }}} */
    1107             : 
    1108             : /* {{{ proto int memory_get_peak_usage([bool real_usage])
    1109             :    Returns the peak allocated by PHP memory */
    1110           0 : PHP_FUNCTION(memory_get_peak_usage) {
    1111           0 :         zend_bool real_usage = 0;
    1112             : 
    1113           0 :         if (zend_parse_parameters(ZEND_NUM_ARGS(), "|b", &real_usage) == FAILURE) {
    1114           0 :                 RETURN_FALSE;
    1115             :         }
    1116             : 
    1117           0 :         RETURN_LONG(zend_memory_peak_usage(real_usage));
    1118             : }
    1119             : /* }}} */
    1120             : 
    1121             : /*
    1122             :  * Local variables:
    1123             :  * tab-width: 4
    1124             :  * c-basic-offset: 4
    1125             :  * End:
    1126             :  * vim600: sw=4 ts=4 fdm=marker
    1127             :  * vim<600: sw=4 ts=4
    1128             :  */

Generated by: LCOV version 1.10

Generated at Wed, 24 Aug 2016 12:20:32 +0000 (7 hours ago)

Copyright © 2005-2016 The PHP Group
All rights reserved.