Back to index

php5  5.3.10
Defines | Functions
var.c File Reference
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include "php.h"
#include "php_string.h"
#include "php_var.h"
#include "php_smart_str.h"
#include "basic_functions.h"
#include "php_incomplete_class.h"

Go to the source code of this file.

Defines

#define COMMON   (Z_ISREF_PP(struc) ? "&" : "")
#define buffer_append_spaces(buf, num_spaces)

Functions

static int php_array_element_dump (zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
static int php_object_property_dump (zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
PHPAPI void php_var_dump (zval **struc, int level TSRMLS_DC)
 PHP_FUNCTION (var_dump)
static int zval_array_element_dump (zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
static int zval_object_property_dump (zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
PHPAPI void php_debug_zval_dump (zval **struc, int level TSRMLS_DC)
 PHP_FUNCTION (debug_zval_dump)
static int php_array_element_export (zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
static int php_object_element_export (zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
PHPAPI void php_var_export_ex (zval **struc, int level, smart_str *buf TSRMLS_DC)
PHPAPI void php_var_export (zval **struc, int level TSRMLS_DC)
 PHP_FUNCTION (var_export)
static void php_var_serialize_intern (smart_str *buf, zval *struc, HashTable *var_hash TSRMLS_DC)
static int php_add_var_hash (HashTable *var_hash, zval *var, void *var_old TSRMLS_DC)
static void php_var_serialize_long (smart_str *buf, long val)
static void php_var_serialize_string (smart_str *buf, char *str, int len)
static zend_bool php_var_serialize_class_name (smart_str *buf, zval *struc TSRMLS_DC)
static void php_var_serialize_class (smart_str *buf, zval *struc, zval *retval_ptr, HashTable *var_hash TSRMLS_DC)
PHPAPI void php_var_serialize (smart_str *buf, zval **struc, HashTable *var_hash TSRMLS_DC)
 PHP_FUNCTION (serialize)
 PHP_FUNCTION (unserialize)
 PHP_FUNCTION (memory_get_usage)
 PHP_FUNCTION (memory_get_peak_usage)

Define Documentation

#define buffer_append_spaces (   buf,
  num_spaces 
)
Value:
do { \
              char *tmp_spaces; \
              int tmp_spaces_len; \
              tmp_spaces_len = spprintf(&tmp_spaces, 0,"%*c", num_spaces, ' '); \
              smart_str_appendl(buf, tmp_spaces, tmp_spaces_len); \
              efree(tmp_spaces); \
       } while(0);

Definition at line 339 of file var.c.

#define COMMON   (Z_ISREF_PP(struc) ? "&" : "")

Definition at line 35 of file var.c.


Function Documentation

static int php_add_var_hash ( HashTable var_hash,
zval *  var,
void *var_old  TSRMLS_DC 
) [inline, static]

Definition at line 539 of file var.c.

{
       ulong var_no;
       char id[32], *p;
       register int len;

       /* relies on "(long)" being a perfect hash function for data pointers,
        * however the actual identity of an object has had to be determined
        * by its object handle and the class entry since 5.0. */
       if ((Z_TYPE_P(var) == IS_OBJECT) && Z_OBJ_HT_P(var)->get_class_entry) {
              p = smart_str_print_long(id + sizeof(id) - 1,
                            (((size_t)Z_OBJCE_P(var) << 5)
                            | ((size_t)Z_OBJCE_P(var) >> (sizeof(long) * 8 - 5)))
                            + (long) Z_OBJ_HANDLE_P(var));
              *(--p) = 'O';
              len = id + sizeof(id) - 1 - p;
       } else {
              p = smart_str_print_long(id + sizeof(id) - 1, (long) var);
              len = id + sizeof(id) - 1 - p;
       }

       if (var_old && zend_hash_find(var_hash, p, len, var_old) == SUCCESS) {
              if (!Z_ISREF_P(var)) {
                     /* we still need to bump up the counter, since non-refs will
                      * be counted separately by unserializer */
                     var_no = -1;
                     zend_hash_next_index_insert(var_hash, &var_no, sizeof(var_no), NULL);
              }
              return FAILURE;
       }

       /* +1 because otherwise hash will think we are trying to store NULL pointer */
       var_no = zend_hash_num_elements(var_hash) + 1;
       zend_hash_add(var_hash, p, len, &var_no, sizeof(var_no), NULL);
       return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int php_array_element_dump ( zval **zv  TSRMLS_DC,
int  num_args,
va_list  args,
zend_hash_key hash_key 
) [static]

Definition at line 38 of file var.c.

{
       int level;

       level = va_arg(args, int);

       if (hash_key->nKeyLength == 0) { /* numeric key */
              php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
       } else { /* string key */
              php_printf("%*c[\"", level + 1, ' ');
              PHPWRITE(hash_key->arKey, hash_key->nKeyLength - 1);
              php_printf("\"]=>\n");
       }
       php_var_dump(zv, level + 2 TSRMLS_CC);
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int php_array_element_export ( zval **zv  TSRMLS_DC,
int  num_args,
va_list  args,
zend_hash_key hash_key 
) [static]

Definition at line 348 of file var.c.

{
       int level;
       smart_str *buf;

       level = va_arg(args, int);
       buf = va_arg(args, smart_str *);

       if (hash_key->nKeyLength == 0) { /* numeric key */
              buffer_append_spaces(buf, level+1);
              smart_str_append_long(buf, (long) hash_key->h);
              smart_str_appendl(buf, " => ", 4);
       } else { /* string key */
              char *key, *tmp_str;
              int key_len, tmp_len;
              key = php_addcslashes(hash_key->arKey, hash_key->nKeyLength - 1, &key_len, 0, "'\\", 2 TSRMLS_CC);
              tmp_str = php_str_to_str_ex(key, key_len, "\0", 1, "' . \"\\0\" . '", 12, &tmp_len, 0, NULL);

              buffer_append_spaces(buf, level + 1);

              smart_str_appendc(buf, '\'');
              smart_str_appendl(buf, tmp_str, tmp_len);
              smart_str_appendl(buf, "' => ", 5);

              efree(key);
              efree(tmp_str);
       }
       php_var_export_ex(zv, level + 2, buf TSRMLS_CC);

       smart_str_appendc(buf, ',');
       smart_str_appendc(buf, '\n');

       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI void php_debug_zval_dump ( zval **  struc,
int level  TSRMLS_DC 
)

Definition at line 240 of file var.c.

{
       HashTable *myht = NULL;
       char *class_name;
       zend_uint class_name_len;
       int (*zval_element_dump_func)(zval** TSRMLS_DC, int, va_list, zend_hash_key*);
       int is_temp = 0;

       if (level > 1) {
              php_printf("%*c", level - 1, ' ');
       }

       switch (Z_TYPE_PP(struc)) {
       case IS_BOOL:
              php_printf("%sbool(%s) refcount(%u)\n", COMMON, Z_LVAL_PP(struc)?"true":"false", Z_REFCOUNT_PP(struc));
              break;
       case IS_NULL:
              php_printf("%sNULL refcount(%u)\n", COMMON, Z_REFCOUNT_PP(struc));
              break;
       case IS_LONG:
              php_printf("%slong(%ld) refcount(%u)\n", COMMON, Z_LVAL_PP(struc), Z_REFCOUNT_PP(struc));
              break;
       case IS_DOUBLE:
              php_printf("%sdouble(%.*G) refcount(%u)\n", COMMON, (int) EG(precision), Z_DVAL_PP(struc), Z_REFCOUNT_PP(struc));
              break;
       case IS_STRING:
              php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_PP(struc));
              PHPWRITE(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc));
              php_printf("\" refcount(%u)\n", Z_REFCOUNT_PP(struc));
              break;
       case IS_ARRAY:
              myht = Z_ARRVAL_PP(struc);
              if (myht->nApplyCount > 1) {
                     PUTS("*RECURSION*\n");
                     return;
              }
              php_printf("%sarray(%d) refcount(%u){\n", COMMON, zend_hash_num_elements(myht), Z_REFCOUNT_PP(struc));
              zval_element_dump_func = zval_array_element_dump;
              goto head_done;
       case IS_OBJECT:
              myht = Z_OBJDEBUG_PP(struc, is_temp);
              if (myht && myht->nApplyCount > 1) {
                     PUTS("*RECURSION*\n");
                     return;
              }
              if (Z_OBJ_HANDLER_PP(struc, get_class_name)) {
                     Z_OBJ_HANDLER_PP(struc, get_class_name)(*struc, &class_name, &class_name_len, 0 TSRMLS_CC);
                     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));
                     efree(class_name);
              } else {
                     php_printf("%sobject(unknown class)#%d (%d) refcount(%u){\n", COMMON, Z_OBJ_HANDLE_PP(struc), myht ? zend_hash_num_elements(myht) : 0, Z_REFCOUNT_PP(struc));
              }
              zval_element_dump_func = zval_object_property_dump;
head_done:
              if (myht) {
                     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));
                     if (is_temp) {
                            zend_hash_destroy(myht);
                            efree(myht);
                     }
              }
              if (level > 1) {
                     php_printf("%*c", level - 1, ' ');
              }
              PUTS("}\n");
              break;
       case IS_RESOURCE: {
              char *type_name;

              type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(struc) TSRMLS_CC);
              php_printf("%sresource(%ld) of type (%s) refcount(%u)\n", COMMON, Z_LVAL_PP(struc), type_name ? type_name : "Unknown", Z_REFCOUNT_PP(struc));
              break;
       }
       default:
              php_printf("%sUNKNOWN:0\n", COMMON);
              break;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHP_FUNCTION ( var_dump  )

Definition at line 170 of file var.c.

{
       zval ***args;
       int argc;
       int    i;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) {
              return;
       }

       for (i = 0; i < argc; i++) {
              php_var_dump(args[i], 1 TSRMLS_CC);
       }
       efree(args);
}

Here is the call graph for this function:

PHP_FUNCTION ( debug_zval_dump  )

Definition at line 322 of file var.c.

{
       zval ***args;
       int argc;
       int    i;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) {
              return;
       }

       for (i = 0; i < argc; i++) {
              php_debug_zval_dump(args[i], 1 TSRMLS_CC);
       }
       efree(args);
}

Here is the call graph for this function:

PHP_FUNCTION ( var_export  )

Definition at line 515 of file var.c.

{
       zval *var;
       zend_bool return_output = 0;
       smart_str buf = {0};

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|b", &var, &return_output) == FAILURE) {
              return;
       }

       php_var_export_ex(&var, 1, &buf TSRMLS_CC);
       smart_str_0 (&buf);

       if (return_output) {
              RETVAL_STRINGL(buf.c, buf.len, 1);
       } else {
              PHPWRITE(buf.c, buf.len);
       }
       smart_str_free(&buf);
}

Here is the call graph for this function:

PHP_FUNCTION ( serialize  )

Definition at line 892 of file var.c.

{
       zval **struc;
       php_serialize_data_t var_hash;
       smart_str buf = {0};

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &struc) == FAILURE) {
              return;
       }

       Z_TYPE_P(return_value) = IS_STRING;
       Z_STRVAL_P(return_value) = NULL;
       Z_STRLEN_P(return_value) = 0;

       PHP_VAR_SERIALIZE_INIT(var_hash);
       php_var_serialize(&buf, struc, &var_hash TSRMLS_CC);
       PHP_VAR_SERIALIZE_DESTROY(var_hash);

       if (buf.c) {
              RETURN_STRINGL(buf.c, buf.len, 0);
       } else {
              RETURN_NULL();
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( unserialize  )

Definition at line 920 of file var.c.

{
       char *buf = NULL;
       int buf_len;
       const unsigned char *p;
       php_unserialize_data_t var_hash;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &buf, &buf_len) == FAILURE) {
              RETURN_FALSE;
       }

       if (buf_len == 0) {
              RETURN_FALSE;
       }

       p = (const unsigned char*) buf;
       PHP_VAR_UNSERIALIZE_INIT(var_hash);
       if (!php_var_unserialize(&return_value, &p, p + buf_len, &var_hash TSRMLS_CC)) {
              PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
              zval_dtor(return_value);
              php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Error at offset %ld of %d bytes", (long)((char*)p - buf), buf_len);
              RETURN_FALSE;
       }
       PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
}

Here is the call graph for this function:

PHP_FUNCTION ( memory_get_usage  )

Definition at line 949 of file var.c.

                               {
       zend_bool real_usage = 0;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &real_usage) == FAILURE) {
              RETURN_FALSE;
       }

       RETURN_LONG(zend_memory_usage(real_usage TSRMLS_CC));
}

Here is the call graph for this function:

PHP_FUNCTION ( memory_get_peak_usage  )

Definition at line 962 of file var.c.

                                    {
       zend_bool real_usage = 0;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &real_usage) == FAILURE) {
              RETURN_FALSE;
       }

       RETURN_LONG(zend_memory_peak_usage(real_usage TSRMLS_CC));
}

Here is the call graph for this function:

static int php_object_element_export ( zval **zv  TSRMLS_DC,
int  num_args,
va_list  args,
zend_hash_key hash_key 
) [static]

Definition at line 384 of file var.c.

{
       int level;
       smart_str *buf;

       level = va_arg(args, int);
       buf = va_arg(args, smart_str *);

       buffer_append_spaces(buf, level + 2);
       if (hash_key->nKeyLength != 0) {
              char *class_name, /* ignored, but must be passed to unmangle */
                      *pname,
                      *pname_esc;
              int  pname_esc_len;
              
              zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1,
                            &class_name, &pname);
              pname_esc = php_addcslashes(pname, strlen(pname), &pname_esc_len, 0,
                     "'\\", 2 TSRMLS_CC);

              smart_str_appendc(buf, '\'');
              smart_str_appendl(buf, pname_esc, pname_esc_len);
              smart_str_appendc(buf, '\'');
              efree(pname_esc);
       } else {
              smart_str_append_long(buf, hash_key->h);
       }

       smart_str_appendl(buf, " => ", 4);
       php_var_export_ex(zv, level + 2, buf TSRMLS_CC);
       smart_str_appendc(buf, ',');
       smart_str_appendc(buf, '\n');

       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int php_object_property_dump ( zval **zv  TSRMLS_DC,
int  num_args,
va_list  args,
zend_hash_key hash_key 
) [static]

Definition at line 56 of file var.c.

{
       int level;
       char *prop_name, *class_name;

       level = va_arg(args, int);

       if (hash_key->nKeyLength == 0) { /* numeric key */
              php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
       } else { /* string key */
              int unmangle = zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1, &class_name, &prop_name);
              php_printf("%*c[", level + 1, ' ');

              if (class_name && unmangle == SUCCESS) {
                     if (class_name[0] == '*') {
                            php_printf("\"%s\":protected", prop_name);
                     } else {
                            php_printf("\"%s\":\"%s\":private", prop_name, class_name);
                     }
              } else {
                     php_printf("\"");
                     PHPWRITE(hash_key->arKey, hash_key->nKeyLength - 1);
                     php_printf("\"");
              }
              ZEND_PUTS("]=>\n");
       }
       php_var_dump(zv, level + 2 TSRMLS_CC);
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI void php_var_dump ( zval **  struc,
int level  TSRMLS_DC 
)

Definition at line 87 of file var.c.

{
       HashTable *myht;
       char *class_name;
       zend_uint class_name_len;
       int (*php_element_dump_func)(zval** TSRMLS_DC, int, va_list, zend_hash_key*);
       int is_temp;

       if (level > 1) {
              php_printf("%*c", level - 1, ' ');
       }

       switch (Z_TYPE_PP(struc)) {
       case IS_BOOL:
              php_printf("%sbool(%s)\n", COMMON, Z_LVAL_PP(struc) ? "true" : "false");
              break;
       case IS_NULL:
              php_printf("%sNULL\n", COMMON);
              break;
       case IS_LONG:
              php_printf("%sint(%ld)\n", COMMON, Z_LVAL_PP(struc));
              break;
       case IS_DOUBLE:
              php_printf("%sfloat(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_PP(struc));
              break;
       case IS_STRING:
              php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_PP(struc));
              PHPWRITE(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc));
              PUTS("\"\n");
              break;
       case IS_ARRAY:
              myht = Z_ARRVAL_PP(struc);
              if (++myht->nApplyCount > 1) {
                     PUTS("*RECURSION*\n");
                     --myht->nApplyCount;
                     return;
              }
              php_printf("%sarray(%d) {\n", COMMON, zend_hash_num_elements(myht));
              php_element_dump_func = php_array_element_dump;
              is_temp = 0;
              goto head_done;
       case IS_OBJECT:
              myht = Z_OBJDEBUG_PP(struc, is_temp);
              if (myht && ++myht->nApplyCount > 1) {
                     PUTS("*RECURSION*\n");
                     --myht->nApplyCount;
                     return;
              }

              Z_OBJ_HANDLER(**struc, get_class_name)(*struc, &class_name, &class_name_len, 0 TSRMLS_CC);
              php_printf("%sobject(%s)#%d (%d) {\n", COMMON, class_name, Z_OBJ_HANDLE_PP(struc), myht ? zend_hash_num_elements(myht) : 0);
              efree(class_name);
              php_element_dump_func = php_object_property_dump;
head_done:
              if (myht) {
                     zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_element_dump_func, 1, level);
                     --myht->nApplyCount;
                     if (is_temp) {
                            zend_hash_destroy(myht);
                            efree(myht);
                     }
              }
              if (level > 1) {
                     php_printf("%*c", level-1, ' ');
              }
              PUTS("}\n");
              break;
       case IS_RESOURCE: {
              char *type_name;

              type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(struc) TSRMLS_CC);
              php_printf("%sresource(%ld) of type (%s)\n", COMMON, Z_LVAL_PP(struc), type_name ? type_name : "Unknown");
              break;
       }
       default:
              php_printf("%sUNKNOWN:0\n", COMMON);
              break;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI void php_var_export ( zval **  struc,
int level  TSRMLS_DC 
)

Definition at line 503 of file var.c.

{
       smart_str buf = {0};
       php_var_export_ex(struc, level, &buf TSRMLS_CC);
       smart_str_0 (&buf);
       PHPWRITE(buf.c, buf.len);
       smart_str_free(&buf);
}

Here is the call graph for this function:

PHPAPI void php_var_export_ex ( zval **  struc,
int  level,
smart_str *buf  TSRMLS_DC 
)

Definition at line 421 of file var.c.

{
       HashTable *myht;
       char *tmp_str, *tmp_str2;
       int tmp_len, tmp_len2;
       char *class_name;
       zend_uint class_name_len;

       switch (Z_TYPE_PP(struc)) {
       case IS_BOOL:
       if (Z_LVAL_PP(struc)) {
              smart_str_appendl(buf, "true", 4);
       } else {
              smart_str_appendl(buf, "false", 5);
       }
              break;
       case IS_NULL:
              smart_str_appendl(buf, "NULL", 4);
              break;
       case IS_LONG:
              smart_str_append_long(buf, Z_LVAL_PP(struc));
              break;
       case IS_DOUBLE:
              tmp_len = spprintf(&tmp_str, 0,"%.*H", (int) EG(precision), Z_DVAL_PP(struc));
              smart_str_appendl(buf, tmp_str, tmp_len);
              efree(tmp_str);
              break;
       case IS_STRING:
              tmp_str = php_addcslashes(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc), &tmp_len, 0, "'\\", 2 TSRMLS_CC);
              tmp_str2 = php_str_to_str_ex(tmp_str, tmp_len, "\0", 1, "' . \"\\0\" . '", 12, &tmp_len2, 0, NULL);

              smart_str_appendc(buf, '\'');
              smart_str_appendl(buf, tmp_str2, tmp_len2);
              smart_str_appendc(buf, '\'');

              efree(tmp_str2);
              efree(tmp_str);
              break;
       case IS_ARRAY:
              myht = Z_ARRVAL_PP(struc);
              if (level > 1) {
                     smart_str_appendc(buf, '\n');
                     buffer_append_spaces(buf, level - 1);
              }
              smart_str_appendl(buf, "array (\n", 8);
              zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_array_element_export, 2, level, buf);

              if (level > 1) {
                     buffer_append_spaces(buf, level - 1);
              }
              smart_str_appendc(buf, ')');

              break;
       case IS_OBJECT:
              myht = Z_OBJPROP_PP(struc);
              if (level > 1) {
                     smart_str_appendc(buf, '\n');
                     buffer_append_spaces(buf, level - 1);
              }
              Z_OBJ_HANDLER(**struc, get_class_name)(*struc, &class_name, &class_name_len, 0 TSRMLS_CC);

              smart_str_appendl(buf, class_name, class_name_len);
              smart_str_appendl(buf, "::__set_state(array(\n", 21);

              efree(class_name);
              if (myht) {
                     zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_object_element_export, 2, level, buf);
              }
              if (level > 1) {
                     buffer_append_spaces(buf, level - 1);
              }
              smart_str_appendl(buf, "))", 2);

              break;
       default:
              smart_str_appendl(buf, "NULL", 4);
              break;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHPAPI void php_var_serialize ( smart_str buf,
zval **  struc,
HashTable *var_hash  TSRMLS_DC 
)

Definition at line 883 of file var.c.

{
       php_var_serialize_intern(buf, *struc, var_hash TSRMLS_CC);
       smart_str_0(buf);
}

Here is the call graph for this function:

static void php_var_serialize_class ( smart_str buf,
zval *  struc,
zval *  retval_ptr,
HashTable *var_hash  TSRMLS_DC 
) [static]

Definition at line 610 of file var.c.

{
       int count;
       zend_bool incomplete_class;

       incomplete_class = php_var_serialize_class_name(buf, struc TSRMLS_CC);
       /* count after serializing name, since php_var_serialize_class_name
        * changes the count if the variable is incomplete class */
       count = zend_hash_num_elements(HASH_OF(retval_ptr));
       if (incomplete_class) {
              --count;
       }
       smart_str_append_long(buf, count);
       smart_str_appendl(buf, ":{", 2);

       if (count > 0) {
              char *key;
              zval **d, **name;
              ulong index;
              HashPosition pos;
              int i;
              zval nval, *nvalp;

              ZVAL_NULL(&nval);
              nvalp = &nval;

              zend_hash_internal_pointer_reset_ex(HASH_OF(retval_ptr), &pos);

              for (;; zend_hash_move_forward_ex(HASH_OF(retval_ptr), &pos)) {
                     i = zend_hash_get_current_key_ex(HASH_OF(retval_ptr), &key, NULL, &index, 0, &pos);

                     if (i == HASH_KEY_NON_EXISTANT) {
                            break;
                     }

                     if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) {
                            continue;
                     }
                     zend_hash_get_current_data_ex(HASH_OF(retval_ptr), (void **) &name, &pos);

                     if (Z_TYPE_PP(name) != IS_STRING) {
                            php_error_docref(NULL TSRMLS_CC, E_NOTICE, "__sleep should return an array only containing the names of instance-variables to serialize.");
                            /* we should still add element even if it's not OK,
                             * since we already wrote the length of the array before */
                            smart_str_appendl(buf,"N;", 2);
                            continue;
                     }
                     if (zend_hash_find(Z_OBJPROP_P(struc), Z_STRVAL_PP(name), Z_STRLEN_PP(name) + 1, (void *) &d) == SUCCESS) {
                            php_var_serialize_string(buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
                            php_var_serialize_intern(buf, *d, var_hash TSRMLS_CC);
                     } else {
                            zend_class_entry *ce;
                            ce = zend_get_class_entry(struc TSRMLS_CC);
                            if (ce) {
                                   char *prot_name, *priv_name;
                                   int prop_name_length;

                                   do {
                                          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);
                                          if (zend_hash_find(Z_OBJPROP_P(struc), priv_name, prop_name_length + 1, (void *) &d) == SUCCESS) {
                                                 php_var_serialize_string(buf, priv_name, prop_name_length);
                                                 pefree(priv_name, ce->type & ZEND_INTERNAL_CLASS);
                                                 php_var_serialize_intern(buf, *d, var_hash TSRMLS_CC);
                                                 break;
                                          }
                                          pefree(priv_name, ce->type & ZEND_INTERNAL_CLASS);
                                          zend_mangle_property_name(&prot_name, &prop_name_length, "*", 1, Z_STRVAL_PP(name), Z_STRLEN_PP(name), ce->type & ZEND_INTERNAL_CLASS);
                                          if (zend_hash_find(Z_OBJPROP_P(struc), prot_name, prop_name_length + 1, (void *) &d) == SUCCESS) {
                                                 php_var_serialize_string(buf, prot_name, prop_name_length);
                                                 pefree(prot_name, ce->type & ZEND_INTERNAL_CLASS);
                                                 php_var_serialize_intern(buf, *d, var_hash TSRMLS_CC);
                                                 break;
                                          }
                                          pefree(prot_name, ce->type & ZEND_INTERNAL_CLASS);
                                          php_var_serialize_string(buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
                                          php_var_serialize_intern(buf, nvalp, var_hash TSRMLS_CC);
                                          php_error_docref(NULL TSRMLS_CC, E_NOTICE, "\"%s\" returned as member variable from __sleep() but does not exist", Z_STRVAL_PP(name));
                                   } while (0);
                            } else {
                                   php_var_serialize_string(buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
                                   php_var_serialize_intern(buf, nvalp, var_hash TSRMLS_CC);
                            }
                     }
              }
       }
       smart_str_appendc(buf, '}');
}

Here is the call graph for this function:

Here is the caller graph for this function:

static zend_bool php_var_serialize_class_name ( smart_str buf,
zval *struc  TSRMLS_DC 
) [inline, static]

Definition at line 595 of file var.c.

{
       PHP_CLASS_ATTRIBUTES;

       PHP_SET_CLASS_ATTRIBUTES(struc);
       smart_str_appendl(buf, "O:", 2);
       smart_str_append_long(buf, (int)name_len);
       smart_str_appendl(buf, ":\"", 2);
       smart_str_appendl(buf, class_name, name_len);
       smart_str_appendl(buf, "\":", 2);
       PHP_CLEANUP_CLASS_ATTRIBUTES();
       return incomplete_class;
}

Here is the caller graph for this function:

static void php_var_serialize_intern ( smart_str buf,
zval *  struc,
HashTable *var_hash  TSRMLS_DC 
) [static]

Definition at line 699 of file var.c.

{
       int i;
       ulong *var_already;
       HashTable *myht;

       if (var_hash && php_add_var_hash(var_hash, struc, (void *) &var_already TSRMLS_CC) == FAILURE) {
              if (Z_ISREF_P(struc)) {
                     smart_str_appendl(buf, "R:", 2);
                     smart_str_append_long(buf, (long)*var_already);
                     smart_str_appendc(buf, ';');
                     return;
              } else if (Z_TYPE_P(struc) == IS_OBJECT) {
                     smart_str_appendl(buf, "r:", 2);
                     smart_str_append_long(buf, (long)*var_already);
                     smart_str_appendc(buf, ';');
                     return;
              }
       }

       switch (Z_TYPE_P(struc)) {
              case IS_BOOL:
                     smart_str_appendl(buf, "b:", 2);
                     smart_str_append_long(buf, Z_LVAL_P(struc));
                     smart_str_appendc(buf, ';');
                     return;

              case IS_NULL:
                     smart_str_appendl(buf, "N;", 2);
                     return;

              case IS_LONG:
                     php_var_serialize_long(buf, Z_LVAL_P(struc));
                     return;

              case IS_DOUBLE: {
                            char *s;

                            smart_str_appendl(buf, "d:", 2);
                            s = (char *) safe_emalloc(PG(serialize_precision), 1, MAX_LENGTH_OF_DOUBLE + 1);
                            php_gcvt(Z_DVAL_P(struc), PG(serialize_precision), '.', 'E', s);
                            smart_str_appends(buf, s);
                            smart_str_appendc(buf, ';');
                            efree(s);
                            return;
                     }

              case IS_STRING:
                     php_var_serialize_string(buf, Z_STRVAL_P(struc), Z_STRLEN_P(struc));
                     return;

              case IS_OBJECT: {
                            zval *retval_ptr = NULL;
                            zval fname;
                            int res;
                            zend_class_entry *ce = NULL;

                            if (Z_OBJ_HT_P(struc)->get_class_entry) {
                                   ce = Z_OBJCE_P(struc);
                            }

                            if (ce && ce->serialize != NULL) {
                                   /* has custom handler */
                                   unsigned char *serialized_data = NULL;
                                   zend_uint serialized_length;

                                   if (ce->serialize(struc, &serialized_data, &serialized_length, (zend_serialize_data *)var_hash TSRMLS_CC) == SUCCESS) {
                                          smart_str_appendl(buf, "C:", 2);
                                          smart_str_append_long(buf, (int)Z_OBJCE_P(struc)->name_length);
                                          smart_str_appendl(buf, ":\"", 2);
                                          smart_str_appendl(buf, Z_OBJCE_P(struc)->name, Z_OBJCE_P(struc)->name_length);
                                          smart_str_appendl(buf, "\":", 2);

                                          smart_str_append_long(buf, (int)serialized_length);
                                          smart_str_appendl(buf, ":{", 2);
                                          smart_str_appendl(buf, serialized_data, serialized_length);
                                          smart_str_appendc(buf, '}');
                                   } else {
                                          smart_str_appendl(buf, "N;", 2);
                                   }
                                   if (serialized_data) {
                                          efree(serialized_data);
                                   }
                                   return;
                            }

                            if (ce && ce != PHP_IC_ENTRY && zend_hash_exists(&ce->function_table, "__sleep", sizeof("__sleep"))) {
                                   INIT_PZVAL(&fname);
                                   ZVAL_STRINGL(&fname, "__sleep", sizeof("__sleep") - 1, 0);
                                   res = call_user_function_ex(CG(function_table), &struc, &fname, &retval_ptr, 0, 0, 1, NULL TSRMLS_CC);

                                   if (res == SUCCESS && !EG(exception)) {
                                          if (retval_ptr) {
                                                 if (HASH_OF(retval_ptr)) {
                                                        php_var_serialize_class(buf, struc, retval_ptr, var_hash TSRMLS_CC);
                                                 } else {
                                                        php_error_docref(NULL TSRMLS_CC, E_NOTICE, "__sleep should return an array only containing the names of instance-variables to serialize");
                                                        /* we should still add element even if it's not OK,
                                                         * since we already wrote the length of the array before */
                                                        smart_str_appendl(buf,"N;", 2);
                                                 }
                                                 zval_ptr_dtor(&retval_ptr);
                                          }
                                          return;
                                   }
                            }

                            if (retval_ptr) {
                                   zval_ptr_dtor(&retval_ptr);
                            }
                            /* fall-through */
                     }
              case IS_ARRAY: {
                     zend_bool incomplete_class = 0;
                     if (Z_TYPE_P(struc) == IS_ARRAY) {
                            smart_str_appendl(buf, "a:", 2);
                            myht = HASH_OF(struc);
                     } else {
                            incomplete_class = php_var_serialize_class_name(buf, struc TSRMLS_CC);
                            myht = Z_OBJPROP_P(struc);
                     }
                     /* count after serializing name, since php_var_serialize_class_name
                      * changes the count if the variable is incomplete class */
                     i = myht ? zend_hash_num_elements(myht) : 0;
                     if (i > 0 && incomplete_class) {
                            --i;
                     }
                     smart_str_append_long(buf, i);
                     smart_str_appendl(buf, ":{", 2);
                     if (i > 0) {
                            char *key;
                            zval **data;
                            ulong index;
                            uint key_len;
                            HashPosition pos;

                            zend_hash_internal_pointer_reset_ex(myht, &pos);
                            for (;; zend_hash_move_forward_ex(myht, &pos)) {
                                   i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos);
                                   if (i == HASH_KEY_NON_EXISTANT) {
                                          break;
                                   }
                                   if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) {
                                          continue;
                                   }

                                   switch (i) {
                                          case HASH_KEY_IS_LONG:
                                                 php_var_serialize_long(buf, index);
                                                 break;
                                          case HASH_KEY_IS_STRING:
                                                 php_var_serialize_string(buf, key, key_len - 1);
                                                 break;
                                   }

                                   /* we should still add element even if it's not OK,
                                    * since we already wrote the length of the array before */
                                   if (zend_hash_get_current_data_ex(myht, (void **) &data, &pos) != SUCCESS
                                          || !data
                                          || data == &struc
                                          || (Z_TYPE_PP(data) == IS_ARRAY && Z_ARRVAL_PP(data)->nApplyCount > 1)
                                   ) {
                                          smart_str_appendl(buf, "N;", 2);
                                   } else {
                                          if (Z_TYPE_PP(data) == IS_ARRAY) {
                                                 Z_ARRVAL_PP(data)->nApplyCount++;
                                          }
                                          php_var_serialize_intern(buf, *data, var_hash TSRMLS_CC);
                                          if (Z_TYPE_PP(data) == IS_ARRAY) {
                                                 Z_ARRVAL_PP(data)->nApplyCount--;
                                          }
                                   }
                            }
                     }
                     smart_str_appendc(buf, '}');
                     return;
              }
              default:
                     smart_str_appendl(buf, "i:0;", 4);
                     return;
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void php_var_serialize_long ( smart_str buf,
long  val 
) [inline, static]

Definition at line 577 of file var.c.

{
       smart_str_appendl(buf, "i:", 2);
       smart_str_append_long(buf, val);
       smart_str_appendc(buf, ';');
}

Here is the caller graph for this function:

static void php_var_serialize_string ( smart_str buf,
char *  str,
int  len 
) [inline, static]

Definition at line 585 of file var.c.

{
       smart_str_appendl(buf, "s:", 2);
       smart_str_append_long(buf, len);
       smart_str_appendl(buf, ":\"", 2);
       smart_str_appendl(buf, str, len);
       smart_str_appendl(buf, "\";", 2);
}

Here is the caller graph for this function:

static int zval_array_element_dump ( zval **zv  TSRMLS_DC,
int  num_args,
va_list  args,
zend_hash_key hash_key 
) [static]

Definition at line 187 of file var.c.

{
       int level;

       level = va_arg(args, int);

       if (hash_key->nKeyLength == 0) { /* numeric key */
              php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
       } else { /* string key */
              /* XXX: perphaps when we are inside the class we should permit access to
               * private & protected values
               */
              if (va_arg(args, int) && hash_key->arKey[0] == '\0') {
                     return 0;
              }
              php_printf("%*c[\"", level + 1, ' ');
              PHPWRITE(hash_key->arKey, hash_key->nKeyLength - 1);
              php_printf("\"]=>\n");
       }
       php_debug_zval_dump(zv, level + 2 TSRMLS_CC);
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int zval_object_property_dump ( zval **zv  TSRMLS_DC,
int  num_args,
va_list  args,
zend_hash_key hash_key 
) [static]

Definition at line 211 of file var.c.

{
       int level;
       char *prop_name, *class_name;

       level = va_arg(args, int);

       if (hash_key->nKeyLength == 0) { /* numeric key */
              php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
       } else { /* string key */
              zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1, &class_name, &prop_name);
              php_printf("%*c[", level + 1, ' ');

              if (class_name) {
                     if (class_name[0] == '*') {
                            php_printf("\"%s\":protected", prop_name);
                     } else {
                            php_printf("\"%s\":\"%s\":private", prop_name, class_name);
                     }
              } else {
                     php_printf("\"%s\"", prop_name);
              }
              ZEND_PUTS("]=>\n");
       }
       php_debug_zval_dump(zv, level + 2 TSRMLS_CC);
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: