Fixed zend_print_zval_r_ex() to use the write callback function

diff --git a/Zend/zend.c b/Zend/zend.c
index 65d874d09883c6ef28b0548b7def467632eafb16..04a78627fb0fbd4ac81c572142d3bbe6163b23dc 100644 (file)
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -225,7 +225,7 @@ static uint zend_version_info_length;
 #define ZEND_CORE_VERSION_INFO "Zend Engine v" ZEND_VERSION ", Copyright (c) 1998-2009 Zend Technologies\n"
 #define PRINT_ZVAL_INDENT 4
 
-static void print_hash(HashTable *ht, int indent, zend_bool is_object TSRMLS_DC) /* {{{ */
+static void print_hash(zend_write_func_t write_func, HashTable *ht, int indent, zend_bool is_object TSRMLS_DC) /* {{{ */
 {
        zval **tmp;
        zstr string_key;
@@ -236,18 +236,18 @@ static void print_hash(HashTable *ht, int indent, zend_bool is_object TSRMLS_DC)
        zend_uchar ztype;
 
        for (i = 0; i < indent; i++) {
-               ZEND_PUTS(" ");
+               ZEND_PUTS_EX(" ");
        }
-       ZEND_PUTS("(\n");
+       ZEND_PUTS_EX("(\n");
        indent += PRINT_ZVAL_INDENT;
        zend_hash_internal_pointer_reset_ex(ht, &iterator);
        while (zend_hash_get_current_data_ex(ht, (void **) &tmp, &iterator) == SUCCESS) {
                zend_uchar key_type;
 
                for (i = 0; i < indent; i++) {
-                       ZEND_PUTS(" ");
+                       ZEND_PUTS_EX(" ");
                }
-               ZEND_PUTS("[");
+               ZEND_PUTS_EX("[");
                switch ((key_type = zend_hash_get_current_key_ex(ht, &string_key, &str_len, &num_key, 0, &iterator))) {
                        case HASH_KEY_IS_STRING:
                                ztype = IS_STRING;
@@ -260,33 +260,83 @@ str_type:
 
                                        int mangled = zend_u_unmangle_property_name(ztype, string_key, str_len - 1, &class_name, &prop_name);
 
+                                       if (ztype == IS_UNICODE) {
+                                               UConverter *conv = ZEND_U_CONVERTER(UG(output_encoding_conv));
+                                               UErrorCode status = U_ZERO_ERROR;
+                                               char *s = NULL;
+                                               int s_len;
+
+                                               zend_unicode_to_string_ex(conv, &s, &s_len, prop_name.u, u_strlen(prop_name.u), &status);
+                                               if (U_FAILURE(status)) {
+                                                       zend_error(E_WARNING, "Could not convert Unicode to printable form");
+                                                       return;
+                                               }
+                                               ZEND_WRITE_EX(s, s_len);
+                                               efree(s);
+                                       } else {
+                                               ZEND_PUTS_EX(prop_name.s);
+                                       }
                                        if (class_name.v && mangled == SUCCESS) {
                                                if (class_name.s[0]=='*') {
-                                                       zend_printf("%R:protected", ztype, prop_name);
+                                                       ZEND_PUTS_EX(":protected");
                                                } else {
-                                                       zend_printf("%R:%v:private", ztype, prop_name, class_name);
+                                                       ZEND_PUTS_EX(":");
+                                                       if (UG(unicode)) {
+                                                               UConverter *conv = ZEND_U_CONVERTER(UG(output_encoding_conv));
+                                                               UErrorCode status = U_ZERO_ERROR;
+                                                               char *s = NULL;
+                                                               int s_len;
+
+                                                               zend_unicode_to_string_ex(conv, &s, &s_len, class_name.u, u_strlen(class_name.u), &status);
+                                                               if (U_FAILURE(status)) {
+                                                                       zend_error(E_WARNING, "Could not convert Unicode to printable form");
+                                                                       return;
+                                                               }
+                                                               ZEND_WRITE_EX(s, s_len);
+                                                               efree(s);
+                                                       } else {
+                                                               ZEND_PUTS_EX(class_name.s);
+                                                       }
+                                                       ZEND_PUTS_EX(":private");
                                                }
-                                       } else {
-                                               zend_printf("%R", ztype, prop_name);
                                        }
                                } else {
-                                       zend_printf("%R", ztype, string_key);
+                                       if (ztype == IS_UNICODE) {
+                                               UConverter *conv = ZEND_U_CONVERTER(UG(output_encoding_conv));
+                                               UErrorCode status = U_ZERO_ERROR;
+                                               char *s = NULL;
+                                               int s_len;
+
+                                               zend_unicode_to_string_ex(conv, &s, &s_len, string_key.u, str_len-1, &status);
+                                               if (U_FAILURE(status)) {
+                                                       zend_error(E_WARNING, "Could not convert Unicode to printable form");
+                                                       return;
+                                               }
+                                               ZEND_WRITE_EX(s, s_len);
+                                               efree(s);
+                                       } else {
+                                               ZEND_WRITE_EX(string_key.s, str_len-1);
+                                       }
                                }
                                break;
                        case HASH_KEY_IS_LONG:
-                               zend_printf("%ld", num_key);
+                               {
+                                       char key[25];
+                                       snprintf(key, sizeof(key), "%ld", num_key);
+                                       ZEND_PUTS_EX(key);
+                               }
                                break;
                }
-               ZEND_PUTS("] => ");
-               zend_print_zval_r(*tmp, indent+PRINT_ZVAL_INDENT TSRMLS_CC);
-               ZEND_PUTS("\n");
+               ZEND_PUTS_EX("] => ");
+               zend_print_zval_r_ex(write_func, *tmp, indent+PRINT_ZVAL_INDENT TSRMLS_CC);
+               ZEND_PUTS_EX("\n");
                zend_hash_move_forward_ex(ht, &iterator);
        }
        indent -= PRINT_ZVAL_INDENT;
        for (i = 0; i < indent; i++) {
-               ZEND_PUTS(" ");
+               ZEND_PUTS_EX(" ");
        }
-       ZEND_PUTS(")\n");
+       ZEND_PUTS_EX(")\n");
 }
 /* }}} */
 
@@ -581,13 +631,13 @@ ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int
 {
        switch (Z_TYPE_P(expr)) {
                case IS_ARRAY:
-                       ZEND_PUTS("Array\n");
+                       ZEND_PUTS_EX("Array\n");
                        if (++Z_ARRVAL_P(expr)->nApplyCount>1) {
-                               ZEND_PUTS(" *RECURSION*");
+                               ZEND_PUTS_EX(" *RECURSION*");
                                Z_ARRVAL_P(expr)->nApplyCount--;
                                return;
                        }
-                       print_hash(Z_ARRVAL_P(expr), indent, 0 TSRMLS_CC);
+                       print_hash(write_func, Z_ARRVAL_P(expr), indent, 0 TSRMLS_CC);
                        Z_ARRVAL_P(expr)->nApplyCount--;
                        break;
                case IS_OBJECT:
@@ -601,10 +651,26 @@ ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int
                                        Z_OBJ_HANDLER_P(expr, get_class_name)(expr, &class_name, &clen, 0 TSRMLS_CC);
                                }
                                if (class_name.v) {
-                                       zend_printf("%v Object\n", class_name.v);
+                                       if (UG(unicode)) {
+                                               UConverter *conv = ZEND_U_CONVERTER(UG(output_encoding_conv));
+                                               UErrorCode status = U_ZERO_ERROR;
+                                               char *s = NULL;
+                                               int s_len;
+
+                                               zend_unicode_to_string_ex(conv, &s, &s_len, class_name.u, clen, &status);
+                                               if (U_FAILURE(status)) {
+                                                       zend_error(E_WARNING, "Could not convert Unicode to printable form");
+                                                       return;
+                                               }
+                                               ZEND_WRITE_EX(s, s_len);
+                                               efree(s);
+                                       } else {
+                                               ZEND_PUTS_EX(class_name.s);
+                                       }
                                } else {
-                                       zend_printf("%s Object\n", "Unknown Class");
+                                       ZEND_PUTS_EX("Unknown Class");
                                }
+                               ZEND_PUTS_EX(" Object\n");
                                if (class_name.v) {
                                        efree(class_name.v);
                                }
@@ -612,11 +678,11 @@ ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int
                                        break;
                                }
                                if (++properties->nApplyCount>1) {
-                                       ZEND_PUTS(" *RECURSION*");
+                                       ZEND_PUTS_EX(" *RECURSION*");
                                        properties->nApplyCount--;
                                        return;
                                }
-                               print_hash(properties, indent, 1 TSRMLS_CC);
+                               print_hash(write_func, properties, indent, 1 TSRMLS_CC);
                                properties->nApplyCount--;
                                if (is_temp) {
                                        zend_hash_destroy(properties);
@@ -625,7 +691,7 @@ ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int
                                break;
                        }
                default:
-                       zend_print_variable(expr);
+                       zend_print_zval_ex(write_func, expr, indent);
                        break;
        }
 }

diff --git a/Zend/zend.h b/Zend/zend.h
index aad207fbd1dec9b042989afe3bd5ab99c2e2c9e6..1ba3f5e0a80e164b4e4258ac5c6344a3f70f24e4 100644 (file)
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -653,7 +653,9 @@ END_EXTERN_C()
 
 /* output support */
 #define ZEND_WRITE(str, str_len)               zend_write((str), (str_len))
+#define ZEND_WRITE_EX(str, str_len)            write_func((str), (str_len))
 #define ZEND_PUTS(str)                                 zend_write((str), strlen((str)))
+#define ZEND_PUTS_EX(str)                              write_func((str), strlen((str)))
 #define ZEND_PUTC(c)                                   zend_write(&(c), 1), (c)
 
 BEGIN_EXTERN_C()