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

Generated by: LCOV version 1.10

Generated at Sat, 27 Sep 2014 16:43:20 +0000 (4 days ago)

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