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: 480 508 94.5 %
Date: 2014-10-24 Functions: 23 24 95.8 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10

Generated at Fri, 24 Oct 2014 05:21:55 +0000 (43 hours ago)

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