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

Generated by: LCOV version 1.10

Generated at Tue, 14 Oct 2014 07:25:51 +0000 (6 days ago)

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